pycadkit 0.2.0__tar.gz → 0.2.1__tar.gz

{pycadkit-0.2.0 → pycadkit-0.2.1}/Cargo.lock

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

{pycadkit-0.2.0 → pycadkit-0.2.1}/Cargo.toml

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

{pycadkit-0.2.0 → pycadkit-0.2.1}/PKG-INFO

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

{pycadkit-0.2.0 → pycadkit-0.2.1}/crates/cadkit-dgn/src/writer/encode.rs

@@ -1,7 +1,7 @@
 //! Belgelenmiş V8 öğe alanlarının sınır denetimli kodlayıcısı.
 
 use crate::native::v8::ModelHeader;
-use cadkit_core::{Entity, Error, Lineweight, Point3, Result, Value, Vec3};
+use cadkit_core::{Entity, Error, Point3, Result, Value, Vec3};
 
 pub(super) fn put(b: &mut [u8], offset: usize, value: &[u8]) -> Result<()> {
     let end = offset
@@ -62,6 +62,7 @@ pub(super) fn prefix(kind: u32, size: usize, id: u64, level: u32, time: f64) ->
     Ok(b)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(super) fn header(
     kind: u32,
     size: usize,
@@ -70,6 +71,7 @@ pub(super) fn header(
     time: f64,
     entity: &Entity,
     three: bool,
+    weight: u32,
 ) -> Result<Vec<u8>> {
     let mut b = prefix(kind | 0x1000_0000, size, id, level, time)?;
     let hole = matches!(entity.props.get("dgn.hole"), Some(Value::Bool(true)));
@@ -99,17 +101,6 @@ pub(super) fn header(
             u32::try_from(*n).map_err(|_| Error::invalid(0, "DGN style"))?,
         )?;
     }
-    let weight = match entity.props.get("dgn.weight") {
-        Some(Value::Int(n)) => u32::try_from(*n).map_err(|_| Error::invalid(0, "DGN weight"))?,
-        _ => match entity.lineweight {
-            Lineweight::Millimeters(_) => {
-                return Err(Error::Unsupported(
-                    "DGN lineweight requires dgn.weight index".into(),
-                ));
-            }
-            _ => 0,
-        },
-    };
     u32_at(&mut b, 0x30, weight)?;
     Ok(b)
 }
@@ -160,6 +151,29 @@ pub(super) fn range(b: &mut [u8], points: &[[f64; 3]]) -> Result<()> {
     Ok(())
 }
 
+/// Absolute bounds for generated records; type-17 stores a relative high span.
+pub(super) fn absolute_range(b: &[u8]) -> Result<[[i64; 3]; 2]> {
+    let text = crate::le::u32_at(b, 0).is_some_and(|kind| kind & 0xffff == 17);
+    let mut low = [0; 3];
+    let mut high = [0; 3];
+    for (axis, (lo, hi)) in low.iter_mut().zip(high.iter_mut()).enumerate() {
+        *lo = crate::le::i64_at(b, 0x38 + axis * 8)
+            .ok_or_else(|| Error::invalid(0, "short DGN record range"))?;
+        let stored_high = crate::le::i64_at(b, 0x50 + axis * 8)
+            .ok_or_else(|| Error::invalid(0, "short DGN record range"))?;
+        *hi = if text {
+            if stored_high < 0 {
+                return Err(Error::invalid(0, "negative DGN text range span"));
+            }
+            lo.checked_add(stored_high)
+                .ok_or_else(|| Error::invalid(0, "DGN text range high overflow"))?
+        } else {
+            stored_high
+        };
+    }
+    Ok([low, high])
+}
+
 pub(super) fn utf16(value: &str) -> Result<Vec<u8>> {
     if value.contains('\0') {
         return Err(Error::invalid(0, "embedded NUL in DGN string"));

{pycadkit-0.2.0 → pycadkit-0.2.1}/crates/cadkit-dgn/src/writer/mod.rs

@@ -203,15 +203,24 @@ 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,
+    )?;
+    tables.observe_model_fonts(
+        model
+            .graphic_pages
+            .iter()
+            .chain(&model.control_pages)
+            .flat_map(|p| &p.elements),
+        &read,
+    );
     let mut state = State {
-        tables: Tables::new(
-            native
-                .named_pages
-                .iter()
-                .flat_map(|p| p.elements.iter().cloned()),
-            max_id,
-            &read,
-        )?,
+        tables,
         model: header,
         options,
         wide_tags: wide_integer_tags(&source.entities),
@@ -315,9 +324,14 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
     let mut low = [i64::MAX; 3];
     let mut high = [i64::MIN; 3];
     for b in &records {
-        for (i, (lo, hi)) in low.iter_mut().zip(high.iter_mut()).enumerate() {
-            *lo = (*lo).min(le::i64_at(b, 0x38 + i * 8).unwrap_or(0));
-            *hi = (*hi).max(le::i64_at(b, 0x50 + i * 8).unwrap_or(0));
+        let [record_low, record_high] = absolute_range(b)?;
+        for ((lo, hi), (record_lo, record_hi)) in low
+            .iter_mut()
+            .zip(high.iter_mut())
+            .zip(record_low.into_iter().zip(record_high))
+        {
+            *lo = (*lo).min(record_lo);
+            *hi = (*hi).max(record_hi);
         }
     }
     if records.is_empty() {
@@ -470,7 +484,8 @@ impl State<'_> {
         entity: &Entity,
         three: bool,
     ) -> Result<Vec<u8>> {
-        let mut b = encode::header(kind, size, id, level, time, entity, three)?;
+        let weight = self.lineweight(entity)?;
+        let mut b = encode::header(kind, size, id, level, time, entity, three, weight)?;
         if !entity.props.contains_key("dgn.color_index") {
             use cadkit_core::Color;
             let color = if entity.color == Color::ByLayer {
@@ -513,6 +528,52 @@ impl State<'_> {
         Ok(b)
     }
 
+    fn lineweight(&self, entity: &Entity) -> Result<u32> {
+        fn native(props: &cadkit_core::Props) -> Result<Option<u32>> {
+            match props.get("dgn.weight") {
+                Some(Value::Int(n)) => {
+                    let weight = u32::try_from(*n)
+                        .map_err(|_| Error::invalid(0, "DGN weight must be a nonnegative index"))?;
+                    if weight > 31 {
+                        return Err(Error::Unsupported("DGN lineweight indexes above 31".into()));
+                    }
+                    Ok(Some(weight))
+                }
+                Some(_) => Err(Error::invalid(0, "DGN weight must be an integer index")),
+                None => Ok(None),
+            }
+        }
+        if let Some(weight) = native(&entity.props)? {
+            return Ok(weight);
+        }
+        let weight = if entity.lineweight == cadkit_core::Lineweight::ByLayer {
+            match self
+                .layers
+                .iter()
+                .find(|layer| Some(layer.name.as_str()) == entity.layer.as_deref())
+            {
+                Some(layer) => {
+                    if let Some(weight) = native(&layer.props)? {
+                        return Ok(weight);
+                    }
+                    layer.lineweight
+                }
+                None => cadkit_core::Lineweight::Default,
+            }
+        } else {
+            entity.lineweight
+        };
+        match weight {
+            cadkit_core::Lineweight::Millimeters(_) => Err(Error::Unsupported(
+                "DGN lineweight needs an explicit entity/layer dgn.weight index; millimeter mapping is display-dependent".into(),
+            )),
+            cadkit_core::Lineweight::ByBlock => Err(Error::Unsupported(
+                "resolve ByBlock lineweight before DGN export".into(),
+            )),
+            cadkit_core::Lineweight::Default | cadkit_core::Lineweight::ByLayer => Ok(0),
+        }
+    }
+
     fn add(&mut self, b: Vec<u8>, tag: bool) -> Result<()> {
         self.bytes = self.bytes.saturating_add(b.len() as u64);
         if self.bytes > self.options.limits.max_decompressed_bytes
@@ -820,17 +881,7 @@ impl State<'_> {
                 {
                     return Err(Error::invalid(0, "invalid text dimensions or normal"));
                 }
-                let font = match e.props.get("dgn.font_number") {
-                    Some(Value::Int(n)) => {
-                        u32::try_from(*n).map_err(|_| Error::invalid(0, "invalid DGN font"))?
-                    }
-                    _ => match style {
-                        Some(name) => *self.tables.fonts.get(name).ok_or_else(|| {
-                            Error::Unsupported("text font is absent from seed".into())
-                        })?,
-                        None => self.tables.fonts.values().next().copied().unwrap_or(0),
-                    },
-                };
+                let font = self.tables.font(e, style.as_deref())?;
                 let (justification, fx, fy) = text::justification(e, *halign, *valign)?;
                 let length = text::length(e, value, *height * *width_factor, fx)?;
                 let (x, y, n) = cadkit_core::geom_ops::arbitrary_axes(*normal);
@@ -879,7 +930,14 @@ impl State<'_> {
                 rotation(&mut b, 0x90, a, c, n, three)?;
                 point(&mut b, if three { 0xb0 } else { 0x98 }, origin, three)?;
                 put(&mut b, offset, &value)?;
-                range(&mut b, &[origin])?;
+                text::range(
+                    &mut b,
+                    origin,
+                    a,
+                    c,
+                    length * self.model.uor_per_master,
+                    height * self.model.uor_per_master,
+                )?;
                 links.extend(self.codepage_link()?);
                 b
             }
@@ -1074,17 +1132,8 @@ impl State<'_> {
         }
         let mut corners = vec![];
         for child in self.records.get(first..).unwrap_or(&[]) {
-            let p = [
-                le::i64_at(child, 0x38).unwrap_or(0) as f64,
-                le::i64_at(child, 0x40).unwrap_or(0) as f64,
-                le::i64_at(child, 0x48).unwrap_or(0) as f64,
-            ];
-            let q = [
-                le::i64_at(child, 0x50).unwrap_or(0) as f64,
-                le::i64_at(child, 0x58).unwrap_or(0) as f64,
-                le::i64_at(child, 0x60).unwrap_or(0) as f64,
-            ];
-            corners.extend([p, q]);
+            let [low, high] = absolute_range(child)?;
+            corners.extend([low.map(|v| v as f64), high.map(|v| v as f64)]);
         }
         if let Some(parent) = self.records.get_mut(index) {
             range(parent, &corners)?;

{pycadkit-0.2.0 → pycadkit-0.2.1}/crates/cadkit-dgn/src/writer/tables.rs

@@ -6,8 +6,8 @@ use crate::native::{
     element::{ElementData, TagDef, TagSetData, TagValue},
     v8::RawElement,
 };
-use cadkit_core::{Attribute, Error, Result, Value};
-use std::collections::{BTreeMap, HashSet};
+use cadkit_core::{Attribute, Entity, Error, Result, Value};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 
 pub(super) struct Tables {
     pub records: Vec<Vec<u8>>,
@@ -16,6 +16,7 @@ pub(super) struct Tables {
     pub levels: BTreeMap<String, u32>,
     pub sets: BTreeMap<Option<String>, (u64, TagSetData)>,
     pub last_id: u64,
+    referenced_fonts: BTreeSet<u32>,
     max_level: u32,
     level_template: Option<Vec<u8>>,
     tag_set_template: Option<Vec<u8>>,
@@ -34,6 +35,7 @@ impl Tables {
             levels: BTreeMap::new(),
             sets: BTreeMap::new(),
             last_id,
+            referenced_fonts: BTreeSet::new(),
             max_level: 0,
             level_template: None,
             tag_set_template: None,
@@ -79,6 +81,28 @@ impl Tables {
         }
         Ok(out)
     }
+    pub fn observe_model_fonts<'a>(
+        &mut self,
+        records: impl Iterator<Item = &'a RawElement>,
+        read: &cadkit_core::ReadOptions,
+    ) {
+        for raw in records {
+            let font = match decode_v8::decode(
+                raw,
+                crate::text::encoding_for(read.fallback_codepage.as_deref()),
+                &read.limits,
+            )
+            .data
+            {
+                ElementData::Text(text) => Some(text.font),
+                ElementData::TextNode(text) => Some(text.font),
+                _ => None,
+            };
+            if let Some(font) = font {
+                self.referenced_fonts.insert(font);
+            }
+        }
+    }
     pub fn id(&mut self) -> Result<u64> {
         self.last_id = self
             .last_id
@@ -113,6 +137,53 @@ impl Tables {
         self.levels.insert(name.into(), level);
         Ok(level)
     }
+
+    pub fn font(&self, entity: &Entity, style: Option<&str>) -> Result<u32> {
+        let explicit = match entity.props.get("dgn.font_number") {
+            Some(Value::Int(n)) => {
+                Some(u32::try_from(*n).map_err(|_| Error::invalid(0, "invalid DGN font number"))?)
+            }
+            Some(_) => return Err(Error::invalid(0, "DGN font number must be an integer")),
+            None => None,
+        };
+        let known = |number| {
+            number == 0
+                || self.fonts.values().any(|n| *n == number)
+                || self.referenced_fonts.contains(&number)
+        };
+        let named = match style {
+            Some(name) => Some(
+                self.fonts
+                    .get(name)
+                    .copied()
+                    .or_else(|| {
+                        name.strip_prefix("DGN_FONT_")?
+                            .parse()
+                            .ok()
+                            .filter(|n| known(*n))
+                    })
+                    .ok_or_else(|| {
+                        Error::Unsupported("text font style is absent from seed".into())
+                    })?,
+            ),
+            None => None,
+        };
+        if let Some(number) = explicit {
+            // Font zero is the existing implicit fallback. A seed can also reference
+            // an external RSC font in its graphics without a named table definition.
+            // Do not accept unreferenced foreign indexes merely because they are small.
+            if !known(number) {
+                return Err(Error::Unsupported(
+                    "text font number is absent from seed".into(),
+                ));
+            }
+            if named.is_some_and(|n| n != number) {
+                return Err(Error::invalid(0, "DGN font number and style name disagree"));
+            }
+            return Ok(number);
+        }
+        Ok(named.unwrap_or_else(|| self.fonts.values().next().copied().unwrap_or(0)))
+    }
     pub fn tag(&mut self, attribute: &Attribute) -> Result<(u64, u16, u16)> {
         let name = &attribute.set;
         let value_type = match attribute.value {

{pycadkit-0.2.0 → pycadkit-0.2.1}/crates/cadkit-dgn/src/writer/tests/application.rs

@@ -106,3 +106,46 @@ fn new_then_edited_geometry_unicode_labels_and_identifier_types() {
         assert!((position.y - 4.).abs() < 1e-8);
     }
 }
+
+#[test]
+fn bylayer_lineweight_resolves_explicit_native_layer_index() {
+    let mut entity = line();
+    entity.layer = Some("Synthetic layer".into());
+    let mut source = document(false, vec![entity]);
+    let mut layer = cadkit_core::Layer {
+        name: "Synthetic layer".into(),
+        lineweight: cadkit_core::Lineweight::Millimeters(0.25),
+        ..Default::default()
+    };
+    layer.props.insert("dgn.weight".into(), Value::Int(3));
+    source.layers.push(layer);
+    let blank = seed(false);
+    let weight = |source: &Document| {
+        let bytes = write_v8(source, &blank, &WriteOptions::default()).unwrap();
+        let parsed = crate::read(&bytes, &ReadOptions::default()).unwrap();
+        parsed.models[0].entities[0].props["dgn.weight"].clone()
+    };
+    assert_eq!(weight(&source), Value::Int(3));
+    source.models[0].entities[0]
+        .props
+        .insert("dgn.weight".into(), Value::Int(7));
+    assert_eq!(weight(&source), Value::Int(7));
+    source.models[0].entities[0].props.remove("dgn.weight");
+    source.models[0].entities[0].lineweight = cadkit_core::Lineweight::Default;
+    assert_eq!(weight(&source), Value::Int(0));
+    source.models[0].entities[0].lineweight = cadkit_core::Lineweight::ByBlock;
+    assert!(write_v8(&source, &blank, &WriteOptions::default()).is_err());
+    source.models[0].entities[0].lineweight = cadkit_core::Lineweight::ByLayer;
+    source.layers[0].props.remove("dgn.weight");
+    assert!(write_v8(&source, &blank, &WriteOptions::default()).is_err());
+    for invalid in [
+        Value::Int(-1),
+        Value::Int(32),
+        Value::Int(i64::from(u32::MAX)),
+        Value::Float(3.),
+        Value::Text("3".into()),
+    ] {
+        source.layers[0].props.insert("dgn.weight".into(), invalid);
+        assert!(write_v8(&source, &blank, &WriteOptions::default()).is_err());
+    }
+}

{pycadkit-0.2.0 → pycadkit-0.2.1}/crates/cadkit-dgn/src/writer/tests/raster.rs

@@ -3,7 +3,7 @@
 use super::*;
 
 fn raster_seed() -> Vec<u8> {
-    let mut frame = header(94, 0x400, 100, 0, 0., &line(), false).unwrap();
+    let mut frame = header(94, 0x400, 100, 0, 0., &line(), false, 0).unwrap();
     let matrix = [
         1., 0., 0., 1000., 0., 1., 0., 2000., 0., 0., 1., 0., 0., 0., 0., 1.,
     ];