Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Measure: centre-to-centre for holes, diameters for circles and arcs, slot sizes (#1392) (#1419)

bherbruck1744fbb2628d
diff --git a/assets/locales/de.json b/assets/locales/de.json
index 5fd806e170..8f3cb0e8da 100644
--- a/assets/locales/de.json
+++ b/assets/locales/de.json
@@ -906,5 +906,14 @@
"Type": "Typ",
"joint.one_component": "Diese Teile sind Körper einer Komponente: {bodies}. Ein Gelenk bewegt eine Komponente gegenüber einer anderen, daher braucht jedes Teil eine eigene Komponente.",
"joint.one_body": "Beide Auswahlen liegen auf {body}. Wählen Sie die zweite auf einem anderen Teil.",
- "joint.from_bodies_hint": "Jeder ausgewählte Körper kommt in eine eigene neue Komponente und bleibt, wo er ist."
+ "joint.from_bodies_hint": "Jeder ausgewählte Körper kommt in eine eigene neue Komponente und bleibt, wo er ist.",
+ "Circumference": "Umfang",
+ "Arc length": "Bogenlänge",
+ "Slot width": "Langlochbreite",
+ "Centre to centre": "Mitte zu Mitte",
+ "Overall length": "Gesamtlänge",
+ "Min": "Min",
+ "Max": "Max",
+ "Length": "Länge",
+ "Area": "Fläche"
}
diff --git a/assets/locales/en.json b/assets/locales/en.json
index a04d8c93ee..6cce438812 100644
--- a/assets/locales/en.json
+++ b/assets/locales/en.json
@@ -1163,5 +1163,12 @@
"Round": "Round",
"joint.one_component": "These parts are bodies of one component: {bodies}. A joint moves one component against another, so each part needs a component of its own.",
"joint.one_body": "Both picks are on {body}. Pick the second one on another part.",
- "joint.from_bodies_hint": "Each picked body moves into a new component of its own and stays where it is."
+ "joint.from_bodies_hint": "Each picked body moves into a new component of its own and stays where it is.",
+ "Circumference": "Circumference",
+ "Arc length": "Arc length",
+ "Slot width": "Slot width",
+ "Centre to centre": "Centre to centre",
+ "Overall length": "Overall length",
+ "Min": "Min",
+ "Max": "Max"
}
diff --git a/assets/locales/ja.json b/assets/locales/ja.json
index 901c485da1..5c17756f97 100644
--- a/assets/locales/ja.json
+++ b/assets/locales/ja.json
@@ -1163,5 +1163,12 @@
"Round": "丸め",
"joint.one_component": "これらの部品は 1 つのコンポーネントのボディです: {bodies}。ジョイントはコンポーネント同士を動かすため、部品ごとに専用のコンポーネントが必要です。",
"joint.one_body": "両方の選択が {body} 上にあります。2 つ目は別の部品で選択してください。",
- "joint.from_bodies_hint": "選択した各ボディを、位置はそのままで専用の新しいコンポーネントに移動します。"
+ "joint.from_bodies_hint": "選択した各ボディを、位置はそのままで専用の新しいコンポーネントに移動します。",
+ "Circumference": "円周",
+ "Arc length": "円弧の長さ",
+ "Slot width": "長穴の幅",
+ "Centre to centre": "中心間",
+ "Overall length": "全長",
+ "Min": "最小",
+ "Max": "最大"
}
diff --git a/assets/locales/ko.json b/assets/locales/ko.json
index 15f3f1cc09..02c70ea7f9 100644
--- a/assets/locales/ko.json
+++ b/assets/locales/ko.json
@@ -906,5 +906,14 @@
"Type": "유형",
"joint.one_component": "이 부품들은 한 구성 요소의 바디입니다: {bodies}. 관절은 한 구성 요소를 다른 구성 요소에 대해 움직이므로 부품마다 자체 구성 요소가 필요합니다.",
"joint.one_body": "두 선택이 모두 {body}에 있습니다. 두 번째는 다른 부품에서 선택하세요.",
- "joint.from_bodies_hint": "선택한 각 바디가 제자리에 그대로 있으면서 자체의 새 구성 요소로 옮겨집니다."
+ "joint.from_bodies_hint": "선택한 각 바디가 제자리에 그대로 있으면서 자체의 새 구성 요소로 옮겨집니다.",
+ "Circumference": "원주",
+ "Arc length": "호 길이",
+ "Slot width": "슬롯 폭",
+ "Centre to centre": "중심 간",
+ "Overall length": "전체 길이",
+ "Min": "최소",
+ "Max": "최대",
+ "Length": "길이",
+ "Area": "면적"
}
diff --git a/assets/locales/zh.json b/assets/locales/zh.json
index bb32bcc78a..c52b52316c 100644
--- a/assets/locales/zh.json
+++ b/assets/locales/zh.json
@@ -1163,5 +1163,12 @@
"Round": "圆角",
"joint.one_component": "这些零件是同一组件的实体:{bodies}。接头使一个组件相对另一个组件运动,因此每个零件都需要自己的组件。",
"joint.one_body": "两次选择都在 {body} 上。请在另一个零件上选择第二个。",
- "joint.from_bodies_hint": "每个所选实体移入各自的新组件,位置保持不变。"
+ "joint.from_bodies_hint": "每个所选实体移入各自的新组件,位置保持不变。",
+ "Circumference": "周长",
+ "Arc length": "弧长",
+ "Slot width": "槽宽",
+ "Centre to centre": "中心距",
+ "Overall length": "总长",
+ "Min": "最小",
+ "Max": "最大"
}
diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index b294984582..410c6c4360 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -13,7 +13,7 @@ pub static COMMANDS: &[CommandSpec] = &[
.icon("measure")
.key("I")
.noundo()
- .params("bodies?: [names] (default all); or items: [1-2 selections] → length/area/volume, minimum distance (from, to) and angle"),
+ .params("bodies?: [names] (default all); or items: [1-2 selections] → length/area/volume; diameter, radius, circumference or arc_length/angle_deg of circles, arcs and cylinders; slot sizes; min (distance_mm, from, to), max, center_distance (centre to centre, or from an axis) and angle"),
CommandSpec::new("document.inspect", "Inspect Design", inspect).noundo().params("measure?: bool (include body measurements)"),
CommandSpec::new("sketch.inspect", "Inspect Sketch", sketch_inspect).noundo().params("sketch?: id|name (default active)"),
CommandSpec::new("model.edges", "List Edges", model_edges).noundo().params("body: name"),
diff --git a/crates/engine/src/cmd/measure_sel.rs b/crates/engine/src/cmd/measure_sel.rs
index 4ad82745d1..18da943c97 100644
--- a/crates/engine/src/cmd/measure_sel.rs
+++ b/crates/engine/src/cmd/measure_sel.rs
@@ -1,10 +1,13 @@
//! Measuring picked geometry (`inspect.measure` with `items`): one item gives its length, area,
-//! volume or position; two give the minimum distance between them (with the two closest
-//! points) and, where both have a direction (planar faces, straight edges), the angle.
+//! volume or position, and a round one (circle, arc, cylinder) its diameter and radius, a slot
+//! its sizes; two give the minimum and maximum distance between them (with their points), the
+//! distance from a round item's centre or axis (see [`super::measure_shape`]) and, where both
+//! have a direction (planar faces, straight edges), the angle.
use serde_json::{Value, json};
use solidcraft_geom::{Mesh, Vec3};
+use super::measure_shape::{Shape, Slot, add_round, centre};
use crate::params::bad;
use crate::{Result, Sel, Session};
@@ -68,13 +71,214 @@ fn face_tris(m: &Mesh, f: usize) -> Vec<[Vec3; 3]> {
m.triangles.iter().zip(&m.tri_face).filter(|(_, tf)| **tf as usize == f).filter_map(|(t, _)| m.tri(t)).collect()
}
-/// Geometry, direction (planar face normal, straight edge direction) and a description.
-fn describe(s: &Session, sel: &Sel) -> Option<(Geo, Option<Vec3>, Value)> {
+/// A described item: its geometry, direction (planar face normal, straight edge direction),
+/// description and exact shape.
+struct Item {
+ geo: Geo,
+ dir: Option<Vec3>,
+ json: Value,
+ shape: Shape,
+ /// A slot this item is one end of (or the outline of).
+ slot: Option<Slot>,
+}
+
+/// The circle through a polyline's points (all on one within `tol`): a fallback for edges the
+/// kernel can't name (mesh bodies).
+fn fit_circle(pts: &[Vec3], tol: f64) -> Option<(Vec3, Vec3, f64)> {
+ let n = pts.len().checked_sub(1)?;
+ let (a, b, c) = (*pts.first()?, *pts.get(n / 3)?, *pts.get(2 * n / 3)?);
+ let (u, v) = (b - a, c - a);
+ let w = u.cross(v);
+ if !(w.len2() > u.len2() * v.len2() * 1e-16) {
+ return None;
+ }
+ let center = a + (v * u.len2() - u * v.len2()).cross(w) * (1.0 / (2.0 * w.len2()));
+ let axis = w.normalized()?;
+ let radius = center.dist(a);
+ let on = pts.iter().all(|p| (p.dist(center) - radius).abs() <= tol && (*p - center).dot(axis).abs() <= tol);
+ (on && radius.is_finite()).then_some((center, axis, radius))
+}
+
+/// The round shape of mesh edge `index` of body `b`: from the kernel's exact curve when it
+/// is the same edge (its ends on the polyline), else fitted to the polyline's points.
+fn edge_round(b: &solidcraft_doc::ModelBody, m: &Mesh, index: usize, whole: bool) -> Option<Shape> {
+ let pts = m.edges.get(index)?;
+ let tol = (m.bounds().diagonal().max(1.0) * 1e-6).max(1e-9);
+ let exact = solidcraft_kernel::edge_circle(&b.body, index).filter(|c| {
+ let ends = [pts.first(), pts.last()].into_iter().flatten().all(|p| p.dist(c.start).min(p.dist(c.end)) <= tol * 10.0);
+ let on = pts.iter().all(|p| (p.dist(c.center) - c.radius).abs() <= tol * 10.0);
+ ends && on
+ });
+ let (center, axis, radius, angle) = match exact {
+ Some(c) => (c.center, c.axis, c.radius, if whole { std::f64::consts::TAU } else { c.angle }),
+ None => {
+ let all: Vec<Vec3> =
+ if whole { m.circular_rim(index).iter().filter_map(|&i| m.edges.get(i)).flatten().copied().collect() } else { pts.clone() };
+ let (center, axis, radius) = fit_circle(&all, tol * 10.0)?;
+ let angle = if whole { std::f64::consts::TAU } else { polyline_len(pts) / radius };
+ (center, axis, radius, angle)
+ }
+ };
+ Some(Shape::Round { center, axis, radius, angle, planar: true, lo: 0.0, hi: 0.0 })
+}
+
+/// Points along a circle or arc (`angle` from `start` about `axis`).
+fn arc_points(center: Vec3, axis: Vec3, start: Vec3, angle: f64) -> Vec<Vec3> {
+ let x = start - center;
+ let y = axis.cross(x);
+ let n = 128;
+ (0..=n)
+ .map(|i| {
+ let t = angle * f64::from(i) / f64::from(n);
+ center + x * t.cos() + y * t.sin()
+ })
+ .collect()
+}
+
+/// The solved sketch holding a picked curve or point: `sketch` when given, else the active
+/// sketch, else the last sketch with that id.
+fn sketch_of<'a>(
+ s: &Session,
+ st: &'a solidcraft_doc::ModelState,
+ sketch: Option<u64>,
+ has: impl Fn(&solidcraft_sketch::Sketch) -> bool,
+) -> Option<&'a solidcraft_doc::SolvedSketch> {
+ if let Some(id) = sketch {
+ return st.sketch(id);
+ }
+ if let Some(ss) = s.active_sketch.and_then(|id| st.sketch(id)).filter(|ss| has(&ss.sketch)) {
+ return Some(ss);
+ }
+ st.sketches.iter().rev().map(|ss| &**ss).find(|ss| has(&ss.sketch))
+}
+
+fn sketch_curve(ss: &solidcraft_doc::SolvedSketch, id: &str) -> Option<Item> {
+ use solidcraft_sketch::CurveKind;
+ let sk = &ss.sketch;
+ let c = sk.curves.get(sk.curve_index(id)?)?;
+ let at = |i: usize| sk.points.get(i).map(|p| ss.plane.to_world(p.pos));
+ let normal = ss.plane.normal();
+ let (shape, pts) = match c.kind {
+ CurveKind::Circle { c, r } => {
+ let center = at(c)?;
+ let shape = Shape::Round { center, axis: normal, radius: r, angle: std::f64::consts::TAU, planar: true, lo: 0.0, hi: 0.0 };
+ (shape, arc_points(center, normal, center + ss.plane.x * r, std::f64::consts::TAU))
+ }
+ CurveKind::Arc { c, a, b } => {
+ let (center, a, b) = (at(c)?, at(a)?, at(b)?);
+ let radius = center.dist(a);
+ let (x, y) = ((a - center).normalized()?, normal.cross((a - center).normalized()?));
+ let mut angle = (b - center).dot(y).atan2((b - center).dot(x));
+ if angle <= 0.0 {
+ angle += std::f64::consts::TAU;
+ }
+ let shape = Shape::Round { center, axis: normal, radius, angle, planar: true, lo: 0.0, hi: 0.0 };
+ (shape, arc_points(center, normal, a, angle))
+ }
+ CurveKind::Line { a, b } => {
+ let (a, b) = (at(a)?, at(b)?);
+ (Shape::Line { a, b }, densify(&[a, b]))
+ }
+ _ => return None,
+ };
+ let mut json = json!({"type": "sketch_curve", "id": id});
+ let dir = match shape {
+ Shape::Line { a, b } => {
+ json["length_mm"] = json!(a.dist(b));
+ (b - a).normalized()
+ }
+ _ => {
+ json["length_mm"] = json!(polyline_len(&pts));
+ add_round(&mut json, &shape);
+ None
+ }
+ };
+ Some(Item { geo: Geo::Points(pts), dir, json, shape, slot: None })
+}
+
+/// A profile (closed region of a sketch): its area, and when it is a circle or a slot, its
+/// sizes.
+fn profile(ss: &solidcraft_doc::SolvedSketch, index: usize) -> Option<Item> {
+ use solidcraft_geom::{Seg2, Vec2};
+ let pr = ss.profiles.get(index)?;
+ let outline: Vec<Vec3> = pr.region.outer.polyline(1e-3).iter().map(|p| ss.plane.to_world(*p)).collect();
+ let mut json = json!({"type": "profile", "area_mm2": pr.region.area()});
+ let normal = ss.plane.normal();
+ // Arcs about one centre merge (a circle is two halves); straight pieces stay as they are.
+ let mut arcs: Vec<(Vec2, f64, f64)> = Vec::new();
+ let mut lines: Vec<(Vec2, Vec2)> = Vec::new();
+ let mut other = !pr.region.holes.is_empty();
+ for seg in &pr.region.outer.segs {
+ match *seg {
+ Seg2::Arc { center, radius, sweep, .. } => {
+ match arcs.iter_mut().find(|(c, r, _)| c.dist(center) <= 1e-6 * (1.0 + radius) && (r - radius).abs() <= 1e-6 * (1.0 + radius)) {
+ Some(a) => a.2 += sweep,
+ None => arcs.push((center, radius, sweep)),
+ }
+ }
+ Seg2::Line { a, b } => lines.push((a, b)),
+ _ => other = true,
+ }
+ }
+ let mut shape = Shape::Other;
+ let mut slot = None;
+ if !other {
+ if let ([(c, r, sweep)], []) = (arcs.as_slice(), lines.as_slice())
+ && (sweep.abs() - std::f64::consts::TAU).abs() < 1e-6
+ {
+ shape = Shape::Round {
+ center: ss.plane.to_world(*c),
+ axis: normal,
+ radius: *r,
+ angle: std::f64::consts::TAU,
+ planar: true,
+ lo: 0.0,
+ hi: 0.0,
+ };
+ add_round(&mut json, &shape);
+ } else if let Some((a, b, r)) = super::measure_shape::slot_outline(&arcs, &lines) {
+ let s = Slot { width: 2.0 * r, centres: (ss.plane.to_world(a), ss.plane.to_world(b)) };
+ json["slot"] = s.json();
+ slot = Some(s);
+ }
+ }
+ let planar = Some(normal);
+ let geo = Geo::Points(densify(&outline));
+ let shape = if matches!(shape, Shape::Other) { Shape::Plane { point: ss.plane.origin, normal } } else { shape };
+ Some(Item { geo, dir: planar, json, shape, slot })
+}
+
+/// A slot this cylindrical face is one end of, from the body's other faces.
+fn face_slot(b: &solidcraft_doc::ModelBody, m: &Mesh, shape: &Shape, pts: &[Vec3]) -> Option<Slot> {
+ let faces = m.tri_face.iter().map(|f| *f as usize + 1).max().unwrap_or(0);
+ if faces > 4000 {
+ return None;
+ }
+ let mut verts: Vec<Vec<Vec3>> = vec![Vec::new(); faces];
+ for (t, f) in m.triangles.iter().zip(&m.tri_face) {
+ if let (Some(v), Some(tri)) = (verts.get_mut(*f as usize), m.tri(t)) {
+ v.extend(tri);
+ }
+ }
+ let surfaces: Vec<(solidcraft_kernel::FaceSurface, Vec<Vec3>)> =
+ verts.into_iter().enumerate().filter_map(|(i, v)| Some((solidcraft_kernel::face_surface(&b.body, i)?, v))).collect();
+ super::measure_shape::slot_from_faces(shape, pts, &surfaces)
+}
+
+fn describe(s: &Session, sel: &Sel) -> Option<Item> {
let st = s.world_state();
- Some(match sel {
- Sel::Vertex { point, .. } => (Geo::Points(vec![*point]), None, json!({"type": "vertex", "position": point})),
+ let plain = |geo, dir, json| Some(Item { geo, dir, json, shape: Shape::Other, slot: None });
+ match sel {
+ Sel::Vertex { point, .. } => Some(Item {
+ geo: Geo::Points(vec![*point]),
+ dir: None,
+ json: json!({"type": "vertex", "position": point}),
+ shape: Shape::Point(*point),
+ slot: None,
+ }),
Sel::Edge { body, index, point } => {
- let m = st.body(body)?.mesh();
+ let b = st.body(body)?;
+ let m = b.mesh();
let index = edge_index(&m, *index, *point)?;
let pts = m.edges.get(index)?;
let rim = m.circular_rim(index);
@@ -82,29 +286,81 @@ fn describe(s: &Session, sel: &Sel) -> Option<(Geo, Option<Vec3>, Value)> {
let pieces: Vec<&Vec<Vec3>> = rim.iter().filter_map(|&i| m.edges.get(i)).collect();
let len: f64 = pieces.iter().map(|p| polyline_len(p)).sum();
let points = pieces.iter().flat_map(|p| densify(p)).collect();
- return Some((Geo::Points(points), None, json!({"type": "edge", "length_mm": len})));
+ let mut json = json!({"type": "edge", "length_mm": len});
+ let shape = edge_round(b, &m, index, true).unwrap_or(Shape::Other);
+ add_round(&mut json, &shape);
+ return Some(Item { geo: Geo::Points(points), dir: None, json, shape, slot: None });
}
- let (a, b) = (*pts.first()?, *pts.last()?);
- let straight = (b - a).normalized().filter(|d| pts.iter().all(|p| (*p - a).cross(*d).len() < 1e-6 * (1.0 + a.dist(b))));
+ let (a, z) = (*pts.first()?, *pts.last()?);
+ let straight = (z - a).normalized().filter(|d| pts.iter().all(|p| (*p - a).cross(*d).len() < 1e-6 * (1.0 + a.dist(z))));
let len = polyline_len(pts);
- (Geo::Points(densify(pts)), straight, json!({"type": "edge", "length_mm": len}))
+ let mut json = json!({"type": "edge", "length_mm": len});
+ let shape = match straight {
+ Some(_) => Shape::Line { a, b: z },
+ None => edge_round(b, &m, index, false).unwrap_or(Shape::Other),
+ };
+ add_round(&mut json, &shape);
+ Some(Item { geo: Geo::Points(densify(pts)), dir: straight, json, shape, slot: None })
}
Sel::Face { body, index, .. } => {
- let m = st.body(body)?.mesh();
- let tris = m.surface_patch(*index).into_iter().flat_map(|f| face_tris(&m, f)).collect::<Vec<_>>();
+ let b = st.body(body)?;
+ let m = b.mesh();
+ let patch = m.surface_patch(*index);
+ let tris = patch.iter().flat_map(|f| face_tris(&m, *f)).collect::<Vec<_>>();
let area: f64 = tris.iter().map(|[a, b, c]| (*b - *a).cross(*c - *a).len() * 0.5).sum();
let normals: Vec<Vec3> = tris.iter().filter_map(|[a, b, c]| (*b - *a).cross(*c - *a).normalized()).collect();
let planar = normals.first().copied().filter(|n0| normals.iter().all(|n| n.dot(*n0) > 1.0 - 1e-6));
- (Geo::Tris(tris), planar, json!({"type": "face", "area_mm2": area, "planar": planar.is_some()}))
+ let mut json = json!({"type": "face", "area_mm2": area, "planar": planar.is_some()});
+ let verts: Vec<Vec3> = tris.iter().flat_map(|t| t.iter().copied()).collect();
+ let shape = match solidcraft_kernel::face_surface(&b.body, *index) {
+ Some(solidcraft_kernel::FaceSurface::Cylinder { origin, axis, radius }) => {
+ super::measure_shape::cylinder(origin, axis, radius, &verts).unwrap_or(Shape::Other)
+ }
+ Some(solidcraft_kernel::FaceSurface::Plane { normal, point }) if planar.is_some() => Shape::Plane { point, normal },
+ None => match (planar, verts.first()) {
+ (Some(normal), Some(point)) => Shape::Plane { point: *point, normal },
+ _ => Shape::Other,
+ },
+ _ => Shape::Other,
+ };
+ add_round(&mut json, &shape);
+ let slot = if matches!(shape, Shape::Round { .. }) && !shape.full() { face_slot(b, &m, &shape, &verts) } else { None };
+ if let Some(sl) = &slot {
+ json["slot"] = sl.json();
+ }
+ Some(Item { geo: Geo::Tris(tris), dir: planar, json, shape, slot })
}
Sel::Body { name } => {
let m = st.body(name)?.mesh();
let tris: Vec<[Vec3; 3]> = m.triangles.iter().filter_map(|t| m.tri(t)).collect();
let v = m.measure().volume;
- (Geo::Tris(tris), None, json!({"type": "body", "name": name, "volume_mm3": v}))
+ plain(Geo::Tris(tris), None, json!({"type": "body", "name": name, "volume_mm3": v}))
}
- _ => return None,
- })
+ Sel::SketchCurve { id } => sketch_curve(sketch_of(s, &st, None, |sk| sk.curve_index(id).is_some())?, id),
+ Sel::ExternalSketchCurve { sketch, id } => sketch_curve(sketch_of(s, &st, Some(*sketch), |_| true)?, id),
+ Sel::SketchPoint { id } | Sel::ExternalSketchPoint { id, .. } => {
+ let given = match sel {
+ Sel::ExternalSketchPoint { sketch, .. } => Some(*sketch),
+ _ => None,
+ };
+ // "<sketch id>:<point id>" names a point of any sketch.
+ let (given, id) = match id.split_once(':').and_then(|(k, p)| Some((k.parse::<u64>().ok()?, p))) {
+ Some((k, p)) if given.is_none() => (Some(k), p),
+ _ => (given, id.as_str()),
+ };
+ let ss = sketch_of(s, &st, given, |sk| sk.point_index(id).is_some())?;
+ let p = ss.plane.to_world(ss.sketch.points.get(ss.sketch.point_index(id)?)?.pos);
+ Some(Item {
+ geo: Geo::Points(vec![p]),
+ dir: None,
+ json: json!({"type": "sketch_point", "id": id, "position": p}),
+ shape: Shape::Point(p),
+ slot: None,
+ })
+ }
+ Sel::Profile { sketch, index } => profile(st.sketch(*sketch)?, *index),
+ _ => None,
+ }
}
fn sample<T: Copy>(v: &[T], max: usize) -> Vec<T> {
@@ -195,22 +451,89 @@ pub(crate) fn measure_items(s: &Session, items: &Value) -> Result<Value> {
}
let mut described = Vec::new();
for x in &sels {
- described.push(describe(s, x).ok_or_else(|| bad(cmd, "an item can't be measured (pick vertices, edges, faces or bodies)"))?);
+ described.push(
+ describe(s, x).ok_or_else(|| bad(cmd, "an item can't be measured (pick vertices, edges, faces, bodies, sketch curves or profiles)"))?,
+ );
}
- let mut out = json!({"items": described.iter().map(|d| d.2.clone()).collect::<Vec<_>>()});
- if let [(ga, da, _), (gb, db, _)] = described.as_slice() {
- if let Some((p, q)) = closest(ga, gb) {
- out["distance_mm"] = json!(p.dist(q));
+ let mut out = json!({"items": described.iter().map(|d| d.json.clone()).collect::<Vec<_>>()});
+ if let [one] = described.as_slice() {
+ for k in ["diameter", "radius", "circumference", "angle_deg", "arc_length", "center", "slot"] {
+ if let Some(v) = one.json.get(k) {
+ out[k] = v.clone();
+ }
+ }
+ if let Some(sl) = &one.slot {
+ out["center_from"] = json!(sl.centres.0);
+ out["center_to"] = json!(sl.centres.1);
+ }
+ }
+ if let [a, b] = described.as_slice() {
+ let near = closest(&a.geo, &b.geo);
+ let far = farthest(&a.geo, &b.geo);
+ let c = centre(&a.shape, &b.shape);
+ // An exact closest or farthest distance stands only where the mesh agrees with it to
+ // within its chord error (a bounded face can end before the exact value's point).
+ let radii = [a.shape, b.shape].iter().map(|x| if let Shape::Round { radius, .. } = x { *radius } else { 0.0 }).sum::<f64>();
+ let slack = radii * 0.05 + 1e-6;
+ let mut min = near.map(|(p, q)| p.dist(q));
+ if let (Some(exact), Some(m)) = (c.and_then(|c| c.min), min)
+ && (m - exact).abs() <= slack
+ {
+ min = Some(exact);
+ }
+ let mut max = far.map(|(p, q)| p.dist(q));
+ if let (Some(exact), Some(m)) = (c.and_then(|c| c.max), max)
+ && (m - exact).abs() <= slack
+ {
+ max = Some(exact);
+ }
+ if let (Some((p, q)), Some(d)) = (near, min) {
+ out["distance_mm"] = json!(d);
out["from"] = json!(p);
out["to"] = json!(q);
out["delta"] = json!(q - p);
+ out["min"] = json!(d);
+ }
+ if let (Some((p, q)), Some(d)) = (far, max) {
+ out["max"] = json!(d);
+ out["max_from"] = json!(p);
+ out["max_to"] = json!(q);
+ out["max_delta"] = json!(q - p);
+ }
+ if let Some(c) = c {
+ out["center_distance"] = json!(c.distance);
+ out["center_from"] = json!(c.from);
+ out["center_to"] = json!(c.to);
+ out["center_delta"] = json!(c.to - c.from);
}
- if let (Some(a), Some(b)) = (da, db) {
+ out["measure"] = json!(if c.is_some() { "center" } else { "min" });
+ if let (Some(da), Some(db)) = (a.dir, b.dir) {
let both_faces = matches!(sels.as_slice(), [Sel::Face { .. }, Sel::Face { .. }]);
- let c = a.dot(*b).clamp(-1.0, 1.0);
- let c = if both_faces { c } else { c.abs() };
- out["angle_deg"] = json!(c.acos().to_degrees());
+ let cos = da.dot(db).clamp(-1.0, 1.0);
+ let cos = if both_faces { cos } else { cos.abs() };
+ out["angle_deg"] = json!(cos.acos().to_degrees());
}
}
Ok(out)
}
+
+/// Farthest pair of points between two pieces of geometry (on their samples and vertices).
+fn farthest(a: &Geo, b: &Geo) -> Option<(Vec3, Vec3)> {
+ let pts = |g: &Geo| -> Vec<Vec3> {
+ match g {
+ Geo::Points(p) => sample(p, 2000),
+ Geo::Tris(t) => sample(&t.iter().flat_map(|t| t.iter().copied()).collect::<Vec<_>>(), 2000),
+ }
+ };
+ let (p, q) = (pts(a), pts(b));
+ let mut best: Option<(f64, Vec3, Vec3)> = None;
+ for x in &p {
+ for y in &q {
+ let d = x.dist(*y);
+ if best.is_none_or(|(bd, _, _)| d > bd) {
+ best = Some((d, *x, *y));
+ }
+ }
+ }
+ best.map(|(_, x, y)| (x, y))
+}
diff --git a/crates/engine/src/cmd/measure_shape.rs b/crates/engine/src/cmd/measure_shape.rs
new file mode 100644
index 0000000000..507d57a3a5
--- /dev/null
+++ b/crates/engine/src/cmd/measure_shape.rs
@@ -0,0 +1,385 @@
+//! What a picked item is, exactly (#1392): circles, arcs and cylinders (round items with an
+//! axis), planes, straight lines and points, from the B-rep's exact curves and surfaces or the
+//! sketch's own geometry. Round items report their diameter and radius, and a pair with a
+//! round item measures from its centre or axis, with the closest and farthest distances too.
+
+use serde_json::{Value, json};
+use solidcraft_geom::Vec3;
+
+use std::f64::consts::{PI, TAU};
+
+/// The exact shape of a picked item.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum Shape {
+ /// A circle, an arc or a cylinder. `center` lies on the axis: a circle's or arc's centre,
+ /// or for a cylinder the point of the axis level with the middle of the face. `lo..hi` is
+ /// the extent along `axis` from `center` (0..0 for a planar circle). `angle` is the span
+ /// around the axis (2π all the way round).
+ Round {
+ center: Vec3,
+ axis: Vec3,
+ radius: f64,
+ angle: f64,
+ planar: bool,
+ lo: f64,
+ hi: f64,
+ },
+ Plane {
+ point: Vec3,
+ normal: Vec3,
+ },
+ Line {
+ a: Vec3,
+ b: Vec3,
+ },
+ Point(Vec3),
+ Other,
+}
+
+/// Within this of a whole turn counts as all the way round (a tessellated face's coverage).
+const FULL_TURN: f64 = TAU - 1e-3;
+
+impl Shape {
+ pub(crate) fn full(&self) -> bool {
+ matches!(self, Shape::Round { angle, .. } if *angle >= FULL_TURN)
+ }
+}
+
+/// Diameter, radius and length (circumference or arc length, with the arc's angle) of a round
+/// item, added to its description. Ø first, then R, then the length.
+pub(crate) fn add_round(v: &mut Value, shape: &Shape) {
+ let Shape::Round { center, axis, radius, angle, planar, .. } = *shape else { return };
+ v["diameter"] = json!(2.0 * radius);
+ v["radius"] = json!(radius);
+ if angle >= FULL_TURN {
+ v["circumference"] = json!(TAU * radius);
+ } else {
+ v["angle_deg"] = json!(angle.to_degrees());
+ v["arc_length"] = json!(radius * angle);
+ }
+ v["center"] = json!(center);
+ v["axis"] = json!(axis);
+ v["round"] = json!(if !planar {
+ "cylinder"
+ } else if angle >= FULL_TURN {
+ "circle"
+ } else {
+ "arc"
+ });
+}
+
+/// Cylinder `axis` through `origin` of radius `radius` over the points of its face: the
+/// round shape, centred level with the middle of the face, with its extent and coverage.
+pub(crate) fn cylinder(origin: Vec3, axis: Vec3, radius: f64, pts: &[Vec3]) -> Option<Shape> {
+ let axis = axis.normalized()?;
+ if pts.is_empty() || !(radius.is_finite() && radius > 0.0) {
+ return None;
+ }
+ let ts: Vec<f64> = pts.iter().map(|p| (*p - origin).dot(axis)).collect();
+ let (tmin, tmax) = ts.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), t| (a.min(*t), b.max(*t)));
+ let mid = (tmin + tmax) * 0.5;
+ let center = origin + axis * mid;
+ Some(Shape::Round { center, axis, radius, angle: coverage(center, axis, pts), planar: false, lo: tmin - mid, hi: tmax - mid })
+}
+
+/// The angle around the axis the points cover: a whole turn less the widest gap between them.
+pub(crate) fn coverage(center: Vec3, axis: Vec3, pts: &[Vec3]) -> f64 {
+ let x = axis.any_perp();
+ let y = axis.cross(x);
+ let mut angles: Vec<f64> = pts
+ .iter()
+ .filter_map(|p| {
+ let d = *p - center;
+ let r = d - axis * d.dot(axis);
+ (r.len() > 1e-12).then(|| r.dot(y).atan2(r.dot(x)))
+ })
+ .collect();
+ if angles.len() < 2 {
+ return 0.0;
+ }
+ angles.sort_by(f64::total_cmp);
+ let wrap = angles.first().copied().unwrap_or(0.0) + TAU - angles.last().copied().unwrap_or(0.0);
+ let widest = angles.windows(2).map(|w| w[1] - w[0]).fold(wrap, f64::max);
+ // Tessellation leaves gaps of a few degrees on a whole cylinder: those still count.
+ if widest < 0.35 { TAU } else { TAU - widest }
+}
+
+/// The unit direction a point leaves the axis at, towards the middle of the face's points.
+fn bulge(center: Vec3, axis: Vec3, pts: &[Vec3]) -> Option<Vec3> {
+ let sum = pts.iter().fold(Vec3::ZERO, |acc, p| {
+ let d = *p - center;
+ acc + (d - axis * d.dot(axis)).normalized().unwrap_or(Vec3::ZERO)
+ });
+ sum.normalized()
+}
+
+/// Closest points of two infinite lines (a point and a unit direction each).
+fn line_line(p1: Vec3, d1: Vec3, p2: Vec3, d2: Vec3) -> (Vec3, Vec3) {
+ let w = p1 - p2;
+ let b = d1.dot(d2);
+ let denom = 1.0 - b * b;
+ if denom < 1e-12 {
+ return (p1, p2 + d2 * w.dot(d2));
+ }
+ let (d, e) = (d1.dot(w), d2.dot(w));
+ let s = (b * e - d) / denom;
+ let t = (e - b * d) / denom;
+ (p1 + d1 * s, p2 + d2 * t)
+}
+
+fn parallel(a: Vec3, b: Vec3) -> bool {
+ a.cross(b).len() < 1e-6
+}
+
+/// A measurement from a round item's centre or axis.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct Centre {
+ pub distance: f64,
+ pub from: Vec3,
+ pub to: Vec3,
+ /// Closest and farthest distances worked out exactly (`None`: measure them on the mesh).
+ pub min: Option<f64>,
+ pub max: Option<f64>,
+}
+
+/// Distance between two non-negative in-plane circles' rims, closest and farthest, with
+/// centres `d` apart.
+fn rims(d: f64, ra: f64, rb: f64) -> (f64, f64) {
+ let near = if d >= ra + rb {
+ d - ra - rb
+ } else if d <= (ra - rb).abs() {
+ (ra - rb).abs() - d
+ } else {
+ 0.0
+ };
+ (near, d + ra + rb)
+}
+
+/// Centre-to-centre (axis to axis, axis to plane, line or point) between two items, when one
+/// of them is round. `None` for pairs without a round item and where an axis meets the other
+/// item at an angle that gives no single distance (a cylinder crossing a plane).
+pub(crate) fn centre(a: &Shape, b: &Shape) -> Option<Centre> {
+ match (a, b) {
+ (Shape::Round { .. }, _) => from_round(a, b),
+ (_, Shape::Round { .. }) => from_round(b, a).map(|c| Centre { from: c.to, to: c.from, ..c }),
+ _ => None,
+ }
+}
+
+fn from_round(a: &Shape, b: &Shape) -> Option<Centre> {
+ let Shape::Round { center: ca, axis: na, radius: ra, planar: pa, lo: loa, hi: hia, .. } = *a else { return None };
+ let full_a = a.full();
+ let c = match *b {
+ Shape::Round { center: cb, axis: nb, radius: rb, lo: lob, hi: hib, .. } => {
+ if parallel(na, nb) {
+ let w = cb - ca;
+ let along = w.dot(na);
+ // Drawn level with A's centre: on B's axis, the foot of A's centre.
+ let foot = cb - na * along;
+ let d = (w - na * along).len();
+ let (mut min, mut max) = (None, None);
+ if full_a && b.full() {
+ // B's extent along A's axis.
+ let s = if na.dot(nb) >= 0.0 { 1.0 } else { -1.0 };
+ let (b0, b1) = (along + lob * s, along + hib * s);
+ let (b0, b1) = (b0.min(b1), b0.max(b1));
+ let gap = (loa.max(b0) - hia.min(b1)).max(0.0);
+ let reach = (hia - b0).abs().max((b1 - loa).abs());
+ let (near, far) = rims(d, ra, rb);
+ min = Some(near.hypot(gap));
+ max = Some(far.hypot(reach));
+ }
+ Centre { distance: d, from: ca, to: foot, min, max }
+ } else {
+ let (p, q) = line_line(ca, na, cb, nb);
+ Centre { distance: p.dist(q), from: p, to: q, min: None, max: None }
+ }
+ }
+ Shape::Plane { point, normal } => {
+ let n = normal.normalized()?;
+ let h = (ca - point).dot(n);
+ if na.dot(n).abs() < 1e-6 {
+ // Axis along the plane: axis to plane, and the rim's nearest and farthest.
+ let d = h.abs();
+ let (min, max) = if full_a { (Some((d - ra).max(0.0)), Some(d + ra)) } else { (None, None) };
+ Centre { distance: d, from: ca, to: ca - n * h, min: if d >= ra { min } else { None }, max }
+ } else if pa {
+ // A circle's centre to the plane.
+ Centre { distance: h.abs(), from: ca, to: ca - n * h, min: None, max: None }
+ } else {
+ return None;
+ }
+ }
+ Shape::Line { a: la, b: lb } => {
+ let dir = (lb - la).normalized()?;
+ let (p, q) = line_line(ca, na, la, dir);
+ let d = p.dist(q);
+ let across = dir.dot(na).abs() < 1e-6;
+ let min = (full_a && across && d >= ra).then_some(d - ra);
+ Centre { distance: d, from: p, to: q, min, max: None }
+ }
+ Shape::Point(p) => {
+ if pa {
+ let d = p.dist(ca);
+ let in_plane = (p - ca).dot(na).abs() < 1e-6 * (1.0 + d);
+ let (min, max) = if full_a && in_plane { (Some((d - ra).abs()), Some(d + ra)) } else { (None, None) };
+ Centre { distance: d, from: ca, to: p, min, max }
+ } else {
+ let w = p - ca;
+ let foot = ca + na * w.dot(na);
+ Centre { distance: p.dist(foot), from: foot, to: p, min: None, max: None }
+ }
+ }
+ Shape::Other => return None,
+ };
+ (c.distance.is_finite() && c.from.is_finite() && c.to.is_finite()).then_some(c)
+}
+
+/// A slot's sizes: width (the ends' diameter), the distance between the ends' centres and the
+/// overall length, with the two centres.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct Slot {
+ pub width: f64,
+ pub centres: (Vec3, Vec3),
+}
+
+impl Slot {
+ pub(crate) fn json(&self) -> Value {
+ let c2c = self.centres.0.dist(self.centres.1);
+ json!({"width": self.width, "center_distance": c2c, "overall_length": c2c + self.width, "centers": [self.centres.0, self.centres.1]})
+ }
+}
+
+/// A slot's outline in its plane: two half-circle ends of one radius joined by two straight
+/// sides. `arcs` are (centre, radius, swept angle) with pieces of one end already merged,
+/// `lines` the straight pieces (2D, in the sketch plane).
+pub(crate) fn slot_outline(
+ arcs: &[(solidcraft_geom::Vec2, f64, f64)],
+ lines: &[(solidcraft_geom::Vec2, solidcraft_geom::Vec2)],
+) -> Option<(solidcraft_geom::Vec2, solidcraft_geom::Vec2, f64)> {
+ let [(c1, r1, s1), (c2, r2, s2)] = arcs else { return None };
+ let tol = 1e-6 * (1.0 + r1.abs() + c1.dist(*c2));
+ if (r1 - r2).abs() > tol || (s1.abs() - PI).abs() > 1e-4 || (s2.abs() - PI).abs() > 1e-4 || c1.dist(*c2) <= tol || lines.is_empty() {
+ return None;
+ }
+ let along = (*c2 - *c1).normalized()?;
+ // Every straight piece runs along the slot, `r` to one side of the centre line.
+ let side = |p: solidcraft_geom::Vec2| (p - *c1).cross(along);
+ let ok = lines.iter().all(|(a, b)| {
+ let d = *b - *a;
+ d.cross(along).abs() <= tol * (1.0 + d.len()) && (side(*a).abs() - r1).abs() <= tol && (side(*b).abs() - r1).abs() <= tol
+ });
+ let both = lines.iter().any(|(a, _)| side(*a) > 0.0) && lines.iter().any(|(a, _)| side(*a) < 0.0);
+ (ok && both).then_some((*c1, *c2, *r1))
+}
+
+/// A slot cut or boss on a solid, found from one of its half-cylinder ends: another half
+/// cylinder of the same radius on a parallel axis, bulging the other way, and two planes along
+/// the slot `r` either side of its centre line. `faces` gives each face's surface and points.
+pub(crate) fn slot_from_faces(picked: &Shape, picked_pts: &[Vec3], faces: &[(solidcraft_kernel::FaceSurface, Vec<Vec3>)]) -> Option<Slot> {
+ use solidcraft_kernel::FaceSurface;
+ let Shape::Round { center, axis, radius, angle, planar: false, .. } = *picked else { return None };
+ if (angle - PI).abs() > 0.3 {
+ return None;
+ }
+ let tol = 1e-6 * (1.0 + radius) * 100.0;
+ let out_a = bulge(center, axis, picked_pts)?;
+ for (s, pts) in faces {
+ let FaceSurface::Cylinder { origin, axis: ax, radius: r } = *s else { continue };
+ if (r - radius).abs() > tol || !parallel(ax, axis) {
+ continue;
+ }
+ let Some(Shape::Round { center: cb, angle: ab, .. }) = cylinder(origin, ax, r, pts) else { continue };
+ let w = cb - center;
+ let off = w - axis * w.dot(axis);
+ let Some(along) = off.normalized() else { continue };
+ if (ab - PI).abs() > 0.3 || off.len() <= tol {
+ continue;
+ }
+ let Some(out_b) = bulge(cb, axis, pts) else { continue };
+ // Each end bulges away from the other.
+ if out_a.dot(along) > -0.5 || out_b.dot(along) < 0.5 {
+ continue;
+ }
+ let across = axis.cross(along);
+ let sides = faces.iter().filter(|(fs, _)| match *fs {
+ FaceSurface::Plane { normal, point } => {
+ parallel(normal, across) && ((point - center).dot(across).abs() - radius).abs() <= tol.max(radius * 1e-4)
+ }
+ _ => false,
+ });
+ let (mut pos, mut neg) = (false, false);
+ for (fs, _) in sides {
+ if let FaceSurface::Plane { point, .. } = fs {
+ if (*point - center).dot(across) > 0.0 { pos = true } else { neg = true }
+ }
+ }
+ if pos && neg {
+ // Both centres level with the picked end's middle.
+ return Some(Slot { width: 2.0 * radius, centres: (center, center + off) });
+ }
+ }
+ None
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use solidcraft_geom::Vec2;
+
+ fn circle(c: Vec3, r: f64) -> Shape {
+ Shape::Round { center: c, axis: Vec3::Z, radius: r, angle: TAU, planar: true, lo: 0.0, hi: 0.0 }
+ }
+
+ #[test]
+ fn two_circles_measure_centre_to_centre_with_rims() {
+ let c = centre(&circle(Vec3::ZERO, 3.0), &circle(Vec3::new(30.0, 40.0, 0.0), 2.0)).unwrap();
+ assert!((c.distance - 50.0).abs() < 1e-12);
+ assert!((c.min.unwrap() - 45.0).abs() < 1e-12);
+ assert!((c.max.unwrap() - 55.0).abs() < 1e-12);
+ }
+
+ #[test]
+ fn a_cylinder_to_a_side_plane_measures_from_its_axis() {
+ let cyl = Shape::Round { center: Vec3::new(10.0, 15.0, 5.0), axis: Vec3::Z, radius: 2.5, angle: TAU, planar: false, lo: -5.0, hi: 5.0 };
+ let plane = Shape::Plane { point: Vec3::ZERO, normal: Vec3::new(-1.0, 0.0, 0.0) };
+ let c = centre(&cyl, &plane).unwrap();
+ assert!((c.distance - 10.0).abs() < 1e-12);
+ assert!((c.min.unwrap() - 7.5).abs() < 1e-12 && (c.max.unwrap() - 12.5).abs() < 1e-12);
+ // Swapped, the line runs the other way.
+ let d = centre(&plane, &cyl).unwrap();
+ assert_eq!((d.from, d.to), (c.to, c.from));
+ // A cylinder crossing a plane has no single axis distance.
+ assert!(centre(&cyl, &Shape::Plane { point: Vec3::ZERO, normal: Vec3::Z }).is_none());
+ }
+
+ #[test]
+ fn an_axis_to_a_crossing_edge_is_the_distance_between_the_lines() {
+ let cyl = Shape::Round { center: Vec3::new(10.0, 15.0, 5.0), axis: Vec3::Z, radius: 2.5, angle: TAU, planar: false, lo: -5.0, hi: 5.0 };
+ let edge = Shape::Line { a: Vec3::new(0.0, 0.0, 10.0), b: Vec3::new(40.0, 0.0, 10.0) };
+ let c = centre(&cyl, &edge).unwrap();
+ assert!((c.distance - 15.0).abs() < 1e-12);
+ assert!((c.min.unwrap() - 12.5).abs() < 1e-12);
+ assert!(c.from.dist(Vec3::new(10.0, 15.0, 10.0)) < 1e-12 && c.to.dist(Vec3::new(10.0, 0.0, 10.0)) < 1e-12);
+ }
+
+ #[test]
+ fn coverage_of_a_half_and_a_whole_ring() {
+ let ring = |n: usize, span: f64| -> Vec<Vec3> {
+ (0..=n).map(|i| Vec3::new((span * i as f64 / n as f64).cos(), (span * i as f64 / n as f64).sin(), 0.0)).collect()
+ };
+ assert!((coverage(Vec3::ZERO, Vec3::Z, &ring(32, PI)) - PI).abs() < 1e-9);
+ assert_eq!(coverage(Vec3::ZERO, Vec3::Z, &ring(32, TAU)), TAU);
+ }
+
+ #[test]
+ fn a_slot_outline_and_not_a_slot() {
+ let arcs = [(Vec2::new(0.0, 0.0), 3.0, PI), (Vec2::new(20.0, 0.0), 3.0, PI)];
+ let lines = [(Vec2::new(0.0, -3.0), Vec2::new(20.0, -3.0)), (Vec2::new(20.0, 3.0), Vec2::new(0.0, 3.0))];
+ let (a, b, r) = slot_outline(&arcs, &lines).unwrap();
+ assert_eq!((a.dist(b), r), (20.0, 3.0));
+ let skew = [(Vec2::new(0.0, -3.0), Vec2::new(20.0, -2.0)), (Vec2::new(20.0, 3.0), Vec2::new(0.0, 3.0))];
+ assert!(slot_outline(&arcs, &skew).is_none());
+ assert!(slot_outline(&[(Vec2::new(0.0, 0.0), 3.0, PI), (Vec2::new(20.0, 0.0), 4.0, PI)], &lines).is_none());
+ }
+}
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 07f2c088c0..c4d2d0c201 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -42,6 +42,7 @@ mod libraries;
mod material_properties;
mod materials;
mod measure_sel;
+mod measure_shape;
mod mesh;
mod metadata;
pub(crate) mod motion;
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 32b2a26629..59a0a7cecc 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -941,6 +941,8 @@ mod hole_matrix_tests;
#[cfg(test)]
mod large_assembly_tests;
#[cfg(test)]
+mod measure_centre_tests;
+#[cfg(test)]
mod naming_history_tests;
#[cfg(test)]
mod pattern_suppress_tests;
diff --git a/crates/engine/src/measure_centre_tests.rs b/crates/engine/src/measure_centre_tests.rs
new file mode 100644
index 0000000000..747918891d
--- /dev/null
+++ b/crates/engine/src/measure_centre_tests.rs
@@ -0,0 +1,218 @@
+//! Measure on holes, circles, arcs and slots (#1392): centre-to-centre and axis-to-edge
+//! distances with the closest and farthest listed too, diameters and radii, slot sizes. Every
+//! expected value is worked out by hand from the part's dimensions.
+
+use std::f64::consts::{PI, TAU};
+
+use serde_json::{Value, json};
+use solidcraft_geom::Vec3;
+
+use crate::Session;
+
+fn run(s: &mut Session, id: &str, p: Value) -> Value {
+ match s.execute(id, &p) {
+ Ok(v) => v,
+ Err(e) => panic!("{id} {p}: {e}"),
+ }
+}
+
+fn close(v: &Value, want: f64, tol: f64) -> bool {
+ v.as_f64().is_some_and(|x| (x - want).abs() <= tol)
+}
+
+/// A 60 × 40 × 10 plate with a Ø6 hole at (15, 20) and a Ø8 hole at (45, 20).
+fn plate(s: &mut Session) {
+ run(s, "solid.box", json!({"length": 60, "width": 40, "height": 10}));
+ run(s, "solid.cylinder", json!({"radius": 3, "height": 12, "base": [15, 20, -1], "operation": "cut"}));
+ run(s, "solid.cylinder", json!({"radius": 4, "height": 12, "base": [45, 20, -1], "operation": "cut"}));
+}
+
+fn body(s: &Session) -> String {
+ s.model.state().bodies.first().unwrap().name.clone()
+}
+
+/// The cylindrical face of radius `r`, as a pick.
+fn hole(s: &Session, r: f64) -> Value {
+ let st = s.model.state();
+ let b = st.bodies.first().unwrap();
+ let m = b.mesh();
+ let n = m.tri_face.iter().map(|f| *f as usize + 1).max().unwrap();
+ let f = (0..n)
+ .find(|&f| matches!(solidcraft_kernel::face_surface(&b.body, f), Some(solidcraft_kernel::FaceSurface::Cylinder { radius, .. }) if (radius - r).abs() < 1e-6))
+ .unwrap_or_else(|| panic!("no hole of radius {r}"));
+ let p = m.triangles.iter().zip(&m.tri_face).find(|(_, tf)| **tf as usize == f).and_then(|(t, _)| m.tri(t)).unwrap()[0];
+ json!({"type": "face", "body": b.name, "index": f, "point": p})
+}
+
+/// The planar face all of whose points satisfy `on`, as a pick.
+fn flat(s: &Session, on: impl Fn(Vec3) -> bool) -> Value {
+ let st = s.model.state();
+ let b = st.bodies.first().unwrap();
+ let m = b.mesh();
+ let n = m.tri_face.iter().map(|f| *f as usize + 1).max().unwrap();
+ let f = (0..n)
+ .find(|&f| {
+ let tris: Vec<_> = m.triangles.iter().zip(&m.tri_face).filter(|(_, tf)| **tf as usize == f).filter_map(|(t, _)| m.tri(t)).collect();
+ !tris.is_empty() && tris.iter().all(|t| t.iter().all(|p| on(*p)))
+ })
+ .unwrap();
+ let p = m.triangles.iter().zip(&m.tri_face).find(|(_, tf)| **tf as usize == f).and_then(|(t, _)| m.tri(t)).unwrap()[0];
+ json!({"type": "face", "body": b.name, "index": f, "point": p})
+}
+
+/// The mesh edge all of whose points satisfy `on`, as a pick.
+fn edge(s: &Session, on: impl Fn(Vec3) -> bool) -> Value {
+ let st = s.model.state();
+ let b = st.bodies.first().unwrap();
+ let m = b.mesh();
+ let i = m.edges.iter().position(|e| e.iter().all(|p| on(*p))).expect("edge");
+ let e = &m.edges[i];
+ json!({"type": "edge", "body": b.name, "index": i, "point": e[e.len() / 2]})
+}
+
+fn measure(s: &mut Session, items: Vec<Value>) -> Value {
+ run(s, "inspect.measure", json!({ "items": items }))
+}
+
+#[test]
+fn two_holes_measure_centre_to_centre_with_min_and_max() {
+ let mut s = Session::default();
+ plate(&mut s);
+ let (a, b) = (hole(&s, 3.0), hole(&s, 4.0));
+ let r = measure(&mut s, vec![a.clone(), b.clone()]);
+ assert!(close(&r["center_distance"], 30.0, 1e-9), "{r}");
+ assert!(close(&r["min"], 30.0 - 3.0 - 4.0, 1e-9), "{r}");
+ assert!(close(&r["max"], (37.0f64).hypot(10.0), 1e-9), "{r}");
+ assert_eq!(r["measure"], "center");
+ // Backward compatible: the closest distance is still `distance_mm`, with its points.
+ assert!(close(&r["distance_mm"], 23.0, 1e-9) && r["from"].is_array() && r["to"].is_array(), "{r}");
+ // The centre line runs between the two axes, square to them.
+ let (f, t) = (&r["center_from"], &r["center_to"]);
+ assert!(close(&f[0], 15.0, 1e-9) && close(&f[1], 20.0, 1e-9) && close(&t[0], 45.0, 1e-9) && close(&t[1], 20.0, 1e-9), "{r}");
+ assert!(close(&f[2], t[2].as_f64().unwrap(), 1e-9), "{r}");
+ // Each hole: Ø, R and circumference.
+ assert!(close(&r["items"][0]["diameter"], 6.0, 1e-9) && close(&r["items"][0]["radius"], 3.0, 1e-9), "{r}");
+ assert!(close(&r["items"][1]["circumference"], 8.0 * PI, 1e-9), "{r}");
+ // The two rims on the top face: the same centres, the rims' gap and span.
+ let rim = |c: f64, rr: f64| move |p: Vec3| (p.z - 10.0).abs() < 1e-6 && ((p - Vec3::new(c, 20.0, 10.0)).len() - rr).abs() < 1e-6;
+ let (ea, eb) = (edge(&s, rim(15.0, 3.0)), edge(&s, rim(45.0, 4.0)));
+ let r = measure(&mut s, vec![ea.clone(), eb]);
+ assert!(close(&r["center_distance"], 30.0, 1e-9) && close(&r["min"], 23.0, 1e-9) && close(&r["max"], 37.0, 1e-9), "{r}");
+ // One rim: Ø, R and circumference first-class.
+ let r = measure(&mut s, vec![ea]);
+ assert!(close(&r["diameter"], 6.0, 1e-9) && close(&r["radius"], 3.0, 1e-9) && close(&r["circumference"], TAU * 3.0, 1e-9), "{r}");
+ assert_eq!(r["items"][0]["round"], "circle", "{r}");
+}
+
+#[test]
+fn a_hole_to_the_plate_edge_and_side_measures_from_its_axis() {
+ let mut s = Session::default();
+ plate(&mut s);
+ let a = hole(&s, 3.0);
+ // The top front edge (y = 0, z = 10).
+ let e = edge(&s, |p| p.y.abs() < 1e-9 && (p.z - 10.0).abs() < 1e-9);
+ let r = measure(&mut s, vec![a.clone(), e]);
+ assert!(close(&r["center_distance"], 20.0, 1e-9), "{r}");
+ assert!(close(&r["min"], 17.0, 1e-9), "{r}");
+ assert!(r["max"].as_f64().unwrap() > 20.0, "{r}");
+ // The front face (y = 0): axis to plane, the rim's nearest and farthest.
+ let f = flat(&s, |p| p.y.abs() < 1e-9);
+ let r = measure(&mut s, vec![f, a.clone()]);
+ assert!(close(&r["center_distance"], 20.0, 1e-9) && close(&r["min"], 17.0, 1e-9), "{r}");
+ // The face reaches past the hole: its far corners are farther than the rim's far side.
+ assert!(r["max"].as_f64().unwrap() > 23.0, "{r}");
+ // Picked plane first: the centre line still starts at the plane.
+ assert!(close(&r["center_from"][1], 0.0, 1e-9) && close(&r["center_to"][1], 20.0, 1e-9), "{r}");
+ // Two planes keep today's measure: no centre.
+ let top = flat(&s, |p| (p.z - 10.0).abs() < 1e-9);
+ let bottom = flat(&s, |p| p.z.abs() < 1e-9);
+ let r = measure(&mut s, vec![top, bottom]);
+ assert!(r.get("center_distance").is_none() && close(&r["distance_mm"], 10.0, 1e-9) && r["measure"] == "min", "{r}");
+}
+
+#[test]
+fn sketch_circle_arc_and_slot() {
+ let mut s = Session::default();
+ run(&mut s, "sketch.create", json!({"plane": "XY"}));
+ let c = run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 5}))["curves"][0].as_str().unwrap().to_string();
+ let a =
+ run(&mut s, "sketch.arc.center_point", json!({"center": [30, 0], "start": [34, 0], "sweep": 90}))["curves"][0].as_str().unwrap().to_string();
+ let r = measure(&mut s, vec![json!({"type": "sketch_curve", "id": c})]);
+ assert!(close(&r["diameter"], 10.0, 1e-9) && close(&r["radius"], 5.0, 1e-9) && close(&r["circumference"], 10.0 * PI, 1e-9), "{r}");
+ let r = measure(&mut s, vec![json!({"type": "sketch_curve", "id": a})]);
+ assert!(close(&r["radius"], 4.0, 1e-9) && close(&r["diameter"], 8.0, 1e-9), "{r}");
+ assert!(close(&r["angle_deg"], 90.0, 1e-9) && close(&r["arc_length"], 2.0 * PI, 1e-9), "{r}");
+ assert_eq!(r["items"][0]["round"], "arc");
+ // Circle to arc: centre to centre.
+ let r = measure(&mut s, vec![json!({"type": "sketch_curve", "id": c}), json!({"type": "sketch_curve", "id": a})]);
+ assert!(close(&r["center_distance"], 30.0, 1e-9), "{r}");
+ run(&mut s, "sketch.slot.center_to_center", json!({"p0": [0, 40], "p1": [20, 40], "width": 6}));
+ let sid = s.active_sketch.unwrap();
+ run(&mut s, "sketch.finish", json!({}));
+ let st = s.model.state();
+ let ss = st.sketch(sid).unwrap();
+ let slot =
+ ss.profiles.iter().position(|p| p.region.outer.segs.len() >= 4 && (p.area - (20.0 * 6.0 + PI * 9.0)).abs() < 1e-6).expect("slot profile");
+ let circle = ss.profiles.iter().position(|p| (p.area - PI * 25.0).abs() < 1e-6).expect("circle profile");
+ let r = measure(&mut s, vec![json!({"type": "profile", "sketch": sid, "index": slot})]);
+ let sl = &r["slot"];
+ assert!(close(&sl["width"], 6.0, 1e-9) && close(&sl["center_distance"], 20.0, 1e-9) && close(&sl["overall_length"], 26.0, 1e-9), "{r}");
+ let r = measure(&mut s, vec![json!({"type": "profile", "sketch": sid, "index": circle})]);
+ assert!(close(&r["diameter"], 10.0, 1e-9), "{r}");
+}
+
+#[test]
+fn a_slot_cut_in_a_plate_reports_its_sizes_from_an_end() {
+ let mut s = Session::default();
+ run(&mut s, "solid.box", json!({"length": 60, "width": 40, "height": 10}));
+ run(&mut s, "sketch.create", json!({"plane": "XY"}));
+ run(&mut s, "sketch.slot.center_to_center", json!({"p0": [20, 20], "p1": [40, 20], "width": 8}));
+ run(&mut s, "sketch.finish", json!({}));
+ run(&mut s, "solid.extrude", json!({"distance": 10, "operation": "cut", "profiles": "all"}));
+ let st = s.model.state();
+ let b = st.bodies.first().unwrap();
+ let m = b.mesh();
+ let n = m.tri_face.iter().map(|f| *f as usize + 1).max().unwrap();
+ let end = (0..n)
+ .find(|&f| matches!(solidcraft_kernel::face_surface(&b.body, f), Some(solidcraft_kernel::FaceSurface::Cylinder { radius, .. }) if (radius - 4.0).abs() < 1e-6))
+ .expect("slot end");
+ let p = m.triangles.iter().zip(&m.tri_face).find(|(_, tf)| **tf as usize == end).and_then(|(t, _)| m.tri(t)).unwrap()[0];
+ let name = body(&s);
+ let r = measure(&mut s, vec![json!({"type": "face", "body": name, "index": end, "point": p})]);
+ let sl = &r["slot"];
+ assert!(close(&sl["width"], 8.0, 1e-9) && close(&sl["center_distance"], 20.0, 1e-9) && close(&sl["overall_length"], 28.0, 1e-9), "{r}");
+ // The end is a half cylinder: R 4, half a turn.
+ assert!(close(&r["radius"], 4.0, 1e-9) && close(&r["angle_deg"], 180.0, 1.0), "{r}");
+}
+
+#[test]
+fn a_fillet_edge_is_an_arc() {
+ let mut s = Session::default();
+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20}));
+ run(&mut s, "solid.fillet", json!({"edges": [[40, 30, 10]], "radius": 5}));
+ // The fillet's quarter circle on the top face: centre (35, 25, 20).
+ let e = edge(&s, |p| (p.z - 20.0).abs() < 1e-9 && ((p - Vec3::new(35.0, 25.0, 20.0)).len() - 5.0).abs() < 1e-6);
+ let r = measure(&mut s, vec![e]);
+ assert!(close(&r["radius"], 5.0, 1e-9) && close(&r["diameter"], 10.0, 1e-9), "{r}");
+ assert!(close(&r["angle_deg"], 90.0, 1e-6) && close(&r["arc_length"], 2.5 * PI, 1e-6), "{r}");
+ assert!(close(&r["center"][0], 35.0, 1e-9) && close(&r["center"][1], 25.0, 1e-9), "{r}");
+}
+
+/// A plate with holes through STEP: the holes come back as cylinders, and measure the same.
+#[test]
+fn step_round_trip_of_a_plate_with_holes() {
+ let dir = std::env::temp_dir().join(format!("solidcraft-measure-1392-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let path = dir.join("Plate.step");
+ let mut s = Session::default();
+ plate(&mut s);
+ run(&mut s, "file.export", json!({"path": path.to_string_lossy()}));
+ let mut t = Session::default();
+ run(&mut t, "doc.open", json!({"path": path.to_string_lossy()}));
+ let (a, b) = (hole(&t, 3.0), hole(&t, 4.0));
+ let r = measure(&mut t, vec![a, b]);
+ assert!(close(&r["center_distance"], 30.0, 1e-6), "{r}");
+ assert!(close(&r["min"], 23.0, 1e-6), "{r}");
+ assert!(close(&r["items"][0]["diameter"], 6.0, 1e-6) && close(&r["items"][1]["diameter"], 8.0, 1e-6), "{r}");
+ let _ = std::fs::remove_dir_all(&dir);
+}
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 0eaf370ce1..d99415e9d0 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -143,7 +143,7 @@ pub use step::step_export;
pub use step_in::{ImportedBody, StepImport, StepNode, step_cache_alive, step_import, step_import_shared, step_orientation_errors, step_validate};
pub use step_out::{ExportBody, ExportProduct, StepHeader, step_export_bodies, step_export_products};
pub use surface_extend::{ExtendLimit, ExtendMode, ExtendOptions, extend_surface};
-pub use surface_kind::{FaceSurface, face_surface};
+pub use surface_kind::{EdgeCircle, FaceSurface, edge_circle, face_surface};
pub use surface_offset::offset_surface;
pub use surface_ruled::{Ruled, RuledCorners, RuledMode, ruled_surface};
pub use surface_untrim::{UntrimHoles, untrim};
diff --git a/crates/kernel/src/surface_kind.rs b/crates/kernel/src/surface_kind.rs
index 9ef1f2da8f..2982fb59ad 100644
--- a/crates/kernel/src/surface_kind.rs
+++ b/crates/kernel/src/surface_kind.rs
@@ -3,7 +3,10 @@
use solidcraft_geom::Vec3;
+use truck_modeling as mt;
+
use crate::Body;
+use crate::body::from_p3;
use crate::offset::{Surf, surf_of};
/// A face's analytic surface. Axes are unit vectors.
@@ -51,6 +54,85 @@ pub fn face_surface(b: &Body, face: usize) -> Option<FaceSurface> {
})
}
+/// The circle (or arc of one) an edge's curve lies on, from its exact curve.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EdgeCircle {
+ pub center: Vec3,
+ /// Unit normal of the circle's plane, oriented so the edge runs counter-clockwise about it.
+ pub axis: Vec3,
+ pub radius: f64,
+ /// The edge's ends (the same point for a closed circle).
+ pub start: Vec3,
+ pub end: Vec3,
+ /// The angle the edge spans (radians, 2π for a whole circle).
+ pub angle: f64,
+}
+
+/// The circle edge `edge` (in the order of [`Body::edges`] and the tessellated mesh's edges)
+/// lies on, if its curve is a circle or an arc of one. `None` for other curves, mesh bodies
+/// and an index out of range.
+pub fn edge_circle(b: &Body, edge: usize) -> Option<EdgeCircle> {
+ use mt::{BoundedCurve, ParametricCurve};
+ if b.mesh.is_some() {
+ return None;
+ }
+ let e = Body::unique_edges(&b.solid).into_iter().nth(edge)?;
+ let tol = (b.size() * 1e-7).max(1e-9) * 100.0;
+ crate::guard("edge circle", || {
+ let c = e.oriented_curve();
+ let (t0, t1) = c.range_tuple();
+ let at = |f: f64| from_p3(c.subs(t0 + (t1 - t0) * f));
+ let samples: Vec<Vec3> = (0..=24).map(|i| at(f64::from(i) / 24.0)).collect();
+ Ok(circle_through(&samples, tol))
+ })
+ .ok()
+ .flatten()
+}
+
+/// The circle through evenly spaced samples of a curve (first to last), if they all lie on one.
+fn circle_through(s: &[Vec3], tol: f64) -> Option<EdgeCircle> {
+ let (start, end) = (*s.first()?, *s.last()?);
+ let closed = start.dist(end) <= tol;
+ // Three well-spread samples: a quarter, half and three quarters for a closed curve.
+ let n = s.len().checked_sub(1)?;
+ let (a, b, c) = if closed { (*s.get(n / 4)?, *s.get(n / 2)?, *s.get(3 * n / 4)?) } else { (start, *s.get(n / 2)?, end) };
+ let (u, v) = (b - a, c - a);
+ let w = u.cross(v);
+ if !(w.len2() > u.len2() * v.len2() * 1e-16) {
+ return None;
+ }
+ let center = a + (v * u.len2() - u * v.len2()).cross(w) * (1.0 / (2.0 * w.len2()));
+ let axis = w.normalized()?;
+ let radius = center.dist(a);
+ if !(radius.is_finite() && radius > tol) || s.iter().any(|p| (p.dist(center) - radius).abs() > tol || (*p - center).dot(axis).abs() > tol) {
+ return None;
+ }
+ let x = (start - center).normalized()?;
+ let y = axis.cross(x);
+ let turn = |p: Vec3| {
+ let d = p - center;
+ let t = d.dot(y).atan2(d.dot(x));
+ if t < 0.0 { t + std::f64::consts::TAU } else { t }
+ };
+ // Accumulate the turn sample to sample so the span is right whichever way the curve runs.
+ let mut angle = 0.0;
+ let mut last = 0.0;
+ for p in s.iter().skip(1) {
+ let t = turn(*p);
+ let mut d = t - last;
+ if d < -std::f64::consts::PI {
+ d += std::f64::consts::TAU;
+ } else if d > std::f64::consts::PI {
+ d -= std::f64::consts::TAU;
+ }
+ angle += d;
+ last = t;
+ }
+ let (axis, angle) = if angle < 0.0 { (axis * -1.0, -angle) } else { (axis, angle) };
+ let angle = if closed { std::f64::consts::TAU } else { angle.min(std::f64::consts::TAU) };
+ Some(EdgeCircle { center, axis, radius, start, end, angle })
+}
+
impl FaceSurface {
/// The point of the whole surface (not only of its face) nearest `p`. `None` where every
/// point of a ring is as near (on a cylinder's or cone's axis, at a sphere's or torus's
diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs
index 5ed9cf94f5..cddc50590d 100644
--- a/crates/mcp/src/tests.rs
+++ b/crates/mcp/src/tests.rs
@@ -1373,3 +1373,21 @@ fn tool_annotations_tell_the_whole_truth() {
}
assert!(tools.iter().all(|t| t["annotations"]["readOnlyHint"].is_boolean()), "every tool is annotated");
}
+
+/// `measure` with `items` (#1392): a sketch circle's diameter and radius, and two circles'
+/// centre-to-centre with the closest and farthest distances.
+#[test]
+fn measure_items_gives_diameters_and_centre_distances() {
+ let mut s = server();
+ tool(&mut s, "execute", json!({"command": "sketch.create", "params": {"plane": "XY"}}));
+ let a = tool(&mut s, "execute", json!({"command": "sketch.circle.center", "params": {"center": [0, 0], "radius": 3}}));
+ let b = tool(&mut s, "execute", json!({"command": "sketch.circle.center", "params": {"center": [30, 40], "radius": 2}}));
+ let id = |r: &Value| r["curves"][0].as_str().or(r["result"]["curves"][0].as_str()).unwrap().to_string();
+ let (a, b) = (id(&a), id(&b));
+ let one = tool(&mut s, "measure", json!({"items": [{"type": "sketch_curve", "id": a}]}));
+ assert_eq!((one["diameter"].as_f64(), one["radius"].as_f64()), (Some(6.0), Some(3.0)), "{one}");
+ let two = tool(&mut s, "measure", json!({"items": [{"type": "sketch_curve", "id": a}, {"type": "sketch_curve", "id": b}]}));
+ assert!((two["center_distance"].as_f64().unwrap() - 50.0).abs() < 1e-9, "{two}");
+ assert!((two["min"].as_f64().unwrap() - 45.0).abs() < 1e-9 && (two["max"].as_f64().unwrap() - 55.0).abs() < 1e-9, "{two}");
+ assert!(two["distance_mm"].is_number() && two["from"].is_array(), "{two}");
+}
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index 13737beb37..42be3d7774 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -135,8 +135,17 @@ pub fn tool_definitions() -> Vec<Value> {
"measure",
"Measure bodies",
"Volume (mm³), surface area (mm²), centre of mass, bounding box and face/edge/vertex counts of one body or all \
- bodies, with totals.",
- obj(json!({"body": string("Body name (default: all bodies)")}), &[]),
+ bodies, with totals. With `items` (one or two selections, as `execute` takes them: faces, edges, vertices, \
+ sketch curves, profiles): one item's length, area or position, a circle's, arc's or cylinder's `diameter` and \
+ `radius` (with `circumference`, or an arc's `arc_length` and `angle_deg`), a slot's `slot` sizes; two items' \
+ `min` and `max` distance and, where one is round, `center_distance` (centre to centre, or from its axis).",
+ obj(
+ json!({
+ "body": string("Body name (default: all bodies)"),
+ "items": {"type": "array", "items": {"type": "object"}, "description": "One or two selections to measure instead of bodies, e.g. {\"type\": \"face\", \"body\": \"Body1\", \"index\": 3, \"point\": [x,y,z]}"},
+ }),
+ &[],
+ ),
Effect::ReadOnly,
),
tool(
@@ -388,6 +397,9 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Map<String, Value>) -> Result<V
Ok(d)
}
"measure" => {
+ if let Some(items) = a.get("items") {
+ return exec(b, "inspect.measure", json!({ "items": items }));
+ }
let p = match str_arg(a, "body") {
Some(body) => json!({"bodies": [body]}),
None => json!({}),
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 2cc38d3f58..7b04073ec4 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -249,8 +249,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj
app.dialog = Some(d);
return;
}
- if let Kind::Measure { result: Some(r), .. } = &d.kind {
- measure_line(app, painter, proj, r);
+ if let Kind::Measure { result: Some(r), show, .. } = &d.kind {
+ measure_line(app, painter, proj, r, *show);
app.dialog = Some(d);
return;
}
@@ -758,14 +758,11 @@ fn radius_spline_handles(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Pain
true
}
-/// The measured distance: a line between the closest points with its length.
-fn measure_line(app: &SolveApp, painter: &egui::Painter, proj: &Proj, r: &serde_json::Value) {
+/// The measured distance: a line between the ends of the shown measure (the centres for
+/// centre to centre, the closest or farthest points) with its length.
+fn measure_line(app: &SolveApp, painter: &egui::Painter, proj: &Proj, r: &serde_json::Value, show: Option<crate::dialogs::Shown>) {
let t = Tokens::get();
- let p = |k: &str| -> Option<Vec3> {
- let a = r.get(k)?.as_array()?;
- Some(Vec3::new(a.first()?.as_f64()?, a.get(1)?.as_f64()?, a.get(2)?.as_f64()?))
- };
- let (Some(a), Some(b), Some(d)) = (p("from"), p("to"), r.get("distance_mm").and_then(|v| v.as_f64())) else { return };
+ let Some((_, d, a, b)) = crate::dialogs::shown_distance(r, show) else { return };
let (Some(sa), Some(sb)) = (proj.to_screen(a), proj.to_screen(b)) else { return };
painter.line_segment([sa, sb], Stroke::new(2.0, t.manipulator));
for s in [sa, sb] {
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index ef774b66f5..de221c752f 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -193,6 +193,9 @@ pub enum Kind {
Measure {
result: Option<Value>,
of: Vec<Sel>,
+ /// The measure chosen in the panel (centre, min or max); `None` follows the result's
+ /// own default (centre where a round item gives one).
+ show: Option<Shown>,
},
/// Move bodies by a distance along X, Y and Z.
/// Move/Copy (see `dialogs_move`): the move type, X/Y/Z distances (Point to Position: the
@@ -528,9 +531,10 @@ impl Dialog {
"inspect.section" => {
Dialog::new(Kind::Section { offset: "0 mm".into(), flip: false }, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)])
}
- "inspect.measure" => {
- Dialog::new(Kind::Measure { result: None, of: Vec::new() }, vec![SelInput::new("Items", FACES | EDGES | selection::VERTICES, true)])
- }
+ "inspect.measure" => Dialog::new(
+ Kind::Measure { result: None, of: Vec::new(), show: None },
+ vec![SelInput::new("Items", FACES | EDGES | selection::VERTICES | selection::CURVES | PROFILES, true)],
+ ),
"solid.pattern.rectangular" => Dialog::new(
Kind::PatternRect { count: "3".into(), spacing: "20 mm".into(), count2: "1".into(), spacing2: "20 mm".into() },
vec![
@@ -1745,7 +1749,7 @@ pub(crate) fn fill_cells(st: &solidcraft_engine::doc::ModelState, tools: &[Strin
/// Measure again when the picked items changed.
fn update_measure(app: &SolveApp, d: &mut Dialog) {
let items: Vec<Sel> = sels(d, 0).to_vec();
- if let Kind::Measure { result, of } = &mut d.kind
+ if let Kind::Measure { result, of, .. } = &mut d.kind
&& *of != items
{
*result = if items.is_empty() { None } else { Some(app.session.measure_items(&items)) };
@@ -1757,8 +1761,39 @@ fn fmt_mm(app: &SolveApp, v: &Value) -> String {
v.as_f64().map(|x| crate::prefs::show_mm(app, x, 1)).unwrap_or_default()
}
+/// Which distance of a pair the Measure panel shows (and the canvas draws).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Shown {
+ /// Centre to centre, or from a round item's axis.
+ Centre,
+ /// Closest points.
+ Min,
+ /// Farthest points.
+ Max,
+}
+
+fn vec3_of(v: &Value) -> Option<Vec3> {
+ let a = v.as_array()?;
+ Some(Vec3::new(a.first()?.as_f64()?, a.get(1)?.as_f64()?, a.get(2)?.as_f64()?))
+}
+
+/// The distance shown for a measured pair: which one, its value and its two ends. The chosen
+/// one when the result has it, otherwise the result's default (centre, else the closest).
+pub(crate) fn shown_distance(r: &Value, show: Option<Shown>) -> Option<(Shown, f64, Vec3, Vec3)> {
+ let get = |which: Shown| -> Option<(Shown, f64, Vec3, Vec3)> {
+ let (d, from, to) = match which {
+ Shown::Centre => ("center_distance", "center_from", "center_to"),
+ Shown::Min => ("distance_mm", "from", "to"),
+ Shown::Max => ("max", "max_from", "max_to"),
+ };
+ Some((which, r.get(d)?.as_f64()?, vec3_of(r.get(from)?)?, vec3_of(r.get(to)?)?))
+ };
+ let default = if r.get("measure").and_then(Value::as_str) == Some("center") { Shown::Centre } else { Shown::Min };
+ show.and_then(get).or_else(|| get(default)).or_else(|| get(Shown::Min))
+}
+
/// The measurement in the dialog.
-fn measure_rows(app: &SolveApp, ui: &mut egui::Ui, r: Option<&Value>) {
+fn measure_rows(app: &SolveApp, ui: &mut egui::Ui, r: Option<&Value>, show: &mut Option<Shown>) {
let t = Tokens::get();
let Some(r) = r else {
ui.label("");
@@ -1772,33 +1807,74 @@ fn measure_rows(app: &SolveApp, ui: &mut egui::Ui, r: Option<&Value>) {
ui.end_row();
return;
}
+ let mm = |v: &Value| fmt_mm(app, v);
for (i, it) in r["items"].as_array().into_iter().flatten().enumerate() {
- let what = match it["type"].as_str() {
- Some("edge") => format!("Length {}", fmt_mm(app, &it["length_mm"])),
- Some("face") => format!("Area {}", crate::prefs::show_mm(app, it["area_mm2"].as_f64().unwrap_or(0.0), 2)),
- Some("vertex") => {
+ // Round items: Ø first, then R, then the length (circumference, or the arc's length
+ // and angle).
+ let mut lines: Vec<String> = Vec::new();
+ if it.get("diameter").is_some() {
+ lines.push(format!("Ø {}", mm(&it["diameter"])));
+ lines.push(format!("R {}", mm(&it["radius"])));
+ if it.get("circumference").is_some() {
+ lines.push(format!("{} {}", tr("Circumference"), mm(&it["circumference"])));
+ } else if let Some(a) = it["angle_deg"].as_f64() {
+ lines.push(format!("{} {}", tr("Arc length"), mm(&it["arc_length"])));
+ lines.push(format!("{} {a:.2}°", crate::i18n::tr_label("Angle")));
+ }
+ }
+ if let Some(sl) = it.get("slot") {
+ lines.push(format!("{} {}", tr("Slot width"), mm(&sl["width"])));
+ lines.push(format!("{} {}", tr("Centre to centre"), mm(&sl["center_distance"])));
+ lines.push(format!("{} {}", tr("Overall length"), mm(&sl["overall_length"])));
+ }
+ let round = it.get("diameter").is_some();
+ match it["type"].as_str() {
+ Some("edge" | "sketch_curve") if !round => lines.push(format!("{} {}", tr("Length"), mm(&it["length_mm"]))),
+ Some("face" | "profile") => {
+ lines.push(format!("{} {}", tr("Area"), crate::prefs::show_mm(app, it["area_mm2"].as_f64().unwrap_or(0.0), 2)))
+ }
+ Some("vertex" | "sketch_point") => {
let p = &it["position"];
- format!("At {}, {}, {}", fmt_mm(app, &p[0]), fmt_mm(app, &p[1]), fmt_mm(app, &p[2]))
+ lines.push(format!("At {}, {}, {}", mm(&p[0]), mm(&p[1]), mm(&p[2])));
}
- _ => String::new(),
- };
- ui.label(format!("Item {}", i + 1));
- ui.label(what);
- ui.end_row();
+ _ => {}
+ }
+ for (k, line) in lines.into_iter().enumerate() {
+ ui.label(if k == 0 { format!("Item {}", i + 1) } else { String::new() });
+ ui.label(line);
+ ui.end_row();
+ }
}
- if r.get("distance_mm").is_some() {
- ui.label(RichText::new(tr("Distance")).strong());
- ui.label(RichText::new(fmt_mm(app, &r["distance_mm"])).strong());
- ui.end_row();
- let d = &r["delta"];
- for (k, l) in ["ΔX", "ΔY", "ΔZ"].iter().enumerate() {
- ui.label(*l);
- ui.label(crate::prefs::show_mm(app, d[k].as_f64().unwrap_or(0.0).abs(), 1));
+ if let Some((now, d, a, b)) = shown_distance(r, *show) {
+ if r.get("center_distance").is_some() {
+ // Centre, min and max all listed; the chosen one is drawn and broken into ΔX/Y/Z.
+ for (which, label, key) in
+ [(Shown::Centre, "Centre to centre", "center_distance"), (Shown::Min, "Min", "distance_mm"), (Shown::Max, "Max", "max")]
+ {
+ let Some(v) = r.get(key).filter(|v| v.is_number()) else { continue };
+ if ui.radio(now == which, tr(label)).clicked() {
+ *show = Some(which);
+ }
+ let text = RichText::new(mm(v));
+ ui.label(if now == which { text.strong() } else { text });
+ ui.end_row();
+ }
+ } else {
+ ui.label(RichText::new(crate::i18n::tr_label("Distance")).strong());
+ ui.label(RichText::new(crate::prefs::show_mm(app, d, 1)).strong());
+ ui.end_row();
+ }
+ let delta = b - a;
+ for (l, v) in [("ΔX", delta.x), ("ΔY", delta.y), ("ΔZ", delta.z)] {
+ ui.label(l);
+ ui.label(crate::prefs::show_mm(app, v.abs(), 1));
ui.end_row();
}
}
- if let Some(a) = r["angle_deg"].as_f64() {
- ui.label(RichText::new(tr("Angle")).strong());
+ if let Some(a) = r["angle_deg"].as_f64()
+ && r["items"].as_array().is_some_and(|v| v.len() == 2)
+ {
+ ui.label(RichText::new(crate::i18n::tr_label("Angle")).strong());
ui.label(RichText::new(format!("{a:.3}°")).strong());
ui.end_row();
}
@@ -2373,7 +2449,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
d.extra.insert("combine".into(), json!(op == 1));
ui.end_row();
}
- Kind::Measure { result, .. } => measure_rows(app, ui, result.as_ref()),
+ Kind::Measure { result, show, .. } => measure_rows(app, ui, result.as_ref(), show),
Kind::OffsetPlane { offset } => {
row_label(ui, "Distance");
enter |= field(ui, offset);
diff --git a/docs/mcp.md b/docs/mcp.md
index 7ef017db83..4a2ba2524c 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -146,7 +146,7 @@ They cover the workflow, the command shapes, how to verify with `measure`, and t
| `execute` | `command`, `params?`, `verbose?` (default true) | Run any command with JSON parameters (`list_commands` shows them). Failures leave the design unchanged. A feature command replies with the feature (`feature`, `name`), every body (`bodies`) and the bodies it created, changed and removed (`created_bodies`, `changed_bodies`, `removed_bodies`). `verbose: false` uses the same compact reply as `batch`. |
| `batch` | `commands: [{command, params}]`, `rollback?` (default true), `verbose?` (default true) | Run steps in order, stop at the first error and undo the completed steps. The reply names the failing step (`failed.index`, `failed.command`, `failed.error`) and every result before it. `verbose: false` keeps the reply small in large designs: feature steps leave out the full body list (`created_bodies`, `changed_bodies`, `removed_bodies` stay) and sketch steps the ids they repeat outside `created`. Bridged to an app that has `engine.batch`, the whole batch is one control request (one frame of the app). Older apps, and apps showing the agent cursor, get the steps one by one. |
| `inspect_design` | `measure?` (default true), `sketches?` (default true) | Design properties (`metadata`: project, author… and other tools' keys; set them with `execute` `document.metadata.set`), parameters, timeline (type, suppressed, rolled back, error, warning, timing), bodies (volume, area, centre of mass, bbox, face/edge/vertex counts, visible; `removed_later: true` while a sketch is being edited on a rolled-back timeline and a later feature deletes the body, which is then not shown), sketches (curves, points, constraints, profiles, DOF, solve status, visible), selection, undo depth. Hide helper sketches, bodies or construction planes with `execute` `browser.visibility` (`{items, visible}` or `{folder, visible}`), and joint glyphs with `{joints: [id or name], visible}` or `{folder: "joints", visible}` (a hidden joint still constrains and drives; `joint.list` reports each joint's `visible`). |
-| `measure` | `body?` | Volume (mm³), area (mm²), centre of mass, bbox and topology counts per body, with totals. |
+| `measure` | `body?` or `items?` | Volume (mm³), area (mm²), centre of mass, bbox and topology counts per body, with totals. With `items` (one or two selections as `execute` takes them: `face`, `edge`, `vertex`, `sketch_curve`, `profile`), the picked geometry instead: see below. |
| `body_topology` | `body` | Edges (index, midpoint, length, ends) and faces (index, name, area, centroid, normal, `point`, and for a cylindrical face its `cylinder`: `origin`, `axis`, `radius`). An edge midpoint is the `[x,y,z]` that picks that edge for fillet and chamfer. A face's `point` lies on it and picks it (its centroid may not: that of a face with a hole is in the hole); a face's `name` picks it for the commands that take faces (`face.delete`, `solid.shell`, `solid.draft`, `solid.offset_face`, `solid.split_face`, `solid.replace_face`, and `face` of `sheet.convert`). |
| `set_parameter` | `name`, `value` (number or expression), `unit?`, `comment?` | Create or change a user parameter and recompute; reports `recomputed` (features rebuilt), `restored` (features whose earlier result for the same inputs was reused, e.g. a value set back) and features that now fail. |
| `screenshot` | `view?` (iso, top, front, back, bottom, left, right, home, fit, or a named view saved with `view.save`), `camera?` (`{target, yaw, pitch, distance, fov?}`, as `view.apply`), `path?`, `width?`, `height?`, `source?` (window, model), `grid?`, `axes?` | A PNG image content block. Headless: CPU render fitted to the model, or from the named view or camera. Bridged: the app window (default) or a model render with the app's camera; a named view or camera moves the app's viewport there first (`execute` `view.apply` does the same without a screenshot). `grid: false` and `axes: false` leave the ground grid (it lies on Z 0 and cuts through a part that straddles it) and the origin's axes out of a model render; axes hidden with `browser.visibility` stay out whatever `axes` says. Bridged, a screenshot that gives `grid` or `axes` is a model render, which follows the app's Grid and Origin switches for what it does not give; `source: "window"` with either is an error. |
@@ -157,6 +157,24 @@ They cover the workflow, the command shapes, how to verify with `measure`, and t
| `open` | `path` | Open a `.solidcraft` design, a STEP file (`.step`/`.stp`) as a new design holding its bodies (an Import base feature), or a 3MF/STL file as mesh bodies. |
| `save` | `path?` | Save the design (to its current file without `path`). |
+`measure` with `items` reports each item under `items` (`length_mm`, `area_mm2` or `position`).
+A circle, arc, hole or other cylindrical face also gives `diameter`, `radius`, `center` and
+`axis`, with `circumference` when it goes all the way round, or `arc_length` and `angle_deg`
+for an arc; `round` says which (`circle`, `arc`, `cylinder`). A slot (a sketch profile of two
+half circles and two lines, or one half-cylinder end of a slot in a solid) gives `slot`:
+`width`, `center_distance` and `overall_length`. With one item these fields are repeated at
+the top level. With two items:
+
+- `min` (also `distance_mm`, with `from`, `to` and `delta`): the closest distance;
+- `max` (with `max_from`, `max_to`): the farthest distance;
+- `center_distance` (with `center_from`, `center_to`): when an item is round, from its centre
+ or axis: axis to axis for parallel axes, the closest distance between the axes otherwise,
+ and axis to plane, line or point;
+- `measure`: the distance the Measure panel shows first (`center` where there is one, else `min`);
+- `angle_deg` between two planar faces or straight edges.
+
+Earlier fields are unchanged, so older scripts keep working.
+
To change a feature after it is made, read its definition with `execute` `timeline.inspect`
(`{feature}`: id or name) and change fields with `timeline.edit` (`{feature, set}`; e.g.
`{"extent": {"distance": "30"}}`). The fields per feature type are listed in the book's