pycadkit 0.3.0__tar.gz → 0.3.1__tar.gz

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

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

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

@@ -4,7 +4,7 @@ members = ["crates/*"]
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.3.0"
+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.3.0" }
-cadkit-dgn = { path = "crates/cadkit-dgn", version = "0.3.0" }
-cadkit-dwg = { path = "crates/cadkit-dwg", version = "0.3.0" }
-cadkit-dxf = { path = "crates/cadkit-dxf", version = "0.3.0" }
-cadkit-gml = { path = "crates/cadkit-gml", version = "0.3.0" }
-cadkit = { path = "crates/cadkit", version = "0.3.0" }
+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.3.0 → pycadkit-0.3.1}/PKG-INFO

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

{pycadkit-0.3.0 → 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.3.0 → pycadkit-0.3.1}/crates/cadkit-dgn/src/map/mod.rs

@@ -671,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(
@@ -683,6 +683,19 @@ impl Mapper {
                     "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,7 +933,7 @@ 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,
         }
     }
 
@@ -1109,30 +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);
-    // `0x108`/`0x110` is the frame's extent from its origin (the same values as the
-    // element range extent on the private sample), not an absolute corner.
-    let [dx, dy] = corner?;
-    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;
     }
-    Some(([m03, m13, m23], a.scaled(w), b.scaled(h)))
+    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;
+    }
+    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).
@@ -1529,23 +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.
-        // The frame stores its extent from the translation (rotated frames unverified).
+        // 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 = [300.0 * a[0] + 200.0 * b[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.3.0 → pycadkit-0.3.1}/crates/cadkit-dgn/src/writer/encode.rs

