Projection chips redraw the preview; auto-crop as the DNG default crop

Picking a chip stored the choice for the merge and changed nothing on
screen — the chip did not even highlight, since the selected property
was never written back. Now the pick is reflected, and the job, waiting
for its decision, takes a Preview request, draws the alignment on the
chosen surface at proxy cost and reports again; the drain puts the new
picture and its size up. Auto is the surface the field of view suggests.

Also:
The largest rectangle inside the frames' coverage is found a row at a
time — a histogram of consecutive covered rows and a stack pass per row —
so the composite is never held to be measured (FR-MRG-11). It is written
as DefaultCropOrigin/DefaultCropSize (FR-MRG-4): the file opens on the
picture, the border is still in it, and resetting the crop shows it.
rawler reports the crop as the picture, which the test checks.

FR-MRG-4 records the question raised the same day — fill the border
rather than crop it — as open: a non-generative fill through the heal,
or a generative inpainter with its licence and weights. Neither decided.

core/dr-export/src/dng.rs

@@ -60,7 +60,12 @@ pub struct DngProfile {
 ///
 /// `PhotometricInterpretation = LinearRaw`, `DNGVersion 1.4`, uncompressed,
 /// `Orientation = 1` — the composite is written upright (panorama.md §8).
-pub fn write_linear_dng<W, F>(
+///
+/// `crop` is asked once every strip is in, and its answer — the largest
+/// rectangle the frames covered, found while the strips went by
+/// (`Inscribed`) — becomes `DefaultCropOrigin`/`DefaultCropSize`
+/// (FR-MRG-4): the file opens on the picture, and the border is still in it.
+pub fn write_linear_dng<W, F, C>(
     out: W,
     width: u32,
     height: u32,
@@ -68,10 +73,12 @@ pub fn write_linear_dng<W, F>(
     profile: &DngProfile,
     source: Option<&SourceMetadata>,
     mut strips: F,
+    crop: C,
 ) -> Result<(), ExportError>
 where
     W: Write + Seek,
     F: FnMut(usize, &mut Vec<u16>) -> Result<(), ExportError>,
+    C: FnOnce() -> Option<crate::Rect>,
 {
     let enc = |e: tiff::TiffError| ExportError::Encode(e.to_string());
     let mut encoder = TiffEncoder::new(out).map_err(enc)?;
@@ -99,6 +106,22 @@ where
         }
         image.write_strip(&buf).map_err(enc)?;
     }
+    if let Some(r) = crop().filter(|r| r.width > 0 && r.height > 0) {
+        let r = crate::Rect {
+            x: r.x.min(width - 1),
+            y: r.y.min(height - 1),
+            width: r.width.min(width - r.x.min(width - 1)),
+            height: r.height.min(height - r.y.min(height - 1)),
+        };
+        image
+            .encoder()
+            .write_tag(Tag::Unknown(tag::DEFAULT_CROP_ORIGIN), &[r.x, r.y][..])
+            .map_err(enc)?;
+        image
+            .encoder()
+            .write_tag(Tag::Unknown(tag::DEFAULT_CROP_SIZE), &[r.width, r.height][..])
+            .map_err(enc)?;
+    }
     image.finish().map_err(enc)
 }
 
@@ -154,6 +177,8 @@ mod tag {
     pub const UNIQUE_CAMERA_MODEL: u16 = 50708;
     pub const BLACK_LEVEL: u16 = 50714;
     pub const WHITE_LEVEL: u16 = 50717;
+    pub const DEFAULT_CROP_ORIGIN: u16 = 50719;
+    pub const DEFAULT_CROP_SIZE: u16 = 50720;
     pub const COLOR_MATRIX_1: u16 = 50721;
     pub const COLOR_MATRIX_2: u16 = 50722;
     pub const AS_SHOT_NEUTRAL: u16 = 50728;
@@ -205,16 +230,32 @@ mod tests {
             model: Some("Canon EOS 6D".into()),
             ..Default::default()
         };
-        write_linear_dng(&mut bytes, width, height, rows, &profile(), Some(&source), |k, buf| {
-            let first = k as u32 * rows;
-            let n = rows.min(height - first);
-            for y in first..first + n {
-                for x in 0..width {
-                    buf.extend([(x + y * width) as u16, 1000, 2000]);
+        write_linear_dng(
+            &mut bytes,
+            width,
+            height,
+            rows,
+            &profile(),
+            Some(&source),
+            |k, buf| {
+                let first = k as u32 * rows;
+                let n = rows.min(height - first);
+                for y in first..first + n {
+                    for x in 0..width {
+                        buf.extend([(x + y * width) as u16, 1000, 2000]);
+                    }
                 }
-            }
-            Ok(())
-        })
+                Ok(())
+            },
+            || {
+                Some(crate::Rect {
+                    x: 2,
+                    y: 1,
+                    width: 15,
+                    height: 10,
+                })
+            },
+        )
         .expect("written");
         bytes.into_inner()
     }
@@ -242,15 +283,27 @@ mod tests {
         // The profile came through as the camera's.
         assert!(image.camera.color_matrix.len() >= 1);
         assert_eq!(image.model, "Canon EOS 6D");
+        // The default crop is what the decoder reports as the picture.
+        let crop = image.crop_area.expect("a crop");
+        assert_eq!((crop.p.x, crop.p.y, crop.d.w, crop.d.h), (2, 1, 15, 10));
     }
 
     #[test]
     fn a_strip_of_the_wrong_length_is_refused() {
         let mut bytes = std::io::Cursor::new(Vec::new());
-        let err = write_linear_dng(&mut bytes, 8, 8, 8, &profile(), None, |_, buf| {
-            buf.extend([0u16; 10]);
-            Ok(())
-        })
+        let err = write_linear_dng(
+            &mut bytes,
+            8,
+            8,
+            8,
+            &profile(),
+            None,
+            |_, buf| {
+                buf.extend([0u16; 10]);
+                Ok(())
+            },
+            || None,
+        )
         .unwrap_err();
         assert!(matches!(err, ExportError::Encode(_)));
     }