From 91ecea8cfdb7e6e7a9089e40578303e5f99cfdbd Mon Sep 17 00:00:00 2001 From: takuto-NA Date: Wed, 4 Nov 2026 18:30:31 +0000 Subject: [PATCH] Properties: account for sheet perforations (#6025) (#6028) * claim: #6025 * fix(engine): account for sheet perforations in physical properties * fix(inspect): retain kernel topology counts for sheet bodies --- crates/doc/src/sheet.rs | 117 +++++++++ crates/engine/src/cmd/component_properties.rs | 19 +- .../src/cmd/component_properties_tests.rs | 247 ++++++++++++++++++ crates/engine/src/cmd/inspect.rs | 65 ++--- crates/engine/src/cmd/mass_properties.rs | 17 +- crates/engine/src/cmd/measure_sel.rs | 7 +- docs/assembly-properties.md | 10 + 7 files changed, 446 insertions(+), 36 deletions(-) diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs index 6b1d0ca65..6b4b4e4e3 100644 --- a/crates/doc/src/sheet.rs +++ b/crates/doc/src/sheet.rs @@ -2545,6 +2545,123 @@ impl SheetBody { .sum() } + /// Include the physical holes that perforation fields leave out of the B-rep measurement. + /// `placement` maps this sheet's geometry into the measurement's frame. Hole cylinders + /// lie on panels, clear of bends; their volume moments follow each panel's current fold. + /// Bounding boxes and B-rep topology are unchanged by these interior holes. + pub fn correct_perforation_properties(&self, measured: &mut kernel::BodyMeasure, placement: &Mat) -> Result<()> { + let (mut removed, mut area_delta, mut moment_delta) = (0.0, 0.0, Vec3::ZERO); + self.visit_perforation_cylinders(placement, |center, volume, area, _| { + removed += volume; + area_delta += area; + // Use distances from the measured centre, including far-away placements. + moment_delta += (measured.centroid - center) * volume; + })?; + if removed == 0.0 { + return Ok(()); + } + let volume = measured.volume - removed; + let area = measured.area + area_delta; + let centroid = measured.centroid + moment_delta / volume; + if !(volume.is_finite() && volume > 0.0 && area.is_finite() && area >= 0.0 && centroid.is_finite()) { + return Err(DocError::Invalid(format!("invalid perforation physical properties for `{}`", self.body))); + } + measured.volume = volume; + measured.area = area; + measured.centroid = centroid; + Ok(()) + } + + /// Remove the same hole cylinders from the inertia spread as from volume and centroid. + /// The input and output tensors are at unit density, about their respective centroids. + pub fn correct_perforation_mass_properties(&self, measured: &mut solidcraft_geom::MassProperties, placement: &Mat) -> Result<()> { + use solidcraft_geom::inertia; + let (mut removed, mut moment_delta, mut removed_inertia) = (0.0, Vec3::ZERO, [[0.0; 3]; 3]); + self.visit_perforation_cylinders(placement, |center, volume, _, own| { + let delta = measured.centroid - center; + removed += volume; + moment_delta += delta * volume; + let about_center = inertia::shifted(&own, volume, delta); + for (row, hole) in removed_inertia.iter_mut().zip(about_center) { + for (value, h) in row.iter_mut().zip(hole) { + *value += h; + } + } + })?; + if removed == 0.0 { + return Ok(()); + } + let volume = measured.volume - removed; + let delta = moment_delta / volume; + let centroid = measured.centroid + delta; + let mut tensor = measured.inertia; + for (row, hole) in tensor.iter_mut().zip(removed_inertia) { + for (value, h) in row.iter_mut().zip(hole) { + *value -= h; + } + } + // Move from the old centre to the new one, reversing the parallel-axis term. + let tensor = inertia::shifted(&tensor, -volume, delta); + if !(volume.is_finite() && volume > 0.0 && centroid.is_finite() && tensor.iter().flatten().all(|v| v.is_finite())) { + return Err(DocError::Invalid(format!("invalid perforation inertia for `{}`", self.body))); + } + measured.volume = volume; + measured.centroid = centroid; + measured.inertia = tensor; + Ok(()) + } + + /// Analytic cylinders at each panel's current fold, in the requested measurement frame. + fn visit_perforation_cylinders(&self, placement: &Mat, mut visit: impl FnMut(Vec3, f64, f64, solidcraft_geom::inertia::Tensor3)) -> Result<()> { + if self.perforations.is_empty() { + return Ok(()); + } + let invalid = || DocError::Invalid(format!("invalid perforation physical properties for `{}`", self.body)); + if !(self.t.is_finite() && self.t > 0.0) || placement.iter().flatten().any(|v| !v.is_finite()) { + return Err(invalid()); + } + let isometry = |m: &Mat| { + let [x, y, z] = [0, 1, 2].map(|i| Vec3::new(m[i][0], m[i][1], m[i][2])); + m.iter().flatten().all(|v| v.is_finite()) + && m[0][3] == 0.0 + && m[1][3] == 0.0 + && m[2][3] == 0.0 + && m[3][3] == 1.0 + && [x, y, z].iter().all(|a| (a.dot(*a) - 1.0).abs() < 1e-9) + && x.dot(y).abs() < 1e-9 + && x.dot(z).abs() < 1e-9 + && y.dot(z).abs() < 1e-9 + }; + let panels: Vec<_> = self.panels().into_iter().map(|(i, region)| (mat_mul(placement, &self.world(i)), region)).collect(); + let flat = mat_mul(placement, &self.world(None)); + if !isometry(&flat) || panels.iter().any(|(world, _)| !isometry(world)) { + return Err(DocError::Invalid("not supported yet: perforation physical properties under scale or shear".into())); + } + for p in &self.perforations { + if !([p.diameter, p.pitch, p.margin].iter().all(|v| v.is_finite()) && p.diameter > 0.0 && p.pitch > p.diameter && p.margin >= 0.0) { + return Err(invalid()); + } + let holes = self.perforation_holes(p)?; + let disk = std::f64::consts::PI * (p.diameter / 2.0).powi(2); + let volume = disk * self.t; + let area_delta = std::f64::consts::PI * p.diameter * self.t - 2.0 * disk; + let radius2 = (p.diameter / 2.0).powi(2); + let transverse = volume * (3.0 * radius2 + self.t * self.t) / 12.0; + let own = [[transverse, 0.0, 0.0], [0.0, transverse, 0.0], [0.0, 0.0, volume * radius2 / 2.0]]; + for hole in holes { + let world = if self.flat || panels.len() == 1 { + &flat + } else { + &panels.iter().find(|(_, region)| region.contains(hole)).ok_or_else(invalid)?.0 + }; + let center = apply_point(world, v3(hole) + Vec3::Z * (self.t / 2.0)); + let rotation = [0, 1, 2].map(|i| [0, 1, 2].map(|j| world[j][i])); + visit(center, volume, area_delta, solidcraft_geom::inertia::transformed(&own, &rotation)); + } + } + Ok(()) + } + /// Topology counted by faces and loops: a round hole is one face bounded by two closed circular /// edges (one vertex each), where the sewn solid splits it into arcs. Returns the change to /// the sewn (faces, edges, vertices). diff --git a/crates/engine/src/cmd/component_properties.rs b/crates/engine/src/cmd/component_properties.rs index 1cb482d5f..42fd9bc24 100644 --- a/crates/engine/src/cmd/component_properties.rs +++ b/crates/engine/src/cmd/component_properties.rs @@ -234,7 +234,12 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool, #[cfg(test)] work::count(|w| w.spreads += spread_bodies.len()); let spreads = solidcraft_kernel::map_on_threads(&spread_bodies, 16, |&i| { - state.bodies.get(i).and_then(|b| solidcraft_io::mass_properties(&b.body).ok().flatten()).and_then(|m| m.gyration()) + let body = state.bodies.get(i)?; + let mut measured = solidcraft_io::mass_properties(&body.body).ok().flatten()?; + if let Some(sheet) = state.sheets.iter().find(|sheet| sheet.body == body.definition_name()) { + sheet.correct_perforation_mass_properties(&mut measured, &solidcraft_doc::IDENTITY).ok()?; + } + measured.gyration() }); let spread: BTreeMap = spread_bodies.into_iter().zip(spreads).filter_map(|(i, g)| Some((i, g.flatten()?))).collect(); // A window waiting for the result (the Properties window) sees how far it is and can stop it. @@ -254,7 +259,17 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool, } done += 1; let transform: Mat = doc.model_body_offset(body).map(|offset| solidcraft_doc::mat_mul(&transform, offset)).unwrap_or(transform); - let measured = measure_placed(body, transform)?; + let mut measured = measure_placed(body, transform)?; + if let Some(sheet) = state.sheets.iter().find(|sheet| sheet.body == body.definition_name() && !sheet.perforations.is_empty()) { + let mut corrected = body.measure()?; + corrected.volume = measured.volume; + corrected.area = measured.area; + corrected.centroid = measured.centroid; + sheet.correct_perforation_properties(&mut corrected, &transform)?; + measured.volume = corrected.volume; + measured.area = corrected.area; + measured.centroid = corrected.centroid; + } let density = doc.density(&body.name); let body_mass = measured.volume * density / 1000.0; let closed = measured.closed; diff --git a/crates/engine/src/cmd/component_properties_tests.rs b/crates/engine/src/cmd/component_properties_tests.rs index fc42af5d6..b09f82de2 100644 --- a/crates/engine/src/cmd/component_properties_tests.rs +++ b/crates/engine/src/cmd/component_properties_tests.rs @@ -1,5 +1,6 @@ use crate::Session; use serde_json::{Value, json}; +use solidcore_record::Vec2; use solidcraft_geom::prelude::*; fn run(s: &mut Session, cmd: &str, params: Value) -> Value { @@ -89,6 +90,252 @@ fn body_reassignment_offsets_preserve_world_properties() { close(&r["total"]["center_of_mass"][0], 5.0); } +fn panel_blank(s: &mut Session, width: f64, height: f64) { + run(s, "sheet.manage_rules", json!({"name": "Panel 0.8", "thickness": "0.8", "active": true})); + run(s, "sketch.create", json!({"plane": "XY", "name": "Blank"})); + run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [width, height]})); + run(s, "sketch.finish", json!({})); + run(s, "sheet.flange", json!({"sketch": "Blank", "body_name": "Panel"})); +} + +fn perforated_panel(s: &mut Session) { + panel_blank(s, 20.0, 10.0); + run(s, "sheet.perforate", json!({"diameter": "2", "pitch": "10", "margin": "1", "pattern": "square"})); + run(s, "material.assign", json!({"bodies": ["Panel"], "material": "Steel"})); +} + +/// Two radius-1 holes centred at (2, 2) and (12, 2), through a 20 x 10 x 0.8 blank. +fn perforated_panel_expected() -> (f64, f64, [f64; 3]) { + let removed = 2.0 * std::f64::consts::PI * 0.8; + let volume = 160.0 - removed; + let area = 448.0 - 0.8 * std::f64::consts::PI; + (volume, area, [(160.0 * 10.0 - removed * 7.0) / volume, (160.0 * 5.0 - removed * 2.0) / volume, 0.4]) +} + +#[test] +fn perforated_sheet_properties_include_holes_and_their_off_centre_volume_moment() { + let mut s = Session::default(); + perforated_panel(&mut s); + let (volume, area, center) = perforated_panel_expected(); + let density = s.doc.density("Panel"); + let doc = s.doc.clone(); + let undo = s.undo.len(); + for command in ["component.properties", "inspect.measure"] { + let result = run(&mut s, command, json!({})); + close(&result["total"]["volume_mm3"], volume); + close(&result["total"]["mass_g"], volume * density / 1000.0); + close(&result["total"]["area_mm2"], area); + for (axis, expected) in center.iter().enumerate() { + close(&result["bodies"][0]["center_of_mass"][axis], *expected); + } + } + let inspected = run(&mut s, "document.inspect", json!({"measure": true})); + close(&inspected["bodies"][0]["volume_mm3"], volume); + close(&inspected["bodies"][0]["area_mm2"], area); + for key in ["faces", "edges", "vertices"] { + assert_eq!(inspected["bodies"][0][key], inspected["bodies"][0]["kernel"][key], "document.inspect retains kernel {key}"); + } + assert!(inspected["bodies"][0].get("sheet_metal").is_none()); + let picked = run(&mut s, "inspect.measure", json!({"items": [{"type": "body", "name": "Panel"}]})); + close(&picked["items"][0]["volume_mm3"], volume); + assert!(std::sync::Arc::ptr_eq(&s.doc, &doc)); + assert_eq!(s.undo.len(), undo, "measuring must not add an undo step"); +} + +#[test] +fn perforated_sheet_instances_keep_physical_properties_in_nested_world_placements() { + let mut s = Session::default(); + let parent = run(&mut s, "component.create", json!({"name": "Subassembly", "grounded": false})); + let child = run(&mut s, "component.create", json!({"name": "Sheet", "grounded": false})); + perforated_panel(&mut s); + let sheet_density = s.doc.density("Panel"); + run(&mut s, "component.activate", json!({"component": "root"})); + let copy = run(&mut s, "occurrence.copy", json!({"component": parent["component"], "translate": [40, 0, 0]})); + run( + &mut s, + "occurrence.move", + json!({"occurrence": parent["occurrence"], "translate": [20, 0, 10], "axis": [0, 0, 1], "angle": "90 deg", "capture": false}), + ); + box_in(&mut s, "Ballast"); + let ballast_body = s.model.state().bodies.last().unwrap().name.clone(); + run(&mut s, "material.assign", json!({"bodies": [ballast_body], "material": "Aluminum"})); + let ballast_mass = s.doc.density(&ballast_body); + let (volume, area, center) = perforated_panel_expected(); + let sheet_mass = volume * sheet_density / 1000.0; + let first = [20.0 - center[1], center[0], 10.0 + center[2]]; + let second = [40.0 + center[0], center[1], center[2]]; + let doc = s.doc.clone(); + let moves = s.pending_moves.clone(); + let undo = s.undo.len(); + for (parent_occurrence, expected) in [(&parent["occurrence"], first), (©["occurrence"], second)] { + let properties = + run(&mut s, "occurrence.properties", json!({"occurrence": child["occurrence"], "path": [parent_occurrence, child["occurrence"]]})); + close(&properties["total"]["volume_mm3"], volume); + close(&properties["total"]["mass_g"], sheet_mass); + close(&properties["total"]["area_mm2"], area); + for (axis, coordinate) in expected.iter().enumerate() { + close(&properties["total"]["center_of_mass"][axis], *coordinate); + } + } + let properties = run(&mut s, "component.properties", json!({"component": "root"})); + let mass = 2.0 * sheet_mass + ballast_mass; + close(&properties["total"]["volume_mm3"], 2.0 * volume + 1000.0); + close(&properties["total"]["mass_g"], mass); + for axis in 0..3 { + close(&properties["total"]["center_of_mass"][axis], (sheet_mass * (first[axis] + second[axis]) + ballast_mass * 5.0) / mass); + } + let measured = run(&mut s, "inspect.measure", json!({})); + close(&measured["total"]["volume_mm3"], 2.0 * volume + 1000.0); + close(&measured["total"]["mass_g"], mass); + assert_eq!(measured["bodies"].as_array().unwrap().iter().filter(|b| b["sheet_metal"] == true).count(), 2); + assert!(std::sync::Arc::ptr_eq(&s.doc, &doc)); + assert_eq!(s.pending_moves, moves); + assert_eq!(s.undo.len(), undo); +} + +#[test] +fn perforated_sheet_centroid_follows_a_folded_panel_and_unfolds() { + use std::f64::consts::{FRAC_PI_2, PI}; + let mut s = Session::default(); + panel_blank(&mut s, 30.0, 10.0); + run( + &mut s, + "sheet.fold", + json!({"points": [[10, 0, 0], [10, 10, 0]], "angle": "90 deg", "radius": "0.8", "position": "centerline", "fixed": [2, 5, 0]}), + ); + let before = run(&mut s, "component.properties", json!({"component": "root"})); + run(&mut s, "sheet.perforate", json!({"diameter": "2", "pitch": "10", "margin": "0", "pattern": "square"})); + let sheet = &s.model.state().sheets[0]; + let holes = sheet.perforation_holes(&sheet.perforations[0]).unwrap(); + assert_eq!(holes.len(), 2); + // Fold boundaries carry kernel roundoff; keep the analytic centres and the + // same sub-micrometre tolerance used by the property checks below. + for (hole, expected) in holes.iter().zip([Vec2::new(1.0, 1.0), Vec2::new(21.0, 1.0)]) { + assert!(hole.dist(expected) < 1e-6, "{hole:?} != {expected:?}"); + } + // The right panel turns up by 90 degrees about a y-parallel bend axis at + // z = radius + thickness. Its mid-plane is radius + thickness/2 from that axis. + let allowance = FRAC_PI_2 * (0.8 + 0.44 * 0.8); + let bend_start = 10.0 - allowance / 2.0; + let right_hole = [bend_start + 1.2, 1.0, 1.6 + 21.0 - bend_start - allowance]; + let old_volume = before["total"]["volume_mm3"].as_f64().unwrap(); + let hole_volume = PI * 0.8; + let volume = old_volume - 2.0 * hole_volume; + let result = run(&mut s, "component.properties", json!({"component": "root"})); + close(&result["total"]["volume_mm3"], volume); + for (axis, left) in [1.0, 1.0, 0.4].iter().enumerate() { + let old = before["total"]["center_of_mass"][axis].as_f64().unwrap(); + close(&result["total"]["center_of_mass"][axis], old + hole_volume * (2.0 * old - left - right_hole[axis]) / volume); + } + run(&mut s, "sheet.unfold", json!({})); + let result = run(&mut s, "component.properties", json!({"component": "root"})); + let volume = 240.0 - 2.0 * hole_volume; + close(&result["total"]["volume_mm3"], volume); + for (axis, expected) in [(240.0 * 15.0 - 2.0 * hole_volume * 11.0) / volume, (240.0 * 5.0 - 2.0 * hole_volume) / volume, 0.4].iter().enumerate() { + close(&result["total"]["center_of_mass"][axis], *expected); + } +} + +#[test] +fn perforated_sheet_correction_rejects_invalid_metadata_without_partial_changes() { + let mut s = Session::default(); + perforated_panel(&mut s); + let state = s.model.state(); + let measured = solidcraft_kernel::measure(&state.bodies[0].body).unwrap(); + for pitch in [0.0, -1.0, f64::NAN, f64::INFINITY] { + let mut sheet = state.sheets[0].clone(); + sheet.perforations[0].pitch = pitch; + let mut actual = measured.clone(); + assert!(sheet.correct_perforation_properties(&mut actual, &solidcraft_doc::IDENTITY).is_err()); + assert_eq!(actual.volume, measured.volume); + assert_eq!(actual.area, measured.area); + assert_eq!(actual.centroid, measured.centroid); + } + let mut scaled = solidcraft_doc::IDENTITY; + scaled[0][0] = 2.0; + let mut sheared = solidcraft_doc::IDENTITY; + sheared[0][1] = 0.5; + for placement in [scaled, sheared] { + let mut actual = measured.clone(); + assert!(state.sheets[0].correct_perforation_properties(&mut actual, &placement).is_err()); + assert_eq!((actual.volume, actual.area, actual.centroid), (measured.volume, measured.area, measured.centroid)); + } +} + +#[test] +fn perforated_sheet_body_transfer_preserves_world_mass_and_centroid() { + let mut s = Session::default(); + perforated_panel(&mut s); + let moved = run(&mut s, "component.create", json!({"name": "MovedSheet", "grounded": false})); + run(&mut s, "occurrence.move", json!({"occurrence": moved["occurrence"], "translate": [100, 0, 0]})); + run(&mut s, "component.move_bodies", json!({"bodies": ["Panel"], "component": moved["component"]})); + let (volume, _, center) = perforated_panel_expected(); + let mass = volume * s.doc.density("Panel") / 1000.0; + for command in ["component.properties", "inspect.measure"] { + let result = run(&mut s, command, json!({"component": "root"})); + close(&result["total"]["volume_mm3"], volume); + close(&result["total"]["mass_g"], mass); + for (axis, expected) in center.iter().enumerate() { + close(&result["bodies"][0]["center_of_mass"][axis], *expected); + } + } +} + +#[test] +fn perforated_sheet_inertia_removes_analytic_hole_cylinders_and_turns_with_the_sheet() { + let mut s = Session::default(); + let c = run(&mut s, "component.create", json!({"name": "Sheet", "grounded": false})); + perforated_panel(&mut s); + let (volume, _, center) = perforated_panel_expected(); + let old_center = [10.0, 5.0, 0.4]; + let mut expected = [[0.0; 3]; 3]; + let dimensions: [f64; 3] = [20.0, 10.0, 0.8]; + for i in 0..3 { + expected[i][i] = 160.0 * (dimensions[(i + 1) % 3].powi(2) + dimensions[(i + 2) % 3].powi(2)) / 12.0; + } + let hole_volume = std::f64::consts::PI * 0.8; + let own = [hole_volume * (3.0 + 0.64) / 12.0, hole_volume * (3.0 + 0.64) / 12.0, hole_volume / 2.0]; + for hole in [[2.0, 2.0, 0.4], [12.0, 2.0, 0.4]] { + let d = [0, 1, 2].map(|i| hole[i] - old_center[i]); + let d2: f64 = d.iter().map(|v| v * v).sum(); + for i in 0..3 { + for j in 0..3 { + expected[i][j] -= if i == j { own[i] + hole_volume * d2 } else { 0.0 } - hole_volume * d[i] * d[j]; + } + } + } + let d = [0, 1, 2].map(|i| center[i] - old_center[i]); + let d2: f64 = d.iter().map(|v| v * v).sum(); + for i in 0..3 { + for j in 0..3 { + expected[i][j] = (expected[i][j] - volume * (if i == j { d2 } else { 0.0 } - d[i] * d[j])) * s.doc.density("Panel") / 1000.0; + } + } + let first = run(&mut s, "component.properties", json!({})); + tensor_close(&first["total"]["inertia_g_mm2"], expected, 1e-9); + let verify_assembly = |s: &mut Session, tensor: [[f64; 3]; 3], center: [f64; 3]| { + let assembly = run(s, "assembly.mass_properties", json!({})); + let occurrence = assembly["occurrences"].as_array().unwrap().iter().find(|o| o["occurrence"] == c["occurrence"]).unwrap(); + let mass = &occurrence["mass"]; + assert!((mass["mass_kg"].as_f64().unwrap() - volume * s.doc.density("Panel") * 1e-6).abs() < 1e-12); + for (axis, coordinate) in center.iter().enumerate() { + close(&mass["center_of_mass_mm"][axis], *coordinate); + } + tensor_close(&mass["inertia_world_kg_mm2"], tensor.map(|row| row.map(|value| value / 1000.0)), 1e-9); + }; + verify_assembly(&mut s, expected, center); + run( + &mut s, + "occurrence.move", + json!({"occurrence": c["occurrence"], "translate": [100, 40, 10], "axis": [0, 0, 1], "angle": "90 deg", "capture": false}), + ); + let turned = run(&mut s, "component.properties", json!({})); + let rotation = [[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]; + let rotated = solidcraft_geom::inertia::transformed(&expected, &rotation); + tensor_close(&turned["total"]["inertia_g_mm2"], rotated, 1e-9); + verify_assembly(&mut s, rotated, [100.0 - center[1], 40.0 + center[0], 10.0 + center[2]]); +} + #[test] fn properties_reject_hostile_identifiers_and_options() { let mut s = Session::default(); diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs index 7a1427012..5db90bd69 100644 --- a/crates/engine/src/cmd/inspect.rs +++ b/crates/engine/src/cmd/inspect.rs @@ -128,7 +128,30 @@ pub(crate) fn encloses_volume(body: &solidcraft_kernel::Body) -> bool { } pub fn measure_json(b: &solidcraft_doc::ModelBody) -> Value { - match b.measure() { + measure_sheet_json(b, None) +} + +pub(super) fn measure_body( + b: &solidcraft_doc::ModelBody, + definitions: Option<&solidcraft_doc::ModelState>, +) -> Result { + let mut measured = b.measure()?; + if let Some(state) = definitions + && let Some(sheet) = state.sheets.iter().find(|sheet| sheet.body == b.definition_name() && !sheet.perforations.is_empty()) + { + let definition = state.body(b.definition_name()).ok_or_else(|| EngineError::Other(format!("missing sheet body `{}`", sheet.body)))?; + // A body transfer moves the geometry and sheet metadata together. Apply only + // the placement relative to the current definition, so holes move once. + let inverse = solidcraft_doc::mat_inverse(&definition.source_transform) + .ok_or_else(|| EngineError::Other(format!("invalid sheet placement for `{}`", sheet.body)))?; + let placement = solidcraft_doc::mat_mul(&b.source_transform, &inverse); + sheet.correct_perforation_properties(&mut measured, &placement)?; + } + Ok(measured) +} + +fn measure_sheet_json(b: &solidcraft_doc::ModelBody, definitions: Option<&solidcraft_doc::ModelState>) -> Value { + match measure_body(b, definitions) { Ok(m) => { let closed = encloses_volume(&b.body); json!({ @@ -157,6 +180,7 @@ fn measure(s: &mut Session, p: &Value) -> Result { return super::measure_sel::measure_items(s, items); } let want = string_list(cmd, p, "bodies")?; + let definitions = s.model.state(); let st = s.world_state()?; let selected: Vec<_> = st.bodies.iter().filter(|b| want.is_empty() || want.contains(&b.name)).collect(); if !want.is_empty() && selected.len() != want.len() { @@ -167,7 +191,7 @@ fn measure(s: &mut Session, p: &Value) -> Result { return Ok(json!({"body_count": bodies.len(), "bodies": bodies})); } // Each body is measured on its own: on all cores, in body order. - let mut bodies: Vec = solidcraft_kernel::map_on_threads(&selected, 16, |b| measure_json(b)) + let mut bodies: Vec = solidcraft_kernel::map_on_threads(&selected, 16, |b| measure_sheet_json(b, Some(&definitions))) .into_iter() .zip(&selected) .map(|(m, b)| m.unwrap_or_else(|| json!({"name": b.name, "error": "measuring this body failed"}))) @@ -182,35 +206,13 @@ fn measure(s: &mut Session, p: &Value) -> Result { b["density_g_cm3"] = json!(rho); b["mass_g"] = json!(v * rho / 1000.0); } - } - // Sheet metal keeps the edges where bends meet flat faces (so bends stay visible): count its - // B-rep faces as they are, without merging coplanar neighbours. - let sheets = s.model.state().sheets.clone(); - for b in &mut bodies { - if let Some(sh) = sheets.iter().find(|x| b["name"].as_str() == Some(x.body.as_str())) { - let (df, de, dv) = sh.round_hole_correction(); - for (k, d) in [("faces", df), ("edges", de), ("vertices", dv)] { - b[k] = json!(b["kernel"][k].as_i64().unwrap_or(0) + d); + // Only Measure exposes sheet boundary counts; document.inspect keeps kernel counts. + if let Some(sheet) = definitions.sheets.iter().find(|sheet| sheet.body == source) { + let (df, de, dv) = sheet.round_hole_correction(); + for (key, delta) in [("faces", df), ("edges", de), ("vertices", dv)] { + b[key] = json!(b["kernel"][key].as_i64().unwrap_or(0) + delta); } b["sheet_metal"] = json!(true); - // A perforation field (#732) is not cut into the B-rep: take its open area out of the volume, the mass - // and the area (both faces minus the holes, plus the bores). - let open = sh.perforated_area(); - if open > 0.0 { - if let Some(v) = b["volume_mm3"].as_f64() { - let nv = v - open * sh.t; - if let Some(m) = b["mass_g"].as_f64().filter(|_| v > 0.0) { - b["mass_g"] = json!(m * nv / v); - } - b["volume_mm3"] = json!(nv); - } - let bores: f64 = sh - .perforations - .iter() - .map(|p| sh.perforation_holes(p).map_or(0.0, |h| h.len() as f64) * std::f64::consts::PI * p.diameter * sh.t) - .sum(); - b["area_mm2"] = json!(b["area_mm2"].as_f64().unwrap_or(0.0) - 2.0 * open + bores); - } } } let skipped = bodies.iter().filter(|b| b["closed"] == false).count(); @@ -395,9 +397,12 @@ fn inspect(s: &mut Session, p: &Value) -> Result { }) }) .collect(); + let definitions = s.model.state(); let with_measure = bool_(p, "measure").unwrap_or(false); // Each body is measured on its own: on all cores, in body order (as `inspect.measure`). - let mut measured = if with_measure { solidcraft_kernel::map_on_threads(&st.bodies, 16, measure_json) } else { Vec::new() }.into_iter(); + let mut measured = + if with_measure { solidcraft_kernel::map_on_threads(&st.bodies, 16, |b| measure_sheet_json(b, Some(&definitions))) } else { Vec::new() } + .into_iter(); let bodies: Vec = st .bodies .iter() diff --git a/crates/engine/src/cmd/mass_properties.rs b/crates/engine/src/cmd/mass_properties.rs index fc76e680f..f1fe212d2 100644 --- a/crates/engine/src/cmd/mass_properties.rs +++ b/crates/engine/src/cmd/mass_properties.rs @@ -242,9 +242,20 @@ pub fn assembly(doc: &Document, state: &ModelState) -> Result = BTreeMap::new(); for (i, s) in measured.into_iter().zip(shapes) { diff --git a/crates/engine/src/cmd/measure_sel.rs b/crates/engine/src/cmd/measure_sel.rs index 8a75cbb19..a51dba48f 100644 --- a/crates/engine/src/cmd/measure_sel.rs +++ b/crates/engine/src/cmd/measure_sel.rs @@ -380,7 +380,12 @@ fn describe(s: &Session, st: &solidcraft_doc::ModelState, sel: &Sel) -> Option = m.triangles.iter().filter_map(|t| m.tri(t)).collect(); - let v = m.measure().volume; + let definitions = s.model.state(); + let v = if definitions.sheets.iter().any(|sheet| sheet.body == body.definition_name() && !sheet.perforations.is_empty()) { + super::inspect::measure_body(body, Some(&definitions)).ok()?.volume + } else { + m.measure().volume + }; plain(Geo::Tris(tris), None, json!({"type": "body", "name": name, "closed": closed, "volume_mm3": closed.then_some(v)})) } Sel::SketchCurve { id, sketch } => sketch_curve(sketch_of(s, st, *sketch, |sk| sk.curve_index(id).is_some())?, id), diff --git a/docs/assembly-properties.md b/docs/assembly-properties.md index 79d9f574e..76e93b86c 100644 --- a/docs/assembly-properties.md +++ b/docs/assembly-properties.md @@ -40,6 +40,16 @@ null center of mass and bounding box. A failed body measurement returns an error presenting an incomplete assembly total. These commands leave geometry, pending placements and undo history unchanged. +Sheet-metal perforation fields contribute their physical holes to volume, mass, surface area +and center of mass even though they do not cut the B-rep. Hole centers follow the panels when +folded or unfolded and follow each occurrence's placement. Measure and component/occurrence +Properties use the same correction. Bounding boxes and B-rep topology still describe the +uncut body. A failed perforation calculation returns an error rather than an uncorrected total. +The inertia tensor also removes each analytic hole cylinder, including its offset from the +sheet's center of mass. +Measuring a perforated sheet after scaling or shearing its metadata is not supported and +returns an error. Rigid and mirrored placements preserve the analytic hole dimensions. + ## Moment of inertia Each closed body's entry has `inertia_g_mm2`: its inertia tensor about its own center of mass,