Mirror and pattern: a pattern or mirror feature as the source (#395) (#3998)

* claim: #395

* Mirror and pattern: a pattern or mirror feature as the source (#395)

A pattern or mirror of features refused another pattern or mirror as a
source ("Pat cannot be patterned or mirrored yet"). Such a source now
stands for what it copied: its own sources are replayed at each of its
transforms moved by each of ours, to any depth up to eight. Copies of
a feature picked directly keep the instance numbers they had, so
existing designs keep their face names; copies made through a nested
pattern or mirror are numbered after them, so one feature reached two
ways never names two copies alike. A pattern or mirror of bodies as
the source is still refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Martin Pålsson
2026-10-24 07:55:14 +00:00
committed by GitHub
parent e67ae66f3e
commit 4dc30c092d
2 changed files with 211 additions and 11 deletions
+115 -11
View File
@@ -1975,6 +1975,13 @@ impl Model {
}
_ => Vec::new(),
};
// Copies made through a pattern or mirror among the sources come after (#395).
let mats = match &f.kind {
FeatureKind::Pattern { features, bodies, .. } | FeatureKind::Mirror { features, bodies, .. } if bodies.is_empty() => {
copy_instances(doc, &vals, &state, &crate::plain(features), &mats).unwrap_or(mats)
}
_ => mats,
};
next.stamp(&state, f, key, mats);
for b in &mut next.bodies {
if !b.transferred {
@@ -5513,6 +5520,108 @@ fn copy_misses(st: &ModelState, f: &Feature, targets: &[String], tools: &[Traced
})
}
/// The deepest a pattern or mirror reaches through patterns and mirrors of features (#395).
const MAX_NESTING: usize = 8;
/// The feature a pattern or mirror names as a source. A sketch and its extrude often share a
/// name; the feature that makes geometry wins.
fn source_feature<'a>(doc: &'a Document, name: &str) -> Result<&'a Feature> {
doc.features
.iter()
.find(|x| x.name == name && !matches!(x.kind, FeatureKind::Sketch { .. } | FeatureKind::ConstructionPlane { .. }))
.or_else(|| doc.find_feature(name))
.ok_or_else(|| DocError::Unknown(format!("feature `{name}`")))
}
/// What a pattern or mirror of features copies, when it is the source of another one (#395): its
/// own sources, and the transforms of its copies. `None` for any other feature, and for a pattern
/// or mirror of bodies (its copies are bodies, which a pattern or mirror of features can't take).
fn copied_features(doc: &Document, vals: &BTreeMap<String, Value>, st: &ModelState, src: &Feature) -> Result<Option<(Vec<String>, Vec<Mat>)>> {
match &src.kind {
FeatureKind::Pattern { features, pattern, bodies } if bodies.is_empty() => {
Ok(Some((crate::plain(features), pattern_transforms(doc, vals, st, src.component, pattern)?)))
}
FeatureKind::Mirror { features, plane, bodies, .. } if bodies.is_empty() => {
let pl = doc.resolve_plane_in(vals, plane, 0, Some(st))?;
Ok(Some((crate::plain(features), vec![mirror_matrix(&pl)])))
}
_ => Ok(None),
}
}
/// The copies a pattern or mirror of `features` at `mats` makes, source by source: the source
/// feature, the transforms of its copies, and the instance number of its first copy less one.
/// A source that is itself a pattern or mirror of features (#395) stands for what it copied: its
/// own sources, at each of its transforms moved by each of ours. Those copies are numbered after
/// `mats`' own (which keep the numbers they always had), each nested source in a block of its
/// own, so no two copies of one feature share an instance. Suppressed sources copy nothing.
fn copy_plan<'a>(
doc: &'a Document,
vals: &BTreeMap<String, Value>,
st: &ModelState,
features: &[String],
mats: &[Mat],
) -> Result<Vec<(&'a Feature, Vec<Mat>, usize)>> {
#[allow(clippy::too_many_arguments)]
fn walk<'a>(
doc: &'a Document,
vals: &BTreeMap<String, Value>,
st: &ModelState,
features: &[String],
mats: &[Mat],
first: usize,
next: &mut usize,
depth: usize,
out: &mut Vec<(&'a Feature, Vec<Mat>, usize)>,
) -> Result<()> {
for name in features {
if doc.find_feature(name).is_some_and(|x| x.suppressed) {
continue;
}
let src = source_feature(doc, name)?;
let Some((inner, inner_mats)) = copied_features(doc, vals, st, src)? else {
out.push((src, mats.to_vec(), first));
continue;
};
if depth >= MAX_NESTING {
return Err(DocError::Invalid(format!("patterns and mirrors of patterns and mirrors nest at most {MAX_NESTING} deep")));
}
let moved: Vec<Mat> = mats.iter().flat_map(|m| inner_mats.iter().map(move |mi| crate::mat_mul(m, mi))).collect();
if moved.len() > MAX_INSTANCES || next.saturating_add(moved.len()) > MAX_INSTANCES * MAX_NESTING {
return Err(DocError::Invalid("too many pattern instances".into()));
}
let block = *next;
*next += moved.len();
walk(doc, vals, st, &inner, &moved, block, next, depth + 1, out)?;
}
Ok(())
}
let mut next = mats.len();
let mut out = Vec::new();
walk(doc, vals, st, features, mats, 0, &mut next, 0, &mut out)?;
Ok(out)
}
/// The transforms of a pattern's or mirror's copies in their instance order (instance `k + 1`
/// is the `k`-th): `mats`, then those of the copies made through patterns and mirrors among
/// `features` ([`copy_plan`]). Naming finds a copy's faces through them.
fn copy_instances(doc: &Document, vals: &BTreeMap<String, Value>, st: &ModelState, features: &[String], mats: &[Mat]) -> Result<Vec<Mat>> {
let plan = copy_plan(doc, vals, st, features, mats)?;
let len = plan.iter().map(|(_, ms, first)| first + ms.len()).max().unwrap_or(0).max(mats.len());
let mut all = vec![crate::IDENTITY; len];
for (slot, m) in all.iter_mut().zip(mats) {
*slot = *m;
}
for (_, ms, first) in &plan {
for (k, m) in ms.iter().enumerate() {
if let Some(slot) = all.get_mut(first + k) {
*slot = *m;
}
}
}
Ok(all)
}
/// Apply transformed copies of the tools of `features` (patterns, mirrors).
fn replay(
doc: &Document,
@@ -5537,14 +5646,9 @@ fn replay(
});
}
let (mut missed, mut total) = (0usize, 0usize);
for name in features.iter().filter(|n| !suppressed.contains(n)) {
// A sketch and its extrude often share a name; the feature that makes geometry wins.
let src = doc
.features
.iter()
.find(|x| &x.name == name && !matches!(x.kind, FeatureKind::Sketch { .. } | FeatureKind::ConstructionPlane { .. }))
.or_else(|| doc.find_feature(name))
.ok_or_else(|| DocError::Unknown(format!("feature `{name}`")))?;
let kept: Vec<String> = features.iter().filter(|n| !suppressed.contains(n)).cloned().collect();
let plan = copy_plan(doc, vals, st, &kept, mats)?;
for (src, mats, first) in &plan {
// A fillet or chamfer repeats at the copied edges.
if let FeatureKind::Fillet { edges, radius, .. } | FeatureKind::Chamfer { edges, distance: radius, .. } = &src.kind {
let r = val(vals, radius, Kind::Length)?;
@@ -5601,7 +5705,7 @@ fn replay(
copies.extend(
hole_tools(vals, st, &at, d, diameter, &depth, hole)?
.into_iter()
.map(|t| Traced { lineage: t.lineage.map(|l| l.copied(src.id, k + 1)), body: t.body }),
.map(|t| Traced { lineage: t.lineage.map(|l| l.copied(src.id, first + k + 1)), body: t.body }),
);
}
instances.push(start..copies.len());
@@ -5613,7 +5717,7 @@ fn replay(
for body in more::rib_tools(vals, st, src, Some(m))? {
// Each copy's faces are named as the rib's, with the instance.
let t = Traced::unnamed(body);
copies.push(Traced { lineage: t.lineage.map(|l| l.copied(src.id, k + 1)), body: t.body });
copies.push(Traced { lineage: t.lineage.map(|l| l.copied(src.id, first + k + 1)), body: t.body });
}
}
} else {
@@ -5622,7 +5726,7 @@ fn replay(
for (k, m) in mats.iter().enumerate() {
let start = copies.len();
for t in &tools {
copies.push(t.copied(kernel::transform_matrix(&t.body, *m)?, src.id, k + 1));
copies.push(t.copied(kernel::transform_matrix(&t.body, *m)?, src.id, first + k + 1));
}
instances.push(start..copies.len());
}
+96
View File
@@ -707,3 +707,99 @@ fn patterns_and_mirrors_of_a_rib() {
check(&s, &[ribs[0], ribs[2]]);
assert!(rel(volume(&mut s), before + 2.0 * rib) < 1e-6, "two ribs: {} vs {}", volume(&mut s), before + 2.0 * rib);
}
/// #395: a pattern or mirror of features takes a pattern or mirror of features as a source: it
/// copies what that one made (its copies, not its source). The issue's design: a 40 × 30 × 20
/// box with a hole `H` at (−15, −10) and `Pat`, two more holes along x at 10 mm steps.
#[test]
fn patterns_and_mirrors_of_patterns_and_mirrors() {
use solidcraft_geom::Vec3;
let hole = PI * 1.5 * 1.5 * 20.0;
let design = || {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "corner": [-20, -15, 0], "name": "Box"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Spot"}));
run(&mut s, "sketch.circle.center", json!({"center": [-15, -10], "radius": 1.5}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"sketch": "Spot", "through_all": true, "operation": "cut", "name": "H"}));
run(&mut s, "solid.pattern.rectangular", json!({"features": ["H"], "dir1": [1, 0, 0], "count1": 3, "spacing1": 10, "name": "Pat"}));
s
};
let across_xz = json!({"origin": [0, 0, 0], "normal": [0, 1, 0]});
let across_yz = json!({"origin": [0, 0, 0], "normal": [1, 0, 0]});
// Each case: the steps after `design`, the holes there must be, and the spots that must
// stay material.
type Case = (Vec<(&'static str, Value)>, Vec<[f64; 2]>, Vec<[f64; 2]>);
let cases: Vec<(&str, Case)> = vec![
// The issue's step: the mirror of `Pat` is its two copies mirrored.
(
"mirror of a pattern",
(vec![("solid.mirror", json!({"features": ["Pat"], "plane": across_xz}))], vec![[-5.0, 10.0], [5.0, 10.0]], vec![[-15.0, 10.0]]),
),
// With its source too: the six holes the issue expects.
(
"mirror of a hole and its pattern",
(
vec![("solid.mirror", json!({"features": ["H", "Pat"], "plane": across_xz}))],
vec![[-15.0, 10.0], [-5.0, 10.0], [5.0, 10.0]],
vec![[15.0, 10.0]],
),
),
(
"pattern of a pattern",
(
vec![("solid.pattern.rectangular", json!({"features": ["Pat"], "dir1": [0, 1, 0], "count1": 2, "spacing1": 20}))],
vec![[-5.0, 10.0], [5.0, 10.0]],
vec![[-15.0, 10.0]],
),
),
(
"mirror of a mirror",
(
vec![
("solid.mirror", json!({"features": ["H"], "plane": across_yz, "name": "Mir"})),
("solid.mirror", json!({"features": ["Mir"], "plane": across_xz})),
],
vec![[15.0, -10.0], [15.0, 10.0]],
vec![[-15.0, 10.0]],
),
),
(
"pattern of a mirror",
(
vec![
("solid.mirror", json!({"features": ["H"], "plane": across_yz, "name": "Mir"})),
("solid.pattern.rectangular", json!({"features": ["Mir"], "dir1": [0, 1, 0], "count1": 2, "spacing1": 20})),
],
vec![[15.0, -10.0], [15.0, 10.0]],
vec![[-15.0, 10.0]],
),
),
];
for (what, (steps, holes, material)) in cases {
let mut s = design();
let before = volume(&mut s);
for (id, p) in steps {
run(&mut s, id, p);
}
for r in &s.model.results {
assert!(r.error.is_none(), "{what}: {}: {:?}", r.name, r.error);
}
let st = s.world_state();
assert_eq!(st.bodies.len(), 1, "{what}");
let body = &st.bodies[0].body;
for [x, y] in &holes {
assert!(!body.contains(Vec3::new(*x, *y, 10.0)), "{what}: a hole at ({x}, {y})");
assert!(body.contains(Vec3::new(*x, *y + 2.5, 10.0)), "{what}: material beside ({x}, {y})");
}
for [x, y] in &material {
assert!(body.contains(Vec3::new(*x, *y, 10.0)), "{what}: no hole at ({x}, {y})");
}
// The listed holes the steps added (in the last two cases `Mir` made the first of them).
let added = holes.len();
// Measured on the body's mesh, like the other tests here: to 1e-5 of the whole body.
let after = volume(&mut s);
let want = before - added as f64 * hole;
assert!(rel(after, want) < 1e-5, "{what}: {after} mm³, {added} more holes than {before} = {want}");
}
}