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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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'sdiff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rsindex 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.rsindex 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<VOk(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.rsindex 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, projapp.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::Paintrue}-/// 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.rsindex 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.mdindex 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