dtourolle/DarkRoom
1
0
Fork 0
Code Issues 39 Pull Requests Actions Packages Projects Releases 20 Wiki Activity

Store what the model found, so a reopened photograph keeps its masks

Browse Source 
A subject or category layer was written to the sidecar as identity alone —
which run, which instance, which category — on the reasoning that the pixels
are reproducible by running the same model over the same image. They are, but
only by *running the model*, and nothing runs one except a photographer
pressing "find subjects". So on every path that did not already have a run in
memory the layer resolved to no coverage, `MaskPass::render` logged "has no
distance field; skipping", and the adjustment was silently absent:

  - reopening an edited photograph rendered it without its local adjustments,
    and then saved that state back on the way out;
  - a batch export from the grid could not have them at any point, because
    `render_from_library` opens a session, applies a version and renders, and
    there is no model anywhere on that path. Three hundred files written
    without the edits their photographer made, over a log warning.

Neither failure announced itself. The generated shader still emits the layer's
block and the empty placeholder multiplies it by zero, so the result is a
well-formed frame that is simply missing an edit — `mask_is_stale` already
named the state and called it "not stale, just unrenderable".

The coverage now travels in the file, as one `coverage = w h levels payload`
line at the end of the layer's block.

Two levels, and that is not a compromise. The model hands out a byte per pixel
but `Shaped::build` measures its distance field from `coverage >= 128` and
throws the shoulder away on the first line; everything soft about the rendered
edge comes afterwards from the layer's feather and falloff, which are read off
the distance. So one bit per pixel is not an approximation of what the model
said — it is exactly the part of it that reaches a pixel, and the stored mask
renders the identical frame. Storing all 256 levels would have stored 1.7 MB
of bilinear interpolation to reconstruct a predicate, and would not even have
compressed: a model mask is a bilinear upsample of a coarse grid, so almost no
two adjacent bytes are alike. Measured on a simulated sky and a simulated
figure at 1600x1067, against 1.71 MB raw: 4.0 kB and 6.5 kB at two levels,
46 kB and 76 kB at sixteen, 835 kB and 1.43 MB at all 256. The level count is
still written into the line, so a later build that finds a use for the
shoulder can write sixteen and this one will read them rather than misreading
a stream of lengths as pairs.

The coder is hand-rolled — run-length pairs in a base-64 varint — because
`dr-pipeline` links nothing, which is the property that lets the descriptor
and codegen logic be tested without a device. `flate2` would have been fewer
lines and a dependency in the one crate that has none.

Where it lives matters more than how it is coded. The raster sits on
`MaskLayer` beside the source, not inside `MaskSource::Subject`: the source is
*identity*, which is what makes it diff as a handful of numbers and merge per
field under FR-NC-9, and a raster in there would have given the merge a binary
blob to arbitrate. It takes no part in `MaskLayer`'s equality for the same
reason — a device that has run the model and one that has not hold the same
edit, and counting the difference would raise a conflict over a cache and let
`remote_wins` answer it by discarding the only copy of the pixels.

Encoding happens in `masks_for_storage`, on the save path, rather than in
`ensure_subject_fields` where every coverage already funnels through.
`ensure_subject_fields` runs on a drag — dilating a mask with a compound
morphology rebuilds the field every frame — and encoding a megapixel raster
per frame is the kind of work NFR-P5 exists to keep off a gesture. Saving
happens once, when the photograph stops being the open one, and already costs
a network round trip.

