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>
66 lines
3.1 KiB
Rust
66 lines
3.1 KiB
Rust
//! Clean-up after operations: faces on one surface that meet along an edge become one face, and
|
|
//! two edges on one curve meeting at a vertex nothing else uses become one edge. SMLib does it
|
|
//! (`Brep::merge_faces`, its `SmBrep::RemoveTopologicalEdgesAndVertices`; its booleans do the
|
|
//! same at their end), keeping apart the faces split on purpose along the body's split lines.
|
|
|
|
use solidcore_record::Vec3;
|
|
use solidcore_record::brep::Brep;
|
|
use solidcraft_geom::brep::eval::CurveEval;
|
|
use solidcraft_geom::prelude::*;
|
|
|
|
use crate::body::Body;
|
|
use crate::{KernelError, Result};
|
|
|
|
pub(crate) fn find(p: &mut [usize], mut i: usize) -> usize {
|
|
while let Some(&q) = p.get(i) {
|
|
if q == i {
|
|
break;
|
|
}
|
|
i = q;
|
|
}
|
|
i
|
|
}
|
|
|
|
/// Do the points lie along one of the lines faces were split along on purpose (polylines;
|
|
/// chords of a curved line sag by under a tenth of their length)?
|
|
pub(crate) fn on_split_line(pts: &[Vec3], keep: &[Vec<Vec3>]) -> bool {
|
|
!pts.is_empty()
|
|
&& keep.iter().any(|line| {
|
|
let seg = line.windows(2).filter_map(|w| Some(w.first()?.dist(*w.get(1)?))).fold(0.0, f64::max);
|
|
let tol = 1e-6 * (1.0 + seg) + if line.len() > 2 { seg * 0.1 } else { 0.0 };
|
|
pts.iter().all(|q| line.windows(2).any(|w| w.first().zip(w.get(1)).is_some_and(|(a, b)| q.dist_to_segment(*a, *b) <= tol)))
|
|
})
|
|
}
|
|
|
|
/// Points along edge `e` of the record `b`: its ends and three inside, evenly in its parameter
|
|
/// (the middle one at the middle of its interval).
|
|
pub(crate) fn edge_points(b: &Brep, e: u32) -> Vec<Vec3> {
|
|
let Some(edge) = b.edges.get(e as usize) else { return Vec::new() };
|
|
let Ok(c) = CurveEval::new(edge.parameters()) else { return Vec::new() };
|
|
let [t0, t1] = edge.interval;
|
|
(0..=4).filter_map(|k| c.point(t0 + (t1 - t0) * k as f64 / 4.0)).collect()
|
|
}
|
|
|
|
/// `body` with its faces on one surface merged and its edges on one curve joined, except along
|
|
/// the lines in `keep` (its split lines, as Split Face made them): each face and edge of the
|
|
/// result comes from those of `body` as SMLib's history says (a merged face from every face
|
|
/// merged into it), over `[body]`.
|
|
pub(crate) fn heal(body: &Body, keep: &[Vec<Vec3>]) -> Result<Body> {
|
|
let _span = solidcraft_profile::span("kernel", "heal");
|
|
let record = crate::native::brep_record(body)?;
|
|
// Each edge along a split line, by the point halfway along it.
|
|
let mut kept: Vec<[f64; 3]> = Vec::new();
|
|
if !keep.is_empty() {
|
|
for e in 0..record.edges.len() {
|
|
let pts = edge_points(&record, e as u32);
|
|
if on_split_line(&pts, keep) {
|
|
let mid = pts.get(2).ok_or_else(|| KernelError::Failed(format!("healing: edge {e} has no middle point")))?;
|
|
kept.push([mid.x, mid.y, mid.z]);
|
|
}
|
|
}
|
|
}
|
|
let tolerance = record.tolerance * 10.0;
|
|
let (healed, history) = crate::offset_backend::run("healing", body, None, |b| b.merge_faces(&kept, tolerance))?;
|
|
Ok(healed.with_checked_history(history, &crate::record::counts(&[body])).with_split_lines(body.splits.clone()))
|
|
}
|