forked from 1b-agent/opencadstudio-upstream
feat(area): add object and aggregate modes
Mesh-backed measurements need cached surface metrics. Keep shared loop collection available in web builds.
This commit is contained in:
Hakan Seven committed
1 parent
feb110404c
commit
48332ee807
8 files changed
+456
-60
No files matched your search
@@ -1,19 +1,222 @@
|
||||
// AREA command — compute area and perimeter of a polygon picked point by point.
|
||||
// Press Enter to close and calculate.
|
||||
|
||||
use acadrust::{EntityType, Handle};
|
||||
use glam::DVec3;
|
||||
use crate::t;
|
||||
|
||||
use crate::command::{CadCommand, CmdResult};
|
||||
use crate::command::{CadCommand, CmdOption, CmdResult};
|
||||
use crate::entities::traits::EntityTypeOps;
|
||||
use crate::scene::model::wire_model::WireModel;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum AreaMode {
|
||||
Single,
|
||||
Add,
|
||||
Subtract,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct AreaMeasurement {
|
||||
area: f64,
|
||||
perimeter: Option<f64>,
|
||||
}
|
||||
|
||||
pub struct AreaCommand {
|
||||
mode: AreaMode,
|
||||
points: Vec<DVec3>,
|
||||
object_pick: bool,
|
||||
picked_entity: Option<EntityType>,
|
||||
picked_surface_area: Option<f64>,
|
||||
total_area: f64,
|
||||
total_perimeter: f64,
|
||||
}
|
||||
|
||||
impl AreaCommand {
|
||||
pub fn new() -> Self {
|
||||
Self { points: vec![] }
|
||||
Self {
|
||||
mode: AreaMode::Single,
|
||||
points: Vec::new(),
|
||||
object_pick: false,
|
||||
picked_entity: None,
|
||||
picked_surface_area: None,
|
||||
total_area: 0.0,
|
||||
total_perimeter: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
fn option(label: String, keyword: &str) -> CmdOption {
|
||||
CmdOption { label, keyword: keyword.to_string() }
|
||||
}
|
||||
|
||||
fn point_measurement(points: &[DVec3], close_perimeter: bool) -> AreaMeasurement {
|
||||
if points.len() < 2 {
|
||||
return AreaMeasurement { area: 0.0, perimeter: Some(0.0) };
|
||||
}
|
||||
|
||||
let origin = points[0];
|
||||
let mut area_vector = DVec3::ZERO;
|
||||
for index in 0..points.len() {
|
||||
let a = points[index] - origin;
|
||||
let b = points[(index + 1) % points.len()] - origin;
|
||||
area_vector += a.cross(b);
|
||||
}
|
||||
|
||||
let mut perimeter = points
|
||||
.windows(2)
|
||||
.map(|pair| (pair[1] - pair[0]).length())
|
||||
.sum::<f64>();
|
||||
if close_perimeter {
|
||||
perimeter += (points[0] - points[points.len() - 1]).length();
|
||||
}
|
||||
|
||||
AreaMeasurement { area: area_vector.length() * 0.5, perimeter: Some(perimeter) }
|
||||
}
|
||||
|
||||
fn bulged_polyline_measurement(
|
||||
points: &[(f64, f64)],
|
||||
bulges: &[f64],
|
||||
closed: bool,
|
||||
) -> AreaMeasurement {
|
||||
let count = points.len();
|
||||
if count < 2 {
|
||||
return AreaMeasurement { area: 0.0, perimeter: Some(0.0) };
|
||||
}
|
||||
|
||||
let segment_count = if closed { count } else { count - 1 };
|
||||
let origin = points[0];
|
||||
let mut signed_area = 0.0;
|
||||
let mut perimeter = 0.0;
|
||||
for index in 0..segment_count {
|
||||
let a = points[index];
|
||||
let b = points[(index + 1) % count];
|
||||
let local_a = (a.0 - origin.0, a.1 - origin.1);
|
||||
let local_b = (b.0 - origin.0, b.1 - origin.1);
|
||||
signed_area += 0.5 * (local_a.0 * local_b.1 - local_b.0 * local_a.1);
|
||||
|
||||
let chord = (b.0 - a.0).hypot(b.1 - a.1);
|
||||
let bulge = bulges.get(index).copied().unwrap_or(0.0);
|
||||
if bulge.abs() < 1e-12 || chord <= 1e-12 {
|
||||
perimeter += chord;
|
||||
continue;
|
||||
}
|
||||
|
||||
let angle = 4.0 * bulge.atan();
|
||||
let sine = (angle * 0.5).sin().abs();
|
||||
if sine <= 1e-12 {
|
||||
perimeter += chord;
|
||||
continue;
|
||||
}
|
||||
let radius = chord / (2.0 * sine);
|
||||
signed_area += 0.5 * radius * radius * (angle - angle.sin());
|
||||
perimeter += radius * angle.abs();
|
||||
}
|
||||
|
||||
AreaMeasurement { area: signed_area.abs(), perimeter: Some(perimeter) }
|
||||
}
|
||||
|
||||
fn entity_measurement(entity: &EntityType) -> Option<AreaMeasurement> {
|
||||
match entity {
|
||||
EntityType::LwPolyline(polyline) => {
|
||||
let points = polyline
|
||||
.vertices
|
||||
.iter()
|
||||
.map(|vertex| (vertex.location.x, vertex.location.y))
|
||||
.collect::<Vec<_>>();
|
||||
let bulges = polyline.vertices.iter().map(|vertex| vertex.bulge).collect::<Vec<_>>();
|
||||
Some(Self::bulged_polyline_measurement(
|
||||
&points,
|
||||
&bulges,
|
||||
polyline.is_closed,
|
||||
))
|
||||
}
|
||||
EntityType::Polyline2D(polyline) => {
|
||||
let points = polyline
|
||||
.vertices
|
||||
.iter()
|
||||
.map(|vertex| (vertex.location.x, vertex.location.y))
|
||||
.collect::<Vec<_>>();
|
||||
let bulges = polyline.vertices.iter().map(|vertex| vertex.bulge).collect::<Vec<_>>();
|
||||
Some(Self::bulged_polyline_measurement(
|
||||
&points,
|
||||
&bulges,
|
||||
polyline.is_closed(),
|
||||
))
|
||||
}
|
||||
EntityType::Polyline(polyline) => {
|
||||
let points = polyline
|
||||
.vertices
|
||||
.iter()
|
||||
.map(|vertex| {
|
||||
DVec3::new(vertex.location.x, vertex.location.y, vertex.location.z)
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
Some(Self::point_measurement(&points, polyline.is_closed()))
|
||||
}
|
||||
EntityType::Polyline3D(polyline) => {
|
||||
let points = polyline
|
||||
.vertices
|
||||
.iter()
|
||||
.map(|vertex| {
|
||||
DVec3::new(vertex.position.x, vertex.position.y, vertex.position.z)
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
Some(Self::point_measurement(&points, polyline.is_closed()))
|
||||
}
|
||||
EntityType::Spline(spline) => {
|
||||
let points = crate::entities::spline::measurement_polyline(spline)
|
||||
.into_iter()
|
||||
.map(|point| DVec3::new(point[0], point[1], point[2]))
|
||||
.collect::<Vec<_>>();
|
||||
Some(Self::point_measurement(
|
||||
&points,
|
||||
spline.flags.closed || spline.flags.periodic,
|
||||
))
|
||||
}
|
||||
_ => entity.mass_props().map(|props| AreaMeasurement {
|
||||
area: props.area,
|
||||
perimeter: Some(props.perimeter),
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
fn result_message(measurement: AreaMeasurement) -> String {
|
||||
match measurement.perimeter {
|
||||
Some(perimeter) => crate::tr!(
|
||||
"area-result",
|
||||
area = format!("{:.4}", measurement.area),
|
||||
perimeter = format!("{perimeter:.4}"),
|
||||
),
|
||||
None => crate::tr!("area-result-area-only", area = format!("{:.4}", measurement.area)),
|
||||
}
|
||||
}
|
||||
|
||||
fn running_result_message(&self, measurement: AreaMeasurement) -> String {
|
||||
match measurement.perimeter {
|
||||
Some(perimeter) => crate::tr!(
|
||||
"area-running-result",
|
||||
area = format!("{:.4}", measurement.area),
|
||||
perimeter = format!("{perimeter:.4}"),
|
||||
total_area = format!("{:.4}", self.total_area),
|
||||
total_perimeter = format!("{:.4}", self.total_perimeter),
|
||||
),
|
||||
None => crate::tr!(
|
||||
"area-running-result-area-only",
|
||||
area = format!("{:.4}", measurement.area),
|
||||
total_area = format!("{:.4}", self.total_area),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
fn finish_measurement(&mut self, measurement: AreaMeasurement) -> CmdResult {
|
||||
if self.mode == AreaMode::Single {
|
||||
return CmdResult::Measurement(Self::result_message(measurement));
|
||||
}
|
||||
|
||||
let sign = if self.mode == AreaMode::Add { 1.0 } else { -1.0 };
|
||||
self.total_area += sign * measurement.area;
|
||||
if let Some(perimeter) = measurement.perimeter {
|
||||
self.total_perimeter += sign * perimeter;
|
||||
}
|
||||
self.points.clear();
|
||||
self.object_pick = false;
|
||||
CmdResult::ReportMeasurement(self.running_result_message(measurement))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,61 +226,127 @@ impl CadCommand for AreaCommand {
|
||||
}
|
||||
|
||||
fn prompt(&self) -> String {
|
||||
if self.points.is_empty() {
|
||||
t!("AREA Specify first corner point (Enter to cancel):").into_owned()
|
||||
} else {
|
||||
let n = self.points.len();
|
||||
t!(
|
||||
"AREA Specify next point (%{n} picked, Enter to calculate):",
|
||||
n = n
|
||||
)
|
||||
.into_owned()
|
||||
if self.object_pick {
|
||||
return crate::tr!("area-prompt-object");
|
||||
}
|
||||
if !self.points.is_empty() {
|
||||
return crate::tr!("area-prompt-next", count = self.points.len());
|
||||
}
|
||||
match self.mode {
|
||||
AreaMode::Single => crate::tr!("area-prompt-first"),
|
||||
AreaMode::Add => crate::tr!("area-prompt-add"),
|
||||
AreaMode::Subtract => crate::tr!("area-prompt-subtract"),
|
||||
}
|
||||
}
|
||||
|
||||
fn on_point(&mut self, pt: DVec3) -> CmdResult {
|
||||
self.points.push(pt);
|
||||
fn options(&self) -> Vec<CmdOption> {
|
||||
if self.object_pick || !self.points.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let object = || Self::option(crate::tr!("area-option-object"), "OBJECT");
|
||||
let add = || Self::option(crate::tr!("area-option-add"), "ADD");
|
||||
let subtract = || Self::option(crate::tr!("area-option-subtract"), "SUBTRACT");
|
||||
match self.mode {
|
||||
AreaMode::Single => vec![object(), add(), subtract()],
|
||||
AreaMode::Add => vec![object(), subtract()],
|
||||
AreaMode::Subtract => vec![object(), add()],
|
||||
}
|
||||
}
|
||||
|
||||
fn wants_text_input(&self) -> bool {
|
||||
!self.object_pick
|
||||
}
|
||||
|
||||
fn point_step_accepts_keywords(&self) -> bool {
|
||||
!self.object_pick
|
||||
}
|
||||
|
||||
fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
|
||||
if self.object_pick || !self.points.is_empty() {
|
||||
return Some(CmdResult::NeedPoint);
|
||||
}
|
||||
match text.trim().to_ascii_uppercase().as_str() {
|
||||
"O" | "OBJECT" => self.object_pick = true,
|
||||
"A" | "ADD" => self.mode = AreaMode::Add,
|
||||
"S" | "SUBTRACT" => self.mode = AreaMode::Subtract,
|
||||
_ => return Some(CmdResult::NeedPoint),
|
||||
}
|
||||
Some(CmdResult::NeedPoint)
|
||||
}
|
||||
|
||||
fn needs_entity_pick(&self) -> bool {
|
||||
self.object_pick
|
||||
}
|
||||
|
||||
fn entity_pick_includes_fills(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
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);
|
||||
self.picked_surface_area = None;
|
||||
}
|
||||
|
||||
fn inject_picked_surface_area(&mut self, area: f64) {
|
||||
self.picked_surface_area = Some(area);
|
||||
}
|
||||
|
||||
fn on_entity_pick(&mut self, handle: Handle, _point: DVec3) -> CmdResult {
|
||||
if handle.is_null() {
|
||||
return CmdResult::NeedPoint;
|
||||
}
|
||||
let measurement = self
|
||||
.picked_entity
|
||||
.take()
|
||||
.and_then(|entity| Self::entity_measurement(&entity))
|
||||
.or_else(|| {
|
||||
self.picked_surface_area.take().map(|area| AreaMeasurement {
|
||||
area,
|
||||
perimeter: None,
|
||||
})
|
||||
});
|
||||
match measurement {
|
||||
Some(measurement) => self.finish_measurement(measurement),
|
||||
None => CmdResult::ReportMeasurement(crate::tr!("area-object-not-measurable")),
|
||||
}
|
||||
}
|
||||
|
||||
fn on_point(&mut self, point: DVec3) -> CmdResult {
|
||||
self.points.push(point);
|
||||
CmdResult::NeedPoint
|
||||
}
|
||||
|
||||
fn on_enter(&mut self) -> CmdResult {
|
||||
if self.object_pick {
|
||||
return CmdResult::Cancel;
|
||||
}
|
||||
if self.points.is_empty() {
|
||||
self.object_pick = true;
|
||||
return CmdResult::NeedPoint;
|
||||
}
|
||||
if self.points.len() < 3 {
|
||||
return CmdResult::Cancel;
|
||||
}
|
||||
// Shoelace formula in the world XY plane, evaluated in f64 relative to
|
||||
// the first vertex. Subtracting that origin keeps the cross-product
|
||||
// terms small even at large (survey/UTM) coordinates, avoiding the
|
||||
// catastrophic cancellation a raw f32/absolute evaluation suffers.
|
||||
let n = self.points.len();
|
||||
let origin = self.points[0];
|
||||
let mut area_sum = 0.0f64;
|
||||
let mut perimeter = 0.0f64;
|
||||
for idx in 0..n {
|
||||
let a = self.points[idx] - origin;
|
||||
let b = self.points[(idx + 1) % n] - origin;
|
||||
area_sum += a.x * b.y - b.x * a.y;
|
||||
perimeter += (self.points[(idx + 1) % n] - self.points[idx]).length();
|
||||
}
|
||||
let area = (area_sum * 0.5).abs();
|
||||
let area_s = format!("{area:.4}");
|
||||
let perimeter_s = format!("{perimeter:.4}");
|
||||
let msg = t!(
|
||||
"Area = %{area}, Perimeter = %{perimeter}",
|
||||
area = area_s,
|
||||
perimeter = perimeter_s
|
||||
)
|
||||
.into_owned();
|
||||
CmdResult::Measurement(msg)
|
||||
let measurement = Self::point_measurement(&self.points, true);
|
||||
self.finish_measurement(measurement)
|
||||
}
|
||||
|
||||
fn on_mouse_move(&mut self, pt: DVec3) -> Option<WireModel> {
|
||||
if self.points.is_empty() {
|
||||
fn on_mouse_move(&mut self, point: DVec3) -> Option<WireModel> {
|
||||
if self.object_pick || self.points.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let f = |p: DVec3| [p.x as f32, p.y as f32, p.z as f32];
|
||||
let mut pts: Vec<[f32; 3]> = self.points.iter().map(|p| f(*p)).collect();
|
||||
pts.push(f(pt));
|
||||
pts.push(f(self.points[0]));
|
||||
let to_render = |p: DVec3| [p.x as f32, p.y as f32, p.z as f32];
|
||||
let mut points = self.points.iter().map(|point| to_render(*point)).collect::<Vec<_>>();
|
||||
points.push(to_render(point));
|
||||
points.push(to_render(self.points[0]));
|
||||
Some(WireModel {
|
||||
taper_widths: Vec::new(),
|
||||
world_width: 0.0,
|
||||
@@ -89,25 +358,23 @@ impl CadCommand for AreaCommand {
|
||||
dash_align_end: None,
|
||||
text_verts: Vec::new(),
|
||||
name: "area_preview".into(),
|
||||
points: pts,
|
||||
points,
|
||||
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![],
|
||||
snap_pts: Vec::new(),
|
||||
tangent_geoms: Vec::new(),
|
||||
aci: 0,
|
||||
key_vertices: vec![],
|
||||
key_vertices: Vec::new(),
|
||||
aabb: WireModel::UNBOUNDED_AABB,
|
||||
plinegen: true,
|
||||
fill_tris: vec![],
|
||||
fill_tris: Vec::new(),
|
||||
fill_tris_low: Vec::new(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ── Autocomplete registry ─────────────────────────────────
|
||||
inventory::submit!(crate::command::CommandRegistration { names: &["AREA"] }); // AreaCommand
|
||||
inventory::submit!(crate::command::CommandRegistration { names: &["AREA"] });
|
||||
Reference in new issue
Block a user