SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Assembly: name placed bodies without rescanning the design (#7380)
Jackson Oursland4e07b6c4b7f3
diff --git a/crates/doc/src/assembly.rs b/crates/doc/src/assembly.rsindex d2d2c80fb4..0ca382f854 100644--- a/crates/doc/src/assembly.rs+++ b/crates/doc/src/assembly.rs@@ -313,9 +313,10 @@ impl Document {pub fn body_frames_with_source(&self, st: &crate::ModelState) -> Vec<(String, String, u64, Vec<u64>, Mat)> {let mut out = Vec::new();let owners = self.model_body_components(st);+ let names = WorldNames::new(self, st);for (comp, path, m) in self.placements() {for (b, _) in st.bodies.iter().zip(&owners).filter(|(_, owner)| **owner == comp) {- let name = self.world_body_name(st, &b.name, comp, &path);+ let name = names.name(&b.name, comp, &path);let w = match self.model_body_offset(b) {Some(o) => mat_mul(&m, o),None => m,@@ -328,38 +329,10 @@ impl Document {/// Computed placement name. Source names retain priority; ambiguous labels use full IDs./// Resolves label ambiguity with bounded dynamic counts instead of expanding all placements.+ /// To name many placed bodies, make one [`WorldNames`] and ask it for each.pub fn world_body_name(&self, st: &crate::ModelState, source: &str, component: u64, path: &[u64]) -> String {- if path == self.first_path(component) {- return source.to_string();- }- let names: Vec<&str> = path.iter().filter_map(|id| self.occurrences.iter().find(|o| o.id == *id)).map(|o| o.name.as_str()).collect();- let label = names.join("/");- let candidate = format!("{source} ({label})");- let mut counts = std::collections::BTreeMap::from([(0, 1usize)]);- for name in &names {- let mut next = std::collections::BTreeMap::<u64, usize>::new();- for o in self.occurrences.iter().filter(|o| o.name == *name) {- if let Some(count) = counts.get(&o.parent) {- let n = next.entry(o.component).or_default();- *n = (*n + count).min(2);- }- }- counts = next;- }- let ambiguous = counts.get(&component).copied().unwrap_or(0) > 1;- // Slash and reserved-marker names could alias concatenated labels or fallback keys.- let reserved =- self.occurrences.iter().any(|o| o.name.contains('/') || o.name.contains("@occ[")) || st.bodies.iter().any(|b| b.name.contains("@occ["));- if !ambiguous && !reserved && st.body(&candidate).is_none() {- return candidate;- }- let ids = path.iter().map(u64::to_string).collect::<Vec<_>>().join("/");- let encoded = serde_json::to_string(source).unwrap_or_else(|_| source.to_string());- let mut key = format!("{encoded}@occ[{ids}]");- while st.body(&key).is_some() {- key.push('#');- }- key+ // One name: scanning the design once is cheaper than indexing it first.+ placed_name(&Scan { doc: self, st }, source, component, path)}/// The occurrence path of a component's first placement.@@ -438,3 +411,140 @@ impl Document {Ok(id)}}++/// The names of a design's placed bodies ([`Document::world_body_name`]), with what naming one+/// needs from the whole design worked out once: the occurrences by id, by name and by+/// component, the model's body names, and whether any name could alias a label or fallback key.+/// Naming each body of an assembly is then as cheap as its occurrence path, not a scan of the+/// whole design.+pub struct WorldNames<'a> {+ /// The first occurrence with each id.+ by_id: std::collections::HashMap<u64, &'a crate::Occurrence>,+ /// The occurrences with each name, in document order.+ by_name: std::collections::HashMap<&'a str, Vec<&'a crate::Occurrence>>,+ /// Each component's first occurrence ([`Document::occurrence_of`]).+ first_of: std::collections::HashMap<u64, &'a crate::Occurrence>,+ bodies: std::collections::HashSet<&'a str>,+ /// Some occurrence or body name has a slash or the fallback key's marker.+ reserved: bool,+}++impl<'a> WorldNames<'a> {+ pub fn new(doc: &'a Document, st: &'a crate::ModelState) -> WorldNames<'a> {+ let mut by_id = std::collections::HashMap::with_capacity(doc.occurrences.len());+ let mut by_name: std::collections::HashMap<&str, Vec<&crate::Occurrence>> = std::collections::HashMap::new();+ let mut first_of = std::collections::HashMap::new();+ for o in &doc.occurrences {+ by_id.entry(o.id).or_insert(o);+ by_name.entry(o.name.as_str()).or_default().push(o);+ first_of.entry(o.component).or_insert(o);+ }+ let reserved =+ doc.occurrences.iter().any(|o| o.name.contains('/') || o.name.contains("@occ[")) || st.bodies.iter().any(|b| b.name.contains("@occ["));+ let bodies = st.bodies.iter().map(|b| b.name.as_str()).collect();+ WorldNames { by_id, by_name, first_of, bodies, reserved }+ }++ /// The world name of the body `source` of `component` placed through `path`.+ pub fn name(&self, source: &str, component: u64, path: &[u64]) -> String {+ placed_name(self, source, component, path)+ }+}++/// What naming a placed body looks up in the design: by scanning it ([`Scan`], for one name)+/// or through its indexes ([`WorldNames`], for many).+trait NameLookup {+ fn occurrence(&self, id: u64) -> Option<&crate::Occurrence>;+ fn each_named(&self, name: &str, f: &mut dyn FnMut(&crate::Occurrence));+ fn first_of(&self, component: u64) -> Option<&crate::Occurrence>;+ fn reserved(&self) -> bool;+ fn has_body(&self, name: &str) -> bool;+}++/// Lookups by scanning the design.+struct Scan<'a> {+ doc: &'a Document,+ st: &'a crate::ModelState,+}++impl NameLookup for Scan<'_> {+ fn occurrence(&self, id: u64) -> Option<&crate::Occurrence> {+ self.doc.occurrences.iter().find(|o| o.id == id)+ }+ fn each_named(&self, name: &str, f: &mut dyn FnMut(&crate::Occurrence)) {+ self.doc.occurrences.iter().filter(|o| o.name == name).for_each(f);+ }+ fn first_of(&self, component: u64) -> Option<&crate::Occurrence> {+ self.doc.occurrence_of(component)+ }+ fn reserved(&self) -> bool {+ self.doc.occurrences.iter().any(|o| o.name.contains('/') || o.name.contains("@occ["))+ || self.st.bodies.iter().any(|b| b.name.contains("@occ["))+ }+ fn has_body(&self, name: &str) -> bool {+ self.st.body(name).is_some()+ }+}++impl NameLookup for WorldNames<'_> {+ fn occurrence(&self, id: u64) -> Option<&crate::Occurrence> {+ self.by_id.get(&id).copied()+ }+ fn each_named(&self, name: &str, f: &mut dyn FnMut(&crate::Occurrence)) {+ self.by_name.get(name).into_iter().flatten().copied().for_each(f);+ }+ fn first_of(&self, component: u64) -> Option<&crate::Occurrence> {+ self.first_of.get(&component).copied()+ }+ fn reserved(&self) -> bool {+ self.reserved+ }+ fn has_body(&self, name: &str) -> bool {+ self.bodies.contains(name)+ }+}++/// The world name of the body `source` of `component` placed through `path` (see+/// [`Document::world_body_name`]).+fn placed_name(l: &impl NameLookup, source: &str, component: u64, path: &[u64]) -> String {+ // The occurrence path of the component's first placement ([`Document::first_path`]).+ let mut first = Vec::new();+ let mut c = component;+ for _ in 0..1000 {+ if c == 0 {+ break;+ }+ let Some(o) = l.first_of(c) else { break };+ first.insert(0, o.id);+ c = o.parent;+ }+ if path == first {+ return source.to_string();+ }+ let names: Vec<&str> = path.iter().filter_map(|id| l.occurrence(*id)).map(|o| o.name.as_str()).collect();+ let label = names.join("/");+ let candidate = format!("{source} ({label})");+ let mut counts = std::collections::BTreeMap::from([(0, 1usize)]);+ for name in &names {+ let mut next = std::collections::BTreeMap::<u64, usize>::new();+ l.each_named(name, &mut |o| {+ if let Some(count) = counts.get(&o.parent) {+ let n = next.entry(o.component).or_default();+ *n = (*n + count).min(2);+ }+ });+ counts = next;+ }+ let ambiguous = counts.get(&component).copied().unwrap_or(0) > 1;+ // Slash and reserved-marker names could alias concatenated labels or fallback keys.+ if !ambiguous && !l.reserved() && !l.has_body(&candidate) {+ return candidate;+ }+ let ids = path.iter().map(u64::to_string).collect::<Vec<_>>().join("/");+ let encoded = serde_json::to_string(source).unwrap_or_else(|_| source.to_string());+ let mut key = format!("{encoded}@occ[{ids}]");+ while l.has_body(&key) {+ key.push('#');+ }+ key+}diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex dcea015aa9..27a2022a7b 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -8342,12 +8342,13 @@ pub fn world_state_reusing(doc: &Document, st: &ModelState, placed_before: &mut// places hundreds of parts, each a B-rep transform.let mut jobs = Vec::new();let owners = doc.model_body_components(st);+ let names = crate::WorldNames::new(doc, st);let bodies_of = |comp: u64| st.bodies.iter().zip(&owners).filter(move |(_, owner)| **owner == comp).map(|(b, _)| b);for (comp, path, m) in &placements {for b in bodies_of(*comp) {let bm = body_matrix(b, m);if !crate::is_identity(&bm) {- jobs.push((b, bm, doc.world_body_name(st, &b.name, *comp, path)));+ jobs.push((b, bm, names.name(&b.name, *comp, path)));}}}@@ -8366,14 +8367,14 @@ pub fn world_state_reusing(doc: &Document, st: &ModelState, placed_before: &mut// A changed placement keeps a distinct mesh, at that placement's coordinates.let mut placed = if crate::is_identity(&bm) {let mut placed = b.clone();- placed.name = doc.world_body_name(st, &b.name, comp, &path);+ placed.name = names.name(&b.name, comp, &path);placed} else {// The same order as the jobs: this body's, made above (again here if it failed).let placed = match moved.next() {Some((Some(placed), _)) => placed,Some((None, (_, _, name))) => placed_before.placed(b, &bm, name.clone()),- None => placed_before.placed(b, &bm, doc.world_body_name(st, &b.name, comp, &path)),+ None => placed_before.placed(b, &bm, names.name(&b.name, comp, &path)),};placed_now.by_source.insert(placed_key(b, &bm), (b.clone(), placed.clone()));placed@@ -8428,7 +8429,7 @@ pub fn world_state_reusing(doc: &Document, st: &ModelState, placed_before: &mut.filter(|t| st.body(&t.body).map(|body| doc.model_body_component(body)).unwrap_or_else(|| comp_of_feature(t.feature)) == comp){let mut t2 = t.clone();- t2.body = doc.world_body_name(st, &t.body, comp, &path);+ t2.body = names.name(&t.body, comp, &path);let frame = st.body(&t.body).and_then(|body| doc.model_body_offset(body)).map(|offset| crate::mat_mul(&m, offset)).unwrap_or(m);t2.axis_point = crate::apply_point(&frame, t.axis_point);t2.axis = crate::apply_vector(&frame, *t.axis).unit().unwrap_or(t.axis);diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex 9f95713f35..ac4fefdc08 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -69,8 +69,8 @@ pub mod sheet;pub mod text_params;pub use assembly::{- IDENTITY, MAX_PLACEMENT_DEPTH, MAX_PLACEMENTS, Mat, Occurrence, apply_point, apply_vector, is_identity, map_point_expr, mat_inverse, mat_mul,- rigid,+ IDENTITY, MAX_PLACEMENT_DEPTH, MAX_PLACEMENTS, Mat, Occurrence, WorldNames, apply_point, apply_vector, is_identity, map_point_expr, mat_inverse,+ mat_mul, rigid,};pub use document::*;pub use eval::KeptResults;diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rsindex 7961129261..5b3c2df45a 100644--- a/crates/engine/src/cmd/occurrence_tests.rs+++ b/crates/engine/src/cmd/occurrence_tests.rs@@ -101,6 +101,73 @@ fn renaming_a_parent_preserves_hidden_nested_copies_with_ambiguous_labels() {}}+/// The world name of a placed body as `Document::world_body_name` worked it out before+/// `WorldNames` (each name scanning the whole design), kept to prove the two agree.+fn world_name_by_scanning(doc: &crate::doc::Document, st: &crate::doc::ModelState, source: &str, component: u64, path: &[u64]) -> String {+ if path == doc.first_path(component) {+ return source.to_string();+ }+ let names: Vec<&str> = path.iter().filter_map(|id| doc.occurrences.iter().find(|o| o.id == *id)).map(|o| o.name.as_str()).collect();+ let candidate = format!("{source} ({})", names.join("/"));+ let mut counts = std::collections::BTreeMap::from([(0, 1usize)]);+ for name in &names {+ let mut next = std::collections::BTreeMap::<u64, usize>::new();+ for o in doc.occurrences.iter().filter(|o| o.name == *name) {+ if let Some(count) = counts.get(&o.parent) {+ let n = next.entry(o.component).or_default();+ *n = (*n + count).min(2);+ }+ }+ counts = next;+ }+ let ambiguous = counts.get(&component).copied().unwrap_or(0) > 1;+ let reserved =+ doc.occurrences.iter().any(|o| o.name.contains('/') || o.name.contains("@occ[")) || st.bodies.iter().any(|b| b.name.contains("@occ["));+ if !ambiguous && !reserved && st.body(&candidate).is_none() {+ return candidate;+ }+ let ids = path.iter().map(u64::to_string).collect::<Vec<_>>().join("/");+ let mut key = format!("{}@occ[{ids}]", serde_json::to_string(source).unwrap());+ while st.body(&key).is_some() {+ key.push('#');+ }+ key+}++/// Naming every placed body at once (`WorldNames`) gives each the name naming it alone did:+/// nested copies, copies whose labels collide, a body named like a label, and names with a+/// slash or the fallback key's marker.+#[test]+fn placed_body_names_match_naming_each_body_alone() {+ let mut s = Session::default();+ let (parent, _) = created(&mut s, "Assembly");+ let (knob, _) = created(&mut s, "Knob");+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Knob"}));+ run(&mut s, "occurrence.copy", json!({"component": parent, "translate": [20, 0, 0]}));+ run(&mut s, "occurrence.copy", json!({"component": knob, "translate": [0, 20, 0]}));+ run(&mut s, "component.activate", json!({"component": 0}));+ run(&mut s, "solid.box", json!({"length": 1, "width": 1, "height": 1, "body_name": "Knob (Assembly/Knob)"}));+ let check = |s: &Session, step: &str| {+ let st = s.model.state();+ let names = crate::doc::WorldNames::new(&s.doc, &st);+ let mut seen = 0;+ for (component, path, _) in s.doc.placements() {+ for b in st.bodies.iter().filter(|b| s.doc.model_body_component(b) == component) {+ assert_eq!(names.name(&b.name, component, &path), world_name_by_scanning(&s.doc, &st, &b.name, component, &path), "{step}: {path:?}");+ seen += 1;+ }+ }+ assert!(seen >= 5, "{step}: every placement is named ({seen})");+ };+ check(&s, "copies");+ run(&mut s, "component.rename", json!({"component": parent, "name": "Knob"}));+ check(&s, "a parent named like its child");+ run(&mut s, "component.rename", json!({"component": parent, "name": "Assembly/Other"}));+ check(&s, "a slash");+ run(&mut s, "body.rename", json!({"body": "Knob", "name": "Grip (@occ[custom])"}));+ check(&s, "the fallback marker");+}+#[test]fn instance_copy_uses_selected_source_transform() {let mut s = Session::default();diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rsindex 29c0ba8306..a07b4a3052 100644--- a/crates/engine/src/occurrences.rs+++ b/crates/engine/src/occurrences.rs@@ -89,12 +89,13 @@ impl Session {}let hidden: std::collections::BTreeSet<_> = self.visibility.hidden_bodies.iter().map(String::as_str).collect();let mut names = std::collections::BTreeMap::new();+ let (before, after) = (solidcraft_doc::WorldNames::new(previous, state), solidcraft_doc::WorldNames::new(&self.doc, &renamed));for (component, path, _) in previous.placements() {for body in state.bodies.iter().filter(|body| previous.model_body_component(body) == component) {- let old = previous.world_body_name(state, &body.name, component, &path);+ let old = before.name(&body.name, component, &path);if hidden.contains(old.as_str()) {let source = rename.filter(|(old, _)| *old == body.name).map_or(body.name.as_str(), |(_, new)| new);- names.insert(old, self.doc.world_body_name(&renamed, source, component, &path));+ names.insert(old, after.name(source, component, &path));}}}@@ -169,11 +170,12 @@ impl Session {}let leaf = self.doc.occurrences.iter().find(|o| Some(&o.id) == path.last()).ok_or_else(|| invalid("occurrence path has no leaf"))?;let state = self.model.state();+ let names = solidcraft_doc::WorldNames::new(&self.doc, &state);let bodies = state.bodies.iter().filter(|b| self.doc.model_body_component(b) == component)- .map(|b| OccurrenceBody { source: b.name.clone(), world: self.doc.world_body_name(&state, &b.name, component, path) })+ .map(|b| OccurrenceBody { source: b.name.clone(), world: names.name(&b.name, component, path) }).collect();Ok(OccurrencePlacement {occurrence: leaf.id,@@ -417,12 +419,13 @@ impl Session {fn bodies_hidden_by_parents(&self) -> std::collections::BTreeSet<String> {let st = self.model.state();let mut out = std::collections::BTreeSet::new();+ let names = solidcraft_doc::WorldNames::new(&self.doc, &st);for (component, path, _) in self.doc.placements() {let placement_hidden = !path.is_empty() && !self.occurrence_visible(&path);let scope = Self::folder_scope(&path);for b in st.bodies.iter().filter(|b| self.doc.model_body_component(b) == component) {if placement_hidden || self.item_folder_hidden(&scope, component, "bodies", &b.name) {- out.insert(self.doc.world_body_name(&st, &b.name, component, &path));+ out.insert(names.name(&b.name, component, &path));}}}