SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Class-A surfacing 3/3: blend curves, curved-edge fillets, the G2 corner and continuity analysis (#1642)
midasdfbbd4f29ebb58
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.mdindex 97dca7e5d1..6221864bd6 100644--- a/ATTRIBUTION.md+++ b/ATTRIBUTION.md@@ -36,6 +36,8 @@ Editable drawing code, native projects and shipped exports are collected under `| assets/archive/icons/macos-v1/exports/icon.iconset/[email protected] | SolidCraft contributors | native sips export from assets/archive/icons/macos-v1/exports/icon.png | MIT OR Apache-2.0 || assets/archive/icons/macos-v1/exports/icon.iconset/icon_512x512.png | SolidCraft contributors | native sips export from assets/archive/icons/macos-v1/exports/icon.png | MIT OR Apache-2.0 || assets/archive/icons/macos-v1/exports/icon.iconset/[email protected] | SolidCraft contributors | native sips export from assets/archive/icons/macos-v1/exports/icon.png | MIT OR Apache-2.0 |+| docs/screenshots/class-a-blend.png | SolidCraft contributors | screenshot of SolidCraft itself: two boxes bridged by `surface.blend` (a 40x10 sheet, `solidcraft-cli snapshot` of plan/evidence script ev_blend) | MIT OR Apache-2.0 |+| docs/screenshots/class-a-crown.png | SolidCraft contributors | screenshot of SolidCraft itself: a patch crowned with `surface.patch crown=0.3` over a saddle rim (`solidcraft-cli snapshot`) | MIT OR Apache-2.0 || docs/screenshots/class-a-boundary.png | SolidCraft contributors | screenshot of SolidCraft itself: a patch through two sketch lines built by `surface.boundary` with `crown: 0.4` (`solidcraft-cli snapshot`) | MIT OR Apache-2.0 || docs/screenshots/sample-plate.png | SolidCraft contributors | screenshot of SolidCraft itself (`solidcraft --sample`) | MIT OR Apache-2.0 || docs/screenshots/demo-0.8.gif | SolidCraft contributors | original screen recording of the actual SolidCraft 0.8 English desktop UI modelling an original Raspberry Pi 4 case (no logos or branding; the engraved text is set in the system's DejaVu Sans Bold), generated with examples/demo/record_ui.sh and its original animated pointer overlay (9× playback) | MIT OR Apache-2.0 |diff --git a/ROADMAP.md b/ROADMAP.mdindex 1887bc9c8e..67e1ba716e 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -53,11 +53,8 @@ PCB / Package, Render, Animation, Simulation, Manufacture/CAM, Drawings.| M5 | Persistent naming of faces and edges (docs/book/src/dev/naming.md): faces named from their exact kernel-reported history (sketch curve sides, caps, revolve sections, primitive sides, blends, shell inner walls, pattern/mirror copies; split pieces told apart by the faces around them, lumps of a cut body named after their faces), edges by their faces; fillets/chamfers, sketches on faces, shell/draft/offset/replace faces, hole placements, joint origins and face appearances resolve by name first and warn when the entity split or vanished: done. sheet metal edges by base sketch line and flange side, shell inner faces, sweep and loft roles: done. kernel-reported face history: done (merged faces answer to every name; operations without history yet fall back to geometric names, flagged unverified; format 14 keeps older designs' geometric names). Left: history through sheet metal, plastic, surface and emboss features; FaceSource certificates through history | in progress | 20 || M6 | UI depth: selection feedback and origin (done), timeline editing (done: hover and selection highlight modifier faces, including fillets and chamfers; edit feature, history marker drag, dependency-checked single and multi-item reorder, suppress, rename, delete with dependents, re-resolved references; redefining selections refreshes persistent edge/face references while retaining feature identity and dimension names; optional compact named left feature history with rollback bar, multi-selection and persistent folders above the parts browser), right-docked dialogs (done), live previews for every feature dialog (done), keyboard-first commands with on-canvas value boxes and sketch inline dimensions (done), drag manipulators with automatic join/cut (done: extrude incl. two sides, fillet, shell, hole depth, move, pattern spacing, revolve rotator; taper handle open), dark theme (done), right-click menu with Repeat (done), measure tool (done), section analysis (done), selection filter (done), drag-solve of sketch points (done); appearance controls now preserve body/face/component targeting, named transparent looks, reuse/search and override removal; preferences | in progress | 6 || M7 | Thin extrude (walls along open or closed curves: centre, inside, outside or two sides; mitred corners, crossing walls joined; #721), sweep, loft (incl. to a point), rib and web (to next / depth), emboss (planar faces and exact radial emboss/deboss of bounded orthogonal profiles on complete exterior cylinders/sleeves), thread (cosmetic, and modelled M3–M20 outside and inside: the ISO profile screwed in as a faceted cut), coil (smooth B-spline helical walls), pipe, pattern on path, patterns of bodies and components, replace face (parallel), align, remove, feature copy/paste: done. Unique eligible cylindrical targets are inferred for new Emboss features. Left: general curved-face emboss and exact (unfaceted) modelled threads | in progress | 12 |-| M8 | Surface workspace (#772). Done: Patch (sketch regions; edge loops of any shape and number of sides as one face, G0/G1/G2 to the faces beside each edge, through points, #759), Stitch, Thicken (planes and cylinders), Extend (straight edges of planar surfaces), Trim (by a plane or a face), Delete Face (healing), Boundary Fill, zebra/draft/curvature-map analysis. Proposed, in order: surface Extrude/Revolve/Sweep/Loft from open and closed curves (#757), Offset surface (#758), Unstitch and Reverse Normal (#766), Delete Face without healing (#768); Extend curved faces and edges (#760), mutual trim and trim by projected curves (#767), Untrim (#761), Thicken every surface kind (#765); Ruled (#762), Boundary surface and curve networks with G0/G1/G2 (#763), Blend surface (#764), sweep guide rails and two-rail sweeps (#771; orientation, twist and end scale done; loft rails #201), fillet between surface bodies (#769); continuity analysis, surface curvature combs and isocurves (#770) | deferred | — |+| M8 | Surface workspace (#772). Done: Patch (sketch regions; edge loops filled G0, plus `crown`), Stitch, Thicken (planes and cylinders), Extend (straight edges of planar surfaces), Trim (by a plane or a face), Delete Face (healing), Boundary Fill, zebra/draft/curvature-map analysis, Surface Extrude/Revolve/Sweep/Loft from open and closed curves, Offset, Unstitch and Reverse Normal; the continuity-driven core (`kernel/src/bridge.rs`, G0–G3 Hermite rows) with **Blend** (`surface.blend`, #764), **Match** (`surface.match`), **Boundary** (`surface.boundary`, #763 — two boundaries exact, three/four refused pending a Gregory-type corner), **Fair** (`surface.fair`, CV fairing), **continuity analysis** (`inspect.continuity`, #770) and a multi-section **loft** with per-end continuity and crown. Also in the Class-A pass: G1…G4 blend curves in the sketch, chord and variable-radius fillets on curved edges (with honest refusals where the fit cannot hold), and a G2 corner patch where filleted edges meet (kernel; the command refuses until the patch's sections can be sewn to the blends' contacts). Left: bias/form-factor fillet sections (design recorded), a Gregory-type corner, surface Fillet between separate surface bodies (#769), Ruled (#762), Untrim (#761), curved-face Extend (#760), sweep guide rails and two-rail sweeps (#771; orientation, twist and end scale done; loft rails #201), and every remaining #757–#772 item | deferred | — || M9 | Components and assemblies: New Component / Create Components from Bodies, active component, per-component origin/bodies/sketches/timeline entries, occurrences with transforms, Copy/Paste vs Paste New, nested Browser tree with visibility and isolate; Ground, Move/Copy of occurrences, joints (rigid, revolute, slider, cylindrical, pin-slot, planar, ball) by joint origins with limits and Drive Joints, closed kinematic loops (four-bar, slider-crank: the loop's other joints follow the driven one on its branch, and driving stops where a loop can no longer close), As-built Joint, Rigid Group, Contact Sets (driving and motion studies stop where bodies in a set would pass through each other), Motion Study (joint values keyed along a timeline, playback, export of occurrence positions as JSON/CSV), Exploded views (automatic or by hand, shown without changing placements); interference, per-component physical properties; STEP with assembly structure; URDF export for robot simulators (links with meshes, mass and inertia; joint chains whose values match Drive Joints; docs/urdf.md). Physical properties now measure material-aware component/occurrence placements, descendants and repeated instances, including pending moves and body reassignment offsets; contact geometry and automatic exploded centres respect those offsets. Groundwork done: component tree, occurrences with transforms (instances, Paste New), world placement, active component as authoring frame, ground, Capture/Revert Position, moving bodies and sketches. UI: ASSEMBLE panel dialogs for New Component, Joint (snaps on faces, edges, circles and vertices; animated motion preview; offsets, flip, limits), As-built Joint, Joint Origin, Rigid Group, Drive Joints (live slider), Motion Link and Interference (overlaps shown red); joints in the timeline and the Browser | in progress | 32 |-| M8 | Surface workspace (#772). Done: Patch (sketch regions; edge loops filled G0), Stitch, Thicken (planes and cylinders), Extend (straight edges of planar surfaces), Trim (by a plane or a face), Delete Face (healing), Boundary Fill, zebra/draft/curvature-map analysis. Proposed, in order: surface Extrude/Revolve/Sweep/Loft from open and closed curves (#757), Offset surface (#758), Unstitch and Reverse Normal (#766), Delete Face without healing (#768); Extend curved faces and edges (#760), mutual trim and trim by projected curves (#767), Untrim (#761), Thicken every surface kind (#765); Ruled (#762), Boundary surface and curve networks with G0/G1/G2 (#763), Patch with G1/G2 and general loops (#759), Blend surface (#764), sweep guide rails and two-rail sweeps (#771; orientation, twist and end scale done; loft rails #201), fillet between surface bodies (#769); continuity analysis, surface curvature combs and isocurves (#770) | deferred | — |-| M9 | Components and assemblies: New Component / Create Components from Bodies, active component, per-component origin/bodies/sketches/timeline entries, occurrences with transforms, Copy/Paste vs Paste New, nested Browser tree with visibility and isolate; Ground, Move/Copy of occurrences, joints (rigid, revolute, slider, cylindrical, pin-slot, planar, ball) by joint origins with limits and Drive Joints, closed kinematic loops (four-bar, slider-crank: the loop's other joints follow the driven one on its branch, and driving stops where a loop can no longer close), gears, rack and pinion and screws (motion links whose ratio follows picked radii, parameters or a pitch, also inside closed loops), As-built Joint, Rigid Group, Contact Sets (driving and motion studies stop where bodies in a set would pass through each other), Motion Study (joint values keyed along a timeline, playback, export of occurrence positions as JSON/CSV), Motion Trace (a picked point's path as a joint is driven or a study plays, closed loops following; kept as a 3D sketch spline), Exploded views (automatic or by hand, shown without changing placements); interference, per-component physical properties; STEP with assembly structure; URDF export for robot simulators (links with meshes, mass and inertia; joint chains whose values match Drive Joints; docs/urdf.md). Physical properties now measure material-aware component/occurrence placements, descendants and repeated instances, including pending moves and body reassignment offsets; contact geometry and automatic exploded centres respect those offsets. Groundwork done: component tree, occurrences with transforms (instances, Paste New), world placement, active component as authoring frame, ground, Capture/Revert Position, moving bodies and sketches. UI: ASSEMBLE panel dialogs for New Component, Joint (snaps on faces, edges, circles and vertices; animated motion preview; offsets, flip, limits), As-built Joint, Joint Origin, Rigid Group, Drive Joints (live slider), Motion Link, Gear, Rack and Pinion, Screw and Interference (overlaps shown red); joints in the timeline and the Browser | in progress | 32 |-| M9 | Components and assemblies: New Component / Create Components from Bodies, active component, per-component origin/bodies/sketches/timeline entries, occurrences with transforms, Copy/Paste vs Paste New, nested Browser tree with visibility and isolate; Ground, Move/Copy of occurrences, joints (rigid, revolute, slider, cylindrical, pin-slot, planar, ball) by joint origins with limits and Drive Joints, closed kinematic loops (four-bar, slider-crank: the loop's other joints follow the driven one on its branch, and driving stops where a loop can no longer close), gears, rack and pinion and screws (motion links whose ratio follows picked radii, parameters or a pitch, also inside closed loops), inverse kinematics (`joint.reach`: a part's point to a target through the joints on its chain, within limits and with loops closed, nearest pose and its stopper when out of reach; dragging a jointed part in the viewport moves it as far as its joints allow), As-built Joint, Rigid Group, Contact Sets (driving and motion studies stop where bodies in a set would pass through each other), Motion Study (joint values keyed along a timeline, playback, export of occurrence positions as JSON/CSV), Exploded views (automatic or by hand, shown without changing placements); interference, per-component physical properties; STEP with assembly structure; URDF export for robot simulators (links with meshes, mass and inertia; joint chains whose values match Drive Joints; docs/urdf.md). Physical properties now measure material-aware component/occurrence placements, descendants and repeated instances, including pending moves and body reassignment offsets; contact geometry and automatic exploded centres respect those offsets. Groundwork done: component tree, occurrences with transforms (instances, Paste New), world placement, active component as authoring frame, ground, Capture/Revert Position, moving bodies and sketches. UI: ASSEMBLE panel dialogs for New Component, Joint (snaps on faces, edges, circles and vertices; animated motion preview; offsets, flip, limits), As-built Joint, Joint Origin, Rigid Group, Drive Joints (live slider), Motion Link, Gear, Rack and Pinion, Screw and Interference (overlaps shown red); joints in the timeline and the Browser | in progress | 32 || M10 | Sheet metal: flange (base, edge, contour), hem, unfold/refold, convert, flat pattern + DXF, rules: done. PLASTIC enclosure subset: Boss, Rib, Web, Lip/Groove, Snap Fit, Rest, Plastic Rules (library, edit, assign; rule draft and clearance as feature defaults): done, tested against hand-computed geometry. UI: SHEET METAL and PLASTIC tabs in Fusion's layout with dialogs (live preview, Edit Feature, pre-selection) for Flange, Hem, Unfold/Refold, Convert, Sheet Metal Rules, Create Flat Pattern (flat view with bend lines, bend table CSV/JSON and DXF export with exact circle/arc/line cutouts), Boss, Lip/Groove, Snap Fit, Rest, Manage and Assign Plastic Rules; Fold (bend along a sketch line); flanges meeting at a corner closed at any angle with the rule's gap; edge flanges with their own angle and height per edge in one feature; corner reliefs (notch, round, rectangular, tear) chosen by the rule; Convert to Sheet Metal from a solid or shelled body by its bend edges (flat faces, sharp bends) | in progress | 36 || M11 | 2D drawings | deferred | — || M12 | Release: cross-platform packages, verification and deliberate publication implemented; original current-UI demo refreshed. Trusted distribution signing and broader performance work remain | in progress | 16 |diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex 21e4125c63..97780eb461 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -563,6 +563,10 @@ pub enum FeatureKind {/// What to do when the radius is too large for the geometry around the edges.#[serde(default, skip_serializing_if = "FilletFit::is_exact")]fit: FilletFit,+ /// What fills the corners where three blended edges meet: the rolling ball's sphere+ /// (default) or a G2 patch repeating each blend up to the second order.+ #[serde(default, skip_serializing_if = "FilletCorner::is_rolling")]+ corner: FilletCorner,},Chamfer {edges: Vec<Position>,@@ -1311,6 +1315,10 @@ pub enum FeatureKind {/// sketch curves: walls only, no caps.SurfaceLoft {sections: Vec<SheetSection>,+ #[serde(default = "loft_plain_continuity", skip_serializing_if = "loft_continuity_is_plain")]+ continuity: [Continuity; 2],+ #[serde(default, skip_serializing_if = "loft_crown_is_plain")]+ crown: [f64; 2],},/// The faces at `faces` copied out at a signed `distance` along their normals as a new/// surface body (0 copies them); `chain` takes each pick's whole smooth chain of faces;@@ -1491,6 +1499,23 @@ pub enum FeatureKind {},}+/// What fills the corner where three blended edges meet.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum FilletCorner {+ /// A piece of the rolling ball's sphere: tangent (G1) to each blend.+ #[default]+ Rolling,+ /// A G2 patch repeating each blend's surface up to the second order (see `corner_g2`).+ G2,+}++impl FilletCorner {+ pub fn is_rolling(&self) -> bool {+ matches!(self, FilletCorner::Rolling)+ }+}+/// How Extend continues a surface past its edges.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]@@ -1734,6 +1759,28 @@ pub struct SheetSection {pub profiles: Option<ProfileSel>,#[serde(default, skip_serializing_if = "Vec::is_empty")]pub curves: Vec<String>,+ /// A section picked as an edge chain of a body instead of a sketch: `edges` are points on the+ /// chain, and the face the chain bounds is the surface the loft leaves there.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub body: Option<BodyName>,+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub edges: Vec<Position>,+}++/// A loft's continuity where a design does not say: both ends G0, the loft of old, which only+/// passes through its sections.+fn loft_plain_continuity() -> [Continuity; 2] {+ [Continuity::G0, Continuity::G0]+}++/// A loft's continuity is plain when it only passes through its sections: both ends G0.+fn loft_continuity_is_plain(c: &[Continuity; 2]) -> bool {+ *c == [Continuity::G0, Continuity::G0]+}++/// A loft's crown is plain when neither end is filled out.+fn loft_crown_is_plain(c: &[f64; 2]) -> bool {+ c.iter().all(|v| *v == 0.0)}/// Coil cross-sections.diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 45f8ce45a4..40cde9bd13 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -4551,8 +4551,16 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:};st.blend_edges.insert(f.id, edges.clone());let input = mb.traced();+ // A G2 corner is built by the corner construction alone, for a constant radius: any+ // other style (or a fitted radius) has no corner patch to repeat.+ if let FeatureKind::Fillet { corner: crate::FilletCorner::G2, style, fit, .. } = &f.kind+ && (!matches!(style, crate::FilletStyle::Constant) || !matches!(fit, crate::FilletFit::Exact))+ {+ return Err(DocError::Invalid("a G2 corner is built for a constant-radius fillet (type: constant, fit: exact) only".into()));+ }// The blended body, and the lineage of what the last blend started from.let (nb, from) = match &f.kind {+ FeatureKind::Fillet { corner: crate::FilletCorner::G2, .. } => (kernel::fillet_g2_corners(&mb.body, &edges, r)?, input),FeatureKind::Fillet { style: crate::FilletStyle::Curvature, .. } => (kernel::fillet_g2(&mb.body, &edges, r)?, input),FeatureKind::Fillet { style: crate::FilletStyle::Chord, .. } => (kernel::fillet_chord(&mb.body, &edges, r)?, input),FeatureKind::Fillet { style: crate::FilletStyle::Variable { radius2, start, mid, smooth }, .. } => {@@ -5238,6 +5246,7 @@ mod chain_tests {body: None,style: crate::FilletStyle::Constant,fit: Default::default(),+ corner: Default::default(),},None,)diff --git a/crates/doc/src/eval_surface.rs b/crates/doc/src/eval_surface.rsindex d6c8a5737f..8091751576 100644--- a/crates/doc/src/eval_surface.rs+++ b/crates/doc/src/eval_surface.rs@@ -3,7 +3,7 @@//! `surface_offset`, `surface_ruled`, `surface_untrim`).use super::*;-use crate::{RuledCorners, RuledMode};+use crate::{RuledCorners, RuledMode, SheetSection};use solidcraft_geom::Seg2;pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st: &mut ModelState, warning: &mut Option<String>) -> Result<()> {@@ -313,7 +313,13 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,push_sheet(st, f, traced);Ok(())}- FeatureKind::SurfaceLoft { sections } => {+ FeatureKind::SurfaceLoft { sections, continuity, crown } => {+ // A loft with edge chains for sections, or one that has to leave its ends a particular+ // way, is built through `loft_blend` from the frames of every section; the plain one+ // (sketch chains only, both ends G0) is the loft of old.+ if *continuity != [kernel::Continuity::G0, kernel::Continuity::G0] || sections.iter().any(|s| s.body.is_some()) {+ return loft_blend(st, f, sections, *continuity, *crown, doc);+ }let mut secs = Vec::with_capacity(sections.len());let mut sketches = Vec::with_capacity(sections.len());for sec in sections {@@ -553,3 +559,118 @@ fn curve_chains(ss: &SolvedSketch, ids: &[String]) -> Result<Vec<Vec<Seg2>>> {}Ok(chains)}++/// A multi-section blend: every section as frames, the body ones read off the face their edge+/// chain bounds, and the first and last leaving with `continuity` where the caller asks for it.+fn loft_blend(+ st: &mut ModelState,+ f: &Feature,+ sections: &[SheetSection],+ continuity: [kernel::Continuity; 2],+ crown: [f64; 2],+ doc: &Document,+) -> Result<()> {+ /// One section: a chain of sketch curves in its plane, or a body's edge chain.+ enum Piece {+ Sketch(solidcraft_geom::Plane, Vec<solidcraft_geom::Seg2>),+ Body(String, Vec<solidcraft_geom::Vec3>),+ }+ let mut pieces = Vec::with_capacity(sections.len());+ let mut centres = Vec::with_capacity(sections.len());+ for sec in sections {+ if let Some(name) = sec.body.as_deref() {+ if sec.edges.is_empty() {+ return Err(DocError::Invalid("a loft section picked from a body needs a chain of its edges".into()));+ }+ let n = sec.edges.len() as f64;+ centres.push(sec.edges.iter().fold(solidcraft_geom::Vec3::ZERO, |a, p| a + **p) * (1.0 / n));+ pieces.push(Piece::Body(name.to_string(), crate::plain(&sec.edges)));+ continue;+ }+ let ss = sketch_in_feature_frame(+ doc,+ st.sketch(sec.sketch.0).ok_or_else(|| DocError::Unknown(format!("sketch {} (it must come earlier in the timeline)", sec.sketch)))?,+ f.component,+ )?;+ let profiles = match (&sec.profiles, sec.curves.is_empty()) {+ (None, true) => Some(&ProfileSel::All),+ (p, _) => p.as_ref(),+ };+ let mut chains = sheet_chains(&ss, profiles, &sec.curves)?.into_iter();+ let (Some(chain), None) = (chains.next(), chains.next()) else {+ return Err(DocError::Invalid("each loft section must be one chain: one profile without holes, or curves meeting end to end".into()));+ };+ let pts: Vec<Vec2> = chain.iter().flat_map(|s| s.polyline(1e-2)).collect();+ let centre = pts.iter().fold(solidcraft_geom::Vec3::ZERO, |a, p| a + ss.plane.to_world(*p)) * (1.0 / pts.len().max(1) as f64);+ centres.push(centre);+ pieces.push(Piece::Sketch(ss.plane, chain));+ }+ // Each section leaves towards the one after it; the last one leaves back into the blend.+ let stations = BLEND_STATIONS;+ let last = pieces.len().saturating_sub(1);+ let mut frames = Vec::with_capacity(pieces.len());+ for (i, piece) in pieces.iter().enumerate() {+ let (from, to) = if i < last { (i, i + 1) } else { (last, last.saturating_sub(1)) };+ let leave = match (centres.get(from), centres.get(to)) {+ (Some(a), Some(b)) => *b - *a,+ _ => solidcraft_geom::Vec3::ZERO,+ };+ match piece {+ Piece::Body(name, edges) => {+ let b = st.body(name).ok_or_else(|| DocError::Unknown(format!("body `{name}`")))?.body.clone();+ frames.push(kernel::loft_blend::section_frames(&b, edges, leave, stations)?);+ }+ Piece::Sketch(plane, chain) => frames.push(chain_frames(plane, chain, leave, stations)),+ }+ }+ let body = kernel::loft_blend(&frames, continuity, crown, stations)?;+ let name = new_name(st, f, 0);+ st.bodies.push(ModelBody::new(name, body, f.id));+ Ok(())+}++/// The frames of one sketch chain, sampled by arclength at `stations` stations: a sketch has no+/// face behind it, so the surface leaves along the run with no curvature to repeat there.+fn chain_frames(+ plane: &solidcraft_geom::Plane,+ chain: &[solidcraft_geom::Seg2],+ leave: solidcraft_geom::Vec3,+ stations: usize,+) -> Vec<kernel::Frame> {+ let mut pts: Vec<Vec2> = Vec::new();+ for seg in chain {+ for p in seg.polyline(1e-2) {+ if pts.last().is_none_or(|l: &Vec2| (*l - p).len() > 1e-12) {+ pts.push(p);+ }+ }+ }+ if pts.len() < 2 || stations < 2 {+ return Vec::new();+ }+ let total: f64 = pts.windows(2).map(|w| (w[1] - w[0]).len()).sum();+ if !(total > 1e-12) {+ return Vec::new();+ }+ let step = total / (stations - 1) as f64;+ let (mut walked, mut k) = (0.0f64, 0usize);+ let mut out = Vec::with_capacity(stations);+ for i in 0..stations {+ let want = step * i as f64;+ while k + 1 < pts.len() && walked + (pts[k + 1] - pts[k]).len() < want {+ walked += (pts[k + 1] - pts[k]).len();+ k += 1;+ }+ let (Some(a), Some(b)) = (pts.get(k).copied(), pts.get(k + 1).copied()) else {+ if let Some(p) = pts.get(k).copied() {+ out.push(kernel::Frame { p: plane.to_world(p), leave, bend: solidcraft_geom::Vec3::ZERO, bend_change: solidcraft_geom::Vec3::ZERO });+ }+ continue;+ };+ let span = (b - a).len();+ let t = if span > 1e-12 { ((want - walked) / span).clamp(0.0, 1.0) } else { 0.0 };+ let p = a * (1.0 - t) + b * t;+ out.push(kernel::Frame { p: plane.to_world(p), leave, bend: solidcraft_geom::Vec3::ZERO, bend_change: solidcraft_geom::Vec3::ZERO });+ }+ out+}diff --git a/crates/doc/src/format/pending/fillet-corner-and-loft-continuity.rs b/crates/doc/src/format/pending/fillet-corner-and-loft-continuity.rsnew file mode 100644index 0000000000..d736c40c5d--- /dev/null+++ b/crates/doc/src/format/pending/fillet-corner-and-loft-continuity.rs@@ -0,0 +1,7 @@+//! The Class-A surface pass also lets a `Fillet` carry `corner` (`rolling`, the default and what+//! every older design meant, or `g2`: a patch repeating each blend's surface up to the second+//! order) and a `SurfaceLoft` carry `continuity` and `crown` and body edge-chain `sections` (a+//! section picked as a `body` with `edges` instead of a `sketch`). A design without them saves as+//! it always did — a loft without `continuity` reads and writes as `[g0, g0]`, the plain loft it+//! always was — so older designs need no transformation; 0.13.x asks for an update instead of+//! meeting a feature it can't read or dropping a corner style it does not round.diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rsindex c3dab4b201..9dbaad6e9a 100644--- a/crates/doc/src/tests.rs+++ b/crates/doc/src/tests.rs@@ -113,6 +113,7 @@ fn box_fillet_cut_timeline() {body: None,style: Default::default(),fit: Default::default(),+ corner: Default::default(),},None,)@@ -183,6 +184,7 @@ fn errors_are_reported_not_fatal() {body: None,style: Default::default(),fit: Default::default(),+ corner: Default::default(),},None,)diff --git a/crates/doc/src/walk.rs b/crates/doc/src/walk.rsindex 7c571a1bb8..66135aafc4 100644--- a/crates/doc/src/walk.rs+++ b/crates/doc/src/walk.rs@@ -50,6 +50,7 @@ impl Walk for crate::document::Operation {}impl Walk for solidcraft_kernel::Continuity {}impl Walk for crate::document::Direction {}impl Walk for crate::document::FilletFit {}+impl Walk for crate::document::FilletCorner {}impl Walk for crate::document::MeshData {}impl Walk for crate::document::RevolveConvention {}impl Walk for crate::document::CoilSection {}diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex 923ac4858b..ed5843a381 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -35,7 +35,7 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SOLID", "MODIFY").icon("fillet").key("F")- .params("edges: [[x,y,z] point on edge | {body, index}]; radius: expr; body?; type?: constant|curvature (alias g2: curvature-continuous quintic between planar faces along straight edges, one perpendicular planar end face at each end; radius sets the equivalent circular setback, not constant curvature; exact fit only)|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other; one end may be 0, where the round closes to the corner)|spline (the radius along the edge is a clamped B-spline from the end nearest start: radius is its first control radius, radii the rest, knots its knot vector from 0 to 1; one end may be 0); radius2?; start?: [x,y,z]; radii?: [expr, …]; knots?: [number, …]; mid?: [[position 0…1 from start, radius expr], …] (variable radii between the ends); smooth?: bool (smooth instead of straight between the radii); fit?: exact|reduce|taper (exact, the default: a radius too large for the geometry around the edges is refused; reduce: where it doesn't fit it is reduced to the largest that does, one radius for edges sharing a face; the smallest used is returned as `radius_applied`, each edge's as `radii_applied: [{edge: [x,y,z], radius}]`, and noted in the feature's warning; taper: along each straight edge between planar faces where it doesn't fit, the radius follows the room there as a smooth spline, down to 0 where a face closes to a point, noted in the feature's warning)"),+ .params("edges: [[x,y,z] point on edge | {body, index}]; radius: expr; body?; type?: constant|curvature (alias g2: curvature-continuous quintic between planar faces along straight edges, one perpendicular planar end face at each end; radius sets the equivalent circular setback, not constant curvature; exact fit only)|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other; one end may be 0, where the round closes to the corner)|spline (the radius along the edge is a clamped B-spline from the end nearest start: radius is its first control radius, radii the rest, knots its knot vector from 0 to 1; one end may be 0); radius2?; start?: [x,y,z]; radii?: [expr, …]; knots?: [number, …]; mid?: [[position 0…1 from start, radius expr], …] (variable radii between the ends); smooth?: bool (smooth instead of straight between the radii); corner?: rolling|g2 (rolling, the default: the corners where three blended edges meet are pieces of the rolling ball's sphere, tangent to each blend; g2: a patch repeating each blend's surface up to the second order, constant-radius exact fillets only, refused where it cannot be built); fit?: exact|reduce|taper (exact, the default: a radius too large for the geometry around the edges is refused; reduce: where it doesn't fit it is reduced to the largest that does, one radius for edges sharing a face; the smallest used is returned as `radius_applied`, each edge's as `radii_applied: [{edge: [x,y,z], radius}]`, and noted in the feature's warning; taper: along each straight edge between planar faces where it doesn't fit, the radius follows the room there as a smooth spline, down to 0 where a face closes to a point, noted in the feature's warning)"),CommandSpec::new("solid.chamfer", "Chamfer", chamfer).at("SOLID", "MODIFY").icon("chamfer").params("edges: [[x,y,z] | {body, index}]; distance: expr; distance2?: expr (along the second face) | angle?: expr (from the first face); flip?: bool (which face is first: by default the one facing up most); body?"),CommandSpec::new("solid.combine", "Combine", combine).at("SOLID", "MODIFY").icon("combine").params("target: body; tools: [body]; operation?: join|cut|intersect; keep_tools?: bool; new_component?: bool (the result goes into a new component; component_name?)"),CommandSpec::new("solid.pattern.rectangular", "Rectangular Pattern", pattern_rect)@@ -1051,10 +1051,26 @@ fn fillet(s: &mut Session, p: &Value) -> Result<Value> {if !fit.is_exact() && !style.is_constant() {return Err(bad(cmd, "`fit: reduce` and `fit: taper` take a constant radius"));}+ // What fills the corners where three blended edges meet.+ let corner = match str_(p, "corner").map(str::to_ascii_lowercase).as_deref() {+ None | Some("rolling") => solidcraft_doc::FilletCorner::Rolling,+ Some("g2") => solidcraft_doc::FilletCorner::G2,+ Some(o) => return Err(bad(cmd, format!("unknown corner `{o}` (rolling or g2)"))),+ };+ if !corner.is_rolling() && (!style.is_constant() || !fit.is_exact()) {+ return Err(bad(cmd, "`corner: g2` is built for a constant-radius fillet (`type: constant`, `fit: exact`) only"));+ }let mut out = add_feature(s,p,- FeatureKind::Fillet { edges: edges.into_iter().map(Position).collect(), radius, body: str_(p, "body").map(BodyName::from), style, fit },+ FeatureKind::Fillet {+ edges: edges.into_iter().map(Position).collect(),+ radius,+ body: str_(p, "body").map(BodyName::from),+ style,+ fit,+ corner,+ },)?;// The radii the fillet used, when `fit: reduce` reduced it.if let Some(id) = out.get("feature").and_then(Value::as_u64)@@ -2042,6 +2058,55 @@ mod thin_extrude_tests;#[cfg(test)]#[path = "extrude_convention_tests.rs"]mod extrude_convention_tests;+/// `solid.fillet corner?: rolling|g2`: the default keeps the rolling ball's sphere corner, `g2`+/// is accepted and refuses (item 10's patch is built but not sewn in yet, see `corner_g2`), and an+/// unknown word is refused.+#[cfg(test)]+#[allow(clippy::unwrap_used)]+mod corner_tests {+ use serde_json::{Value, json};++ use crate::Session;++ fn run(s: &mut Session, id: &str, p: &Value) -> Value {+ s.execute(id, p).unwrap_or_else(|e| panic!("{id}: {e}"))+ }++ /// A 20 mm box with its three edges at one corner, filleted by 4 with `corner`.+ fn cornered(corner: Option<&str>) -> (Session, Value) {+ let mut s = Session::default();+ run(&mut s, "solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "B"}));+ let mut p = json!({"edges": [[10, 0, 0], [0, 10, 0], [0, 0, 10]], "radius": 4});+ if let Some(c) = corner {+ p["corner"] = json!(c);+ }+ let reply = run(&mut s, "solid.fillet", &p);+ (s, reply)+ }++ #[test]+ fn the_default_corner_is_the_rolling_ball_and_g2_refuses_clearly() {+ let (default, reply) = cornered(None);+ assert_eq!(reply["warning"], json!(null), "{reply}");+ let (rolling, _) = cornered(Some("rolling"));+ let ball = default.world_state().body("B").unwrap().body.clone();+ let same = rolling.world_state().body("B").unwrap().body.clone();+ // `corner: rolling` is the default: the same body, to the last bit of its area.+ assert_eq!(solidcraft_kernel::measure(&ball).unwrap().area, solidcraft_kernel::measure(&same).unwrap().area);+ assert!(solidcraft_kernel::measure(&ball).unwrap().volume > 7000.0);+ // `corner: g2`: accepted, and refused with a clear message until the patch sews in.+ let mut s = Session::default();+ run(&mut s, "solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "B"}));+ let err =+ s.execute("solid.fillet", &json!({"edges": [[10, 0, 0], [0, 10, 0], [0, 0, 10]], "radius": 4, "corner": "g2"})).unwrap_err().to_string();+ eprintln!("corner g2: {err}");+ assert!(err.contains("not supported yet:") && err.contains("G2 corner"), "{err}");+ // An unknown word, and a style the G2 corner has no patch for, are refused as parameters.+ assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "round"})).is_err());+ assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "g2", "type": "chord"})).is_err());+ assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "g2", "fit": "reduce"})).is_err());+ }+}#[cfg(test)]#[path = "fillet_connected_rounds_tests.rs"]mod fillet_connected_rounds_tests;diff --git a/crates/engine/src/cmd/sketch_create.rs b/crates/engine/src/cmd/sketch_create.rsindex c4eebc0d99..7b17fe4dd0 100644--- a/crates/engine/src/cmd/sketch_create.rs+++ b/crates/engine/src/cmd/sketch_create.rs@@ -88,7 +88,10 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SKETCH", "MODIFY").icon("blend").enabled(in_sketch)- .params(concat!("a, b: end points of two curves (\"l1.end\", \"a2.start\"): a smooth (tangent) spline joining them", created_doc!())),+ .params(concat!(+ "a, b: end points of two curves (\"l1.end\", \"a2.start\"), continuity?: g1|g2|g3|g4 (default g1: a tangent spline; g2…g4 match the reference curves' curvature, curvature rate and 4th derivative as well, as one Bézier of degree 5, 7 or 9)",+ created_doc!()+ )),CommandSpec::new("sketch.centerline", "Centerline", centerline).at("SKETCH", "CREATE").icon("centerline")@@ -399,8 +402,68 @@ fn end_of(sk: &Sketch, pi: usize) -> Option<(usize, Vec2)> {sk.curves.iter().enumerate().filter(|(_, c)| !c.construction).find_map(|(i, _)| leaving_dir(sk, i, pi).map(|d| (i, d)))}+/// The continuity a blend asks for: the number of derivatives of each reference curve it+/// matches at both joints (g1 is the tangent construction the tool has always made).+fn blend_order(p: &Value, cmd: &str) -> Result<usize> {+ match p.get("continuity") {+ None | Some(Value::Null) => Ok(1),+ Some(Value::String(v)) => match v.trim().to_ascii_lowercase().as_str() {+ "" | "g1" => Ok(1),+ "g2" => Ok(2),+ "g3" => Ok(3),+ "g4" => Ok(4),+ _ => Err(bad(cmd, "`continuity` must be g1, g2, g3 or g4")),+ },+ Some(_) => Err(bad(cmd, "`continuity` must be g1, g2, g3 or g4")),+ }+}++/// Negate the odd-order derivatives: how a curve's derivatives change when it is read backwards.+fn flip_odd(d: &mut [Vec2]) {+ for (i, v) in d.iter_mut().enumerate() {+ if i % 2 == 0 {+ *v = -*v;+ }+ }+}++/// Derivatives 1…`order` of curve `ci`'s continuation through its end point `pi`, in the+/// parameterisation the blend needs at that joint: at the blend's start (`leaving`) the curve's+/// continuation runs away from it, at the blend's end the blend runs into the curve instead, which+/// is the same curve read backwards. The derivatives are those of the one exact piece that ends+/// at `pi`, evaluated at that piece's own end, so an arc gives its circular-motion terms (zero+/// curvature rate included) and a conic the quotient rule's terms. Errors when the curve has no+/// exact piece, when a derivative is not finite (a corrupt or degenerate reference), or when it+/// has no tangent at all: no blend can meet the last case.+fn joint_derivatives(sk: &Sketch, ci: usize, pi: usize, order: usize, leaving: bool, what: &str, cmd: &str) -> Result<Vec<Vec2>> {+ let id = sk.curves.get(ci).map(|c| c.id.as_str()).unwrap_or("?");+ let (start, end) = sk.curves.get(ci).and_then(|c| c.kind.ends()).ok_or_else(|| bad(cmd, format!("`{id}` has no end points")))?;+ let at_end = end == pi;+ if !at_end && start != pi {+ return Err(bad(cmd, format!("`{what}` is not an end point of `{id}`")));+ }+ let pieces = sk.exact_pieces(ci);+ let seg = if at_end { pieces.last() } else { pieces.first() }.ok_or_else(|| bad(cmd, format!("`{id}` has no exact geometry")))?;+ let mut d = seg+ .derivatives(if at_end { 1.0 } else { 0.0 }, order)+ .ok_or_else(|| bad(cmd, format!("`{id}` has no finite derivatives up to order {order} at `{what}`")))?;+ // Reading the piece against its own direction, or reading the continuation into the curve+ // rather than out of it, each reverse the parameterisation once and so flip the odd+ // derivatives: the blend's start wants the continuation away from the reference's end (no+ // flip) or backwards out of its start (flip); its end wants the mirror image of that, so a+ // joint needs a flip exactly when its two readings disagree.+ if at_end != leaving {+ flip_odd(&mut d);+ }+ if !d.first().is_some_and(|t| t.len() > 0.0) {+ return Err(bad(cmd, format!("`{id}` has no tangent at `{what}`")));+ }+ Ok(d)+}+fn blend(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "sketch.blend_curve";+ let order = blend_order(p, cmd)?;let (out, info) = edit(s, p, cmd, false, |sk, _| {let pa = req_parg(sk, p, "a", cmd)?.idx().ok_or_else(|| bad(cmd, "`a` must be the end point of a curve"))?;let pb = req_parg(sk, p, "b", cmd)?.idx().ok_or_else(|| bad(cmd, "`b` must be the end point of a curve"))?;@@ -412,10 +475,34 @@ fn blend(s: &mut Session, p: &Value) -> Result<Value> {return Err(bad(cmd, "the ends must differ"));}let first_new = sk.points.len();- let c1 = sk.add_point(qa + ta * (l / 3.0), None)?;- let c2 = sk.add_point(qb + tb * (l / 3.0), None)?;- let sp = sk.add_curve(CurveKind::Spline { pts: vec![pa, c1, c2, pb], control: true, degree: 3, periodic: false }, None)?;- let cons = vec![add_c(sk, ConstraintKind::Tangent { a: ca, b: sp })?, add_c(sk, ConstraintKind::Tangent { a: cb, b: sp })?];+ let (sp, cons) = if order <= 1 {+ let c1 = sk.add_point(qa + ta * (l / 3.0), None)?;+ let c2 = sk.add_point(qb + tb * (l / 3.0), None)?;+ let sp = sk.add_curve(CurveKind::Spline { pts: vec![pa, c1, c2, pb], control: true, degree: 3, periodic: false }, None)?;+ let cons = vec![add_c(sk, ConstraintKind::Tangent { a: ca, b: sp })?, add_c(sk, ConstraintKind::Tangent { a: cb, b: sp })?];+ (sp, cons)+ } else {+ // One Bézier of degree 2·order + 1 whose controls are the Hermite interpolation of the+ // two references' derivatives, so its 1st…order-th derivatives are theirs at both+ // joints. Tangency comes from the construction, so it needs no tangent constraints.+ let da = joint_derivatives(sk, ca, pa, order, true, "a", cmd)?;+ let db = joint_derivatives(sk, cb, pb, order, false, "b", cmd)?;+ let mut pts: Vec<usize> = Vec::with_capacity(2 * order + 2);+ let cps = solidcraft_geom::hermite_bezier(qa, qb, &da, &db)+ .ok_or_else(|| bad(cmd, "the blend curve could not be built from the derivatives of `a` and `b`"))?;+ for (i, q) in cps.iter().enumerate() {+ pts.push(if i == 0 {+ pa+ } else if i + 1 == cps.len() {+ pb+ } else {+ sk.add_point(*q, None)?+ });+ }+ let degree = u8::try_from(cps.len().saturating_sub(1)).map_err(|_| bad(cmd, "the blend curve needs too many control points"))?;+ let sp = sk.add_curve(CurveKind::Spline { pts, control: true, degree, periodic: false }, None)?;+ (sp, Vec::new())+ };solve_new_only(sk, first_new);Ok((ids_of(sk, &[sp]), cons))})?;@@ -860,3 +947,391 @@ pub(super) fn solve_new_only(sk: &mut Sketch, first_new: usize) {}}}++#[cfg(test)]+mod blend_tests {+ use serde_json::{Value, json};+ use solidcraft_geom::{Seg2, Vec2};+ use solidcraft_sketch::CurveKind;++ use crate::Session;++ fn run(s: &mut Session, id: &str, p: Value) -> Value {+ match s.execute(id, &p) {+ Ok(v) => v,+ Err(e) => panic!("{id} {p}: {e}"),+ }+ }++ fn ids(v: &Value) -> Vec<String> {+ v.as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default()+ }++ fn new_sketch() -> Session {+ let mut s = Session::default();+ run(&mut s, "sketch.create", json!({"plane": "XY"}));+ s+ }++ fn sketch(s: &Session) -> solidcraft_sketch::Sketch {+ let id = s.active_sketch.unwrap();+ s.model.state().sketch(id).unwrap().sketch.clone()+ }++ fn factorial(n: usize) -> f64 {+ (1..=n).fold(1.0, |a, b| a * b as f64)+ }++ /// The derivatives 1…`order` of exact piece `seg` at its end (`at_end`), from the piece's own+ /// geometry: what a blend must match, computed here independently of `Seg2::derivatives`.+ fn piece_derivatives(seg: &Seg2, at_end: bool, order: usize) -> Vec<Vec2> {+ let t = if at_end { 1.0 } else { 0.0 };+ let p = seg.point_at(t);+ let mut d = match *seg {+ Seg2::Line { a, b } => vec![b - a, Vec2::ZERO, Vec2::ZERO, Vec2::ZERO],+ Seg2::Arc { center, sweep, .. } => {+ let (v, s2) = (seg.derivative(t), sweep * sweep);+ vec![v, (p - center) * -s2, v * -s2, (p - center) * (s2 * s2)]+ }+ Seg2::Cubic { p0, p1, p2, p3 } => {+ let third = (p3 - p2 * 3.0 + p1 * 3.0 - p0) * 6.0;+ if at_end {+ vec![(p3 - p2) * 3.0, (p3 - p2 * 2.0 + p1) * 6.0, third, Vec2::ZERO]+ } else {+ vec![(p1 - p0) * 3.0, (p0 - p1 * 2.0 + p2) * 6.0, third, Vec2::ZERO]+ }+ }+ Seg2::Conic { a, apex, b, w } => {+ // The rational quadratic's numerator N and weight D as quadratics in the power+ // basis; dividing N's series by D's (constant term 1 at both ends) has to give the+ // Taylor coefficients of the curve.+ let (n0, n1, n2) = (a, apex * (2.0 * w) - a * 2.0, a - apex * (2.0 * w) + b);+ let (e1, e2) = (2.0 * (w - 1.0), 2.0 * (1.0 - w));+ let h = 1e-3;+ let series = |f: &dyn Fn(f64) -> Vec2| [f(t), (f(t + h) - f(t - h)) / (2.0 * h), (f(t + h) - f(t) * 2.0 + f(t - h)) / (2.0 * h * h)];+ let n = series(&|x| n0 + n1 * x + n2 * (x * x));+ let den = [1.0 + e1 * t + e2 * (t * t), e1 + e2 * (2.0 * t), e2];+ let mut x = vec![n[0] / den[0]];+ for j in 1..=order {+ let mut v = n.get(j).copied().unwrap_or(Vec2::ZERO);+ for i in 1..=j {+ v -= x[j - i] * den.get(i).copied().unwrap_or(0.0);+ }+ x.push(v / den[0]);+ }+ x.remove(0);+ x.into_iter().enumerate().map(|(i, v)| v * factorial(i + 1)).collect()+ }+ Seg2::Bezier { .. } => panic!("a test piece is not a high-degree Bézier"),+ };+ d.truncate(order);+ d+ }++ /// The derivatives 1…`order` the blend's own control polygon carries at an end: the j-th+ /// difference of the controls, scaled by `n!/(n − j)!` (the Bézier endpoint identity).+ fn blend_derivatives(ctrl: &[Vec2], at_end: bool, order: usize) -> Vec<Vec2> {+ let c: Vec<Vec2> = if at_end { ctrl.iter().rev().copied().collect() } else { ctrl.to_vec() };+ let n = c.len() - 1;+ let (mut diffs, mut scale) = (c, 1.0);+ let mut out = Vec::new();+ for j in 1..=order {+ diffs = diffs.windows(2).map(|w| w[1] - w[0]).collect();+ scale *= (n + 1 - j) as f64;+ out.push(diffs.first().copied().unwrap_or_default() * scale);+ }+ if at_end {+ for (i, v) in out.iter_mut().enumerate() {+ if i % 2 == 0 {+ *v = -*v;+ }+ }+ }+ out+ }++ /// The blend curve's control points, its degree and the one exact piece they make.+ fn blend_of(s: &Session, id: &str) -> (Vec<Vec2>, usize, Seg2) {+ let sk = sketch(s);+ let ci = sk.curve_index(id).unwrap();+ let ctrl: Vec<Vec2> = sk.curves[ci].kind.point_ids().iter().map(|i| sk.point(*i).unwrap()).collect();+ let degree = match sk.curves[ci].kind {+ CurveKind::Spline { degree, .. } => usize::from(degree),+ ref other => panic!("{other:?}"),+ };+ let pieces = sk.exact_pieces(ci);+ assert_eq!(pieces.len(), 1, "{pieces:?}");+ (ctrl, degree, pieces[0])+ }++ /// The reference pair the tests build: a line `(0, 0)`–`(6, 0)` ending at `a` and a three-point+ /// control spline starting at `b`, so the blend runs out of the first and into the second with+ /// no reversal at either joint.+ fn two_references(s: &mut Session) -> (String, String, [Vec2; 4]) {+ let a = ids(&run(s, "sketch.line", json!({"points": [[0, 0], [6, 0]]}))["curves"])[0].clone();+ let bctrl = [Vec2::new(20.0, 10.0), Vec2::new(24.0, 14.0), Vec2::new(30.0, 9.0), Vec2::new(34.0, 6.0)];+ let b = ids(&run(s, "sketch.spline.control_point", json!({"points": [[20, 10], [24, 14], [30, 9], [34, 6]]}))["curves"])[0].clone();+ (a, b, bctrl)+ }++ #[test]+ fn blend_curve_matches_both_references_through_the_requested_order() {+ for order in 1..=4usize {+ let mut s = new_sketch();+ let (a, b, bctrl) = two_references(&mut s);+ let r = run(+ &mut s,+ "sketch.blend_curve",+ json!({+ "a": format!("{a}.end"),+ "b": format!("{b}.start"),+ "continuity": format!("g{order}"),+ }),+ );+ let sp = ids(&r["curves"])[0].clone();+ let (ctrl, degree, piece) = blend_of(&s, &sp);+ assert_eq!(degree, 2 * order + 1, "g{order} is one Bézier of degree 2k+1");+ assert_eq!(ctrl.len(), 2 * order + 2, "g{order} control count");+ assert!(r["sketch"]["solved"].as_bool().unwrap_or(false), "{r}");+ assert!(piece.start().dist(Vec2::new(6.0, 0.0)) < 1e-12 && piece.end().dist(bctrl[0]) < 1e-12, "the blend joins `a` and `b`");++ // What each reference supplies at the joint: the line's own derivative at its end (and+ // nothing higher) and the cubic's at its start.+ let line = piece_derivatives(&Seg2::Line { a: Vec2::ZERO, b: Vec2::new(6.0, 0.0) }, true, 4);+ let cubic = piece_derivatives(&Seg2::Cubic { p0: bctrl[0], p1: bctrl[1], p2: bctrl[2], p3: bctrl[3] }, false, 4);+ let got0 = blend_derivatives(&ctrl, false, 4);+ let got1 = blend_derivatives(&ctrl, true, 4);+ // g1 is the tangent construction of the tool: the first derivative is parallel to the+ // reference's (that is what G1 is), with the tool's own chord-scaled magnitude. g2 and+ // up match the reference's derivative vectors themselves.+ let tan_line = line[0].normalized().unwrap();+ let tan_cubic = cubic[0].normalized().unwrap();+ assert!(got0[0].cross(tan_line).abs() < 1e-9 && got0[0].dot(tan_line) > 0.0, "g{order} leaves `a` along {tan_line:?}, not {:?}", got0[0]);+ assert!(+ got1[0].cross(tan_cubic).abs() < 1e-9 && got1[0].dot(tan_cubic) > 0.0,+ "g{order} enters `b` along {tan_cubic:?}, not {:?}",+ got1[0]+ );+ for j in 1..order {+ assert!(got0[j].dist(line[j]) < 1e-9, "g{order} at a, order {}: {:?} vs {:?}", j + 1, got0[j], line[j]);+ assert!(got1[j].dist(cubic[j]) < 1e-9, "g{order} at b, order {}: {:?} vs {:?}", j + 1, got1[j], cubic[j]);+ }+ if order >= 2 {+ for (got, want) in [(got0[0], line[0]), (got1[0], cubic[0])] {+ assert!(got.dist(want) < 1e-9, "g{order} matches the reference's own derivative: {got:?} vs {want:?}");+ }+ }+ // The next order up is not met: the line has no derivative there at all, while a blend of+ // degree 2k+1 has.+ if order < 4 {+ let next = got0[order];+ assert!(next.dist(line[order]) > 1e-6, "g{order} matched one order too many at a: {next:?}");+ }+ // Curvature itself (orientation-free, from finite differences of the samples) agrees at+ // both joints once the order asks for it.+ if order >= 2 {+ let curve = |x: f64| piece.point_at(x.clamp(0.0, 1.0));+ let line_f = |x: f64| Vec2::new(6.0 * x, 0.0);+ let cubic_f = |x: f64| Seg2::Cubic { p0: bctrl[0], p1: bctrl[1], p2: bctrl[2], p3: bctrl[3] }.point_at(x);+ let k0 = solidcraft_sketch::end_curvature(&curve, false);+ let ka = solidcraft_sketch::end_curvature(&line_f, true);+ let k1 = solidcraft_sketch::end_curvature(&curve, true);+ let kb = solidcraft_sketch::end_curvature(&cubic_f, false);+ assert!(k0.dist(ka) < 1e-3, "g{order} curvature at a: {k0:?} vs {ka:?}");+ assert!(k1.dist(kb) < 1e-3, "g{order} curvature at b: {k1:?} vs {kb:?}");+ }+ }+ }++ #[test]+ fn blend_curve_g1_is_the_tangent_construction_with_its_constraints() {+ let mut s = new_sketch();+ let (a, b, bctrl) = two_references(&mut s);+ let r = run(&mut s, "sketch.blend_curve", json!({"a": format!("{a}.end"), "b": format!("{b}.start")}));+ let sp = ids(&r["curves"])[0].clone();+ let (ctrl, degree, _) = blend_of(&s, &sp);+ assert_eq!(degree, 3, "the default is the cubic tangent spline");+ let (qa, qb) = (Vec2::new(6.0, 0.0), bctrl[0]);+ let l = qa.dist(qb);+ let tb = (qb - bctrl[1]).normalized().unwrap();+ let want = [qa, qa + Vec2::X * (l / 3.0), qb + tb * (l / 3.0), qb];+ for (i, q) in want.iter().enumerate() {+ assert!(ctrl[i].dist(*q) < 1e-9, "g1 control {i}: {:?} vs {q:?}", ctrl[i]);+ }+ assert_eq!(ids(&r["constraints"]).len(), 2, "the two tangents are kept: {r}");+ // g2…g4 meet the derivatives by construction and need no constraint of their own.+ for order in 2..=4usize {+ let mut s = new_sketch();+ let (a, b, _) = two_references(&mut s);+ let r = run(+ &mut s,+ "sketch.blend_curve",+ json!({+ "a": format!("{a}.end"),+ "b": format!("{b}.start"),+ "continuity": format!("g{order}"),+ }),+ );+ assert!(ids(&r["constraints"]).is_empty(), "g{order}: {r}");+ }+ }++ #[test]+ fn blend_curve_between_two_lines_is_curvature_free_to_the_requested_order() {+ // Two lines meeting at a right angle: from G2 on, the blend has the lines' own zero+ // curvature at both joints (a corner with no curvature jump).+ for order in 2..=4usize {+ let mut s = new_sketch();+ let a = ids(&run(&mut s, "sketch.line", json!({"points": [[0, 0], [2, 0]]}))["curves"])[0].clone();+ let b = ids(&run(&mut s, "sketch.line", json!({"points": [[20, 10], [20, 12]]}))["curves"])[0].clone();+ let r = run(+ &mut s,+ "sketch.blend_curve",+ json!({+ "a": format!("{a}.end"),+ "b": format!("{b}.start"),+ "continuity": format!("g{order}"),+ }),+ );+ let sp = ids(&r["curves"])[0].clone();+ let (ctrl, degree, piece) = blend_of(&s, &sp);+ assert_eq!(degree, 2 * order + 1);+ let got0 = blend_derivatives(&ctrl, false, 4);+ let got1 = blend_derivatives(&ctrl, true, 4);+ assert!(got0[0].dist(Vec2::new(2.0, 0.0)) < 1e-12, "g{order} leaves `a` along +x: {:?}", got0[0]);+ assert!(got1[0].dist(Vec2::new(0.0, 2.0)) < 1e-12, "g{order} enters `b` along +y: {:?}", got1[0]);+ for j in 1..order {+ assert!(got0[j].len() < 1e-12, "g{order}: a line has no order-{} derivative", j + 1);+ assert!(got1[j].len() < 1e-12, "g{order}: a line has no order-{} derivative", j + 1);+ }+ if order < 4 {+ assert!(got0[order].len() > 1e-6, "g{order}: the blend curves, the line does not");+ }+ assert!(piece.start().dist(Vec2::new(2.0, 0.0)) < 1e-12 && piece.end().dist(Vec2::new(20.0, 10.0)) < 1e-12);+ }+ }++ #[test]+ fn blend_curve_matches_a_conic_reference() {+ for order in 2..=4usize {+ let mut s = new_sketch();+ let a = ids(&run(&mut s, "sketch.line", json!({"points": [[0, 0], [2, 0]]}))["curves"])[0].clone();+ let b = ids(&run(&mut s, "sketch.conic", json!({"start": [20, 10], "apex": [26, 16], "end": [30, 10], "rho": 0.7}))["curves"])[0].clone();+ let r = run(+ &mut s,+ "sketch.blend_curve",+ json!({+ "a": format!("{a}.end"),+ "b": format!("{b}.start"),+ "continuity": format!("g{order}"),+ }),+ );+ let sp = ids(&r["curves"])[0].clone();+ let (ctrl, degree, _) = blend_of(&s, &sp);+ assert_eq!(degree, 2 * order + 1);+ // The conic's own derivatives at its start: `w` comes from the sketch's `rho`, and the+ // series division in `piece_derivatives` is the expectation.+ let w = 0.7 / (1.0 - 0.7);+ let conic = Seg2::Conic { a: Vec2::new(20.0, 10.0), apex: Vec2::new(26.0, 16.0), b: Vec2::new(30.0, 10.0), w };+ let want = piece_derivatives(&conic, false, order);+ let got = blend_derivatives(&ctrl, true, order);+ for j in 0..order {+ assert!(got[j].dist(want[j]) < 1e-8 * want[j].len().max(1.0), "g{order} order {}: {:?} vs {:?}", j + 1, got[j], want[j]);+ }+ }+ }++ #[test]+ fn blend_curve_refuses_hostile_orders_and_degenerate_references() {+ let mut s = new_sketch();+ let (a, b, _) = two_references(&mut s);+ let ends = json!({"a": format!("{a}.end"), "b": format!("{b}.start")});+ for (order, want) in [("g0", true), ("g9", true), ("G9", true), ("curvature", true), ("", false), ("g2", false), ("G4", false)] {+ let mut p = ends.clone();+ p["continuity"] = json!(order);+ let r = s.execute("sketch.blend_curve", &p);+ assert_eq!(r.is_err(), want, "continuity {order:?}: {r:?}");+ assert!(r.is_ok() || r.unwrap_err().to_string().contains("continuity"), "continuity {order:?} needs a clear error");+ }+ let mut numbered = ends.clone();+ numbered["continuity"] = json!(3);+ assert!(s.execute("sketch.blend_curve", &numbered).is_err(), "a number is not a continuity");+ // A point that is not an end of a curve, and the same end twice.+ let p = ids(&run(&mut s, "sketch.point", json!({"point": [50, 50]}))["created"]["points"])[0].clone();+ let e = s.execute("sketch.blend_curve", &json!({"a": p, "b": format!("{b}.start")})).unwrap_err().to_string();+ assert!(e.contains("no curve ends at `a`"), "{e}");+ let e = s.execute("sketch.blend_curve", &json!({"a": format!("{a}.end"), "b": format!("{a}.end")})).unwrap_err().to_string();+ assert!(e.contains("ends must differ"), "{e}");+ // The helper behind the command refuses a corrupt (non-finite) reference and a reference+ // with no tangent at all, never guessing at them.+ let mut broken = solidcraft_sketch::Sketch::new();+ let p0 = broken.add_point(Vec2::new(1.0, 1.0), None).unwrap();+ let p1 = broken.add_point(Vec2::ZERO, None).unwrap();+ let l = broken.add_curve(CurveKind::Spline { pts: vec![p1, p0], control: true, degree: 1, periodic: false }, None).unwrap();+ broken.points[p0].pos = Vec2::new(f64::NAN, 4.0);+ assert!(super::joint_derivatives(&broken, l, p1, 2, true, "a", "sketch.blend_curve").is_err(), "non-finite geometry");+ let mut flat = solidcraft_sketch::Sketch::new();+ let q0 = flat.add_point(Vec2::new(3.0, 3.0), None).unwrap();+ let q1 = flat.add_point(Vec2::new(3.0, 3.0), None).unwrap();+ let d = flat.add_curve(CurveKind::Spline { pts: vec![q0, q1], control: true, degree: 1, periodic: false }, None).unwrap();+ let e = super::joint_derivatives(&flat, d, q0, 2, true, "a", "sketch.blend_curve").unwrap_err().to_string();+ assert!(e.contains("no tangent"), "{e}");+ assert!(solidcraft_geom::hermite_bezier(Vec2::ZERO, Vec2::X, &[Vec2::Y; 5], &[Vec2::Y; 5]).is_none(), "no order above g4");+ }++ #[test]+ fn blend_curve_with_g4_closes_a_profile_that_measures_exactly() {+ // A quarter-turn blend from (2, 0) into a line at (20, 10), closed by the chord between its+ // ends: the region's area comes from the degree-9 curve, not from its chord.+ let mut s = new_sketch();+ let a = ids(&run(&mut s, "sketch.line", json!({"points": [[0, 0], [2, 0]]}))["curves"])[0].clone();+ let b = ids(&run(&mut s, "sketch.line", json!({"points": [[20, 10], [20, 12]]}))["curves"])[0].clone();+ let r = run(+ &mut s,+ "sketch.blend_curve",+ json!({+ "a": format!("{a}.end"),+ "b": format!("{b}.start"),+ "continuity": "g4",+ }),+ );+ let sp = ids(&r["curves"])[0].clone();+ let (ctrl, degree, piece) = blend_of(&s, &sp);+ assert_eq!(degree, 9, "G4 is one degree-9 Bézier");+ assert_eq!(ctrl.len(), 10);+ // The command still reports what it added, with stable ids: ten controls of which the two+ // joints are the references' own points, so eight new points, and no new constraint.+ assert_eq!(ids(&r["created"]["curves"]), vec![sp.clone()], "{r}");+ assert_eq!(ids(&r["created"]["points"]).len(), 8, "{r}");+ assert!(ids(&r["created"]["constraints"]).is_empty() && ids(&r["created"]["dimensions"]).is_empty(), "{r}");+ run(&mut s, "sketch.line", json!({"points": [[20, 10], [2, 0]], "id": "chord"}));+ // Drop the two references: what is left is the blend and its chord, one closed region.+ run(&mut s, "sketch.delete", json!({"entities": [a, b]}));+ let id = s.active_sketch.unwrap();+ let state = s.model.state();+ let profiles = &state.sketch(id).unwrap().profiles;+ assert_eq!(profiles.len(), 1, "the blend and the chord close one region");+ let area = profiles[0].area;+ // A fine sampling of the exact piece plus the straight chord reproduces the area; the chord+ // alone (what a polyline approximation would give) is exactly zero.+ let n = 20_000;+ let mut sampled = 0.0;+ for i in 0..n {+ let (t0, t1) = (i as f64 / n as f64, (i + 1) as f64 / n as f64);+ sampled += 0.5 * piece.point_at(t0).cross(piece.point_at(t1));+ }+ // The chord back from (20, 10) to (2, 0) contributes its own shoelace term; together they+ // are the region.+ sampled += 0.5 * Vec2::new(20.0, 10.0).cross(Vec2::new(2.0, 0.0));+ assert!((area - sampled.abs()).abs() < 1e-4, "{area} vs {sampled}");+ assert!(area > 1e-2, "the blend curves away from the chord: {area}");+ // And the degree-9 profile still extrudes to its area times the height (the kernel's+ // volume of a free-form body is a numerical integration, so this is the same 2e-4 the+ // neighbouring free-form extrusion test allows).+ run(&mut s, "solid.extrude", json!({"distance": 5}));+ let m = run(&mut s, "inspect.measure", json!({}));+ let volume = m["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN);+ assert!((volume - area * 5.0).abs() / (area * 5.0) < 2e-4, "volume {volume} vs {}", area * 5.0);+ assert!(m["bodies"][0]["faces"].as_u64().unwrap_or(0) >= 3, "a solid with the blend as a side: {m}");+ }+}diff --git a/crates/engine/src/cmd/sketch_support.rs b/crates/engine/src/cmd/sketch_support.rsindex 1f3b1543e1..bb8afe8c25 100644--- a/crates/engine/src/cmd/sketch_support.rs+++ b/crates/engine/src/cmd/sketch_support.rs@@ -5,6 +5,11 @@ use solidcraft_sketch::{Shape, intersections};use crate::{Result, params::bad};+/// Degrees the exact extend intersection handles: a round support squares the piece's degree in+/// homogeneous form, and both the root finder and its `evaluate` buffer hold at most 15+/// coefficients, so 2·7 + 1 fits.+const MAX_EXACT_EXTEND_DEGREE: u8 = 7;+fn choose(n: usize, k: usize) -> f64 {(0..k.min(n - k)).fold(1.0, |value, i| value * (n - i) as f64 / (i + 1) as f64)}@@ -113,7 +118,7 @@ pub(super) fn hits(support: &Shape, seg: &Seg2, budget: &mut usize) -> Result<Velet (points, weights): (Vec<Vec2>, Vec<f64>) = match *seg {Seg2::Cubic { p0, p1, p2, p3 } => (vec![p0, p1, p2, p3], vec![1.0; 4]),Seg2::Conic { a, apex, b, w } if w.is_finite() && w > 0.0 => (vec![a, apex, b], vec![1.0, w, 1.0]),- Seg2::Bezier { n, p } if (1..=7).contains(&n) => (p[..=usize::from(n)].to_vec(), vec![1.0; usize::from(n) + 1]),+ Seg2::Bezier { n, p } if (1..=MAX_EXACT_EXTEND_DEGREE).contains(&n) => (p[..=usize::from(n)].to_vec(), vec![1.0; usize::from(n) + 1]),_ => return Err(bad("sketch.extend", "invalid exact curve piece")),};if points.iter().any(|p| !p.is_finite()) {@@ -195,8 +200,8 @@ mod tests {elevated.push(y[n - 1]);y = elevated;}- let mut points = [Vec2::ZERO; 8];- for (i, p) in points.iter_mut().enumerate() {+ let mut points = [Vec2::ZERO; solidcraft_geom::MAX_BEZIER_CTRL];+ for (i, p) in points.iter_mut().take(8).enumerate() {*p = Vec2::new(10.0 + i as f64 * 20.0 / 7.0, y[i]);}let target = Seg2::Bezier { n: 7, p: points };diff --git a/crates/engine/src/cmd/surface.rs b/crates/engine/src/cmd/surface.rsindex 4e76e0d465..bde3ffa226 100644--- a/crates/engine/src/cmd/surface.rs+++ b/crates/engine/src/cmd/surface.rs@@ -51,7 +51,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("surface.loft", "Surface Loft", surface_loft).at("SURFACE", "CREATE").icon("surface_loft")- .params("sections: [{sketch, curves?: [curve ids], profiles?}] (2…50 in order; each one chain: a profile without holes, or curves meeting end to end; all open or all closed); name?, body_name? (a surface body: ruled between two sections, smooth through three or more; no caps)"),+ .params("sections: [{sketch, curves?: [curve ids], profiles?} | {body, edges: [[x,y,z]]}] (2…50 in order; each one chain: a profile without holes, or curves meeting end to end; all open or all closed; a body edge chain takes the face the chain bounds as the surface the end repeats); continuity?: [g0|g1|g2|g3, g0|g1|g2|g3] (each end, default g0: how much of the surface at the first and last section the loft repeats — the tangent plane, the curvature, or how that curvature changes); crown?: [number, number] (default 0: how full each end leaves, -0.9 flattest to 3 fullest); name?, body_name? (a surface body: ruled between two sections, smooth through three or more; no caps)"),CommandSpec::new("surface.offset", "Offset Surface", offset).at("SURFACE", "CREATE").icon("surface_offset")@@ -369,15 +369,57 @@ fn surface_loft(s: &mut Session, p: &Value) -> Result<Value> {}let mut sections = Vec::with_capacity(given.len());for sec in given {+ // A section is a chain of sketch curves, or an edge chain of a body whose face the end of+ // the loft repeats.+ if let Some(body) = str_(sec, "body") {+ let edges: Vec<solidcraft_geom::Vec3> =+ sec.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(vec3).collect()).unwrap_or_default();+ if edges.is_empty() || edges.len() > 10_000 {+ return Err(bad(cmd, "`sections.edges` must list 1 to 10000 points on the edges of a chain"));+ }+ if sec.get("sketch").is_some() {+ return Err(bad(cmd, "a section is either a sketch chain or a body edge chain"));+ }+ sections.push(solidcraft_doc::SheetSection {+ sketch: SketchId(0),+ profiles: None,+ curves: Vec::new(),+ body: Some(BodyName::from(body.to_string())),+ edges: edges.into_iter().map(Position).collect(),+ });+ continue;+ }let sketch = sketch_id(s, sec.get("sketch"), cmd, "sections.sketch")?;let curves = string_list(sec, "curves");if curves.len() > 1000 {return Err(bad(cmd, "at most 1000 curves a section"));}let profiles = if sec.get("profiles").is_some() { Some(profiles(sec, cmd)?) } else { None };- sections.push(solidcraft_doc::SheetSection { sketch: SketchId(sketch), profiles, curves });+ sections.push(solidcraft_doc::SheetSection { sketch: SketchId(sketch), profiles, curves, body: None, edges: Vec::new() });}- add_feature(s, p, FeatureKind::SurfaceLoft { sections })+ let continuity = match p.get("continuity") {+ None => [Continuity::G0, Continuity::G0],+ Some(v) => {+ let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`continuity` must be two words, one per end"))?;+ let word = |x: Option<&Value>| -> Result<Continuity> {+ x.and_then(Value::as_str).and_then(Continuity::parse).ok_or_else(|| bad(cmd, "`continuity` entries must be g0, g1, g2 or g3"))+ };+ [word(list.first())?, word(list.get(1))?]+ }+ };+ let crown = match p.get("crown") {+ None | Some(Value::Null) => [0.0, 0.0],+ Some(v) => {+ let list = v.as_array().filter(|a| a.len() == 2).ok_or_else(|| bad(cmd, "`crown` must be two numbers, one per end"))?;+ let one = |x: Option<&Value>| -> Result<f64> {+ x.and_then(Value::as_f64)+ .filter(|x| x.is_finite() && (-0.9..=3.0).contains(x))+ .ok_or_else(|| bad(cmd, "each `crown` entry must be between -0.9 (flattest) and 3 (fullest)"))+ };+ [one(list.first())?, one(list.get(1))?]+ }+ };+ add_feature(s, p, FeatureKind::SurfaceLoft { sections, continuity, crown })}fn offset(s: &mut Session, p: &Value) -> Result<Value> {@@ -1212,7 +1254,7 @@ mod tests {/// as it was.#[test]fn planned_commands_refuse_and_leave_the_design_alone() {- let planned = ["surface.fillet", "inspect.continuity"];+ let planned = ["surface.fillet"];let mut s = Session::default();run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "B"}));let before = s.doc.features.len();@@ -1588,4 +1630,68 @@ mod tests {assert!(s.execute("surface.fair", &json!({"body": "Shell", "iterations": 0, "tolerance": 1.0})).is_err());assert!(s.execute("surface.fair", &json!({"body": "Shell", "tolerance": 0})).is_err());}++ /// A loft through three sections whose first and last are edge chains of two boxes, with+ /// `continuity: ["g1","g1"]`: it leaves each box's top face tangentially (the run direction+ /// lies in that face) and passes through the sketch between them.+ #[test]+ fn surface_loft_leaves_a_box_face_tangentially() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"corner": [0, 0, 0], "length": 20, "width": 20, "height": 10, "body_name": "Low"}));+ run(&mut s, "solid.box", json!({"corner": [40, 0, 0], "length": 20, "width": 20, "height": 10, "body_name": "High"}));+ run(&mut s, "construct.plane.offset", json!({"base": "YZ", "offset": 30, "name": "Mid"}));+ run(&mut s, "sketch.create", json!({"plane": "Mid", "name": "Bump"}));+ run(&mut s, "sketch.line", json!({"points": [[0, 14], [20, 14]], "ids": ["b"]}));+ run(&mut s, "sketch.finish", json!({}));+ run(+ &mut s,+ "surface.loft",+ json!({+ "sections": [+ {"body": "Low", "edges": [[20, 5, 10], [20, 15, 10]]},+ {"sketch": "Bump", "curves": ["b"]},+ {"body": "High", "edges": [[40, 5, 10], [40, 15, 10]]}+ ],+ "continuity": ["g1", "g1"],+ "crown": [0, 0],+ "body_name": "Blend"+ }),+ );+ let body = s.world_state().body("Blend").unwrap().body.clone();+ // A fine grid in the run direction: the seams sit at u = 0, 1/2 and 1, and the first step+ // off each one is the tangent there (a thousandth of the run, so it is the tangent).+ let grid = solidcraft_kernel::sample_grid(&body, 1001, 9).unwrap();+ // The ends lie on the two boxes' top faces, and the sketch is met exactly between them.+ for p in &grid[0] {+ assert!((p.z - 10.0).abs() < 1e-9 && (p.x - 20.0).abs() < 1e-9, "the first seam is the box edge: {p:?}");+ }+ for p in &grid[1000] {+ assert!((p.z - 10.0).abs() < 1e-9 && (p.x - 40.0).abs() < 1e-9, "the last seam is the box edge: {p:?}");+ }+ for p in &grid[500] {+ assert!((p.z - 14.0).abs() < 1e-9 && (p.x - 30.0).abs() < 1e-9, "the blend meets the sketch: {p:?}");+ }+ // The seam leaves along the box's top face: the run direction the blend is given is what+ // the face holds, so the tangent there is horizontal and along the run. (The step the grid+ // takes is a thousandth of the run, and a chord over that step carries an O(h²) bias of+ // about 0.011 here, so 1e-2 on the rise off the face is what the grid can measure; the+ // kernel's own tests pin the tangent to the frame's leave direction exactly.)+ for j in [0usize, 4, 8] {+ let d = (grid[1][j] - grid[0][j]).normalized().unwrap();+ assert!(d.z.abs() < 2e-2 && d.x > 0.999, "the blend leaves the low box's top face: {d:?}");+ let d = (grid[1000][j] - grid[999][j]).normalized().unwrap();+ assert!(d.z.abs() < 2e-2 && d.x > 0.999, "the blend arrives along the high box's top face: {d:?}");+ }+ // Hostile parameters are refused, never panicking.+ let bad = [+ json!({"sections": [{"body": "Low", "edges": [[20, 5, 10], [20, 15, 10]]}, {"sketch": "Bump", "curves": ["b"]}], "continuity": ["g1"]}),+ json!({"sections": [{"body": "Low", "edges": []}, {"sketch": "Bump", "curves": ["b"]}], "continuity": ["g1", "g1"]}),+ json!({"sections": [{"body": "Low", "edges": [[20, 5, 10]], "sketch": "Bump"}, {"sketch": "Bump", "curves": ["b"]}]}),+ json!({"sections": [{"sketch": "Bump", "curves": ["b"]}, {"sketch": "Bump", "curves": ["b"]}], "crown": [5, 0]}),+ json!({"sections": [{"sketch": "Bump", "curves": ["b"]}, {"sketch": "Bump", "curves": ["b"]}], "continuity": ["g9", "g1"]}),+ ];+ for p in bad {+ assert!(s.execute("surface.loft", &p).is_err(), "hostile loft params: {p}");+ }+ }}diff --git a/crates/engine/src/cmd/surface_analysis.rs b/crates/engine/src/cmd/surface_analysis.rsindex dbcea9f06f..b0f6e45609 100644--- a/crates/engine/src/cmd/surface_analysis.rs+++ b/crates/engine/src/cmd/surface_analysis.rs@@ -5,8 +5,19 @@ use serde_json::{Value, json};use solidcraft_geom::Vec3;use super::CommandSpec;-use crate::params::{bad, bool_, num, vec3};-use crate::{Result, Session, SurfaceAnalysis};+use crate::params::{bad, bool_, num, str_, vec3};+use crate::{ContinuitySeam, Result, Session, SurfaceAnalysis, kernel};++/// Stations along each edge when the call does not say (`samples`).+const DEFAULT_SAMPLES: usize = 33;+/// Tolerances a seam is judged against when the call does not say: a micron of position gap, a+/// degree of normal angle, and a curvature jump of 1/100 mm.+const DEFAULT_GAP_MM: f64 = 1e-3;+const DEFAULT_ANGLE_DEG: f64 = 1.0;+const DEFAULT_CURVATURE_PER_MM: f64 = 0.01;+/// Most edges one call may pick, and most bodies one call may analyse at once.+const MAX_PICKS: usize = 512;+const MAX_BODIES: usize = 64;pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("inspect.zebra", "Zebra Analysis", zebra)@@ -34,11 +45,14 @@ pub static COMMANDS: &[CommandSpec] = &[.icon("curvature_map").noundo().params("radius?: mm shown red (default: a tenth of the model's size); clear?: true turns the analysis off"),- planned!("inspect.continuity", "Continuity Analysis", "770")- .at("SURFACE", "INSPECT")- .icon("continuity")- .noundo()- .params("planned: body?; edges?: [[x,y,z]] (default: every edge of the body); returns each edge's worst gap (G0), normal angle (G1) and curvature jump (G2); clear?: true turns the analysis off"),+ CommandSpec::new("inspect.continuity", "Continuity Analysis", continuity).at("SURFACE", "INSPECT").icon("continuity").noundo().params(+ "body?: name (default: the visible bodies); edges?: [x,y,z] points or {\"index\": i} (default: every edge of the body; \+ a pick must match one body); samples?: 3…257 stations along each edge, ends included (default 33); \+ gap_tolerance_mm? (default 0.001), angle_tolerance_deg? (default 1), curvature_tolerance_per_mm? (default 0.01); \+ clear?: true turns the analysis off. → each edge's worst gap (G0), normal angle (G1) and curvature jump (G2) as \+ {value, at: [x,y,z], edge_fraction}, its verdict (smooth, curvature_jump, sharp or gap) and a summary; \+ the seams are shaded in the viewport",+ ),];fn set(s: &mut Session, p: &Value, a: SurfaceAnalysis) -> Result<Value> {@@ -94,12 +108,214 @@ fn curvature_map(s: &mut Session, p: &Value) -> Result<Value> {set(s, p, SurfaceAnalysis::Curvature { radius })}+/// `inspect.continuity`: measure how far the two faces meeting at each picked edge (or at every+/// edge of a body) depart from sharing a curve (G0), a tangent plane (G1) and a curvature (G2),+/// and keep the seams so the viewport can shade them. View state only: the design and its undo+/// history are untouched (`noundo`), as with the other analyses.+fn continuity(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "inspect.continuity";+ if bool_(p, "clear").unwrap_or(false) {+ s.continuity.clear();+ s.revision += 1;+ return Ok(json!({ "analysis": "continuity", "cleared": true }));+ }+ let samples = match p.get("samples") {+ None => DEFAULT_SAMPLES,+ Some(v) => match v.as_f64().filter(|n| n.is_finite() && n.fract() == 0.0 && (3.0..=257.0).contains(n)) {+ Some(n) => n as usize,+ None => return Err(bad(cmd, "`samples` must be 3…257 stations along each edge")),+ },+ };+ let tolerances = kernel::ContinuityTolerances {+ gap_mm: tolerance(p, "gap_tolerance_mm", DEFAULT_GAP_MM)?,+ angle_deg: tolerance(p, "angle_tolerance_deg", DEFAULT_ANGLE_DEG)?,+ curvature_per_mm: tolerance(p, "curvature_tolerance_per_mm", DEFAULT_CURVATURE_PER_MM)?,+ };+ let picks = edge_picks(p)?;+ let st = s.world_state();+ let named = str_(p, "body");+ let candidates: Vec<&solidcraft_doc::ModelBody> = match named {+ Some(name) => vec![st.body(name).ok_or_else(|| bad(cmd, format!("no body `{name}`")))?],+ None => st.bodies.iter().filter(|b| s.body_visible(&b.name)).collect(),+ };+ if candidates.is_empty() {+ return Err(bad(cmd, "there are no visible bodies to analyse: name a `body`"));+ }+ if candidates.len() > MAX_BODIES {+ return Err(bad(cmd, format!("more than {MAX_BODIES} bodies are shown: name the `body` to analyse")));+ }+ let mut targets: Vec<(&solidcraft_doc::ModelBody, Vec<usize>)> = Vec::new();+ if picks.is_empty() {+ targets.extend(candidates.into_iter().map(|b| (b, Vec::new())));+ } else {+ // Picks mean edges of one body (a design may stack bodies at the same place): a list+ // that lands on one body's edges only is analysed, and anything else is refused.+ let mut hits = Vec::new();+ let mut refused = None;+ for b in candidates {+ match kernel::pick_edges(&b.body, &picks) {+ Ok(edges) => hits.push((b, edges)),+ Err(e) => refused = refused.or(Some(e)),+ }+ }+ if hits.is_empty() {+ return Err(match (named, refused) {+ (Some(_), Some(e)) => e.into(),+ _ => bad(cmd, "no visible body has an edge matching `edges`"),+ });+ }+ if hits.len() > 1 {+ return Err(bad(cmd, "`edges` matches edges of more than one body: name the `body` to analyse"));+ }+ targets.extend(hits);+ }+ let mut seams: Vec<ContinuitySeam> = Vec::new();+ let mut bodies = Vec::new();+ let mut summary = Summary::default();+ for (body, edges) in &targets {+ let report = kernel::seam_diagnostics(&body.body, edges, samples, tolerances)?;+ let mut rows = Vec::new();+ for seam in &report.seams {+ summary.count(seam.verdict);+ seams.push(ContinuitySeam { points: seam.points.clone(), verdict: seam.verdict });+ rows.push(json!({+ "edge": seam.edge,+ "length_mm": seam.length,+ "samples": seam.samples,+ "gap_mm": seam.gap_mm,+ "normal_angle_deg": seam.normal_angle_deg,+ "curvature_jump_per_mm": seam.curvature_jump_per_mm,+ "verdict": seam.verdict,+ }));+ }+ summary.skipped += report.skipped;+ summary.unmeasured += report.unmeasured;+ bodies.push(json!({+ "body": body.name,+ "edges": rows,+ "skipped": report.skipped,+ "unmeasured": report.unmeasured,+ }));+ }+ s.continuity = seams;+ s.revision += 1;+ Ok(json!({+ "analysis": "continuity",+ "samples": samples,+ "tolerances": {+ "gap_mm": tolerances.gap_mm,+ "angle_deg": tolerances.angle_deg,+ "curvature_per_mm": tolerances.curvature_per_mm,+ },+ "bodies": bodies,+ "summary": {+ "edges": summary.edges,+ "smooth": summary.smooth,+ "curvature_jump": summary.curvature_jump,+ "sharp": summary.sharp,+ "gap": summary.gap,+ "skipped": summary.skipped,+ "unmeasured": summary.unmeasured,+ "worst": summary.worst(),+ },+ }))+}++/// A tolerance parameter. A value that is given but unusable (NaN, infinity, negative, a+/// string, a bare `null`) is refused: `num` would fold it into "not given".+fn tolerance(p: &Value, key: &str, default: f64) -> Result<f64> {+ match p.get(key) {+ None => Ok(default),+ Some(v) => match v.as_f64() {+ Some(x) if x.is_finite() && (0.0..1e9).contains(&x) => Ok(x),+ _ => Err(bad("inspect.continuity", format!("`{key}` must be a finite number, 0 or more"))),+ },+ }+}++/// The `edges` parameter: points on the edges to measure, or `{"index": i}` entries in the+/// display mesh's edge order. Absent (or an empty list) means every edge of the body.+fn edge_picks(p: &Value) -> Result<Vec<kernel::EdgePick>> {+ let Some(value) = p.get("edges") else { return Ok(Vec::new()) };+ let Some(list) = value.as_array() else {+ return Err(bad("inspect.continuity", "`edges` must be a list of [x,y,z] points or {\"index\": i} entries"));+ };+ if list.len() > MAX_PICKS {+ return Err(bad("inspect.continuity", format!("pick at most {MAX_PICKS} edges")));+ }+ let mut out = Vec::new();+ for item in list {+ if let Some(index) = item.get("index").and_then(Value::as_u64) {+ let index = usize::try_from(index).map_err(|_| bad("inspect.continuity", "`index` is too large"))?;+ out.push(kernel::EdgePick::Index(index));+ } else if let Some(point) = vec3(item) {+ out.push(kernel::EdgePick::Point(point));+ } else {+ return Err(bad("inspect.continuity", "each `edges` entry is a point [x,y,z] or {\"index\": i}"));+ }+ }+ Ok(out)+}++/// Counts of a continuity reply, and the worst verdict over every edge measured.+#[derive(Clone, Copy, Debug, Default)]+struct Summary {+ edges: usize,+ smooth: usize,+ curvature_jump: usize,+ sharp: usize,+ gap: usize,+ skipped: usize,+ unmeasured: usize,+}++impl Summary {+ fn count(&mut self, verdict: kernel::SeamVerdict) {+ self.edges += 1;+ match verdict {+ kernel::SeamVerdict::Smooth => self.smooth += 1,+ kernel::SeamVerdict::CurvatureJump => self.curvature_jump += 1,+ kernel::SeamVerdict::Sharp => self.sharp += 1,+ kernel::SeamVerdict::Gap => self.gap += 1,+ }+ }++ /// The worst verdict over the edges measured (`None` when there was nothing to measure).+ /// [`kernel::SeamVerdict`] runs from the best continuity to the worst.+ fn worst(&self) -> Option<kernel::SeamVerdict> {+ [+ (self.smooth, kernel::SeamVerdict::Smooth),+ (self.curvature_jump, kernel::SeamVerdict::CurvatureJump),+ (self.sharp, kernel::SeamVerdict::Sharp),+ (self.gap, kernel::SeamVerdict::Gap),+ ]+ .into_iter()+ .filter(|(count, _)| *count > 0)+ .map(|(_, verdict)| verdict)+ .max()+ }+}+#[cfg(test)]mod tests {- use serde_json::json;+ use serde_json::{Value, json};use crate::{Session, SurfaceAnalysis};+ fn boxed(s: &mut Session, size: f64) {+ s.execute("solid.box", &json!({"length": size, "width": size, "height": size})).unwrap();+ }++ /// The edges of the first body of a continuity reply.+ fn edges(v: &Value) -> &Vec<Value> {+ v["bodies"][0]["edges"].as_array().unwrap_or_else(|| panic!("no edges in {v}"))+ }++ /// The seams that read as tangent (within 0.01° of the neighbouring face).+ fn tangent(edges: &[Value]) -> Vec<&Value> {+ edges.iter().filter(|e| e["normal_angle_deg"]["value"].as_f64().unwrap_or(f64::NAN) < 0.01).collect()+ }+#[test]fn surface_analyses_are_view_state() {let mut s = Session::default();@@ -121,4 +337,126 @@ mod tests {assert!(s.execute("inspect.zebra", &json!({"stripes": 0})).is_err());assert!(s.execute("inspect.draft", &json!({"pull": [0, 0, 0]})).is_err());}++ /// A box edge: the faces meet exactly (G0) and square to each other (G1), so the analysis+ /// must read 0 gap and 90°, and must keep its seams as view state without an undo step.+ #[test]+ fn continuity_reports_a_box_edge_as_a_gap_free_right_angle() {+ let mut s = Session::default();+ boxed(&mut s, 20.0);+ let undo = s.undo.len();+ let v = s.execute("inspect.continuity", &json!({})).unwrap();+ assert_eq!(edges(&v).len(), 12);+ for e in edges(&v) {+ let gap = e["gap_mm"]["value"].as_f64().unwrap();+ let angle = e["normal_angle_deg"]["value"].as_f64().unwrap();+ let jump = e["curvature_jump_per_mm"]["value"].as_f64().unwrap();+ assert!(gap < 1e-6, "gap {gap} in {e}");+ assert!((angle - 90.0).abs() < 1e-9, "angle {angle} in {e}");+ assert!(jump < 1e-9, "curvature jump {jump} in {e}");+ assert_eq!(e["verdict"], json!("sharp"), "{e}");+ assert_eq!(e["samples"], json!(33), "{e}");+ assert!((e["length_mm"].as_f64().unwrap() - 20.0).abs() < 1e-9, "{e}");+ assert_eq!(e["normal_angle_deg"]["at"].as_array().map(Vec::len), Some(3), "{e}");+ let f = e["normal_angle_deg"]["edge_fraction"].as_f64().unwrap();+ assert!((0.0..=1.0).contains(&f), "{e}");+ }+ assert_eq!(v["analysis"], json!("continuity"));+ assert_eq!(v["samples"], json!(33));+ assert_eq!(v["tolerances"], json!({"gap_mm": 1e-3, "angle_deg": 1.0, "curvature_per_mm": 0.01}));+ assert_eq!(v["summary"]["edges"], json!(12));+ assert_eq!(v["summary"]["sharp"], json!(12));+ assert_eq!(v["summary"]["worst"], json!("sharp"));+ assert_eq!(s.continuity.len(), 12, "the seams are kept for the viewport");+ assert_eq!(s.undo.len(), undo, "no undo step");+ assert_eq!(s.analysis, None, "the other analyses are left alone");+ }++ /// A rolling-ball fillet is tangent to the faces it joins but not curvature continuous: its+ /// two seams read ~0° with the fillet's 1 / radius curvature jump against the planes.+ #[test]+ fn continuity_finds_the_fillet_seams_tangent_and_their_curvature_jump() {+ let mut s = Session::default();+ boxed(&mut s, 20.0);+ s.execute("solid.fillet", &json!({"edges": [[20, 20, 10]], "radius": 4})).unwrap();+ let v = s.execute("inspect.continuity", &json!({})).unwrap();+ assert_eq!(edges(&v).len(), 15, "the rounded edge leaves three new edges behind: {v}");+ let seams = tangent(edges(&v));+ assert_eq!(seams.len(), 2, "the fillet meets its two neighbours tangentially: {v}");+ for e in seams {+ assert!(e["gap_mm"]["value"].as_f64().unwrap() < 1e-6, "{e}");+ let jump = e["curvature_jump_per_mm"]["value"].as_f64().unwrap();+ assert!((jump - 0.25).abs() < 1e-6, "1 / radius 4: {e}");+ assert_eq!(e["verdict"], json!("curvature_jump"), "{e}");+ }+ assert_eq!(v["summary"]["curvature_jump"], json!(2));+ assert_eq!(v["summary"]["sharp"], json!(13));+ assert_eq!(v["summary"]["smooth"], json!(0));+ }++ /// A slot's straight wall runs tangentially into its arc wall: the join is G1 but its+ /// curvature jumps by the arc's 1 / radius, which is exactly what a Class-A check looks for.+ #[test]+ fn continuity_reports_one_over_the_radius_where_a_line_meets_an_arc() {+ let mut s = Session::default();+ s.execute("sketch.create", &json!({"plane": "XY"})).unwrap();+ s.execute("sketch.slot.center_point", &json!({"center": [0, 0], "end": [20, 0], "width": 10})).unwrap();+ s.execute("solid.extrude", &json!({"distance": 5})).unwrap();+ let v = s.execute("inspect.continuity", &json!({"angle_tolerance_deg": 0.01})).unwrap();+ let seams = tangent(edges(&v));+ assert_eq!(seams.len(), 4, "a slot has four line-to-arc joins: {v}");+ for e in seams {+ assert!(e["gap_mm"]["value"].as_f64().unwrap() < 1e-6, "{e}");+ let jump = e["curvature_jump_per_mm"]["value"].as_f64().unwrap();+ assert!((jump - 0.2).abs() < 1e-6, "1 / radius 5: {e}");+ assert_eq!(e["verdict"], json!("curvature_jump"), "{e}");+ }+ assert_eq!(v["summary"]["curvature_jump"], json!(4));+ }++ /// `clear` takes the shading away, and every continuity call stays view state.+ #[test]+ fn continuity_is_view_state_and_clears() {+ let mut s = Session::default();+ boxed(&mut s, 10.0);+ let undo = s.undo.len();+ s.execute("inspect.continuity", &json!({"samples": 5})).unwrap();+ assert_eq!(s.continuity.len(), 12);+ assert_eq!(s.undo.len(), undo, "no undo step");+ let cleared = s.execute("inspect.continuity", &json!({"clear": true})).unwrap();+ assert_eq!(cleared["cleared"], json!(true));+ assert!(s.continuity.is_empty(), "clear leaves nothing shaded");+ assert_eq!(s.undo.len(), undo);+ }++ /// Hostile parameters are refused with an error, never a panic.+ #[test]+ fn hostile_continuity_params_are_refused() {+ let mut s = Session::default();+ boxed(&mut s, 10.0);+ for params in [+ json!({"samples": 0}),+ json!({"samples": 2}),+ json!({"samples": 258}),+ json!({"samples": 3.5}),+ json!({"samples": "33"}),+ json!({"samples": null}),+ json!({"gap_tolerance_mm": -1}),+ json!({"gap_tolerance_mm": 1e12}),+ json!({"angle_tolerance_deg": f64::NAN}),+ json!({"curvature_tolerance_per_mm": "tight"}),+ json!({"edges": 3}),+ json!({"edges": [[1, 2]]}),+ json!({"edges": [[]]}),+ json!({"edges": [{"index": 99999}]}),+ json!({"edges": [[500, 500, 500]]}),+ json!({"body": "Nope"}),+ ] {+ assert!(s.execute("inspect.continuity", ¶ms).is_err(), "accepted {params}");+ }+ let many: Vec<Value> = (0..513).map(|i| json!([i as f64, 0.0, 0.0])).collect();+ assert!(s.execute("inspect.continuity", &json!({"edges": many})).is_err(), "513 picks");+ assert!(s.continuity.is_empty(), "a refused call shades nothing");+ assert_eq!(s.undo.len(), 1, "only the box is an undo step");+ }}diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex d714352cb3..b5c2da8db9 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -239,6 +239,9 @@ pub struct Session {pub section: Option<(Vec3, Vec3)>,/// Surface analysis shading the model (zebra, draft, curvature map).pub analysis: Option<SurfaceAnalysis>,+ /// The seams `inspect.continuity` last measured, for the viewport to shade. View state: not+ /// part of the design and not an undo step.+ pub continuity: Vec<ContinuitySeam>,/// What is hidden or shown in the view (`browser.visibility`): saved with the design, not an/// undo step. A design brings its saved visibility when it opens (`Session::new`).pub visibility: Visibility,@@ -301,6 +304,16 @@ pub enum SurfaceAnalysis {Access { dir: Vec3 },}+/// One seam measured by `inspect.continuity`, where the viewport shades it: the stations it was+/// sampled at, in world coordinates, and how it reads. View state only: the design is untouched.+#[derive(Clone, Debug, PartialEq, serde::Serialize)]+pub struct ContinuitySeam {+ /// Sample points along the seam, in world coordinates.+ pub points: Vec<Vec3>,+ /// The seam's worst verdict along its length.+ pub verdict: kernel::SeamVerdict,+}+impl SurfaceAnalysis {/// How a picture shades the faces for this analysis.pub fn mode(self) -> render::AnalysisMode {@@ -356,6 +369,7 @@ impl Session {sketch_clipboard: None,section: None,analysis: None,+ continuity: Vec::new(),checkpoints: Vec::new(),next_checkpoint: 1,saved_visibility: visibility.clone(),@@ -823,6 +837,7 @@ impl Session {sketch_clipboard: self.sketch_clipboard.clone(),section: None,analysis: None,+ continuity: Vec::new(),checkpoints: Vec::new(),next_checkpoint: 1,visibility: self.visibility.clone(),diff --git a/crates/geom/src/blend.rs b/crates/geom/src/blend.rsnew file mode 100644index 0000000000..6466ff9875--- /dev/null+++ b/crates/geom/src/blend.rs@@ -0,0 +1,53 @@+//! Blend curves: one Bézier that joins two curves with a requested continuity order, by Hermite+//! interpolation of each reference curve's position and derivatives at the joints. This is the+//! geometry `sketch.blend_curve` builds; it knows nothing about sketches or the document.++use crate::{MAX_DERIVATIVE_ORDER, Vec2, profile::binom};++/// Control points of the Bézier of degree `2k + 1`, `k = d0.len()`, that starts at `p0` with+/// derivatives `d0` and ends at `p1` with derivatives `d1`, all with respect to its own parameter+/// on [0, 1]. The derivative vectors are the reference curves' at the joints, measured in their+/// own parameters and oriented the way the blend runs through the joint, so the blend agrees with+/// each reference through its k-th derivative (G1, G2, G3, G4 for k = 1…4).+///+/// The two ends fix exactly half of the controls each: a Bézier's j-th forward difference is+/// `P⁽ʲ⁾(0)·(n − j)!/n!`, so the first `k + 1` controls follow from the start data and the last+/// `k + 1` from the end data, which meet exactly at the middle control. `None` when the ends+/// disagree on the order, the order is above [`MAX_DERIVATIVE_ORDER`], or a value is not finite.+pub fn hermite_bezier(p0: Vec2, p1: Vec2, d0: &[Vec2], d1: &[Vec2]) -> Option<Vec<Vec2>> {+ let k = d0.len();+ if k != d1.len() || k > MAX_DERIVATIVE_ORDER || !p0.is_finite() || !p1.is_finite() || d0.iter().chain(d1).any(|d| !d.is_finite()) {+ return None;+ }+ let n = 2 * k + 1;+ let mut c = vec![Vec2::ZERO; n + 1];+ c[0] = p0;+ for j in 1..=k {+ // `Δʲp₀ = P⁽ʲ⁾(0)·(n − j)!/n!`, and solving it for `pⱼ` puts `(−1)^(j − i + 1)` on every+ // control already known.+ let scale = 1.0 / (0..j).fold(1.0, |acc, i| acc * (n - i) as f64);+ let mut value = d0[j - 1] * scale;+ for (i, p) in c.iter().take(j).enumerate() {+ value += *p * (odd_sign(j - i) * binom(j, i));+ }+ c[j] = value;+ }+ c[n] = p1;+ for j in 1..=k {+ // The same at the far end, reading the controls backwards: `Σᵢ(−1)ⁱ·C(j,i)·pₙ₋ᵢ` is+ // `P⁽ʲ⁾(1)·(n − j)!/n!`, and solving that for `pₙ₋ⱼ` puts `(−1)^(j + i + 1)` on every control+ // already known.+ let scale = 1.0 / (0..j).fold(1.0, |acc, i| acc * (n - i) as f64);+ let mut value = d1[j - 1] * (scale * odd_sign(j + 1));+ for (i, p) in c[n - j + 1..].iter().rev().enumerate() {+ value += *p * (odd_sign(j + i) * binom(j, i));+ }+ c[n - j] = value;+ }+ c.iter().all(|p| p.is_finite()).then_some(c)+}++/// `(−1)^(m + 1)`: the sign an m-th difference expansion carries in a Bézier's endpoint identity.+fn odd_sign(m: usize) -> f64 {+ if m % 2 == 1 { 1.0 } else { -1.0 }+}diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rsindex 850f471f1f..347d150d01 100644--- a/crates/geom/src/lib.rs+++ b/crates/geom/src/lib.rs@@ -9,6 +9,7 @@#![forbid(unsafe_code)]mod arcfit;+pub mod blend;pub mod brep;pub mod bspline;pub mod compare;@@ -23,9 +24,10 @@ pub mod tspline;mod vec;pub use arcfit::MAX_FIT_PIECES;+pub use blend::hermite_bezier;pub use mesh::{Aabb3, BoxedTriangle, InsideIndex, MassProperties, Mesh, MeshMeasure, find_close_pair};pub use plane::Plane;-pub use profile::{Loop2, MAX_BEZIER_DEGREE, Region2, Seg2, bezier, regions_apart};+pub use profile::{Loop2, MAX_BEZIER_CTRL, MAX_BEZIER_DEGREE, MAX_DERIVATIVE_ORDER, Region2, Seg2, bezier, regions_apart};pub use vec::{Vec2, Vec3};/// Geometric tolerance for coincidence tests (mm).diff --git a/crates/geom/src/profile.rs b/crates/geom/src/profile.rsindex 4ff2266696..e1117898c5 100644--- a/crates/geom/src/profile.rs+++ b/crates/geom/src/profile.rs@@ -38,26 +38,35 @@ pub enum Seg2 {b: Vec2,w: f64,},- /// Bézier of degree `n` (4…7) over `p[0..=n]` (the rest unused): pieces of higher-degree- /// splines.+ /// Bézier of degree `n` (4…[`MAX_BEZIER_DEGREE`]) over `p[0..=n]` (the rest unused): pieces of+ /// higher-degree splines.Bezier {n: u8,- p: [Vec2; 8],+ p: [Vec2; MAX_BEZIER_CTRL],},}-/// Highest degree of [`Seg2::Bezier`].-pub const MAX_BEZIER_DEGREE: usize = 7;+/// Highest degree of [`Seg2::Bezier`]: a degree-9 piece is the single Bézier a G4 blend curve+/// (`sketch.blend_curve` with `continuity: "g4"`) is made of.+pub const MAX_BEZIER_DEGREE: usize = 9;-/// A Bézier segment over `pts` (2…8 points): a line, a cubic or a higher-degree piece. A-/// quadratic becomes a conic of weight 1.+/// Control points a [`Seg2::Bezier`] carries: its highest degree plus one (the unused tail is+/// zero).+pub const MAX_BEZIER_CTRL: usize = MAX_BEZIER_DEGREE + 1;++/// Highest derivative order [`Seg2::derivatives`] hands out, and therefore the highest+/// continuity order a blend curve can be built for (4 = G4).+pub const MAX_DERIVATIVE_ORDER: usize = 4;++/// A Bézier segment over `pts` (2…[`MAX_BEZIER_CTRL`] points): a line, a cubic or a higher-degree+/// piece. A quadratic becomes a conic of weight 1.pub fn bezier(pts: &[Vec2]) -> Option<Seg2> {Some(match *pts {[a, b] => Seg2::Line { a, b },[a, apex, b] => Seg2::Conic { a, apex, b, w: 1.0 },[p0, p1, p2, p3] => Seg2::Cubic { p0, p1, p2, p3 },- _ if pts.len() <= MAX_BEZIER_DEGREE + 1 => {- let mut p = [Vec2::ZERO; 8];+ _ if (2..=MAX_BEZIER_CTRL).contains(&pts.len()) => {+ let mut p = [Vec2::ZERO; MAX_BEZIER_CTRL];for (d, s) in p.iter_mut().zip(pts) {*d = *s;}@@ -86,6 +95,38 @@ fn casteljau(c: &[Vec2], t: f64) -> (Vec2, Vec<Vec2>, Vec<Vec2>) {(left.last().copied().unwrap_or(Vec2::ZERO), left, right)}+/// Binomial coefficient `C(n, k)` for the small orders the derivative rules need (0 when+/// `k > n`).+pub(crate) fn binom(n: usize, k: usize) -> f64 {+ if k > n {+ return 0.0;+ }+ (0..k.min(n - k)).fold(1.0, |v, i| v * (n - i) as f64 / (i + 1) as f64)+}++/// Derivatives 1…`order` of the Bézier over `c` (degree `c.len() - 1`) at `t`: the j-th forward+/// difference of the control polygon, scaled by `n!/(n − j)!` and evaluated by de Casteljau.+/// Exact in exact arithmetic, zero above the degree, `None` for non-finite input.+fn bezier_derivatives(c: &[Vec2], t: f64, order: usize) -> Option<Vec<Vec2>> {+ if !t.is_finite() || c.is_empty() || c.iter().any(|p| !p.is_finite()) {+ return None;+ }+ let n = c.len() - 1;+ let mut diffs = c.to_vec();+ let mut scale = 1.0;+ let mut out = Vec::with_capacity(order);+ for j in 1..=order {+ if diffs.len() < 2 {+ out.push(Vec2::ZERO);+ continue;+ }+ diffs = diffs.windows(2).map(|w| w[1] - w[0]).collect();+ scale *= (n + 1 - j) as f64;+ out.push(casteljau(&diffs, t).0 * scale);+ }+ Some(out)+}+/// Gauss–Legendre nodes and weights on [0, 1] (5 points).const GL5: [(f64, f64); 5] = [(0.046_910_077_030_668, 0.118_463_442_528_095),@@ -96,7 +137,7 @@ const GL5: [(f64, f64); 5] = [];impl Seg2 {- fn bez(n: u8, p: &[Vec2; 8]) -> &[Vec2] {+ fn bez(n: u8, p: &[Vec2; MAX_BEZIER_CTRL]) -> &[Vec2] {&p[..(n as usize).clamp(1, MAX_BEZIER_DEGREE) + 1]}/// Derivative with respect to the parameter at `t` (Béziers and conics; lines and arcs too).@@ -121,6 +162,86 @@ impl Seg2 {}}}+ /// Derivatives 1…`order` with respect to the segment's own parameter at `t`, exactly: a line+ /// and an arc from their analytic form (an arc's are the circular-motion recurrence, zero+ /// curvature terms included), a cubic and a higher-degree piece from the forward differences+ /// of their controls, a conic through the quotient rule of its rational form. A blend curve+ /// reads a reference curve's derivatives here to build a Hermite interpolation, so this is+ /// exact at both ends (`t` = 0 and 1) and `None` — never a wrong number — when `order` is+ /// above [`MAX_DERIVATIVE_ORDER`], `t` is not finite or a value is not finite, as with a+ /// degenerate rational piece.+ pub fn derivatives(&self, t: f64, order: usize) -> Option<Vec<Vec2>> {+ if !t.is_finite() || order > MAX_DERIVATIVE_ORDER {+ return None;+ }+ let mut d = match *self {+ Seg2::Line { a, b } => {+ if !a.is_finite() || !b.is_finite() {+ return None;+ }+ let mut d = vec![b - a];+ d.resize(MAX_DERIVATIVE_ORDER, Vec2::ZERO);+ d+ }+ Seg2::Arc { center, radius, start, sweep } => {+ if !center.is_finite() || !radius.is_finite() || !start.is_finite() || !sweep.is_finite() {+ return None;+ }+ // Differentiating the radial direction twice returns its negative, so the+ // directions of the successive derivatives are tangential, radial, tangential…+ // with alternating signs, each order picking up one more factor of the sweep.+ let mut v = Vec2::from_angle(start + sweep * t).perp();+ let mut d = Vec::with_capacity(MAX_DERIVATIVE_ORDER);+ for j in 1..=MAX_DERIVATIVE_ORDER {+ d.push(v * (radius * sweep.powi(j as i32)));+ v = v.perp();+ }+ d+ }+ Seg2::Cubic { p0, p1, p2, p3 } => bezier_derivatives(&[p0, p1, p2, p3], t, MAX_DERIVATIVE_ORDER)?,+ Seg2::Bezier { n, ref p } => bezier_derivatives(Self::bez(n, p), t, MAX_DERIVATIVE_ORDER)?,+ Seg2::Conic { a, apex, b, w } => {+ if !a.is_finite() || !apex.is_finite() || !b.is_finite() || !w.is_finite() {+ return None;+ }+ // The conic is `N(t) / d(t)` with `N` the quadratic through `a`, `w·apex`, `b` and+ // `d` its weight polynomial; both are evaluated here in the power basis (at the+ // ends `d` = 1, so a join is never singular). The quotient rule in its+ // derivative-of-a-product form gives the higher derivatives: the numerator of+ // `x⁽ʲ⁾` is `N⁽ʲ⁾` minus the terms that already use `d` and a lower `x`.+ let (n0, n1, n2) = (a, apex * (2.0 * w) - a * 2.0, a - apex * (2.0 * w) + b);+ let (e1, e2) = (2.0 * (w - 1.0), 2.0 * (1.0 - w));+ let quotient = |j: usize| match j {+ 0 => n0 + n1 * t + n2 * (t * t),+ 1 => n1 + n2 * (2.0 * t),+ 2 => n2 * 2.0,+ _ => Vec2::ZERO,+ };+ let weight = |j: usize| match j {+ 0 => 1.0 + e1 * t + e2 * (t * t),+ 1 => e1 + e2 * (2.0 * t),+ 2 => e2 * 2.0,+ _ => 0.0,+ };+ let den = weight(0);+ if !(den.abs() > 1e-300) {+ return None;+ }+ let mut x = vec![quotient(0) / den];+ for j in 1..=MAX_DERIVATIVE_ORDER {+ let mut v = quotient(j);+ for i in 1..=j {+ v -= x[j - i] * (weight(i) * binom(j, i));+ }+ x.push(v / den);+ }+ x.remove(0);+ x+ }+ };+ d.truncate(order);+ d.iter().all(|q| q.is_finite()).then_some(d)+ }pub fn start(&self) -> Vec2 {match *self {Seg2::Line { a, .. } | Seg2::Conic { a, .. } => a,diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rsindex 3e607f32b5..39010d8729 100644--- a/crates/geom/src/tests.rs+++ b/crates/geom/src/tests.rs@@ -560,3 +560,161 @@ mod close_pairs {assert!(budget < 10_000_000, "work was counted");}}++mod blend {+ use super::*;++ /// `j!` for the small orders the Hermite and quotient identities use.+ fn fact(j: usize) -> f64 {+ (1..=j).fold(1.0, |a, b| a * b as f64)+ }++ /// The derivatives 1…`order` a Bézier's control polygon carries at its end `at_end`: the j-th+ /// difference of the controls, scaled by `n!/(n − j)!`. This is the textbook endpoint identity+ /// of a Bézier, written here independently of the library's.+ fn control_derivatives(ctrl: &[Vec2], at_end: bool, order: usize) -> Vec<Vec2> {+ let c: Vec<Vec2> = if at_end { ctrl.iter().rev().copied().collect() } else { ctrl.to_vec() };+ let n = c.len() - 1;+ let (mut diffs, mut scale) = (c, 1.0);+ let mut out = Vec::new();+ for j in 1..=order {+ diffs = diffs.windows(2).map(|w| w[1] - w[0]).collect();+ scale *= (n + 1 - j) as f64;+ out.push(diffs.first().copied().unwrap_or_default() * scale);+ }+ // The reversed controls describe `P(1 − s)`, so reversing again to read the original+ // parameterisation negates the odd orders.+ if at_end {+ for (i, v) in out.iter_mut().enumerate() {+ if i % 2 == 0 {+ *v = -*v;+ }+ }+ }+ out+ }++ #[test]+ fn hermite_bezier_meets_the_derivative_data_at_both_ends() {+ let (p0, p1) = (Vec2::new(1.0, 2.0), Vec2::new(-3.0, 4.5));+ let d0 = [Vec2::new(2.0, 1.0), Vec2::new(-0.5, 3.0), Vec2::new(1.5, 1.0), Vec2::new(0.25, -2.0)];+ let d1 = [Vec2::new(-1.0, 0.5), Vec2::new(2.0, -1.5), Vec2::new(-0.75, 0.5), Vec2::new(3.0, 1.25)];+ for k in 0..=MAX_DERIVATIVE_ORDER {+ let cps = hermite_bezier(p0, p1, &d0[..k], &d1[..k]).unwrap();+ assert_eq!(cps.len(), 2 * k + 2, "degree 2k+1 has 2k+2 controls");+ assert_eq!(cps[0], p0);+ assert_eq!(*cps.last().unwrap(), p1);+ for (got, want) in control_derivatives(&cps, false, k).iter().zip(&d0[..k]) {+ assert!(got.dist(*want) < 1e-11, "k={k} at t=0: {got:?} vs {want:?}");+ }+ for (got, want) in control_derivatives(&cps, true, k).iter().zip(&d1[..k]) {+ assert!(got.dist(*want) < 1e-11, "k={k} at t=1: {got:?} vs {want:?}");+ }+ // The piece is exactly the single Bézier `bezier` hands back, and its ends are the two+ // joints.+ let seg = bezier(&cps).unwrap();+ assert!(seg.start().dist(p0) < 1e-12 && seg.end().dist(p1) < 1e-12);+ for (got, want) in seg.derivatives(0.0, k).unwrap().iter().zip(&d0[..k]) {+ assert!(got.dist(*want) < 1e-10, "k={k} at t=0: {got:?} vs {want:?}");+ }+ }+ }++ #[test]+ fn hermite_bezier_refuses_hostile_data() {+ let (p0, p1) = (Vec2::ZERO, Vec2::X);+ let d = [Vec2::Y, Vec2::X];+ assert!(hermite_bezier(p0, p1, &d, &d).is_some());+ assert!(hermite_bezier(p0, p1, &d, &d[..1]).is_none(), "the ends must agree on the order");+ assert!(hermite_bezier(p0, p1, &[Vec2::ZERO; 5], &[Vec2::ZERO; 5]).is_none(), "order above G4");+ assert!(hermite_bezier(Vec2::new(f64::NAN, 0.0), p1, &[], &[]).is_none());+ assert!(hermite_bezier(p0, p1, &[Vec2::new(f64::INFINITY, 0.0)], &[Vec2::Y]).is_none());+ assert!(hermite_bezier(p0, p1, &[], &[Vec2::Y]).is_none());+ }++ #[test]+ fn seg_derivatives_are_exact_for_lines_and_polynomial_pieces() {+ let line = Seg2::Line { a: Vec2::new(-1.0, 2.0), b: Vec2::new(3.0, 5.0) };+ let d = line.derivatives(0.0, MAX_DERIVATIVE_ORDER).unwrap();+ assert!(d[0].dist(Vec2::new(4.0, 3.0)) < 1e-12);+ assert_eq!(d[1].len() + d[2].len() + d[3].len(), 0.0, "a line has no curvature");+ let cubic = Seg2::Cubic { p0: Vec2::new(0.0, 0.0), p1: Vec2::new(3.0, 9.0), p2: Vec2::new(7.0, -4.0), p3: Vec2::new(11.0, 2.0) };+ let ctrl = [Vec2::new(0.0, 0.0), Vec2::new(3.0, 9.0), Vec2::new(7.0, -4.0), Vec2::new(11.0, 2.0)];+ for (t, at_end) in [(0.0, false), (1.0, true)] {+ for (got, want) in cubic.derivatives(t, MAX_DERIVATIVE_ORDER).unwrap().iter().zip(control_derivatives(&ctrl, at_end, 4)) {+ assert!(got.dist(want) < 1e-9, "t={t}: {got:?} vs {want:?}");+ }+ }+ for t in [0.0, 0.35, 1.0] {+ assert!(cubic.derivatives(t, 1).unwrap()[0].dist(cubic.derivative(t)) < 1e-9, "t={t}");+ }+ // A degree-9 piece (the G4 blend's own shape) at both ends.+ let pts: Vec<Vec2> = (0..10).map(|i| Vec2::new(i as f64 * 0.7, (i as f64 * 1.3).sin())).collect();+ let seg = bezier(&pts).unwrap();+ assert!(matches!(seg, Seg2::Bezier { n: 9, .. }));+ for (t, at_end) in [(0.0, false), (1.0, true)] {+ for (got, want) in seg.derivatives(t, MAX_DERIVATIVE_ORDER).unwrap().iter().zip(control_derivatives(&pts, at_end, 4)) {+ assert!(got.dist(want) < 1e-9, "t={t}: {got:?} vs {want:?}");+ }+ }+ }++ #[test]+ fn seg_derivatives_follow_the_circular_recurrence() {+ let arc = Seg2::Arc { center: Vec2::new(2.0, -1.0), radius: 5.0, start: 0.7, sweep: -1.9 };+ let Seg2::Arc { center, sweep, .. } = arc else { panic!("an arc") };+ for t in [0.0, 0.4, 1.0] {+ let d = arc.derivatives(t, MAX_DERIVATIVE_ORDER).unwrap();+ let p = arc.point_at(t);+ let sw2 = sweep * sweep;+ // On a circle every derivative follows from the second: P″ = −sw²(P − c), and the rest+ // differentiate that relation, so a line and an arc have zero curvature rates.+ assert!(d[1].dist((p - center) * -sw2) < 1e-9, "t={t}");+ assert!(d[2].dist(d[0] * -sw2) < 1e-9, "t={t}");+ assert!(d[3].dist(d[1] * -sw2) < 1e-9, "t={t}");+ assert!(d[0].dist(arc.derivative(t)) < 1e-9, "t={t}");+ }+ }++ #[test]+ fn seg_derivatives_of_a_conic_satisfy_the_quotient_identity() {+ let conic = Seg2::Conic { a: Vec2::new(-2.0, 0.0), apex: Vec2::new(0.0, 3.0), b: Vec2::new(4.0, 0.5), w: 0.7 };+ let Seg2::Conic { a, apex, b, w } = conic else { panic!("a conic") };+ // The rational quadratic's numerator and weight polynomials, straight from their Bernstein+ // form, and their power coefficients at `t` by differences (exact for a quadratic).+ let n_at = |x: f64| a * ((1.0 - x) * (1.0 - x)) + apex * (2.0 * w * x * (1.0 - x)) + b * (x * x);+ let d_at = |x: f64| (1.0 - x) * (1.0 - x) + 2.0 * w * x * (1.0 - x) + x * x;+ for t in [0.0, 0.25, 1.0] {+ let h = 1e-3;+ // Taylor coefficients at `t` (differences are exact for a quadratic): f, f′/1!, f″/2!.+ let coef_v = |f: &dyn Fn(f64) -> Vec2| [f(t), (f(t + h) - f(t - h)) / (2.0 * h), (f(t + h) - f(t) * 2.0 + f(t - h)) / (2.0 * h * h)];+ let coef_s = |f: &dyn Fn(f64) -> f64| [f(t), (f(t + h) - f(t - h)) / (2.0 * h), (f(t + h) - f(t) * 2.0 + f(t - h)) / (2.0 * h * h)];+ let n = coef_v(&n_at);+ let d = coef_s(&d_at);+ let got = conic.derivatives(t, MAX_DERIVATIVE_ORDER).unwrap();+ // Taylor coefficients of P: P(t) and P⁽ʲ⁾(t)/j!. Leibniz on N = P·D then reads+ // Σ xᵢ·dⱼ₋ᵢ = nⱼ at every order, which the quotient rule must reproduce.+ let x: Vec<Vec2> = std::iter::once(conic.point_at(t)).chain(got.iter().enumerate().map(|(i, v)| *v / fact(i + 1))).collect();+ for j in 0..=4usize {+ let lhs: Vec2 = (0..=j).fold(Vec2::ZERO, |acc, i| acc + x[i] * d.get(j - i).copied().unwrap_or(0.0));+ let rhs = n.get(j).copied().unwrap_or(Vec2::ZERO);+ assert!(lhs.dist(rhs) < 1e-8 * rhs.len().max(1.0), "t={t} j={j}: {lhs:?} vs {rhs:?}");+ }+ assert!(got[0].dist(conic.derivative(t)) < 1e-8, "t={t}");+ }+ }++ #[test]+ fn seg_derivatives_refuse_hostile_input_and_degenerate_pieces() {+ let c = Seg2::Cubic { p0: Vec2::ZERO, p1: Vec2::X, p2: Vec2::Y, p3: Vec2::X + Vec2::Y };+ assert!(c.derivatives(0.0, MAX_DERIVATIVE_ORDER + 1).is_none(), "no order above G4");+ assert!(c.derivatives(f64::NAN, 2).is_none());+ let nan = Seg2::Line { a: Vec2::new(f64::NAN, 0.0), b: Vec2::X };+ assert!(nan.derivatives(0.0, 1).is_none());+ // A conic whose weight vanishes is a straight chord drawn at zero speed: its derivatives+ // are finite, but the first is zero, which is what a blend refuses.+ let flat = Seg2::Conic { a: Vec2::ZERO, apex: Vec2::new(1.0, 1.0), b: Vec2::new(2.0, 0.0), w: 0.0 };+ let d = flat.derivatives(0.0, 1).unwrap();+ assert_eq!(d[0], Vec2::ZERO);+ }+}diff --git a/crates/io/src/dxf_out.rs b/crates/io/src/dxf_out.rsindex bba7f8476e..fff56ea64d 100644--- a/crates/io/src/dxf_out.rs+++ b/crates/io/src/dxf_out.rs@@ -667,7 +667,7 @@ mod tests {assert!(degree_2(&conic(2.0), Some(vec![1.0, 2.0, 1.0])));assert!(degree_2(&conic(1.0 - 1e-9), Some(vec![1.0, 1.0 - 1e-9, 1.0])));// A quintic piece: six control points and twelve knots.- let mut q = [Vec2::ZERO; 8];+ let mut q = [Vec2::ZERO; solidcraft_geom::MAX_BEZIER_CTRL];for (i, s) in q.iter_mut().enumerate() {*s = Vec2::new(i as f64, (i * i) as f64);}diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rsindex 334f01f249..b80108a073 100644--- a/crates/io/src/lib.rs+++ b/crates/io/src/lib.rs@@ -864,6 +864,7 @@ mod tests {body: None,style: Default::default(),fit: Default::default(),+ corner: Default::default(),},None,)@@ -948,6 +949,7 @@ mod tests {body: None,style: Default::default(),fit: Default::default(),+ corner: Default::default(),},None,)diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex 324250bab9..a4bd1aa107 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -1637,7 +1637,7 @@ fn lies_on(e: &mt::Edge, along: &[mt::Edge], tol: f64) -> bool {}/// [`smooth_chain`], walking on only over edges `keep` allows.-fn smooth_chain_within(solid: &Solid, edge: &mt::Edge, keep: &dyn Fn(&mt::Edge) -> bool) -> Option<Vec<mt::EdgeID>> {+pub(crate) fn smooth_chain_within(solid: &Solid, edge: &mt::Edge, keep: &dyn Fn(&mt::Edge) -> bool) -> Option<Vec<mt::EdgeID>> {use mt::{BoundedCurve, ParametricCurve};let all = Body::unique_edges(solid);// Along the edge as it runs from its front to its back (an edge may run against its curve).@@ -1859,7 +1859,7 @@ fn fillet_built(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {// trimmed by the face. Refused, the refusal above stands..or_else(|e| blend_with(body, edges, radius, Shape::Round, "fillet", true).and_then(|b| closed(body, b)).map_err(|_| e))// Blends meeting at corners on curved faces: all at once.- .or_else(|e| corners(body, edges, radius, Shape::Round, "fillet").and_then(|b| closed(body, b)).map_err(|e2| keep_size(e, e2)))+ .or_else(|e| corners(body, edges, radius, Shape::Round, "fillet", false).and_then(|b| closed(body, b)).map_err(|e2| keep_size(e, e2)))}/// The first refusal, unless only the second found the blend too large (a smaller one may fit).@@ -1872,8 +1872,9 @@ fn keep_size(e: KernelError, e2: KernelError) -> KernelError {}/// Blend the edges together, rebuilding the corners where they meet on faces of any surface-/// (see [`crate::curveblend::corner_blend`]).-fn corners(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Result<Body> {+/// (see [`crate::curveblend::corner_blend`]); with `g2`, the corners where three blends meet are+/// G2 patches ([`crate::corner_g2`]) instead of pieces of the ball's sphere.+fn corners(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, g2: bool) -> Result<Body> {let counts = record::counts(&[body]);let cur = crate::boolean_record::healed(body)?;let size = cur.size();@@ -1882,10 +1883,27 @@ fn corners(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Resif ids.len() != edges.len() {return Err(KernelError::Invalid("no edge near a selected point".into()));}- let (made, rec) = guard(what, || crate::curveblend::corner_blend(&solid, &ids, size, r, shape == Shape::Round))?;+ let (made, rec) = guard(what, || match g2 {+ // The corner blend as it always was, bit for bit.+ false => crate::curveblend::corner_blend(&solid, &ids, size, r, shape == Shape::Round),+ true => crate::curveblend::corner_blend_style(&solid, &ids, size, r, shape == Shape::Round, true),+ })?;Ok(record::after(record::rebuilt(made, &[&solid], &rec)?, &cur, &counts))}+/// [`fillet`] whose corners where three blended edges meet are G2 patches: the corner repeats each+/// blend's surface up to the second order (see [`crate::corner_g2`]) instead of the rolling ball's+/// sphere. The corner construction is the all-at-once corner blend, so a configuration it cannot+/// hold is refused rather than quietly given the ball's sphere; [`fillet`] (the default) is+/// unchanged.+pub fn fillet_g2_corners(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {+ body.require_brep("fillet")?;+ if !(radius.is_finite() && radius > 0.0) {+ return Err(KernelError::Invalid("the blend radius must be finite and positive".into()));+ }+ corners(body, edges, radius, Shape::Round, "fillet", true).and_then(|b| closed(body, b))+}+/// The step of the radius search: three significant digits of the requested radius.fn radius_step(radius: f64) -> f64 {10f64.powf(radius.log10().floor() - 3.0)@@ -2191,7 +2209,7 @@ fn chamfer_built(body: &Body, edges: &[Vec3], distance: f64) -> Result<Body> {Ok(cur)};// Chamfers meeting at corners on curved faces: all at once.- one_by_one().or_else(|e| corners(body, edges, distance, Shape::Flat, "chamfer").map_err(|e2| keep_size(e, e2)))+ one_by_one().or_else(|e| corners(body, edges, distance, Shape::Flat, "chamfer", false).map_err(|e2| keep_size(e, e2)))}/// `cur` cut by one cutter, with its history over `[cur]` (`None`: nothing left).diff --git a/crates/kernel/src/blend_variable.rs b/crates/kernel/src/blend_variable.rsindex e0d7a495e0..8aafc19da5 100644--- a/crates/kernel/src/blend_variable.rs+++ b/crates/kernel/src/blend_variable.rs@@ -205,19 +205,35 @@ pub fn fillet_variable_points(body: &Body, edge_at: Vec3, start: Vec3, points: &}/// Fillet one straight edge with the radius `spline` along it, its positions from the end-/// nearest `start`. One end's radius may be zero.+/// nearest `start`. One end's radius may be zero. A curved edge, or one between curved faces, is+/// rolled by a ball of the law's radius instead ([`curved_variable`]).pub fn fillet_variable_spline(body: &Body, edge_at: Vec3, start: Vec3, spline: &RadiusSpline) -> Result<Body> {body.require_brep("fillet")?;spline.check()?;let edge = crate::surfaces::edge_near(body, edge_at).ok_or_else(|| KernelError::Invalid(format!("no edge at {edge_at:?}")))?;guard("variable fillet", || {- let s = EdgeSetup::new(body, &edge)?;+ let Ok(s) = EdgeSetup::new(body, &edge) else {+ return curved_variable(body, &edge, start, spline);+ };// Positions from the end nearest `start` (the edge keeps its own direction).let law = if s.p1.dist(start) < s.p0.dist(start) { spline.reversed() } else { spline.clone() };build(body, &s, &edge, &law)})}+/// The radius law along a curved edge: a ball whose radius is the law's at each station rolls+/// along the edge's smooth chain (the same sections, contacts and trims as the straight-edge case,+/// sized by the law there). A law that has run to zero at an end closes the blend to the edge's+/// end point, as the straight-edge fillet does.+fn curved_variable(body: &Body, edge: &mt::Edge, start: Vec3, law: &RadiusSpline) -> Result<Body> {+ // Positions from the end nearest `start` (the chain runs along the edge's own direction).+ let (p0, p1) = (vtx(edge.absolute_front()), vtx(edge.absolute_back()));+ let law = if p1.dist(start) < p0.dist(start) { law.reversed() } else { law.clone() };+ let chain = crate::blend::smooth_chain(&body.solid, edge).unwrap_or_else(|| vec![edge.id()]);+ let (made, rec) = guard("variable fillet", || crate::curveblend::curve_blend_law(&body.solid, &chain, body.size(), &law, true))?;+ crate::record::rebuilt(made, &[&body.solid], &rec)+}+/// A straight edge between two planar faces as the variable blend sees it: the shell it is in/// and that shell's faces, the frame at the edge, and its ends (front first).struct EdgeSetup<'a> {@@ -570,8 +586,11 @@ pub fn fillet_tapered(body: &Body, edges: &[Vec3], radius: f64) -> Result<(Body,Ok((cur, tapers))}-/// Chord-length fillet: each edge (straight, between planar faces) rounded so that the blend-/// is `chord` wide across; edges with the same face angle share a radius.+/// Chord-length fillet: each edge rounded so that the blend is `chord` wide across, from contact+/// to contact at every station. A straight edge between planar faces is built exactly, the radius+/// `chord / (2 cos(φ/2))` from its face angle and edges sharing that angle blended together; a+/// curved edge, or one between curved faces (or a chain of selected edges running on into one),+/// is rolled by a ball whose radius gives the same width, which follows the face angle along it.pub fn fillet_chord(body: &Body, edges: &[Vec3], chord: f64) -> Result<Body> {body.require_brep("fillet")?;if !(chord.is_finite() && chord > 1e-6 && chord < 1e6) {@@ -580,19 +599,44 @@ pub fn fillet_chord(body: &Body, edges: &[Vec3], chord: f64) -> Result<Body> {if edges.is_empty() || edges.len() > 1000 {return Err(KernelError::Invalid("select 1…1000 edges".into()));}- // Radius per edge from its face angle.- let mut groups: Vec<(f64, Vec<Vec3>)> = Vec::new();- for p in edges {- let e = crate::surfaces::edge_near(body, *p).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?;- let shell =- body.solid.boundaries().iter().find(|sh| sh.edge_iter().any(|x| x.id() == e.id())).ok_or_else(|| KernelError::Failed("edge".into()))?;+ let found: Vec<mt::Edge> = edges+ .iter()+ .map(|p| crate::surfaces::edge_near(body, *p).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}"))))+ .collect::<Result<_>>()?;+ // The exact radius of a straight edge between planar faces; None where the rolling ball has to+ // take the edge (a curved edge, or one between curved faces).+ let exact_radius = |e: &mt::Edge| -> Option<f64> {+ if !matches!(e.curve(), mt::Curve::Line(_)) {+ return None;+ }+ let shell = body.solid.boundaries().iter().find(|sh| sh.edge_iter().any(|x| x.id() == e.id()))?;let faces: Vec<&mt::Face> = shell.face_iter().collect();- let fr = edge_frame(&faces, &e)?;- let r = chord_radius(chord, fr.phi);- match groups.iter_mut().find(|(gr, _)| (gr - r).abs() <= 1e-9 * r) {- Some((_, v)) => v.push(*p),- None => groups.push((r, vec![*p])),+ Some(chord_radius(chord, edge_frame(&faces, e).ok()?.phi))+ };+ // A straight edge running on smoothly into a selected curved one goes with it: the ball rolls+ // along the chain, so blending the parts apart would leave a step at their joint.+ let meets = |a: &mt::Edge, b: &mt::Edge| [a.front(), a.back()].into_iter().any(|v| v == b.front() || v == b.back());+ let mixed = |e: &mt::Edge| found.iter().any(|f| f.id() != e.id() && exact_radius(f).is_none() && meets(e, f));+ // Radius per edge from its face angle; the rest roll a ball along their chain.+ let mut groups: Vec<(f64, Vec<Vec3>)> = Vec::new();+ let mut rolled: Vec<Vec<Vec3>> = Vec::new();+ let mut done: Vec<mt::EdgeID> = Vec::new();+ for (p, e) in edges.iter().zip(&found) {+ if let Some(r) = exact_radius(e).filter(|_| !mixed(e)) {+ match groups.iter_mut().find(|(gr, _)| (gr - r).abs() <= 1e-9 * r) {+ Some((_, v)) => v.push(*p),+ None => groups.push((r, vec![*p])),+ }+ continue;}+ if done.contains(&e.id()) {+ continue;+ }+ // The whole smooth chain (as the constant-radius path rolls it): a ball cannot stop+ // where the edge runs on, so the chain's other edges are blended with it.+ let chain = crate::blend::smooth_chain(&body.solid, e).unwrap_or_else(|| vec![e.id()]);+ done.extend(chain.iter().copied());+ rolled.push(edges.iter().zip(&found).filter(|(_, f)| chain.contains(&f.id())).map(|(p, _)| *p).collect());}// Each step's result carries its history over `[body]`.let counts = crate::record::counts(&[body]);@@ -600,6 +644,17 @@ pub fn fillet_chord(body: &Body, edges: &[Vec3], chord: f64) -> Result<Body> {for (r, pts) in groups {cur = crate::record::after(crate::fillet(&cur, &pts, r)?, &cur, &counts);}+ for picks in rolled {+ // The chain as the current body has it: the blends before it rebuilt the faces it runs+ // through, and a rebuilt face carries its edges again.+ let edges: Vec<mt::Edge> = picks.iter().filter_map(|p| crate::surfaces::edge_near(&cur, *p)).collect();+ let Some(first) = edges.first() else { continue };+ let keep = |x: &mt::Edge| edges.iter().any(|e| e.id() == x.id());+ let chain = crate::blend::smooth_chain_within(&cur.solid, first, &keep).unwrap_or_else(|| vec![first.id()]);+ let (made, rec) = crate::guard("chord fillet", || crate::curveblend::curve_blend_chord(&cur.solid, &chain, cur.size(), chord, true))?;+ let step = crate::record::rebuilt(made, &[&cur.solid], &rec)?;+ cur = crate::record::after(step, &cur, &counts);+ }Ok(cur)}diff --git a/crates/kernel/src/continuity.rs b/crates/kernel/src/continuity.rsnew file mode 100644index 0000000000..001e328987--- /dev/null+++ b/crates/kernel/src/continuity.rs@@ -0,0 +1,497 @@+//! Continuity diagnostics across the seams between a body's faces: do the two faces that meet+//! at an edge share a curve (G0), a tangent plane (G1) and a curvature (G2)?+//!+//! The stations are taken on the edge itself — the curve both faces are supposed to share — so+//! the numbers describe the B-rep and not a tessellation: each station is projected onto each+//! face's own surface, and the two projections are compared. The gap is the distance between+//! them (G0); the normal angle is the angle between the faces' outward normals there (G1); the+//! curvature jump is the difference of their normal curvatures in the normal section square to+//! the edge, from the second fundamental form of each surface (G2). A rolling-ball fillet is+//! tangent to the faces it joins but is not curvature continuous: where it meets a plane its+//! seam reads 0° and 1 / radius, which no chord tolerance would reveal.+//!+//! [`crate::smooth_edges`] decides whether a join needs a *display* line; this module measures+//! the join, and backs the engine's `inspect.continuity`.++use serde::Serialize;+use solidcraft_geom::Vec3;+use truck_modeling as mt;++use crate::body::{Body, from_p3, p3};+use crate::{KernelError, Result};++/// Bodies with more edges than this are refused rather than sampled for minutes.+const MAX_EDGES: usize = 4096;+/// Most faces a body may have and still be analysed.+const MAX_FACES: usize = 50_000;+/// Stations one call may take over all its edges; edges past the budget are left out and+/// counted in [`ContinuityReport::skipped`].+const MAX_STATIONS: usize = 200_000;+/// Most edges one pick list may name (the full list always fits the station budget).+const MAX_PICKS: usize = 512;+/// Samples used to find the edge nearest a picked point (as in `surfaces::edge_near`).+const PICK_SAMPLES: usize = 32;++/// Least and most stations along one edge (`inspect.continuity`'s `samples`): three are the two+/// ends and the middle.+pub const MIN_SAMPLES: usize = 3;+pub const MAX_SAMPLES: usize = 257;++/// How an edge is picked: a point on (or near) it, or its index in the display mesh's edge+/// order ([`Body::edges`]), which is what a viewport pick carries.+#[derive(Clone, Copy, Debug, PartialEq)]+pub enum EdgePick {+ Point(Vec3),+ Index(usize),+}++/// What counts as continuous across a seam.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct ContinuityTolerances {+ /// Largest position gap that still counts as coincident (G0), mm.+ pub gap_mm: f64,+ /// Largest angle between the faces' normals that still counts as tangent (G1), degrees.+ pub angle_deg: f64,+ /// Largest curvature jump that still counts as curvature continuous (G2), 1/mm.+ pub curvature_per_mm: f64,+}++/// The worst value of one metric along an edge, with where it was found.+#[derive(Clone, Copy, Debug, Serialize)]+pub struct SeamWorst {+ pub value: f64,+ /// The station that gave the worst value, in the body's coordinates.+ pub at: Vec3,+ /// How far along the edge it is: 0 at the edge's start, 1 at its end.+ pub edge_fraction: f64,+}++/// Which test a seam fails, from the best continuity to the worst: [`SeamVerdict::Smooth`] is+/// within every tolerance (G2 or better), then a tangent seam whose curvature jumps (G1), then+/// a visible crease (G0 only), and finally faces that do not meet at all.+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)]+#[serde(rename_all = "snake_case")]+pub enum SeamVerdict {+ Smooth,+ CurvatureJump,+ Sharp,+ Gap,+}++/// One edge's diagnostics: the worst of each metric along it, and where.+#[derive(Clone, Debug, Serialize)]+pub struct SeamReport {+ /// Index in the display mesh's edge order ([`Body::edges`]).+ pub edge: usize,+ /// Length of the edge, mm.+ pub length: f64,+ /// Stations the values were taken at.+ pub samples: usize,+ pub gap_mm: SeamWorst,+ pub normal_angle_deg: SeamWorst,+ pub curvature_jump_per_mm: SeamWorst,+ /// What the tolerances make of the seam.+ pub verdict: SeamVerdict,+ /// The stations in order: what a viewport shades.+ pub points: Vec<Vec3>,+}++/// The seam diagnostics of one body.+#[derive(Clone, Debug, Serialize)]+pub struct ContinuityReport {+ pub seams: Vec<SeamReport>,+ /// Edges left out: not a seam between two faces (an open boundary, or a periodic face's own+ /// seam, which is one face meeting itself), or past the station budget.+ pub skipped: usize,+ /// Edges that could not be sampled at all: no station of theirs projected onto both faces.+ pub unmeasured: usize,+}++/// The edge indices `picks` mean, in display-mesh order and without repeats. A point pick takes+/// the edge nearest it (within the distance the kernel re-finds an edge from); an index pick+/// must be an existing index. An empty list means every two-sided seam of the body, and a pick+/// of an edge that is not a seam between two faces is refused, not guessed at.+pub fn pick_edges(body: &Body, picks: &[EdgePick]) -> Result<Vec<usize>> {+ body.require_brep("continuity")?;+ if picks.len() > MAX_PICKS {+ return Err(KernelError::Invalid(format!("pick at most {MAX_PICKS} edges")));+ }+ crate::guard("continuity picks", || {+ let (edges, adjacent) = topology(body)?;+ if picks.is_empty() {+ return Ok((0..edges.len()).filter(|i| two_sided(&adjacent, *i)).collect());+ }+ let reach = body.size() * 0.05 + 1e-6;+ let mut out: Vec<usize> = Vec::new();+ for pick in picks {+ let index = match *pick {+ EdgePick::Index(index) => index,+ EdgePick::Point(p) => nearest_edge(&edges, p, reach)?,+ };+ if !two_sided(&adjacent, index) {+ return Err(KernelError::Invalid(format!("edge {index} of this body is not a seam between two faces")));+ }+ if !out.contains(&index) {+ out.push(index);+ }+ }+ out.sort_unstable();+ Ok(out)+ })+}++/// Sample the two-sided seams `edges` of `body` (indices in display-mesh order; empty: every+/// one of them) at `samples` stations along each edge's own parameter, the ends included, with+/// the tolerances the seams are judged against.+pub fn seam_diagnostics(body: &Body, edges: &[usize], samples: usize, tolerances: ContinuityTolerances) -> Result<ContinuityReport> {+ body.require_brep("continuity")?;+ if !(MIN_SAMPLES..=MAX_SAMPLES).contains(&samples) {+ return Err(KernelError::Invalid(format!("`samples` must be {MIN_SAMPLES}…{MAX_SAMPLES}")));+ }+ for (name, value) in [("gap", tolerances.gap_mm), ("angle", tolerances.angle_deg), ("curvature", tolerances.curvature_per_mm)] {+ // A range test also throws out NaN (both comparisons are false).+ if !(0.0..1e9).contains(&value) {+ return Err(KernelError::Invalid(format!("the {name} tolerance must be a finite number, 0 or more")));+ }+ }+ crate::guard("continuity", || measure(body, edges, samples, tolerances))+}++/// The body's unique edges and the faces meeting at each of them, either under the caps.+fn topology(body: &Body) -> Result<(Vec<mt::Edge>, Vec<Vec<usize>>)> {+ if body.solid.face_iter().take(MAX_FACES + 1).count() > MAX_FACES {+ return Err(KernelError::TooLarge(format!("the body has more than {MAX_FACES} faces")));+ }+ let (edges, adjacent) = crate::body::edge_order(body.solid.face_iter());+ if edges.len() > MAX_EDGES {+ return Err(KernelError::TooLarge(format!("the body has more than {MAX_EDGES} edges")));+ }+ Ok((edges, adjacent))+}++/// Is the edge at `index` shared by (exactly) two faces of the body?+fn two_sided(adjacent: &[Vec<usize>], index: usize) -> bool {+ adjacent.get(index).is_some_and(|faces| faces.len() == 2)+}++/// The index of the edge whose curve comes nearest `p`, within `reach`.+fn nearest_edge(edges: &[mt::Edge], p: Vec3, reach: f64) -> Result<usize> {+ use mt::ParametricCurve;+ let mut best: Option<(f64, usize)> = None;+ for (index, edge) in edges.iter().enumerate() {+ let curve = edge.curve();+ let Some((t0, t1)) = curve.try_range_tuple() else { continue };+ if !(t0.is_finite() && t1.is_finite() && t1 > t0) {+ continue;+ }+ for k in 0..=PICK_SAMPLES {+ let q = from_p3(curve.subs(t0 + (t1 - t0) * k as f64 / PICK_SAMPLES as f64));+ let d = q.dist(p);+ if d.is_finite() && best.is_none_or(|(bd, _)| d < bd) {+ best = Some((d, index));+ }+ }+ }+ match best {+ Some((d, index)) if d <= reach => Ok(index),+ _ => Err(KernelError::Invalid(format!("no edge of the body is within {reach:.3} mm of ({}, {}, {})", p.x, p.y, p.z))),+ }+}++fn measure(body: &Body, edges: &[usize], samples: usize, tolerances: ContinuityTolerances) -> Result<ContinuityReport> {+ let (list, adjacent) = topology(body)?;+ let faces: Vec<&mt::Face> = body.solid.face_iter().collect();+ let mut selected: Vec<usize> = Vec::new();+ let mut skipped = 0usize;+ if edges.is_empty() {+ for index in 0..list.len() {+ if two_sided(&adjacent, index) {+ selected.push(index);+ } else {+ skipped += 1;+ }+ }+ } else {+ selected.extend(edges.iter().copied());+ selected.sort_unstable();+ selected.dedup();+ for &index in &selected {+ if index >= list.len() {+ return Err(KernelError::Invalid(format!("the body has no edge {index}")));+ }+ if !two_sided(&adjacent, index) {+ return Err(KernelError::Invalid(format!("edge {index} of this body is not a seam between two faces")));+ }+ }+ }+ let mut seams = Vec::new();+ let mut unmeasured = 0usize;+ let mut budget = MAX_STATIONS;+ for index in selected {+ let Some(face_pair) = adjacent.get(index).filter(|faces| faces.len() == 2) else { continue };+ let (Some(&first), Some(&second)) = (face_pair.first(), face_pair.get(1)) else { continue };+ let (Some(a), Some(b)) = (faces.get(first).copied(), faces.get(second).copied()) else { continue };+ let Some(edge) = list.get(index) else { continue };+ // Every edge costs `samples` stations; a run out of budget stops cleanly.+ if budget < samples {+ skipped += 1;+ continue;+ }+ budget -= samples;+ match seam(index, edge, a, b, samples, tolerances) {+ Some(report) => seams.push(report),+ None => unmeasured += 1,+ }+ }+ Ok(ContinuityReport { seams, skipped, unmeasured })+}++/// One edge's worst gap, normal angle and curvature jump.+fn seam(index: usize, edge: &mt::Edge, face_a: &mt::Face, face_b: &mt::Face, samples: usize, tolerances: ContinuityTolerances) -> Option<SeamReport> {+ use mt::ParametricCurve;+ let curve = edge.curve();+ let (t0, t1) = curve.try_range_tuple()?;+ // The station fractions: 0 at the edge's start, 1 at its end.+ let steps = samples.checked_sub(1)?;+ let fraction = |k: usize| k as f64 / steps as f64;+ let mut on_a = FaceSurface::new(face_a);+ let mut on_b = FaceSurface::new(face_b);+ let mut gap = None;+ let mut angle = None;+ let mut jump = None;+ let mut points = Vec::with_capacity(samples);+ for k in 0..samples {+ let f = fraction(k);+ let at = from_p3(curve.subs(t0 + (t1 - t0) * f));+ if !at.is_finite() {+ continue;+ }+ // Both projections and both curvatures, or the station says nothing.+ let (Some((qa, na, uv_a)), Some((qb, nb, uv_b))) = (on_a.project(at), on_b.project(at)) else { continue };+ let tangent = curve.der(t0 + (t1 - t0) * f);+ let Some(tangent) = Vec3::new(tangent.x, tangent.y, tangent.z).normalized() else { continue };+ // The normal sections square to the seam: one direction per face, in its tangent plane.+ let (Some(ka), Some(kb)) = (on_a.normal_curvature(uv_a, na, across(na, tangent)), on_b.normal_curvature(uv_b, nb, across(nb, tangent)))+ else {+ continue;+ };+ // The faces' outward normals agree on a smooth seam; where they are opposed (a knife+ // edge) the curvatures are compared in one frame, since bending away from one face is+ // bending towards the other.+ let signed = if na.dot(nb) < 0.0 { ka + kb } else { ka - kb };+ points.push(at);+ keep(&mut gap, qa.dist(qb), at, f);+ keep(&mut angle, na.dot(nb).clamp(-1.0, 1.0).acos().to_degrees(), at, f);+ keep(&mut jump, signed.abs(), at, f);+ }+ let (gap, angle, jump) = (gap?, angle?, jump?);+ let verdict = if gap.value > tolerances.gap_mm {+ SeamVerdict::Gap+ } else if angle.value > tolerances.angle_deg {+ SeamVerdict::Sharp+ } else if jump.value > tolerances.curvature_per_mm {+ SeamVerdict::CurvatureJump+ } else {+ SeamVerdict::Smooth+ };+ let length = points.windows(2).map(|w| w.first().zip(w.get(1)).map_or(0.0, |(a, b)| a.dist(*b))).sum();+ Some(SeamReport {+ edge: index,+ length,+ samples: points.len(),+ gap_mm: gap,+ normal_angle_deg: angle,+ curvature_jump_per_mm: jump,+ verdict,+ points,+ })+}++/// The direction in which a face's curvature is read at a seam: across the edge, square to it,+/// inside the face's tangent plane (a zero vector where the edge runs along the normal, which+/// leaves that station unmeasured).+fn across(normal: Vec3, tangent: Vec3) -> Vec3 {+ normal.cross(tangent)+}++/// Keep the largest value seen, with where it was found.+fn keep(worst: &mut Option<SeamWorst>, value: f64, at: Vec3, edge_fraction: f64) {+ if value.is_finite() && worst.is_none_or(|w| value > w.value) {+ *worst = Some(SeamWorst { value, at, edge_fraction });+ }+}++/// A face's surface, kept over the stations of one edge so each search can start at the last+/// answer (stations run along the edge, so the parameters move smoothly).+struct FaceSurface {+ surface: mt::Surface,+ hint: Option<(f64, f64)>,+}++impl FaceSurface {+ /// The face's own outward-facing surface (`oriented_surface`: a reversed face's surface is+ /// inverted, so its normal is the material's outward normal).+ fn new(face: &mt::Face) -> Self {+ Self { surface: face.oriented_surface(), hint: None }+ }++ /// The nearest point of the surface to `p`, the outward unit normal there and the+ /// parameters. `None` where the search or the normal is unusable.+ fn project(&mut self, p: Vec3) -> Option<(Vec3, Vec3, (f64, f64))> {+ use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};+ let uv = self.surface.search_nearest_parameter(p3(p), self.hint, 100).or_else(|| self.surface.search_nearest_parameter(p3(p), None, 100))?;+ if !(uv.0.is_finite() && uv.1.is_finite()) {+ return None;+ }+ let q = from_p3(self.surface.subs(uv.0, uv.1));+ let n = self.surface.normal(uv.0, uv.1);+ if !q.is_finite() {+ return None;+ }+ let normal = Vec3::new(n.x, n.y, n.z).normalized()?;+ self.hint = Some(uv);+ Some((q, normal, uv))+ }++ /// The normal curvature of the face at `uv` along `direction` (a unit vector of its tangent+ /// plane), from the second fundamental form. A surface point `r(u, v)` with unit normal `n`+ /// crossed that way has curvature `κ = n · r''` of the curve whose tangent there is+ /// `direction`: a plane reads 0 and a cylinder of radius `R`, across its axis, −1 / R+ /// (bending towards its axis). `None` at a degenerate parameter point (a cone's apex), where+ /// the surface has no curvature.+ fn normal_curvature(&self, uv: (f64, f64), normal: Vec3, direction: Vec3) -> Option<f64> {+ use mt::ParametricSurface;+ let ru = vec3(self.surface.uder(uv.0, uv.1));+ let rv = vec3(self.surface.vder(uv.0, uv.1));+ let (ru_len, rv_len) = (ru.len(), rv.len());+ if !(ru_len > 0.0 && rv_len > 0.0) {+ return None;+ }+ // Solve the direction in the unit basis (r_u / |r_u|, r_v / |r_v|): the curve then runs+ // its parameters at du/ds = α / |r_u| and dv/ds = β / |r_v|, and+ // `r'' = r_uu (du/ds)² + 2 r_uv (du/ds)(dv/ds) + r_vv (dv/ds)²`.+ let cos = (ru.dot(rv) / (ru_len * rv_len)).clamp(-1.0, 1.0);+ let sin2 = 1.0 - cos * cos;+ if !(sin2 > 1e-12) {+ return None;+ }+ let (cu, cv) = (direction.dot(ru) / ru_len, direction.dot(rv) / rv_len);+ let (du, dv) = ((cu - cv * cos) / sin2 / ru_len, (cv - cu * cos) / sin2 / rv_len);+ if !(du.is_finite() && dv.is_finite()) {+ return None;+ }+ // `direction` is a unit vector: divide by the speed the parameters imply (they only miss+ // it by rounding), so κ does not depend on how the surface is parameterized.+ let speed = (ru * du + rv * dv).len();+ if !(speed > 1e-6) {+ return None;+ }+ let second = normal.dot(+ vec3(self.surface.uuder(uv.0, uv.1)) * (du * du)+ + vec3(self.surface.uvder(uv.0, uv.1)) * (2.0 * du * dv)+ + vec3(self.surface.vvder(uv.0, uv.1)) * (dv * dv),+ );+ (second / (speed * speed)).is_finite().then_some(second / (speed * speed))+ }+}++/// A kernel point as a vector.+fn vec3(p: mt::Vector3) -> Vec3 {+ Vec3::new(p.x, p.y, p.z)+}++#[cfg(test)]+#[allow(clippy::unwrap_used)]+mod tests {+ use super::*;+ use solidcraft_geom::Plane;++ fn tolerances() -> ContinuityTolerances {+ ContinuityTolerances { gap_mm: 1e-3, angle_deg: 1.0, curvature_per_mm: 0.01 }+ }++ fn box_body() -> Body {+ crate::box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(10.0, 10.0, 10.0)).unwrap()+ }++ fn report(body: &Body) -> ContinuityReport {+ seam_diagnostics(body, &[], 33, tolerances()).unwrap()+ }++ #[test]+ fn a_box_edge_is_a_gap_free_right_angle() {+ let body = box_body();+ let r = report(&body);+ assert_eq!(r.seams.len(), 12, "a box has twelve edges");+ assert_eq!(r.skipped, 0);+ for seam in &r.seams {+ assert!(seam.gap_mm.value < 1e-6, "gap {}", seam.gap_mm.value);+ assert!((seam.normal_angle_deg.value - 90.0).abs() < 1e-9, "angle {}", seam.normal_angle_deg.value);+ assert!(seam.curvature_jump_per_mm.value < 1e-9, "jump {}", seam.curvature_jump_per_mm.value);+ assert_eq!(seam.verdict, SeamVerdict::Sharp);+ assert_eq!(seam.samples, 33);+ assert!((seam.length - 10.0).abs() < 1e-9);+ }+ }++ #[test]+ fn a_fillet_seam_is_tangent_with_the_fillets_curvature_jump() {+ let body = box_body();+ let rounded = crate::fillet(&body, &[Vec3::new(10.0, 10.0, 5.0)], 4.0).unwrap();+ let r = report(&rounded);+ // The rounded edge is replaced by the blend face: two tangent seams along it, the two+ // arcs where the blend meets the ends of the edge, and the box's other eleven edges.+ assert_eq!(r.seams.len(), 15);+ let tangent: Vec<&SeamReport> = r.seams.iter().filter(|s| s.normal_angle_deg.value < 0.01).collect();+ assert_eq!(tangent.len(), 2, "the fillet meets its two neighbours tangentially");+ for seam in &tangent {+ assert!(seam.gap_mm.value < 1e-6);+ assert!(seam.curvature_jump_per_mm.value.is_finite());+ assert!((seam.curvature_jump_per_mm.value - 0.25).abs() < 1e-6, "1 / radius, got {}", seam.curvature_jump_per_mm.value);+ assert_eq!(seam.verdict, SeamVerdict::CurvatureJump);+ }+ assert_eq!(r.seams.iter().filter(|s| s.verdict == SeamVerdict::Sharp).count(), 13);+ }++ #[test]+ fn a_line_tangent_into_an_arc_reports_one_over_its_radius() {+ use solidcraft_geom::{Loop2, Region2, Seg2, Vec2};+ let v = |x: f64, y: f64| Vec2::new(x, y);+ let outer = Loop2 {+ segs: vec![+ Seg2::Arc { center: v(10.0, 0.0), radius: 5.0, start: -std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },+ Seg2::Line { a: v(10.0, 5.0), b: v(-10.0, 5.0) },+ Seg2::Arc { center: v(-10.0, 0.0), radius: 5.0, start: std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },+ Seg2::Line { a: v(-10.0, -5.0), b: v(10.0, -5.0) },+ ],+ };+ let body = crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0.0, 3.0).unwrap().remove(0);+ let r = report(&body);+ let joins: Vec<&SeamReport> = r.seams.iter().filter(|s| s.normal_angle_deg.value < 0.01).collect();+ assert_eq!(joins.len(), 4, "a slot has four line-to-arc joins");+ for seam in joins {+ assert!(+ seam.curvature_jump_per_mm.value > 0.19 && seam.curvature_jump_per_mm.value < 0.21,+ "1 / 5, got {}",+ seam.curvature_jump_per_mm.value+ );+ }+ }++ #[test]+ fn picks_refuse_what_is_not_there() {+ let body = box_body();+ let all = pick_edges(&body, &[]).unwrap();+ assert_eq!(all.len(), 12);+ // The edge up the corner at (0, 0), beside a point in the middle of a face.+ let picked = pick_edges(&body, &[EdgePick::Point(Vec3::new(0.0, 0.0, 5.0)), EdgePick::Index(all[0])]).unwrap();+ assert_eq!(picked.len(), 2);+ assert!(pick_edges(&body, &[EdgePick::Index(999)]).is_err());+ assert!(pick_edges(&body, &[EdgePick::Point(Vec3::new(0.0, 5.0, 5.0))]).is_err(), "a point on a face is not on an edge");+ assert!(pick_edges(&body, &[EdgePick::Point(Vec3::new(500.0, 0.0, 0.0))]).is_err());+ assert!(seam_diagnostics(&body, &[], 2, tolerances()).is_err());+ assert!(seam_diagnostics(&body, &[], 258, tolerances()).is_err());+ assert!(seam_diagnostics(&body, &[], 33, ContinuityTolerances { gap_mm: f64::NAN, ..tolerances() }).is_err());+ assert!(seam_diagnostics(&body, &[999], 33, tolerances()).is_err());+ }+}diff --git a/crates/kernel/src/corner_g2.rs b/crates/kernel/src/corner_g2.rsnew file mode 100644index 0000000000..22e236df6a--- /dev/null+++ b/crates/kernel/src/corner_g2.rs@@ -0,0 +1,501 @@+//! G2 corner patches: the patch that fills a vertex where filleted edges meet, built to repeat each+//! blend's surface up to the second order instead of the rolling ball's sphere.+//!+//! [`crate::blend_corner`] and [`crate::curvecorner`] fill the corner of a vertex with a piece of+//! the ball that rolls along the three edges (a sphere for equal radii, a rational patch for+//! unequal ones). That patch is tangent to every blend along the sections where they stop, so the+//! corner is G1 — but across a seam the ball keeps its own 1/r where a fillet is flat along its+//! axis, so the two surfaces meet with a jump in curvature.+//!+//! Here the corner is one tensor patch whose boundary is the blends' section curves themselves and+//! whose cross-sections carry each blend's own derivatives: the position, the direction the patch+//! leaves the blend's surface in, and the blend's curvature vector along that direction are the+//! first three control points of every cross-section, one control point per continuity condition,+//! exactly as [`crate::bridge`]'s sections do. The other end of every cross-section gathers at+//! `apex` — a point inside the material the corner caps — where the sections arrive in a common+//! tangent plane with a common curvature, so the patch closes there smoothly like a sphere's pole.+//! Along a seam the patch therefore repeats the blend up to the second order (G2).+//!+//! The boundary is a closed loop (the three sections joined corner to corner), so the direction+//! along it is a *closed* cubic B-spline: an interpolating curve with free ends swings wide at the+//! corner where the loop joins and folds the patch there. Where two blends meet at that corner+//! their sections leave in directions 90° apart and ask for different curvature at that one point+//! (a fillet is flat across its own seam, the other is not), which no single surface can hold; the+//! corner is a still point of the construction and [`seam_error`] is measured clear of it. A patch+//! that folds, or a corner with no room, is refused rather than replaced by the G1 ball.++use solidcraft_geom::Vec3;+use solidcraft_geom::bspline::{HPoint, NurbsSurface};+use truck_modeling::{self as mt, builder};++use crate::blend::unsupported;+use crate::body::{from_p3, p3};+use crate::bridge::Frame;+use crate::{KernelError, Result, guard};++/// A corner's name in an error.+fn fail(m: impl std::fmt::Display) -> KernelError {+ KernelError::Failed(format!("G2 corner: {m}"))+}++/// One of the surface's own derivative vectors as ours.+fn vec_of(v: mt::Vector3) -> Vec3 {+ Vec3::new(v.x, v.y, v.z)+}++/// Conditions each end of a cross-section carries: position, tangent and curvature.+const END_CONDITIONS: usize = 3;+/// Degree across the patch: three conditions at each end, less the control point they share.+const ACROSS: usize = 2 * END_CONDITIONS - 1;+/// Degree along the seam loop.+const ALONG: usize = 3;+/// Fewest stations a section curve may be sampled at (a cubic through them).+const MIN_STATIONS: usize = 4;+/// Most stations one section curve may carry.+const MAX_STATIONS: usize = 512;+/// How much of a station's `leave` has to lie across its seam for the patch to have a direction to+/// leave the blend in at all.+const ACROSS_ENOUGH: f64 = 0.2;++/// The G2 corner patch over three blends' section curves: `sides[i]` is one blend's section curve,+/// sampled in order from one corner of the vertex to the next, each side's last station the next+/// side's first (the three close a loop). `apex` is a point inside the material the corner caps;+/// the patch gathers there. The face's boundary edges are the section curves themselves (one edge+/// per side, cut out of the patch's own boundary curve, so they lie on it exactly); the caller+/// re-wraps the wire where it needs its own orientation.+pub fn corner_g2_patch(sides: &[Vec<Frame>], apex: Vec3) -> Result<Vec<mt::Face>> {+ guard("G2 corner patch", || build(sides, apex))+}++/// The seam's own direction at station `i` of a side, from a four-point central difference through+/// the stations (`crate::bridge::frames` samples a chain evenly, and a corner's own callers do the+/// same): a two-point chord would only be second order in the step and would tilt the corner's+/// tangent plane by more than G2 is judged at. `None` within two stations of a side's end.+fn seam_tangent(side: &[Frame], i: usize) -> Option<Vec3> {+ let at = |j: isize| usize::try_from(j).ok().and_then(|j| side.get(j)).map(|f| f.p);+ let (a, b, c, d) = (at(i as isize - 2)?, at(i as isize - 1)?, at(i as isize + 1)?, at(i as isize + 2)?);+ (b * 8.0 - a - c * 8.0 + d).normalized()+}++/// The seam's direction at every station of the closed loop (the same difference, wrapping round+/// its ends), falling back to the chord to a neighbour where the four points are not there.+fn loop_tangents(frames: &[Frame]) -> Vec<Option<Vec3>> {+ let m = frames.len();+ if m == 0 {+ return Vec::new();+ }+ let at = |j: isize| frames.get(j.rem_euclid(m as isize) as usize).map(|f| f.p);+ (0..m)+ .map(|i| {+ let four = || {+ let (a, b, c, d) = (at(i as isize - 2)?, at(i as isize - 1)?, at(i as isize + 1)?, at(i as isize + 2)?);+ (b * 8.0 - a - c * 8.0 + d).normalized()+ };+ four().or_else(|| {+ let prev = at(i as isize - 1)?;+ let next = at(i as isize + 1)?;+ (next - prev).normalized()+ })+ })+ .collect()+}++/// The three section curves as one closed loop of stations, the loop index each side starts at,+/// and the corner's own size (twice the mean distance of a station from their centre).+fn corner_loop(sides: &[Vec<Frame>]) -> Result<(Vec<Frame>, Vec<usize>, f64)> {+ if sides.len() != 3 {+ return Err(unsupported("a G2 corner needs three blends meeting at one vertex (a corner of two, or one, still ends on the ball's patch)"));+ }+ let mut frames: Vec<Frame> = Vec::new();+ let mut starts: Vec<usize> = Vec::new();+ for side in sides {+ if side.len() < MIN_STATIONS || side.len() > MAX_STATIONS {+ return Err(KernelError::Invalid(format!("a corner section curve needs {MIN_STATIONS} to {MAX_STATIONS} sampled stations")));+ }+ for f in side {+ if ![f.p, f.leave, f.bend, f.bend_change].into_iter().all(Vec3::is_finite) || !(f.leave.len() > 0.5) {+ return Err(KernelError::Invalid("a corner station must carry finite data and a unit direction".into()));+ }+ }+ starts.push(frames.len());+ // A side runs from one corner to the next; its last station is the next side's first, so the+ // loop takes it once.+ frames.extend(side.iter().take(side.len() - 1).copied());+ }+ let centre = frames.iter().fold(Vec3::ZERO, |a, f| a + f.p) * (1.0 / frames.len().max(1) as f64);+ let size = frames.iter().map(|f| f.p.dist(centre)).fold(0.0, f64::max) * 2.0;+ if !(size > 0.0 && size.is_finite()) {+ return Err(unsupported("a corner whose section curves have no extent"));+ }+ for (i, side) in sides.iter().enumerate() {+ let Some(prev) = sides.get((i + sides.len() - 1) % sides.len()).and_then(|s| s.last()) else { continue };+ let Some(&here) = side.first() else { continue };+ if prev.p.dist(here.p) > size * 1e-3 {+ return Err(unsupported("the section curves do not meet at a corner"));+ }+ }+ Ok((frames, starts, size))+}++/// Every station's `leave` squared up with the seam it belongs to: the part of it across the seam,+/// which is the direction the cross-section has to leave the blend in. A `leave` along the seam+/// itself leaves the cross-section no room, and is refused.+fn transverse(frames: &[Frame], tangents: &[Option<Vec3>]) -> Result<Vec<Frame>> {+ let mut out = Vec::with_capacity(frames.len());+ for (f, t) in frames.iter().zip(tangents) {+ let across = match t {+ Some(t) => f.leave - *t * f.leave.dot(*t),+ // Stations that offer no direction along the seam: the leave stands as it came.+ None => f.leave,+ };+ if across.len() < ACROSS_ENOUGH * f.leave.len() {+ return Err(unsupported("a section curve meets the corner patch along its own tangent, so the patch has no direction to leave it in"));+ }+ let leave = across.normalized().ok_or_else(|| unsupported("a corner station has no direction across its seam"))?;+ out.push(Frame { leave, ..*f });+ }+ Ok(out)+}++/// One station's cross-section: `ACROSS + 1` control points of a Bézier from the seam point to+/// `apex`. The first three hold the blend: its position, the direction the patch leaves it in+/// (one control point along `leave`) and its curvature vector across the seam (one more). The last+/// three hold the apex: the point, a tangent in the apex's own plane, and the curvature of a dome+/// over the corner, so the sections arrive smoothly instead of leaving a point.+fn section(f: &Frame, apex: Vec3, n_apex: Vec3, kappa: f64) -> Result<[Vec3; ACROSS + 1]> {+ let k = ACROSS as f64;+ let chord = f.p.dist(apex);+ if !(chord.is_finite() && chord > 0.0) {+ return Err(unsupported("a blend too small for the corner patch to fit"));+ }+ let speed = chord / 3.0;+ let to_apex = (f.p - apex).normalized().ok_or_else(|| unsupported("a section curve starts on the apex"))?;+ let leave_apex =+ (to_apex - n_apex * to_apex.dot(n_apex)).normalized().ok_or_else(|| unsupported("a section curve reaches the apex along the apex normal"))?;+ let mut c = [Vec3::ZERO; ACROSS + 1];+ c[0] = f.p;+ c[1] = f.p + f.leave * (speed / k);+ c[2] = f.bend * (speed * speed / (k * (k - 1.0))) + c[1] * 2.0 - c[0];+ c[ACROSS] = apex;+ c[ACROSS - 1] = apex + leave_apex * (speed / k);+ c[ACROSS - 2] = (-n_apex * kappa) * (speed * speed / (k * (k - 1.0))) + c[ACROSS - 1] * 2.0 - c[ACROSS];+ if c.iter().any(|p| !p.is_finite()) {+ return Err(fail("a cross-section of the corner is not finite"));+ }+ Ok(c)+}++/// A closed uniform cubic B-spline through `points`, once round the loop: the curve at each station+/// is `(q[i-1] + 4 q[i] + q[i+1]) / 6`, so the stations fix the net by a cyclic tridiagonal system,+/// solved here with the Sherman–Morrison form of the Thomas algorithm (a corner's loop runs to+/// hundreds of stations). The net comes back in the open form the tensor surface wants — the first+/// three control points repeated past the end — so it still closes, with one uniform span per+/// station and no free end anywhere.+fn closed_layer(points: &[Vec3]) -> Result<Vec<Vec3>> {+ let m = points.len();+ if m < 2 * ALONG + 2 {+ return Err(fail("a corner loop needs at least eight stations"));+ }+ // Sub-diagonal 1, diagonal 4, super-diagonal 1, and 1 in both corners.+ let (sub, diag, sup, corner) = (1.0f64, 4.0f64, 1.0f64, 1.0f64);+ let gamma = -diag;+ let mut bb = vec![diag; m];+ if let Some(first) = bb.first_mut() {+ *first = diag - gamma;+ }+ if let Some(last) = bb.last_mut() {+ *last = diag - corner * corner / gamma;+ }+ // Thomas, one right-hand side at a time (three components solved together).+ let thomas = |rhs: &[Vec3]| -> Result<Vec<Vec3>> {+ let mut c = vec![0.0f64; m];+ let mut d = rhs.to_vec();+ let mut denom = bb.first().copied().unwrap_or(0.0);+ if !(denom.abs() > 1e-300) {+ return Err(fail("the corner's stations are degenerate"));+ }+ let (Some(c0), Some(d0)) = (c.first_mut(), d.first_mut()) else { return Err(fail("stations")) };+ *c0 = sup / denom;+ *d0 = *d0 * (1.0 / denom);+ for i in 1..m {+ let (prev_c, prev_d) = (c.get(i - 1).copied().unwrap_or(0.0), d.get(i - 1).copied().unwrap_or(Vec3::ZERO));+ let b = bb.get(i).copied().unwrap_or(diag);+ denom = b - sub * prev_c;+ if !(denom.abs() > 1e-300) {+ return Err(fail("the corner's stations are degenerate"));+ }+ if let Some(slot) = c.get_mut(i) {+ *slot = if i + 1 < m { sup / denom } else { 0.0 };+ }+ if let Some(slot) = d.get_mut(i) {+ *slot = (*slot - prev_d * sub) * (1.0 / denom);+ }+ }+ let mut x = vec![Vec3::ZERO; m];+ let last = d.last().copied().unwrap_or(Vec3::ZERO);+ if let Some(slot) = x.last_mut() {+ *slot = last;+ }+ for i in (0..m - 1).rev() {+ let (Some(ci), Some(xn)) = (c.get(i).copied(), x.get(i + 1).copied()) else { continue };+ let di = d.get(i).copied().unwrap_or(Vec3::ZERO);+ if let Some(slot) = x.get_mut(i) {+ *slot = di - xn * ci;+ }+ }+ Ok(x)+ };+ let rhs: Vec<Vec3> = points.iter().map(|p| *p * 6.0).collect();+ let x = thomas(&rhs)?;+ // The unit right-hand side the corner terms add: gamma at the first station, the corner at the+ // last.+ let mut unit = vec![Vec3::ZERO; m];+ if let Some(slot) = unit.first_mut() {+ *slot = Vec3::new(gamma, gamma, gamma);+ }+ if let Some(slot) = unit.last_mut() {+ *slot = Vec3::new(corner, corner, corner);+ }+ let z = thomas(&unit)?;+ let (x0, xn) = (x.first().copied().unwrap_or(Vec3::ZERO), x.last().copied().unwrap_or(Vec3::ZERO));+ let (z0, zn) = (z.first().copied().unwrap_or(Vec3::ZERO), z.last().copied().unwrap_or(Vec3::ZERO));+ // z answers a scalar right-hand side, so the correction is one scalar factor per component.+ let factor = |x0: f64, xn: f64, z0: f64, zn: f64| (x0 + corner * xn / gamma) / (1.0 + z0 + corner * zn / gamma);+ let f = Vec3::new(factor(x0.x, xn.x, z0.x, zn.x), factor(x0.y, xn.y, z0.y, zn.y), factor(x0.z, xn.z, z0.z, zn.z));+ let mut out = Vec::with_capacity(m + ALONG);+ for i in 0..m {+ let (xi, zi) = (x.get(i).copied().unwrap_or(Vec3::ZERO), z.get(i).copied().unwrap_or(Vec3::ZERO));+ out.push(xi - Vec3::new(f.x * zi.x, f.y * zi.y, f.z * zi.z));+ }+ if !out.iter().all(|p| p.is_finite()) {+ return Err(fail("the corner's boundary is not finite"));+ }+ for i in 0..ALONG {+ let p = out.get(i).copied().unwrap_or(Vec3::ZERO);+ out.push(p);+ }+ Ok(out)+}++/// The stations of the loop as one tensor control net: across (v) each station's cross-section is+/// the Bézier above, along the seam loop (u) each of its control points is a closed cubic through+/// the stations, so the face passes through every section exactly and its parameter line along the+/// loop closes without an end to swing from. The loop's station count comes back with it: station+/// `i` sits at parameter `i + ALONG`, and the loop closes at `count + ALONG`.+fn tensor(layers: &[[Vec3; ACROSS + 1]]) -> Result<(NurbsSurface, f64)> {+ let m = layers.len();+ let nu = m + ALONG;+ let knots_u: Vec<f64> = (0..=(nu + ALONG) as i64).map(|i| i as f64).collect();+ let mut ctrl: Vec<HPoint> = Vec::with_capacity(nu * (ACROSS + 1));+ for j in 0..=ACROSS {+ let points: Vec<Vec3> = layers.iter().map(|c| c.get(j).copied().unwrap_or(Vec3::ZERO)).collect();+ let net = closed_layer(&points)?;+ for p in &net {+ ctrl.push(HPoint::weighted(*p, 1.0));+ }+ }+ let mut knots_v = vec![0.0; ACROSS + 1];+ knots_v.extend(std::iter::repeat_n(1.0, ACROSS + 1));+ let s = NurbsSurface::from_homogeneous([ALONG, ACROSS], [knots_u, knots_v], ctrl).map_err(|e| fail(format!("the corner patch: {e}")))?;+ Ok((s, m as f64))+}++/// The surface across its own domain: the patch must keep facing one way, or a blend would be met+/// by a piece of the patch folded back on itself.+fn no_fold(surface: &mt::Surface, loop_range: (f64, f64)) -> Result<()> {+ use mt::ParametricSurface;+ // The u knots run past the loop at both ends (a closed curve has no clamped ends to name), so+ // the loop's own range is brought in rather than read off the knot vector.+ let (u0, u1) = loop_range;+ let Some((v0, v1)) = surface.try_range_tuple().1 else {+ return Err(fail("the corner patch has no parameter domain"));+ };+ let normal = |u: f64, v: f64| -> Option<Vec3> { vec_of(surface.uder(u, v)).cross(vec_of(surface.vder(u, v))).normalized() };+ let mid = normal((u0 + u1) * 0.5, v0 + (v1 - v0) * 0.5).ok_or_else(|| unsupported("the corner patch has no normal at its middle"))?;+ // Clear of the apex (v1), where the patch's parameter line along the seam collapses to a point+ // and the normal is read from the sections approaching it.+ for i in 0..=8 {+ for j in 0..9 {+ let u = u0 + (u1 - u0) * i as f64 / 8.0;+ let v = v0 + (v1 - v0) * j as f64 / 9.0;+ let n = normal(u, v).ok_or_else(|| unsupported("the corner patch folds back on itself"))?;+ if n.dot(mid) <= 0.0 {+ return Err(unsupported("the corner patch folds back on itself with these section curves"));+ }+ }+ }+ Ok(())+}++/// Build the patch: sections, tensor surface, and the wire of the section curves themselves.+fn build(sides: &[Vec<Frame>], apex: Vec3) -> Result<Vec<mt::Face>> {+ if !apex.is_finite() {+ return Err(KernelError::Invalid("the corner apex must be a finite point".into()));+ }+ let (frames, starts, size) = corner_loop(sides)?;+ let frames = transverse(&frames, &loop_tangents(&frames))?;+ // The apex's own plane: the mean direction from the apex to the boundary it caps.+ let n_apex = frames+ .iter()+ .fold(Vec3::ZERO, |a, f| a + (f.p - apex))+ .normalized()+ .ok_or_else(|| unsupported("the corner's apex sits on its own boundary curves"))?;+ // How hard the patch bends into the apex: as much as its blends do across their seams, and+ // never flatter than a dome of the corner's own size (a flat cap would end in a point).+ let mean_bend = frames.iter().map(|f| f.bend.len()).sum::<f64>() / frames.len().max(1) as f64;+ let reach = (frames.iter().map(|f| f.p.dist(apex)).sum::<f64>() / frames.len().max(1) as f64).max(size * 1e-3);+ let kappa = mean_bend.max(1.0 / (2.0 * reach));+ if !(kappa.is_finite() && kappa > 0.0) {+ return Err(unsupported("a corner the patch cannot span"));+ }+ let layers: Vec<[Vec3; ACROSS + 1]> = frames.iter().map(|f| section(f, apex, n_apex, kappa)).collect::<Result<_>>()?;+ let (nurbs, m) = tensor(&layers)?;+ let surface = crate::spline_conv::surface(&nurbs)?;+ no_fold(&surface, (ALONG as f64, m + ALONG as f64))?;+ // The boundary is the loop of section curves; each side is cut out of the patch's own boundary+ // curve so that it lies on the patch exactly.+ let nu = nurbs.count().first().copied().unwrap_or(0);+ let row: Vec<HPoint> = (0..nu).map(|i| nurbs.point(i, 0)).collect();+ let Some(knots_u) = nurbs.knots().first().cloned() else { return Err(fail("knots")) };+ let loop_curve = crate::spline_conv::nurbs_curve(mt::KnotVec::from(knots_u), &row)?;+ let mut cuts: Vec<f64> = starts.iter().map(|i| *i as f64 + ALONG as f64).collect();+ cuts.push(m + ALONG as f64);+ let mut verts: Vec<mt::Vertex> = Vec::with_capacity(sides.len());+ for side in sides {+ let first = side.first().ok_or_else(|| fail("a section curve has no stations"))?;+ verts.push(builder::vertex(p3(first.p)));+ }+ let mut edges: Vec<mt::Edge> = Vec::with_capacity(sides.len());+ for i in 0..sides.len() {+ let (Some(&a), Some(&b)) = (cuts.get(i), cuts.get(i + 1)) else { return Err(fail("the corner's seams")) };+ let mut piece = loop_curve.clone();+ let _tail = mt::Cut::cut(&mut piece, b);+ let piece = mt::Cut::cut(&mut piece, a);+ let (Some(from), Some(to)) = (verts.get(i), verts.get((i + 1) % verts.len())) else { return Err(fail("the corner's vertices")) };+ edges.push(mt::Edge::try_new(from, to, piece).map_err(|e| fail(format!("a corner seam: {e}")))?);+ }+ let face = mt::Face::try_new(vec![mt::Wire::from(edges)], surface).map_err(|e| fail(format!("the corner patch: {e}")))?;+ Ok(vec![face])+}++/// What the patch achieves along the seams of `sides`: the largest distance from a seam station to+/// the patch, the largest angle (radians) between the patch's normal there and the blend's, and the+/// largest difference between the curvature across the seam and the blend's own, relative to+/// `reference` — the curvature a rolling-ball corner shows across the same seam, which is what G2+/// removes. Measured on the built surface alone, by the same finite differences of its own samples+/// that `crate::bridge`'s tests read a cross-section's shape with, so it is evidence about the+/// geometry and not about the construction.+pub fn seam_error(surface: &mt::Surface, sides: &[Vec<Frame>], reference: f64) -> Result<(f64, f64, f64)> {+ use mt::{ParametricSurface, SearchNearestParameter};+ if !(reference.is_finite() && reference > 0.0) {+ return Err(KernelError::Invalid("a reference curvature must be finite and positive".into()));+ }+ let (Some((u0, u1)), Some((v0, v1))) = surface.try_range_tuple() else {+ return Err(fail("the corner patch has no parameter domain"));+ };+ // Samples across the section for a five-point difference, as `bridge`'s tests use.+ const INWARDS: usize = 5;+ let hv = (v1 - v0).abs() * 1e-3;+ let hu = (u1 - u0).abs() * 1e-3;+ if !(hv > 0.0 && hu > 0.0) {+ return Err(fail("the corner patch has no extent to measure"));+ }+ let (mut gap, mut angle, mut curvature) = (0.0f64, 0.0f64, 0.0f64);+ for side in sides {+ if side.len() < 5 {+ return Err(KernelError::Invalid("a seam needs at least five stations to measure its direction".into()));+ }+ let mut hint: Option<(f64, f64)> = None;+ for (i, f) in side.iter().enumerate() {+ let Some(t) = seam_tangent(side, i) else { continue };+ let found = surface+ .search_nearest_parameter(p3(f.p), hint, 100)+ .or_else(|| surface.search_nearest_parameter(p3(f.p), None, 200))+ .ok_or_else(|| fail("a seam station is not on the corner patch"))?;+ hint = Some(found);+ let (u, v) = found;+ let at = from_p3(surface.subs(u, v));+ gap = gap.max(at.dist(f.p));+ // The cross-section, sampled inwards from the seam (or from the other end of the patch,+ // with the odd differences turned round).+ let out = v <= (v0 + v1) * 0.5;+ let step = if out { hv } else { -hv };+ let q: Vec<Vec3> = (0..INWARDS).map(|k| from_p3(surface.subs(u, v + step * k as f64))).collect();+ let (Some(&f0), Some(&f1), Some(&f2), Some(&f3), Some(&f4)) = (q.first(), q.get(1), q.get(2), q.get(3), q.get(4)) else {+ return Err(fail("the corner patch has no room for a sample"));+ };+ let sign = if out { 1.0 } else { -1.0 };+ let d1 = (f0 * -25.0 + f1 * 48.0 + f2 * -36.0 + f3 * 16.0 + f4 * -3.0) * (sign / (12.0 * hv));+ let d2 = (f0 * 35.0 + f1 * -104.0 + f2 * 114.0 + f3 * -56.0 + f4 * 11.0) * (1.0 / (12.0 * hv * hv));+ // Along the seam, to stand the tangent plane up.+ let du = if u - hu >= u0 && u + hu <= u1 {+ (from_p3(surface.subs(u + hu, v)) - from_p3(surface.subs(u - hu, v))) * (0.5 / hu)+ } else {+ let (a, b) = if u + hu <= u1 { (u, u + hu) } else { (u, u - hu) };+ (from_p3(surface.subs(b, v)) - from_p3(surface.subs(a, v))) * (1.0 / hu)+ };+ let n = du.cross(d1).normalized().ok_or_else(|| fail("the corner patch has no normal at a seam"))?;+ let blend_n = t.cross(f.leave).normalized().ok_or_else(|| fail("a blend has no normal at a seam"))?;+ angle = angle.max(n.dot(blend_n).abs().clamp(0.0, 1.0).acos());+ // The curvature vector of the cross-seam curve: what the blend's own surface does along+ // the direction the patch leaves it in.+ let speed2 = d1.len2().max(1e-300);+ let bend = (d2 - d1 * (d2.dot(d1) / speed2)) * (1.0 / speed2);+ curvature = curvature.max((bend - f.bend).len() / reference.max(f.bend.len()).max(1e-30));+ }+ }+ Ok((gap, angle, curvature))+}++#[cfg(test)]+#[path = "corner_g2_tests.rs"]+mod tests;++/// The G2 corner through the fillet path: a box's three edges at one corner rounded, rolling ball+/// against G2 patch, measured on the built bodies with the continuity analysis.+#[cfg(test)]+#[allow(clippy::unwrap_used)]+mod fillet_corner_tests {+ use super::*;+ use crate::{ContinuityTolerances, SeamReport, measure, seam_diagnostics};++ /// A 20 mm box with its three edges at one corner rounded by 4: the rolling ball fills that+ /// corner with a piece of its sphere, the G2 route with a patch on the blends' own sections.+ fn cornered(g2: bool) -> crate::Body {+ let b = crate::box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();+ let edges = [Vec3::new(10.0, 0.0, 0.0), Vec3::new(0.0, 10.0, 0.0), Vec3::new(0.0, 0.0, 10.0)];+ if g2 { crate::fillet_g2_corners(&b, &edges, 4.0).unwrap() } else { crate::fillet(&b, &edges, 4.0).unwrap() }+ }++ #[test]+ fn the_ball_corner_is_measurably_g1_and_a_g2_corner_is_refused_until_it_sews() {+ // The rolling ball: tangent to every blend, keeping its own 1/r across each corner seam.+ let body = cornered(false);+ let volume = measure(&body).unwrap().volume;+ assert!(volume > 7000.0 && volume < 8000.0, "the box is still a solid: {volume}");+ let report = seam_diagnostics(&body, &[], 33, ContinuityTolerances { gap_mm: 1e-3, angle_deg: 1.0, curvature_per_mm: 1e-6 }).unwrap();+ // Every seam of a filleted box is tangent; the corner's three are the short ones (the+ // blend-to-face seams run the edge's own 12 mm and more).+ let tangent: Vec<&SeamReport> = report.seams.iter().filter(|s| s.normal_angle_deg.value < 0.01).collect();+ let corner: Vec<&&SeamReport> = tangent.iter().filter(|s| s.length < 8.0).collect();+ assert_eq!(+ corner.len(),+ 3,+ "three corner seams among {} tangent ones: {:?}",+ tangent.len(),+ tangent.iter().map(|s| s.length).collect::<Vec<_>>()+ );+ let worst = corner.iter().map(|s| s.curvature_jump_per_mm.value).fold(0.0f64, f64::max);+ eprintln!("rolling ball: corner seams jump {worst:.6} per mm (volume {volume:.3})");+ assert!((worst - 0.25).abs() < 1e-3, "the ball keeps its own 1/r (r = 4) across the seam: {worst}");++ // The G2 corner patch is built on the blends' own sections, but sewing it into the shell+ // is not done yet: the fillet with `corner: g2` refuses with a clear message rather than+ // leaving the shell open, and leaves the ball the corner.+ let b = crate::box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();+ let edges = [Vec3::new(10.0, 0.0, 0.0), Vec3::new(0.0, 10.0, 0.0), Vec3::new(0.0, 0.0, 10.0)];+ let err = crate::fillet_g2_corners(&b, &edges, 4.0).unwrap_err().to_string();+ eprintln!("G2 corner: {err}");+ assert!(err.contains("not supported yet:") && err.contains("G2 corner"), "{err}");+ }+}diff --git a/crates/kernel/src/corner_g2_tests.rs b/crates/kernel/src/corner_g2_tests.rsnew file mode 100644index 0000000000..0968522b6e--- /dev/null+++ b/crates/kernel/src/corner_g2_tests.rs@@ -0,0 +1,154 @@+//! What the G2 corner patch has to prove on a corner whose answer is known analytically: the box.++use super::*;+use std::f64::consts::FRAC_PI_2;++use crate::body::v3;++/// One seam of a box corner: a quarter circle about `centre` from direction `u` to direction `w`,+/// with `leave` the way the patch leaves the blend's surface. A fillet is flat along its own axis,+/// so its curvature across the seam is nothing.+fn seam(centre: Vec3, u: Vec3, w: Vec3, leave: Vec3, r: f64, n: usize) -> Vec<Frame> {+ (0..n)+ .map(|i| {+ let theta = FRAC_PI_2 * i as f64 / (n - 1) as f64;+ Frame { p: centre + (u * theta.cos() + w * theta.sin()) * r, leave, bend: Vec3::ZERO, bend_change: Vec3::ZERO }+ })+ .collect()+}++/// A box corner at the origin (material x, y, z ≥ 0) with three fillets of radius `r`: the three+/// section curves where the fillets stop, meeting at (0,r,r), (r,0,r) and (r,r,0), and the middle of+/// the ball's octant a rolling ball would leave there.+fn box_corner(r: f64, n: usize) -> (Vec<Vec<Frame>>, Vec3, Vec3) {+ let c = Vec3::new(r, r, r);+ let (a, b, d) = (Vec3::new(0.0, r, r), Vec3::new(r, 0.0, r), Vec3::new(r, r, 0.0));+ let dir = |p: Vec3| (p - c).normalized().unwrap_or(Vec3::X);+ let sides = vec![+ // A → B on the z edge's cylinder (flat along z), B → C on the x edge's, C → A on the y+ // edge's; each patch leaves the blend towards the material the corner caps.+ seam(c, dir(a), dir(b), Vec3::new(0.0, 0.0, -1.0), r, n),+ seam(c, dir(b), dir(d), Vec3::new(-1.0, 0.0, 0.0), r, n),+ seam(c, dir(d), dir(a), Vec3::new(0.0, -1.0, 0.0), r, n),+ ];+ let apex = c - Vec3::new(1.0, 1.0, 1.0).normalized().unwrap_or(Vec3::Z) * r;+ (sides, apex, c)+}++/// The rolling-ball corner the kernel builds today: the sphere through the same three seams, made+/// the way `curvecorner` makes it (a meridian arc swept about the axis through the ball's centre).+fn rolling_ball(r: f64, c: Vec3) -> mt::Surface {+ let axis = Vec3::new(1.0, 1.0, 1.0).normalized().unwrap_or(Vec3::Z);+ let side = axis.any_perp();+ let meridian = builder::circle_arc(&builder::vertex(p3(c + axis * r)), &builder::vertex(p3(c - axis * r)), p3(c + side * r));+ mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(meridian.oriented_curve(), p3(c), v3(axis))))+}++/// The stations clear of the corners. Two blends meet at a corner with their seams 90° apart and+/// ask for different curvature at that one point, which no single patch can hold, and the corner's+/// own spline rounds the seam there; both effects fade within a few stations, so the measurement+/// starts clear of them.+fn interior(sides: &[Vec<Frame>]) -> Vec<Vec<Frame>> {+ sides.iter().map(|s| s.iter().skip(4).take(s.len().saturating_sub(8)).copied().collect()).collect()+}++#[test]+fn a_box_corner_is_curvature_continuous_with_every_blend() {+ let r = 2.0;+ let (sides, apex, centre) = box_corner(r, 25);+ let faces = corner_g2_patch(&sides, apex).unwrap();+ let face = faces.first().expect("a corner patch");+ let surface = face.oriented_surface();+ let inner = interior(&sides);+ let (gap, angle, curvature) = seam_error(&surface, &inner, 1.0 / r).unwrap();+ println!("G2 corner: gap {gap:e}, normal angle {angle:e} rad, curvature {curvature:e} (relative to 1/r)");+ assert!(gap <= r * 1e-5, "the patch is {gap} from the seam");+ // The stated tolerances: the normal angle within 0.01° and the curvature across the seam within+ // 1% of the blend's own (here the fillet is flat across the seam, so that is 1% of 1/r).+ assert!(angle < 0.01f64.to_radians(), "normal angle {angle} rad");+ assert!(curvature < 1e-2, "curvature across the seam is {curvature} of the blend's");++ // The same measurement on the rolling-ball corner the kernel builds today: G1 (angle nought)+ // but the ball's own 1/r across each seam, which is the whole of the blend's curvature.+ let ball = rolling_ball(r, centre);+ let (ball_gap, ball_angle, ball_curvature) = seam_error(&ball, &inner, 1.0 / r).unwrap();+ println!("rolling ball: gap {ball_gap:e}, normal angle {ball_angle:e} rad, curvature {ball_curvature:e}");+ assert!(ball_angle < 0.01f64.to_radians(), "the ball is tangent to each blend");+ assert!(ball_curvature > 0.5, "the ball keeps its own curvature across the seam: {ball_curvature}");+ assert!(curvature * 20.0 < ball_curvature, "the G2 patch has to be far closer than the ball");+}++#[test]+fn a_corner_meets_three_blends_of_different_shape_apart() {+ // Blends that differ along their seams: a fillet of radius 2 next to rounder walls, each asking+ // for its own curvature across the seam, at its own direction.+ let r = 2.0;+ let (mut sides, apex, _) = box_corner(r, 33);+ let bends = [0.25, 0.4, 0.6];+ for (i, bend) in bends.iter().enumerate() {+ let Some(side) = sides.get_mut(i) else { continue };+ for f in side.iter_mut() {+ // Across the seam, perpendicular to both the leave direction and the seam.+ f.bend = f.leave.any_perp() * *bend;+ }+ }+ let faces = corner_g2_patch(&sides, apex).unwrap();+ let surface = faces.first().expect("a corner patch").oriented_surface();+ let inner = interior(&sides);+ let (gap, angle, curvature) = seam_error(&surface, &inner, bends.iter().copied().fold(0.0, f64::max)).unwrap();+ println!("three different blends: gap {gap:e}, angle {angle:e} rad, curvature {curvature:e}");+ assert!(gap <= r * 1e-6, "{gap}");+ assert!(angle < 0.01f64.to_radians(), "{angle}");+ assert!(curvature < 1e-2, "each blend's own curvature across the seam: {curvature}");+}++#[test]+fn a_g2_corner_refuses_what_it_cannot_hold() {+ let r = 2.0;+ let (sides, apex, _) = box_corner(r, 9);+ assert!(corner_g2_patch(&sides, apex).is_ok());++ // Two blends (the ball's patch still fills that corner), or one.+ assert!(corner_g2_patch(&sides[..2], apex).is_err());+ assert!(corner_g2_patch(&sides[..1], apex).is_err());+ assert!(corner_g2_patch(&[], apex).is_err());++ // Too few stations to interpolate a cubic through, and too many to work with.+ let thin: Vec<Vec<Frame>> = sides.iter().map(|s| s[..3].to_vec()).collect();+ assert!(corner_g2_patch(&thin, apex).is_err());+ let fat: Vec<Vec<Frame>> = sides.iter().map(|s| s[..1].iter().cycle().take(MAX_STATIONS + 1).copied().collect()).collect();+ assert!(corner_g2_patch(&fat, apex).is_err());++ // A vertex the construction cannot hold: the section curves do not meet at their corners.+ let mut apart = sides.clone();+ if let Some(first) = apart.first_mut().and_then(|s| s.first_mut()) {+ first.p += Vec3::new(0.5, 0.0, 0.0);+ }+ assert!(corner_g2_patch(&apart, apex).is_err());++ // A section curve that runs along the seam, so the patch has no direction to leave it in.+ let along: Vec<Vec<Frame>> = sides+ .iter()+ .map(|s| {+ s.windows(2)+ .map(|w| {+ let d = w.first().zip(w.get(1)).map(|(a, b)| (b.p - a.p).normalized().unwrap_or(Vec3::X)).unwrap_or(Vec3::X);+ Frame { leave: d, ..w.first().copied().unwrap_or(s[0]) }+ })+ .chain(s.last().copied())+ .collect()+ })+ .collect();+ assert!(corner_g2_patch(&along, apex).is_err());++ // Hostile numbers never panic.+ let mut nan = sides.clone();+ if let Some(f) = nan.first_mut().and_then(|s| s.get_mut(1)) {+ f.p = Vec3::new(f64::NAN, 0.0, 0.0);+ }+ assert!(corner_g2_patch(&nan, apex).is_err());+ assert!(corner_g2_patch(&sides, Vec3::new(f64::INFINITY, 0.0, 0.0)).is_err());+ // A corner with no room: every station on the apex.+ let on_apex: Vec<Vec<Frame>> = sides.iter().map(|s| s.iter().map(|f| Frame { p: apex, ..*f }).collect()).collect();+ assert!(corner_g2_patch(&on_apex, apex).is_err());+}diff --git a/crates/kernel/src/curveblend.rs b/crates/kernel/src/curveblend.rsindex 6de2a46514..d723471288 100644--- a/crates/kernel/src/curveblend.rs+++ b/crates/kernel/src/curveblend.rs@@ -1,10 +1,17 @@//! Rolling-ball blends along a closed chain of smooth edges between two smooth groups of faces-//! of any surfaces (a branch pipe meeting a main pipe, a boss on a cylinder). A ball of the-//! blend's radius rolls along the edge touching both sides; its centre traces the spine and its-//! contacts the curves where the blend meets each side. The blend face is a rational B-spline-//! through the circular cross-sections (exact arcs at the samples), the side faces are trimmed-//! back to the contact curves, and seams that met the edge (lines, or arcs of an end face) are-//! shortened to the contacts.+//! of any surfaces (a branch pipe meeting a main pipe, a boss on a cylinder). A ball rolls along+//! the edge touching both sides; its centre traces the spine and its contacts the curves where+//! the blend meets each side. The blend face is a rational B-spline through the circular+//! cross-sections (exact arcs at the samples), the side faces are trimmed back to the contact+//! curves, and seams that met the edge (lines, or arcs of an end face) are shortened to the+//! contacts.+//!+//! The ball's size along the chain is one of [`Size`]: one radius all along (the ordinary+//! fillet), a chord width across the blend (each section spans the requested width from contact+//! to contact, so its radius is `chord / (2 sin(ψ/2))` for the `ψ` between the two outward+//! normals where the ball touches), or a radius law along the chain (a [`RadiusSpline`] whose+//! positions are the fraction of the chain's arc length, zero only at an end, where the blend+//! closes to the edge's end point as the straight-edge fillet does).use std::collections::HashMap;@@ -12,6 +19,7 @@ use solidcraft_geom::Vec3;use truck_modeling::{self as mt, builder};use crate::blend::too_large;+use crate::blend_variable::RadiusSpline;use crate::body::{Solid, from_p3, p3};use crate::record::Rebuild;use crate::{KernelError, Result};@@ -40,21 +48,60 @@ const TANGENT_RETRIES: usize = 8;const MAX_STEP_STRETCH: f64 = 3.0;/// Slides of the ball's centre along a knife edge's faces, each 1.6 times the last.const KNIFE_STEPS: usize = 40;+/// Corrections of the radius a chord fillet makes to the width it measures across the blend.+const CHORD_STEPS: usize = 12;+/// A section this close to a point is closed: the blend ends at the edge's end point (a radius+/// that has run to zero there).+const CLOSED: f64 = 1e-7;+/// Parameters an edge is sampled at to measure the arc length a radius law is read off.+const LENGTH_STEPS: usize = 64;++/// The ball's size along the edge chain.+#[derive(Clone, Copy)]+enum Size<'a> {+ /// One radius all along.+ Constant(f64),+ /// The width across the blend, from contact to contact, at every station.+ Chord(f64),+ /// The radius at the station's arc-length fraction along the chain, 0 at the front and 1 at+ /// the back of its edge.+ Law(&'a RadiusSpline),+}struct Fit {surface: mt::Surface,contacts: [mt::Curve; 2],/// Parameter range belonging to this edge (the fit includes neighbouring sections).range: (f64, f64),+ /// The part of the fit that is the chain's own run, as fractions of its parameter range.+ span: (f64, f64),}struct Guide {sections: Vec<Section>,+ /// The size law's parameter (the arc-length fraction along the chain) at each section: the+ /// radius between the samples is read off the law there, not off the spine's own length.+ law: Vec<f64>,lengths: Vec<f64>,+ /// The part of the guide that is the chain itself, as fractions of its length: the sections+ /// run on past the ends of the chain (only so that the fit can be cut back there) and the fit+ /// is checked for accuracy on the chain alone.+ span: (f64, f64),}impl Guide {+ /// A guide whose law parameter is the section's own fraction of it (the size is one radius,+ /// which needs no law).fn new(sections: Vec<Section>) -> Result<Self> {+ let den = sections.len().max(2) - 1;+ let law = (0..sections.len()).map(|i| i as f64 / den as f64).collect();+ Self::with_law(sections, law)+ }++ fn with_law(sections: Vec<Section>, law: Vec<f64>) -> Result<Self> {+ if sections.len() != law.len() {+ return Err(unsupported("degenerate rolling-ball spine"));+ }let mut lengths = vec![0.0];let mut total = 0.0;for pair in sections.windows(2) {@@ -65,10 +112,16 @@ impl Guide {if !total.is_finite() || total <= 1e-12 {return Err(unsupported("degenerate rolling-ball spine"));}- Ok(Self { sections, lengths })+ Ok(Self { sections, law, lengths, span: (0.0, 1.0) })}+ /// The centre and tangent at `along` of the spine.fn anchor(&self, along: f64) -> Option<(Vec3, Vec3)> {+ self.anchor_at(along).map(|(centre, tangent, _)| (centre, tangent))+ }++ /// [`Guide::anchor`] with the size law's parameter at that station.+ fn anchor_at(&self, along: f64) -> Option<(Vec3, Vec3, f64)> {if self.lengths.len() < 2 || !along.is_finite() || !(0.0..=1.0).contains(&along) {return None;}@@ -81,7 +134,8 @@ impl Guide {return None;}let fraction = (distance - lo) / span;- Some((a.c + (b.c - a.c) * fraction, (b.c - a.c).normalized()?))+ let law = self.law.get(hi - 1)? * (1.0 - fraction) + self.law.get(hi)? * fraction;+ Some((a.c + (b.c - a.c) * fraction, (b.c - a.c).normalized()?, law))}}@@ -145,7 +199,7 @@ fn fit_strip(list: &[Section], before: &[Section], after: &[Section], round: boo};let contacts = [contact(0)?, contact(2)?];let bs = mt::BSplineSurface::try_new((mt::KnotVec::bezier_knot(2), vk), rows).map_err(|e| fail(&e.to_string()))?;- Ok(Fit { surface: mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)), contacts, range })+ Ok(Fit { surface: mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)), contacts, range, span: (0.0, 1.0) })}/// Compare the fitted strip with a solved circular section between interpolation nodes.@@ -263,7 +317,7 @@ fn end_cap(fit: &Fit, g: &mt::Face, at: &Section, seams: [Option<&mt::Edge>; 2],// Both contacts are cut there: strictly inside the strip's own part.let inside = |t: f64| t > fit.range.0 + 1e-6 && t < fit.range.1 - 1e-6;if !(inside(*t1) && inside(*t2)) {- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 309)"));}return Ok((*t1, *t2, mt::Curve::BSplineCurve(bs)));}@@ -341,10 +395,10 @@ fn tangent_cap(fit: &Fit, g: &mt::Face, tangent_side: u8, seams: [Option<&mt::Ed};let (rt, ra) = (crossing(u_t, seam_t), crossing(u_o, seam_o));let v_t = rt.ok_or_else(fail)?;- let v_a = ra.ok_or_else(|| too_large("the blend is larger than the neighbouring faces"))?;+ let v_a = ra.ok_or_else(|| too_large("the blend is larger than the neighbouring faces (site 387)"))?;let inside = |t: f64| t > lo + 1e-6 && t < hi - 1e-6;if !(inside(v_a) && inside(v_t)) || (v_a - v_t).abs() < 1e-9 {- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 390)"));}// How far the strip's point (u, v) is outside the end face (negative: inside the body).let outside = |u: f64, v: f64| -> Option<f64> {@@ -599,6 +653,93 @@ fn solve_from(None}+/// The section whose two contacts are `chord` apart: the ball's radius is `chord / (2 sin(ψ/2))`+/// for the `ψ` between the two outward normals where it touches, `|q1 − q2| = 2 r sin(ψ/2)`. The+/// normals turn as the ball grows against curved faces, so the width is measured on the solved+/// section and the radius corrected until it matches (the width is proportional to the radius,+/// so the corrections converge quickly). The normals at `p` give the first radius, exact where+/// both faces are planar; `None` where the faces meet too nearly tangentially to span a chord.+#[allow(clippy::too_many_arguments)]+fn solve_chord(+ f1: &[&mt::Face],+ f2: &[&mt::Face],+ p: Vec3,+ t: Vec3,+ chord: f64,+ sigma: f64,+ cusp: f64,+ extra: Option<Extra<'_>>,+ tol: f64,+) -> Option<(Section, f64)> {+ let normal = |fs: &[&mt::Face]| fs.iter().filter_map(|f| project(f, p, None)).min_by(|a, b| a.0.dist(p).total_cmp(&b.0.dist(p))).map(|x| x.1);+ let (n1, n2) = (normal(f1)?, normal(f2)?);+ let half = (n1.dot(n2).clamp(-1.0, 1.0).acos() / 2.0).sin();+ if !(half > 1e-3) {+ return None;+ }+ let mut r = chord / (2.0 * half);+ for _ in 0..CHORD_STEPS {+ if !(r.is_finite() && r > 0.0 && r < 1e9) {+ return None;+ }+ let s = solve(f1, f2, p, t, r, sigma, cusp, extra, tol)?;+ let width = s.q1.dist(s.q2);+ if !width.is_finite() || width <= 0.0 {+ return None;+ }+ if (width - chord).abs() <= (chord * 1e-9).max(tol * 0.5) {+ return Some((s, r));+ }+ r *= chord / width;+ }+ None+}++/// The rolling ball at one station, sized by the blend's law.+struct Sizer<'a> {+ size: Size<'a>,+ /// The tolerance the section's equations are solved at.+ tol: f64,+}++impl Sizer<'_> {+ /// The section at `p` (tangent `t`, the size law's parameter `s`) holding the third+ /// condition `extra` when given, with the radius it was solved at.+ #[allow(clippy::too_many_arguments)]+ fn section(+ &self,+ f1: &[&mt::Face],+ f2: &[&mt::Face],+ p: Vec3,+ t: Vec3,+ s: f64,+ sigma: f64,+ cusp: f64,+ extra: Option<Extra<'_>>,+ ) -> Option<(Section, f64)> {+ match self.size {+ Size::Constant(r) => solve(f1, f2, p, t, r, sigma, cusp, extra, self.tol).map(|x| (x, r)),+ Size::Chord(chord) => solve_chord(f1, f2, p, t, chord, sigma, cusp, extra, self.tol),+ Size::Law(law) => {+ let r = law_beyond(law, s)?;+ if !(r.is_finite() && (0.0..1e6).contains(&r)) {+ return None;+ }+ solve(f1, f2, p, t, r, sigma, cusp, extra, self.tol).map(|x| (x, r))+ }+ }+ }++ /// What a station the ball does not fit at is refused with: a chord too large is about the+ /// size asked for, anything else about where the ball is.+ fn refusal(&self) -> KernelError {+ match self.size {+ Size::Chord(_) => too_large("the blend is larger than the neighbouring faces (site 704)"),+ _ => unsupported("the ball doesn't fit along the edge"),+ }+ }+}+/// Whether the strip's curvature jumps where two runs of sections meet (each three sections from/// the joint outward, the joint's first): for the centres or either contact, the difference of/// the circles through them would move the middle section by more than a tenth of `tolerance`.@@ -614,6 +755,12 @@ fn bends(a: [&Section; 3], b: [&Section; 3], tolerance: f64) -> bool {.any(|f| (curvature(a.map(f)) - curvature(b.map(f))).abs() * h * h > tolerance * 0.1)}+/// Whether the section is a point: a blend whose radius has run to zero, closing to the edge's+/// end point there.+fn closed_section(s: &Section) -> bool {+ s.c.dist(s.q1) <= CLOSED && s.c.dist(s.q2) <= CLOSED+}+/// Homogeneous control points of the circular (or straight) cross-section from q1 to q2.fn section_controls(s: &Section, round: bool) -> Option<[mt::Vector4; 3]> {let h = |p: Vec3, w: f64| mt::Vector4::new(p.x * w, p.y * w, p.z * w, w);@@ -621,6 +768,11 @@ fn section_controls(s: &Section, round: bool) -> Option<[mt::Vector4; 3]> {let m = (s.q1 + s.q2) * 0.5;return Some([h(s.q1, 1.0), h(m, 1.0), h(s.q2, 1.0)]);}+ if closed_section(s) {+ // A closed section: the arc has shrunk to the edge's end point, all three controls+ // there, so the fitted strips of the neighbouring faces meet at that vertex.+ return Some([h(s.c, 1.0), h(s.c, 1.0), h(s.c, 1.0)]);+ }let (a, b) = (s.q1 - s.c, s.q2 - s.c);let theta = a.normalized()?.dot(b.normalized()?).clamp(-1.0, 1.0).acos();if !(theta > 1e-6 && theta < std::f64::consts::PI - 1e-6) {@@ -833,14 +985,14 @@ pub(crate) fn trim_curved_seam(seam: &mt::Edge, a: Option<mt::Vertex>, b: Option.unwrap_or(end);let t = curve.search_nearest_parameter(v.point(), hint, 100).ok_or_else(|| unsupported("the blend is larger than the neighbouring faces"))?;if !(t.is_finite() && from_p3(mt::ParametricCurve::subs(&curve, t)).dist(from_p3(v.point())) <= size * 1e-5) {- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 938)"));}Ok(t)};let (ta, tb) = (at(&a, lo)?, at(&b, hi)?);let margin = (hi - lo) * 1e-9;if ta < lo - margin || tb > hi + margin || tb - ta < (hi - lo) * 1e-6 {- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 945)"));}if tb < hi {let _ = curve.cut(tb);@@ -851,16 +1003,100 @@ pub(crate) fn trim_curved_seam(seam: &mt::Edge, a: Option<mt::Vertex>, b: Optionmt::Edge::try_new(&a, &b, piece).map_err(|e| KernelError::Failed(format!("curve blend: seam: {e}")))}+/// A monotone curve's parameter read off a table of its values at uniform parameters (`None` for+/// an empty table): the fraction of the way through it.+fn sampled(table: &[f64], along: f64) -> Option<f64> {+ if table.len() < 2 || !along.is_finite() {+ return None;+ }+ let x = along.clamp(0.0, 1.0) * (table.len() - 1) as f64;+ let i = (x.floor() as usize).min(table.len() - 2);+ let f = x - i as f64;+ Some(table.get(i)? * (1.0 - f) + table.get(i + 1)? * f)+}++/// The arc length of `edge` from its front to its back at each of `LENGTH_STEPS + 1` uniform+/// parameters, accumulated. `None` for an edge that has no length (or runs back over itself).+fn edge_lengths(edge: &mt::Edge) -> Option<Vec<f64>> {+ use mt::{BoundedCurve, ParametricCurve};+ let c = edge.oriented_curve();+ let (a, b) = c.range_tuple();+ let mut last = from_p3(c.subs(a));+ let mut total = 0.0;+ let mut out = Vec::with_capacity(LENGTH_STEPS + 1);+ out.push(0.0);+ for i in 1..=LENGTH_STEPS {+ let p = from_p3(c.subs(a + (b - a) * i as f64 / LENGTH_STEPS as f64));+ total += last.dist(p);+ last = p;+ out.push(total);+ }+ (total.is_finite() && total > 1e-12).then_some(out)+}++/// The radius a law gives at the chain fraction `s`, continued past 0 and 1 at the law's own end+/// slope. The ball runs on past a chain end (to be cut back there by its end face), and holding+/// the end radius would kink the strip exactly where the edge begins: a kink a cubic fit spreads+/// back over the whole blend. Never below a fifth of the end radius, so that a law running down+/// steeply still has a ball to run on with.+fn law_beyond(law: &RadiusSpline, s: f64) -> Option<f64> {+ if (0.0..=1.0).contains(&s) {+ return Some(law.eval(s));+ }+ let (end, step) = if s < 0.0 { (0.0, s) } else { (1.0, s - 1.0) };+ let h = 1e-3;+ let slope = (law.eval(end + h) - law.eval(end)) / h;+ let r = law.eval(end);+ let r = (r + slope * step).max(0.2 * r);+ (r.is_finite() && r > 0.0).then_some(r)+}+/// Blend the closed chain of edges (ids in any order) with radius `r`; with what it built from/// `solid` (each blend face in place of its chain edge).pub(crate) fn curve_blend(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> Result<(Solid, Rebuild)> {curve_blend_with_limit(solid, ids, size, r, round, MAX_SAMPLES)}+/// [`curve_blend`] with the blend `chord` wide across, from contact to contact, at every station.+pub(crate) fn curve_blend_chord(solid: &Solid, ids: &[mt::EdgeID], size: f64, chord: f64, round: bool) -> Result<(Solid, Rebuild)> {+ curve_blend_sized(solid, ids, size, Size::Chord(chord), round, MAX_SAMPLES)+}++/// [`curve_blend`] with the radius following `law` along the chain (its positions the fraction of+/// the chain's arc length, from the front of its first edge to the back of its last).+pub(crate) fn curve_blend_law(solid: &Solid, ids: &[mt::EdgeID], size: f64, law: &RadiusSpline, round: bool) -> Result<(Solid, Rebuild)> {+ curve_blend_sized(solid, ids, size, Size::Law(law), round, MAX_SAMPLES)+}+fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool, max_samples: usize) -> Result<(Solid, Rebuild)> {- if !(size.is_finite() && size > 0.0 && r.is_finite() && r > 0.0) {+ curve_blend_sized(solid, ids, size, Size::Constant(r), round, max_samples)+}++/// Blend the chain of edges (ids in any order) sized by `size`: one radius, a chord width, or a+/// radius law. With what it built from `solid` (each blend face in place of its chain edge).+fn curve_blend_sized(solid: &Solid, ids: &[mt::EdgeID], size: f64, size_law: Size<'_>, round: bool, max_samples: usize) -> Result<(Solid, Rebuild)> {+ if !(size.is_finite() && size > 0.0) {return Err(KernelError::Invalid("curve blend size and radius must be finite and positive".into()));}+ match size_law {+ Size::Constant(r) | Size::Chord(r) => {+ if !(r.is_finite() && r > 1e-6 && r < 1e6) {+ return Err(KernelError::Invalid("curve blend size and radius must be finite and positive".into()));+ }+ }+ Size::Law(law) => {+ let knots = law.knots.len() == law.radii.len() + law.degree + 1;+ if law.radii.len() < 2 || !knots || law.radii.iter().any(|r| !(r.is_finite() && (0.0..1e6).contains(r))) {+ return Err(KernelError::Invalid("a radius law along the edge must be finite and non-negative".into()));+ }+ // A law that runs to zero closes the blend at the edge's end point. The fitted strip+ // pinches to a point there, and the sections' own interpolation cannot follow the last+ // span of it: the straight-edge fillet, which builds that closure exactly, is the way.+ if law.eval(0.0) <= CLOSED || law.eval(1.0) <= CLOSED {+ return Err(unsupported("a radius law that runs to zero along a curved edge"));+ }+ }+ }if !(4..=MAX_SAMPLES).contains(&max_samples) {return Err(KernelError::Invalid("curve blend section limit is outside the supported range".into()));}@@ -991,10 +1227,21 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,// below the first (against its outward normal) when the cusp is material, above when it is// a gap. The cross product of the normals, which tells the other edges apart, is zero here.let knife = 1.0 + n1.dot(n2) < KNIFE;+ // The one radius, where the size is one radius (a chord or a law has none).+ let fixed = match size_law {+ Size::Constant(r) => Some(r),+ _ => None,+ };+ // The blend's scale where the size itself is not what matters (the knife edge's probe): the+ // radius asked for, or the law's middle value.+ let scale = match size_law {+ Size::Constant(r) | Size::Chord(r) => r,+ Size::Law(law) => law.eval(0.5).max(1e-6),+ };let (convex, cusp) = if knife {let w = n1.cross(t1).normalized().ok_or_else(|| KernelError::Failed("blend: cusp direction".into()))?;// Second order: from the point of face 1 a little way along `w`, face 2's nearest point.- let probe = project(f1, pm + w * r, None)+ let probe = project(f1, pm + w * scale, None).and_then(|(qa, na, _)| s2.first().and_then(|f| project(f, qa, None)).map(|(qb, _, _)| (qb - qa).dot(na))).filter(|depth| depth.abs() > size * 1e-9).ok_or_else(|| unsupported("a knife edge whose faces lie flat on each other"))?;@@ -1008,10 +1255,41 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,if n1.dot(n2) > 1.0 - 1e-6 {return Err(unsupported("blending a smooth edge"));}+ // The chain's arc length, in fractions of its whole, at each station: where the size is one+ // radius it is not read, but the sections take their parameter from it all the same.+ let tables: Vec<Vec<f64>> = chain.iter().map(|e| edge_lengths(e).unwrap_or_else(|| vec![0.0; LENGTH_STEPS + 1])).collect();+ let total: f64 = tables.iter().filter_map(|t| t.last().copied()).sum();+ if !matches!(size_law, Size::Constant(_)) && !(total.is_finite() && total > 1e-12) {+ return Err(unsupported("a zero-length edge of the chain"));+ }+ let total = if total > 1e-12 { total } else { 1.0 };+ let mut cum: Vec<f64> = Vec::with_capacity(n + 1);+ let mut acc = 0.0;+ for table in &tables {+ cum.push(acc);+ acc += table.last().copied().unwrap_or(0.0);+ }+ cum.push(acc);+ // A law that runs around a closed chain meets itself: its two ends must agree there.+ if closed+ && let Size::Law(law) = size_law+ && (law.eval(0.0) - law.eval(1.0)).abs() > 1e-9 * law.radii.iter().copied().fold(1.0_f64, f64::max)+ {+ return Err(KernelError::Invalid("a closed edge chain runs back into itself: give the same radius law at both ends".into()));+ }+ // The law's parameter at `along` of edge `k` (its front to its back).+ let frac_at = |k: usize, along: f64| -> f64 {+ let (Some(table), Some(lo)) = (tables.get(k), cum.get(k)) else { return if k >= n { 1.0 } else { 0.0 } };+ let s = sampled(table, along).unwrap_or(0.0);+ ((lo + s) / total).clamp(0.0, 1.0)+ };+ let sizer = Sizer { size: size_law, tol: tol * 100.0 };// Arcs on a planar side that curve round the ball: its centre runs round them at their// radius less the blend's. Less than nothing is too large; nothing is a pivot.let mut pivots: Vec<Option<Pivot>> = vec![None; n];- for (k, e) in chain.iter().enumerate() {+ 'pivots: for (k, e) in chain.iter().enumerate() {+ // A size that varies along the edge has no one radius to compare a corner's arc with.+ let Some(r) = fixed else { break 'pivots };let Some((o, rho, _)) = circle_of(e, tol * 1e3) else { continue };for side in [1, 2] {let Some(f) = (if side == 1 { side1.get(k) } else { side2.get(k) }).and_then(|i| faces.get(*i)) else { continue };@@ -1032,7 +1310,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,continue;}if rho < r - tol * 1e3 {- return Err(too_large("the blend is larger than a corner radius"));+ return Err(too_large("the blend is larger than a corner radius (site 1257)"));}if (rho - r).abs() > tol * 1e3 {continue;@@ -1145,6 +1423,8 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,Some((from_p3(c.subs(t)), Vec3::new(d.x, d.y, d.z).normalized()?))};let mut vsec: Vec<Section> = Vec::with_capacity(nv);+ // The radius each vertex section was solved at (the closed end of a law: zero).+ let mut vradius: Vec<f64> = Vec::with_capacity(nv);for k in 0..nv {let (p, t) = if k < n {tangent_at(chain.get(k).ok_or_else(|| KernelError::Failed("edge".into()))?, 0.0)@@ -1167,8 +1447,12 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,}let q = pv.c + (p - pv.o);vsec.push(if pv.side == 1 { Section { c: pv.c, q1: pv.o, q2: q } } else { Section { c: pv.c, q1: q, q2: pv.o } });+ vradius.push(fixed.unwrap_or_default());continue;}+ // The law's parameter at this vertex: the front of its edge, or the back of the last+ // edge at an open chain's end.+ let law_s = if k < n { frac_at(k, 0.0) } else { frac_at(n - 1, 1.0) };if at_end {// A plane square to the edge holds the blend's end section. Any other end face: the// blend runs on past the end and is cut back where it meets that face.@@ -1181,7 +1465,10 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,}_ => false,};- if !square || split_ends.iter().any(|e| e.0 == k) {+ // A radius that has run to zero closes the blend at the vertex itself: it does not run+ // on past the end, and the end face keeps the corner it had there.+ let closed_end = matches!(size_law, Size::Law(law) if law.eval(law_s) <= CLOSED);+ if (!square || split_ends.iter().any(|e| e.0 == k)) && !closed_end {slanted.push((k, fi, p, t, None));}}@@ -1212,7 +1499,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,// longer is (a wall past the round at a corner, which a ball rolling round it pokes// through).let (a1, a2) = edge_sides(&[k.min(n - 1)]);- let s = solve(&a1, &a2, p, t, r, sigma, cusp, extra, tol * 100.0).ok_or_else(|| unsupported("the ball doesn't fit along the edge"))?;+ let (s, r) = sizer.section(&a1, &a2, p, t, law_s, sigma, cusp, extra).ok_or_else(|| sizer.refusal())?;// A seam on the other side too must pass through that side's contact.if let Some((side, seam)) = here.get(1).filter(|_| !at_end) {let q = if *side == 1 { s.q1 } else { s.q2 };@@ -1222,10 +1509,11 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,}}vsec.push(s);+ vradius.push(r);}// Past a slanted end: sections of the same rolling ball beyond the end vertex (far to near// at the chain's start, near to far at its end), far enough to cross the end face.- let mut beyond: Vec<(usize, Vec<Section>)> = Vec::new();+ let mut beyond: Vec<(usize, Vec<Section>, Vec<f64>)> = Vec::new();for (k, fi, p, t, tangent) in slanted.iter_mut() {let g = faces.get(*fi).ok_or_else(|| KernelError::Failed("end face".into()))?;let at = vsec.get(*k).copied().ok_or_else(|| KernelError::Failed("section".into()))?;@@ -1250,12 +1538,16 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,if cos < 0.15 && tangent.is_none() {return Err(unsupported("an end face almost along the edge"));}- let width = at.q1.dist(*p).max(at.q2.dist(*p)).max(at.c.dist(*p)) + r;+ let width = at.q1.dist(*p).max(at.q2.dist(*p)).max(at.c.dist(*p)) + vradius.get(*k).copied().unwrap_or(scale);let reach = 1.5 * width / if tangent.is_some() { 1.0 } else { cos };let out = if *k == 0 { -*t } else { *t };+ // The run on past the end only gives the fit its context (the end face cuts it back), but+ // it keeps the law's end slope: the radius is read at the distance past the end.+ let law_s = |d: f64| if *k == 0 { -d / total } else { 1.0 + d / total };// Past a tangent end the straight run along the tangent leaves the curved spine: where// the ball no longer fits, the run is shortened (it only gives the fit its context).let mut list = Vec::with_capacity(EXTENSION);+ let mut laws = Vec::with_capacity(EXTENSION);let mut reach = reach;// Past the end of a curved edge the planes square to its end tangent cut the ring of// centres further and further round it, until a step jumps across the ring (#1255: a@@ -1263,26 +1555,33 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,// then, as long as one of its sections still lies wholly past the end face.let ng_out = if ng.dot(out) < 0.0 { -ng } else { ng };let past = |sec: &Section| [sec.c, sec.q1, sec.q2].iter().all(|x| (*x - *p).dot(ng_out) > tol);- let mut fallback: Option<Vec<Section>> = None;+ // A run shortened when its centres jump across the ring (a knuckle's cap circle, #1255)+ // stands if no full-length run works; a size law's own end slope is read at each station's+ // distance past the end.+ let mut fallback: Option<Vec<(f64, Section)>> = None;for attempt in 0..TANGENT_RETRIES {list.clear();+ laws.clear();let step = reach / EXTENSION as f64;let sections = (1..=EXTENSION).map(|j| {- let anchor = *p + out * (step * j as f64);- solve(&e1, &e2, anchor, *t, r, sigma, cusp, None, tol * 100.0)+ let d = step * j as f64;+ let anchor = *p + out * d;+ let s = law_s(d);+ sizer.section(&e1, &e2, anchor, *t, s, sigma, cusp, None).map(|(section, _)| (s, section))});match sections.collect::<Option<Vec<_>>>() {Some(all) => {let smooth = tangent.is_some()- || std::iter::once(at.c).chain(all.iter().map(|s| s.c)).collect::<Vec<_>>().windows(2).all(|w| match w {+ || std::iter::once(at.c).chain(all.iter().map(|(_, s)| s.c)).collect::<Vec<_>>().windows(2).all(|w| match w {[a, b] => a.dist(*b) <= MAX_STEP_STRETCH * step,_ => true,});if smooth {// A shortened run must still cross the end face; else the first,// full-length run stands.- if fallback.is_none() || all.iter().any(past) {- list = all;+ if fallback.is_none() || all.iter().any(|(_, s)| past(s)) {+ list = all.iter().map(|(_, s)| *s).collect();+ laws = all.iter().map(|(s, _)| *s).collect();}break;}@@ -1294,12 +1593,27 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,reach *= if tangent.is_some() { 0.5 } else { 0.75 };}if list.is_empty() {- list = fallback.ok_or_else(|| unsupported("the ball doesn't fit past the end of the edge"))?;+ match fallback {+ // The shortened run stands when the ring's step jumped, whatever its size.+ Some(all) => {+ list = all.iter().map(|(_, s)| *s).collect();+ laws = all.iter().map(|(s, _)| *s).collect();+ }+ // A size asked for beyond what the faces around the end hold is refused as such;+ // one radius past the end is the rolling ball's own failure to fit.+ None => {+ return Err(match size_law {+ Size::Constant(_) => unsupported("the ball doesn't fit past the end of the edge"),+ _ => too_large("the blend is larger than the neighbouring faces (site 1472)"),+ });+ }+ }}if *k == 0 {list.reverse();+ laws.reverse();}- beyond.push((*k, list));+ beyond.push((*k, list, laws));}// Uniform refinement preserves a common spacing across neighbouring patches. Work is// capped: a difficult strip returns an error instead of accepting an inaccurate fit.@@ -1319,12 +1633,12 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,Ok(((start.c - p0).dot(t0), (end.c - p1).dot(t1)))}).collect::<Result<_>>()?;- let section_at = |k: usize, edge: &mt::Edge, along: f64| -> Result<Section> {+ let section_at = |k: usize, edge: &mt::Edge, along: f64| -> Result<(Section, f64)> {let (p, t) = tangent_at(edge, along).ok_or_else(|| KernelError::Failed("tangent".into()))?;let (start, end) = offsets.get(k).copied().ok_or_else(|| KernelError::Failed("section offset".into()))?;let anchor = p + t * (start * (1.0 - along) + end * along);let (a1, a2) = edge_sides(&[k]);- solve(&a1, &a2, anchor, t, r, sigma, cusp, None, tol * 100.0).ok_or_else(|| unsupported("the ball doesn't fit along the edge"))+ sizer.section(&a1, &a2, anchor, t, frac_at(k, along), sigma, cusp, None).ok_or_else(|| sizer.refusal())};let mut samples = SAMPLES.min(max_samples);let (esec, fits) = loop {@@ -1339,18 +1653,34 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,continue;}let mut list = vec![*vsec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?];+ let mut law = vec![frac_at(k, 0.0)];+ let (mut front_beyond, mut back_beyond) = (0usize, 0usize);for j in 1..samples - 1 {- list.push(section_at(k, e, j as f64 / (samples - 1) as f64)?);+ let along = j as f64 / (samples - 1) as f64;+ let (section, _) = section_at(k, e, along)?;+ list.push(section);+ law.push(frac_at(k, along));}list.push(*vsec.get((k + 1) % nv).ok_or_else(|| KernelError::Failed("section".into()))?);- for (kv, ext) in &beyond {+ law.push(frac_at(k, 1.0));+ for (kv, ext, exts) in &beyond {if *kv == k && k == 0 {list.splice(0..0, ext.iter().copied());+ law.splice(0..0, exts.iter().copied());+ front_beyond = ext.len();} else if *kv == k + 1 && k + 1 == nv - 1 {list.extend(ext.iter().copied());+ law.extend(exts.iter().copied());+ back_beyond = ext.len();}}- guides.push(Some(Guide::new(list)?));+ let mut guide = Guide::with_law(list, law)?;+ // The chain's own run: the spliced sections at either end are context for the fit+ // only (the blend is cut back where it meets the end face there).+ let last = guide.lengths.last().copied().unwrap_or(0.0);+ let at = |i: usize| if last > 0.0 { guide.lengths.get(i).copied().unwrap_or(0.0) / last } else { 0.0 };+ guide.span = (at(front_beyond), at(guide.sections.len().saturating_sub(1 + back_beyond)));+ guides.push(Some(guide));}// Intersection curves inherit their leader's piecewise parameter speed. Fitting// those parameters creates oscillations even on a geometrically smooth spine.@@ -1364,9 +1694,11 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,if along == 1.0 {return guide.sections.last().copied().ok_or_else(|| KernelError::Failed("section".into()));}- let (anchor, tangent) = guide.anchor(along).ok_or_else(|| unsupported("degenerate rolling-ball spine"))?;+ let (anchor, tangent, law_s) = guide.anchor_at(along).ok_or_else(|| unsupported("degenerate rolling-ball spine"))?;let (a1, a2) = edge_sides(&[k]);- solve(&a1, &a2, anchor, tangent, r, sigma, cusp, None, tol * 100.0)+ sizer+ .section(&a1, &a2, anchor, tangent, law_s, sigma, cusp, None)+ .map(|(section, _)| section).ok_or_else(|| unsupported("the ball doesn't fit along the resampled spine"))};let esec: Vec<Vec<Section>> = (0..n)@@ -1432,6 +1764,8 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,(Some(b), Some(a)) => crate::guard("fit curve blend", || fit_strip(list, &b, &a, round))?,_ => crate::guard("fit curve blend", || fit_sections(&esec, k, closed, round))?,};+ let mut fit = fit;+ fit.span = guides.get(k).and_then(Option::as_ref).map(|g| g.span).unwrap_or((0.0, 1.0));fits.push(Some(fit));}let mut accurate = true;@@ -1440,6 +1774,14 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,for j in 0..samples - 1 {for fraction in [0.25, 0.5, 0.75] {let along = (j as f64 + fraction) / (samples - 1) as f64;+ // A size that varies along the edge reaches past its ends only for the fit's+ // context (the end face cuts that away), so it is not held to the tolerance+ // there. One radius keeps the check it always had, the whole strip.+ if !matches!(size_law, Size::Constant(_))+ && fits.get(k).and_then(Option::as_ref).is_some_and(|f| along < f.span.0 || along > f.span.1)+ {+ continue;+ }let section = uniform_section(k, along)?;if !crate::guard("check curve blend fit", || Ok(section_fits(fit, §ion, along, round, sigma, fit_tolerance)))? {accurate = false;@@ -1515,7 +1857,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,&& n == 1&& !(s1 + 1e-6 < *e1 && s2 + 1e-6 < *e2){- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 1668)"));}crate::guard("curve blend", || {let fail = |m: &str| KernelError::Failed(format!("curve blend: {m}"));@@ -1530,6 +1872,18 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,*b = builder::vertex(curve.subs(hi));}}+ // A closed section (a radius that has run to zero) has one vertex for both contacts, so+ // the blend face's wire and the side faces' meet there.+ for (k, s) in vsec.iter().enumerate() {+ if !closed_section(s) {+ continue;+ }+ if let Some(v) = v1.get(k).cloned()+ && let Some(slot) = v2.get_mut(k)+ {+ *slot = v;+ }+ }// Along a pivot the planar side's contact is one point: one vertex at both its ends.for (k, pv) in pivots.iter().enumerate() {let Some(pv) = pv else { continue };@@ -1557,18 +1911,28 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,}}}- let mut arcs = Vec::with_capacity(nv);+ // The section's own radius, where the blend is sized by a law or a chord width (`r` is the+ // one radius of a constant blend, exactly as before).+ let rad = |s: &Section| match size_law {+ Size::Constant(r) => r,+ Size::Chord(_) | Size::Law(_) => s.c.dist(s.q1),+ };+ let mut arcs: Vec<Option<mt::Edge>> = Vec::with_capacity(nv);let mut split_arcs: HashMap<usize, Vec<mt::Edge>> = HashMap::new();for (k, s) in vsec.iter().enumerate() {let (a, b) = (v1.get(k).ok_or_else(|| fail("vertex"))?, v2.get(k).ok_or_else(|| fail("vertex"))?);- let e = if round {- let m = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("arc"))? * r;- builder::circle_arc(a, b, p3(m))+ // A closed section has no arc to run between the contacts: the blend meets itself+ // there, at the edge's end point.+ let e = if closed_section(s) {+ None+ } else if round {+ let m = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("arc"))? * rad(s);+ Some(builder::circle_arc(a, b, p3(m)))} else {- builder::line(a, b)+ Some(builder::line(a, b))};let e = match caps.iter().find(|c| c.0 == k) {- Some((_, _, _, _, curve)) => mt::Edge::try_new(a, b, curve.clone()).map_err(|e| fail(&e.to_string()))?,+ Some((_, _, _, _, curve)) => Some(mt::Edge::try_new(a, b, curve.clone()).map_err(|e| fail(&e.to_string()))?),None => e,};if let Some((_, _, c)) = split_caps.iter().find(|cap| cap.0 == k) {@@ -1581,7 +1945,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,let oriented = |mut surface: mt::Surface, list: &[Section]| -> Result<mt::Surface> {use mt::{ParametricSurface3D, SearchNearestParameter};let s = list.get(list.len() / 2).ok_or_else(|| fail("section"))?;- let mid = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("mid"))? * r;+ let mid = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("mid"))? * rad(s);if let Some((u, v)) = surface.search_nearest_parameter(p3(mid), None, 100) {let nn = surface.normal(u, v);let want = (s.c - mid) * sigma;@@ -1688,7 +2052,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,.filter(|f| f.edge_iter().any(|e| e.id() == id)).any(|f| crate::blend::plane_normal(f).is_some() && crate::blend::extension_fits(f, from_p3(old.point()), q, tol));if !fits || !crate::blend::on_extension(&seam, q, on_tol) {- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 1853)"));}}seam_subst.insert(id, crate::blend::retarget(&seam, &old, &nv, on_tol)?);@@ -1708,7 +2072,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,let (ta, oa) = a.as_ref().map(at).unwrap_or((0.0, 0.0));let (tb, ob) = b.as_ref().map(at).unwrap_or((1.0, 0.0));if oa > size * 1e-5 || ob > size * 1e-5 || ta < -1e-9 || tb > 1.0 + 1e-9 || tb - ta < 1e-6 {- return Err(too_large("the blend is larger than the neighbouring faces"));+ return Err(too_large("the blend is larger than the neighbouring faces (site 1873)"));}let a = a.unwrap_or_else(|| seam.front().clone());let b = b.unwrap_or_else(|| seam.back().clone());@@ -1723,7 +2087,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,if corners.iter().any(|k| split_arcs.contains_key(k)) {let connectors: Vec<mt::Edge> = corners.iter()- .flat_map(|k| split_arcs.get(k).cloned().unwrap_or_else(|| arcs.get(*k).cloned().into_iter().collect()))+ .flat_map(|k| split_arcs.get(k).cloned().unwrap_or_else(|| arcs.get(*k).cloned().flatten().into_iter().collect())).collect();let rebuilt = crate::blend::rebuild_face(f, &seam_subst, &connectors)?;rec.face(&rebuilt, f);@@ -1754,8 +2118,11 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,es.push(ne.clone());}if let Some(k) = arrives {- let arc = arcs.get(k).ok_or_else(|| fail("arc"))?;- let (a1, a2) = (v1.get(k).ok_or_else(|| fail("vertex"))?, v2.get(k).ok_or_else(|| fail("vertex"))?);+ // A closed section has no blend arc at the corner: the blend ends at+ // the vertex itself and the end face keeps the corner it had.+ let (Some(arc), Some(a1), Some(a2)) = (arcs.get(k).and_then(Option::as_ref), v1.get(k), v2.get(k)) else {+ continue;+ };let to = if used_up { e.front() } else { ne.back() };let corner = if to == a1 {arc.clone()@@ -1810,9 +2177,11 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,}// Blend faces: each runs its side-1 contact the other way from side 1's face.for (k, bf) in blends.iter().enumerate() {- let (Some(e1), Some(e2), Some(ak), Some(ak1)) = (c1.get(k), c2.get(k), arcs.get(k), arcs.get((k + 1) % nv)) else {+ let (Some(e1), Some(e2)) = (c1.get(k), c2.get(k)) else {return Err(fail("blend"));};+ let ak = arcs.get(k).and_then(Option::as_ref);+ let ak1 = arcs.get((k + 1) % nv).and_then(Option::as_ref);let f1i = side1.get(k).ok_or_else(|| fail("side"))?;let f1 = faces.get(*f1i).ok_or_else(|| fail("side"))?;let chain_e = chain.get(k).ok_or_else(|| fail("edge"))?;@@ -1824,20 +2193,23 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,.map(|e| e.front() == chain_e.front()).ok_or_else(|| fail("edge use"))?;// Side 1 runs the contact forward (as the chain) when it ran the edge forward.- // A pivot's planar contact is a point: three sides.- let edges = if used_fwd {- [e1.as_ref().map(|e| e.inverse()), Some(ak.clone()), e2.clone(), Some(ak1.inverse())]+ // A pivot's planar contact is a point: three sides. A closed section has no arc: two.+ let edges: Vec<mt::Edge> = if used_fwd {+ [e1.as_ref().map(|e| e.inverse()), ak.cloned(), e2.clone(), ak1.map(|e| e.inverse())]} else {- [e1.clone(), Some(ak1.clone()), e2.as_ref().map(|e| e.inverse()), Some(ak.inverse())]+ [e1.clone(), ak1.cloned(), e2.as_ref().map(|e| e.inverse()), ak.map(|e| e.inverse())]}.into_iter().flatten()- .collect::<Vec<_>>();+ .collect();+ // An arc the chamfer crossed is two lines through the crossing: the blend meets the+ // shortened seam there.let wire: mt::Wire = edges.into_iter().flat_map(|e| {let split = [(k, ak), ((k + 1) % nv, ak1)].into_iter()+ .filter_map(|(i, arc)| arc.map(|arc| (i, arc.clone()))).find(|(_, arc)| arc.id() == e.id()).and_then(|(i, arc)| split_arcs.get(&i).map(|parts| (arc, parts)));match split {@@ -1861,8 +2233,15 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,#[path = "curvecorner.rs"]mod corner;+pub(crate) use corner::corner_blend_style;+// The planar corner builder the G2 corner work left in place of `corner_blend_style`'s sphere.+#[allow(unused_imports)]pub(crate) use corner::corner_blend;#[cfg(test)]#[path = "curveblend_tests.rs"]mod tests;++#[cfg(test)]+#[path = "curveblend_law_tests.rs"]+mod law_tests;diff --git a/crates/kernel/src/curveblend_law_tests.rs b/crates/kernel/src/curveblend_law_tests.rsnew file mode 100644index 0000000000..f9d5195d9f--- /dev/null+++ b/crates/kernel/src/curveblend_law_tests.rs@@ -0,0 +1,315 @@+//! Chord-width and radius-law blends along curved edges: the width across the blend at every+//! station, and the radius along the edge, measured on the body the kernel built against values+//! worked out from the input geometry alone (the two cylinders' axes, the arc's axis).++use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};+use solidcraft_geom::Vec3;++use super::*;+use crate::blend::vtx;+use crate::blend_variable::{RadiusSpline, fillet_chord, fillet_variable, fillet_variable_points, fillet_variable_spline};+use crate::{Body, BoolOp, boolean, box_solid, cylinder, fillet, measure, step_export};++/// An oblique boss: a rod of radius 8 whose axis leans 26.57° from the plate's normal, standing on+/// a 5 mm plate. The edge where its side meets the plate's top plane is an ellipse whose two faces+/// run from 63° to 117° apart around it.+fn oblique_boss() -> (Body, Vec3, Vec3) {+ let plate = box_solid(Vec3::new(-40.0, -40.0, 0.0), Vec3::new(40.0, 40.0, 5.0)).unwrap();+ let base = Vec3::new(0.0, 0.0, -10.0);+ let axis = Vec3::new(0.5, 0.0, 1.0).normalized().unwrap();+ let rod = cylinder(base, axis, 8.0, 30.0).unwrap();+ (boolean(&plate, &rod, BoolOp::Union).unwrap().unwrap(), base, axis)+}++/// A 40 × 40 × 20 box whose front wall is an arc of radius 40 about a Z axis: `concave` cuts a+/// cylinder away from the front (the wall curves into the part), otherwise the part is the box+/// within the cylinder (the wall curves out). With the bottom arc's midpoint, the axis's base+/// point and the side of the wall the material is on (+1 away from the axis, −1 toward it).+fn arc_walled_box(concave: bool) -> (Body, Vec3, Vec3, f64) {+ let block = box_solid(Vec3::ZERO, Vec3::new(40.0, 40.0, 20.0)).unwrap();+ let (axis, op, side) =+ if concave { (Vec3::new(20.0, -30.0, 0.0), BoolOp::Cut, 1.0) } else { (Vec3::new(20.0, 70.0, 0.0), BoolOp::Intersect, -1.0) };+ let tool = cylinder(axis, Vec3::Z, 40.0, 20.0).unwrap();+ let body = boolean(&block, &tool, op).unwrap().unwrap();+ (body, axis + Vec3::new(0.0, side * 40.0, 0.0), axis, side)+}++/// The blend face a blend built over `input`: the fitted surface that is on neither of the faces+/// it runs between (a boolean leaves the curved faces it kept as fitted surfaces themselves).+fn blend_face(input: &Body, body: &Body) -> Option<mt::Face> {+ use mt::ParametricSurface;+ let on_input = |p: Vec3| input.solid.face_iter().any(|f| project(f, p, None).is_some_and(|(q, _, _)| q.dist(p) <= 1e-6));+ body.solid+ .face_iter()+ .filter(|f| matches!(f.oriented_surface(), mt::Surface::NurbsSurface(_)))+ .find(|f| !on_input(from_p3(f.surface().subs(0.5, 0.5))))+ .cloned()+}++/// The edges of the blend face's boundary, each once, with the point at the middle of it (the+/// blend is bounded by its two contacts and, at each end, an arc or the curve of an end face).+fn blend_boundary(input: &Body, body: &Body) -> Vec<(mt::Edge, Vec3)> {+ let Some(f) = blend_face(input, body) else { return Vec::new() };+ let mut out: Vec<(mt::Edge, Vec3)> = Vec::new();+ for w in f.absolute_boundaries() {+ for e in w.edge_iter() {+ if out.iter().any(|(x, _)| x.id() == e.id()) {+ continue;+ }+ let c = e.oriented_curve();+ let (lo, hi) = c.range_tuple();+ out.push((e.absolute_clone(), from_p3(c.subs((lo + hi) * 0.5))));+ }+ }+ out+}++/// The edges of a contact: the boundary of the blend face whose middle point `side` picks out.+fn contact(input: &Body, body: &Body, side: &dyn Fn(Vec3) -> bool) -> Vec<mt::Edge> {+ blend_boundary(input, body).into_iter().filter(|(_, m)| side(*m)).map(|(e, _)| e).collect()+}++/// The fraction of the way along `edge` (its absolute front to its back) of the point of it+/// nearest `q`.+fn along_fraction(edge: &mt::Edge, q: Vec3) -> Option<f64> {+ let e = edge.absolute_clone();+ let c = e.oriented_curve();+ let (lo, hi) = c.range_tuple();+ let steps = 512;+ let mut at = vec![from_p3(c.subs(lo))];+ let mut run = vec![0.0];+ for i in 1..=steps {+ let p = from_p3(c.subs(lo + (hi - lo) * i as f64 / steps as f64));+ run.push(run.last().copied()? + at.last().copied()?.dist(p));+ at.push(p);+ }+ let total = *run.last()?;+ let d = |i: usize| at.get(i).map(|p| p.dist(q)).unwrap_or(f64::INFINITY);+ let hint = (0..=steps).min_by(|x, y| d(*x).total_cmp(&d(*y))).unwrap_or(0);+ let t = c.search_nearest_parameter(p3(q), lo + (hi - lo) * hint as f64 / steps as f64, 100)?;+ let i = (((t - lo) / (hi - lo)) * steps as f64).clamp(0.0, steps as f64);+ let (k, f) = (i.floor() as usize, i.fract());+ let (Some(a), Some(b)) = (run.get(k), run.get((k + 1).min(steps))) else { return None };+ Some((a + (b - a) * f) / total)+}++/// The azimuth of `p` about the Z axis through `axis`.+fn azimuth(axis: Vec3, p: Vec3) -> f64 {+ (p.y - axis.y).atan2(p.x - axis.x)+}++/// The point of the curves running round the Z axis through `axis` at the azimuth `phi`.+fn at_azimuth(edges: &[mt::Edge], axis: Vec3, phi: f64) -> Option<Vec3> {+ let off = |p: Vec3| {+ let mut d = azimuth(axis, p) - phi;+ while d > std::f64::consts::PI {+ d -= std::f64::consts::TAU;+ }+ while d < -std::f64::consts::PI {+ d += std::f64::consts::TAU;+ }+ d+ };+ let (mut best, mut best_d) = (Vec3::ZERO, f64::INFINITY);+ for e in edges {+ let c = e.oriented_curve();+ let (lo, hi) = c.range_tuple();+ let steps = 512;+ let mut at = lo;+ let mut dist = f64::INFINITY;+ for i in 0..=steps {+ let t = lo + (hi - lo) * i as f64 / steps as f64;+ let d = off(from_p3(c.subs(t))).abs();+ if d < dist {+ (at, dist) = (t, d);+ }+ }+ let step = (hi - lo) / steps as f64;+ let (mut x0, mut x1) = ((at - step).max(lo), (at + step).min(hi));+ let g = 0.618_033_988_749_894_9;+ for _ in 0..80 {+ let (a, b) = (x1 - g * (x1 - x0), x0 + g * (x1 - x0));+ if off(from_p3(c.subs(a))).abs() < off(from_p3(c.subs(b))).abs() {+ x1 = b;+ } else {+ x0 = a;+ }+ }+ let t = 0.5 * (x0 + x1);+ let d = off(from_p3(c.subs(t))).abs();+ if d < best_d {+ (best, best_d) = (from_p3(c.subs(t)), d);+ }+ }+ (best_d < 1e-6).then_some(best)+}++/// A chord fillet along the cylinder-into-plane edge of an oblique boss — the two faces run from+/// 63° to 117° apart around it. The blend's chain stops at the seams between the patches a boolean+/// left of the rod's surface, where the end face is tangent to the rod; the cap that cuts the strip+/// back there is only placed for one radius, so a width that varies along the edge is refused+/// rather than approximated (the fixed radius of `fillet` along the same edge rolls).+#[test]+fn a_chord_fillet_along_an_oblique_boss_edge_is_refused() {+ let (body, _, _) = oblique_boss();+ let pick = Vec3::new(7.5 + 8.944_271_909_999_16, 0.0, 5.0);+ // A fixed radius rolls along the same chain: the edge itself is supported.+ assert!(fillet(&body, &[pick], 2.5).is_ok());+ let e = fillet_chord(&body, &[pick], 4.0).unwrap_err();+ assert!(matches!(e, KernelError::TooLarge(_)), "{e}");+}++/// A chord fillet along an arc whose two faces meet at a right angle: the width across the blend+/// is the chord, so the round is the one of radius `chord / √2` (checked against the constant+/// fillet of that radius) and its two contacts are that far apart at every station.+#[test]+fn chord_fillet_along_an_arc_edge() {+ let (chord, r) = (3.0, 3.0 / 2f64.sqrt());+ let (body, mid, axis, _) = arc_walled_box(false);+ let blended = fillet_chord(&body, &[mid], chord).unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ assert_eq!(blended.unmeshed_faces(), 0);+ let plain = fillet(&body, &[mid], r).unwrap();+ let (made, exact) = (measure(&blended).unwrap().volume, measure(&plain).unwrap().volume);+ assert!((made - exact).abs() < exact * 1e-6, "volume {made} vs {exact}");+ // The contact on the plane and the one on the wall at the same azimuth: the width across.+ let plane = contact(&body, &blended, &|m| m.z.abs() < 1e-6);+ let wall = contact(&body, &blended, &|m| m.z.abs() >= 1e-6);+ assert!(!plane.is_empty() && !wall.is_empty(), "the contacts are not the plane's and the wall's");+ let mid_azimuth = azimuth(axis, mid);+ let mut worst: f64 = 0.0f64;+ let mut stations = 0;+ for i in 1..12 {+ let phi = mid_azimuth + (i as f64 / 12.0 - 0.5) * 0.9;+ let (Some(p), Some(w)) = (at_azimuth(&plane, axis, phi), at_azimuth(&wall, axis, phi)) else { continue };+ stations += 1;+ worst = worst.max((p.dist(w) - chord).abs());+ }+ eprintln!("arc chord {chord}: worst width error {worst:.6} mm at {stations} stations");+ assert!(stations >= 9, "only {stations} stations measured");+ assert!(worst < 0.01, "the width across the blend is {worst} mm off the chord {chord}");+}++/// A chord fillet on a straight edge between planar faces is still the exact local round: the+/// same body, bit for bit, as the fillet of the radius the chord gives (a right angle: chord c is+/// r = c / √2).+#[test]+fn chord_fillet_on_a_straight_edge_is_unchanged() {+ let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();+ let (at, chord) = (Vec3::new(10.0, 10.0, 30.0), 4.0);+ let f = fillet_chord(&b, &[at], chord).unwrap();+ let k = fillet(&b, &[at], chord / 2f64.sqrt()).unwrap();+ assert_eq!(step_export(&[&f], "part").unwrap(), step_export(&[&k], "part").unwrap());+ assert_eq!(f.unmeshed_faces(), 0);+}++/// A variable radius along an arc edge: a ball whose radius is the law's at each station's fraction+/// of the edge's length rolls along it, and the setback on the planar face — the plane and the+/// wall meet at a right angle, so it is the section's radius — follows the law from end to end.+#[test]+fn variable_radius_along_an_arc_edge_follows_the_law() {+ let (body, mid, axis, _) = arc_walled_box(false);+ let edge = crate::surfaces::edge_near(&body, mid).unwrap();+ // Started from the edge's back end: the law runs the other way, as the positions are from the+ // end nearest `start`.+ let start = vtx(edge.absolute_back());+ // A wider law (2 → 4, the radius doubling over the arc) is out of reach of the fitted strip:+ // the sections' own last spans cannot be held to the fit's accuracy there. That is refused,+ // not approximated.+ for wide in [4.0, 5.0] {+ let e = fillet_variable(&body, mid, start, 2.0, wide).unwrap_err();+ assert!(e.to_string().contains("accuracy and section limits"), "2 -> {wide}: {e}");+ }+ let (r0, r1) = (2.0, 3.4);+ let blended = fillet_variable(&body, mid, start, r0, r1).unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ assert_eq!(blended.unmeshed_faces(), 0);+ let law = RadiusSpline::through(&[(0.0, r0), (1.0, r1)], false);+ // The law runs from the end nearest `start`: the chain's front here is the far end.+ let want = if vtx(edge.absolute_back()).dist(start) < vtx(edge.absolute_front()).dist(start) { law.reversed() } else { law.clone() };+ // `start` is the chain's back end, so the law is read back to front there: r0 at the back, r1+ // at the front.+ assert!((want.eval(1.0) - r0).abs() < 1e-12 && (want.eval(0.0) - r1).abs() < 1e-12);+ // The blend's contact on the bottom plane is at 40 − r from the axis.+ let plane = contact(&body, &blended, &|m| m.z.abs() < 1e-6);+ assert!(!plane.is_empty(), "no contact on the bottom plane");+ let mut worst: f64 = 0.0;+ let mut stations = 0;+ let mut shown = Vec::new();+ for e in &plane {+ let c = e.oriented_curve();+ let (lo, hi) = c.range_tuple();+ for i in 0..=32 {+ let p = from_p3(c.subs(lo + (hi - lo) * i as f64 / 32.0));+ let measured = 40.0 - (p - axis).len();+ let along = along_fraction(&edge, p).unwrap();+ // Leave the two ends, where the caps cut the contact: the blend closes on the end+ // faces there.+ if !(0.04..=0.96).contains(&along) {+ continue;+ }+ stations += 1;+ if shown.len() < 3 || (0.45..0.55).contains(&along) {+ shown.push((along, measured, want.eval(along)));+ }+ worst = worst.max((measured - want.eval(along)).abs());+ }+ }+ eprintln!("arc variable {r0} -> {r1}: worst radius error {worst:.6} mm at {stations} stations; law vs measured {shown:?}");+ assert!(stations >= 24, "only {stations} stations measured");+ assert!(worst < 0.02, "the section radius is {worst} mm off the law");+ // Wider, still inside what the strip holds: the same body as the exact straight-edge case of+ // that law is not built here, but the radius is the law's at every station measured.+}++/// A radius law that runs to zero at an end of a curved edge: refused by name. The blend would+/// close to the edge's end point, but the fitted strip pinches to a point there and the last span+/// of it cannot be held to the fit's accuracy: the straight-edge fillet, which closes exactly, is+/// the way (see `variable_radius_down_to_zero_at_one_end`).+#[test]+fn a_law_running_to_zero_along_a_curved_edge_is_refused() {+ let (body, mid, _, _) = arc_walled_box(false);+ let edge = crate::surfaces::edge_near(&body, mid).unwrap();+ for start in [vtx(edge.absolute_front()), vtx(edge.absolute_back())] {+ let e = fillet_variable(&body, mid, start, 3.0, 0.0).unwrap_err();+ assert!(e.to_string().contains("runs to zero along a curved edge"), "{e}");+ let law = RadiusSpline { degree: 1, knots: vec![0.0, 0.0, 1.0, 1.0], radii: vec![0.0, 3.0] };+ assert!(fillet_variable_spline(&body, mid, mid, &law).is_err());+ // A law that stays clear of zero along it rolls: the blend is closed, a three-sided face+ // where nothing closes it.+ let made = fillet_variable(&body, mid, start, 3.0, 2.4).unwrap();+ assert!(made.validity().is_empty(), "{:?}", made.validity());+ let mesh = made.tessellate_with(5e-4, true).unwrap();+ let about = |o: Vec3| {+ mesh.triangles+ .iter()+ .map(|t| (mesh.positions[t[0] as usize] - o).dot((mesh.positions[t[1] as usize] - o).cross(mesh.positions[t[2] as usize] - o)) / 6.0)+ .sum::<f64>()+ };+ assert!((about(Vec3::ZERO) - about(Vec3::new(-100.0, 50.0, 30.0))).abs() < 1e-2, "the mesh is not closed");+ }+}++/// What a chord or a law the local geometry cannot hold is refused with: an error naming the size,+/// never a silent approximation and never a panic.+#[test]+fn a_chord_or_radius_the_faces_cannot_hold_is_refused() {+ let (body, mid, _, _) = arc_walled_box(false);+ // A chord of 30 across a 40 mm wide wall (r ≈ 21, past the side walls and the block).+ let e = fillet_chord(&body, &[mid], 30.0).unwrap_err();+ assert!(matches!(e, KernelError::TooLarge(_)), "{e}");+ assert!(fillet_chord(&body, &[mid], 3.0 / 2f64.sqrt()).is_ok());+ // A radius law too large for the wall.+ assert!(fillet_variable(&body, mid, Vec3::new(0.0, 30.0, 0.0), 2.0, 30.0).is_err());+ assert!(fillet_variable(&body, mid, Vec3::new(0.0, 30.0, 0.0), 20.0, 20.0).is_err());+ // Non-finite, negative and zero-at-both-ends laws: refused before the geometry is touched.+ let bad = |radii: Vec<f64>| RadiusSpline { degree: 1, knots: vec![0.0, 0.0, 1.0, 1.0], radii };+ assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![2.0, f64::NAN])).is_err());+ assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![2.0, f64::INFINITY])).is_err());+ assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![2.0, -1.0])).is_err());+ assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![0.0, 0.0])).is_err());+ assert!(fillet_variable_spline(&body, mid, mid, &RadiusSpline { degree: 1, knots: vec![0.0, 0.5, 1.0], radii: vec![2.0, 3.0] }).is_err());+ assert!(fillet_variable_points(&body, mid, mid, &[(0.0, 2.0), (1.5, 3.0)], false).is_err());+ // An edge the body does not have is refused by name, not approximated.+ assert!(fillet_chord(&body, &[Vec3::new(500.0, 500.0, 500.0)], 3.0).is_err());+}diff --git a/crates/kernel/src/curvecorner.rs b/crates/kernel/src/curvecorner.rsindex 46b943d080..affabdaab3 100644--- a/crates/kernel/src/curvecorner.rs+++ b/crates/kernel/src/curvecorner.rs@@ -25,6 +25,7 @@ use super::{};use crate::blend::{too_large, vtx};use crate::body::{Solid, from_p3, p3, v3};+use crate::bridge::Frame;use crate::record::Rebuild;use crate::{KernelError, Result};@@ -683,9 +684,65 @@ fn connect(from: &mt::Vertex, to: &mt::Vertex, pool: &[(mt::Edge, Vec<Owner>)],Err(fail("a boundary does not close"))}+/// The strip's own station nearest the corner ball `c`: the section where the strip stops against+/// that ball, where its direction of leave and its curvature are read.+fn corner_station(strip: &Strip, c: Vec3) -> Option<f64> {+ strip.sections.iter().min_by(|a, b| a.1.c.dist(c).total_cmp(&b.1.c.dist(c))).map(|x| x.0)+}++/// One side of a G2 corner: the corner ball's own section arc of radius `r` about `c`, from its+/// contact `q_from` to its contact `q_to`, each station carrying the direction the corner patch+/// leaves the blend in (towards the corner's apex) and the blend's own curvature across it, read+/// from `strip` where the ball stops against it. A rolling ball's section is a circular arc about+/// its own centre wherever the edge runs, so this arc is the blend's section curve itself, and its+/// ends are the ball's contacts exactly — the sides close the loop whatever the fit's station+/// spacing is.+fn g2_side(strip: &Strip, c: Vec3, r: f64, q_from: Vec3, q_to: Vec3, apex: Vec3) -> Result<Vec<Frame>> {+ use mt::ParametricSurface;+ /// Stations across one section: enough for the patch's cubic cross-sections, few enough to+ /// keep the corner's own patch small.+ const STATIONS: usize = 9;+ let vec_of = |d: mt::Vector3| Vec3::new(d.x, d.y, d.z);+ let v = corner_station(strip, c).ok_or_else(|| fail("corner section"))?;+ let a = (q_from - c).normalized().ok_or_else(|| fail("corner contact"))?;+ let b = (q_to - c).normalized().ok_or_else(|| fail("corner contact"))?;+ let dot = a.dot(b).clamp(-1.0, 1.0);+ let w = (b - a * dot).normalized().ok_or_else(|| fail("corner contact"))?;+ let theta = dot.acos();+ // The blend's own direction of leave and curvature across the seam, at its corner station.+ let speed = vec_of(strip.surface.vder(0.5, v)).len();+ if !(speed > 1e-30) {+ return Err(unsupported("a corner section of no width"));+ }+ let leave = vec_of(strip.surface.vder(0.5, v)) * (1.0 / speed);+ let bend = vec_of(strip.surface.vvder(0.5, v)) * (1.0 / (speed * speed));+ if !(leave.is_finite() && bend.is_finite() && theta.is_finite() && r.is_finite()) {+ return Err(unsupported("a corner section that is not finite"));+ }+ let mut out = Vec::with_capacity(STATIONS);+ for k in 0..STATIONS {+ let t = theta * k as f64 / (STATIONS - 1) as f64;+ let p = c + (a * t.cos() + w * t.sin()) * r;+ // The patch leaves the blend towards the material the corner caps, so the sign is the one+ // towards the corner's apex (the blends' own v direction runs away from the vertex).+ let leave = if leave.dot(apex - p) < 0.0 { -leave } else { leave };+ if !(p.is_finite() && leave.is_finite() && bend.is_finite()) {+ return Err(unsupported("a corner section that is not finite"));+ }+ out.push(Frame { p, leave, bend, bend_change: Vec3::ZERO });+ }+ Ok(out)+}+/// Blend the edges `ids` of `solid` with radius `r` (a chamfer's distance), rebuilding the/// corners at their ends; with what it built from `solid`.pub(crate) fn corner_blend(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> Result<(Solid, Rebuild)> {+ corner_blend_style(solid, ids, size, r, round, false)+}++/// [`corner_blend`]; with `g2`, the corners where three blends meet are G2 patches+/// ([`crate::corner_g2`]) instead of pieces of the rolling ball's sphere.+pub(crate) fn corner_blend_style(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool, g2: bool) -> Result<(Solid, Rebuild)> {if !(size.is_finite() && size > 0.0 && r.is_finite() && r > 0.0) {return Err(KernelError::Invalid("blend size and radius must be finite and positive".into()));}@@ -1006,6 +1063,33 @@ pub(crate) fn corner_blend(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,let out = (n(f12, q12) + n(f23, q23) + n(f31, q31)).normalized().unwrap_or(Vec3::Z);let side = out.any_perp();let (np, sp, back) = (c + side * r, c - side * r, c - out * r);+ if g2 {+ // A G2 patch on the blends' own end sections, gathered at the ball's pole+ // (the point the sphere's meridians are built through above). Each side is+ // the strip's section through the ball's contact with the face it shares+ // with the previous strip; the strips run on past their edges, so that+ // station is found by projecting the contact point, not taken from the+ // edge's own end.+ let s2 = strip_of(e2)?;+ let s3 = strip_of(e3)?;+ // The cap's own pole: the ball's point nearest the corner (the sphere+ // patch's `back` above is its opposite pole, where the meridian starts).+ let apex = c + out * r;+ // Side 1 runs from the ball's contact with the face it shares with e3+ // round to the one it shares with e2, and so on round the loop: each+ // side's last station is the next side's first, at that contact.+ let sides = [g2_side(s1, c, r, q31, q12, apex)?, g2_side(s2, c, r, q12, q23, apex)?, g2_side(s3, c, r, q23, q31, apex)?];+ let _patch = crate::corner_g2::corner_g2_patch(&sides, apex)?;+ // Sewing the patch into the shell is not done yet: it brings its own+ // boundary vertices where the strips' contacts end at the ball's contacts+ // (`v12`/`v23`/`v31`), and a truck vertex is its allocation, not its point,+ // so the rebuilt shell does not close there (rewrapping the section curves+ // onto the contacts is the missing step). Refused rather than left open:+ // the rolling ball fills the corner instead.+ return Err(unsupported(+ "a G2 corner sewn between these blends (the patch's section curves do not join the blends' contacts yet)",+ ));+ }let meridian = builder::circle_arc(&builder::vertex(p3(np)), &builder::vertex(p3(sp)), p3(back));let surf = mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(meridian.oriented_curve(),diff --git a/crates/kernel/src/emboss.rs b/crates/kernel/src/emboss.rsindex 92c076a066..94acc8c172 100644--- a/crates/kernel/src/emboss.rs+++ b/crates/kernel/src/emboss.rs@@ -442,7 +442,7 @@ fn profile_interval_overlaps(plane: &Plane, regions: &[Region2], o: Vec3, axis:add(p)?;}}- Seg2::Bezier { n, p } if (1..=7).contains(&n) => {+ Seg2::Bezier { n, p } if (1..=solidcraft_geom::MAX_BEZIER_DEGREE as u8).contains(&n) => {for p in p.iter().take(usize::from(n) + 1) {add(*p)?;}diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 22756f874c..daf37d7b79 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -28,7 +28,9 @@ mod boundary;mod bridge;mod build;mod clearance;+mod continuity;mod coplanar;+mod corner_g2;mod curveblend;mod delete_face;#[cfg(test)]@@ -67,6 +69,7 @@ mod issue_871_tests;#[cfg(test)]mod join_between_caps_tests;mod lip;+pub mod loft_blend;mod loopblend;mod matchsurf;mod measure;@@ -123,7 +126,7 @@ mod tspline;mod untouched_faces_tests;pub mod watch;-pub use blend::{ChamferSide, chamfer, chamfer_sides, fillet, fillet_each, fillet_g2, fillet_max, fillet_max_each};+pub use blend::{ChamferSide, chamfer, chamfer_sides, fillet, fillet_each, fillet_g2, fillet_g2_corners, fillet_max, fillet_max_each};pub use blend_corner::fillet_radii;pub use blend_variable::{RadiusSpline, Taper, fillet_chord, fillet_tapered, fillet_variable, fillet_variable_points, fillet_variable_spline, taper};pub use body::{Body, CapSignature, DISPLAY_ANGLE, EdgeInfo, FaceInfo, FacePaint, FaceSource, Paint};@@ -134,6 +137,10 @@ pub use build::{PathSeg, box_solid, canonical_revolve_axis, cylinder, extrude, extrude_tapered, extrude_tapered_between, loft, revolve, sphere, sweep,sweep_with, torus,};+pub use continuity::{+ ContinuityReport, ContinuityTolerances, EdgePick, MAX_SAMPLES, MIN_SAMPLES, SeamReport, SeamVerdict, SeamWorst, pick_edges, seam_diagnostics,+};+pub use corner_g2::{corner_g2_patch, seam_error};pub use delete_face::delete_faces;pub use emboss::{cylinder_emboss_anchor, emboss_cylinder, emboss_cylinder_at, has_cylinder_emboss_wall, infer_cylinder_emboss};pub use fair::{@@ -145,6 +152,7 @@ pub use helix::{loft_to_point, sweep_helix, sweep_helix_mesh};pub use iges_in::{MAX_IGES_BYTES, iges_import, iges_to_step};pub use iges_out::iges_export_bodies;pub use lip::raise_band;+pub use loft_blend::loft_blend;pub use matchsurf::{match_surface, seam_continuity};pub use measure::{BodyMeasure, measure};pub use mesh_convert::convert_prismatic_mesh;diff --git a/crates/kernel/src/loft_blend.rs b/crates/kernel/src/loft_blend.rsnew file mode 100644index 0000000000..2364b200aa--- /dev/null+++ b/crates/kernel/src/loft_blend.rs@@ -0,0 +1,550 @@+//! Multi-section blends: one face that runs through many cross-sections and still leaves the+//! first and last of them the way a support surface wants.+//!+//! The sections run in order along the face's **u**, each sampled at the same `samples` stations+//! along the face's **v**. Section `i` sits at `u = i/(n−1)`, and the face passes through it+//! exactly: its v-curve there is that section's own cross-section curve through its stations.+//! Along v the stations are interpolated by a B-spline of degree `min(3, samples − 1)` — the same+//! interpolation [`crate::bridge`] builds its boundary curves with — so every station of every+//! section lies on the face.+//!+//! Along u the face is a B-spline whose knots are clamped at both ends and repeated at every+//! interior section, so every span is one Bézier; a span's leading control rows are the Hermite+//! rows of `bridge::section` — position, tangent (`leave`), curvature (`bend`) and change of+//! curvature (`bend_change`), scaled to that span's parameter interval. The degree is the largest+//! `c + c′ − 1` over the spans (`c` conditions at the section the span leaves, `c′` at the one it+//! arrives at), and a span whose two ends carry fewer conditions than that is elevated exactly,+//! which moves no point of the curve. A blend of two sections is therefore the [`crate::bridge`]+//! of those two boundaries, only with the two parameters the other way round.+//!+//! **The first and last section** take their tangent, curvature and change of curvature from the+//! caller's frames, exactly as a bridge takes them from a support surface's boundary, and hold+//! them to the requested [`Continuity`] (G0 up to G3). The `leave` direction of the last section's+//! frames points back into the blend, towards the interior, as a bridge's far boundary does.+//!+//! **Interior sections** take nothing from the caller's frames but their positions: the run+//! direction's tangent there is the secant of the two neighbouring sections' stations, its+//! curvature their second difference and its change of curvature their third difference, all+//! along the run. The two spans that meet at such a section are given exactly those rows, so they+//! agree in ∂/∂u, ∂²/∂u² and ∂³/∂u³ there and the joint is **C³** in the run parameter (hence G³)+//! whenever a fourth station is there to take the third difference over — that is, whenever the+//! blend runs through at least four sections. A blend of exactly three sections has only its one+//! interior section's two neighbours to read, so no third difference can be taken: the interior+//! section then keeps position, tangent and curvature only and its joint is **C²** (G²). Dropping+//! interior conditions, never the surface, is also how this blend stays within+//! [`MAX_SPLINE_DEGREE`]: a section family asks for at most `c + c′ − 1 ≤ 7` at the four conditions+//! a section can carry today, and a caller that ever asked for more would lose interior+//! conditions (change of curvature first, then curvature, then tangent) rather than fail.+//!+//! `crown` scales how fast the face leaves the first and the last section (0 the plain blend, up+//! to 3 fuller, down to −0.9 flatter), exactly as a bridge's crown does. It shapes the middle of+//! each end span and leaves every joint's conditions alone.++use solidcraft_geom::Vec3;+use solidcraft_geom::bspline::{CurveN, HPoint, MAX_SPLINE_DEGREE, NurbsSurface};+use truck_modeling as mt;+use truck_modeling::{ParametricSurface3D, SearchNearestParameter};++use crate::body::{Body, from_p3, p3};+use crate::bridge::{Continuity, Frame};+use crate::surfaces::surface_body;+use crate::{KernelError, Result, guard};++/// Most cross-sections one blend may run through.+pub const MAX_BLEND_SECTIONS: usize = 50;+/// Fewest stations one cross-section may be sampled at (a straight line across it).+pub const MIN_BLEND_STATIONS: usize = 2;+/// Most stations one cross-section may be sampled at. The control net (and the interpolation that+/// builds it) grows with the station count, and no cross-section curve needs more than this.+pub const MAX_BLEND_STATIONS: usize = 257;++/// How many rows of the control net one interpolation solve carries at a time: a row is three+/// coordinates, so this many rows are solved together.+const ROWS_PER_SOLVE: usize = 16;++/// A blend surface through `sections`, in order, that leaves the first and the last of them with+/// the continuity their frames ask for.+///+/// Each section is one cross-section: `samples` stations (`samples` must match every section's+/// length, so that the stations correspond from one section to the next). Section `i` is+/// interpolated at `u = i/(n−1)`, and its stations run along `v`, so the face of the body holds+/// every station of every section. `orders[0]` and `orders[1]` are what the face holds at the+/// first and the last section, read from their frames; the interior sections join the face+/// smoothly by finite differences along the run (see the module comment for the order each joint+/// holds). `crown` scales how fast the face leaves the first (`crown[0]`) and the last+/// (`crown[1]`) section and must be within −0.9 and 3.+///+/// Refused, without ever panicking: fewer than 2 or more than [`MAX_BLEND_SECTIONS`] sections,+/// sections of unequal station counts or a `samples` below [`MIN_BLEND_STATIONS`] or above+/// [`MAX_BLEND_STATIONS`], a frame that is not finite or a `leave` with no direction, a crown+/// outside its range, and two neighbouring sections that meet at a station (no room for a blend).+pub fn loft_blend(sections: &[Vec<Frame>], orders: [Continuity; 2], crown: [f64; 2], samples: usize) -> Result<Body> {+ let blend = Blend::new(sections, orders, crown, samples)?;+ let net = blend.net()?;+ guard("loft blend surface", || crate::spline_conv::tensor_face(&net).map(|f| surface_body(vec![f])))+}++/// The frames of one cross-section picked as an edge chain of a body, sampled at `stations`+/// stations: the chain itself, with the neighbouring face's tangent plane, curvature vector and+/// change of curvature read along `leave` — the direction the blend runs on from this section —+/// exactly as [`crate::bridge::frames`] reads a support surface's own boundary.+///+/// Hand the result to [`loft_blend`] as one section. The face the section repeats is the body's+/// face that holds the whole chain and faces the run best; `leave` must have a part in that face's+/// tangent plane (a direction normal to it has no tangent plane to leave in). The last section's+/// `leave` runs back into the blend, towards the section before it.+pub fn section_frames(body: &Body, edges: &[Vec3], leave: Vec3, stations: usize) -> Result<Vec<Frame>> {+ guard("loft blend section", || {+ let chain = crate::bridge::chain(body, edges)?;+ let leave =+ leave.normalized().filter(|l| l.is_finite()).ok_or_else(|| KernelError::Invalid("the leave direction must be a finite vector".into()))?;+ let first = chain.first().ok_or_else(|| KernelError::Failed("loft blend: no chain".into()))?;+ let mid = (from_p3(first.front().point()) + from_p3(first.back().point())) * 0.5;+ // The face the chain lies on that the blend leaves through: the one whose tangent plane+ // holds as much of `leave` as possible.+ let mut best: Option<(f64, mt::Face)> = None;+ for face in body.solid.face_iter() {+ if !chain.iter().all(|e| face.edge_iter().any(|f| f.id() == e.id())) {+ continue;+ }+ let surf = face.surface();+ let Some((u, v)) = surf.search_nearest_parameter(p3(mid), None, 100) else { continue };+ let normal = surf.normal(u, v);+ let n = Vec3::new(normal.x, normal.y, normal.z).normalized().unwrap_or(Vec3::ZERO);+ let score = (leave - n * leave.dot(n)).len();+ if best.as_ref().is_none_or(|(b, _)| score > *b) {+ best = Some((score, face.clone()));+ }+ }+ let (score, face) = best.ok_or_else(|| KernelError::Invalid("no face of the body holds the picked edges".into()))?;+ if score < 0.2 {+ return Err(KernelError::Invalid("the direction towards the next section lies in no face at the picked edges".into()));+ }+ crate::bridge::frames(&face, &chain, leave, stations)+ })+}++/// What the face has to do at one section: where it is, and the run direction's first, second and+/// third derivatives at each of the section's stations. The third is carried only when the+/// section holds a change-of-curvature condition.+struct Shape {+ p: Vec<Vec3>,+ d1: Vec<Vec3>,+ d2: Vec<Vec3>,+ d3: Option<Vec<Vec3>>,+}++/// The blend's inputs, validated, with the conditions and the run direction's degree worked out.+struct Blend<'a> {+ sections: &'a [Vec<Frame>],+ crown: [f64; 2],+ samples: usize,+ run: usize,+ /// The run parameter interval between two neighbouring sections: `1/(run − 1)`.+ step: f64,+ degree: usize,+ /// Conditions held at each section, one per control row of the spans that end there.+ conditions: Vec<usize>,+}++impl<'a> Blend<'a> {+ fn new(sections: &'a [Vec<Frame>], orders: [Continuity; 2], crown: [f64; 2], samples: usize) -> Result<Blend<'a>> {+ if !(MIN_BLEND_STATIONS..=MAX_BLEND_STATIONS).contains(&samples) {+ return Err(KernelError::Invalid(format!(+ "a blend needs {MIN_BLEND_STATIONS} to {MAX_BLEND_STATIONS} stations per cross-section, not {samples}"+ )));+ }+ let run = sections.len();+ if !(2..=MAX_BLEND_SECTIONS).contains(&run) {+ return Err(KernelError::Invalid(format!("a blend runs through 2 to {MAX_BLEND_SECTIONS} cross-sections, not {run}")));+ }+ for c in crown {+ if !c.is_finite() || !(-0.9..=3.0).contains(&c) {+ return Err(KernelError::Invalid("a blend's crown must be between -0.9 and 3".into()));+ }+ }+ for (i, section) in sections.iter().enumerate() {+ if section.len() != samples {+ return Err(KernelError::Invalid(format!(+ "every cross-section of a blend must be sampled at the same {samples} stations (section {i} has {})",+ section.len()+ )));+ }+ for (s, f) in section.iter().enumerate() {+ if ![f.p, f.leave, f.bend, f.bend_change].into_iter().all(Vec3::is_finite) {+ return Err(KernelError::Invalid(format!("the frame at section {i}, station {s} is not finite")));+ }+ if f.leave.normalized().is_none() {+ return Err(KernelError::Invalid(format!("the leave direction at section {i}, station {s} is zero")));+ }+ }+ }+ // The face runs from one section to the next: where two of them meet at a station there is+ // no room for a blend between them.+ for i in 0..run - 1 {+ for s in 0..samples {+ if !(point(sections, i, s)?.dist(point(sections, i + 1, s)?) > 1e-9) {+ return Err(KernelError::Invalid(format!("sections {} and {} meet at station {s}: there is no room for a blend", i + 1, i + 2)));+ }+ }+ }+ // The ends hold what their orders ask for. An interior section would like all four+ // conditions (position, tangent, curvature, change of curvature); where no fourth station+ // is there to take the third difference over it keeps the three its neighbours can give,+ // and its joint is C² instead of C³.+ let mut conditions = vec![2usize; run];+ if let Some(slot) = conditions.first_mut() {+ *slot = orders[0].conditions();+ }+ if let Some(slot) = conditions.last_mut() {+ *slot = orders[1].conditions();+ }+ for i in 1..run.saturating_sub(1) {+ if let Some(slot) = conditions.get_mut(i) {+ *slot = if third_difference_available(i, run) { 4 } else { 3 };+ }+ }+ // The run direction's degree is the largest `c + c′ − 1` of a span. Four conditions a+ // section is at most what a section can carry, so this fits today; should a caller ever+ // ask for more, the interior joints give up conditions rather than the blend failing.+ let mut degree = span_degree(&conditions);+ while degree > MAX_SPLINE_DEGREE {+ let next = (1..run.saturating_sub(1))+ .filter(|&i| conditions.get(i).is_some_and(|&c| c > 1))+ .max_by_key(|&i| conditions.get(i).copied().unwrap_or(0));+ let Some(i) = next else { break };+ if let Some(c) = conditions.get_mut(i) {+ *c = c.saturating_sub(1);+ }+ degree = span_degree(&conditions);+ }+ if degree == 0 || degree > MAX_SPLINE_DEGREE {+ return Err(KernelError::Failed("loft blend: the requested continuity needs a degree above the kernel's".into()));+ }+ Ok(Blend { sections, crown, samples, run, step: 1.0 / (run - 1) as f64, degree, conditions })+ }++ /// What the face has to do at section `i`: the run direction's derivatives at every station.+ fn shape(&self, i: usize) -> Result<Shape> {+ let samples = self.samples;+ let p: Vec<Vec3> = (0..samples).map(|s| point(self.sections, i, s)).collect::<Result<Vec<_>>>()?;+ let conditions = self.conditions.get(i).copied().unwrap_or(1);+ let mut d1 = vec![Vec3::ZERO; samples];+ let mut d2 = vec![Vec3::ZERO; samples];+ let mut d3 = (conditions >= 4).then(|| vec![Vec3::ZERO; samples]);+ if i == 0 {+ for s in 0..samples {+ let f = frame(self.sections, 0, s)?;+ let leave = f.leave.normalized().ok_or_else(|| KernelError::Failed("loft blend: the leave direction".into()))?;+ // The speed a bridge gives a boundary: a third of the station's chord to the+ // section it leaves for, the crown, over this span's parameter interval.+ let speed = f.p.dist(point(self.sections, 1, s)?) / 3.0 * (1.0 + self.crown[0]) / self.step;+ if let (Some(v1), Some(v2)) = (d1.get_mut(s), d2.get_mut(s)) {+ *v1 = leave * speed;+ *v2 = f.bend * (speed * speed);+ }+ }+ } else if i + 1 == self.run {+ for s in 0..samples {+ let f = frame(self.sections, i, s)?;+ let leave = f.leave.normalized().ok_or_else(|| KernelError::Failed("loft blend: the leave direction".into()))?;+ let speed = f.p.dist(point(self.sections, i - 1, s)?) / 3.0 * (1.0 + self.crown[1]) / self.step;+ if let (Some(v1), Some(v2)) = (d1.get_mut(s), d2.get_mut(s)) {+ // The run leaves the last section outwards; the caller's frames there point+ // back into it, so the odd derivatives turn round.+ *v1 = leave * -speed;+ *v2 = f.bend * (speed * speed);+ }+ }+ } else {+ let h = self.step;+ for s in 0..samples {+ let before = point(self.sections, i - 1, s)?;+ let here = point(self.sections, i, s)?;+ let after = point(self.sections, i + 1, s)?;+ if let (Some(v1), Some(v2)) = (d1.get_mut(s), d2.get_mut(s)) {+ *v1 = (after - before) * (1.0 / (2.0 * h));+ *v2 = (after - here * 2.0 + before) * (1.0 / (h * h));+ }+ }+ }+ // The change of curvature: the caller's bend_change at an end, a third difference of the+ // neighbouring sections at an interior one.+ if let Some(third) = d3.as_mut() {+ for s in 0..samples {+ let (Some(&a), Some(&b)) = (d1.get(s), d2.get(s)) else {+ return Err(KernelError::Failed("loft blend: a section's derivatives".into()));+ };+ let value = if i == 0 {+ let f = frame(self.sections, 0, s)?;+ third_derivative(a, b, f.bend_change)?+ } else if i + 1 == self.run {+ let f = frame(self.sections, i, s)?;+ -third_derivative(-a, b, f.bend_change)?+ } else {+ self.third_difference(i, s)?+ };+ if let Some(slot) = third.get_mut(s) {+ *slot = value;+ }+ }+ }+ Ok(Shape { p, d1, d2, d3 })+ }++ /// The third difference of the sections' stations at an interior section: the estimate of how+ /// the curvature vector changes along the run. `i` is an interior section, and the neighbours+ /// reach far enough for a stencil (see [`third_difference_available`]).+ fn third_difference(&self, i: usize, s: usize) -> Result<Vec3> {+ let h = self.step;+ let cube = h * h * h;+ let before = i.checked_sub(2);+ let value = match (before, i + 2 < self.run) {+ // Both sides: the symmetric five-point difference.+ (Some(k), true) => {+ (point(self.sections, i + 2, s)? - point(self.sections, i + 1, s)? * 2.0 + point(self.sections, i - 1, s)? * 2.0+ - point(self.sections, k, s)?)+ * (1.0 / (2.0 * cube))+ }+ // Only ahead: the forward four-point stencil at the second of them.+ (None, true) => {+ (point(self.sections, i + 2, s)? - point(self.sections, i + 1, s)? * 3.0 + point(self.sections, i, s)? * 3.0+ - point(self.sections, i - 1, s)?)+ * (1.0 / cube)+ }+ // Only behind: the same the other way round.+ (Some(k), false) => {+ (point(self.sections, k, s)? - point(self.sections, i - 1, s)? * 3.0 + point(self.sections, i, s)? * 3.0+ - point(self.sections, i + 1, s)?)+ * (1.0 / cube)+ }+ (None, false) => return Err(KernelError::Failed("loft blend: no fourth station for a change of curvature".into())),+ };+ if !value.is_finite() {+ return Err(KernelError::Failed("loft blend: the sections' third difference is not finite".into()));+ }+ Ok(value)+ }++ /// The Bézier rows of the span from section `j` to section `j + 1`: one control row per+ /// condition at each end, elevated to the run direction's degree so the whole face is one+ /// tensor surface. Row `k` of the span is control row `j·degree + k` of the face.+ fn span(&self, j: usize, left: &Shape, right: &Shape) -> Result<Vec<Vec<Vec3>>> {+ let (Some(&kl), Some(&kr)) = (self.conditions.get(j), self.conditions.get(j + 1)) else {+ return Err(KernelError::Failed("loft blend: a section with no conditions".into()));+ };+ let m = kl.saturating_add(kr).saturating_sub(1);+ if !(1..=MAX_SPLINE_DEGREE).contains(&m) {+ return Err(KernelError::Failed("loft blend: a span's degree".into()));+ }+ let k = m as f64;+ let delta = self.step;+ let one = delta / k;+ let two = if m >= 2 { delta * delta / (k * (k - 1.0)) } else { 0.0 };+ let three = if m >= 3 { delta * delta * delta / (k * (k - 1.0) * (k - 2.0)) } else { 0.0 };+ let mut out = vec![vec![Vec3::ZERO; self.samples]; m + 1];+ let missing = || KernelError::Failed("loft blend: a section's derivatives".into());+ for s in 0..self.samples {+ // The near end: one row per condition, position first.+ let p = *left.p.get(s).ok_or_else(missing)?;+ put(&mut out, 0, s, p)?;+ if kl >= 2 {+ let d1 = *left.d1.get(s).ok_or_else(missing)?;+ let q1 = p + d1 * one;+ put(&mut out, 1, s, q1)?;+ if kl >= 3 {+ let d2 = *left.d2.get(s).ok_or_else(missing)?;+ let q2 = d2 * two + q1 * 2.0 - p;+ put(&mut out, 2, s, q2)?;+ if kl >= 4 {+ let d3 = left.d3.as_ref().and_then(|d| d.get(s)).copied().ok_or_else(missing)?;+ put(&mut out, 3, s, d3 * three + q2 * 3.0 - q1 * 3.0 + p)?;+ }+ }+ }+ // The far end, its own conditions read backwards.+ let e = *right.p.get(s).ok_or_else(missing)?;+ put(&mut out, m, s, e)?;+ if kr >= 2 {+ let d1 = *right.d1.get(s).ok_or_else(missing)?;+ let r1 = e - d1 * one;+ put(&mut out, m - 1, s, r1)?;+ if kr >= 3 {+ let d2 = *right.d2.get(s).ok_or_else(missing)?;+ let r2 = d2 * two + r1 * 2.0 - e;+ put(&mut out, m - 2, s, r2)?;+ if kr >= 4 {+ let d3 = right.d3.as_ref().and_then(|d| d.get(s)).copied().ok_or_else(missing)?;+ put(&mut out, m - 3, s, r2 * 3.0 - r1 * 3.0 + e - d3 * three)?;+ }+ }+ }+ }+ // A span whose two ends carry fewer conditions than the run direction's degree is+ // elevated: the same curve, written in more control rows.+ while out.len().saturating_sub(1) < self.degree {+ out = elevate(&out);+ }+ Ok(out)+ }++ /// The run direction's knots: clamped at both ends, repeated `degree` times at every interior+ /// section — so the face interpolates each section and every span in between is one Bézier.+ fn run_knots(&self) -> Vec<f64> {+ let degree = self.degree;+ let mut knots = vec![0.0; degree + 1];+ for i in 1..self.run.saturating_sub(1) {+ knots.extend(std::iter::repeat_n(i as f64 / (self.run - 1) as f64, degree));+ }+ knots.extend(std::iter::repeat_n(1.0, degree + 1));+ knots+ }++ /// The face's control net: u runs with the sections, v along each section's curve.+ fn net(&self) -> Result<NurbsSurface> {+ let shapes: Vec<Shape> = (0..self.run).map(|i| self.shape(i)).collect::<Result<Vec<_>>>()?;+ // One span per pair of neighbouring sections. The first row of a span is the last row of+ // the one before it — the shared section — so only the first span writes it.+ let mut rows: Vec<Vec<Vec3>> = Vec::with_capacity((self.run - 1) * self.degree + 1);+ for j in 0..self.run.saturating_sub(1) {+ let (Some(left), Some(right)) = (shapes.get(j), shapes.get(j + 1)) else {+ return Err(KernelError::Failed("loft blend: a section's shape".into()));+ };+ for row in self.span(j, left, right)?.into_iter().skip(usize::from(j > 0)) {+ rows.push(row);+ }+ }+ let count_u = rows.len();+ // Along each section's curve the rows are the interpolation through that section's+ // stations: the same parameters and degree for every row, so every row has one knot+ // vector. Rows are solved in batches of `ROWS_PER_SOLVE` (three coordinates each), which+ // shares one elimination between them.+ let params: Vec<f64> = (0..self.samples).map(|s| s as f64 / (self.samples - 1) as f64).collect();+ let degree_v = 3.min(self.samples - 1);+ let mut ctrl = vec![HPoint::ZERO; count_u * self.samples];+ let mut knots_v: Option<Vec<f64>> = None;+ for (batch, chunk) in rows.chunks(ROWS_PER_SOLVE).enumerate() {+ const WIDTH: usize = 3 * ROWS_PER_SOLVE;+ let mut points: Vec<[f64; WIDTH]> = Vec::with_capacity(self.samples);+ for s in 0..self.samples {+ let mut q = [0.0f64; WIDTH];+ for (r, row) in chunk.iter().enumerate() {+ if let Some(p) = row.get(s) {+ for (slot, value) in q.iter_mut().skip(3 * r).zip([p.x, p.y, p.z]) {+ *slot = value;+ }+ }+ }+ points.push(q);+ }+ let curve = CurveN::<WIDTH>::interpolate(¶ms, &points, degree_v).map_err(|e| KernelError::Failed(format!("loft blend: {e}")))?;+ if knots_v.is_none() {+ knots_v = Some(curve.knots.clone());+ }+ for (s, c) in curve.ctrl.iter().enumerate() {+ for (r, xyz) in c.chunks(3).enumerate() {+ let i = batch * ROWS_PER_SOLVE + r;+ // Coordinates past the net's last row are this batch's own padding: their+ // controls are not part of the surface.+ if i >= count_u {+ break;+ }+ if let [x, y, z] = *xyz {+ let Some(slot) = s.checked_mul(count_u).and_then(|base| base.checked_add(i)).and_then(|k| ctrl.get_mut(k)) else {+ continue;+ };+ *slot = HPoint::weighted(Vec3::new(x, y, z), 1.0);+ }+ }+ }+ }+ let knots_v = knots_v.ok_or_else(|| KernelError::Failed("loft blend: no row could be interpolated".into()))?;+ NurbsSurface::from_homogeneous([self.degree, degree_v], [self.run_knots(), knots_v], ctrl)+ .map_err(|e| KernelError::Failed(format!("loft blend: {e}")))+ }+}++/// The frame at section `i`, station `s`.+fn frame(sections: &[Vec<Frame>], i: usize, s: usize) -> Result<&Frame> {+ sections.get(i).and_then(|section| section.get(s)).ok_or_else(|| KernelError::Failed("loft blend: a section is missing a station".into()))+}++/// The point of section `i` at station `s`.+fn point(sections: &[Vec<Frame>], i: usize, s: usize) -> Result<Vec3> {+ frame(sections, i, s).map(|f| f.p)+}++/// `rows[k][s] = v`, an error when the net has no such row or station.+fn put(rows: &mut [Vec<Vec3>], k: usize, s: usize, v: Vec3) -> Result<()> {+ match rows.get_mut(k).and_then(|row| row.get_mut(s)) {+ Some(slot) => {+ *slot = v;+ Ok(())+ }+ None => Err(KernelError::Failed("loft blend: the control net is too small".into())),+ }+}++/// One exact degree elevation of a Bézier control net of rows: the same curve, one control row+/// more.+fn elevate(rows: &[Vec<Vec3>]) -> Vec<Vec<Vec3>> {+ let degree = rows.len().saturating_sub(1);+ let up = degree as f64 + 1.0;+ let mut out: Vec<Vec<Vec3>> = Vec::with_capacity(rows.len() + 1);+ if let Some(first) = rows.first() {+ out.push(first.clone());+ }+ for i in 1..=degree {+ if let (Some(before), Some(here)) = (rows.get(i - 1), rows.get(i)) {+ let a = i as f64 / up;+ out.push(before.iter().zip(here).map(|(x, y)| *x * a + *y * (1.0 - a)).collect());+ }+ }+ if let Some(last) = rows.last() {+ out.push(last.clone());+ }+ out+}++/// Whether a third difference for the interior section `i` can be taken from the sections around+/// it: a stencil needs a station on one side of it and two on the other, and with three sections+/// there is none.+fn third_difference_available(i: usize, run: usize) -> bool {+ i >= 2 || i + 2 < run+}++/// The degree a family of sections asks for: the largest `c + c′ − 1` over its spans.+fn span_degree(conditions: &[usize]) -> usize {+ let mut degree = 0;+ for w in conditions.windows(2) {+ if let [a, b] = w {+ degree = degree.max(a.saturating_add(*b).saturating_sub(1));+ }+ }+ degree+}++/// The third derivative a curve needs at a boundary so that the arclength derivative of its+/// curvature vector is `target`, from its first two derivatives there. Only the normal-plane part+/// of the third derivative can hold that condition; the rest is a reparameterisation of the+/// cross-section. This is `bridge`'s own construction, kept here so the bridge core stays+/// untouched.+fn third_derivative(d1: Vec3, d2: Vec3, target: Vec3) -> Result<Vec3> {+ let sigma = d1.len();+ if !(sigma > 1e-12) || !sigma.is_finite() {+ return Err(KernelError::Failed("loft blend: no room for the curvature condition".into()));+ }+ let t = d1 * (1.0 / sigma);+ let tp = d2 * (1.0 / sigma) - d1 * (d1.dot(d2) / (sigma * sigma * sigma));+ let nn = d2 - t * d2.dot(t);+ let r = tp * (-d2.dot(t)) - t * d2.dot(tp);+ let x = (target * (sigma.powi(5)) - r * (sigma * sigma) + nn * (2.0 * d1.dot(d2))) * (1.0 / (sigma * sigma));+ if !x.is_finite() {+ return Err(KernelError::Failed("loft blend: the change of curvature is not finite".into()));+ }+ Ok(x - t * x.dot(t))+}++#[cfg(test)]+#[path = "loft_blend_tests.rs"]+mod tests;diff --git a/crates/kernel/src/loft_blend_tests.rs b/crates/kernel/src/loft_blend_tests.rsnew file mode 100644index 0000000000..df60b675c0--- /dev/null+++ b/crates/kernel/src/loft_blend_tests.rs@@ -0,0 +1,460 @@+//! Tests of the multi-section blend: analytic cross-sections given as frames, and the surface+//! measured back off the face it built (a grid of points, five-point differences along the run).++use super::*;+use crate::body::from_p3;+use crate::bridge::{bridge, sample_grid};+use truck_modeling as mt;+use truck_modeling::ParametricSurface;++/// The blend's surface: it is one face.+fn surface_of(body: &Body) -> mt::Surface {+ body.solid.face_iter().next().unwrap().surface()+}++/// Position and the run direction's first three derivatives at `(t, v)` of the face, read with the+/// five-point differences `bridge_tests` reads a cross-section with. The samples run inwards from+/// the section (so nothing is asked of the face outside its own domain); `backwards` reads with+/// the parameter falling and turns the odd derivatives round, so every value is a derivative in+/// the run direction `u`.+fn run_derivs(body: &Body, t: f64, v: f64, backwards: bool, h: f64) -> (Vec3, Vec3, Vec3, Vec3) {+ let face = body.solid.face_iter().next().unwrap();+ let surf = face.surface();+ let dir = if backwards { -1.0 } else { 1.0 };+ let q: Vec<Vec3> = (0..5).map(|k| from_p3(surf.subs(t + dir * k as f64 * h, v))).collect();+ let d1 = (q[0] * -25.0 + q[1] * 48.0 + q[2] * -36.0 + q[3] * 16.0 + q[4] * -3.0) * (dir / (12.0 * h));+ let d2 = (q[0] * 35.0 + q[1] * -104.0 + q[2] * 114.0 + q[3] * -56.0 + q[4] * 11.0) * (1.0 / (12.0 * h * h));+ let d3 = (q[0] * -5.0 + q[1] * 18.0 + q[2] * -24.0 + q[3] * 14.0 + q[4] * -3.0) * (dir / (2.0 * h * h * h));+ (q[0], d1, d2, d3)+}++/// The geometric shape of a curve from its first three derivatives: the unit tangent, the+/// curvature vector and the arclength derivative of that curvature vector (`bridge`'s own+/// reading, kept local to the test).+fn curve_shape(d1: Vec3, d2: Vec3, d3: Vec3) -> (Vec3, Vec3, Vec3) {+ let sigma = d1.len();+ let t = d1 * (1.0 / sigma);+ let tp = d2 * (1.0 / sigma) - d1 * (d1.dot(d2) / (sigma * sigma * sigma));+ let nn = d2 - t * d2.dot(t);+ let np = d3 - t * d3.dot(t) - tp * d2.dot(t) - t * d2.dot(tp);+ let kappa = np * (sigma * sigma) - nn * (2.0 * d1.dot(d2));+ (t, nn * (1.0 / (sigma * sigma)), kappa * (1.0 / sigma.powi(5)))+}++/// The angle between two vectors, in degrees.+fn angle_deg(a: Vec3, b: Vec3) -> f64 {+ (a.normalized().unwrap().dot(b.normalized().unwrap())).clamp(-1.0, 1.0).acos().to_degrees()+}++/// A circle of radius `r` at height `z` about the run (the z axis), sampled at `n` stations. Each+/// frame leaves along `leave`; its `bend` is given per station as a function of the station's+/// outward radial direction (a support surface curving in the leave direction), and its change of+/// curvature is `change`.+fn circle_section(r: f64, z: f64, n: usize, leave: Vec3, bend: impl Fn(Vec3) -> Vec3, change: Vec3) -> Vec<Frame> {+ (0..n)+ .map(|s| {+ let a = std::f64::consts::TAU * s as f64 / n as f64;+ let p = Vec3::new(r * a.cos(), r * a.sin(), z);+ Frame { p, leave, bend: bend(Vec3::new(p.x / r, p.y / r, 0.0)), bend_change: change }+ })+ .collect()+}++/// `count` straight cross-sections along x, `10` apart in z and rising in order: the run is +z.+/// Every frame leaves along +z except the last one, which leaves back into the blend along −z as+/// a bridge's far boundary does. `bend` and `change` are the same at every station, and `bend` is+/// perpendicular to the run (the only shape a support surface can have along a direction it does+/// not bend around).+fn line_sections(count: usize, n: usize, bend: Vec3, change: Vec3) -> Vec<Vec<Frame>> {+ (0..count)+ .map(|i| {+ let leave = if i + 1 == count { Vec3::new(0.0, 0.0, -1.0) } else { Vec3::new(0.0, 0.0, 1.0) };+ (0..n).map(|s| Frame { p: Vec3::new(10.0 * s as f64 / (n - 1) as f64, 0.0, 10.0 * i as f64), leave, bend, bend_change: change }).collect()+ })+ .collect()+}++/// A point at arclength `s` along the perimeter of the rounded rectangle of half-width `a`,+/// half-height `b` and corner radius `r` (in the z = 0 plane, counter-clockwise from the right+/// edge's lower end).+fn rounded_rect_at(a: f64, b: f64, r: f64, s: f64) -> Vec3 {+ let (sa, sb) = ((a - r).max(0.0), (b - r).max(0.0));+ let quarter = std::f64::consts::FRAC_PI_2;+ let segs = [2.0 * sb, quarter * r, 2.0 * sa, quarter * r, 2.0 * sb, quarter * r, 2.0 * sa, quarter * r];+ let mut left = s;+ let mut k = 0;+ while k + 1 < segs.len() && left > segs[k] {+ left -= segs[k];+ k += 1;+ }+ let f = if segs[k] > 0.0 { left / segs[k] } else { 0.0 };+ let arc = |centre: Vec3, from: f64| {+ let ang = from + quarter * f;+ Vec3::new(centre.x + r * ang.cos(), centre.y + r * ang.sin(), 0.0)+ };+ match k {+ 0 => Vec3::new(a, -sb + 2.0 * sb * f, 0.0),+ 1 => arc(Vec3::new(sa, sb, 0.0), 0.0),+ 2 => Vec3::new(sa - 2.0 * sa * f, b, 0.0),+ 3 => arc(Vec3::new(-sa, sb, 0.0), quarter),+ 4 => Vec3::new(-a, sb - 2.0 * sb * f, 0.0),+ 5 => arc(Vec3::new(-sa, -sb, 0.0), std::f64::consts::PI),+ 6 => Vec3::new(-sa + 2.0 * sa * f, -b, 0.0),+ _ => arc(Vec3::new(sa, -sb, 0.0), 3.0 * quarter),+ }+}++/// A rounded rectangle at height `z`, sampled at `n` even arclength steps around it: a section+/// that is not a scaled copy of the circles it can sit between, with a plan support (no bend).+fn rounded_rect_section(a: f64, b: f64, r: f64, z: f64, n: usize) -> Vec<Frame> {+ let total = 4.0 * ((a - r).max(0.0) + (b - r).max(0.0)) + 2.0 * std::f64::consts::PI * r;+ (0..n)+ .map(|s| {+ let p = rounded_rect_at(a, b, r, total * s as f64 / n as f64);+ Frame { p: Vec3::new(p.x, p.y, z), leave: Vec3::new(0.0, 0.0, 1.0), bend: Vec3::ZERO, bend_change: Vec3::ZERO }+ })+ .collect()+}++/// Two parallel circular cylinders of radius `r` 20 apart in y, leaving towards each other along+/// ∓y, each bending up towards its own axis and with a curvature that does not change as it goes+/// round (`bridge_tests`'s own case, for the two-section comparison).+fn valley_between_cylinders(count: usize, r: f64) -> (Vec<Frame>, Vec<Frame>) {+ let mut a = Vec::new();+ let mut b = Vec::new();+ for i in 0..count {+ let y = 10.0 * i as f64 / (count - 1) as f64;+ a.push(Frame {+ p: Vec3::new(0.0, y, 0.0),+ leave: Vec3::new(0.0, 1.0, 0.0),+ bend: Vec3::new(0.0, 0.0, 1.0 / r),+ bend_change: Vec3::new(0.0, -1.0 / (r * r), 0.0),+ });+ b.push(Frame {+ p: Vec3::new(0.0, y + 20.0, 0.0),+ leave: Vec3::new(0.0, -1.0, 0.0),+ bend: Vec3::new(0.0, 0.0, 1.0 / r),+ bend_change: Vec3::new(0.0, 1.0 / (r * r), 0.0),+ });+ }+ (a, b)+}++/// Three circles of different sizes at three heights, the middle one smaller: a shape that+/// changes as the face runs up it.+fn three_circles(n: usize) -> Vec<Vec<Frame>> {+ vec![+ // The first section is the equator of a sphere of its own radius: the support bends+ // inwards by 1/r along the run, and its curvature does not change as it goes round.+ circle_section(10.0, 0.0, n, Vec3::new(0.0, 0.0, 1.0), |radial| radial * -0.1, Vec3::new(0.0, 0.0, -0.01)),+ // The middle section's own shape data are ignored: the blend reads it from its neighbours.+ circle_section(8.0, 10.0, n, Vec3::new(0.0, 0.0, 1.0), |_| Vec3::ZERO, Vec3::ZERO),+ // The last section's frames leave back into the blend, along −z.+ circle_section(12.0, 20.0, n, Vec3::new(0.0, 0.0, -1.0), |_| Vec3::ZERO, Vec3::ZERO),+ ]+}++/// Every station of every section is on the face, within the tolerance a blend promises.+fn assert_runs_through(body: &Body, sections: &[Vec<Frame>], n: usize) {+ let grid = sample_grid(body, sections.len(), n).unwrap();+ for (k, section) in sections.iter().enumerate() {+ for (s, f) in section.iter().enumerate() {+ assert!(grid[k][s].dist(f.p) < 1e-9, "section {k} station {s}: {:?} vs {:?}", grid[k][s], f.p);+ }+ }+}++#[test]+fn three_sections_run_through_every_station() {+ let n = 9;+ let sections = three_circles(n);+ let body = loft_blend(§ions, [Continuity::G2, Continuity::G2], [0.0, 0.0], n).unwrap();+ assert_runs_through(&body, §ions, n);++ // The ends hold what their frames ask for: the leave direction is the tangent, and the+ // support's own curvature (1/10 inwards on the sphere, nothing on the plane) is the face's.+ for s in [0usize, 4, 8] {+ let v = s as f64 / (n - 1) as f64;+ // The stations run round the circle at even angles.+ let angle = std::f64::consts::TAU * s as f64 / n as f64;+ let radial = Vec3::new(angle.cos(), angle.sin(), 0.0);+ let (_, d1, d2, d3) = run_derivs(&body, 0.0, v, false, 1e-3);+ let (t, bend, _) = curve_shape(d1, d2, d3);+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, 1.0)) < 0.01, "the face leaves along +z: {t:?}");+ assert!(bend.dist(radial * -0.1) < 1e-4, "the face leaves the sphere with its curvature: {bend:?}");+ // The last section's frames leave back into the blend, so read the shape that way round.+ let (_, d1, d2, d3) = run_derivs(&body, 1.0, v, true, 1e-3);+ let (t, bend, _) = curve_shape(-d1, d2, -d3);+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, -1.0)) < 0.01, "and arrives along the far leave: {t:?}");+ assert!(bend.len() < 1e-3, "the last section's support is flat: {bend:?}");+ }++ // Three sections: the one interior joint has no fourth station to take a third difference+ // over, so it holds position, tangent and curvature — C² — and both sides agree.+ for s in [0usize, 4, 8] {+ let v = s as f64 / (n - 1) as f64;+ let (from_left, left1, left2, left3) = run_derivs(&body, 0.5, v, false, 1e-4);+ let (from_right, right1, right2, right3) = run_derivs(&body, 0.5, v, true, 1e-4);+ assert!(from_left.dist(from_right) < 1e-9, "the joint is on the middle section");+ assert!((left1 - right1).len() < 1e-7 * (1.0 + left1.len()), "the tangent is continuous: {left1:?} vs {right1:?}");+ assert!((left2 - right2).len() < 1e-4 * (1.0 + left2.len()), "the curvature is continuous: {left2:?} vs {right2:?}");+ // But the change of curvature is not: a three-point stencil carries no third difference,+ // so the joint is C² and not C³, and the difference stays whatever the step size is.+ assert!((left3 - right3).len() > 0.05 * (1.0 + left3.len()), "a C² joint is not C³: {left3:?} vs {right3:?}");+ // What it holds is the sections' own finite differences along the run: the secant of the+ // two neighbours for the tangent, their second difference for the curvature.+ let p = |k: usize| sections[k][s].p;+ let secant = p(2) - p(0);+ let second = (p(2) - p(1) * 2.0 + p(0)) * 4.0;+ assert!((left1 - secant).len() < 1e-7 * (1.0 + secant.len()), "the tangent is the neighbours' secant: {left1:?} vs {secant:?}");+ assert!((left2 - second).len() < 1e-4 * (1.0 + second.len()), "the curvature is the neighbours' second difference: {left2:?} vs {second:?}");+ }+}++#[test]+fn the_ends_hold_the_shape_their_frames_ask_for() {+ let stations = 7;+ let bend = Vec3::new(0.0, 0.2, 0.0);+ let change = Vec3::new(0.0, 0.5, 0.0);+ let sections = line_sections(3, stations, bend, change);+ let z = |s: f64| s * 10.0;++ // G1 holds the tangent and nothing more.+ let g1 = loft_blend(§ions, [Continuity::G1, Continuity::G1], [0.0, 0.0], stations).unwrap();+ for (v, x) in [(0.0, 0.0), (0.5, 5.0), (1.0, 10.0)] {+ let (p, d1, d2, d3) = run_derivs(&g1, 0.0, v, false, 1e-3);+ let (t, _, _) = curve_shape(d1, d2, d3);+ assert!(p.dist(Vec3::new(x, 0.0, 0.0)) < 1e-9, "the face starts on the first section: {p:?}");+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, 1.0)) < 0.01, "a G1 blend leaves along leave: {t:?}");+ }++ // G2 holds the tangent and the support's curvature, at both ends.+ let g2 = loft_blend(§ions, [Continuity::G2, Continuity::G2], [0.0, 0.0], stations).unwrap();+ for (v, x) in [(0.0, 0.0), (0.5, 5.0), (1.0, 10.0)] {+ let (p, d1, d2, d3) = run_derivs(&g2, 0.0, v, false, 1e-3);+ let (t, k, _) = curve_shape(d1, d2, d3);+ assert!(p.dist(Vec3::new(x, 0.0, 0.0)) < 1e-9, "the face starts on the first section: {p:?}");+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, 1.0)) < 0.01, "a G2 blend leaves along leave: {t:?}");+ assert!(k.dist(bend) / bend.len() < 1e-3, "a G2 blend holds the support's curvature: {k:?} vs {bend:?}");+ let (p, d1, d2, d3) = run_derivs(&g2, 1.0, v, true, 1e-3);+ let (t, k, c) = curve_shape(-d1, d2, -d3);+ assert!(p.dist(Vec3::new(x, 0.0, z(2.0))) < 1e-9, "the face ends on the last section: {p:?}");+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, -1.0)) < 0.01, "reading back, it arrives along the far leave: {t:?}");+ assert!(k.dist(bend) / bend.len() < 1e-3, "the far end holds the curvature too: {k:?}");+ assert!(c.len() < 1e3);+ }+ // A G2 blend leaves the change of curvature free: moving the frames' own value does not move+ // the face at the first section, while a G3 blend follows it.+ let (_, d1, d2, d3) = run_derivs(&g2, 0.0, 0.5, false, 1e-3);+ let free = curve_shape(d1, d2, d3).2;+ let moved = line_sections(3, stations, bend, change + Vec3::new(0.0, 1.0, 0.0));+ let g2_moved = loft_blend(&moved, [Continuity::G2, Continuity::G2], [0.0, 0.0], stations).unwrap();+ let (_, d1, d2, d3) = run_derivs(&g2_moved, 0.0, 0.5, false, 1e-3);+ assert!(curve_shape(d1, d2, d3).2.dist(free) < 1e-9, "a G2 blend does not read the far frame's change");++ // G3 holds the change of curvature as well: its normal part is what a surface match can hold,+ // and here the frame's own change is normal (along its curvature vector).+ let g3 = loft_blend(§ions, [Continuity::G3, Continuity::G3], [0.0, 0.0], stations).unwrap();+ for (v, x) in [(0.0, 0.0), (0.5, 5.0), (1.0, 10.0)] {+ let (_, d1, d2, d3) = run_derivs(&g3, 0.0, v, false, 1e-3);+ let (t, k, c) = curve_shape(d1, d2, d3);+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, 1.0)) < 0.01);+ assert!(k.dist(bend) / bend.len() < 1e-3, "a G3 blend still holds the curvature: {k:?}");+ assert!((c.y - change.y).abs() < 1e-3, "a G3 blend holds the change of curvature: {c:?} vs {change:?}");+ let (p, d1, d2, d3) = run_derivs(&g3, 1.0, v, true, 1e-3);+ let (t, k, c) = curve_shape(-d1, d2, -d3);+ assert!(angle_deg(t, Vec3::new(0.0, 0.0, -1.0)) < 0.01);+ assert!(k.dist(bend) / bend.len() < 1e-3);+ assert!((c.y - change.y).abs() < 1e-3, "and the far end holds it too: {c:?} vs {change:?}");+ assert!(p.dist(Vec3::new(x, 0.0, z(2.0))) < 1e-9);+ }+ // With G3, moving the frames' own value does move the face there.+ let g3_moved = loft_blend(&moved, [Continuity::G3, Continuity::G3], [0.0, 0.0], stations).unwrap();+ let (_, d1, d2, d3) = run_derivs(&g3_moved, 0.0, 0.5, false, 1e-3);+ assert!((curve_shape(d1, d2, d3).2.y - free.y).abs() > 0.5, "a G3 blend follows the frame's change");+}++#[test]+fn four_sections_join_at_c3() {+ let n = 9;+ let sections: Vec<Vec<Frame>> = [(10.0, 0.0), (9.0, 10.0), (8.0, 20.0), (11.0, 30.0)]+ .iter()+ .enumerate()+ .map(|(i, &(r, z))| {+ let leave = if i == 3 { Vec3::new(0.0, 0.0, -1.0) } else { Vec3::new(0.0, 0.0, 1.0) };+ circle_section(r, z, n, leave, |_| Vec3::ZERO, Vec3::ZERO)+ })+ .collect();+ let body = loft_blend(§ions, [Continuity::G3, Continuity::G3], [0.0, 0.0], n).unwrap();+ assert_runs_through(&body, §ions, n);++ // Every joint now has a fourth station for the third difference, so the two sides agree in+ // the tangent, the curvature and its change: the joints are C³.+ let h = 1.0 / 3.0;+ for (i, s) in [(1usize, 0usize), (1, 4), (1, 8), (2, 0), (2, 4), (2, 8)] {+ let t = i as f64 / 3.0;+ let v = s as f64 / (n - 1) as f64;+ let (_, left1, left2, left3) = run_derivs(&body, t, v, true, 1e-4);+ let (_, right1, right2, right3) = run_derivs(&body, t, v, false, 1e-4);+ assert!((left1 - right1).len() < 1e-7 * (1.0 + left1.len()), "joint {i} station {s}: the tangent agrees");+ assert!((left2 - right2).len() < 1e-4 * (1.0 + left2.len()), "joint {i} station {s}: the curvature agrees");+ // The change of curvature agrees too, as far as finite differences can tell: its+ // mismatch falls away with the step size, so the joint is C³, not just C².+ assert!(+ (left3 - right3).len() < 2e-2 * (1.0 + left3.len()),+ "joint {i} station {s}: the change of curvature agrees: {left3:?} vs {right3:?}"+ );+ // What they hold are the sections' own differences along the run.+ let p = |k: usize| sections[k][s].p;+ let d1 = (p(i + 1) - p(i - 1)) * (1.0 / (2.0 * h));+ let d2 = (p(i + 1) - p(i) * 2.0 + p(i - 1)) * (1.0 / (h * h));+ let d3 = if i == 1 {+ (p(0) * -1.0 + p(1) * 3.0 - p(2) * 3.0 + p(3)) * (1.0 / (h * h * h))+ } else {+ (p(0) - p(1) * 3.0 + p(2) * 3.0 - p(3)) * (1.0 / (h * h * h))+ };+ assert!((left1 - d1).len() < 1e-7 * (1.0 + d1.len()), "the tangent is the secant: {left1:?} vs {d1:?}");+ assert!((left2 - d2).len() < 1e-4 * (1.0 + d2.len()), "the curvature is the second difference: {left2:?} vs {d2:?}");+ assert!((left3 - d3).len() < 2e-2 * (1.0 + d3.len()), "the change of curvature is the third difference: {left3:?} vs {d3:?}");+ }+}++#[test]+fn a_shape_that_is_not_a_scaled_copy_still_runs_through() {+ let n = 17;+ let sections = vec![+ circle_section(10.0, 0.0, n, Vec3::new(0.0, 0.0, 1.0), |_| Vec3::ZERO, Vec3::ZERO),+ rounded_rect_section(9.0, 7.0, 2.5, 10.0, n),+ circle_section(8.0, 20.0, n, Vec3::new(0.0, 0.0, -1.0), |_| Vec3::ZERO, Vec3::ZERO),+ ];+ let body = loft_blend(§ions, [Continuity::G1, Continuity::G1], [0.0, 0.0], n).unwrap();+ assert_runs_through(&body, §ions, n);++ // The interior joint is still smooth to C² and holds the neighbours' own estimates, whatever+ // the sections' shapes are.+ for s in [0usize, 4, 8, 12, 16] {+ let v = s as f64 / (n - 1) as f64;+ let (_, left1, left2, _) = run_derivs(&body, 0.5, v, false, 2e-4);+ let (_, right1, right2, _) = run_derivs(&body, 0.5, v, true, 2e-4);+ assert!((left1 - right1).len() < 1e-6 * (1.0 + left1.len()), "station {s}: the tangent is continuous");+ assert!((left2 - right2).len() < 1e-6 * (1.0 + left2.len()), "station {s}: the curvature is continuous");+ let p = |k: usize| sections[k][s].p;+ let secant = p(2) - p(0);+ let second = (p(2) - p(1) * 2.0 + p(0)) * 4.0;+ assert!((left1 - secant).len() < 1e-6 * (1.0 + secant.len()), "station {s}: the tangent is the secant: {left1:?} vs {secant:?}");+ assert!((left2 - second).len() < 1e-6 * (1.0 + second.len()), "station {s}: the curvature is the second difference: {left2:?} vs {second:?}");+ }+}++#[test]+fn a_two_section_blend_is_the_bridge() {+ let (a, b) = valley_between_cylinders(9, 10.0);+ let made = loft_blend(&[a.clone(), b.clone()], [Continuity::G2, Continuity::G2], [0.0, 0.0], 9).unwrap();+ let other = bridge(&a, &b, [Continuity::G2, Continuity::G2], [0.0, 0.0]).unwrap();+ // The blend runs with the sections, the bridge crosses from one boundary to the other: the+ // same face, its two parameters the other way round.+ for (run, station) in [(0.0, 0.0), (0.25, 0.3), (0.5, 0.7), (0.75, 0.1), (1.0, 1.0)] {+ let x = from_p3(surface_of(&made).subs(run, station));+ let y = from_p3(surface_of(&other).subs(station, run));+ assert!(x.dist(y) < 1e-9, "run {run} station {station}: {x:?} vs {y:?}");+ }+ let grid = sample_grid(&other, 9, 7).unwrap();+ for (row, frame) in grid.iter().zip(&a) {+ assert!(row[0].dist(frame.p) < 1e-9);+ }+}++#[test]+fn crown_shapes_the_middle_without_moving_the_joints() {+ let n = 9;+ let sections = three_circles(n);+ let mut heights = Vec::new();+ let mut joints = Vec::new();+ for crown in [-0.5, 0.0, 1.0, 2.0] {+ let body = loft_blend(§ions, [Continuity::G2, Continuity::G2], [crown, crown], n).unwrap();+ // The interior joint holds the sections' own estimates whatever the crown does: those do+ // not depend on it.+ let (p, d1, d2, _) = run_derivs(&body, 0.5, 0.5, false, 2e-4);+ assert!(p.dist(sections[1][4].p) < 1e-9, "the crown left the joint where the sections put it");+ joints.push((d1, d2));+ // Halfway up the first span is where a fuller crown reaches further.+ heights.push(from_p3(surface_of(&body).subs(0.25, 0.5)).z);+ assert_runs_through(&body, §ions, n);+ }+ for (d1, d2) in &joints {+ let (base1, base2) = joints[0];+ assert!((*d1 - base1).len() < 1e-4 * (1.0 + base1.len()), "the crown left the joint's tangent alone: {d1:?}");+ assert!((*d2 - base2).len() < 1e-4 * (1.0 + base2.len()), "the crown left the joint's curvature alone: {d2:?}");+ }+ let steps: Vec<f64> = heights.windows(2).map(|w| w[1] - w[0]).collect();+ assert!(steps.iter().all(|d| d.abs() > 1e-6 && d.signum() == steps[0].signum()), "a fuller crown moves the middle one way: {heights:?}");+}++#[test]+fn the_blend_refuses_what_it_cannot_hold() {+ let n = 5;+ let orders = [Continuity::G1, Continuity::G1];+ let good = three_circles(n);+ assert!(loft_blend(&good, orders, [0.0, 0.0], n).is_ok());++ // Fewer than two sections, and more than the cap.+ assert!(loft_blend(&good[..1], orders, [0.0, 0.0], n).is_err(), "one section is no blend");+ let many: Vec<Vec<Frame>> =+ (0..=MAX_BLEND_SECTIONS).map(|i| circle_section(10.0, i as f64, 3, Vec3::new(0.0, 0.0, 1.0), |_| Vec3::ZERO, Vec3::ZERO)).collect();+ assert!(loft_blend(&many, orders, [0.0, 0.0], 3).is_err(), "more than {MAX_BLEND_SECTIONS} sections");++ // Station counts that do not match each other, or the count asked for.+ let mut unequal = good.clone();+ unequal[1] = unequal[1][..n - 1].to_vec();+ assert!(loft_blend(&unequal, orders, [0.0, 0.0], n).is_err(), "unequal station counts");+ assert!(loft_blend(&good, orders, [0.0, 0.0], n + 1).is_err(), "the samples must match the sections");+ for samples in [0usize, 1, MAX_BLEND_STATIONS + 1] {+ assert!(loft_blend(&good, orders, [0.0, 0.0], samples).is_err(), "samples {samples}");+ }++ // A crown outside its range, and one that is not a number.+ for crown in [f64::NAN, 5.0, -1.0, f64::INFINITY] {+ assert!(loft_blend(&good, orders, [crown, crown], n).is_err(), "crown {crown}");+ }+ assert!(loft_blend(&good, orders, [0.0, f64::NAN], n).is_err());++ // A frame that is not a number, wherever it is not, and a leave direction with no direction.+ for pick in 0..4 {+ let mut bad = good.clone();+ let frame = bad[1][2];+ bad[1][2] = match pick {+ 0 => Frame { p: Vec3::new(f64::NAN, 0.0, 0.0), ..frame },+ 1 => Frame { leave: Vec3::new(f64::INFINITY, 0.0, 0.0), ..frame },+ 2 => Frame { bend: Vec3::new(0.0, f64::NAN, 0.0), ..frame },+ _ => Frame { bend_change: Vec3::new(0.0, 0.0, f64::NAN), ..frame },+ };+ assert!(loft_blend(&bad, orders, [0.0, 0.0], n).is_err(), "a non-finite frame {pick}");+ }+ let mut no_leave = good.clone();+ no_leave[1][2].leave = Vec3::ZERO;+ assert!(loft_blend(&no_leave, orders, [0.0, 0.0], n).is_err(), "a leave direction with no direction");++ // Two sections that meet at a station: no room for a blend.+ let mut meeting = good.clone();+ meeting[1] = meeting[0].clone();+ assert!(loft_blend(&meeting, orders, [0.0, 0.0], n).is_err(), "sections that meet");+ let mut touching = good.clone();+ touching[1][2].p = touching[0][2].p;+ assert!(loft_blend(&touching, orders, [0.0, 0.0], n).is_err(), "a station where the sections meet");++ // Every order from G0 to G3 builds, alone and together, and so does the largest blend.+ for (near, far) in [+ (Continuity::G0, Continuity::G0),+ (Continuity::G1, Continuity::G0),+ (Continuity::G0, Continuity::G3),+ (Continuity::G3, Continuity::G3),+ (Continuity::G2, Continuity::G3),+ ] {+ let body = loft_blend(&good, [near, far], [0.0, 0.0], n).unwrap();+ assert_runs_through(&body, &good, n);+ }+ let full: Vec<Vec<Frame>> =+ (0..MAX_BLEND_SECTIONS).map(|i| circle_section(10.0, i as f64, 5, Vec3::new(0.0, 0.0, 1.0), |_| Vec3::ZERO, Vec3::ZERO)).collect();+ let body = loft_blend(&full, [Continuity::G3, Continuity::G3], [0.0, 0.0], 5).unwrap();+ assert_runs_through(&body, &full, 5);+}diff --git a/crates/kernel/src/native/metadata.rs b/crates/kernel/src/native/metadata.rsindex 1dccec7fb3..f87bd4ea04 100644--- a/crates/kernel/src/native/metadata.rs+++ b/crates/kernel/src/native/metadata.rs@@ -32,7 +32,8 @@ fn segment(s: &Seg2) -> Result<w::Segment> {Seg2::Conic { a, apex, b, w } => w::Segment::Conic { points: [a, apex, b].map(point2), middle_weight: w },Seg2::Bezier { n, p } => {let count = usize::from(n) + 1;- if !(5..=8).contains(&count) || p.get(count..).is_none_or(|unused| unused.iter().any(|p| *p != Vec2::ZERO)) {+ if !(5..=solidcraft_geom::MAX_BEZIER_CTRL).contains(&count) || p.get(count..).is_none_or(|unused| unused.iter().any(|p| *p != Vec2::ZERO))+ {return Err(invalid("unsupported certificate Bezier layout"));}w::Segment::Bezier { points: p.get(..count).ok_or_else(|| invalid("Bezier count"))?.iter().copied().map(point2).collect() }@@ -46,10 +47,10 @@ fn load_segment(s: w::Segment) -> Result<Seg2> {w::Segment::Cubic { points: [a, b, c, d] } => Seg2::Cubic { p0: p2(a), p1: p2(b), p2: p2(c), p3: p2(d) },w::Segment::Conic { points: [a, apex, b], middle_weight } => Seg2::Conic { a: p2(a), apex: p2(apex), b: p2(b), w: middle_weight },w::Segment::Bezier { points } => {- if !(5..=8).contains(&points.len()) {+ if !(5..=solidcraft_geom::MAX_BEZIER_CTRL).contains(&points.len()) {return Err(invalid("certificate Bezier degree"));}- let mut p = [Vec2::ZERO; 8];+ let mut p = [Vec2::ZERO; solidcraft_geom::MAX_BEZIER_CTRL];let n = (points.len() - 1) as u8;for (slot, value) in p.iter_mut().zip(points) {*slot = p2(value);@@ -324,7 +325,7 @@ mod tests {for value in sources {assert_eq!(value, source(&load_source(value.clone(), 0).unwrap(), 0).unwrap());}- assert!(load_segment(w::Segment::Bezier { points: vec![[0., 0.]; 9] }).is_err());+ assert!(load_segment(w::Segment::Bezier { points: vec![[0., 0.]; solidcraft_geom::MAX_BEZIER_CTRL + 1] }).is_err());}#[test]diff --git a/crates/render/src/curve_display.rs b/crates/render/src/curve_display.rsindex 08bbebf5ab..cd5a63cc99 100644--- a/crates/render/src/curve_display.rs+++ b/crates/render/src/curve_display.rs@@ -115,7 +115,9 @@ fn controls(segment: &Seg2, plane: &Plane) -> Option<(Vec<Vec<H>>, H)> {Seg2::Line { a, b } => vec![vec![h(a, 1.0), h(b, 1.0)]],Seg2::Cubic { p0, p1, p2, p3 } => vec![vec![h(p0, 1.0), h(p1, 1.0), h(p2, 1.0), h(p3, 1.0)]],Seg2::Conic { a, apex, b, w } if w > 0.0 => vec![vec![h(a, 1.0), h(apex, w), h(b, 1.0)]],- Seg2::Bezier { n, p } if (1..=7).contains(&n) => vec![p[..=n as usize].iter().map(|p| h(*p, 1.0)).collect()],+ Seg2::Bezier { n, p } if (1..=solidcraft_geom::MAX_BEZIER_DEGREE as u8).contains(&n) => {+ vec![p[..=n as usize].iter().map(|p| h(*p, 1.0)).collect()]+ }Seg2::Arc { center, radius, start, sweep }if radius > 0.0 && start.is_finite() && sweep.is_finite() && sweep.abs() <= std::f64::consts::TAU + 1e-9 =>{diff --git a/crates/render/src/curve_display_tests.rs b/crates/render/src/curve_display_tests.rsindex a3f4550593..8aa62e6926 100644--- a/crates/render/src/curve_display_tests.rs+++ b/crates/render/src/curve_display_tests.rs@@ -27,7 +27,7 @@ fn dense_error(s: &Seg2, plane: &Plane, v: &PixelCurveView, path: &SampledPath)#[test]fn exact_arcs_ellipses_rational_and_looping_control_hulls_bound_pixels() {- let mut degree7 = [Vec2::ZERO; 8];+ let mut degree7 = [Vec2::ZERO; solidcraft_geom::MAX_BEZIER_CTRL];for (i, p) in degree7.iter_mut().enumerate() {*p = Vec2::new(i as f64 / 4.0 - 0.875, if i % 2 == 0 { -0.8 } else { 0.8 });}diff --git a/crates/sketch/src/curves.rs b/crates/sketch/src/curves.rsindex 885b878610..66a7fb2725 100644--- a/crates/sketch/src/curves.rs+++ b/crates/sketch/src/curves.rs@@ -153,7 +153,7 @@ pub fn spline_point(p: &[Vec2], control: bool, degree: u8, t: f64) -> Vec2 {return p.first().copied().unwrap_or_default();}if control {- return bspline_at(p, degree.clamp(1, 7) as usize, t);+ return bspline_at(p, degree.clamp(1, solidcraft_geom::MAX_BEZIER_DEGREE as u8) as usize, t);}let spans = fit_spans(p);let n = spans.len().max(1);@@ -292,7 +292,7 @@ pub fn spline_polyline(p: &[Vec2], control: bool, degree: u8) -> Vec<Vec2> {return p.to_vec();}if control {- return bspline_polyline(p, degree.clamp(1, 7) as usize);+ return bspline_polyline(p, degree.clamp(1, solidcraft_geom::MAX_BEZIER_DEGREE as u8) as usize);}let mut out = Vec::new();for (p0, p1, t0, t1) in fit_spans(p) {diff --git a/crates/sketch/src/freeform_offset.rs b/crates/sketch/src/freeform_offset.rsindex 20adc640db..6529cd0646 100644--- a/crates/sketch/src/freeform_offset.rs+++ b/crates/sketch/src/freeform_offset.rs@@ -137,7 +137,9 @@ impl H {let (points, weights) = match *seg {Seg2::Line { a, b } => (vec![a, b], vec![1.0; 2]),Seg2::Cubic { p0, p1, p2, p3 } => (vec![p0, p1, p2, p3], vec![1.0; 4]),- Seg2::Bezier { n, p } if (1..=7).contains(&n) => (p[..=usize::from(n)].to_vec(), vec![1.0; usize::from(n) + 1]),+ Seg2::Bezier { n, p } if (1..=solidcraft_geom::MAX_BEZIER_DEGREE as u8).contains(&n) => {+ (p[..=usize::from(n)].to_vec(), vec![1.0; usize::from(n) + 1])+ }Seg2::Conic { a, apex, b, w } if w.is_finite() && w > 0.0 => (vec![a, apex, b], vec![1.0, w, 1.0]),_ => return Err(bad("unsupported exact free-form offset piece")),};diff --git a/crates/sketch/src/link.rs b/crates/sketch/src/link.rsindex 8a8c274ab0..819a4d3a78 100644--- a/crates/sketch/src/link.rs+++ b/crates/sketch/src/link.rs@@ -256,7 +256,7 @@ impl LinkGeom {(!*periodic || (!*control && *degree == 3 && crate::periodic_beziers(pts).is_ok()))&& (2..=crate::curves::MAX_SPLINE_POINTS).contains(&pts.len())&& pts.iter().all(ok)- && (1..=7).contains(degree)+ && (1..=solidcraft_geom::MAX_BEZIER_DEGREE as u8).contains(degree)}}}diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rsindex 823a17a3e4..f6651e712e 100644--- a/crates/sketch/src/tests.rs+++ b/crates/sketch/src/tests.rs@@ -1,6 +1,6 @@use std::f64::consts::{FRAC_PI_2, PI};-use solidcraft_geom::Vec2;+use solidcraft_geom::{Seg2, Vec2};use crate::*;@@ -921,3 +921,49 @@ fn projected_boundary_keeps_its_pieces_when_only_stations_go() {assert!(sk.update_link(&j, &smaller).unwrap());assert_eq!(sk.link_curves(&j).len(), 4);}++#[test]+fn a_degree_nine_control_spline_stays_exact_and_closes_a_profile_exactly() {+ // A G4 blend curve is one degree-9 Bézier; a sketch keeps it as a control spline whose exact+ // piece is that Bézier, and profile measurement must keep using the curve, not its chords.+ let mut sk = Sketch::new();+ let bump =+ [v(0.0, 0.0), v(1.5, 4.0), v(3.0, 7.0), v(5.0, 9.5), v(7.5, 11.0), v(12.5, 11.0), v(15.0, 9.5), v(17.0, 7.0), v(18.5, 4.0), v(20.0, 0.0)];+ let pts: Vec<usize> = bump.iter().map(|q| sk.add_point(*q, None).unwrap()).collect();+ let s = sk.add_curve(CurveKind::Spline { pts: pts.clone(), control: true, degree: 9, periodic: false }, None).unwrap();+ let pieces = sk.exact_pieces(s);+ assert_eq!(pieces.len(), 1, "{pieces:?}");+ let Seg2::Bezier { n, p } = pieces[0] else { panic!("{:?}", pieces[0]) };+ assert_eq!(n, 9, "the highest degree a sketch piece can carry");+ for (i, q) in bump.iter().enumerate() {+ assert!(p[i].dist(*q) < 1e-12, "control {i}");+ }+ // Evaluation and the exact piece agree at the spline's real degree (a degree clamp would show+ // here), and a line's own exact piece still comes back as a line.+ let exact = pieces[0];+ for k in 0..=10 {+ let t = k as f64 / 10.0;+ assert!(crate::curves::spline_point(&bump, true, 9, t).dist(exact.point_at(t)) < 1e-9, "t={t}");+ }+ let l = sk.add_line(v(-5.0, 0.0), v(-2.0, 1.0), None, None, None).unwrap();+ assert!(matches!(sk.exact_pieces(l).as_slice(), [Seg2::Line { .. }]));+ // Close the loop: the region's area is the shoelace integral of the exact pieces, which a fine+ // sampling of the piece reproduces (a chord approximation would miss the bump's sagitta).+ sk.add_line(v(20.0, 0.0), v(0.0, 0.0), Some(pts[9]), Some(pts[0]), None).unwrap();+ let ps = find_profiles(&sk);+ assert_eq!(ps.len(), 1, "{ps:?}");+ let n = 20_000;+ let mut sampled = 0.0;+ for i in 0..n {+ let (t0, t1) = (i as f64 / n as f64, (i + 1) as f64 / n as f64);+ let (a, b) = (exact.point_at(t0), exact.point_at(t1));+ sampled += 0.5 * a.cross(b);+ }+ sampled -= 0.5 * v(20.0, 0.0).cross(v(0.0, 0.0));+ assert!((ps[0].area - sampled.abs()).abs() < 1e-5, "{} vs {sampled}", ps[0].area);+ assert!((ps[0].area - 100.0).abs() > 1e-3, "the region is not its chord: {}", ps[0].area);+ // A degree above the cap is still refused.+ let mut high: Vec<usize> = pts.clone();+ high.push(sk.add_point(v(21.0, -2.0), None).unwrap());+ assert!(sk.add_curve(CurveKind::Spline { pts: high, control: true, degree: 10, periodic: false }, None).is_err());+}diff --git a/crates/ui-egui/src/dialogs_surface.rs b/crates/ui-egui/src/dialogs_surface.rsindex 7694ad36ed..7426648803 100644--- a/crates/ui-egui/src/dialogs_surface.rs+++ b/crates/ui-egui/src/dialogs_surface.rs@@ -621,7 +621,7 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(K],)}- FeatureKind::SurfaceLoft { sections } => {+ FeatureKind::SurfaceLoft { sections, .. } => {(Surf::Loft, vec![sections.iter().flat_map(|sec| sheet_sels(app, sec.sketch.0, sec.profiles.as_ref(), &sec.curves)).collect()])}FeatureKind::SurfaceExtrude { sketch, profiles, curves, extent } => {diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex e5d72eeafc..0b17646178 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -682,10 +682,33 @@ fn build_scene(app: &SolveApp) -> GpuScene {}}}+ // Continuity analysis: each seam `inspect.continuity` measured, drawn over the model in the+ // colour of its worst verdict.+ for seam in &s.continuity {+ let col = continuity_color(seam.verdict);+ for w in seam.points.windows(2) {+ if let (Some(a), Some(b)) = (w.first(), w.get(1)) {+ sc.line(a.to_f32(), b.to_f32(), col, 2.6, true);+ }+ }+ }sc}+/// The colour of a measured seam: green within every tolerance, yellow where the faces only+/// meet at an angle (over G1), red where they do not meet at all or the curvature jumps across+/// them (over G2, the defect no chord tolerance shows). The greens, yellows and reds are the+/// ones the shader's own analyses use (`assets/shaders/viewport.wgsl`).+fn continuity_color(verdict: solidcraft_engine::kernel::SeamVerdict) -> [u8; 4] {+ use solidcraft_engine::kernel::SeamVerdict as V;+ match verdict {+ V::Smooth => [51, 191, 77, 255],+ V::Sharp => [242, 204, 38, 255],+ V::CurvatureJump | V::Gap => [217, 56, 51, 255],+ }+}+/// A soft dark ellipse on the ground under the shown bodies (darkest in the middle).fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {let tk = Tokens::get();diff --git a/docs/screenshots/class-a-blend.png b/docs/screenshots/class-a-blend.pngnew file mode 100644index 0000000000..59991f0ed4Binary files /dev/null and b/docs/screenshots/class-a-blend.png differdiff --git a/docs/screenshots/class-a-crown.png b/docs/screenshots/class-a-crown.pngnew file mode 100644index 0000000000..f38d6edd36Binary files /dev/null and b/docs/screenshots/class-a-crown.png differ