mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-21 20:40:02 +00:00
Merge pull request #3350 from storytold/stack/r2
Land #2763, #2905, #2918, #3233, #2804: tilted 2D polylines, mirrored heights on save, kept APPIDs, plot layout flags, Generate Boundary
This commit is contained in:
@@ -85,6 +85,9 @@ pub struct Foreign {
|
||||
/// The drawing's own `$ACADVER` is the version it is saved as, which SAVEAS changes, so a
|
||||
/// later save must not take it for this one (#2471).
|
||||
pub version: Option<String>,
|
||||
/// The file's registered applications (APPID names as read, in file order). Saving writes
|
||||
/// them all back, whether or not any xdata still names them.
|
||||
pub appids: Vec<String>,
|
||||
}
|
||||
|
||||
impl Foreign {
|
||||
@@ -103,6 +106,7 @@ impl Foreign {
|
||||
&& self.targets.is_empty()
|
||||
&& self.class_order.is_empty()
|
||||
&& self.data_store.is_empty()
|
||||
&& self.appids.is_empty()
|
||||
}
|
||||
|
||||
/// The entities with a geometry record in the data store: an `ACDSRECORD` naming the entity
|
||||
|
||||
@@ -821,6 +821,18 @@ pub struct PageSetup {
|
||||
/// save keeps where the sheet sits; `None` for a page CADCraft made, written as 0,0 (#2109).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub image_origin: Option<Vec2>,
|
||||
/// The plot layout flags (DXF group 70 of AcDbPlotSettings) as the file had them. Saving keeps
|
||||
/// the bits CADCraft doesn't model (plot paper space last, plot with plot styles, standard
|
||||
/// scale and the rest) as read instead of forcing its defaults (#3227); `None` for page setups
|
||||
/// made in CADCraft.
|
||||
#[serde(skip)]
|
||||
pub file_plot_flags: Option<i64>,
|
||||
/// The standard scale the file chose (DXF group 75, such as 25 for 1:50) and the plot scale it
|
||||
/// was read with. While the scale is unchanged, saving keeps that choice and the standard scale
|
||||
/// flag instead of writing the scale as a custom one; `None` for a custom scale, scaled to
|
||||
/// fit, or a page setup made in CADCraft.
|
||||
#[serde(skip)]
|
||||
pub file_standard_scale: Option<(i64, f64)>,
|
||||
}
|
||||
|
||||
impl Default for PageSetup {
|
||||
@@ -844,6 +856,8 @@ impl Default for PageSetup {
|
||||
paper_mm: None,
|
||||
file_paper: None,
|
||||
image_origin: None,
|
||||
file_plot_flags: None,
|
||||
file_standard_scale: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
//! HATCH, GRADIENT, BOUNDARY, REGION: boundaries from pick points or selected closed objects.
|
||||
//! HATCHGENERATEBOUNDARY: polylines around existing hatches.
|
||||
|
||||
mod patfile;
|
||||
pub(super) use edit::{set_pattern, takes_pattern};
|
||||
@@ -36,6 +37,9 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
// Typed with nothing selected it asks for objects, as in AutoCAD, rather than converting none.
|
||||
.interactive(|_| Ok(Box::new(SelectRun::new("region", "REGION")))),
|
||||
CommandSpec::new("hatchedit", "Hatch Edit", edit::run_hatchedit).menu(&["Modify", "Object", "Hatch..."]).alias(&["he", "-hatchedit"]).params("{handles?, pattern?, scale?, angle?, gradient?: {name?, color1?, color2?, angle? (degrees), centered?} (makes or changes a gradient fill; `pattern` turns it back), associative?: bool (false unlinks; true links each loop to a closed object of the same shape, or to `boundary` objects), boundary?: [hex], addPoints?: [[x,y]], addBoundary?: [hex], removeLoops?: [zero-based index] (geometry edits require one hatch), style?, origin? | originMode?, separate?: true, recreate?: \"polyline\"|\"region\", associate?: bool (link to the recreated boundary)}").interactive(|s| Ok(Box::new(edit::HatchEditM::new(s)))),
|
||||
CommandSpec::new("hatchgenerateboundary", "Generate Boundary", edit::run_hatchgenerateboundary)
|
||||
.params("{handles?} (a closed polyline around each boundary loop of the hatches, which stay as they are) → handles")
|
||||
.interactive(|_| Ok(Box::new(SelectRun::new("hatchgenerateboundary", "HATCHGENERATEBOUNDARY")))),
|
||||
CommandSpec::new("hatchpick", "Hatch Pick", pick::run_hatchpick)
|
||||
.params("{points?: [[x,y]] (internal points), handles?: [hex] (closed objects)} (typed: Points, Objects, oRigin or Hatch, then the picks): the Hatch and Gradient dialog's picks, kept in the session; changes nothing")
|
||||
.enabled(has_doc)
|
||||
|
||||
@@ -29,6 +29,59 @@ fn hatches(s: &Session, p: &Value) -> Result<Vec<Handle>> {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Most polylines one HATCHGENERATEBOUNDARY call creates.
|
||||
const MAX_GENERATED: usize = 10_000;
|
||||
|
||||
/// HATCHGENERATEBOUNDARY: a closed polyline around every boundary loop (outer and islands) of
|
||||
/// the selected hatches, at each hatch's height. The hatches are not changed: an associative
|
||||
/// hatch stays linked to its own boundary objects and is not linked to the new polylines.
|
||||
pub(super) fn run_hatchgenerateboundary(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let selected = targets(s, p)?;
|
||||
// The polylines go to the current space, so every hatch must be there too.
|
||||
let space = s.space();
|
||||
let mut loops = Vec::new();
|
||||
let mut found = false;
|
||||
// A hatch named twice gets its boundary once.
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
{
|
||||
let d = s.doc()?;
|
||||
for h in selected {
|
||||
let Some(e) = d.entity(h) else { continue };
|
||||
let EntityKind::Hatch(x) = &e.kind else { continue };
|
||||
if !seen.insert(h) {
|
||||
continue;
|
||||
}
|
||||
found = true;
|
||||
if d.space_of(h).as_ref() != Some(&space) {
|
||||
return Err(bad("hatchgenerateboundary", format!("hatch {} is not in the current space; switch to its layout first", h.hex())));
|
||||
}
|
||||
// Every selected hatch counts: none is left out of a call that succeeds. Compared
|
||||
// against the room left, so a hostile loop count can't overflow the sum.
|
||||
if x.loops.len() > MAX_GENERATED.saturating_sub(loops.len()) {
|
||||
return Err(bad("hatchgenerateboundary", format!("more than {MAX_GENERATED} boundary polylines in one call; select fewer hatches")));
|
||||
}
|
||||
// The elevation runs along the hatch's normal: one facing down Z (mirrored) lies at its
|
||||
// negative, where the polyline, facing up, goes.
|
||||
let z = if e.common.extrusion.z < 0.0 { -x.elevation } else { x.elevation };
|
||||
loops.extend(x.loops.iter().map(|l| (l.vertices.clone(), z)));
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
return Err(bad("hatchgenerateboundary", "select one or more hatches"));
|
||||
}
|
||||
// Everything is checked before anything is added, so a refused call leaves nothing behind.
|
||||
let mut created = Vec::new();
|
||||
for (vs, elevation) in loops {
|
||||
let mut kind = lwpoly(vs, true);
|
||||
if let EntityKind::LwPolyline(pl) = &mut kind {
|
||||
pl.elevation = elevation;
|
||||
}
|
||||
created.push(s.add_entity(kind)?.hex());
|
||||
}
|
||||
let n = created.len();
|
||||
Ok(json!({ "handles": created, "message": format!("{n} boundary polyline(s) created.") }))
|
||||
}
|
||||
|
||||
fn outline(l: &HatchLoop) -> Vec<Vec2> {
|
||||
Polyline { vertices: l.vertices.clone(), closed: true }.tessellate(1e-3)
|
||||
}
|
||||
|
||||
@@ -235,6 +235,7 @@ pub const NO_FILES: &[&str] = &[
|
||||
"boundary",
|
||||
"region",
|
||||
"hatchedit",
|
||||
"hatchgenerateboundary",
|
||||
"hatchpick",
|
||||
"overkill",
|
||||
"block",
|
||||
|
||||
@@ -0,0 +1,205 @@
|
||||
//! HATCHGENERATEBOUNDARY (#2801): closed polylines around existing hatches, which stay as they are.
|
||||
|
||||
use cadcraft_engine::doc::{EntityKind, Handle, Hatch, LwPolyline};
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
fn hatch(s: &Session, h: &str) -> Hatch {
|
||||
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
|
||||
EntityKind::Hatch(x) => x.clone(),
|
||||
k => panic!("not a hatch: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn poly(s: &Session, h: &str) -> LwPolyline {
|
||||
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
|
||||
EntityKind::LwPolyline(p) => p.clone(),
|
||||
k => panic!("not a polyline: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn handle(v: &Value) -> String {
|
||||
v["handle"].as_str().unwrap().to_string()
|
||||
}
|
||||
|
||||
fn handles(v: &Value) -> Vec<String> {
|
||||
v["handles"].as_array().unwrap().iter().map(|h| h.as_str().unwrap().to_string()).collect()
|
||||
}
|
||||
|
||||
fn rect(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> String {
|
||||
handle(&s.execute("rectang", &json!({ "p1": a, "p2": b })).unwrap())
|
||||
}
|
||||
|
||||
fn count(s: &Session) -> usize {
|
||||
s.doc().unwrap().model.iter().count()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generates_a_closed_polyline_around_a_hatch_without_its_outline() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r.clone()] })).unwrap());
|
||||
s.execute("erase", &json!({ "handles": [r] })).unwrap();
|
||||
let before = hatch(&s, &h);
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h.clone()] })).unwrap();
|
||||
let new = handles(&v);
|
||||
assert_eq!(new.len(), 1);
|
||||
let p = poly(&s, &new[0]);
|
||||
assert!(p.closed);
|
||||
assert_eq!(p.vertices, before.loops[0].vertices);
|
||||
assert_eq!(hatch(&s, &h), before, "the hatch is not changed");
|
||||
s.execute("undo", &json!({})).unwrap();
|
||||
assert_eq!(count(&s), 1, "one undo step removes what was generated");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn islands_get_their_own_polylines() {
|
||||
let mut s = Session::new();
|
||||
rect(&mut s, [0.0, 0.0], [20.0, 20.0]);
|
||||
rect(&mut s, [5.0, 5.0], [10.0, 10.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "points": [[2, 2]] })).unwrap());
|
||||
assert_eq!(hatch(&s, &h).loops.len(), 2);
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap();
|
||||
assert_eq!(handles(&v).len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_selected_hatch_gets_its_boundary() {
|
||||
let mut s = Session::new();
|
||||
let a = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let b = rect(&mut s, [10.0, 0.0], [14.0, 2.0]);
|
||||
let ha = handle(&s.execute("hatch", &json!({ "handles": [a] })).unwrap());
|
||||
let hb = handle(&s.execute("hatch", &json!({ "handles": [b] })).unwrap());
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [ha, hb] })).unwrap();
|
||||
assert_eq!(handles(&v).len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hatch_named_twice_gets_one_boundary() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h.clone(), h] })).unwrap();
|
||||
assert_eq!(handles(&v).len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_associative_hatch_stays_linked_to_its_own_boundary() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r.clone()], "associative": true })).unwrap());
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h.clone()] })).unwrap();
|
||||
let p = handles(&v)[0].clone();
|
||||
// Moving the generated polyline leaves the hatch where it is.
|
||||
s.execute("move", &json!({ "handles": [p], "delta": [0, 10] })).unwrap();
|
||||
assert_eq!(hatch(&s, &h).loops[0].vertices[0].p.y, 0.0);
|
||||
// Moving the original rectangle still moves the hatch.
|
||||
s.execute("move", &json!({ "handles": [r], "delta": [10, 0] })).unwrap();
|
||||
assert!(hatch(&s, &h).associative);
|
||||
assert_eq!(hatch(&s, &h).loops[0].vertices[0].p.x, 10.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boundaries_keep_the_hatch_elevation() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
s.doc_mut()
|
||||
.unwrap()
|
||||
.modify_entity(Handle::parse_hex(&h).unwrap(), |e| {
|
||||
if let EntityKind::Hatch(x) = &mut e.kind {
|
||||
x.elevation = 300.0;
|
||||
}
|
||||
})
|
||||
.unwrap();
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap();
|
||||
assert_eq!(poly(&s, &handles(&v)[0]).elevation, 300.0);
|
||||
}
|
||||
|
||||
/// A mirrored hatch (normal 0,0,-1, as exploding a mirrored block makes) at elevation 300 lies at
|
||||
/// world Z -300; its boundary, facing up, goes there too, not to +300.
|
||||
#[test]
|
||||
fn a_mirrored_hatchs_boundary_keeps_its_world_height() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
s.doc_mut()
|
||||
.unwrap()
|
||||
.modify_entity(Handle::parse_hex(&h).unwrap(), |e| {
|
||||
e.common.extrusion = cadcraft_engine::geom::Vec3::new(0.0, 0.0, -1.0);
|
||||
if let EntityKind::Hatch(x) = &mut e.kind {
|
||||
x.elevation = 300.0;
|
||||
}
|
||||
})
|
||||
.unwrap();
|
||||
let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap();
|
||||
let new = Handle::parse_hex(&handles(&v)[0]).unwrap();
|
||||
let e = s.doc().unwrap().entity(new).unwrap().clone();
|
||||
let EntityKind::LwPolyline(p) = &e.kind else { panic!("not a polyline") };
|
||||
assert_eq!(e.common.extrusion.z.signum() * p.elevation, -300.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_hatch_in_another_space_and_adds_nothing() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
|
||||
let before = s.doc().unwrap().entity_count();
|
||||
let e = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap_err();
|
||||
assert!(e.to_string().contains("not in the current space"), "{e}");
|
||||
assert_eq!(s.doc().unwrap().entity_count(), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_more_boundaries_than_the_limit_and_adds_nothing() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
// One hatch with more loops than one call may turn into polylines.
|
||||
s.doc_mut()
|
||||
.unwrap()
|
||||
.modify_entity(Handle::parse_hex(&h).unwrap(), |e| {
|
||||
if let EntityKind::Hatch(x) = &mut e.kind {
|
||||
let l = x.loops[0].clone();
|
||||
x.loops = vec![l; 10_001];
|
||||
}
|
||||
})
|
||||
.unwrap();
|
||||
let before = count(&s);
|
||||
assert!(s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).is_err());
|
||||
assert_eq!(count(&s), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_a_hatch() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
assert!(s.execute("hatchgenerateboundary", &json!({ "handles": [r] })).is_err());
|
||||
assert_eq!(count(&s), 1, "nothing is added");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_at_once_on_selected_hatches() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
s.set_selection(vec![Handle::parse_hex(&h).unwrap()]);
|
||||
s.start("hatchgenerateboundary").unwrap();
|
||||
assert!(s.current_prompt().is_none(), "a pickfirst selection needs no prompt");
|
||||
assert_eq!(count(&s), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn asks_for_hatches_without_a_selection() {
|
||||
let mut s = Session::new();
|
||||
let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]);
|
||||
let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap());
|
||||
s.set_selection(Vec::new());
|
||||
s.start("hatchgenerateboundary").unwrap();
|
||||
assert!(s.current_prompt().is_some());
|
||||
s.input(Input::Pick(vec![Handle::parse_hex(&h).unwrap()])).unwrap();
|
||||
s.input(Input::Enter).unwrap();
|
||||
assert!(s.current_prompt().is_none());
|
||||
assert_eq!(count(&s), 3);
|
||||
}
|
||||
@@ -68,6 +68,7 @@ mod group_selection;
|
||||
mod groups;
|
||||
mod hatch_assoc;
|
||||
mod hatch_dialog_helpers;
|
||||
mod hatch_generate_boundary;
|
||||
mod hatch_numeric_validation;
|
||||
mod hatch_options;
|
||||
mod helix;
|
||||
|
||||
@@ -457,6 +457,10 @@ pub(crate) fn read(secs: &[SectionRef<'_>], d: &mut Drawing) {
|
||||
if !f.is_empty() {
|
||||
f.version = file_version(secs);
|
||||
}
|
||||
// Added after the version: registered applications alone are no kept objects whose groups
|
||||
// the DWG writer must read as the file's version, and nearly every file has some (ACAD).
|
||||
let appids = tables.iter().filter(|(k, _, _)| k == "APPID").filter_map(|(_, _, t)| val(t, 2)).map(|n| n.trim().to_string());
|
||||
f.appids = appids.take(MAX_OBJECTS).collect();
|
||||
// The file's handles of the objects CADCraft writes itself (AutoLISP's `handent`).
|
||||
f.handles = ids.iter().filter(|(h, _)| !ents.contains_key(*h)).filter_map(|(h, k)| Some((handle(h)?, k.clone()))).take(MAX_OBJECTS).collect();
|
||||
if !f.is_empty() || !f.handles.is_empty() {
|
||||
@@ -1267,7 +1271,7 @@ pub(crate) fn finish(
|
||||
join_entries(&map, b, kept, &mut out);
|
||||
}
|
||||
}
|
||||
add_appids(&mut out);
|
||||
add_appids(&mut out, &f.appids);
|
||||
let top = max_handle(&out).saturating_add(1);
|
||||
if let Some(t) = seed_index(&out).and_then(|i| out.get_mut(i))
|
||||
&& Handle::parse_hex(&t.str()).is_none_or(|h| h.0 < top)
|
||||
@@ -1593,9 +1597,13 @@ fn xdata(map: &Map, x: &ForeignExtra, own: &HashSet<String>, out: &mut Vec<Tag>)
|
||||
}
|
||||
}
|
||||
|
||||
/// APPID records for every application with xdata in the file, added to the APPID table.
|
||||
fn add_appids(out: &mut Vec<Tag>) {
|
||||
let used: BTreeMap<String, String> = out.iter().filter(|t| t.code == 1001).map(|t| (up(&t.str()), t.str().trim().to_string())).collect();
|
||||
/// APPID records for every application with xdata in the file and every one the file read had
|
||||
/// (`kept`), added to the APPID table.
|
||||
fn add_appids(out: &mut Vec<Tag>, kept: &[String]) {
|
||||
let mut used: BTreeMap<String, String> = out.iter().filter(|t| t.code == 1001).map(|t| (up(&t.str()), t.str().trim().to_string())).collect();
|
||||
for name in kept.iter().filter(|n| !n.is_empty()) {
|
||||
used.entry(up(name)).or_insert_with(|| name.clone());
|
||||
}
|
||||
let recs = written_records(out);
|
||||
let Some(table) = recs.iter().position(|r| {
|
||||
r.sec == "TABLES" && r.kind == "TABLE" && val(out.get(r.start + 1..r.end).unwrap_or(&[]), 2).is_some_and(|n| up(&n) == "APPID")
|
||||
|
||||
@@ -88,6 +88,7 @@ fn lwpolyline(tags: &[Tag], c: &mut Common, t: &T) -> Option<EntityKind> {
|
||||
// In a tilted plane: drawn as seen from above, at the vertices' mean height, its
|
||||
// vertices now plan coordinates.
|
||||
(verts, elevation) = plan_of_tilted(c.extrusion, elevation, &verts, flags & 1 != 0);
|
||||
thickness_along_z(c);
|
||||
c.extrusion = Vec3::Z;
|
||||
} else if c.extrusion.z < 0.0 {
|
||||
for v in &mut verts {
|
||||
@@ -577,7 +578,7 @@ pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) -
|
||||
break;
|
||||
}
|
||||
}
|
||||
let c = common(t);
|
||||
let mut c = common(t);
|
||||
let mut extra: Vec<EntityKind> = Vec::new();
|
||||
let k = if flags & 64 != 0 {
|
||||
// Face records that name a missing vertex (or fewer than three) are dropped: they draw
|
||||
@@ -599,13 +600,26 @@ pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) -
|
||||
} else if flags & 8 != 0 {
|
||||
EntityKind::Polyline3d(Polyline3d { points: pts.iter().map(|p| p.0).collect(), closed: flags & 1 != 0 })
|
||||
} else {
|
||||
// A 2D polyline's vertices are in its OCS: mirrored like LWPOLYLINE.
|
||||
let m = if c.extrusion.z < 0.0 { -1.0 } else { 1.0 };
|
||||
// A 2D polyline's vertices are in its OCS, at the elevation of the POLYLINE's own point:
|
||||
// in a tilted plane drawn as seen from above like LWPOLYLINE, else mirrored like it.
|
||||
let closed = flags & 1 != 0;
|
||||
let mut vertices: Vec<PolyVertex> = pts.iter().map(|p| PolyVertex { p: p.0.xy(), bulge: p.1, start_width: p.2, end_width: p.3 }).collect();
|
||||
let mut elevation = t.p(10).z;
|
||||
if tilted(c.extrusion, run_points(&vertices, elevation, closed)) {
|
||||
(vertices, elevation) = plan_of_tilted(c.extrusion, elevation, &vertices, closed);
|
||||
thickness_along_z(&mut c);
|
||||
c.extrusion = Vec3::Z;
|
||||
} else if c.extrusion.z < 0.0 {
|
||||
for v in &mut vertices {
|
||||
v.p.x = -v.p.x;
|
||||
v.bulge = -v.bulge;
|
||||
}
|
||||
}
|
||||
EntityKind::LwPolyline(LwPolyline {
|
||||
vertices: pts.iter().map(|p| PolyVertex { p: Vec2::new(m * p.0.x, p.0.y), bulge: m * p.1, start_width: p.2, end_width: p.3 }).collect(),
|
||||
closed: flags & 1 != 0,
|
||||
vertices,
|
||||
closed,
|
||||
const_width: t.fd(40, 0.0).min(t.fd(41, 0.0)).max(0.0),
|
||||
elevation: t.p(10).z,
|
||||
elevation,
|
||||
plinegen: flags & 128 != 0,
|
||||
})
|
||||
};
|
||||
@@ -714,3 +728,11 @@ fn helix(tags: &[Tag]) -> Helix {
|
||||
}
|
||||
.sanitized()
|
||||
}
|
||||
|
||||
/// A polyline drawn as seen from above gets the normal +Z: its thickness keeps the side of Z it
|
||||
/// extruded toward, which the normal it is losing said.
|
||||
fn thickness_along_z(c: &mut Common) {
|
||||
if c.extrusion.z < 0.0 {
|
||||
c.thickness = -c.thickness;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -421,6 +421,8 @@ pub(super) fn page_setup(t: &T, tags: &[Tag]) -> PageSetup {
|
||||
// Plot layout flags: 2 display plot styles, 4 centred, 16 standard scale (75 = 0: scaled
|
||||
// to fit), 128 lineweights.
|
||||
if let Some(flags) = t.i(70) {
|
||||
// Kept to be written back (a 16-bit group: only those bits).
|
||||
p.file_plot_flags = Some(flags & 0xFFFF);
|
||||
p.show_plot_styles = flags & 2 != 0;
|
||||
p.center = flags & 4 != 0;
|
||||
p.lineweights = flags & 128 != 0;
|
||||
@@ -432,6 +434,13 @@ pub(super) fn page_setup(t: &T, tags: &[Tag]) -> PageSetup {
|
||||
if let Some(s) = pos(ratio).or_else(|| pos(t.f(147))) {
|
||||
p.scale = s;
|
||||
}
|
||||
// A standard scale (flag 16, group 75 above 0: 0 is scaled to fit, the DXF Reference lists
|
||||
// 1 to 32), kept with the scale it stands for so a save can tell it was not changed.
|
||||
if t.i(70).is_some_and(|f| f & 16 != 0)
|
||||
&& let Some(code) = t.i(75).filter(|c| (1..=32).contains(c))
|
||||
{
|
||||
p.file_standard_scale = Some((code, p.scale));
|
||||
}
|
||||
p.plot_area = match t.i(74) {
|
||||
Some(0) => "display",
|
||||
Some(1) => "extents",
|
||||
|
||||
@@ -108,7 +108,10 @@ fn write_basic_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bo
|
||||
EntityKind::Line(l) => {
|
||||
w.s(0, "LINE");
|
||||
common(w, e, owner, paper, "AcDbLine");
|
||||
thickness(w, e);
|
||||
// Along the normal written with it (210 below), as read.
|
||||
if e.common.thickness != 0.0 {
|
||||
w.f(39, e.common.thickness);
|
||||
}
|
||||
w.p(10, l.a);
|
||||
w.p(11, l.b);
|
||||
extrusion(w, e);
|
||||
@@ -156,8 +159,13 @@ fn write_basic_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bo
|
||||
if p.const_width > 0.0 {
|
||||
w.f(43, p.const_width);
|
||||
}
|
||||
if p.elevation != 0.0 {
|
||||
w.f(38, p.elevation);
|
||||
// The elevation runs along the polyline's normal, which isn't written: one facing down
|
||||
// Z is at the elevation's negative. That is exact for a normal of 0,0,-1 only; a tilted
|
||||
// one pointing partly down is flipped the same way (the reader brings tilted polylines
|
||||
// into plan with normal Z, so only other sources make one).
|
||||
let elevation = if e.common.extrusion.z < 0.0 { -p.elevation } else { p.elevation };
|
||||
if elevation != 0.0 {
|
||||
w.f(38, elevation);
|
||||
}
|
||||
thickness(w, e);
|
||||
for v in &p.vertices {
|
||||
@@ -609,7 +617,10 @@ fn write_hatch_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bo
|
||||
if let EntityKind::Hatch(h) = &e.kind {
|
||||
w.s(0, "HATCH");
|
||||
common(w, e, owner, paper, "AcDbHatch");
|
||||
w.p(10, Vec3::new(0.0, 0.0, h.elevation));
|
||||
// Its elevation runs along its normal, written as Z: one facing down is at the negative.
|
||||
// Exact for a normal of 0,0,-1; the reader brings a tilted hatch into plan with normal Z.
|
||||
let elevation = if e.common.extrusion.z < 0.0 { -h.elevation } else { h.elevation };
|
||||
w.p(10, Vec3::new(0.0, 0.0, elevation));
|
||||
w.p(210, Vec3::Z);
|
||||
w.s(2, &h.pattern);
|
||||
w.i(70, i64::from(h.solid));
|
||||
@@ -829,10 +840,14 @@ fn gradient(w: &mut W, g: &Gradient) {
|
||||
w.s(1000, g.color2.name());
|
||||
}
|
||||
|
||||
/// Group 39 (thickness) of the entities whose DXF Reference record has one; only when set.
|
||||
/// Group 39 (thickness) of the entities whose DXF Reference record has one; only when set. They
|
||||
/// are written with no normal, so they extrude along Z: one whose normal points down Z extrudes
|
||||
/// the other way, and its thickness changes sign. That is exact for a normal of 0,0,-1; a tilted
|
||||
/// one pointing partly down only gets the closer of the two directions.
|
||||
fn thickness(w: &mut W, e: &Entity) {
|
||||
if e.common.thickness != 0.0 {
|
||||
w.f(39, e.common.thickness);
|
||||
let t = if e.common.extrusion.z < 0.0 { -e.common.thickness } else { e.common.thickness };
|
||||
if t != 0.0 {
|
||||
w.f(39, t);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -413,6 +413,23 @@ struct LayoutWriteData<'a> {
|
||||
limits: Option<(Vec2, Vec2)>,
|
||||
}
|
||||
|
||||
/// The plot layout flags (AcDbPlotSettings group 70) for `page`. The bits CADCraft models come
|
||||
/// from the page: 2 display plot styles, 4 centred, 128 lineweights, and 16 standard scale where
|
||||
/// the scale decides it (scaled to fit: set; a custom scale: clear). The rest are kept as the file
|
||||
/// had them (#3227); a page CADCraft made gets 512 (plot paper space last) and 32 (plot with plot
|
||||
/// styles), and 16 when its scale is standard.
|
||||
fn plot_layout_flags(page: &PageSetup, standard: bool) -> i64 {
|
||||
const MODELED: i64 = 2 | 4 | 128;
|
||||
const STANDARD_SCALE: i64 = 16;
|
||||
let kept = match page.file_plot_flags {
|
||||
Some(f) if page.scale_to_fit => (f & !MODELED) | STANDARD_SCALE,
|
||||
Some(f) if !standard => f & !MODELED & !STANDARD_SCALE,
|
||||
Some(f) => f & !MODELED,
|
||||
None => 512 | 32 | if standard { STANDARD_SCALE } else { 0 },
|
||||
};
|
||||
kept | if page.lineweights { 128 } else { 0 } | if page.center { 4 } else { 0 } | if page.show_plot_styles { 2 } else { 0 }
|
||||
}
|
||||
|
||||
fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData<'_>) {
|
||||
let d = context.drawing;
|
||||
let layout_dict = context.dictionary;
|
||||
@@ -426,13 +443,10 @@ fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData<
|
||||
// Plot scale: a standard scale when fitting or 1:1, otherwise custom (142 paper units
|
||||
// per 143 drawing units).
|
||||
let scale = if page.scale.is_finite() && page.scale > 0.0 { page.scale } else { 1.0 };
|
||||
let standard = page.scale_to_fit || scale == 1.0;
|
||||
let plot_flags = 512
|
||||
| 32
|
||||
| if standard { 16 } else { 0 }
|
||||
| if page.lineweights { 128 } else { 0 }
|
||||
| if page.center { 4 } else { 0 }
|
||||
| if page.show_plot_styles { 2 } else { 0 };
|
||||
// The file's standard scale (such as 1:50) while the scale is still the one read with it.
|
||||
let file_standard = page.file_standard_scale.filter(|&(_, s)| !page.scale_to_fit && s == scale).map(|(code, _)| code);
|
||||
let standard = page.scale_to_fit || scale == 1.0 || file_standard.is_some();
|
||||
let plot_flags = plot_layout_flags(page, standard);
|
||||
let plot_type = match page.plot_area.as_str() {
|
||||
"display" => 0,
|
||||
"extents" => 1,
|
||||
@@ -474,7 +488,7 @@ fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData<
|
||||
w.i(73, rotation);
|
||||
w.i(74, plot_type);
|
||||
w.s(7, &page.plot_style_table);
|
||||
w.i(75, if page.scale_to_fit { 0 } else { 16 });
|
||||
w.i(75, if page.scale_to_fit { 0 } else { file_standard.unwrap_or(16) });
|
||||
w.f(147, scale);
|
||||
// The paper image origin the file had (#2109), else 0,0.
|
||||
let origin = page.image_origin.filter(|o| o.is_finite()).unwrap_or(Vec2::ZERO);
|
||||
|
||||
@@ -2683,6 +2683,84 @@ fn mirrored_2d_polyline_extrusion_flips_x_and_bulge() {
|
||||
assert_eq!(got, vec![(-1.0, 0.0, -1.0), (-3.0, 0.0, 0.0)]);
|
||||
}
|
||||
|
||||
/// Objects whose normal is 0,0,-1, at OCS height 5 and most of them 2 thick, keep their world height
|
||||
/// and the side they extrude to through a save. They are written with no normal (along Z), so an
|
||||
/// elevation or a thickness written as read put a polyline or a hatch at Z +5 instead of -5, and
|
||||
/// extruded a circle, point, solid or text up instead of down (AutoCAD 2024 opening the saved file,
|
||||
/// measured). A line writes its normal, and keeps its thickness as read. The same objects facing up
|
||||
/// (no normal, and 0,0,1) keep +5 and +2: only a normal pointing down Z changes the sign.
|
||||
#[test]
|
||||
fn mirrored_objects_keep_their_world_height_and_thickness_side() {
|
||||
let records = |normal: &str| {
|
||||
format!(
|
||||
"0\nLWPOLYLINE\n8\n0\n90\n2\n70\n0\n38\n5\n39\n2\n{normal}10\n0\n20\n0\n42\n0.5\n10\n-10\n20\n0\n\
|
||||
0\nPOLYLINE\n8\n0\n66\n1\n70\n0\n10\n0\n20\n0\n30\n5\n{normal}0\nVERTEX\n8\n0\n10\n0\n20\n10\n0\nVERTEX\n8\n0\n10\n-10\n20\n10\n0\nSEQEND\n\
|
||||
0\nCIRCLE\n8\n0\n10\n-10\n20\n5\n30\n5\n40\n5\n39\n2\n{normal}\
|
||||
0\nARC\n8\n0\n10\n-30\n20\n5\n30\n5\n40\n5\n50\n180\n51\n270\n{normal}\
|
||||
0\nPOINT\n8\n0\n10\n-40\n20\n0\n30\n5\n39\n2\n{normal}\
|
||||
0\nSOLID\n8\n0\n10\n50\n20\n0\n30\n5\n11\n60\n21\n0\n31\n5\n12\n50\n22\n5\n32\n5\n13\n60\n23\n5\n33\n5\n39\n2\n{normal}\
|
||||
0\nHATCH\n8\n0\n10\n0\n20\n0\n30\n5\n{normal}2\nSOLID\n70\n1\n71\n0\n91\n1\n92\n2\n72\n0\n73\n1\n93\n4\n\
|
||||
10\n70\n20\n0\n10\n80\n20\n0\n10\n80\n20\n5\n10\n70\n20\n5\n97\n0\n75\n0\n76\n1\n98\n0\n\
|
||||
0\nTEXT\n8\n0\n10\n-90\n20\n0\n30\n5\n40\n2\n1\nA\n39\n2\n{normal}\
|
||||
0\nLINE\n8\n0\n39\n2\n10\n0\n20\n20\n30\n3\n11\n10\n21\n20\n31\n3\n{normal}"
|
||||
)
|
||||
};
|
||||
let (down, up) = ("210\n0\n220\n0\n230\n-1\n", "210\n0\n220\n0\n230\n1\n");
|
||||
let text = format!("0\nSECTION\n2\nENTITIES\n{}{}{}0\nENDSEC\n0\nEOF\n", records(down), records(""), records(up));
|
||||
// Each object's kind, world height and thickness along world Z.
|
||||
let place = |d: &Drawing| -> Vec<(&'static str, f64, f64)> {
|
||||
d.model
|
||||
.iter()
|
||||
.map(|e| {
|
||||
let n = e.common.extrusion.z.signum();
|
||||
let (kind, z) = match &e.kind {
|
||||
EntityKind::LwPolyline(p) => ("polyline", n * p.elevation),
|
||||
EntityKind::Circle(c) => ("circle", c.center.z),
|
||||
EntityKind::Arc(a) => ("arc", a.center.z),
|
||||
EntityKind::Point(p) => ("point", p.p.z),
|
||||
EntityKind::Solid(s) => ("solid", s.corners[0].z),
|
||||
EntityKind::Hatch(h) => ("hatch", n * h.elevation),
|
||||
EntityKind::Text(t) => ("text", t.insert.z),
|
||||
EntityKind::Line(l) => ("line", l.a.z),
|
||||
_ => ("other", f64::NAN),
|
||||
};
|
||||
(kind, z, n * e.common.thickness)
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
let d = read(text.as_bytes(), "m.dxf").unwrap();
|
||||
let mut want = vec![
|
||||
("polyline", -5.0, -2.0),
|
||||
("polyline", -5.0, 0.0),
|
||||
("circle", -5.0, -2.0),
|
||||
("arc", -5.0, 0.0),
|
||||
("point", 5.0, -2.0),
|
||||
("solid", -5.0, -2.0),
|
||||
("hatch", -5.0, 0.0),
|
||||
("text", -5.0, -2.0),
|
||||
("line", 3.0, -2.0),
|
||||
];
|
||||
let facing_up = [
|
||||
("polyline", 5.0, 2.0),
|
||||
("polyline", 5.0, 0.0),
|
||||
("circle", 5.0, 2.0),
|
||||
("arc", 5.0, 0.0),
|
||||
("point", 5.0, 2.0),
|
||||
("solid", 5.0, 2.0),
|
||||
("hatch", 5.0, 0.0),
|
||||
("text", 5.0, 2.0),
|
||||
("line", 3.0, 2.0),
|
||||
];
|
||||
want.extend(facing_up);
|
||||
want.extend(facing_up);
|
||||
assert_eq!(place(&d), want, "as read");
|
||||
let out = write(&d, "m.dxf").unwrap();
|
||||
assert_eq!(place(&read(&out, "m.dxf").unwrap()), want, "after a save");
|
||||
let pairs = dxf_pairs(std::str::from_utf8(&out).unwrap());
|
||||
let lines: Vec<_> = dxf_records(&pairs, "LINE").into_iter().map(|l| (group(l, "39"), group(l, "230"))).collect();
|
||||
assert_eq!(lines, [(Some("2.0"), Some("-1.0")), (Some("2.0"), None), (Some("2.0"), None)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mirrored_hatch_extrusion_flips_boundary() {
|
||||
// HATCH boundaries are OCS: the square (1,0)..(3,2) under extrusion (0,0,-1) lies at (-3,0)..(-1,2).
|
||||
@@ -2727,6 +2805,20 @@ fn tilted_hatch_turns_its_gradient() {
|
||||
assert!((g.angle - std::f64::consts::PI).abs() < 1e-9, "gradient angle {}", g.angle);
|
||||
}
|
||||
|
||||
/// A tilted polyline with a thickness, its normal pointing partly down Z, still extrudes toward -Z
|
||||
/// once it is drawn as seen from above and saved with no normal.
|
||||
#[test]
|
||||
fn tilted_thick_polyline_keeps_its_extrusion_side() {
|
||||
let text = "0\nSECTION\n2\nENTITIES\n0\nLWPOLYLINE\n8\n0\n90\n2\n70\n0\n39\n5\n210\n0\n220\n0.5\n230\n-0.8660254037844386\n\
|
||||
10\n1\n20\n0\n10\n3\n20\n2\n0\nENDSEC\n0\nEOF\n";
|
||||
let d = read(text.as_bytes(), "p.dxf").unwrap();
|
||||
let e = d.model.iter().next().unwrap();
|
||||
assert_eq!((e.common.thickness, e.common.extrusion), (-5.0, Vec3::Z));
|
||||
let back = roundtrip(&d);
|
||||
let e = back.model.iter().next().unwrap();
|
||||
assert_eq!((e.common.thickness, e.common.extrusion), (-5.0, Vec3::Z), "saved with no normal, it still extrudes toward -Z");
|
||||
}
|
||||
|
||||
/// A straight tilted LWPOLYLINE keeps its vertex widths (groups 40/41) on the projected vertices.
|
||||
#[test]
|
||||
fn tilted_straight_lwpolyline_keeps_its_widths() {
|
||||
@@ -2841,6 +2933,57 @@ fn tilted_lwpolyline_is_drawn_as_seen_from_above() {
|
||||
assert_eq!(p.vertices.iter().map(|v| v.bulge).collect::<Vec<_>>(), vec![1.0, 1.0]);
|
||||
}
|
||||
|
||||
/// A 2D POLYLINE (heavy polyline) in a tilted plane is drawn as seen from above, like a
|
||||
/// LWPOLYLINE: before, its OCS points were taken for world coordinates. With extrusion
|
||||
/// (0, 0.5, -√3/2) the OCS axes are x = (-1,0,0) and y = (0, √3/2, 1/2), and the elevation of 2
|
||||
/// moves the plane by twice the normal, (0, 1, -√3): the square (1,0)..(3,2) lies over
|
||||
/// (-3,1)..(-1,1+√3), its corners at a mean height of 1/2 - √3.
|
||||
#[test]
|
||||
fn tilted_2d_polyline_is_drawn_as_seen_from_above() {
|
||||
let square = |n: &str| {
|
||||
format!(
|
||||
"0\nSECTION\n2\nENTITIES\n0\nPOLYLINE\n8\n0\n66\n1\n10\n0\n20\n0\n30\n2\n70\n1\n{n}\
|
||||
0\nVERTEX\n8\n0\n10\n1\n20\n0\n0\nVERTEX\n8\n0\n10\n3\n20\n0\n0\nVERTEX\n8\n0\n10\n3\n20\n2\n\
|
||||
0\nVERTEX\n8\n0\n10\n1\n20\n2\n0\nSEQEND\n0\nENDSEC\n0\nEOF\n"
|
||||
)
|
||||
};
|
||||
let d = read(square("210\n0\n220\n0.5\n230\n-0.8660254037844386\n").as_bytes(), "p.dxf").unwrap();
|
||||
let b = d.extents(&Space::Model);
|
||||
let r3 = 3f64.sqrt();
|
||||
for (got, want) in [(b.min.x, -3.0), (b.min.y, 1.0), (b.max.x, -1.0), (b.max.y, 1.0 + r3)] {
|
||||
assert!((got - want).abs() < 1e-9, "extents {b:?}");
|
||||
}
|
||||
let e = d.model.iter().next().unwrap();
|
||||
assert_eq!(e.common.extrusion, Vec3::Z, "its points are plan coordinates now");
|
||||
let EntityKind::LwPolyline(p) = &e.kind else { panic!("not a polyline") };
|
||||
assert!((p.elevation - (0.5 - r3)).abs() < 1e-9, "the mean height of its corners: {}", p.elevation);
|
||||
// In plan and in the mirrored plane the polyline stays as it was: mirrored only in x.
|
||||
let plain = read(square("").as_bytes(), "p.dxf").unwrap();
|
||||
let b = plain.extents(&Space::Model);
|
||||
assert!((b.min.x - 1.0).abs() < 1e-9 && (b.max.y - 2.0).abs() < 1e-9, "extents {b:?}");
|
||||
let mirrored = read(square("210\n0\n220\n0\n230\n-1\n").as_bytes(), "p.dxf").unwrap();
|
||||
let b = mirrored.extents(&Space::Model);
|
||||
assert!((b.min.x + 3.0).abs() < 1e-9 && (b.max.x + 1.0).abs() < 1e-9, "extents {b:?}");
|
||||
assert_eq!(mirrored.model.iter().next().unwrap().common.extrusion, Vec3::new(0.0, 0.0, -1.0));
|
||||
}
|
||||
|
||||
/// A tilted 2D POLYLINE with an arc keeps its shape as seen from above: the half circle from
|
||||
/// (0,0) to (2,0) is flattened into its half ellipse, in plan x from -2 to 0 and reaching √3/2.
|
||||
#[test]
|
||||
fn tilted_2d_polyline_arc_is_flattened() {
|
||||
let text = "0\nSECTION\n2\nENTITIES\n0\nPOLYLINE\n8\n0\n66\n1\n10\n0\n20\n0\n30\n0\n70\n0\n210\n0\n220\n0.5\n230\n-0.8660254037844386\n\
|
||||
0\nVERTEX\n8\n0\n10\n0\n20\n0\n42\n1\n0\nVERTEX\n8\n0\n10\n2\n20\n0\n0\nSEQEND\n0\nENDSEC\n0\nEOF\n";
|
||||
let d = read(text.as_bytes(), "p.dxf").unwrap();
|
||||
let p = first(&d, |k| if let EntityKind::LwPolyline(p) = k { Some(p.clone()) } else { None });
|
||||
assert!(p.vertices.len() > 8 && p.vertices.iter().all(|v| v.bulge == 0.0), "{} vertices", p.vertices.len());
|
||||
let b = d.extents(&Space::Model);
|
||||
// Bulge 1 turns counter-clockwise from (0,0) to (2,0), so the arc runs below its chord, down
|
||||
// to OCS y -1: plan y -√3/2.
|
||||
for (got, want) in [(b.min.x, -2.0), (b.max.x, 0.0), (b.min.y, -(3f64.sqrt()) / 2.0), (b.max.y, 0.0)] {
|
||||
assert!((got - want).abs() < 5e-3, "extents {b:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The model extents of a one-loop solid HATCH whose edge boundary is `edges` (group 72 onwards).
|
||||
fn hatch_edge_extents(edges: &str) -> Bounds2 {
|
||||
let n = edges.matches("72\n").count();
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
//! #3227: saving kept the layout's plot flags only for the bits CADCraft models and forced 512
|
||||
//! (plot paper space last), 32 (plot with plot styles) and 16 (standard scale) on, so a layout
|
||||
//! with flags 0 came back as 560, in DXF and in DWG.
|
||||
|
||||
use cadcraft_doc::{Drawing, Layout, PageSetup};
|
||||
use cadcraft_io::{read, write};
|
||||
|
||||
/// A drawing with layout SHEET read with plot layout `flags` (lineweights, centring and display
|
||||
/// plot styles follow them, as the reader sets them).
|
||||
fn drawing(flags: i64) -> Drawing {
|
||||
let mut d = Drawing::new_imperial();
|
||||
let mut l = Layout::new("SHEET", 1);
|
||||
l.page = PageSetup {
|
||||
lineweights: flags & 128 != 0,
|
||||
center: flags & 4 != 0,
|
||||
show_plot_styles: flags & 2 != 0,
|
||||
file_plot_flags: Some(flags),
|
||||
..PageSetup::default()
|
||||
};
|
||||
d.layouts.push(l);
|
||||
d
|
||||
}
|
||||
|
||||
/// The plot layout flags of SHEET after saving `d` as `name` and reading it back.
|
||||
fn flags_after_save(d: &Drawing, name: &str) -> Option<i64> {
|
||||
let bytes = write(d, name).unwrap();
|
||||
let back = read(&bytes, name).unwrap();
|
||||
back.layouts.iter().find(|l| l.name == "SHEET")?.page.file_plot_flags
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plot_layout_flags_are_saved_as_read() {
|
||||
cadcraft_io::dwg_worker::allow_in_process();
|
||||
for name in ["sheet.dxf", "sheet.dwg"] {
|
||||
for flags in [0, 176, 560, 688] {
|
||||
assert_eq!(flags_after_save(&drawing(flags), name), Some(flags), "{name}: flags {flags}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unchanged_standard_scale_keeps_its_flag_and_choice() {
|
||||
cadcraft_io::dwg_worker::allow_in_process();
|
||||
// Flags 176 with standard scale 25 (1:50): the scale is 0.02, not 1:1, and still standard.
|
||||
let mut d = drawing(176);
|
||||
let page = &mut d.layouts.last_mut().unwrap().page;
|
||||
page.scale = 0.02;
|
||||
page.file_standard_scale = Some((25, 0.02));
|
||||
for name in ["sheet.dxf", "sheet.dwg"] {
|
||||
let back = read(&write(&d, name).unwrap(), name).unwrap();
|
||||
let page = &back.layouts.iter().find(|l| l.name == "SHEET").unwrap().page;
|
||||
assert_eq!(page.file_plot_flags, Some(176), "{name}");
|
||||
assert_eq!(page.file_standard_scale, Some((25, 0.02)), "{name}");
|
||||
}
|
||||
// A scale changed after reading is a custom one: 16 is cleared and the choice dropped.
|
||||
d.layouts.last_mut().unwrap().page.scale = 0.05;
|
||||
assert_eq!(flags_after_save(&d, "sheet.dxf"), Some(160));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_page_still_decides_the_bits_cadcraft_models() {
|
||||
// Lineweights turned on and a custom scale chosen after reading flags 16: 128 is set and the
|
||||
// standard scale bit cleared, the rest kept.
|
||||
let mut d = drawing(16 | 512);
|
||||
let page = &mut d.layouts.last_mut().unwrap().page;
|
||||
page.lineweights = true;
|
||||
page.scale = 0.02;
|
||||
assert_eq!(flags_after_save(&d, "sheet.dxf"), Some(512 | 128));
|
||||
// A page made in CADCraft keeps the defaults (plot paper space last, plot with plot styles,
|
||||
// standard scale, lineweights).
|
||||
let mut d = drawing(0);
|
||||
d.layouts.last_mut().unwrap().page = PageSetup::default();
|
||||
assert_eq!(flags_after_save(&d, "sheet.dxf"), Some(512 | 128 | 32 | 16));
|
||||
}
|
||||
@@ -36,6 +36,7 @@ mod helix_roundtrip;
|
||||
mod layer_states_acad;
|
||||
mod layout_limits_roundtrip;
|
||||
mod layout_paper_units;
|
||||
mod layout_plot_flags;
|
||||
mod layout_plot_window;
|
||||
mod leader_vertex_elevation;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
|
||||
@@ -257,7 +257,8 @@ pub(super) fn assert_layouts(a: &Drawing, b: &Drawing, context: &str) {
|
||||
let back = b.layouts.iter().find(|l| l.name == layout.name).expect("layout must survive");
|
||||
assert_eq!(back.tab_order, layout.tab_order, "{context}.{}.tab_order", layout.name);
|
||||
// The groups 44, 45 and 73 the file stored are provenance, not a setting.
|
||||
let setting = |p: &cadcraft_doc::PageSetup| cadcraft_doc::PageSetup { file_paper: None, ..p.clone() };
|
||||
let setting =
|
||||
|p: &cadcraft_doc::PageSetup| cadcraft_doc::PageSetup { file_paper: None, file_plot_flags: None, file_standard_scale: None, ..p.clone() };
|
||||
assert_eq!(setting(&back.page), setting(&layout.page), "{context}.{}.page", layout.name);
|
||||
assert_eq!(back.view, layout.view, "{context}.{}.view", layout.name);
|
||||
compare::entities(a, b, &layout.entities, &back.entities, &format!("{context}.layout[{}]", layout.name));
|
||||
|
||||
@@ -112,7 +112,7 @@ fn layout_page_setup_and_paper_view_round_trip() {
|
||||
for (a, b) in d.layouts.iter().zip(&r.layouts) {
|
||||
assert_eq!(a.name, b.name);
|
||||
// The groups 44, 45 and 73 the file stored are provenance, not a setting.
|
||||
let read = cadcraft_doc::PageSetup { file_paper: None, ..b.page.clone() };
|
||||
let read = cadcraft_doc::PageSetup { file_paper: None, file_plot_flags: None, file_standard_scale: None, ..b.page.clone() };
|
||||
assert_eq!(a.page, read, "{}", a.name);
|
||||
assert_eq!(a.view, b.view, "{}", a.name);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
//! The registered applications (APPID) of a file are saved back, in DXF and in DWG, save after
|
||||
//! save, also those no xdata names.
|
||||
|
||||
use cadcraft_doc::Drawing;
|
||||
use cadcraft_io::{read, read_dxf, write, write_dxf};
|
||||
|
||||
/// The records of a DXF: each `(code, value)` from its `0` group on.
|
||||
fn records(text: &str) -> Vec<Vec<(i32, String)>> {
|
||||
let lines: Vec<&str> = text.lines().collect();
|
||||
let mut out: Vec<Vec<(i32, String)>> = Vec::new();
|
||||
for chunk in lines.chunks(2) {
|
||||
let [code, value] = chunk else { break };
|
||||
let Ok(c) = code.trim().parse::<i32>() else { continue };
|
||||
let pair = (c, value.trim().to_string());
|
||||
if c == 0 {
|
||||
out.push(vec![pair]);
|
||||
} else if let Some(r) = out.last_mut() {
|
||||
r.push(pair);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The value of the record's first group `code`.
|
||||
fn value(r: &[(i32, String)], code: i32) -> Option<&str> {
|
||||
r.iter().find(|(c, _)| *c == code).map(|(_, v)| v.as_str())
|
||||
}
|
||||
|
||||
/// A file whose APPID table has `Other_App` (handle 7A00), which no xdata names; with `xdata`,
|
||||
/// a line's xdata names it as `OTHER_APP`.
|
||||
fn source(xdata: bool) -> String {
|
||||
let mut out = String::new();
|
||||
let mut put = |c: i32, v: &str| out.push_str(&format!("{c:>3}\n{v}\n"));
|
||||
for r in records(&write_dxf(&Drawing::new_metric())) {
|
||||
for (c, v) in &r {
|
||||
put(*c, v);
|
||||
}
|
||||
if xdata && r[0].1 == "SECTION" && value(&r, 2) == Some("ENTITIES") {
|
||||
for (c, v) in [
|
||||
(0, "LINE"),
|
||||
(5, "7A01"),
|
||||
(100, "AcDbEntity"),
|
||||
(8, "0"),
|
||||
(100, "AcDbLine"),
|
||||
(10, "0"),
|
||||
(20, "0"),
|
||||
(30, "0"),
|
||||
(11, "10"),
|
||||
(21, "0"),
|
||||
(31, "0"),
|
||||
(1001, "OTHER_APP"),
|
||||
(1000, "x"),
|
||||
] {
|
||||
put(c, v);
|
||||
}
|
||||
}
|
||||
if r[0].1 == "TABLE" && value(&r, 2) == Some("APPID") {
|
||||
let table = value(&r, 5).unwrap_or("0").to_string();
|
||||
for (c, v) in [
|
||||
(0, "APPID"),
|
||||
(5, "7A00"),
|
||||
(330, table.as_str()),
|
||||
(100, "AcDbSymbolTableRecord"),
|
||||
(100, "AcDbRegAppTableRecord"),
|
||||
(2, "Other_App"),
|
||||
(70, "0"),
|
||||
] {
|
||||
put(c, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// How many APPID records of the DXF are named `Other_App`, in any case.
|
||||
fn appids(text: &str) -> usize {
|
||||
records(text).into_iter().filter(|r| r[0].1 == "APPID" && value(r, 2).is_some_and(|n| n.eq_ignore_ascii_case("Other_App"))).count()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registered_applications_no_xdata_names_are_kept() {
|
||||
cadcraft_io::dwg_worker::allow_in_process();
|
||||
let mut d = read_dxf(source(false).as_bytes()).expect("read");
|
||||
for generation in 1..=2 {
|
||||
let text = write_dxf(&d);
|
||||
assert_eq!(appids(&text), 1, "DXF {generation}");
|
||||
d = read_dxf(text.as_bytes()).expect("reread");
|
||||
}
|
||||
for generation in 1..=2 {
|
||||
let dwg = write(&d, "kept.dwg").expect("DWG");
|
||||
d = read(&dwg, "kept.dwg").expect("DWG read");
|
||||
assert_eq!(appids(&write_dxf(&d)), 1, "DWG {generation}");
|
||||
}
|
||||
}
|
||||
|
||||
/// An application both registered and named by xdata, in another case, gets one record.
|
||||
#[test]
|
||||
fn a_registered_application_xdata_names_gets_one_record() {
|
||||
cadcraft_io::dwg_worker::allow_in_process();
|
||||
let mut d = read_dxf(source(true).as_bytes()).expect("read");
|
||||
for generation in 1..=2 {
|
||||
let text = write_dxf(&d);
|
||||
assert!(text.contains("OTHER_APP"), "DXF {generation}: the line's xdata is kept");
|
||||
assert_eq!(appids(&text), 1, "DXF {generation}");
|
||||
d = read_dxf(text.as_bytes()).expect("reread");
|
||||
}
|
||||
for generation in 1..=2 {
|
||||
let dwg = write(&d, "kept.dwg").expect("DWG");
|
||||
d = read(&dwg, "kept.dwg").expect("DWG read");
|
||||
assert_eq!(appids(&write_dxf(&d)), 1, "DWG {generation}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Registered applications alone are not kept objects: a file with nothing else to keep notes no
|
||||
/// version, so the DWG writer reads its R2000 text as before rather than as the file's version.
|
||||
#[test]
|
||||
fn registered_applications_alone_note_no_version() {
|
||||
let d = read_dxf(source(false).as_bytes()).expect("read");
|
||||
assert!(d.foreign.appids.iter().any(|n| n == "Other_App"), "{:?}", d.foreign.appids);
|
||||
assert_eq!(d.foreign.version, None);
|
||||
}
|
||||
@@ -133,8 +133,8 @@ pub fn entries(app: &CadApp) -> Vec<Vec<Entry>> {
|
||||
}
|
||||
|
||||
/// The edit commands of the selected objects' type (when they are all of one type), with their
|
||||
/// labels: Edit Text for text, Block Editor and Edit Attributes for block references, Hatch Edit,
|
||||
/// Polyline Edit, Spline Edit…
|
||||
/// labels: Edit Text for text, Block Editor and Edit Attributes for block references, Hatch Edit
|
||||
/// and Generate Boundary for hatches, Polyline Edit, Spline Edit…
|
||||
fn object_commands(app: &CadApp) -> Vec<(&'static str, Option<&'static str>)> {
|
||||
let Ok(d) = app.session.doc() else { return Vec::new() };
|
||||
let sel = app.session.selection();
|
||||
@@ -153,7 +153,7 @@ fn object_commands(app: &CadApp) -> Vec<(&'static str, Option<&'static str>)> {
|
||||
}
|
||||
v
|
||||
}
|
||||
EntityKind::Hatch(_) => vec![("hatchedit", None)],
|
||||
EntityKind::Hatch(_) => vec![("hatchedit", None), ("hatchgenerateboundary", None)],
|
||||
EntityKind::LwPolyline(_) | EntityKind::Polyline3d(_) => vec![("pedit", Some("Polyline Edit"))],
|
||||
EntityKind::Spline(_) => vec![("splinedit", Some("Spline Edit"))],
|
||||
EntityKind::Dimension(_) => vec![("dimtedit", None)],
|
||||
|
||||
@@ -374,6 +374,7 @@
|
||||
From Desde
|
||||
From Template... Desde plantilla...
|
||||
General General
|
||||
Generate Boundary Generar contorno
|
||||
Geometric Center Centro geométrico
|
||||
Geometric Constraint Restricción geométrica
|
||||
Geometric Constraints Restricciones geométricas
|
||||
|
||||
|
@@ -296,6 +296,7 @@
|
||||
Freeze/Thaw in the current viewport 在当前视口中冻结/解冻
|
||||
From 自
|
||||
General 常规
|
||||
Generate Boundary 生成边界
|
||||
Geometric Center 几何中心
|
||||
Geometric Constraint 几何约束
|
||||
Geometric Constraints 几何约束
|
||||
|
||||
|
Reference in New Issue
Block a user