mirror of
https://github.com/bherbruck/solidcraft.git
synced 2026-11-16 21:51:01 +00:00
dc38349cbf
* 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>
46 lines
2.2 KiB
Rust
46 lines
2.2 KiB
Rust
use super::*;
|
|
|
|
/// A wedge 40 x 20, 15 high, its top front edge along x from 0 to 40.
|
|
fn wedge_body() -> Body {
|
|
use solidcore_record::{Loop2, Plane, Region2, Vec2};
|
|
let outer = Loop2::polygon(&[Vec2::new(0., 0.), Vec2::new(40., 0.), Vec2::new(0., 20.)]);
|
|
crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0., 15.).unwrap().pop().unwrap()
|
|
}
|
|
|
|
fn wedge() -> Body {
|
|
let body = wedge_body();
|
|
let at = Vec3::new(20., 0., 15.);
|
|
// The room's taper, closing to zero at the wedge's tip, given as a spline fillet: R16 itself
|
|
// is built over the wedge's cliffs (the blend-overflow decision), so a tapered fillet no
|
|
// longer tapers it.
|
|
let t = taper(&body, at, 16.).unwrap();
|
|
fillet_variable_spline(&body, at, t.start, &t.spline).unwrap()
|
|
}
|
|
|
|
/// The wedge's variable round takes off the union of its balls (smlib#78, solidcore#2262):
|
|
/// `removed_by_balls` along the 40 mm edge, about 754.28, on whichever kernel the test runs.
|
|
#[test]
|
|
fn the_wedge_round_keeps_its_volume() {
|
|
let v = crate::measure(&wedge()).unwrap().volume;
|
|
let law = taper(&wedge_body(), Vec3::new(20., 0., 15.), 16.).unwrap().spline;
|
|
let want = 6000.0 - super::tests::removed_by_balls(40.0, &|u| law.eval(u), &|_, _| f64::INFINITY, &[]);
|
|
assert!(((v - want) / want).abs() < 1e-4, "{v} vs {want}");
|
|
}
|
|
|
|
/// The display mesh of a fillet tapering to zero at a wedge's tip converges to the B-rep: each
|
|
/// mesh lies within its chord tolerance of the faces, so its volume is within the body's area
|
|
/// times that tolerance of the exact one (SMLib's, integrated on the surfaces, to 1e-8). Only
|
|
/// the mesher is under test here; the taper's own law is `taper_follows_the_room_along_the_edge`'s.
|
|
#[test]
|
|
fn collapsed_taper_mesh_stays_accurate_as_tolerance_decreases() {
|
|
let body = wedge();
|
|
let exact = crate::measure(&body).unwrap();
|
|
for tol in [0.002, 0.001, 0.0005, 0.0002] {
|
|
let mesh = body.mesh(&crate::MeshTolerance::chord(tol)).unwrap();
|
|
assert!(mesh.positions.iter().all(|p| p.x.is_finite() && p.y.is_finite() && p.z.is_finite()));
|
|
let got = mesh.measure().volume;
|
|
let bound = exact.area * tol;
|
|
assert!((got - exact.volume).abs() <= bound, "tol={tol}: mesh {got} vs exact {} (within {bound})", exact.volume);
|
|
}
|
|
}
|