diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index dd6aef2d2..b8c7c2478 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -3434,30 +3434,60 @@ fn edge_dir(e: &kernel::EdgeInfo) -> Vec3 { if straight && a.dist(*b) > 1e-9 { (*b - *a).normalized().unwrap_or(Vec3::ZERO) } else { Vec3::ZERO } } -/// References for edges picked at `pts` on the body a blend would go on (the state before it). -pub fn edge_refs(st: &ModelState, body: &Option, pts: &[Vec3]) -> Vec { - let Ok(ti) = blend_target(st, body, pts) else { return Vec::new() }; - let Some(mb) = st.bodies.get(ti) else { return Vec::new() }; - let size = mb.body.size(); - let Ok(edges) = mb.body.edges((size * 1e-3).max(1e-3)) else { return Vec::new() }; - let bb = mb.mesh().bounds(); - pts.iter() - .map(|p| { - let e = edges.iter().min_by(|x, y| { - let d = |e: &kernel::EdgeInfo| e.points.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min); - d(x).total_cmp(&d(y)) - }); - EdgeRef { dir: e.map(edge_dir).unwrap_or(Vec3::ZERO), min: bb.min, max: bb.max } - }) - .collect() +/// The body each edge picked at `pts` lies on (the state before a blend): the named body, else, +/// for each point on its own, the body with an edge nearest it. A blend over the edges of +/// several bodies remembers every edge on the body it was picked on, never on the first edge's. +fn picked_bodies(st: &ModelState, body: &Option, pts: &[Vec3]) -> Option> { + if body.is_some() || st.bodies.iter().filter(|b| !b.body.is_mesh()).count() < 2 { + blend_target(st, body, pts).ok().map(|ti| vec![ti; pts.len()]) + } else { + pts.iter().map(|p| blend_target(st, &None, std::slice::from_ref(p)).ok()).collect() + } } -/// Persistent names of the edges picked at `pts` on the body a blend would go on. -pub fn edge_names_for(st: &ModelState, body: &Option, pts: &[Vec3]) -> Vec { - match blend_target(st, body, pts).ok().and_then(|i| st.bodies.get(i)) { - Some(b) => crate::naming::edge_names_at(b, pts), - None => Vec::new(), +/// References for edges picked at `pts` on the bodies a blend would go on (the state before it). +pub fn edge_refs(st: &ModelState, body: &Option, pts: &[Vec3]) -> Vec { + let Some(on) = picked_bodies(st, body, pts) else { return Vec::new() }; + let mut seen: BTreeMap, solidcraft_geom::Aabb3)>> = BTreeMap::new(); + let mut out = Vec::with_capacity(pts.len()); + for (p, ti) in pts.iter().zip(on) { + let found = seen.entry(ti).or_insert_with(|| { + let mb = st.bodies.get(ti)?; + let size = mb.body.size(); + Some((mb.body.edges((size * 1e-3).max(1e-3)).ok()?, mb.mesh().bounds())) + }); + let Some((edges, bb)) = found else { return Vec::new() }; + let e = edges.iter().min_by(|x, y| { + let d = |e: &kernel::EdgeInfo| e.points.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min); + d(x).total_cmp(&d(y)) + }); + out.push(EdgeRef { dir: e.map(edge_dir).unwrap_or(Vec3::ZERO), min: bb.min, max: bb.max }); } + out +} + +/// Persistent names of the edges picked at `pts`, each on the body it lies on (see +/// [`picked_bodies`]). +pub fn edge_names_for(st: &ModelState, body: &Option, pts: &[Vec3]) -> Vec { + let Some(on) = picked_bodies(st, body, pts) else { return Vec::new() }; + let mut out = vec![String::new(); pts.len()]; + let mut done: Vec = Vec::new(); + for &ti in &on { + if done.contains(&ti) { + continue; + } + done.push(ti); + let Some(b) = st.bodies.get(ti) else { continue }; + // The body's names are worked out once for all its picks. + let idx: Vec = on.iter().enumerate().filter(|(_, t)| **t == ti).map(|(i, _)| i).collect(); + let at: Vec = idx.iter().filter_map(|i| pts.get(*i).copied()).collect(); + for (i, n) in idx.into_iter().zip(crate::naming::edge_names_at(b, &at)) { + if let Some(slot) = out.get_mut(i) { + *slot = n; + } + } + } + out } /// The stored pick sits on the axis of a round, not on an edge. The nearest edge within a @@ -3563,6 +3593,263 @@ fn blend_target(state: &ModelState, body: &Option, edges: &[Vec }) } +/// Whether `p` lies in the bounding box a reference recorded (with a little slack): an edge +/// picked on a body lies in that body's box. +fn in_ref_box(r: &EdgeRef, p: Vec3) -> bool { + let slack = ((r.max - r.min).len() * 1e-2).max(1e-3); + (r.min.x - slack..=r.max.x + slack).contains(&p.x) + && (r.min.y - slack..=r.max.y + slack).contains(&p.y) + && (r.min.z - slack..=r.max.z + slack).contains(&p.z) +} + +/// The stored name of a blend's edge `i` (picked at `p`), when it can be trusted. Builds before +/// blends over several bodies were split by body named every edge on the first edge's body: the +/// name of a pick on another body is that body's nearest edge, and the reference's box (that +/// body's) does not hold the pick. Such a name (and its reference) is not used. +fn trusted_edge_name(f: &Feature, i: usize, p: Vec3) -> Option<&str> { + let n = f.edge_names.get(i).filter(|n| !n.is_empty())?; + match f.edge_refs.get(i) { + Some(r) if !in_ref_box(r, p) => None, + _ => Some(n.as_str()), + } +} + +/// The body (index) an edge name finds an edge on, when one does: the one where the edge still +/// runs through the pick `p`, else where the name is one edge (not split), else the nearest. +fn named_body(st: &ModelState, name: &str, p: Vec3) -> Option { + // Names start with the feature that made the face: only bodies with such a face can hold it. + let bare = crate::naming::legacy_name(name).unwrap_or(name); + let token = bare.find(':').map(|k| &bare[..=k]); + let mut best: Option<(usize, (bool, bool, f64))> = None; + for (i, b) in st.bodies.iter().enumerate() { + if b.body.is_mesh() || token.is_some_and(|t| !crate::naming::face_names(b).iter().any(|n| n.contains(t))) { + continue; + } + let Ok(hit) = crate::naming::locate_edge(b, name, p) else { continue }; + let score = (hit.on_point, !hit.split, -hit.point.dist(p)); + if best.as_ref().is_none_or(|(_, s)| score.partial_cmp(s).is_some_and(|o| o.is_gt())) { + best = Some((i, score)); + } + } + best.map(|(i, _)| i) +} + +/// The body (index) an edge picked at `p` lies on: the body with an edge through it. +fn body_on_edge(st: &ModelState, p: Vec3) -> Option { + let mut best: Option<(usize, f64)> = None; + for (i, b) in st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh()) { + let size = b.body.size(); + let tight = (size * 2e-3).max(1e-3); + if let Ok(Some((_, d))) = b.body.nearest_edge(p, (size * 1e-3).max(1e-3)) + && d <= tight + && best.is_none_or(|(_, bd)| d < bd) + { + best = Some((i, d)); + } + } + best.map(|(i, _)| i) +} + +/// The body (index) each edge of a blend is on: the named body; else, for each edge, the body +/// its stored name finds it on. A named edge that is gone stays on the bodies the feature's other +/// edges were found on; an unnamed one goes to the body the pick lies on an edge of; failing +/// both, the body nearest the first pick (as before blends were split by body). A named edge is +/// never moved onto another body because that body's edge is nearer. +fn blend_bodies(st: &ModelState, f: &Feature, body: &Option, pts: &[Vec3]) -> Result> { + // Named, or only one body to blend: no lookup. + if body.is_some() || st.bodies.iter().filter(|b| !b.body.is_mesh()).count() < 2 { + let ti = blend_target(st, body, pts)?; + return Ok(vec![ti; pts.len()]); + } + let names: Vec> = pts.iter().enumerate().map(|(i, p)| trusted_edge_name(f, i, *p)).collect(); + let by_name: Vec> = names.iter().zip(pts).map(|(n, p)| n.and_then(|n| named_body(st, n, *p))).collect(); + let mut named: Vec = by_name.iter().flatten().copied().collect(); + named.sort_unstable(); + named.dedup(); + // Of the bodies the feature's other edges were found on, the one with an edge nearest `p`. + let nearest_named = |p: Vec3| { + named + .iter() + .filter_map(|i| { + let b = st.bodies.get(*i)?; + let tol = (b.body.size() * 2e-3).max(1e-3); + Some((*i, b.body.nearest_edge(p, tol).ok()??.1)) + }) + .min_by(|a, b| a.1.total_cmp(&b.1)) + .map(|(i, _)| i) + }; + let mut fallback = None; + let mut out = Vec::with_capacity(pts.len()); + for ((b, n), p) in by_name.into_iter().zip(&names).zip(pts) { + let found = match (b, n) { + (Some(ti), _) => Some(ti), + // A named edge that is gone stays with the feature's other bodies: another body's + // edge where it was picked is not it. + (None, Some(_)) => nearest_named(*p).or_else(|| body_on_edge(st, *p)), + (None, None) => body_on_edge(st, *p).or_else(|| nearest_named(*p)), + }; + let ti = match (found, fallback) { + (Some(ti), _) => ti, + (None, Some(ti)) => ti, + (None, None) => *fallback.insert(blend_target(st, &None, pts)?), + }; + out.push(ti); + } + Ok(out) +} + +/// The edges `idx` of blend `f` found on body `mb`: by name first; a name that is gone falls back +/// to the point, with a warning. +fn blend_edges_on(mb: &ModelBody, f: &Feature, edges: &[crate::Position], idx: &[usize], warning: &mut Option) -> Result> { + let pick = |i: usize| edges.get(i).map(|p| p.0).unwrap_or(Vec3::ZERO); + if !f.edge_names.iter().any(|n| !n.is_empty()) { + let pts: Vec = idx.iter().map(|i| pick(*i)).collect(); + let refs: Vec = idx.iter().map_while(|i| f.edge_refs.get(*i).cloned()).collect(); + return resolve_edges(&mb.body, &pts, &refs, warning); + } + let (mut out, mut notes) = (Vec::new(), Vec::new()); + for &i in idx { + let p = pick(i); + let stored = f.edge_names.get(i).filter(|n| !n.is_empty()); + let trusted = trusted_edge_name(f, i, p); + // A name recorded on another body (see `trusted_edge_name`): the pick alone. + if stored.is_some() && trusted.is_none() { + let mut w = None; + match resolve_edges(&mb.body, &[p], &[], &mut w) { + Ok(q) => out.extend(q), + Err(_) => notes.push("an edge reference was not found at its point and was skipped".to_string()), + } + notes.extend(w); + continue; + } + match trusted.map(|n| (n, crate::naming::locate_edge(mb, n, p))) { + Some((n, Ok(hit))) => { + if let Some(note) = hit.note(n) { + notes.push(note); + } + // The body changed since the pick: the pick may now sit at an end of the edge. + let moved = f.edge_refs.get(i).is_some_and(|r| { + let now = mb.mesh().bounds(); + let tight = (mb.body.size() * 2e-3).max(1e-3); + now.min.dist(r.min) > tight || now.max.dist(r.max) > tight + }); + out.push(if moved { off_the_ends(mb, hit.edge, hit.point) } else { hit.point }); + } + Some((_, Err(_))) | None => { + let mut w = None; + let refs: Vec = f.edge_refs.get(i).cloned().into_iter().collect(); + let skipped = format!("edge `{}` no longer exists and was skipped", stored.map(String::as_str).unwrap_or("?")); + // The name is gone. A pick on the axis of a round must not fall through to the + // tangency seam (#775). A sharp edge that moved still resolves from the point, + // which an edit relies on. + if pick_lies_on_a_round_axis(&mb.body, p) { + notes.push(skipped); + } else if let Ok(q) = resolve_edges(&mb.body, &[p], &refs, &mut w) { + out.extend(q); + notes.push(match stored { + Some(n) => format!("edge `{n}` no longer exists; using the edge at the picked point"), + None => "an edge reference without a name was found by its point".into(), + }); + } else { + notes.push(skipped); + } + } + } + } + if out.is_empty() { + let why = if notes.is_empty() { String::new() } else { format!(" ({})", notes.join("; ")) }; + return Err(DocError::Invalid(format!("none of the selected edges exist any more{why}"))); + } + if !notes.is_empty() { + *warning = Some(notes.join("; ")); + } + Ok(out) +} + +/// A point on edge `edge` of a body for the kernel to find it by: `p`, unless it lies at an end +/// of the edge (an upstream edit moved the edge along it), where the edges meeting there are as +/// near: then the edge's middle. +fn off_the_ends(mb: &ModelBody, edge: usize, p: Vec3) -> Vec3 { + let m = mb.mesh(); + let Some(e) = m.edges.get(edge) else { return p }; + let tight = (mb.body.size() * 2e-3).max(1e-3); + let (Some(a), Some(b)) = (e.first(), e.last()) else { return p }; + if p.dist(*a) > tight && p.dist(*b) > tight { + return p; + } + let total: f64 = e.windows(2).map(|w| w[0].dist(w[1])).sum(); + let mut acc = 0.0; + for w in e.windows(2) { + let l = w[0].dist(w[1]); + if acc + l >= total / 2.0 { + let t = if l > 0.0 { (total / 2.0 - acc) / l } else { 0.0 }; + return w[0] + (w[1] - w[0]) * t; + } + acc += l; + } + p +} + +/// The edges a tapered fillet tapered (a point on each, with its taper). +type Tapered = Vec<(Vec3, kernel::Taper)>; + +/// Body `mb` with blend `f` applied at `edges` (radius or distance `r`), the radii a fitted fillet +/// used (when it reduced any) and the edges it tapered. +fn blend_body( + vals: &BTreeMap, + f: &Feature, + mb: &ModelBody, + edges: &[Vec3], + r: f64, + warning: &mut Option, +) -> Result<(Traced, Option>, Tapered)> { + let input = mb.traced(); + let (mut used, mut tapered) = (None, Vec::new()); + // The blended body, and the lineage of what the last blend started from. + let (nb, from) = match &f.kind { + FeatureKind::Fillet { corner: crate::FilletCorner::G2, .. } => (kernel::fillet_g2_corners(&mb.body, edges, r)?, input), + FeatureKind::Fillet { style: crate::FilletStyle::Curvature, .. } => (kernel::fillet_g2(&mb.body, edges, r)?, input), + FeatureKind::Fillet { style: crate::FilletStyle::Chord, .. } => (kernel::fillet_chord(&mb.body, edges, r)?, input), + FeatureKind::Fillet { style: crate::FilletStyle::Variable { radius2, start, mid, smooth }, .. } => { + let r2 = val(vals, radius2, Kind::Length)?; + let mut pts = vec![(0.0, r), (1.0, r2)]; + for (t, e) in mid { + pts.push((*t, val(vals, e, Kind::Length)?)); + } + one_by_one(input, edges, |b, p| kernel::fillet_variable_points(b, p, start.0, &pts, *smooth))? + } + FeatureKind::Fillet { style: crate::FilletStyle::Spline { start, knots, radii }, .. } => { + let mut values = vec![r]; + for e in radii { + values.push(val(vals, e, Kind::Length)?); + } + let law = crate::FilletStyle::spline(knots, values); + one_by_one(input, edges, |b, p| kernel::fillet_variable_spline(b, p, start.0, &law))? + } + FeatureKind::Fillet { fit: crate::FilletFit::Taper, .. } => { + let (b, tapers) = kernel::fillet_tapered(&mb.body, edges, r)?; + if let Some(note) = tapered_note(&tapers) { + append_warning(warning, note); + } + tapered = edges.iter().copied().zip(tapers).filter_map(|(p, t)| Some((p, t?))).collect(); + (b, input) + } + FeatureKind::Fillet { fit, .. } => { + let (b, u) = fillet_fitted(&mb.body, edges, r, *fit)?; + if let Some(u) = &u { + append_warning(warning, reduced_note(u, r)); + } + used = u; + (b, input) + } + FeatureKind::Chamfer { distance2, angle, flip, .. } => (chamfer_with(vals, &mb.body, edges, r, distance2, angle, *flip)?, input), + _ => return Err(DocError::Invalid("blend".into())), + }; + // Keeping the input's planar certificates may join faces; their history stays over the same + // operand. + Ok((Traced::step(nb.with_preserved_planar_sources(&mb.body)?, &[&from]), used, tapered)) +} + /// The revolve axis in the sketch's 2D coordinates (a point on it, its direction). `construct` /// gives a construction axis, by name, in the sketch's 3D frame. pub(crate) fn revolve_axis(ss: &SolvedSketch, axis: &AxisRef, construct: &dyn Fn(&str) -> Result<(Vec3, Vec3)>) -> Result<(Vec2, Vec2)> { @@ -5795,24 +6082,39 @@ fn replay( // its picked points. let found = st.blend_edges.get(&src.id).cloned().unwrap_or_else(|| crate::plain(edges)); for m in mats { - let moved: Vec = found.iter().map(|p| crate::apply_point(m, *p)).collect(); - let ti = blend_target(st, &None, &moved)?; - let Some(mb) = st.bodies.get(ti).cloned() else { continue }; - let nb = match &src.kind { - FeatureKind::Chamfer { distance2, angle, flip, .. } => chamfer_with(vals, &mb.body, &moved, r, distance2, angle, *flip)?, - // A copy is congruent to the original: the radius it was reduced to first. - FeatureKind::Fillet { fit, .. } => match st.fitted.get(&src.id) { - Some(used) => { - kernel::fillet_each(&mb.body, &moved, used).or_else(|_| fillet_fitted(&mb.body, &moved, r, *fit).map(|x| x.0))? - } - None => fillet_fitted(&mb.body, &moved, r, *fit)?.0, - }, - _ => kernel::fillet(&mb.body, &moved, r)?, - }; - // A copy blends edges the pattern's own copies made: named after the body so far. - let nb = mb.traced().then(nb); - if let Some(slot) = st.bodies.get_mut(ti) { - *slot = ModelBody::traced_new(mb.name, nb, mb.feature); + let moved_all: Vec = found.iter().map(|p| crate::apply_point(m, *p)).collect(); + // The copies of a blend over several bodies blend each body's own edges. + let mut groups: Vec<(usize, Vec)> = Vec::new(); + for (i, p) in moved_all.iter().enumerate() { + let ti = match body_on_edge(st, *p) { + Some(ti) => ti, + None => blend_target(st, &None, &moved_all)?, + }; + match groups.iter_mut().find(|(b, _)| *b == ti) { + Some((_, idx)) => idx.push(i), + None => groups.push((ti, vec![i])), + } + } + for (ti, idx) in groups { + let moved: Vec = idx.iter().filter_map(|i| moved_all.get(*i).copied()).collect(); + let Some(mb) = st.bodies.get(ti).cloned() else { continue }; + let nb = match &src.kind { + FeatureKind::Chamfer { distance2, angle, flip, .. } => chamfer_with(vals, &mb.body, &moved, r, distance2, angle, *flip)?, + // A copy is congruent to the original: the radius it was reduced to first. + FeatureKind::Fillet { fit, .. } => match st.fitted.get(&src.id) { + Some(used) => { + let used: Vec = idx.iter().map(|i| used.get(*i).copied().unwrap_or(r)).collect(); + kernel::fillet_each(&mb.body, &moved, &used).or_else(|_| fillet_fitted(&mb.body, &moved, r, *fit).map(|x| x.0))? + } + None => fillet_fitted(&mb.body, &moved, r, *fit)?.0, + }, + _ => kernel::fillet(&mb.body, &moved, r)?, + }; + // A copy blends edges the pattern's own copies made: named after the body so far. + let nb = mb.traced().then(nb); + if let Some(slot) = st.bodies.get_mut(ti) { + *slot = ModelBody::traced_new(mb.name, nb, mb.feature); + } } } continue; @@ -6726,54 +7028,6 @@ fn eval_feature(doc: &Document, vals: &BTreeMap, f: &Feature, st: } FeatureKind::Fillet { edges, radius, body, .. } | FeatureKind::Chamfer { edges, distance: radius, body, .. } => { let r = val(vals, radius, Kind::Length)?; - let ti = blend_target(st, body, &crate::plain(edges))?; - let Some(mb) = st.bodies.get(ti) else { return Err(DocError::Invalid("body".into())) }; - let edges = if f.edge_names.iter().any(|n| !n.is_empty()) { - // By name first; a name that is gone falls back to the point, with a warning. - let (mut out, mut notes) = (Vec::new(), Vec::new()); - for (i, p) in edges.iter().enumerate() { - match f.edge_names.get(i).filter(|n| !n.is_empty()).map(|n| (n, crate::naming::locate_edge(mb, n, p.0))) { - Some((n, Ok(hit))) => { - if let Some(note) = hit.note(n) { - notes.push(note); - } - out.push(hit.point); - } - Some((_, Err(_))) | None => { - let mut w = None; - let refs: Vec = f.edge_refs.get(i).cloned().into_iter().collect(); - let skipped = - format!("edge `{}` no longer exists and was skipped", f.edge_names.get(i).map(String::as_str).unwrap_or("?")); - // The name is gone. A pick on the axis of a round must not fall - // through to the tangency seam (#775). A sharp edge that moved - // still resolves from the point, which an edit relies on. - if pick_lies_on_a_round_axis(&mb.body, p.0) { - notes.push(skipped); - } else if let Ok(q) = resolve_edges(&mb.body, &[p.0], &refs, &mut w) { - out.extend(q); - notes.push(match f.edge_names.get(i) { - Some(n) if !n.is_empty() => format!("edge `{n}` no longer exists; using the edge at the picked point"), - _ => "an edge reference without a name was found by its point".into(), - }); - } else { - notes.push(skipped); - } - } - } - } - if out.is_empty() { - let why = if notes.is_empty() { String::new() } else { format!(" ({})", notes.join("; ")) }; - return Err(DocError::Invalid(format!("none of the selected edges exist any more{why}"))); - } - if !notes.is_empty() { - *warning = Some(notes.join("; ")); - } - out - } else { - resolve_edges(&mb.body, &crate::plain(edges), &f.edge_refs, warning)? - }; - st.blend_edges.insert(f.id, edges.clone()); - let input = mb.traced(); // A G2 corner is built by the corner construction alone, for a constant radius: any // other style (or a fitted radius) has no corner patch to repeat. if let FeatureKind::Fillet { corner: crate::FilletCorner::G2, style, fit, .. } = &f.kind @@ -6781,55 +7035,52 @@ fn eval_feature(doc: &Document, vals: &BTreeMap, f: &Feature, st: { return Err(DocError::Invalid("a G2 corner is built for a constant-radius fillet (type: constant, fit: exact) only".into())); } - // The blended body, and the lineage of what the last blend started from. - let (nb, from) = match &f.kind { - FeatureKind::Fillet { corner: crate::FilletCorner::G2, .. } => (kernel::fillet_g2_corners(&mb.body, &edges, r)?, input), - FeatureKind::Fillet { style: crate::FilletStyle::Curvature, .. } => (kernel::fillet_g2(&mb.body, &edges, r)?, input), - FeatureKind::Fillet { style: crate::FilletStyle::Chord, .. } => (kernel::fillet_chord(&mb.body, &edges, r)?, input), - FeatureKind::Fillet { style: crate::FilletStyle::Variable { radius2, start, mid, smooth }, .. } => { - let r2 = val(vals, radius2, Kind::Length)?; - let mut pts = vec![(0.0, r), (1.0, r2)]; - for (t, e) in mid { - pts.push((*t, val(vals, e, Kind::Length)?)); - } - one_by_one(input, &edges, |b, p| kernel::fillet_variable_points(b, p, start.0, &pts, *smooth))? + // Each edge is found on its own body (picked over several bodies, the edges of each + // are blended on it), all against the bodies as they were before this feature. + let on = blend_bodies(st, f, body, &crate::plain(edges))?; + let mut groups: Vec<(usize, Vec)> = Vec::new(); + for (i, ti) in on.iter().enumerate() { + match groups.iter_mut().find(|(b, _)| b == ti) { + Some((_, idx)) => idx.push(i), + None => groups.push((*ti, vec![i])), } - FeatureKind::Fillet { style: crate::FilletStyle::Spline { start, knots, radii }, .. } => { - let mut values = vec![r]; - for e in radii { - values.push(val(vals, e, Kind::Length)?); - } - let law = crate::FilletStyle::spline(knots, values); - one_by_one(input, &edges, |b, p| kernel::fillet_variable_spline(b, p, start.0, &law))? + } + let (mut found, mut notes, mut fitted, mut tapered_all) = (Vec::new(), Vec::new(), Vec::new(), Vec::new()); + let mut reduced = false; + let mut blended = Vec::new(); + for (ti, idx) in &groups { + let Some(mb) = st.bodies.get(*ti) else { return Err(DocError::Invalid("body".into())) }; + let mut w = None; + let edges = blend_edges_on(mb, f, edges, idx, &mut w)?; + if let Some(w) = w { + notes.push(w); } - FeatureKind::Fillet { fit: crate::FilletFit::Taper, .. } => { - let (b, tapers) = kernel::fillet_tapered(&mb.body, &edges, r)?; - if let Some(note) = tapered_note(&tapers) { - append_warning(warning, note); - } - let tapered: Vec<(Vec3, kernel::Taper)> = edges.iter().copied().zip(tapers).filter_map(|(p, t)| Some((p, t?))).collect(); - if !tapered.is_empty() { - st.tapered.insert(f.id, tapered); - } - (b, input) + let mut note = None; + let (nb, used, tapered) = blend_body(vals, f, mb, &edges, r, &mut note)?; + if let Some(n) = note { + notes.push(n); } - FeatureKind::Fillet { fit, .. } => { - let (b, used) = fillet_fitted(&mb.body, &edges, r, *fit)?; - if let Some(used) = used { - append_warning(warning, reduced_note(&used, r)); - st.fitted.insert(f.id, used); - } - (b, input) + reduced |= used.is_some(); + fitted.extend(used.unwrap_or_else(|| vec![r; edges.len()])); + tapered_all.extend(tapered); + found.extend(edges); + blended.push((*ti, nb)); + } + if !notes.is_empty() { + *warning = Some(notes.join("; ")); + } + st.blend_edges.insert(f.id, found); + if reduced { + st.fitted.insert(f.id, fitted); + } + if !tapered_all.is_empty() { + st.tapered.insert(f.id, tapered_all); + } + for (ti, nb) in blended { + if let Some(slot) = st.bodies.get_mut(ti) { + let (name, feat) = (slot.name.clone(), slot.feature); + *slot = ModelBody::traced_new(name, nb, feat); } - FeatureKind::Chamfer { distance2, angle, flip, .. } => (chamfer_with(vals, &mb.body, &edges, r, distance2, angle, *flip)?, input), - _ => return Err(DocError::Invalid("blend".into())), - }; - // Keeping the input's planar certificates may join faces; their history stays over - // the same operand. - let nb = Traced::step(nb.with_preserved_planar_sources(&mb.body)?, &[&from]); - let (name, feat) = (mb.name.clone(), mb.feature); - if let Some(slot) = st.bodies.get_mut(ti) { - *slot = ModelBody::traced_new(name, nb, feat); } Ok(()) } diff --git a/crates/engine/src/naming_history_tests.rs b/crates/engine/src/naming_history_tests.rs index 3a435a6ac..cb93874bb 100644 --- a/crates/engine/src/naming_history_tests.rs +++ b/crates/engine/src/naming_history_tests.rs @@ -461,3 +461,131 @@ fn a_design_saved_before_pieces_were_numbered_by_place_keeps_their_numbers() { saved_with.refresh(); assert_eq!(listed(&mut saved_with, "Block"), kept); } + +/// The volumes of the design's bodies, by name. +fn volumes(s: &Session) -> Vec<(String, f64)> { + let st = s.model.state(); + st.bodies.iter().map(|b| (b.name.clone(), solidcraft_kernel::measure(&b.body).unwrap().volume)).collect() +} + +/// Whether the four vertical corners of the box `lo`..`hi` are rounded halfway up `z`. +fn corners_rounded(s: &Session, lo: [f64; 2], hi: [f64; 2], z: f64) -> bool { + let e = 0.2; + [[lo[0] + e, lo[1] + e], [hi[0] - e, lo[1] + e], [hi[0] - e, hi[1] - e], [lo[0] + e, hi[1] - e]].iter().all(|[x, y]| !solid_at(s, [*x, *y, z])) +} + +/// A 50 mm square box of parametric `height`, and a 10 mm box sketched on its top: two bodies. +fn stacked_boxes(s: &mut Session) { + run(s, "parameters.add", json!({"name": "height", "expression": "40 mm"})); + run(s, "sketch.create", json!({"plane": "XY", "name": "Low"})); + run(s, "sketch.rectangle.two_point", json!({"p0": [-25, -25], "p1": [25, 25]})); + run(s, "sketch.finish", json!({})); + run(s, "solid.extrude", json!({"distance": "height", "name": "Lower"})); + run(s, "sketch.create", json!({"plane": {"face": [0, 0, 40]}, "name": "High"})); + run(s, "sketch.rectangle.two_point", json!({"p0": [-25, -25], "p1": [25, 25]})); + run(s, "sketch.finish", json!({})); + run(s, "solid.extrude", json!({"distance": 10, "operation": "new", "name": "Upper"})); + assert_eq!(s.model.state().bodies.len(), 2); +} + +/// Every feature evaluated without an error or a warning. +fn all_clean(s: &Session, when: &str) { + for f in &s.doc.features { + let r = s.model.result(f.id); + assert_eq!(r.and_then(|r| r.error.clone()), None, "{} {when}", f.name); + assert_eq!(r.and_then(|r| r.warning.clone()), None, "{} {when}", f.name); + } +} + +/// Two stacked boxes, the lower one of parametric height, the vertical edges of each rounded by +/// its own fillet (or by one fillet for all eight). Raising the lower box puts the upper box's +/// picks (z = 45) on the lower box's rounded corners: the upper box's rounds stay on the upper +/// box, found by their names, not moved onto the lower box's already rounded edges. +#[test] +fn rounds_on_stacked_boxes_stay_on_their_own_box_when_the_lower_one_grows() { + for one_feature in [false, true] { + let mut s = Session::default(); + stacked_boxes(&mut s); + let low = json!([[-25, -25, 20], [25, -25, 20], [25, 25, 20], [-25, 25, 20]]); + let high = json!([[-25, -25, 45], [25, -25, 45], [-25, 25, 45], [25, 25, 45]]); + if one_feature { + let all: Vec = low.as_array().unwrap().iter().chain(high.as_array().unwrap()).cloned().collect(); + run(&mut s, "solid.fillet", json!({"edges": all, "radius": 2, "name": "Rounds"})); + } else { + run(&mut s, "solid.fillet", json!({"edges": low, "radius": 2, "name": "RoundLow"})); + run(&mut s, "solid.fillet", json!({"edges": high, "radius": 2, "name": "RoundHigh"})); + } + for height in [40.0, 50.0, 47.0, 45.0, 30.0] { + change(&mut s, "height", &format!("{height} mm")); + let when = format!("at height {height} ({one_feature})"); + assert_eq!(s.model.state().bodies.len(), 2, "{when}"); + assert!(corners_rounded(&s, [-25.0, -25.0], [25.0, 25.0], height / 2.0), "lower box {when}: {:?}", volumes(&s)); + assert!(corners_rounded(&s, [-25.0, -25.0], [25.0, 25.0], height + 5.0), "upper box {when}: {:?}", volumes(&s)); + // Nothing else rounded: the edges where the boxes meet stay sharp. + assert!(solid_at(&s, [0.0, -24.9, height - 0.1]), "a top edge of the lower box was rounded {when}"); + assert!(solid_at(&s, [0.0, -24.9, height + 0.1]), "a bottom edge of the upper box was rounded {when}"); + all_clean(&s, &when); + } + } +} + +/// Two bodies from one extrude (two profiles), all eight vertical edges rounded in one fillet: +/// each edge is rounded on its own body, never moved onto the first body. +#[test] +fn one_fillet_over_two_bodies_of_one_extrude_rounds_each_body_s_own_edges() { + let mut s = Session::default(); + run(&mut s, "parameters.add", json!({"name": "h", "expression": "20 mm"})); + run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"})); + run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [40, 30]})); + run(&mut s, "sketch.rectangle.two_point", json!({"p0": [45, 0], "p1": [85, 30]})); + run(&mut s, "sketch.finish", json!({})); + run(&mut s, "solid.extrude", json!({"distance": "h", "profiles": [0, 1], "operation": "new", "name": "Pair"})); + assert_eq!(s.model.state().bodies.len(), 2); + let edges = json!([[0, 0, 10], [40, 0, 10], [40, 30, 10], [0, 30, 10], [45, 0, 10], [85, 0, 10], [85, 30, 10], [45, 30, 10]]); + run(&mut s, "solid.fillet", json!({"edges": edges, "radius": 2, "name": "Rounds"})); + let check = |s: &Session, z: f64, when: &str| { + assert!(corners_rounded(s, [0.0, 0.0], [40.0, 30.0], z), "first body {when}: {:?}", volumes(s)); + assert!(corners_rounded(s, [45.0, 0.0], [85.0, 30.0], z), "second body {when}: {:?}", volumes(s)); + // Nothing else rounded: the top edges stay sharp. + assert!(solid_at(s, [20.0, 0.1, 2.0 * z - 0.1]) && solid_at(s, [65.0, 0.1, 2.0 * z - 0.1]), "a top edge was rounded {when}"); + assert_eq!(error(s, "Rounds"), None, "{when}"); + assert_eq!(warning(s, "Rounds"), None, "{when}"); + }; + check(&s, 10.0, "when made"); + change(&mut s, "h", "30 mm"); + check(&s, 15.0, "after h changed"); +} + +/// One fillet over a vertical edge of each of two stacked boxes. A build before blends were split +/// by body named the upper box's edge after the lower box's nearest edge (its top front edge), +/// which was rounded instead. The pick (outside the box the name was recorded on) shows that name +/// is not the upper box's: the edge is found at its point, on the upper box. +#[test] +fn one_fillet_over_stacked_boxes_rounds_the_upper_box_s_edge_even_when_saved_named_on_the_lower() { + let mut s = Session::default(); + stacked_boxes(&mut s); + run(&mut s, "solid.fillet", json!({"edges": [[25, -25, 20], [-25, -25, 45]], "radius": 2, "name": "Rounds"})); + let check = |s: &Session, when: &str| { + assert!(!solid_at(s, [24.8, -24.8, 20.0]), "lower box's edge not rounded {when}"); + assert!(!solid_at(s, [-24.8, -24.8, 45.0]), "upper box's edge not rounded {when}"); + assert!(solid_at(s, [0.0, -24.9, 39.9]), "the lower box's top front edge was rounded {when}"); + all_clean(s, when); + }; + check(&s, "when made"); + let f = id(&s, "Rounds"); + let names = s.doc.feature(f).unwrap().edge_names.clone(); + let upper = format!("F{}:", id(&s, "Upper")); + assert!(names[1].starts_with(&upper), "the upper box's edge is named on the upper box: {names:?}"); + // As an older build saved it: both edges named and referenced on the lower box. + let before = s.model.state_before(f); + let lower = before.bodies.iter().find(|b| b.feature == id(&s, "Lower")).unwrap().clone(); + let old_names = solidcraft_doc::naming::edge_names_at(&lower, &[Vec3::new(25.0, -25.0, 20.0), Vec3::new(-25.0, -25.0, 45.0)]); + assert!(old_names[1].contains("top"), "{old_names:?}"); + let old_refs = + solidcraft_doc::edge_refs(&before, &Some(lower.name.clone().into()), &[Vec3::new(25.0, -25.0, 20.0), Vec3::new(-25.0, -25.0, 45.0)]); + let feature = s.doc_mut().feature_mut(f).unwrap(); + feature.edge_names = old_names; + feature.edge_refs = old_refs; + s.refresh(); + check(&s, "saved by an older build"); +}