@@ -240,7 +240,12 @@ pub(super) fn utf16_unterminated(value: &str) -> Result<Vec<u8>> {
 }
 
 pub(super) fn string_link(id: u32, value: &str) -> Result<Vec<u8>> {
-    let text = utf16_unterminated(value)?;
+    string_link_bytes(id, &utf16_unterminated(value)?)
+}
+
+/// String linkage holding `text` as already encoded (`ff fd` + UTF-16LE or 8-bit bytes),
+/// zero padded to 8 bytes; its length counts no terminator.
+pub(super) fn string_link_bytes(id: u32, text: &[u8]) -> Result<Vec<u8>> {
     let size = (12 + text.len() + 7) & !7;
     if size > 512 {
         return Err(Error::LimitExceeded(
@@ -252,7 +257,7 @@ pub(super) fn string_link(id: u32, value: &str) -> Result<Vec<u8>> {
     put(&mut b, 2, &0x56d2u16.to_le_bytes())?;
     u32_at(&mut b, 4, id)?;
     u32_at(&mut b, 8, text.len() as u32)?;
-    put(&mut b, 12, &text)?;
+    put(&mut b, 12, text)?;
     Ok(b)
 }
 pub(super) fn dependency(app: u16, id: u64) -> Result<Vec<u8>> {

{pycadkit-0.3.0 → pycadkit-0.3.1}/crates/cadkit-dgn/src/writer/mod.rs

@@ -4,12 +4,13 @@ mod container;
 mod encode;
 mod polyline;
 mod raster;
+mod raster_template;
 mod tables;
 mod text;
 
 use crate::{
     le,
-    native::v8::{self, ModelHeader, RawElement},
+    native::v8::{self, AuxRecord, ModelHeader, PageHeader, RawElement},
 };
 use cadkit_core::{
     Attribute, Document, Entity, EntityKind, Error, GroupKind, Limits, Point3, ReadOptions, Result,
@@ -39,7 +40,9 @@ pub struct WriteOptions {
     /// drawing units. Defaults to 0.01 (1 cm for metres), allowing coordinate rounding.
     pub planarity_tolerance: f64,
     /// Preserve unchanged raster attachments from the same seed, including their
-    /// opaque control and auxiliary records. New or edited attachments are rejected.
+    /// 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.
     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.
@@ -68,6 +71,20 @@ 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,
+/// 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.
+pub fn seed_has_raster_template(seed: &[u8], options: &ReadOptions) -> Result<bool> {
+    let native = v8::read(seed, options)?;
+    Ok(match native.models.as_slice() {
+        [model] => raster_template::Template::capture(model).is_some(),
+        _ => false,
+    })
+}
+
 fn compressed(bytes: &[u8]) -> Result<Vec<u8>> {
     let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
     encoder.write_all(bytes)?;
@@ -232,6 +249,8 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
         rasters: &rasters,
         records: vec![],
         tags: vec![],
+        new_controls: vec![],
+        new_xattributes: vec![],
         work: 0,
         vertices: 0,
         bytes: rasters.bytes,
@@ -245,6 +264,8 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
         state.entity(entity, 0, false)?;
     }
     state.records.append(&mut state.tags);
+    let new_controls = std::mem::take(&mut state.new_controls);
+    let new_xattributes = std::mem::take(&mut state.new_xattributes);
     let records = state.records;
     let named = state.tables.finish(options.timestamp_ms)?;
     let max_id = records
@@ -305,14 +326,50 @@ pub fn write_v8(doc: &Document, seed: &[u8], options: &WriteOptions) -> Result<V
         .map(|p| p.header.format_version)
         .filter(|v| matches!(v, 2 | 3))
         .unwrap_or(3);
-    put_pages(
+    let record_pages = put_pages(
         &mut replacements,
         &format!("Dgn-Md/{}/Dgn^G", model.storage),
         &records,
         version,
         options.limits.max_decompressed_bytes,
     )?;
-    rasters.write_auxiliary(&mut replacements)?;
+    rasters.write_auxiliary(&mut replacements, &new_controls)?;
+    if let Some(template) = rasters
+        .template
+        .as_ref()
+        .filter(|_| !new_xattributes.is_empty())
+    {
+        // An XAttribute sits in the auxiliary page numbered like the graphic page of its
+        // element, as in every observed attachment.
+        let mut pages: BTreeMap<u32, Vec<AuxRecord>> = BTreeMap::new();
+        for (index, record) in new_xattributes {
+            let number = record_pages
+                .get(index)
+                .copied()
+                .ok_or_else(|| Error::invalid(0, "raster frame record outside the pages"))?;
+            pages.entry(number).or_default().push(record);
+        }
+        let mut last = 0;
+        for (number, records) in &pages {
+            let header = PageHeader {
+                record_count: 0,
+                format_version: template.aux_version,
+                page_number: *number,
+                population: 0,
+            };
+            replacements.insert(
+                format!("Dgn-Md/{}/Dgn^GA/${number}", model.storage),
+                Some(raster::aux_page(records, header)?),
+            );
+            last = *number;
+        }
+        // `^AH` is at least the highest page number in every observed file; the next free
+        // number is the most common value.
+        replacements.insert(
+            format!("Dgn-Md/{}/Dgn^GA/^AH", model.storage),
+            Some(last.saturating_add(1).to_le_bytes().to_vec()),
+        );
+    }
     if rasters.keep_control_counter {
         // Every control auxiliary page is retained as is; so is its page counter.
         replacements.remove(&format!("Dgn-Md/{}/Dgn^CA/^AH", model.storage));
@@ -391,13 +448,15 @@ 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.
 fn put_pages(
     replacements: &mut BTreeMap<String, Option<Vec<u8>>>,
     prefix: &str,
     records: &[Vec<u8>],
     version: u32,
     max: u64,
-) -> Result<()> {
+) -> Result<Vec<u32>> {
     let total = records
         .iter()
         .try_fold(0u64, |sum, r| sum.checked_add(r.len() as u64 + 4))
@@ -408,6 +467,7 @@ fn put_pages(
     let mut first = 0;
     let mut bytes = 0usize;
     let mut number = 1u32;
+    let mut numbers = Vec::with_capacity(records.len());
     for (i, r) in records.iter().enumerate() {
         if bytes > 0 && bytes.saturating_add(r.len() + 4) > 256 * 1024 {
             replacements.insert(
@@ -421,12 +481,13 @@ fn put_pages(
                 .ok_or_else(|| Error::LimitExceeded("DGN page count".into()))?;
         }
         bytes = bytes.saturating_add(r.len() + 4);
+        numbers.push(number);
     }
     replacements.insert(
         format!("{prefix}/${number}"),
         Some(page(records.get(first..).unwrap_or(&[]), version, number)?),
     );
-    Ok(())
+    Ok(numbers)
 }
 
 /// An absent tag set is distinct from every explicitly named tag set.
@@ -476,6 +537,10 @@ struct State<'a> {
     rasters: &'a raster::Preserved,
     records: Vec<Vec<u8>>,
     tags: Vec<Vec<u8>>,
+    /// Control records of new raster attachments, in stored order.
+    new_controls: Vec<Vec<u8>>,
+    /// XAttributes of new raster frames with the index of the frame in `records`.
+    new_xattributes: Vec<(usize, AuxRecord)>,
     work: u64,
     vertices: u64,
     bytes: u64,
@@ -584,9 +649,14 @@ impl State<'_> {
 
     fn add(&mut self, b: Vec<u8>, tag: bool) -> Result<()> {
         self.bytes = self.bytes.saturating_add(b.len() as u64);
+        let new_rasters = self
+            .new_controls
+            .len()
+            .saturating_add(self.new_xattributes.len()) as u64;
         if self.bytes > self.options.limits.max_decompressed_bytes
             || (self.records.len().saturating_add(self.tags.len()) as u64)
                 .saturating_add(self.rasters.objects)
+                .saturating_add(new_rasters)
                 >= self.options.limits.max_objects
         {
             return Err(Error::LimitExceeded("DGN output record budget".into()));
@@ -607,6 +677,9 @@ impl State<'_> {
             .tables
             .level(e.layer.as_deref(), self.options.timestamp_ms)?;
         if matches!(e.kind, EntityKind::Image { .. }) {
+            if e.id.is_none() {
+                return self.new_raster(e, level, component);
+            }
             let (id, record) = self.rasters.frame(e, component)?;
             self.add(record, false)?;
             return self.attributes(e, id, level);
@@ -964,6 +1037,36 @@ impl State<'_> {
         self.add(finish(b, &links)?, false)?;
         self.attributes(e, id, level)
     }
+    /// A new raster attachment cloned from the seed template (see `raster_template`).
+    fn new_raster(&mut self, e: &Entity, level: u32, component: bool) -> Result<()> {
+        if component {
+            return Err(Error::Unsupported(
+                "new DGN raster attachments cannot be complex group components".into(),
+            ));
+        }
+        let template = self
+            .rasters
+            .template
+            .as_ref()
+            .ok_or_else(|| Error::Unsupported(raster_template::NO_TEMPLATE.into()))?;
+        let mut ids = [0u64; 10];
+        for id in &mut ids {
+            *id = self.tables.id()?;
+        }
+        let group = template.instantiate(e, ids, level, self.model, self.options.timestamp_ms)?;
+        let extra = group
+            .controls
+            .iter()
+            .map(|c| c.len() as u64)
+            .sum::<u64>()
+            .saturating_add(group.xattribute.payload.len() as u64 + 28);
+        self.bytes = self.bytes.saturating_add(extra);
+        let index = self.records.len();
+        self.new_controls.extend(group.controls);
+        self.new_xattributes.push((index, group.xattribute));
+        self.add(group.frame, false)?;
+        self.attributes(e, group.frame_id, level)
+    }
     fn points(
         &mut self,
         e: &Entity,