1b-agent/OneCAD-Draft
1
0 Fork 0
forked from 1b-agent/opencadstudio-upstream
Code Pull Requests Activity

feat(dimension): complete diameter workflow

Browse Source
This commit is contained in:
Hakan Seven committed 2026-08-25 20:57:28 +03:00
2 parents 8140c39e0d 75f042607e
commit 9ded5eb04f
27 files changed
+659 -218
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/modules/annotate/diameter_dim.rs
+144 -62
View File
@@ -1,11 +1,11 @@
// DIMDIAMETER command — diameter dimension for circles and arcs.
use acadrust::entities::{Dimension, DimensionDiameter};
use acadrust::types::Vector3;
use acadrust::types::{Handle, Vector3};
use acadrust::EntityType;
use glam::{DVec3, Vec3};
use crate::command::{CadCommand, CmdResult, WorkingPlane};
use crate::command::{
CadCommand, CmdOption, CmdResult, DimensionAssociationInput, WorkingPlane,
};
use crate::modules::{IconKind, ModuleEvent, ToolDef};
use crate::scene::model::wire_model::WireModel;
use crate::t;
@@ -22,40 +22,43 @@ pub fn tool() -> ToolDef {
}
enum Step {
CenterPoint,
ArcPoint(DVec3),
TextPoint { center: DVec3, arc_pt: DVec3 },
SelectObject,
DimLine(crate::scene::dimension_assoc::RadialSourceGeometry),
}
pub struct DiameterDimensionCommand {
step: Step,
plane: WorkingPlane,
/// Optional text that replaces the measured value (None = measurement).
text_override: Option<String>,
/// True while the next typed line is captured as the text override.
awaiting_text: bool,
/// Explicit text rotation in radians (None = follow the UCS/style).
text_angle: Option<f64>,
/// True while the next typed value is captured as the text angle.
awaiting_angle: bool,
picked_entity: Option<EntityType>,
source_handle: Option<Handle>,
}
impl DiameterDimensionCommand {
pub fn new() -> Self {
Self {
step: Step::CenterPoint,
plane: WorkingPlane::default(),
step: Step::SelectObject,
text_override: None,
awaiting_text: false,
text_angle: None,
awaiting_angle: false,
picked_entity: None,
source_handle: None,
}
}
fn editor_anchor(&self) -> DVec3 {
match self.step {
Step::SelectObject => DVec3::ZERO,
Step::DimLine(source) => dvec(source.point_at_angle(source.start_angle)),
}
}
}
impl CadCommand for DiameterDimensionCommand {
fn set_working_plane(&mut self, plane: WorkingPlane) {
self.plane = plane;
fn set_working_plane(&mut self, _plane: WorkingPlane) {
}
fn name(&self) -> &'static str {
@@ -64,54 +67,58 @@ impl CadCommand for DiameterDimensionCommand {
fn prompt(&self) -> String {
if self.awaiting_text {
return t!("DIMDIAMETER Enter dimension text (blank = measured value):").into_owned();
return t!("DIMDIAMETER Enter dimension text (blank = measured value):")
.into_owned();
}
if self.awaiting_angle {
return t!("DIMDIAMETER Specify text angle (degrees):").into_owned();
}
match self.step {
Step::CenterPoint => t!("DIMDIAMETER Specify center point:").into_owned(),
Step::ArcPoint(_) => t!("DIMDIAMETER Specify point on circle:").into_owned(),
Step::TextPoint { .. } => {
t!("DIMDIAMETER Specify dimension line location [Text/Angle]:").into_owned()
Step::SelectObject => {
t!("DIMDIAMETER Select arc, circle, or polyline arc:").into_owned()
}
Step::DimLine(_) => {
t!("DIMDIAMETER Specify dimension line location [Mtext/Text/Angle]:")
.into_owned()
}
}
}
fn on_point(&mut self, pt: DVec3) -> CmdResult {
match self.step {
Step::CenterPoint => {
self.step = Step::ArcPoint(pt);
CmdResult::NeedPoint
}
Step::ArcPoint(center) => {
self.step = Step::TextPoint { center, arc_pt: pt };
CmdResult::NeedPoint
}
Step::TextPoint { center, arc_pt } => {
let center = self.plane.to_local(center);
let arc_pt = self.plane.to_local(arc_pt);
let pt = self.plane.to_local(pt);
let mut dim = DimensionDiameter::new(v3(center), v3(arc_pt));
dim.base.definition_point = v3(arc_pt);
Step::SelectObject => CmdResult::NeedPoint,
Step::DimLine(source) => {
let source_plane = WorkingPlane::new(
DVec3::from_array(source.plane.origin),
DVec3::from_array(source.plane.x_axis),
DVec3::from_array(source.plane.y_axis),
);
let chord = source_plane.to_local(dvec(source.chord_at(pt.to_array())));
let far_chord = source_plane.to_local(dvec(source.opposite_chord_at(pt.to_array())));
let pt = source_plane.to_local(pt);
let mut dim = DimensionDiameter::new(v3(chord), v3(far_chord));
dim.base.text_middle_point = v3(pt);
dim.base.insertion_point = v3(pt);
dim.leader_length = arc_pt.distance(pt);
dim.base.text_user_positioned = true;
dim.leader_length = chord.distance(pt);
dim.base.actual_measurement = dim.measurement();
dim.base.user_text = self.text_override.clone();
// An explicit text angle overrides the default rotation.
crate::entities::dimension::set_dimension_text_override(
&mut dim.base,
self.text_override.clone(),
);
if let Some(a) = self.text_angle {
dim.base.text_rotation = a;
}
CmdResult::CommitAndExit(self.plane.place_entity(EntityType::Dimension(
Dimension::Diameter(dim),
)))
CmdResult::CommitDimension {
entity: source_plane
.place_entity(EntityType::Dimension(Dimension::Diameter(dim))),
association: DimensionAssociationInput::Infer(self.source_handle),
}
}
}
}
fn on_enter(&mut self) -> CmdResult {
// A bare Enter while entering override text accepts the measured value.
if self.awaiting_text {
self.awaiting_text = false;
return CmdResult::NeedPoint;
@@ -123,24 +130,37 @@ impl CadCommand for DiameterDimensionCommand {
CmdResult::Cancel
}
fn on_escape(&mut self) -> CmdResult {
CmdResult::Cancel
}
fn wants_text_input(&self) -> bool {
true
}
fn point_step_accepts_keywords(&self) -> bool {
// While entering the override text or angle it is a value, not a point step.
!self.awaiting_text && !self.awaiting_angle
}
fn wants_text_with_spaces(&self) -> bool {
// The override text may contain spaces.
self.awaiting_text
}
fn options(&self) -> Vec<CmdOption> {
if matches!(self.step, Step::DimLine(_)) && !self.awaiting_text && !self.awaiting_angle {
vec![
CmdOption::new("MText", "MTEXT"),
CmdOption::new("Text", "TEXT"),
CmdOption::new("Angle", "ANGLE"),
]
} else {
Vec::new()
}
}
fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
if self.awaiting_text {
let t = text.trim();
// Blank (or the "<>" placeholder) keeps the measured value.
self.text_override = if t.is_empty() || t == "<>" {
None
} else {
@@ -151,7 +171,6 @@ impl CadCommand for DiameterDimensionCommand {
}
if self.awaiting_angle {
let t = text.trim();
// Blank clears any explicit angle (follow the default again).
self.text_angle = if t.is_empty() {
None
} else {
@@ -160,11 +179,19 @@ impl CadCommand for DiameterDimensionCommand {
self.awaiting_angle = false;
return Some(CmdResult::NeedPoint);
}
match text.trim().to_uppercase().as_str() {
"T" | "TEXT" | "M" | "MTEXT" => {
if !matches!(self.step, Step::DimLine(_)) {
return None;
}
match text.trim().to_ascii_uppercase().as_str() {
"T" | "TEXT" => {
self.awaiting_text = true;
Some(CmdResult::NeedPoint)
}
"M" | "MTEXT" => Some(CmdResult::SuspendForMTextInput {
pos: self.editor_anchor(),
initial: self.text_override.clone().unwrap_or_default(),
height: 2.5,
}),
"A" | "ANGLE" => {
self.awaiting_angle = true;
Some(CmdResult::NeedPoint)
@@ -173,14 +200,60 @@ impl CadCommand for DiameterDimensionCommand {
}
}
fn on_editor_text(&mut self, value: String) {
let value = value.trim();
self.text_override = if value.is_empty() || value == "<>" {
None
} else {
Some(value.to_string())
};
}
fn on_editor_closed(&mut self, _committed: bool) -> CmdResult {
CmdResult::NeedPoint
}
fn needs_entity_pick(&self) -> bool {
matches!(self.step, Step::SelectObject)
}
fn entity_pick_highlights_hover(&self) -> bool {
true
}
fn inject_before_entity_pick(&self) -> bool {
true
}
fn inject_picked_entity(&mut self, entity: EntityType) {
self.picked_entity = Some(entity);
}
fn on_entity_pick(&mut self, handle: Handle, point: DVec3) -> CmdResult {
let Some(entity) = self.picked_entity.take() else {
return CmdResult::NeedPoint;
};
let Some(source) = crate::scene::dimension_assoc::radial_source_at(
&entity,
Vector3::new(point.x, point.y, point.z),
) else {
return CmdResult::NeedPoint;
};
if !source.radius.is_finite() || source.radius <= 1e-12 {
return CmdResult::NeedPoint;
}
self.source_handle = Some(handle);
self.step = Step::DimLine(source);
CmdResult::NeedPoint
}
fn on_mouse_move(&mut self, pt: DVec3) -> Option<WireModel> {
let pt = pt.as_vec3();
match self.step {
Step::CenterPoint => None,
Step::ArcPoint(center) => Some(preview_line(center.as_vec3(), pt)),
Step::TextPoint { center, arc_pt } => {
let far = center + (center - arc_pt); // opposite point on circle
Some(preview_line(far.as_vec3(), pt))
Step::SelectObject => None,
Step::DimLine(source) => {
let chord = dvec(source.chord_at(pt.to_array())).as_vec3();
let far_chord = dvec(source.opposite_chord_at(pt.to_array())).as_vec3();
Some(preview_line(far_chord, chord, pt.as_vec3()))
}
}
}
@@ -190,7 +263,12 @@ fn v3(p: DVec3) -> Vector3 {
Vector3::new(p.x, p.y, p.z)
}
fn preview_line(a: Vec3, b: Vec3) -> WireModel {
fn dvec(point: Vector3) -> DVec3 {
DVec3::new(point.x, point.y, point.z)
}
fn preview_line(far_chord: Vec3, chord: Vec3, text: Vec3) -> WireModel {
let separator = [f32::NAN; 3];
WireModel {
point_marker: None,
taper_widths: Vec::new(),
@@ -204,11 +282,17 @@ fn preview_line(a: Vec3, b: Vec3) -> WireModel {
render_instance: None,
pick_tris: Vec::new(),
pick_tris_low: Vec::new(),
dash_from_start: false,
dash_align_end: None,
text_verts: Vec::new(),
dash_from_start: false,
dash_align_end: None,
text_verts: Vec::new(),
name: "dimdia_preview".into(),
points: vec![[a.x, a.y, a.z], [b.x, b.y, b.z]],
points: vec![
far_chord.to_array(),
chord.to_array(),
separator,
chord.to_array(),
text.to_array(),
],
points_low: Vec::new(),
color: WireModel::CYAN,
selected: false,
@@ -226,6 +310,4 @@ fn preview_line(a: Vec3, b: Vec3) -> WireModel {
}
}
// ── Autocomplete registry ─────────────────────────────────
inventory::submit!(crate::command::CommandRegistration { names: &["DIMDIAMETER"] }); // DiameterDimensionCommand
inventory::submit!(crate::command::CommandRegistration { names: &["DIMDIAMETER"] });
src/modules/draw/modify/explode.rs
+157 -20
View File
@@ -612,10 +612,66 @@ struct DimMetrics {
/// suppression), DIMCLRD/E/T (colours) and DIMLWD/E (lineweights).
fn dim_metrics(dim: &Dimension, doc: &CadDocument) -> DimMetrics {
let name = dim.base().style_name.as_str();
let style = doc.dim_styles.iter().find(|s| {
let mut effective_style = doc.dim_styles.iter().find(|s| {
s.name.eq_ignore_ascii_case(name)
|| (name.trim().is_empty() && s.name.eq_ignore_ascii_case("Standard"))
});
}).cloned();
if let Some(style) = &mut effective_style {
use crate::entities::dim_override as ov;
let data = &dim.base().common.extended_data;
macro_rules! real {
($field:ident, $code:ident) => {
if let Some(value) = ov::real(data, ov::$code) {
style.$field = value;
}
};
}
macro_rules! int {
($field:ident, $code:ident) => {
if let Some(value) = ov::int(data, ov::$code) {
style.$field = value;
}
};
}
macro_rules! flag {
($field:ident, $code:ident) => {
if let Some(value) = ov::int(data, ov::$code) {
style.$field = value != 0;
}
};
}
macro_rules! handle {
($field:ident, $code:ident) => {
if let Some(value) = ov::handle(data, ov::$code) {
style.$field = value;
}
};
}
real!(dimscale, DIMSCALE);
real!(dimasz, DIMASZ);
real!(dimcen, DIMCEN);
real!(dimexo, DIMEXO);
real!(dimexe, DIMEXE);
real!(dimtsz, DIMTSZ);
real!(dimdle, DIMDLE);
real!(dimfxl, DIMFXL);
flag!(dimfxlon, DIMFXLON);
flag!(dimse1, DIMSE1);
flag!(dimse2, DIMSE2);
flag!(dimsd1, DIMSD1);
flag!(dimsd2, DIMSD2);
flag!(dimsoxd, DIMSOXD);
flag!(dimsah, DIMSAH);
int!(dimclrd, DIMCLRD);
int!(dimclre, DIMCLRE);
int!(dimclrt, DIMCLRT);
int!(dimlwd, DIMLWD);
int!(dimlwe, DIMLWE);
handle!(dimblk, DIMBLK);
handle!(dimblk1, DIMBLK1);
handle!(dimblk2, DIMBLK2);
}
let style = effective_style.as_ref();
let scale = style
.map(|s| if s.dimscale > 1e-6 { s.dimscale } else { 1.0 })
.unwrap_or(1.0);
@@ -630,7 +686,15 @@ fn dim_metrics(dim: &Dimension, doc: &CadDocument) -> DimMetrics {
let t = ArrowKind::Tick { size: dimtsz as f32 };
(t.clone(), t)
} else if let Some(s) = style {
if s.dimsah {
if matches!(dim, Dimension::Diameter(_)) {
use crate::entities::dim_override as ov;
let data = &dim.base().common.extended_data;
let first = ov::handle(data, ov::DIMBLK1)
.unwrap_or(if s.dimsah { s.dimblk1 } else { s.dimblk });
let second = ov::handle(data, ov::DIMBLK2)
.unwrap_or(if s.dimsah { s.dimblk2 } else { s.dimblk });
(arrow_from_block(doc, first, asz), arrow_from_block(doc, second, asz))
} else if s.dimsah {
(arrow_from_block(doc, s.dimblk1, asz), arrow_from_block(doc, s.dimblk2, asz))
} else {
let a = arrow_from_block(doc, s.dimblk, asz);
@@ -993,27 +1057,101 @@ fn explode_dimension(dim: &Dimension, doc: &CadDocument) -> Vec<EntityType> {
result.extend(dim_center_mark(center, met.dimcen, len, &dim_c));
}
Dimension::Diameter(d) => {
// Full diameter through the centre (far edge -> near edge), inward
// terminators at both edges, plus the centre mark.
let (center, edge) = (d.angle_vertex, d.definition_point);
let far = v3(2.0 * center.x - edge.x, 2.0 * center.y - edge.y, edge.z);
result.push(make_seg(&far, &edge, &dim_c));
let (edge, far) = (d.angle_vertex, d.definition_point);
let center = v3(
(edge.x + far.x) * 0.5,
(edge.y + far.y) * 0.5,
(edge.z + far.z) * 0.5,
);
let len = ((edge.x - far.x).powi(2) + (edge.y - far.y).powi(2))
.sqrt()
.max(1e-12);
let (ux, uy) = ((edge.x - far.x) / len, (edge.y - far.y) / len);
result.extend(dim_terminator(edge, -ux, -uy, &met.arrow1, &dim_c));
result.extend(dim_terminator(far, ux, uy, &met.arrow2, &dim_c));
// Optional leader past the near edge toward the text. DIM-DIA-LEADER.
if d.leader_length.abs() > 1e-9 {
let anchor = dim_text_anchor(base, center, edge);
let ld = norm2(anchor.x - edge.x, anchor.y - edge.y, ux, uy);
let ticks = met.dimtsz > 1e-9;
let extension = if ticks { met.dimdle } else { 0.0 };
let edge_outer = v3(
edge.x + ux * extension,
edge.y + uy * extension,
edge.z,
);
let far_outer = v3(
far.x - ux * extension,
far.y - uy * extension,
far.z,
);
if !met.dimsd1 {
result.push(make_seg(&edge_outer, &center, &dim_c));
}
if !met.dimsd2 {
result.push(make_seg(&center, &far_outer, &dim_c));
}
let outside = !ticks && met.dimasz > 1e-6 && len < 2.0 * met.dimasz;
if outside {
result.extend(dim_terminator(edge, ux, uy, &met.arrow1, &dim_c));
result.extend(dim_terminator(far, -ux, -uy, &met.arrow2, &dim_c));
if !met.dimsoxd {
let stub = 2.0 * met.dimasz;
if !met.dimsd1 {
result.push(make_seg(
&edge,
&v3(edge.x + ux * stub, edge.y + uy * stub, edge.z),
&dim_c,
));
}
if !met.dimsd2 {
result.push(make_seg(
&far,
&v3(far.x - ux * stub, far.y - uy * stub, far.z),
&dim_c,
));
}
}
} else {
result.extend(dim_terminator(edge, -ux, -uy, &met.arrow1, &dim_c));
result.extend(dim_terminator(far, ux, uy, &met.arrow2, &dim_c));
}
let anchor = dim_text_anchor(base, center, edge);
let distance_squared = |first: Vector3, second: Vector3| {
(first.x - second.x).powi(2)
+ (first.y - second.y).powi(2)
+ (first.z - second.z).powi(2)
};
let (leader_tip, suppressed, fallback) = if distance_squared(anchor, edge)
<= distance_squared(anchor, far)
{
(edge, met.dimsd1, (ux, uy))
} else {
(far, met.dimsd2, (-ux, -uy))
};
if !suppressed && d.leader_length.abs() > 1e-9 {
let ld = norm2(
anchor.x - leader_tip.x,
anchor.y - leader_tip.y,
fallback.0,
fallback.1,
);
result.push(make_seg(
&edge,
&v3(edge.x + ld.0 * d.leader_length, edge.y + ld.1 * d.leader_length, edge.z),
&leader_tip,
&v3(
leader_tip.x + ld.0 * d.leader_length.abs(),
leader_tip.y + ld.1 * d.leader_length.abs(),
leader_tip.z,
),
&dim_c,
));
}
if !met.dimse1 {
if let Some(points) = crate::scene::dimension_assoc::radial_extension_points(
doc,
base.common.handle,
met.dimexo,
met.dimexe,
) {
for pair in points.windows(2) {
result.push(make_seg(&pair[0], &pair[1], &ext_c));
}
}
}
result.extend(dim_center_mark(center, met.dimcen, len * 0.5, &dim_c));
}
Dimension::Angular2Ln(d) => {
@@ -1566,16 +1704,15 @@ mod tests {
assert!(lines > 5, "angular bake must include arc chords, got {lines} lines");
}
// A diameter dimension bakes a line edge-to-edge THROUGH the centre, not a
// radius-length line. The two extreme endpoints must be equidistant from the
// centre (angle_vertex) and the centre must lie between them.
// Diameter endpoints stay equidistant from the circle center.
#[test]
fn diameter_dim_bakes_through_center() {
use acadrust::entities::DimensionDiameter;
let mut doc = CadDocument::new();
let center = Vector3::new(3.0, 4.0, 0.0);
let edge = Vector3::new(8.0, 4.0, 0.0); // radius 5 along +x
let mut d = DimensionDiameter::new(center, edge);
let far = Vector3::new(-2.0, 4.0, 0.0);
let mut d = DimensionDiameter::new(edge, far);
d.base.text_middle_point = Vector3::new(3.0, 9.0, 0.0);
let handle = doc
.add_entity(EntityType::Dimension(Dimension::Diameter(d)))