* assembly(feat): ground first parts and drag free joint chains Ground the first top-level part when it is created and let face dragging reposition free occurrences or any member of a floating joint chain in one undo step. Preserve exact repeated-placement frames, joint values, modifier selection and Escape cancellation. Keep the accumulated fixture, viewport layout and documentation integration fixes from the existing PR. Signed-off-by: Karl Von Richter<karl@embeint.com> * assembly(fix): update movable fixtures for first-part grounding Accept the documented grounded override in component creation, explicitly free movement fixtures, and keep linked clipboard pastes movable even in an empty document. Cover first and reused linked pastes, default insertion grounding, and single-step undo in the existing link tests. Signed-off-by: Karl Von Richter<karl@embeint.com> * assembly(test): keep the motion-cost crank free Unground the first component in the document-level joint-face measurement fixture so its motion samples can rotate after first-part grounding. Preserve the rotation and shared-measurement assertions that caught the Linux CI failure. Signed-off-by: Karl Von Richter<karl@embeint.com> * assembly(test): free the frame placement fixture Create the frame-member placement fixture ungrounded before moving it above its root sketch. Keep its world-space member assertions while respecting first-part grounding in the frame tests added on main. Signed-off-by: Karl Von Richter<karl@embeint.com> --------- Signed-off-by: Karl Von Richter<karl@embeint.com>
641 lines
31 KiB
Rust
641 lines
31 KiB
Rust
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||
|
||
use serde_json::{Value, json};
|
||
use std::f64::consts::PI;
|
||
|
||
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 f(v: &Value) -> f64 {
|
||
v.as_f64().unwrap_or_else(|| panic!("not a number: {v}"))
|
||
}
|
||
|
||
fn rel(a: f64, b: f64) -> f64 {
|
||
(a - b).abs() / b.abs().max(1e-12)
|
||
}
|
||
|
||
fn new_sketch() -> Session {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||
s
|
||
}
|
||
|
||
/// The areas of the active sketch's profiles, largest first.
|
||
fn profile_areas(s: &Session) -> Vec<f64> {
|
||
let id = s.active_sketch.unwrap();
|
||
let mut a: Vec<f64> = s.model.state().sketch(id).unwrap().profiles.iter().map(|p| p.area).collect();
|
||
a.sort_by(|x, y| y.total_cmp(x));
|
||
a
|
||
}
|
||
|
||
#[test]
|
||
fn list_gives_every_kind_with_a_working_example() {
|
||
let mut s = Session::default();
|
||
let out = run(&mut s, "frame.profile.list", json!({}));
|
||
let kinds = out["kinds"].as_array().unwrap();
|
||
let ids: Vec<&str> = kinds.iter().filter_map(|k| k["kind"].as_str()).collect();
|
||
assert_eq!(ids, ["bar", "round_bar", "rect_tube", "round_tube", "angle", "channel", "i_beam"]);
|
||
for k in kinds {
|
||
let r = run(&mut s, "frame.profile.properties", json!({"profile": k["example"]}));
|
||
assert!(f(&r["area"]) > 0.0, "{}", k["kind"]);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn properties_fill_defaults_and_give_mass_per_metre() {
|
||
let mut s = Session::default();
|
||
let r = run(
|
||
&mut s,
|
||
"frame.profile.properties",
|
||
json!({"profile": {"kind": "rect_tube", "width": 40, "height": 40, "wall": 3, "outer_radius": 0}, "density": 7850}),
|
||
);
|
||
let area = 40.0 * 40.0 - 34.0 * 34.0;
|
||
assert!(rel(f(&r["area"]), area) < 1e-12, "{r}");
|
||
assert!(rel(f(&r["mass_per_m"]), area * 1e-6 * 7850.0) < 1e-12, "{r}");
|
||
assert!(rel(f(&r["ixx"]), (40f64.powi(4) - 34f64.powi(4)) / 12.0) < 1e-12, "{r}");
|
||
let r = run(&mut s, "frame.profile.properties", json!({"profile": {"kind": "rect_tube", "width": 40, "height": 40, "wall": 3}}));
|
||
assert_eq!(r["profile"]["outer_radius"], json!(6.0), "{r}");
|
||
assert!(r.get("mass_per_m").is_none(), "{r}");
|
||
}
|
||
|
||
#[test]
|
||
fn bad_profiles_are_refused_with_the_reason() {
|
||
let mut s = new_sketch();
|
||
for (p, why) in [
|
||
(json!({}), "`profile` is required"),
|
||
(json!({"profile": {"kind": "hexagon"}}), "`profile`"),
|
||
(json!({"profile": {"kind": "rect_tube", "width": 10, "height": 10, "wall": 5}}), "wall"),
|
||
(json!({"profile": {"kind": "round_bar", "diameter": -1}}), "diameter"),
|
||
(json!({"profile": {"kind": "round_bar", "diameter": 10}, "density": -1}), "density"),
|
||
(json!({"profile": {"kind": "round_bar", "diameter": 10}, "density": "steel"}), "density"),
|
||
] {
|
||
let err = s.execute("frame.profile.properties", &p).unwrap_err().to_string();
|
||
assert!(err.contains(why), "{p}: {err}");
|
||
}
|
||
for p in [
|
||
json!({"profile": {"kind": "round_bar", "diameter": 10}, "at": [1e300, 0]}),
|
||
json!({"profile": {"kind": "round_bar", "diameter": 10}, "at": "here"}),
|
||
json!({"profile": {"kind": "round_bar", "diameter": 10}, "anchor": "middle"}),
|
||
json!({"profile": {"kind": "round_bar", "diameter": 10}, "angle": "a lot"}),
|
||
json!({"profile": {"kind": "round_bar", "diameter": 10}, "fixed": 3}),
|
||
] {
|
||
assert!(s.execute("frame.profile.insert", &p).is_err(), "{p} is refused");
|
||
}
|
||
// Nothing was drawn.
|
||
assert!(profile_areas(&s).is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn insert_needs_a_sketch() {
|
||
let mut s = Session::default();
|
||
assert!(s.execute("frame.profile.insert", &json!({"profile": {"kind": "round_bar", "diameter": 10}})).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn inserted_tube_is_one_profile_with_its_hole() {
|
||
let mut s = new_sketch();
|
||
let r = run(&mut s, "frame.profile.insert", json!({"profile": {"kind": "rect_tube", "width": 40, "height": 40, "wall": 3}}));
|
||
let area = f(&r["section"]["area"]);
|
||
// Outer radius 6, inner radius 3.
|
||
let want = (1600.0 - (4.0 - PI) * 36.0) - (34.0 * 34.0 - (4.0 - PI) * 9.0);
|
||
assert!(rel(area, want) < 1e-12, "{r}");
|
||
// Four lines and four arcs outside, the same inside.
|
||
assert_eq!(r["created"]["curves"].as_array().unwrap().len(), 16, "{r}");
|
||
// The sketch has the wall and, as a region of its own, the inside.
|
||
let areas = profile_areas(&s);
|
||
assert_eq!(areas.len(), 2, "{areas:?}");
|
||
assert!(areas.iter().any(|a| rel(*a, want) < 1e-9), "the wall is the tube's section: {areas:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn inserted_channel_extrudes_to_its_area_times_length() {
|
||
let mut s = new_sketch();
|
||
let r = run(
|
||
&mut s,
|
||
"frame.profile.insert",
|
||
json!({"profile": {"kind": "channel", "height": 60, "width": 45, "web": 5, "flange": 6}, "at": [100, 50], "anchor": "bottom_left"}),
|
||
);
|
||
let area = f(&r["section"]["area"]);
|
||
let areas = profile_areas(&s);
|
||
assert!(areas.iter().any(|a| rel(*a, area) < 1e-9), "{areas:?} vs {area}");
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "solid.extrude", json!({"distance": 500, "profiles": [{"point": [101.5, 51.5]}]}));
|
||
let m = run(&mut s, "inspect.measure", json!({}));
|
||
let v = f(&m["total"]["volume_mm3"]);
|
||
// The kernel measures arcs through their facets: within 1e-4.
|
||
assert!(rel(v, area * 500.0) < 1e-4, "volume {v} vs {}", area * 500.0);
|
||
// The bottom-left corner sits on (100, 50): the body spans 100…145 and 50…110.
|
||
let bb = &m["bodies"][0]["bbox"];
|
||
let near = |v: &Value, want: f64| (f(v) - want).abs() < 1e-6;
|
||
assert!(near(&bb["min"][0], 100.0) && near(&bb["min"][1], 50.0) && near(&bb["max"][0], 145.0) && near(&bb["max"][1], 110.0), "{bb}");
|
||
}
|
||
|
||
#[test]
|
||
fn inserted_profile_turns_about_its_anchor_and_stays_fixed() {
|
||
let mut s = new_sketch();
|
||
let r = run(
|
||
&mut s,
|
||
"frame.profile.insert",
|
||
json!({"profile": {"kind": "angle", "width": 60, "height": 40, "thickness": 5}, "anchor": "bottom_left", "angle": PI / 2.0}),
|
||
);
|
||
let id = s.active_sketch.unwrap();
|
||
let sk = s.model.state().sketch(id).unwrap().sketch.clone();
|
||
let created: Vec<&str> = r["created"]["curves"].as_array().unwrap().iter().filter_map(Value::as_str).collect();
|
||
assert!(!created.is_empty());
|
||
for c in sk.curves.iter().filter(|c| created.contains(&c.id.as_str())) {
|
||
assert!(c.fixed, "{} is locked", c.id);
|
||
}
|
||
// Turned a quarter about the heel at the origin: the 60 mm leg runs up the y axis, the 40 mm
|
||
// one along −x.
|
||
let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);
|
||
for p in &sk.points {
|
||
lo = [lo[0].min(p.pos.x), lo[1].min(p.pos.y)];
|
||
hi = [hi[0].max(p.pos.x), hi[1].max(p.pos.y)];
|
||
}
|
||
assert!((lo[0] + 40.0).abs() < 1e-9 && hi[0].abs() < 1e-9 && lo[1].abs() < 1e-9 && (hi[1] - 60.0).abs() < 1e-9, "{lo:?} {hi:?}");
|
||
// Unlocked on request.
|
||
let r =
|
||
run(&mut s, "frame.profile.insert", json!({"profile": {"kind": "round_tube", "diameter": 20, "wall": 2}, "at": [200, 0], "fixed": false}));
|
||
assert_eq!(r["created"]["curves"].as_array().unwrap().len(), 2, "two circles: {r}");
|
||
let sk = s.model.state().sketch(id).unwrap().sketch.clone();
|
||
assert!(sk.curves.iter().filter(|c| r["created"]["curves"].as_array().unwrap().contains(&json!(c.id))).all(|c| !c.fixed));
|
||
}
|
||
|
||
#[test]
|
||
fn insert_is_one_undo_step() {
|
||
let mut s = new_sketch();
|
||
run(&mut s, "frame.profile.insert", json!({"profile": {"kind": "i_beam", "height": 100, "width": 50, "web": 4.5, "flange": 7}}));
|
||
assert_eq!(profile_areas(&s).len(), 1);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert!(profile_areas(&s).is_empty());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------------
|
||
// Members
|
||
|
||
/// How close a measured volume comes: the kernel measures curved faces through their facets.
|
||
const MEASURED: f64 = 1e-3;
|
||
|
||
/// The section area of a 40 × 40 × 3 rectangular tube (outer radius 6, inner 3).
|
||
fn tube_area() -> f64 {
|
||
(1600.0 - (4.0 - PI) * 36.0) - (34.0 * 34.0 - (4.0 - PI) * 9.0)
|
||
}
|
||
|
||
fn tube() -> Value {
|
||
json!({"kind": "rect_tube", "width": 40, "height": 40, "wall": 3})
|
||
}
|
||
|
||
/// A body's name, volume, bounding box and centre of mass.
|
||
type Measured = (String, f64, [f64; 3], [f64; 3], [f64; 3]);
|
||
|
||
fn bodies(s: &mut Session) -> Vec<Measured> {
|
||
let m = run(s, "inspect.measure", json!({}));
|
||
let v3 = |v: &Value| [f(&v[0]), f(&v[1]), f(&v[2])];
|
||
m["bodies"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.map(|b| {
|
||
(b["name"].as_str().unwrap().to_string(), f(&b["volume_mm3"]), v3(&b["bbox"]["min"]), v3(&b["bbox"]["max"]), v3(&b["center_of_mass"]))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn total_volume(s: &mut Session) -> f64 {
|
||
bodies(s).iter().map(|b| b.1).sum()
|
||
}
|
||
|
||
fn near3(got: [f64; 3], want: [f64; 3]) -> bool {
|
||
got.iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-6)
|
||
}
|
||
|
||
/// A 600 × 400 rectangle on XY, as the frame sketch `Frame`.
|
||
fn rectangle_frame(s: &mut Session) {
|
||
run(s, "sketch.create", json!({"plane": "XY", "name": "Frame"}));
|
||
run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [600, 400]}));
|
||
run(s, "sketch.finish", json!({}));
|
||
}
|
||
|
||
#[test]
|
||
fn members_follow_every_line_of_a_rectangle() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
let r = run(&mut s, "frame.member", json!({"sketch": "Frame", "profile": tube()}));
|
||
let bs = bodies(&mut s);
|
||
assert_eq!(bs.len(), 4, "{r}");
|
||
let names: Vec<&str> = bs.iter().map(|b| b.0.as_str()).collect();
|
||
assert_eq!(names, ["Rect Tube 40x40x3", "Rect Tube 40x40x3 (2)", "Rect Tube 40x40x3 (3)", "Rect Tube 40x40x3 (4)"]);
|
||
// Each member is the section run the length of its line: 2 × 600 + 2 × 400.
|
||
let v = total_volume(&mut s);
|
||
assert!(rel(v, tube_area() * 2000.0) < MEASURED, "{v} vs {}", tube_area() * 2000.0);
|
||
// The bottom line runs along +X: the profile is centred on it, square to it.
|
||
assert!(bs.iter().any(|b| near3(b.2, [0.0, -20.0, -20.0]) && near3(b.3, [600.0, 20.0, 20.0])), "{bs:?}");
|
||
// The right line runs along Y at x = 600.
|
||
assert!(bs.iter().any(|b| near3(b.2, [580.0, 0.0, -20.0]) && near3(b.3, [620.0, 400.0, 20.0])), "{bs:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn members_follow_a_parameter_edit() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "parameters.add", json!({"name": "W", "expression": "600 mm"}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Frame"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[0, 0], ["W", 0], ["W", 400], [0, 400]], "closed": true}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "frame.member", json!({"sketch": "Frame", "profile": tube()}));
|
||
assert!(rel(total_volume(&mut s), tube_area() * 2000.0) < MEASURED);
|
||
run(&mut s, "parameters.change", json!({"name": "W", "expression": "800 mm"}));
|
||
// The two 600 mm members are 800 mm now.
|
||
let v = total_volume(&mut s);
|
||
assert!(rel(v, tube_area() * 2400.0) < MEASURED, "{v} vs {}", tube_area() * 2400.0);
|
||
}
|
||
|
||
#[test]
|
||
fn members_along_3d_sketch_lines() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Tower"}));
|
||
run(&mut s, "sketch.options", json!({"sketch_3d": true}));
|
||
run(&mut s, "sketch.line3d", json!({"points": [[0, 0, 0], [0, 0, 1500], [600, 0, 1500]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "frame.member", json!({"sketch": "Tower", "profile": tube()}));
|
||
let bs = bodies(&mut s);
|
||
assert_eq!(bs.len(), 2, "{bs:?}");
|
||
// The upright: square to Z, the profile's x along world X.
|
||
assert!(bs.iter().any(|b| near3(b.2, [-20.0, -20.0, 0.0]) && near3(b.3, [20.0, 20.0, 1500.0])), "{bs:?}");
|
||
// The rail along X at the top.
|
||
assert!(bs.iter().any(|b| near3(b.2, [0.0, -20.0, 1480.0]) && near3(b.3, [600.0, 20.0, 1520.0])), "{bs:?}");
|
||
let v = total_volume(&mut s);
|
||
assert!(rel(v, tube_area() * 2100.0) < MEASURED, "{v} vs {} {bs:?}", tube_area() * 2100.0);
|
||
}
|
||
|
||
#[test]
|
||
fn a_profile_sketch_is_the_section() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Tube section"}));
|
||
run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 20}));
|
||
run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 17}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XZ", "name": "Post"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[0, 0], [1000, 0]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
// The material: the ring between the circles (nested loops alternate).
|
||
run(&mut s, "frame.member", json!({"sketch": "Post", "profile_sketch": "Tube section"}));
|
||
let bs = bodies(&mut s);
|
||
assert_eq!(bs.len(), 1);
|
||
assert_eq!(bs[0].0, "Tube section");
|
||
let ring = PI * (400.0 - 289.0) * 1000.0;
|
||
assert!(rel(bs[0].1, ring) < MEASURED, "{} vs {ring}", bs[0].1);
|
||
// Picked: the inner disc alone.
|
||
run(&mut s, "frame.member", json!({"sketch": "Post", "profile_sketch": "Tube section", "profiles": [{"point": [0, 0]}]}));
|
||
// A second feature of the same profile numbers on from the first.
|
||
let disc = bodies(&mut s).into_iter().find(|b| b.0 != "Tube section").unwrap();
|
||
assert_eq!(disc.0, "Tube section (2)");
|
||
assert!(rel(disc.1, PI * 289.0 * 1000.0) < MEASURED, "{disc:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn anchor_angle_and_mirror_place_the_profile() {
|
||
let place = |extra: Value| {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Rail"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[0, 0], [1000, 0]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
let mut p = json!({"sketch": "Rail", "profile": {"kind": "angle", "width": 60, "height": 40, "thickness": 5}, "anchor": "bottom_left"});
|
||
for (k, v) in extra.as_object().unwrap() {
|
||
p[k] = v.clone();
|
||
}
|
||
run(&mut s, "frame.member", p);
|
||
bodies(&mut s).remove(0)
|
||
};
|
||
// Along +X the profile's x is world +Y and its y world +Z: the heel on the line, the legs
|
||
// running +Y (60) and +Z (40).
|
||
let plain = place(json!({}));
|
||
assert!(near3(plain.2, [0.0, 0.0, 0.0]) && near3(plain.3, [1000.0, 60.0, 40.0]), "{plain:?}");
|
||
// Turned a quarter: the 60 mm leg up, the 40 mm one toward −Y.
|
||
let b = place(json!({"angle": "90 deg"}));
|
||
assert!(near3(b.2, [0.0, -40.0, 0.0]) && near3(b.3, [1000.0, 0.0, 60.0]), "{b:?}");
|
||
// Mirrored: the same box, the heel at the far side (the mass sits past the middle).
|
||
let m = place(json!({"mirror": true}));
|
||
assert!(near3(m.2, [0.0, 0.0, 0.0]) && near3(m.3, [1000.0, 60.0, 40.0]), "{m:?}");
|
||
assert!(plain.4[1] < 30.0 && m.4[1] > 30.0, "{plain:?} {m:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn bad_members_are_refused() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Arc"}));
|
||
let arc = run(&mut s, "sketch.arc.three_point", json!({"start": [0, 0], "end": [100, 0], "through": [50, 30]}));
|
||
let arc_id = arc["created"]["curves"][0].as_str().unwrap().to_string();
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Empty"}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
for (p, why) in [
|
||
(json!({"sketch": "Frame"}), "`profile`"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "profile_sketch": "Frame"}), "one of them"),
|
||
(json!({"sketch": "Frame", "profile_sketch": "Frame"}), "must not be the frame sketch"),
|
||
(json!({"sketch": "Nowhere", "profile": tube()}), "no sketch"),
|
||
(json!({"sketch": "Frame", "profile": {"kind": "rect_tube", "width": 10, "height": 10, "wall": 5}}), "wall"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "lines": []}), "`lines`"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "lines": ["nope"]}), "nope"),
|
||
(json!({"sketch": "Arc", "profile": tube(), "lines": [arc_id]}), "not a straight line"),
|
||
(json!({"sketch": "Arc", "profile": tube()}), "no lines"),
|
||
(json!({"sketch": "Empty", "profile": tube()}), "no lines"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "anchor": "middle"}), "`anchor`"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "angle": "a lot"}), "angle"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "mirror": 3}), "`mirror`"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "names": ["Rail"]}), "`names`"),
|
||
(json!({"sketch": "Frame", "profile": tube(), "names": {"l1": " "}}), "`names`"),
|
||
] {
|
||
let err = s.execute("frame.member", &p).unwrap_err().to_string();
|
||
assert!(err.contains(why), "{p}: {err}");
|
||
}
|
||
assert!(bodies(&mut s).is_empty(), "nothing was made");
|
||
// Not while a sketch is open.
|
||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||
assert!(s.execute("frame.member", &json!({"sketch": "Frame", "profile": tube()})).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn members_undo_and_survive_save_and_reopen() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
run(
|
||
&mut s,
|
||
"frame.member",
|
||
json!({"sketch": "Frame", "profile": tube(), "anchor": "bottom", "angle": "15 deg", "mirror": true, "body_name": "Rail"}),
|
||
);
|
||
let before = bodies(&mut s);
|
||
assert_eq!(before.len(), 4);
|
||
assert_eq!(before[0].0, "Rail");
|
||
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
|
||
let after = bodies(&mut reopened);
|
||
assert_eq!(before.len(), after.len());
|
||
for (b, a) in before.iter().zip(&after) {
|
||
assert_eq!(b.0, a.0);
|
||
assert!(rel(a.1, b.1) < 1e-9 && near3(a.2, b.2) && near3(a.3, b.3), "{b:?} vs {a:?}");
|
||
}
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert!(bodies(&mut s).is_empty());
|
||
run(&mut s, "edit.redo", json!({}));
|
||
assert_eq!(bodies(&mut s).len(), 4);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------------
|
||
// Regressions from the adversarial review of #4003
|
||
|
||
/// The lines of sketch `name`, as (id, start, end) in sketch coordinates.
|
||
fn sketch_lines(s: &Session, name: &str) -> Vec<(String, [f64; 2], [f64; 2])> {
|
||
let id = s.doc.find_feature(name).unwrap().id;
|
||
let sk = s.doc.sketch(id).unwrap();
|
||
sk.curves
|
||
.iter()
|
||
.filter_map(|c| match c.kind {
|
||
solidcraft_sketch::CurveKind::Line { a, b } => {
|
||
let (p, q) = (sk.points[a].pos, sk.points[b].pos);
|
||
Some((c.id.clone(), [p.x, p.y], [q.x, q.y]))
|
||
}
|
||
_ => None,
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// The id of the line of sketch `name` with both ends at x = `x`.
|
||
fn line_at_x(s: &Session, name: &str, x: f64) -> String {
|
||
sketch_lines(s, name).into_iter().find(|(_, a, b)| (a[0] - x).abs() < 1e-9 && (b[0] - x).abs() < 1e-9).unwrap().0
|
||
}
|
||
|
||
/// The id of the line of sketch `name` with both ends at y = `y`.
|
||
fn line_at_y(s: &Session, name: &str, y: f64) -> String {
|
||
sketch_lines(s, name).into_iter().find(|(_, a, b)| (a[1] - y).abs() < 1e-9 && (b[1] - y).abs() < 1e-9).unwrap().0
|
||
}
|
||
|
||
fn delete_line(s: &mut Session, sketch: &str, line: &str) {
|
||
run(s, "sketch.edit", json!({"sketch": sketch}));
|
||
run(s, "sketch.delete", json!({"entities": [line]}));
|
||
run(s, "sketch.finish", json!({}));
|
||
}
|
||
|
||
/// Each body's bounding box by name.
|
||
fn boxes(s: &mut Session) -> std::collections::BTreeMap<String, ([f64; 3], [f64; 3])> {
|
||
bodies(s).into_iter().map(|b| (b.0, (b.2, b.3))).collect()
|
||
}
|
||
|
||
#[test]
|
||
fn projected_edges_are_not_member_lines() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length": 100, "width": 100, "height": 10, "body_name": "Plate"}));
|
||
// A sketch on the plate's top face projects its edges; the one line drawn is the only member.
|
||
run(&mut s, "sketch.create", json!({"plane": {"face": [50, 50, 10]}, "name": "On plate"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[10, 10], [90, 10]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
// The plate's four edges are in the sketch, projected.
|
||
assert_eq!(sketch_lines(&s, "On plate").len(), 5);
|
||
run(&mut s, "frame.member", json!({"sketch": "On plate", "profile": tube()}));
|
||
let members: Vec<Measured> = bodies(&mut s).into_iter().filter(|b| b.0 != "Plate").collect();
|
||
assert_eq!(members.len(), 1, "{members:?}");
|
||
assert!(rel(members[0].1, tube_area() * 80.0) < MEASURED, "{members:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_profile_sketch_on_a_face_is_its_drawn_section() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length": 100, "width": 100, "height": 10, "body_name": "Plate"}));
|
||
run(&mut s, "sketch.create", json!({"plane": {"face": [50, 50, 10]}, "name": "Section on plate"}));
|
||
run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 20}));
|
||
run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 17}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XZ", "name": "Post"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[200, 0], [200, 1000]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
assert_eq!(sketch_lines(&s, "Section on plate").len(), 4, "the plate's edges, projected");
|
||
run(&mut s, "frame.member", json!({"sketch": "Post", "profile_sketch": "Section on plate"}));
|
||
let member = bodies(&mut s).into_iter().find(|b| b.0 != "Plate").unwrap();
|
||
assert!(rel(member.1, PI * (400.0 - 289.0) * 1000.0) < MEASURED, "{member:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn members_keep_their_names_when_a_line_is_deleted() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
run(&mut s, "frame.member", json!({"sketch": "Frame", "profile": tube()}));
|
||
let before = boxes(&mut s);
|
||
assert_eq!(before.len(), 4);
|
||
let right = line_at_x(&s, "Frame", 600.0);
|
||
delete_line(&mut s, "Frame", &right);
|
||
let after = boxes(&mut s);
|
||
assert_eq!(after.len(), 3, "{after:?}");
|
||
// Each member left is still called what it was, and is where it was.
|
||
for (name, bb) in &after {
|
||
assert_eq!(before.get(name), Some(bb), "{name} moved: {before:?} → {after:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_renamed_member_keeps_its_name_through_line_edits() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
run(&mut s, "frame.member", json!({"sketch": "Frame", "profile": tube()}));
|
||
let top = boxes(&mut s).into_iter().find(|(_, (lo, _))| (lo[1] - 380.0).abs() < 1e-6).unwrap();
|
||
run(&mut s, "body.rename", json!({"body": top.0, "name": "Top rail"}));
|
||
let before = boxes(&mut s);
|
||
assert_eq!(before.get("Top rail"), Some(&top.1));
|
||
let left = line_at_x(&s, "Frame", 0.0);
|
||
delete_line(&mut s, "Frame", &left);
|
||
let after = boxes(&mut s);
|
||
assert_eq!(after.len(), 3);
|
||
for (name, bb) in &after {
|
||
assert_eq!(before.get(name), Some(bb), "{name}: {before:?} → {after:?}");
|
||
}
|
||
// It survives saving and reopening.
|
||
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
|
||
assert_eq!(boxes(&mut reopened), after);
|
||
}
|
||
|
||
#[test]
|
||
fn a_numbered_member_name_is_kept_when_the_first_feature_goes() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
let (bottom, top) = (line_at_y(&s, "Frame", 0.0), line_at_y(&s, "Frame", 400.0));
|
||
run(&mut s, "frame.member", json!({"sketch": "Frame", "lines": [bottom], "profile": tube(), "name": "First"}));
|
||
run(&mut s, "frame.member", json!({"sketch": "Frame", "lines": [top], "profile": tube(), "name": "Second"}));
|
||
assert_eq!(boxes(&mut s).keys().collect::<Vec<_>>(), ["Rect Tube 40x40x3", "Rect Tube 40x40x3 (2)"]);
|
||
run(&mut s, "timeline.delete", json!({"feature": "First"}));
|
||
assert_eq!(boxes(&mut s).keys().collect::<Vec<_>>(), ["Rect Tube 40x40x3 (2)"]);
|
||
}
|
||
|
||
#[test]
|
||
fn an_asymmetric_profile_turns_with_its_3d_line() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Tower"}));
|
||
run(&mut s, "sketch.options", json!({"sketch_3d": true}));
|
||
run(&mut s, "sketch.line3d", json!({"points": [[0, 0, 0], [0, 0, 1500], [600, 0, 1500]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "frame.member", json!({"sketch": "Tower", "profile": {"kind": "bar", "width": 60, "height": 10}}));
|
||
let bs = bodies(&mut s);
|
||
// The post: the bar's width (its x) along world X, its height along Y.
|
||
assert!(bs.iter().any(|b| near3(b.2, [-30.0, -5.0, 0.0]) && near3(b.3, [30.0, 5.0, 1500.0])), "{bs:?}");
|
||
// The rail along +X: width along +Y, height up.
|
||
assert!(bs.iter().any(|b| near3(b.2, [0.0, -30.0, 1495.0]) && near3(b.3, [600.0, 30.0, 1505.0])), "{bs:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_post_a_hair_off_vertical_is_oriented_as_a_vertical_one() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Posts"}));
|
||
run(&mut s, "sketch.options", json!({"sketch_3d": true}));
|
||
run(&mut s, "sketch.line3d", json!({"points": [[0, 0, 0], [1e-5, 0, 1000]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "frame.member", json!({"sketch": "Posts", "profile": {"kind": "bar", "width": 60, "height": 10}}));
|
||
let b = bodies(&mut s).remove(0);
|
||
// Width along X as for a true vertical, not along Y.
|
||
assert!((b.3[0] - b.2[0] - 60.0).abs() < 1e-3 && (b.3[1] - b.2[1] - 10.0).abs() < 1e-3, "{b:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn thick_sections_build_with_their_default_radii() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Rail"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[0, 0], [500, 0]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
for profile in [
|
||
json!({"kind": "angle", "width": 20, "height": 20, "thickness": 10}),
|
||
json!({"kind": "channel", "height": 50, "width": 10, "web": 6, "flange": 2}),
|
||
json!({"kind": "channel", "height": 20, "width": 40, "web": 5, "flange": 8}),
|
||
json!({"kind": "i_beam", "height": 100, "width": 10, "web": 6, "flange": 5}),
|
||
] {
|
||
run(&mut s, "frame.member", json!({"sketch": "Rail", "profile": profile}));
|
||
}
|
||
assert_eq!(bodies(&mut s).len(), 4);
|
||
}
|
||
|
||
#[test]
|
||
fn profile_dimensions_follow_parameters() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "parameters.add", json!({"name": "T", "expression": "3 mm"}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Rail"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[0, 0], [1000, 0]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
let square = |t: f64| (1600.0 - (40.0 - 2.0 * t).powi(2)) * 1000.0;
|
||
let sharp = json!({"kind": "rect_tube", "width": 40, "height": 40, "wall": "T", "outer_radius": 0});
|
||
let props = run(&mut s, "frame.profile.properties", json!({"profile": sharp}));
|
||
assert!(rel(f(&props["area"]), square(3.0) / 1000.0) < 1e-12, "{props}");
|
||
run(&mut s, "frame.member", json!({"sketch": "Rail", "profile": sharp}));
|
||
assert!(rel(total_volume(&mut s), square(3.0)) < 1e-9);
|
||
run(&mut s, "parameters.change", json!({"name": "T", "expression": "2 mm"}));
|
||
assert!(rel(total_volume(&mut s), square(2.0)) < 1e-9, "{}", total_volume(&mut s));
|
||
// A parameter that makes the profile not fit fails the feature, naming the dimension.
|
||
let err = s.execute("parameters.change", &json!({"name": "T", "expression": "25 mm"})).err().map(|e| e.to_string()).unwrap_or_default();
|
||
let fid = s.doc.features.iter().find(|f| matches!(f.kind, solidcraft_doc::FeatureKind::FrameMember { .. })).unwrap().id;
|
||
let failing = s.model.result(fid).and_then(|r| r.error.clone()).unwrap_or_default();
|
||
assert!(err.contains("wall") || failing.contains("wall"), "{err} / {failing}");
|
||
}
|
||
|
||
#[test]
|
||
fn bare_profile_numbers_are_in_the_design_units() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "document.units", json!({"units": "in"}));
|
||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Rail"}));
|
||
run(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0]]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "frame.member", json!({"sketch": "Rail", "profile": {"kind": "bar", "width": 2, "height": 1}}));
|
||
let b = bodies(&mut s).remove(0);
|
||
// 2 in across (world Y) and 1 in up (world Z).
|
||
assert!((b.3[1] - b.2[1] - 50.8).abs() < 1e-6 && (b.3[2] - b.2[2] - 25.4).abs() < 1e-6, "{b:?}");
|
||
let props = run(&mut s, "frame.profile.properties", json!({"profile": {"kind": "round_bar", "diameter": 1}}));
|
||
assert!((f(&props["width"]) - 25.4).abs() < 1e-9, "{props}");
|
||
}
|
||
|
||
#[test]
|
||
fn members_follow_a_frame_sketch_in_another_component() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
let c = run(&mut s, "component.create", json!({"name": "Frame parts", "grounded": false}))["component"].as_u64().unwrap();
|
||
let o = s.doc.occurrence_of(c).unwrap().id;
|
||
run(&mut s, "occurrence.move", json!({"occurrence": o, "translate": [0, 0, 100], "capture": true}));
|
||
// Made in the moved component, the members still lie on the root's frame sketch.
|
||
run(&mut s, "frame.member", json!({"sketch": "Frame", "profile": tube()}));
|
||
let bs = bodies(&mut s);
|
||
assert_eq!(bs.len(), 4);
|
||
for b in &bs {
|
||
assert!((b.2[2] + 20.0).abs() < 1e-6 && (b.3[2] - 20.0).abs() < 1e-6, "{b:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn listing_a_line_twice_is_refused() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
let bottom = line_at_y(&s, "Frame", 0.0);
|
||
let err = s.execute("frame.member", &json!({"sketch": "Frame", "profile": tube(), "lines": [bottom, bottom]})).unwrap_err().to_string();
|
||
assert!(err.contains("listed twice"), "{err}");
|
||
}
|
||
|
||
/// Edit Feature keeps each member's name, a renamed one too, through a change of profile; giving
|
||
/// the members a name renames them all.
|
||
#[test]
|
||
fn editing_the_feature_keeps_member_names_until_it_names_them() {
|
||
let mut s = Session::default();
|
||
rectangle_frame(&mut s);
|
||
let fid = run(&mut s, "frame.member", json!({"sketch": "Frame", "profile": tube()}))["feature"].clone();
|
||
let top = boxes(&mut s).into_iter().find(|(_, (lo, _))| (lo[1] - 380.0).abs() < 1e-6).unwrap().0;
|
||
run(&mut s, "body.rename", json!({"body": top, "name": "Top rail"}));
|
||
let names: Vec<String> = boxes(&mut s).into_keys().collect();
|
||
let bigger = json!({"kind": "rect_tube", "width": 50, "height": 50, "wall": 3});
|
||
run(&mut s, "timeline.redefine", json!({"feature": fid, "command": "frame.member", "params": {"sketch": "Frame", "profile": bigger}}));
|
||
let after = boxes(&mut s);
|
||
assert_eq!(after.keys().cloned().collect::<Vec<_>>(), names);
|
||
// The top rail is the 50 mm tube now, centred on the line at y = 400.
|
||
assert!(near3(after["Top rail"].0, [0.0, 375.0, -25.0]) && near3(after["Top rail"].1, [600.0, 425.0, 25.0]), "{after:?}");
|
||
let params = json!({"sketch": "Frame", "profile": bigger, "body_name": "Rail"});
|
||
run(&mut s, "timeline.redefine", json!({"feature": fid, "command": "frame.member", "params": params}));
|
||
assert_eq!(boxes(&mut s).into_keys().collect::<Vec<_>>(), ["Rail", "Rail (2)", "Rail (3)", "Rail (4)"]);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert_eq!(boxes(&mut s).into_keys().collect::<Vec<_>>(), names);
|
||
}
|