2bc41aeb8602
pathfinder_clip.rs
//! Pathfinder on clip groups (#8093): a clip group's members take part only where its clipping
//! path shows them, so Divide and the other operations leave out the hidden art.
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::NodeKind;
use vectorcraft_geom::{FillRule, PathData, Rect};
use crate::*;
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
s
}
fn id(v: &Value) -> NodeId {
NodeId(v["id"].as_u64().unwrap_or_else(|| panic!("no id in {v}")))
}
fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64, fill: Color) -> NodeId {
let r = id(&s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap());
s.edit("fill", |d, _| {
d.node_mut(r).unwrap().appearance.set_fill(Paint::solid(fill));
Ok(())
})
.unwrap();
r
}
fn clip(s: &mut Session, ids: &[NodeId]) -> NodeId {
id(&s.execute("object.clippingMask.make", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap())
}
fn red() -> Color {
Color::rgb(1.0, 0.0, 0.0)
}
fn blue() -> Color {
Color::rgb(0.0, 0.0, 1.0)
}
fn green() -> Color {
Color::rgb(0.0, 1.0, 0.0)
}
/// A red square at (0, 0) and a blue one at (50, 50), both 100 pt, clipped by a 100 pt square
/// mask at (25, 25): the clip group. The mask shows 8750 pt² of them.
fn clipped_pair(s: &mut Session) -> NodeId {
let a = rect(s, 0.0, 0.0, 100.0, 100.0, red());
let b = rect(s, 50.0, 50.0, 100.0, 100.0, blue());
let mask = rect(s, 25.0, 25.0, 100.0, 100.0, green());
clip(s, &[a, b, mask])
}
/// The shapes `op` makes of the selection, the members of the group it makes or the one shape:
/// (fill, path, rule) each.
fn pieces(s: &mut Session, op: &str) -> Vec<(Paint, PathData, FillRule)> {
let r = s.execute(op, &json!({})).unwrap();
let g = s.doc().unwrap().doc.node(NodeId(r["ids"][0].as_u64().unwrap())).cloned().unwrap();
let shape = |n: &vectorcraft_doc::Node| match &n.kind {
NodeKind::Path { path, rule, .. } => (n.appearance.fill_paint(), path.clone(), *rule),
NodeKind::Compound { children, rule } => {
let subs = children.iter().flat_map(|c| c.path_data().unwrap().subpaths.clone()).collect();
(n.appearance.fill_paint(), PathData::new(subs), *rule)
}
k => panic!("not a path: {k:?}"),
};
match &g.kind {
NodeKind::Group { children, .. } => children.iter().map(|c| shape(c)).collect(),
_ => vec![shape(&g)],
}
}
fn area(p: &(Paint, PathData, FillRule)) -> f64 {
vectorcraft_pathops::area(&p.1, p.2)
}
fn bounds(ps: &[(Paint, PathData, FillRule)]) -> Rect {
ps.iter().filter_map(|p| p.1.bounds()).reduce(|a, b| a.union(b)).unwrap()
}
fn select(s: &mut Session, ids: &[NodeId]) {
s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap();
}
fn assert_inside(r: Rect, within: Rect) {
assert!(within.inflate(1e-6, 1e-6).contains_rect(r), "{r:?} reaches out of {within:?}");
}
/// The issue's case: Divide on a clip group gives the pieces the mask shows, cut along it, and the
/// hidden art goes.
#[test]
fn divide_on_a_clip_group_keeps_only_what_the_mask_shows() {
let mut s = session();
let g = clipped_pair(&mut s);
select(&mut s, &[g]);
let ps = pieces(&mut s, "object.pathfinder.divide");
assert_eq!(ps.len(), 3, "red alone, the overlap and blue alone: {ps:?}");
let total: f64 = ps.iter().map(area).sum();
assert!((total - 8750.0).abs() < 1.0, "the visible area, not the whole art: {total}");
assert_inside(bounds(&ps), Rect::new(25.0, 25.0, 125.0, 125.0));
let blue: f64 = ps.iter().filter(|p| p.0 == Paint::solid(blue())).map(area).sum();
assert!((blue - 5625.0).abs() < 1.0, "the overlap takes the front (blue) fill: {blue}");
assert!(ps.iter().all(|p| p.0 != Paint::solid(green())), "the clipping path adds no piece: {ps:?}");
}
/// An irregular mask: a square clipped by a circle divides into a disc.
#[test]
fn divide_cuts_along_a_curved_clipping_path() {
let mut s = session();
let square = rect(&mut s, 100.0, 100.0, 300.0, 300.0, red());
let circle = id(&s.execute("shape.ellipse", &json!({"x": 150, "y": 150, "width": 200, "height": 200})).unwrap());
let g = clip(&mut s, &[square, circle]);
select(&mut s, &[g]);
let ps = pieces(&mut s, "object.pathfinder.divide");
assert_eq!(ps.len(), 1, "{ps:?}");
let disc = std::f64::consts::PI * 100.0 * 100.0;
assert!((area(&ps[0]) - disc).abs() < disc * 1e-3, "{} vs {disc}", area(&ps[0]));
assert_inside(bounds(&ps), Rect::new(150.0, 150.0, 350.0, 350.0));
}
/// A clip group inside a clip group: its members show only where both masks do.
#[test]
fn nested_clip_groups_cut_by_both_masks() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 200.0, 200.0, red());
let inner_mask = rect(&mut s, 0.0, 0.0, 100.0, 200.0, green());
let inner = clip(&mut s, &[a, inner_mask]);
let outer_mask = rect(&mut s, 0.0, 50.0, 200.0, 100.0, green());
let outer = clip(&mut s, &[inner, outer_mask]);
select(&mut s, &[outer]);
let ps = pieces(&mut s, "object.pathfinder.divide");
assert_eq!(ps.len(), 1, "{ps:?}");
assert!((area(&ps[0]) - 10000.0).abs() < 1.0, "100 × 100 shows: {}", area(&ps[0]));
assert_inside(bounds(&ps), Rect::new(0.0, 50.0, 100.0, 150.0));
}
/// A member the mask hides altogether gives no piece.
#[test]
fn a_member_the_mask_hides_gives_no_piece() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0, red());
let b = rect(&mut s, 300.0, 300.0, 100.0, 100.0, blue());
let mask = rect(&mut s, 0.0, 0.0, 150.0, 150.0, green());
let g = clip(&mut s, &[a, b, mask]);
select(&mut s, &[g]);
let ps = pieces(&mut s, "object.pathfinder.divide");
assert_eq!(ps.len(), 1, "only the red square shows: {ps:?}");
assert_eq!(ps[0].0, Paint::solid(red()));
}
/// A cutting line in a clip group cuts only where the mask shows it: its hidden part leaves the
/// other selected art alone.
#[test]
fn a_clipped_cutting_line_cuts_only_where_it_shows() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0, red());
let line = id(&s.execute("shape.line", &json!({"x1": 50, "y1": -50, "x2": 50, "y2": 400})).unwrap());
let mask = rect(&mut s, 0.0, 0.0, 100.0, 100.0, green());
let g = clip(&mut s, &[a, line, mask]);
let other = rect(&mut s, 0.0, 200.0, 100.0, 100.0, blue());
select(&mut s, &[g, other]);
let ps = pieces(&mut s, "object.pathfinder.divide");
let red = ps.iter().filter(|p| p.0 == Paint::solid(red())).count();
let blue = ps.iter().filter(|p| p.0 == Paint::solid(blue())).count();
assert_eq!((red, blue), (2, 1), "the line halves the red square, not the blue one: {ps:?}");
}
/// Every Shape Mode and Pathfinder button takes the members as the mask shows them (#3367 asks
/// this of Merge). The mask, 100 × 60 pt at (25, 25), cuts through the squares' overlap: it shows
/// 4500 pt² of red, 2625 pt² of blue and 1750 pt² of their overlap.
#[test]
fn every_operation_takes_only_what_the_mask_shows() {
for (op, want) in [
("unite", Some(5375.0)),
("minusFront", Some(2750.0)),
("minusBack", Some(875.0)),
("intersect", Some(1750.0)),
("exclude", Some(3625.0)),
("trim", Some(5375.0)),
("merge", Some(5375.0)),
("crop", Some(1750.0)),
("outline", None),
] {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0, red());
let b = rect(&mut s, 50.0, 50.0, 100.0, 100.0, blue());
let mask = rect(&mut s, 25.0, 25.0, 100.0, 60.0, green());
let g = clip(&mut s, &[a, b, mask]);
select(&mut s, &[g]);
let ps = pieces(&mut s, &format!("object.pathfinder.{op}"));
assert_inside(bounds(&ps), Rect::new(25.0, 25.0, 125.0, 85.0));
if let Some(want) = want {
let total: f64 = ps.iter().map(area).sum();
assert!((total - want).abs() < 1.0, "{op}: {total}, want {want}");
}
}
}
/// Among other objects a clip group acts as one shape: the union of what its mask shows.
#[test]
fn a_clip_group_among_other_objects_is_the_area_its_mask_shows() {
let mut s = session();
let g = clipped_pair(&mut s);
let other = rect(&mut s, 300.0, 0.0, 50.0, 50.0, blue());
select(&mut s, &[g, other]);
let ps = pieces(&mut s, "object.pathfinder.unite");
let total: f64 = ps.iter().map(area).sum();
assert!((total - (8750.0 + 2500.0)).abs() < 1.0, "{total}");
}
/// Among other objects a clip group takes the style of its top member that shows: a member the
/// mask hides paints nothing.
#[test]
fn a_hidden_top_member_gives_no_style() {
let mut s = session();
// Below the clip group, so the result takes the group's style.
let other = rect(&mut s, 50.0, 50.0, 100.0, 100.0, green());
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0, red());
let b = rect(&mut s, 300.0, 300.0, 100.0, 100.0, blue());
let mask = rect(&mut s, 0.0, 0.0, 150.0, 150.0, green());
let g = clip(&mut s, &[a, b, mask]);
select(&mut s, &[other, g]);
let ps = pieces(&mut s, "object.pathfinder.unite");
assert_eq!(ps.len(), 1, "{ps:?}");
assert_eq!(ps[0].0, Paint::solid(red()), "not the hidden blue member's fill");
assert!((area(&ps[0]) - 17500.0).abs() < 1.0, "{}", area(&ps[0]));
}
/// A selection the masks hide altogether says so.
#[test]
fn art_the_masks_hide_altogether_is_refused_with_a_reason() {
let mut s = session();
let a = rect(&mut s, 300.0, 300.0, 100.0, 100.0, red());
let mask = rect(&mut s, 0.0, 0.0, 100.0, 100.0, green());
let g = clip(&mut s, &[a, mask]);
select(&mut s, &[g]);
let undo = s.doc().unwrap().history.undo.len();
let e = s.execute("object.pathfinder.divide", &json!({})).unwrap_err().to_string();
assert!(e.contains("clipping masks hide"), "{e}");
assert_eq!(s.doc().unwrap().history.undo.len(), undo, "nothing changes");
}
/// A clip group its mask hides altogether, selected with a red square at (0, 0) and a blue one at
/// (50, 50), each 100 pt, at `position` in the stacking order (0: at the back).
fn with_a_hidden_clip_group(s: &mut Session, position: usize) {
let mut ids = vec![];
for i in 0..3 {
if i == position {
// Two members, so among other objects the group is one shape: their union.
let a = rect(s, 300.0, 300.0, 100.0, 100.0, green());
let b = rect(s, 450.0, 300.0, 100.0, 100.0, green());
let mask = rect(s, 0.0, 0.0, 100.0, 100.0, green());
ids.push(clip(s, &[a, b, mask]));
} else {
let at = if ids.len() == usize::from(position == 0) { 0.0 } else { 50.0 };
ids.push(rect(s, at, at, 100.0, 100.0, if at == 0.0 { red() } else { blue() }));
}
}
select(s, &ids);
}
/// A selected object its masks hide altogether is an empty operand: Intersect, Minus Front with
/// it at the back, Minus Back with it in front and Crop with it on top give nothing, and the other
/// operations make what they make without it.
#[test]
fn a_hidden_operand_is_an_empty_shape_where_it_changes_the_result() {
for (op, position) in [("intersect", 1), ("minusFront", 0), ("minusBack", 2), ("crop", 2)] {
let mut s = session();
with_a_hidden_clip_group(&mut s, position);
let undo = s.doc().unwrap().history.undo.len();
let e = s.execute(&format!("object.pathfinder.{op}"), &json!({})).unwrap_err().to_string();
assert!(e.contains("empty result"), "{op}: {e}");
assert_eq!(s.doc().unwrap().history.undo.len(), undo, "{op}: nothing changes");
}
for (op, position, want) in [("unite", 2, 17500.0), ("exclude", 2, 15000.0), ("minusFront", 2, 7500.0), ("minusBack", 0, 7500.0)] {
let mut s = session();
with_a_hidden_clip_group(&mut s, position);
let ps = pieces(&mut s, &format!("object.pathfinder.{op}"));
let total: f64 = ps.iter().map(area).sum();
assert!((total - want).abs() < 1.0, "{op}: {total}, want {want}");
assert!(ps.iter().all(|p| p.0 != Paint::solid(green())), "{op}: the hidden group's style: {ps:?}");
}
}
/// A clip group whose clipping path clips by nothing (here an empty group) hides its members, as on
/// the canvas: they are a hidden operand too, not left out of the selection.
#[test]
fn a_clipping_path_that_clips_by_nothing_hides_the_members() {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0, red());
let b = rect(&mut s, 50.0, 50.0, 100.0, 100.0, blue());
let m1 = rect(&mut s, 300.0, 300.0, 100.0, 100.0, green());
let m2 = rect(&mut s, 450.0, 300.0, 100.0, 100.0, green());
let mask = rect(&mut s, 300.0, 300.0, 300.0, 100.0, green());
let g = clip(&mut s, &[m1, m2, mask]);
s.edit("empty clipping path", |d, _| {
let empty = vectorcraft_doc::Node::group(d.alloc_id(), vec![]);
let NodeKind::Group { children, .. } = &mut d.node_mut(g).unwrap().kind else { panic!("not a group") };
children[0] = std::sync::Arc::new(empty);
Ok(())
})
.unwrap();
select(&mut s, &[a, b, g]);
let e = s.execute("object.pathfinder.intersect", &json!({})).unwrap_err().to_string();
assert!(e.contains("empty result"), "not the squares' overlap: {e}");
select(&mut s, &[g]);
let e = s.execute("object.pathfinder.divide", &json!({})).unwrap_err().to_string();
assert!(e.contains("clipping masks hide"), "{e}");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.