a770fa5a5e5f
linear.rs
use super::text::linear_text;
use super::{DimConfig, DimGeometry, DimKind, LineRole, Vec2, ext_line, readable};
struct LinearDimState {
p1: Vec2,
p2: Vec2,
f1: Vec2,
f2: Vec2,
u: Vec2,
n: Vec2,
measurement: f64,
text_width: f64,
text_height: f64,
has_text: bool,
tick_like: bool,
arrow_width: f64,
arrows_inside: bool,
text_outside: bool,
just: u8,
centred: bool,
moved: bool,
outside_arrows: bool,
angle: f64,
half_extent: f64,
along_center: Vec2,
side_out: Vec2,
text_axis: Vec2,
offset: Vec2,
text_mid: Vec2,
}
pub(super) fn draw_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2) {
let mut state = prepare_linear(config, g, *text_mid_out);
position_linear_text(config, &mut state);
draw_linear_lines(config, g, &state);
*text_angle_out = state.angle;
*text_mid_out = state.text_mid;
}
fn prepare_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_mid: Vec2) -> LinearDimState {
let d = config.dimension;
let st = config.style;
let p1 = d.p13.xy();
let p2 = d.p14.xy();
let on = d.defpt.xy();
let direction = match d.kind {
DimKind::Linear { rotation } => Vec2::from_angle(rotation),
_ => (p2 - p1).normalized(),
};
let direction = if direction == Vec2::ZERO || !direction.is_finite() { Vec2::X } else { direction };
let oblique = d.marks.oblique.map(Vec2::from_angle).filter(|axis| axis.is_finite() && axis.cross(direction).abs() > 1e-6);
let foot = |point: Vec2| match oblique {
Some(axis) => point + axis * ((on - point).cross(direction) / axis.cross(direction)),
None => on + direction * (point - on).dot(direction),
};
let (f1, f2) = (foot(p1), foot(p2));
let raw_measurement = (p2 - p1).dot(direction).abs();
g.mtext = linear_text(raw_measurement, d, st, "");
g.measurement = raw_measurement;
let measurement = f1.dist(f2);
if !st.suppress_ext1 {
g.ext_n(ext_line(p1, f1, st, config.scale), false);
}
if !st.suppress_ext2 {
g.ext_n(ext_line(p2, f2, st, config.scale), true);
}
let dimension_axis = (f2 - f1).normalized();
let u = if dimension_axis == Vec2::ZERO || !dimension_axis.is_finite() { direction } else { dimension_axis };
let n = u.perp();
let (text_width, text_height) = config.measure(&g.mtext);
let has_text = text_width > 0.0;
let tick_like = config.ticks || (config.first_arrow.is_tick() && config.second_arrow.is_tick());
let arrow_width = if tick_like { 0.0 } else { config.arrow_size };
let arrows_fit = tick_like || measurement > 2.0 * config.arrow_size + 1e-9;
let along_angle = readable(u.angle());
let extent = |angle: f64| {
let axis = Vec2::from_angle(angle);
(text_width * axis.dot(u).abs() + text_height * axis.perp().dot(u).abs()) / 2.0
};
let inside_angle = text_angle(config, st.text_inside_horizontal, along_angle);
let tvp = if st.text_above == 0 && st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 };
let centred = st.text_above == 0 && tvp.abs() < 0.7;
let text_need = if centred { 2.0 * (extent(inside_angle) + config.gap) } else { 2.0 * extent(inside_angle) };
let fits = !has_text || measurement >= text_need + 2.0 * arrow_width;
let text_fits = !has_text || measurement >= text_need;
let just = st.text_just.min(4);
let (text_inside, arrows_inside) = if d.user_text_pos || !has_text || just >= 3 {
(true, arrows_fit)
} else if fits {
(true, true)
} else if st.text_inside {
(true, false)
} else {
match st.fit {
0 => (false, false),
1 => (text_fits, false),
2 => (false, arrows_fit),
_ if arrows_fit => (false, true),
_ => (text_fits, false),
}
};
let text_outside = !text_inside;
LinearDimState {
p1,
p2,
f1,
f2,
u,
n,
measurement,
text_width,
text_height,
has_text,
tick_like,
arrow_width,
arrows_inside,
text_outside,
just,
centred,
moved: text_outside && st.text_move != 0,
outside_arrows: !arrows_inside && !st.suppress_outside_arrows,
angle: 0.0,
half_extent: 0.0,
along_center: f1.mid(f2),
side_out: n,
text_axis: Vec2::X,
offset: Vec2::ZERO,
text_mid,
}
}
/// The text's angle: an explicit text rotation (DIMTEDIT Angle, the Properties palette's Text
/// rotation) turns it, so the dimension line leaves room for the text as turned; otherwise
/// horizontal (DIMTIH inside, DIMTOH outside) or `along` the line.
fn text_angle(config: &DimConfig<'_>, horizontal: bool, along: f64) -> f64 {
let rotation = config.dimension.text_rotation;
if rotation != 0.0 && rotation.is_finite() {
rotation
} else if horizontal {
0.0
} else {
along
}
}
fn position_linear_text(config: &DimConfig<'_>, state: &mut LinearDimState) {
let st = config.style;
let along_angle = readable(state.u.angle());
let extent = |angle: f64| {
let axis = Vec2::from_angle(angle);
(state.text_width * axis.dot(state.u).abs() + state.text_height * axis.perp().dot(state.u).abs()) / 2.0
};
let inside_angle = text_angle(config, st.text_inside_horizontal, along_angle);
state.angle = if state.text_outside { text_angle(config, st.text_outside_horizontal, along_angle) } else { inside_angle };
state.half_extent = extent(state.angle);
state.along_center = if state.text_outside {
state.f2 + state.u * (2.0 * config.arrow_size.max(config.tick_size) + config.gap + state.half_extent)
} else {
match state.just {
1 => state.f1 + state.u * (state.arrow_width + config.gap + state.half_extent + config.arrow_size),
2 => state.f2 - state.u * (state.arrow_width + config.gap + state.half_extent + config.arrow_size),
_ => state.f1.mid(state.f2),
}
};
state.side_out = if (config.dimension.defpt.xy() - state.p1).dot(state.n) >= 0.0 { state.n } else { -state.n };
state.text_axis = Vec2::from_angle(state.angle);
let clearance = |axis: Vec2, across: f64| {
config.gap + state.text_width * state.text_axis.dot(axis).abs() / 2.0 + state.text_height * state.text_axis.perp().dot(axis).abs() * across
};
// Empirical #2004 match: 0.595× height with SHX and 0.601× with TrueType.
let off_along = |axis: Vec2| clearance(axis, if st.text_above == 1 { 0.6 } else { 0.5 });
let above = if state.angle.abs() < 1e-12 && state.n.y.abs() > 1e-9 {
if state.n.y > 0.0 { state.n } else { -state.n }
} else if state.angle.abs() < 1e-12 {
if state.n.x < 0.0 { state.n } else { -state.n }
} else if state.text_axis.perp().dot(state.n) >= 0.0 {
state.n
} else {
-state.n
};
state.offset = match st.text_above {
0 => above * (if st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 } * config.text_height),
2 => state.side_out * off_along(state.side_out),
4 => -above * off_along(-above),
_ => above * off_along(above),
};
if state.just >= 3 && !config.dimension.user_text_pos && state.has_text {
let (point, foot) = if state.just == 3 { (state.p1, state.f1) } else { (state.p2, state.f2) };
let extension_axis = (foot - point).normalized();
let extension_axis = if extension_axis == Vec2::ZERO { state.side_out } else { extension_axis };
state.angle = readable(extension_axis.angle());
let outward = if state.just == 3 { -state.u } else { state.u };
state.text_mid = foot
+ extension_axis * (st.ext_extend * config.scale + config.gap + state.text_width / 2.0)
+ outward * (config.gap + state.text_height / 2.0);
} else if state.moved {
let mid = state.f1.mid(state.f2);
// Half the text height either way, whatever DIMTAD says (#2222).
let clear = clearance(state.side_out, 0.5);
let lift = clear + 2.0 * config.arrow_size.max(config.tick_size);
state.text_mid =
if st.text_move == 1 { mid + state.side_out * lift + state.u * state.half_extent } else { mid + state.side_out * (lift + clear) };
} else if !config.dimension.user_text_pos {
state.text_mid = state.along_center + state.offset;
}
}
fn draw_linear_lines(config: &DimConfig<'_>, g: &mut DimGeometry, state: &LinearDimState) {
let d = config.dimension;
let st = config.style;
let (u, n) = (state.u, state.n);
let dle = if state.tick_like { st.dim_line_extend * config.scale } else { 0.0 };
let lo = if st.suppress_dim1 { state.measurement / 2.0 } else { f64::NEG_INFINITY };
let hi = if st.suppress_dim2 { state.measurement / 2.0 } else { f64::INFINITY };
let seg = |geometry: &mut DimGeometry, a: Vec2, b: Vec2| {
let (ta, tb) = ((a - state.f1).dot(u), (b - state.f1).dot(u));
let (t0, t1) = (ta.min(tb).max(lo), ta.max(tb).min(hi));
if t1 > t0 + 1e-12 {
geometry.dim(vec![state.f1 + u * t0, state.f1 + u * t1]);
}
};
let inner = |geometry: &mut DimGeometry, a: Vec2, b: Vec2| {
if state.centred && state.has_text && !state.text_outside && state.just <= 2 && !d.user_text_pos {
let half = state.half_extent + config.gap;
let (t0, t1) = ((state.along_center - u * half - state.f1).dot(u), (state.along_center + u * half - state.f1).dot(u));
if t0 > (a - state.f1).dot(u) + 1e-9 {
seg(geometry, a, state.f1 + u * t0);
}
if t1 < (b - state.f1).dot(u) - 1e-9 {
seg(geometry, state.f1 + u * t1, b);
}
} else {
seg(geometry, a, b);
}
};
let to_text = |geometry: &mut DimGeometry, from: Vec2| {
let to = state.text_mid - state.offset - u * (state.half_extent + config.gap);
if state.text_outside && (to - from).dot(u) > 0.0 {
seg(geometry, from, from + u * (to - from).dot(u));
}
};
if state.arrows_inside {
let first_inset = if st.suppress_dim1 { 0.0 } else { config.end(g, config.first_arrow, state.f1, -u) };
let second_inset = if st.suppress_dim2 { 0.0 } else { config.end(g, config.second_arrow, state.f2, u) };
inner(g, state.f1 - u * dle + u * first_inset, state.f2 + u * dle - u * second_inset);
to_text(g, state.f2);
} else {
let stub = config.arrow_size * 2.0;
if state.outside_arrows {
if !st.suppress_dim1 {
config.end(g, config.first_arrow, state.f1, u);
}
if !st.suppress_dim2 {
config.end(g, config.second_arrow, state.f2, -u);
}
seg(g, state.f1 - u * stub, state.f1);
seg(g, state.f2, state.f2 + u * stub);
}
if st.force_line_inside {
inner(g, state.f1, state.f2);
}
to_text(g, if state.outside_arrows { state.f2 + u * stub } else { state.f2 });
}
if (d.user_text_pos || state.moved) && st.text_move == 1 && state.has_text {
let base = state.f1.mid(state.f2);
let offset = (state.text_mid - base).dot(n).abs();
if offset > state.text_height / 2.0 + config.gap + 1e-9 {
let side = if (base - state.text_mid).dot(state.text_axis) >= 0.0 { state.text_axis } else { -state.text_axis };
g.dim(vec![base, state.text_mid + side * (state.text_width / 2.0 + config.gap)]);
}
}
if let Some(jog) = d.marks.jog_line {
let at = state.f1 + u * (jog.xy() - state.f1).dot(u);
let height = 1.5 * config.text_height;
if at.is_finite() && height > 0.0 {
let radius = height / 2.0;
g.cut(at, radius, Some(LineRole::Dim));
g.dim(vec![at - u * radius, at - u * (radius / 4.0) + n * (height / 2.0), at + u * (radius / 4.0) - n * (height / 2.0), at + u * radius]);
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.