From 6a0166853fc2d01e15114182be2a969870055924 Mon Sep 17 00:00:00 2001 From: brett19 Date: Sat, 31 Oct 2026 09:37:58 -0700 Subject: [PATCH] A round mitred to one that overflows goes first with it (fork 9ba2b12); flags() and warnings overflow_first takes the mitred pairs of the stopped call (solidcore#2045's mitred_edges) and grows the rounds that go first through every mitre, as the capi's. The flag test reads UpstreamFixes::flags (solidcore#2024), and the check's own filter of SMLib's warning gives way to AssertReport::is_warning (solidcore#2023). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk --- crates/smlib/src/core.rs | 8 ++-- crates/smlib/src/core/blend.rs | 51 +++++++++++++++++++++----- crates/smlib/src/core/measure.rs | 15 ++------ crates/smlib/src/core/measure_tests.rs | 2 +- 4 files changed, 51 insertions(+), 25 deletions(-) diff --git a/crates/smlib/src/core.rs b/crates/smlib/src/core.rs index f9d0746a2..82dd02c82 100644 --- a/crates/smlib/src/core.rs +++ b/crates/smlib/src/core.rs @@ -501,12 +501,12 @@ mod tests { #[test] fn every_upstream_fix_is_on() { - let f = format!("{:?}", fixes()); - let off: Vec<&str> = - f.split([',', '{', '}']).filter_map(|kv| kv.trim().strip_suffix(": false")).filter(|name| !HELD_BACK.contains(name)).collect(); + let f = fixes(); + let flags: Vec<(&str, bool)> = f.flags().collect(); + let off: Vec<&str> = flags.iter().filter(|(name, on)| !on && !HELD_BACK.contains(name)).map(|(name, _)| *name).collect(); assert!(off.is_empty(), "UpstreamFixes flags are off: {off:?}"); for name in HELD_BACK { - assert!(f.contains(&format!("{name}: false")), "{name} is on or gone: drop it from HELD_BACK"); + assert!(flags.contains(&(*name, false)), "{name} is on or gone: drop it from HELD_BACK"); } } diff --git a/crates/smlib/src/core/blend.rs b/crates/smlib/src/core/blend.rs index 57de9152f..cb20f6002 100644 --- a/crates/smlib/src/core/blend.rs +++ b/crates/smlib/src/core/blend.rs @@ -285,10 +285,13 @@ fn blend_failure(s: &FilletSession<'_>, e: SolidError, corner: bool) -> Error { /// `round_edges`' `overflow_first` argument: with it the session stops, nothing built, when blends /// of several edges overflow their faces across cliffs (`SetOverflowFirst`) or (`classify_only`) /// always (`SetClassifyOnly`), and `stopped` gets the edges whose blends overflow -/// (`GetOverflowEdges`; the capi's status `OVERFLOW_FIRST`, the call's failure then meaning only that). +/// (`GetOverflowEdges`; the capi's status `OVERFLOW_FIRST`, the call's failure then meaning only that) +/// and `mitred` the edges of each two rounds mitred at a face's concave corner, two by two +/// (`GetMitredEdges`), when the caller asks. struct OverflowFirst<'a> { classify_only: bool, stopped: &'a mut Option>, + mitred: Option<&'a mut Vec>, } /// `round_edges` and `chamfer_offsets` (with equal offsets): `edges` of `b` blended in place, @@ -365,6 +368,9 @@ fn blend_edges_stopping( && s.error_info().code == FilletErrorType::OverflowFirst as i32 { *o.stopped = Some(s.overflow_edges()); + if let Some(m) = o.mitred { + *m = s.mitred_edges(); + } } Ok(Err(Err(blend_failure(&s, e, corner)))) } @@ -553,8 +559,11 @@ const OVERFLOW_GOES_FIRST: bool = true; /// nothing was built in) go first: on a fresh copy of `body`, the picked edges tagged with their /// places ([`Picked`]), those are rounded, and each other picked edge is then what is left of it, /// the edges carrying its tag, rounded at its size. A picked edge with nothing left is gone: its -/// points are flagged in `dropped`. Where none overflows on its own, or all do, the edges are -/// rounded together as before. The result is the new body. Unlike the capi, the tags come off it +/// points are flagged in `dropped`. Two rounds mitred at a face's concave corner (`mitred`, the edges +/// of each such pair two by two, as the stopped call found them in `w`) meet in their mitre, each run +/// on past the corner: one goes first with the other, so a round mitred to one that overflows goes +/// first too (fork 9ba2b12). Where none overflows on its own, or all go first, the edges are rounded +/// together as before. The result is the new body. Unlike the capi, the tags come off it /// (nothing reads them after the call, and a later call's copy would carry them on). #[allow(clippy::too_many_arguments)] // the capi's overflow_first fn overflow_first( @@ -564,6 +573,7 @@ fn overflow_first( tolerance: f64, section: Section<'_>, picked: &[EdgeId], + mitred: &[EdgeId], each: &[f64], w: &mut Brep, dropped: &mut [bool], @@ -581,10 +591,10 @@ fn overflow_first( Ok(_) => return Ok(Err(Error::NoMatch { point: 0 })), Err(m) => return Ok(Err(edge_miss(m))), }; - let (mut lead, mut lead_sizes, mut rest) = (Vec::new(), Vec::new(), Vec::new()); + let mut goes_first = vec![false; picked.len()]; for (i, ((&e, &to), &size)) in picked.iter().zip(&again).zip(each).enumerate() { let mut stopped = None; - let alone = OverflowFirst { classify_only: true, stopped: &mut stopped }; + let alone = OverflowFirst { classify_only: true, stopped: &mut stopped, mitred: None }; match blend_edges_stopping(k, w, &[e], &[size], section, None, &[], None, Some(alone))? { Err(Err(why)) if stopped.is_none() => return Ok(Err(why)), Err(Ok(_)) => return Ok(Err(Error::Unsupported)), @@ -592,7 +602,30 @@ fn overflow_first( Err(Err(_)) => {} } fresh.add_attribute(EntityRef::Edge(to), Attribute::application(PICKED_ID, Behavior::Copy, Picked(i)))?; - if stopped.is_some_and(|over| !over.is_empty()) { + if let Some(flag) = goes_first.get_mut(i) { + *flag = stopped.is_some_and(|over| !over.is_empty()); + } + } + // A round mitred to one that goes first goes with it, through every mitre. + let place = |e: &EdgeId| picked.iter().position(|p| p == e); + let pairs: Vec<(usize, usize)> = mitred.as_chunks::<2>().0.iter().filter_map(|[a, b]| Some((place(a)?, place(b)?))).collect(); + let mut grew = true; + while grew { + grew = false; + for &(a, b) in &pairs { + if goes_first.get(a) != goes_first.get(b) { + for i in [a, b] { + if let Some(flag) = goes_first.get_mut(i) { + *flag = true; + } + } + grew = true; + } + } + } + let (mut lead, mut lead_sizes, mut rest) = (Vec::new(), Vec::new(), Vec::new()); + for (i, ((&to, &size), &first)) in again.iter().zip(each).zip(&goes_first).enumerate() { + if first { lead.push(to); lead_sizes.push(size); } else { @@ -766,11 +799,11 @@ fn blend_call( // first, on a fresh copy, and the others then round what is left of their edges. An edge // the overflow removes whole is gone (`dropped`); one it cuts keeps the rest. let may_go_first = OVERFLOW_GOES_FIRST && back.is_empty() && open == Corners::Filled && picked.len() > 1; - let mut stopped = None; - let first = may_go_first.then_some(OverflowFirst { classify_only: false, stopped: &mut stopped }); + let (mut stopped, mut mitred) = (None, Vec::new()); + let first = may_go_first.then_some(OverflowFirst { classify_only: false, stopped: &mut stopped, mitred: Some(&mut mitred) }); let done = blend_edges_stopping(k, &mut w, &picked, &each, section, None, &back, (open == Corners::Open).then_some(&mut patches), first)?; if stopped.is_some() { - return Ok(match overflow_first(k, body, points, tolerance, section, &picked, &each, &mut w, dropped)? { + return Ok(match overflow_first(k, body, points, tolerance, section, &picked, &mitred, &each, &mut w, dropped)? { Ok(fresh) => finish(fresh, solid_in)?, Err(e) => Err(e), }); diff --git a/crates/smlib/src/core/measure.rs b/crates/smlib/src/core/measure.rs index 65ff68d45..5195c3b17 100644 --- a/crates/smlib/src/core/measure.rs +++ b/crates/smlib/src/core/measure.rs @@ -6,7 +6,7 @@ //! [`check`] fails with "not supported yet" while a test it reaches is unported in solidcore. use solidcore::error::EntityRef; -use solidcore::geom::assert_array::{AssertArray, AssertReport, labels, obj_type_string}; +use solidcore::geom::assert_array::{AssertArray, AssertReport, obj_type_string}; use solidcore::geom::attribute::{AttributeStore, ObjectKey}; use solidcore::geom::tol::{SmallTopoType, brep_zone_tol_3d, context_xsect_tol_3d}; use solidcore::heal::gap::GapFunction; @@ -261,18 +261,11 @@ fn report_line(r: &AssertReport) -> String { s } -/// The capi's `advisory()`: `SmBrep` test 21, "Suspicious Shell Count" (a body of several faces -/// with one shell each), is a warning. `SmBrep::AssertValid` reports it without failing, and -/// faces that meet nowhere (a sheet's faces offset apart across a sharp edge) rightly make such a -/// body. -fn advisory(r: &AssertReport) -> bool { - r.reporting_type == labels::BREP_TYPE && r.list_index == 0 && r.test_index == 21 -} - /// The capi's `collect()`: appends the failed reports of `list`, one line each, and counts them; -/// SMLib's warnings ([`advisory`]) are neither. +/// SMLib's warnings ([`AssertReport::is_warning`]: `SmBrep` test 21, "Suspicious Shell Count", a +/// body of several faces with one shell each, is one) are neither. fn collect(list: &AssertArray, out: &mut String, failures: &mut usize) { - for r in list.reports().iter().filter(|r| !r.ok && !advisory(r)) { + for r in list.reports().iter().filter(|r| !r.ok && !r.is_warning()) { *failures += 1; out.push_str(&report_line(r)); out.push('\n'); diff --git a/crates/smlib/src/core/measure_tests.rs b/crates/smlib/src/core/measure_tests.rs index e70349e8c..fbbfde5c3 100644 --- a/crates/smlib/src/core/measure_tests.rs +++ b/crates/smlib/src/core/measure_tests.rs @@ -397,7 +397,7 @@ fn a_sealed_void_measures_its_volume() { /// Two 10 mm squares apart in z = 0, one body of two faces with a shell each (as the top and /// front of a box offset apart across their edge make, kernel case /// `surfaces/cov-offset-two-faces-across-a-sharp-edge-come-apart`): `SmBrep` test 21, -/// "Suspicious Shell Count", warns of it, and the capi's check (`advisory`) counts no warning. +/// "Suspicious Shell Count", warns of it, and the capi's check counts no warning. #[test] fn faces_apart_with_a_shell_each_check_valid() { use solidcore::geom::axis2_placement::Axis2Placement;