Files
makeCAD/crates/engine/src/cmd/motion_trace.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

439 lines
19 KiB
Rust

//! Associative trace definitions and dependency checks. Sampling uses the existing motion
//! driver on a scratch session; only a changed generated wire is handed to the evaluator.
use solidcraft_geom::prelude::*;
use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
use serde_json::{Value, json};
use solidcore_record::Vec3;
use solidcraft_doc::joints::{self, JointOrigin, Snap};
use solidcraft_doc::motion::{MotionTrace, TraceMotion};
use solidcraft_doc::{IDENTITY, apply_point};
use crate::params::{bad, bool_};
use crate::{Result, Session};
const CMD: &str = "motion.trace.edit";
#[derive(Clone, Debug, Default)]
pub(crate) struct Cache {
entries: Arc<BTreeMap<u64, CacheEntry>>,
history: Arc<BTreeMap<u64, Vec<(Value, Vec<Vec3>)>>>,
#[cfg(test)]
pub(crate) recomputations: usize,
}
#[derive(Clone, Debug)]
struct CacheEntry {
inputs: std::result::Result<Value, String>,
error: Option<String>,
}
fn motion(s: &Session, p: &Value, cmd: &str) -> Result<TraceMotion> {
let _ = super::motion_plan(s, p, cmd)?;
if p.get("study").is_some() {
let study = s.doc.assembly.studies.get(super::study_index(s, p, cmd)?).ok_or_else(|| bad(cmd, "study is missing"))?;
Ok(TraceMotion::Study { study: study.id })
} else {
Ok(TraceMotion::Joint {
joint: super::joint_id(s, p.get("joint"), cmd)?,
index: p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize,
from: p.get("from").cloned().unwrap_or(Value::Null),
to: p.get("to").cloned().unwrap_or(Value::Null),
})
}
}
pub(super) fn source(s: &Session, p: &Value, cmd: &str) -> Result<MotionTrace> {
if s.doc.assembly.traces.len() >= super::MAX_ITEMS {
return Err(bad(cmd, "too many motion traces"));
}
let (occurrence, local) = super::traced_point(s, p, cmd)?;
let point = match p.get("point_ref") {
Some(v) => {
let mut reference = v.clone();
// The origin parser uses an occurrence's first placement. A trace can name a
// different nested instance; convert its world pick to that canonical frame.
let id = occurrence.last().copied().unwrap_or(0);
let placed = placed_world(s, &occurrence)?;
let inverse = solidcraft_doc::mat_inverse(&placed).ok_or_else(|| bad(cmd, "invalid occurrence placement"))?;
let canonical = joints::occurrence_world(&s.doc, id);
for key in ["face", "circle", "edge", "point", "corner"] {
if let Some(at) = reference.get(key).and_then(crate::params::vec3) {
let at = apply_point(&canonical, apply_point(&inverse, at));
reference[key] = json!([at.x, at.y, at.z]);
}
}
if let Some(z) = reference.get("z").and_then(crate::params::vec3) {
let z = solidcraft_doc::apply_vector(&canonical, solidcraft_doc::apply_vector(&inverse, z));
reference["z"] = json!([z.x, z.y, z.z]);
}
let o = super::super::joints::origin_param(s, Some(&reference), cmd)?;
if o.occurrence != occurrence.last().copied().unwrap_or(0) {
return Err(bad(cmd, "point_ref must belong to the traced occurrence"));
}
o
}
None => JointOrigin { occurrence: occurrence.last().copied().unwrap_or(0), snap: Snap::Point { point: local, z: None, x: None } },
};
let referenced = apply_point(&joints::resolve_origin(&s.doc, &s.model.state(), &point)?, Vec3::ZERO);
if referenced.dist(local) > 1e-4 {
return Err(bad(cmd, "point_ref must resolve to the traced point"));
}
let motion = motion(s, p, cmd)?;
let samples = p.get("samples").map(|_| super::sample_count(p, 100, super::MAX_TRACE, cmd)).transpose()?;
Ok(MotionTrace {
sketch: 0,
wire: String::new(),
occurrence,
point,
motion,
samples,
seeds: s.doc.assembly.joints.iter().map(|j| (j.id, j.values.clone())).collect(),
})
}
fn params(t: &MotionTrace, point: Vec3) -> Value {
let mut p = match &t.motion {
TraceMotion::Joint { joint, index, from, to } => json!({"joint":joint,"index":index,"from":from,"to":to}),
TraceMotion::Study { study } => json!({"study":study}),
};
p["occurrence"] = json!(t.occurrence);
p["point"] = json!([point.x, point.y, point.z]);
if let Some(n) = t.samples {
p["samples"] = json!(n);
}
p
}
fn local(s: &Session, t: &MotionTrace) -> Result<Vec3> {
if t.occurrence.len() > 64
|| t.seeds.len() > joints::MAX_JOINTS
|| t.seeds.iter().any(|(_, q)| q.len() > 6 || q.iter().any(|v| !v.is_finite()))
|| t.point.occurrence != t.occurrence.last().copied().unwrap_or(0)
{
return Err(bad(CMD, "invalid saved trace inputs"));
}
let m = joints::resolve_origin(&s.doc, &s.model.state(), &t.point)?;
let p = apply_point(&m, Vec3::ZERO);
if !p.len().is_finite() || p.len() >= 1e7 {
return Err(bad(CMD, "invalid trace point"));
}
Ok(p)
}
fn placed_world(s: &Session, path: &[u64]) -> Result<solidcraft_doc::Mat> {
s.doc.path_placement(path).map(|(_, world)| world).ok_or_else(|| bad(CMD, "the trace occurrence path is missing"))
}
/// Only the moving graph connected to the trace/driver is followed. Grounded anchors stop
/// traversal, so another mechanism attached to the same ground does not invalidate this one.
fn graph(s: &Session, t: &MotionTrace) -> (BTreeSet<u64>, BTreeSet<u64>) {
let a = &s.doc.assembly;
// With contact enabled another mechanism can be an obstacle. Its joint frames and
// stationary placements are then dependencies too, even without a joint to this trace.
if a.contact_enabled {
return (s.doc.occurrences.iter().map(|o| o.id).collect(), a.joints.iter().map(|j| j.id).collect());
}
let anchor = |id: u64| id == 0 || s.doc.occurrences.iter().any(|o| o.id == id && o.grounded);
let mut occurrences: BTreeSet<u64> = t.occurrence.iter().copied().collect();
let mut ids: BTreeSet<u64> = match &t.motion {
TraceMotion::Joint { joint, .. } => BTreeSet::from([*joint]),
TraceMotion::Study { study } => a.studies.iter().find(|m| m.id == *study).into_iter().flat_map(|m| m.keys.iter().map(|k| k.joint)).collect(),
};
loop {
let before = (occurrences.len(), ids.len());
for j in a.joints.iter().take(joints::MAX_JOINTS) {
if ids.contains(&j.id) || (!j.suppressed && [j.a.occurrence, j.b.occurrence].iter().any(|o| !anchor(*o) && occurrences.contains(o))) {
ids.insert(j.id);
occurrences.extend([j.a.occurrence, j.b.occurrence]);
}
}
for l in a.links.iter().take(joints::MAX_JOINTS) {
if ids.contains(&l.a) || ids.contains(&l.b) {
ids.extend([l.a, l.b]);
}
}
let parents: Vec<_> = s.doc.occurrences.iter().filter(|o| occurrences.contains(&o.id)).flat_map(|o| s.doc.first_path(o.parent)).collect();
occurrences.extend(parents);
if before == (occurrences.len(), ids.len()) {
break;
}
}
(occurrences, ids)
}
fn inputs(s: &Session, t: &MotionTrace) -> Result<Value> {
let at = local(s, t)?;
// The plan reads only driving inputs, not the picked point or displayed placement.
let p = params(t, at);
placed_world(s, &t.occurrence)?;
let (default, given, plan) = super::motion_plan(s, &p, CMD)?;
let n = super::sample_count(&p, default.min(super::MAX_TRACE), super::MAX_TRACE, CMD)?;
let (occurrences, ids) = graph(s, t);
let st = s.model.state();
let seeds: BTreeMap<u64, &Vec<f64>> = t.seeds.iter().map(|(id, q)| (*id, q)).collect();
let params = joints::Params::new(&s.doc);
let mut joints = Vec::new();
for j in s.doc.assembly.joints.iter().filter(|j| ids.contains(&j.id)) {
let mut definition = j.clone();
definition.name.clear();
definition.values = seeds.get(&j.id).map(|q| (*q).clone()).unwrap_or_default();
let (offset, angle, q) = joints::expressed(&params, &definition)?;
definition.offset = offset;
definition.angle = angle;
definition.values = q;
definition.exprs = Default::default();
let fa = joints::resolve_origin(&s.doc, &st, &j.a)?;
let fb = joints::resolve_origin(&s.doc, &st, &j.b)?;
joints.push(json!([definition, fa, fb]));
}
// Poses of driven parts are outputs. Only anchors and placements no joint places are
// inputs. Include ancestors of nested paths to notice an enclosing assembly's move.
let placed: BTreeSet<u64> = s.doc.assembly.joints.iter().filter(|j| !j.suppressed).flat_map(|j| [j.a.occurrence, j.b.occurrence]).collect();
let poses: Vec<Value> = s
.doc
.occurrences
.iter()
.filter(|o| occurrences.contains(&o.id))
.map(|o| json!([o.id, o.parent, o.component, o.grounded, if o.grounded || !placed.contains(&o.id) { o.transform } else { IDENTITY }]))
.collect();
let links: Vec<_> = s
.doc
.assembly
.links
.iter()
.filter(|l| ids.contains(&l.a) || ids.contains(&l.b))
.map(|l| {
let mut l = l.clone();
l.coupling = None;
l
})
.collect();
let study = match &t.motion {
TraceMotion::Study { study } => s.doc.assembly.studies.iter().find(|m| m.id == *study).map(|m| json!([m.steps, m.keys])),
_ => None,
};
let contact = if s.doc.assembly.contact_enabled {
// Contact reads geometry, not just the joint frames. Content keys avoid meshing or
// hashing triangles here; unkeyed bodies conservatively invalidate on a new revision.
let bodies: Vec<_> = st.bodies.iter().map(|b| json!([b.name, b.component, b.geometry_key().unwrap_or(s.revision)])).collect();
json!([s.doc.assembly.contact_all, s.doc.assembly.contact_sets, bodies])
} else {
Value::Null
};
// A plan fills unkeyed coordinates from the current pose. They belong to the retained
// branch seed instead; normalizing the small value vectors avoids copying the document
// merely to check whether a cached trace is still valid.
let mut ends = [plan(s, 0, n), plan(s, n - 1, n)];
for end in &mut ends {
for (id, values) in end {
if let Some(seed) = seeds.get(id) {
for (i, v) in values.iter_mut().enumerate() {
if !given.contains(&(*id, i)) {
*v = seed.get(i).copied().unwrap_or(0.0);
}
}
}
}
}
Ok(json!([t.sketch, t.wire, t.occurrence, at, n, given, ends, joints, poses, links, study, contact]))
}
fn seeded(s: &Session, t: &MotionTrace) -> Session {
let mut scratch = s.scratch();
let seeds: BTreeMap<_, _> = t.seeds.iter().map(|(id, q)| (*id, q)).collect();
for j in &mut scratch.doc_mut().assembly.joints {
if let Some(q) = seeds.get(&j.id) {
j.values = (*q).clone();
}
}
scratch
}
pub(super) fn remember(s: &mut Session, t: &MotionTrace) {
let key = inputs(s, t).map_err(|e| e.to_string());
if let Ok(key) = &key
// design-only: a motion trace's wire is in one of the design's sketches.
&& let Some(points) = s.doc.sketch(t.sketch).ok().and_then(|sk| sk.wires.iter().find(|w| w.id == t.wire)).map(|w| w.fit.clone())
{
remember_points(s, t.sketch, key.clone(), points);
}
Arc::make_mut(&mut s.motion_traces.entries).insert(t.sketch, CacheEntry { inputs: key, error: None });
}
fn remember_points(s: &mut Session, id: u64, key: Value, points: Vec<Vec3>) {
let history = Arc::make_mut(&mut s.motion_traces.history).entry(id).or_default();
if history.iter().all(|(old, _)| *old != key) {
if history.len() >= 8 {
history.remove(0);
}
history.push((key, points));
}
}
fn same_points(a: &[Vec3], b: &[Vec3]) -> bool {
a.len() == b.len() && a.iter().zip(b).all(|(a, b)| a.dist(*b) < 1e-9)
}
fn sample(s: &Session, t: &MotionTrace) -> Result<Vec<Vec3>> {
let at = local(s, t)?;
let mut scratch = seeded(s, t);
scratch.pending_moves.clear();
let world = placed_world(&scratch, &t.occurrence)?;
let p = params(t, apply_point(&world, at));
let (mut points, _) = super::sample_trace(&scratch, &p, CMD)?;
super::finish_trace(&mut points);
if points.len() < 2 {
return Err(bad(CMD, "the traced point no longer moves"));
}
Ok(points)
}
/// Refresh generated curves once after the input model and joint origins are current. A
/// failed dependency retains the last curve and publishes a warning instead of a stale success.
pub(crate) fn refresh(s: &mut Session) {
// Designs without associations pay no dependency-walk or geometry-check cost.
if s.doc.assembly.traces.is_empty() {
s.motion_traces.entries = Default::default();
s.motion_traces.history = Default::default();
return;
}
let existing: BTreeSet<u64> = s.doc.features.iter().map(|f| f.id).collect();
if s.doc.assembly.traces.iter().any(|t| !existing.contains(&t.sketch)) {
s.doc_mut().assembly.traces.retain(|t| existing.contains(&t.sketch));
}
if s.doc.assembly.traces.is_empty() {
s.motion_traces.entries = Default::default();
s.motion_traces.history = Default::default();
return;
}
let traces: Vec<_> = s.doc.assembly.traces.iter().take(super::MAX_ITEMS).cloned().collect();
for r in &mut s.model.results {
if traces.iter().any(|t| t.sketch == r.id) && r.warning.as_ref().is_some_and(|w| w.starts_with("Motion Trace: ")) {
r.warning = None;
}
}
if s.motion_traces.entries.keys().any(|id| !traces.iter().any(|t| t.sketch == *id)) {
Arc::make_mut(&mut s.motion_traces.entries).retain(|id, _| traces.iter().any(|t| t.sketch == *id));
Arc::make_mut(&mut s.motion_traces.history).retain(|id, _| traces.iter().any(|t| t.sketch == *id));
}
let mut changed = false;
for t in &traces {
if s.doc.feature(t.sketch).is_none_or(|f| f.suppressed) {
continue;
}
let key = inputs(s, t).map_err(|e| e.to_string());
let cached = key
.as_ref()
.ok()
.and_then(|key| s.motion_traces.history.get(&t.sketch).and_then(|h| h.iter().find(|(old, _)| old == key)).map(|(_, p)| p.clone()));
let unchanged = s.motion_traces.entries.get(&t.sketch).is_some_and(|old| old.inputs == key);
if unchanged
&& cached.as_ref().is_none_or(|points| {
// design-only: a motion trace's wire is in one of the design's sketches.
s.doc.sketch(t.sketch).ok().and_then(|sk| sk.wires.iter().find(|w| w.id == t.wire)).is_some_and(|w| same_points(&w.fit, points))
})
{
continue;
}
let result = match &key {
Ok(_) => match cached {
Some(points) => Ok(points),
None => {
#[cfg(test)]
{
s.motion_traces.recomputations += 1;
}
sample(s, t).map_err(|e| e.to_string())
}
},
Err(e) => Err(e.clone()),
};
if let (Ok(key), Ok(points)) = (&key, &result) {
remember_points(s, t.sketch, key.clone(), points.clone());
}
let error = match result {
// design-only: a motion trace's wire is in one of the design's sketches.
Ok(points) => match s.doc.sketch(t.sketch).ok().and_then(|sk| sk.wires.iter().find(|w| w.id == t.wire)) {
Some(wire) if same_points(&wire.fit, &points) => None,
Some(_) => {
// design-only: a motion trace's wire is in one of the design's sketches.
if let Ok(sk) = s.doc_mut().sketch_mut(t.sketch)
&& let Some(wire) = sk.wires.iter_mut().find(|w| w.id == t.wire)
{
wire.pts = solidcraft_sketch::fit_polyline(&points);
wire.fit = points;
changed = true;
}
None
}
None => Some("the generated trace curve is missing; detach or recreate the trace".to_string()),
},
Err(e) => Some(e),
};
Arc::make_mut(&mut s.motion_traces.entries).insert(t.sketch, CacheEntry { inputs: key, error });
}
if changed {
s.model.evaluate(&s.doc);
s.revision += 1;
}
for t in &traces {
if let Some(error) = s.motion_traces.entries.get(&t.sketch).and_then(|e| e.error.as_ref())
&& let Some(r) = s.model.results.iter_mut().find(|r| r.id == t.sketch)
{
r.warning = Some(format!("Motion Trace: {error}; showing its last successful curve"));
}
}
}
pub(super) fn list(s: &Session) -> Vec<Value> {
s.doc
.assembly
.traces
.iter()
.map(|t| {
json!({"sketch":t.sketch,"motion":t.motion,"samples":t.samples,
"error":s.motion_traces.entries.get(&t.sketch).and_then(|e| e.error.as_ref())})
})
.collect()
}
pub(super) fn edit(s: &mut Session, p: &Value) -> Result<Value> {
let key = p.get("sketch").map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())).ok_or_else(|| bad(CMD, "give a sketch"))?;
let id = s.doc.find_feature(&key).map(|f| f.id).ok_or_else(|| bad(CMD, "trace sketch is missing"))?;
let i = s.doc.assembly.traces.iter().position(|t| t.sketch == id).ok_or_else(|| bad(CMD, "the sketch has no associative trace"))?;
if bool_(p, "auto_update") == Some(false) {
s.doc_mut().assembly.traces.remove(i);
Arc::make_mut(&mut s.motion_traces.entries).remove(&id);
Arc::make_mut(&mut s.motion_traces.history).remove(&id);
return Ok(json!({"sketch":id,"auto_update":false}));
}
let mut t = s.doc.assembly.traces.get(i).cloned().ok_or_else(|| bad(CMD, "trace is missing"))?;
if p.get("study").is_some() || p.get("joint").is_some() {
t.motion = motion(s, p, CMD)?;
} else if let TraceMotion::Joint { from, to, index, .. } = &mut t.motion {
if let Some(v) = p.get("from") {
*from = v.clone();
}
if let Some(v) = p.get("to") {
*to = v.clone();
}
if let Some(v) = p.get("index") {
*index = v.as_u64().and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad(CMD, "invalid index"))?;
}
}
if p.get("samples").is_some() {
t.samples = Some(super::sample_count(p, 100, super::MAX_TRACE, CMD)?);
}
inputs(s, &t)?;
// Validate before publishing an edited definition; execute can then undo the whole edit.
if s.doc.assembly.traces.get(i) != Some(&t)
&& let Some(slot) = s.doc_mut().assembly.traces.get_mut(i)
{
*slot = t;
}
Ok(json!({"sketch":id,"auto_update":true}))
}