diff --git a/apps/solidcraft-cli/tests/naming_corpus.rs b/apps/solidcraft-cli/tests/naming_corpus.rs index 48e75db6b..50e5c8f25 100644 --- a/apps/solidcraft-cli/tests/naming_corpus.rs +++ b/apps/solidcraft-cli/tests/naming_corpus.rs @@ -175,14 +175,9 @@ fn record_refs(out: &mut Vec<(String, bool)>, s: &Session, f: &Feature) { ("not checked (a cylindrical emboss finds its face on its own body)".to_string(), true) } else { match naming::locate_face_on_body(&fst, f.kind.face_body(), n, p) { - Some(hit) => ( - format!( - "{}{}", - face_label(&fst, hit.body, hit.face), - flags(&[(hit.split, "split"), (hit.merged, "merged"), (!hit.verified, "geometric"), (hit.legacy, "legacy")]) - ), - true, - ), + Some(hit) => { + (format!("{}{}", face_label(&fst, hit.body, hit.face), flags(&[(!hit.verified, "geometric"), (hit.legacy, "legacy")])), true) + } None => ("gone".into(), false), } }; @@ -198,7 +193,7 @@ fn record_refs(out: &mut Vec<(String, bool)>, s: &Session, f: &Feature) { "{} edge {}{}", b.name, naming::edge_names(b).get(hit.edge).map(String::as_str).unwrap_or("?"), - flags(&[(hit.split, "split"), (!hit.verified, "geometric"), (hit.legacy, "legacy")]) + flags(&[(!hit.verified, "geometric"), (hit.legacy, "legacy")]) ), true, ), diff --git a/crates/doc/src/config_shell_tests.rs b/crates/doc/src/config_shell_tests.rs index 48e9f04b3..d583b6413 100644 --- a/crates/doc/src/config_shell_tests.rs +++ b/crates/doc/src/config_shell_tests.rs @@ -221,7 +221,7 @@ fn regularized_shell_keeps_legacy_and_explicit_single_face_projections_closed() let mut sketch = solidcraft_sketch::Sketch::new(); let link = sketch.add_link(solidcraft_sketch::LinkKind::Project, source, &legacy.geom).unwrap(); sketch.links[0].face_name = Some(crate::naming::face_names(body)[index].clone()); - let warnings = crate::project::refresh_links(&doc, &values, &state, &plane, &mut sketch); + let warnings = crate::project::refresh_links(&doc, &values, &state, &plane, &mut sketch).unwrap(); assert!(warnings.is_empty(), "{warnings:?}"); assert!(!sketch.links[0].lost); assert!(!sketch.update_link(&link, &explicit.geom).unwrap()); @@ -308,7 +308,7 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material } #[test] -fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() { +fn saved_curved_strip_projection_asks_for_its_face_again_after_exact_wall_coalescence() { use solidcraft_sketch::{LinkKind, LinkSource, Sketch}; let mut doc = Document::new("saved curved strip"); doc.set_param("width", "80", Some("mm"), None).unwrap(); @@ -356,13 +356,13 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() { // longest spread), from z = 0 to 2. Projected on YZ, the quarter round from (40, 24) to // (34, 30) is the rectangle y 24..30, z 0..2: its two arcs and its two straight sides. let former = format!("{stem}#1"); + let reference = former.clone(); let source = LinkSource::Face { body: "Case".into(), at }; let (a, b, c, d) = (Vec2::new(24., 0.), Vec2::new(30., 0.), Vec2::new(30., 2.), Vec2::new(24., 2.)); let geometry: Vec<_> = [(a, b), (b, c), (c, d), (d, a)].into_iter().map(|(p, q)| solidcraft_sketch::LinkGeom::Line(p, q)).collect(); let mut sketch = Sketch::new(); sketch.add_link(LinkKind::Project, source, &geometry).unwrap(); sketch.links[0].face_name = Some(former); - let original = sketch.clone(); let sk = doc .add_feature(FeatureKind::Sketch { plane: PlaneRef::Custom { plane: solidcraft_geom::Plane::YZ }, sketch }, Some("Saved corner strip")) .unwrap(); @@ -387,25 +387,21 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() { let mut cold = Model::new(); cold.evaluate(&loaded); for current in [&model, &cold] { + // No face is the piece any more, and the whole wall is not it: the sketch fails, + // asking for its face again, and so does the material made from it. The case builds. let result = current.results.iter().find(|r| r.id == sk).unwrap(); - assert!(result.error.is_none()); - assert!(result.warning.as_deref().unwrap().contains("no longer exists; last geometry retained")); + assert_eq!(result.error.as_deref().and_then(crate::reselect_parts), Some(("Saved corner strip", reference.as_str())), "{result:?}"); + assert!(current.results.iter().find(|r| r.id == boss).unwrap().error.is_some()); + assert!(current.results.iter().filter(|r| r.id != sk && r.id != boss).all(|r| r.error.is_none()), "{:?}", current.results); let state = current.state(); - let solved = state.sketch(sk).unwrap(); - assert!(solved.sketch.links[0].lost); - assert_eq!(solved.sketch.points, original.points); - assert_eq!(solved.sketch.curves, original.curves); - let material = state.bodies.iter().find(|body| body.feature == boss).unwrap(); - assert!( - (solidcraft_kernel::measure(&material.body).unwrap().volume - 12.).abs() < 1e-7, - "two-mm strip cannot expand to a full thirty-mm wall" - ); + assert!(state.body("Case").is_some()); + assert!(state.bodies.iter().all(|body| body.feature != boss), "two-mm strip cannot expand to a full thirty-mm wall"); } } } #[test] -fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() { +fn saved_stepped_tab_cut_piece_projection_asks_for_its_face_again_without_expanding_material() { use solidcraft_sketch::{LinkKind, LinkSource, Sketch}; let mut doc = Document::new("public stepped tab case"); doc.set_param("length", "40", Some("mm"), None).unwrap(); @@ -466,9 +462,8 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() { let geometry: Vec<_> = (0..4).map(|i| solidcraft_sketch::LinkGeom::Line(corners[i], corners[(i + 1) % 4])).collect(); let mut sketch = Sketch::new(); sketch.add_link(LinkKind::Project, LinkSource::Face { body: "Case".into(), at }, &geometry).unwrap(); - sketch.links[0].face_name = Some(former); - let original = sketch.clone(); - let captured = original.points.iter().filter(|p| p.link.is_some()).map(|p| p.pos).collect::>(); + sketch.links[0].face_name = Some(former.clone()); + let captured = sketch.points.iter().filter(|p| p.link.is_some()).map(|p| p.pos).collect::>(); assert_eq!(captured.len(), 4); assert!(captured.iter().all(|p| (p.x == 10. || p.x == 20.) && (p.y == 0. || p.y == 20.))); let sk = doc.add_feature(FeatureKind::Sketch { plane: PlaneRef::Custom { plane }, sketch }, Some("Saved wall patch")).unwrap(); @@ -493,22 +488,13 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() { let mut cold = Model::new(); cold.evaluate(&reopened); for current in [&model, &cold] { + // No face is the patch any more, and the whole wall is not it: the sketch fails, + // asking for its face again, and so does the stock made from it. let result = current.results.iter().find(|r| r.id == sk).unwrap(); - assert!(result.error.is_none(), "{result:?}"); - assert!(result.warning.as_deref().is_some_and(|w| w.contains("no longer exists; last geometry retained")), "{result:?}"); + assert_eq!(result.error.as_deref().and_then(crate::reselect_parts), Some(("Saved wall patch", former.as_str())), "{result:?}"); + assert!(current.results.iter().find(|r| r.id == material).unwrap().error.is_some()); let state = current.state(); - let saved = state.sketch(sk).unwrap(); - assert!(saved.sketch.links[0].lost); - assert_eq!(saved.sketch.points, original.points); - assert_eq!(saved.sketch.curves, original.curves); - let stock = state.bodies.iter().find(|b| b.feature == material).unwrap(); - assert!( - (solidcraft_kernel::measure(&stock.body).unwrap().volume - 200.).abs() < 1e-7, - "saved10x20 patch must not become30x20 wall; actualvolume={}, bounds={:?}, originalpoints={:?}", - solidcraft_kernel::measure(&stock.body).unwrap().volume, - stock.mesh().bounds(), - original.points - ); + assert!(state.bodies.iter().all(|b| b.feature != material), "saved 10 x 20 patch must not become the 30 x 20 wall"); let case = state.body("Case").unwrap(); let expected = length * 30. * 20. + 8. * 10. * 8. - (length - 2. * wall) * (30. - 2. * wall) * (20. - wall); assert!((solidcraft_kernel::measure(&case.body).unwrap().volume - expected).abs() < 1e-6); diff --git a/crates/doc/src/construct.rs b/crates/doc/src/construct.rs index 6b21b8465..720d6bcbb 100644 --- a/crates/doc/src/construct.rs +++ b/crates/doc/src/construct.rs @@ -141,16 +141,16 @@ fn construct<'a>(st: &'a ModelState, name: &str) -> Result<&'a ConstructGeom> { st.construct.iter().find(|c| c.name == name).map(|c| &c.geom).ok_or_else(|| DocError::Unknown(format!("construction `{name}`"))) } -/// The face picked: (body, face index, point on it). +/// The face picked: (body, face index, point on it). A face picked with a name is the face the +/// name finds, or the reference fails, asking for it to be picked again. fn face_of<'a>(st: &'a ModelState, at: Vec3, name: &Option) -> Result<(&'a ModelBody, usize, Vec3)> { // The named face itself: its nearest point to the old pick can lie on an edge it shares // (a corner round that a parameter moved away from the pick), where picking again by the // point finds the flat face beside it (#1255). - if let Some(hit) = name.as_deref().and_then(|n| crate::name_lookup::locate_face(st, n, at)) - && let Some(b) = st.bodies.get(hit.body).filter(|b| !b.body.is_mesh()) - && hit.face < b.body.face_count() - { - return Ok((b, hit.face, hit.point)); + if let Some(n) = name.as_deref() { + return crate::name_lookup::locate_face(st, n, at) + .and_then(|hit| st.bodies.get(hit.body).filter(|b| !b.body.is_mesh() && hit.face < b.body.face_count()).map(|b| (b, hit.face, hit.point))) + .ok_or_else(|| DocError::reselect(n)); } for b in bodies(st) { if let Some(fi) = crate::appearance::face_index_at(b, at) { @@ -165,16 +165,13 @@ fn edge_points(st: &ModelState, at: Vec3, name: &Option) -> Result(st: &'a ModelState, at: Vec3, name: &Option) -> Result<(&'a ModelBody, usize, Vec)> { let mut at = at; if let Some(n) = name { - for b in bodies(st) { - if let Ok((q, _)) = crate::naming::find_edge(b, n, at) { - at = q; - break; - } - } + at = bodies(st).find_map(|b| crate::naming::find_edge(b, n, at).ok()).ok_or_else(|| DocError::reselect(n.as_str()))?; } let mut best: Option<(f64, &ModelBody, usize, Vec)> = None; for b in bodies(st) { @@ -216,7 +213,7 @@ fn named_vertex(st: &ModelState, at: Vec3, names: &[String]) -> Option { .iter() .map(|n| { // The edge with that name itself, never the one nearest the old pick. - let on = bodies(st).find_map(|b| crate::naming::find_edge(b, n, at).ok())?.0; + let on = bodies(st).find_map(|b| crate::naming::find_edge(b, n, at).ok())?; let pts = edge_points(st, on, &None).ok()?; Some([*pts.first()?, *pts.last()?]) }) @@ -683,12 +680,15 @@ pub(crate) fn resolve_geo_plane(ctx: &Ctx, p: &PlaneRef) -> Result { impl GeoRef { /// Where a picked edge or face is now, found the way evaluation finds it (by its persistent - /// name, else at the picked point): a point on it. `None` for other references and for an + /// name when it has one, else at the picked point): a point on it. `None` for other references and for an /// edge or face that is gone. pub fn picked_point(&self, st: &ModelState) -> Option { match self { GeoRef::Edge { at, name } => { - let on = name.as_deref().and_then(|n| bodies(st).find_map(|b| crate::naming::find_edge(b, n, *at).ok())).map_or(*at, |(q, _)| q); + let on = match name.as_deref() { + Some(n) => bodies(st).find_map(|b| crate::naming::find_edge(b, n, *at).ok())?, + None => *at, + }; edge_pick(st, on, &None).ok().map(|_| on) } GeoRef::Face { at, name } => face_of(st, *at, name).ok().map(|(_, _, p)| p), diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index f764a4c6d..5142380bf 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -3483,18 +3483,18 @@ fn trusted_edge_name(f: &Feature, i: usize, p: Vec3) -> Option<&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. +/// runs through the pick `p`, 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; + let mut best: Option<(usize, (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)); + let score = (hit.on_point, -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)); } @@ -3566,8 +3566,9 @@ fn blend_bodies(st: &ModelState, f: &Feature, body: &Option, pt 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. +/// The edges `idx` of blend `f` found on body `mb`: by name, where the edge was stored with one. +/// A name that no longer finds exactly its edge fails the blend, asking for the edge to be picked +/// again; so does a name a build stored for the wrong body (see `trusted_edge_name`). 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()) { @@ -3578,51 +3579,34 @@ fn blend_edges_on(mb: &ModelBody, f: &Feature, edges: &[crate::Position], idx: & 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 Some(stored) = f.edge_names.get(i).filter(|n| !n.is_empty()) else { + // An edge picked without a name: by its point. A pick on the axis of a round must not + // fall through to the tangency seam (#775). 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()), + let refs: Vec = f.edge_refs.get(i).cloned().into_iter().collect(); + let skipped = "edge `?` no longer exists and was skipped"; + if pick_lies_on_a_round_axis(&mb.body, p) { + notes.push(skipped.into()); + } else if let Ok(q) = resolve_edges(&mb.body, &[p], &refs, &mut w) { + out.extend(q); + notes.push("an edge reference without a name was found by its point".into()); + } else { + notes.push(skipped.into()); } - notes.extend(w); continue; + }; + let hit = + trusted_edge_name(f, i, p).and_then(|n| crate::naming::locate_edge(mb, n, p).ok()).ok_or_else(|| DocError::reselect(stored.as_str()))?; + if let Some(note) = hit.note(stored) { + notes.push(note); } - 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); - } - } - } + // 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 }); } if out.is_empty() { let why = if notes.is_empty() { String::new() } else { format!(" ({})", notes.join("; ")) }; @@ -5712,9 +5696,9 @@ fn copied_features(doc: &Document, vals: &BTreeMap, st: &ModelSta /// `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. /// `f` with each face point moved onto its named face (on the body the feature names, when it -/// names one and the face is there) in `state`, and notes for names that no longer find their -/// face. `None` when `f` names no face; an error when the frame the faces are looked up in -/// cannot be made (the feature fails with it). +/// names one and the face is there) in `state`, and notes on how the faces were found. `None` +/// when `f` names no face; an error when a name no longer finds its face (the feature asks for +/// it to be picked again), or when the frame the faces are looked up in cannot be made. fn with_named_face_points(doc: &Document, state: &ModelState, f: &Feature) -> Result)>> { // Cylindrical emboss resolves its named face in the selected body's frame // and certifies an analytic anchor; mesh projection here would undo that. @@ -5754,7 +5738,7 @@ fn with_named_face_points(doc: &Document, state: &ModelState, f: &Feature) -> Re _ => *p = hit.pick_point(&fst, *p), } } - None => notes.push(format!("face `{n}` no longer exists; using the face at the picked point")), + None => return Err(DocError::reselect(n.as_str())), } } Ok(Some((g, notes))) @@ -6279,53 +6263,31 @@ pub(crate) fn sheet_face_plane_in_frame(doc: &Document, st: &ModelState, comp: u }) } -/// The plane of the body face a sketch sits on, found again: among planar faces with the -/// picked plane's normal, the one nearest `at`. The picked frame moves along its normal onto it. -fn face_plane(st: &ModelState, picked: &Plane, at: Vec3, name: Option<&str>) -> (Plane, Option) { +/// The plane of the body face a sketch sits on, found again: the face its stored `name` finds, +/// which must still be planar and face the picked plane's way (else the sketch fails, asking for +/// its face to be picked again); without a name, among planar faces with the picked plane's +/// normal, the one nearest `at`. The picked frame moves along its normal onto it. +fn face_plane(st: &ModelState, picked: &Plane, at: Vec3, name: Option<&str>) -> Result<(Plane, Option)> { let n = picked.normal(); - // By name first: the face (or a piece of it) with that name, facing the same way. if let Some(name) = name { - // (distance from `at`, plane offset along n, what to say about how it was found) - let mut found: Option<(f64, f64, Option)> = None; - for b in st.bodies.iter().filter(|b| !b.body.is_mesh()) { - let named = crate::naming::faces_with_stem(b, name); - if named.is_empty() { - continue; - } - let tol = (b.body.size() * 1e-3).max(1e-3); - let Ok(faces) = b.body.faces(tol) else { continue }; - for f in faces { - let hit = named.contains(&f.index); - if let (true, Some(fnrm)) = (hit, f.plane_normal) - && fnrm.dot(n) > 1.0 - 1e-6 - { - let d = f.centroid.dist(at); - if found.as_ref().is_none_or(|x| d < x.0) { - // A name saved before format 14 is found as it was then, without a note. - let note = if crate::naming::legacy_name(name).is_some() { - None - } else if !crate::naming::face_has_name(b, f.index, name) { - Some(format!("face `{name}` was split; using the piece nearest the picked point")) - } else if !crate::naming::face_name_exact(b, f.index) && (f.centroid - at).dot(n).abs() > tol { - // Named from geometry and moved off the picked plane: geometry alone decided. - Some(format!("face `{name}` was found by geometry, not exact history; check it")) - } else { - None - }; - found = Some((d, f.centroid.dot(n), note)); - } - } - } + let hit = crate::naming::locate_face(st, name, at).ok_or_else(|| DocError::reselect(name))?; + let b = st.bodies.get(hit.body).ok_or_else(|| DocError::reselect(name))?; + let tol = (b.body.size() * 1e-3).max(1e-3); + let face = b.body.faces(tol)?.into_iter().find(|f| f.index == hit.face).ok_or_else(|| DocError::reselect(name))?; + if !face.plane_normal.is_some_and(|fnrm| fnrm.dot(n) > 1.0 - 1e-6) { + return Err(DocError::reselect(name)); } - if let Some((_, off, note)) = found { - return (picked.offset(off - picked.origin.dot(n)), note); - } - let (pl, w) = face_plane(st, picked, at, None); - let note = format!( - "the face `{name}` the sketch was on no longer exists; {}", - if w.is_some() { "the sketch stays where it was" } else { "using the face at the picked point" } - ); - return (pl, Some(note)); + // A name saved before format 14 is found as it was then, without a note. + let note = if crate::naming::legacy_name(name).is_none() + && !crate::naming::face_name_exact(b, hit.face) + && (face.centroid - at).dot(n).abs() > tol + { + // Named from geometry and moved off the picked plane: geometry alone decided. + Some(format!("face `{name}` was found by geometry, not exact history; check it")) + } else { + None + }; + return Ok((picked.offset(face.centroid.dot(n) - picked.origin.dot(n)), note)); } let mut best: Option<(f64, f64)> = None; // (distance from `at`, plane offset along n) for b in &st.bodies { @@ -6349,13 +6311,13 @@ fn face_plane(st: &ModelState, picked: &Plane, at: Vec3, name: Option<&str>) -> } } } - match best { + Ok(match best { Some((_, off)) => { let shift = off - picked.origin.dot(n); (picked.offset(shift), None) } None => (*picked, Some("the face the sketch was on is gone; the sketch stays where it was".into())), - } + }) } /// A chamfer, equal or by its second distance or angle. @@ -6449,7 +6411,7 @@ fn eval_feature( (None, plane) if crate::sheet::plane_sheet_face(plane).is_some() => { (doc.resolve_plane_in(vals, &sheet_face_plane_in_frame(doc, st, f.component, plane)?, 0, Some(&fst))?, None) } - (None, PlaneRef::Face { plane: picked, at, name, anchor: None }) => face_plane(&fst, picked, *at, name.as_deref()), + (None, PlaneRef::Face { plane: picked, at, name, anchor: None }) => face_plane(&fst, picked, *at, name.as_deref())?, (None, other) => (doc.resolve_plane_in(vals, other, 0, Some(&fst))?, None), }; let mut sk = sketch.clone(); @@ -6457,8 +6419,8 @@ fn eval_feature( // ones its expressions give come first. doc.apply_text_values(vals, &mut sk)?; let mut warns = match anchor { - Some(anchor) => crate::project::refresh_face_anchor_links(doc, vals, &fst, &plane, &mut sk, anchor), - None => crate::project::refresh_links(doc, vals, &fst, &plane, &mut sk), + Some(anchor) => crate::project::refresh_face_anchor_links(doc, vals, &fst, &plane, &mut sk, anchor)?, + None => crate::project::refresh_links(doc, vals, &fst, &plane, &mut sk)?, }; drop(fst); sk.refresh_offsets()?; @@ -8156,7 +8118,7 @@ mod named_face_lookup_tests { assert!(b.mesh.get().is_none(), "{} was meshed", b.name); } let h = hit.unwrap(); - assert_eq!((h.body, h.split, h.merged), (7, false, false)); + assert_eq!(h.body, 7); assert_eq!(found(hit), found(crate::naming::locate_face(&st, &name, top))); // Looking over every body names (and so meshes) them all. assert!(st.bodies.iter().all(|b| b.mesh.get().is_some())); @@ -8177,12 +8139,12 @@ mod named_face_lookup_tests { } } let moved = crate::name_lookup::locate_face_on_body(&st, Some("Part1"), &name, top).unwrap(); - assert_eq!((moved.body, moved.split), (2, false)); + assert_eq!(moved.body, 2); } /// A copy of a body has its source's face names. Over every body the name finds the face on - /// both, and the one nearest the point is taken as a piece of a split face. A feature on the - /// copy takes the copy's face, whole. + /// both, and takes the one the point lies on; a point on neither finds no face (it is never + /// told apart by the nearest). A feature on the copy takes the copy's face. #[test] fn the_same_face_on_a_copy_is_not_a_piece_of_the_named_bodys_face() { let mut st = parts(2); @@ -8194,7 +8156,8 @@ mod named_face_lookup_tests { let on_copy = crate::name_lookup::locate_face_on_body(&st, Some("Part1"), &name, top).unwrap(); let everywhere = crate::naming::locate_face(&st, &name, top).unwrap(); assert_eq!((on_copy.body, on_copy.face, on_copy.point), (everywhere.body, everywhere.face, everywhere.point)); - assert_eq!((on_copy.split, everywhere.split), (false, true)); assert_eq!(on_copy.note(&name), None); + assert!(crate::naming::locate_face(&st, &name, Vec3::new(15.0, 5.0, 30.0)).is_none()); + assert_eq!(crate::name_lookup::locate_face_on_body(&st, Some("Part1"), &name, Vec3::new(15.0, 5.0, 30.0)).map(|hit| hit.body), Some(1)); } } diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rs index 377bb8443..5cb0e12c5 100644 --- a/crates/doc/src/eval_more.rs +++ b/crates/doc/src/eval_more.rs @@ -44,17 +44,8 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap, f: &Feature, { let mut scoped = ModelState::default(); scoped.bodies.push(mb.clone()); - let (picked, split) = crate::naming::point_on_face(&scoped, name, at) - .ok_or_else(|| DocError::Invalid("selected cylinder face no longer exists".into()))?; - if split { - return Err(DocError::Invalid("selected cylinder face was split".into())); - } - let (index, _, _) = crate::project::nearest_face(&mb.mesh(), picked) - .ok_or_else(|| DocError::Invalid("selected cylinder face cannot be resolved".into()))?; - if !crate::naming::face_has_name(&mb, index as usize, name) { - return Err(DocError::Invalid("selected cylinder face is ambiguous".into())); - } - at = kernel::cylinder_emboss_anchor(&mb.body, index as usize, picked)?; + let hit = crate::name_lookup::locate_face(&scoped, name, at).ok_or_else(|| DocError::reselect(name.as_str()))?; + at = kernel::cylinder_emboss_anchor(&mb.body, hit.face, hit.point)?; } let result = kernel::emboss_cylinder_at(&mb.body, at, &plane, ®ions, if *deboss { -d } else { d })?; if let Some(slot) = st.bodies.get_mut(i) { @@ -759,21 +750,19 @@ pub(super) fn sheet_eval( let mb = st.body(body).cloned().ok_or_else(|| DocError::Unknown(format!("body `{body}`")))?; let r = doc.sheet_rule(rule.as_deref()); let values = |t: Option| doc.rule_values_at(vals, &r, t); - // The bend edges by name first; a name that is gone keeps its point, with a warning. + // The bend edges by name where they have one: a name that no longer finds its edge + // fails the conversion, asking for the edge to be picked again. let mut picks = Vec::with_capacity(bends.len()); for (i, p) in bends.iter().enumerate() { let name = f.edge_names.get(i).filter(|n| !n.is_empty()); - picks.push(match name.map(|n| (n, crate::naming::locate_edge(&mb, n, p.0))) { - Some((n, Ok(hit))) => { + picks.push(match name { + Some(n) => { + let hit = crate::naming::locate_edge(&mb, n, p.0).map_err(|_| DocError::reselect(n.as_str()))?; if let Some(note) = hit.note(n) { append_warning(warning, note); } hit.point } - Some((n, Err(_))) => { - append_warning(warning, format!("edge `{n}` no longer exists; using the edge at the picked point")); - p.0 - } None => p.0, }); } diff --git a/crates/doc/src/history_names.rs b/crates/doc/src/history_names.rs index f37d6ecce..1bd4f8605 100644 --- a/crates/doc/src/history_names.rs +++ b/crates/doc/src/history_names.rs @@ -12,9 +12,10 @@ //! piece of `F2:top` bounded by the block's left wall and the slot's left wall. Pieces nothing //! around them tells apart are numbered (`#1`, `#2`): in the order of what they came from when //! that differs (exact), else in the kernel's order (unverified). A face made of several (a -//! coplanar join) takes one name and keeps the others as aliases, the faces merged into it. A -//! face a feature built from several of its own roles (a side drawn in collinear pieces) has each -//! of them as a name (synonyms): each names that very face. +//! coplanar join) takes one name and keeps the others as aliases: a reference to one of them is +//! to a face that is no longer as it was picked, and finds nothing. A face a feature built from +//! several of its own roles (a side drawn in collinear pieces) has each of them as a name +//! (synonyms): each names that very face. //! //! A piece that is split again keeps the face's stem and the bounds that told the piece it //! came from apart: its name lists the faces around it, not the qualifiers of the pieces @@ -40,8 +41,8 @@ pub struct Names { /// What a face answers to besides its name, and how sure its name is. #[derive(Clone, Debug, Default)] pub(crate) struct FaceInfo { - /// Names of the other faces merged into it (a reference to one of them finds this face, as - /// the face it was merged into). + /// Names of the other faces merged into it. A reference to one of them is to a face that is + /// not this one as it was picked: a feature's reference by one finds nothing (`name_lookup`). pub aliases: Vec, /// Other names of this very face: the roles besides its first of a face the feature that /// built it made from several (a side drawn in collinear pieces is one face, made by each). diff --git a/crates/doc/src/hole_reference.rs b/crates/doc/src/hole_reference.rs index 187a1971f..7dc682888 100644 --- a/crates/doc/src/hole_reference.rs +++ b/crates/doc/src/hole_reference.rs @@ -167,12 +167,16 @@ fn to_polyline(p: Vec3, e: &[Vec3]) -> f64 { e.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min) } -/// Reference edge `k` (its ends, and its index in the mesh), found by `name`, else by the edge -/// nearest `p`: one that runs through `p` for a fresh pick, within a quarter of the body for a -/// stored one. It must be straight. +/// Reference edge `k` (its ends, and its index in the mesh), found by `name` (a name that finds +/// no edge fails, asking for the edge to be picked again), else by the edge nearest `p`: one +/// that runs through `p` for a fresh pick, within a quarter of the body for a stored one. It +/// must be straight. fn find_edge(b: &ModelBody, m: &Mesh, k: usize, p: Vec3, name: Option<&str>, exact: bool) -> Result<(Vec3, Vec3, usize)> { let size = b.body.size().max(1e-9); - let by_name = name.filter(|n| !n.is_empty()).and_then(|n| crate::naming::locate_edge(b, n, p).ok()).map(|hit| hit.edge); + let by_name = match name.filter(|n| !n.is_empty()) { + Some(n) => Some(crate::naming::locate_edge(b, n, p).map_err(|_| DocError::reselect(n))?.edge), + None => None, + }; let i = match by_name { Some(i) => i, None => { diff --git a/crates/doc/src/joints_cam.rs b/crates/doc/src/joints_cam.rs index 8b1be1c6d..79c45141e 100644 --- a/crates/doc/src/joints_cam.rs +++ b/crates/doc/src/joints_cam.rs @@ -341,7 +341,7 @@ fn profile_points(doc: &Document, st: &ModelState, p: &CamProfile, cam: &super:: let (body, p) = bodies .iter() .enumerate() - .find_map(|(i, b)| crate::naming::find_edge(b, name, *pick).ok().map(|(p, _)| (i, p))) + .find_map(|(i, b)| crate::naming::find_edge(b, name, *pick).ok().map(|p| (i, p))) .ok_or_else(|| bad(&format!("the edge `{name}` no longer exists (edit the cam to pick again)")))?; (on, at) = (Some(body), p); } diff --git a/crates/doc/src/joints_edge.rs b/crates/doc/src/joints_edge.rs index afa006976..c2fd1ed7a 100644 --- a/crates/doc/src/joints_edge.rs +++ b/crates/doc/src/joints_edge.rs @@ -54,7 +54,7 @@ fn face_of(b: &ModelBody, i: usize, name: Option<&str>, pick: Vec3) -> Result<(u let planar = |f: usize| infos.iter().find(|x| x.index == f).and_then(|x| x.plane_normal.map(|n| (x.index, n, x.centroid, x.area))); let chosen = match name { Some(n) => { - let (f, _, _) = crate::naming::face_on_body(b, n, pick) + let (f, _) = crate::naming::face_on_body(b, n, pick) .ok_or_else(|| DocError::Invalid(format!("joint origin: the face `{n}` no longer exists (edit the joint to pick again)")))?; if !beside.contains(&f) { return Err(DocError::Invalid(format!("joint origin: the face `{n}` no longer meets its edge (edit the joint to pick again)"))); @@ -190,7 +190,7 @@ pub fn edge_snap(doc: &Document, st: &ModelState, comp: u64, pick: Vec3, on: Opt Some(p) => { let f = crate::naming::face_name_at_body(b, p) .and_then(|n| crate::naming::face_on_body(b, &n, p)) - .map(|(f, _, _)| f) + .map(|(f, _)| f) .ok_or_else(|| DocError::Invalid("joint origin: `on` is not on a face of that body".into()))?; if !beside.contains(&f) { return Err(DocError::Invalid("joint origin: `on` picks a face the edge doesn't bound".into())); diff --git a/crates/doc/src/joints_face.rs b/crates/doc/src/joints_face.rs index 18da16b76..91b5b0d1c 100644 --- a/crates/doc/src/joints_face.rs +++ b/crates/doc/src/joints_face.rs @@ -32,17 +32,16 @@ fn gone(name: &str) -> DocError { /// The face called `name` on the bodies of `component` nearest `pick` (an error when it is gone: /// a joint must not quietly attach elsewhere). Each body is looked at in its own coordinates, and -/// a face the name finds exactly comes before a piece of it or a face it was merged into. Only the -/// component's own bodies: the parts of one STEP import share their face names, and another +/// the nearest of the faces the name finds is taken. Only the component's own bodies: the parts of one STEP import share their face names, and another /// part's face of that name can lie nearer the pick than this part's own. pub(super) fn named_face<'a>(doc: &Document, st: &'a ModelState, component: u64, pick: Vec3, name: &str) -> Result> { let own = component_bodies(doc, st, component).into_iter().filter_map(|body| { let offset = doc.model_body_offset(body).copied().unwrap_or(IDENTITY); - let (face, at, inexact) = crate::naming::face_on_body(body, name, apply_point(&mat_inverse(&offset)?, pick))?; + let (face, at) = crate::naming::face_on_body(body, name, apply_point(&mat_inverse(&offset)?, pick))?; let point = apply_point(&offset, at); - Some(((inexact, point.dist(pick)), NamedFace { body, face, point, offset })) + Some((point.dist(pick), NamedFace { body, face, point, offset })) }); - if let Some((_, nf)) = own.min_by(|(a, _), (b, _)| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1))) { + if let Some((_, nf)) = own.min_by(|(a, _), (b, _)| a.total_cmp(b)) { return Ok(nf); } // On none of them (the face's body has gone to another component since): wherever the name @@ -53,7 +52,7 @@ pub(super) fn named_face<'a>(doc: &Document, st: &'a ModelState, component: u64, return Ok(NamedFace { body, face: hit.face, point: hit.point, offset: IDENTITY }); }; let inv = mat_inverse(&offset).ok_or_else(|| gone(name))?; - let (face, at, _) = crate::naming::face_on_body(body, name, apply_point(&inv, pick)).ok_or_else(|| gone(name))?; + let (face, at) = crate::naming::face_on_body(body, name, apply_point(&inv, pick)).ok_or_else(|| gone(name))?; Ok(NamedFace { body, face, point: apply_point(&offset, at), offset }) } diff --git a/crates/doc/src/name_lookup.rs b/crates/doc/src/name_lookup.rs index fada5873e..72b38d52f 100644 --- a/crates/doc/src/name_lookup.rs +++ b/crates/doc/src/name_lookup.rs @@ -1,12 +1,15 @@ //! Finding a face or edge again by the name a feature stored for it. //! -//! The face with that name is the face; else the one face answering to it (a face merged into -//! it, or the named piece told apart by the faces around it, which still bound it); else, when -//! several faces are pieces of the named one, the piece nearest the reference's point, and the -//! feature says the face was split. Names saved before format 14 ([`LEGACY_MARK`]) are found -//! among the names geometry gives, as the builds that saved them found them. A face whose name -//! was worked out from geometry, found where the reference's point no longer lies, is reported: -//! only geometry decided. +//! The face with that name is the face (a face its feature made from several of its roles, a +//! side drawn in collinear pieces, has each as a name); else the one face answering to it as +//! exactly: the named piece told apart by the faces around it, which still bound it. Nothing +//! else is: when the named face was split into several pieces, when it was merged into another +//! face, when only a face of the same stem is left, or when the name is on several bodies, the +//! name finds nothing and the feature that uses it fails, asking for the reference to be picked +//! again ([`crate::DocError::Reselect`]). Names saved before format 14 ([`LEGACY_MARK`]) are +//! found among the names geometry gives, as the builds that saved them found them. A face whose +//! name was worked out from geometry, found where the reference's point no longer lies, is +//! reported: only geometry decided. use solidcraft_geom::{Mesh, Vec3}; @@ -34,8 +37,6 @@ pub struct EdgeHit { pub edge: usize, /// A point on the edge: the reference's own point when it lies on it, else the edge's middle. pub point: Vec3, - /// The named edge is not one edge any more: the piece nearest the point was taken. - pub split: bool, /// Whether the names of the faces it separates follow exact history (and the edge is not /// one of several between them, numbered by where they lie). pub verified: bool, @@ -46,8 +47,8 @@ pub struct EdgeHit { } /// The edge of a body a stored edge name finds: the edge with that name; else the one edge -/// between the faces it names (followed through splits and merges of those faces); else the -/// piece of it nearest `near` (`split`). `Err` explains when there is none. +/// between the faces it names exactly (see [`exactly`]). `Err` explains when there is none: no +/// such edge, or the named edge split into several. pub fn locate_edge(b: &ModelBody, name: &str, near: Vec3) -> Result { if let Some(old) = legacy_name(name) { return legacy_locate_edge(b, old, near).map_err(|_| format!("edge `{name}` no longer exists")); @@ -64,7 +65,7 @@ pub fn locate_edge(b: &ModelBody, name: &str, near: Vec3) -> Result Result { let on = edge_near(b, &m, i, near); mid(i) - .map(|p| EdgeHit { edge: i, point: if on { near } else { p }, split: false, verified: verified(i), on_point: on, legacy: false }) + .map(|p| EdgeHit { edge: i, point: if on { near } else { p }, verified: verified(i), on_point: on, legacy: false }) .ok_or_else(|| "edge".into()) }; if let Some(i) = names.iter().position(|n| n == name) { @@ -75,19 +76,22 @@ pub fn locate_edge(b: &ModelBody, name: &str, near: Vec3) -> Result)> = None; for (i, fs) in m.edge_faces.iter().enumerate() { let [fa, fb] = fs.as_slice() else { continue }; - let Some(level) = edge_match(&faces, *fa as usize, *fb as usize, wanted) else { continue }; + let Some(level) = edge_match(&faces, *fa as usize, *fb as usize, wanted).filter(|level| exactly(*level)) else { continue }; keep_best(&mut best, level, i); } - let (level, cands) = best.ok_or_else(|| format!("edge `{name}` no longer exists"))?; - if let ([i], true) = (cands.as_slice(), level >= Match::Piece) { - return exact(*i); + let (_, cands) = best.ok_or_else(|| format!("edge `{name}` no longer exists"))?; + match cands.as_slice() { + [i] => exact(*i), + _ => Err(format!("edge `{name}` is no longer one edge")), } - cands - .iter() - .filter_map(|i| mid(*i).map(|p| (p, *i))) - .min_by(|a, b| a.0.dist(near).total_cmp(&b.0.dist(near))) - .map(|(p, i)| EdgeHit { edge: i, point: p, split: true, verified: verified(i), on_point: false, legacy: false }) - .ok_or_else(|| format!("edge `{name}` no longer exists")) +} + +/// Whether a face found at `level` is exactly the face a name named: the very name (or another +/// name of that very face: a face its feature made from several roles has each), or the named +/// piece told apart by the faces around it. A face the named one was merged into, or a face of +/// the same stem, is not. +fn exactly(level: Match) -> bool { + matches!(level, Match::Exact | Match::Piece) } /// Whether the picked point `near` lies on edge `i` of body `b` (whose mesh is `m`): then a @@ -138,16 +142,14 @@ fn legacy_locate_edge(b: &ModelBody, name: &str, near: Vec3) -> Result Option { - if self.split { - Some(format!("face `{name}` was split; using the piece nearest the picked point")) - } else if self.merged { - Some(format!("face `{name}` was merged into another face; using that face")) - } else if !self.verified && !self.on_point && !self.legacy { + if !self.verified && !self.on_point && !self.legacy { Some(format!("face `{name}` was found by geometry, not exact history; check it")) } else { None @@ -316,9 +320,7 @@ fn inside_nearest(m: &Mesh, face: usize, p: Vec3, margin: f64) -> Option { impl EdgeHit { /// What a feature says about how it found an edge by its stored name `name` (`None`: exactly). pub fn note(&self, name: &str) -> Option { - if self.split { - Some(format!("edge `{name}` was split; using the piece nearest the picked point")) - } else if !self.verified && !self.on_point && !self.legacy { + if !self.verified && !self.on_point && !self.legacy { Some(format!("edge `{name}` was found by geometry, not exact history; check it")) } else { None @@ -326,103 +328,100 @@ impl EdgeHit { } } -/// The face a stored face name finds, on any body: the face with that name, or the one face -/// answering to it (merged into it, or the named piece told apart by the faces around it); else -/// the piece of it nearest `p` (`split`). +/// The face a stored face name finds, on any body: the face with that name, or the named piece +/// told apart by the faces around it. `None` when no face does, or several do. pub fn locate_face(st: &ModelState, name: &str, p: Vec3) -> Option { if crate::sheet::split_sheet_face_name(name).is_some() { - return sheet_locate(st, name, p); + return sheet_locate(st, name, p).ok(); } // Every body's names are read below: work out the ones not known yet on all cores first // (each body's names are its own, whichever thread works them out). if legacy_name(name).is_none() { naming::warm_names(st.bodies.iter().filter(|b| !b.body.is_mesh())); } - locate_in(st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh()), name, p) + locate_in(st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh()), name, p).ok() } /// [`locate_face`] for a feature that works on the faces of the body called `body` (a shell, a -/// draft…): the one face of that body with the very name, found without working out the names -/// of every other body (a body named from geometry is meshed for it: seconds in a large model). -/// Else as [`locate_face`], over every body: the name moved to another body (a combine took the -/// face), or on this body it names a piece of a split face or a merged one. The same face on -/// another body (a copy of this one) is not a piece of this body's face. +/// draft…): the face of that body the name finds, found without working out the names of every +/// other body (a body named from geometry is meshed for it: seconds in a large model). When +/// that body has no such face, as [`locate_face`] over every body: the name moved to another +/// body (a combine took the face). The same face on another body (a copy of this one) does not +/// make this body's face ambiguous. pub fn locate_face_on_body(st: &ModelState, body: Option<&str>, name: &str, p: Vec3) -> Option { - if crate::sheet::split_sheet_face_name(name).is_some() { - return sheet_locate(st, name, p); + if crate::sheet::split_sheet_face_name(name).is_some() || legacy_name(name).is_some() { + return locate_face(st, name, p); } - if legacy_name(name).is_none() - && let Some(i) = body.and_then(|n| st.bodies.iter().position(|b| b.name == n)) + if let Some(i) = body.and_then(|n| st.bodies.iter().position(|b| b.name == n)) && let Some(b) = st.bodies.get(i).filter(|b| !b.body.is_mesh()) - && let Some(hit) = locate_in(std::iter::once((i, b)), name, p) - && !hit.split - && naming::names(b).faces.get(hit.face).is_some_and(|n| n == name) { - return Some(hit); + match locate_in(std::iter::once((i, b)), name, p) { + Ok(hit) => return Some(hit), + Err(Miss::Several) => return None, + Err(Miss::Gone) => {} + } } locate_face(st, name, p) } /// [`locate_face`] for a sheet face's readable name (`sheet:::`, see -/// [`crate::sheet::body_sheet_face_names`]): the face of that body the sheet names so, else the -/// piece of it nearest `p` (`split`). The sheet itself says which face it is, so the name holds -/// however the faces of the body are numbered. -fn sheet_locate(st: &ModelState, name: &str, p: Vec3) -> Option { - let (body, _) = crate::sheet::split_sheet_face_name(name)?; - let (bi, b) = st.bodies.iter().enumerate().find(|(_, b)| b.name == body && !b.body.is_mesh())?; +/// [`crate::sheet::body_sheet_face_names`]): the face of that body the sheet names so. The sheet +/// itself says which face it is, so the name holds however the faces of the body are numbered. +fn sheet_locate(st: &ModelState, name: &str, p: Vec3) -> Result { + let (body, _) = crate::sheet::split_sheet_face_name(name).ok_or(Miss::Gone)?; + let (bi, b) = st.bodies.iter().enumerate().find(|(_, b)| b.name == body && !b.body.is_mesh()).ok_or(Miss::Gone)?; let names = crate::sheet::body_sheet_face_names(st, b); let faces: Vec = names.iter().enumerate().filter(|(_, n)| n.as_deref() == Some(name)).map(|(i, _)| i).collect(); - let m = b.mesh(); - let (distance, face, point) = - faces.iter().filter_map(|f| nearest_on_face(&m, *f, p).map(|(d, q)| (d, *f, q))).min_by(|a, c| a.0.total_cmp(&c.0))?; - Some(FaceHit { - body: bi, - face, - point, - split: faces.len() > 1, - merged: false, - verified: true, - on_point: distance <= (b.body.size() * 1e-3).max(1e-3), - legacy: false, - }) + let face = match faces.as_slice() { + [face] => *face, + [] => return Err(Miss::Gone), + _ => return Err(Miss::Several), + }; + let (distance, point) = nearest_on_face(&b.mesh(), face, p).ok_or(Miss::Gone)?; + Ok(FaceHit { body: bi, face, point, verified: true, on_point: distance <= (b.body.size() * 1e-3).max(1e-3), legacy: false }) } -/// [`locate_face`] among `bodies` (with their indices). -fn locate_in<'a>(bodies: impl Iterator, name: &str, p: Vec3) -> Option { +/// [`locate_face`] among `bodies` (with their indices): the one face the name finds there. +fn locate_in<'a>(bodies: impl Iterator, name: &str, p: Vec3) -> Result { if let Some(old) = legacy_name(name) { - return legacy_locate(bodies, old, p); + return legacy_locate(bodies, old, p).ok_or(Miss::Gone); } let mut best: Option<(Match, Vec<(usize, &ModelBody, usize)>)> = None; for (bi, b) in bodies { let names = naming::names(b); for face in 0..names.faces.len() { - if let Some(level) = crate::history_names::matches(&names, face, name) { + if let Some(level) = crate::history_names::matches(&names, face, name).filter(|level| exactly(*level)) { keep_best(&mut best, level, (bi, b, face)); } } } - let (level, faces) = best?; - let unique = faces.len() == 1 && level >= Match::Piece; - let mut nearest: Option<(f64, usize, &ModelBody, usize, Vec3)> = None; - for (bi, b, face) in faces { - if let Some((d, q)) = nearest_on_face(&b.mesh(), face, p) - && nearest.as_ref().is_none_or(|n| d < n.0) - { - nearest = Some((d, bi, b, face, q)); - } + let (level, faces) = best.ok_or(Miss::Gone)?; + let found = |(body, b, face): (usize, &ModelBody, usize)| { + let (distance, point) = nearest_on_face(&b.mesh(), face, p)?; + Some(FaceHit { + body, + face, + point, + verified: naming::names(b).verified(face), + on_point: distance <= (b.body.size() * 1e-3).max(1e-3), + legacy: false, + }) + }; + if let [one] = faces.as_slice() { + return found(*one).ok_or(Miss::Gone); + } + // The very face on several bodies (a body and its copies, whose faces keep their names): the + // one the reference's point lies on. Pieces of one face are never told apart by a point. + let mut bodies: Vec = faces.iter().map(|(bi, _, _)| *bi).collect(); + bodies.dedup(); + if level != Match::Exact || bodies.len() < faces.len() { + return Err(Miss::Several); + } + let mut on = faces.into_iter().filter_map(found).filter(|hit| hit.on_point); + match (on.next(), on.next()) { + (Some(hit), None) => Ok(hit), + _ => Err(Miss::Several), } - let (distance, body, b, face, point) = nearest?; - let on_point = distance <= (b.body.size() * 1e-3).max(1e-3); - Some(FaceHit { - body, - face, - point, - split: !unique, - merged: level == Match::Alias, - verified: naming::names(b).verified(face), - on_point, - legacy: false, - }) } /// [`locate_face`] for a name saved before format 14 (without its mark), as those builds found @@ -430,7 +429,7 @@ fn locate_in<'a>(bodies: impl Iterator, name: &st /// nearer `p`), the nearest point on it. fn legacy_locate<'a>(bodies: impl Iterator, name: &str, p: Vec3) -> Option { let stem = strip_piece(name); - let mut best: Option<(f64, usize, usize, Vec3, bool, f64)> = None; + let mut best: Option<(f64, usize, usize, Vec3, f64)> = None; for (bi, b) in bodies { let names = legacy_face_names(b); let tol = (b.body.size() * 1e-3).max(1e-3); @@ -445,28 +444,19 @@ fn legacy_locate<'a>(bodies: impl Iterator, name: let q = closest(p, a, bb, c); let d = q.dist(p) - if exact { 1e-9 } else { 0.0 }; if d.is_finite() && best.is_none_or(|x| d < x.0) { - best = Some((d, bi, *f as usize, q, !exact, tol)); + best = Some((d, bi, *f as usize, q, tol)); } } } - best.map(|(d, body, face, point, split, tol)| FaceHit { - body, - face, - point, - split, - merged: false, - verified: false, - on_point: d <= tol, - legacy: true, - }) + best.map(|(d, body, face, point, tol)| FaceHit { body, face, point, verified: false, on_point: d <= tol, legacy: true }) } -/// Whether face `index` of a body is the face a stored name names: that name (or one merged into -/// it); for a name saved before format 14, that name among the names those builds gave. +/// Whether face `index` of a body is exactly the face a stored name names (see [`exactly`]); for +/// a name saved before format 14, that name among the names those builds gave. pub fn face_has_name(b: &ModelBody, index: usize, name: &str) -> bool { match legacy_name(name) { Some(old) => legacy_face_names(b).get(index).is_some_and(|n| n == old), - None => crate::history_names::matches(&naming::names(b), index, name).is_some_and(|m| m >= Match::Alias), + None => crate::history_names::matches(&naming::names(b), index, name).is_some_and(exactly), } } @@ -487,7 +477,7 @@ pub fn faces_with_stem(b: &ModelBody, name: &str) -> Vec { /// [`locate_face`] on one body. pub(crate) fn locate_on(body: &ModelBody, name: &str, p: Vec3) -> Option { - locate_in(std::iter::once((0, body)), name, p) + locate_in(std::iter::once((0, body)), name, p).ok() } /// The one face a name `model.faces` lists finds, on the body called `body` or, without one, on @@ -504,11 +494,10 @@ pub fn locate_one(st: &ModelState, body: Option<&str>, name: &str) -> Result format!("no face is named `{name}` (`model.faces` lists the names)"), + Miss::Several => format!("`{name}` names more than one face (pieces of a split face): give the name of one piece"), + }); } let bodies: Vec<(usize, &ModelBody)> = st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh() && body.is_none_or(|n| b.name == n)).collect(); @@ -516,11 +505,10 @@ pub fn locate_one(st: &ModelState, body: Option<&str>, name: &str) -> Result 1 && legacy_name(name).is_none() { naming::warm_names(bodies.iter().map(|(_, b)| *b)); } - let hit = locate_in(bodies.into_iter(), name, Vec3::ZERO).ok_or_else(|| format!("no face is named `{name}` (`model.faces` lists the names)"))?; - if hit.split { - return Err(format!( - "`{name}` names more than one face (pieces of a split face, or faces of several bodies): give `body`, or the name of one piece" - )); - } - Ok(hit) + locate_in(bodies.into_iter(), name, Vec3::ZERO).map_err(|miss| match miss { + Miss::Gone => format!("no face is named `{name}` (`model.faces` lists the names)"), + Miss::Several => { + format!("`{name}` names more than one face (pieces of a split face, or faces of several bodies): give `body`, or the name of one piece") + } + }) } diff --git a/crates/doc/src/named_projection_tests.rs b/crates/doc/src/named_projection_tests.rs index 4adae985d..f2de76196 100644 --- a/crates/doc/src/named_projection_tests.rs +++ b/crates/doc/src/named_projection_tests.rs @@ -28,7 +28,7 @@ fn named_manual_projection_keeps_its_body_and_face_at_shared_boundaries() { sketch.links[0].source = LinkSource::Face { body: "Source".into(), at: Vec3::new(0., 0., 10.) }; let mut current = ModelState::default(); current.bodies.extend([named_box("Source", 20., 20.), named_box("Control", 5., 10.)]); - assert!(crate::project::refresh_links(&doc, &BTreeMap::new(), ¤t, &plane, &mut sketch).is_empty()); + assert!(crate::project::refresh_links(&doc, &BTreeMap::new(), ¤t, &plane, &mut sketch).unwrap().is_empty()); assert!(!sketch.links[0].lost); assert!(sketch.points.iter().any(|point| point.pos.x > 19.)); assert!(sketch.points.iter().any(|point| point.pos.y > 19.)); @@ -40,9 +40,9 @@ fn named_manual_projection_keeps_its_body_and_face_at_shared_boundaries() { let saved = sketch.clone(); let mut missing = ModelState::default(); missing.bodies.push(named_box("Control", 5., 10.)); - let warnings = crate::project::refresh_links(&doc, &BTreeMap::new(), &missing, &plane, &mut sketch); - assert!(sketch.links[0].lost); - assert!(!warnings.is_empty()); + // Its body gone, the named face finds nothing: the sketch fails, asking for it again. + let error = crate::project::refresh_links(&doc, &BTreeMap::new(), &missing, &plane, &mut sketch).unwrap_err(); + assert!(matches!(&error, crate::DocError::Reselect { reference, .. } if reference == "shared:top"), "{error}"); assert_eq!(sketch.curves, saved.curves); assert_eq!(sketch.points, saved.points); assert_eq!(sketch.links[0].id, link); diff --git a/crates/doc/src/naming.rs b/crates/doc/src/naming.rs index b28dc5633..44faad240 100644 --- a/crates/doc/src/naming.rs +++ b/crates/doc/src/naming.rs @@ -939,10 +939,10 @@ fn edge_names_from(b: &ModelBody, faces: &[String]) -> Vec { names } -/// The edge of a body with this name: exact, else the pieces of the same edge nearest `near` -/// (`Err` explains when there is none). -pub fn find_edge(b: &ModelBody, name: &str, near: Vec3) -> Result<(Vec3, bool), String> { - locate_edge(b, name, near).map(|hit| (hit.point, hit.split)) +/// A point on the edge of a body this name finds (see [`locate_edge`]; `Err` explains when there +/// is none). +pub fn find_edge(b: &ModelBody, name: &str, near: Vec3) -> Result { + locate_edge(b, name, near).map(|hit| hit.point) } /// Names of the edges nearest each point on a body (for storing references). @@ -1100,21 +1100,20 @@ pub fn named_face_point(st: &ModelState, body: Option<&str>, name: &str) -> Resu face_spot(b, hit.face).map(|spot| spot.point).ok_or_else(|| format!("face `{name}` has no surface to pick")) } -/// The point on the face with this name nearest `p` (a split face: its nearest piece, with -/// `true` for "not exactly that face": split, or merged into another); `None` when no face has -/// the name. -pub fn point_on_face(st: &ModelState, name: &str, p: Vec3) -> Option<(Vec3, bool)> { - locate_face(st, name, p).map(|hit| (hit.point, hit.split || hit.merged)) +/// The point on the face this name finds nearest `p`; `None` when the name finds no face (see +/// [`locate_face`]). +pub fn point_on_face(st: &ModelState, name: &str, p: Vec3) -> Option { + locate_face(st, name, p).map(|hit| hit.point) } /// Resolve a legacy named face only on its recorded source body. Return the /// selected face index as well as the closest point, which may lie on a shared /// edge and therefore must not be used to pick the face a second time. -pub fn face_on_body(body: &ModelBody, name: &str, p: Vec3) -> Option<(usize, Vec3, bool)> { +pub fn face_on_body(body: &ModelBody, name: &str, p: Vec3) -> Option<(usize, Vec3)> { if body.body.is_mesh() { return None; } - crate::name_lookup::locate_on(body, name, p).map(|hit| (hit.face, hit.point, hit.split || hit.merged)) + crate::name_lookup::locate_on(body, name, p).map(|hit| (hit.face, hit.point)) } #[cfg(test)] @@ -1140,7 +1139,7 @@ mod tests { fn same_hit(a: &FaceHit, b: &FaceHit) { assert_eq!((a.body, a.face, a.point), (b.body, b.face, b.point)); - assert_eq!((a.split, a.merged, a.verified, a.on_point, a.legacy), (b.split, b.merged, b.verified, b.on_point, b.legacy)); + assert_eq!((a.verified, a.on_point, a.legacy), (b.verified, b.on_point, b.legacy)); } #[test] diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rs index a50ff5622..e629aa024 100644 --- a/crates/doc/src/project.rs +++ b/crates/doc/src/project.rs @@ -600,20 +600,24 @@ pub fn resolved_edge_name(st: &ModelState, r: &Resolved) -> Option { crate::naming::edge_names(body).get(index).filter(|name| !name.is_empty()).cloned() } -/// Re-resolve every link of a sketch (in place). Returns warnings for lost, moved or rebuilt -/// links; lost links keep their last geometry. fn lost(reference: &str) -> DocError { DocError::Unknown(format!("{reference} no longer exists")) } /// The edge a link's stored name finds, and the body it is on: the link's body, or, when no -/// body has that name any more (it was joined into another), the body on which the name finds -/// the edge nearest the link's point. +/// body has that name any more (it was joined into another), the one body on which the name +/// finds an edge. fn locate_named_edge(st: &ModelState, body: &str, name: &str, at: Vec3) -> Option<(String, crate::naming::EdgeHit)> { let hit = |b: &crate::ModelBody| crate::naming::locate_edge(b, name, at).ok().map(|hit| (b.name.clone(), hit)); match st.body(body) { Some(b) => hit(b), - None => st.bodies.iter().filter(|b| !b.body.is_mesh()).filter_map(hit).min_by(|a, b| a.1.point.dist(at).total_cmp(&b.1.point.dist(at))), + None => { + let mut found = st.bodies.iter().filter(|b| !b.body.is_mesh()).filter_map(hit); + match (found.next(), found.next()) { + (Some(one), None) => Some(one), + _ => None, + } + } } } @@ -752,6 +756,7 @@ pub fn resolve_face_indices(st: &ModelState, plane: &Plane, kind: LinkKind, body }) } +/// [`refresh_links`] for a sketch attached to a face by `anchor`. pub fn refresh_face_anchor_links( doc: &Document, vals: &BTreeMap, @@ -759,7 +764,7 @@ pub fn refresh_face_anchor_links( plane: &Plane, sk: &mut Sketch, anchor: &crate::FaceAnchor, -) -> Vec { +) -> Result> { refresh_links_in(doc, vals, st, plane, sk, Some(anchor)) } @@ -832,7 +837,11 @@ fn merge_family_lines(geom: Vec) -> Result> { Ok(result) } -pub fn refresh_links(doc: &Document, vals: &BTreeMap, st: &ModelState, plane: &Plane, sk: &mut Sketch) -> Vec { +/// Re-resolve every link of a sketch (in place). Returns warnings for lost, moved or rebuilt +/// links; lost links keep their last geometry. A link kept by the name of a face or edge that no +/// longer finds exactly that face or edge is not lost: the sketch fails, asking for the +/// reference to be picked again ([`DocError::Reselect`]). +pub fn refresh_links(doc: &Document, vals: &BTreeMap, st: &ModelState, plane: &Plane, sk: &mut Sketch) -> Result> { refresh_links_in(doc, vals, st, plane, sk, None) } @@ -869,7 +878,7 @@ fn refresh_links_in( plane: &Plane, sk: &mut Sketch, anchor: Option<&crate::FaceAnchor>, -) -> Vec { +) -> Result> { let mut warn = Vec::new(); let links = sk.links.clone(); for l in &links { @@ -878,45 +887,18 @@ fn refresh_links_in( if !l.auto_face && let (Some(name), LinkSource::Face { body, at }) = (&l.face_name, &mut source) { - if let Some((index, p, split)) = st.body(body).and_then(|target| crate::naming::face_on_body(target, name, *at)) { - let stem = crate::naming::strip_piece(name); - let removed_piece = split - && name != stem - && st.body(body).is_some_and(|target| { - (certified_planar_construction(target, index) || target.body.face_was_coalesced(index)) - && crate::naming::face_has_name(target, index, stem) - }); - if removed_piece { - sk.set_link_lost(&l.id, true); - warn.push(format!("projected face piece `{name}` no longer exists; last geometry retained")); - continue; - } - *at = p; - named_face = Some((body.clone(), index, p)); - if split { - warn.push(format!("projected face `{name}` was split; using the nearest piece")); - } - } else { - sk.set_link_lost(&l.id, true); - warn.push(format!("projected face `{name}` no longer exists")); - continue; - } + let (index, p) = + st.body(body).and_then(|target| crate::naming::face_on_body(target, name, *at)).ok_or_else(|| DocError::reselect(name.as_str()))?; + *at = p; + named_face = Some((body.clone(), index, p)); } // An edge the link keeps by name is that edge of its body, wherever it went. When no - // edge has the name any more the link is lost: no other edge is taken for it. + // edge has the name any more no other edge is taken for it: the sketch fails. let mut named_edge = None; if let (Some(name), LinkSource::Edge { body, at }) = (&l.edge_name, &source) { - match locate_named_edge(st, body, name, *at) { - Some((body, hit)) => { - warn.extend(hit.note(name).map(|note| format!("projected {note}"))); - named_edge = Some((body, hit.edge, *at)); - } - None => { - sk.set_link_lost(&l.id, true); - warn.push(format!("projected reference lost: edge `{name}` no longer exists; last geometry retained")); - continue; - } - } + let (body, hit) = locate_named_edge(st, body, name, *at).ok_or_else(|| DocError::reselect(name.as_str()))?; + warn.extend(hit.note(name).map(|note| format!("projected {note}"))); + named_edge = Some((body, hit.edge, *at)); } let resolved = if matches!(source, LinkSource::Text { .. }) { // A text needs nothing outside its sketch; one on a path follows a curve of it. @@ -974,7 +956,7 @@ fn refresh_links_in( } } } - warn + Ok(warn) } // --------------------------------------------------------------------------------------------- diff --git a/crates/engine/src/boolean_regression_tests.rs b/crates/engine/src/boolean_regression_tests.rs index 8731e71cb..02f542019 100644 --- a/crates/engine/src/boolean_regression_tests.rs +++ b/crates/engine/src/boolean_regression_tests.rs @@ -1168,12 +1168,17 @@ fn prism_edge_in_a_round_cornered_slab_end_face_joins() { /// of the bodies as they lie left the hole closed by a skin of no thickness (the plate's top face /// whole over the hole, the tool's end face under it), which no volume shows and which was kept. /// The hole is open, and the cut takes the whole tool: the circle of radius 3.04 the two -/// profiles make, from the barrel cut's floor at z 1.6 up to the plate's top at z 2.8. +/// profiles make, from the barrel cut's floor at z 1.6 up to the plate's top at z 2.8. The design +/// was saved by an older build: Extrude13 starts from a piece of a face that is no longer that +/// piece, so it fails, asking for its face again; the rest builds. #[test] fn cut_up_to_the_plate_top_face_opens_the_hole() { let mut script: Value = serde_json::from_str(include_str!("../../../examples/regressions/cut_up_to_face_leaves_skin.json")).unwrap(); let s = replay_value(&script); - assert!(s.model.results.iter().all(|r| r.error.is_none()), "{:?}", s.model.results); + let failed = + |r: &solidcraft_doc::FeatureResult| r.error.as_deref().and_then(solidcraft_doc::reselect_parts).map(|(feature, _)| feature.to_string()); + assert!(s.model.results.iter().all(|r| r.error.is_none() || failed(r).as_deref() == Some("Extrude13")), "{:?}", s.model.results); + assert!(s.model.results.iter().any(|r| failed(r).as_deref() == Some("Extrude13"))); let state = s.model.state(); let body = &state.body("Body7").unwrap().body; assert!(body.validity().is_empty(), "{:?}", body.validity()); diff --git a/crates/engine/src/cmd/component_clone.rs b/crates/engine/src/cmd/component_clone.rs index 5e0b9e5dc..55c84e18c 100644 --- a/crates/engine/src/cmd/component_clone.rs +++ b/crates/engine/src/cmd/component_clone.rs @@ -498,7 +498,6 @@ pub(super) fn paste( } if let Some(name) = &face.name { face.point = solidcraft_doc::naming::point_on_face(&state, name, face.point) - .map(|(point, _)| point) .ok_or_else(|| bad(CMD, "source frozen face appearance lost its identity"))?; } let source_body = state.body(&face.body).ok_or_else(|| bad(CMD, "source frozen face appearance lost its body"))?; diff --git a/crates/engine/src/cmd/component_clone_tests.rs b/crates/engine/src/cmd/component_clone_tests.rs index b817a4e7c..b879f2d3f 100644 --- a/crates/engine/src/cmd/component_clone_tests.rs +++ b/crates/engine/src/cmd/component_clone_tests.rs @@ -479,7 +479,7 @@ fn transferred_frozen_face_paint_ignores_consumed_legacy_offset() { let part = component(&mut s, "Part"); run(&mut s, "component.move_bodies", json!({"component":part,"bodies":["Foreign"]})); let original = s.doc.appearances.faces.iter().find(|face| face.body == "Foreign").unwrap(); - let expected = solidcraft_doc::naming::point_on_face(&s.model.state(), original.name.as_ref().unwrap(), original.point).unwrap().0; + let expected = solidcraft_doc::naming::point_on_face(&s.model.state(), original.name.as_ref().unwrap(), original.point).unwrap(); copy(&mut s, part); let paint = s.doc.appearances.faces.iter().find(|face| face.body == "Foreign (2)").unwrap(); assert!(paint.point.dist(expected) < 1e-6, "{:?} versus {expected:?}", paint.point); diff --git a/crates/engine/src/cmd/component_extract.rs b/crates/engine/src/cmd/component_extract.rs index 744479dcc..cabb6785a 100644 --- a/crates/engine/src/cmd/component_extract.rs +++ b/crates/engine/src/cmd/component_extract.rs @@ -131,10 +131,10 @@ fn keep_component_looks(doc: &mut Document, owners: &BTreeMap, comp /// What the bodies `new` call the face or edge that `old` calls `name`, found where it is. fn renamed(old: &ModelState, new: &[&ModelBody], name: &str, near: Vec3) -> Option { use solidcraft_doc::{appearance::face_index_at, naming}; - if let Some((p, _)) = naming::point_on_face(old, name, near) { + if let Some(p) = naming::point_on_face(old, name, near) { return new.iter().find_map(|b| face_index_at(b, p).and_then(|i| naming::face_names(b).get(i).cloned())); } - let p = old.bodies.iter().find_map(|b| naming::find_edge(b, name, near).ok())?.0; + let p = old.bodies.iter().find_map(|b| naming::find_edge(b, name, near).ok())?; new.iter().find(|b| face_index_at(b, p).is_some()).and_then(|b| naming::edge_names_at(b, &[p]).pop()) } diff --git a/crates/engine/src/cmd/features_more_tests.rs b/crates/engine/src/cmd/features_more_tests.rs index 21c7d8189..2d74db520 100644 --- a/crates/engine/src/cmd/features_more_tests.rs +++ b/crates/engine/src/cmd/features_more_tests.rs @@ -1829,26 +1829,31 @@ fn a_line_of_text_cuts_into_a_block_at_any_depth() { /// A design saved before tapered sides were built through `taper_loop` (#1014), by the build /// before it: two tapered bosses apart from each other (now joined in one boolean), a fillet on -/// a sloping side edge of one and on the top edge of the other, both saved by edge name. They -/// still find their edges, and the part comes out the same. +/// a sloping side edge of one and on the top edge of the other, both saved by edge name. The +/// sloping edge is still the edge its name names. The top edge was saved as an edge of piece `#1` +/// of the cone's side, which is one face now: no edge is that edge any more, so that fillet fails +/// and asks for its edge to be picked again (never the nearest edge of the whole face), and the +/// rest of the part comes out as before. #[test] -fn fillets_on_tapered_bosses_saved_before_still_find_their_edges() { +fn a_fillet_saved_on_a_piece_of_a_tapered_side_that_is_whole_now_asks_for_its_edge_again() { let text = include_str!("../../../../tests/taper/before-1014/two_tapered_bosses_filleted.json"); let mut s = Session::new(solidcraft_doc::Document::from_json(text).unwrap()); let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap(); - for name in ["Extrude2", "Fillet1", "Fillet2"] { + for name in ["Extrude2", "Fillet1"] { let id = s.doc.find_feature(name).unwrap().id; let r = s.model.result(id).unwrap(); assert!(r.error.is_none() && r.warning.is_none(), "{name}: {:?} {:?}", r.error, r.warning); } + let fillet = s.doc.find_feature("Fillet2").unwrap().id; + let error = s.model.result(fillet).unwrap().error.clone().unwrap(); + assert_eq!(solidcraft_doc::reselect_parts(&error), Some(("Fillet2", "F4:side:c1#1|F4:top#[F4:side:c1]")), "{error}"); // In closed form: the 80 × 40 × 20 block, the 20 × 20 boss 10 high tapered 5° in (a frustum, // top 20 − 20 tan 5° square: 3660.251034), the Ø16 boss tapered alike (a cone frustum, top // radius 8 − 10 tan 5°: 1798.751833); less the R1 round along a sloping corner (the corner's // section, r²(cot φ/2 − (π − φ)/2) at its dihedral angle φ = 90.435°, times its length - // between z = 20 and 30: 2.124401) and the R0.5 round all round the cone's top (the section - // at the rim's 95°, turned about the axis by Pappus: 1.928463). The build that saved it, - // with truck, measured 69454.885209. - assert!((volume - 69454.950004).abs() < 1e-3, "{volume}"); + // between z = 20 and 30: 2.124401). The R0.5 round all round the cone's top (1.928463) is + // the failed fillet's. + assert!((volume - 69456.878467).abs() < 1e-3, "{volume}"); assert_eq!(s.world_state().unwrap().bodies.len(), 1); } diff --git a/crates/engine/src/cmd/plastic.rs b/crates/engine/src/cmd/plastic.rs index 38de1be77..32e5ed765 100644 --- a/crates/engine/src/cmd/plastic.rs +++ b/crates/engine/src/cmd/plastic.rs @@ -509,8 +509,7 @@ mod tests { let before = s.model.state_before(feature.id); let name = feature.face_names.first().unwrap(); let point = solidcraft_doc::naming::point_on_face(&before, name, Vec3::new(0., -28., 20.)) - .expect("the original wall identity survives merged pieces") - .0; + .expect("the original wall identity survives merged pieces"); assert!((point - Vec3::new(0., -33., 20.)).len() < 1e-8, "{point:?}"); assert!(s.model.results.iter().all(|result| result.error.is_none())); let check = |session: &Session| { diff --git a/crates/engine/src/cmd/sketch_project.rs b/crates/engine/src/cmd/sketch_project.rs index feaebfecc..347148838 100644 --- a/crates/engine/src/cmd/sketch_project.rs +++ b/crates/engine/src/cmd/sketch_project.rs @@ -194,10 +194,16 @@ pub(super) fn refresh(s: &Session, doc: &Document, id: u64, sk: &mut Sketch) -> return vec!["lost face attachment; reattach explicitly".into()]; }; let Ok(plane) = sketch_plane(&doc, id, &st) else { return Vec::new() }; - let warnings = match attachment { + let refreshed = match attachment { Some(anchor) => solidcraft_doc::project::refresh_face_anchor_links(&doc, &vals, &st, &plane, sk, anchor), None => solidcraft_doc::project::refresh_links(&doc, &vals, &st, &plane, sk), }; + // A link whose named face or edge is gone fails the sketch when it is evaluated; while it is + // edited, that is what the refresh says. + let warnings = match refreshed { + Ok(warnings) => warnings, + Err(e) => return vec![e.in_feature(&doc.feature(id).map(|f| f.name.clone()).unwrap_or_default()).to_string()], + }; if let Ok(stored) = doc.sketch(id) && sk.positions_in(stored).is_some() { diff --git a/crates/engine/src/cmd/sketch_project_edge_tests.rs b/crates/engine/src/cmd/sketch_project_edge_tests.rs index db3528ae1..97472f680 100644 --- a/crates/engine/src/cmd/sketch_project_edge_tests.rs +++ b/crates/engine/src/cmd/sketch_project_edge_tests.rs @@ -1,6 +1,6 @@ //! A projected edge stays the edge that was picked: its link keeps the edge's persistent name, //! so the edge is found by that name wherever a change of the body takes it, and no other edge -//! is taken for it when it is split or gone. +//! is taken for it when it is split or gone: the sketch fails, asking for the edge again. use serde_json::{Value, json}; use solidcraft_geom::{Vec2, Vec3}; @@ -119,11 +119,17 @@ fn a_projected_edge_stays_that_edge_when_the_body_changes_size() { assert!(matches!(&stored(&s).source, LinkSource::Edge { body, at } if body == "Body1" && at.dist(Vec3::new(400.0, 25.0, 20.0)) < 1e-6)); } +/// What sketch `Top` asks to be picked again, when it fails for a reference it lost. +fn reselect(s: &Session) -> Option { + let r = s.model.result(s.doc.find_feature("Top").unwrap().id).unwrap(); + r.error.as_deref().and_then(solidcraft_doc::reselect_parts).filter(|(feature, _)| *feature == "Top").map(|(_, reference)| reference.to_string()) +} + /// A slot cut through the plate from x = 80 to 120, y = 20 to 30 leaves the picked edge in two -/// pieces, y = 0..20 and y = 30..50. The link, picked at y = 10, gives the piece it was picked -/// on and says the edge was split; without the slot it is the whole edge again. +/// pieces, y = 0..20 and y = 30..50. Neither is the edge: the sketch fails, asking for it again +/// (never the piece nearest the pick); without the slot it is the whole edge again. #[test] -fn a_projected_edge_that_was_split_gives_its_nearest_piece_and_says_so() { +fn a_projected_edge_that_was_split_fails_its_sketch_asking_for_the_edge_again() { let mut s = Session::default(); plate(&mut s); run(&mut s, "sketch.create", json!({"plane": "XY", "name": "SlotSketch"})); @@ -133,31 +139,28 @@ fn a_projected_edge_that_was_split_gives_its_nearest_piece_and_says_so() { run(&mut s, "timeline.suppress", json!({"feature": "Slot", "suppressed": true})); project_right_edge(&mut s, 10.0); assert_line(&s, 100.0, (0.0, 50.0), "drawn"); + let name = stored(&s).edge_name.unwrap(); run(&mut s, "timeline.suppress", json!({"feature": "Slot", "suppressed": false})); - assert_line(&s, 100.0, (0.0, 20.0), "split"); - assert!(trouble(&s).contains("was split"), "{}", trouble(&s)); - assert!(!link(&s).lost); + assert_eq!(reselect(&s), Some(name), "{}", trouble(&s)); run(&mut s, "timeline.suppress", json!({"feature": "Slot", "suppressed": true})); assert_line(&s, 100.0, (0.0, 50.0), "whole again"); assert_eq!(trouble(&s), ""); } /// A fillet of radius 4 takes the picked edge away. Its two tangent edges are 4 from the picked -/// point, the nearest edges there are now: the link is lost and keeps its line, it takes -/// neither of them. Without the fillet the link has its edge again. +/// point, the nearest edges there are now: the sketch takes neither of them, it fails, asking for +/// its edge again. Without the fillet the link has its edge again. #[test] -fn a_projected_edge_that_is_gone_is_lost_not_replaced() { +fn a_projected_edge_that_is_gone_fails_its_sketch_not_replaced() { let mut s = Session::default(); plate(&mut s); run(&mut s, "solid.fillet", json!({"edges": [[100, 25, 20]], "radius": "4 mm", "name": "Round"})); run(&mut s, "timeline.suppress", json!({"feature": "Round", "suppressed": true})); project_right_edge(&mut s, 25.0); assert_line(&s, 100.0, (0.0, 50.0), "drawn"); + let name = stored(&s).edge_name.unwrap(); run(&mut s, "timeline.suppress", json!({"feature": "Round", "suppressed": false})); - let said = trouble(&s); - assert!(said.contains("projected reference lost: edge") && said.contains("no longer exists"), "{said}"); - assert!(link(&s).lost); - assert_line(&s, 100.0, (0.0, 50.0), "the last geometry is kept"); + assert_eq!(reselect(&s), Some(name), "{}", trouble(&s)); run(&mut s, "timeline.suppress", json!({"feature": "Round", "suppressed": true})); assert_eq!(trouble(&s), ""); assert!(!link(&s).lost); diff --git a/crates/engine/src/cmd/sketch_project_tests.rs b/crates/engine/src/cmd/sketch_project_tests.rs index 6c32703a2..543112cff 100644 --- a/crates/engine/src/cmd/sketch_project_tests.rs +++ b/crates/engine/src/cmd/sketch_project_tests.rs @@ -304,21 +304,20 @@ fn deleting_one_edge_of_a_projected_face_keeps_the_others_as_they_were() { assert!(s.doc.sketch(id).unwrap().links.is_empty()); } +/// The edge a projection was made from goes with its body: the sketch fails, asking for the edge +/// again, instead of keeping a lost link. #[test] -fn lost_reference_keeps_geometry_with_a_warning() { +fn a_reference_whose_body_is_gone_fails_its_sketch_asking_for_it_again() { let mut s = Session::default(); run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10})); let boxf = s.doc.features.last().unwrap().id; run(&mut s, "sketch.create", json!({"plane": "XY"})); run(&mut s, "sketch.project", json!({"refs": [{"edge": [5, 0, 10]}]})); run(&mut s, "sketch.finish", json!({})); + let name = s.doc.sketch(s.doc.features.last().unwrap().id).unwrap().links[0].edge_name.clone().unwrap(); run(&mut s, "timeline.suppress", json!({"feature": boxf, "suppressed": true})); - let st = s.model.state(); - let ss = st.sketches.last().unwrap(); - assert_eq!(ss.sketch.curves.len(), 1, "geometry kept"); - assert!(ss.sketch.links[0].lost); - let w = s.model.results.last().unwrap().warning.clone().unwrap_or_default(); - assert!(w.contains("lost"), "{w}"); + let r = s.model.results.last().unwrap(); + assert_eq!(r.error.as_deref().and_then(solidcraft_doc::reselect_parts), Some((r.name.as_str(), name.as_str())), "{r:?}"); } #[test] @@ -558,8 +557,8 @@ fn sweeps_and_pipes_follow_3d_sketch_curves() { } /// #47: references to other bodies: an edge, a face's loops and a silhouette of a second body -/// project into a sketch on the first; they follow an edit of that body (a parameter) and -/// are reported lost, not crashed on, when it goes away. +/// project into a sketch on the first; they follow an edit of that body (a parameter), and when +/// it goes away the sketch fails, asking for the named edge again, not crashed on. #[test] fn project_and_include_from_other_bodies() { let mut s = Session::default(); @@ -589,13 +588,17 @@ fn project_and_include_from_other_bodies() { let id = s.doc.features.iter().find(|f| matches!(f.kind, solidcraft_doc::FeatureKind::Sketch { .. })).unwrap().id; let si = run(&mut s, "sketch.inspect", json!({"sketch": id})); assert!(xs(&si).iter().any(|x| (x - 70.0).abs() < 1e-6), "{:?}", xs(&si)); - // Remove the cylinder: its silhouette and edge are lost, with a warning and no error. + // Remove the cylinder: the edge included from it is gone, and the sketch asks for it again. let cyl = s.doc.features.iter().find(|f| matches!(f.kind, solidcraft_doc::FeatureKind::Cylinder { .. })).unwrap().id; run(&mut s, "timeline.delete", json!({"feature": cyl})); let t = run(&mut s, "document.inspect", json!({})); let row = t["timeline"].as_array().unwrap().iter().find(|r| r["id"] == json!(id)).cloned().unwrap(); - assert!(row["error"].is_null(), "{row}"); - assert!(row["warning"].as_str().is_some_and(|w| w.contains("lost")), "{row}"); + let error = row["error"].as_str().unwrap_or_default(); + assert!( + solidcraft_doc::reselect_parts(error) + .is_some_and(|(feature, reference)| feature == row["name"] && reference.starts_with(&format!("F{cyl}:"))), + "{row}" + ); } /// A cylinder's wall and the torus of a rounded rim are drawn as one face but stored in halves diff --git a/crates/engine/src/naming_history_tests.rs b/crates/engine/src/naming_history_tests.rs index e78604914..7a5cca7f7 100644 --- a/crates/engine/src/naming_history_tests.rs +++ b/crates/engine/src/naming_history_tests.rs @@ -27,6 +27,12 @@ fn error(s: &Session, name: &str) -> Option { s.model.result(id(s, name)).and_then(|r| r.error.clone()) } +/// The reference feature `name` failed on, asking for it to be picked again. +fn reselect(s: &Session, name: &str) -> Option { + let error = error(s, name)?; + solidcraft_doc::reselect_parts(&error).filter(|(feature, _)| *feature == name).map(|(_, reference)| reference.to_string()) +} + /// Whether any body holds `p`. fn solid_at(s: &Session, p: [f64; 3]) -> bool { s.model.state().bodies.iter().any(|b| b.body.contains(Vec3::new(p[0], p[1], p[2]))) @@ -171,14 +177,16 @@ fn a_piece_keeps_its_identity_when_the_cut_that_made_it_moves_or_shrinks() { change(&mut s, "slot_w", "0.05 mm"); assert_eq!(warning(&s, "Raise"), None); assert!(solid_at(&s, [39.0, 15.0, 11.0]) && !solid_at(&s, [27.0, 15.0, 11.0])); - // Gone altogether (suppressed), the piece is the whole top again: said, not guessed. + // Gone altogether (suppressed), the top is whole again, which is not the piece: the raise + // fails, asking for its face again, never guessed. run(&mut s, "timeline.suppress", json!({"feature": "Slot", "suppressed": true})); - let w = warning(&s, "Raise").unwrap_or_default(); - assert!(w.contains("split") || w.contains("no longer exists"), "{w}"); + assert_eq!(reselect(&s, "Raise").as_ref(), raise.face_names.first()); } +/// A face merged into another is not the face that was picked: the feature on it fails, asking +/// for its face again; when the faces part again, the reference finds its face. #[test] -fn a_face_merged_into_another_answers_to_its_name_and_says_so() { +fn a_face_merged_into_another_asks_for_its_face_again() { let mut s = Session::default(); block(&mut s); run(&mut s, "parameters.add", json!({"name": "boss_h", "expression": "5 mm"})); @@ -191,13 +199,13 @@ fn a_face_merged_into_another_answers_to_its_name_and_says_so() { let raise = s.doc.find_feature("Raise").cloned().unwrap(); assert_eq!(raise.face_names, vec![format!("F{boss}:top")]); assert!(solid_at(&s, [50.0, 15.0, 5.5]) && !solid_at(&s, [50.0, 15.0, 6.5])); - // As tall as the block, the boss's top and the block's are one face: the reference finds - // it and says it was merged. + // As tall as the block, the boss's top and the block's are one face: not the boss's top. change(&mut s, "boss_h", "10 mm"); + assert_eq!(reselect(&s, "Raise").as_ref(), raise.face_names.first()); + assert!(!solid_at(&s, [50.0, 15.0, 10.5]) && !solid_at(&s, [20.0, 15.0, 10.5]), "nothing is raised"); + change(&mut s, "boss_h", "5 mm"); assert_eq!(error(&s, "Raise"), None); - let w = warning(&s, "Raise").unwrap_or_default(); - assert!(w.contains("merged"), "{w}"); - assert!(solid_at(&s, [50.0, 15.0, 10.5]) && solid_at(&s, [20.0, 15.0, 10.5]), "the merged top is raised as one"); + assert!(solid_at(&s, [50.0, 15.0, 5.5]) && !solid_at(&s, [20.0, 15.0, 10.5])); } #[test] @@ -630,9 +638,9 @@ fn one_fillet_over_two_bodies_of_one_extrude_rounds_each_body_s_own_edges() { /// 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. +/// is not the upper box's edge: the fillet fails, asking for that edge again, and rounds nothing. #[test] -fn one_fillet_over_stacked_boxes_rounds_the_upper_box_s_edge_even_when_saved_named_on_the_lower() { +fn one_fillet_over_stacked_boxes_saved_named_on_the_lower_asks_for_the_upper_edge_again() { 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"})); @@ -655,10 +663,11 @@ fn one_fillet_over_stacked_boxes_rounds_the_upper_box_s_edge_even_when_saved_nam 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_names = old_names.clone(); feature.edge_refs = old_refs; s.refresh(); - check(&s, "saved by an older build"); + assert_eq!(reselect(&s, "Rounds").as_ref(), old_names.get(1)); + assert!(solid_at(&s, [24.8, -24.8, 20.0]) && solid_at(&s, [-24.8, -24.8, 45.0]), "nothing is rounded"); } /// A shell opened by a point pick on a bar's end face keeps opening that face when a parameter diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 2ceb72884..13fd632e4 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -2635,6 +2635,13 @@ mod naming { s.model.result(id).and_then(|r| r.warning.clone()) } + /// The reference feature `name` failed on, asking for it to be picked again. + fn reselect(s: &Session, name: &str) -> Option { + let id = s.doc.find_feature(name).map(|f| f.id)?; + let error = s.model.result(id).and_then(|r| r.error.clone())?; + solidcraft_doc::reselect_parts(&error).filter(|(feature, _)| *feature == name).map(|(_, reference)| reference.to_string()) + } + /// A 40 x 30 x 10 block (sketch S: l1…l4 counter-clockwise from the origin), a hole H, a /// fillet on the right top edge. fn block() -> Session { @@ -2692,8 +2699,10 @@ mod naming { assert_eq!(warning(&s, "Round"), None); } + /// The notch leaves the filleted edge in two pieces: neither is the edge, so the fillet fails, + /// asking for its edge again, and never rounds the piece nearest the pick. #[test] - fn a_split_edge_warns_and_takes_the_nearest_piece() { + fn a_split_edge_fails_the_fillet_asking_for_the_edge_again() { let mut s = block(); // Upstream of the fillet, a notch through the middle of the filleted edge. run(&mut s, "timeline.roll_to", json!({"feature": "Hole"})); @@ -2702,12 +2711,13 @@ mod naming { run(&mut s, "sketch.finish", json!({})); run(&mut s, "solid.extrude", json!({"sketch": "N", "distance": 10, "operation": "cut", "name": "Notch"})); run(&mut s, "timeline.roll_to", json!({})); - let w = warning(&s, "Round").unwrap_or_default(); - assert!(w.contains("split"), "{w}"); + assert_eq!(reselect(&s, "Round").as_deref(), Some("F2:side:l2|F2:top")); } + /// The face the filleted edge bounded is gone with its sketch line: the fillet fails, asking + /// for its edge again. #[test] - fn a_removed_segment_warns() { + fn a_removed_segment_fails_the_fillet_asking_for_the_edge_again() { let mut s = block(); // Replace the right side (l2) of the rectangle with a new line: the face it made is gone. let sk = s.doc.find_feature("S").map(|f| f.id).unwrap(); @@ -2716,8 +2726,7 @@ mod naming { run(&mut s, "sketch.line", json!({"points": [[40, 0], [40, 30]], "ids": ["right"]})); let r: Result = s.execute("sketch.finish", &json!({})); assert!(r.is_ok() || r.is_err()); - let w = warning(&s, "Round").unwrap_or_default(); - assert!(w.contains("no longer exists"), "{w}"); + assert_eq!(reselect(&s, "Round").as_deref(), Some("F2:side:l2|F2:top")); } fn face_names(s: &mut Session, body: &str) -> Vec { @@ -4454,7 +4463,7 @@ fn a_side_drawn_in_two_collinear_pieces_extrudes_into_one_face() { let st = s.model.state(); let body = st.body("Body1").unwrap(); let edge = format!("F2:side:{}|F2:top", pieces[1]); - let (at, _) = solidcraft_doc::naming::find_edge(body, &edge, geom::Vec3::new(15.0, 0.0, 5.0)).unwrap(); + let at = solidcraft_doc::naming::find_edge(body, &edge, geom::Vec3::new(15.0, 0.0, 5.0)).unwrap(); assert!(at.y.abs() < 1e-9 && (at.z - 5.0).abs() < 1e-9, "{edge} at {at:?}"); // A sketch attaches to the joined side as to any side. assert_eq!(run(&mut s, "sketch.create", json!({"plane": {"face": [15, 0, 2.5]}}))["attachment"], "exact_face"); diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 707723bde..533ae07b3 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -5117,8 +5117,7 @@ fn named_refill(s: &Session, body: Option<&str>, name: &str, point: Vec3, edge: .filter_map(|b| naming::locate_edge(b, name, point).ok().map(|hit| (b, hit))) .min_by(|(_, a), (_, b)| a.point.dist(point).total_cmp(&b.point.dist(point)))?; (b, hit.edge, hit.point) - } else if let Some((b, (index, point, _))) = body.and_then(|n| st.body(n)).and_then(|b| naming::face_on_body(b, name, point).map(|hit| (b, hit))) - { + } else if let Some((b, (index, point))) = body.and_then(|n| st.body(n)).and_then(|b| naming::face_on_body(b, name, point).map(|hit| (b, hit))) { (b, index, point) } else { let hit = naming::locate_face(&st, name, point)?; diff --git a/crates/ui-egui/src/dialogs_all_tests.rs b/crates/ui-egui/src/dialogs_all_tests.rs index 107dd2c98..c9bcd090a 100644 --- a/crates/ui-egui/src/dialogs_all_tests.rs +++ b/crates/ui-egui/src/dialogs_all_tests.rs @@ -742,7 +742,7 @@ fn draft_uses_the_picked_solid_beside_a_hidden_overlapping_mesh() { let target = body.name.clone(); let point = Vec3::new(20.0, 10.0, 5.0); let name = naming::face_name_at_body(body, point).unwrap(); - let (index, _, _) = naming::face_on_body(body, &name, point).unwrap(); + let (index, _) = naming::face_on_body(body, &name, point).unwrap(); h.app.session.selection = vec![Sel::Face { body: target.clone(), index, point }]; let mut d = Dialog::for_command(&h.app, "solid.draft").unwrap(); d.inputs[1].items = vec![Sel::Plane { name: "XY".into() }];