Files
solidcraft/crates/engine/src/cmd/view_dxf_tests.rs
T
ba4f7864ff Export Current View as DXF includes shown sketches (#3708) (#3780)
* claim: #3708

* Export Current View as DXF includes shown sketches (#3708)

The view export refused a design with only a sketch and left shown
sketches out when bodies were present. It now draws the sketches the
viewport shows (profile curves only: no construction geometry, points,
dimensions or constraints) on a SKETCH layer, one entity per curve.
Finished sketches are hidden behind bodies through the body-edge
occlusion; the active sketch is drawn on top, as in the viewport.
Sketch points use the same projection, budgets and cancellation.

The export is refused only when there is neither a visible body nor a
shown sketch curve; the dialog and the command share that check
(cmd::view_dxf_exportable).

---------

Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-21 23:09:57 +00:00

236 lines
11 KiB
Rust

use super::*;
use solidcraft_geom::{Vec2, Vec3};
use solidcraft_render::StandardView;
fn run(s: &mut Session, id: &str, p: Value) -> Value {
s.execute(id, &p).unwrap()
}
fn sample() -> Session {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length":40,"width":30,"height":10,"body_name":"Plate"}));
// A blind hole on the bottom, completely hidden from above.
run(&mut s, "solid.cylinder", json!({"radius":3,"height":4,"base":[10,10,0],"operation":"cut","targets":["Plate"]}));
s
}
fn camera(view: StandardView) -> Camera {
let mut c = Camera { target: Vec3::new(20., 15., 5.), fov: 0., distance: 150., ..Default::default() };
c.set_view(view);
c
}
fn export(s: &mut Session, c: Camera, hidden: &str) -> Value {
run(s, CMD, json!({"camera":c,"hidden":hidden}))
}
#[test]
fn view_dxf_cancellation_at_each_stage_preserves_the_destination_and_document() {
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
struct CancelAt {
stage: &'static str,
cancelled: AtomicBool,
reached: AtomicBool,
}
impl solidcraft_kernel::watch::Watch for CancelAt {
fn cancelled(&self) -> bool {
self.cancelled.load(Ordering::Relaxed)
}
fn progress(&self, stage: &'static str, done: usize, _total: usize) {
if stage == self.stage && (done > 0 || stage == "dxf_write") {
self.reached.store(true, Ordering::Relaxed);
self.cancelled.store(true, Ordering::Relaxed);
}
}
}
let dir = std::env::temp_dir().join(format!("solidcraft-dxf-cancel-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("drawing.dxf");
let mut s = sample();
let doc = s.doc.clone();
let undo = s.undo.len();
for stage in ["dxf_meshes", "dxf_index", "dxf_projection", "dxf_occlusion", "dxf_write"] {
std::fs::write(&path, b"previous drawing").unwrap();
let watch = Arc::new(CancelAt { stage, cancelled: AtomicBool::new(false), reached: AtomicBool::new(false) });
let result = solidcraft_kernel::watch::watching(watch.clone(), || {
s.execute(CMD, &json!({"camera":camera(StandardView::Top),"path":path.to_string_lossy()}))
});
assert!(result.unwrap_err().to_string().contains("cancelled"), "{stage}");
assert!(watch.reached.load(Ordering::Relaxed), "{stage}");
assert_eq!(std::fs::read(&path).unwrap(), b"previous drawing", "{stage}");
assert!(Arc::ptr_eq(&doc, &s.doc));
assert_eq!(s.undo.len(), undo);
}
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn view_dxf_blind_back_hole_is_omitted_or_dashed_and_front_hole_is_visible() {
let mut s = sample();
let undo = s.undo.len();
let doc = s.doc.clone();
let top = export(&mut s, camera(StandardView::Top), "omit");
let dashed = export(&mut s, camera(StandardView::Top), "dashed");
assert!(top["visible"].as_u64().unwrap() > 0);
assert_eq!(top["hidden"], 0);
assert!(dashed["hidden"].as_u64().unwrap() > 12, "{dashed}");
assert_eq!(top["visible"], dashed["visible"]);
assert!(!top["dxf"].as_str().unwrap().contains("HIDDEN"));
assert!(dashed["dxf"].as_str().unwrap().contains("LWPOLYLINE"));
assert!(dashed["dxf"].as_str().unwrap().contains("128\n"));
let bottom = export(&mut s, camera(StandardView::Bottom), "omit");
assert!(bottom["visible"].as_u64().unwrap() > top["visible"].as_u64().unwrap());
assert_eq!(s.undo.len(), undo);
assert!(std::sync::Arc::ptr_eq(&doc, &s.doc));
}
#[test]
fn view_dxf_respects_hidden_bodies_mm_and_camera_roll() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length":40,"width":30,"height":10,"body_name":"Plate"}));
run(&mut s, "solid.box", json!({"length":5,"width":5,"height":5,"corner":[100,0,0],"body_name":"Other"}));
run(&mut s, "browser.visibility", json!({"items":["Other"],"visible":false}));
let mut c = camera(StandardView::Top);
let drawing = export(&mut s, c, "omit");
let size = |v: &Value| {
let mut points = Vec::new();
for g in solidcraft_io::read_dxf(v["dxf"].as_str().unwrap()).unwrap() {
if let solidcraft_io::Geom2::Line(a, b) = g {
points.extend([a, b]);
}
}
let min = points.iter().fold(Vec2::new(f64::INFINITY, f64::INFINITY), |a, p| Vec2::new(a.x.min(p.x), a.y.min(p.y)));
let max = points.iter().fold(Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY), |a, p| Vec2::new(a.x.max(p.x), a.y.max(p.y)));
max - min
};
let d = size(&drawing);
assert!((d.x - 40.).abs() < 0.001 && (d.y - 30.).abs() < 0.001, "{d:?}");
c.roll = std::f64::consts::FRAC_PI_2;
let d = size(&export(&mut s, c, "omit"));
assert!((d.x - 30.).abs() < 0.001 && (d.y - 40.).abs() < 0.001, "{d:?}");
run(&mut s, "browser.visibility", json!({"items":["Plate"],"visible":false}));
assert!(s.execute(CMD, &json!({"camera":c})).is_err());
}
#[test]
fn view_dxf_cylinders_have_side_silhouettes_and_perspective_is_supported() {
let mut s = Session::default();
run(&mut s, "solid.cylinder", json!({"radius":10,"height":20}));
let mut c = camera(StandardView::Front);
c.target = Vec3::new(0., 0., 10.);
let v = export(&mut s, c, "omit");
let lines = solidcraft_io::read_dxf(v["dxf"].as_str().unwrap()).unwrap();
assert!(lines.iter().filter(|g| matches!(g,solidcraft_io::Geom2::Line(a,b) if (a.y-b.y).abs()>19.9)).count() >= 2);
c.fov = 0.6;
let v = export(&mut s, c, "dashed");
assert_eq!(v["projection"], "perspective");
assert!(v["visible"].as_u64().unwrap() > 0);
}
#[test]
fn view_dxf_rejects_invalid_options_and_near_eye_geometry_without_panicking() {
let mut s = sample();
for extra in [json!({"hidden":"all"}), json!({"hidden":true}), json!({"tolerance":0}), json!({"tolerance":"x"}), json!({"path":false})] {
let mut p = extra;
p["camera"] = json!(camera(StandardView::Top));
assert!(s.execute(CMD, &p).is_err(), "{p}");
}
assert!(s.execute(CMD, &json!({})).is_err());
let mut c = camera(StandardView::Top);
c.fov = 0.5;
c.distance = 1.;
assert!(s.execute(CMD, &json!({"camera":c})).is_err());
c.fov = 4.;
assert!(s.execute(CMD, &json!({"camera":c})).is_err());
}
#[test]
fn view_dxf_keeps_every_occurrence_while_sharing_geometry() {
let mut s = Session::default();
let component = run(&mut s, "component.create", json!({"name":"Repeated part"}))["component"].as_u64().unwrap();
run(&mut s, "solid.box", json!({"length":8,"width":6,"height":3}));
for x in [15., 30.] {
run(&mut s, "occurrence.copy", json!({"component":component,"translate":[x,0,0]}));
}
run(&mut s, "component.activate", json!({"component":0}));
let doc = s.doc.clone();
let result = export(&mut s, camera(StandardView::Top), "dashed");
assert_eq!(result["stats"]["bodies"], 3);
assert_eq!(result["stats"]["shared_meshes"], 1);
assert_eq!(result["stats"]["worker_limit"], meshes::WORKERS);
assert!(result["hidden"].as_u64().unwrap() > 0);
let lines = solidcraft_io::read_dxf(result["dxf"].as_str().unwrap()).unwrap();
let mut centers = std::collections::BTreeSet::new();
for line in lines {
if let solidcraft_io::Geom2::Line(a, b) = line {
// Each translated copy has a visible top perimeter, including the offscreen one.
if (a.y - b.y).abs() > 5.9 {
centers.insert(((a.x + 20.) / 15.).floor() as i64);
}
}
}
assert!(centers.len() >= 3, "{centers:?}");
assert!(std::sync::Arc::ptr_eq(&doc, &s.doc));
}
#[test]
fn view_dxf_exports_a_sketch_only_design_on_the_sketch_layer() {
let mut s = Session::default();
assert!(s.execute(CMD, &json!({"camera":camera(StandardView::Top)})).is_err());
run(&mut s, "sketch.create", json!({"plane":"XY"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[60,40]}));
run(&mut s, "sketch.circle.center", json!({"center":[30,20],"radius":8}));
for finish in [false, true] {
if finish {
run(&mut s, "sketch.finish", json!({}));
}
let v = export(&mut s, camera(StandardView::Top), "omit");
// Four rectangle sides and one circle, each its own entity.
assert_eq!(v["sketch"], 5, "{v}");
let geometry = solidcraft_io::read_dxf(v["dxf"].as_str().unwrap()).unwrap();
let (mut sides, mut circle) = (Vec::new(), 0);
for g in geometry {
let solidcraft_io::Geom2::Line(a, b) = g else { panic!("{g:?}") };
// The drawing is centred on the camera target (20, 15).
let on_circle = |p: Vec2| ((p - Vec2::new(10., 5.)).len() - 8.).abs() < 0.02;
if on_circle(a) && on_circle(b) {
circle += 1;
} else {
sides.push((a.dist(b) * 1000.).round() as i64);
}
}
sides.sort_unstable();
assert_eq!(sides, [40_000, 40_000, 60_000, 60_000], "finish={finish}");
assert!(circle > 16, "{circle}");
}
}
#[test]
fn view_dxf_hides_finished_sketches_behind_bodies_but_draws_the_active_sketch_on_top() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length":40,"width":30,"height":10}));
run(&mut s, "sketch.create", json!({"plane":{"origin":[0,0,-5],"x_dir":[1,0,0],"y_dir":[0,1,0]}}));
run(&mut s, "sketch.line", json!({"points":[[-20,15],[60,15]]}));
// The box's edges run along y = 0 and y = 30; only the sketch line lies on y = 15 (0 in the
// drawing, which is centred on the camera target; the top view is tilted a hair).
let length = |v: &Value| {
let lines = solidcraft_io::read_dxf(v["dxf"].as_str().unwrap()).unwrap();
lines
.iter()
.filter_map(|g| if let solidcraft_io::Geom2::Line(a, b) = g { Some((*a, *b)) } else { None })
.filter(|(a, b)| a.y.abs() < 1e-3 && b.y.abs() < 1e-3)
.map(|(a, b)| a.dist(b))
.sum::<f64>()
};
let active = export(&mut s, camera(StandardView::Top), "omit");
assert_eq!(active["sketch"], 1, "{active}");
assert!((length(&active) - 80.).abs() < 1e-3 && active["dxf"].as_str().unwrap().contains("SKETCH"));
run(&mut s, "sketch.finish", json!({}));
let finished = export(&mut s, camera(StandardView::Top), "omit");
assert_eq!(finished["sketch"], 2, "{finished}");
assert!((length(&finished) - 40.).abs() < 1e-3, "{}", length(&finished));
let dashed = export(&mut s, camera(StandardView::Top), "dashed");
assert_eq!(dashed["sketch"], 2);
assert!((length(&dashed) - 80.).abs() < 1e-3, "{}", length(&dashed));
}