SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Fillet/chamfer: find each edge on its own body (#6378)
bherbruckbba19536230c
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex dd6aef2d26..b8c7c2478e 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).+/// 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<crate::BodyName>, pts: &[Vec3]) -> Option<Vec<usize>> {+ 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()+ }+}++/// 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<crate::BodyName>, pts: &[Vec3]) -> Vec<EdgeRef> {- 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()+ let Some(on) = picked_bodies(st, body, pts) else { return Vec::new() };+ let mut seen: BTreeMap<usize, Option<(Vec<kernel::EdgeInfo>, 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` on the body a blend would go on.+/// 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<crate::BodyName>, pts: &[Vec3]) -> Vec<String> {- 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(),+ let Some(on) = picked_bodies(st, body, pts) else { return Vec::new() };+ let mut out = vec![String::new(); pts.len()];+ let mut done: Vec<usize> = 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<usize> = on.iter().enumerate().filter(|(_, t)| **t == ti).map(|(i, _)| i).collect();+ let at: Vec<Vec3> = 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<crate::BodyName>, 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<usize> {+ // 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<usize> {+ 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<crate::BodyName>, pts: &[Vec3]) -> Result<Vec<usize>> {+ // 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<Option<&str>> = pts.iter().enumerate().map(|(i, p)| trusted_edge_name(f, i, *p)).collect();+ let by_name: Vec<Option<usize>> = names.iter().zip(pts).map(|(n, p)| n.and_then(|n| named_body(st, n, *p))).collect();+ let mut named: Vec<usize> = 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<String>) -> Result<Vec<Vec3>> {+ 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<Vec3> = idx.iter().map(|i| pick(*i)).collect();+ let refs: Vec<EdgeRef> = 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<EdgeRef> = 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<String, Value>,+ f: &Feature,+ mb: &ModelBody,+ edges: &[Vec3],+ r: f64,+ warning: &mut Option<String>,+) -> Result<(Traced, Option<Vec<f64>>, 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<Vec3> = 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<Vec3> = 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<usize>)> = 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<Vec3> = 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<f64> = 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<String, Value>, 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<EdgeRef> = 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<String, Value>, 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<usize>)> = 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.rsindex 3a435a6ace..cb93874bbf 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<Value> = 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");+}