SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 287/509: Continuity Analysis measures G3 and G4; the dialogs offer what each construction builds
jyviko7c14ae2ce21f
diff --git a/apps/solidcraft-cli/src/kernel_cases.rs b/apps/solidcraft-cli/src/kernel_cases.rsindex 272c3c99b1..3d6a01bd1d 100644--- a/apps/solidcraft-cli/src/kernel_cases.rs+++ b/apps/solidcraft-cli/src/kernel_cases.rs@@ -126,7 +126,8 @@ const SEAM_ANGLE_DEG: f64 = 1.0;/// with how many seams and stations clear there were. An error where the seams can't be measured.fn curvature_jumps(body: &solidcraft_engine::kernel::Body, near: [f64; 3], within: f64, clear: f64) -> Result<Value, String> {use solidcraft_engine::geom::Vec3;- let tol = solidcraft_engine::kernel::ContinuityTolerances { gap_mm: 1e-3, angle_deg: SEAM_ANGLE_DEG, curvature_per_mm: 0.0 };+ let tol =+ solidcraft_engine::kernel::ContinuityTolerances { gap_mm: 1e-3, angle_deg: SEAM_ANGLE_DEG, curvature_per_mm: 0.0, ..Default::default() };let report = solidcraft_engine::kernel::seam_diagnostics(body, &[], SEAM_SAMPLES, tol).map_err(|e| e.to_string())?;let at = Vec3::new(near[0], near[1], near[2]);let seams: Vec<_> = reportdiff --git a/assets/locales/pending/continuity-g4.json b/assets/locales/pending/continuity-g4.jsonnew file mode 100644index 0000000000..364540c672--- /dev/null+++ b/assets/locales/pending/continuity-g4.json@@ -0,0 +1,30 @@+{+ "en": {+ "ui.continuity_smooth_curvature_change": "Smooth curvature change",+ "ui.continuity_smooth_curvature_change_tip": "Smooth curvature change (G4): even the way the curvature changes runs on smoothly across the seam."+ },+ "ar": {+ "ui.continuity_smooth_curvature_change": "تغيّر انحناء سلس",+ "ui.continuity_smooth_curvature_change_tip": "تغيّر انحناء سلس (G4): حتى طريقة تغيّر الانحناء تستمر بسلاسة عبر خط الالتقاء."+ },+ "de": {+ "ui.continuity_smooth_curvature_change": "Glatte Krümmungsänderung",+ "ui.continuity_smooth_curvature_change_tip": "Glatte Krümmungsänderung (G4): Selbst die Art, wie sich die Krümmung ändert, läuft an der Naht glatt weiter."+ },+ "he": {+ "ui.continuity_smooth_curvature_change": "שינוי עקמומיות חלק",+ "ui.continuity_smooth_curvature_change_tip": "שינוי עקמומיות חלק (G4): גם האופן שבו העקמומיות משתנה ממשיך בצורה חלקה לאורך התפר."+ },+ "ja": {+ "ui.continuity_smooth_curvature_change": "なめらかな曲率変化",+ "ui.continuity_smooth_curvature_change_tip": "なめらかな曲率変化 (G4): 境目で曲率の変わり方そのものもなめらかに続きます。"+ },+ "ko": {+ "ui.continuity_smooth_curvature_change": "부드러운 곡률 변화",+ "ui.continuity_smooth_curvature_change_tip": "부드러운 곡률 변화(G4): 이음매에서 곡률이 변하는 방식까지 부드럽게 이어집니다."+ },+ "zh": {+ "ui.continuity_smooth_curvature_change": "平滑曲率变化",+ "ui.continuity_smooth_curvature_change_tip": "平滑曲率变化 (G4):连曲率的变化方式在接缝处也平滑延续。"+ }+}diff --git a/crates/engine/src/cmd/surface_analysis.rs b/crates/engine/src/cmd/surface_analysis.rsindex 451562dd4b..079bd7ca24 100644--- a/crates/engine/src/cmd/surface_analysis.rs+++ b/crates/engine/src/cmd/surface_analysis.rs@@ -10,11 +10,6 @@ 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;@@ -48,11 +43,14 @@ pub static COMMANDS: &[CommandSpec] = &[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); \+ gap_tolerance_mm? (default 0.001), angle_tolerance_deg? (default 1), curvature_tolerance_per_mm? (default 0.01), \+ curvature_change_tolerance_per_mm2? (default 0.001), curvature_change_rate_tolerance_per_mm3? (default 0.0001); \add?: true keeps the seams already shaded and adds these (measuring an edge again replaces it); \- 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",+ clear?: true turns the analysis off. → each edge's worst gap (G0), normal angle (G1), curvature jump (G2), \+ jump of the curvature's change across the seam dκ/ds (G3) and of that change's rate d²κ/ds² (G4), from the \+ faces' exact derivatives, as {value, at: [x,y,z], edge_fraction}; its order (g0…g4: the highest every station \+ meets within the tolerances, null where the faces do not meet), its verdict (smooth: g2 or better, \+ curvature_jump, sharp or gap) and a summary; the seams are shaded in the viewport",),];@@ -127,10 +125,13 @@ fn continuity(s: &mut Session, p: &Value) -> Result<Value> {None => return Err(bad(cmd, "`samples` must be 3…257 stations along each edge")),},};+ let default = kernel::ContinuityTolerances::default();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)?,+ 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)?,+ curvature_change_per_mm2: tolerance(p, "curvature_change_tolerance_per_mm2", default.curvature_change_per_mm2)?,+ curvature_change_rate_per_mm3: tolerance(p, "curvature_change_rate_tolerance_per_mm3", default.curvature_change_rate_per_mm3)?,};let picks = edge_picks(p)?;let st = s.world_state()?;@@ -177,8 +178,14 @@ fn continuity(s: &mut Session, p: &Value) -> Result<Value> {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 { body: body.name.clone(), edge: seam.edge, points: seam.points.clone(), verdict: seam.verdict });+ summary.count(seam.verdict, seam.order);+ seams.push(ContinuitySeam {+ body: body.name.clone(),+ edge: seam.edge,+ points: seam.points.clone(),+ verdict: seam.verdict,+ order: seam.order,+ });rows.push(json!({"edge": seam.edge,"length_mm": seam.length,@@ -186,6 +193,9 @@ fn continuity(s: &mut Session, p: &Value) -> Result<Value> {"gap_mm": seam.gap_mm,"normal_angle_deg": seam.normal_angle_deg,"curvature_jump_per_mm": seam.curvature_jump_per_mm,+ "curvature_change_jump_per_mm2": seam.curvature_change_jump_per_mm2,+ "curvature_change_rate_jump_per_mm3": seam.curvature_change_rate_jump_per_mm3,+ "order": seam.order,"verdict": seam.verdict,}));}@@ -213,6 +223,8 @@ fn continuity(s: &mut Session, p: &Value) -> Result<Value> {"gap_mm": tolerances.gap_mm,"angle_deg": tolerances.angle_deg,"curvature_per_mm": tolerances.curvature_per_mm,+ "curvature_change_per_mm2": tolerances.curvature_change_per_mm2,+ "curvature_change_rate_per_mm3": tolerances.curvature_change_rate_per_mm3,},"bodies": bodies,"summary": {@@ -223,6 +235,7 @@ fn continuity(s: &mut Session, p: &Value) -> Result<Value> {"gap": summary.gap,"skipped": summary.skipped,"unmeasured": summary.unmeasured,+ "orders": summary.orders(),"worst": summary.worst(),},}))@@ -274,11 +287,16 @@ struct Summary {gap: usize,skipped: usize,unmeasured: usize,+ /// Seams by the highest order they meet, indexed by [`kernel::Continuity::order`].+ by_order: [usize; 5],}impl Summary {- fn count(&mut self, verdict: kernel::SeamVerdict) {+ fn count(&mut self, verdict: kernel::SeamVerdict, order: Option<kernel::Continuity>) {self.edges += 1;+ if let Some(slot) = order.and_then(|g| self.by_order.get_mut(g.order())) {+ *slot += 1;+ }match verdict {kernel::SeamVerdict::Smooth => self.smooth += 1,kernel::SeamVerdict::CurvatureJump => self.curvature_jump += 1,@@ -287,6 +305,11 @@ impl Summary {}}+ /// How many seams meet each order at best, by its word (`g0` … `g4`).+ fn orders(&self) -> serde_json::Map<String, Value> {+ kernel::Continuity::ALL.into_iter().zip(self.by_order).map(|(g, n)| (g.as_str().to_string(), json!(n))).collect()+ }+/// 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> {@@ -362,6 +385,7 @@ mod tests {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["order"], json!("g0"), "{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}");@@ -370,7 +394,11 @@ mod tests {}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["tolerances"],+ json!({"gap_mm": 1e-3, "angle_deg": 1.0, "curvature_per_mm": 0.01, "curvature_change_per_mm2": 1e-3, "curvature_change_rate_per_mm3": 1e-4})+ );+ assert_eq!(v["summary"]["orders"], json!({"g0": 12, "g1": 0, "g2": 0, "g3": 0, "g4": 0}));assert_eq!(v["summary"]["edges"], json!(12));assert_eq!(v["summary"]["sharp"], json!(12));assert_eq!(v["summary"]["worst"], json!("sharp"));@@ -395,7 +423,12 @@ mod tests {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!(e["order"], json!("g1"), "a plane tangent to a cylinder is G1, not G2: {e}");+ assert!(e["curvature_change_jump_per_mm2"]["value"].as_f64().unwrap() < 1e-9, "{e}");+ assert!(e["curvature_change_rate_jump_per_mm3"]["value"].as_f64().unwrap() < 1e-9, "{e}");}+ assert_eq!(v["summary"]["orders"]["g1"], json!(2));+ assert_eq!(s.continuity.iter().filter(|seam| seam.order == Some(crate::kernel::Continuity::G1)).count(), 2);assert_eq!(v["summary"]["curvature_jump"], json!(2));assert_eq!(v["summary"]["sharp"], json!(13));assert_eq!(v["summary"]["smooth"], json!(0));@@ -473,6 +506,8 @@ mod tests {json!({"gap_tolerance_mm": 1e12}),json!({"angle_tolerance_deg": f64::NAN}),json!({"curvature_tolerance_per_mm": "tight"}),+ json!({"curvature_change_tolerance_per_mm2": -0.5}),+ json!({"curvature_change_rate_tolerance_per_mm3": null}),json!({"edges": 3}),json!({"edges": [[1, 2]]}),json!({"edges": [[]]}),diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex ef62f48025..07016b2cbd 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -503,6 +503,9 @@ pub struct ContinuitySeam {pub points: Vec<Vec3>,/// The seam's worst verdict along its length.pub verdict: kernel::SeamVerdict,+ /// The highest continuity order it meets along its whole length (`None`: the faces do not+ /// meet).+ pub order: Option<kernel::Continuity>,}/// A face Isocurve Analysis shows: the body, the picked point on the face (its face is founddiff --git a/crates/engine/src/thread_tests.rs b/crates/engine/src/thread_tests.rsindex 6d6ff0ba52..b9c2a6b4bf 100644--- a/crates/engine/src/thread_tests.rs+++ b/crates/engine/src/thread_tests.rs@@ -1040,7 +1040,7 @@ fn a_modelled_threads_flank_joins_are_not_drawn() {.get(f as usize).is_some_and(|f| f.nurbs.is_none() && matches!(f.surface, Surface::Spline { .. } | Surface::RationalSpline { .. }))};- let tolerances = solidcraft_kernel::ContinuityTolerances { gap_mm: 1e-3, angle_deg: 0.5, curvature_per_mm: 1.0 };+ let tolerances = solidcraft_kernel::ContinuityTolerances { gap_mm: 1e-3, angle_deg: 0.5, curvature_per_mm: 1.0, ..Default::default() };let report = solidcraft_kernel::seam_diagnostics(body, &[], 33, tolerances).unwrap();let mut flank_joins = 0;let mut worst: f64 = 0.0;diff --git a/crates/kernel/src/continuity.rs b/crates/kernel/src/continuity.rsindex 74363a2f8b..fd8c37bf73 100644--- a/crates/kernel/src/continuity.rs+++ b/crates/kernel/src/continuity.rs@@ -1,12 +1,18 @@//! 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)?+//! at an edge share a curve (G0), a tangent plane (G1), a curvature (G2), the way that curvature+//! changes across the seam (G3) and the way that change changes (G4)?//!//! 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+//! the edge, from the second fundamental form of each surface (G2); the curvature-change jump and+//! its rate's jump compare the first and second arc-length derivatives of those normal sections'+//! curvatures across the edge (G3, G4). All three come from each surface's exact partial+//! derivatives ([`solidcraft_geom::brep::normal_section`]), never from samples. Each seam's+//! [`SeamReport::order`] is the highest order whose test, and every lower one, its worst station+//! passes. 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.//!@@ -15,9 +21,11 @@use serde::Serialize;use solidcraft_geom::Vec3;+use solidcraft_geom::brep::normal_section::{SectionJet, normal_section};use solidcraft_geom::brep::{self as b, eval::CurveEval, eval::SurfaceEval};use crate::body::Body;+use crate::continuity_order::Continuity;use crate::{KernelError, Result};/// Bodies with more edges than this are refused rather than sampled for minutes.@@ -54,8 +62,37 @@ pub struct ContinuityTolerances {pub angle_deg: f64,/// Largest curvature jump that still counts as curvature continuous (G2), 1/mm.pub curvature_per_mm: f64,+ /// Largest jump of the curvature's change across the seam that still counts as G3, 1/mm².+ pub curvature_change_per_mm2: f64,+ /// Largest jump of that change's rate that still counts as G4, 1/mm³.+ pub curvature_change_rate_per_mm3: f64,}+impl Default for ContinuityTolerances {+ /// A micron of gap, a degree of normal angle, a curvature jump of 1/100 mm, and a change of+ /// curvature (and its rate) a tenth as large again per millimetre.+ fn default() -> Self {+ ContinuityTolerances {+ gap_mm: 1e-3,+ angle_deg: 1.0,+ curvature_per_mm: 1e-2,+ curvature_change_per_mm2: 1e-3,+ curvature_change_rate_per_mm3: 1e-4,+ }+ }+}++impl ContinuityTolerances {+ /// The tolerance of each metric, in [`Metrics`] order (G0 … G4).+ fn by_order(&self) -> Metrics {+ [self.gap_mm, self.angle_deg, self.curvature_per_mm, self.curvature_change_per_mm2, self.curvature_change_rate_per_mm3]+ }+}++/// One value per order a seam is tested for, G0 … G4: the gap, the normal angle, and the jumps of+/// the curvature, of its change, and of that change's rate.+type Metrics = [f64; 5];+/// The worst value of one metric along an edge, with where it was found.#[derive(Clone, Copy, Debug, Serialize)]pub struct SeamWorst {@@ -67,8 +104,9 @@ pub struct SeamWorst {}/// 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.+/// curvature continuous (G2 or better: [`SeamReport::order`] says how much 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 {@@ -78,6 +116,18 @@ pub enum SeamVerdict {Gap,}+impl SeamVerdict {+ /// The verdict of a seam whose highest order met is `order` (`None`: not even G0).+ pub fn of(order: Option<Continuity>) -> SeamVerdict {+ match order {+ None => SeamVerdict::Gap,+ Some(Continuity::G0) => SeamVerdict::Sharp,+ Some(Continuity::G1) => SeamVerdict::CurvatureJump,+ Some(_) => SeamVerdict::Smooth,+ }+ }+}+/// One edge's diagnostics: the worst of each metric along it, and where.#[derive(Clone, Debug, Serialize)]pub struct SeamReport {@@ -90,7 +140,14 @@ pub struct SeamReport {pub gap_mm: SeamWorst,pub normal_angle_deg: SeamWorst,pub curvature_jump_per_mm: SeamWorst,- /// What the tolerances make of the seam.+ /// The worst jump of the curvature's arc-length derivative across the seam (G3), 1/mm².+ pub curvature_change_jump_per_mm2: SeamWorst,+ /// The worst jump of its second derivative (G4), 1/mm³.+ pub curvature_change_rate_jump_per_mm3: SeamWorst,+ /// The highest order every station meets within the tolerances (`None`: the faces do not+ /// meet).+ pub order: Option<Continuity>,+ /// What the tolerances make of the seam ([`SeamVerdict::of`] its order).pub verdict: SeamVerdict,/// The stations in order: what a viewport shades.pub points: Vec<Vec3>,@@ -98,7 +155,7 @@ pub struct SeamReport {pub stations: Vec<SeamStation>,}-/// One station of a seam: how far along the edge, and the three metrics there.+/// One station of a seam: how far along the edge, and the five metrics there.#[derive(Clone, Copy, Debug, Serialize)]pub struct SeamStation {/// 0 at the edge's start, 1 at its end.@@ -106,6 +163,28 @@ pub struct SeamStation {pub gap_mm: f64,pub normal_angle_deg: f64,pub curvature_jump_per_mm: f64,+ pub curvature_change_jump_per_mm2: f64,+ pub curvature_change_rate_jump_per_mm3: f64,+}++impl SeamStation {+ fn new(edge_fraction: f64, m: Metrics) -> SeamStation {+ let [gap_mm, normal_angle_deg, curvature_jump_per_mm, curvature_change_jump_per_mm2, curvature_change_rate_jump_per_mm3] = m;+ SeamStation {+ edge_fraction,+ gap_mm,+ normal_angle_deg,+ curvature_jump_per_mm,+ curvature_change_jump_per_mm2,+ curvature_change_rate_jump_per_mm3,+ }+ }+}++/// The highest order whose metric, and every lower one, is within its tolerance.+fn highest_met(worst: Metrics, tolerances: Metrics) -> Option<Continuity> {+ let met = worst.iter().zip(tolerances).take_while(|(w, t)| **w <= *t).count();+ met.checked_sub(1).and_then(Continuity::from_order)}/// The seam diagnostics of one body.@@ -160,7 +239,8 @@ pub fn seam_diagnostics(body: &Body, edges: &[usize], samples: usize, tolerancesif !(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)] {+ let names = ["gap", "angle", "curvature", "curvature change", "curvature change rate"];+ for (name, value) in names.into_iter().zip(tolerances.by_order()) {// 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")));@@ -289,7 +369,7 @@ fn measure(body: &Body, edges: &[usize], samples: usize, tolerances: ContinuityTOk(ContinuityReport { seams, skipped, unmeasured })}-/// One edge's worst gap, normal angle and curvature jump.+/// One edge's worst gap, normal angle and jumps of curvature, its change and that change's rate.fn seam(index: usize,curve: &CurveEval,@@ -301,52 +381,22 @@ fn seam() -> Option<SeamReport> {// 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 gap = None;- let mut angle = None;- let mut jump = None;+ let mut worst: [Option<SeamWorst>; 5] = [None; 5];let mut points = Vec::with_capacity(samples);let mut stations = Vec::with_capacity(samples);for k in 0..samples {- let f = fraction(k);+ let f = k as f64 / steps as f64;let Some((at, tangent)) = curve.derivs(t0 + (t1 - t0) * f) else { continue };- 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 Some(tangent) = tangent.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 };- let station = SeamStation {- edge_fraction: f,- gap_mm: qa.dist(qb),- normal_angle_deg: na.dot(nb).clamp(-1.0, 1.0).acos().to_degrees(),- curvature_jump_per_mm: signed.abs(),- };+ let Some(metrics) = station(at, tangent, &mut on_a, &mut on_b) else { continue };points.push(at);- stations.push(station);- keep(&mut gap, station.gap_mm, at, f);- keep(&mut angle, station.normal_angle_deg, at, f);- keep(&mut jump, station.curvature_jump_per_mm, 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- };+ stations.push(SeamStation::new(f, metrics));+ for (w, value) in worst.iter_mut().zip(metrics) {+ keep(w, value, at, f);+ }+ }+ let [gap, angle, jump, change, rate] = worst;+ let [gap, angle, jump, change, rate] = [gap?, angle?, jump?, change?, rate?];+ let order = highest_met([gap.value, angle.value, jump.value, change.value, rate.value], tolerances.by_order());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,@@ -355,12 +405,38 @@ fn seam(gap_mm: gap,normal_angle_deg: angle,curvature_jump_per_mm: jump,- verdict,+ curvature_change_jump_per_mm2: change,+ curvature_change_rate_jump_per_mm3: rate,+ order,+ verdict: SeamVerdict::of(order),points,stations,})}+/// The five metrics at the seam point `at` (edge tangent `tangent`): both projections and both+/// faces' normal sections square to the seam, or the station says nothing.+fn station(at: Vec3, tangent: Vec3, on_a: &mut FaceSurface, on_b: &mut FaceSurface) -> Option<Metrics> {+ if !at.is_finite() {+ return None;+ }+ let ((qa, na, uv_a), (qb, nb, uv_b)) = (on_a.project(at)?, on_b.project(at)?);+ let tangent = tangent.normalized()?;+ let ja = on_a.section(uv_a, na, across(na, tangent))?;+ let jb = on_b.section(uv_b, nb, across(nb, tangent))?;+ // The faces' outward normals agree on a smooth seam; where they are opposed (a knife edge)+ // the sections are compared in one frame: face b's normal and its across direction both turn+ // round, so its k-th derivative of curvature reads (−1)^(k+1) times as much in face a's.+ let opposed = na.dot(nb) < 0.0;+ let jump = |k: usize, a: f64, b: f64| {+ let flip = if opposed && k % 2 == 0 { -1.0 } else { 1.0 };+ (a - flip * b).abs()+ };+ let [ka, ca, ra] = ja.values();+ let [kb, cb, rb] = jb.values();+ Some([qa.dist(qb), na.dot(nb).clamp(-1.0, 1.0).acos().to_degrees(), jump(0, ka, kb), jump(1, ca, cb), jump(2, ra, rb)])+}+/// 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).@@ -402,40 +478,12 @@ impl FaceSurface {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; 2], normal: Vec3, direction: Vec3) -> Option<f64> {- let (_, ru, rv) = self.surface.derivs(uv[0], uv[1])?;- let (ruu, ruv, rvv) = self.surface.second(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(ruu * (du * du) + ruv * (2.0 * du * dv) + rvv * (dv * dv));- (second / (speed * speed)).is_finite().then_some(second / (speed * speed))+ /// The face's normal section at `uv` along `direction` (a unit vector of its tangent plane):+ /// its curvature `κ = n · r″` and κ's first two arc-length derivatives, from the surface's+ /// exact partials. 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).+ fn section(&self, uv: [f64; 2], normal: Vec3, direction: Vec3) -> Option<SectionJet> {+ normal_section(&self.surface.partials(uv[0], uv[1])?, normal, direction)}}@@ -443,10 +491,10 @@ impl FaceSurface {#[allow(clippy::unwrap_used)]mod tests {use super::*;- use solidcraft_geom::Plane;+ use solidcraft_geom::{Plane, Seg2};fn tolerances() -> ContinuityTolerances {- ContinuityTolerances { gap_mm: 1e-3, angle_deg: 1.0, curvature_per_mm: 0.01 }+ ContinuityTolerances::default()}fn box_body() -> Body {@@ -468,6 +516,7 @@ mod tests {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.order, Some(Continuity::G0));assert_eq!(seam.samples, 33);assert!((seam.length - 10.0).abs() < 1e-9);}@@ -488,6 +537,9 @@ mod tests {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);+ // A plane tangent to a cylinder: G1, not G2. Neither section's curvature changes.+ assert_eq!(seam.order, Some(Continuity::G1));+ assert!(seam.curvature_change_jump_per_mm2.value < 1e-9 && seam.curvature_change_rate_jump_per_mm3.value < 1e-9);}assert_eq!(r.seams.iter().filter(|s| s.verdict == SeamVerdict::Sharp).count(), 13);}@@ -517,6 +569,89 @@ mod tests {}}+ /// A 3 mm tall prism over a profile that runs along a line from (-20, 0) to the origin, on+ /// into `transition` (starting at the origin, leaving along +x), and back straight to+ /// (-20, 20): its one tangent wall seam is the line meeting the transition.+ fn line_into(transition: Seg2) -> Body {+ use solidcraft_geom::{Loop2, Region2, Vec2};+ let end = match transition {+ Seg2::Cubic { p3, .. } => p3,+ Seg2::Bezier { n, p } => p[usize::from(n)],+ _ => Vec2::new(0.0, 0.0),+ };+ let outer = Loop2 {+ segs: vec![+ Seg2::Line { a: Vec2::new(-20.0, 0.0), b: Vec2::new(0.0, 0.0) },+ transition,+ Seg2::Line { a: end, b: Vec2::new(-20.0, 20.0) },+ Seg2::Line { a: Vec2::new(-20.0, 20.0), b: Vec2::new(-20.0, 0.0) },+ ],+ };+ crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0.0, 3.0).unwrap().remove(0)+ }++ /// The one seam of `body` where the faces are tangent.+ fn tangent_seam(body: &Body) -> SeamReport {+ let r = report(body);+ let mut tangent: Vec<SeamReport> = r.seams.into_iter().filter(|s| s.normal_angle_deg.value < 0.01).collect();+ assert_eq!(tangent.len(), 1, "{tangent:?}");+ tangent.remove(0)+ }++ /// A plane into a cubic whose first three control points lie on the plane's line: the cubic+ /// starts with zero curvature (G2), but its curvature changes there. For control points+ /// (0,0), (L,0), (2L,0), (3L,H): B′ = (3L, 0), B″ = 0 and B‴ = (0, 6H) at the start, so+ /// dκ/dt = (x′y‴ − y′x‴) / |B′|³ = 2H / (3L²) and, at ds/dt = 3L, dκ/ds = 2H / (9L³): with+ /// L = H = 10, 2 / 900 per mm².+ #[test]+ fn a_plane_into_a_g2_transition_is_curvature_continuous_but_not_g3() {+ use solidcraft_geom::Vec2;+ let v = Vec2::new;+ let body = line_into(Seg2::Cubic { p0: v(0.0, 0.0), p1: v(10.0, 0.0), p2: v(20.0, 0.0), p3: v(30.0, 10.0) });+ let seam = tangent_seam(&body);+ assert!(seam.curvature_jump_per_mm.value < 1e-9, "{}", seam.curvature_jump_per_mm.value);+ let change = seam.curvature_change_jump_per_mm2.value;+ assert!((change - 2.0 / 900.0).abs() < 1e-9, "dκ/ds 2/900, got {change}");+ assert_eq!(seam.order, Some(Continuity::G2));+ assert_eq!(seam.verdict, SeamVerdict::Smooth, "G2 is still smooth to the older verdict");+ }++ /// A plane into a quartic whose first four control points are evenly spaced on the plane's+ /// line: curvature and its change both start at zero (G3), but the change's rate does not.+ /// For (0,0), (L,0), (2L,0), (3L,0), (4L,H): B′ = (4L, 0), B″ = B‴ = 0 and B⁗ = (0, 24H),+ /// so d²κ/dt² = (x′y⁗ − y′x⁗) / |B′|³ = 3H / (2L²) and, at ds/dt = 4L, d²κ/ds² = 3H / (32L⁴):+ /// with L = 5, H = 10, 3 / 2000 per mm³.+ #[test]+ fn a_plane_into_a_g3_transition_holds_the_change_of_curvature_but_not_g4() {+ use solidcraft_geom::Vec2;+ let mut p = [Vec2::new(0.0, 0.0); solidcraft_geom::MAX_BEZIER_CTRL];+ for (k, q) in [(5.0, 0.0), (10.0, 0.0), (15.0, 0.0), (20.0, 10.0)].into_iter().enumerate() {+ p[k + 1] = Vec2::new(q.0, q.1);+ }+ let body = line_into(Seg2::Bezier { n: 4, p });+ let seam = tangent_seam(&body);+ assert!(seam.curvature_jump_per_mm.value < 1e-9 && seam.curvature_change_jump_per_mm2.value < 1e-9, "{seam:?}");+ let rate = seam.curvature_change_rate_jump_per_mm3.value;+ assert!((rate - 3.0 / 2000.0).abs() < 1e-9, "d²κ/ds² 3/2000, got {rate}");+ assert_eq!(seam.order, Some(Continuity::G3));+ // Within a looser rate tolerance the same seam reads G4.+ let loose = ContinuityTolerances { curvature_change_rate_per_mm3: 1e-2, ..tolerances() };+ let r = seam_diagnostics(&body, &[seam.edge], 33, loose).unwrap();+ assert_eq!(r.seams[0].order, Some(Continuity::G4));+ }++ #[test]+ fn the_highest_order_met_needs_every_order_below_it() {+ let tol = [1.0; 5];+ assert_eq!(highest_met([0.0; 5], tol), Some(Continuity::G4));+ assert_eq!(highest_met([0.0, 0.0, 2.0, 0.0, 0.0], tol), Some(Continuity::G1), "a G2 failure caps the order");+ assert_eq!(highest_met([2.0, 0.0, 0.0, 0.0, 0.0], tol), None, "faces that do not meet have no order");+ assert_eq!(highest_met([0.0, 0.0, 0.0, f64::NAN, 0.0], tol), Some(Continuity::G2), "NaN never passes");+ for (order, verdict) in [(None, SeamVerdict::Gap), (Some(Continuity::G0), SeamVerdict::Sharp), (Some(Continuity::G3), SeamVerdict::Smooth)] {+ assert_eq!(SeamVerdict::of(order), verdict);+ }+ }+#[test]fn picks_refuse_what_is_not_there() {let body = box_body();@@ -531,6 +666,7 @@ mod tests {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, &[], 33, ContinuityTolerances { curvature_change_rate_per_mm3: -1.0, ..tolerances() }).is_err());assert!(seam_diagnostics(&body, &[999], 33, tolerances()).is_err());}}diff --git a/crates/kernel/src/corner_g2_tests.rs b/crates/kernel/src/corner_g2_tests.rsindex 5b25e12225..bf0aa7a84f 100644--- a/crates/kernel/src/corner_g2_tests.rs+++ b/crates/kernel/src/corner_g2_tests.rs@@ -25,7 +25,9 @@ fn corner_seams(body: &Body, share: f64) -> (f64, f64, usize) {.map(|(i, _)| i).collect();let edges: Vec<usize> = (0..rec.edges.len()).filter(|e| rec.edges[*e].uses.iter().any(|u| corner_faces.contains(&(u.face as usize)))).collect();- let report = seam_diagnostics(body, &edges, 65, ContinuityTolerances { gap_mm: 1e-3, angle_deg: 1.0, curvature_per_mm: 1e-6 }).unwrap();+ let report =+ seam_diagnostics(body, &edges, 65, ContinuityTolerances { gap_mm: 1e-3, angle_deg: 1.0, curvature_per_mm: 1e-6, ..Default::default() })+ .unwrap();// The corner's vertices where its boundary turns: an end of two of its seams whose// directions there differ.let ends: Vec<(Vec3, Vec3, f64)> = reportdiff --git a/crates/ui-egui/src/dialogs_surface.rs b/crates/ui-egui/src/dialogs_surface.rsindex 3886152a06..6581adf296 100644--- a/crates/ui-egui/src/dialogs_surface.rs+++ b/crates/ui-egui/src/dialogs_surface.rs@@ -9,6 +9,7 @@ use solidcraft_engine::Sel;use solidcraft_engine::doc::expr::Kind as ValueKind;use solidcraft_engine::doc::{AxisRef, Direction, FaceAt, FeatureKind, Mat, PlaneRef, Position, ProfileSel, RuledCorners, RuledMode};use solidcraft_engine::geom::Vec3;+use solidcraft_engine::kernel::{Construction, Continuity};use crate::SolveApp;use crate::dialogs::{Kind, OP_LABELS, OPS, combo, form_row, op_index};@@ -58,21 +59,21 @@ crate::dialog_descriptor::dialog_descriptors! {Loft {rail_fit: usize,},- /// `continuity`: an index into [`BLEND_CONTINUITY`] for each end, [from, to]; `bulge`: how+ /// `continuity`: an index into [`BLEND_ORDERS`] for each end, [from, to]; `bulge`: how/// full each end leaves (0 is the plain bridge); `stitch`: sew the blend onto both bodies.Blend {continuity: [usize; 2],bulge: [f64; 2],stitch: bool,},- /// `continuity`: an index into [`PATCH_CONTINUITY`] (for a loop of sketch curves, how much of+ /// `continuity`: an index into [`BOUNDARY_ORDERS`] (for a loop of sketch curves, how much of/// the sketch's plane each side repeats; for picked edges, how the surface meets the faces/// beside them); `join`: sew the surface into the body of its edges.Boundary {continuity: usize,join: bool,},- /// `continuity`: an index into [`PATCH_CONTINUITY`] (how a patch on edges meets the faces+ /// `continuity`: an index into [`PATCH_ORDERS`] (how a patch on edges meets the faces/// beside its loop).Patch {continuity: usize,@@ -137,29 +138,51 @@ impl Surf {}}-/// How a patch on edges meets the faces beside its loop (labels, and the `continuity` parameter).-/// Labels are plain words; the order's code (G0, G1, G2) is in each one's hover text.-const PATCH_CONTINUITY: [(&str, &str); 3] = [("ui.continuity_position", "g0"), ("ui.continuity_tangent", "g1"), ("ui.continuity_curvature", "g2")];+/// A dialog's continuity choices: the orders a construction builds, from the kernel's table+/// ([`Construction::offered`]), so an order a construction learns shows up here by itself. The+/// dialog keeps an index into them; labels are plain words, each order's code (G0 …) is in the+/// hover text.+#[derive(Clone, Copy, Debug)]+struct Orders(Construction);-/// How much of the surface at its edges each end of a blend repeats (labels, and the-/// `continuity` words).-const BLEND_CONTINUITY: [(&str, &str); 4] =- [("ui.continuity_position", "g0"), ("ui.continuity_tangent", "g1"), ("ui.continuity_curvature", "g2"), ("ui.continuity_curvature_change", "g3")];+/// How a patch on edges meets the faces beside its loop.+const PATCH_ORDERS: Orders = Orders(Construction::Patch);+/// How much of the surface at its edges each end of a blend repeats.+const BLEND_ORDERS: Orders = Orders(Construction::Bridge);+/// A boundary's one row serves its loop patch (a bridge) and its curve network alike: the orders+/// a network builds, the fewer of the two.+const BOUNDARY_ORDERS: Orders = Orders(Construction::Network);-/// Each continuity's hover text, in the order of [`BLEND_CONTINUITY`]: where its code (G0 … G3)-/// is shown.-const CONTINUITY_TIPS: [&str; 4] =- ["ui.continuity_position_tip", "ui.continuity_tangent_tip", "ui.continuity_curvature_tip", "ui.continuity_curvature_change_tip"];+impl Orders {+ fn all(self) -> Vec<Continuity> {+ self.0.offered()+ }-/// A Continuity row's segments over `orders` (the segments draw their text as given).-fn continuity_segments(ui: &mut egui::Ui, selected: &mut usize, orders: &[(&str, &str)]) -> egui::Response {- let labels: Vec<&str> = orders.iter().map(|(label, _)| crate::i18n::tr(label)).collect();- ui.scope(|ui| ui_kit::segmented(ui, selected, &labels, Default::default())).response-}+ /// The message ids of the labels, in order.+ fn labels(self) -> Vec<&'static str> {+ self.all().into_iter().map(Continuity::label_id).collect()+ }++ /// The hover text: a line for each order.+ fn tip(self) -> String {+ self.all().into_iter().map(|g| crate::i18n::tr(g.tip_id())).collect::<Vec<_>>().join("\n")+ }-/// The hover text of a list of `orders` continuities: a line for each.-fn continuity_tip(orders: usize) -> String {- CONTINUITY_TIPS.iter().take(orders).map(|tip| crate::i18n::tr(tip)).collect::<Vec<_>>().join("\n")+ /// The command word of the choice at `index`.+ fn word(self, index: usize) -> Option<&'static str> {+ self.all().get(index).map(|g| g.as_str())+ }++ /// The index of `g` among the choices (`None`: not offered).+ fn index(self, g: Continuity) -> Option<usize> {+ self.all().iter().position(|o| *o == g)+ }++ /// A Continuity row's segments (the segments draw their text as given).+ fn segments(self, ui: &mut egui::Ui, selected: &mut usize) -> egui::Response {+ let labels: Vec<&str> = self.labels().into_iter().map(crate::i18n::tr).collect();+ ui.scope(|ui| ui_kit::segmented(ui, selected, &labels, Default::default())).response+ }}/// What a boundary surface becomes: a body of its own, or part of the body of its edges.@@ -292,27 +315,23 @@ pub fn rows(ui: &mut egui::Ui, k: &mut Surf) -> bool {ui_kit::options(ui, "untrim_options", &mut [("Restore outer boundary", outer), ("In place (surfaces)", in_place)]);}Surf::Patch { continuity } => {- form_row(ui, "Continuity", |ui| continuity_segments(ui, continuity, &PATCH_CONTINUITY))- .on_hover_text(continuity_tip(PATCH_CONTINUITY.len()));+ form_row(ui, "Continuity", |ui| PATCH_ORDERS.segments(ui, continuity)).on_hover_text(PATCH_ORDERS.tip());}Surf::Blend { continuity, bulge, stitch } => {let [from, to] = continuity;let [from_bulge, to_bulge] = bulge;- form_row(ui, "Start continuity", |ui| ui_kit::dropdown(ui, "bl_cont0", from, &BLEND_CONTINUITY.map(|(label, _)| label)))- .on_hover_text(continuity_tip(BLEND_CONTINUITY.len()));+ form_row(ui, "Start continuity", |ui| ui_kit::dropdown(ui, "bl_cont0", from, &BLEND_ORDERS.labels())).on_hover_text(BLEND_ORDERS.tip());form_row(ui, "Start bulge", |ui| {ui_kit::scalar_field(ui, from_bulge, -0.9..=3.0);});- form_row(ui, "End continuity", |ui| ui_kit::dropdown(ui, "bl_cont1", to, &BLEND_CONTINUITY.map(|(label, _)| label)))- .on_hover_text(continuity_tip(BLEND_CONTINUITY.len()));+ form_row(ui, "End continuity", |ui| ui_kit::dropdown(ui, "bl_cont1", to, &BLEND_ORDERS.labels())).on_hover_text(BLEND_ORDERS.tip());form_row(ui, "End bulge", |ui| {ui_kit::scalar_field(ui, to_bulge, -0.9..=3.0);});ui_kit::options(ui, "blend_options", &mut [("Stitch to both bodies", stitch)]);}Surf::Boundary { continuity, join } => {- form_row(ui, "Continuity", |ui| continuity_segments(ui, continuity, &PATCH_CONTINUITY))- .on_hover_text(continuity_tip(PATCH_CONTINUITY.len()));+ form_row(ui, "Continuity", |ui| BOUNDARY_ORDERS.segments(ui, continuity)).on_hover_text(BOUNDARY_ORDERS.tip());form_row(ui, "Operation", |ui| {let mut op = usize::from(*join);combo(ui, "bo_op", &BOUNDARY_OPS, &mut op);@@ -565,7 +584,7 @@ pub fn commands(app: &SolveApp, k: &Surf, inputs: &[SelInput], extra: &Map<Strinlet (body, edges) = body_and_edges(items(inputs, i))?;Ok(json!({"body": body, "edges": edges}))};- let word = |i: usize| BLEND_CONTINUITY.get(i).map_or("g1", |(_, w)| *w);+ let word = |i: usize| BLEND_ORDERS.word(i).unwrap_or("g1");let mut p = json!({"from": side(0)?,"to": side(1)?,@@ -579,7 +598,7 @@ pub fn commands(app: &SolveApp, k: &Surf, inputs: &[SelInput], extra: &Map<Strin}Surf::Boundary { continuity, join } => {need(0, "the curves (sketch curves or edges)")?;- let word = PATCH_CONTINUITY.get(*continuity).map_or("g0", |(_, w)| *w);+ let word = BOUNDARY_ORDERS.word(*continuity).unwrap_or("g0");let across = items(inputs, 1);let picks = items(inputs, 0);let sketch_ids: Vec<String> = picks.curve_ids();@@ -628,7 +647,7 @@ pub fn commands(app: &SolveApp, k: &Surf, inputs: &[SelInput], extra: &Map<Strinlet edges: Vec<Value> = items(inputs, 0).edge_points().into_iter().map(pt).collect();let body = items(inputs, 0).iter().find_map(|x| if let Sel::Edge { body, .. } = x { Some(body.clone()) } else { None });let mut p = json!({"edges": edges, "body": body});- if let Some((_, word)) = PATCH_CONTINUITY.get(*continuity).filter(|_| *continuity > 0) {+ if let Some(word) = PATCH_ORDERS.word(*continuity).filter(|_| *continuity > 0) {p["continuity"] = json!(word);}let points: Vec<Value> = items(inputs, 1)@@ -866,7 +885,7 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(K)}FeatureKind::SurfaceBlend { from, to, continuity, bulge, align, seam, stitch } => {- let index = |c: &solidcraft_engine::doc::kernel::Continuity| BLEND_CONTINUITY.iter().position(|(_, w)| *w == c.as_str()).unwrap_or(1);+ let index = |c: &Continuity| BLEND_ORDERS.index(*c).unwrap_or(1);let k = Surf::Blend { continuity: continuity.each_ref().map(index), bulge: *bulge, stitch: *stitch };// What the dialog does not show is kept as it was: the leave directions and the seams.let mut extra = Map::new();@@ -882,8 +901,8 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(Kreturn Some((Kind::Surface(k), ins, extra));}FeatureKind::SurfaceBoundary { sketch, curves, orders, crown, samples, .. } => {- let first = orders.first().copied().unwrap_or(solidcraft_engine::doc::kernel::Continuity::G1);- let index = PATCH_CONTINUITY.iter().position(|(_, w)| *w == first.as_str());+ let first = orders.first().copied().unwrap_or(Continuity::G1);+ let index = BOUNDARY_ORDERS.index(first);// What the dialog does not show is kept as it was: a crown, the stations, and orders// that differ from side to side or that the list does not offer (G3).let mut extra = Map::new();@@ -924,8 +943,8 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(K}).collect()};- let g = u.iter().chain(v).find(|c| c.body.is_some()).map_or(solidcraft_engine::doc::kernel::Continuity::G0, |c| c.continuity);- let index = PATCH_CONTINUITY.iter().position(|(_, w)| *w == g.as_str()).unwrap_or(0);+ let g = u.iter().chain(v).find(|c| c.body.is_some()).map_or(Continuity::G0, |c| c.continuity);+ let index = BOUNDARY_ORDERS.index(g).unwrap_or(0);(Surf::Boundary { continuity: index, join: *operation == solidcraft_engine::doc::Operation::Join }, vec![sels(u), sels(v)])}FeatureKind::SurfaceLoft { sections, rails, rail_fit, .. } => {@@ -957,7 +976,7 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(Ksels.extend((0..ss.profiles.len()).map(|index| Sel::Profile { sketch: sk.0, index }));}}- let index = PATCH_CONTINUITY.iter().position(|(_, w)| *w == continuity.all.as_str()).unwrap_or(0);+ let index = PATCH_ORDERS.index(continuity.all).unwrap_or(0);// What the dialog does not show is kept as it was: the crown, edges with a// continuity of their own, and points that are not on a face any more.let through: Vec<Sel> = points.iter().filter_map(|p| crate::dialogs::face_sel(s, p.0)).collect();@@ -1103,3 +1122,40 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(K}Some((Kind::Surface(k), ins, Map::new()))}++#[cfg(test)]+mod tests {+ use super::*;++ /// Whether `text` names a continuity by its code (G0 … G4).+ fn coded(text: &str) -> bool {+ Continuity::ALL.iter().any(|g| text.contains(g.code()))+ }++ /// The Patch, Blend and Boundary rows offer what their construction builds, from G0; their+ /// labels are words in every complete catalogue (and the RTL ones), never a code, and each+ /// hover line names its order's code for those who know it.+ #[test]+ fn continuity_rows_are_words_and_keep_the_codes_for_the_hover_text() {+ for orders in [PATCH_ORDERS, BLEND_ORDERS, BOUNDARY_ORDERS] {+ let all = orders.all();+ assert_eq!(all, orders.0.offered());+ assert_eq!(all.first(), Some(&Continuity::G0), "{orders:?}");+ for (i, g) in all.iter().enumerate() {+ assert_eq!(orders.word(i), Some(g.as_str()));+ assert_eq!(orders.index(*g), Some(i));+ }+ assert_eq!(orders.word(all.len()), None);+ }+ assert_eq!(BLEND_ORDERS.all().last(), Some(&Continuity::G3), "a blend builds up to G3 today");+ for lang in ["en", "ar", "he", "ja", "zh", "de", "ko"] {+ let locale = crate::i18n::Locale::for_language(lang);+ for g in Continuity::ALL {+ let (label, tip) = (locale.text(g.label_id()), locale.text(g.tip_id()));+ assert!(label != g.label_id() && tip != g.tip_id(), "{lang}: {g:?} has no text");+ assert!(!coded(&label), "{lang}: the {g:?} label names a code: {label}");+ assert!(tip.contains(g.code()), "{lang}: the {g:?} hover text names its code: {tip}");+ }+ }+ }+}diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rsindex 417868d071..d740fed506 100644--- a/crates/ui-egui/src/sketch_tools.rs+++ b/crates/ui-egui/src/sketch_tools.rs@@ -7,9 +7,10 @@ use crate::icons::markers::glyph_icon;use crate::icons::markers::glyph_letter;use std::cell::{Cell, RefCell};-use egui::{Pos2, Stroke};+use egui::{Color32, Pos2, Stroke};use serde_json::{Value, json};use solidcraft_engine::geom::{Vec2, Vec3};+use solidcraft_engine::kernel::Continuity;use crate::SolveApp;use crate::tool_modifiers::{Audit, Binding, Match, ModAction, ModifierCombo, Scope, ToolModifiers, Trigger};@@ -172,47 +173,70 @@ fn analysis(app: &mut SolveApp, cmd: &str, p: Value) {}}-/// A seam from an `inspect.continuity` reply as a marker label: its class and the measure that-/// decided it (the gap, the angle between the faces' normals, or the curvature jump).+/// The message id of the class a seam whose highest order met is `order` reads as: a gap, a+/// crease (G0 only), or the word of its order (Tangent … Smooth curvature change).+pub(crate) fn order_class(order: Option<Continuity>) -> &'static str {+ match order {+ None => "ui.continuity_gap",+ Some(Continuity::G0) => "ui.continuity_crease",+ Some(g) => g.label_id(),+ }+}++/// The measure a seam of `order` fails the next order on: its reply key, symbol and unit.+fn next_measure(order: Continuity) -> Option<(&'static str, &'static str, &'static str)> {+ match order {+ Continuity::G1 => Some(("curvature_jump_per_mm", "\u{394}k", "/mm")),+ Continuity::G2 => Some(("curvature_change_jump_per_mm2", "\u{394}k\u{2032}", "/mm\u{b2}")),+ Continuity::G3 => Some(("curvature_change_rate_jump_per_mm3", "\u{394}k\u{2033}", "/mm\u{b3}")),+ Continuity::G0 | Continuity::G4 => None,+ }+}++/// A seam from an `inspect.continuity` reply as a marker label: its class in words and the+/// measure that keeps it from the next order (the gap, the angle between the faces' normals, or+/// the jump of the curvature, of its change, or of that change's rate).fn continuity_label(app: &SolveApp, seam: &Value) -> String {let deg = |key: &str| seam[key]["value"].as_f64().map(|x| format!("{x:.3}\u{b0}")).unwrap_or_default();- let jump = seam["curvature_jump_per_mm"]["value"].as_f64().map(|k| format!("\u{394}k {k:.4}/mm")).unwrap_or_default();- match seam["verdict"].as_str().unwrap_or_default() {- "gap" => format!("Gap {}", seam["gap_mm"]["value"].as_f64().map(|g| crate::prefs::show_mm(app, g, 1)).unwrap_or_default()),- "sharp" => format!("{} {}", crate::i18n::tr("ui.continuity_crease"), deg("normal_angle_deg")),- "curvature_jump" => format!("{} {} {jump}", crate::i18n::tr("ui.continuity_tangent"), deg("normal_angle_deg")),- "smooth" => format!("{} {} {jump}", crate::i18n::tr("ui.continuity_curvature"), deg("normal_angle_deg")),- other => other.to_string(),+ let order = seam["order"].as_str().and_then(Continuity::parse);+ let class = crate::i18n::tr(order_class(order));+ match order {+ None => format!("{class} {}", seam["gap_mm"]["value"].as_f64().map(|g| crate::prefs::show_mm(app, g, 1)).unwrap_or_default()),+ Some(g) => {+ let next = next_measure(g)+ .and_then(|(key, symbol, unit)| seam[key]["value"].as_f64().map(|x| format!(" {symbol} {x:.4}{unit}")))+ .unwrap_or_default();+ format!("{class} {}{next}", deg("normal_angle_deg"))+ }}}-/// The Continuity Analysis legend in the viewport's lower left corner: each class in its-/// colour, while seams are shaded.+/// The Continuity Analysis legend in the viewport's lower left corner: each class in its colour+/// and width (the curvature-continuous orders share a colour and widen with each order), while+/// seams are shaded.fn continuity_legend(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {if app.session.continuity.is_empty() {return;}let tk = crate::theme::Tokens::get();- let [smooth, jump, sharp, gap] = tk.continuity;- // Stable ids: this Gap is a hole between faces, not the sheet-metal gap (`ui.sheet_gap`).- let tr = crate::i18n::tr;- let rows = [- (tr("ui.continuity_curvature"), smooth),- (tr("ui.continuity_tangent"), jump),- (tr("ui.continuity_crease"), sharp),- (tr("ui.continuity_gap"), gap),- ];+ // Best to worst. Stable ids: this Gap is a hole between faces, not the sheet-metal gap.+ let mut classes: Vec<Option<Continuity>> = Continuity::ALL.into_iter().rev().map(Some).collect();+ classes.push(None);+ let rows: Vec<(&str, Color32, f32)> = classes+ .into_iter()+ .map(|order| (crate::i18n::tr(order_class(order)), crate::viewport::continuity_color(&tk, order), crate::viewport::seam_width(order)))+ .collect();let font = egui::FontId::proportional(tk.font_body);let (row, pad, swatch) = (18.0, 8.0, 22.0);- let text_width = rows.iter().map(|(label, _)| painter.layout_no_wrap(label.to_string(), font.clone(), tk.text).size().x).fold(0.0, f32::max);+ let text_width = rows.iter().map(|(label, ..)| painter.layout_no_wrap(label.to_string(), font.clone(), tk.text).size().x).fold(0.0, f32::max);let size = egui::vec2(pad + swatch + 8.0 + text_width + pad, rows.len() as f32 * row + 2.0 * pad);let available = crate::shell::bottom_overlay_rect(app, proj.rect);let frame = egui::Rect::from_min_size(available.left_bottom() + egui::vec2(16.0, -(size.y + 16.0)), size);painter.rect_filled(frame, tk.radius_sm, tk.panel.gamma_multiply(0.9));crate::scenario::publish_rect("continuity_legend", frame);- for (i, (label, col)) in rows.iter().enumerate() {+ for (i, (label, col, width)) in rows.iter().enumerate() {let y = frame.top() + pad + row * (i as f32 + 0.5);- painter.line_segment([egui::pos2(frame.left() + pad, y), egui::pos2(frame.left() + pad + swatch, y)], Stroke::new(3.0, *col));+ painter.line_segment([egui::pos2(frame.left() + pad, y), egui::pos2(frame.left() + pad + swatch, y)], Stroke::new(*width, *col));painter.text(egui::pos2(frame.left() + pad + swatch + 8.0, y), egui::Align2::LEFT_CENTER, *label, font.clone(), tk.text);}}@@ -288,16 +312,16 @@ pub fn start_hook(app: &mut SolveApp, id: &str) -> bool {}let Ok(v) = app.run(id, json!({})) else { return false };let summary = &v["summary"];- // Each class in the legend's words.- let counts: Vec<String> = [- ("smooth", "ui.continuity_curvature"),- ("curvature_jump", "ui.continuity_tangent"),- ("sharp", "ui.continuity_crease"),- ("gap", "ui.continuity_gap"),- ]- .iter()- .filter_map(|(key, class)| summary[*key].as_u64().filter(|n| *n > 0).map(|n| format!("{n} {}", crate::i18n::tr(class))))- .collect();+ // Each class in the legend's words, best first.+ let gaps = summary["gap"].as_u64().filter(|n| *n > 0).map(|n| format!("{n} {}", crate::i18n::tr(order_class(None))));+ let counts: Vec<String> = Continuity::ALL+ .into_iter()+ .rev()+ .filter_map(|g| {+ summary["orders"][g.as_str()].as_u64().filter(|n| *n > 0).map(|n| format!("{n} {}", crate::i18n::tr(order_class(Some(g)))))+ })+ .chain(gaps)+ .collect();app.set_status(format!("Continuity: {} (click the button again to turn it off)", counts.join(", ")), false);return true;}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 970dc49ee9..a7c9ce1c04 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -458,6 +458,7 @@ fn scene_key(app: &SolveApp) -> u64 {seam.edge.hash(&mut h);seam.points.len().hash(&mut h);format!("{:?}", seam.verdict).hash(&mut h);+ seam.order.hash(&mut h);seam.points.first().map(|p| [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()]).hash(&mut h);}// So are the faces Isocurve Analysis shows (their curves follow the bodies, hashed above).@@ -1419,10 +1420,11 @@ pub(crate) 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 = sc.color(c4(continuity_color(&tk, seam.verdict)));+ let col = sc.color(c4(continuity_color(&tk, seam.order)));+ let width = seam_width(seam.order);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.line(a.to_f32(), b.to_f32(), col, width, true);}}}@@ -1443,13 +1445,15 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {sc}-/// The colour of a measured seam, one per verdict from the theme's `continuity` tokens: within-/// every tolerance (G2), tangent with a curvature jump (G1), a crease (G0), and faces that do-/// not meet.-fn continuity_color(t: &Tokens, verdict: solidcraft_engine::kernel::SeamVerdict) -> Color32 {+/// The colour of a measured seam whose highest order met is `order`, from the theme's+/// `continuity` tokens by its verdict ([`SeamVerdict::of`]): curvature continuous (G2 and up),+/// tangent with a curvature jump (G1), a crease (G0), and faces that do not meet.+///+/// [`SeamVerdict::of`]: solidcraft_engine::kernel::SeamVerdict::of+pub(crate) fn continuity_color(t: &Tokens, order: Option<solidcraft_engine::kernel::Continuity>) -> Color32 {use solidcraft_engine::kernel::SeamVerdict as V;let [smooth, jump, sharp, gap] = t.continuity;- match verdict {+ match V::of(order) {V::Smooth => smooth,V::CurvatureJump => jump,V::Sharp => sharp,@@ -1457,6 +1461,13 @@ fn continuity_color(t: &Tokens, verdict: solidcraft_engine::kernel::SeamVerdict)}}+/// The stroke width of a measured seam: 2.6 px, and one more for each order past G2 the+/// curvature-continuous seams meet (G3, G4), which share G2's colour.+pub(crate) fn seam_width(order: Option<solidcraft_engine::kernel::Continuity>) -> f32 {+ let past_g2 = order.map_or(0, |g| g.order().saturating_sub(2));+ 2.6 + past_g2 as f32+}+/// 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();