* Kernel: the B-rep record and the native body file come from solidcore-record SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history, envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses `solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted. What computes from coordinates stays with the kernel, in geom's `brep`: - `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes, unit revolution axes, non-singular placements). `check::validate` and `check::validate_built` are the record's validation and these together, and every caller of `Brep::validate` uses them, so what is accepted is unchanged; - `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`, `edge_curve_interval` and `form_turns`; - `brep::pcurve::eval`: a pcurve's point; - `geometry::check`, `placement::moved` and `split_edges` become functions on the record. The kernel's native module keeps the conversion between a body and its saved record (metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module declared, is deleted. solidcore-record is pinned to its rev on solidcore's `layer-record` branch. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT * Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`, `Region2`) moves to `solidcore-record`, with its constants and component-wise operators only (owner decision, solidcore layer split). Their geometry stays in geom as traits: `Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`, `Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller names the types from `solidcore_record`; geom no longer defines or re-exports them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT * Kernel: pin solidcore-record to solidcore main f5e8e9a29 solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is identical to the rev pinned before but for its clippy configuration. The lock is regenerated against the merged rev. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT --------- Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
453 lines
23 KiB
Rust
453 lines
23 KiB
Rust
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||
|
||
use crate::Session;
|
||
use serde_json::{Value, json};
|
||
use solidcore_record::Vec3;
|
||
use solidcraft_doc::{Document, FeatureKind, RevolveConvention};
|
||
use solidcraft_geom::prelude::*;
|
||
use std::f64::consts::{FRAC_PI_2, PI, SQRT_2};
|
||
|
||
fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
|
||
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
|
||
}
|
||
|
||
fn profile(s: &mut Session, opposed: bool) {
|
||
run(s, "sketch.create", json!({"name":"Profile","plane":"XY"}));
|
||
run(s, "sketch.rectangle.two_point", json!({"p0":[2,0],"p1":[4,10]}));
|
||
if opposed {
|
||
run(s, "sketch.rectangle.two_point", json!({"p0":[-4,0],"p1":[-2,10]}));
|
||
}
|
||
run(s, "sketch.finish", json!({}));
|
||
}
|
||
|
||
fn turn(s: &mut Session, sign: f64, settings: Value) {
|
||
let mut p = json!({"sketch":"Profile","axis":{"origin":[0,0,0],"dir":[0,sign,0]},"angle":"90 deg","direction":"symmetric","operation":"new","name":"Turn","body_name":"Turned"});
|
||
p.as_object_mut().unwrap().extend(settings.as_object().unwrap().clone());
|
||
run(s, "solid.revolve", p);
|
||
}
|
||
|
||
fn check_centered(s: &Session, opposed: bool) {
|
||
let state = s.model.state();
|
||
let expected = 30.0 * PI * if opposed { 2.0 } else { 1.0 };
|
||
let volume: f64 = state.bodies.iter().map(|mb| solidcraft_kernel::measure(&mb.body).unwrap().volume).sum();
|
||
assert!((volume - expected).abs() < 0.03, "{volume} vs {expected}");
|
||
for sign in if opposed { vec![1.0, -1.0] } else { vec![1.0] } {
|
||
let body = &state
|
||
.bodies
|
||
.iter()
|
||
.find(|mb| mb.body.classify_point(Vec3::new(sign * 3.0, 5.0, 0.0)).unwrap() == solidcraft_kernel::PointClass::Inside)
|
||
.unwrap()
|
||
.body;
|
||
assert_eq!(body.classify_point(Vec3::new(0.0, 5.0, 3.0)).unwrap(), solidcraft_kernel::PointClass::Outside);
|
||
assert_eq!(body.classify_point(Vec3::new(sign * 3.0 * (PI / 6.0).cos(), 5.0, 1.5)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
assert_eq!(body.classify_point(Vec3::new(sign * 3.0 * (PI / 6.0).cos(), 5.0, -1.5)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
let bounds = body.mesh(&solidcraft_kernel::MeshTolerance::chord(1e-4)).unwrap().bounds();
|
||
assert!((bounds.min.z + 2.0 * SQRT_2).abs() < 1e-6, "{bounds:?}");
|
||
assert!((bounds.max.z - 2.0 * SQRT_2).abs() < 1e-6, "{bounds:?}");
|
||
let inner_x = if sign > 0.0 { bounds.min.x } else { -bounds.max.x };
|
||
assert!((inner_x - SQRT_2).abs() < 1e-6, "{bounds:?}");
|
||
let centroid = solidcraft_kernel::measure(body).unwrap().centroid;
|
||
let radial = (2.0 / 3.0) * (64.0 - 8.0) / (16.0 - 4.0);
|
||
let want_x = radial * (PI / 4.0).sin() / (PI / 4.0);
|
||
assert!((centroid.x - sign * want_x).abs() < 0.005, "{centroid:?}");
|
||
assert!((centroid.y - 5.0).abs() < 1e-6);
|
||
assert!(centroid.z.abs() < 1e-6);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn new_symmetric_revolves_center_material_for_both_axis_signs_and_negative_angles() {
|
||
for sign in [-1.0, 1.0] {
|
||
for angle in ["90 deg", "-90 deg"] {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
turn(&mut s, sign, json!({"angle":angle}));
|
||
assert!(matches!(s.doc.find_feature("Turn").unwrap().kind, FeatureKind::Revolve { convention: RevolveConvention::SketchNormal, .. }));
|
||
check_centered(&s, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn opposed_profiles_use_independent_sweep_axes() {
|
||
for sign in [-1.0, 1.0] {
|
||
let mut s = Session::default();
|
||
profile(&mut s, true);
|
||
turn(&mut s, sign, json!({}));
|
||
check_centered(&s, true);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn two_sided_revolves_use_the_canonical_negative_and_positive_limits() {
|
||
for sign in [-1.0, 1.0] {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
turn(&mut s, sign, json!({"direction":"positive","angle":"60 deg","angle2":"30 deg"}));
|
||
let state = s.model.state();
|
||
let body = &state.bodies[0].body;
|
||
let bounds = body.mesh(&solidcraft_kernel::MeshTolerance::chord(1e-4)).unwrap().bounds();
|
||
assert!((bounds.min.x - 1.0).abs() < 1e-6, "{bounds:?}");
|
||
assert!((bounds.max.x - 4.0).abs() < 1e-4);
|
||
assert!((bounds.min.z + 2.0).abs() < 1e-6);
|
||
assert!((bounds.max.z - 2.0 * 3.0f64.sqrt()).abs() < 1e-6);
|
||
assert_eq!(body.classify_point(Vec3::new(3.0, 5.0, 0.0)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
assert_eq!(body.classify_point(Vec3::new(0.0, 5.0, 3.0)).unwrap(), solidcraft_kernel::PointClass::Outside);
|
||
assert!((solidcraft_kernel::measure(body).unwrap().volume - 30.0 * PI).abs() < 0.03);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn legacy_missing_convention_keeps_geometry_through_edit_redefine_undo_and_reopen() {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
turn(&mut s, -1.0, json!({"convention":"legacy_axis_start"}));
|
||
let mut saved: Value = serde_json::from_str(&s.doc.to_json()).unwrap();
|
||
saved["format"] = json!("solidcraft/10");
|
||
for f in saved["features"].as_array_mut().unwrap() {
|
||
f.as_object_mut().unwrap().remove("convention");
|
||
}
|
||
let mut s = Session::new(Document::from_json(&saved.to_string()).unwrap());
|
||
let original = s.doc.find_feature("Turn").unwrap().kind.clone();
|
||
let check = |s: &Session| {
|
||
assert_eq!(s.doc.find_feature("Turn").unwrap().kind, original);
|
||
let state = s.model.state();
|
||
let body = &state.bodies[0].body;
|
||
assert_eq!(body.classify_point(Vec3::new(0.0, 5.0, 3.0)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
assert_eq!(body.classify_point(Vec3::new(3.0, 5.0, 0.0)).unwrap(), solidcraft_kernel::PointClass::Outside);
|
||
let bounds = body.mesh(&solidcraft_kernel::MeshTolerance::chord(1e-4)).unwrap().bounds();
|
||
assert!((bounds.min.x + 2.0 * SQRT_2).abs() < 1e-6);
|
||
assert!((bounds.max.x - 2.0 * SQRT_2).abs() < 1e-6);
|
||
assert!((bounds.min.z - SQRT_2).abs() < 1e-6);
|
||
};
|
||
check(&s);
|
||
let angle_input = s.doc.find_feature("Turn").unwrap().param_names[0].clone();
|
||
run(&mut s, "parameters.change", json!({"name":angle_input,"expression":"60 deg"}));
|
||
let changed = s.model.state();
|
||
assert_eq!(changed.bodies[0].body.classify_point(Vec3::new(1.5, 5.0, 3.0 * 3.0f64.sqrt() / 2.0)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
assert_eq!(changed.bodies[0].body.classify_point(Vec3::new(3.0, 5.0, 0.0)).unwrap(), solidcraft_kernel::PointClass::Outside);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
check(&s);
|
||
run(&mut s, "timeline.edit", json!({"feature":"Turn","set":{"angle":"90 deg"}}));
|
||
check(&s);
|
||
run(
|
||
&mut s,
|
||
"timeline.redefine",
|
||
json!({"feature":"Turn","command":"solid.revolve","params":{"sketch":"Profile","axis":{"origin":[0,0,0],"dir":[0,-1,0]},"angle":"90 deg","direction":"symmetric","body_name":"Turned"}}),
|
||
);
|
||
check(&s);
|
||
run(&mut s, "timeline.edit", json!({"feature":"Turn","set":{"convention":"sketch_normal"}}));
|
||
check_centered(&s, false);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
check(&s);
|
||
let reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
|
||
check(&reopened);
|
||
// A newly authored feature in this migrated document uses current semantics.
|
||
turn(&mut s, -1.0, json!({"name":"NewTurn","body_name":"NewTurned"}));
|
||
assert!(matches!(s.doc.find_feature("NewTurn").unwrap().kind, FeatureKind::Revolve { convention: RevolveConvention::SketchNormal, .. }));
|
||
}
|
||
|
||
#[test]
|
||
fn extent_handle_angles_match_new_and_legacy_material() {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
let state = s.model.state();
|
||
let ss = &state.sketches[0];
|
||
let regions = vec![ss.profiles[0].region.clone()];
|
||
for convention in [RevolveConvention::SketchNormal, RevolveConvention::LegacyAxisStart] {
|
||
let extent = solidcraft_doc::revolve_extent_with_convention(
|
||
&state,
|
||
&ss.plane,
|
||
®ions,
|
||
(Vec3::ZERO, -Vec3::Y),
|
||
(FRAC_PI_2, None),
|
||
true,
|
||
None,
|
||
convention,
|
||
)
|
||
.unwrap();
|
||
assert_eq!(extent.rotation_axis, -Vec3::Y);
|
||
assert!((extent.display_start - if convention == RevolveConvention::SketchNormal { -PI / 4.0 } else { PI / 4.0 }).abs() < 1e-12);
|
||
assert!((extent.sweep - FRAC_PI_2).abs() < 1e-12);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn symmetric_revolve_preserves_a_translated_rotated_sketch_frame() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"name":"Profile","plane":{"origin":[10,20,30],"x_dir":[0,0,1],"y_dir":[1,0,0]}}));
|
||
run(&mut s, "sketch.rectangle.two_point", json!({"p0":[2,0],"p1":[4,10]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "solid.revolve", json!({"sketch":"Profile","axis":{"origin":[10,20,30],"dir":[-1,0,0]},"angle":"90 deg","direction":"symmetric"}));
|
||
let state = s.model.state();
|
||
let body = &state.bodies[0].body;
|
||
let bounds = body.mesh(&solidcraft_kernel::MeshTolerance::chord(1e-4)).unwrap().bounds();
|
||
assert!(bounds.min.dist(Vec3::new(10.0, 20.0 - 2.0 * SQRT_2, 30.0 + SQRT_2)) < 1e-6, "{bounds:?}");
|
||
assert!(bounds.max.dist(Vec3::new(20.0, 20.0 + 2.0 * SQRT_2, 34.0)) < 1e-4, "{bounds:?}");
|
||
assert_eq!(body.classify_point(Vec3::new(15.0, 20.0, 33.0)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
assert_eq!(body.classify_point(Vec3::new(15.0, 23.0, 30.0)).unwrap(), solidcraft_kernel::PointClass::Outside);
|
||
assert!((solidcraft_kernel::measure(body).unwrap().volume - 30.0 * PI).abs() < 0.03);
|
||
}
|
||
|
||
#[test]
|
||
fn copied_revolves_keep_their_convention_and_angular_material() {
|
||
for convention in ["sketch_normal", "legacy_axis_start"] {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
turn(&mut s, -1.0, json!({"convention":convention}));
|
||
run(&mut s, "timeline.copy", json!({"features":["Profile","Turn"]}));
|
||
run(&mut s, "timeline.paste", json!({"translate":[0,20,0]}));
|
||
let state = s.model.state();
|
||
let probe = if convention == "sketch_normal" { Vec3::new(3.0, 25.0, 0.0) } else { Vec3::new(0.0, 25.0, 3.0) };
|
||
assert!(state.bodies.iter().any(|mb| mb.body.classify_point(probe).unwrap() == solidcraft_kernel::PointClass::Inside));
|
||
let modes: Vec<_> = s
|
||
.doc
|
||
.features
|
||
.iter()
|
||
.filter_map(|f| if let FeatureKind::Revolve { convention, .. } = f.kind { Some(convention) } else { None })
|
||
.collect();
|
||
assert_eq!(modes.len(), 2);
|
||
assert_eq!(modes[0], modes[1]);
|
||
let reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
|
||
assert!(reopened.model.state().bodies.iter().any(|mb| mb.body.classify_point(probe).unwrap() == solidcraft_kernel::PointClass::Inside));
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn centered_coplanar_cut_uses_the_actual_angular_interval() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"corner":[2,0,-4],"length":2,"width":10,"height":8,"body_name":"Stock"}));
|
||
profile(&mut s, false);
|
||
turn(&mut s, -1.0, json!({"operation":"cut","targets":["Stock"]}));
|
||
let state = s.model.state();
|
||
// Removed sector clipped by x>=2: 10∫[-π/4,π/4](16−4sec²θ)/2 dθ.
|
||
// The sector crosses the whole stock at z=0, leaving two disconnected solids.
|
||
let expected = 200.0 - 40.0 * PI;
|
||
let volumes: Vec<_> = state.bodies.iter().map(|mb| solidcraft_kernel::measure(&mb.body).unwrap().volume).collect();
|
||
let total: f64 = volumes.iter().sum();
|
||
assert!((total - expected).abs() < 0.05, "{volumes:?}: total{total}, expected{expected}");
|
||
assert_eq!(state.bodies.len(), 2);
|
||
assert!(volumes.iter().all(|v| (*v - expected / 2.0).abs() < 0.025));
|
||
let contains = |p| state.bodies.iter().any(|mb| mb.body.classify_point(p).unwrap() == solidcraft_kernel::PointClass::Inside);
|
||
assert!(!contains(Vec3::new(3.0, 5.0, 0.0)));
|
||
assert!(contains(Vec3::new(3.0, 5.0, 3.5)));
|
||
assert!(contains(Vec3::new(3.0, 5.0, -3.5)));
|
||
}
|
||
|
||
#[test]
|
||
fn one_sided_and_full_revolves_keep_the_existing_material() {
|
||
for angle in ["90 deg", "360 deg"] {
|
||
for sign in [-1.0, 1.0] {
|
||
for convention in ["legacy_axis_start", "sketch_normal"] {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
turn(&mut s, sign, json!({"angle":angle,"direction":"positive","convention":convention}));
|
||
let state = s.model.state();
|
||
let body = &state.bodies[0].body;
|
||
assert_eq!(body.classify_point(Vec3::new(3.0 / SQRT_2, 5.0, 3.0 / SQRT_2)).unwrap(), solidcraft_kernel::PointClass::Inside);
|
||
assert_eq!(
|
||
body.classify_point(Vec3::new(-3.0 / SQRT_2, 5.0, -3.0 / SQRT_2)).unwrap() == solidcraft_kernel::PointClass::Inside,
|
||
angle == "360 deg"
|
||
);
|
||
let expected = if angle == "360 deg" { 120.0 * PI } else { 30.0 * PI };
|
||
assert!((solidcraft_kernel::measure(body).unwrap().volume - expected).abs() < 0.08);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn point_targets_use_each_profiles_canonical_axis_for_both_axis_signs() {
|
||
for sign in [-1.0, 1.0] {
|
||
for opposed in [false, true] {
|
||
let mut s = Session::default();
|
||
profile(&mut s, opposed);
|
||
turn(&mut s, sign, json!({"to":[0,5,3]}));
|
||
let state = s.model.state();
|
||
let expected = 30.0 * PI * if opposed { 2.0 } else { 1.0 };
|
||
let volume: f64 = state.bodies.iter().map(|mb| solidcraft_kernel::measure(&mb.body).unwrap().volume).sum();
|
||
assert!((volume - expected).abs() < 0.05, "{volume}");
|
||
assert!(
|
||
state
|
||
.bodies
|
||
.iter()
|
||
.any(|mb| mb.body.classify_point(Vec3::new(3.0 / SQRT_2, 5.0, 3.0 / SQRT_2)).unwrap() == solidcraft_kernel::PointClass::Inside)
|
||
);
|
||
assert!(
|
||
!state
|
||
.bodies
|
||
.iter()
|
||
.any(|mb| mb.body.classify_point(Vec3::new(3.0 / SQRT_2, 5.0, -3.0 / SQRT_2)).unwrap() == solidcraft_kernel::PointClass::Inside)
|
||
);
|
||
assert_eq!(
|
||
state
|
||
.bodies
|
||
.iter()
|
||
.any(|mb| mb.body.classify_point(Vec3::new(-3.0 / SQRT_2, 5.0, 3.0 / SQRT_2)).unwrap() == solidcraft_kernel::PointClass::Inside),
|
||
opposed
|
||
);
|
||
assert!(
|
||
!state
|
||
.bodies
|
||
.iter()
|
||
.any(|mb| mb.body.classify_point(Vec3::new(-3.0 / SQRT_2, 5.0, -3.0 / SQRT_2)).unwrap() == solidcraft_kernel::PointClass::Inside)
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn an_axis_target_is_an_actionable_atomic_error_for_new_convention() {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
let before = s.doc.to_json();
|
||
let e = s.execute("solid.revolve", &json!({"sketch":"Profile","axis":"Y","to":[0,5,0]})).unwrap_err().to_string();
|
||
assert!(e.contains("target lies on the axis"), "{e}");
|
||
assert_eq!(s.doc.to_json(), before);
|
||
}
|
||
|
||
#[test]
|
||
fn curved_targets_keep_only_the_material_before_the_post_for_both_axis_signs() {
|
||
for sign in [-1.0, 1.0] {
|
||
for opposed in [false, true] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.cylinder", json!({"base":[0,14,-5],"radius":4,"height":15,"body_name":"Post"}));
|
||
run(&mut s, "sketch.create", json!({"name":"Profile","plane":"XZ"}));
|
||
run(&mut s, "sketch.rectangle.two_point", json!({"p0":[10,0],"p1":[15,5]}));
|
||
if opposed {
|
||
run(&mut s, "sketch.rectangle.two_point", json!({"p0":[-15,0],"p1":[-10,5]}));
|
||
}
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "solid.revolve", json!({"sketch":"Profile","axis":{"origin":[0,0,0],"dir":[0,0,sign]},"to":[4,14,2],"body_name":"Arc"}));
|
||
let state = s.model.state();
|
||
let post = &state.body("Post").unwrap().body;
|
||
let arcs: Vec<_> = state.bodies.iter().filter(|mb| mb.name != "Post").collect();
|
||
assert_eq!(arcs.len(), if opposed { 2 } else { 1 });
|
||
for side in if opposed { vec![1.0, -1.0] } else { vec![1.0] } {
|
||
let probe = Vec3::new(side * 12.0 * (PI / 6.0).cos(), 6.0, -2.5);
|
||
let arc = &arcs.iter().find(|mb| mb.body.classify_point(probe).unwrap() == solidcraft_kernel::PointClass::Inside).unwrap().body;
|
||
assert_eq!(
|
||
arc.classify_point(Vec3::new(-side * 12.0 * (PI / 6.0).cos(), 6.0, -2.5)).unwrap(),
|
||
solidcraft_kernel::PointClass::Outside
|
||
);
|
||
assert_eq!(
|
||
arc.classify_point(Vec3::new(side * 12.0 * (PI / 6.0).cos(), -6.0, -2.5)).unwrap(),
|
||
solidcraft_kernel::PointClass::Outside
|
||
);
|
||
let full = PI * (225.0 - 100.0) * 5.0;
|
||
let angle = solidcraft_kernel::measure(arc).unwrap().volume / full * 360.0;
|
||
assert!(angle > 60.0 && angle < 90.0, "{angle}");
|
||
let overlap = solidcraft_kernel::boolean(arc, post, solidcraft_kernel::BoolOp::Intersect).unwrap();
|
||
assert!(overlap.is_none_or(|b| solidcraft_kernel::measure(&b).unwrap().volume < 1e-3));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The construction-axis points of a feature's JSON moved along x by `dx`.
|
||
fn shift_points(v: &mut Value, dx: f64) {
|
||
match v {
|
||
Value::Array(a) if a.len() == 3 && a.iter().all(Value::is_number) => a[0] = json!(a[0].as_f64().unwrap() + dx),
|
||
Value::Array(a) => a.iter_mut().for_each(|x| shift_points(x, dx)),
|
||
Value::Object(o) => o.values_mut().for_each(|x| shift_points(x, dx)),
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// A construction axis picked as the revolve axis (#2885, #4506) is saved by name, survives
|
||
/// saving and opening, and the revolve follows the axis when it is edited.
|
||
#[test]
|
||
fn construction_axis_revolve_follows_the_axis() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "construct.axis.two_points", json!({"a":{"point":[0,0,0]},"b":{"point":[0,30,0]},"name":"Axis1"}));
|
||
profile(&mut s, false);
|
||
run(&mut s, "solid.revolve", json!({"sketch":"Profile","axis":"Axis1","angle":"180 deg","operation":"new","profiles":[0],"name":"Turn"}));
|
||
let turn = s.doc.find_feature("Turn").unwrap();
|
||
assert!(matches!(&turn.kind, FeatureKind::Revolve { axis: solidcraft_doc::AxisRef::Construction { name }, .. } if name == "Axis1"));
|
||
let reopened = Document::from_json(&s.doc.to_json()).unwrap();
|
||
assert_eq!(reopened.find_feature("Turn").unwrap().kind, turn.kind);
|
||
let volume = |s: &Session| solidcraft_kernel::measure(&s.model.state().bodies[0].body).unwrap().volume;
|
||
assert!((volume(&s) - 60.0 * PI).abs() < 0.05);
|
||
assert!((volume(&Session::new(reopened)) - 60.0 * PI).abs() < 0.05);
|
||
// Moving the axis 1 mm away from the profile widens the ring: radii 3 to 5 instead of 2 to 4.
|
||
let mut axis = serde_json::to_value(s.doc.find_feature("Axis1").unwrap()).unwrap();
|
||
let def = if axis.get("def").is_some() { axis.get_mut("def") } else { axis.pointer_mut("/kind/def") }.unwrap();
|
||
shift_points(def, -1.0);
|
||
let set = if axis.get("def").is_some() { json!({"def": axis["def"]}) } else { json!({"kind": {"def": axis["kind"]["def"]}}) };
|
||
run(&mut s, "timeline.edit", json!({"feature":"Axis1","set":set}));
|
||
assert!((volume(&s) - 80.0 * PI).abs() < 0.05, "{}", volume(&s));
|
||
}
|
||
|
||
#[test]
|
||
fn construction_axis_revolve_rejects_invalid_axes_atomically() {
|
||
for (a, b, message) in [
|
||
([0, 0, 0], [0, 0, 30], "does not lie in the sketch plane"),
|
||
([0, 0, 1], [0, 30, 1], "does not lie in the sketch plane"),
|
||
([3, 0, 0], [3, 30, 0], "profile crosses the revolve axis"),
|
||
] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "construct.axis.two_points", json!({"a":{"point":a},"b":{"point":b},"name":"Axis1"}));
|
||
profile(&mut s, false);
|
||
let before = s.doc.to_json();
|
||
let error =
|
||
s.execute("solid.revolve", &json!({"sketch":"Profile","axis":"Axis1","angle":"180 deg","operation":"new"})).unwrap_err().to_string();
|
||
assert!(error.contains(message), "{error}");
|
||
assert_eq!(s.doc.to_json(), before);
|
||
assert!(s.model.state().bodies.is_empty());
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn world_axis_from_timeline_inspect_round_trips() {
|
||
for (axis, radial, axial) in [("X", Vec3::Y, Vec3::X), ("Y", Vec3::X, Vec3::Y), ("Z", Vec3::X, Vec3::Z)] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "sketch.create", json!({"name":"Profile","plane":{"origin":[0,0,0],"x_dir":radial,"y_dir":axial}}));
|
||
run(&mut s, "sketch.rectangle.two_point", json!({"p0":[2,0],"p1":[4,10]}));
|
||
run(&mut s, "sketch.finish", json!({}));
|
||
run(&mut s, "solid.revolve", json!({"sketch":"Profile","axis":axis,"angle":"90 deg","operation":"new","name":"Turn"}));
|
||
let inspected = run(&mut s, "timeline.inspect", json!({"feature":"Turn"}));
|
||
let stored_axis = inspected["definition"]["axis"].clone();
|
||
assert_eq!(stored_axis, json!({"type":"world","axis":axis}));
|
||
let original = s.doc.find_feature("Turn").unwrap().kind.clone();
|
||
let original_measure = solidcraft_kernel::measure(&s.model.state().bodies[0].body).unwrap();
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert!(s.model.state().bodies.is_empty());
|
||
|
||
run(&mut s, "solid.revolve", json!({"sketch":"Profile","axis":stored_axis,"angle":"90 deg","operation":"new","name":"Turn"}));
|
||
assert_eq!(s.doc.find_feature("Turn").unwrap().kind, original);
|
||
let state = s.model.state();
|
||
assert_eq!(state.bodies.len(), 1);
|
||
let measure = solidcraft_kernel::measure(&state.bodies[0].body).unwrap();
|
||
// A quarter of an annular cylinder: pi * (4^2 - 2^2) * 10 / 4.
|
||
assert!((measure.volume - 30.0 * PI).abs() < 0.03, "{axis}: {}", measure.volume);
|
||
assert!((measure.volume - original_measure.volume).abs() < 1e-6);
|
||
assert!(measure.centroid.dist(original_measure.centroid) < 1e-6);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn invalid_world_axis_objects_are_rejected_atomically() {
|
||
let mut s = Session::default();
|
||
profile(&mut s, false);
|
||
let before = s.doc.to_json();
|
||
for axis in [
|
||
json!({"type":"world"}),
|
||
json!({"type":"world","axis":null}),
|
||
json!({"type":"world","axis":1}),
|
||
json!({"type":"world","axis":[0,1,0]}),
|
||
json!({"type":"world","axis":{}}),
|
||
json!({"type":"world","axis":""}),
|
||
json!({"type":"world","axis":"x"}),
|
||
json!({"type":"world","axis":"y"}),
|
||
json!({"type":"world","axis":"z"}),
|
||
json!({"type":"world","axis":"W","dir":[0,1,0]}),
|
||
] {
|
||
let error = s.execute("solid.revolve", &json!({"sketch":"Profile","axis":axis,"angle":"90 deg","operation":"new"})).unwrap_err();
|
||
let message = error.to_string();
|
||
assert!(matches!(error, crate::EngineError::BadParams { .. }), "{axis}: {message}");
|
||
assert!(message.contains("world axis") && message.contains("X, Y or Z"), "{axis}: {message}");
|
||
assert_eq!(s.doc.to_json(), before);
|
||
assert!(s.model.state().bodies.is_empty());
|
||
}
|
||
}
|