Files
solidcraft/crates/engine/src/cmd/surface_analysis.rs
T
jyvikoandClaude Opus 5.5 6ab96c6583 View analyses: one toggle group, its state in the session
Zebra, Draft, Curvature Map, Environment Map, Accessibility, Continuity,
Isocurve and Curvature Comb are one group: turning one on turns the one on
before off (Session::analyses_off), and the session says which is on
(Session::active_analysis). The new inspect.analysis names it and off: true
turns it off (typed contract and reply). The toolbar shows the active one's
button pressed, its tool running or not. Curvature Comb's button toggles:
on, the tool combs the edges clicked; again, off and the combs go; Esc or a
right click in the tool turns it off; opening another dialog leaves it on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 08:48:54 -04:00

606 lines
28 KiB
Rust

//! Surface analyses: zebra stripes, draft angle and curvature map shading of the model's faces.
//! View state only: no geometry changes and no undo step. The view analyses (these shadings,
//! continuity seams, isocurves and curvature combs) are one group: one at a time is on, and
//! `inspect.analysis` says which or turns it off.
use serde_json::{Value, json};
use solidcraft_geom::Vec3;
use super::CommandSpec;
use crate::params::{bad, bool_, num, str_, vec3};
use crate::{ContinuitySeam, Result, Session, SurfaceAnalysis, kernel};
/// 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)
.at("SKETCH", "INSPECT")
.icon("zebra")
.noundo()
.params("stripes?: number across the view (default 12); clear?: true turns the analysis off"),
CommandSpec::new("inspect.draft", "Draft Analysis", draft)
.at("SKETCH", "INSPECT")
.icon("draft_analysis")
.noundo()
.params("pull?: [x,y,z] direction (default Z); angle?: degrees (default 1); clear?: true turns the analysis off"),
CommandSpec::new("inspect.environment_map", "Environment Map Analysis", |s, p| set(s, p, SurfaceAnalysis::Environment))
.at("SKETCH", "INSPECT")
.icon("environment_map")
.noundo()
.params("clear?: true turns the analysis off"),
CommandSpec::new("inspect.accessibility", "Accessibility Analysis", accessibility)
.at("SKETCH", "INSPECT")
.icon("accessibility")
.noundo()
.params("direction?: [x,y,z] the tool comes from (default Z, from above); clear?: true turns the analysis off"),
CommandSpec::new("inspect.curvature_map", "Curvature Map Analysis", curvature_map)
.at("SKETCH", "INSPECT")
.icon("curvature_map")
.noundo()
.params("radius?: mm shown red (default: a tenth of the model's size); clear?: true turns the analysis off"),
CommandSpec::new("inspect.analysis", "View Analysis", crate::checked!("inspect.analysis", analysis))
.icon("zebra")
.noundo()
.doc_only()
.contract(&ANALYSIS_CONTRACT)
.output(crate::schema::output_schema_for::<crate::schema::surface_analysis::AnalysisState>)
.params(
"off?: true turns the view analysis on now off. → active: the command id of the view analysis on (inspect.zebra, \
inspect.draft, inspect.curvature_map, inspect.environment_map, inspect.accessibility, inspect.continuity, \
inspect.isocurve or inspect.curvature_comb), or null. One is on at a time: turning one on turns the one on before \
off. Read-only without `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), \
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), 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",
),
];
const ANALYSIS_CONTRACT: crate::schema::TypedContract<crate::schema::surface_analysis::AnalysisParams> = crate::schema::TypedContract::new();
/// The view analyses, by the command that turns each on: the shadings, the continuity seams, the
/// isocurves and the curvature combs. One at a time is on.
impl Session {
/// The view analysis on now, by its command id, or `None`.
pub fn active_analysis(&self) -> Option<&'static str> {
if let Some(a) = self.analysis {
Some(a.command())
} else if self.comb.is_some() {
Some("inspect.curvature_comb")
} else if !self.isocurves.is_empty() {
Some("inspect.isocurve")
} else if !self.continuity.is_empty() {
Some("inspect.continuity")
} else {
None
}
}
/// Turn every view analysis off but the one command `keep` turns on (`None`: all of them).
pub fn analyses_off(&mut self, keep: Option<&str>) {
if self.analysis.is_some_and(|a| Some(a.command()) != keep) {
self.analysis = None;
}
if keep != Some("inspect.curvature_comb") {
self.comb = None;
}
if keep != Some("inspect.isocurve") {
self.isocurves.clear();
}
if keep != Some("inspect.continuity") {
self.continuity.clear();
}
self.revision += 1;
}
}
impl SurfaceAnalysis {
/// The command that turns this analysis on.
pub fn command(self) -> &'static str {
match self {
SurfaceAnalysis::Zebra { .. } => "inspect.zebra",
SurfaceAnalysis::Draft { .. } => "inspect.draft",
SurfaceAnalysis::Curvature { .. } => "inspect.curvature_map",
SurfaceAnalysis::Environment => "inspect.environment_map",
SurfaceAnalysis::Access { .. } => "inspect.accessibility",
}
}
}
/// `inspect.analysis`: which view analysis is on, and `off` turns it off.
fn analysis(s: &mut Session, p: &Value) -> Result<Value> {
let off = match p.get("off") {
None | Some(Value::Null) => false,
Some(Value::Bool(b)) => *b,
Some(_) => return Err(bad("inspect.analysis", "`off` must be true or false")),
};
if off {
s.analyses_off(None);
}
Ok(json!({"active": s.active_analysis()}))
}
fn set(s: &mut Session, p: &Value, a: SurfaceAnalysis) -> Result<Value> {
if bool_(p, "clear").unwrap_or(false) {
s.analysis = None;
} else {
s.analyses_off(Some(a.command()));
s.analysis = Some(a);
}
s.revision += 1;
Ok(json!({ "analysis": s.analysis }))
}
fn zebra(s: &mut Session, p: &Value) -> Result<Value> {
let stripes = num(p, "stripes").unwrap_or(12.0);
if !(stripes.is_finite() && (1.0..=200.0).contains(&stripes)) {
return Err(bad("inspect.zebra", "`stripes` must be 1…200"));
}
set(s, p, SurfaceAnalysis::Zebra { stripes })
}
fn draft(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "inspect.draft";
let pull = match p.get("pull") {
Some(v) => vec3(v).and_then(Vec3::normalized).ok_or_else(|| bad(cmd, "`pull` must be a non-zero [x,y,z]"))?,
None => Vec3::Z,
};
let angle = num(p, "angle").unwrap_or(1.0);
if !(angle.is_finite() && (0.0..90.0).contains(&angle)) {
return Err(bad(cmd, "`angle` must be 0…90 degrees"));
}
set(s, p, SurfaceAnalysis::Draft { pull, angle })
}
fn accessibility(s: &mut Session, p: &Value) -> Result<Value> {
let dir = match p.get("direction") {
Some(v) => vec3(v).and_then(Vec3::normalized).ok_or_else(|| bad("inspect.accessibility", "`direction` must be a non-zero [x,y,z]"))?,
None => Vec3::Z,
};
set(s, p, SurfaceAnalysis::Access { dir })
}
fn curvature_map(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "inspect.curvature_map";
let radius = match num(p, "radius") {
Some(r) if r.is_finite() && r > 1e-6 && r < 1e9 => r,
Some(_) => return Err(bad(cmd, "`radius` must be positive")),
None => {
let st = s.model.state();
let size = st.bodies.iter().map(|b| b.mesh().bounds().diagonal()).fold(0.0_f64, f64::max);
if size > 0.0 { size / 10.0 } else { 10.0 }
}
};
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 => kernel::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 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)?,
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()?;
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, 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,
"samples": seam.samples,
"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,
}));
}
summary.skipped += report.skipped;
summary.unmeasured += report.unmeasured;
bodies.push(json!({
"body": body.name,
"edges": rows,
"skipped": report.skipped,
"unmeasured": report.unmeasured,
}));
}
if bool_(p, "add").unwrap_or(false) {
// The seams shown stay; an edge measured again takes its new reading.
s.continuity.retain(|kept| !seams.iter().any(|new| new.body == kept.body && new.edge == kept.edge));
s.continuity.extend(seams);
} else {
s.continuity = seams;
}
if !s.continuity.is_empty() {
s.analyses_off(Some("inspect.continuity"));
}
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,
"curvature_change_per_mm2": tolerances.curvature_change_per_mm2,
"curvature_change_rate_per_mm3": tolerances.curvature_change_rate_per_mm3,
},
"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,
"orders": summary.orders(),
"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,
/// 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, 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,
kernel::SeamVerdict::Sharp => self.sharp += 1,
kernel::SeamVerdict::Gap => self.gap += 1,
}
}
/// 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> {
[
(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::{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();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
let undo = s.undo.len();
s.execute("inspect.zebra", &json!({"stripes": 20})).unwrap();
assert_eq!(s.analysis, Some(SurfaceAnalysis::Zebra { stripes: 20.0 }));
s.execute("inspect.draft", &json!({"pull": [0, 0, 2], "angle": 3})).unwrap();
assert!(matches!(s.analysis, Some(SurfaceAnalysis::Draft { angle, .. }) if angle == 3.0));
s.execute("inspect.curvature_map", &json!({})).unwrap();
assert!(matches!(s.analysis, Some(SurfaceAnalysis::Curvature { radius }) if (radius - 300f64.sqrt() / 10.0).abs() < 1e-6));
s.execute("inspect.environment_map", &json!({})).unwrap();
assert_eq!(s.analysis, Some(SurfaceAnalysis::Environment));
s.execute("inspect.accessibility", &json!({"direction": [0, 0, -3]})).unwrap();
assert_eq!(s.analysis, Some(SurfaceAnalysis::Access { dir: solidcraft_geom::Vec3::new(0.0, 0.0, -1.0) }));
s.execute("inspect.curvature_map", &json!({"clear": true})).unwrap();
assert_eq!(s.analysis, None);
assert_eq!(s.undo.len(), undo, "no undo steps");
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["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}");
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, "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"));
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!(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));
}
/// 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);
}
/// `add` keeps what is shaded and adds the picked edges: an edge measured again replaces its
/// seam instead of drawing it twice, and a call without `add` starts over.
#[test]
fn continuity_add_keeps_the_seams_shown() {
let mut s = Session::default();
boxed(&mut s, 10.0);
s.execute("inspect.continuity", &json!({"edges": [[5, 0, 0]]})).unwrap();
assert_eq!(s.continuity.len(), 1);
let v = s.execute("inspect.continuity", &json!({"edges": [[0, 5, 0]], "add": true})).unwrap();
assert_eq!(edges(&v).len(), 1, "the reply covers the edges this call measured: {v}");
assert_eq!(s.continuity.len(), 2, "the first seam stays");
s.execute("inspect.continuity", &json!({"edges": [[5, 0, 0]], "add": true, "samples": 5})).unwrap();
assert_eq!(s.continuity.len(), 2, "measured again, not added twice");
assert!(s.continuity.iter().any(|seam| seam.points.len() == 5), "with its new reading");
assert!(s.continuity.iter().all(|seam| seam.body == "Body1"), "{:?}", s.continuity);
s.execute("inspect.continuity", &json!({"edges": [[10, 5, 0]]})).unwrap();
assert_eq!(s.continuity.len(), 1, "without `add` the shading starts over");
s.execute("inspect.continuity", &json!({"add": true})).unwrap();
assert_eq!(s.continuity.len(), 12, "every edge once");
}
/// 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!({"curvature_change_tolerance_per_mm2": -0.5}),
json!({"curvature_change_rate_tolerance_per_mm3": null}),
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", &params).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");
}
}