Version skew holds both ways. A file with no `coverage` line reads exactly as
it did before, which is a layer that needs the model run; an unreadable one
costs the pixels and not the layer, because the layer is the edit and the
raster is a cache of it. An old build reading a new file drops the key it does
not understand, which costs a model run and no work. And a payload that will
not compress is refused rather than truncated: a checkerboard would encode to
twice the raster it came from, so past 64 kB nothing is stored and the
behaviour falls back to what it was — half a mask would render as a mask that
is confidently wrong, which is the failure that tells nobody.
This commit is contained in:
dtourolle
2026-08-30 21:28:54 +02:00
parent 6acc98baad
commit 89c4ff1820
9 changed files with 1688 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ui/dr-ui/src/develop.rs
+518 -48
View File
@@ -9,6 +9,7 @@
//! declared [`ParamKind`], not from which parameter it is (ARCH §4.3), so a
//! new operation appears in the panel with no change here (FR-DEV-3c).
use std::borrow::Cow;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
@@ -1868,63 +1869,172 @@ impl DevelopSession {
h
}
/// Rebuild the distance fields if anything they depend on moved.
fn ensure_subject_fields(&mut self, ctx: &GpuContext) {
/// One layer's coverage: what the model says now, or what the sidecar
/// remembered it saying.
///
/// **The model first, always.** It is the live answer, it is the only one
/// that can respond to the refine control, and a run in this sitting is by
/// definition newer than anything a file was holding.
///
/// The fallback is the point of the stored raster. A photograph reopened,
/// and a batch export from the grid — which opens a session, applies a
/// version and never runs a model at all — have no segmentation to ask, so
/// before this they resolved every subject and category layer to nothing
/// and wrote out a file missing the local adjustments, with a line in the
/// log as the only sign. See [`dr_pipeline::coverage`].
///
/// `None` for every other source: a gradient and a brush are rasterised
/// from their own geometry and have no coverage to fetch, and the caller
/// gives them a placeholder field so the slot indices still line up.
fn layer_coverage<'a>(
&'a self,
layer: &'a dr_pipeline::mask::MaskLayer,
width: usize,
height: usize,
) -> Option<Cow<'a, [u8]>> {
use dr_pipeline::mask::MaskSource;
let live = self
.segmentation
.as_ref()
.and_then(|seg| match &layer.source {
MaskSource::Category { name, .. } => seg.category_mask_at(name, layer.refine),
MaskSource::Subject { index, .. } => {
seg.instance_mask(*index as usize).map(Cow::Borrowed)
}
_ => None,
});
if live.is_some() {
return live;
}
match layer.source {
// Resampled where it was written against a different proxy edge;
// in the ordinary case the sizes match and this is the decode.
MaskSource::Subject { .. } | MaskSource::Category { .. } => layer
.coverage
.as_ref()
.map(|stored| Cow::Owned(stored.decode_at(width, height))),
_ => None,
}
}
/// TRACES: FR-CAT-8 | FR-DEV-3
/// The mask stack as it should be written to a sidecar.
///
/// The stack the graph holds, with each model layer's coverage brought up
/// to what the segmentation now says it is. That raster is what lets the
/// *next* opening of this photograph render the layer without a model run
/// — the whole of [`dr_pipeline::coverage`]'s reason to exist.
///
/// # Why here, and not where the field is built
///
/// `ensure_subject_fields` is the tempting place: it is the one funnel
/// every coverage passes through, so recording it there would catch every
/// route automatically. But it runs on a *drag* — dilating a mask with a
/// compound morphology rebuilds the field every frame — and encoding a
/// megapixel raster per frame is exactly the kind of work NFR-P5 is about.
///
/// Saving happens when the photograph stops being the open one, once, and
/// already costs a network round trip. So the encoding is done here, where
/// nothing is waiting on it, and the session's own rendering goes on
/// reading the model directly.
///
/// Returns the stack by value rather than mutating: the caller is
/// serialising, not editing, and a graph that quietly gained a field on
/// the way past would be a mutation nobody asked for and undo would not
/// know about.
pub fn masks_for_storage(&self) -> dr_pipeline::mask::MaskStack {
use dr_pipeline::coverage::{Coverage, RENDERED_LEVELS};
use dr_pipeline::mask::MaskSource;
let mut stack = self.graph.masks().clone();
let Some(seg) = self.segmentation.as_ref() else {
// No model has run this sitting, so whatever the layers arrived
// holding is still the best answer anyone has. Handing the stack
// back untouched is what stops a photograph that was opened,
// glanced at and closed from losing the coverage its own sidecar
// gave it.
return stack;
};
let (pw, ph) = seg.proxy_size();
for layer in stack.layers_mut() {
let values = match &layer.source {
MaskSource::Category { name, .. } => seg.category_mask_at(name, layer.refine),
MaskSource::Subject { index, .. } => {
seg.instance_mask(*index as usize).map(Cow::Borrowed)
}
// Nothing else has a model behind it. Left alone rather than
// cleared, so a hand-written file's key survives a round trip
// even though nothing samples it.
_ => continue,
};
// The layer names something this run does not contain — a stale
// index, a category the scene model no longer offers. Keeping what
// was stored is right: it is a mask that was once correct, and the
// panel is already telling the user the layer is stale.
let Some(values) = values else { continue };
// `None` from the encoder means "will not fit in a sidecar", and
// the stored raster is then cleared rather than left standing. It
// would describe the layer at some earlier refine, and a mask of
// the wrong shape presented as authoritative is worse than the
// honest state, which is that this one needs the model run.
layer.coverage = Coverage::encode(&values, pw, ph, RENDERED_LEVELS).map(Arc::new);
}
stack
}
/// Rebuild the distance fields if anything they depend on moved.
fn ensure_subject_fields(&mut self, ctx: &GpuContext) {
let key = self.subject_signature();
if key == self.subject_key && self.subjects.is_some() {
return;
}
let Some(seg) = self.segmentation.as_ref() else {
return;
// The proxy the fields are measured in: the segmentation's own where
// one has been run, and otherwise the size the mask array is
// rasterised at. `mask_raster_size` derives that from the photograph
// rather than from a segmentation for exactly this case, and the two
// are the same number by construction — see there.
let (pw, ph) = match self.segmentation.as_ref() {
Some(seg) => seg.proxy_size(),
None => {
let (w, h) = self.mask_raster_size();
(w as usize, h as usize)
}
};
let (pw, ph) = seg.proxy_size();
// In `active()` order, because that is the order the rasteriser walks
// and the order it indexes these by.
let mut fields: Vec<Vec<f32>> = Vec::new();
for layer in self.graph.masks().active() {
let field = match &layer.source {
MaskSource::Category { name, .. } => seg
.category_mask_at(name, layer.refine)
.map(|coverage| {
dr_segment::Shaped::build(
&coverage,
pw,
ph,
128,
morphology_for(layer.morphology),
layer.morph_radius * pw.min(ph) as f32,
)
.distance
})
// Full size, never `unwrap_or_default`: an empty vec is a
// wrong-sized field, `SubjectMasks::upload` rejects the
// whole batch on one, and every other layer in the stack
// then loses its mask too. One stale name should cost one
// layer, not all of them.
.unwrap_or_else(|| vec![-1.0; pw * ph]),
MaskSource::Subject { index, .. } => seg
.instance_mask(*index as usize)
.map(|coverage| {
dr_segment::Shaped::build(
coverage,
pw,
ph,
128,
morphology_for(layer.morphology),
// Radii are fractions of the shorter edge; the
// field is in proxy pixels.
layer.morph_radius * pw.min(ph) as f32,
)
.distance
})
.unwrap_or_else(|| vec![-1.0; pw * ph]),
// A placeholder of the right size, so the slot indices line up
// with `active()` whatever mix of sources the stack holds.
_ => vec![-1.0; pw * ph],
let field = match self.layer_coverage(layer, pw, ph) {
Some(coverage) => {
dr_segment::Shaped::build(
&coverage,
pw,
ph,
128,
morphology_for(layer.morphology),
// Radii are fractions of the shorter edge; the field
// is in proxy pixels.
layer.morph_radius * pw.min(ph) as f32,
)
.distance
}
// Full size, never `unwrap_or_default`: an empty vec is a
// wrong-sized field, `SubjectMasks::upload` rejects the whole
// batch on one, and every other layer in the stack then loses
// its mask too. One stale name should cost one layer, not all
// of them.
//
// It is also the placeholder a gradient or a brush gets, so
// the slot indices line up with `active()` whatever mix of
// sources the stack holds.
None => vec![-1.0; pw * ph],
};
fields.push(field);
}
@@ -2978,10 +3088,11 @@ impl DevelopSession {
};
match self.segmentation.as_ref() {
Some(seg) => layer.is_stale(seg.signature()),
// Nothing loaded to compare against. Not stale, just unrenderable
// — the distinction matters because "stale" invites the user to
// recompute the selection and this only needs the segmentation
// running.
// Nothing loaded to compare against, and nothing to report: the
// layer renders from the raster its sidecar stored (see
// `layer_coverage`). It was already not *stale* before that — the
// word invites the user to recompute a selection that is fine —
// and now it is not unrenderable either.
None => false,
}
}
@@ -4757,6 +4868,365 @@ mod tests {
);
}
// ----------------------------------------------------------------------
// Stored coverage (dr_pipeline::coverage)
// ----------------------------------------------------------------------
//
// A subject or category layer is stored in the sidecar as identity — which
// run, which instance, which category — and identity resolves to pixels
// only while that run is in memory. So reopening an edited photograph
// dropped every model-backed local adjustment, and a batch export, which
// never runs a model at all, could not have them at any point. Both
// failures were silent: the shader still emitted the layer's block, the
// placeholder multiplied it by zero, and the result was a well-formed
// frame with the adjustment simply absent.
/// A stored edit holding one subject layer over the left half of the
/// frame, as a session that *had* run the model would have written it.
///
/// `stored` is the whole variable: with the raster, this is a sidecar
/// written by a build that persists coverage; without it, one written
/// before that existed. Everything else about the two is identical, which
/// is what makes the pair of tests below a measurement rather than an
/// assertion about two different edits.
fn version_with_a_subject(proxy: (u32, u32), stored: bool) -> dr_pipeline::Version {
use dr_pipeline::coverage::{Coverage, RENDERED_LEVELS};
let (pw, ph) = (proxy.0 as usize, proxy.1 as usize);
let mut values = vec![0u8; pw * ph];
for y in 0..ph {
for x in 0..pw / 2 {
values[y * pw + x] = 255;
}
}
let mut layer = MaskLayer::new(
"m1",
MaskSource::Subject {
signature: 0xfeed,
index: 0,
class: "dog".into(),
score: 0.9,
},
);
layer.set_param("exposure", ParamId("exposure"), 2.0);
if stored {
layer.coverage = Some(Arc::new(
Coverage::encode(&values, pw, ph, RENDERED_LEVELS).expect("a half frame encodes"),
));
}
let mut graph = EditGraph::default_chain();
graph.masks_mut().push(layer);
dr_pipeline::Version::from_graph("default", "Default", &graph)
}
/// A flat grey session with nothing segmented, and its render.
fn grey_session(ctx: &GpuContext) -> (DevelopSession, Vec<u8>) {
let rgba: Vec<u8> = (0..64 * 64).flat_map(|_| [128u8, 128, 128, 255]).collect();
let mut session =
DevelopSession::open_rgb(ctx, &rgba, 64, 64, dr_types::Orientation::NORMAL)
.expect("session");
assert!(
!session.has_segmentation(),
"the premise: no model has been run"
);
let before = read_back(ctx, &session.render(64, 64).expect("render"));
(session, before)
}
/// TRACES: FR-DEV-3 | FR-CAT-8
/// Reopening an edited photograph renders its subject mask, with no model.
///
/// This is the failure the stored raster exists for. `apply_version` is
/// exactly what opening a photograph from the library does with the
/// sidecar it fetched, and until the coverage went into the file the layer
/// resolved to nothing every time.
#[test]
fn a_stored_subject_mask_renders_with_no_model_run() {
let Some(ctx) = headless() else { return };
let (mut session, before) = grey_session(&ctx);
let proxy = session.mask_raster_size();
session.apply_version(&version_with_a_subject(proxy, true));
let after = read_back(&ctx, &session.render(64, 64).expect("render"));
let at = |px: &[u8], x: usize, y: usize| px[(y * 64 + x) * 4];
assert!(
at(&after, 16, 32) > at(&before, 16, 32) + 20,
"the covered half must brighten: {} against {}",
at(&after, 16, 32),
at(&before, 16, 32)
);
// And only that half. A mask that failed the other way — covering
// everything — would pass the assertion above and is the louder bug.
assert_eq!(
at(&after, 56, 32),
at(&before, 56, 32),
"the uncovered half must not move"
);
}
/// The control for the test above: the same edit with the raster left out
/// is the behaviour every build had before this, which is no mask at all.
///
/// Worth pinning down in both directions. It is what a sidecar written by
/// an older build looks like, and reading one must go on being harmless —
/// the layer needs the model run, exactly as it always did, rather than
/// rendering as an empty mask or as the whole frame.
#[test]
fn a_subject_mask_with_no_stored_coverage_still_needs_the_model() {
let Some(ctx) = headless() else { return };
let (mut session, before) = grey_session(&ctx);
let proxy = session.mask_raster_size();
session.apply_version(&version_with_a_subject(proxy, false));
let after = read_back(&ctx, &session.render(64, 64).expect("render"));
assert_eq!(
after, before,
"with no coverage the layer contributes nothing"
);
}
/// TRACES: FR-EXP-9 | FR-CAT-8
/// A batch export renders the stored mask too.
///
/// `export::render_from_library` fetches the RAW and the sidecar, opens a
/// session, applies the version and calls `render_for_export` — and it
/// runs no model on the way, so before the coverage was stored a batch
/// wrote out files with the photographer's local adjustments missing, over
/// a log warning nobody was reading. These two lines are that path with
/// the fetch taken out.
#[test]
fn an_export_renders_a_stored_subject_mask() {
let Some(ctx) = headless() else { return };
let rgba: Vec<u8> = (0..64 * 64).flat_map(|_| [128u8, 128, 128, 255]).collect();
let mut session =
DevelopSession::open_rgb(&ctx, &rgba, 64, 64, dr_types::Orientation::NORMAL)
.expect("session");
let plain = session
.render_for_export(dr_types::ColourSpace::Srgb)
.expect("export");
let proxy = session.mask_raster_size();
session.apply_version(&version_with_a_subject(proxy, true));
let masked = session
.render_for_export(dr_types::ColourSpace::Srgb)
.expect("export");
let at = |f: &dr_export::Frame, x: usize, y: usize| f.rgba[(y * 64 + x) * 4];
assert!(
at(&masked, 16, 32) > at(&plain, 16, 32) + 20,
"the exported file must carry the local adjustment: {} against {}",
at(&masked, 16, 32),
at(&plain, 16, 32)
);
assert_eq!(
at(&masked, 56, 32),
at(&plain, 56, 32),
"and only where the mask covers"
);
}
/// What a session hands the sidecar writer when no model has run.
///
/// Untouched, and that is the whole of it: a photograph opened, looked at
/// and closed must not have the coverage its own sidecar gave it stripped
/// out on the way past. Saving is automatic, so a stack that lost the
/// raster here would lose it on disk within seconds of being opened.
#[test]
fn saving_without_a_model_keeps_the_coverage_that_was_loaded() {
let Some(ctx) = headless() else { return };
let (mut session, _) = grey_session(&ctx);
let proxy = session.mask_raster_size();
session.apply_version(&version_with_a_subject(proxy, true));
let stored = session.masks_for_storage();
assert_eq!(stored.len(), 1);
assert!(
stored.layers()[0].coverage.is_some(),
"the raster the sidecar gave us must go back to the sidecar"
);
}
/// A session holding a segmentation with one instance over the left half.
///
/// Built rather than detected. What these tests need is coverage of a
/// *known* shape, so that "the stored raster renders what the model's did"
/// is a comparison rather than a hope — and asking a real run what it
/// happened to find in a synthetic frame would make the assertion depend
/// on the weights. `segmented_session` above is the one that runs a model,
/// and it goes on doing so.
fn session_with_a_left_half_subject(ctx: &GpuContext) -> DevelopSession {
let rgba: Vec<u8> = (0..64 * 64).flat_map(|_| [128u8, 128, 128, 255]).collect();
let mut session =
DevelopSession::open_rgb(ctx, &rgba, 64, 64, dr_types::Orientation::NORMAL)
.expect("session");
let (pw, ph) = session.mask_raster_size();
let (pw, ph) = (pw as usize, ph as usize);
let mut mask = vec![0u8; pw * ph];
for y in 0..ph {
for x in 0..pw / 2 {
mask[y * pw + x] = 255;
}
}
session.segmentation = Some(segmentation::Segmentation::for_test(
vec![segmentation::InstanceSummary {
class_name: "dog".into(),
score: 0.9,
mask,
bbox: (0.0, 0.0, (pw / 2) as f32, ph as f32),
}],
Vec::new(),
0xfeed,
(pw, ph),
));
session.subjects = None;
session.subject_key = 0;
session
}
/// TRACES: FR-DEV-3 | FR-CAT-8
/// The whole claim, end to end: what is stored renders what was rendered.
///
/// A session with a model's coverage in hand draws the mask; the stack it
/// hands the sidecar writer goes through the file and into a session with
/// no model at all; and the two frames must be the same. Anything weaker
/// — that the coverage is present, that it round-trips as bytes — would
/// still pass if the raster came back at the wrong scale, upside down, or
/// a threshold out.
#[test]
fn a_stored_mask_renders_exactly_what_the_model_rendered() {
let Some(ctx) = headless() else { return };
let mut live = session_with_a_left_half_subject(&ctx);
let id = live.add_subject_mask(0).expect("a subject layer");
live.graph
.masks_mut()
.get_mut(&id)
.expect("the layer")
.set_param("exposure", ParamId("exposure"), 2.0);
let with_model = read_back(&ctx, &live.render(64, 64).expect("render"));
// Through the sidecar, the way `presets::save_open_edit` does it: the
// graph's own parameters, with the stack that carries the coverage
// substituted for the one the graph is holding.
let mut version = dr_pipeline::Version::from_graph("default", "Default", &live.graph);
version.masks = live.masks_for_storage();
let mut sidecar = dr_pipeline::Sidecar::new();
sidecar.put(version);
let text = sidecar.to_text();
let parsed = dr_pipeline::Sidecar::parse(&text).expect("reparse");
let rgba: Vec<u8> = (0..64 * 64).flat_map(|_| [128u8, 128, 128, 255]).collect();
let mut reopened =
DevelopSession::open_rgb(&ctx, &rgba, 64, 64, dr_types::Orientation::NORMAL)
.expect("session");
assert!(
!reopened.has_segmentation(),
"the point: nothing has run a model in this session"
);
reopened.apply_version(parsed.default_version().expect("a version"));
let from_the_file = read_back(&ctx, &reopened.render(64, 64).expect("render"));
assert_eq!(
from_the_file, with_model,
"the reopened frame must be the frame the model produced"
);
// And that both are actually a mask rather than both being nothing.
let at = |px: &[u8], x: usize| px[(32 * 64 + x) * 4];
assert!(
at(&with_model, 16) > at(&with_model, 56) + 20,
"the premise: the live render really is masked ({} against {})",
at(&with_model, 16),
at(&with_model, 56)
);
}
/// And what a session hands over when a model *has* run: the coverage
/// folded in, at the proxy the distance field is measured in.
///
/// The encoding happens here rather than where the field is built because
/// that runs on a drag — see `masks_for_storage`.
#[test]
fn saving_after_a_model_run_folds_the_coverage_in() {
let Some(ctx) = headless() else { return };
let mut session = session_with_a_left_half_subject(&ctx);
let id = session.add_subject_mask(0).expect("a subject layer");
let stored = session.masks_for_storage();
let coverage = stored
.get(&id)
.expect("the layer is in the stack")
.coverage
.as_ref()
.expect("a subject the model found has coverage to store");
let (pw, ph) = session.mask_raster_size();
assert_eq!(
(coverage.width(), coverage.height()),
(pw as usize, ph as usize)
);
let decoded = coverage.decode();
assert_eq!(decoded[32 * pw as usize + 8], 255, "inside the subject");
assert_eq!(decoded[32 * pw as usize + 56], 0, "outside it");
assert!(
coverage.encoded_len() < 512,
"a half-frame mask is a handful of runs, not {} bytes",
coverage.encoded_len()
);
}
/// A layer whose coverage came from the file must still take the model's
/// once a model runs — the live answer is the only one that responds to
/// the refine control, and a run in this sitting is newer than a file.
#[test]
fn a_model_run_takes_precedence_over_what_was_stored() {
let Some(ctx) = headless() else { return };
let mut session = session_with_a_left_half_subject(&ctx);
// Stored coverage saying the *right* half, against a segmentation
// saying the left.
let (pw, ph) = session.mask_raster_size();
let (pw, ph) = (pw as usize, ph as usize);
let mut mirrored = vec![0u8; pw * ph];
for y in 0..ph {
for x in pw / 2..pw {
mirrored[y * pw + x] = 255;
}
}
let id = session.add_subject_mask(0).expect("a subject layer");
{
let layer = session.graph.masks_mut().get_mut(&id).expect("the layer");
layer.set_param("exposure", ParamId("exposure"), 2.0);
layer.coverage = Some(Arc::new(
dr_pipeline::Coverage::encode(
&mirrored,
pw,
ph,
dr_pipeline::coverage::RENDERED_LEVELS,
)
.expect("encode"),
));
}
let frame = read_back(&ctx, &session.render(64, 64).expect("render"));
let at = |x: usize| frame[(32 * 64 + x) * 4];
assert!(
at(16) > at(56) + 20,
"the model's left half must win over the file's right half: \
{} against {}",
at(16),
at(56)
);
}
/// TRACES: FR-DEV-3
/// Multi-select: one slider, applied to every selected layer.
///