Complete arc length dimension workflow

src/modules/annotate/arc_length_dim.rs

@@ -0,0 +1,638 @@
+use acadrust::entities::{Dimension, DimensionArc};
+use acadrust::types::{Handle, Vector3};
+use acadrust::EntityType;
+use cadkernel::geom2d::tessellate::{arc, DEFAULT_SEGMENTS_PER_RADIAN};
+use glam::DVec3;
+
+use crate::command::{
+    CadCommand, CmdOption, CmdResult, DimensionAssociationInput,
+    DimensionAssociationSource, WorkingPlane,
+};
+use crate::modules::{IconKind, ModuleEvent, ToolDef};
+use crate::scene::dimension_assoc::{
+    polyline_arc_point_marker, RadialSourceGeometry,
+    POLYLINE_ARC_CENTER_MARKER,
+};
+use crate::scene::model::wire_model::WireModel;
+
+pub const ICON: IconKind =
+    IconKind::Svg(include_bytes!("../../../assets/icons/dim_angular.svg"));
+
+pub fn tool() -> ToolDef {
+    ToolDef {
+        id: "DIMARC",
+        label: "Arc Length",
+        icon: ICON,
+        event: ModuleEvent::Command("DIMARC".to_string()),
+    }
+}
+
+#[derive(Clone, Copy)]
+enum SourceBinding {
+    Arc,
+    PolylineSegment(i32),
+}
+
+#[derive(Clone, Copy)]
+struct ArcSelection {
+    source: RadialSourceGeometry,
+    binding: SourceBinding,
+    start_angle: f64,
+    end_angle: f64,
+    is_partial: bool,
+}
+
+impl ArcSelection {
+    fn new(source: RadialSourceGeometry, binding: SourceBinding) -> Option<Self> {
+        let sweep = positive_sweep(source.start_angle, source.end_angle);
+        (source.limited && source.radius > 1.0e-12 && sweep > 1.0e-12).then_some(Self {
+            source,
+            binding,
+            start_angle: source.start_angle,
+            end_angle: source.start_angle + sweep,
+            is_partial: false,
+        })
+    }
+
+    fn sweep(self) -> f64 {
+        positive_sweep(self.start_angle, self.end_angle)
+    }
+
+    fn point_at(self, angle: f64) -> DVec3 {
+        dvec(self.source.point_at_angle(angle))
+    }
+
+    fn center(self) -> DVec3 {
+        dvec(self.source.center_world())
+    }
+
+    fn plane(self) -> WorkingPlane {
+        WorkingPlane::new(
+            DVec3::from_array(self.source.plane.origin),
+            DVec3::from_array(self.source.plane.x_axis),
+            DVec3::from_array(self.source.plane.y_axis),
+        )
+    }
+
+    fn clamped_angle(self, point: DVec3) -> f64 {
+        let raw = self.source.angle_at(point.to_array());
+        let relative = (raw - self.start_angle).rem_euclid(std::f64::consts::TAU);
+        let sweep = self.sweep();
+        if relative <= sweep + 1.0e-10 {
+            return self.start_angle + relative.min(sweep);
+        }
+        let start_distance = relative.min(std::f64::consts::TAU - relative);
+        let end_relative = (raw - self.end_angle).rem_euclid(std::f64::consts::TAU);
+        let end_distance = end_relative.min(std::f64::consts::TAU - end_relative);
+        if start_distance <= end_distance {
+            self.start_angle
+        } else {
+            self.end_angle
+        }
+    }
+
+    fn with_partial(self, first: f64, second: f64) -> Option<Self> {
+        let first = (first - self.start_angle)
+            .rem_euclid(std::f64::consts::TAU)
+            .clamp(0.0, self.sweep());
+        let second = (second - self.start_angle)
+            .rem_euclid(std::f64::consts::TAU)
+            .clamp(0.0, self.sweep());
+        let (start, end) = if first <= second {
+            (first, second)
+        } else {
+            (second, first)
+        };
+        (end - start > 1.0e-12).then_some(Self {
+            start_angle: self.start_angle + start,
+            end_angle: self.start_angle + end,
+            is_partial: true,
+            ..self
+        })
+    }
+
+    fn association_sources(self, handle: Handle) -> Vec<Option<DimensionAssociationSource>> {
+        match self.binding {
+            SourceBinding::Arc => vec![
+                Some(DimensionAssociationSource::explicit(handle, -3, 0.0)),
+                Some(DimensionAssociationSource::explicit(
+                    handle,
+                    -2,
+                    self.start_angle,
+                )),
+                Some(DimensionAssociationSource::explicit(
+                    handle,
+                    -2,
+                    self.end_angle,
+                )),
+            ],
+            SourceBinding::PolylineSegment(segment) => {
+                let point_marker = polyline_arc_point_marker(segment);
+                vec![
+                    Some(DimensionAssociationSource::explicit(
+                        handle,
+                        POLYLINE_ARC_CENTER_MARKER,
+                        segment as f64,
+                    )),
+                    Some(DimensionAssociationSource::explicit(
+                        handle,
+                        point_marker,
+                        self.start_angle,
+                    )),
+                    Some(DimensionAssociationSource::explicit(
+                        handle,
+                        point_marker,
+                        self.end_angle,
+                    )),
+                ]
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Step {
+    SelectObject,
+    DimLine(ArcSelection),
+    PartialFirst(ArcSelection),
+    PartialSecond {
+        selection: ArcSelection,
+        first_angle: f64,
+    },
+}
+
+pub struct ArcLengthDimensionCommand {
+    step: Step,
+    picked_entity: Option<EntityType>,
+    source_handle: Option<Handle>,
+    text_override: Option<String>,
+    awaiting_text: bool,
+    text_angle: Option<f64>,
+    awaiting_angle: bool,
+    leader_enabled: bool,
+}
+
+impl ArcLengthDimensionCommand {
+    pub fn new() -> Self {
+        Self {
+            step: Step::SelectObject,
+            picked_entity: None,
+            source_handle: None,
+            text_override: None,
+            awaiting_text: false,
+            text_angle: None,
+            awaiting_angle: false,
+            leader_enabled: false,
+        }
+    }
+
+    fn editor_anchor(&self) -> DVec3 {
+        match self.step {
+            Step::SelectObject => DVec3::ZERO,
+            Step::DimLine(selection)
+            | Step::PartialFirst(selection)
+            | Step::PartialSecond { selection, .. } => {
+                selection.point_at(selection.start_angle + selection.sweep() * 0.5)
+            }
+        }
+    }
+
+    fn commit_dimension(&self, selection: ArcSelection, point: DVec3) -> CmdResult {
+        let plane = selection.plane();
+        let center = plane.to_local(selection.center());
+        let first = plane.to_local(selection.point_at(selection.start_angle));
+        let second = plane.to_local(selection.point_at(selection.end_angle));
+        let picked = plane.to_local(point);
+        let picked_radius = (picked - center).truncate().length();
+        if !picked_radius.is_finite() || picked_radius <= 1.0e-12 {
+            return CmdResult::NeedPoint;
+        }
+
+        let mut dimension = DimensionArc::default();
+        dimension.center_point = v3(center);
+        dimension.first_extension_point = v3(first);
+        dimension.second_extension_point = v3(second);
+        dimension.definition_point = v3(picked);
+        dimension.is_partial = selection.is_partial;
+        dimension.arc_start_parameter = selection.start_angle;
+        dimension.arc_end_parameter = selection.end_angle;
+        dimension.base.definition_point = dimension.definition_point;
+        dimension.base.text_middle_point = dimension.definition_point;
+        dimension.base.insertion_point = dimension.definition_point;
+        dimension.has_leader = self.leader_enabled && selection.sweep() > std::f64::consts::FRAC_PI_2;
+        if dimension.has_leader {
+            let middle = selection.start_angle + selection.sweep() * 0.5;
+            let anchor = DVec3::new(
+                center.x + picked_radius * middle.cos(),
+                center.y + picked_radius * middle.sin(),
+                picked.z,
+            );
+            dimension.first_leader_point = v3(anchor);
+            dimension.second_leader_point = v3(picked);
+            dimension.definition_point = v3(anchor);
+            dimension.base.definition_point = dimension.definition_point;
+            dimension.base.text_user_positioned = true;
+        }
+        dimension.base.actual_measurement = dimension.measurement();
+        crate::entities::dimension::set_dimension_text_override(
+            &mut dimension.base,
+            self.text_override.clone(),
+        );
+        if let Some(angle) = self.text_angle {
+            dimension.base.text_rotation = angle;
+        }
+
+        let association = self.source_handle.map_or_else(
+            || DimensionAssociationInput::Explicit(Vec::new()),
+            |handle| {
+                DimensionAssociationInput::Explicit(
+                    selection.association_sources(handle),
+                )
+            },
+        );
+        CmdResult::CommitDimension {
+            entity: plane.place_entity(EntityType::Dimension(Dimension::Arc(dimension))),
+            association,
+        }
+    }
+}
+
+impl CadCommand for ArcLengthDimensionCommand {
+    fn set_working_plane(&mut self, _plane: WorkingPlane) {}
+
+    fn name(&self) -> &'static str {
+        "DIMARC"
+    }
+
+    fn prompt(&self) -> String {
+        if self.awaiting_text {
+            return "DIMARC  Enter dimension text (blank = measured value):".to_string();
+        }
+        if self.awaiting_angle {
+            return "DIMARC  Specify text angle (degrees):".to_string();
+        }
+        match self.step {
+            Step::SelectObject => {
+                "DIMARC  Select arc or polyline arc segment:".to_string()
+            }
+            Step::DimLine(selection) => {
+                let leader_option = if selection.sweep() > std::f64::consts::FRAC_PI_2 {
+                    if self.leader_enabled { "/No Leader" } else { "/Leader" }
+                } else {
+                    ""
+                };
+                format!(
+                    "DIMARC  Specify arc length dimension location [Mtext/Text/Angle/Partial{leader_option}]:"
+                )
+            }
+            Step::PartialFirst(_) => {
+                "DIMARC  Specify first point of partial arc:".to_string()
+            }
+            Step::PartialSecond { .. } => {
+                "DIMARC  Specify second point of partial arc:".to_string()
+            }
+        }
+    }
+
+    fn on_point(&mut self, point: DVec3) -> CmdResult {
+        match self.step {
+            Step::SelectObject => CmdResult::NeedPoint,
+            Step::DimLine(selection) => self.commit_dimension(selection, point),
+            Step::PartialFirst(selection) => {
+                self.step = Step::PartialSecond {
+                    selection,
+                    first_angle: selection.clamped_angle(point),
+                };
+                CmdResult::NeedPoint
+            }
+            Step::PartialSecond {
+                selection,
+                first_angle,
+            } => {
+                let second_angle = selection.clamped_angle(point);
+                let Some(partial) = selection.with_partial(first_angle, second_angle) else {
+                    return CmdResult::NeedPoint;
+                };
+                self.leader_enabled = false;
+                self.step = Step::DimLine(partial);
+                CmdResult::NeedPoint
+            }
+        }
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        if self.awaiting_text {
+            self.awaiting_text = false;
+            return CmdResult::NeedPoint;
+        }
+        if self.awaiting_angle {
+            self.awaiting_angle = false;
+            return CmdResult::NeedPoint;
+        }
+        CmdResult::Cancel
+    }
+
+    fn on_escape(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+
+    fn wants_text_input(&self) -> bool {
+        true
+    }
+
+    fn point_step_accepts_keywords(&self) -> bool {
+        !self.awaiting_text && !self.awaiting_angle
+    }
+
+    fn wants_text_with_spaces(&self) -> bool {
+        self.awaiting_text
+    }
+
+    fn options(&self) -> Vec<CmdOption> {
+        let Step::DimLine(selection) = self.step else {
+            return Vec::new();
+        };
+        if self.awaiting_text || self.awaiting_angle {
+            return Vec::new();
+        }
+        let mut options = vec![
+            CmdOption::new("MText", "MTEXT"),
+            CmdOption::new("Text", "TEXT"),
+            CmdOption::new("Angle", "ANGLE"),
+            CmdOption::new("Partial", "PARTIAL"),
+        ];
+        if selection.sweep() > std::f64::consts::FRAC_PI_2 {
+            options.push(if self.leader_enabled {
+                CmdOption::new("No Leader", "NOLEADER")
+            } else {
+                CmdOption::new("Leader", "LEADER")
+            });
+        }
+        options
+    }
+
+    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
+        if self.awaiting_text {
+            let value = text.trim();
+            self.text_override = if value.is_empty() || value == "<>" {
+                None
+            } else {
+                Some(value.to_string())
+            };
+            self.awaiting_text = false;
+            return Some(CmdResult::NeedPoint);
+        }
+        if self.awaiting_angle {
+            let value = text.trim();
+            self.text_angle = if value.is_empty() {
+                None
+            } else {
+                crate::entities::common::parse_typed_angle(value)
+            };
+            self.awaiting_angle = false;
+            return Some(CmdResult::NeedPoint);
+        }
+        let Step::DimLine(selection) = self.step else {
+            return None;
+        };
+        match text.trim().to_ascii_uppercase().as_str() {
+            "M" | "MTEXT" => Some(CmdResult::SuspendForMTextInput {
+                pos: self.editor_anchor(),
+                initial: self.text_override.clone().unwrap_or_default(),
+                height: 2.5,
+            }),
+            "T" | "TEXT" => {
+                self.awaiting_text = true;
+                Some(CmdResult::NeedPoint)
+            }
+            "A" | "ANGLE" => {
+                self.awaiting_angle = true;
+                Some(CmdResult::NeedPoint)
+            }
+            "P" | "PARTIAL" => {
+                self.step = Step::PartialFirst(selection);
+                Some(CmdResult::NeedPoint)
+            }
+            "L" | "LEADER" if selection.sweep() > std::f64::consts::FRAC_PI_2 => {
+                self.leader_enabled = true;
+                Some(CmdResult::NeedPoint)
+            }
+            "N" | "NOLEADER" => {
+                self.leader_enabled = false;
+                Some(CmdResult::NeedPoint)
+            }
+            _ => None,
+        }
+    }
+
+    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.limited {
+            return CmdResult::NeedPoint;
+        }
+        let binding = match entity {
+            EntityType::Arc(_) => SourceBinding::Arc,
+            EntityType::LwPolyline(_) | EntityType::Polyline2D(_) => {
+                SourceBinding::PolylineSegment(source.marker)
+            }
+            _ => return CmdResult::NeedPoint,
+        };
+        let Some(selection) = ArcSelection::new(source, binding) else {
+            return CmdResult::NeedPoint;
+        };
+        self.source_handle = Some(handle);
+        self.step = Step::DimLine(selection);
+        CmdResult::NeedPoint
+    }
+
+    fn on_mouse_move(&mut self, point: DVec3) -> Option<WireModel> {
+        match self.step {
+            Step::SelectObject | Step::PartialFirst(_) => None,
+            Step::DimLine(selection) => Some(dimension_preview(
+                selection,
+                point,
+                self.leader_enabled,
+            )),
+            Step::PartialSecond {
+                selection,
+                first_angle,
+            } => {
+                let second_angle = selection.clamped_angle(point);
+                let partial = selection.with_partial(first_angle, second_angle)?;
+                Some(partial_preview(partial))
+            }
+        }
+    }
+}
+
+fn positive_sweep(start: f64, end: f64) -> f64 {
+    let raw = end - start;
+    let mut sweep = raw.rem_euclid(std::f64::consts::TAU);
+    if sweep <= 1.0e-12 && raw.abs() > 1.0e-12 {
+        sweep = std::f64::consts::TAU;
+    }
+    sweep
+}
+
+fn dimension_preview(
+    selection: ArcSelection,
+    point: DVec3,
+    leader: bool,
+) -> WireModel {
+    let plane = selection.plane();
+    let center = plane.to_local(selection.center());
+    let first = plane.to_local(selection.point_at(selection.start_angle));
+    let second = plane.to_local(selection.point_at(selection.end_angle));
+    let point = plane.to_local(point);
+    let radius = (point - center).truncate().length();
+    if radius <= 1.0e-12 {
+        return preview_wire(Vec::new(), "dimarc_preview");
+    }
+    let start_land = DVec3::new(
+        center.x + radius * selection.start_angle.cos(),
+        center.y + radius * selection.start_angle.sin(),
+        point.z,
+    );
+    let end_land = DVec3::new(
+        center.x + radius * selection.end_angle.cos(),
+        center.y + radius * selection.end_angle.sin(),
+        point.z,
+    );
+    let mut points = vec![first, start_land, nan(), second, end_land, nan()];
+    points.extend(
+        arc(
+            [center.x, center.y],
+            radius,
+            selection.start_angle,
+            selection.end_angle,
+            point.z,
+            DEFAULT_SEGMENTS_PER_RADIAN,
+        )
+        .into_iter()
+        .map(DVec3::from_array),
+    );
+    if leader && selection.sweep() > std::f64::consts::FRAC_PI_2 {
+        let middle = selection.start_angle + selection.sweep() * 0.5;
+        points.extend([
+            nan(),
+            DVec3::new(
+                center.x + radius * middle.cos(),
+                center.y + radius * middle.sin(),
+                point.z,
+            ),
+            point,
+        ]);
+    }
+    preview_wire(
+        points
+            .into_iter()
+            .map(|value| if value.is_nan() { value } else { plane.to_world(value) })
+            .collect(),
+        "dimarc_preview",
+    )
+}
+
+fn partial_preview(selection: ArcSelection) -> WireModel {
+    let points = arc(
+        selection.source.center,
+        selection.source.radius,
+        selection.start_angle,
+        selection.end_angle,
+        0.0,
+        DEFAULT_SEGMENTS_PER_RADIAN,
+    )
+    .into_iter()
+    .map(|point| DVec3::from_array(selection.source.plane.point_at([point[0], point[1]])))
+    .collect();
+    preview_wire(points, "dimarc_partial_preview")
+}
+
+fn v3(point: DVec3) -> Vector3 {
+    Vector3::new(point.x, point.y, point.z)
+}
+
+fn dvec(point: Vector3) -> DVec3 {
+    DVec3::new(point.x, point.y, point.z)
+}
+
+fn nan() -> DVec3 {
+    DVec3::splat(f64::NAN)
+}
+
+fn preview_wire(points: Vec<DVec3>, name: &str) -> WireModel {
+    WireModel {
+        point_marker: None,
+        taper_widths: Vec::new(),
+        pattern_stations: Vec::new(),
+        world_width: 0.0,
+        depth_override: None,
+        display_visible: true,
+        plot_visible: true,
+        fill_is_3d: false,
+        fill_is_2d_solid: false,
+        render_instance: None,
+        pick_tris: Vec::new(),
+        pick_tris_low: Vec::new(),
+        dash_from_start: false,
+        dash_align_end: None,
+        text_verts: Vec::new(),
+        name: name.to_string(),
+        points: points
+            .into_iter()
+            .map(|point| [point.x as f32, point.y as f32, point.z as f32])
+            .collect(),
+        points_low: Vec::new(),
+        color: WireModel::CYAN,
+        selected: false,
+        pattern_length: 0.0,
+        pattern: [0.0; 8],
+        line_weight_px: 1.0,
+        snap_pts: vec![],
+        tangent_geoms: vec![],
+        aci: 0,
+        key_vertices: vec![],
+        aabb: WireModel::UNBOUNDED_AABB,
+        plinegen: true,
+        fill_tris: vec![],
+        fill_tris_low: Vec::new(),
+    }
+}
+
+inventory::submit!(crate::command::CommandRegistration { names: &["DIMARC"] });

src/modules/annotate/mod.rs

@@ -1,6 +1,7 @@
 // Annotate module — dimension, text, leader, table, and markup tools.
 
 pub mod aligned_dim;
+pub mod arc_length_dim;
 pub mod angular_dim;
 pub mod data_extract;
 pub mod data_link;
@@ -98,6 +99,11 @@ impl CadModule for AnnotateModule {
                                     angular_dim::tool().label,
                                     angular_dim::tool().icon,
                                 ),
+                                (
+                                    arc_length_dim::tool().id,
+                                    arc_length_dim::tool().label,
+                                    arc_length_dim::tool().icon,
+                                ),
                                 (
                                     radius_dim::tool().id,
                                     radius_dim::tool().label,