Files
solidcraft/crates/sketch/src/offset.rs
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

354 lines
19 KiB
Rust

//! Associative offsets keep their output entity ids while their source curves move.
use crate::{ConstraintKind, CurveKind, Shape, Sketch, SketchError, intersections};
use serde::{Deserialize, Serialize};
use solidcore_record::Vec2;
use solidcraft_geom::prelude::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct OffsetChain {
pub sources: Vec<(String, bool)>,
pub outputs: Vec<String>,
pub distance: f64,
pub closed: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub topology: Option<crate::offset_topology::OffsetTopology>,
}
impl OffsetChain {
/// Includes reserved corner roles that may temporarily disappear from the boundary.
pub fn owns_output(&self, output: &str) -> bool {
self.outputs.iter().any(|id| id == output) || self.topology.as_ref().is_some_and(|t| t.roles.iter().any(|r| r.output == output))
}
}
impl Sketch {
/// The signed distance of the association that owns an output (including retired roles).
pub fn offset_distance(&self, output: &str) -> Option<f64> {
self.offsets
.iter()
.find(|o| o.owns_output(output))
.map(|o| o.distance)
.or_else(|| self.freeform_offsets.iter().find(|o| o.output == output).map(|o| o.distance))
}
/// A Parallel between an offset line and the source it follows (#4464). The association
/// keeps them parallel already, and the output's points are held during a solve, so solving
/// it would only pin the source to the output's current direction. It drives again once
/// Break releases the output.
pub(crate) fn follows_its_source(&self, kind: &ConstraintKind) -> bool {
let ConstraintKind::Parallel { a, b } = *kind else {
return false;
};
let (Some(a), Some(b)) = (self.curves.get(a).map(|c| c.id.as_str()), self.curves.get(b).map(|c| c.id.as_str())) else {
return false;
};
self.offsets.iter().any(|o| {
o.sources.iter().enumerate().any(|(i, (source, _))| {
let output = match &o.topology {
Some(t) => t.roles.get(i).map(|r| r.output.as_str()),
None => o.outputs.get(i).map(String::as_str),
};
output.is_some_and(|output| (source == a && output == b) || (source == b && output == a))
})
})
}
/// An arc an offset made round its source's own centre (#6569). Its ends are held while the
/// sketch solves, so its own condition, both ends as far from the centre, only tied that
/// centre (and the source with it) to the middle of the held ends: a slot offset by 1 mm
/// could no longer be moved by the dimension that places it. The source's own arc keeps the
/// centre, and the offset is rebuilt from the source after the solve.
pub(crate) fn offset_arc_follows_source(&self, curve: usize) -> bool {
if self.offsets.is_empty() {
return false;
}
let Some(arc) = self.curves.get(curve) else { return false };
let CurveKind::Arc { c: centre, .. } = arc.kind else { return false };
let output = |id: &str| self.offsets.iter().any(|o| o.owns_output(id));
output(&arc.id) && self.curves.iter().enumerate().any(|(k, other)| k != curve && other.kind.uses(centre) && !output(&other.id))
}
/// A circle an offset made (#9264). The offset sets its radius from the source's after the
/// solve, so the solve holds that radius instead of counting it as a free unknown.
pub(crate) fn offset_circle_follows_source(&self, curve: usize) -> bool {
let Some(circle) = self.curves.get(curve) else { return false };
matches!(circle.kind, CurveKind::Circle { .. }) && self.offsets.iter().any(|o| o.owns_output(&circle.id))
}
/// Endpoints of a normal-distance annotation, evaluated from its source curve.
pub fn offset_dimension_points(&self, output: &str) -> Option<(Vec2, Vec2)> {
let (source, forward, distance) = self
.offsets
.iter()
.find(|o| o.owns_output(output))
.and_then(|o| o.sources.first().map(|(id, forward)| (id.as_str(), *forward, o.distance)))
.or_else(|| self.freeform_offsets.iter().find(|o| o.output == output).map(|o| (o.source.as_str(), o.forward, o.distance)))?;
let index = self.curve_index(source)?;
let segment = self.exact_segs(index).unwrap_or_else(|| self.segs(index)).into_iter().next()?;
let p = segment.point_at(0.5);
let tangent = (segment.point_at(0.5001) - segment.point_at(0.4999)).normalized()?;
Some((p, p + tangent.perp() * if forward { distance } else { -distance }))
}
/// Removing an output removes its relationship. A partial analytic chain
/// deletion releases the surviving outputs, while retained dependents keep
/// their source references so the command's refresh refuses broken sources.
pub(crate) fn prune_offsets_for_removed_curves(&mut self, which: &[usize]) {
let removed = which.iter().filter_map(|i| self.curves.get(*i).map(|curve| curve.id.clone())).collect::<std::collections::BTreeSet<_>>();
if removed.is_empty() {
return;
}
let released = self
.offsets
.iter()
.filter(|offset| offset.outputs.iter().any(|id| removed.contains(id)))
.flat_map(|offset| offset.outputs.iter().cloned().chain(offset.topology.iter().flat_map(|t| t.roles.iter().map(|r| r.output.clone()))))
.chain(self.freeform_offsets.iter().filter(|offset| removed.contains(&offset.output)).map(|offset| offset.output.clone()))
.collect::<std::collections::BTreeSet<_>>();
self.offsets.retain(|offset| !offset.outputs.iter().any(|id| removed.contains(id)));
self.freeform_offsets.retain(|offset| !removed.contains(&offset.output));
self.constraints.retain(|c| !matches!(&c.kind, ConstraintKind::OffsetDistance { output, .. } if released.contains(output)));
let points = self
.curves
.iter()
.filter(|curve| released.contains(&curve.id))
.flat_map(|curve| curve.kind.point_ids())
.collect::<std::collections::BTreeSet<_>>();
for index in points {
if index != 0
&& self.curves.iter().all(|curve| !curve.kind.uses(index) || released.contains(&curve.id))
&& let Some(point) = self.points.get_mut(index)
{
point.fixed = false;
}
}
}
/// Retry a failed solve whose source edit was blocked by attachments to an offset's old
/// fixed points. Seed the sources without those attachments, rebuild the offsets, then
/// solve every attachment with the sources held. Nothing is adopted unless the complete
/// sketch solves with its original constraints and orientation.
pub fn solve_after_offset_edit(
&mut self,
old: &crate::DrivingValues,
reference: Option<&[Vec2]>,
analysis: crate::Analysis,
) -> Option<crate::SolveReport> {
let source =
|id: &str| self.offsets.iter().any(|o| o.sources.iter().any(|(s, _)| s == id)) || self.freeform_offsets.iter().any(|o| o.source == id);
let output = |id: &str| self.offsets.iter().any(|o| o.owns_output(id)) || self.freeform_offsets.iter().any(|o| o.output == id);
let source_points: std::collections::BTreeSet<usize> =
self.curves.iter().filter(|c| source(&c.id)).flat_map(|c| c.kind.point_ids()).collect();
let outputs: std::collections::BTreeSet<usize> = self.curves.iter().enumerate().filter(|(_, c)| output(&c.id)).map(|(i, _)| i).collect();
let output_points: std::collections::BTreeSet<usize> =
outputs.iter().filter_map(|i| self.curves.get(*i)).flat_map(|c| c.kind.point_ids()).filter(|p| !source_points.contains(p)).collect();
let mut candidate = self.clone();
candidate.constraints.retain(|c| {
!c.kind.indices().1.iter().any(|i| outputs.contains(i)) && !self.constraint_points(&c.kind).iter().any(|p| output_points.contains(p))
});
if candidate.constraints.len() == self.constraints.len() {
return None;
}
let before: Vec<Vec2> = reference.map_or_else(|| self.points.iter().map(|p| p.pos).collect(), <[Vec2]>::to_vec);
if !crate::solve_after_edit_with_analysis(&mut candidate, old, Some(&before), crate::Analysis::StatusOnly).keeps_orientation() {
return None;
}
candidate.constraints.clone_from(&self.constraints);
candidate.refresh_offsets().ok()?;
// Keep the freshly rebuilt offset exact while its attached geometry catches up.
// Refresh may retire output curves or refine a dependent spline: resolve holds again.
let hold = crate::Hold {
points: candidate.curves.iter().filter(|c| source(&c.id)).flat_map(|c| c.kind.point_ids()).collect(),
radii: candidate.curves.iter().enumerate().filter(|(_, c)| source(&c.id) || output(&c.id)).map(|(i, _)| i).collect(),
};
if !crate::solve_with(&mut candidate, &hold, Some(&before), crate::Analysis::StatusOnly, None).keeps_orientation() {
// A cap tangent to an arc can land on the other tangency branch after a large
// jump. Walk the held source and output points from their stored positions.
// Their own dimensions are restored after the walk, not imposed at each step.
let mut walking = candidate.clone();
walking.constraints.retain(|c| candidate.constraint_points(&c.kind).iter().any(|p| !hold.points.contains(p)));
for i in &hold.points {
if let Some(p) = walking.points.get_mut(*i) {
p.fixed = true;
}
}
for i in &hold.radii {
if let Some(c) = walking.curves.get_mut(*i) {
c.fixed = true;
}
}
let mut from = walking.clone();
for (p, pos) in from.points.iter_mut().zip(&before) {
p.pos = *pos;
}
crate::solve_after_link_move(&mut walking, &from, old, crate::Analysis::StatusOnly)?;
for (p, q) in candidate.points.iter_mut().zip(&walking.points) {
p.pos = q.pos;
}
for (c, d) in candidate.curves.iter_mut().zip(&walking.curves) {
c.kind.clone_from(&d.kind);
}
}
// Publish ordinary freedom/redundancy diagnostics, without the temporary holds.
let report = crate::solve_after_edit_with_analysis(&mut candidate, old, Some(&before), analysis);
if !report.keeps_orientation() {
return None;
}
*self = candidate;
Some(report)
}
pub fn refresh_offsets(&mut self) -> Result<(), SketchError> {
if self.offsets.is_empty() && self.freeform_offsets.is_empty() {
return Ok(());
}
let mut candidate = self.clone();
let mut driven = std::collections::BTreeSet::new();
for constraint in &self.constraints {
if let ConstraintKind::OffsetDistance { output, value, reverse } = &constraint.kind {
self.validate(&constraint.kind)?;
let analytic = candidate.offsets.iter().position(|o| o.owns_output(output));
let freeform = candidate.freeform_offsets.iter().position(|o| o.output == *output);
let identity = analytic
.or_else(|| freeform.map(|i| candidate.offsets.len() + i))
.ok_or_else(|| SketchError::Invalid("missing offset dimension association".into()))?;
if constraint.driven || !driven.insert(identity) {
return Err(SketchError::Invalid("an offset must have exactly one driving distance".into()));
}
let distance = if *reverse { -*value } else { *value };
if let Some(offset) = analytic.and_then(|i| candidate.offsets.get_mut(i)) {
offset.distance = distance;
}
if let Some(offset) = freeform.and_then(|i| candidate.freeform_offsets.get_mut(i)) {
offset.distance = distance;
}
}
}
candidate.refresh_analytic_offsets()?;
candidate.refresh_freeform_offsets()?;
*self = candidate;
Ok(())
}
fn refresh_analytic_offsets(&mut self) -> Result<(), SketchError> {
for index in 0..self.offsets.len() {
if self.refresh_convex_offset(index)? {
continue;
}
let offset = self.offsets.get(index).cloned().ok_or_else(|| SketchError::Invalid("missing offset chain".into()))?;
if offset.sources.len() != offset.outputs.len() || offset.sources.len() > 10_000 || !offset.distance.is_finite() {
return Err(SketchError::Invalid("damaged offset chain".into()));
}
let bad = || SketchError::Invalid("an offset source vanished or changed shape".into());
let mut pieces = Vec::new();
for (id, forward) in &offset.sources {
let i = self.curve_index(id).ok_or_else(bad)?;
let kind = &self.curves.get(i).ok_or_else(bad)?.kind;
let piece = match *kind {
CurveKind::Line { a, b } => {
let (a, b) = (self.point(a).ok_or_else(bad)?, self.point(b).ok_or_else(bad)?);
let (a, b) = if *forward { (a, b) } else { (b, a) };
let n = (b - a).normalized().ok_or_else(bad)?.perp() * offset.distance;
(Shape::Line { a: a + n, b: b + n }, a + n, b + n, None)
}
CurveKind::Arc { c, a, b } => {
let (c, a, b) = (self.point(c).ok_or_else(bad)?, self.point(a).ok_or_else(bad)?, self.point(b).ok_or_else(bad)?);
let r = c.dist(a) - if *forward { offset.distance } else { -offset.distance };
if r <= 1e-9 {
return Err(SketchError::Invalid("the offset collapses an arc".into()));
}
let a = c + (a - c).normalized().ok_or_else(bad)? * r;
let b = c + (b - c).normalized().ok_or_else(bad)? * r;
let (a, b) = if *forward { (a, b) } else { (b, a) };
(Shape::Round { c, r, start: 0.0, sweep: std::f64::consts::TAU }, a, b, Some(*forward))
}
CurveKind::Circle { c, r } => {
let c = self.point(c).ok_or_else(bad)?;
let r = r - offset.distance;
if r <= 1e-9 {
return Err(SketchError::Invalid("the offset collapses a circle".into()));
}
let out = offset.outputs.first().and_then(|id| self.curve_index(id)).ok_or_else(bad)?;
if let Some(crate::Curve { kind: CurveKind::Circle { r: target, .. }, .. }) = self.curves.get_mut(out) {
*target = r;
} else {
return Err(bad());
}
let _ = c;
continue;
}
_ => return Err(bad()),
};
pieces.push(piece);
}
if pieces.is_empty() {
continue;
}
// Which way a piece runs at `p`: a line along itself, an arc anticlockwise round its
// centre when it follows its source forward.
let along = |piece: &(Shape, Vec2, Vec2, Option<bool>), p: Vec2| match (&piece.0, piece.3) {
(Shape::Line { a, b }, _) => *b - *a,
(Shape::Round { c, .. }, Some(true)) => (p - *c).perp(),
(Shape::Round { c, .. }, Some(false)) => (*c - p).perp(),
_ => Vec2::new(0.0, 0.0),
};
let joint = |i: usize, j: usize| -> Result<Vec2, SketchError> {
let (x, y) = (pieces.get(i).ok_or_else(bad)?, pieces.get(j).ok_or_else(bad)?);
if x.2.dist(y.1) < 1e-6 {
return Ok(x.2);
}
let guess = (x.2 + y.1) * 0.5;
let mut found = intersections(&x.0, &y.0);
found.sort_by(|a, b| a.dist(guess).total_cmp(&b.dist(guess)));
// Where the sources touch, as two tangent arcs do at a dog bone's notch (#10984),
// both crossings are as far from the corner and rounding chose one. The pieces
// overlap there: they meet where both are cut short, not where both run on and
// cross into a loop.
let cut_short = |p: Vec2| (p - x.2).dot(along(x, x.2)) < 0.0 && (p - y.1).dot(along(y, y.1)) > 0.0;
match found.as_slice() {
[p, q, ..] if (q.dist(guess) - p.dist(guess)).abs() <= 1e-9 * (1.0 + p.dist(*q)) && !cut_short(*p) && cut_short(*q) => Ok(*q),
[p, ..] => Ok(*p),
[] => Err(SketchError::Invalid("the offset curves no longer meet".into())),
}
};
let n = pieces.len();
let mut joints = vec![if offset.closed { joint(n - 1, 0)? } else { pieces.first().ok_or_else(bad)?.1 }];
for i in 0..n.saturating_sub(1) {
joints.push(joint(i, i + 1)?);
}
if !offset.closed {
joints.push(pieces.last().ok_or_else(bad)?.2);
}
for (i, id) in offset.outputs.iter().enumerate() {
let a = *joints.get(i).ok_or_else(bad)?;
let b = *joints.get(if offset.closed { (i + 1) % n } else { i + 1 }).ok_or_else(bad)?;
let shape = &pieces.get(i).ok_or_else(bad)?.0;
if let Shape::Line { a: p, b: q } = shape
&& (b - a).dot(*q - *p) <= 1e-9
{
return Err(SketchError::Invalid("the offset curves would cross".into()));
}
let ci = self.curve_index(id).ok_or_else(bad)?;
let kind = self.curves.get(ci).ok_or_else(bad)?.kind.clone();
let (pa, pb) = match kind {
CurveKind::Line { a, b } => (a, b),
CurveKind::Arc { a, b, .. } => {
if offset.sources.get(i).is_some_and(|x| x.1) {
(a, b)
} else {
(b, a)
}
}
_ => return Err(bad()),
};
for (pi, pos) in [(pa, a), (pb, b)] {
if let Some(p) = self.points.get_mut(pi) {
p.pos = pos;
p.fixed = true;
}
}
}
}
Ok(())
}
}