Files
solidcraft/crates/engine/src/hole_reference_tests.rs
T
98abb249c4 Cylinder: place by distances from reference edges, like Hole (#6380) (#6381)
* claim: #6380

* Cylinder: place by distances from reference edges, like Hole (#6380)

A Cylinder standing on a flat face can take up to two straight edges of
that face as references, each with the distance of its base centre from
the edge's line, measured in the face's plane, as a Single hole does
(#37). `solid.cylinder` takes them as `references: [{edge, distance}]`
with a numeric `base`; the edges are found again by their persistent
names, else their points, so the cylinder follows them when the part
changes, and each distance is a parameter (an input of Inspect Feature).
A cylinder without references stays at its base, as before.

In the Cylinder window, started on a picked face, Reference 1 and 2 take
the edges, each with its Distance measured from the pick, so it works
with the mouse alone; the canvas shows each distance with a box to type
it in, and Edit Feature picks the edges again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Cylinder: Edit Feature shows each reference edge input once (#6380)

A face selected when Edit Feature opened the window had already added
the reference inputs; the edit added them a second time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Cylinder references: the measured-once cost test's cylinder has none (#6380)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Cylinder: pick the face it stands on in its window, then the edges (#6380)

The Cylinder window took its place only from a face selected before it
opened, so started first it stood at the origin and offered no reference
edges. It now has a Face input before Reference 1 and 2, as the Hole
window does: start Cylinder, click the face, click the edges, OK.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Glossary: reference edge, and "Reference" among the words with more than one meaning (#6380)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Cylinder edge references: the Cone dialog (#6250) gets the references field too

The Cone primitive landed on main after this branch began; its dialog initialisers lacked
the `refs` field the Primitive kind gained here. The dense form check for Cylinder fills only
its fields: its face and reference edges place it, which the reference tests cover.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Cylinder: declare references in its contract; reference-placed cylinders are not placement-independent

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
2026-10-27 19:28:22 +00:00

286 lines
14 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! A Single hole placed by distances from reference edges (#37): the centre sits at the typed
//! distances from straight edges of its face, measured in the face's plane, follows the edges
//! when the part changes (also after the design is saved and reopened), and a bad reference is
//! refused with an error. A cylinder takes the same references for its base (#6380).
use std::f64::consts::PI;
use serde_json::{Value, json};
use solidcraft_doc::FeatureKind;
use solidcraft_geom::Vec3;
use crate::{EngineError, 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 solid_at(s: &Session, p: Vec3) -> bool {
s.model.state().bodies.iter().any(|b| b.body.contains(p))
}
/// The bore (5 mm across, 4 mm deep, down from the top face at z = `top`) is about (x, y):
/// empty on its axis and up to 2 mm from it, solid 3 mm from it in every direction (the margins
/// leave room for the facets of a larger body's coarser mesh).
fn bore_at(s: &Session, x: f64, y: f64, top: f64) {
let at = Vec3::new(x, y, top - 2.0);
for k in 0..8 {
let a = PI / 4.0 * f64::from(k);
let p = |r: f64| at + Vec3::new(a.cos(), a.sin(), 0.0) * r;
assert!(!solid_at(s, p(0.0)) && !solid_at(s, p(2.0)), "the bore about ({x}, {y}) is empty {a} rad from +x");
assert!(solid_at(s, p(3.0)), "the wall about ({x}, {y}) is solid {a} rad from +x");
}
}
/// The last feature's position and reference edges.
fn hole(s: &Session) -> (Vec3, Vec<solidcraft_doc::HoleReference>) {
match &s.doc.features.last().map(|f| &f.kind) {
Some(FeatureKind::Hole { position, references, .. }) => (position.0, references.clone()),
other => panic!("the last feature is not a hole: {other:?}"),
}
}
/// A 50 × 40 × 10 box from the origin whose length and width are parameters.
fn plate() -> Session {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "len", "expression": "50 mm"}));
run(&mut s, "parameters.add", json!({"name": "wid", "expression": "40 mm"}));
run(&mut s, "solid.box", json!({"length": "len", "width": "wid", "height": 10, "corner": [0, 0, 0]}));
s
}
/// A Ø5 × 4 hole picked at (30, 25) on the top, with these references.
fn referenced(references: Value) -> Value {
json!({"position": [30, 25, 10], "diameter": 5, "depth": 4, "name": "H", "references": references})
}
#[test]
fn a_hole_sits_at_its_distances_from_two_edges() {
let mut s = plate();
// 10 mm from the left edge (x = 0) and 12 mm from the front edge (y = 0) of the top.
run(&mut s, "solid.hole", referenced(json!([{"edge": [0, 20, 10], "distance": 10}, {"edge": [25, 0, 10], "distance": "12 mm"}])));
let (position, refs) = hole(&s);
assert!(position.dist(Vec3::new(10.0, 12.0, 10.0)) < 1e-6, "the hole is placed at (10, 12), not {position:?}");
assert_eq!(refs.len(), 2);
bore_at(&s, 10.0, 12.0, 10.0);
assert!(solid_at(&s, Vec3::new(30.0, 25.0, 8.0)), "nothing is drilled where the face was picked");
// The distances are the hole's parameters, named like its other inputs.
let f = s.doc.find_feature("H").unwrap();
let labels: Vec<&str> = f.kind.inputs().iter().map(|(label, _, _)| *label).collect();
assert_eq!(labels.iter().filter(|l| **l == "Reference distance").count(), 2, "{labels:?}");
assert_eq!(f.param_names.len(), labels.len());
assert_eq!(f.edge_names.len(), 2, "each reference edge keeps its persistent name");
// One reference: the hole moves square to that edge and keeps its place along it.
run(&mut s, "edit.undo", json!({}));
run(&mut s, "solid.hole", referenced(json!([{"edge": [0, 20, 10], "distance": 10}])));
bore_at(&s, 10.0, 25.0, 10.0);
}
#[test]
fn a_hole_follows_its_edges_when_the_box_grows() {
let mut s = plate();
// From the far edges: 10 mm from x = len, 12 mm from y = wid.
run(&mut s, "solid.hole", referenced(json!([{"edge": [50, 20, 10], "distance": 10}, {"edge": [25, 40, 10], "distance": 12}])));
bore_at(&s, 40.0, 28.0, 10.0);
let id = s.doc.find_feature("H").unwrap().id;
run(&mut s, "parameters.change", json!({"name": "len", "expression": "80 mm"}));
run(&mut s, "parameters.change", json!({"name": "wid", "expression": "65 mm"}));
assert!(s.model.result(id).is_some_and(|r| r.error.is_none()), "{:?}", s.model.result(id).map(|r| &r.error));
bore_at(&s, 70.0, 53.0, 10.0);
assert!(solid_at(&s, Vec3::new(40.0, 28.0, 8.0)), "the old spot is solid again");
// A distance is a parameter too: changing it moves the hole.
let d = s.doc.find_feature("H").unwrap().param_names.last().cloned().unwrap();
run(&mut s, "parameters.change", json!({"name": d, "expression": "20 mm"}));
bore_at(&s, 70.0, 45.0, 10.0);
// Smaller than where the hole was placed: it still follows its edges.
run(&mut s, "parameters.change", json!({"name": "len", "expression": "30 mm"}));
bore_at(&s, 20.0, 45.0, 10.0);
// Saved and reopened, the hole keeps its references and its place.
let mut t = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
t.refresh();
bore_at(&t, 20.0, 45.0, 10.0);
assert_eq!(hole(&t).1, hole(&s).1);
}
#[test]
fn a_bad_reference_is_refused() {
let mut s = plate();
run(&mut s, "solid.hole", json!({"position": [25, 20, 10], "diameter": 10, "name": "Bore"}));
let before = s.doc.features.len();
let edge = |p: [f64; 3], d: Value| json!({"edge": p, "distance": d});
for (refs, why) in [
(json!([edge([25.0, 30.0, 10.0], json!(5))]), "no edge"),
(json!([edge([30.0, 20.0, 10.0], json!(5))]), "not straight"),
(json!([edge([0.0, 0.0, 5.0], json!(5))]), "square to the face"),
(json!([edge([0.0, 20.0, 10.0], json!(5)), edge([50.0, 20.0, 10.0], json!(5))]), "parallel"),
(json!([edge([0.0, 20.0, 10.0], json!(5)), edge([25.0, 0.0, 10.0], json!(5)), edge([50.0, 20.0, 10.0], json!(5))]), "at most 2"),
(json!([edge([0.0, 20.0, 10.0], json!("-5 mm"))]), "0 or more"),
(json!([edge([0.0, 20.0, 10.0], json!(500))]), "off its face"),
(json!([edge([0.0, 20.0, 10.0], json!("5 deg"))]), "references"),
(json!([edge([0.0, 20.0, 10.0], json!("nope"))]), "references"),
(json!([{"edge": [0, 20], "distance": 5}]), "edge"),
(json!([{"edge": [0, 20, 10]}]), "distance"),
(json!({"edge": [0, 20, 10], "distance": 5}), "list"),
] {
let p = referenced(refs.clone());
match s.execute("solid.hole", &p) {
Err(EngineError::Internal(..)) | Ok(_) => panic!("{refs} is refused"),
Err(e) => assert!(e.to_string().contains(why), "{refs}: {e}"),
}
assert_eq!(s.doc.features.len(), before, "{refs} adds nothing");
}
// Not with sketch points or a position given as expressions.
for p in [
json!({"position": ["30 mm", "25 mm", "10 mm"], "diameter": 5, "references": [edge([0.0, 20.0, 10.0], json!(5))]}),
json!({"sketch": 1, "points": ["p1"], "diameter": 5, "references": [edge([0.0, 20.0, 10.0], json!(5))]}),
] {
assert!(s.execute("solid.hole", &p).is_err(), "{p}");
}
}
#[test]
fn hostile_references_never_panic() {
let mut s = plate();
let values = crate::tests::hostile_values();
let mut panicked = Vec::new();
for v in &values {
for refs in [
v.clone(),
json!([v]),
json!([v, v]),
json!([{"edge": v, "distance": 5}]),
json!([{"edge": [0, 20, 10], "distance": v}]),
json!([{"edge": [0, 20, 10], "distance": 5}, {"edge": v, "distance": v}]),
] {
for at in [json!([30, 25, 10]), json!([0, 0, 10]), json!([1e300, 0, 10]), v.clone()] {
let p = json!({"position": at, "diameter": 5, "references": refs});
if let Err(EngineError::Internal(id, msg)) = s.execute("solid.hole", &p) {
panicked.push(format!("{id} {p}: {msg}"));
}
}
}
}
assert!(panicked.is_empty(), "solid.hole panicked:\n{}", panicked.join("\n"));
}
/// The last feature's base and reference edges.
fn cylinder(s: &Session) -> (solidcraft_doc::PointExpr, Vec<solidcraft_doc::HoleReference>) {
match &s.doc.features.last().map(|f| &f.kind) {
Some(FeatureKind::Cylinder { base, references, .. }) => (base.clone(), references.clone()),
other => panic!("the last feature is not a cylinder: {other:?}"),
}
}
/// A Ø6 × 5 cylinder joined onto the plate's top (z = 10), picked at (30, 25), with these
/// references.
fn standing(references: Value) -> Value {
json!({"base": [30, 25, 10], "axis": [0, 0, 1], "radius": 3, "height": 5, "operation": "join", "name": "C", "references": references})
}
/// The cylinder (Ø6, from z = 10 to 15) stands about (x, y): solid on its axis and up to 2 mm
/// from it, empty 4 mm from it in every direction.
fn pin_at(s: &Session, x: f64, y: f64) {
let at = Vec3::new(x, y, 12.5);
for k in 0..8 {
let a = PI / 4.0 * f64::from(k);
let p = |r: f64| at + Vec3::new(a.cos(), a.sin(), 0.0) * r;
assert!(solid_at(s, p(0.0)) && solid_at(s, p(2.0)), "the cylinder about ({x}, {y}) is solid {a} rad from +x");
assert!(!solid_at(s, p(4.0)), "beside the cylinder about ({x}, {y}) is empty {a} rad from +x");
}
}
#[test]
fn a_cylinder_follows_its_edges_when_the_plate_changes() {
let mut s = plate();
// 10 mm from the far edge (x = len), 12 mm from the front edge (y = 0).
let refs = json!([{"edge": [50, 20, 10], "distance": 10}, {"edge": [25, 0, 10], "distance": "12 mm"}]);
run(&mut s, "solid.cylinder", standing(refs.clone()));
let (base, references) = cylinder(&s);
assert_eq!(base.map(|c| c.to_string()), ["40", "12", "10"].map(String::from), "the base keeps where the distances put it");
assert_eq!(references.len(), 2);
pin_at(&s, 40.0, 12.0);
let f = s.doc.find_feature("C").unwrap();
let id = f.id;
assert_eq!(f.edge_names.len(), 2, "each reference edge keeps its persistent name");
// The distances are inputs (Inspect Feature lists them) and parameters.
let inspected = run(&mut s, "timeline.inspect", json!({"feature": "C"}));
let labels: Vec<&str> = inspected["inputs"].as_array().unwrap().iter().filter_map(|i| i["label"].as_str()).collect();
assert_eq!(labels.iter().filter(|l| **l == "Reference distance").count(), 2, "{labels:?}");
// The plate grows: the cylinder stays 10 mm from its far edge.
run(&mut s, "parameters.change", json!({"name": "len", "expression": "80 mm"}));
assert!(s.model.result(id).is_some_and(|r| r.error.is_none()), "{:?}", s.model.result(id).map(|r| &r.error));
pin_at(&s, 70.0, 12.0);
assert!(!solid_at(&s, Vec3::new(40.0, 12.0, 12.5)), "nothing stands at the old spot");
// A distance changed as a parameter moves it.
let d = s.doc.find_feature("C").unwrap().param_names.last().cloned().unwrap();
run(&mut s, "parameters.change", json!({"name": d, "expression": "20 mm"}));
pin_at(&s, 70.0, 20.0);
// Undo and redo.
run(&mut s, "edit.undo", json!({}));
pin_at(&s, 70.0, 12.0);
run(&mut s, "edit.redo", json!({}));
pin_at(&s, 70.0, 20.0);
// Saved and reopened, it keeps its references and its place.
let mut t = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
t.refresh();
pin_at(&t, 70.0, 20.0);
assert_eq!(cylinder(&t).1, cylinder(&s).1);
run(&mut t, "parameters.change", json!({"name": "len", "expression": "60 mm"}));
pin_at(&t, 50.0, 20.0);
}
#[test]
fn a_cylinder_without_references_stays_at_its_base() {
let mut s = plate();
run(&mut s, "solid.cylinder", standing(json!([])));
assert!(cylinder(&s).1.is_empty());
assert!(!s.doc.to_json().contains("references"), "a cylinder without references is saved as before");
pin_at(&s, 30.0, 25.0);
run(&mut s, "parameters.change", json!({"name": "len", "expression": "80 mm"}));
pin_at(&s, 30.0, 25.0);
// One reference: it moves square to that edge and keeps its place along it.
run(&mut s, "edit.undo", json!({}));
run(&mut s, "edit.undo", json!({}));
run(&mut s, "solid.cylinder", standing(json!([{"edge": [0, 20, 10], "distance": 10}])));
pin_at(&s, 10.0, 25.0);
}
#[test]
fn a_bad_cylinder_reference_is_refused() {
let mut s = plate();
let before = s.doc.features.len();
let edge = |p: [f64; 3], d: Value| json!({"edge": p, "distance": d});
for (refs, why) in [
(json!([edge([25.0, 30.0, 10.0], json!(5))]), "no edge"),
(json!([edge([0.0, 20.0, 10.0], json!(5)), edge([50.0, 20.0, 10.0], json!(5))]), "parallel"),
(json!([edge([0.0, 20.0, 10.0], json!(5)), edge([25.0, 0.0, 10.0], json!(5)), edge([50.0, 20.0, 10.0], json!(5))]), "at most 2"),
(json!([edge([0.0, 20.0, 10.0], json!("-5 mm"))]), "0 or more"),
(json!([edge([0.0, 20.0, 10.0], json!(500))]), "off its face"),
(json!([edge([0.0, 20.0, 10.0], json!("5 deg"))]), "references"),
] {
match s.execute("solid.cylinder", &standing(refs.clone())) {
Err(EngineError::Internal(..)) | Ok(_) => panic!("{refs} is refused"),
Err(e) => assert!(e.to_string().contains(why), "{refs}: {e}"),
}
assert_eq!(s.doc.features.len(), before, "{refs} adds nothing");
}
let p = json!({"base": ["30 mm", "25 mm", "10 mm"], "radius": 3, "height": 5, "references": [edge([0.0, 20.0, 10.0], json!(5))]});
assert!(s.execute("solid.cylinder", &p).is_err(), "not with a base given as expressions");
let values = crate::tests::hostile_values();
let mut panicked = Vec::new();
for v in &values {
for refs in [v.clone(), json!([v]), json!([{"edge": v, "distance": 5}]), json!([{"edge": [0, 20, 10], "distance": v}])] {
for base in [json!([30, 25, 10]), json!([1e300, 0, 10]), v.clone()] {
let p = json!({"base": base, "radius": 3, "height": 5, "references": refs});
if let Err(EngineError::Internal(id, msg)) = s.execute("solid.cylinder", &p) {
panicked.push(format!("{id} {p}: {msg}"));
}
}
}
}
assert!(panicked.is_empty(), "solid.cylinder panicked:\n{}", panicked.join("\n"));
}