//! Fill-only open-path Eraser regressions through the public engine and CPU renderer. // Integration tests may unwrap and panic on failure (AGENTS.md). #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] use serde_json::{Value, json}; use vectorcraft_doc::{NodeId, NodeKind}; use vectorcraft_engine::Session; use vectorcraft_geom::{FillRule, PathData, Point}; fn session() -> Session { let mut s = Session::new(); s.execute("file.new", &json!({"width": 300, "height": 300})).unwrap(); s } fn path(s: &Session, id: NodeId) -> &PathData { match &s.doc().unwrap().doc.node(id).unwrap().kind { NodeKind::Path { path, .. } => path, _ => panic!("the fixture is a path"), } } fn paths(s: &Session) -> Vec { let mut paths = vec![]; s.doc().unwrap().doc.walk(|node| { if let NodeKind::Path { path, .. } = &node.kind { paths.push(path.clone()); } }); paths } // The varied setting necessarily selects erase_varied, while a circular nib keeps the // same deterministic swept area as the fixed tip. No random input or device is involved. fn erase(s: &mut Session, mut params: Value, varied: bool) -> Value { if varied { params["angleMode"] = json!("pressure"); params["angleVariation"] = json!(30); params["roundness"] = json!(100); } s.execute("path.eraseRegion", ¶ms).unwrap() } fn eraser_preserves_the_fill_of_an_open_rectangle_case(varied: bool) { let samples = [(110.0, 125.0), (190.0, 125.0), (110.0, 175.0), (190.0, 175.0)]; let render = |s: &Session| { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) }; for closed in [true, false] { let mut s = session(); let id = NodeId( s.execute( "path.create", &json!({"closed": closed, "anchors": [ {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("select.none", &json!({})).unwrap(); assert_eq!(path(&s, id).is_closed(), closed); let before = render(&s); for (x, y) in samples.into_iter().chain([(150.0, 150.0)]) { assert_eq!(before.pixel(x as u32, y as u32), [0, 0, 0, 255], "closed={closed}: original fill at ({x}, {y})"); } // The explicit command fixes the tip at 10 pt; its round ends are outside the rectangle. erase(&mut s, json!({"points": [[50, 150], [250, 150]], "size": 10}), varied); let remaining: Vec = paths(&s); let filled = |x, y| remaining.iter().any(|path| vectorcraft_geom::hit::fill_contains(&path.to_bezpath(), FillRule::NonZero, Point::new(x, y))); let after = render(&s); for (x, y) in samples { assert!(filled(x, y), "closed={closed}: retained fill missing at ({x}, {y})"); assert_eq!(after.pixel(x as u32, y as u32), [0, 0, 0, 255], "closed={closed}: retained pixel at ({x}, {y})"); } assert!(!filled(150.0, 150.0), "closed={closed}: eraser band still filled"); assert_eq!(after.pixel(150, 150)[3], 0, "closed={closed}: erased pixel"); let area: f64 = remaining.iter().map(|path| vectorcraft_pathops::area(path, FillRule::NonZero)).sum(); assert!((area - 9000.0).abs() < 1.0, "closed={closed}: retained area {area}"); } } #[test] fn eraser_preserves_the_fill_of_an_open_rectangle() { eraser_preserves_the_fill_of_an_open_rectangle_case(false); } #[test] fn eraser_preserves_the_fill_of_an_open_rectangle_varied_tip() { eraser_preserves_the_fill_of_an_open_rectangle_case(true); } fn eraser_keeps_open_compound_holes_with_both_fill_rules_case(varied: bool) { for rule in ["nonZero", "evenOdd"] { let mut s = session(); let outer = NodeId( s.execute( "path.create", &json!({"anchors": [ {"x": 100, "y": 100}, {"x": 300, "y": 100}, {"x": 300, "y": 300}, {"x": 100, "y": 300} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); let inner = NodeId( s.execute( "path.create", &json!({"anchors": [ {"x": 150, "y": 150}, {"x": 150, "y": 250}, {"x": 250, "y": 250}, {"x": 250, "y": 150} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); for id in [outer, inner] { s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); } s.execute("select.set", &json!({"ids": [outer.0, inner.0]})).unwrap(); let compound = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap()); s.execute("path.setFillRule", &json!({"rule": rule})).unwrap(); s.execute("select.none", &json!({})).unwrap(); let members = match &s.doc().unwrap().doc.node(compound).unwrap().kind { NodeKind::Compound { children, .. } => children, other => panic!("expected compound path, got {other:?}"), }; assert!(members.iter().all(|member| !member.path_data().unwrap().is_closed()), "{rule}: both source contours remain open"); let before = vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); assert!(before.pixel(120, 140)[3] > 240, "{rule}: ring fills before Eraser"); assert_eq!(before.pixel(200, 200)[3], 0, "{rule}: the compound hole is empty before Eraser"); let before_miss = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let miss_history = s.doc().unwrap().history.undo.len(); let miss = erase(&mut s, json!({"points": [[200, 200]], "size": 10}), varied); assert_eq!(miss["ids"], json!([]), "{rule}: a stroke wholly inside the hole misses"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_miss); assert_eq!(s.doc().unwrap().history.undo.len(), miss_history, "{rule}: the hole miss adds no history"); erase(&mut s, json!({"points": [[80, 120], [320, 120]], "size": 10}), varied); let after = vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); assert_eq!(after.pixel(120, 120)[3], 0, "{rule}: swept band is empty"); assert!(after.pixel(120, 140)[3] > 240, "{rule}: retained ring is filled"); assert_eq!(after.pixel(200, 200)[3], 0, "{rule}: compound hole remains empty"); } } #[test] fn eraser_keeps_open_compound_holes_with_both_fill_rules() { eraser_keeps_open_compound_holes_with_both_fill_rules_case(false); } #[test] fn eraser_keeps_open_compound_holes_with_both_fill_rules_varied_tip() { eraser_keeps_open_compound_holes_with_both_fill_rules_case(true); } fn eraser_removes_only_the_swept_strip_from_a_zero_signed_area_open_bowtie_case(varied: bool) { let mut s = session(); let id = NodeId( s.execute( "path.create", &json!({"anchors": [ {"x": 100, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200}, {"x": 200, "y": 100} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("select.none", &json!({})).unwrap(); assert!(!path(&s, id).is_closed(), "the bowtie is open"); assert!(path(&s, id).subpaths.first().unwrap().signed_area().abs() < 1e-9, "the bowtie has zero signed area"); let render = |s: &Session| { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) }; let before = render(&s); let before_area: f64 = before.pixels.as_chunks::<4>().0.iter().map(|rgba| f64::from(rgba[3]) / 255.0).sum(); assert!((before_area - 5000.0).abs() < 2.0, "the open bowtie fills both lobes: {before_area}"); for y in [110, 140, 175] { assert!(before.pixel(150, y)[3] > 240, "original lobe pixel y={y}"); } erase(&mut s, json!({"points": [[50, 125], [250, 125]], "size": 10}), varied); let after = render(&s); let after_area: f64 = after.pixels.as_chunks::<4>().0.iter().map(|rgba| f64::from(rgba[3]) / 255.0).sum(); assert!((after_area - 4500.0).abs() < 2.0, "only the 500 px² sweep strip is removed: {after_area}"); assert!(after.pixel(150, 110)[3] > 240); assert!(after.pixel(150, 140)[3] > 240); assert!(after.pixel(150, 175)[3] > 240); assert_eq!(after.pixel(150, 125)[3], 0, "the swept strip is empty"); let area: f64 = paths(&s).iter().map(|path| vectorcraft_pathops::area(path, FillRule::NonZero)).sum(); assert!((area - 4500.0).abs() < 1.0, "retained bowtie area {area}"); } #[test] fn eraser_removes_only_the_swept_strip_from_a_zero_signed_area_open_bowtie() { eraser_removes_only_the_swept_strip_from_a_zero_signed_area_open_bowtie_case(false); } #[test] fn eraser_removes_only_the_swept_strip_from_a_zero_signed_area_open_bowtie_varied_tip() { eraser_removes_only_the_swept_strip_from_a_zero_signed_area_open_bowtie_case(true); } #[test] fn eraser_keeps_painted_stroke_open_paths_on_the_outline_route() { for varied in [false, true] { let mut s = session(); let id = NodeId( s.execute( "path.create", &json!({"anchors": [ {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("stroke.set", &json!({"ids": [id.0], "weight": 4})).unwrap(); s.execute("select.none", &json!({})).unwrap(); assert!(!path(&s, id).is_closed()); let appearance = &s.doc().unwrap().doc.node(id).unwrap().appearance; assert_eq!(appearance.stroke_width(), 4.0); assert!(!appearance.stroke_paint().is_none()); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let history = s.doc().unwrap().history.undo.len(); let selection = s.doc().unwrap().selection.clone(); let before_image = vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); assert_eq!(before_image.pixel(150, 150), [0, 0, 0, 255], "the interior really has visible fill"); assert!(before_image.pixel(150, 100)[3] > 240, "the open path has painted visible stroke"); // This sweep lies inside the fill, at least 30 pt from any painted outline. // Fill-only scope must not extend to this painted-stroke path or wrap it. let miss = erase(&mut s, json!({"points": [[130, 150], [170, 150]], "size": 10}), varied); assert_eq!(miss["ids"], json!([]), "varied={varied}: the existing outline route misses"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before, "varied={varied}: no replacement or wrapper"); assert_eq!(s.doc().unwrap().history.undo.len(), history); assert_eq!(s.doc().unwrap().selection, selection); let after_image = vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); assert_eq!(after_image.pixels, before_image.pixels); } } // The Alt-drag marquee dispatches the same public Eraser command with `rect` instead of `points`. fn marquee_rectangle(s: &mut Session, closed: bool, stroked: bool) -> NodeId { let id = NodeId( s.execute( "path.create", &json!({"closed": closed, "anchors": [ {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); if stroked { s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("stroke.set", &json!({"ids": [id.0], "weight": 4})).unwrap(); } else { s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); } id } #[test] fn eraser_marquee_preserves_open_fill_like_closed_and_undo() { for closed in [true, false] { let mut s = session(); let id = marquee_rectangle(&mut s, closed, false); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); assert_eq!(path(&s, id).is_closed(), closed); let render = |s: &Session| { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) }; let before_image = render(&s); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let retained = [(110, 125), (190, 125), (110, 175), (190, 175)]; for (x, y) in retained.into_iter().chain([(150, 150)]) { assert_eq!(before_image.pixel(x, y), [0, 0, 0, 255], "closed={closed}: original fill at ({x}, {y})"); } s.execute("path.eraseRegion", &json!({"rect": [50, 145, 200, 10]})).unwrap(); let after_image = render(&s); for (x, y) in retained { assert_eq!(after_image.pixel(x, y), [0, 0, 0, 255], "closed={closed}: marquee lost retained fill at ({x}, {y})"); } assert_eq!(after_image.pixel(150, 150)[3], 0, "closed={closed}: marquee band is empty"); let remaining = paths(&s); let area: f64 = remaining.iter().map(|p| vectorcraft_pathops::area(p, FillRule::NonZero)).sum(); assert!((area - 9000.0).abs() < 1.0, "closed={closed}: marquee retained area {area}"); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1, "one marquee is one edit"); let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let after_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before, "closed={closed}: Undo restores the original document"); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after); assert_eq!(s.doc().unwrap().selection, after_selection); } } #[test] fn eraser_marquee_keeps_compound_holes_and_outline_controls() { for rule in ["nonZero", "evenOdd"] { let mut s = session(); let mut ids = vec![]; for anchors in [ json!([{"x": 100, "y": 100}, {"x": 300, "y": 100}, {"x": 300, "y": 300}, {"x": 100, "y": 300}]), json!([{"x": 150, "y": 150}, {"x": 150, "y": 250}, {"x": 250, "y": 250}, {"x": 250, "y": 150}]), ] { let id = s.execute("path.create", &json!({"anchors": anchors})).unwrap()["id"].as_u64().unwrap(); s.execute("paint.setFill", &json!({"ids": [id], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap(); ids.push(id); } s.execute("select.set", &json!({"ids": ids})).unwrap(); let compound = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap()); s.execute("path.setFillRule", &json!({"rule": rule})).unwrap(); s.execute("select.none", &json!({})).unwrap(); let members = match &s.doc().unwrap().doc.node(compound).unwrap().kind { NodeKind::Compound { children, .. } => children, other => panic!("expected compound, got {other:?}"), }; assert!(members.iter().all(|n| !n.path_data().unwrap().is_closed())); let render = |s: &Session| { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) }; let before_image = render(&s); assert!(before_image.pixel(120, 120)[3] > 240, "{rule}: original ring is filled"); assert_eq!(before_image.pixel(200, 200)[3], 0, "{rule}: original hole is empty"); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let miss = s.execute("path.eraseRegion", &json!({"rect": [180, 180, 40, 40]})).unwrap(); assert_eq!(miss["ids"], json!([]), "{rule}: a marquee wholly inside the hole misses"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = s.execute("path.eraseRegion", &json!({"rect": [80, 115, 240, 10]})).unwrap(); assert!(!result["ids"].as_array().unwrap().is_empty()); for id in result["ids"].as_array().unwrap() { assert!( matches!(s.doc().unwrap().doc.node(NodeId(id.as_u64().unwrap())).unwrap().kind, NodeKind::Compound { .. }), "{rule}: no wrapper replaces the compound pieces" ); } let after_image = render(&s); assert_eq!(after_image.pixel(120, 120)[3], 0, "{rule}: marquee band is empty"); assert!(after_image.pixel(120, 140)[3] > 240, "{rule}: ring outside the marquee remains filled"); assert_eq!(after_image.pixel(200, 200)[3], 0, "{rule}: compound hole stays empty"); let area: f64 = after_image.pixels.as_chunks::<4>().0.iter().map(|rgba| f64::from(rgba[3]) / 255.0).sum(); assert!((area - 28000.0).abs() < 2.0, "{rule}: marquee removes only its 2000 px² strip: {area}"); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); } // Filled AND painted-stroke open art keeps the existing outline route, so an interior // marquee that touches none of its three painted edges is a genuine no-op. let mut s = session(); let id = marquee_rectangle(&mut s, false, true); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let miss = s.execute("path.eraseRegion", &json!({"rect": [130, 145, 40, 10]})).unwrap(); assert_eq!(miss["ids"], json!([])); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); // Knife's target collection must not inherit the Eraser-only open-fill area extension. let mut s = session(); let id = marquee_rectangle(&mut s, false, false); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let miss = s.execute("path.knife", &json!({"points": [[50, 150], [250, 150]]})).unwrap(); assert_eq!(miss["ids"], json!([])); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); } // A mask is a role of one first child, not a collection of ordinary sibling pieces. struct ClipMaskFixture { group: NodeId, mask: NodeId, art: NodeId, compound: bool, rule: FillRule, appearance: Value, art_json: Value, } fn blue_clip_art(s: &mut Session) -> NodeId { let art = NodeId(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 300, "height": 300})).unwrap()["id"].as_u64().unwrap()); s.execute("paint.setFill", &json!({"ids": [art.0], "color": "#0000ff"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [art.0], "none": true})).unwrap(); art } fn painted_clip(s: &mut Session, art: NodeId, mask: NodeId, compound: bool) -> ClipMaskFixture { s.execute("select.set", &json!({"ids": [art.0, mask.0]})).unwrap(); let group = NodeId(s.execute("object.clippingMask.make", &json!({})).unwrap()["id"].as_u64().unwrap()); assert!(s.doc().unwrap().doc.node(mask).unwrap().appearance.fill_paint().is_none(), "Make clears the clipping path's paint"); // The reported area route requires visible fill on the mask AFTER Make, which clears it. s.execute("paint.setFill", &json!({"ids": [mask.0], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [mask.0], "none": true})).unwrap(); s.execute("select.set", &json!({"ids": [mask.0]})).unwrap(); assert_eq!(s.doc().unwrap().selection.objects, vec![mask], "only the mask is an Eraser target"); let node = s.doc().unwrap().doc.node(mask).unwrap(); assert!(!node.appearance.fill_paint().is_none(), "the restored visible fill admits the area route"); assert!(node.appearance.stroke_paint().is_none(), "no painted stroke admits an outline fallback"); let rule = match &node.kind { NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. } => *rule, other => panic!("expected a path or compound mask, got {other:?}"), }; let fixture = ClipMaskFixture { group, mask, art, compound, rule, appearance: serde_json::to_value(&node.appearance).unwrap(), art_json: serde_json::to_value(s.doc().unwrap().doc.node(art).unwrap()).unwrap(), }; assert_clip_identity(s, &fixture); fixture } fn assert_clip_identity(s: &Session, c: &ClipMaskFixture) { let d = &s.doc().unwrap().doc; let children = match &d.node(c.group).unwrap().kind { NodeKind::Group { children, clip: true } => children, other => panic!("expected the original clip group, got {other:?}"), }; assert_eq!(children.iter().map(|n| n.id).collect::>(), [c.mask, c.art], "the one mask stays first; no painted siblings or promoted art"); let mask = d.node(c.mask).unwrap(); let rule = match (&mask.kind, c.compound) { (NodeKind::Path { rule, clipping: true, .. }, false) | (NodeKind::Compound { rule, .. }, true) => *rule, (other, _) => panic!("the original mask kind/role changed: {other:?}"), }; assert_eq!(rule, c.rule); assert_eq!(serde_json::to_value(&mask.appearance).unwrap(), c.appearance); assert_eq!(serde_json::to_value(d.node(c.art).unwrap()).unwrap(), c.art_json, "the clipped art itself is untouched"); } fn assert_clip_pixels(s: &Session, blue: &[(u32, u32)], clear: &[(u32, u32)]) { let image = vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); for &(x, y) in blue { assert_eq!(image.pixel(x, y), [0, 0, 255, 255], "clipped blue art at ({x}, {y}), not a painted mask sibling"); } for &(x, y) in clear { assert_eq!(image.pixel(x, y)[3], 0, "transparent clip region at ({x}, {y})"); } } fn clip_eraser(s: &mut Session, mode: &str, full: bool) -> Value { if mode == "rect" { let rect = if full { json!([50, 50, 300, 300]) } else { json!([50, 145, 200, 10]) }; s.execute("path.eraseRegion", &json!({"rect": rect})).unwrap() } else { assert!(matches!(mode, "fixed" | "varied")); let params = if full { json!({"points": [[150, 150]], "size": 300}) } else { json!({"points": [[50, 150], [250, 150]], "size": 10}) }; erase(s, params, mode == "varied") } } fn fully_erase_clip_and_restore(s: &mut Session, c: &ClipMaskFixture, mode: &str) { let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); clip_eraser(s, mode, true); let image = vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); assert!(image.pixels.as_chunks::<4>().0.iter().all(|pixel| pixel[3] == 0), "empty geometry must hide all clipped art, not promote it"); assert_clip_identity(s, c); match &s.doc().unwrap().doc.node(c.mask).unwrap().kind { NodeKind::Path { path, .. } => assert!(path.is_empty()), NodeKind::Compound { children, .. } => assert!(children.is_empty()), other => panic!("empty mask retains its kind: {other:?}"), } assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); let empty = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let empty_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), empty); assert_eq!(s.doc().unwrap().selection, empty_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); assert_clip_identity(s, c); } #[test] fn eraser_clipping_split_and_empty_masks_keep_their_single_role() { for closed in [false, true] { for mode in ["fixed", "varied", "rect"] { let mut s = session(); let art = blue_clip_art(&mut s); let mask = marquee_rectangle(&mut s, closed, false); let c = painted_clip(&mut s, art, mask, false); assert_eq!(path(&s, mask).is_closed(), closed, "the original mask's open/closed state is real"); assert_clip_pixels(&s, &[(110, 125), (190, 125), (110, 175), (190, 175), (150, 150)], &[(90, 150)]); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); clip_eraser(&mut s, mode, false); assert_clip_pixels(&s, &[(110, 125), (190, 125), (110, 175), (190, 175)], &[(150, 150), (90, 150)]); assert_clip_identity(&s, &c); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1, "closed={closed}, mode={mode}: one erase edit"); let split = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let split_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), split); assert_eq!(s.doc().unwrap().selection, split_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); fully_erase_clip_and_restore(&mut s, &c, mode); } } } #[test] fn eraser_clipping_compound_holes_and_empty_masks_keep_their_rule() { for rule in ["nonZero", "evenOdd"] { let mut s = session(); let art = blue_clip_art(&mut s); let mut ids = vec![]; for anchors in [ json!([{"x": 100, "y": 100}, {"x": 300, "y": 100}, {"x": 300, "y": 300}, {"x": 100, "y": 300}]), json!([{"x": 150, "y": 150}, {"x": 150, "y": 250}, {"x": 250, "y": 250}, {"x": 250, "y": 150}]), ] { let id = s.execute("path.create", &json!({"anchors": anchors})).unwrap()["id"].as_u64().unwrap(); s.execute("paint.setFill", &json!({"ids": [id], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap(); ids.push(id); } s.execute("select.set", &json!({"ids": ids})).unwrap(); let mask = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap()); s.execute("path.setFillRule", &json!({"rule": rule})).unwrap(); let c = painted_clip(&mut s, art, mask, true); assert_eq!(c.rule, if rule == "evenOdd" { FillRule::EvenOdd } else { FillRule::NonZero }); let members = match &s.doc().unwrap().doc.node(mask).unwrap().kind { NodeKind::Compound { children, .. } => children, other => panic!("expected compound, got {other:?}"), }; assert!(members.iter().all(|member| !member.path_data().unwrap().is_closed()), "the source contours are open"); assert_clip_pixels(&s, &[(120, 110), (120, 120), (120, 140)], &[(200, 200), (90, 110)]); // First witness the independent zero-mask promotion defect in actual pixels. let original = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let original_selection = s.doc().unwrap().selection.clone(); let original_history = s.doc().unwrap().history.undo.len(); fully_erase_clip_and_restore(&mut s, &c, "rect"); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), original); assert_eq!(s.doc().unwrap().selection, original_selection); assert_eq!(s.doc().unwrap().history.undo.len(), original_history); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); s.execute("path.eraseRegion", &json!({"rect": [80, 115, 240, 10]})).unwrap(); assert_clip_identity(&s, &c); assert_clip_pixels(&s, &[(120, 110), (120, 140)], &[(120, 120), (200, 200), (90, 110)]); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); let split = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let split_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), split); assert_eq!(s.doc().unwrap().selection, split_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); // Member IDs may be rebuilt by set_geometry; only the compound mask's own role is stable. } } #[test] fn eraser_clipping_path_eraser_keeps_mask_but_removes_ordinary_art() { let mut s = session(); let art = blue_clip_art(&mut s); let mask = marquee_rectangle(&mut s, false, false); let c = painted_clip(&mut s, art, mask, false); assert!(!path(&s, mask).is_closed()); assert_clip_pixels(&s, &[(190, 110), (190, 150), (190, 190)], &[(90, 150)]); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); s.execute("path.eraseSegments", &json!({"points": [[50, 150], [250, 150]], "width": 10})).unwrap(); // The two open outline pieces close as triangles for clipping, not as an area subtraction. assert_clip_pixels(&s, &[(190, 110), (190, 190)], &[(190, 150), (90, 150)]); assert_clip_identity(&s, &c); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); let split = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let split_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), split); assert_eq!(s.doc().unwrap().selection, split_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); // The same shared apply_plan must still REMOVE wholly erased ordinary art. let mut s = session(); let ordinary = marquee_rectangle(&mut s, false, false); s.execute("select.set", &json!({"ids": [ordinary.0]})).unwrap(); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); s.execute("path.eraseSegments", &json!({"points": [[50, 150], [250, 150]], "width": 300})).unwrap(); assert!(s.doc().unwrap().doc.node(ordinary).is_none(), "ordinary art does not retain an empty mask node"); assert!(s.doc().unwrap().selection.is_empty()); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert!(s.doc().unwrap().doc.node(ordinary).is_none()); assert!(s.doc().unwrap().selection.is_empty()); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); } // Bounds-fitted fill gradients are page-space paints, not Along-stroke gradients. fn eraser_gradient_fill(s: &mut Session, id: NodeId, placed: bool) -> Value { let mut gradient = json!({"kind": "linear", "angle": 90, "dither": false, "stops": [ {"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"} ]}); if placed { gradient["start"] = json!([150, 200]); gradient["end"] = json!([150, 100]); } s.execute("paint.setFill", &json!({"ids": [id.0], "gradient": gradient})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let vectorcraft_doc::color::Paint::Gradient(g) = s.doc().unwrap().doc.node(id).unwrap().appearance.fill_paint() else { panic!("the public paint command must install a gradient fill"); }; assert_eq!(g.geom.is_some(), placed, "the fixture distinguishes fitted and explicitly placed gradients"); assert!(!g.gradient.dither, "exact retained-pixel comparisons do not use noise"); serde_json::to_value(g.geom).unwrap() } fn eraser_gradient_image(s: &Session) -> vectorcraft_render::Rendered { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) } fn eraser_gradient_region(s: &mut Session, mode: &str, trim: bool, miss: bool) -> Value { if mode == "rect" { let rect = if miss { json!([10, 10, 10, 10]) } else if trim { json!([50, 90, 200, 20]) } else { json!([50, 145, 200, 10]) }; s.execute("path.eraseRegion", &json!({"rect": rect})).unwrap() } else { assert!(matches!(mode, "fixed" | "varied")); let params = if miss { json!({"points": [[20, 20]], "size": 10}) } else if trim { json!({"points": [[50, 100], [250, 100]], "size": 20}) } else { json!({"points": [[50, 150], [250, 150]], "size": 10}) }; erase(s, params, mode == "varied") } } fn eraser_gradient_rectangle_case(closed: bool, mode: &str, trim: bool, placed: bool) { let mut s = session(); let id = marquee_rectangle(&mut s, closed, false); let placed_geom = eraser_gradient_fill(&mut s, id, placed); assert_eq!(path(&s, id).is_closed(), closed); let before_image = eraser_gradient_image(&s); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); for y in [125, 175] { assert_eq!(before_image.pixel(150, y)[3], 255, "the retained sample is inside the original fill"); } assert_ne!(before_image.pixel(150, 125), before_image.pixel(150, 175), "the original ramp varies vertically"); let erased_y = if trim { 105 } else { 150 }; assert_eq!(before_image.pixel(150, erased_y)[3], 255); let miss = eraser_gradient_region(&mut s, mode, trim, true); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "a miss must not pin or replace the document"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = eraser_gradient_region(&mut s, mode, trim, false); let ids = result["ids"].as_array().unwrap(); assert_eq!(ids.len(), if trim { 1 } else { 2 }, "closed={closed}, mode={mode}, trim={trim}: actual piece count"); let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(150, erased_y)[3], 0, "the erase operation really removes the intended band"); for y in [125, 175] { assert_eq!( after_image.pixel(150, y), before_image.pixel(150, y), "closed={closed}, mode={mode}, trim={trim}, placed={placed}: retained gradient color at (150, {y})" ); } if placed { for id in ids { let node = s.doc().unwrap().doc.node(NodeId(id.as_u64().unwrap())).unwrap(); let vectorcraft_doc::color::Paint::Gradient(g) = node.appearance.fill_paint() else { panic!("the placed fill remains a gradient") }; assert_eq!(serde_json::to_value(g.geom).unwrap(), placed_geom, "an explicit vector is not refitted"); } } assert_eq!(s.doc().unwrap().history.undo.len(), history + 1, "one erase is one edit"); let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let after_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after); assert_eq!(s.doc().unwrap().selection, after_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); assert_eq!(eraser_gradient_image(&s).pixels, after_image.pixels, "Redo restores the exact rendered result"); } #[test] fn eraser_gradient_retains_page_colors_for_split_trim_and_placed_fill() { // A legal already-placed vector is the positive control for the shared pinning seam. eraser_gradient_rectangle_case(false, "fixed", false, true); for closed in [false, true] { for mode in ["fixed", "varied", "rect"] { for trim in [false, true] { eraser_gradient_rectangle_case(closed, mode, trim, false); } } } } fn eraser_gradient_compound_fixture(s: &mut Session, rule: &str) -> (NodeId, NodeId, NodeId) { let mut ids = vec![]; for anchors in [ json!([{"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200}]), json!([{"x": 140, "y": 140}, {"x": 140, "y": 160}, {"x": 160, "y": 160}, {"x": 160, "y": 140}]), ] { let id = s.execute("path.create", &json!({"anchors": anchors})).unwrap()["id"].as_u64().unwrap(); s.execute("paint.setFill", &json!({"ids": [id], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap(); ids.push(id); } let outer = NodeId(*ids.first().unwrap()); let inner = NodeId(*ids.get(1).unwrap()); s.execute("select.set", &json!({"ids": ids})).unwrap(); let compound = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap()); s.execute("path.setFillRule", &json!({"rule": rule})).unwrap(); eraser_gradient_fill(s, compound, false); let owner = s.doc().unwrap().doc.node(compound).unwrap(); let members = match &owner.kind { NodeKind::Compound { children, .. } => children, other => panic!("expected a compound, got {other:?}"), }; assert_eq!(members.len(), 2); for member in members { assert!(!member.path_data().unwrap().is_closed(), "the compound's source contours are genuinely open"); assert!(member.appearance.fill_paint().is_none() && member.appearance.stroke_paint().is_none(), "the parent alone owns the paint"); } let bounds = owner.geometric_bounds().unwrap(); assert_eq!(bounds, vectorcraft_geom::Rect::new(100.0, 100.0, 200.0, 200.0)); (outer, inner, compound) } fn eraser_gradient_compound_case(outline: bool, rule: &str) { let mut s = session(); let (outer, inner, compound) = eraser_gradient_compound_fixture(&mut s, rule); let before_image = eraser_gradient_image(&s); let retained = if outline { vec![(190, 175)] } else { vec![(150, 125), (150, 175)] }; for &(x, y) in &retained { assert_eq!(before_image.pixel(x, y)[3], 255, "{rule}: retained source interior"); } assert_ne!(before_image.pixel(190, 125), before_image.pixel(190, 175), "the parent paint is a nonconstant vertical ramp"); assert_eq!(before_image.pixel(155, 155)[3], 0, "the source hole is empty"); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let inner_before = serde_json::to_value(s.doc().unwrap().doc.node(inner).unwrap()).unwrap(); let miss = if outline { s.execute("path.eraseSegments", &json!({"points": [[20, 20]], "width": 20})).unwrap() } else { s.execute("path.eraseRegion", &json!({"rect": [145, 145, 10, 10]})).unwrap() }; assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "{rule}: no-op must not pin the owner"); assert_eq!(s.doc().unwrap().history.undo.len(), history); assert_eq!(s.doc().unwrap().selection, selection); if outline { // Path Eraser plans the outer leaf, but its Compound parent supplies the gradient. s.execute("path.eraseSegments", &json!({"points": [[50, 100], [250, 100]], "width": 20})).unwrap(); let after_bounds = s.doc().unwrap().doc.node(compound).unwrap().geometric_bounds().unwrap(); assert!((after_bounds.y0 - 110.0).abs() < 1e-5, "the edited extremal outline shrinks the parent fit: {after_bounds:?}"); assert_eq!(serde_json::to_value(s.doc().unwrap().doc.node(inner).unwrap()).unwrap(), inner_before, "the inner member itself was not edited"); let hole = Point::new(155.0, 155.0); assert!( vectorcraft_geom::hit::fill_contains(&path(&s, outer).to_bezpath(), FillRule::NonZero, hole), "the sample remains inside the outer fill" ); assert!( vectorcraft_geom::hit::fill_contains(&path(&s, inner).to_bezpath(), FillRule::NonZero, hole), "the unchanged inner contour still makes a hole there" ); } else { s.execute("path.eraseRegion", &json!({"rect": [50, 145, 200, 10]})).unwrap(); } let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(155, 155)[3], 0, "{rule}: the un-erased part of the hole stays empty"); if !outline { assert_eq!(after_image.pixel(190, 150)[3], 0, "the marquee actually removes filled art across the ring"); assert_eq!(after_image.pixel(150, 142)[3], 0, "the hole above the erased band remains empty"); } for &(x, y) in &retained { assert_eq!( after_image.pixel(x, y), before_image.pixel(x, y), "{rule}, outline={outline}: parent-owned gradient must keep its original color at ({x}, {y})" ); } assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let after_selection = s.doc().unwrap().selection.clone(); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after); assert_eq!(s.doc().unwrap().selection, after_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); assert_eq!(eraser_gradient_image(&s).pixels, after_image.pixels); } #[test] fn eraser_gradient_compound_owner_keeps_page_colors_and_holes() { for outline in [true, false] { for rule in ["nonZero", "evenOdd"] { eraser_gradient_compound_case(outline, rule); } } } fn eraser_container_gradient_fixture(s: &mut Session, placed: bool, nested: bool) -> (NodeId, NodeId, NodeId, Value) { let mut ids = vec![]; for anchors in [ json!([{"x": 100, "y": 100}, {"x": 150, "y": 100}, {"x": 150, "y": 140}, {"x": 100, "y": 140}]), json!([{"x": 170, "y": 160}, {"x": 220, "y": 160}, {"x": 220, "y": 200}, {"x": 170, "y": 200}]), ] { let id = s.execute("path.create", &json!({"anchors": anchors, "closed": true})).unwrap()["id"].as_u64().unwrap(); s.execute("paint.setFill", &json!({"ids": [id], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap(); ids.push(id); } let edited = NodeId(ids[0]); let sibling = NodeId(ids[1]); s.execute("select.set", &json!({"ids": ids})).unwrap(); let inner = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()); let owner = if nested { NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()) } else { inner }; s.execute("appearance.addFill", &json!({"ids": [owner.0], "target": "object"})).unwrap(); let mut gradient = json!({"kind": "linear", "angle": 90, "dither": false, "stops": [ {"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"} ]}); if placed { gradient["start"] = json!([160, 200]); gradient["end"] = json!([160, 100]); } s.execute("appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "gradient": gradient})).unwrap(); let d = &s.doc().unwrap().doc; let n = d.node(owner).unwrap(); assert!(matches!(n.kind, NodeKind::Group { clip: false, .. })); assert_eq!(n.appearance.items.len(), 1, "the Group owns one fill row"); assert_eq!(n.appearance.contents_at(), 0, "the own fill paints above the children's black fills"); let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the Group itself owns the gradient") }; assert_eq!(g.geom.is_some(), placed); assert!(!g.gradient.dither); let geom = serde_json::to_value(g.geom).unwrap(); assert_eq!(n.geometric_bounds().unwrap(), vectorcraft_geom::Rect::new(100.0, 100.0, 220.0, 200.0)); for id in [edited, sibling] { assert!(!d.node(id).unwrap().appearance.has_unplaced_gradient(), "the gradient is not on a leaf"); } assert_eq!(d.parent_of(edited), Some(inner)); if nested { assert_eq!(d.parent_of(inner), Some(owner)); assert!(d.node(inner).unwrap().appearance.items.is_empty(), "the intervening Group has no own paint"); } s.execute("select.set", &json!({"ids": [edited.0]})).unwrap(); (edited, sibling, owner, geom) } fn eraser_container_gradient_restore(s: &mut Session, before: &Value, selection: &vectorcraft_doc::Selection, history: usize) { let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let after_selection = s.doc().unwrap().selection.clone(); let after_pixels = eraser_gradient_image(s).pixels; assert_eq!(s.doc().unwrap().history.undo.len(), history + 1, "one erase remains one edit"); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), *before); assert_eq!(&s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after); assert_eq!(s.doc().unwrap().selection, after_selection); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); assert_eq!(eraser_gradient_image(s).pixels, after_pixels); } fn eraser_container_gradient_case(placed: bool, nested: bool) { let mut s = session(); let (edited, sibling, owner, geom) = eraser_container_gradient_fixture(&mut s, placed, nested); let before_image = eraser_gradient_image(&s); assert_eq!(before_image.pixel(125, 105)[3], 255, "the extremal child really paints the erase region"); assert_eq!(before_image.pixel(190, 175)[3], 255); assert_ne!(before_image.pixel(190, 175), before_image.pixel(190, 185), "the owner's paint varies on the untouched sibling"); assert_ne!(before_image.pixel(190, 175), [0, 0, 0, 255], "the Group's top paint actually covers the black child"); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let sibling_before = serde_json::to_value(before.node(sibling).unwrap()).unwrap(); let ancestry = before.ancestry(edited).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let miss = eraser_gradient_region(&mut s, "rect", true, true); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "a miss must not replace any ancestor"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = eraser_gradient_region(&mut s, "rect", true, false); assert_eq!(result["ids"].as_array().unwrap().len(), 1, "trim keeps one piece, not a split"); let d = &s.doc().unwrap().doc; assert_eq!(d.ancestry(edited).unwrap(), ancestry, "the child and every original container retain their roles"); assert_eq!(serde_json::to_value(d.node(sibling).unwrap()).unwrap(), sibling_before, "the sibling itself was not edited"); let n = d.node(owner).unwrap(); assert!(matches!(n.kind, NodeKind::Group { clip: false, .. })); assert!((n.geometric_bounds().unwrap().y0 - 110.0).abs() < 1e-5, "the owner's original minimum y really shrinks"); let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(125, 105)[3], 0, "the intended band is erased through the Group's paint"); assert_eq!( after_image.pixel(190, 175), before_image.pixel(190, 175), "placed={placed}, nested={nested}: erasing one child must not recolor its untouched sibling" ); if placed { let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the own fill stays a gradient") }; assert_eq!(serde_json::to_value(g.geom).unwrap(), geom, "an explicitly placed owner is not refitted"); } eraser_container_gradient_restore(&mut s, &before_json, &selection, history); } #[test] fn eraser_container_gradient_keeps_untouched_sibling_colors() { // Positive control runs before the unchanged-product fitted-paint failure. eraser_container_gradient_case(true, false); eraser_container_gradient_case(false, false); eraser_container_gradient_case(false, true); } fn eraser_container_effect_gradient_case(group: bool, placed: bool) { let mut s = session(); let (edited, owner, geom) = if group { let (edited, _, owner, geom) = eraser_container_gradient_fixture(&mut s, placed, false); (edited, owner, geom) } else { let id = marquee_rectangle(&mut s, true, false); let geom = eraser_gradient_fill(&mut s, id, placed); (id, id, geom) }; s.execute( "effect.apply", &json!({ "ids": [owner.0], "target": "object", "item": null, "effect": "path.offsetPath", "params": {"offset": 10, "joins": "round"} }), ) .unwrap(); let d = &s.doc().unwrap().doc; let n = d.node(owner).unwrap(); assert_eq!(n.appearance.effects.len(), 1); let effect = &n.appearance.effects[0]; assert_eq!(effect.id, "path.offsetPath"); assert!(effect.visible); assert_eq!(effect.params["offset"].as_f64(), Some(10.0)); assert_eq!(effect.params["joins"], json!("round")); let effect_before = serde_json::to_value(&n.appearance.effects).unwrap(); let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the effect owner really owns the gradient") }; assert_eq!(g.geom.is_some(), placed); assert!(!g.gradient.dither); assert_eq!(g.gradient.stops.len(), 2); assert_ne!(g.gradient.stops[0].color, g.gradient.stops[1].color, "the own paint is a real nonconstant ramp before rendering"); let original_bounds = n.geometric_bounds().unwrap(); assert_eq!((original_bounds.y0, original_bounds.y1), (100.0, 200.0)); let before_image = eraser_gradient_image(&s); assert_eq!(before_image.pixel(125, 105)[3], 255); assert_eq!(before_image.pixel(190, 175)[3], 255); assert_eq!(before_image.pixel(190, 185)[3], 255); assert_ne!(before_image.pixel(190, 175), before_image.pixel(190, 185), "the rendered own gradient is nonconstant"); assert_eq!(before_image.pixel(190, 205)[3], 255, "the live positive offset paints beyond the source's y=200 bounds"); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let ancestry = before.ancestry(edited).unwrap(); let miss = s.execute("path.eraseRegion", &json!({"rect": [10, 10, 10, 10]})).unwrap(); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before)); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); // Remove 30 pt of source height: the remaining +10 pt live offset cannot // repaint the cleared (125,105) pixel. The offset itself remains live. let result = s.execute("path.eraseRegion", &json!({"rect": [50, 80, 200, 50]})).unwrap(); assert_eq!(result["ids"].as_array().unwrap().len(), 1, "this is a one-piece extremal trim"); let d = &s.doc().unwrap().doc; assert_eq!(d.ancestry(edited).unwrap(), ancestry); let n = d.node(owner).unwrap(); assert!((n.geometric_bounds().unwrap().y0 - 130.0).abs() < 1e-5, "the original owner bounds really shrink"); assert_eq!(serde_json::to_value(&n.appearance.effects).unwrap(), effect_before, "the edit must not flatten or remove the live effect"); let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(125, 105)[3], 0, "the +10 offset cannot repaint this deliberately deep erased band"); assert_eq!( after_image.pixel(190, 175), before_image.pixel(190, 175), "group={group}, placed={placed}: freezing the raw Node box must not recolor retained effected art" ); if placed { let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the placed fill remains a gradient") }; assert_eq!(serde_json::to_value(g.geom).unwrap(), geom); } eraser_container_gradient_restore(&mut s, &before_json, &selection, history); } #[test] fn eraser_container_gradient_keeps_evaluated_offset_fit() { // Establish ordinary legal placement through the SAME live offset first. eraser_container_effect_gradient_case(true, true); eraser_container_effect_gradient_case(false, true); eraser_container_effect_gradient_case(true, false); eraser_container_effect_gradient_case(false, false); } fn eraser_placement_ramp(placed: bool, bottom: f64, top: f64) -> Value { let mut gradient = json!({"kind": "linear", "angle": 90, "dither": false, "stops": [ {"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"} ]}); if placed { gradient["start"] = json!([160, bottom]); gradient["end"] = json!([160, top]); } gradient } fn eraser_placement_effects(s: &Session, owner: NodeId) -> Value { let n = s.doc().unwrap().doc.node(owner).unwrap(); json!({"object": n.appearance.effects, "items": n.appearance.items.iter().map(|item| item.effects()).collect::>()}) } fn eraser_placement_trim( s: &mut Session, edited: NodeId, owner: NodeId, clear: (u32, u32), ) -> (vectorcraft_render::Rendered, vectorcraft_render::Rendered) { let before_image = eraser_gradient_image(s); assert_eq!(before_image.pixel(clear.0, clear.1)[3], 255, "the actual effected art paints the erase witness"); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let ancestry = before.ancestry(edited).unwrap(); let effects = eraser_placement_effects(s, owner); let bounds = before.node(owner).unwrap().geometric_bounds().unwrap(); assert_eq!((bounds.y0, bounds.y1), (100.0, 200.0)); let miss = s.execute("path.eraseRegion", &json!({"rect": [10, 10, 10, 10]})).unwrap(); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before)); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = s.execute("path.eraseRegion", &json!({"rect": [50, 80, 200, 50]})).unwrap(); assert_eq!(result["ids"].as_array().unwrap().len(), 1, "the extremal trim keeps one piece"); let d = &s.doc().unwrap().doc; assert_eq!(d.ancestry(edited).unwrap(), ancestry); assert!((d.node(owner).unwrap().geometric_bounds().unwrap().y0 - 130.0).abs() < 1e-5); assert_eq!(eraser_placement_effects(s, owner), effects, "stored object and item effects stay live and identical"); let after_image = eraser_gradient_image(s); assert_eq!(after_image.pixel(clear.0, clear.1)[3], 0, "the witness really leaves the effected art"); eraser_container_gradient_restore(s, &before_json, &selection, history); (before_image, after_image) } fn eraser_placement_matches( placed: &(vectorcraft_render::Rendered, vectorcraft_render::Rendered), fitted: &(vectorcraft_render::Rendered, vectorcraft_render::Rendered), samples: &[(u32, u32)], ) { for &(x, y) in samples { assert_eq!(placed.0.pixel(x, y)[3], 255); assert_eq!(placed.1.pixel(x, y)[3], 255, "the equivalent placed control retains the sample"); assert_eq!(fitted.0.pixel(x, y), placed.0.pixel(x, y), "the public placed vector is equivalent BEFORE the edit at ({x},{y})"); assert_eq!( fitted.1.pixel(x, y), placed.1.pixel(x, y), "fitted and equivalent placed paint follow the SAME live effects AFTER the edit at ({x},{y})" ); } assert_ne!(placed.0.pixel(samples[0].0, samples[0].1), placed.0.pixel(samples[1].0, samples[1].1)); } fn eraser_placement_affine_scene(placed: bool) -> (vectorcraft_render::Rendered, vectorcraft_render::Rendered) { let mut s = session(); let (edited, _, owner, _) = eraser_container_gradient_fixture(&mut s, false, false); // Offset10 makes the original aggregate fit y=90..210. The explicit control // fixes THAT frame before the following Transform carries it, not the raw box. s.execute( "appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "gradient": eraser_placement_ramp(placed, 210.0, 90.0)}), ) .unwrap(); s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "path.offsetPath", "params": {"offset": 10, "joins": "round"}}), ) .unwrap(); s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "distort.transform", "params": {"scaleH": 100, "scaleV": 150, "reference": 8, "objects": true, "copies": 0, "random": false, "rotate": 0, "moveH": 0, "moveV": 0, "patterns": false, "strokes": false}}), ) .unwrap(); let n = s.doc().unwrap().doc.node(owner).unwrap(); assert_eq!(n.appearance.effects.len(), 2); let transform = &n.appearance.effects[1]; assert_eq!(transform.id, "distort.transform"); assert!(transform.visible); assert_eq!(transform.params["scaleV"].as_f64(), Some(150.0)); assert_eq!(transform.params["reference"].as_f64(), Some(8.0)); assert_eq!(transform.params["objects"].as_bool(), Some(true)); assert_eq!(transform.params["copies"].as_f64(), Some(0.0)); let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("own Group gradient missing") }; assert_eq!(g.geom.is_some(), placed); // Reference8 is the bottom-right of the effected aggregate (230,210), // unchanged by the top trim. V150 sends the original y90 edge to y30; // without this actual affine action pixel(125,60) would be transparent. eraser_placement_trim(&mut s, edited, owner, (125, 60)) } #[test] fn eraser_placement_control_affine_carry_matches_equivalent_placed() { let placed = eraser_placement_affine_scene(true); let fitted = eraser_placement_affine_scene(false); eraser_placement_matches(&placed, &fitted, &[(190, 175), (190, 185)]); } fn eraser_placement_item_stroke_scene(placed: bool) -> (vectorcraft_render::Rendered, vectorcraft_render::Rendered) { let mut s = session(); let id = marquee_rectangle(&mut s, true, false); s.execute("paint.setFill", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("stroke.set", &json!({"ids": [id.0], "weight": 10})).unwrap(); // The row's +10 geometry expands y100..200 to y90..210; Within stroke // weight10 fits its gradient to the inflated y85..215 paint box. s.execute( "paint.setStroke", &json!({"ids": [id.0], "gradient": eraser_placement_ramp(placed, 215.0, 85.0)}), ) .unwrap(); let index = s .doc() .unwrap() .doc .node(id) .unwrap() .appearance .items .iter() .position(|item| matches!(item, vectorcraft_doc::AppearanceItem::Stroke(_))) .unwrap(); s.execute("paint.editGradient", &json!({"ids": [id.0], "item": index, "stroke": true, "strokeMode": "within"})).unwrap(); s.execute( "effect.apply", &json!({"ids": [id.0], "target": "object", "item": index, "effect": "path.offsetPath", "params": {"offset": 10, "joins": "round"}}), ) .unwrap(); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let n = s.doc().unwrap().doc.node(id).unwrap(); assert!(matches!(n.kind, NodeKind::Path { .. })); assert!(n.appearance.fill_paint().is_none()); assert!(n.appearance.effects.is_empty(), "this effect belongs only to the stroke row"); let vectorcraft_doc::AppearanceItem::Stroke(st) = &n.appearance.items[index] else { panic!("public stroke row missing") }; assert_eq!(st.width, 10.0); assert_eq!(st.gradient_mode, vectorcraft_doc::StrokeGradientMode::Within); assert!(st.path_gradient().is_none(), "the test excludes Along/Across path-coordinate paint"); assert_eq!(st.effects.len(), 1); assert_eq!(st.effects[0].id, "path.offsetPath"); assert!(st.effects[0].visible); let vectorcraft_doc::color::Paint::Gradient(g) = &st.paint else { panic!("stroke gradient missing") }; assert_eq!(g.geom.is_some(), placed); assert!(!g.gradient.dither); eraser_placement_trim(&mut s, id, id, (150, 90)) } #[test] fn eraser_placement_control_item_within_stroke_matches_equivalent_placed() { let placed = eraser_placement_item_stroke_scene(true); let fitted = eraser_placement_item_stroke_scene(false); eraser_placement_matches(&placed, &fitted, &[(210, 175), (210, 185)]); } fn eraser_mixed_gradient_hidden_stroke(s: &mut Session, id: NodeId, rasterize: bool) -> usize { let index = s.doc().unwrap().doc.node(id).unwrap().appearance.items.iter().position(|item| !item.is_fill()).unwrap(); s.execute( "appearance.setItem", &json!({"ids": [id.0], "index": index, "weight": 4, "gradient": { "kind": "linear", "stops": [{"offset": 0, "color": "#00ff00"}, {"offset": 1, "color": "#ff00ff"}] }}), ) .unwrap(); let mode = if rasterize { "within" } else { "along" }; s.execute("paint.editGradient", &json!({"ids": [id.0], "item": index, "stroke": true, "strokeMode": mode})).unwrap(); if rasterize { s.execute("effect.apply", &json!({"ids": [id.0], "target": "object", "item": index, "effect": "rasterize", "params": {}})).unwrap(); } s.execute("appearance.setItem", &json!({"ids": [id.0], "index": index, "visible": false})).unwrap(); index } fn eraser_mixed_gradient_rows_case(placed: bool, rasterize: bool) -> ([[u8; 4]; 2], [[u8; 4]; 2]) { let mut s = session(); let id = marquee_rectangle(&mut s, false, false); let placed_geom = eraser_gradient_fill(&mut s, id, placed); let index = eraser_mixed_gradient_hidden_stroke(&mut s, id, rasterize); let node = s.doc().unwrap().doc.node(id).unwrap(); assert!(!path(&s, id).is_closed(), "the fixture exercises the fill-only open-path route"); assert!(node.appearance.has_drawn_fill()); let hidden = node.appearance.items[index].clone(); let vectorcraft_doc::AppearanceItem::Stroke(stroke) = &hidden else { panic!("the explicit row is a stroke") }; assert!(!stroke.visible); assert_eq!(stroke.width, 4.0, "the hidden row has a genuine positive stroke weight"); assert!(matches!(stroke.paint, vectorcraft_doc::color::Paint::Gradient(_))); assert_eq!(stroke.path_gradient().is_some(), !rasterize, "the two cases isolate the two owner-wide guard branches"); assert_eq!( stroke.gradient_mode, if rasterize { vectorcraft_doc::StrokeGradientMode::Within } else { vectorcraft_doc::StrokeGradientMode::Along } ); assert_eq!(stroke.effects.iter().any(|e| e.visible && e.id == "rasterize"), rasterize); assert!( node.appearance .items .iter() .all(|item| { !matches!(item, vectorcraft_doc::AppearanceItem::Stroke(st) if st.visible && !st.paint.is_none() && st.width > 0.0) }), "no visible painted stroke may change Eraser's area eligibility" ); let vectorcraft_doc::color::Paint::Gradient(fill) = node.appearance.fill_paint() else { panic!("the visible fill is a gradient") }; assert_eq!(fill.geom.is_some(), placed); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let before_image = eraser_gradient_image(&s); let before_colors = [before_image.pixel(150, 125), before_image.pixel(150, 175)]; assert!(before_colors.iter().all(|color| color[3] == 255)); assert_ne!(before_colors[0], before_colors[1], "the visible fill is a genuine nonconstant ramp"); assert_eq!(before_image.pixel(150, 150)[3], 255); let miss = eraser_gradient_region(&mut s, "rect", false, true); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before)); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = eraser_gradient_region(&mut s, "rect", false, false); let ids = result["ids"].as_array().unwrap(); assert_eq!(ids.len(), 2, "the marquee splits the filled area into two retained pieces"); for value in ids { let node = s.doc().unwrap().doc.node(NodeId(value.as_u64().unwrap())).unwrap(); assert_eq!(node.appearance.items[index], hidden, "the unsupported hidden row stays byte-for-byte unchanged"); if placed { let vectorcraft_doc::color::Paint::Gradient(fill) = node.appearance.fill_paint() else { panic!("the fill stays a gradient") }; assert_eq!(serde_json::to_value(fill.geom).unwrap(), placed_geom); } } let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(150, 150)[3], 0, "the intended fill band is erased"); let after_colors = [after_image.pixel(150, 125), after_image.pixel(150, 175)]; eraser_container_gradient_restore(&mut s, &before_json, &selection, history); (before_colors, after_colors) } #[test] fn eraser_mixed_gradient_rows_keep_visible_fill_placement() { let placed_along = eraser_mixed_gradient_rows_case(true, false); assert_eq!(placed_along.0, placed_along.1, "an explicitly placed fill with hidden Along stroke is the legitimate control"); let placed_rasterize = eraser_mixed_gradient_rows_case(true, true); assert_eq!(placed_rasterize.0, placed_rasterize.1, "an explicitly placed fill with a hidden Rasterize row remains unchanged"); // Finish both fitted scenes, including metadata/no-op/Undo controls, before the shared color assertion. let fitted_along = eraser_mixed_gradient_rows_case(false, false); let fitted_rasterize = eraser_mixed_gradient_rows_case(false, true); assert!( fitted_along.0 == fitted_along.1 && fitted_rasterize.0 == fitted_rasterize.1, "hidden rows must not suppress the visible fill's placement: Along {fitted_along:?}; Rasterize {fitted_rasterize:?}" ); } fn eraser_endpoint_region(s: &mut Session, mode: &str, miss: bool) -> Value { if mode == "rect" { let rect = if miss { json!([55, 145, 10, 10]) } else { json!([150, 140, 20, 20]) }; s.execute("path.eraseRegion", &json!({"rect": rect})).unwrap() } else { let points = if miss { json!([[60, 150]]) } else { json!([[160, 150]]) }; erase(s, json!({"points": points, "size": 20}), mode == "varied") } } fn eraser_keeps_unused_endpoint_handles_out_of_fill_case(mode: &str) { for (closed, stroked) in [(false, false), (true, false), (false, true)] { let mut s = session(); let id = NodeId( s.execute( "path.create", &json!({"closed": closed, "anchors": [ {"x": 100, "y": 100, "in": [0, 100]}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200, "out": [0, 200]} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); if stroked { s.execute("paint.setFill", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("stroke.set", &json!({"ids": [id.0], "weight": 4})).unwrap(); } else { s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); } s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let sp = &path(&s, id).subpaths[0]; assert_eq!(sp.closed, closed); assert_eq!(sp.anchors.first().unwrap().h_in, Point::new(0.0, 100.0)); assert_eq!(sp.anchors.last().unwrap().h_out, Point::new(0.0, 200.0)); let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let before_image = eraser_gradient_image(&s); assert_eq!(before_image.pixel(60, 150)[3], if closed { 255 } else { 0 }, "{mode}: fixture closure"); assert_eq!(before_image.pixel(160, 150)[3], if stroked { 0 } else { 255 }, "{mode}: interior witness"); let result = eraser_endpoint_region(&mut s, mode, false); let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(160, 150)[3], 0, "{mode}: erased interior"); assert_eq!(after_image.pixel(60, 150), before_image.pixel(60, 150), "{mode}: no new bulge or lost closed curve"); if stroked { assert_eq!(result["ids"], json!([]), "{mode}: the open outline misses an interior dab"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); continue; } assert_eq!(after_image.pixel(180, 180), [0, 0, 0, 255], "{mode}: retained fill"); assert_eq!(s.doc().unwrap().history.undo.len(), history + 1); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before, "{mode}: original geometry and endpoint handles restored"); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); if !closed { let miss = eraser_endpoint_region(&mut s, mode, true); assert_eq!(miss["ids"], json!([]), "{mode}: the phantom bulge cannot count as an intersection"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); } } } #[test] fn eraser_keeps_unused_endpoint_handles_out_of_fill_marquee() { eraser_keeps_unused_endpoint_handles_out_of_fill_case("rect"); } #[test] fn eraser_keeps_unused_endpoint_handles_out_of_fill_fixed_tip() { eraser_keeps_unused_endpoint_handles_out_of_fill_case("fixed"); } #[test] fn eraser_keeps_unused_endpoint_handles_out_of_fill_varied_tip() { eraser_keeps_unused_endpoint_handles_out_of_fill_case("varied"); } fn eraser_copying_container_gradient_before_colors(before_image: &vectorcraft_render::Rendered) -> [[u8; 4]; 2] { let before_colors = [before_image.pixel(190, 175), before_image.pixel(190, 185)]; assert!(before_colors.iter().all(|color| color[3] == 255)); assert_ne!(before_colors[0], before_colors[1], "the original sibling draws a nonconstant gradient"); assert_ne!(before_colors[0], [0, 0, 0, 255], "the Group's own fill covers the black child"); assert_eq!(before_image.pixel(125, 105)[3], 255, "the original extremal child paints the trim witness"); assert_eq!(before_image.pixel(190, 295)[3], 255, "the translated sibling copy really paints"); before_colors } fn eraser_copying_container_gradient_child_offset(s: &mut Session, sibling: NodeId, owner: NodeId, placed: bool) { s.execute( "effect.apply", &json!({"ids": [sibling.0], "target": "object", "item": null, "effect": "path.offsetPath", "params": {"offset": 10, "joins": "round"}}), ) .unwrap(); // The untouched sibling's live offset makes the evaluated source box // [100,100,230,210]; the Group's raw source box is still [100,100,220,200]. let mut gradient = eraser_placement_ramp(placed, 210.0, 100.0); if placed { gradient["start"] = json!([165, 210]); gradient["end"] = json!([165, 100]); } s.execute("appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "gradient": gradient})).unwrap(); let sibling_node = s.doc().unwrap().doc.node(sibling).unwrap(); assert_eq!(sibling_node.appearance.effects.len(), 1); assert_eq!(sibling_node.appearance.effects[0].id, "path.offsetPath"); assert!(sibling_node.appearance.effects[0].visible); assert_eq!(sibling_node.appearance.effects[0].params["offset"].as_f64(), Some(10.0)); } fn eraser_copying_container_gradient_scene(placed: bool) -> ([[u8; 4]; 2], [[u8; 4]; 2]) { let mut s = session(); let (edited, sibling, owner, geom) = eraser_container_gradient_fixture(&mut s, placed, false); s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "stylize.dropShadow", "params": {"x": 10, "y": 0, "blur": 0}}), ) .unwrap(); s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "distort.transform", "params": {"scaleH": 100, "scaleV": 100, "reference": 8, "objects": true, "copies": 1, "random": false, "rotate": 0, "moveH": 0, "moveV": 120, "patterns": false, "strokes": false}}), ) .unwrap(); let n = s.doc().unwrap().doc.node(owner).unwrap(); assert!(matches!(n.kind, NodeKind::Group { clip: false, .. })); assert_eq!(n.appearance.effects.len(), 2); assert_eq!(n.appearance.effects[0].id, "stylize.dropShadow"); assert!(n.appearance.effects[0].visible); assert_eq!(n.appearance.effects[1].id, "distort.transform"); assert!(n.appearance.effects[1].visible); assert_eq!(n.appearance.effects[1].params["copies"].as_f64(), Some(1.0)); assert_eq!(n.appearance.effects[1].params["moveV"].as_f64(), Some(120.0)); let effects = serde_json::to_value(&n.appearance.effects).unwrap(); let before_image = eraser_gradient_image(&s); let before_colors = eraser_copying_container_gradient_before_colors(&before_image); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let sibling_before = serde_json::to_value(before.node(sibling).unwrap()).unwrap(); let ancestry = before.ancestry(edited).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let miss = eraser_gradient_region(&mut s, "rect", true, true); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "a miss cannot pin an ancestor"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = eraser_gradient_region(&mut s, "rect", true, false); assert_eq!(result["ids"].as_array().unwrap().len(), 1, "the extremal trim keeps one piece"); let d = &s.doc().unwrap().doc; assert_eq!(d.ancestry(edited).unwrap(), ancestry); assert_eq!(serde_json::to_value(d.node(sibling).unwrap()).unwrap(), sibling_before, "the sibling itself is unchanged"); let n = d.node(owner).unwrap(); assert!(matches!(n.kind, NodeKind::Group { clip: false, .. })); assert!((n.geometric_bounds().unwrap().y0 - 110.0).abs() < 1e-5); assert_eq!(serde_json::to_value(&n.appearance.effects).unwrap(), effects, "both effects stay live and unchanged"); if placed { let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the own fill stays a gradient") }; assert_eq!(serde_json::to_value(g.geom).unwrap(), geom, "the explicit source fit must not be rewritten"); } let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(125, 105)[3], 0, "the intended band was erased"); let after_colors = [after_image.pixel(190, 175), after_image.pixel(190, 185)]; assert!(after_colors.iter().all(|color| color[3] == 255)); eraser_container_gradient_restore(&mut s, &before_json, &selection, history); (before_colors, after_colors) } #[test] fn eraser_copying_container_gradient_keeps_source_fit_on_untouched_sibling() { // The source is painted before its translated copy is made. The fixture's explicit // [160,200] -> [160,100] fit is equivalent to the source's original fitted paint. let placed = eraser_copying_container_gradient_scene(true); let fitted = eraser_copying_container_gradient_scene(false); assert_eq!(placed.0, placed.1, "the legitimate explicitly placed source fit preserves the untouched sibling"); assert_eq!(fitted.0, placed.0, "both source fits must draw the same original sibling before editing"); assert_eq!(fitted.1, fitted.0, "pinning a copying container must not recolor an untouched original sibling"); assert_eq!(fitted.1, placed.1, "the fitted edit must match the equivalent explicitly placed source fit"); } fn eraser_copying_container_gradient_owner_effects(n: &vectorcraft_doc::Node, nested_copy: bool) { assert!(matches!(n.kind, NodeKind::Group { clip: false, .. })); assert_eq!(n.appearance.effects.len(), if nested_copy { 3 } else { 2 }); assert_eq!(n.appearance.effects[0].id, "stylize.dropShadow"); assert!(n.appearance.effects[0].visible); for (index, effect) in n.appearance.effects.iter().enumerate().skip(1) { assert_eq!(effect.id, "distort.transform"); assert!(effect.visible); assert_eq!(effect.params["copies"].as_f64(), Some(1.0)); let move_v = if nested_copy && index == 1 { 60.0 } else { 120.0 }; assert_eq!(effect.params["moveV"].as_f64(), Some(move_v)); } } fn eraser_copying_container_gradient_variant_scene(placed: bool, nested_copy: bool) -> ([[u8; 4]; 2], [[u8; 4]; 2]) { let mut s = session(); let (edited, sibling, owner, _) = eraser_container_gradient_fixture(&mut s, placed, false); if !nested_copy { eraser_copying_container_gradient_child_offset(&mut s, sibling, owner, placed); } s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "stylize.dropShadow", "params": {"x": 10, "y": 0, "blur": 0}}), ) .unwrap(); if nested_copy { s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "distort.transform", "params": {"scaleH": 100, "scaleV": 100, "reference": 8, "objects": true, "copies": 1, "random": false, "rotate": 0, "moveH": 0, "moveV": 60, "patterns": false, "strokes": false}}), ) .unwrap(); } s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "distort.transform", "params": {"scaleH": 100, "scaleV": 100, "reference": 8, "objects": true, "copies": 1, "random": false, "rotate": 0, "moveH": 0, "moveV": 120, "patterns": false, "strokes": false}}), ) .unwrap(); let n = s.doc().unwrap().doc.node(owner).unwrap(); eraser_copying_container_gradient_owner_effects(n, nested_copy); let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the Group owns the gradient") }; assert_eq!(g.geom.is_some(), placed); let geom = serde_json::to_value(g.geom).unwrap(); let effects = serde_json::to_value(&n.appearance.effects).unwrap(); let before_image = eraser_gradient_image(&s); let before_colors = eraser_copying_container_gradient_before_colors(&before_image); let before = s.doc().unwrap().doc.clone(); let before_json = serde_json::to_value(&before).unwrap(); let sibling_before = serde_json::to_value(before.node(sibling).unwrap()).unwrap(); let ancestry = before.ancestry(edited).unwrap(); let selection = s.doc().unwrap().selection.clone(); let history = s.doc().unwrap().history.undo.len(); let miss = eraser_gradient_region(&mut s, "rect", true, true); assert_eq!(miss["ids"], json!([])); assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "a miss cannot pin an ancestor"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_json); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(s.doc().unwrap().history.undo.len(), history); let result = eraser_gradient_region(&mut s, "rect", true, false); assert_eq!(result["ids"].as_array().unwrap().len(), 1, "the extremal trim keeps one piece"); let d = &s.doc().unwrap().doc; assert_eq!(d.ancestry(edited).unwrap(), ancestry); assert_eq!(serde_json::to_value(d.node(sibling).unwrap()).unwrap(), sibling_before, "the sibling itself is unchanged"); let n = d.node(owner).unwrap(); assert!(matches!(n.kind, NodeKind::Group { clip: false, .. })); assert!((n.geometric_bounds().unwrap().y0 - 110.0).abs() < 1e-5); assert_eq!(serde_json::to_value(&n.appearance.effects).unwrap(), effects, "both effects stay live and unchanged"); if placed { let vectorcraft_doc::color::Paint::Gradient(g) = n.appearance.fill_paint() else { panic!("the own fill stays a gradient") }; assert_eq!(serde_json::to_value(g.geom).unwrap(), geom, "the explicit source fit must not be rewritten"); } let after_image = eraser_gradient_image(&s); assert_eq!(after_image.pixel(125, 105)[3], 0, "the intended band was erased"); let after_colors = [after_image.pixel(190, 175), after_image.pixel(190, 185)]; assert!(after_colors.iter().all(|color| color[3] == 255)); eraser_container_gradient_restore(&mut s, &before_json, &selection, history); (before_colors, after_colors) } #[test] fn eraser_copying_container_gradient_keeps_evaluated_child_source_fit() { let placed = eraser_copying_container_gradient_variant_scene(true, false); let fitted = eraser_copying_container_gradient_variant_scene(false, false); assert_eq!(placed.0, placed.1, "the explicitly placed evaluated-child source fit preserves the untouched sibling"); assert_eq!(fitted.0, placed.0, "both paints fit the evaluated source before copying"); assert_eq!(fitted.1, fitted.0, "pinning uses evaluated child geometry, not the raw prefix box"); assert_eq!(fitted.1, placed.1, "fitted paint matches the equivalent evaluated-source placement after editing"); } #[test] fn eraser_copying_container_gradient_keeps_source_fit_through_earlier_copy() { // Both copying effects are eligible: the outer split still leaves the earlier // copying Transform in its prefix. Own paint is fitted before either copy. let placed = eraser_copying_container_gradient_variant_scene(true, true); let fitted = eraser_copying_container_gradient_variant_scene(false, true); assert_eq!(placed.0, placed.1, "the explicit original-source fit is unchanged by the trim"); assert_eq!(fitted.0, placed.0, "the original source fit is equivalent before both copy stages"); assert_eq!(fitted.1, fitted.0, "pinning follows the earlier eligible copy split as rendering does"); assert_eq!(fitted.1, placed.1, "both live copy stages preserve the same source placement after editing"); } #[test] fn eraser_keeps_group_painted_open_paths_on_the_outline_route() { for mode in ["fixed", "varied", "marquee"] { for group_stroke in [false, true] { let mut s = session(); let id = NodeId( s.execute( "path.create", &json!({"anchors": [ {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#0000ff"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let group = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()); if group_stroke { s.execute("appearance.addStroke", &json!({"ids": [group.0], "target": "object"})).unwrap(); s.execute( "appearance.setItem", &json!({"ids": [group.0], "target": "object", "index": 0, "color": "#ff0000", "weight": 4}), ) .unwrap(); } s.execute("select.none", &json!({})).unwrap(); assert!(!path(&s, id).is_closed()); let d = &s.doc().unwrap().doc; assert_eq!(d.parent_of(id), Some(group)); assert!(d.node(id).unwrap().appearance.stroke_paint().is_none()); assert_eq!(d.node(group).unwrap().appearance.stroke_width(), if group_stroke { 4.0 } else { 0.0 }); let render = |s: &Session| { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) }; let before_image = render(&s); assert_eq!(before_image.pixel(150, 150), [0, 0, 255, 255]); if group_stroke { assert_eq!(before_image.pixel(150, 100), [255, 0, 0, 255], "the Group really paints the child's open outline"); assert_eq!(before_image.pixel(99, 125)[3], 0, "the missing closing edge is not stroked"); } let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let history = s.doc().unwrap().history.undo.len(); let selection = s.doc().unwrap().selection.clone(); let paint = s.paint.clone(); // This ordinary Eraser gesture hits fill, at least 30 pt from every real outline. let result = match mode { "marquee" => s.execute("path.eraseRegion", &json!({"rect": [130, 145, 40, 10]})).unwrap(), _ => erase(&mut s, json!({"points": [[130, 150], [170, 150]], "size": 10}), mode == "varied"), }; if group_stroke { assert_eq!(result["ids"], json!([]), "{mode}: a Group-painted open outline keeps main's miss behavior"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().history.undo.len(), history); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(render(&s).pixels, before_image.pixels); } else { assert!(!result["ids"].as_array().unwrap().is_empty(), "{mode}: the fill-only Group control still cuts as an area"); let after_image = render(&s); assert_eq!(after_image.pixel(150, 150)[3], 0); assert_eq!(after_image.pixel(120, 125), [0, 0, 255, 255]); } assert_eq!(s.paint, paint); } } } #[test] fn eraser_ancestor_stroke_classification_keeps_container_context() { for container in ["nested", "layer", "compound", "clip"] { for stroke in ["painted", "hidden", "none", "zero"] { eraser_ancestor_stroke_case(container, stroke); } } } fn eraser_ancestor_stroke_case(container: &str, stroke: &str) { let mut s = eraser_ancestor_stroke_scene(container, stroke); let render = |s: &Session| { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) }; let before_image = render(&s); assert_eq!(before_image.pixel(150, 150), [0, 0, 255, 255], "{container}/{stroke}: actual filled input"); let outline_route = stroke == "painted" && container != "clip"; if outline_route { assert_eq!(before_image.pixel(150, 100), [255, 0, 0, 255], "{container}: actual ancestor stroke"); } else if container == "clip" && stroke == "painted" { assert_eq!(before_image.pixel(150, 90), [255, 0, 0, 255], "the ancestor paints the clipping outline"); assert_eq!(before_image.pixel(150, 100), [0, 0, 255, 255], "the ancestor does not stroke the clipped child's outline"); } let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); let history = s.doc().unwrap().history.undo.len(); let selection = s.doc().unwrap().selection.clone(); let paint = s.paint.clone(); let result = erase(&mut s, json!({"points": [[130, 150], [170, 150]], "size": 10}), false); if outline_route { assert_eq!(result["ids"], json!([]), "{container}/{stroke}: preserve main's open-outline miss"); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().history.undo.len(), history); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(render(&s).pixels, before_image.pixels); } else { assert!(!result["ids"].as_array().unwrap().is_empty(), "{container}/{stroke}: the eligible fill still cuts"); let after_image = render(&s); assert_eq!(after_image.pixel(150, 150)[3], 0, "{container}/{stroke}"); assert_eq!(after_image.pixel(120, 125), [0, 0, 255, 255], "{container}/{stroke}"); s.execute("edit.undo", &json!({})).unwrap(); assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before); assert_eq!(s.doc().unwrap().selection, selection); assert_eq!(render(&s).pixels, before_image.pixels); s.execute("edit.redo", &json!({})).unwrap(); assert_eq!(render(&s).pixel(150, 150)[3], 0); } assert_eq!(s.paint, paint); } fn eraser_ancestor_stroke_scene(container: &str, stroke: &str) -> Session { let mut s = session(); let id = NodeId( s.execute( "path.create", &json!({"anchors": [ {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} ]}), ) .unwrap()["id"] .as_u64() .unwrap(), ); s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#0000ff"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [id.0], "none": true})).unwrap(); s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); let mut subject = id; if container == "compound" { let other = s .execute( "path.create", &json!({"anchors": [ {"x": 220, "y": 100}, {"x": 240, "y": 100}, {"x": 240, "y": 120}, {"x": 220, "y": 120} ]}), ) .unwrap()["id"] .as_u64() .unwrap(); s.execute("paint.setFill", &json!({"ids": [other], "color": "#0000ff"})).unwrap(); s.execute("paint.setStroke", &json!({"ids": [other], "none": true})).unwrap(); s.execute("select.set", &json!({"ids": [id.0, other]})).unwrap(); subject = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap()); let NodeKind::Compound { children, .. } = &s.doc().unwrap().doc.node(subject).unwrap().kind else { panic!("the public Make command produces a compound path") }; assert_eq!(children.len(), 2); assert!(children.iter().all(|child| !child.path_data().unwrap().is_closed())); } else if container == "clip" { let mask = s.execute("shape.rectangle", &json!({"x": 90, "y": 90, "width": 120, "height": 120})).unwrap()["id"].as_u64().unwrap(); s.execute("select.set", &json!({"ids": [id.0, mask]})).unwrap(); subject = NodeId(s.execute("object.clippingMask.make", &json!({})).unwrap()["id"].as_u64().unwrap()); assert!(s.doc().unwrap().doc.node(subject).unwrap().clips()); } let owner = if container == "layer" { s.doc().unwrap().doc.layer_of(id).unwrap() } else { s.execute("select.set", &json!({"ids": [subject.0]})).unwrap(); let inner = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()); if container == "nested" { NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()) } else { inner } }; s.execute("appearance.addStroke", &json!({"ids": [owner.0], "target": "object"})).unwrap(); s.execute( "appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "color": "#ff0000", "weight": if stroke == "zero" { 0 } else { 4 }, "visible": stroke != "hidden"}), ) .unwrap(); if stroke == "none" { s.execute("appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "none": true})).unwrap(); } // Select only the original open child (or the two-member compound). In the clip // control, neither the mask nor the other container geometry is an Eraser target. let selected = if container == "compound" { subject } else { id }; s.execute("select.set", &json!({"ids": [selected.0]})).unwrap(); s } // Pinning-only checks: no Eraser operation or other geometry edit is performed below. fn eraser_pinning_only_same_pixels(a: &vectorcraft_render::Rendered, b: &vectorcraft_render::Rendered, label: &str) { let changed = (0..300).find_map(|y| (0..300).find(|&x| a.pixel(x, y) != b.pixel(x, y)).map(|x| (x, y, a.pixel(x, y), b.pixel(x, y)))); assert_eq!(changed, None, "{label}: first changed pixel"); } fn eraser_pinning_only_nested_scene(placed: bool, parent_offset: bool) -> (Session, NodeId) { let mut s = session(); let (_, _, owner, _) = eraser_container_gradient_fixture(&mut s, false, false); s.execute("select.set", &json!({"ids": [owner.0]})).unwrap(); let outer = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap()); if parent_offset { s.execute( "effect.apply", &json!({"ids": [outer.0], "target": "object", "item": null, "effect": "path.offsetPath", "params": {"offset": 10, "joins": "round"}}), ) .unwrap(); } // These are the retained ordinary fit and the existing +10 pt evaluated fit. let (bottom, top) = if parent_offset { (210.0, 90.0) } else { (200.0, 100.0) }; s.execute( "appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "gradient": eraser_placement_ramp(placed, bottom, top)}), ) .unwrap(); let doc = &s.doc().unwrap().doc; assert_eq!(doc.parent_of(owner), Some(outer), "INPUT: the gradient owner is nested in the effect owner"); assert_eq!(doc.node(owner).unwrap().geometric_bounds().unwrap(), vectorcraft_geom::Rect::new(100.0, 100.0, 220.0, 200.0)); assert!(doc.node(owner).unwrap().appearance.effects.is_empty(), "INPUT: the offset belongs to the enclosing Group only"); let effects = &doc.node(outer).unwrap().appearance.effects; assert_eq!(effects.len(), usize::from(parent_offset)); if parent_offset { assert_eq!(effects[0].id, "path.offsetPath"); assert!(effects[0].visible); assert_eq!(effects[0].params["offset"].as_f64(), Some(10.0)); assert_eq!(effects[0].params["joins"], json!("round")); } let vectorcraft_doc::color::Paint::Gradient(g) = doc.node(owner).unwrap().appearance.fill_paint() else { panic!("INPUT: the nested Group owns the gradient") }; assert_eq!(g.geom.is_some(), placed); assert!(!g.gradient.dither); (s, owner) } fn eraser_pinning_only_nested_case(parent_offset: bool) { let (s, owner) = eraser_pinning_only_nested_scene(false, parent_offset); let (placed, placed_owner) = eraser_pinning_only_nested_scene(true, parent_offset); let before = eraser_gradient_image(&s); let explicit = eraser_gradient_image(&placed); assert_eq!(before.pixel(190, 175)[3], 255, "INPUT: the retained sibling is painted"); assert_eq!(before.pixel(190, 185)[3], 255); assert_ne!(before.pixel(190, 175), before.pixel(190, 185), "INPUT: the fitted ramp is nonconstant"); if parent_offset { assert_eq!(before.pixel(190, 205)[3], 255, "INPUT: the enclosing positive offset reaches beyond the raw box"); } eraser_pinning_only_same_pixels(&before, &explicit, "INPUT: the independently placed control matches before pinning"); let placed_doc = &placed.doc().unwrap().doc; assert!( vectorcraft_render::pinned_appearance_for_geometry_edit(placed_doc, placed_doc.node(placed_owner).unwrap()).is_none(), "INPUT: an already explicit placement needs no pinning" ); let label = if parent_offset { "PINNING_ONLY: nested Group under positive Offset Path" } else { "CONTROL: nested Group without enclosing effects" }; eraser_pinning_only_store(&s.doc().unwrap().doc, owner, &before, !parent_offset, label); } fn eraser_pinning_only_store(doc: &vectorcraft_doc::Document, owner: NodeId, before: &vectorcraft_render::Rendered, required: bool, label: &str) { let original = serde_json::to_value(doc).unwrap(); let node = doc.node(owner).unwrap(); let Some(pinned) = vectorcraft_render::pinned_appearance_for_geometry_edit(doc, node) else { assert!(!required, "INPUT: the ordinary control must pin reproducibly: {label}"); assert_eq!(serde_json::to_value(doc).unwrap(), original); println!("PINNING_FALLBACK: {label} remains fitted; no pixel failure established"); return; }; assert_eq!(serde_json::to_value(doc).unwrap(), original, "INPUT: the public helper leaves its input unchanged"); let vectorcraft_doc::color::Paint::Gradient(g) = pinned.fill_paint() else { panic!("INPUT: returned paint is a gradient") }; assert!(g.geom.is_some(), "INPUT: the returned fitted gradient has an explicit placement"); // The fixed linear fixture permits only stored gradient geometry to change, not effects or other row data. let mut normalized = pinned.clone(); assert_eq!(normalized.items.len(), node.appearance.items.len()); for (after, before) in normalized.items.iter_mut().zip(&node.appearance.items) { if let (vectorcraft_doc::color::Paint::Gradient(a), vectorcraft_doc::color::Paint::Gradient(b)) = (after.paint_mut(), before.paint()) { a.geom = b.geom; } } assert_eq!(serde_json::to_value(&normalized).unwrap(), serde_json::to_value(&node.appearance).unwrap(), "INPUT: only placement changes"); let mut only_paint = doc.clone(); only_paint.node_mut(owner).unwrap().appearance = pinned.into(); let mut restored = only_paint.clone(); restored.node_mut(owner).unwrap().appearance = node.appearance.clone(); assert_eq!(serde_json::to_value(&restored).unwrap(), original, "INPUT: geometry, effects and every other source field are unchanged"); let after = vectorcraft_render::Renderer::new().render(&only_paint, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); eraser_pinning_only_same_pixels(before, &after, label); } #[test] fn eraser_pinning_only_nested_gradient_matches_unchanged_render() { // Establish the ordinary nested Group without an enclosing geometry effect FIRST. eraser_pinning_only_nested_case(false); // One retained positive offset, no cut, parameter search or timing measurement. eraser_pinning_only_nested_case(true); } fn eraser_pinning_only_text_clip_case(stroked: bool, no_stroke: Option<&vectorcraft_render::Rendered>) -> vectorcraft_render::Rendered { assert_eq!(stroked, no_stroke.is_some(), "INPUT: the subject follows its no-stroke control"); // Original clippaint.rs text, paint, font defaults and geometry; one retained ordinary scale. let mut s = session(); let art = s.execute("shape.rectangle", &json!({"x": 0, "y": 50, "width": 30, "height": 100})).unwrap()["id"].as_u64().unwrap(); s.execute("paint.setFill", &json!({"ids": [art], "color": "#ff0000"})).unwrap(); let text = NodeId(s.execute("text.create", &json!({"x": 10, "y": 120, "text": "Clip", "size": 72})).unwrap()["id"].as_u64().unwrap()); s.execute("select.all", &json!({})).unwrap(); let owner = NodeId(s.execute("object.clippingMask.make", &json!({})).unwrap()["id"].as_u64().unwrap()); s.execute("paint.setFill", &json!({"ids": [text.0], "color": "#0000ff"})).unwrap(); if stroked { s.execute("paint.setStroke", &json!({"ids": [text.0], "color": "#00ff00"})).unwrap(); s.execute("stroke.set", &json!({"ids": [text.0], "weight": 2})).unwrap(); } else { s.execute("paint.setStroke", &json!({"ids": [text.0], "none": true})).unwrap(); } s.execute("appearance.addFill", &json!({"ids": [owner.0], "target": "object"})).unwrap(); s.execute( "appearance.setItem", &json!({"ids": [owner.0], "target": "object", "index": 0, "gradient": eraser_placement_ramp(false, 200.0, 100.0)}), ) .unwrap(); s.execute( "effect.apply", &json!({"ids": [owner.0], "target": "object", "item": null, "effect": "distort.transform", "params": {"scaleH": 100, "scaleV": 150, "reference": 8, "objects": true, "copies": 0, "random": false, "rotate": 0, "moveH": 0, "moveV": 0, "patterns": false, "strokes": false}}), ) .unwrap(); let doc = &s.doc().unwrap().doc; let node = doc.node(owner).unwrap(); assert!(node.clips(), "INPUT: the source is a clipping Group"); assert_eq!(node.children().unwrap()[0].id, text); let t = doc.node(text).unwrap(); let NodeKind::Text(type_) = &t.kind else { panic!("INPUT: the clipping object is type") }; assert_eq!(type_.plain_text(), "Clip"); assert_eq!(t.clip_paint().stroke.is_some(), stroked, "INPUT: only the character-stroke paint distinguishes the control"); let bounds = t.geometric_bounds().unwrap(); assert!(bounds.width() > 0.0 && bounds.height() > 0.0, "INPUT: actual font setup supplies nonempty glyph geometry"); let effects = &node.appearance.effects; assert_eq!(effects.len(), 1); assert_eq!(effects[0].id, "distort.transform"); assert!(effects[0].visible); for (key, expected) in [("scaleH", 100.0), ("scaleV", 150.0), ("reference", 8.0), ("copies", 0.0)] { assert_eq!(effects[0].params[key].as_f64(), Some(expected), "INPUT: accepted Transform {key}"); } let before = eraser_gradient_image(&s); let background = before.pixel(299, 299); assert_eq!(background[3], 0, "INPUT: the retained background sample is clear"); if let Some(control) = no_stroke { assert_eq!(control.pixel(299, 299), background, "INPUT: both unchanged renders use the same background"); } let mut ramp = std::collections::BTreeSet::new(); let mut green = 0; let mut outside_green = 0; for y in 0..300 { for x in 0..300 { let p = before.pixel(x, y); if p[3] == 255 && p[0] > 0 && p[2] > 0 && p[1] == 0 { ramp.insert(p); } let painted_stroke = p[3] > 0 && p[1] > 200 && p[0] < 60 && p[2] < 60; green += usize::from(painted_stroke); outside_green += usize::from(painted_stroke && no_stroke.is_some_and(|control| control.pixel(x, y) == background)); } } assert!(ramp.len() > 1, "INPUT: the fitted container gradient paints actual nonconstant glyph pixels"); assert_eq!(green > 0, stroked, "INPUT: the painted-character stroke is actually visible only in the subject"); if stroked { assert!(outside_green > 0, "INPUT: the actual character stroke paints where the no-stroke control has only clear background"); } let label = if stroked { "PINNING_ONLY: painted clipping text under nonuniform scale" } else { "CONTROL: same glyph/scale without painted-clip wrapper" }; eraser_pinning_only_store(doc, owner, &before, !stroked, label); before } #[test] fn eraser_pinning_only_painted_text_clip_matches_unchanged_render() { let control = eraser_pinning_only_text_clip_case(false, None); eraser_pinning_only_text_clip_case(true, Some(&control)); } #[test] fn eraser_pinning_only_keeps_hidden_geometry_and_raster_ancestors_supported() { for raster in [false, true] { let (mut s, owner) = eraser_pinning_only_nested_scene(false, !raster); let outer = s.doc().unwrap().doc.parent_of(owner).unwrap(); if raster { s.execute( "effect.apply", &json!({"ids": [outer.0], "target": "object", "item": null, "effect": "blur.gaussian", "params": {"radius": 3}}), ) .unwrap(); } let mut doc = (*s.doc().unwrap().doc).clone(); if !raster { let ancestor = doc.node_mut(outer).unwrap(); ancestor.appearance.effects[0].visible = false; } let effect = &doc.node(outer).unwrap().appearance.effects[0]; assert_eq!(doc.node(outer).unwrap().appearance.effects.len(), 1); assert_eq!(effect.visible, raster); if raster { assert_eq!(effect.id, "blur.gaussian"); assert_eq!(effect.params["radius"].as_f64(), Some(3.0)); } else { assert_eq!(effect.id, "path.offsetPath"); assert_eq!(effect.params["offset"].as_f64(), Some(10.0)); } let before = vectorcraft_render::Renderer::new().render(&doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); assert_eq!(before.pixel(190, 175)[3], 255, "INPUT: ordinary gradient art remains visible"); assert_ne!(before.pixel(190, 175), before.pixel(190, 185), "INPUT: the paint is nonconstant"); let label = if raster { "CONTROL: visible Gaussian ancestor" } else { "CONTROL: hidden Offset Path ancestor" }; eraser_pinning_only_store(&doc, owner, &before, true, label); } }