Files
makeCAD/crates/kernel/src/intersection.rs
T
jyviko dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* 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>
2026-11-03 09:04:26 -05:00

68 lines
3.3 KiB
Rust

//! Where two bodies meet, each whole or one face of it: the edges SMLib's imprint of the first by
//! the second makes (`capi/include/smlib.h`, "Imprint": each face the tool meets is cut along the
//! intersection). SMLib intersects the faces' surfaces and trims each curve to both faces, so an
//! edge it makes is exactly where they meet: its record curve (a B-spline SMLib fitted within its
//! tolerance, or the line, circle or ellipse it is) on its interval. Which edges are new comes from
//! the imprint's own history: an edge no edge of either operand became.
use solidcore_record::Vec3;
use solidcore_record::brep::Curve;
use crate::body::{Body, MeshTolerance};
use crate::{KernelError, Result};
/// One edge where two bodies meet.
#[derive(Clone, Debug, PartialEq)]
pub struct MeetingEdge {
/// The edge's record curve, exactly as SMLib made it.
pub curve: Curve,
/// Its interval on `curve`.
pub interval: [f64; 2],
/// Its points at the chord tolerance asked for, from its start to its end.
pub points: Vec<Vec3>,
}
fn failed(what: &str, e: impl crate::Cause) -> KernelError {
KernelError::smlib(format!("SMLib intersection curve: {what}"), e)
}
/// `body` itself, or its faces `faces` (in its face order) alone as a surface body.
fn part(body: &Body, faces: Option<&[usize]>) -> Result<Body> {
let Some(faces) = faces else { return Ok(body.clone()) };
let count = body.record().faces.len();
if let Some(f) = faces.iter().find(|f| **f >= count) {
return Err(KernelError::Invalid(format!("the body has no face {f}")));
}
if faces.is_empty() {
return Err(KernelError::Invalid("no face given".into()));
}
let taken: Vec<(usize, bool)> = faces.iter().map(|f| (*f, false)).collect();
crate::surfaces::taken(body, body.record(), &taken)
}
/// Where `a` (or its faces `a_face`) meets `b` (or its faces `b_face`): every edge SMLib's imprint
/// of the one by the other makes, its points at `chord` mm. Empty where they do not meet.
pub fn meeting_edges(a: &Body, a_face: Option<&[usize]>, b: &Body, b_face: Option<&[usize]>, chord: f64) -> Result<Vec<MeetingEdge>> {
let (a, b) = (part(a, a_face)?, part(b, b_face)?);
let ta = a.smlib()?.tagged(0).map_err(|e| failed("tag", e))?;
let tb = b.smlib()?.tagged(1).map_err(|e| failed("tag", e))?;
let Some(cut) = ta.imprint(&tb).map_err(|e| failed("imprint", e))? else { return Ok(Vec::new()) };
let history = cut.history().map_err(|e| failed("history", e))?;
let (body, order) = crate::native::body_from_smlib_ordered(&cut)?;
let order = order.ok_or_else(|| failed("history", "the imprint's edges cannot be numbered"))?;
let mesh = body.mesh(&MeshTolerance::chord(chord))?;
let record = body.record();
let mut out = Vec::new();
for (i, edge) in history.edges.iter().enumerate() {
if !edge.origins.is_empty() {
continue;
}
let at = if order.edges.is_empty() { Some(i) } else { order.edges.get(i).copied() };
let (Some(e), Some(points)) = (at.and_then(|k| record.edges.get(k)), at.and_then(|k| mesh.edges.get(k))) else {
return Err(failed("history", format!("edge {i} is not in the imprinted body")));
};
out.push(MeetingEdge { curve: e.parameters().clone(), interval: e.interval, points: points.clone() });
}
Ok(out)
}