pycadkit 0.3.3__tar.gz → 0.3.5__tar.gz

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

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

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

@@ -4,7 +4,7 @@ members = ["crates/*"]
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.3.3"
+version = "0.3.5"
 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.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" }
+cadkit-core = { path = "crates/cadkit-core", version = "0.3.5" }
+cadkit-dgn = { path = "crates/cadkit-dgn", version = "0.3.5" }
+cadkit-dwg = { path = "crates/cadkit-dwg", version = "0.3.5" }
+cadkit-dxf = { path = "crates/cadkit-dxf", version = "0.3.5" }
+cadkit-gml = { path = "crates/cadkit-gml", version = "0.3.5" }
+cadkit = { path = "crates/cadkit", version = "0.3.5" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = "2"

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

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

{pycadkit-0.3.3 → pycadkit-0.3.5}/crates/cadkit-dgn/src/native/decode_v8.rs

@@ -136,9 +136,10 @@ pub fn decode(raw: &RawElement, enc: &'static Encoding, limits: &Limits) -> Elem
         35 => d.cell().map(ElementData::SharedCellInstance),
         37 => d.tag(&linkages).map(ElementData::Tag),
         39 => d.tag_set(&linkages).map(ElementData::TagSet),
+        // An attachment written with a relative path stores an empty full path.
         90 => Ok(ElementData::RasterReference {
-            file_name: linkage::string(&linkages, 3),
-            full_path: linkage::string(&linkages, 0x1f),
+            file_name: linkage::string(&linkages, 3).filter(|s| !s.is_empty()),
+            full_path: linkage::string(&linkages, 0x1f).filter(|s| !s.is_empty()),
         }),
         94 => le::f64s::<16>(d.b, 0x78)
             .map(|matrix| ElementData::RasterFrame {

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

@@ -2,6 +2,7 @@
 
 mod container;
 mod encode;
+mod named;
 mod polyline;
 mod raster;
 mod raster_builtin;
@@ -237,14 +238,7 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
     }
     let max_id = max_id.max(le::u64_at(&seed_header.data, 0x128).unwrap_or(0));
     let rasters = raster::Preserved::prepare(doc, seed, model, &read, options)?;
-    let mut tables = Tables::new(
-        native
-            .named_pages
-            .iter()
-            .flat_map(|p| p.elements.iter().cloned()),
-        max_id,
-        &read,
-    )?;
+    let mut tables = Tables::new(&native.named_pages, max_id, &read)?;
     tables.observe_model_fonts(
         model
             .graphic_pages
@@ -283,7 +277,7 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
     let named = state.tables.finish(options.timestamp_ms)?;
     let max_id = records
         .iter()
-        .chain(named.iter())
+        .chain(named.iter().map(|r| &r.bytes))
         .filter_map(|r| le::u64_at(r, 16))
         .max()
         .unwrap_or(max_id)
@@ -304,7 +298,7 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
         .collect();
     let mut replacements = BTreeMap::new();
     for stream in &native.streams {
-        if stream
+        let model_stream = stream
             .path
             .starts_with(&format!("Dgn-Md/{}/Dgn^G/", model.storage))
             || stream
@@ -315,9 +309,8 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
                 .starts_with(&format!("Dgn-Md/{}/Dgn^GA/", model.storage))
             || stream
                 .path
-                .starts_with(&format!("Dgn-Md/{}/Dgn^CA/", model.storage))
-            || stream.path.starts_with("Dgn^Nm/")
-        {
+                .starts_with(&format!("Dgn-Md/{}/Dgn^CA/", model.storage));
+        if model_stream || stream.path.starts_with("Dgn^Nm/") {
             // A page the reader could not decode was neither checked for content nor
             // carried into the named tables; dropping it would lose seed data silently.
             let page = stream.path.rsplit('/').next().is_some_and(|n| {
@@ -330,7 +323,10 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
                     format!("seed page {} could not be decoded", stream.path),
                 ));
             }
-            replacements.insert(stream.path.clone(), None);
+            // Dictionary pages are kept and only rewritten where they change (`named`).
+            if model_stream {
+                replacements.insert(stream.path.clone(), None);
+            }
         }
     }
     let version = graphic_page_version(model);
@@ -382,15 +378,11 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
         // Every control auxiliary page is retained as is; so is its page counter.
         replacements.remove(&format!("Dgn-Md/{}/Dgn^CA/^AH", model.storage));
     }
-    put_pages(
+    named::write(
         &mut replacements,
-        "Dgn^Nm",
+        &native.named_pages,
+        &native.named_aux,
         &named,
-        native
-            .named_pages
-            .first()
-            .map(|p| p.header.format_version)
-            .unwrap_or(3),
         options.limits.max_decompressed_bytes,
     )?;
     let mut mh = header.raw.clone();
@@ -456,8 +448,8 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
 #[cfg(test)]
 mod tests;
 
-/// Writes `records` to pages `{prefix}/$1`, `$2`, ... of at most 256 KiB and returns the
-/// page number of every record.
+/// Writes graphic `records` to pages `{prefix}/$1`, `$2`, ... of at most 256 KiB and returns
+/// the page number of every record. Dictionary pages keep the seed's layout instead (`named`).
 fn put_pages(
     replacements: &mut BTreeMap<String, Option<Vec<u8>>>,
     prefix: &str,

pycadkit-0.3.5/crates/cadkit-dgn/src/writer/named.rs

@@ -0,0 +1,203 @@
+//! Dictionary pages of the output: `Dgn^Nm/$n` (tables, tag sets, cell definitions) and
+//! their XAttribute pages `Dgn^NmA/$n`.
+//!
+//! The seed's page layout is kept: every seed page keeps its number, its records stay in
+//! order, and a page whose records did not change keeps its stream byte for byte (empty
+//! pages included). A changed page is rewritten in place; new tables and tag sets share one
+//! new page after the seed's last page. MicroStation keeps a complex element (a table with
+//! its entries, a cell definition with its components) on one page and does not join one
+//! across a page boundary: a level table split over two pages is not loaded as one table.
+//! Its pages hold as many records as that takes (595,424 inflated bytes observed), so only
+//! the caller's decompression limit bounds a page; nothing is split at a fixed size
+//! (`docs/dgn/FORMAT_NOTES.md`, "Dictionary pages").
+
+use super::{compressed, encode::u32_at, raster, tables::NamedRecord};
+use crate::native::v8::{AuxPage, AuxRecord, Page, PageHeader, RawElement};
+use cadkit_core::{Error, Result};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+
+/// Puts the dictionary pages that differ from the seed's, and the XAttribute pages whose
+/// records moved with their elements, into `replacements`. `records` are in stored order
+/// (as [`super::tables::Tables::finish`] returns them). The inflated records together must
+/// not exceed `max` bytes.
+pub(super) fn write(
+    replacements: &mut BTreeMap<String, Option<Vec<u8>>>,
+    seed_pages: &[Page],
+    seed_aux: &[AuxPage],
+    records: &[NamedRecord],
+    max: u64,
+) -> Result<()> {
+    let total = records
+        .iter()
+        .try_fold(0u64, |sum, r| sum.checked_add(r.bytes.len() as u64 + 4))
+        .ok_or_else(|| Error::LimitExceeded("DGN dictionary records".into()))?;
+    if total > max {
+        return Err(Error::LimitExceeded("DGN dictionary records".into()));
+    }
+    let new_page = seed_pages
+        .iter()
+        .map(|p| p.number)
+        .max()
+        .unwrap_or(0)
+        .checked_add(1)
+        .ok_or_else(|| Error::LimitExceeded("DGN page count".into()))?;
+    let mut pages: BTreeMap<u32, Vec<&NamedRecord>> = BTreeMap::new();
+    for r in records {
+        pages.entry(r.page.unwrap_or(new_page)).or_default().push(r);
+    }
+    for page in seed_pages {
+        let kept = pages.get(&page.number).map(Vec::as_slice).unwrap_or(&[]);
+        let same = kept.len() == page.elements.len()
+            && kept
+                .iter()
+                .zip(&page.elements)
+                .all(|(r, e)| r.prefix == e.prefix && r.bytes == e.bytes);
+        if !same {
+            replacements.insert(
+                page.path.clone(),
+                Some(encode(kept, page.header.format_version)?),
+            );
+        }
+    }
+    // As before 0.3.5, new pages take the version of the seed's first page.
+    let version = seed_pages
+        .first()
+        .map(|p| p.header.format_version)
+        .unwrap_or(3);
+    if let Some(added) = pages.get(&new_page) {
+        replacements.insert(
+            format!(
+                "{}/${new_page}",
+                storage(seed_pages.first().map(|p| &p.path), "Dgn^Nm")
+            ),
+            Some(encode(added, version)?),
+        );
+    }
+    move_xattributes(replacements, seed_pages, seed_aux, &pages)
+}
+
+/// The storage of a seed page `path` (`Dgn^Nm` of `Dgn^Nm/$1`), or `default`.
+fn storage<'a>(path: Option<&'a String>, default: &'a str) -> &'a str {
+    path.and_then(|p| p.rsplit_once('/'))
+        .map(|(storage, _)| storage)
+        .unwrap_or(default)
+}
+
+/// A dictionary page: `{record count, format version, 0, 0}`, then the zlib-compressed
+/// records, each after its 4-byte prefix. An empty page is the header alone. The page
+/// number and population are 0 as on every dictionary page MicroStation wrote (private
+/// corpus: 3,932 of 3,932 pages); cadkit before 0.3.5 wrote the page number and the
+/// record count there.
+fn encode(records: &[&NamedRecord], version: u32) -> Result<Vec<u8>> {
+    let mut out = vec![0; 16];
+    u32_at(
+        &mut out,
+        0,
+        u32::try_from(records.len())
+            .map_err(|_| Error::LimitExceeded("DGN page records".into()))?,
+    )?;
+    u32_at(&mut out, 4, version)?;
+    if !records.is_empty() {
+        let mut data = vec![];
+        for r in records {
+            data.extend(r.prefix.to_le_bytes());
+            data.extend_from_slice(&r.bytes);
+        }
+        out.extend(compressed(&data)?);
+    }
+    Ok(out)
+}
+
+/// Keeps every XAttribute on the auxiliary page numbered like the page of its element, as
+/// on every observed file (private corpus: 4,215 of 4,215 `Dgn^NmA` records): records of
+/// moved elements move with them, records of dropped seed elements are dropped, and records
+/// of ids that are not dictionary elements stay where they are. Only pages that change are
+/// rewritten; `Dgn^NmA/^AH` is kept (it never exceeds the highest dictionary page number
+/// in the corpus, and no page is removed).
+fn move_xattributes(
+    replacements: &mut BTreeMap<String, Option<Vec<u8>>>,
+    seed_pages: &[Page],
+    seed_aux: &[AuxPage],
+    pages: &BTreeMap<u32, Vec<&NamedRecord>>,
+) -> Result<()> {
+    if seed_aux.is_empty() {
+        return Ok(());
+    }
+    let mut location: HashMap<u64, u32> = HashMap::new();
+    for (number, records) in pages {
+        for r in records {
+            if let Some(id) = crate::le::u64_at(&r.bytes, 16) {
+                location.entry(id).or_insert(*number);
+            }
+        }
+    }
+    let seed_ids: HashSet<u64> = seed_pages
+        .iter()
+        .flat_map(|p| &p.elements)
+        .filter_map(RawElement::id)
+        .collect();
+    let mut placed: BTreeMap<u32, Vec<AuxRecord>> = BTreeMap::new();
+    let mut changed = BTreeSet::new();
+    for page in seed_aux {
+        placed.entry(page.number).or_default();
+        for record in &page.records {
+            let target = match location.get(&record.element_id) {
+                Some(number) => *number,
+                None if seed_ids.contains(&record.element_id) => {
+                    changed.insert(page.number);
+                    continue;
+                }
+                None => page.number,
+            };
+            if target != page.number {
+                changed.insert(page.number);
+                changed.insert(target);
+            }
+            placed.entry(target).or_default().push(record.clone());
+        }
+    }
+    for number in changed {
+        let seed = seed_aux.iter().find(|p| p.number == number);
+        if let Some(page) = seed.filter(|p| !p.complete) {
+            // Its undecoded tail would be lost.
+            return Err(Error::invalid(
+                0,
+                format!("seed page {} could not be decoded", page.path),
+            ));
+        }
+        let path = match seed {
+            Some(page) => page.path.clone(),
+            None => format!(
+                "{}/${number}",
+                storage(seed_aux.first().map(|p| &p.path), "Dgn^NmA")
+            ),
+        };
+        // A new page takes the version of the seed's first one.
+        let version = seed
+            .or(seed_aux.first())
+            .map(|p| p.header.format_version)
+            .unwrap_or(2);
+        let records = placed.get(&number).map(Vec::as_slice).unwrap_or(&[]);
+        replacements.insert(path, Some(aux_page(records, version)?));
+    }
+    Ok(())
+}
+
+/// An XAttribute page with page number and population 0 (private corpus: 1,188 of 1,188
+/// `Dgn^NmA` pages); an empty page is the header alone.
+fn aux_page(records: &[AuxRecord], version: u32) -> Result<Vec<u8>> {
+    let header = PageHeader {
+        record_count: 0,
+        format_version: version,
+        page_number: 0,
+        population: 0,
+    };
+    if records.is_empty() {
+        let mut out = vec![0; 16];
+        u32_at(&mut out, 4, version)?;
+        return Ok(out);
+    }
+    let mut page = raster::aux_page(records, header)?;
+    u32_at(&mut page, 12, 0)?;
+    Ok(page)
+}

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

@@ -168,7 +168,7 @@ impl Template {
         let (Some(path), Some(size)) = (path, size_px) else {
             return Err(Error::Unsupported(NEEDS_PATH_AND_SIZE.into()));
         };
-        let url = file_url(path)?;
+        let url = full_path(path)?;
         let name = file_name(e, path)?;
         let p = Placement::new(*position, *u_vector, *v_vector, *size, model)?;
         let dpi = self.dpi(e)?;
@@ -388,9 +388,11 @@ impl XAttribute {
             off = start.checked_add(len)?;
         }
         let trailer = payload.get(off..)?.to_vec();
-        // Sub-records 3 and 4 must hold exactly one string, which is what gets replaced.
+        // Sub-records 3 and 4 must hold exactly one string, which is what gets replaced; the
+        // full path in 4 is empty in attachments written with a relative path.
         let single = |i: usize| subs.get(i).and_then(|(_, d)| utf16z_text(d));
-        if trailer.len() > 16 || single(3).is_none() || single(4).is_none() {
+        let empty = subs.get(4).is_some_and(|(_, d)| d.as_slice() == [0, 0]);
+        if trailer.len() > 16 || single(3).is_none() || (single(4).is_none() && !empty) {
             return None;
         }
         Some(Self {
@@ -466,10 +468,14 @@ fn identity(b: &mut [u8], id: u64, time: f64) -> Result<()> {
     f64_at(b, 0x18, time)
 }
 
-/// The stored URL: the path as given when it is already a `file://` URL, else `file://`
-/// followed by the path. The path must be absolute (a drive, UNC or rooted path): the
-/// attachments carry no relative paths.
-fn file_url(path: &str) -> Result<String> {
+/// The stored full path (string linkage `0x1F`, XAttribute sub-record 4).
+///
+/// An absolute path (a drive, UNC or rooted path) is stored as a `file://` URL, as every
+/// observed attachment stores it; a path that already is one is kept. A relative path
+/// names a file beside the DGN, so the attachment carries no machine-specific location:
+/// a bare file name stores an empty full path, `.\name` (or `./name`) is stored as given.
+/// Relative paths into other folders are refused.
+fn full_path(path: &str) -> Result<String> {
     let has_scheme = path
         .get(..7)
         .is_some_and(|s| s.eq_ignore_ascii_case("file://"));
@@ -478,17 +484,35 @@ fn file_url(path: &str) -> Result<String> {
     } else {
         path
     };
+    if local.contains('\0') {
+        return Err(Error::invalid(0, "DGN raster path contains NUL"));
+    }
     let bytes = local.as_bytes();
     let drive = matches!(bytes, [d, b':', b'\\' | b'/', ..] if d.is_ascii_alphabetic());
-    if local.contains('\0') || !(drive || local.starts_with('\\') || local.starts_with('/')) {
+    if drive || local.starts_with('\\') || local.starts_with('/') {
+        return Ok(if has_scheme {
+            path.to_owned()
+        } else {
+            format!("file://{path}")
+        });
+    }
+    let name = local
+        .strip_prefix(".\\")
+        .or_else(|| local.strip_prefix("./"))
+        .unwrap_or(local);
+    if has_scheme
+        || name.is_empty()
+        || name.contains(['\\', '/', ':'])
+        || matches!(name, "." | "..")
+    {
         return Err(Error::Unsupported(
-            "DGN raster path must be absolute".into(),
+            "DGN raster path must be absolute or name a file beside the DGN".into(),
         ));
     }
-    Ok(if has_scheme {
-        path.to_owned()
+    Ok(if name.len() == local.len() {
+        String::new()
     } else {
-        format!("file://{path}")
+        local.to_owned()
     })
 }