smlib: C++ bodies cross solidcore and come back with the C++ kernel's own arrays
C++ -> arrays -> solidcore -> arrays -> C++ over a filleted box, a holed plate, a swept B-spline, an ellipse edge, a sealed void, sheets, wire edges with a point shell, two lumps and a shelled rounded box. The reference is the C++ kernel's own crossing, which itself moves trims by about 1e-7 on a shelled box; tolerances and EXTENT are excepted, and the test says why. No port difference found. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01MNXLXkZLQ6T7TSi4wswcmk
This commit is contained in:
1 parent
922f781e2e
commit
ae76f0567c
1 file changed
+277
@@ -366,3 +366,280 @@ fn a_sealed_void_matches_the_cpp_kernel() {
|
||||
outer_first(&h.cpp_arrays().unwrap(), &format!("{at}, C++ export"));
|
||||
}
|
||||
}
|
||||
|
||||
/// C++ bodies through solidcore and back. Three crossings of the same C++ arrays are held equal,
|
||||
/// ints exactly and reals to 1e-12 (the record too, where the record can say it):
|
||||
/// - the C++ kernel's own: its import of them, exported again;
|
||||
/// - solidcore's: `from_arrays`, then `to_arrays`;
|
||||
/// - both: solidcore's arrays imported by the C++ kernel and exported again.
|
||||
///
|
||||
/// The first is the reference, not the arrays that went in: a crossing itself moves a few reals on
|
||||
/// the C++ kernel too (UV trims made at export, about 1e-7 on a shelled box), so those are held to
|
||||
/// the arrays that went in only at [`FIRST_CROSSING`]. Tolerances are excepted: they cross on
|
||||
/// purpose as each entity's own (`own_tolerances`, TOLERANCE as twice the B-rep's) where the C++
|
||||
/// export writes the largest over them all, so that a body does not grow its tolerance at every
|
||||
/// crossing (`tolerances_cross_the_arrays_per_entity`); on a body an operation made the numbers
|
||||
/// cannot agree. So is EXTENT, the bounding box padded by those tolerances.
|
||||
#[cfg(feature = "native")]
|
||||
mod cpp_round_trip {
|
||||
use serde_json::Value;
|
||||
use solidcraft_geom::brep as b;
|
||||
|
||||
use super::{close, from_arrays, native, rel, to_arrays, volume};
|
||||
use crate::flat::{self, EDGE_TOLERANCE, EXTENT, Flat, TOLERANCE, VERTEX_TOLERANCE};
|
||||
use crate::import::Arrays;
|
||||
use crate::sweeps::{Curve, DraftCorner, SweepFrame};
|
||||
use crate::{Brep, ffi};
|
||||
|
||||
const PICK_TOL: f64 = 1e-6;
|
||||
|
||||
/// How far any crossing, the C++ kernel's own included, may move a real of the arrays that
|
||||
/// went in.
|
||||
const FIRST_CROSSING: f64 = 1e-6;
|
||||
|
||||
fn cpp_box(o: [f64; 3], s: [f64; 3]) -> Brep {
|
||||
crate::init().unwrap();
|
||||
Brep::made(ffi::make_box(&o, &s).unwrap())
|
||||
}
|
||||
|
||||
fn cpp_cylinder(o: [f64; 3], r: f64, h: f64) -> Brep {
|
||||
crate::init().unwrap();
|
||||
Brep::made(ffi::make_cylinder(&o, r, h).unwrap())
|
||||
}
|
||||
|
||||
fn cut(a: &Brep, b: &Brep) -> Brep {
|
||||
Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap())
|
||||
}
|
||||
|
||||
/// `f` with the sweeps on the C++ kernel, whatever the route.
|
||||
fn on_cpp(f: impl FnOnce() -> crate::Result<Brep>) -> Brep {
|
||||
crate::init().unwrap();
|
||||
crate::sweeps::ON_CPP.with(|c| c.set(true));
|
||||
let r = f();
|
||||
crate::sweeps::ON_CPP.with(|c| c.set(false));
|
||||
r.unwrap()
|
||||
}
|
||||
|
||||
/// The record as JSON, every `tolerance` (the B-rep's, an edge's, a vertex's) gone.
|
||||
fn without_tolerances(rec: &b::Brep) -> Value {
|
||||
fn strip(v: &mut Value) {
|
||||
match v {
|
||||
Value::Object(m) => {
|
||||
m.remove("tolerance");
|
||||
m.values_mut().for_each(strip);
|
||||
}
|
||||
Value::Array(a) => a.iter_mut().for_each(strip),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let mut v = serde_json::to_value(rec).unwrap();
|
||||
strip(&mut v);
|
||||
v
|
||||
}
|
||||
|
||||
/// `want` and `got` agree: ints exact, reals within `tol`, tolerances and EXTENT excepted.
|
||||
fn same_arrays(at: &str, want: &Arrays, got: &Arrays, tol: f64) {
|
||||
assert_eq!(want.ints.keys().collect::<Vec<_>>(), got.ints.keys().collect::<Vec<_>>(), "{at}: int arrays");
|
||||
for (id, v) in &want.ints {
|
||||
assert_eq!(v, &got.ints[id], "{at}: int array {id}");
|
||||
}
|
||||
assert_eq!(want.reals.keys().collect::<Vec<_>>(), got.reals.keys().collect::<Vec<_>>(), "{at}: real arrays");
|
||||
for (id, v) in &want.reals {
|
||||
if [TOLERANCE, EXTENT, EDGE_TOLERANCE, VERTEX_TOLERANCE].contains(id) {
|
||||
assert_eq!(v.len(), got.reals[id].len(), "{at}: real array {id} length");
|
||||
continue;
|
||||
}
|
||||
let (x, y) = (serde_json::to_value(v).unwrap(), serde_json::to_value(&got.reals[id]).unwrap());
|
||||
close(&x, &y, tol, &format!("{at}: real array {id}"));
|
||||
}
|
||||
}
|
||||
|
||||
/// [`same_arrays`], and their records the same, valid and with tolerances excepted.
|
||||
fn same_records(at: &str, want: &Arrays, got: &Arrays, tol: f64) -> b::Brep {
|
||||
same_arrays(at, want, got, tol);
|
||||
let ((w, _), (g, _)) = (native(want).unwrap(), native(got).unwrap());
|
||||
w.validate().unwrap();
|
||||
g.validate().unwrap();
|
||||
close(&without_tolerances(&w), &without_tolerances(&g), tol, at);
|
||||
w
|
||||
}
|
||||
|
||||
/// The three crossings of `theirs`: the C++ kernel's own, solidcore's, and solidcore's arrays
|
||||
/// back through the C++ kernel.
|
||||
fn crossings(theirs: &Arrays) -> [Arrays; 3] {
|
||||
let own = Flat::from_arrays(theirs).unwrap().import().unwrap().cpp_arrays().unwrap();
|
||||
let ours = to_arrays(&from_arrays(theirs).unwrap()).unwrap();
|
||||
let back = Flat::from_arrays(&ours).unwrap().import().unwrap().cpp_arrays().unwrap();
|
||||
[own, ours, back]
|
||||
}
|
||||
|
||||
/// Arrays the record cannot say (wire and point shells): the crossings' arrays only.
|
||||
fn crosses_as_arrays(name: &str, theirs: &Arrays) {
|
||||
let [own, ours, back] = crossings(theirs);
|
||||
same_arrays(&format!("{name}, solidcore's arrays"), &own, &ours, 1e-12);
|
||||
same_arrays(&format!("{name}, back through C++"), &own, &back, 1e-12);
|
||||
}
|
||||
|
||||
/// `cpp` across: returns its record, for the case to say what it holds.
|
||||
fn crosses(name: &str, cpp: &Brep) -> b::Brep {
|
||||
let theirs = cpp.cpp_arrays().unwrap();
|
||||
let [own, ours, back] = crossings(&theirs);
|
||||
same_records(&format!("{name}, solidcore's arrays"), &own, &ours, 1e-12);
|
||||
same_records(&format!("{name}, back through C++"), &own, &back, 1e-12);
|
||||
same_records(&format!("{name}, the arrays that went in"), &theirs, &ours, FIRST_CROSSING)
|
||||
}
|
||||
|
||||
/// [`crosses`], and solidcore measures the C++ kernel's volume.
|
||||
fn crosses_with_volume(name: &str, cpp: &Brep) -> b::Brep {
|
||||
let rec = crosses(name, cpp);
|
||||
let body = from_arrays(&cpp.cpp_arrays().unwrap()).unwrap();
|
||||
let (v, want) = (volume(&body, 1e-8).unwrap(), ffi::volume(cpp.cpp().unwrap(), 1e-8).unwrap());
|
||||
assert!(rel(v, want) < 1e-7, "{name}: solidcore {v} vs C++ {want}");
|
||||
rec
|
||||
}
|
||||
|
||||
fn has_face(rec: &b::Brep, f: impl Fn(&b::Face) -> bool) -> bool {
|
||||
rec.faces.iter().any(f)
|
||||
}
|
||||
|
||||
/// A 20 mm box with three edges at one corner rounded: rolling-ball faces and a corner patch,
|
||||
/// on an operation's tolerances.
|
||||
#[test]
|
||||
fn a_filleted_box() {
|
||||
let a = cpp_box([0.0; 3], [20.0; 3]);
|
||||
let edges = [[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], [0.0, 0.0, 10.0]];
|
||||
let f = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::Fillet, a.cpp().unwrap(), &edges, PICK_TOL, 2.0).unwrap());
|
||||
let rec = crosses_with_volume("filleted box", &f);
|
||||
assert!(rec.faces.len() > 6, "{}", rec.faces.len());
|
||||
}
|
||||
|
||||
/// A plate with a round hole: inner loops, and a cylinder face looking at its axis.
|
||||
#[test]
|
||||
fn a_holed_plate() {
|
||||
let p = cut(&cpp_box([0.0; 3], [40.0, 30.0, 5.0]), &cpp_cylinder([20.0, 15.0, -1.0], 6.0, 7.0));
|
||||
let rec = crosses_with_volume("holed plate", &p);
|
||||
assert!(has_face(&rec, |f| f.loops.len() > 1), "no inner loop");
|
||||
}
|
||||
|
||||
/// A square swept along a cubic B-spline path: B-spline walls that are nothing analytic.
|
||||
#[test]
|
||||
fn a_swept_nurbs_face() {
|
||||
let c = [[-2.0, -2.0, 0.0], [2.0, -2.0, 0.0], [2.0, 2.0, 0.0], [-2.0, 2.0, 0.0]];
|
||||
let square: Vec<Curve> = (0..4).map(|i| Curve::Line { start: c[i], end: c[(i + 1) % 4] }).collect();
|
||||
let points = [[0.0, 0.0, 0.0, 1.0], [0.0, 10.0, 20.0, 1.0], [10.0, -10.0, 40.0, 1.0], [10.0, 0.0, 60.0, 1.0]];
|
||||
let path = [Curve::Nurbs { degree: 3, points: points.to_vec(), knots: vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0] }];
|
||||
let s = on_cpp(|| Brep::sweep(&square, &path, SweepFrame::Follow, true));
|
||||
let rec = crosses_with_volume("swept square", &s);
|
||||
assert!(has_face(&rec, |f| matches!(f.surface, b::Surface::Spline { .. } | b::Surface::RationalSpline { .. })), "no NURBS face");
|
||||
}
|
||||
|
||||
/// A cylinder sliced by a plane leaning 45 degrees: the cut's edge an ellipse.
|
||||
#[test]
|
||||
fn an_ellipse_edge() {
|
||||
let cyl = cpp_cylinder([0.0, 0.0, -30.0], 5.0, 60.0);
|
||||
let (s, c) = std::f64::consts::FRAC_PI_4.sin_cos();
|
||||
// About y through the origin; the box's underside is the plane z = 0 turned.
|
||||
let turn = [[c, 0.0, s, 0.0], [0.0, 1.0, 0.0, 0.0], [-s, 0.0, c, 0.0], [0.0, 0.0, 0.0, 1.0]];
|
||||
let tool = Brep::made(ffi::transform(cpp_box([-50.0, -50.0, 0.0], [100.0; 3]).cpp().unwrap(), &turn).unwrap());
|
||||
let rec = crosses_with_volume("leaning cut", &cut(&cyl, &tool));
|
||||
assert!(rec.edges.iter().any(|e| matches!(e.curve, b::Curve::Ellipse { .. })), "no ellipse edge");
|
||||
}
|
||||
|
||||
/// A 20 mm box with a 10 mm void sealed inside: two shells in the solid's region.
|
||||
#[test]
|
||||
fn a_sealed_void() {
|
||||
let v = cut(&cpp_box([-10.0; 3], [20.0; 3]), &cpp_box([-5.0; 3], [10.0; 3]));
|
||||
let rec = crosses_with_volume("sealed void", &v);
|
||||
assert!(rec.regions.iter().any(|r| r.shells.len() == 2), "{:?}", rec.regions);
|
||||
assert!(rec.regions.iter().any(|r| r.void), "{:?}", rec.regions);
|
||||
}
|
||||
|
||||
/// One planar face, and an open extrusion: a sheet's shells, no solid.
|
||||
#[test]
|
||||
fn sheets() {
|
||||
let c = [[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 6.0, 0.0], [0.0, 6.0, 0.0]];
|
||||
let rect: Vec<Curve> = (0..4).map(|i| Curve::Line { start: c[i], end: c[(i + 1) % 4] }).collect();
|
||||
let rec = crosses("planar sheet", &on_cpp(|| Brep::planar_faces(&rect)));
|
||||
assert_eq!(rec.faces.len(), 1);
|
||||
let open = on_cpp(|| Brep::extrude(&rect, [0.0, 0.0, 1.0], 5.0, 0.0, DraftCorner::default(), false));
|
||||
let rec = crosses("open extrusion", &open);
|
||||
assert_eq!(rec.faces.len(), 4);
|
||||
}
|
||||
|
||||
/// A C++ box's arrays with one wire edge of each kind (a line, a whole circle, a half ellipse,
|
||||
/// a cubic B-spline) and one point, each a shell of its own in the infinite region. The C API
|
||||
/// gives no body without a face (`take`), so these lie beside a box.
|
||||
fn box_with_wires_and_a_point() -> Arrays {
|
||||
let tau = std::f64::consts::TAU;
|
||||
let mut a = cpp_box([20.0; 3], [5.0; 3]).cpp_arrays().unwrap();
|
||||
let first_new = a.ints[&flat::VERTEX_POINT_TYPE].len() as i64;
|
||||
a.ints.get_mut(&flat::REGION_SHELL_COUNT).unwrap()[0] += 5;
|
||||
for (id, v) in
|
||||
[(flat::SHELL_FACEUSE_COUNT, [0, 0, 0, 0, 0]), (flat::SHELL_WIRE_EDGE_COUNT, [1, 1, 1, 1, 0]), (flat::SHELL_POINT_TYPE, [0, 0, 0, 0, 1])]
|
||||
{
|
||||
a.ints.get_mut(&id).unwrap().splice(1..1, v);
|
||||
}
|
||||
a.ints.insert(
|
||||
flat::WIRE_EDGE_CURVE_TYPE,
|
||||
[flat::CURVE_LINE, flat::CURVE_CIRCLE, flat::CURVE_ELLIPSE, flat::CURVE_NURBS].map(i64::from).to_vec(),
|
||||
);
|
||||
a.ints.insert(flat::WIRE_EDGE_VERTICES, [0, 1, 2, 2, 3, 4, 5, 6].map(|v| first_new + v).to_vec());
|
||||
a.ints.insert(flat::WIRE_EDGE_NURBS_VERTEX_COUNT, vec![4]);
|
||||
a.ints.insert(flat::WIRE_EDGE_NURBS_ORDER, vec![4]);
|
||||
let points = [[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [4.0, 0.0, 5.0], [3.0, 0.0, -5.0], [-3.0, 0.0, -5.0], [0.0, 9.0, 0.0], [9.0, 9.0, 3.0]];
|
||||
a.ints.get_mut(&flat::VERTEX_POINT_TYPE).unwrap().extend([1; 7]);
|
||||
a.reals.get_mut(&flat::VERTEX_POSITION).unwrap().extend(points.concat());
|
||||
let base = a.reals[&TOLERANCE][0];
|
||||
a.reals.get_mut(&VERTEX_TOLERANCE).unwrap().extend([base; 7]);
|
||||
let reals: [(i32, Vec<f64>); 17] = [
|
||||
(flat::SHELL_POINT_POSITION, vec![1.0, 2.0, 3.0]),
|
||||
(flat::WIRE_EDGE_RANGE, vec![0.0, 10.0, 0.0, tau, 0.0, std::f64::consts::PI, 0.0, 1.0]),
|
||||
(flat::WIRE_EDGE_LINE_ORIGIN, vec![0.0; 3]),
|
||||
(flat::WIRE_EDGE_LINE_DIRECTION, vec![1.0, 0.0, 0.0]),
|
||||
(flat::WIRE_EDGE_CIRCLE_CENTER, vec![0.0, 0.0, 5.0]),
|
||||
(flat::WIRE_EDGE_CIRCLE_AXIS, vec![0.0, 0.0, 1.0]),
|
||||
(flat::WIRE_EDGE_CIRCLE_REF_DIRECTION, vec![1.0, 0.0, 0.0]),
|
||||
(flat::WIRE_EDGE_CIRCLE_RADIUS, vec![4.0]),
|
||||
(flat::WIRE_EDGE_ELLIPSE_CENTER, vec![0.0, 0.0, -5.0]),
|
||||
(flat::WIRE_EDGE_ELLIPSE_AXIS, vec![0.0, 0.0, 1.0]),
|
||||
(flat::WIRE_EDGE_ELLIPSE_REF_DIRECTION, vec![1.0, 0.0, 0.0]),
|
||||
(flat::WIRE_EDGE_ELLIPSE_X_RADIUS, vec![3.0]),
|
||||
(flat::WIRE_EDGE_ELLIPSE_Y_RADIUS, vec![2.0]),
|
||||
(flat::WIRE_EDGE_NURBS_CVS, [points[5], [3.0, 12.0, 0.0], [6.0, 6.0, 2.0], points[6]].concat()),
|
||||
(flat::WIRE_EDGE_NURBS_KNOTS, vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0]),
|
||||
(flat::WIRE_EDGE_NURBS_WEIGHTS, Vec::new()),
|
||||
(EXTENT, vec![-3.0, 0.0, -5.0, 25.0, 25.0, 25.0]),
|
||||
];
|
||||
a.reals.extend(reals);
|
||||
a
|
||||
}
|
||||
|
||||
/// Wire edges no face uses and a point shell. The record says no such shell from SMLib, so
|
||||
/// arrays only.
|
||||
#[test]
|
||||
fn wire_edges_and_a_point_shell() {
|
||||
let theirs = Flat::from_arrays(&box_with_wires_and_a_point()).unwrap().import().unwrap().cpp_arrays().unwrap();
|
||||
assert_eq!(theirs.ints[&flat::WIRE_EDGE_CURVE_TYPE].len(), 4);
|
||||
assert_eq!(theirs.reals[&flat::SHELL_POINT_POSITION], [1.0, 2.0, 3.0]);
|
||||
crosses_as_arrays("wire edges and a point", &theirs);
|
||||
}
|
||||
|
||||
/// Two boxes apart, united: two lumps.
|
||||
#[test]
|
||||
fn a_multi_lump_body() {
|
||||
let (a, b) = (cpp_box([0.0; 3], [10.0; 3]), cpp_box([30.0, 0.0, 0.0], [5.0; 3]));
|
||||
let u = Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), ffi::ops::BOOLEAN_UNION).unwrap());
|
||||
let rec = crosses_with_volume("two lumps", &u);
|
||||
assert_eq!(ffi::ops::solid_count(u.cpp().unwrap()).unwrap(), 2);
|
||||
assert_eq!(rec.faces.len(), 12);
|
||||
}
|
||||
|
||||
/// A rounded box shelled: faces on the offsets of its rounds, on the operation's tolerances.
|
||||
#[test]
|
||||
fn a_shelled_rounded_box() {
|
||||
let a = cpp_box([0.0; 3], [20.0; 3]);
|
||||
let r = ffi::ops::pick_op(ffi::ops::Pick::Fillet, a.cpp().unwrap(), &[[10.0, 0.0, 0.0]], PICK_TOL, 2.0).unwrap();
|
||||
let s = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::Shell, &r, &[[10.0, 10.0, 20.0]], PICK_TOL, -1.0).unwrap());
|
||||
crosses_with_volume("shelled rounded box", &s);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user