mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-17 07:25:16 +00:00
723 lines
32 KiB
Rust
723 lines
32 KiB
Rust
//! Image menu: Image Size, Canvas Size, Crop, Trim, Mode (colour model and
|
||
//! bit depth) conversions, Duplicate.
|
||
|
||
use photocraft_algo::resample::{Resample, crop_surface, resize_surface_in_canvas, translate_surface};
|
||
use photocraft_color::{ColorMode, SampleType};
|
||
use photocraft_doc::{Document, Effect, Effects, FxPaint, Layer, LayerContent, Size};
|
||
use photocraft_geom::Rect;
|
||
use photocraft_raster::Surface;
|
||
use serde_json::{Value, json};
|
||
|
||
use crate::commands::CommandSpec;
|
||
use crate::{EngineError, Result, Session};
|
||
|
||
fn has_doc(s: &Session) -> std::result::Result<(), String> {
|
||
s.active().map(|_| ()).ok_or_else(|| "no document open".into())
|
||
}
|
||
|
||
/// Applies `f` to every pixel surface of a layer tree: content (raster or
|
||
/// cached text/shape/smart pixels), fill caches, and (if `masks`) masks.
|
||
pub(crate) fn for_each_surface(layers: &mut [Layer], masks: bool, f: &mut dyn FnMut(&mut Surface, bool)) {
|
||
for l in layers {
|
||
if masks && let Some(m) = &mut l.mask {
|
||
f(&mut m.surface, true);
|
||
}
|
||
if let Some(fc) = &mut l.fill_cache {
|
||
f(&mut fc.surface, false);
|
||
}
|
||
match &mut l.content {
|
||
LayerContent::Raster(s) => f(s, false),
|
||
LayerContent::Text(t) => {
|
||
if let Some(c) = &mut t.cache {
|
||
f(c, false)
|
||
}
|
||
}
|
||
LayerContent::Shape(sh) => {
|
||
if let Some(c) = &mut sh.cache {
|
||
f(c, false)
|
||
}
|
||
}
|
||
LayerContent::Smart(sm) => {
|
||
if let Some(c) = &mut sm.cache {
|
||
f(c, false)
|
||
}
|
||
}
|
||
LayerContent::Group(g) => for_each_surface(&mut g.children, masks, f),
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Converts every pixel surface of a layer tree (masks included) to `depth`.
|
||
pub(crate) fn convert_layers_depth(layers: &mut [Layer], depth: SampleType) {
|
||
for_each_surface(layers, true, &mut |surf, _| {
|
||
let f = surf.format().with_sample(depth);
|
||
*surf = surf.convert(f);
|
||
});
|
||
}
|
||
|
||
pub(crate) fn for_each_layer(layers: &mut [Layer], f: &mut dyn FnMut(&mut Layer)) {
|
||
for l in layers {
|
||
f(l);
|
||
if let Some(ch) = l.children_mut() {
|
||
for_each_layer(ch, f);
|
||
}
|
||
}
|
||
}
|
||
|
||
pub(crate) fn scale_effects(fx: &mut Effects, k: f32) {
|
||
for e in &mut fx.items {
|
||
match e {
|
||
Effect::DropShadow(s) | Effect::InnerShadow(s) => {
|
||
s.distance *= k;
|
||
s.size *= k;
|
||
}
|
||
Effect::OuterGlow(g) | Effect::InnerGlow(g) => g.size *= k,
|
||
Effect::Stroke(s) => s.size *= k,
|
||
Effect::Satin(s) => {
|
||
s.distance *= k;
|
||
s.size *= k;
|
||
}
|
||
Effect::BevelEmboss(b) => {
|
||
b.size *= k;
|
||
b.soften *= k;
|
||
}
|
||
Effect::PatternOverlay { scale, .. } => *scale *= k,
|
||
Effect::GradientOverlay { .. } | Effect::ColorOverlay { .. } => {}
|
||
}
|
||
if let Effect::Stroke(s) = e
|
||
&& let FxPaint::Pattern { scale, .. } = &mut s.paint
|
||
{
|
||
*scale *= k;
|
||
}
|
||
}
|
||
// Effects changed: the preserved PSD block no longer applies.
|
||
if k != 1.0 {
|
||
fx.psd_raw = None;
|
||
}
|
||
}
|
||
|
||
fn parse_resample(s: &str) -> Option<Resample> {
|
||
Some(match s {
|
||
"none" => return None,
|
||
"nearest" | "nearestNeighbor" => Resample::Nearest,
|
||
"bilinear" => Resample::Bilinear,
|
||
"lanczos" => Resample::Lanczos,
|
||
"preserveDetails" => Resample::PreserveDetails,
|
||
_ => Resample::Bicubic,
|
||
})
|
||
}
|
||
|
||
/// Image → Image Size.
|
||
fn image_size(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let d = s.active().ok_or(EngineError::NoDocument)?;
|
||
let (ow, oh) = (d.doc.size.width, d.doc.size.height);
|
||
let resample = parse_resample(p.get("resample").and_then(Value::as_str).unwrap_or("bicubic"));
|
||
let pw = p.get("width").and_then(Value::as_f64);
|
||
let ph = p.get("height").and_then(Value::as_f64);
|
||
// Missing dimension keeps the aspect ratio.
|
||
let (nw, nh) = match (pw, ph) {
|
||
(Some(w), Some(h)) => (w, h),
|
||
(Some(w), None) => (w, w * oh as f64 / ow.max(1) as f64),
|
||
(None, Some(h)) => (h * ow as f64 / oh.max(1) as f64, h),
|
||
(None, None) => (ow as f64, oh as f64),
|
||
};
|
||
let (nw, nh) = (nw.round().clamp(1.0, 300_000.0) as u32, nh.round().clamp(1.0, 300_000.0) as u32);
|
||
let dpi = p.get("resolution").and_then(Value::as_f64).map(|v| v as f32);
|
||
s.edit("Image Size", |doc, _| {
|
||
if let Some(r) = dpi {
|
||
doc.resolution_dpi = r.clamp(1.0, 10_000.0);
|
||
}
|
||
let Some(filter) = resample else { return Ok(()) };
|
||
let (sx, sy) = (nw as f64 / ow.max(1) as f64, nh as f64 / oh.max(1) as f64);
|
||
if (sx - 1.0).abs() < 1e-12 && (sy - 1.0).abs() < 1e-12 {
|
||
return Ok(());
|
||
}
|
||
// Content that reaches the canvas edge keeps it: a Background stays opaque to the border.
|
||
let canvas = Rect::new(0, 0, ow as i32, oh as i32);
|
||
for_each_surface(&mut doc.layers, true, &mut |surf, is_mask| {
|
||
*surf = resize_surface_in_canvas(surf, sx, sy, if is_mask { Resample::Bilinear } else { filter }, canvas);
|
||
});
|
||
let k = ((sx + sy) / 2.0) as f32;
|
||
for_each_layer(&mut doc.layers, &mut |l| scale_effects(&mut l.effects, k));
|
||
for ch in doc.channels.iter_mut().chain(doc.quick_mask.as_mut()) {
|
||
ch.surface = resize_surface_in_canvas(&ch.surface, sx, sy, Resample::Bilinear, canvas);
|
||
}
|
||
if let Some(sel) = &doc.selection {
|
||
doc.selection = Some(resize_surface_in_canvas(sel, sx, sy, Resample::Bilinear, canvas));
|
||
}
|
||
// Vector geometry, guides and marks scale with the pixels; vectors re-render sharp.
|
||
crate::canvas_geom::transform_geometry(doc, &photocraft_geom::Affine { m: [sx, 0.0, 0.0, sy, 0.0, 0.0] });
|
||
doc.size = Size::new(nw, nh);
|
||
crate::canvas_geom::refresh(doc, crate::canvas_geom::Refresh::All);
|
||
Ok(())
|
||
})?;
|
||
Ok(json!({ "width": nw, "height": nh }))
|
||
}
|
||
|
||
fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
|
||
EngineError::BadParams { cmd: cmd.into(), msg: msg.into() }
|
||
}
|
||
|
||
/// Moves every surface, channel, selection and guide by `(dx, dy)`.
|
||
///
|
||
/// Fails, before moving anything, when some pixels would land outside the i32 coordinate
|
||
/// range: the surface copy saturates its target rectangle there, which no longer matches
|
||
/// the pixel data and panics (#959).
|
||
fn translate_doc(doc: &mut Document, cmd: &str, dx: i32, dy: i32) -> Result<()> {
|
||
if dx == 0 && dy == 0 {
|
||
return Ok(());
|
||
}
|
||
let fits = |r: Rect| {
|
||
r.is_empty() || (r.x0.checked_add(dx).is_some() && r.x1.checked_add(dx).is_some() && r.y0.checked_add(dy).is_some() && r.y1.checked_add(dy).is_some())
|
||
};
|
||
let mut ok = true;
|
||
for_each_surface(&mut doc.layers, true, &mut |surf, _| ok = ok && fits(surf.content_bounds()));
|
||
ok = ok
|
||
&& doc.channels.iter().chain(doc.quick_mask.as_ref()).all(|ch| fits(ch.surface.content_bounds()))
|
||
&& doc.selection.as_ref().is_none_or(|sel| fits(sel.content_bounds()));
|
||
if !ok {
|
||
return Err(bad(cmd, format!("moving the document by ({dx}, {dy}) would push its pixels outside the 32-bit coordinate range")));
|
||
}
|
||
for_each_surface(&mut doc.layers, true, &mut |surf, _| *surf = translate_surface(surf, dx, dy));
|
||
for ch in doc.channels.iter_mut().chain(doc.quick_mask.as_mut()) {
|
||
ch.surface = translate_surface(&ch.surface, dx, dy);
|
||
}
|
||
if let Some(sel) = &doc.selection {
|
||
doc.selection = Some(translate_surface(sel, dx, dy));
|
||
}
|
||
// Type, shapes, smart objects, vector masks, paths, guides, slices, notes… (caches above
|
||
// are already translated exactly, so nothing needs re-rendering for the move itself).
|
||
crate::canvas_geom::transform_geometry(doc, &photocraft_geom::Affine::translate(f64::from(dx), f64::from(dy)));
|
||
Ok(())
|
||
}
|
||
|
||
/// Crops the document to `r` (in current document coordinates).
|
||
fn crop_doc(doc: &mut Document, cmd: &str, r: Rect, delete_pixels: bool) -> Result<()> {
|
||
// The origin moves to (0, 0); `-i32::MIN` has no i32 value (#959).
|
||
let (Some(dx), Some(dy)) = (r.x0.checked_neg(), r.y0.checked_neg()) else {
|
||
return Err(bad(cmd, format!("the crop origin ({}, {}) can't be moved to (0, 0) within the 32-bit coordinate range", r.x0, r.y0)));
|
||
};
|
||
if delete_pixels {
|
||
for_each_surface(&mut doc.layers, false, &mut |surf, _| *surf = crop_surface(surf, r));
|
||
}
|
||
translate_doc(doc, cmd, dx, dy)?;
|
||
doc.size = Size::new(r.width(), r.height());
|
||
crate::canvas_geom::refresh(doc, crate::canvas_geom::Refresh::Shapes);
|
||
Ok(())
|
||
}
|
||
|
||
fn anchor_factors(a: &str) -> (f64, f64) {
|
||
let x = if a.contains("Left") || a == "left" {
|
||
0.0
|
||
} else if a.contains("Right") || a == "right" {
|
||
1.0
|
||
} else {
|
||
0.5
|
||
};
|
||
let y = if a.starts_with("top") {
|
||
0.0
|
||
} else if a.starts_with("bottom") {
|
||
1.0
|
||
} else {
|
||
0.5
|
||
};
|
||
(x, y)
|
||
}
|
||
|
||
fn extension_color(s: &Session, p: &Value) -> [f32; 4] {
|
||
match p.get("extensionColor").and_then(Value::as_str).unwrap_or("background") {
|
||
"foreground" => s.tools.foreground,
|
||
"white" => [1.0; 4],
|
||
"black" => [0.0, 0.0, 0.0, 1.0],
|
||
"transparent" => [0.0; 4],
|
||
hex if hex.starts_with('#') => {
|
||
let h = hex.trim_start_matches('#');
|
||
let c = |i: usize| h.get(i..i + 2).and_then(|x| u8::from_str_radix(x, 16).ok()).map_or(0.0, |v| f32::from(v) / 255.0);
|
||
[c(0), c(2), c(4), 1.0]
|
||
}
|
||
_ => s.tools.background,
|
||
}
|
||
}
|
||
|
||
/// Image → Canvas Size.
|
||
fn canvas_size(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let d = s.active().ok_or(EngineError::NoDocument)?;
|
||
let (ow, oh) = (d.doc.size.width as f64, d.doc.size.height as f64);
|
||
let relative = p.get("relative").and_then(Value::as_bool).unwrap_or(false);
|
||
let w = p.get("width").and_then(Value::as_f64).unwrap_or(if relative { 0.0 } else { ow });
|
||
let h = p.get("height").and_then(Value::as_f64).unwrap_or(if relative { 0.0 } else { oh });
|
||
let (nw, nh) = if relative { (ow + w, oh + h) } else { (w, h) };
|
||
let (nw, nh) = (nw.round().clamp(1.0, 300_000.0) as u32, nh.round().clamp(1.0, 300_000.0) as u32);
|
||
let (ax, ay) = anchor_factors(p.get("anchor").and_then(Value::as_str).unwrap_or("center"));
|
||
let dx = ((nw as f64 - ow) * ax).round() as i32;
|
||
let dy = ((nh as f64 - oh) * ay).round() as i32;
|
||
let ext = extension_color(s, p);
|
||
s.edit("Canvas Size", |doc, _| {
|
||
translate_doc(doc, "image.canvasSize", dx, dy)?;
|
||
doc.size = Size::new(nw, nh);
|
||
crate::canvas_geom::refresh(doc, crate::canvas_geom::Refresh::Shapes);
|
||
let canvas = doc.bounds();
|
||
let old = Rect::from_xywh(dx, dy, ow as u32, oh as u32);
|
||
// The locked Background layer is extended with the extension colour.
|
||
if ext[3] > 0.0
|
||
&& let Some(bg) = doc.layers.first_mut()
|
||
&& bg.name == "Background"
|
||
&& bg.locks.transparency
|
||
&& let LayerContent::Raster(surf) = &mut bg.content
|
||
{
|
||
let fmt = surf.format();
|
||
let px = photocraft_raster::from_rgba(&fmt, ext);
|
||
let keep = surf.content_bounds().intersect(&old);
|
||
let saved = surf.to_interleaved(keep);
|
||
surf.fill_rect(canvas, &px);
|
||
if !keep.is_empty() {
|
||
surf.write_interleaved(keep, &saved);
|
||
}
|
||
}
|
||
Ok(())
|
||
})?;
|
||
Ok(json!({ "width": nw, "height": nh, "offset": [dx, dy] }))
|
||
}
|
||
|
||
/// Image → Crop (to the selection bounds).
|
||
fn crop(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let delete = p.get("deleteCroppedPixels").and_then(Value::as_bool).unwrap_or(true);
|
||
// Values beyond i32 would wrap through the narrowing casts into a rectangle unrelated to
|
||
// the numbers passed; reject them (see `commands::int_i32`).
|
||
let explicit = match (
|
||
crate::commands::int_i32("image.crop", p, "x")?,
|
||
crate::commands::int_i32("image.crop", p, "y")?,
|
||
crate::commands::int_i32("image.crop", p, "width")?,
|
||
crate::commands::int_i32("image.crop", p, "height")?,
|
||
) {
|
||
(Some(x), Some(y), Some(w), Some(h)) if w > 0 && h > 0 => {
|
||
// A far edge past i32::MAX used to saturate, silently cropping less than asked (#959).
|
||
let end = |o: i32, len: i32, ko: &str, kl: &str| {
|
||
o.checked_add(len)
|
||
.ok_or_else(|| bad("image.crop", format!("`{ko}` + `{kl}` = {} is outside the 32-bit coordinate range", i64::from(o) + i64::from(len))))
|
||
};
|
||
Some(Rect::new(x, y, end(x, w, "x", "width")?, end(y, h, "y", "height")?))
|
||
}
|
||
_ => None,
|
||
};
|
||
// An explicit rectangle (the Crop tool) may extend past the canvas; a selection crop is clamped.
|
||
let r = explicit
|
||
.or_else(|| s.active().and_then(|d| d.doc.selection.as_ref().map(|sel| sel.content_bounds().intersect(&d.doc.bounds()))))
|
||
.unwrap_or(Rect::EMPTY);
|
||
if r.is_empty() {
|
||
return Err(EngineError::Other("nothing to crop: pass x/y/width/height or make a selection".into()));
|
||
}
|
||
s.edit("Crop", |doc, _| {
|
||
crop_doc(doc, "image.crop", r, delete)?;
|
||
doc.selection = None;
|
||
Ok(())
|
||
})?;
|
||
Ok(json!({ "x": r.x0, "y": r.y0, "width": r.width(), "height": r.height() }))
|
||
}
|
||
|
||
/// Image → Trim.
|
||
fn trim(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let d = s.active().ok_or(EngineError::NoDocument)?;
|
||
let canvas = d.doc.bounds();
|
||
let buf = photocraft_compose::flatten(&d.doc);
|
||
let based = p.get("basedOn").and_then(Value::as_str).unwrap_or("transparent");
|
||
let w = canvas.width() as usize;
|
||
let reference = match based {
|
||
"topLeft" => Some(buf.px[0]),
|
||
"bottomRight" => buf.px.last().copied(),
|
||
_ => None,
|
||
};
|
||
let differs = |q: [f32; 4]| match reference {
|
||
None => q[3] > 0.0,
|
||
Some(r) => (0..4).any(|c| (q[c] * q[3] - r[c] * r[3]).abs() > 0.5 / 255.0 || (c == 3 && (q[3] - r[3]).abs() > 0.5 / 255.0)),
|
||
};
|
||
let mut b = Rect::EMPTY;
|
||
for (i, q) in buf.px.iter().enumerate() {
|
||
if differs(*q) {
|
||
let (x, y) = ((i % w) as i32, (i / w) as i32);
|
||
b = if b.is_empty() { Rect::new(x, y, x + 1, y + 1) } else { b.union(&Rect::new(x, y, x + 1, y + 1)) };
|
||
}
|
||
}
|
||
if b.is_empty() {
|
||
return Err(EngineError::Other("nothing to trim to".into()));
|
||
}
|
||
let side = |k: &str| p.get(k).and_then(Value::as_bool).unwrap_or(true);
|
||
let r = Rect::new(
|
||
if side("left") { b.x0 } else { canvas.x0 },
|
||
if side("top") { b.y0 } else { canvas.y0 },
|
||
if side("right") { b.x1 } else { canvas.x1 },
|
||
if side("bottom") { b.y1 } else { canvas.y1 },
|
||
);
|
||
s.edit("Trim", |doc, _| crop_doc(doc, "image.trim", r, true))?;
|
||
Ok(json!({ "x": r.x0, "y": r.y0, "width": r.width(), "height": r.height() }))
|
||
}
|
||
|
||
/// Image → Mode → colour model, through the CMS (see [`crate::color_cmds::convert_mode`]).
|
||
fn convert_mode(s: &mut Session, mode: ColorMode, p: &Value) -> Result<Value> {
|
||
crate::color_cmds::convert_mode(s, mode, p)
|
||
}
|
||
|
||
/// Image → Mode → 8/16/32 Bits/Channel.
|
||
fn convert_depth(s: &mut Session, depth: SampleType) -> Result<Value> {
|
||
let current = s.active().ok_or(EngineError::NoDocument)?.doc.depth;
|
||
if current == depth {
|
||
// History::record clears redo even when an edit closure leaves the document unchanged.
|
||
return Ok(Value::Null);
|
||
}
|
||
s.edit("Bit Depth", |doc, _| {
|
||
convert_layers_depth(&mut doc.layers, depth);
|
||
for ch in doc.channels.iter_mut().chain(doc.quick_mask.as_mut()) {
|
||
let f = ch.surface.format().with_sample(depth);
|
||
ch.surface = ch.surface.convert(f);
|
||
}
|
||
doc.depth = depth;
|
||
Ok(())
|
||
})?;
|
||
Ok(Value::Null)
|
||
}
|
||
|
||
/// Image → Duplicate.
|
||
fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let d = s.active().ok_or(EngineError::NoDocument)?;
|
||
let mut doc = (*d.doc).clone();
|
||
doc.id = photocraft_doc::DocId::fresh();
|
||
doc.name = p.get("name").and_then(Value::as_str).map(str::to_string).unwrap_or_else(|| format!("{} copy", d.doc.name));
|
||
if p.get("mergedOnly").and_then(Value::as_bool).unwrap_or(false) {
|
||
let buf = photocraft_compose::flatten(&doc);
|
||
let fmt = doc.pixel_format();
|
||
let mut surf = Surface::new(fmt);
|
||
let vals: Vec<f32> = buf.px.iter().flat_map(|q| photocraft_raster::from_rgba(&fmt, *q)).collect();
|
||
surf.write_region(doc.bounds(), &vals);
|
||
surf.prune();
|
||
doc.layers = vec![Layer::new("Background", LayerContent::Raster(surf))];
|
||
}
|
||
for_each_layer(&mut doc.layers, &mut |l| l.id = photocraft_doc::LayerId::fresh());
|
||
let name = doc.name.clone();
|
||
let index = s.add_document(doc, None);
|
||
Ok(json!({ "document": index, "name": name }))
|
||
}
|
||
|
||
macro_rules! spec {
|
||
($id:literal, $label:literal, [$($m:literal),*], $params:literal, $en:expr, $run:expr) => {
|
||
CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: None, params: $params, enabled: $en, run: $run, journal: true }
|
||
};
|
||
}
|
||
|
||
/// Image menu command specs.
|
||
pub fn specs() -> Vec<CommandSpec> {
|
||
vec![
|
||
spec!(
|
||
"image.imageSize",
|
||
"Image Size…",
|
||
["Image"],
|
||
r##"{"width":px,"height":px,"resolution":ppi,"resample":"bicubic|bilinear|nearest|lanczos|preserveDetails|none"="bicubic"}"##,
|
||
has_doc,
|
||
image_size
|
||
),
|
||
spec!(
|
||
"image.canvasSize",
|
||
"Canvas Size…",
|
||
["Image"],
|
||
r##"{"width":px,"height":px,"relative":bool=false,"anchor":"topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight"="center","extensionColor":"background|foreground|white|black|transparent|#rrggbb"="background"}"##,
|
||
has_doc,
|
||
canvas_size
|
||
),
|
||
spec!("image.crop", "Crop", ["Image"], r##"{"x":px,"y":px,"width":px,"height":px,"deleteCroppedPixels":bool=true}"##, has_doc, crop),
|
||
spec!(
|
||
"image.trim",
|
||
"Trim…",
|
||
["Image"],
|
||
r##"{"basedOn":"transparent|topLeft|bottomRight"="transparent","top":bool=true,"bottom":bool=true,"left":bool=true,"right":bool=true}"##,
|
||
has_doc,
|
||
trim
|
||
),
|
||
spec!(
|
||
"image.mode.rgb",
|
||
"RGB Color",
|
||
["Image", "Mode"],
|
||
r##"{"profile":"<builtin id>|working|/path/to/profile.icc"=working,"intent":"perceptual|relative|saturation|absolute"="relative","bpc":bool=true}"##,
|
||
has_doc,
|
||
|s, p| convert_mode(s, ColorMode::Rgb, p)
|
||
),
|
||
spec!(
|
||
"image.mode.grayscale",
|
||
"Grayscale",
|
||
["Image", "Mode"],
|
||
r##"{"profile":"<builtin id>|working|/path/to/profile.icc"=working,"intent":"perceptual|relative|saturation|absolute"="relative","bpc":bool=true}"##,
|
||
has_doc,
|
||
|s, p| convert_mode(s, ColorMode::Grayscale, p)
|
||
),
|
||
spec!(
|
||
"image.mode.cmyk",
|
||
"CMYK Color",
|
||
["Image", "Mode"],
|
||
r##"{"profile":"<builtin id>|working|/path/to/profile.icc"=working,"intent":"perceptual|relative|saturation|absolute"="relative","bpc":bool=true}"##,
|
||
has_doc,
|
||
|s, p| convert_mode(s, ColorMode::Cmyk, p)
|
||
),
|
||
spec!(
|
||
"image.mode.lab",
|
||
"Lab Color",
|
||
["Image", "Mode"],
|
||
r##"{"profile":"<builtin id>|working|/path/to/profile.icc"=working,"intent":"perceptual|relative|saturation|absolute"="relative","bpc":bool=true}"##,
|
||
has_doc,
|
||
|s, p| convert_mode(s, ColorMode::Lab, p)
|
||
),
|
||
spec!("image.mode.bits8", "8 Bits/Channel", ["Image", "Mode"], "{}", has_doc, |s, _| convert_depth(s, SampleType::U8)),
|
||
spec!("image.mode.bits16", "16 Bits/Channel", ["Image", "Mode"], "{}", has_doc, |s, _| convert_depth(s, SampleType::U16)),
|
||
spec!("image.mode.bits32", "32 Bits/Channel", ["Image", "Mode"], "{}", has_doc, |s, _| convert_depth(s, SampleType::F32)),
|
||
spec!("image.duplicate", "Duplicate…", ["Image"], r##"{"name":str,"mergedOnly":bool=false}"##, has_doc, duplicate),
|
||
]
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn crop_rejects_rectangles_that_would_wrap() {
|
||
let mut s = session();
|
||
// 2^32 + 100 wrapped to `x = 100` through the narrowing casts: a crop rectangle
|
||
// somewhere unrelated to the numbers passed.
|
||
let err = s.execute("image.crop", json!({"x": 4_294_967_396_i64, "y": 0, "width": 10, "height": 10})).unwrap_err();
|
||
assert!(err.to_string().contains("32-bit"), "{err}");
|
||
// In-range rectangles past the canvas still work (clamped by the crop itself).
|
||
s.execute("image.crop", json!({"x": -10, "y": -10, "width": 1000, "height": 1000})).unwrap();
|
||
}
|
||
|
||
/// A crop whose translation to the origin can't be represented in i32 is rejected before
|
||
/// anything changes (#959): `-i32::MIN` overflowed the negation in `crop_doc`, `x + width`
|
||
/// past i32::MAX silently shortened the crop, and an origin one past i32::MIN moved the
|
||
/// layer pixels beyond i32::MAX (a length-mismatch panic while translating surfaces).
|
||
#[test]
|
||
fn crop_rejects_origins_that_cannot_move_to_zero() {
|
||
const MIN: i64 = i32::MIN as i64;
|
||
const MAX: i64 = i32::MAX as i64;
|
||
let cases = [
|
||
json!({"x": MIN, "y": 0, "width": 1, "height": 1}),
|
||
json!({"x": 0, "y": MIN, "width": 1, "height": 1}),
|
||
json!({"x": MIN, "y": MIN, "width": 1, "height": 1}),
|
||
json!({"x": MIN, "y": 0, "width": 1, "height": 1, "deleteCroppedPixels": false}),
|
||
json!({"x": MAX - 5, "y": 0, "width": 10, "height": 1}),
|
||
json!({"x": 0, "y": MAX - 5, "width": 1, "height": 10}),
|
||
json!({"x": MIN + 1, "y": 0, "width": 1, "height": 1, "deleteCroppedPixels": false}),
|
||
json!({"x": 0, "y": MIN + 1, "width": 1, "height": 1, "deleteCroppedPixels": false}),
|
||
];
|
||
for p in cases {
|
||
let mut s = session();
|
||
let before = s.active().unwrap().doc.clone();
|
||
let (rev, steps) = (s.active().unwrap().revision, s.active().unwrap().history.entries().len());
|
||
let err = s.execute("image.crop", p.clone()).unwrap_err();
|
||
assert!(matches!(err, EngineError::BadParams { .. }), "{p}: {err}");
|
||
assert!(err.to_string().contains("32-bit"), "{p}: {err}");
|
||
let st = s.active().unwrap();
|
||
assert!(std::sync::Arc::ptr_eq(&st.doc, &before), "{p}: document changed");
|
||
assert_eq!(st.doc.size, Size::new(40, 20), "{p}");
|
||
assert_eq!(st.doc.layers[1].surface().unwrap().content_bounds(), Rect::new(10, 5, 20, 15), "{p}");
|
||
assert_eq!((st.revision, st.history.entries().len()), (rev, steps), "{p}: history step recorded");
|
||
}
|
||
// Control: a legal negative origin past the canvas still crops (and extends) the canvas.
|
||
let mut s = session();
|
||
s.execute("image.crop", json!({"x": -10, "y": -5, "width": 60, "height": 30})).unwrap();
|
||
assert_eq!(doc(&s).size, Size::new(60, 30));
|
||
assert_eq!(doc(&s).layers[1].surface().unwrap().pixel(20, 10), vec![1.0, 0.0, 0.0, 1.0]);
|
||
// A far-off crop that deletes the (non-overlapping) pixels has nothing left to move.
|
||
let mut s = session();
|
||
s.execute("image.crop", json!({"x": MIN + 1, "y": 0, "width": 1, "height": 1})).unwrap();
|
||
assert_eq!(doc(&s).size, Size::new(1, 1));
|
||
}
|
||
|
||
fn session() -> Session {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", json!({"width": 40, "height": 20})).unwrap();
|
||
s.execute("layer.new.layer", json!({})).unwrap();
|
||
s.edit("paint", |doc, active| {
|
||
let l = doc.layer_mut(active.unwrap()).unwrap();
|
||
l.surface_mut().unwrap().fill_rect(Rect::new(10, 5, 20, 15), &[1.0, 0.0, 0.0, 1.0]);
|
||
l.mask = Some(photocraft_doc::LayerMask::reveal_all());
|
||
l.effects.items.push(Effect::default_drop_shadow());
|
||
Ok(())
|
||
})
|
||
.unwrap();
|
||
s
|
||
}
|
||
|
||
fn doc(s: &Session) -> &Document {
|
||
&s.active().unwrap().doc
|
||
}
|
||
|
||
#[test]
|
||
fn image_size_scales_everything() {
|
||
for resample in ["bicubic", "bilinear", "nearest", "lanczos", "preserveDetails"] {
|
||
let mut s = session();
|
||
s.execute("image.imageSize", json!({"width": 80, "resample": resample})).unwrap();
|
||
let d = doc(&s);
|
||
assert_eq!(d.size, Size::new(80, 40), "{resample}");
|
||
let l = &d.layers[1];
|
||
let b = l.surface().unwrap().content_bounds();
|
||
assert!((b.x0 - 20).abs() <= 1 && (b.x1 - 40).abs() <= 1, "{resample} {b:?}");
|
||
let Effect::DropShadow(sh) = &l.effects.items[0] else { panic!() };
|
||
assert_eq!(sh.distance, 10.0);
|
||
assert_eq!(l.mask.as_ref().unwrap().surface.default_pixel(), vec![1.0]);
|
||
}
|
||
}
|
||
|
||
/// The canvas border stays opaque after Image Size (it used to fade into transparency, so a
|
||
/// Background or a 200 % export got a translucent frame), and a full selection stays full.
|
||
#[test]
|
||
fn image_size_keeps_canvas_edges_opaque() {
|
||
for depth in [8, 16, 32] {
|
||
for (w, resample) in [(60, "bicubic"), (41, "lanczos"), (15, "bilinear"), (77, "preserveDetails")] {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", json!({"width": 30, "height": 20, "depth": depth, "background": "#336699"})).unwrap();
|
||
s.execute("select.all", json!({})).unwrap();
|
||
s.execute("image.imageSize", json!({"width": w, "resample": resample})).unwrap();
|
||
let d = doc(&s);
|
||
let flat = photocraft_compose::flatten(d);
|
||
let (w, h) = (flat.rect.width() as usize, flat.rect.height() as usize);
|
||
let mid = flat.px[(h / 2) * w + w / 2];
|
||
assert!((mid[3] - 1.0).abs() < 1e-3, "{depth} {resample}: {mid:?}");
|
||
for p in &flat.px {
|
||
let off = p.iter().zip(mid).map(|(a, b)| (a - b).abs()).fold(0.0f32, f32::max);
|
||
assert!(off < 0.01, "{depth} {resample} {w}: {p:?} vs {mid:?}");
|
||
}
|
||
let sel = d.selection.as_ref().unwrap();
|
||
let (x1, y1) = (d.size.width as i32 - 1, d.size.height as i32 - 1);
|
||
for (x, y) in [(0, 0), (x1, 0), (0, y1), (x1, y1)] {
|
||
assert!(sel.pixel(x, y)[0] > 0.99, "{depth} {resample}: selection at ({x},{y})");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn resolution_only_change() {
|
||
let mut s = session();
|
||
s.execute("image.imageSize", json!({"resolution": 300, "resample": "none", "width": 999})).unwrap();
|
||
assert_eq!(doc(&s).size, Size::new(40, 20));
|
||
assert_eq!(doc(&s).resolution_dpi, 300.0);
|
||
}
|
||
|
||
/// #1114: nearest neighbor reduction keeps source values without averaging.
|
||
#[test]
|
||
fn nearest_neighbor_reduction_keeps_source_values() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
|
||
s.execute("tools.setColors", json!({"foreground": "#000000", "background": "#ffffff"})).unwrap();
|
||
for y in 0..8 {
|
||
for x in 0..8 {
|
||
if (x + y) % 2 == 0 {
|
||
s.execute("select.rect", json!({"x": x, "y": y, "width": 1, "height": 1})).unwrap();
|
||
s.execute("edit.fill", json!({"contents": "foreground"})).unwrap();
|
||
}
|
||
}
|
||
}
|
||
s.execute("select.deselect", json!({})).unwrap();
|
||
let st = s.active().unwrap();
|
||
let before = st.doc.layers[0].surface().unwrap().rgba(0, 0);
|
||
assert!(before[0] < 0.01, "setup: (0,0) should be black, got {before:?}");
|
||
s.execute("image.imageSize", json!({"width": 4, "height": 4, "resample": "nearest"})).unwrap();
|
||
let st = s.active().unwrap();
|
||
let surf = st.doc.layers[0].surface().unwrap();
|
||
for (x, y) in [(0, 0), (1, 1), (2, 3)] {
|
||
let v = surf.rgba(x, y)[0];
|
||
assert!(v < 0.01 || v > 0.99, "nearest produced an averaged value {v} at ({x},{y})");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn canvas_size_anchors_and_extends_background() {
|
||
let mut s = session();
|
||
s.execute("image.canvasSize", json!({"width": 60, "height": 30, "anchor": "topLeft", "extensionColor": "#00ff00"})).unwrap();
|
||
let d = doc(&s);
|
||
assert_eq!(d.size, Size::new(60, 30));
|
||
assert_eq!(d.layers[1].surface().unwrap().content_bounds(), Rect::new(10, 5, 20, 15));
|
||
let bg = d.layers[0].surface().unwrap();
|
||
assert_eq!(bg.pixel(50, 25), vec![0.0, 1.0, 0.0, 1.0]);
|
||
assert_eq!(bg.pixel(5, 5), vec![1.0, 1.0, 1.0, 1.0]);
|
||
let mut s = session();
|
||
s.execute("image.canvasSize", json!({"width": 20, "height": 10, "relative": true, "anchor": "center"})).unwrap();
|
||
assert_eq!(doc(&s).layers[1].surface().unwrap().content_bounds(), Rect::new(20, 10, 30, 20));
|
||
}
|
||
|
||
#[test]
|
||
fn crop_to_selection_and_trim() {
|
||
let mut s = session();
|
||
assert!(s.execute("image.crop", json!({})).is_err(), "no selection, no rect");
|
||
s.execute("select.rect", json!({"x": 5, "y": 2, "width": 20, "height": 10})).unwrap();
|
||
s.execute("image.crop", json!({})).unwrap();
|
||
let d = doc(&s);
|
||
assert_eq!(d.size, Size::new(20, 10));
|
||
assert!(d.selection.is_none());
|
||
assert_eq!(d.layers[1].surface().unwrap().content_bounds(), Rect::new(5, 3, 15, 10));
|
||
// Trim transparent: hide the background, trim to the red square.
|
||
let mut s = session();
|
||
s.execute("layer.setProps", json!({"layer": doc(&s).layers[0].id.0, "visible": false})).unwrap();
|
||
s.execute("image.trim", json!({"basedOn": "transparent"})).unwrap();
|
||
// The red square (10×10) plus its drop shadow (distance 5, size 5).
|
||
let size = doc(&s).size;
|
||
assert!(size.width > 10 && size.width < 30 && size.height > 10 && size.height < 25, "{size:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn crop_to_explicit_rect_can_extend_canvas() {
|
||
let mut s = session();
|
||
s.execute("image.crop", json!({"x": 10, "y": 5, "width": 10, "height": 10})).unwrap();
|
||
assert_eq!(doc(&s).size, Size::new(10, 10));
|
||
assert_eq!(doc(&s).layers[1].surface().unwrap().pixel(0, 0), vec![1.0, 0.0, 0.0, 1.0]);
|
||
let mut s = session();
|
||
s.execute("image.crop", json!({"x": -10, "y": 0, "width": 60, "height": 20})).unwrap();
|
||
assert_eq!(doc(&s).size, Size::new(60, 20));
|
||
assert_eq!(doc(&s).layers[1].surface().unwrap().pixel(20, 5), vec![1.0, 0.0, 0.0, 1.0]);
|
||
}
|
||
|
||
#[test]
|
||
fn trim_based_on_top_left_colour() {
|
||
let mut s = session();
|
||
s.edit("no fx", |doc, _| {
|
||
doc.layers[1].effects.items.clear();
|
||
Ok(())
|
||
})
|
||
.unwrap();
|
||
s.execute("image.trim", json!({"basedOn": "topLeft"})).unwrap();
|
||
assert_eq!(doc(&s).size, Size::new(10, 10));
|
||
}
|
||
|
||
#[test]
|
||
fn mode_and_depth_conversions() {
|
||
let mut s = session();
|
||
s.execute("image.mode.grayscale", json!({})).unwrap();
|
||
assert_eq!(doc(&s).mode, ColorMode::Grayscale);
|
||
assert_eq!(doc(&s).layers[1].surface().unwrap().format().mode, ColorMode::Grayscale);
|
||
s.execute("image.mode.bits16", json!({})).unwrap();
|
||
assert_eq!(doc(&s).depth, SampleType::U16);
|
||
assert_eq!(doc(&s).layers[1].surface().unwrap().format().sample, SampleType::U16);
|
||
assert_eq!(doc(&s).layers[1].mask.as_ref().unwrap().surface.format().sample, SampleType::U16);
|
||
s.execute("image.mode.cmyk", json!({})).unwrap();
|
||
s.execute("image.mode.bits32", json!({})).unwrap();
|
||
s.execute("image.mode.lab", json!({})).unwrap();
|
||
s.execute("image.mode.rgb", json!({})).unwrap();
|
||
s.execute("image.mode.bits8", json!({})).unwrap();
|
||
let d = doc(&s);
|
||
assert_eq!((d.mode, d.depth), (ColorMode::Rgb, SampleType::U8));
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(doc(&s).depth, SampleType::F32);
|
||
let revision = s.active().unwrap().revision;
|
||
s.execute("image.mode.bits32", json!({})).unwrap();
|
||
assert_eq!(s.active().unwrap().revision, revision, "an unchanged bit depth must preserve the history branch");
|
||
assert!(s.redo(), "selecting the current depth must not discard the undone conversion");
|
||
assert_eq!(doc(&s).depth, SampleType::U8);
|
||
}
|
||
|
||
#[test]
|
||
fn duplicate_document() {
|
||
let mut s = session();
|
||
let r = s.execute("image.duplicate", json!({"mergedOnly": true})).unwrap();
|
||
assert_eq!(r["document"], json!(1));
|
||
assert_eq!(s.documents().len(), 2);
|
||
assert_eq!(doc(&s).layers.len(), 1);
|
||
assert!(doc(&s).name.ends_with("copy"));
|
||
}
|
||
}
|