SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
DXF export: the full R2000 file structure strict readers need (#9144) (#9662)
PaddleStroke8d22b3a41a59
diff --git a/crates/io/src/dxf_out.rs b/crates/io/src/dxf_out.rsindex 7881672e62..6a2c93c9f3 100644--- a/crates/io/src/dxf_out.rs+++ b/crates/io/src/dxf_out.rs@@ -4,10 +4,11 @@//! Curves stay exact: a circle is a CIRCLE, a circular arc an ARC, a whole ellipse one ELLIPSE//! and a conic arc of weight below 1 an elliptical ELLIPSE arc; Béziers (TrueType glyph//! outlines, spline pieces) and the other conics are SPLINEs of their own degree. The file holds-//! what the entities refer to and what release 2000 needs to read them: the version, the-//! handle seed, the units and the extents; the linetype, layer and block-record tables; the-//! model and paper space blocks; handles, owners and the subclass markers of each entity; the-//! root dictionary. Layers can be dashed and a drawing can carry TEXT (for annotations). Group+//! what the entities refer to and what release 2000 needs to read them: the version, code page,+//! handle seed, units and extents; the (empty) CLASSES section; all nine symbol tables, with the+//! active viewport, the linetypes, layers, text style, the ACAD application id, the dimension+//! style and the block records; the model and paper space blocks; handles, owners and the+//! subclass markers of each entity; the root dictionary and its group dictionary. Layers can be dashed and a drawing can carry TEXT (for annotations). Group//! codes follow Autodesk's public DXF reference.use std::f64::consts::TAU;@@ -267,6 +268,11 @@ impl Out {self.num(c + 10, p.y);self.num(c + 20, 0.0);}+ /// A 2D point: codes `c` and `c + 10`.+ fn point2(&mut self, c: i32, p: Vec2) {+ self.num(c, p.x);+ self.num(c + 10, p.y);+ }fn handle(&mut self) -> String {let h = format!("{:X}", self.next);self.next += 1;@@ -366,10 +372,48 @@ pub fn write_dxf_drawing(layers: &[DxfLayer], entities: &[DxfEntity]) -> Result<let (model, paper) = (o.handle(), o.handle());let root = o.handle();+ // Release 2000 readers expect the CLASSES section, even empty, between HEADER and TABLES.+ o.code(0, "SECTION");+ o.code(2, "CLASSES");+ o.code(0, "ENDSEC");++ // All nine symbol tables, in the reference's order, even those with nothing to hold: a+ // strict reader (AutoCAD among them, #9144) refuses a file that leaves one out.o.code(0, "SECTION");o.code(2, "TABLES");- // The three every drawing has, and DASHED, which the dashed layers name: dash and gap lengths- // (a gap is negative) after the pattern's total.+ // The active viewport, looking down on the whole drawing so it opens zoomed to fit.+ let t = o.table("VPORT", 1);+ o.record("VPORT", "AcDbViewportTableRecord", &t);+ o.code(2, "*Active");+ o.code(70, 0);+ o.point2(10, Vec2::ZERO);+ o.point2(11, Vec2::new(1.0, 1.0));+ o.point2(12, (lo + hi) * 0.5);+ o.point2(13, Vec2::ZERO);+ o.point2(14, Vec2::new(10.0, 10.0));+ o.point2(15, Vec2::new(10.0, 10.0));+ o.num(16, 0.0);+ o.num(26, 0.0);+ o.num(36, 1.0);+ o.num(17, 0.0);+ o.num(27, 0.0);+ o.num(37, 0.0);+ const ASPECT: f64 = 1.5;+ let size = hi - lo;+ let height = (size.y.max(size.x / ASPECT) * 1.1).max(1.0);+ o.num(40, if height.is_finite() { height } else { 1.0 });+ o.num(41, ASPECT);+ o.num(42, 50.0);+ o.num(43, 0.0);+ o.num(44, 0.0);+ o.num(50, 0.0);+ o.num(51, 0.0);+ for (code, value) in [(71, 0), (72, 1000), (73, 1), (74, 3), (75, 0), (76, 0), (77, 0), (78, 0)] {+ o.code(code, value);+ }+ o.code(0, "ENDTAB");+ // The three linetypes every drawing has, and DASHED, which the dashed layers name: dash and+ // gap lengths (a gap is negative) after the pattern's total.let mut linetypes: Vec<(&str, &str, &[f64])> = vec![("ByBlock", "", &[]),("ByLayer", "", &[]),@@ -416,6 +460,29 @@ pub fn write_dxf_drawing(layers: &[DxfLayer], entities: &[DxfEntity]) -> Result<o.code(3, "txt");o.code(4, "");o.code(0, "ENDTAB");+ for name in ["VIEW", "UCS"] {+ o.table(name, 0);+ o.code(0, "ENDTAB");+ }+ // The application id every drawing registers.+ let t = o.table("APPID", 1);+ o.record("APPID", "AcDbRegAppTableRecord", &t);+ o.code(2, "ACAD");+ o.code(70, 0);+ o.code(0, "ENDTAB");+ // The one dimension style, with the default settings. The table has a subclass of its own+ // and its records keep their handle under 105, not 5.+ let t = o.table("DIMSTYLE", 1);+ o.code(100, "AcDbDimStyleTable");+ let h = o.handle();+ o.code(0, "DIMSTYLE");+ o.code(105, h);+ o.code(330, &t);+ o.code(100, "AcDbSymbolTableRecord");+ o.code(100, "AcDbDimStyleTableRecord");+ o.code(2, "Standard");+ o.code(70, 0);+ o.code(0, "ENDTAB");let t = o.table("BLOCK_RECORD", 2);for (h, name) in [(&model, "*Model_Space"), (&paper, "*Paper_Space")] {o.code(0, "BLOCK_RECORD");@@ -535,11 +602,20 @@ pub fn write_dxf_drawing(layers: &[DxfLayer], entities: &[DxfEntity]) -> Result<o.code(0, "SECTION");o.code(2, "OBJECTS");+ // The root dictionary, which must name the group dictionary (empty: no groups).+ let groups = o.handle();o.code(0, "DICTIONARY");o.code(5, root.as_str());o.code(330, 0);o.code(100, "AcDbDictionary");o.code(281, 1);+ o.code(3, "ACAD_GROUP");+ o.code(350, &groups);+ o.code(0, "DICTIONARY");+ o.code(5, &groups);+ o.code(330, &root);+ o.code(100, "AcDbDictionary");+ o.code(281, 1);o.code(0, "ENDSEC");o.code(0, "EOF");@@ -548,6 +624,10 @@ pub fn write_dxf_drawing(layers: &[DxfLayer], entities: &[DxfEntity]) -> Result<head.code(2, "HEADER");head.code(9, "$ACADVER");head.code(1, "AC1015");+ // Every character in the file is ASCII (other letters are `\U+XXXX`), which this code page+ // reads as itself.+ head.code(9, "$DWGCODEPAGE");+ head.code(3, "ANSI_1252");head.code(9, "$HANDSEED");head.code(5, format!("{:X}", o.next));head.code(9, "$INSUNITS");@@ -966,6 +1046,76 @@ mod tests {}}+ #[test]+ fn a_strict_reader_finds_every_section_table_and_the_group_dictionary() {+ // #9144: AutoCAD refused the exported view. A release 2000 file has the CLASSES section,+ // all nine symbol tables with their standard records, and a root dictionary naming+ // ACAD_GROUP.+ let ents = [+ DxfEntity { layer: "VISIBLE".into(), shape: DxfShape::Line(Vec2::new(0.0, 0.0), Vec2::new(30.0, 0.0)) },+ DxfEntity { layer: "VISIBLE".into(), shape: DxfShape::Circle { c: Vec2::new(15.0, 5.0), r: 5.0 } },+ ];+ let dxf = write_dxf_drawing(&[DxfLayer::new("VISIBLE", 7)], &ents).unwrap();+ let p = pairs(&dxf);+ let sections: Vec<&str> = p.windows(2).filter(|w| w[0] == (0, "SECTION".into())).map(|w| w[1].1.as_str()).collect();+ assert_eq!(sections, ["HEADER", "CLASSES", "TABLES", "BLOCKS", "ENTITIES", "OBJECTS"]);+ let tables: Vec<&str> = p.windows(2).filter(|w| w[0] == (0, "TABLE".into())).map(|w| w[1].1.as_str()).collect();+ assert_eq!(tables, ["VPORT", "LTYPE", "LAYER", "STYLE", "VIEW", "UCS", "APPID", "DIMSTYLE", "BLOCK_RECORD"]);+ // Each table says how many records it holds, and holds them.+ for table in tables {+ let at = p.iter().position(|(c, v)| (*c, v.as_str()) == (2, table)).unwrap();+ let count: usize = p[at..].iter().find(|(c, _)| *c == 70).unwrap().1.parse().unwrap();+ assert_eq!(table_records(&p, table).len(), count, "{table}");+ }+ assert_eq!(table_records(&p, "APPID").iter().map(|r| field(r, 2)).collect::<Vec<_>>(), ["ACAD"]);+ let dimstyles = table_records(&p, "DIMSTYLE");+ // (The DIMSTYLE table's own subclass comes before its record.)+ let [standard] = dimstyles.as_slice() else { panic!("{dimstyles:?}") };+ assert_eq!(field(standard, 2), "Standard");+ assert!(!field(standard, 105).is_empty() && field(standard, 5).is_empty(), "{standard:?}");+ // The active viewport looks down on the middle of the drawing (0, 0)..(30, 10), all of it in view.+ let vports = table_records(&p, "VPORT");+ let [active] = vports.as_slice() else { panic!("{vports:?}") };+ assert_eq!(field(active, 2), "*Active");+ assert_eq!((field(active, 12), field(active, 22), field(active, 36)), ("15.0", "5.0", "1.0"));+ let (height, aspect): (f64, f64) = (field(active, 40).parse().unwrap(), field(active, 41).parse().unwrap());+ assert!(height >= 10.0 && height * aspect >= 30.0, "{height} {aspect}");+ // The root dictionary names the group dictionary, which it owns.+ let objects = p.iter().position(|(c, v)| (*c, v.as_str()) == (2, "OBJECTS")).unwrap();+ let mut dictionaries: Vec<Vec<(i32, String)>> = Vec::new();+ for (c, v) in p[objects + 1..].iter().take_while(|(c, v)| (*c, v.as_str()) != (0, "ENDSEC")) {+ match c {+ 0 => dictionaries.push(Vec::new()),+ _ => dictionaries.last_mut().unwrap().push((*c, v.clone())),+ }+ }+ let [root, groups] = dictionaries.as_slice() else { panic!("{dictionaries:?}") };+ assert_eq!((field(root, 330), field(root, 3)), ("0", "ACAD_GROUP"));+ assert_eq!(field(root, 350), field(groups, 5));+ assert_eq!(field(groups, 330), field(root, 5));+ // Handles, under 5 and the DIMSTYLE's 105, are unique and below the seed.+ let seed_at = p.iter().position(|(c, v)| (*c, v.as_str()) == (9, "$HANDSEED")).unwrap() + 1;+ let seed = u64::from_str_radix(&p[seed_at].1, 16).unwrap();+ let mut handles: Vec<u64> = p+ .iter()+ .enumerate()+ .filter(|(i, (c, _))| *i != seed_at && (*c == 5 || *c == 105))+ .map(|(_, (_, v))| u64::from_str_radix(v, 16).unwrap())+ .collect();+ let n = handles.len();+ handles.sort_unstable();+ handles.dedup();+ assert_eq!(handles.len(), n);+ assert!(handles.iter().all(|h| *h < seed));+ // Every owner (330) is 0 or a handle in the file.+ for (_, v) in p.iter().filter(|(c, _)| *c == 330) {+ let h = u64::from_str_radix(v, 16).unwrap();+ assert!(h == 0 || handles.binary_search(&h).is_ok(), "owner {v}");+ }+ // SolidCraft's own reader still reads it.+ assert_eq!(read_dxf(&dxf).unwrap().len(), 2);+ }+#[test]fn the_extents_hold_the_text() {// Five letters of 3 mm, turned to read upwards: 0.8 × 3 × 5 = 12 mm long around y = 12, and