pycadkit 0.3.2__tar.gz → 0.3.3__tar.gz

{pycadkit-0.3.2 → pycadkit-0.3.3}/Cargo.lock

@@ -66,7 +66,7 @@ checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "cadkit"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit-core",
  "cadkit-dgn",
@@ -78,7 +78,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-capi"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit",
  "serde",
@@ -87,7 +87,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-cli"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit",
  "clap",
@@ -96,7 +96,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-core"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "serde",
  "serde_json",
@@ -105,7 +105,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-dgn"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit-core",
  "cfb",
@@ -116,7 +116,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-dwg"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit-core",
  "cadkit-dxf",
@@ -126,7 +126,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-dxf"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit-core",
  "encoding_rs",
@@ -135,7 +135,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-gml"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit-core",
  "quick-xml",
@@ -145,7 +145,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-py"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit",
  "pyo3",
@@ -155,7 +155,7 @@ dependencies = [
 
 [[package]]
 name = "cadkit-wasm"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "cadkit",
  "js-sys",

{pycadkit-0.3.2 → pycadkit-0.3.3}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*"]
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.3.2"
+version = "0.3.3"
 edition = "2024"
 rust-version = "1.85"
 license = "MIT OR Apache-2.0"
@@ -14,12 +14,12 @@ keywords = ["cad", "dwg", "dgn", "dxf", "citygml"]
 categories = ["parser-implementations", "graphics", "encoding", "science::geo"]
 
 [workspace.dependencies]
-cadkit-core = { path = "crates/cadkit-core", version = "0.3.2" }
-cadkit-dgn = { path = "crates/cadkit-dgn", version = "0.3.2" }
-cadkit-dwg = { path = "crates/cadkit-dwg", version = "0.3.2" }
-cadkit-dxf = { path = "crates/cadkit-dxf", version = "0.3.2" }
-cadkit-gml = { path = "crates/cadkit-gml", version = "0.3.2" }
-cadkit = { path = "crates/cadkit", version = "0.3.2" }
+cadkit-core = { path = "crates/cadkit-core", version = "0.3.3" }
+cadkit-dgn = { path = "crates/cadkit-dgn", version = "0.3.3" }
+cadkit-dwg = { path = "crates/cadkit-dwg", version = "0.3.3" }
+cadkit-dxf = { path = "crates/cadkit-dxf", version = "0.3.3" }
+cadkit-gml = { path = "crates/cadkit-gml", version = "0.3.3" }
+cadkit = { path = "crates/cadkit", version = "0.3.3" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = "2"

{pycadkit-0.3.2 → pycadkit-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycadkit
-Version: 0.3.2
+Version: 0.3.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{pycadkit-0.3.2 → pycadkit-0.3.3}/crates/cadkit-dgn/src/writer/mod.rs

@@ -4,13 +4,14 @@ mod container;
 mod encode;
 mod polyline;
 mod raster;
+mod raster_builtin;
 mod raster_template;
 mod tables;
 mod text;
 
 use crate::{
     le,
-    native::v8::{self, AuxRecord, ModelHeader, PageHeader, RawElement},
+    native::v8::{self, AuxRecord, ModelHeader, PageHeader, RawElement, V8Model},
 };
 use cadkit_core::{
     Attribute, Document, Entity, EntityKind, Error, GroupKind, Limits, Point3, ReadOptions, Result,
@@ -41,8 +42,9 @@ pub struct WriteOptions {
     pub planarity_tolerance: f64,
     /// Preserve unchanged raster attachments from the same seed, including their
     /// opaque control and auxiliary records. Edited attachments are rejected; images
-    /// without an id are new attachments cloned from a seed attachment (see
-    /// [`seed_has_raster_template`]) whatever this option says.
+    /// without an id are new attachments cloned from a seed attachment, or from the
+    /// built-in group when the seed has none (see [`seed_has_raster_template`]), whatever
+    /// this option says.
     pub preserve_seed_rasters: bool,
     /// Keep the seed model's control records that reference no seed graphic (coordinate
     /// system, model settings and similar) with their auxiliary data, byte for byte.
@@ -71,12 +73,13 @@ pub fn repack_v8(seed: &[u8], options: &ReadOptions) -> Result<Vec<u8>> {
     container::rewrite(seed, &BTreeMap::new(), options)
 }
 
-/// Whether `seed` can receive new raster attachments: its single model holds at least one
-/// complete raster attachment (the records 92, 93, 93, 90, 91 x 5 in the control pages,
+/// Whether `seed` holds its own raster attachment template: its single model holds at least
+/// one complete raster attachment (the records 92, 93, 93, 90, 91 x 5 in the control pages,
 /// the frame 94 they point at and its XAttribute 170) that [`write_v8`] clones for every
-/// [`EntityKind::Image`] without an id. Seeds with several models return `false`, as
-/// `write_v8` accepts single-model seeds only. `Err` when the seed is not a readable
-/// DGN V8 file.
+/// [`EntityKind::Image`] without an id. Without one, `write_v8` clones a built-in group
+/// (bitonal display, 200 DPI unless `dgn.raster_dpi` is given) instead. Seeds with several
+/// models return `false`, as `write_v8` accepts single-model seeds only. `Err` when the
+/// seed is not a readable DGN V8 file.
 pub fn seed_has_raster_template(seed: &[u8], options: &ReadOptions) -> Result<bool> {
     let native = v8::read(seed, options)?;
     Ok(match native.models.as_slice() {
@@ -85,6 +88,16 @@ pub fn seed_has_raster_template(seed: &[u8], options: &ReadOptions) -> Result<bo
     })
 }
 
+/// Format version of new graphic pages: the seed's first page version, else 3.
+fn graphic_page_version(model: &V8Model) -> u32 {
+    model
+        .graphic_pages
+        .first()
+        .map(|p| p.header.format_version)
+        .filter(|v| matches!(v, 2 | 3))
+        .unwrap_or(3)
+}
+
 fn compressed(bytes: &[u8]) -> Result<Vec<u8>> {
     let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
     encoder.write_all(bytes)?;
@@ -320,12 +333,7 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
             replacements.insert(stream.path.clone(), None);
         }
     }
-    let version = model
-        .graphic_pages
-        .first()
-        .map(|p| p.header.format_version)
-        .filter(|v| matches!(v, 2 | 3))
-        .unwrap_or(3);
+    let version = graphic_page_version(model);
     let record_pages = put_pages(
         &mut replacements,
         &format!("Dgn-Md/{}/Dgn^G", model.storage),
@@ -1048,7 +1056,7 @@ impl State<'_> {
             .rasters
             .template
             .as_ref()
-            .ok_or_else(|| Error::Unsupported(raster_template::NO_TEMPLATE.into()))?;
+            .ok_or_else(|| Error::invalid(0, "raster template missing for a new attachment"))?;
         let mut ids = [0u64; 10];
         for id in &mut ids {
             *id = self.tables.id()?;

{pycadkit-0.3.2 → pycadkit-0.3.3}/crates/cadkit-dgn/src/writer/raster.rs

@@ -5,9 +5,10 @@
 //! those fields or leaving known dependencies pointing at regenerated graphic IDs. Control
 //! records that reference a seed graphic are only kept together with that graphic, which
 //! the writer can do for unchanged rasters alone. New attachments (images without an id)
-//! are cloned from a seed attachment instead ([`super::raster_template`]).
+//! are cloned from a seed attachment, or the built-in group, instead
+//! ([`super::raster_template`]).
 
-use super::raster_template::{NO_TEMPLATE, Template};
+use super::raster_template::Template;
 use super::{WriteOptions, compressed, encode::*};
 use crate::native::v8::{AuxPage, AuxRecord, PageHeader, RawElement, V8Model};
 use cadkit_core::{Document, Entity, EntityKind, Error, ReadOptions, Result};
@@ -76,8 +77,13 @@ impl Preserved {
             ));
         }
         let template = if new > 0 {
-            // Captured from the parsed seed, before its model records are dropped.
-            Some(Template::capture(model).ok_or_else(|| Error::Unsupported(NO_TEMPLATE.into()))?)
+            // Captured from the parsed seed, before its model records are dropped; a seed
+            // without an attachment gets the built-in group, its XAttribute paged like the
+            // new graphic pages.
+            Some(match Template::capture(model) {
+                Some(template) => template,
+                None => Template::builtin(super::graphic_page_version(model))?,
+            })
         } else {
             None
         };

pycadkit-0.3.3/crates/cadkit-dgn/src/writer/raster_builtin.rs

@@ -0,0 +1,204 @@
+//! Built-in raster attachment group, used when the seed holds none to clone.
+//!
+//! The records follow the attachment layout of FORMAT_NOTES ("Raster attachments"). Every
+//! byte below is either equal in all complete attachment groups surveyed (2,316 groups in
+//! 2D and 3D files) or, for the undecoded display fields that differ between files, the
+//! value of one combination observed together: bitonal display with a white foreground and
+//! a black background, 200 DPI, the frame on colour 0 with weight 1 and the control records
+//! on the default level (64). Ids, times, the range, the placement, the cross ids and the
+//! strings are zero here; [`super::raster_template::Template::instantiate`] writes them.
+
+use cadkit_core::{Error, Result};
+
+/// A record as its length and its non-zero byte runs `(offset, hex)`.
+pub(super) struct Sparse {
+    pub len: usize,
+    pub runs: &'static [(usize, &'static str)],
+}
+
+impl Sparse {
+    pub fn bytes(&self) -> Result<Vec<u8>> {
+        let mut out = vec![0; self.len];
+        for (offset, hex) in self.runs {
+            let run = decode(hex)?;
+            let end = offset
+                .checked_add(run.len())
+                .filter(|end| *end <= self.len)
+                .ok_or_else(|| Error::invalid(0, "built-in raster record run out of range"))?;
+            out.get_mut(*offset..end)
+                .ok_or_else(|| Error::invalid(0, "built-in raster record run out of range"))?
+                .copy_from_slice(&run);
+        }
+        Ok(out)
+    }
+}
+
+/// Hex digits, spaces ignored.
+fn decode(hex: &str) -> Result<Vec<u8>> {
+    let digits: Vec<u8> = hex
+        .bytes()
+        .filter(|b| *b != b' ')
+        .map(|b| match b {
+            b'0'..=b'9' => Ok(b - b'0'),
+            b'a'..=b'f' => Ok(b - b'a' + 10),
+            _ => Err(Error::invalid(0, "built-in raster record is not hex")),
+        })
+        .collect::<Result<_>>()?;
+    if digits.len() % 2 != 0 {
+        return Err(Error::invalid(
+            0,
+            "built-in raster record has an odd digit count",
+        ));
+    }
+    Ok(digits
+        .chunks_exact(2)
+        .map(|p| p.iter().fold(0, |a, d| a << 4 | d))
+        .collect())
+}
+
+/// Frame 94 (1024 bytes, no linkages): properties `0x0A00`, weight 1, 200 DPI at `0x118`
+/// and `0x120`, and the undecoded display block from `0x128`, unit scales included.
+pub(super) const FRAME: Sparse = Sparse {
+    len: 0x400,
+    runs: &[
+        (0x000, "5e00c010 00020000 0002"),
+        (0x029, "0a 00000000 0000 01"),
+        (0x06c, "05000000 0405"),
+        (0x0fc, "05"),
+        (0x11e, "6940 0000000000006940 008078ff"),
+        (0x136, "f03f 000000000000f03f 00090000 00090000 fe0a"),
+        (0x154, "02000000 00ff01"),
+        (0x358, "01000000 00000000 11000000 00000000 11"),
+        (
+            0x376,
+            "f03f 000000000000f03f 000000000000f03f 000000000000f03f 000000000000f03f \
+             000000000000f03f",
+        ),
+    ],
+};
+
+/// 92 with its dependency linkage `0x271B` (root at `0x84`).
+pub(super) const LINK: Sparse = Sparse {
+    len: 0x90,
+    runs: &[
+        (0x000, "5c00c020 48000000 3c000000 40"),
+        (0x020, "02000000 01000100 01"),
+        (0x078, "0b10d056 1b270100 000301"),
+    ],
+};
+
+/// The two 93 records, subtypes `0x1000C` and `0x1000D`.
+pub(super) const OPTIONS: [Sparse; 2] = [
+    Sparse {
+        len: 0x68,
+        runs: &[(0x000, "5d00c060 34000000 34000000 40"), (0x030, "0c0001")],
+    },
+    Sparse {
+        len: 0x98,
+        runs: &[
+            (0x000, "5d00c060 4c000000 4c000000 40"),
+            (0x030, "0d000100 00000000 11000000 11"),
+            (
+                0x046,
+                "f03f 000000000000f03f 000000000000f03f 000000000000f03f 000000000000f03f \
+                 000000000000f03f 00000040",
+            ),
+        ],
+    },
+];
+
+/// 90 up to its linkages (the strings and the dependency are appended per attachment).
+pub(super) const REFERENCE: Sparse = Sparse {
+    len: 0x78,
+    runs: &[
+        (0x000, "5a00c020 f8000000 3c000000 40"),
+        (0x020, "05000000 03000500"),
+    ],
+};
+
+/// The 90 dependency linkage `0x271B` (root at 12).
+pub(super) const REFERENCE_DEPENDENCY: Sparse = Sparse {
+    len: 0x18,
+    runs: &[(0x000, "0b10d056 1b270100 000301")],
+};
+
+/// The five 91 records in stored order: placement `0x20007`, display `0x20008`
+/// (foreground `FFFFFF`, background `000000`), `0x10009` and the two `0x1000B` holding
+/// the constants "(RM-All)" and "(RM-Defined)".
+pub(super) const SETTINGS: [Sparse; 5] = [
+    Sparse {
+        len: 0xb8,
+        runs: &[
+            (0x000, "5b00c040 5c000000 5c000000 40"),
+            (0x020, "070002"),
+            (0x073, "20"),
+        ],
+    },
+    Sparse {
+        len: 0x60,
+        runs: &[
+            (0x000, "5b00c040 30000000 30000000 40"),
+            (0x020, "08000200 00000000 00407cff 0000ffff ffffffff"),
+            (0x046, "f03f 000000000000f03f"),
+        ],
+    },
+    Sparse {
+        len: 0x230,
+        runs: &[
+            (0x000, "5b00c040 18010000 18010000 40"),
+            (0x020, "09000100 00000000 02000000 00ff01"),
+        ],
+    },
+    Sparse {
+        len: 0x238,
+        runs: &[
+            (0x000, "5b00c040 1c010000 1c010000 40"),
+            (
+                0x020,
+                "0b000100 00000000 28005200 4d002d00 41006c00 6c002900",
+            ),
+            (0x226, "ff"),
+        ],
+    },
+    Sparse {
+        len: 0x238,
+        runs: &[
+            (0x000, "5b00c040 1c010000 1c010000 40"),
+            (
+                0x020,
+                "0b000100 00000000 28005200 4d002d00 44006500 66006900 6e006500 64002900",
+            ),
+        ],
+    },
+];
+
+/// Data of the XAttribute 170 sub-records; 3 and 4 (file name and URL) are written per
+/// attachment.
+pub(super) const XATTRIBUTE_SUBS: [Sparse; 8] = [
+    Sparse { len: 4, runs: &[] },
+    Sparse {
+        len: 0x42,
+        runs: &[(
+            0x000,
+            "02000000 01000000 01000000 ff 28005200 4d002d00 41006c00 6c002900 0000 \
+             01000000 01000000 00 28005200 4d002d00 44006500 66006900 6e006500 64002900",
+        )],
+    },
+    Sparse {
+        len: 0x28,
+        runs: &[(0x000, "01000000 01")],
+    },
+    Sparse { len: 0, runs: &[] },
+    Sparse { len: 0, runs: &[] },
+    Sparse { len: 2, runs: &[] },
+    Sparse { len: 2, runs: &[] },
+    Sparse { len: 4, runs: &[] },
+];
+
+/// Flags of the XAttribute 170 record header and its trailer.
+pub(super) const XATTRIBUTE_FLAGS: u32 = 8;
+pub(super) const XATTRIBUTE_TRAILER: [u8; 4] = [1, 0, 0, 0];
+/// Flags (`u16` at 10) of every XAttribute 170 sub-record header.
+pub(super) const XATTRIBUTE_SUB_FLAGS: u16 = 0x8000;
+/// Offset of the frame id in the 92 dependency linkage.
+pub(super) const LINK_ROOT: usize = 0x84;

{pycadkit-0.3.2 → pycadkit-0.3.3}/crates/cadkit-dgn/src/writer/raster_template.rs

@@ -1,4 +1,5 @@
-//! New raster attachments cloned from a raster attachment of the seed.
+//! New raster attachments cloned from a raster attachment of the seed, or from the built-in
+//! group of [`super::raster_builtin`] when the seed holds none.
 //!
 //! A MicroStation raster attachment is a fixed group of ten records and one XAttribute
 //! (FORMAT_NOTES, "Raster attachments"): control records 92, 93, 93, 90 and five 91 in
@@ -34,8 +35,6 @@ const PLACEMENT_MIN: usize = 0xb8;
 const CONTROLS: usize = 9;
 
 /// Errors with stable messages.
-pub(super) const NO_TEMPLATE: &str =
-    "new DGN raster attachments need a seed raster attachment to clone";
 const NEEDS_PATH_AND_SIZE: &str = "new DGN raster attachments need path and size_px";
 
 /// One complete raster attachment group of the seed, captured before the seed model is
@@ -107,6 +106,45 @@ impl Template {
         (0..controls.len()).find_map(|i| group(&controls, i, &frames, &xattributes))
     }
 
+    /// The built-in group of [`super::raster_builtin`], for seeds that hold no attachment;
+    /// its XAttribute goes in auxiliary pages of format `aux_version`.
+    pub fn builtin(aux_version: u32) -> Result<Self> {
+        use super::raster_builtin as b;
+        let mut subs = Vec::with_capacity(XA_SUBS);
+        for (index, data) in (0u16..).zip(&b::XATTRIBUTE_SUBS) {
+            let data = data.bytes()?;
+            let mut head = [0u8; 16];
+            put(&mut head, 0, &index.to_le_bytes())?;
+            put(&mut head, 2, &XA_SUB_MAGIC.to_le_bytes())?;
+            let len = u16::try_from(data.len())
+                .map_err(|_| Error::LimitExceeded("DGN raster XAttribute string".into()))?;
+            put(&mut head, 8, &len.to_le_bytes())?;
+            put(&mut head, 10, &b::XATTRIBUTE_SUB_FLAGS.to_le_bytes())?;
+            subs.push((head, data));
+        }
+        let [option_a, option_b] = &b::OPTIONS;
+        Ok(Self {
+            frame: b::FRAME.bytes()?,
+            link: b::LINK.bytes()?,
+            link_root: b::LINK_ROOT,
+            options: [option_a.bytes()?, option_b.bytes()?],
+            reference: b::REFERENCE.bytes()?,
+            reference_dependency: b::REFERENCE_DEPENDENCY.bytes()?,
+            settings: b::SETTINGS
+                .iter()
+                .map(b::Sparse::bytes)
+                .collect::<Result<_>>()?,
+            placement: 0,
+            xattribute: XAttribute {
+                reserved: 0,
+                flags: b::XATTRIBUTE_FLAGS,
+                subs,
+                trailer: b::XATTRIBUTE_TRAILER.to_vec(),
+            },
+            aux_version,
+        })
+    }
+
     /// Records of a new attachment for `e`: ids are `ids[0..10]` in the order 94, 92, 93,
     /// 93, 90, 91 x 5 (as MicroStation allocates them), the frame sits on `level`.
     pub fn instantiate(
@@ -569,3 +607,68 @@ impl Placement {
         Ok(())
     }
 }
+
+#[cfg(test)]
+impl Template {
+    /// Whether `self` and `other` agree outside the fields `instantiate` writes.
+    pub fn same_constants(&self, other: &Self) -> bool {
+        fn masked(b: &[u8], ranges: &[(usize, usize)]) -> Vec<u8> {
+            let mut b = b.to_vec();
+            for &(from, to) in [(0x10, 0x20)].iter().chain(ranges) {
+                b.iter_mut().take(to).skip(from).for_each(|x| *x = 0);
+            }
+            b
+        }
+        let same =
+            |a: &[u8], b: &[u8], ranges: &[(usize, usize)]| masked(a, ranges) == masked(b, ranges);
+        let frame = [(0x0c, 0x10), (0x38, 0x68), (0x78, 0xf8), (0x108, 0x118)];
+        let placement = [(0x28, 0x70), (0x88, 0xb8)];
+        let link = [(0x30, 0x38), (self.link_root, self.link_root + 8)];
+        let xattribute = |x: &XAttribute| {
+            let subs: Vec<_> = x
+                .subs
+                .iter()
+                .enumerate()
+                .map(|(i, (head, data))| {
+                    let head = masked(head, &[(8, 10)]);
+                    (
+                        head,
+                        if matches!(i, 3 | 4) {
+                            vec![]
+                        } else {
+                            data.clone()
+                        },
+                    )
+                })
+                .collect();
+            (x.reserved, x.flags, subs, x.trailer.clone())
+        };
+        same(&self.frame, &other.frame, &frame)
+            && self.link_root == other.link_root
+            && same(&self.link, &other.link, &link)
+            && self
+                .options
+                .iter()
+                .zip(&other.options)
+                .all(|(a, b)| same(a, b, &[]))
+            && same(
+                &self.reference,
+                &other.reference,
+                &[(0x04, 0x08), (0x38, 0x40)],
+            )
+            && same(
+                &self.reference_dependency,
+                &other.reference_dependency,
+                &[(12, 20)],
+            )
+            && self.placement == other.placement
+            && self.settings.len() == other.settings.len()
+            && self
+                .settings
+                .iter()
+                .zip(&other.settings)
+                .enumerate()
+                .all(|(i, (a, b))| same(a, b, if i == self.placement { &placement } else { &[] }))
+            && xattribute(&self.xattribute) == xattribute(&other.xattribute)
+    }
+}