SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Update the solidcore kernel to main a445bdaac6 for rc.3 (#13015)
bherbruck670636ecd6a7
diff --git a/Cargo.lock b/Cargo.lockindex d436bf20c2..813f756114 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4051,15 +4051,16 @@ dependencies = [[[package]]name = "solidcore"version = "1.0.1"-source = "git+https://github.com/tangency-labs/solidcore?rev=8ddce901671f1cebd9214a31d21895d725e886c8#8ddce901671f1cebd9214a31d21895d725e886c8"+source = "git+https://github.com/tangency-labs/solidcore?rev=a445bdaac60a980b0e9d1dba3ee28eb7ada44f50#a445bdaac60a980b0e9d1dba3ee28eb7ada44f50"dependencies = [+ "serde","thiserror 2.0.21",][[package]]name = "solidcore-record"version = "0.1.0"-source = "git+https://github.com/tangency-labs/solidcore?rev=f5e8e9a29e0c9b7cf6c4040a5bc8878382b3c62f#f5e8e9a29e0c9b7cf6c4040a5bc8878382b3c62f"+source = "git+https://github.com/tangency-labs/solidcore?rev=a445bdaac60a980b0e9d1dba3ee28eb7ada44f50#a445bdaac60a980b0e9d1dba3ee28eb7ada44f50"dependencies = ["serde","serde_json",diff --git a/Cargo.toml b/Cargo.tomlindex 9b70d178f5..fceb9a453b 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -36,10 +36,10 @@ solidcraft-3dx-client = { path = "crates/threedx-client" }# move the rev on its own commit. For a# local checkout, add `[patch."https://github.com/tangency-labs/solidcore"] solidcore = { path =# "../solidcore/crates/solidcore" }` to a `.cargo/config.toml` outside the repository.-solidcore = { git = "https://github.com/tangency-labs/solidcore", rev = "8ddce901671f1cebd9214a31d21895d725e886c8" }+solidcore = { git = "https://github.com/tangency-labs/solidcore", rev = "a445bdaac60a980b0e9d1dba3ee28eb7ada44f50" }# Geometry as data (solidcore's layers §1, "Record"): the B-rep record, its structural validation# and the native body file. Pinned like solidcore; for a local checkout, patch it as above.-solidcore-record = { git = "https://github.com/tangency-labs/solidcore", rev = "f5e8e9a29e0c9b7cf6c4040a5bc8878382b3c62f" }+solidcore-record = { git = "https://github.com/tangency-labs/solidcore", rev = "a445bdaac60a980b0e9d1dba3ee28eb7ada44f50" }# test tooling: a dev-dependency only (xtask/src/layers.rs)solidcraft-testkit = { path = "crates/testkit" }diff --git a/apps/solidcraft-cli/tests/model_cache.rs b/apps/solidcraft-cli/tests/model_cache.rsindex ff94461d90..4f1f88bebb 100644--- a/apps/solidcraft-cli/tests/model_cache.rs+++ b/apps/solidcraft-cli/tests/model_cache.rs@@ -318,7 +318,7 @@ fn a_model_saved_under_another_check_mode_is_evaluated_again() {/// opened from its model or evaluated anew. Two edges of a 20 mm box rounded r2 (a mitre at the/// corner (20, 0, 20)), saved; opened, the upright edge there rounded r3: the corner all three/// rounded at once make (SMLib's setback corner, kernel `three_rounds_at_a_corner`), 15 faces and-/// 7928.142563938 mm³, the same body as the design evaluated anew.+/// 7927.72428251348 mm³, the same body as the design evaluated anew.#[test]fn a_later_round_after_opening_blends_the_saved_rounds_again() {let mut built = Session::default();@@ -336,7 +336,7 @@ fn a_later_round_after_opening_blends_the_saved_rounds_again() {let b = &st.body("Box").unwrap().body;let v = solidcraft_engine::kernel::measure(b).unwrap().volume;assert_eq!(b.face_count(), 15);- assert!((v - 7928.142563938).abs() < 1e-6, "{v}");+ assert!((v - 7927.72428251348).abs() < 1e-6, "{v}"); // solidcore#2382's setback corner}assert_eq!(model("later round", &cached), model("later round", &rebuilt));let _ = std::fs::remove_file(&path);diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rsindex ad9ec10f14..b4bf99f1f1 100644--- a/crates/doc/src/project.rs+++ b/crates/doc/src/project.rs@@ -1626,7 +1626,57 @@ pub(crate) fn section(plane: &Plane, m: &Mesh, face: Option<u32>) -> Vec<LinkGeolet tight = size * 1e-4;let checkable = exact.len().saturating_mul(close.len()) <= 4_000_000;let strays = |v: &[LinkGeom]| exact.iter().any(|p| !v.iter().any(|g| plain_distance(g, *p).is_none_or(|d| d <= tight)));- if plain(&close) && (close.len() <= lossy.len() || (checkable && strays(&lossy) && !strays(&close))) { close } else { lossy }+ let fitted = if plain(&close) && (close.len() <= lossy.len() || (checkable && strays(&lossy) && !strays(&close))) { close } else { lossy };+ join_rounds(fitted, size * 1e-5)+}++/// Where the fit left a line and an arc ends apart by at most `tol`, both end at one point. A+/// line can swallow an arc's first chord (a mesh crossing just past the tangent line), and+/// [`refine_round`] moves an arc's ends but not the lines': the outline would not close.+fn join_rounds(mut fitted: Vec<LinkGeom>, tol: f64) -> Vec<LinkGeom> {+ for i in 0..fitted.len() {+ let Some(&LinkGeom::Arc { c, mut a, mut b }) = fitted.get(i) else { continue };+ let r = c.dist(a);+ for end in [&mut a, &mut b] {+ for curve in &mut fitted {+ let LinkGeom::Line(p, q) = curve else { continue };+ let (near, far) = if p.dist(*end) <= q.dist(*end) { (p, q) } else { (q, p) };+ if near.dist(*end) <= tol {+ let joint = line_meets_round(*far, *near, c, r, tol);+ *near = joint;+ *end = joint;+ }+ }+ }+ if let Some(arc) = fitted.get_mut(i) {+ *arc = LinkGeom::Arc { c, a, b };+ }+ }+ fitted+}++/// Where a line from `far` ending near `near` meets the circle (`c`, `r`): the tangent point when+/// the line runs into the circle there, within `tol` of it over the arc's first chord, else its+/// crossing nearest `near`, else the circle's point nearest `near`.+fn line_meets_round(far: Vec2, near: Vec2, c: Vec2, r: f64, tol: f64) -> Vec2 {+ let nearest = |[x, y]: [Vec2; 2]| if x.dist(near) <= y.dist(near) { x } else { y };+ let to_centre = c - far;+ let span = to_centre.len();+ if let Some(unit) = to_centre.normalized().filter(|_| span > r) {+ let reach = (span * span - r * r).sqrt();+ let (along, side) = (unit * (reach * reach / span), unit.perp() * (reach * r / span));+ let tangent = nearest([far + along + side, far + along - side]);+ if tangent.dist(near) <= tol + (2.0 * r * tol).sqrt() {+ return tangent;+ }+ }+ let Some(dir) = (near - far).normalized() else { return near };+ let foot = far + dir * (c - far).dot(dir);+ let half = r * r - (foot - c).len2();+ if half >= 0.0 {+ return nearest([foot + dir * half.sqrt(), foot - dir * half.sqrt()]);+ }+ (near - c).normalized().map_or(near, |unit| c + unit * r)}/// How far `p` lies from a line, arc or circle; None for any other curve.diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 7aed8bd69c..005cdea9a1 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -109,11 +109,10 @@ fn fillet_as_wide_as_a_face_rounds_it_off() {/// The owner's ruling of 2026-10-30: two edges of a 20 mm box rounded r2 in one fillet (they/// meet in a mitre at the corner (20, 0, 20), the upright edge there sharp), then the upright edge-/// r3 in a second fillet, whose tangent chain takes the mitre's seam with it. The corner is the-/// one solidcore 8ddce9016 builds for three rounds of different radii there: one patch, 10-/// faces, 7928.743041456134 mm³ (the fork's setback corner, 15 faces and 7928.142563938, waits-/// for solidcore#2310). The r2 rounds keep their names, and the r3 round and the corner's patch-/// are the second fillet's.+/// r3 in a second fillet, whose tangent chain takes the mitre's seam with it. The corner is+/// solidcore's setback corner for three rounds of different radii there (solidcore#2382): 15+/// faces, 7927.724282512234 mm³. The r2 rounds keep their names, and the r3 round and the+/// corner's six patches are the second fillet's.#[test]fn a_later_round_at_a_mitred_corner_is_blended_with_the_rounds_there() {let mut s = Session::default();@@ -135,17 +134,17 @@ fn a_later_round_at_a_mitred_corner_is_blended_with_the_rounds_there() {let second = run(&mut s, "solid.fillet", json!({"edges": [[20, 0, 10]], "radius": 3}))["feature"].as_u64().unwrap();assert!(s.model.results.iter().all(|r| r.error.is_none()), "{:?}", s.model.results);let v = volume(&mut s);- assert!((v - 7928.743041456134).abs() < 1e-6, "{v}");+ assert!((v - 7927.724282512234).abs() < 1e-6, "{v}");let faces = run(&mut s, "model.faces", json!({"body": "Box"}))["faces"].as_array().cloned().unwrap_or_default();- assert_eq!(faces.len(), 10);+ assert_eq!(faces.len(), 15);let after: Vec<String> = rounds.iter().map(|p| named(&mut s, *p)).collect();assert_eq!(after, before);// The r3 round (halfway up, at 45°) and the corner's patches: the faces the second fillet made.let k3 = 3.0 - 4.5_f64.sqrt();assert!(named(&mut s, solidcore_record::Vec3::new(20.0 - k3, k3, 10.0)).starts_with(&format!("F{second}:blend:")));let made = faces.iter().filter(|f| f["name"].as_str().is_some_and(|n| n.starts_with(&format!("F{second}:")))).count();- // the r3 round and the corner's patch- assert_eq!(made, 2, "{faces:?}");+ // the r3 round and the corner's six patches+ assert_eq!(made, 7, "{faces:?}");}#[test]diff --git a/crates/kernel/tests/boolean_props.rs b/crates/kernel/tests/boolean_props.rsindex 2393c14170..401481742f 100644--- a/crates/kernel/tests/boolean_props.rs+++ b/crates/kernel/tests/boolean_props.rs@@ -68,17 +68,14 @@ fn grid_prim() -> impl Strategy<Value = Prim> {prim(grid(), grid_size())}-/// A union across only a box edge or corner is non-manifold, so the kernel may-/// refuse it. This is the same analytic boundary case allowed by box_box_exact.+/// Two boxes that meet only along an edge or at a corner: their union is the two solids touching+/// there (non-manifold along the contact, one body, check-clean).fn edge_only_boxes(a: &Prim, b: &Prim) -> bool {let (Prim::Box { at: a, size: sa }, Prim::Box { at: b, size: sb }) = (a, b) else { return false };let gap = [0, 1, 2].map(|i| a[i].max(b[i]) - (a[i] + sa[i]).min(b[i] + sb[i]));gap.iter().all(|g| *g <= 0.0) && gap.iter().filter(|g| **g == 0.0).count() >= 2}-fn edge_contact_refusal(a: &Prim, b: &Prim, op: BoolOp, result: &Result<f64, TestCaseError>) -> bool {- op == BoolOp::Union && edge_only_boxes(a, b) && result.as_ref().is_err_and(|e| e.to_string().contains("zero-thickness edge contact"))-}fn free_prim() -> impl Strategy<Value = Prim> {prim(free(), free_size())}@@ -107,13 +104,8 @@ fn close(x: f64, y: f64, scale: f64) -> bool {fn identity(a: &Prim, b: &Prim) -> Result<(), TestCaseError> {let (ba, bb) = (a.body(), b.body());let (va, vb) = (vol(&ba), vol(&bb));- let (vu, vi, vc) = (run(&ba, &bb, BoolOp::Union), run(&ba, &bb, BoolOp::Intersect)?, run(&ba, &bb, BoolOp::Cut)?);- if edge_contact_refusal(a, b, BoolOp::Union, &vu) {- prop_assert!(close(vi, 0.0, va + vb), "edge-only contact must have no intersection volume");- } else {- let vu = vu?;- prop_assert!(close(vu + vi, va + vb, va + vb), "union+intersect {} != A+B {} (A {va:.3}, B {vb:.3}, U {vu:.3}, I {vi:.3})", vu + vi, va + vb);- }+ let (vu, vi, vc) = (run(&ba, &bb, BoolOp::Union)?, run(&ba, &bb, BoolOp::Intersect)?, run(&ba, &bb, BoolOp::Cut)?);+ prop_assert!(close(vu + vi, va + vb, va + vb), "union+intersect {} != A+B {} (A {va:.3}, B {vb:.3}, U {vu:.3}, I {vi:.3})", vu + vi, va + vb);prop_assert!(close(vc, va - vi, va + vb), "cut {vc:.3} != A-I {:.3}", va - vi);Ok(())}@@ -127,11 +119,7 @@ fn scale(a: &Prim, b: &Prim, k: f64) -> Result<(), TestCaseError> {let (ba, bb, ka, kb) = (a.body(), b.body(), sc(a).body(), sc(b).body());let s = vol(&ba) + vol(&bb);for op in [BoolOp::Union, BoolOp::Intersect, BoolOp::Cut] {- let (one, big) = (run(&ba, &bb, op), run(&ka, &kb, op));- if edge_contact_refusal(a, b, op, &one) && edge_contact_refusal(a, b, op, &big) {- continue;- }- let (one, big) = (one?, big? / (k * k * k));+ let (one, big) = (run(&ba, &bb, op)?, run(&ka, &kb, op)? / (k * k * k));prop_assert!(close(one, big, s), "{op:?} at scale 1 gives {one:.4}, at scale {k} gives {big:.4} (normalised)");}Ok(())@@ -173,11 +161,7 @@ proptest! {let (ba, bb) = (a.body(), b.body());let s = vol(&ba) + vol(&bb);for op in [BoolOp::Union, BoolOp::Intersect] {- let (ab, ba_) = (run(&ba, &bb, op), run(&bb, &ba, op));- if edge_contact_refusal(&a, &b, op, &ab) && edge_contact_refusal(&a, &b, op, &ba_) {- continue;- }- let (ab, ba_) = (ab?, ba_?);+ let (ab, ba_) = (run(&ba, &bb, op)?, run(&bb, &ba, op)?);prop_assert!(close(ab, ba_, s), "{op:?}: A,B gives {ab:.4} but B,A gives {ba_:.4}");}}@@ -192,11 +176,7 @@ proptest! {let (ta, tb) = (mv(&ba), mv(&bb));let s = vol(&ba) + vol(&bb);for op in [BoolOp::Union, BoolOp::Intersect, BoolOp::Cut] {- let (here, there) = (run(&ba, &bb, op), run(&ta, &tb, op));- if edge_contact_refusal(&a, &b, op, &here) && edge_contact_refusal(&a, &b, op, &there) {- continue;- }- let (here, there) = (here?, there?);+ let (here, there) = (run(&ba, &bb, op)?, run(&ta, &tb, op)?);prop_assert!(close(here, there, s), "{op:?} at origin {here:.4}, moved by {off} gives {there:.4}");}}@@ -240,17 +220,10 @@ proptest! {let (ba, bb) = (pa.body(), pb.body());let (va, vb) = (sa.iter().product::<f64>(), sb.iter().product::<f64>());let s = va + vb;- // Per axis: the gap between the boxes (<0 overlap, 0 touch, >0 apart).- let gap: Vec<f64> = (0..3).map(|i| a[i].max(b[i]) - (a[i] + sa[i]).min(b[i] + sb[i])).collect();- // Touching along an edge or at a corner only: a union there is not a manifold solid.- // The kernel refuses it on purpose ("zero-thickness edge contact"). Allowed, as an error.- let edge_only = gap.iter().all(|g| *g <= 0.0) && gap.iter().filter(|g| **g == 0.0).count() >= 2;prop_assert!(close(run(&ba, &bb, BoolOp::Intersect)?, overlap, s), "intersect != closed-form overlap {overlap}");prop_assert!(close(run(&ba, &bb, BoolOp::Cut)?, va - overlap, s), "cut != closed form {}", va - overlap);- match run(&ba, &bb, BoolOp::Union) {- Err(_) if edge_only => {}- r => prop_assert!(close(r?, s - overlap, s), "union != closed form {}", s - overlap),- }+ // Touching along an edge or at a corner only, the union is the two solids touching there.+ prop_assert!(close(run(&ba, &bb, BoolOp::Union)?, s - overlap, s), "union != closed form {}", s - overlap);}/// Two boxes that share part of a face must fuse into one solid. This is the most common@@ -267,25 +240,40 @@ proptest! {// Cases the property tests found, as plain tests. Ignored until the kernel bug is fixed: run them// with `cargo test -p solidcraft-kernel --test boolean_props -- --ignored`.-/// The saved commutativity case is an intentional non-manifold join refusal,-/// not a failure to join overlapping volumes. Intersection and cut remain valid.+/// The saved commutativity case: two boxes meeting only along an edge. Their union in either+/// order is the two solids touching along it, 437.5 + 625 = 1062.5; they share no volume, and+/// cutting one by the other leaves it whole.#[test]-fn edge_only_box_join_is_refused_in_both_orders() {+fn edge_only_box_join_is_the_two_solids_touching_in_both_orders() {let a = Prim::Box { at: [15.0, 22.5, 0.0], size: [5.0, 5.0, 17.5] };let b = Prim::Box { at: [2.5, 12.5, 0.0], size: [12.5, 10.0, 5.0] };assert!(edge_only_boxes(&a, &b));assert!(!edge_only_boxes(&a, &Prim::Box { at: [15.0, 22.5, 0.0], size: [5.0, 5.0, 5.0] }));let (a, b) = (a.body(), b.body());for (left, right) in [(&a, &b), (&b, &a)] {- let error = run(left, right, BoolOp::Union).expect_err("an edge-only join is non-manifold");- assert!(error.to_string().contains("zero-thickness edge contact"), "{error}");+ let union = run(left, right, BoolOp::Union).unwrap();+ assert!(close(union, 1062.5, 1062.5), "{union}");assert_eq!(run(left, right, BoolOp::Intersect).unwrap(), 0.0);assert!(close(run(left, right, BoolOp::Cut).unwrap(), vol(left), vol(left)));}}+/// Two boxes meeting at one corner: their union is the two solids touching there, 125 + 125.+#[test]+fn corner_only_box_join_is_the_two_solids_touching() {+ let a = Prim::Box { at: [0.0, 0.0, 0.0], size: [5.0, 5.0, 5.0] };+ let b = Prim::Box { at: [5.0, 5.0, 5.0], size: [5.0, 5.0, 5.0] };+ assert!(edge_only_boxes(&a, &b));+ let (a, b) = (a.body(), b.body());+ for (left, right) in [(&a, &b), (&b, &a)] {+ let union = run(left, right, BoolOp::Union).unwrap();+ assert!(close(union, 250.0, 250.0), "{union}");+ assert_eq!(run(left, right, BoolOp::Intersect).unwrap(), 0.0);+ }+}+/// The saved scale-invariance failure: these boxes meet at y=30, z=20 along an-/// edge, so a join is refused at every scale. Intersection and cut still scale.+/// edge, and every operation, the union of the two solids touching there among them, scales.#[test]fn edge_only_box_contact_is_scale_invariant() {let a = Prim::Box { at: [0.0, 15.0, 7.5], size: [7.5, 15.0, 12.5] };diff --git a/crates/smlib/src/core.rs b/crates/smlib/src/core.rsindex f2a6475133..2e1a6a4d26 100644--- a/crates/smlib/src/core.rs+++ b/crates/smlib/src/core.rs@@ -6,7 +6,6 @@//! fork fixed in its own sources; each one turned on here says which fork commit it matches.use std::panic::{AssertUnwindSafe, catch_unwind};-use std::sync::atomic::{AtomicU64, Ordering};use std::sync::{Mutex, PoisonError};use solidcore::geom::attribute::{AttributeStore, ObjectKey};@@ -108,7 +107,6 @@ pub(crate) fn fixes() -> UpstreamFixes {f.offset_resolve_crossing_loops = true;f.offset_walls_touch_refused = true;f.offset_analytic_mate_edges = true;- f.precise_properties_split_at_surface_knots = true;f.nurb_cylinder_inside_out_frame = true;f.shell_inner_shell_of_statuses = true;f.local_operation_offset_status = true;@@ -147,13 +145,10 @@ pub(crate) fn fixes() -> UpstreamFixes {f.torus_signed_gen_curve_interval = true;f.sheet_sweep_joins_profile_wires = true;f.point_solve_keeps_triangle_guess = true;- f.fillet_setback_from_start_vertex = true;f.imprint_trims_edge_to_proto_vertex = true;f.imprint_extends_edge_to_proto_vertex = true;f.fillet_point_step_per_point = true;f.analytic_copy_keeps_parameterization = true;- f.fillet_point_bigger_step_retry = true;- f.fillet_through_extended_rail_end = true;f.precise_properties_body_length_scale = true;f.offset_extension_from_base = true;f.corner_blend_stays_inside_neighbours = true;@@ -174,11 +169,9 @@ pub(crate) fn fixes() -> UpstreamFixes {f.boolean_skips_faces_apart = true;f.uv_trim_checks_on_surface = true;f.loop_orientation_floor_from_loop_box = true;- f.offset_extends_cones_as_themselves = true;f.local_operation_box_holds_new_surfaces = true;f.uv_trim_joins_drop_pieces = true;f.shell_edges_on_analytics_exact = true;- f.ssi_no_reverse_of_empty_trace = true;f.ssi_pole_point_keeps_its_tangent = true;f.iso_curve_sliver_domain_is_degenerate = true;f.corner_blend_coons_patch_tangent_to_sides = true;@@ -230,7 +223,6 @@ pub(crate) fn fixes() -> UpstreamFixes {f.fillet_cleanup_removes_input_slits = true;f.fillet_rail_end_on_continued_surface = true;f.glue_vertices_joins_every_region = true;- f.fillet_nx1_tangent_side_edge_same_convexity = true;f.fillet_removal_takes_ring_fillets = true;// The fork's commits that reached `SMLIB_REV` at eaa998a (tangency-labs/smlib#68, #69, #70).f.fillet_trim_inside_by_best_dot = true;@@ -274,9 +266,7 @@ pub(crate) fn fixes() -> UpstreamFixes {f.offset_keep_cavity_regions = true;f.offset_four_face_vertex_split = true;f.gap_samples_non_bspline_v_stride = true;- f.gap_array_append_updates_longest = true;f.imprint_skips_collapsed_definition = true;- f.precise_properties_trim_base_v = true;f.fillet_blend_curve_revolved_on_arc = true;f.temporary_radius_setup_errors = true;f.ellipse_step_interval_checks = true;@@ -319,7 +309,6 @@ pub(crate) fn fixes() -> UpstreamFixes {f.circle_silhouette_perspective_center = true;f.ellipse_convert_to_2d_uses_both_axes = true;f.circle_offset_antiparallel_normal = true;- f.masked_array_uses_bit_shift = true;f.global_solver_identical_prefers_larger_when_maximizing = true;f.surface_continuity_checks_last_v_knot = true;f.surface_point_solver_propagates_bbox_failure = true;@@ -331,7 +320,6 @@ pub(crate) fn fixes() -> UpstreamFixes {f.crv_in_volume_mults_by_break_index = true;f.curve_bounded_surface_read_uv_type_and_implicit_outer = true;f.polar_box_region_to_arc_transposes_domain = true;- f.point_set_centroid_all_blocks = true;f.local_solve1d_unbounded_newton_step = true;f.composite_curve_bbox_segment_intervals = true;f.knot_vector_valid_requires_span = true;@@ -339,14 +327,12 @@ pub(crate) fn fixes() -> UpstreamFixes {f.curve_property_gs_branch_bounds = true;f.volume_representational_end_continuities = true;f.integrator_propagates_failure = true;- f.precise_properties_span_end_from_below = true;f.offset_open_edge_second_trim_point = true;f.close_loop_relates_only_coincident_edges = true;f.ssi_split_curves_at_singular_points = true;f.surface_parallel_to_vector_checks = true;f.fillet_round_ends_at_tangent_continuation = true;f.geometric_g2_continuity = true;- f.hash_table_grow_preserves_removed_records = true;f.bend_volume_bbox_contains_wide_angle_and_inf_u = true;f.bend_volume_trim_param_box_across_period = true;f.point_set_tight_pbox_projects_points = true;@@ -376,8 +362,6 @@ pub(crate) fn fixes() -> UpstreamFixes {f.fillet_overflow_trim_at_creases = true;f.fillet_section_end_trim_at_creases = true;f.fillet_refuse_mixed_corner_crossing_rails = true;- f.fillet_keep_features = true;- f.fillet_blend_corner = true;f.fillet_exact_arc_sections = true;f.fillet_exact_arc_spans = true;// Held back: see `HELD_BACK`.@@ -385,11 +369,21 @@ pub(crate) fn fixes() -> UpstreamFixes {f.cone_unbounded_parameterized_as_nurb = true;f.ellipse_open_arc_keeps_end_angle = true;f.fillet_round_as_definition = true;- f.fillet_round_on_round_as_definition = true;f.fillet_overflow_crease_along_edge = true;f.plane_first_torus_section_exact = true;f.keep_exact_pcurves = true;f.shell_one_construction = true;+ f.approximate_surface_checks_every_row = true;+ f.topological_vertex_has_only_edge_uses = true;+ f.planar_section_face_tolerance = true;+ f.face_swap_uv_transposes_trims = true;+ f.closed_smooth_pole_tangent_limit = true;+ // Held back: see `HELD_BACK`.+ f.fillet_round_ends_on_outline = false;+ f.fillet_setback_beside_curved_faces = true;+ f.fillet_chamfer_corner = true;+ f.brep_ray_classifies_current_trims = true;+ f.revolution_frame_from_profile_origin = true;f}@@ -399,29 +393,31 @@ pub(crate) fn fixes() -> UpstreamFixes {/// the fork doesn't have stays on, and where solidcore builds what SMLib refuses, a result right/// against its closed form is a win.///-/// `fillet_refuse_rounds_breaking_through` (WR-707, solidcore#2311): sound geometry refused. With it-/// on, 11 rig cases that pass with it off, each graded against its closed form or invariants, are-/// refused as breaking through the part (190-fillet-disc-rim-past-its-2mm-wall fails status 1001-/// instead): every-hole-top-rim-r12-past-plate-bottom, 1080-chamfer-runs-into-openings-cut-by-them-/// (3350, its closed form), 1080-fillet-notched-block-top-outline-r8,-/// 324-fillet-over-hole-cut-by-overlong-cylinder, 324-fillet-over-hole-overlap,-/// 5158-fillet-adjacent-plate-edges-as-thick-as-plate and the sloped and equal-slope basin rims of-/// #1080 and #5835. A fix under the same flag is in progress on solidcore.+/// `fillet_refuse_rounds_breaking_through` (WR-707, solidcore#2311): sound geometry refused. At+/// solidcore 9856ffee5, with it on, the fillet rig's 1668-fillet-both-sides-of-thin-wall-r7 is+/// refused as breaking through the wall into the hollow behind it ("the largest radius that fits is+/// 6.828 mm"), where with it off it builds the closed form, 39509.938 (at 8ddce9016 it refused 11+/// rig cases that pass with it off; at this pin the other 270 fillet rig cases come out as with it+/// off).+///+/// `fillet_round_ends_on_outline` (WR-730, solidcore#2541): volumes wrong against their closed+/// forms, and rounds too big for their faces built instead of refused. With it on, each of these+/// passes with it off: `fillet_over_a_cliff` measures 721.832 against the closed form's 693.205;+/// `a_round_wider_than_its_faces_overflows_onto_its_tangent_sides` 6125.719 against 6107.529;+/// `taper_follows_the_room_along_the_edge` 4210.926 against 4195.579; the round larger than the+/// cube in `hostile_inputs_are_errors` builds (4773.168 against the 1094.853 its refusal leaves),+/// as do the fillets the CLI's `run_strict` and `json_out` tests need to fail; and+/// `a_corner_round_wider_than_its_faces_overflows_and_takes_the_corners_other_edges`,+/// `overflow_goes_first`, `corners_refuse_what_they_cannot_build` and+/// `fillet_edge_removed_by_a_larger_overflowing_round_is_noted` are refused (too large, no room,+/// status 1001), where with it off they build. Measured again at solidcore 9856ffee5: the same.#[cfg(test)]-const HELD_BACK: &[&str] = &["fillet_refuse_rounds_breaking_through"];--/// How far apart two kernels' procedural blend serials start. A body keeps the serials of the-/// kernel that made it and may be used on any other, whose memo of solved stations is keyed by-/// serial alone: the ranges keep one definition's stations from answering for another's. A serial-/// only names a definition, so which range one comes from changes no answer.-pub(crate) const BLEND_SERIALS_PER_KERNEL: u64 = 1 << 40;+const HELD_BACK: &[&str] = &["fillet_refuse_rounds_breaking_through", "fillet_round_ends_on_outline"];-/// A new kernel. Each takes the next range of blend serials, the first starting at 0.+/// A new kernel, with this backend's fixes.fn fresh() -> Kernel {- static MADE: AtomicU64 = AtomicU64::new(0);let mut k = Kernel::new(&KernelOptions::default());k.fixes = fixes();- k.blend_last_serial.set(MADE.fetch_add(1, Ordering::Relaxed).wrapping_mul(BLEND_SERIALS_PER_KERNEL));k}diff --git a/crates/smlib/src/core/blend.rs b/crates/smlib/src/core/blend.rsindex 930927751e..9e4ef013a5 100644--- a/crates/smlib/src/core/blend.rs+++ b/crates/smlib/src/core/blend.rs@@ -1,7 +1,7 @@//! Fillets and chamfers on solidcore: the C API's composition round SMLib's fillet executive,//! ported from the fork's `capi/src/smlib_ops.cpp` (`blend_call`, `round_edges`,-//! `chamfer_offsets`, `chamfer_edges`, `chamfer_radius`, `outer_faceuse`, `face_frame`,-//! `sides_offsets`, `blend_failure`, `setbacks_fit`, `overflow_first`, `Picked`,+//! `chamfer_edges`, `outer_faceuse`, `face_frame`,+//! `blend_failure`, `setbacks_fit`, `overflow_first`, `Picked`,//! `size_ok`, `points_ok`, `tolerance_ok`, `law_ok`, `law_pinches`, `law_along`, `finish`,//! `smlib_fillet`, `smlib_chamfer`, `smlib_blend`, `smlib_blend_dropping`, `smlib_blend_setback`,//! `smlib_blend_setback_open`, `smlib_fillet_variable`, `smlib_chamfer_sides`) and@@ -25,6 +25,7 @@ use std::sync::PoisonError;use solidcore::EntityRef;use solidcore::SolidError;use solidcore::blend::blend_corner::BlendCornerEvent;+use solidcore::blend::chamfer_side::faces_along;use solidcore::blend::fillet_corner::p3::MIXED_CORNER_RAILS_CROSS;use solidcore::blend::fillet_executive::p1::{FilletLaw, FilletLawKind};use solidcore::blend::fillet_executive::p3::{ErrorInfo, FitKind, NoRoomReason};@@ -40,6 +41,7 @@ use solidcore::nurbs::b_spline_curve::p1::{BSplineCurve, BSplineCurveForm, Canonuse solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;use solidcore::query::api_queries::edge_closest_point;use solidcore::query::brep::evaluate_surface_normal;+use solidcore::surface::procedural_blend::chamfer::ChamferSize;use solidcore::topology::brep::p1 as brep_p1;use solidcore::topology::brep::p2 as brep_p2;use solidcore::topology::brep::p2::ArenaNotifyState;@@ -222,30 +224,7 @@ fn mid(b: &Brep, e: EdgeId) -> solidcore::Result<f64> {Ok(b.edge(e)?.interval.evaluate(0.5))}-/// `chamfer_radius`: the radius of the ball whose tangent points on the two faces of `e` lie-/// `distance` back from the edge at its midpoint, `distance * tan(a / 2)` with `a` the angle-/// between the directions into the faces; at a cusp (a knife edge) `distance` itself, the ball-/// whose contacts the chamfer joins. `None` where the capi's returns false.-fn chamfer_radius(k: &Kernel, b: &mut Brep, e: EdgeId, distance: f64) -> solidcore::Result<Option<f64>> {- let Some(u0) = edge::blend_edgeuse(k, b, e)? else { return Ok(None) };- let Some(u1) = eu_p1::radial(b, u0)? else { return Ok(None) };- let t = mid(b, e)?;- let options = BinormalOptions::default();- let Some(e0) = answer(evaluate_binormal(k, b, u0, t, false, &options))? else { return Ok(None) };- let Some(e1) = answer(evaluate_binormal(k, b, u1, t, false, &options))? else { return Ok(None) };- // Unitize's failure (a zero vector) is the capi's `return false`.- let (Ok(n0), Ok(b0), Ok(b1)) = (e0.face_normal.unitize(), e0.binormal.unitize(), e1.binormal.unitize()) else { return Ok(None) };- let c = b0.dot(b1).clamp(-1.0, 1.0);- // At a cusp (a knife edge: the faces tangent within the half degree `GetBlendEdgeuse` calls- // tangent, folded back on each other, the binormals the same way) a is 0 and no ball lies- // `distance` back along both: the chamfer is the chord between the contacts of the ball of- // radius `distance` (fork e96898d).- let cusp = c > 0.0 && b1.dot(n0).abs() < (0.5 * std::f64::consts::PI / 180.0).sin();- let radius = if cusp { distance } else { distance * ((1.0 - c) / (1.0 + c)).sqrt() };- Ok((radius.is_finite() && radius > 0.0).then_some(radius))-}--/// What `round_edges` makes: the capi's kinds less the chamfer, which `chamfer_offsets` makes.+/// What `round_edges` makes.#[derive(Clone, Copy, PartialEq)]enum Section<'a> {/// A circular section of constant radius (or of a variable radius's law), the turns of two@@ -256,9 +235,13 @@ enum Section<'a> {/// `fillet_gn_section_generator`), which takes off what the ball's circle does.Curvature,Chord,- /// A chamfer, with each edge's offset of its second surface (`chamfer_offsets`' `second`;- /// the sizes are the first's).- Chamfer(&'a [f64]),+ /// A chamfer of the sizes asked: one for all the edges or one per edge, and for each edge+ /// the face its first size is along (empty: the blend edge use's). The kernel makes their+ /// offsets, one pair for a tangent chain of one size.+ Chamfer {+ sizes: &'a [ChamferSize],+ along: &'a [FaceId],+ },}/// The faces of `b`, for `made_faces`: a face whose id is new after the operation was made by@@ -373,13 +356,23 @@ fn blend_failure_unsized(info: &ErrorInfo<FilletObject>, e: SolidError, corner:}/// `e` ([`Error::TooLarge`]) with the point at the middle of `edge` of `b`, the edge its size was-/// found for; an equal chamfer's size (its ball's radius, [`chamfer_radius`]) as its distance.-/// Where the edge or its point can't be read the size stays as it is, with no point (a chamfer's-/// size then is not a distance, so it is left a plain refusal).-fn sized_on(k: &Kernel, b: &mut Brep, edge: Option<EdgeId>, section: Section<'_>, e: Error) -> solidcore::Result<Error> {+/// found for; an equal chamfer's size (an offset, [`Section::Chamfer`]) as its distance, by the+/// edge's own ratio of the distance asked to the offset the kernel made of it (`chamfered`: per+/// edge of an equal chamfer, the two). Where the edge or its point can't be read the size stays+/// as it is, with no point (a chamfer's size then is not a distance, so it is left a plain+/// refusal).+fn sized_on(+ k: &Kernel,+ b: &mut Brep,+ edge: Option<EdgeId>,+ section: Section<'_>,+ chamfered: &[(EdgeId, f64, f64)],+ e: Error,+) -> solidcore::Result<Error> {let Error::TooLarge { size, kind, why, .. } = e else { return Ok(e) };+ let chamfer = matches!(section, Section::Chamfer { .. }) && kind == crate::FitKind::Radius;let Some(edge) = edge else {- return Ok(if matches!(section, Section::Chamfer(_)) && kind == crate::FitKind::Radius { Error::NoRoom } else { e });+ return Ok(if chamfer { Error::NoRoom } else { e });};let at = match b.edge(edge) {Ok(rec) => match rec.curve.as_ref() {@@ -388,11 +381,13 @@ fn sized_on(k: &Kernel, b: &mut Brep, edge: Option<EdgeId>, section: Section<'_>},Err(_) => None,};- if matches!(section, Section::Chamfer(_)) && kind == crate::FitKind::Radius {- // The ball's radius is linear in the chamfer's distance along an edge.- return Ok(match chamfer_radius(k, b, edge, 1.0)? {- Some(per_mm) => Error::TooLarge { size: size / per_mm, kind: crate::FitKind::Distance, at, why },- None => Error::NoRoom,+ if chamfer {+ // The offset is linear in the distance along an edge.+ return Ok(match chamfered.iter().find(|(e, ..)| *e == edge) {+ Some(&(_, distance, offset)) if offset > 0.0 => {+ Error::TooLarge { size: size / offset * distance, kind: crate::FitKind::Distance, at, why }+ }+ _ => Error::NoRoom,});}Ok(Error::TooLarge { size, kind, at, why })@@ -450,6 +445,8 @@ fn blend_edges_stopping(let before = face_set(b)?;// The edge a sized refusal names ([`blend_failure`]), read after the session lets `b` go.let mut fit_edge = None;+ // An equal chamfer's edges, each with its distance and the offset the kernel made of it.+ let mut chamfered: Vec<(EdgeId, f64, f64)> = Vec::new();let done = {let mut s = FilletSession::new(k, b)?;// `SetSweptTurns`: read as the corners are made (`fixes.fillet_blend_corner`).@@ -471,12 +468,21 @@ fn blend_edges_stopping(s.prepare_per_edge_constant_radius(k, edges, sizes, &[FilletSurfaceGeneratorType::BlendCurve], 2, GN_THUMBWEIGHT_EQUAL_AREA)}(Section::Chord, _) => s.prepare_per_edge_constant_distance(k, edges, sizes, &[FilletSurfaceGeneratorType::Circular], 1, 1.0),- (Section::Chamfer(second), _) => chamfer_parameters(k, &mut s, edges, sizes, second),+ (Section::Chamfer { sizes, along }, _) => s.prepare_chamfers_along(k, edges, sizes, along).map(|offsets| {+ for (i, (&e, [r, _])) in edges.iter().zip(offsets).enumerate() {+ let size = sizes.get(if sizes.len() == 1 { 0 } else { i });+ if let Some(&ChamferSize::Distances([d, d2])) = size+ && d == d2+ {+ chamfered.push((e, d, r));+ }+ }+ }),};// `AddSetBackVertex` for each set-back vertex, before the corners are made: a set-back// vertex is no Ball (`IsSetBackVertex`, read by `ClassifyBall`), so its corner is the one// the setback is set on.- if !matches!(section, Section::Chamfer(_)) {+ if !matches!(section, Section::Chamfer { .. }) {for sb in setbacks {s.add_set_back_vertex(sb.vertex);}@@ -529,7 +535,7 @@ fn blend_edges_stopping(Err(refusal) => {b.refresh_cached_topology();return Ok(Err(match refusal {- Err(e @ Error::TooLarge { .. }) => Err(sized_on(k, b, fit_edge, section, e)?),+ Err(e @ Error::TooLarge { .. }) => Err(sized_on(k, b, fit_edge, section, &chamfered, e)?),r => r,}));}@@ -571,16 +577,6 @@ fn blend_edges_stopping(Ok(Ok(()))}-/// `chamfer_offsets`' `SetFilletParameters(b, es, kinds, solvers, first, NULL, -1, -1, -1, -1,-/// 1, 1.0, &second)` with every kind `SM_FSG_LINEAR` and every solver `SM_FS_CONST_RADIUS`, as the-/// fork's `SetFilletParameters` runs it (its `pOptSecondRadii`, fork f653ac9).-fn chamfer_parameters(k: &mut Kernel, s: &mut FilletSession<'_>, edges: &[EdgeId], first: &[f64], second: &[f64]) -> solidcore::Result<()> {- if edges.is_empty() {- return Ok(());- }- s.prepare_per_edge_constant_radius_with_second(k, edges, first, second, &[FilletSurfaceGeneratorType::Linear], 1, 1.0)-}-/// The corners' part of `round_edges` / `chamfer_offsets`: a chamfer's corners bevelled; each/// setback set on its vertex's corner (`GetFilletCornerOfVertex`), which must be an/// `SM_FCR_N_x_N_CONVEX` corner or a blend corner whose event is the setback (`SM_FCR_BLEND` with@@ -592,7 +588,7 @@ fn corners(setbacks: &[SetBack],) -> solidcore::Result<std::result::Result<Vec<usize>, std::result::Result<usize, Error>>> {let ids = s.fillet_corners()?;- if matches!(section, Section::Chamfer(_)) {+ if matches!(section, Section::Chamfer { .. }) {for id in ids {s.set_corner_bevel(id, true)?;}@@ -936,16 +932,11 @@ fn blend_call(Blend::Curvature if !one_wedge(k, &mut w, &picked)? => return Ok(Err(Error::Unported(CURVATURE_MIXED_WEDGES))),Blend::Curvature => Section::Curvature,Blend::Chord => Section::Chord,- // `chamfer_edges`: each edge's offsets from its setback at its midpoint.+ // `chamfer_edges`: the sizes asked; the kernel makes each edge's offsets.Blend::Chamfer => {- let mut radii = Vec::with_capacity(picked.len());- for (&e, &d) in picked.iter().zip(&each) {- match chamfer_radius(k, &mut w, e, d)? {- Some(r) => radii.push(r),- None => return Ok(Err(Error::Status(INVALID_INPUT))),- }- }- return Ok(match blend_edges(k, &mut w, &picked, &radii, Section::Chamfer(&radii), None, &[], None)? {+ let chamfers: Vec<ChamferSize> = each.iter().map(|&d| ChamferSize::Distances([d, d])).collect();+ let section = Section::Chamfer { sizes: &chamfers, along: &[] };+ return Ok(match blend_edges(k, &mut w, &picked, &[], section, None, &[], None)? {Ok(()) => finish(w, solid_in)?,Err(Ok(_)) => Err(Error::Unsupported),Err(Err(e)) => Err(e),@@ -1165,39 +1156,6 @@ fn face_frame(k: &Kernel, b: &mut Brep, u: EdgeuseId) -> solidcore::Result<OptioOk(Some((normal * (sign / len), at.binormal)))}-/// `sides_offsets`: the surface offsets of `e` (its blend edge use's surface first) at which-/// `chamfer_offsets` cuts a chamfer `d1` back along the face whose outward normal at the edge's-/// midpoint leans most along `up`, and `second` back along the other (or at the angle `second`-/// to the first face). With b0, b1 the directions into the faces and θ the angle between them,-/// setbacks s0, s1 lie at offsets r0 = (s1 - s0 cos θ) / sin θ and r1 = (s0 - s1 cos θ) / sin θ;-/// an angle φ to the first face gives s1 = s0 sin φ / sin(θ + φ).-fn sides_offsets(k: &Kernel, b: &mut Brep, e: EdgeId, d1: f64, second: ChamferSecond, up: Vec3) -> solidcore::Result<Option<(f64, f64)>> {- let Some(u0) = edge::blend_edgeuse(k, b, e)? else { return Ok(None) };- let Some(u1) = eu_p1::radial(b, u0)? else { return Ok(None) };- let (Some((n0, b0)), Some((n1, b1))) = (face_frame(k, b, u0)?, face_frame(k, b, u1)?) else { return Ok(None) };- let c = b0.dot(b1).clamp(-1.0, 1.0);- let sn = (1.0 - c * c).max(0.0).sqrt();- if !(sn > 1e-6) {- return Ok(None);- }- let mut s0 = d1;- let mut s1 = match second {- ChamferSecond::Distance(d) => d,- ChamferSecond::Angle(phi) => {- let d = (c.acos() + phi).sin();- if !(d > 1e-9) {- return Ok(None);- }- d1 * phi.sin() / d- }- };- if n1.dot(up) > n0.dot(up) {- std::mem::swap(&mut s0, &mut s1);- }- let (r0, r1) = ((s1 - s0 * c) / sn, (s0 - s1 * c) / sn);- Ok((r0.is_finite() && r1.is_finite() && r0 > 0.0 && r1 > 0.0).then_some((r0, r1)))-}-/// `smlib_chamfer_sides`: the edges nearest `points` chamfered `distance` back along the face/// whose outward normal leans most along `first`, and by `second` on the other, with bevelled/// corners.@@ -1219,17 +1177,20 @@ pub(crate) fn chamfer_sides(body: &Body, points: &[[f64; 3]], tolerance: f64, diErr(m) => return Ok(Err(edge_miss(m))),};let solid_in = brep_p2::is_manifold_solid(&w)?;- let (mut r0, mut r1) = (Vec::with_capacity(picked.len()), Vec::with_capacity(picked.len()));+ // The first size is along the face leaning most along `up`.+ let mut along = Vec::with_capacity(picked.len());for &e in &picked {- match sides_offsets(k, &mut w, e, distance, second, up)? {- Some((a, b)) => {- r0.push(a);- r1.push(b);- }+ match answer(faces_along(k, &mut w, e, up))? {+ Some([(f0, l0), (f1, l1)]) => along.push(if l1 > l0 { f1 } else { f0 }),None => return Ok(Err(Error::Status(INVALID_INPUT))),}}- Ok(match blend_edges(k, &mut w, &picked, &r0, Section::Chamfer(&r1), None, &[], None)? {+ let size = match second {+ ChamferSecond::Distance(d) => ChamferSize::Distances([distance, d]),+ ChamferSecond::Angle(angle) => ChamferSize::DistanceAngle { distance, angle },+ };+ let section = Section::Chamfer { sizes: std::slice::from_ref(&size), along: &along };+ Ok(match blend_edges(k, &mut w, &picked, &[], section, None, &[], None)? {Ok(()) => finish(w, solid_in)?,Err(Ok(_)) => Err(Error::Unsupported),Err(Err(e)) => Err(e),diff --git a/crates/smlib/src/core/offset.rs b/crates/smlib/src/core/offset.rsindex 25d1d3a6f6..13fb5dcaf5 100644--- a/crates/smlib/src/core/offset.rs+++ b/crates/smlib/src/core/offset.rs@@ -18,6 +18,8 @@use solidcore::EntityRef;use solidcore::SolidError;+use solidcore::error::offset::OffsetFailure;+use solidcore::error::{ErrorKind, Reason};use solidcore::geom::attribute::{Attribute, Behavior, ids};use solidcore::geom::axis2_placement::Axis2Placement;use solidcore::geom::object::Shape;@@ -29,7 +31,6 @@ use solidcore::nurbs::b_spline_curve::ControlPointForm;use solidcore::nurbs::b_spline_surface::p1::SurfParamType;use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;use solidcore::nurbs::knots::Side;-use solidcore::offset::construction::ShellRefusal;use solidcore::offset::offset_executive::p2::{OffsetOptions, ShellOptions, local_operation_simple, offset_brep_simple, shell_brep_simple};use solidcore::offset::offset_faces::{OffsetFacesExecutive, OffsetFacesRefusal};use solidcore::query::api_queries::{face_bounding_box, face_classify_uv, face_closest_point_in_shape, face_internal_point};@@ -50,21 +51,23 @@ type Out<T> = std::result::Result<T, Error>;/// `SM_ERR_INVALID_INPUT`.const INVALID_INPUT: i32 = 1007;-/// `SM_ERR_OFFSET_WALLS_TOUCH` (fork a759622), which `status` (smlib_shim.h) reports as-/// `SMLIB_ERR_WALLS_TOUCH`.-const OFFSET_WALLS_TOUCH: i32 = 1042;-/// `status` (smlib_shim.h): an offset whose walls touch is [`Error::WallsTouch`]; a vertex moved/// past an edge's other end (`SM_ERR_OFFSET_EDGE_VANISHES`, fork 34318f4) is/// `SMLIB_ERR_UNSUPPORTED`; a wall whose face's offset folds, which solidcore's one construction/// refuses (`fixes.shell_one_construction`, solidcore#2367), is [`Error::WallFolds`] with the-/// largest wall it names; any other status as the blends pass it on.+/// largest wall it names; any other status as the blends pass it on. solidcore names an offset's+/// refusals by their kind and reason (its errors in its own terms, solidcore#2654), whichever+/// status the pinned C++ gives them.fn status(e: SolidError) -> Error {- match e {- SolidError::Upstream { code: OFFSET_WALLS_TOUCH, .. } => Error::WallsTouch,- SolidError::ShellRefused { refusal: ShellRefusal::Fold, size, .. } => Error::WallFolds { largest: size },- e if e.is_offset_edge_vanishes() => Error::Unsupported,- e => blend_status(e),+ if let SolidError::Failed(f) = &e+ && let Reason::Offset(OffsetFailure::Folds { largest, .. }) = f.reason+ {+ return Error::WallFolds { largest: Some(largest) };+ }+ match e.kind() {+ ErrorKind::OffsetWallsTouch => Error::WallsTouch,+ ErrorKind::OffsetEdgeVanishes => Error::Unsupported,+ _ => blend_status(e),}}diff --git a/crates/smlib/src/core/offset_tests.rs b/crates/smlib/src/core/offset_tests.rsindex acfe8d0551..0eb77a3522 100644--- a/crates/smlib/src/core/offset_tests.rs+++ b/crates/smlib/src/core/offset_tests.rs@@ -546,9 +546,8 @@ fn offset_faces_close_a_step_wall() {/// Rig case shell/4492's rounded box: four mitred rounds, r 3, come off a 40 x 30 x 10 box's top/// together and follow it. From height 0 the outline is the 34 x 24 top moved out by the round's/// w(z) = sqrt(9 - (z - axis)^2), or 3 below the axis. With the fork's values at +19, and bodies-/// whose rounds go all the way down from -7 and are cut short from -7.5 (solidcore#2027). At -9-/// solidcore refuses to put the rounds back (solidcore#2020, open): SolidCraft says it does not-/// make that move.+/// whose rounds go all the way down from -7 and are cut short from -7.5 (solidcore#2027). At -9,+/// which solidcore refused before 9856ffee5 (solidcore#2020), it builds the closed form too.#[test]fn mitred_rounds_follow_a_moved_top() {use super::blend::{Corners, blend};@@ -574,6 +573,7 @@ fn mitred_rounds_follow_a_moved_top() {(-7.0, [6, 12, 8]),(-7.5, [6, 12, 8]),(-8.0, [6, 12, 8]),+ (-9.0, [6, 12, 8]),(-9.5, [6, 12, 8]),];for (d, n) in moves {@@ -582,7 +582,6 @@ fn mitred_rounds_follow_a_moved_top() {assert_eq!(counts(&moved).unwrap(), n, "d {d}");assert!(rel(v, analytic(d)) < 1e-6, "d {d}: {v} vs {}", analytic(d));}- assert!(matches!(offset_faces(&rounded, &[top], 0.1, -9.0), Err(Error::Unsupported)));}/// `moved_faces`: drafts so small they leave a plane or cylinder where it was still moved a facediff --git a/crates/smlib/src/core/trim.rs b/crates/smlib/src/core/trim.rsindex 8d9d8d44be..06b94f0d4b 100644--- a/crates/smlib/src/core/trim.rs+++ b/crates/smlib/src/core/trim.rs@@ -24,21 +24,20 @@use std::sync::PoisonError;-use solidcore::EntityRef;use solidcore::curve::curve::Curve;use solidcore::geom::extent2d::Extent2d;-use solidcore::geom::geom_utility::p2::ContinuityType;use solidcore::geom::object::Shape;use solidcore::geom::tol::USE_DEFAULT;use solidcore::geom::vector2d::Point2;use solidcore::geom::vector3d::{Point3, Vec3};use solidcore::kernel::Kernel;-use solidcore::nurbs::b_spline_surface::p1::SurfParamType;use solidcore::nurbs::b_spline_surface_n_lib::p2::EvaluateFlags;use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;use solidcore::query::api_queries::{edge_closest_point, face_closest_point_in_shape, face_internal_point};use solidcore::query::brep::{BrepQuery, LiveBrepObjects};use solidcore::surface::cone::p1::Cone;+use solidcore::surface::extend::Continuity;+use solidcore::surface::side::BoxSide;use solidcore::surface::surface::Surface;use solidcore::surface::surface::SurfaceKind;use solidcore::topology::brep::p1 as brep_p1;@@ -54,6 +53,7 @@ use solidcore::topology::face::{p1 as face_p1, p2 as face_p2, p4 as face_p4};use solidcore::topology::loopuse::{loop_edges, loop_loopuses, notify_ref};use solidcore::topology::topology_traverser::Marks;use solidcore::topology::{Brep, BrepId, EdgeId, FaceId, LoopId, edge};+use solidcore::{EntityRef, SolidError};use super::blend::{p3, status};use super::sweep::build_faces;@@ -454,17 +454,17 @@ pub(crate) fn untrim_face(body: &Body, point: [f64; 3], tol: f64, holes: Option</// grows in u), and whether it is at the box's max.#[derive(Clone, Copy)]struct Side {- which: SurfParamType,+ which: BoxSide,u: bool,high: bool,}/// `SIDES`.const SIDES: [Side; 4] = [- Side { which: SurfParamType::UMin, u: true, high: false },- Side { which: SurfParamType::UMax, u: true, high: true },- Side { which: SurfParamType::VMin, u: false, high: false },- Side { which: SurfParamType::VMax, u: false, high: true },+ Side { which: BoxSide::UMin, u: true, high: false },+ Side { which: BoxSide::UMax, u: true, high: true },+ Side { which: BoxSide::VMin, u: false, high: false },+ Side { which: BoxSide::VMax, u: false, high: true },];/// `SAMPLES`.@@ -546,55 +546,6 @@ fn side_edge(k: &Kernel, b: &Brep, surf: &Surface, dom: &Extent2d, s: Side, edgee.filter(|_| d <= on)}-/// `across`: how far `ext` (the face's surface extended past side `s` of its box `dom`, on the-/// same parameters) runs past that side, measured across it through the side's middle, by-/// 16-point Gauss-Legendre quadrature on 64 pieces. Negative when it can't be evaluated.-fn across(k: &Kernel, ext: &Surface, dom: &Extent2d, s: Side) -> f64 {- const X: [f64; 8] = [- 0.0950125098376374,- 0.2816035507792589,- 0.4580167776572274,- 0.6178762444026438,- 0.755404408355003,- 0.8656312023878318,- 0.9445750230732326,- 0.9894009349916499,- ];- const W: [f64; 8] = [- 0.1894506104550685,- 0.1826034150449236,- 0.1691565193950025,- 0.1495959888165767,- 0.1246289712555339,- 0.0951585116824928,- 0.0622535239386479,- 0.0271524594117541,- ];- const PIECES: usize = 64;- let Ok(bx) = ext.natural_uv_domain_with_nurb(k) else { return -1.0 };- let mid = on_side(dom, s, 0.5);- let from = if s.u { mid.x } else { mid.y };- let to = match (s.u, s.high) {- (true, true) => bx.max().x,- (true, false) => bx.min().x,- (false, true) => bx.max().y,- (false, false) => bx.min().y,- };- let h = (to - from) / PIECES as f64;- let mut length = 0.0;- for piece in 0..PIECES {- let c = from + (piece as f64 + 0.5) * h;- for i in 0..16 {- let (x, w) = if i < 8 { (-X[i], W[i]) } else { (X[i - 8], W[i - 8]) };- let t = c + 0.5 * h * x;- let uv = if s.u { Point2::new(t, mid.y) } else { Point2::new(mid.x, t) };- let Some((_, du, dv)) = eval(k, ext, uv) else { return -1.0 };- length += 0.5 * h.abs() * w * if s.u { du } else { dv }.length();- }- }- length-}-/// `cone_continued`: a cone's or cylinder's face continued naturally `distance` past side `s` of/// its box `dom`, as the analytic itself over a wider STEP domain (degrees round the axis,/// height along it). `None` where the cone can't be widened so (more than a turn, or past the@@ -656,82 +607,16 @@ fn same_patch(k: &Kernel, p: &Surface, q: &Surface, tol: f64) -> bool {}/// `extended_by`: the surface `surf` (whose face is its whole box `dom`) extended past side `s` as-/// `ct` says, so that it runs `distance` past that side measured across it ([`across`]), within-/// 1e-9 of it. `CreateExtendedSurface` takes its distance as an estimate, and how far it then runs-/// is increasing in what it is asked: a bracketed solve on that (each ask scaled by the distance-/// over what it gave until two asks fall either side, then Illinois false position). An extension-/// that moves the face's side off its parameters, or a target not met, is [`Error::NotExact`],-/// never the surface as it came out.-fn extended_by(k: &Kernel, surf: &Surface, dom: &Extent2d, s: Side, ct: ContinuityType, distance: f64, model_tol: f64) -> Result<Surface> {- const BRACKET_TRIES: usize = 40;- const SOLVE_TRIES: usize = 100;- let tol = 1e-9 * distance;- // How far asking `ask` runs, and the surface it makes.- let try_ask = |ask: f64| -> Result<(Surface, f64)> {- let tried = surf.create_extended_surface_dir(k, s.which, ask, ct).map_err(status)?;- // The face's side stays where it was on the extended surface's parameters.- let mid = on_side(dom, s, 0.5);- let stays = matches!((point_at(k, surf, mid), point_at(k, &tried, mid)), (Some(was), Some(now)) if (was - now).length() <= model_tol);- if !stays {- return Err(Error::NotExact);- }- let got = across(k, &tried, dom, s);- if got.is_finite() && got > 0.0 { Ok((tried, got)) } else { Err(Error::NotExact) }- };- // Asks that run short of and past `distance`, by f = got - distance.- let (mut short, mut past) = (None, None);- let mut ask = distance;- for _ in 0..BRACKET_TRIES {- let (made, got) = try_ask(ask)?;- let f = got - distance;- if f.abs() <= tol {- return Ok(made);- }- if f < 0.0 {- short = Some((ask, f));- } else {- past = Some((ask, f));- }- if short.is_some() && past.is_some() {- break;- }- ask *= distance / got;- }- let (Some((mut lo, mut flo)), Some((mut hi, mut fhi))) = (short, past) else { return Err(Error::NotExact) };- // Illinois: false position, halving the value at the end that stays when the same end moves- // twice running.- #[derive(PartialEq)]- enum Moved {- Neither,- Lo,- Hi,- }- let mut moved = Moved::Neither;- for _ in 0..SOLVE_TRIES {- let x = hi - fhi * (hi - lo) / (fhi - flo);- if !(x > lo.min(hi) && x < lo.max(hi)) {- break;- }- let (made, got) = try_ask(x)?;- let f = got - distance;- if f.abs() <= tol {- return Ok(made);- }- if f < 0.0 {- (lo, flo) = (x, f);- if moved == Moved::Lo {- fhi *= 0.5;- }- moved = Moved::Lo;- } else {- (hi, fhi) = (x, f);- if moved == Moved::Hi {- flo *= 0.5;- }- moved = Moved::Hi;- }+/// `how` says, so that it runs `distance` past that side measured across it, exactly: solidcore's+/// one extension ([`Surface::extended_by_distance`]), which keeps the source's own part bit for bit+/// and meets the distance within 1e-9 of it. A distance it cannot meet exactly is+/// [`Error::NotExact`], never a surface that falls short or runs past.+fn extended_by(k: &Kernel, surf: &Surface, dom: &Extent2d, s: Side, how: Continuity, distance: f64) -> Result<Surface> {+ match surf.extended_by_distance(k, dom, s.which, how, distance) {+ Ok(e) => Ok(e.surface),+ Err(SolidError::ExtendRefused { .. } | SolidError::NotConverged { .. }) => Err(Error::NotExact),+ Err(e) => Err(status(e)),}- Err(Error::NotExact)}/// `smlib_extend_sheet`: the one-face sheet `sheet`, whose face is its surface's whole parameter@@ -787,15 +672,13 @@ pub(crate) fn extend_sheet(sheet: &Body, point: [f64; 3], tol: f64, distance: f6if (nl.x - dl.x).abs() > ptol || (nl.y - dl.y).abs() > ptol || (nh.x - dh.x).abs() > ptol || (nh.y - dh.y).abs() > ptol {return Ok(Err(Error::Unsupported));}- let ct = match how {- Continuation::Tangent => ContinuityType::G1,- Continuation::Curvature => ContinuityType::G1G2,- Continuation::Natural => ContinuityType::CInfinity,+ let continuity = match how {+ Continuation::Tangent => Continuity::Tangent,+ Continuation::Curvature => Continuity::Curvature,+ Continuation::Natural => Continuity::Natural,};- // CreateExtendedSurface takes its distance as an estimate (a natural parabola falls 2.5%- // short, a G2 run-off of a circle runs more than twice as far): the distance asked of it- // is solved for until the extension measures `distance` across the side's middle.- let extended = match extended_by(k, &surf, &dom, grow, ct, distance, model_tol) {+ // The extension runs `distance` across the side, exactly (solidcore's one extension).+ let extended = match extended_by(k, &surf, &dom, grow, continuity, distance) {Ok(e) => e,Err(e) => return Ok(Err(e)),};diff --git a/crates/smlib/src/lib.rs b/crates/smlib/src/lib.rsindex 209ef8d8e9..5008f588d4 100644--- a/crates/smlib/src/lib.rs+++ b/crates/smlib/src/lib.rs@@ -55,7 +55,7 @@ pub enum Error {/// middle of the edge it was found for, and why there is no room, when the refusal names them.TooLarge { size: f64, kind: FitKind, at: Option<[f64; 3]>, why: Option<RoomReason> },/// A shell, offset or thicken whose wall is thicker than a face curves: the face's offset- /// folds (solidcore's `ShellRefused`, `ShellRefusal::Fold`). The largest wall that works,+ /// folds (solidcore's `OffsetFailure::Folds`). The largest wall that works,/// when solidcore names one.WallFolds { largest: Option<f64> },/// SMLib cannot build this exactly yet (a variable radius whose law has a corner).diff --git a/crates/smlib/src/tests.rs b/crates/smlib/src/tests.rsindex 1c04e47518..992e0abef9 100644--- a/crates/smlib/src/tests.rs+++ b/crates/smlib/src/tests.rs@@ -486,19 +486,6 @@ fn bodies_move_between_kernels_and_calls_run_side_by_side() {}}-/// Each kernel has its own range of blend serials: a body keeps the serials of the kernel that-/// made it, and another kernel's memo of solved stations must not take them for its own.-#[test]-fn kernels_never_issue_the_same_blend_serial() {- let range = core::BLEND_SERIALS_PER_KERNEL as usize;- let ranges = core::run("outer", |outer| {- let inner = core::run("inner", |inner| Ok(inner.blend_last_serial.get() as usize)).unwrap_or_default();- Ok([outer.blend_last_serial.get() as usize / range, inner / range])- });- let [outer, inner] = ranges.unwrap();- assert_ne!(outer, inner);-}-/// A panic in a call running beside another costs neither: the panicking call's kernel is thrown/// away and the other call and later ones go on.#[test]diff --git a/tests/KNOWN_FAILING_TESTS b/tests/KNOWN_FAILING_TESTSindex 6e0c468b3a..85ffd43933 100644--- a/tests/KNOWN_FAILING_TESTS+++ b/tests/KNOWN_FAILING_TESTS@@ -7,9 +7,8 @@# (`gh run download <run> -R tangency-labs/solidcraft -n <artifact> -D <dir>/<artifact>` for junit# and junit-gpu-1..4), run `cargo xtask known-failing --junit <dir>`, then drop each FIXED line and# add each REGRESSION line with its cause, from the test's failure message.-solidcraft-cli::action_matrix::action_matrix_sample 3 baseline actions fail, the same 3 as on C++: 2 shells (Bad Loop Orient on issue-616-lid-ribs; status 1001 on filleted-shelled-box), 1 fillet (SmSurfOfRevolution Test #7 on oblique_cut_of_cylinder)-solidcraft-cli::model_cache::a_later_round_after_opening_blends_the_saved_rounds_again the later r3 round at the r2 mitre builds solidcore's 10-face corner (7928.743041), the test wants SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310: 15 faces, 7928.142563938-solidcraft-cli::naming_corpus::corpus_designs_name_alike_every_build_and_fail_where_a_reference_is_gone oracle/83-boundary-loop-thicken does not load: step 8, thicken status 1001, as on C+++solidcraft-cli::action_matrix::action_matrix_sample 2 baseline actions fail: 2 shells (Bad Loop Orient on issue-616-lid-ribs; status 1001 on filleted-shelled-box)+solidcraft-cli::naming_corpus::corpus_designs_name_alike_every_build_and_fail_where_a_reference_is_gone oracle/83-boundary-loop-thicken does not load: step 8, the offset of face 0 by -1 is not proved regular, so thicken is refused with no size namedsolidcraft-doc::eval::cost_tests::a_tap_marking_searches_only_the_bodies_near_it main's mesh-based version (#10303) not taken; the exact replacement is to comesolidcraft-doc::eval::cost_tests::a_tap_marking_still_searches_the_bodies_within_its_reach main's mesh-based version (#10303) not taken; the exact replacement is to comesolidcraft-engine::cmd::edit::tests::inserting_variable_fillet_control_preserves_parameters_at_existing_positions solidcore refuses a variable fillet whose law has a corner (solidcore#430)@@ -21,19 +20,12 @@ solidcraft-engine::measure_centre_tests::a_fillet_round_a_boss_reports_its_radiusolidcraft-engine::tests::chord_and_variable_fillets its 2 → 4 → 2 waist: solidcore refuses a variable fillet whose law has a corner (solidcore#430)solidcraft-engine::tests::fillet_fit_taper_closes_to_a_point fillet status 1001 on the taper fit (radius 16 closing to 0), as on C++solidcraft-engine::tests::mirror_placed::dragging_a_mirrored_part_meshes_its_copies_once a copy of a copy drawn from its first copy's triangles (#10101) is triangulated differently from a fresh mesh of it, where truck's meshes are the same under a rigid move, as on SMLib-solidcraft-engine::tests::shell_tangent_chain_that_opens_every_face_explains_how_to_keep_walls the 2 mm shell of the box with every edge rounded r 1.5, its front face open, fails SM_ERR_INVALID_INPUT at solidcore 8ddce9016: the wall is thicker than the rounds and their Ball corners (BallPatch, fillet_blend_corner), whose inward offsets collapsesolidcraft-kernel::blend::corner_tests::a_round_ending_in_an_earlier_round_matches_both_together fillet status 1001 on the round that ends in the earlier one, as on C++-solidcraft-kernel::blend::corner_tests::corner_blends_hold_at_any_scale at 0.01x the arc case's rounds remove 72.783 (scaled back) against 72.713 at 1x, as on C++solidcraft-kernel::blend_corner::tests::issue2422_vertical_after_separate_bottom_rounds the vertical edge after the separate bottom rounds is refused as smooth ("its faces meet tangentially, so there is nothing to round"): the rounds leave it tangent at solidcore 8ddce9016-solidcraft-kernel::blend_corner::tests::three_rounds_at_a_corner the corner's variable-radius transition between rounds of different radii meets its neighbours at 0.144 degrees once its sections are the balls' touch circles (fillet_gn_section_generator, solidcore#2262; 0 with the great circles), as on SMLib d01d7b0; the corner step replaces that transition-solidcraft-kernel::blend_variable::tests::variable_radius_on_a_box_edge the variable round r 2 to 5 along a box edge fails status 1001 at solidcore 8ddce9016solidcraft-kernel::blend_variable::tests::variable_radius_with_a_corner_through_a_middle_point solidcore refuses a variable fillet whose law has a corner (solidcore#430)-solidcraft-kernel::blend_wrong_way_tests::a_chamfer_that_would_grow_the_part_on_a_convex_edge_is_refused at solidcore 8ddce9016 the 0.5 chamfer of the ball cut's rim is no longer refused as too large: the session builds no face (made no change), its tangent chain running into an unblended edgesolidcraft-kernel::corner_g2::tests::a_long_setback_keeps_the_g2_patch_inside_the_box at set backs 11 to 15 the G2 corner patch bulges past the box, as on C++solidcraft-kernel::corner_g2::tests::curvature_rounds_meet_at_a_g2_corner the corner between curvature rounds jumps 2.07 in curvature over 538 stations on solidcore; the test wants it curvature continuous, as SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310 builds itsolidcraft-kernel::corner_g2::tests::the_box_corner_g2_patch_is_a_closed_solid_curvature_continuous_to_its_neighbours the fitted G2 corner patch bulges 1.7e-5 past the box, as on C++solidcraft-kernel::fillet_setback_tests::a_setback_not_past_the_radius_is_refused_naming_the_least solidcore builds setback 5.5 (15 faces) where SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310 refuses it naming the least that builds; nothing names the least setback on solidcore until then-solidcraft-kernel::modify_history_tests::fillet_variable_and_chord the variable round r 2 to 5 along the cube's edge fails status 1001 at solidcore 8ddce9016, as variable_radius_on_a_box_edgesolidcraft-kernel::native::tests::box_and_fillet_have_stable_wire_records the box-edge round's wire record differs from the fixture at solidcore 8ddce9016 (a value 3 is 5): the fixture is re-blessed (NATIVE_BREP_BLESS=1) once the change is shown rightsolidcraft-smlib::ops::tests::a_variable_round_with_a_corner_in_its_law_is_its_balls_union solidcore refuses a variable fillet whose law has a corner (solidcore#430)-solidcraft-ui-egui::preselect_tests::variable_fillet_round_trip the dialog's variable round fails status 1001 at solidcore 8ddce9016, as variable_radius_on_a_box_edgediff --git a/tests/kernel-cases/fillets/KNOWN_FAILING b/tests/kernel-cases/fillets/KNOWN_FAILINGindex 5f094f7e95..0b6c97faf1 100644--- a/tests/kernel-cases/fillets/KNOWN_FAILING+++ b/tests/kernel-cases/fillets/KNOWN_FAILING@@ -4,8 +4,6 @@1080-fillet-equal-slope-basin-1-mm-rim-loop-4 [fail] continuity_order: got {'body': 'Slab', 'edges': 'blend', 'order': 'g0', want >= g1 at every blend seam1080-fillet-sloped-basin-1-mm-rim-r4-2-edges [fail] continuity_order: got {'body': 'Slab', 'edges': 'blend', 'order': 'g0', want >= g1 at every blend seam1080-fillet-sloped-basin-1-mm-rim-r4-4-edges [fail] continuity_order: got {'body': 'Slab', 'edges': 'blend', 'order': 'g0', want >= g1 at every blend seam-2893-chamfer-distance-and-angle-past-the-wall-refused [fail] refused, but not because "angle": step 2 (solid.chamfer): SMLib chamfer: operation: SMLib rejected the input (SM_ERR_INVALID_INPUT)-2893-chamfer-two-distances-elliptical-rim [fail] refused, but not because "not supported yet": step 3 (solid.chamfer): SMLib chamfer: operation: SMLib failed (status 1001) (tangent propagation blended the picked edges' tangent chain with them; with it off, tangent_chain:4782-fillet-bar-edge-wider-than-both-faces [fail] continuity_order: got Box: no null seams want >= g1 at every blend seam9-fillet-corner-curvature-with-reduce-fit [unsupported] solid.fillet builds `corner: g2` with `fit: exact` only9-fillet-corner-curvature-with-taper-fit [unsupported] solid.fillet builds `corner: g2` with `fit: exact` only@@ -16,9 +14,7 @@ cov-fillet-g2-mixed-corner [unsupported] refused as on SMLib d01d7b0: a G2 cornecov-fillet-g2-oblique-three-edge-corner [unsupported] refused on solidcore: its three edges meet at different wedge angles, and one curvature fillet takes the first edge's equal-area thumbweight for every edge (solidcore#2250, issuecomment-6563419897); SMLib d01d7b0 fails it toocov-fillet-g2-pocket-corner [fail] continuity_order: G1 at one seam where the corner patch meets a contact face (g2 wanted), as on SMLib d01d7b0cov-junction-boss-tilt-20-root-round [fail] fillet status 1001 on a cylinder tilted 20 degrees into the plate, as on SMLib-cov-junction-boss-tilt-40-root-round [fail] fillet status 1001 on a cylinder tilted 40 degrees into the plate, as on SMLib-cov-junction-tee-equal-round [fail] the result is not a closed solid, as on SMLib: equal pipes' intersection is two plane ellipses crossing, a corner the old corner code cannot join (the corner step)cov-junction-y-junction-120-round [unsupported] refused as on SMLib: the faces between the three intersection curves narrow to nothing at the two triple points, so the room check trips (the corner step)-report-drafted-peg-front-and-concave-rounds-together-r2 [unsupported] step 13 (solid.fillet): invalid input: not supported yet: the fillet meets a corner of this kind, which SMLib's blends do not handle yet (where its edreport-fillet-curvature-three-edges-at-bar-corner [fail] continuity_order: G1 at one seam where the corner patch meets a contact face (g2 wanted), as on SMLib d01d7b0 (see KNOWN_FAILING)report-fillet-curvature-three-edges-at-bar-corner-solver-residues [fail] continuity_order: G1 at one seam where the corner patch meets a contact face (g2 wanted), as on SMLib d01d7b0 (see KNOWN_FAILING)+report-fillet-curvature-three-edges-at-bar-corner-solver-residues-outside-setback [unsupported] solidcore#2697: solidcore's own filled corner builds this to its closed form (7e-11); SolidCraft's least-squares fit misses curvature by 4.02e-3 against 2.5e-3 at this pindiff --git a/tests/kernel-cases/ladder/11-cumulative-parts/004-housing/expected.json b/tests/kernel-cases/ladder/11-cumulative-parts/004-housing/expected.jsonindex c5cc3e2c26..11ed94e5c3 100644--- a/tests/kernel-cases/ladder/11-cumulative-parts/004-housing/expected.json+++ b/tests/kernel-cases/ladder/11-cumulative-parts/004-housing/expected.json@@ -2,9 +2,9 @@"sources": [],"what": "the running part with every tier: back wall, boss, slot, spline window, tapped holes, rounds, chamfers, shell, vents, and a modelled M16 thread on the boss","source": "analytic",- "method": "10/008 less the M16 groove on the boss: its cylinder runs from the r1 root round (z 21, a shoulder: the groove stops w = 0.932735 clear of it) to the 1 mm top chamfer (z 29, run out through it, a free end); the groove's root r 6.917 stays outside the boss's 1.5 wall's inside (r 6.5), so it cuts the wall only. Bbox: the part's",+ "method": "10/008 less the M16 groove on the boss: its cylinder runs down to the r1 root round's shoulder (End::Shoulder), where it is trimmed at z 21, up to the 1 mm top chamfer (z 29, run out through it, a free end); the groove's root r 6.917 stays outside the boss's 1.5 wall's inside (r 6.5), so it cuts the wall only. Bbox: the part's","body_count": 1,- "volume_mm3": 15138.532607554,+ "volume_mm3": 15111.5575,"bbox": {"min": [0,diff --git a/tests/kernel-cases/ladder/golden.json b/tests/kernel-cases/ladder/golden.jsonindex e1b3c034dd..e274d3759d 100644--- a/tests/kernel-cases/ladder/golden.json+++ b/tests/kernel-cases/ladder/golden.json@@ -1822,12 +1822,12 @@},"ladder/11-cumulative-parts/004-housing": {"measured": {- "area_mm2": 21105.287553425696,+ "area_mm2": 21156.778657103445,"body_count": 1,- "edges": 210,- "faces": 78,- "vertices": 139,- "volume_mm3": 15138.519861452509+ "edges": 218,+ "faces": 81,+ "vertices": 144,+ "volume_mm3": 15111.545095719644},"seconds": 4.128625132,"status": "pass"diff --git a/tests/oracle/77-fillet-variable-linear/expected.json b/tests/oracle/77-fillet-variable-linear/expected.jsonindex 65162b1ff0..7bd4b79fa0 100644--- a/tests/oracle/77-fillet-variable-linear/expected.json+++ b/tests/oracle/77-fillet-variable-linear/expected.json@@ -1,6 +1,5 @@{"source": "analytic",- "known_failure": "the variable round r 2 to 5 along a box edge fails status 1001 at solidcore 8ddce9016 (as blend_variable::tests::variable_radius_on_a_box_edge in tests/KNOWN_FAILING_TESTS)","method": "box 40x30x20 with its top front edge (y=0, z=20) rounded at a radius running straight from 2 (x=0) to 5 (x=40). The round is the union of the balls rolled along the edge, ball s touching both faces at r(s), the law continued past the edge's ends along its end slopes: each section loses the corner points no ball reaches, up to rho(x, t), the nearest entry into a ball along the ray from the edge at the angle t. V, moments and areas integrated by Gauss-Legendre panels in x and t (tools/oracle-analytic/cases_fillets.py)","body_count": 1,"volume_mm3": 23888.613525715446,