Dimensions: a radius leader and an aligned dimension's line reach their text (#12093)

The value text is drawn level, in an upright box, and the line runs
through its middle. The layout stopped the line where the box's farthest
corner reaches along it (half.x*|u.x| + half.y*|u.y|), not where the line
leaves the box (min(half.x/|u.x|, half.y/|u.y|)). They agree only when the
line is level or upright: at 45 degrees a radius leader stopped about
12 px short of its text, and an aligned dimension's line broke too wide
around its value.

One helper, box_exit, gives where the line leaves the box, for the radial
leader, the linear break and the leader to a text pulled past the
extension lines. Whether the text fits between the arrows still goes by
the whole box. A text box that isn't finite counts as empty, and one
larger than a sketch can be is held to MAX_COORD.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
CamWightandClaude Opus 5.5 authored and GitHub committed 2026-11-04 22:05:13 +00:00
1 parent 6870f9539c
commit 2ce55baba1
1 file changed
+88 -6
+88 -6
View File
@@ -11,7 +11,7 @@
use solidcore_record::Vec2;
use solidcraft_geom::prelude::*;
use crate::model::{ConstraintKind, CurveKind, Sketch, TwoCircles};
use crate::model::{ConstraintKind, CurveKind, MAX_COORD, Sketch, TwoCircles};
use crate::union_find::{find, union};
/// What a dimension measures, in a form that can be drawn.
@@ -297,6 +297,13 @@ fn nearest_on(s: (Vec2, Vec2), q: Vec2) -> Vec2 {
s.0 + d * ((q - s.0).dot(d) / l2).clamp(0.0, 1.0)
}
/// How far a line from the centre of an upright text box of half size `half` runs along the
/// unit `u` before it leaves the box. An axis `u` doesn't move along gives `h / 0` (infinite,
/// or NaN for an empty box), which `min` passes over.
fn box_exit(half: Vec2, u: Vec2) -> f64 {
(half.x / u.x.abs()).min(half.y / u.y.abs())
}
/// Lay a dimension out. `text` is the stored text position (None: the default place), `px`
/// the sketch length of one screen pixel and `half` the half size of the text box (sketch
/// units), which the dimension line leaves a gap for.
@@ -308,6 +315,9 @@ pub fn dim_layout(f: &DimFrame, text: Option<Vec2>, px: f64, half: Vec2) -> DimL
/// point of the geometry in `reach` ([`dim_reach`]) instead of the measured points.
pub fn dim_layout_reaching(f: &DimFrame, text: Option<Vec2>, px: f64, half: Vec2, reach: [Option<(Vec2, Vec2)>; 2]) -> DimLayout {
let px = if px.is_finite() && px > 0.0 { px } else { 1.0 };
// A text box is no larger than a sketch can be.
let size = |h: f64| if h.is_finite() { h.clamp(0.0, MAX_COORD) } else { 0.0 };
let half = Vec2::new(size(half.x), size(half.y));
let arrow = 9.0 * px;
let gap = 3.0 * px;
let over = 4.0 * px;
@@ -337,16 +347,18 @@ pub fn dim_layout_reaching(f: &DimFrame, text: Option<Vec2>, px: f64, half: Vec2
let len = (q1 - q0).dot(dir);
let (lo, hi) = if len >= 0.0 { (q0, q1) } else { (q1, q0) };
let span = len.abs();
// Half the text along the line (it is drawn level on screen).
// The text is drawn level on screen: it fits between the arrows when its whole box
// does (`along`, its farthest corner), and the line stops where it meets the box.
let along = (half.x * dir.x.abs() + half.y * dir.y.abs()) + gap;
let meet = box_exit(half, dir) + gap;
let inside = s.abs() + along <= span * 0.5;
if span > 2.0 * arrow + 2.0 * along && inside {
// Arrows inside, pointing out, the line broken around the text.
out.arrows.push((lo, -dir));
out.arrows.push((hi, dir));
let tc = m + n * h + dir * s;
out.lines.push(vec![lo, tc - dir * along]);
out.lines.push(vec![tc + dir * along, hi]);
out.lines.push(vec![lo, tc - dir * meet]);
out.lines.push(vec![tc + dir * meet, hi]);
} else {
// Too tight (or the text pulled out): arrows outside pointing in, short tails.
out.arrows.push((lo, dir));
@@ -358,7 +370,7 @@ pub fn dim_layout_reaching(f: &DimFrame, text: Option<Vec2>, px: f64, half: Vec2
let reach = (tc - m - n * h).dot(dir);
if reach.abs() > span * 0.5 + tail {
let end = if reach > 0.0 { hi + dir * tail } else { lo - dir * tail };
out.lines.push(vec![end, tc - dir * (along * reach.signum())]);
out.lines.push(vec![end, tc - dir * (meet * reach.signum())]);
}
}
}
@@ -377,7 +389,8 @@ pub fn dim_layout_reaching(f: &DimFrame, text: Option<Vec2>, px: f64, half: Vec2
}
}
}
let rim = half.x * u.x.abs() + half.y * u.y.abs() + gap;
// The leader stops where it meets the (level) text box.
let rim = box_exit(half, u) + gap;
let from = if diameter { center - u * radius } else { center };
if d > radius {
// Leader from the far side (or centre) out to the text, arrows on the rim.
@@ -614,4 +627,73 @@ mod tests {
let q = sk.add_point(Vec2::new(30.0, -80.0), None).unwrap_or(0);
assert!(dim_reach(&sk, &ConstraintKind::PointLineDistance { p: q, l, value: 30.0 })[1].is_none());
}
/// Where a line from the centre of an upright text box of half size `half` leaves it, along `u`.
fn exit(half: Vec2, u: Vec2) -> f64 {
(half.x / u.x.abs()).min(half.y / u.y.abs())
}
#[test]
fn a_line_through_its_text_stops_at_the_text_box() {
// A leader or a dimension line at an angle stops the gap past the text box's edge, not
// where the box's farthest corner reaches along it.
let (px, half) = (0.1, Vec2::new(2.5, 0.8));
let gap = 3.0 * px;
let deg = std::f64::consts::PI / 180.0;
for a in [0.0, 1e-9, 30.0 * deg, 45.0 * deg, 90.0 * deg - 1e-9, 90.0 * deg, 135.0 * deg, 270.0 * deg] {
let u = Vec2::from_angle(a);
let want = exit(half, u) + gap;
for diameter in [false, true] {
let circle = DimFrame::Radial { center: Vec2::new(5.0, -3.0), radius: 10.0, diameter, arc: None };
// Text outside: the leader ends `want` short of the text.
let lay = dim_layout(&circle, Some(u * 30.0), px, half);
let end = lay.lines[0][lay.lines[0].len() - 1];
assert!((end.dist(lay.text) - want).abs() < 1e-9, "{a} {diameter}: {} vs {want}", end.dist(lay.text));
// Text inside: the line breaks `want` either side of it.
let lay = dim_layout(&circle, Some(u * 4.0), px, half);
assert_eq!(lay.lines.len(), 2, "{a} {diameter}");
assert!((lay.lines[0][1].dist(lay.text) - want).abs() < 1e-9 && (lay.lines[1][0].dist(lay.text) - want).abs() < 1e-9);
}
}
// An aligned linear dimension at 0°, 45° and 90°: the line breaks `want` either side of its text.
for a in [0.0, 45.0 * deg, 90.0 * deg] {
let dir = Vec2::from_angle(a);
let f = DimFrame::Linear { p0: Vec2::ZERO, p1: dir * 100.0, dir };
let lay = dim_layout(&f, Some(Vec2::new(0.0, 10.0)), px, half);
let want = exit(half, dir) + gap;
assert_eq!(lay.lines.len(), 4, "{a}");
assert!((lay.lines[2][1].dist(lay.text) - want).abs() < 1e-9, "{a}: {} vs {want}", lay.lines[2][1].dist(lay.text));
assert!((lay.lines[3][0].dist(lay.text) - want).abs() < 1e-9);
// Pulled out past the extension lines: the leader along the line reaches it too.
let lay = dim_layout(&f, Some(Vec2::new(80.0, 10.0)), px, half);
assert_eq!(lay.lines.len(), 4, "{a}");
assert!((lay.lines[3][1].dist(lay.text) - want).abs() < 1e-9, "{a}: {} vs {want}", lay.lines[3][1].dist(lay.text));
}
// Whether the text fits between the arrows still goes by the whole box: at 45° a 6 long
// dimension fits the line's crossing of the box (2.86 with the gaps) but not its corners.
let dir = Vec2::from_angle(45.0 * deg);
let l = dim_layout(&DimFrame::Linear { p0: Vec2::ZERO, p1: dir * 6.0, dir }, Some(Vec2::new(0.0, 10.0)), px, half);
assert!(close(l.arrows[0].1, dir) && close(l.arrows[1].1, -dir), "arrows outside: {:?}", l.arrows);
}
#[test]
fn hostile_text_boxes_lay_out_finite() {
let frames = [
DimFrame::Radial { center: Vec2::ZERO, radius: 10.0, diameter: false, arc: None },
DimFrame::Radial { center: Vec2::ZERO, radius: 10.0, diameter: true, arc: Some((0.0, 1.0)) },
DimFrame::Linear { p0: Vec2::ZERO, p1: Vec2::new(70.0, 70.0), dir: Vec2::new(1.0, 1.0) * std::f64::consts::FRAC_1_SQRT_2 },
DimFrame::Linear { p0: Vec2::ZERO, p1: Vec2::new(100.0, 0.0), dir: Vec2::X },
];
let sizes = [0.0, -1.0, f64::NAN, f64::INFINITY, f64::NEG_INFINITY, 1e300, 1e-300, f64::MAX];
let texts = [Vec2::new(20.0, 20.0), Vec2::new(3.0, 0.0), Vec2::new(0.0, 1e-9), Vec2::new(300.0, 10.0), Vec2::new(-300.0, -10.0)];
for f in &frames {
for (hx, hy) in sizes.iter().flat_map(|x| sizes.iter().map(move |y| (*x, *y))) {
for text in texts {
let lay = dim_layout(f, Some(text), 0.1, Vec2::new(hx, hy));
let mut points = lay.lines.iter().flatten().chain(lay.arrows.iter().map(|(p, _)| p));
assert!(lay.text.is_finite() && points.all(|p| p.is_finite()), "{f:?} {hx} {hy} {text:?}: {:?}", lay.lines);
}
}
}
}
}