Merge pull request #1196 from Ramox81/codex/parity-divide-20260911

src/app/command_driver.rs

@@ -3897,23 +3897,25 @@ impl OpenCADStudio {
                 self.tabs[i].scene.clear_preview_wire();
                 self.restore_pre_cmd_tangent();
             }
-            CmdResult::DivideEntity { handle, n } => {
+            CmdResult::DivideEntity { handle, n, marker } => {
                 use crate::modules::draw::inquiry::divide::divide_entity;
                 let pts = self.tabs[i]
                     .scene
                     .document
                     .get_entity(handle)
-                    .map(|e| divide_entity(e, n))
+                    .map(|e| divide_entity(e, n, marker.as_ref()))
                     .unwrap_or_default();
                 let count = pts.len();
                 if count > 0 {
                     self.push_undo_snapshot(i, "DIVIDE");
-                    for p in pts {
+                    let layer = self.tabs[i].active_layer.clone();
+                    for mut p in pts {
+                        p.as_entity_mut().set_layer(layer.clone());
                         self.tabs[i].scene.add_entity(p);
                     }
                     self.tabs[i].dirty = true;
                     self.command_line
-                        .push_output(crate::tf!("DIVIDE: {count} point(s) placed.").as_ref());
+                        .push_output(crate::tf!("DIVIDE: {count} marker(s) placed.").as_ref());
                 } else {
                     self.command_line
                         .push_error(crate::t!("DIVIDE: entity type not supported or N < 2.").as_ref());

src/app/commands/inquiry.rs

@@ -989,7 +989,7 @@ impl OpenCADStudio {
 
             "DIVIDE" => {
                 use crate::modules::draw::inquiry::divide::DivideCommand;
-                let cmd = DivideCommand::new();
+                let cmd = DivideCommand::new().with_blocks(self.tabs[i].scene.custom_block_names());
                 self.command_line.push_info(&cmd.prompt());
                 self.tabs[i].active_cmd = Some(Box::new(cmd));
             }

src/command.rs

@@ -1546,7 +1546,7 @@ pub enum CmdResult {
         op: crate::modules::draw::modify::pedit::PeditOp,
     },
     /// Place Point entities at N equal intervals along the entity.
-    DivideEntity { handle: Handle, n: usize },
+    DivideEntity { handle: Handle, n: usize, marker: Option<CurveMarker> },
     /// Place Point entities at `segment_length` intervals along the entity.
     MeasureEntity { handle: Handle, segment_length: f64 },
     /// Extend/trim a Line or Arc by the given mode; end command.
@@ -2004,6 +2004,14 @@ impl InputKind {
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct CurveMarker {
+    pub block: String,
+    pub align: bool,
+    pub plane: WorkingPlane,
+}
+
+
 /// Current screen projection and configured aperture for point-feature picking.
 #[derive(Clone, Copy)]
 pub struct PointPickContext {

src/entities/curve.rs

@@ -107,6 +107,51 @@ pub fn entity_curve(entity: &EntityType) -> Option<PlanarCurve> {
     }
 }
 
+/// Exact spatial source geometry for commands that traverse nonplanar curves.
+/// Curve construction and arc-length calculations remain in the kernel.
+pub fn entity_spatial_measurement(entity: &EntityType) -> Option<cadkernel::space::ArcLengthCurve3> {
+    use cadkernel::space::{ArcLengthCurve3, NurbsCurve3, Parameterization};
+    let curve = match entity {
+        EntityType::Polyline3D(polyline) => {
+            if polyline.flags.spline_fit {
+                let degree = match polyline.smooth_type as i16 { 5 => 2, 6 => 3, _ => return None };
+                let controls: Vec<_> = polyline.vertices.iter().filter(|vertex| vertex.flags & 16 != 0)
+                    .map(|vertex| [vertex.position.x, vertex.position.y, vertex.position.z]).collect();
+                let curve = NurbsCurve3::from_control_polygon(degree, &controls, polyline.is_closed())?;
+                return ArcLengthCurve3::from_nurbs(curve);
+            }
+            let points: Vec<_> = polyline.vertices.iter().map(|vertex| {
+                [vertex.position.x, vertex.position.y, vertex.position.z]
+            }).collect();
+            return ArcLengthCurve3::from_polyline(&points, polyline.is_closed());
+        }
+        EntityType::Spline(spline) => {
+            if crate::entities::spline::uses_fit_method(spline) {
+                let points: Vec<_> = spline.fit_points.iter().copied().map(xyz).collect();
+                let parameterization = match spline.knot_parameterization {
+                    1 => Parameterization::Centripetal, 2 => Parameterization::Uniform,
+                    _ => Parameterization::Chord,
+                };
+                if spline.flags.periodic {
+                    NurbsCurve3::interpolate_periodic(&points, parameterization)?
+                } else {
+                    if spline.flags.closed { return None; }
+                    NurbsCurve3::interpolate_fit(&points, Some(xyz(spline.begin_tangent)),
+                        Some(xyz(spline.end_tangent)), parameterization)?
+                }
+            } else {
+                let controls: Vec<_> = spline.control_points.iter().copied().map(xyz).collect();
+                let weights = if spline.weights.is_empty() { vec![1.0; controls.len()] }
+                    else { spline.weights.clone() };
+                NurbsCurve3::new_strict(spline.degree as usize, controls, spline.knots.clone(), weights)?
+                    .with_periodicity(spline.flags.periodic)
+            }
+        }
+        _ => return None,
+    };
+    ArcLengthCurve3::from_nurbs(curve)
+}
+
 /// The plane an OCS-stored entity's coordinates are read in.
 ///
 /// `elevation` is the entity's third stored coordinate — the distance along

src/modules/draw/inquiry/divide.rs

@@ -1,86 +1,125 @@
-// DIVIDE command — place Point entities at N equal intervals along an entity.
+// DIVIDE and MEASURE place points or block references along a curve.
-// MEASURE command — place Point entities at fixed-distance intervals along an entity.
+use acadrust::entities::{Insert, Point as PointEnt};
-
-use acadrust::entities::Point as PointEnt;
-use cadkernel::space::PlanarCurve;
 use acadrust::types::Vector3;
-use acadrust::{EntityType, Handle};
+use acadrust::{Entity, EntityType, Handle};
+use cadkernel::space::PlanarCurve;
 use glam::DVec3;
-use crate::entities::curve::entity_curve;
+use crate::command::{CadCommand, CmdOption, CmdResult, CurveMarker, WorkingPlane};
+use crate::entities::curve::{entity_curve, entity_spatial_measurement};
 use crate::t;
+const MEASURE: bool = false;
 
-use crate::command::{CadCommand, CmdResult};
+#[derive(Clone, Copy, PartialEq)]
+enum Step { Pick, Amount, BlockName, Align }
 
-// ── DIVIDE ─────────────────────────────────────────────────────────────────
+pub struct DivisionMarkerCommand {
-
-pub struct DivideCommand {
     target: Option<Handle>,
-    waiting_for_n: bool,
+    pick_point: DVec3,
+    step: Step,
+    blocks: Vec<String>,
+    block: Option<String>,
+    align: bool,
+    plane: WorkingPlane,
+    valid_pick: bool,
 }
 
-impl DivideCommand {
+pub type DivideCommand = DivisionMarkerCommand;
+
+impl DivisionMarkerCommand {
     pub fn new() -> Self {
-        Self {
+        Self { target: None, pick_point: DVec3::ZERO, step: Step::Pick,
-            target: None,
+            blocks: Vec::new(), block: None, align: true,
-            waiting_for_n: false,
+            plane: WorkingPlane::default(), valid_pick: false }
-        }
+    }
+    pub fn with_blocks(mut self, blocks: Vec<String>) -> Self {
+        self.blocks = blocks;
+        self
+    }
+    fn marker(&self) -> Option<CurveMarker> {
+        self.block.as_ref().map(|name| CurveMarker {
+            block: name.clone(), align: self.align, plane: self.plane,
+        })
     }
 }
 
-impl CadCommand for DivideCommand {
+impl CadCommand for DivisionMarkerCommand {
-    fn name(&self) -> &'static str {
+    fn name(&self) -> &'static str { if MEASURE { "MEASURE" } else { "DIVIDE" } }
-        "DIVIDE"
-    }
-
     fn prompt(&self) -> String {
-        if self.target.is_none() {
+        let prompt = match self.step {
-            t!("DIVIDE  Select object to divide:").into_owned()
+            Step::Pick if MEASURE => "Select object to measure:",
-        } else {
+            Step::Pick => "Select object to divide:",
-            t!("DIVIDE  Enter number of segments:").into_owned()
+            Step::BlockName => "Enter name of block to insert:",
+            Step::Align => "Align block with object? [Yes/No] <Yes>:",
+            Step::Amount if MEASURE && self.block.is_none() => "Specify length of segment or [Block]:",
+            Step::Amount if MEASURE => "Specify length of segment:",
+            Step::Amount if self.block.is_none() => "Enter number of segments or [Block]:",
+            Step::Amount => "Enter number of segments:",
+        };
+        format!("{}  {}", self.name(), prompt)
+    }
+    fn options(&self) -> Vec<CmdOption> {
+        match self.step {
+            Step::Amount if self.block.is_none() => vec![CmdOption::new("Block", "B")],
+            Step::Align => vec![CmdOption::new("Yes", "Y"), CmdOption::new("No", "N")],
+            _ => vec![],
         }
     }
-
+    fn set_working_plane(&mut self, plane: WorkingPlane) { self.plane = plane; }
-    fn needs_entity_pick(&self) -> bool {
+    fn needs_entity_pick(&self) -> bool { self.step == Step::Pick }
-        self.target.is_none()
+    fn inject_before_entity_pick(&self) -> bool { true }
+    fn inject_picked_entity(&mut self, entity: EntityType) {
+        self.valid_pick = measurable(&entity).is_some();
     }
-
+    fn on_entity_pick(&mut self, handle: Handle, pt: DVec3) -> CmdResult {
-    fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult {
+        if handle.is_null() || !self.valid_pick { return CmdResult::NeedPoint; }
-        if handle.is_null() {
-            return CmdResult::NeedPoint;
-        }
         self.target = Some(handle);
-        self.waiting_for_n = true;
+        self.pick_point = pt;
+        self.step = Step::Amount;
         CmdResult::NeedPoint
     }
-
+    fn wants_text_input(&self) -> bool { self.step != Step::Pick }
-    fn wants_text_input(&self) -> bool {
-        self.waiting_for_n
-    }
-
     fn dyn_field(&self) -> crate::command::DynField {
-        if self.waiting_for_n {
+        if self.step == Step::Amount { crate::command::DynField::Scalar }
-            crate::command::DynField::Scalar
+        else { crate::command::DynField::Point }
-        } else {
-            crate::command::DynField::Point
-        }
     }
-
+    fn dyn_commit_as_text(&self) -> bool { self.step == Step::Amount }
     fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
-        let n: usize = text.trim().parse().ok().filter(|&n| n >= 2)?;
+        let text = text.trim();
-        let handle = self.target?;
+        match self.step {
-        self.waiting_for_n = false;
+            Step::BlockName => {
-        Some(CmdResult::DivideEntity { handle, n })
+                self.block = Some(self.blocks.iter().find(|name| name.eq_ignore_ascii_case(text))?.clone());
-    }
+                self.step = Step::Align;
-
+            }
-    fn on_point(&mut self, _pt: DVec3) -> CmdResult {
+            Step::Align => {
-        CmdResult::NeedPoint
+                self.align = match text.to_ascii_uppercase().as_str() {
+                    "Y" | "YES" => true,
+                    "N" | "NO" => false,
+                    _ => return None,
+                };
+                self.step = Step::Amount;
+            }
+            Step::Amount => {
+                if self.block.is_none() && matches!(text.to_ascii_uppercase().as_str(), "B" | "BLOCK") {
+                    self.step = Step::BlockName;
+                } else {
+                    let n = text.parse::<usize>().ok().filter(|n| (2..=32767).contains(n))?;
+                    return Some(CmdResult::DivideEntity { handle: self.target?, n, marker: self.marker() });
+                }
+            }
+            Step::Pick => return None,
+        }
+        Some(CmdResult::NeedPoint)
     }
+    fn on_point(&mut self, _pt: DVec3) -> CmdResult { CmdResult::NeedPoint }
     fn on_enter(&mut self) -> CmdResult {
-        CmdResult::Cancel
+        if self.step == Step::Align {
+            self.align = true;
+            self.step = Step::Amount;
+            CmdResult::NeedPoint
+        } else { CmdResult::Cancel }
     }
 }
 
-// ── MEASURE ────────────────────────────────────────────────────────────────
 
 pub struct MeasureCommand {
     target: Option<Handle>,
@@ -157,30 +196,30 @@ impl CadCommand for MeasureCommand {
     }
 }
 
-// ── Geometry ───────────────────────────────────────────────────────────────
 
-/// Compute N-1 equally spaced points along the entity (DIVIDE).
+pub fn divide_entity(entity: &EntityType, n: usize, marker: Option<&CurveMarker>) -> Vec<EntityType> {
-pub fn divide_entity(entity: &EntityType, n: usize) -> Vec<EntityType> {
+    if !(2..=32767).contains(&n) {
-    if n < 2 {
         return vec![];
     }
     let Some((curve, total)) = measurable(entity) else {
         return vec![];
     };
     let step = total / n as f64;
-    (1..n)
+    let last = if curve.is_closed() { n } else { n - 1 };
-        .map(|k| make_point(curve.point_at_distance(step * k as f64)))
+    (1..=last)
+        .map(|k| make_marker(&curve, step * k as f64, marker))
         .collect()
 }
 
-/// Compute points at fixed `segment_length` intervals along the entity (MEASURE).
 pub fn measure_entity(entity: &EntityType, segment_length: f64) -> Vec<EntityType> {
     if segment_length <= 0.0 {
         return vec![];
     }
-    let Some((curve, total)) = measurable(entity) else {
+    let Some(curve) = entity_curve(entity) else {
         return vec![];
     };
+    let total = curve.length();
+    if !total.is_finite() || total <= 1e-10 { return vec![]; }
     let mut pts = Vec::new();
     let mut walked = segment_length;
     while walked < total - 1e-6 {
@@ -190,6 +229,24 @@ pub fn measure_entity(entity: &EntityType, segment_length: f64) -> Vec<EntityTyp
     pts
 }
 
+fn make_marker(curve: &MeasuredCurve, distance: f64, marker: Option<&CurveMarker>) -> EntityType {
+    let pos = curve.point_at_distance(distance);
+    let Some(marker) = marker else {
+        let mut point = PointEnt::new();
+        point.location = Vector3::new(pos[0], pos[1], pos[2]);
+        return EntityType::Point(point);
+    };
+    let local = marker.plane.to_local(DVec3::from_array(pos));
+    let mut insert = Insert::new(marker.block.clone(), Vector3::new(local.x, local.y, local.z));
+    if marker.align {
+        let tangent = DVec3::from_array(curve.tangent_at(curve.parameter_at_distance(distance)));
+        let tangent = marker.plane.vector_to_local(tangent);
+        insert.rotation = tangent.y.atan2(tangent.x);
+    }
+    insert.apply_transform(&marker.plane.to_world_transform());
+    EntityType::Insert(insert)
+}
+
 fn make_point(pos: [f64; 3]) -> EntityType {
     let mut p = PointEnt::new();
     p.location = Vector3::new(pos[0], pos[1], pos[2]);
@@ -198,13 +255,36 @@ fn make_point(pos: [f64; 3]) -> EntityType {
 
 /// The entity's curve and its length, or `None` for anything that cannot be
 /// walked along — a hatch, a block, an unbounded ray.
-fn measurable(entity: &EntityType) -> Option<(PlanarCurve, f64)> {
+enum MeasuredCurve {
-    let curve = entity_curve(entity)?;
+    Planar(PlanarCurve),
-    let total = curve.curve.length();
+    Spatial(cadkernel::space::ArcLengthCurve3),
+}
+impl MeasuredCurve {
+    fn is_closed(&self) -> bool {
+        match self { Self::Planar(curve) => curve.is_closed(), Self::Spatial(curve) => curve.is_closed() }
+    }
+    fn point_at_distance(&self, distance: f64) -> [f64; 3] {
+        match self { Self::Planar(curve) => curve.point_at_distance(distance), Self::Spatial(curve) => curve.point_at_distance(distance) }
+    }
+    fn parameter_at_distance(&self, distance: f64) -> f64 {
+        match self { Self::Planar(curve) => curve.parameter_at_distance(distance), Self::Spatial(curve) => curve.parameter_at_distance(distance) }
+    }
+    fn tangent_at(&self, parameter: f64) -> [f64; 3] {
+        match self { Self::Planar(curve) => curve.tangent_at(parameter), Self::Spatial(curve) => curve.tangent_at(parameter) }
+    }
+}
+
+fn measurable(entity: &EntityType) -> Option<(MeasuredCurve, f64)> {
+    let (curve, total) = if let Some(curve) = entity_curve(entity) {
+        let total = curve.length();
+        (MeasuredCurve::Planar(curve), total)
+    } else {
+        let curve = entity_spatial_measurement(entity)?;
+        let total = curve.length();
+        (MeasuredCurve::Spatial(curve), total)
+    };
     (total.is_finite() && total > 1e-10).then_some((curve, total))
 }
 
-
+inventory::submit!(crate::command::CommandRegistration { names: &["DIVIDE"] });
-// ── Autocomplete registry ─────────────────────────────────
+inventory::submit!(crate::command::CommandRegistration { names: &["MEASURE"] });
-inventory::submit!(crate::command::CommandRegistration { names: &["DIVIDE"] });  // DivideCommand
-inventory::submit!(crate::command::CommandRegistration { names: &["MEASURE"] });  // MeasureCommand