pycadkit 0.2.1__tar.gz → 0.3.1__tar.gz

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

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

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

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

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

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

{pycadkit-0.2.1 → pycadkit-0.3.1}/crates/cadkit/examples/interchange.rs

@@ -75,6 +75,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             set: Some("Örnek".into()),
             position: None,
             invisible: true,
+            ..Default::default()
         });
         if let EntityKind::Polygon {
             exterior,

{pycadkit-0.2.1 → pycadkit-0.3.1}/crates/cadkit-core/src/model.rs

@@ -722,7 +722,7 @@ pub enum Lineweight {
 }
 
 /// Non-graphic data attached to an entity (DWG ATTRIB, DGN tag, item-type property).
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
 pub struct Attribute {
     /// Tag / property name.
     pub tag: String,
@@ -734,13 +734,41 @@ pub struct Attribute {
     pub position: Option<Point3>,
     /// The attribute is not displayed.
     pub invisible: bool,
+    /// Layer of the attribute's own record when the format stores one (a DGN tag
+    /// element has its own level). `None` uses the owning entity's layer.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub layer: Option<String>,
+    /// How the value text is drawn at `position`; `None` when unknown or not drawn.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub display: Option<AttributeDisplay>,
+    /// Format-specific data with no neutral field (e.g. `dgn.color_index`, `dgn.weight`).
+    #[serde(default, skip_serializing_if = "Props::is_empty")]
+    pub props: Props,
+}
+
+/// Text presentation of a displayed attribute value.
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct AttributeDisplay {
+    /// Text height, in drawing units.
+    pub height: f64,
+    /// Character width, in drawing units (DGN stores it separately from the height).
+    pub width: f64,
+    /// Text style (DGN font) name; `None` leaves the choice to the writer's default.
+    pub style: Option<String>,
+    /// Horizontal alignment of the text about `Attribute::position`.
+    pub halign: HAlign,
+    /// Vertical alignment of the text about `Attribute::position`.
+    pub valign: VAlign,
+    /// Rotation about the drawing Z axis, in radians.
+    pub rotation: f64,
 }
 
 /// A loosely typed value for attributes and props.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum Value {
     /// No value.
+    #[default]
     Null,
     /// Boolean.
     Bool(bool),

{pycadkit-0.2.1 → pycadkit-0.3.1}/crates/cadkit-dgn/src/lib.rs

@@ -10,7 +10,7 @@
 pub mod cfb;
 pub mod native;
 pub mod writer;
-pub use writer::{WriteOptions, repack_v8, write_v8};
+pub use writer::{WriteOptions, repack_v8, seed_has_raster_template, write_v8};
 pub mod palette;
 
 mod budget;

{pycadkit-0.2.1 → pycadkit-0.3.1}/crates/cadkit-dgn/src/map/mod.rs

@@ -8,8 +8,8 @@ use std::f64::consts::{FRAC_PI_2, TAU};
 
 use cadkit_core::geom_ops::{arbitrary_axes, clamped_uniform_knots};
 use cadkit_core::{
-    Attribute, Color, Entity, EntityKind, GroupKind, HAlign, LengthUnit, Linetype, Lineweight,
-    Point3, Props, Raw, TextStyle, VAlign, Value, Vec3, Vertex, Warning,
+    Attribute, AttributeDisplay, Color, Entity, EntityKind, GroupKind, HAlign, LengthUnit,
+    Linetype, Lineweight, Point3, Props, Raw, TextStyle, VAlign, Value, Vec3, Vertex, Warning,
 };
 
 use crate::native::element::{
@@ -203,8 +203,6 @@ pub(crate) struct Mapper {
     pub(crate) xattributes: HashMap<u64, Vec<u32>>,
     /// Raster frame id -> image path.
     pub(crate) raster_paths: HashMap<u64, (Option<String>, Option<String>)>,
-    /// Raster frames whose stored extent corner and file are shared with another frame.
-    pub(crate) shared_raster_extent: HashSet<u64>,
     /// Aggregated warnings: code -> (count, first message).
     counts: BTreeMap<String, (u64, String)>,
     pub(crate) warnings: Vec<Warning>,
@@ -226,7 +224,6 @@ impl Mapper {
             attached: HashSet::new(),
             xattributes: HashMap::new(),
             raster_paths: HashMap::new(),
-            shared_raster_extent: HashSet::new(),
             counts: BTreeMap::new(),
             warnings: Vec::new(),
         }
@@ -402,6 +399,14 @@ impl Mapper {
                 );
             }
             p.insert("dgn.properties".into(), Value::Int(i64::from(h.properties)));
+            // Undocumented type-word flags MicroStation sets on its graphics (`0x00C0`);
+            // kept so a rewrite reproduces them.
+            if h.type_flags & 0x00c0 != 0 {
+                p.insert(
+                    "dgn.type_flags".into(),
+                    Value::Int(i64::from(h.type_flags & 0x00c0)),
+                );
+            }
             if h.properties & 0x8000 != 0 && matches!(h.type_code, 6 | 14) {
                 p.insert("dgn.hole".into(), Value::Bool(true));
             }
@@ -441,7 +446,10 @@ impl Mapper {
         }
         if let Some(id) = h.id {
             if let Some(attrs) = self.pending_tags.remove(&id) {
-                e.attributes = attrs.into_iter().map(|(_, a)| a).collect();
+                e.attributes = attrs
+                    .into_iter()
+                    .map(|(_, a)| relative_to_owner(a, &e))
+                    .collect();
             }
         }
         e
@@ -561,7 +569,8 @@ impl Mapper {
                         type_name: "dgn.type_37".into(),
                     },
                 );
-                e.attributes.push(self.attribute(t, &item.el.header, xf));
+                let a = self.attribute(t, &item.el.header, xf);
+                e.attributes.push(relative_to_owner(a, &e));
                 return Some(e);
             }
             ElementData::RasterFrame { .. } => self.image(item, xf),
@@ -662,7 +671,7 @@ impl Mapper {
                 e.props.insert("dgn.point_string".into(), Value::Bool(true));
             }
             ElementData::RasterFrame { matrix, .. } => {
-                // Pixel-to-UOR matrix as stored; the image rectangle comes from the range.
+                // Pixel-to-UOR matrix as stored; the range only checks the placement.
                 if let Some([lo, hi]) = item.el.header.range {
                     let (a, b) = (xf.pt(lo), xf.pt(hi));
                     e.props.insert(
@@ -670,19 +679,23 @@ impl Mapper {
                         Value::List([a.x, a.y, a.z, b.x, b.y, b.z].map(Value::Float).to_vec()),
                     );
                 }
-                if item
-                    .el
-                    .header
-                    .id
-                    .is_some_and(|id| self.shared_raster_extent.contains(&id))
-                {
-                    e.props
-                        .insert("dgn.raster_extent_shared".into(), Value::Bool(true));
-                }
                 e.props.insert(
                     "dgn.raster_matrix".into(),
                     Value::List(matrix.iter().map(|v| Value::Float(*v)).collect()),
                 );
+                // `0x118` / `0x120`: horizontal and vertical resolution in dots per inch.
+                let dpi = crate::le::f64_at(item.raw, 0x118);
+                if let Some(x) = dpi {
+                    e.props.insert("dgn.raster_dpi".into(), Value::Float(x));
+                }
+                if let Some(y) = crate::le::f64_at(item.raw, 0x120).filter(|y| Some(*y) != dpi) {
+                    e.props.insert("dgn.raster_dpi_y".into(), Value::Float(y));
+                }
+                if let Some((rotation, skew)) = frame_angles(matrix) {
+                    e.props
+                        .insert("dgn.raster_rotation".into(), Value::Float(rotation));
+                    e.props.insert("dgn.raster_skew".into(), Value::Float(skew));
+                }
                 let id = item.el.header.id.unwrap_or(0);
                 if let Some((name, full)) = self.raster_paths.get(&id) {
                     if let Some(n) = name {
@@ -873,34 +886,33 @@ impl Mapper {
     fn image(&mut self, item: &Item<'_>, xf: &Xf) -> EntityKind {
         let id = item.el.header.id.unwrap_or(0);
         let range = item.el.header.range;
-        let (matrix_placement, axes) = match &item.el.data {
-            ElementData::RasterFrame { matrix, corner } => {
-                let [m00, m01, _, _, m10, m11, _, _, m20, m21, ..] = *matrix;
-                (
-                    frame_placement(matrix, *corner),
-                    Some((Vec3::new(m00, m10, m20), Vec3::new(m01, m11, m21))),
-                )
-            }
-            _ => (None, None),
+        let (matrix_placement, pixels, axes) = match &item.el.data {
+            ElementData::RasterFrame { matrix, corner } => (
+                frame_placement(matrix, *corner),
+                frame_pixels(matrix, *corner),
+                Some(frame_axes(matrix)),
+            ),
+            _ => (None, None, None),
         };
-        // The element range is MicroStation's own bounding box: a matrix placement that does
-        // not fit inside it is rejected in favour of a placement derived from the range.
-        let placement = match (matrix_placement, range) {
+        // The element range is MicroStation's own bounding box. It only checks the matrix
+        // placement: one that does not fit inside it is replaced by a placement derived from
+        // the range, and the pixel size is then not trusted either.
+        let (placement, size_px) = match (matrix_placement, range) {
             (Some(p), Some(r)) if !within_range(&p, &r, RASTER_RANGE_TOLERANCE) => {
                 self.note("dgn.raster_outside_range", || {
                     "raster transform places the image outside its element range; the range was used"
                         .into()
                 });
-                Some(range_placement(&r, axes))
+                (Some(range_placement(&r, axes)), None)
             }
-            (Some(p), _) => Some(p),
+            (Some(p), _) => (Some(p), pixels),
             (None, Some(r)) => {
                 self.note("dgn.raster_range_placement", || {
                     "raster frame placed from its range (no usable transform)".into()
                 });
-                Some(range_placement(&r, axes))
+                (Some(range_placement(&r, axes)), None)
             }
-            (None, None) => None,
+            (None, None) => (None, None),
         };
         let Some((origin, u, v)) = placement else {
             return EntityKind::Unknown {
@@ -921,13 +933,14 @@ impl Mapper {
             position: xf.pt(origin),
             u_vector: tidy(u.scaled(xf.scale)),
             v_vector: tidy(v.scaled(xf.scale)),
-            size_px: None,
+            size_px,
         }
     }
 
-    /// A tag as an attribute (`position` = origin + offset).
+    /// A tag as an attribute (`position` = origin + offset). The tag element's own level,
+    /// its text presentation and its symbology are kept so a writer can reproduce it.
     pub(crate) fn attribute(
-        &self,
+        &mut self,
         t: &TagData,
         h: &crate::native::element::ElementHeader,
         xf: &Xf,
@@ -937,18 +950,66 @@ impl Mapper {
             .or(t.set_number.map(u64::from))
             .and_then(|k| self.tag_sets.get(&k));
         let def = set.and_then(|s| s.tags.iter().find(|d| d.id == t.tag_index));
+        let tag = def
+            .map(|d| d.name.clone())
+            .unwrap_or_else(|| format!("tag_{}", t.tag_index));
+        let set_name = set.and_then(|s| s.name.clone());
         let [ox, oy, oz] = t.origin;
         let [dx, dy, dz] = t.offset;
         let has_pos = t.origin != [0.0; 3] || t.offset != [0.0; 3];
+        // Observed: hidden tags carry 0x0080 in the property word (FORMAT_NOTES).
+        let invisible = h.properties & 0x0080 != 0;
+        let mut props = Props::new();
+        let mut layer = None;
+        if h.has_display_header {
+            layer = Some(self.level_name(h.level));
+            props.insert("dgn.color_index".into(), Value::Int(i64::from(h.color)));
+            props.insert("dgn.weight".into(), Value::Int(i64::from(h.weight)));
+            props.insert("dgn.style".into(), Value::Int(i64::from(h.style)));
+            if h.graphic_group != 0 {
+                props.insert(
+                    "dgn.graphic_group".into(),
+                    Value::Int(i64::from(h.graphic_group)),
+                );
+            }
+            // Only MicroStation's undecoded property bits add anything to `invisible`.
+            if h.properties & 0x0600 != 0 {
+                props.insert("dgn.properties".into(), Value::Int(i64::from(h.properties)));
+            }
+            if h.type_flags & 0x00c0 != 0 {
+                props.insert(
+                    "dgn.type_flags".into(),
+                    Value::Int(i64::from(h.type_flags & 0x00c0)),
+                );
+            }
+        }
+        // V7 tags and hidden V8 tags without a text size have no usable presentation.
+        let display = (t.size[1] > 0.0 && t.size[0] > 0.0).then(|| {
+            self.used_fonts.insert(t.font);
+            props.insert("dgn.font_number".into(), Value::Int(i64::from(t.font)));
+            props.insert(
+                "dgn.justification".into(),
+                Value::Int(i64::from(t.justification)),
+            );
+            let (halign, valign, _, _) = justification(t.justification);
+            AttributeDisplay {
+                height: xf.dist(t.size[1]),
+                width: xf.dist(t.size[0]),
+                style: Some(self.font_style_name(t.font)),
+                halign,
+                valign,
+                rotation: tag_rotation(t.quaternion),
+            }
+        });
         Attribute {
-            tag: def
-                .map(|d| d.name.clone())
-                .unwrap_or_else(|| format!("tag_{}", t.tag_index)),
+            tag,
             value: tag_value(&t.value),
-            set: set.and_then(|s| s.name.clone()),
+            set: set_name,
             position: has_pos.then(|| xf.pt([ox + dx, oy + dy, oz + dz])),
-            // Observed: hidden tags carry 0x0080 in the property word (FORMAT_NOTES).
-            invisible: h.properties & 0x0080 != 0,
+            invisible,
+            layer,
+            display,
+            props,
         }
     }
 }
@@ -1060,29 +1121,63 @@ fn curve(points: &[UorPoint], xf: &Xf) -> EntityKind {
     }
 }
 
+/// Pixel X and Y axes of a raster frame matrix (row-major 4x4): its first two columns,
+/// one pixel long each, in UOR.
+pub(crate) fn frame_axes(m: &[f64; 16]) -> (Vec3, Vec3) {
+    let [m00, m01, _, _, m10, m11, _, _, m20, m21, ..] = *m;
+    (Vec3::new(m00, m10, m20), Vec3::new(m01, m11, m21))
+}
+
 /// Raster frame placement from its pixel-to-UOR matrix (row-major, translation in the
-/// last column): the image starts at the translation and its edges follow the matrix X / Y
-/// columns, scaled so that the frame reaches its stored extent corner. Handles rotated and
-/// sheared frames; `None` when the corner is missing or the system is degenerate.
+/// last column) and its edge lengths (`0x108`/`0x110`, UOR): the image starts at the
+/// translation (its lower-left corner) and its edges run along the unit matrix X / Y
+/// columns for those lengths, `u = â·ext_x`, `v = b̂·ext_y`. The lengths are measured
+/// along the image axes (width·|a| and height·|b|), not as an XY extent, so rotated and
+/// sheared frames need no solving. `None` when an axis or a length is degenerate.
 pub(crate) fn frame_placement(
     m: &[f64; 16],
-    corner: Option<[f64; 2]>,
+    edges: Option<[f64; 2]>,
 ) -> Option<(UorPoint, Vec3, Vec3)> {
-    let [m00, m01, _, m03, m10, m11, _, m13, m20, m21, _, m23, ..] = *m;
-    let a = Vec3::new(m00, m10, m20);
-    let b = Vec3::new(m01, m11, m21);
-    let [cx, cy] = corner?;
-    let (dx, dy) = (cx - m03, cy - m13);
-    let det = a.x * b.y - a.y * b.x;
-    if !det.is_finite() || det.abs() <= 1e-12 * a.length() * b.length() {
+    let [_, _, _, m03, _, _, _, m13, _, _, _, m23, ..] = *m;
+    let (a, b) = frame_axes(m);
+    let [ex, ey] = edges?;
+    if !(ex.is_finite() && ey.is_finite() && ex > 0.0 && ey > 0.0) {
         return None;
     }
-    let w = (dx * b.y - dy * b.x) / det;
-    let h = (a.x * dy - a.y * dx) / det;
-    if !(w.is_finite() && h.is_finite() && w > 0.0 && h > 0.0) {
+    let (ua, ub) = (a.normalized()?, b.normalized()?);
+    // Parallel axes span no rectangle.
+    if ua.cross(ub).length() <= 1e-9 {
+        return None;
+    }
+    if ![m03, m13, m23].iter().all(|v| v.is_finite()) {
+        return None;
+    }
+    Some(([m03, m13, m23], ua.scaled(ex), ub.scaled(ey)))
+}
+
+/// Pixel size of a raster frame: its edge lengths over the pixel lengths `|a|` and `|b|`
+/// of the matrix axes, rounded. `None` when that is not a positive `u32`.
+pub(crate) fn frame_pixels(m: &[f64; 16], edges: Option<[f64; 2]>) -> Option<[u32; 2]> {
+    let (a, b) = frame_axes(m);
+    let [ex, ey] = edges?;
+    let count = |edge: f64, axis: Vec3| {
+        let n = (edge / axis.length()).round();
+        (n.is_finite() && n >= 1.0 && n <= f64::from(u32::MAX)).then_some(n as u32)
+    };
+    Some([count(ex, a)?, count(ey, b)?])
+}
+
+/// Rotation of the image X axis and skew of its Y axis from the perpendicular, both in
+/// the XY plane, in radians within (-π, π].
+fn frame_angles(m: &[f64; 16]) -> Option<(f64, f64)> {
+    let (a, b) = frame_axes(m);
+    if a.normalized().is_none() || b.normalized().is_none() {
         return None;
     }
-    Some(([m03, m13, m23], a.scaled(w), b.scaled(h)))
+    let rotation = a.y.atan2(a.x);
+    let skew = b.y.atan2(b.x) - rotation - FRAC_PI_2;
+    let skew = skew.sin().atan2(skew.cos());
+    (rotation.is_finite() && skew.is_finite()).then_some((rotation, skew))
 }
 
 /// Most XAttribute kinds listed on one entity (the count is always complete).
@@ -1154,6 +1249,28 @@ pub(crate) fn justification(code: u16) -> (HAlign, VAlign, f64, f64) {
     (h, v, fx, fy)
 }
 
+/// Keeps only what a tag element does not share with its owner: `layer` stays `None` on the
+/// owner's level, and symbology/flag props equal to the owner's are dropped.
+fn relative_to_owner(mut a: Attribute, owner: &Entity) -> Attribute {
+    if a.layer.is_some() && a.layer == owner.layer {
+        a.layer = None;
+    }
+    a.props
+        .retain(|key, value| owner.props.get(key) != Some(value) || key == "dgn.font_number");
+    a
+}
+
+/// Rotation of a displayed tag about +Z in radians, from its stored quaternion (same
+/// convention as text, see [`Rotation::matrix`]). An all-zero quaternion means none.
+pub(crate) fn tag_rotation(q: [f64; 4]) -> f64 {
+    if q.iter().all(|v| *v == 0.0) {
+        return 0.0;
+    }
+    let [m00, _, _, m10, ..] = Rotation::Quaternion(q).matrix();
+    let a = m10.atan2(m00);
+    if a.abs() < 1e-12 { 0.0 } else { a }
+}
+
 /// Text length in UOR and whether it is estimated (`characters x character width`, the
 /// estimate GDAL dgnlib's writer uses for text bounds).
 fn text_length(t: &TextData) -> (f64, bool) {
@@ -1457,25 +1574,46 @@ mod tests {
 
     #[test]
     fn raster_placement_follows_the_matrix() {
-        // 30 degree rotation, 2 UOR per pixel, translation (100, 50); a 300 x 200 pixel image.
+        // 30 degree rotation, 2 UOR per pixel, translation (100, 50); a 300 x 200 pixel
+        // image. `0x108`/`0x110` hold the edge lengths along the image axes (W·|a|, H·|b|).
         let (s, c) = 30f64.to_radians().sin_cos();
         let (a, b) = ([2.0 * c, 2.0 * s], [-2.0 * s, 2.0 * c]);
         let m = [
             a[0], b[0], 0.0, 100.0, a[1], b[1], 0.0, 50.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
         ];
-        let corner = [
-            100.0 + 300.0 * a[0] + 200.0 * b[0],
-            50.0 + 300.0 * a[1] + 200.0 * b[1],
-        ];
-        let (o, u, v) = frame_placement(&m, Some(corner)).unwrap();
+        let edges = [600.0, 400.0];
+        let (o, u, v) = frame_placement(&m, Some(edges)).unwrap();
         assert_eq!(o, [100.0, 50.0, 0.0]);
         assert!(close(u.x, 600.0 * c) && close(u.y, 600.0 * s));
         assert!(close(v.x, -400.0 * s) && close(v.y, 400.0 * c));
+        assert_eq!(frame_pixels(&m, Some(edges)), Some([300, 200]));
+        let (rotation, skew) = frame_angles(&m).unwrap();
+        assert!(close(rotation, 30f64.to_radians()) && close(skew, 0.0));
         assert!(frame_placement(&m, None).is_none());
+        assert!(frame_placement(&m, Some([0.0, 400.0])).is_none());
         let mut flat = m;
         flat[1] = flat[0];
         flat[5] = flat[4];
-        assert!(frame_placement(&flat, Some(corner)).is_none(), "degenerate");
+        assert!(frame_placement(&flat, Some(edges)).is_none(), "degenerate");
+    }
+
+    #[test]
+    fn sheared_raster_frames_keep_their_axes() {
+        // X axis 3 UOR per pixel along +X; Y axis 2 UOR per pixel tilted 10 degrees left of
+        // +Y. The Y edge runs along the tilted axis for H·|b| UOR.
+        let (s, c) = 10f64.to_radians().sin_cos();
+        let (a, b) = ([3.0, 0.0], [-2.0 * s, 2.0 * c]);
+        let m = [
+            a[0], b[0], 0.0, -5.0, a[1], b[1], 0.0, 7.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
+        ];
+        let edges = [3.0 * 120.0, 2.0 * 80.0];
+        let (o, u, v) = frame_placement(&m, Some(edges)).unwrap();
+        assert_eq!(o, [-5.0, 7.0, 0.0]);
+        assert!(close(u.x, 360.0) && close(u.y, 0.0));
+        assert!(close(v.x, -160.0 * s) && close(v.y, 160.0 * c));
+        assert_eq!(frame_pixels(&m, Some(edges)), Some([120, 80]));
+        let (rotation, skew) = frame_angles(&m).unwrap();
+        assert!(close(rotation, 0.0) && close(skew, 10f64.to_radians()));
     }
 
     #[test]

{pycadkit-0.2.1 → pycadkit-0.3.1}/crates/cadkit-dgn/src/map/v8.rs

@@ -203,48 +203,6 @@ fn map_file(file: &V8File, options: &ReadOptions, enc: &'static encoding_rs::Enc
             enc,
             options,
         );
-        // Frames that store the same extent corner for the same file: their extents are then
-        // not image footprints (private sample: 8 frames, one file, one corner).
-        m.shared_raster_extent.clear();
-        let mut by_extent: HashMap<(i64, i64, Option<String>), Vec<u64>> = HashMap::new();
-        for it in &graphic {
-            if let (
-                ElementData::RasterFrame {
-                    corner: Some([cx, cy]),
-                    ..
-                },
-                Some(id),
-            ) = (&it.el.data, it.el.header.id)
-            {
-                let file = m
-                    .raster_paths
-                    .get(&id)
-                    .and_then(|(n, f)| f.clone().or_else(|| n.clone()));
-                by_extent
-                    .entry((cx.round() as i64, cy.round() as i64, file))
-                    .or_default()
-                    .push(id);
-            }
-        }
-        let shared: Vec<u64> = by_extent
-            .into_values()
-            .filter(|v| v.len() > 1)
-            .flatten()
-            .collect();
-        if !shared.is_empty() {
-            m.warn(
-                "dgn.raster_extent_shared",
-                format!(
-                    "{} raster frames share one stored extent corner and file; their \
-                     rectangles (as stored, equal to the element ranges) are probably not \
-                     image footprints",
-                    shared.len()
-                ),
-                None,
-                None,
-            );
-            m.shared_raster_extent.extend(shared);
-        }
         m.pending_tags.clear();
         m.attached.clear();
         for (i, it) in graphic.iter().enumerate() {