1 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.
- 9a7958857 jyviko: doc, engine, ui: placing the model returns its error; placements are checked where they are set
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
268 lines
14 KiB
Rust
268 lines
14 KiB
Rust
//! `surface.boundary` through loops of three or four sketch curves and through curve networks
|
||
//! (#763): analytic areas and shapes, G1 and G2 measured across the edge a surface shares with a
|
||
//! body (`inspect.continuity`), and refusals of hostile networks that never panic.
|
||
|
||
use serde_json::{Value, json};
|
||
|
||
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 first(v: &Value) -> String {
|
||
v.as_array().and_then(|a| a.first()).and_then(Value::as_str).map(str::to_string).unwrap_or_default()
|
||
}
|
||
|
||
/// A sketch line's id.
|
||
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> String {
|
||
first(&run(s, "sketch.line", json!({"points": [a, b]}))["created"]["curves"])
|
||
}
|
||
|
||
/// A 3D sketch line's id (the active sketch must have 3D Sketch on).
|
||
fn line3d(s: &mut Session, a: [f64; 3], b: [f64; 3]) -> String {
|
||
first(&run(s, "sketch.line3d", json!({"points": [a, b]}))["curves"])
|
||
}
|
||
|
||
/// The area of the one face of `body`, and the area `inspect.measure` gives for the whole model.
|
||
fn areas(s: &mut Session, body: &str) -> (f64, f64) {
|
||
let f = run(s, "model.faces", json!({"body": body}));
|
||
let faces = f["faces"].as_array().cloned().unwrap_or_default();
|
||
assert_eq!(faces.len(), 1, "one face: {f}");
|
||
let face = faces[0]["area"].as_f64().unwrap_or(f64::NAN);
|
||
let m = run(s, "inspect.measure", json!({}));
|
||
(face, m["total"]["area_mm2"].as_f64().unwrap_or(f64::NAN))
|
||
}
|
||
|
||
/// Three and four sketch curves in loop order: the flat patch of the loop. A triangle and a square
|
||
/// of lines, and a square whose top is a half circle bulging out, each measure their own area.
|
||
#[test]
|
||
fn three_and_four_curve_loops_are_flat_patches() {
|
||
use std::f64::consts::PI;
|
||
let cases: Vec<(Vec<[[f64; 2]; 2]>, f64, f64)> = vec![
|
||
(vec![[[0.0, 0.0], [20.0, 0.0]], [[20.0, 0.0], [10.0, 15.0]], [[10.0, 15.0], [0.0, 0.0]]], 150.0, 1e-6),
|
||
(vec![[[0.0, 0.0], [10.0, 0.0]], [[10.0, 0.0], [10.0, 10.0]], [[10.0, 10.0], [0.0, 10.0]], [[0.0, 10.0], [0.0, 0.0]]], 100.0, 1e-6),
|
||
];
|
||
for (lines, want, tol) in cases {
|
||
for continuity in [json!("g0"), json!("g1"), json!("g3")] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||
let curves: Vec<String> = lines.iter().map(|[a, b]| line(&mut s, *a, *b)).collect();
|
||
let r = run(&mut s, "surface.boundary", json!({"curves": curves, "continuity": continuity}));
|
||
let body = first(&r["created_bodies"]);
|
||
let (face, total) = areas(&mut s, &body);
|
||
assert!(
|
||
(face - want).abs() < tol * want && (total - want).abs() < tol * want,
|
||
"{} sides, {continuity}: {face} / {total} vs {want}",
|
||
lines.len()
|
||
);
|
||
}
|
||
}
|
||
// A square with a half circle for its top, bulging out: 100 + 12.5π.
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||
let bottom = line(&mut s, [0.0, 0.0], [10.0, 0.0]);
|
||
let right = line(&mut s, [10.0, 0.0], [10.0, 10.0]);
|
||
let arc = first(&run(&mut s, "sketch.arc.three_point", json!({"start": [10, 10], "end": [0, 10], "through": [5, 15]}))["created"]["curves"]);
|
||
let left = line(&mut s, [0.0, 10.0], [0.0, 0.0]);
|
||
let r = run(&mut s, "surface.boundary", json!({"curves": [bottom, right, arc, left]}));
|
||
let (face, total) = areas(&mut s, &first(&r["created_bodies"]));
|
||
let want = 100.0 + 12.5 * PI;
|
||
assert!((face - want).abs() < 2e-3 * want && (total - want).abs() < 2e-3 * want, "{face} / {total} vs {want}");
|
||
}
|
||
|
||
/// Simpson's rule over [0, a] × [0, a] with n (even) intervals each way.
|
||
fn simpson2(f: impl Fn(f64, f64) -> f64, a: f64, n: usize) -> f64 {
|
||
let h = a / n as f64;
|
||
let w = |k: usize| {
|
||
if k == 0 || k == n {
|
||
1.0
|
||
} else if k % 2 == 1 {
|
||
4.0
|
||
} else {
|
||
2.0
|
||
}
|
||
};
|
||
let mut sum = 0.0;
|
||
for i in 0..=n {
|
||
for j in 0..=n {
|
||
sum += w(i) * w(j) * f(i as f64 * h, j as f64 * h);
|
||
}
|
||
}
|
||
sum * h * h / 9.0
|
||
}
|
||
|
||
/// Four straight 3D sketch lines bounding the hyperbolic paraboloid z = x·y/10 over the 10 × 10
|
||
/// square: the network's Coons patch is that surface (every vertex of its mesh on it), and its
|
||
/// area is the paraboloid's, ∫∫ √(1 + (x/10)² + (y/10)²).
|
||
#[test]
|
||
fn a_network_of_3d_lines_is_a_hyperbolic_paraboloid() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||
run(&mut s, "sketch.options", json!({"sketch_3d": true}));
|
||
let a = line3d(&mut s, [0.0, 0.0, 0.0], [10.0, 0.0, 0.0]);
|
||
let c = line3d(&mut s, [0.0, 10.0, 0.0], [10.0, 10.0, 10.0]);
|
||
let d = line3d(&mut s, [0.0, 0.0, 0.0], [0.0, 10.0, 0.0]);
|
||
let b = line3d(&mut s, [10.0, 0.0, 0.0], [10.0, 10.0, 10.0]);
|
||
let r = run(&mut s, "surface.boundary", json!({"u": [a, c], "v": [d, b]}));
|
||
let body = first(&r["created_bodies"]);
|
||
let want = simpson2(|x, y| (1.0 + (x / 10.0).powi(2) + (y / 10.0).powi(2)).sqrt(), 10.0, 200);
|
||
let (face, total) = areas(&mut s, &body);
|
||
// The face's own area comes from the coarse reference mesh (a chord of a fiftieth of a per
|
||
// cent of the body); the measuring mesh is refined onto the surface.
|
||
assert!((face - want).abs() < 1e-2 * want && (total - want).abs() < 1e-3 * want, "{face} / {total} vs {want}");
|
||
let st = s.world_state().unwrap();
|
||
let mesh = st.body(&body).map(|b| b.body.mesh(&solidcraft_kernel::MeshTolerance::chord(0.01))).and_then(Result::ok).unwrap_or_default();
|
||
assert!(!mesh.positions.is_empty());
|
||
for p in &mesh.positions {
|
||
assert!((p.z - p.x * p.y / 10.0).abs() < 1e-6, "{p:?} is off the paraboloid");
|
||
}
|
||
}
|
||
|
||
/// Curves of two planar sketches, one picked by a bare id in the sketch being edited: the loft
|
||
/// between a line on the ground and one 10 mm across and 5 mm up is the flat strip between them.
|
||
#[test]
|
||
fn a_network_takes_curves_from_several_sketches() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Low"}));
|
||
let low = line(&mut s, [0.0, 0.0], [10.0, 0.0]);
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 5, "name": "High"}));
|
||
let high = line(&mut s, [0.0, 10.0], [10.0, 10.0]);
|
||
let r = run(&mut s, "surface.boundary", json!({"u": [{"sketch": "Low", "curves": [low]}, high]}));
|
||
let (face, _) = areas(&mut s, &first(&r["created_bodies"]));
|
||
let want = 10.0 * 125f64.sqrt();
|
||
assert!((face - want).abs() < 1e-6 * want, "{face} vs {want}");
|
||
}
|
||
|
||
/// A quarter cylinder sheet (R = 10, axis along x, its straight top edge at y = 10, z = 0 open)
|
||
/// and a line 3D-sketched above it; returns the sheet's name and the line's id.
|
||
fn cylinder_and_line(s: &mut Session) -> (String, String) {
|
||
run(s, "sketch.create", json!({"plane": "YZ", "name": "Arc"}));
|
||
let h = 10.0 * std::f64::consts::FRAC_1_SQRT_2;
|
||
let arc = first(&run(s, "sketch.arc.three_point", json!({"start": [0, -10], "end": [10, 0], "through": [h, -h]}))["created"]["curves"]);
|
||
run(s, "sketch.finish", json!({}));
|
||
let sheet = first(&run(s, "surface.extrude", json!({"sketch": "Arc", "curves": [arc], "distance": 10}))["created_bodies"]);
|
||
run(s, "sketch.create", json!({"plane": "XY", "name": "Top"}));
|
||
run(s, "sketch.options", json!({"sketch_3d": true}));
|
||
let top = line3d(s, [0.0, 3.0, 12.0], [10.0, 3.0, 12.0]);
|
||
run(s, "sketch.finish", json!({}));
|
||
(sheet, top)
|
||
}
|
||
|
||
/// The edge a surface built from the cylinder's top edge shares with it, measured with
|
||
/// `inspect.continuity`: (normal angle in degrees, curvature jump per mm).
|
||
fn seam(s: &mut Session, body: &str) -> (f64, f64) {
|
||
let v = run(s, "inspect.continuity", json!({"body": body, "edges": [[5.0, 10.0, 0.0]]}));
|
||
let e = v["bodies"][0]["edges"].as_array().and_then(|a| a.first()).cloned().unwrap_or_default();
|
||
(e["normal_angle_deg"]["value"].as_f64().unwrap_or(f64::NAN), e["curvature_jump_per_mm"]["value"].as_f64().unwrap_or(f64::NAN))
|
||
}
|
||
|
||
/// G1 and G2 against a body: a network from the cylinder's open top edge to a line above, joined
|
||
/// into the cylinder. Across the shared edge the normals agree within 0.1° for G1 and G2; the
|
||
/// curvature jumps by much of the cylinder's 1/R with G1 and by under 1% of it with G2.
|
||
#[test]
|
||
fn g1_and_g2_networks_meet_a_body_across_its_edge() {
|
||
let mut jumps = Vec::new();
|
||
for g in ["g1", "g2"] {
|
||
let mut s = Session::default();
|
||
let (sheet, top) = cylinder_and_line(&mut s);
|
||
let r = run(
|
||
&mut s,
|
||
"surface.boundary",
|
||
json!({"u": [{"body": sheet, "edges": [[5.0, 10.0, 0.0]], "continuity": g}, {"sketch": "Top", "curves": [top]}], "operation": "join"}),
|
||
);
|
||
assert!(r["created_bodies"].as_array().is_none_or(Vec::is_empty), "a join makes no new body: {r}");
|
||
let f = run(&mut s, "model.faces", json!({"body": sheet}));
|
||
assert_eq!(f["faces"].as_array().map(Vec::len), Some(2), "the surface is sewn into the sheet: {f}");
|
||
let (angle, jump) = seam(&mut s, &sheet);
|
||
assert!(angle < 0.1, "{g}: normals {angle}° apart across the edge");
|
||
jumps.push(jump);
|
||
}
|
||
let r = 10.0;
|
||
assert!(jumps[0] > 0.2 / r, "G1 leaves the curvature behind: jump {}", jumps[0]);
|
||
assert!(jumps[1] < 0.01 / r, "G2 carries the cylinder's curvature across: jump {}", jumps[1]);
|
||
}
|
||
|
||
/// Networks that cannot be built are refused with a reason — by the command's own checks or by the
|
||
/// kernel — and leave nothing behind; none of them panics.
|
||
#[test]
|
||
fn hostile_networks_are_refused() {
|
||
let mut s = Session::default();
|
||
let (sheet, top) = cylinder_and_line(&mut s);
|
||
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [40, 40, 0]}));
|
||
let boxed = s.world_state().unwrap().bodies.last().map(|b| b.name.clone()).unwrap_or_default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Flat"}));
|
||
let a = line(&mut s, [0.0, 0.0], [10.0, 0.0]);
|
||
let b = line(&mut s, [0.0, 5.0], [10.0, 5.0]);
|
||
let far = line(&mut s, [0.0, 20.0], [10.0, 20.0]);
|
||
let ring = first(&run(&mut s, "sketch.circle.center", json!({"center": [50, 50], "radius": 3}))["created"]["curves"]);
|
||
let bodies = s.world_state().unwrap().bodies.len();
|
||
let edge = |g: &str| json!({"body": sheet, "edges": [[5.0, 10.0, 0.0]], "continuity": g});
|
||
let many: Vec<Value> = (0..33).map(|_| json!(a)).collect();
|
||
let cases: Vec<(Value, &str)> = vec![
|
||
(json!({"u": "l1"}), "list"),
|
||
(json!({"u": [42, a]}), "curve id"),
|
||
(json!({"u": [{}, a]}), "one of"),
|
||
(json!({"u": [{"curves": [], "sketch": "Flat"}, a]}), "sketch curves"),
|
||
(json!({"u": [{"curves": ["nope"]}, a]}), "no sketch curve"),
|
||
(json!({"u": [{"curves": [a], "sketch": "Nope"}, b]}), "no sketch"),
|
||
(json!({"u": [{"body": "Nope", "edges": [[0, 0, 0]]}, a]}), "no body"),
|
||
(json!({"u": [{"body": sheet, "edges": []}, a]}), "edges"),
|
||
(json!({"u": [{"body": sheet, "edges": [["x", 0, 0]]}, a]}), "[x, y, z]"),
|
||
(json!({"u": [{"body": sheet, "edges": [[1e300, 0, 0]]}, a]}), "[x, y, z]"),
|
||
(json!({"u": [{"point": [0, 0]}, a]}), "point"),
|
||
(json!({"u": [{"curves": [a], "body": sheet, "edges": [[5, 10, 0]]}, b]}), "one of"),
|
||
(json!({"u": [{"curves": [a], "continuity": "g1"}, b]}), "body's edges"),
|
||
(json!({"u": [edge("g3"), {"sketch": "Top", "curves": [top]}]}), "not supported yet"),
|
||
(json!({"u": [edge("g9"), {"sketch": "Top", "curves": [top]}]}), "continuity"),
|
||
(json!({"u": many}), "at most"),
|
||
(json!({"u": [a, b], "curves": [a, b]}), "loop"),
|
||
(json!({"u": [a, b], "crown": 1}), "loop"),
|
||
(json!({"u": [a, b], "operation": "cut"}), "operation"),
|
||
(json!({"u": [a, b], "operation": "join"}), "join"),
|
||
(json!({"u": [a]}), "two curves"),
|
||
(json!({"u": [], "v": [a, b]}), "`u`"),
|
||
// The kernel's refusals: curves that miss, a closed curve, G1 on an edge between two faces.
|
||
(json!({"u": [a, b], "v": [{"curves": [far]}, {"curves": [a]}]}), "don't meet"),
|
||
(json!({"u": [{"curves": [ring]}, b]}), "closed"),
|
||
(json!({"u": [{"body": boxed, "edges": [[45, 40, 0]], "continuity": "g1"}, b]}), "open edge"),
|
||
(json!({"u": [a, {"point": [5, 2, 0]}, b]}), "point"),
|
||
];
|
||
for (params, want) in cases {
|
||
let e = match s.execute("surface.boundary", ¶ms) {
|
||
Ok(v) => panic!("{params} was built: {v}"),
|
||
Err(e) => e,
|
||
};
|
||
assert!(!matches!(e, crate::EngineError::Internal(..)), "{params}: {e}");
|
||
assert!(e.to_string().contains(want), "{params}: {e}");
|
||
}
|
||
assert_eq!(s.world_state().unwrap().bodies.len(), bodies, "a refused network left a body behind");
|
||
}
|
||
|
||
/// An edit (`timeline.redefine`) may turn a loop of sketch curves into the network of the same
|
||
/// curves and back: the feature keeps its place and its name, and the surface its area.
|
||
#[test]
|
||
fn an_edit_turns_a_loop_into_a_network_and_back() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Square"}));
|
||
let sides: Vec<String> = [[[0.0, 0.0], [10.0, 0.0]], [[10.0, 0.0], [10.0, 10.0]], [[10.0, 10.0], [0.0, 10.0]], [[0.0, 10.0], [0.0, 0.0]]]
|
||
.iter()
|
||
.map(|[a, b]| line(&mut s, *a, *b))
|
||
.collect();
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "surface.boundary", json!({"sketch": "Square", "curves": sides, "name": "Patch"}));
|
||
let network = json!({"sketch": "Square", "u": [sides[0], sides[2]], "v": [sides[1], sides[3]]});
|
||
run(&mut s, "timeline.redefine", json!({"feature": "Patch", "command": "surface.boundary", "params": network}));
|
||
let kind = |s: &Session| s.doc.find_feature("Patch").map(|f| f.kind.clone());
|
||
assert!(matches!(kind(&s), Some(solidcraft_doc::FeatureKind::SurfaceNetwork { .. })), "{:?}", kind(&s));
|
||
let body = s.world_state().unwrap().bodies.first().map(|b| b.name.clone()).unwrap_or_default();
|
||
assert!((areas(&mut s, &body).0 - 100.0).abs() < 1e-6);
|
||
run(&mut s, "timeline.redefine", json!({"feature": "Patch", "command": "surface.boundary", "params": {"sketch": "Square", "curves": sides}}));
|
||
assert!(matches!(kind(&s), Some(solidcraft_doc::FeatureKind::SurfaceBoundary { .. })), "{:?}", kind(&s));
|
||
assert!((areas(&mut s, &body).0 - 100.0).abs() < 1e-6);
|
||
}
|