diff --git a/Cargo.lock b/Cargo.lock
index 31b1cf6..79f7091 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -602,7 +602,7 @@ dependencies = [
[[package]]
name = "canvas-pilot"
-version = "0.9.71"
+version = "0.9.72"
dependencies = [
"base64 0.22.1",
"craft-dwg",
diff --git a/Cargo.toml b/Cargo.toml
index cb8826e..cc854f0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ default-members = ["crates/canvas-pilot"]
resolver = "3"
[workspace.package]
-version = "0.9.71"
+version = "0.9.72"
edition = "2024"
license = "MIT"
repository = "https://proxy.dandaedre.com/gitea/idle-org/canvas-pilot"
diff --git a/crates/canvas-pilot/examples/read_input_capture.rs b/crates/canvas-pilot/examples/read_input_capture.rs
new file mode 100644
index 0000000..8e69af7
--- /dev/null
+++ b/crates/canvas-pilot/examples/read_input_capture.rs
@@ -0,0 +1,29 @@
+//! Explicit read-only check of input capture framing; never changes device settings.
+use canvas_pilot::{device, device_capture, device_inputs::InputDraft};
+fn main() -> Result<(), String> {
+ let mut args = std::env::args().skip(1);
+ let host = args
+ .next()
+ .ok_or("Usage: read_input_capture DEVICE_IP INPUT_NUMBER")?;
+ let input: u32 = args
+ .next()
+ .ok_or("Input number required")?
+ .parse()
+ .map_err(|_| "Invalid input number")?;
+ let before = device::fetch_input(&host, input)?;
+ let draft = InputDraft::read(&before, input)?;
+ let bytes = device_capture::capture_for(&host, before.profile, input)?;
+ let image = image::load_from_memory(&bytes).map_err(|e| e.to_string())?;
+ let size = [image.width(), image.height()];
+ let after = device::fetch_input(&host, input)?;
+ draft.changes(&after)?;
+ let geometry = device_capture::capture_geometry(&before, input, size)?;
+ if geometry != device_capture::capture_geometry(&after, input, size)? {
+ return Err("Capture geometry changed during the request".into());
+ }
+ println!(
+ "{} · input {input} · PNG {} × {} · {geometry:?}",
+ before.identity, size[0], size[1]
+ );
+ Ok(())
+}
diff --git a/crates/canvas-pilot/src/capture_ui.rs b/crates/canvas-pilot/src/capture_ui.rs
index 4dda748..b6c4e03 100644
--- a/crates/canvas-pilot/src/capture_ui.rs
+++ b/crates/canvas-pilot/src/capture_ui.rs
@@ -359,17 +359,14 @@ impl Editor {
}
let after = canvas_pilot::device::fetch_input(&host, input)?;
draft.changes(&after)?;
- let geometry = if profile == canvas_pilot::device::Profile::Aquilon6 {
- draft.native.filter(|n|((reference.size[0] as f64/reference.size[1] as f64)/(n[0]/n[1])-1.).abs()<0.01).and_then(|native| {
- let base=format!("/device/inputList/items/IN_{input}/plugList/items/{}/settings/cropping/status/pp",draft.plug);
- let edge=|key|before.raw.pointer(&format!("{base}/{key}")).and_then(serde_json::Value::as_f64);
- let crop=canvas_pilot::formats::Crop {left:edge("left")?,right:edge("right")?,top:edge("top")?,bottom:edge("bottom")?};
- crop.remaining(native).ok()?;
- Some(super::inputs_window::CaptureGeometry {native,crop})
- })
- } else {
- None
- };
+ let geometry = device_capture::capture_geometry(&before, input, reference.size)
+ .ok()
+ .filter(|geometry| {
+ device_capture::capture_geometry(&after, input, reference.size)
+ .ok()
+ .as_ref()
+ == Some(geometry)
+ });
let _ = geometry_tx.send(geometry);
}
Ok(reference)
@@ -1564,6 +1561,7 @@ mod tests {
let (geometry_tx, geometry_rx) = std::sync::mpsc::channel();
geometry_tx
.send(Some(super::super::inputs_window::CaptureGeometry {
+ framing: device_capture::CaptureFraming::FullFrame,
native: [1920., 1080.],
crop: canvas_pilot::formats::Crop::default(),
}))
diff --git a/crates/canvas-pilot/src/device_capture.rs b/crates/canvas-pilot/src/device_capture.rs
index aa68dc8..d7fa131 100644
--- a/crates/canvas-pilot/src/device_capture.rs
+++ b/crates/canvas-pilot/src/device_capture.rs
@@ -50,6 +50,128 @@ pub fn inputs(snapshot: &Snapshot) -> Vec {
inputs
}
+/// How the PNG represents the applied input crop.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CaptureFraming {
+ /// Aquilon retains full-source coordinates, blanking the cropped edges.
+ FullFrame,
+ /// Midra returns only the retained image, without the removed edges.
+ Cropped,
+}
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CaptureGeometry {
+ pub native: [f64; 2],
+ pub crop: crate::formats::Crop,
+ pub framing: CaptureFraming,
+}
+
+/// Interpret device readback, never an unsent editor draft. Callers must also
+/// verify that input state stayed unchanged across the capture request.
+pub fn capture_geometry(
+ snapshot: &Snapshot,
+ input: u32,
+ image_size: [u32; 2],
+) -> Result {
+ use crate::device::Profile;
+ let draft = crate::device_inputs::InputDraft::read(snapshot, input)?;
+ let native = draft.native.ok_or("No valid input signal dimensions")?;
+ let prefix = if snapshot.profile == Profile::Aquilon6 {
+ "IN"
+ } else {
+ "INPUT"
+ };
+ let base = format!(
+ "/device/inputList/items/{prefix}_{input}/plugList/items/{}",
+ draft.plug
+ );
+ let plug = snapshot
+ .raw
+ .pointer(&base)
+ .ok_or("Input plug unavailable")?;
+ if plug
+ .pointer("/control/pp/enableCropFinder")
+ .and_then(serde_json::Value::as_bool)
+ == Some(true)
+ {
+ return Err("Disable Crop Finder to preview the applied input crop".into());
+ }
+ let (crop, framing) = match snapshot.profile {
+ Profile::Aquilon6 => {
+ let status = plug
+ .pointer("/settings/cropping/status/pp")
+ .ok_or("Applied input crop unavailable")?;
+ let edge = |key: &str| {
+ status
+ .get(key)
+ .and_then(serde_json::Value::as_f64)
+ .ok_or("Applied crop edge unavailable")
+ };
+ (
+ crate::formats::Crop {
+ left: edge("left")?,
+ right: edge("right")?,
+ top: edge("top")?,
+ bottom: edge("bottom")?,
+ },
+ CaptureFraming::FullFrame,
+ )
+ }
+ Profile::Midra4k => {
+ // Midra exposes crop controls plus the resulting image dimensions,
+ // not Aquilon's separate cropping/status object.
+ let controls = plug
+ .pointer("/settings/cropping/control/pp")
+ .ok_or("Input crop unavailable")?;
+ let edge = |key: &str| {
+ controls
+ .get(key)
+ .and_then(serde_json::Value::as_f64)
+ .ok_or("Crop edge unavailable")
+ };
+ (
+ crate::formats::Crop {
+ left: edge("left")?,
+ right: edge("right")?,
+ top: edge("top")?,
+ bottom: edge("bottom")?,
+ },
+ CaptureFraming::Cropped,
+ )
+ }
+ };
+ let retained = crop.remaining(native)?;
+ let expected = match framing {
+ CaptureFraming::FullFrame => native,
+ CaptureFraming::Cropped => {
+ for (key, expected) in [("imageWidth", retained[0]), ("imageHeight", retained[1])] {
+ let actual = plug
+ .pointer(&format!("/status/signal/pp/{key}"))
+ .and_then(serde_json::Value::as_f64)
+ .ok_or("Applied image dimensions unavailable")?;
+ if (actual - expected).abs() > 1.0 {
+ return Err(
+ "Input crop has not settled; waiting for matching image dimensions".into(),
+ );
+ }
+ }
+ retained
+ }
+ };
+ if image_size.contains(&0) {
+ return Err("Empty capture image".into());
+ }
+ let longest = usize::from(expected[1] > expected[0]);
+ let scale = image_size[longest] as f64 / expected[longest];
+ if (0..2).any(|axis| (image_size[axis] as f64 - expected[axis] * scale).abs() > 1.1) {
+ return Err("Capture dimensions do not match the applied input crop".into());
+ }
+ Ok(CaptureGeometry {
+ native,
+ crop,
+ framing,
+ })
+}
+
/// A single on-demand GET; no routing, capture-library or device-setting writes.
pub fn capture(host: &str, input: u32) -> Result, String> {
capture_for(host, crate::device::Profile::Midra4k, input)
@@ -155,6 +277,87 @@ mod tests {
assert!(capture("not a host", 1).is_err());
assert!(capture("127.0.0.1", 0).is_err());
}
+ fn geometry_snapshot(profile: crate::device::Profile, crop: [f64; 4]) -> Snapshot {
+ let [left, right, top, bottom] = crop;
+ let prefix = if profile == crate::device::Profile::Aquilon6 {
+ "IN"
+ } else {
+ "INPUT"
+ };
+ Snapshot {
+ profile,
+ identity: "capture geometry fixture".into(),
+ screens: vec![],
+ raw: serde_json::json!({"device":{"inputList":{"items":{format!("{prefix}_6"):{
+ "status":{"pp":{"isAvailable":true,"plug":"1"}},
+ "plugList":{"items":{"1":{
+ "control":{"pp":{"enableCropFinder":false}},
+ "status":{"signal":{"pp":{"isValid":true,"aspectWidth":1920,"aspectHeight":1080,"imageWidth":1920.-left-right,"imageHeight":1080.-top-bottom}}},
+ "settings":{"cropping":{
+ "control":{"pp":{"left":left,"right":right,"top":top,"bottom":bottom,"predefined":"NONE"}},
+ "status":{"pp":{"left":left,"right":right,"top":top,"bottom":bottom}}
+ }}
+ }}}
+ }}}}}),
+ }
+ }
+ #[test]
+ fn midra_capture_uses_retained_dimensions_including_portrait_and_pixel_rounding() {
+ use crate::device::Profile;
+ for (crop, size) in [
+ ([0.; 4], [512, 288]),
+ ([1157., 0., 0., 0.], [361, 512]),
+ ([279., 0., 0., 338.], [512, 231]),
+ ] {
+ let mut snapshot = geometry_snapshot(Profile::Midra4k, crop);
+ // Actual Eikos 4K state has no cropping/status subtree.
+ snapshot
+ .raw
+ .pointer_mut("/device/inputList/items/INPUT_6/plugList/items/1/settings/cropping")
+ .unwrap()
+ .as_object_mut()
+ .unwrap()
+ .remove("status");
+ let geometry = capture_geometry(&snapshot, 6, size).unwrap();
+ assert_eq!(geometry.framing, CaptureFraming::Cropped);
+ assert_eq!(geometry.native, [1920., 1080.]);
+ assert_eq!(geometry.crop.left, crop[0]);
+ }
+ }
+ #[test]
+ fn aquilon_capture_keeps_full_frame_coordinates_and_applied_status() {
+ let mut snapshot =
+ geometry_snapshot(crate::device::Profile::Aquilon6, [480., 480., 270., 270.]);
+ // Pending controls do not describe the captured pixels.
+ snapshot.raw["device"]["inputList"]["items"]["IN_6"]["plugList"]["items"]["1"]["settings"]
+ ["cropping"]["control"]["pp"]["left"] = serde_json::json!(0);
+ let geometry = capture_geometry(&snapshot, 6, [512, 288]).unwrap();
+ assert_eq!(geometry.framing, CaptureFraming::FullFrame);
+ assert_eq!(geometry.crop.left, 480.);
+ assert!(capture_geometry(&snapshot, 6, [361, 512]).is_err());
+ }
+ #[test]
+ fn capture_geometry_rejects_unsettled_crop_missing_edges_finder_and_stale_image() {
+ let snapshot = geometry_snapshot(crate::device::Profile::Midra4k, [1157., 0., 0., 0.]);
+ assert!(capture_geometry(&snapshot, 6, [512, 288]).is_err());
+ assert!(capture_geometry(&snapshot, 6, [0, 512]).is_err());
+ for (path, value) in [
+ ("status/signal/pp/imageWidth", serde_json::json!(1920)),
+ ("status/signal/pp/isValid", serde_json::json!(false)),
+ ("settings/cropping/control/pp/left", serde_json::Value::Null),
+ ("control/pp/enableCropFinder", serde_json::json!(true)),
+ ] {
+ let mut changed = snapshot.clone();
+ *changed
+ .raw
+ .pointer_mut(&format!(
+ "/device/inputList/items/INPUT_6/plugList/items/1/{path}"
+ ))
+ .unwrap() = value;
+ assert!(capture_geometry(&changed, 6, [361, 512]).is_err(), "{path}");
+ }
+ }
+
#[test]
fn input_choices_use_available_hardware_and_current_plug_signal() {
let snapshot = Snapshot {
diff --git a/crates/canvas-pilot/src/inputs_window.rs b/crates/canvas-pilot/src/inputs_window.rs
index 2b97e94..06cfad9 100644
--- a/crates/canvas-pilot/src/inputs_window.rs
+++ b/crates/canvas-pilot/src/inputs_window.rs
@@ -10,33 +10,38 @@ use std::collections::BTreeMap;
type Values = BTreeMap;
type CropDrag = (Crop, Pos2, [i8; 2], Values);
type SendJob = std::sync::mpsc::Receiver>;
-#[derive(Clone, Copy, Debug)]
-pub(super) struct CaptureGeometry {
- pub native: [f64; 2],
- pub crop: Crop,
-}
-impl CaptureGeometry {
- pub fn rectangles(self, full: Rect, native: [f64; 2]) -> Option<(Rect, Rect)> {
- if self.native != native || self.crop.remaining(native).is_err() {
- return None;
- }
- let uv = Rect::from_min_max(
- Pos2::new(
- (self.crop.left / native[0]) as f32,
- (self.crop.top / native[1]) as f32,
- ),
- Pos2::new(
- (1. - self.crop.right / native[0]) as f32,
- (1. - self.crop.bottom / native[1]) as f32,
- ),
- );
- let rect = Rect::from_min_max(
- full.min + uv.min.to_vec2() * full.size(),
- full.min + uv.max.to_vec2() * full.size(),
- );
- Some((rect, uv))
+pub(super) use canvas_pilot::device_capture::CaptureGeometry;
+fn capture_rectangles(
+ geometry: CaptureGeometry,
+ full: Rect,
+ native: [f64; 2],
+) -> Option<(Rect, Rect)> {
+ if geometry.native != native || geometry.crop.remaining(native).is_err() {
+ return None;
}
+ let region = Rect::from_min_max(
+ Pos2::new(
+ (geometry.crop.left / native[0]) as f32,
+ (geometry.crop.top / native[1]) as f32,
+ ),
+ Pos2::new(
+ (1. - geometry.crop.right / native[0]) as f32,
+ (1. - geometry.crop.bottom / native[1]) as f32,
+ ),
+ );
+ let rect = Rect::from_min_max(
+ full.min + region.min.to_vec2() * full.size(),
+ full.min + region.max.to_vec2() * full.size(),
+ );
+ let uv = match geometry.framing {
+ canvas_pilot::device_capture::CaptureFraming::FullFrame => region,
+ canvas_pilot::device_capture::CaptureFraming::Cropped => {
+ Rect::from_min_max(Pos2::ZERO, Pos2::new(1., 1.))
+ }
+ };
+ Some((rect, uv))
}
+
#[derive(Default)]
pub(super) struct InputsWindow {
pub open: bool,
@@ -440,7 +445,7 @@ fn crop_editor(
content_painter.set_opacity(1.0);
super::format_ui::paint_pattern_clipped(&content_painter, full, source, Crop::default(), full);
if let Some((texture, geometry)) = preview
- && let Some((known, uv)) = geometry.rectangles(full, native)
+ && let Some((known, uv)) = capture_rectangles(geometry, full, native)
{
content_painter.image(texture, known, uv, Color32::WHITE);
}
@@ -558,6 +563,7 @@ mod tests {
Default::default(),
);
let geometry = CaptureGeometry {
+ framing: canvas_pilot::device_capture::CaptureFraming::FullFrame,
native: [1920., 1080.],
crop: Crop {
left: 480.,
@@ -725,6 +731,7 @@ mod tests {
#[test]
fn captured_pixels_stay_in_original_source_region_when_crop_expands() {
let geometry = CaptureGeometry {
+ framing: canvas_pilot::device_capture::CaptureFraming::FullFrame,
native: [1920., 1080.],
crop: Crop {
left: 480.,
@@ -734,7 +741,7 @@ mod tests {
},
};
let full = Rect::from_min_size(Pos2::new(10., 20.), Vec2::new(192., 108.));
- let (known, uv) = geometry.rectangles(full, [1920., 1080.]).unwrap();
+ let (known, uv) = capture_rectangles(geometry, full, [1920., 1080.]).unwrap();
assert_eq!(
known,
Rect::from_min_size(Pos2::new(58., 47.), Vec2::new(96., 54.))
@@ -743,9 +750,24 @@ mod tests {
uv,
Rect::from_min_max(Pos2::new(0.25, 0.25), Pos2::new(0.75, 0.75))
);
- assert!(geometry.rectangles(full, [1280., 720.]).is_none());
+ let cropped = CaptureGeometry {
+ framing: canvas_pilot::device_capture::CaptureFraming::Cropped,
+ ..geometry
+ };
+ let (cropped_rect, cropped_uv) = capture_rectangles(cropped, full, [1920., 1080.]).unwrap();
+ assert_eq!(cropped_rect, known);
+ assert_eq!(
+ cropped_uv,
+ Rect::from_min_max(Pos2::ZERO, Pos2::new(1., 1.))
+ );
+ assert!(capture_rectangles(geometry, full, [1280., 720.]).is_none());
// Mapping is fixed at capture time, independent of the editable crop box.
- assert_eq!(geometry.rectangles(full, [1920., 1080.]).unwrap().0, known);
+ assert_eq!(
+ capture_rectangles(geometry, full, [1920., 1080.])
+ .unwrap()
+ .0,
+ known
+ );
}
fn input_app() -> Editor {
let mut app = Editor::default();
diff --git a/docs/canvas-pilot/changelog.md b/docs/canvas-pilot/changelog.md
index 0b1cdf6..999ea20 100644
--- a/docs/canvas-pilot/changelog.md
+++ b/docs/canvas-pilot/changelog.md
@@ -4,6 +4,14 @@
## Unreleased
+### v0.9.72
+
+- Fix input-crop capture on Midra: its PNG contains only the retained crop, unlike
+ Aquilon’s full-frame snapshot. Place it in the applied crop rectangle without
+ cropping twice, leaving unknown pixels as the sizing grid.
+- Validate capture dimensions and before/after device state; read-only checks on
+ Eikos 4K 3.3.10 covered uncropped, portrait-cropped and asymmetrically cropped input.
+
### v0.9.71
- Load a local reference picture into a layer’s input preview for offline crop,
diff --git a/docs/canvas-pilot/guide/device.md b/docs/canvas-pilot/guide/device.md
index 7b9e69c..544427a 100644
--- a/docs/canvas-pilot/guide/device.md
+++ b/docs/canvas-pilot/guide/device.md
@@ -267,3 +267,16 @@ replaced; they are not saved in projects or exchange files. Input switching requ
a valid signal with native dimensions matching the editor source format and no
input crop/aspect correction. Unsupported combinations stop preparation with an
error. Sending to Program can visibly change the live source.
+
+
+### Live picture in the input crop editor
+
+In **Input settings**, **Capture input (live)** places the captured picture inside
+its **applied device crop**. Unknown areas keep the sizing grid. Midra returns an
+already-cropped picture; Aquilon retains the full frame with blanked edges. Canvas
+Pilot handles these separately so the crop is not applied twice.
+
+Moving the draft crop does not move the captured picture. After **Send changes**,
+the preview refreshes against device readback. A missing signal or inconsistent
+capture geometry keeps the grid until a matching capture arrives. Disable
+**Crop Finder** in WebRCS when using this preview.
diff --git a/docs/canvas-pilot/guide/formats-and-crop.md b/docs/canvas-pilot/guide/formats-and-crop.md
index e8b9a10..cb1e1e5 100644
--- a/docs/canvas-pilot/guide/formats-and-crop.md
+++ b/docs/canvas-pilot/guide/formats-and-crop.md
@@ -347,8 +347,8 @@ validation and verified readback.
stretches those pixels. After Send, the old capture is cleared while settings
are applied and verified; **Refreshing capture…** remains until a new capture
arrives. Unverified capture geometry shows the grid rather than a distorted image.
- Aquilon captures are supported for the verified full-frame thumbnail geometry;
- no raw/pre-crop endpoint is confirmed.
+ Midra’s already-cropped PNG and Aquilon’s full-frame thumbnail are handled
+ separately, avoiding a second crop. No raw/pre-crop endpoint is confirmed.
Drafts are session-only and are not included in projects or exports. Switching
diff --git a/docs/interfaces/midra-device-send.md b/docs/interfaces/midra-device-send.md
index e352085..d491d9a 100644
--- a/docs/interfaces/midra-device-send.md
+++ b/docs/interfaces/midra-device-send.md
@@ -324,13 +324,18 @@ opted-in layer/dialog consumers for the same input. It never changes input crop
to obtain a raw image. Sends clear the preview/key and suspend capture scheduling
until apply/readback completes; late results from invalidated requests are ignored.
The input crop editor uses the existing sizing pattern behind available pixels.
-For Aquilon, fresh reads bracket capture; stable crop/aspect/plug state and a matching
-thumbnail frame ratio are required for compositing. The image is clipped to the
-captured status-crop region using corresponding full-frame UV coordinates; it is
-never stretched to a newly edited crop. Unknown pixels retain the pattern. Other
-capture geometries show only the grid (no unverified compositing). No raw-capture contract is claimed. Aquilon Cmax 6.2.79 emulator testing showed
-blanked cropped edges; Pulse 4K 3.3.7 served an unchanged thumbnail. Input drafts
-and captures are not serialized, and existing project/exchange versions are unchanged.
+Fresh reads bracket capture for both adapters; stable crop/aspect/plug state and
+matching image dimensions are required for compositing. Aquilon uses the applied
+status-crop region with corresponding full-frame UV coordinates. Midra uses crop
+controls verified against applied image dimensions and places the entire cropped
+PNG within that region. Neither is stretched to a newly edited draft crop.
+Unknown pixels retain the pattern. See the [capture framing contract and Eikos
+4K read-only checks](midra-input-preview.md#input-settings-crop-capture-framing).
+No raw-capture contract is claimed. Aquilon Cmax 6.2.79 emulator testing showed
+blanked cropped edges; an earlier Pulse 4K 3.3.7 emulator served an unchanged
+thumbnail, which must not pass validation if its dimensions conflict with crop
+readback. Input drafts and captures are not serialized, and existing
+project/exchange versions are unchanged.
Manual diagnostic: `cargo run -p canvas-pilot --example check_device_inputs -- HOST`
changes Input 1 crop and restores the original values. Run only against an expressly
diff --git a/docs/interfaces/midra-input-preview.md b/docs/interfaces/midra-input-preview.md
index 05dabb4..6e5df80 100644
--- a/docs/interfaces/midra-input-preview.md
+++ b/docs/interfaces/midra-input-preview.md
@@ -154,3 +154,30 @@ disables automatic capture and Follow input, and rejects late capture results.
The project preview representation retains the original image bytes (see the
[project contract](canvas-pilot.md)). The layer inspector lists these
and captured previews under **Input reference pictures**, below fixed references.
+
+
+## Input-settings crop capture framing
+
+The input-settings editor reads input state before and after capture, rejecting
+changed signal, plug or preprocessing. Capture geometry is resolved in
+`device_capture::capture_geometry`, separately from the editable draft:
+
+- **Midra:** source dimensions are `status/signal/pp/aspectWidth` and
+ `aspectHeight`; crop edges come from `settings/cropping/control/pp`. The applied
+ `imageWidth`/`imageHeight` must match the retained rectangle. The PNG contains
+ only that rectangle, so its full texture is placed at the applied crop position.
+- **Aquilon:** source dimensions and `settings/cropping/status/pp` describe a
+ full-source PNG with blanked crop edges. Both placement and texture coordinates
+ use the retained rectangle; pending control edits are not applied to the image.
+
+Allow one pixel of thumbnail rounding. Invalid signal, unavailable crop values,
+unsettled dimensions, Crop Finder or a mismatched image keep the sizing grid.
+Draft edits do not move or recrop captured pixels. These are transient rendering
+values, not project fields or device writes.
+
+Read-only Eikos 4K 3.3.10 checks on 2026-11-18 observed a 1920×1080 source with
+an uncropped 512×288 PNG; a left crop of 1157 produced a 763×1080 retained region
+and 361×512 PNG; left 279/bottom 338 produced 1641×742 and 512×231 respectively.
+Only numeric framing observations are recorded; source images are not fixtures.
+Run `cargo run --example read_input_capture -- DEVICE_IP INPUT_NUMBER` for an
+explicit read-only before/capture/after check.