@photivra/engine 2.8.1 → 2.10.0

package/dist/facade/simulate-capture.js

@@ -72,9 +72,10 @@ import { createRollingShutterCaptureExposureSchedule, resolveElectronicRollingSh
 import { calculateCaptureExposureWindows } from "../sensor/exposure-window.js";
 import { calculateSensorSpectralQuadrature } from "../sensor/spectral-quadrature.js";
 import { createDiffractionLimitedPsfProfile } from "../optics/diffraction-psf-profile.js";
+import { registerDiffractionPsfKey } from "../optics/site-diffraction-kernel.js";
 import { createDiffractedPlanarProvider } from "./diffraction-provider.js";
 import { resolveGenericPrimeLens } from "../equipment/generic-prime-lenses.js";
-import { executeEnvironmentSensorPhotoSignal, planEnvironmentSensorPhotoSignal } from "../sensor/environment-photo-signal.js";
+import { calculateChannelElectronsPerRadiance } from "./channel-response.js";
 import { calculateSiteEffectiveSaturationCode } from "../capture/raw-white-level.js";
 import { prepareSensorColorDevelopment } from "../color/sensor-color-development.js";
 import { resolveAntiAliasingSpatialKernel } from "../sensor/optical-stack.js";
@@ -96,6 +97,12 @@ export const SIMULATE_CAPTURE_COST_OPTIONS = Object.freeze(["lens.pupilSampling"
     "lens.diffraction", "sensor.antiAliasing", "sensor.pixelAperture.box", "sensor.temporalSampleCount", "motion.rotation", "motion.shutter.rolling", "output.borderHandling.mirror", "output.region",
     "output.whiteBalance.auto", "output.demosaic.ahd", "output.highlightMode.reconstruct", "output.colorEncoding.wide-gamut", "output.gamutMapping.perceptual",
     "output.format.jpeg", "output.format.png", "output.format.dng"]);
+/**
+ * The options that take the exact-or-fast flag (#395), in the path style of {@link SIMULATE_CAPTURE_COST_OPTIONS}: each accepts
+ * the record form with `fast` and is reported in `diagnostics.fast.applied` when it runs. Every one of them takes the flag,
+ * whether or not it has a fast method yet; one without runs exact and reports `false`.
+ */
+export const SIMULATE_CAPTURE_FAST_OPTIONS = Object.freeze(["lens.diffraction", "sensor.antiAliasing", "sensor.pixelAperture.box", "output.demosaic.ahd"]);
 export const FACADE_EVIDENCE = Object.freeze([Object.freeze({ sourceOrigin: "photivra",
         sourceReference: "photivra:simulate-capture-facade", reuseStatus: "photivra-owned" })]);
 const DEFAULTS = Object.freeze({ camera: "professional", fNumber: 8, shutterSeconds: 1 / 125, iso: 100, compensationStops: 0,
@@ -145,8 +152,52 @@ const AA_MAXIMUM_OFFSET_SITES = 4;
 /** Channel responses kept across calls (`axisChannelResponse`): one entry per distinct sensor, exposure and optics state. */
 const CHANNEL_RESPONSE_CACHE_SIZE = 8;
 const channelResponseCache = new Map();
+/**
+ * #449: diffraction profiles kept across calls, by the JSON of their `createDiffractionLimitedPsfProfile` input (the last
+ * DIFFRACTION_PROFILE_CACHE_SIZE, most recently used last). Every region part and detail tile of one request builds the same
+ * input. The kept record is private: each call gets its own copy, as mutable as a newly built one, so a caller's change
+ * never reaches another call. The copy is made of plain records and arrays (plainDataCopy): the kernel set-up structured-clones
+ * the profile once per spectral node, and in a CPU profile of the 96 × 64 Quality tile that clone took about twice as long
+ * (24 instead of 12 ms per call) on a deep-frozen record or on a structuredClone copy as on a newly built record or this copy.
+ */
+const DIFFRACTION_PROFILE_CACHE_SIZE = 8;
+const diffractionProfileCache = new Map();
+/** A copy of plain data (records, arrays, primitives; typed arrays are sliced), built from ordinary literals. */
+function plainDataCopy(value) {
+    if (Array.isArray(value))
+        return value.map(plainDataCopy);
+    if (ArrayBuffer.isView(value))
+        return value.slice();
+    if (value === null || typeof value !== "object")
+        return value;
+    const copy = {};
+    for (const key of Object.keys(value))
+        copy[key] = plainDataCopy(value[key]);
+    return copy;
+}
+/** The profile of `input` (a pure function of the input record): a copy of the kept one when the same input was built before. */
+function cachedDiffractionProfile(input) {
+    const key = JSON.stringify(input);
+    let kept = diffractionProfileCache.get(key);
+    if (kept)
+        diffractionProfileCache.delete(key);
+    else
+        kept = createDiffractionLimitedPsfProfile(input).value;
+    diffractionProfileCache.set(key, kept);
+    if (diffractionProfileCache.size > DIFFRACTION_PROFILE_CACHE_SIZE)
+        diffractionProfileCache.delete(diffractionProfileCache.keys().next().value);
+    // The same fields in the same order as the built record, frozen at the top level like it; `model` is the frozen constant.
+    return Object.freeze({ ...kept, profile: plainDataCopy(kept.profile), wavelengths: plainDataCopy(kept.wavelengths), quadrature: plainDataCopy(kept.quadrature) });
+}
 /** Default birefringent separation in sites: the two-spot MTF |cos(π·f·d)| then has its first zero at Nyquist, f = 1/(2·pitch). */
 const AA_DEFAULT_SEPARATION_SITES = 1;
+/** #395: the `fast` override of an option record (undefined when absent), which must be a Boolean. */
+function fastOverride(record, path) {
+    const value = record.fast;
+    if (value !== undefined && typeof value !== "boolean")
+        fail(path + ".fast must be true or false.");
+    return value;
+}
 /** Parses `sensor.antiAliasing` into engine point-splitting components (offsets in µm, +x right, +y down). */
 function parseAntiAliasing(value, pitch) {
     requireInputObject(value, "sensor.antiAliasing");
@@ -160,18 +211,18 @@ function parseAntiAliasing(value, pitch) {
         return d;
     };
     if (kind === "four-spot") {
-        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "separationSites"]), d = separation(record), h = d * pitch / 2;
+        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "separationSites", "fast"]), d = separation(record), h = d * pitch / 2;
         return { kind, separationSites: d, components: [[-h, -h], [h, -h], [-h, h], [h, h]].map(([x, y]) => ({ offsetMicrometers: { x: x, y: y }, normalizedWeight: 0.25 })) };
     }
     if (kind === "two-spot") {
-        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "axis", "separationSites"]), d = separation(record), h = d * pitch / 2;
+        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "axis", "separationSites", "fast"]), d = separation(record), h = d * pitch / 2;
         if (record.axis !== "horizontal" && record.axis !== "vertical")
             fail("sensor.antiAliasing.axis must be horizontal or vertical.");
         const axis = record.axis;
         return { kind, axis, separationSites: d, components: [-h, h].map((o) => ({ offsetMicrometers: axis === "horizontal" ? { x: o, y: 0 } : { x: 0, y: o }, normalizedWeight: 0.5 })) };
     }
     if (kind === "point-splitting") {
-        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "components"]);
+        const record = allowKeys(value, "sensor.antiAliasing", ["kind", "components", "fast"]);
         if (!Array.isArray(record.components) || record.components.length === 0 || record.components.length > AA_MAXIMUM_COMPONENTS) {
             fail("sensor.antiAliasing.components must be an array of 1 to " + AA_MAXIMUM_COMPONENTS + " components.");
         }
@@ -283,11 +334,25 @@ function spectrumDigestForm(raw, prepared) {
         values.push(prepared.evaluate(nm));
     return { kind: "function-sampled-1nm", rangeNanometers: [FACADE_SPECTRAL_RANGE_NANOMETERS.minimum, FACADE_SPECTRAL_RANGE_NANOMETERS.maximum], values };
 }
+/**
+ * #449: the CIE 1931 ȳ values at luminanceOf's 5 nm nodes, evaluated once (estimateCie1931ColorMatchingFunctions is a pure
+ * function of the wavelength, so each entry is the value the loop would compute).
+ */
+let luminanceCmfY;
+function luminanceNodesY() {
+    if (luminanceCmfY)
+        return luminanceCmfY;
+    const values = [];
+    for (let nm = FACADE_SPECTRAL_RANGE_NANOMETERS.minimum; nm <= FACADE_SPECTRAL_RANGE_NANOMETERS.maximum; nm += 5)
+        values.push(estimateCie1931ColorMatchingFunctions(nm).y);
+    return (luminanceCmfY = Float64Array.from(values));
+}
 function luminanceOf(radiance) {
+    const cmfY = luminanceNodesY();
     let sum = 0;
-    for (let nm = FACADE_SPECTRAL_RANGE_NANOMETERS.minimum; nm <= FACADE_SPECTRAL_RANGE_NANOMETERS.maximum; nm += 5) {
+    for (let nm = FACADE_SPECTRAL_RANGE_NANOMETERS.minimum, i = 0; nm <= FACADE_SPECTRAL_RANGE_NANOMETERS.maximum; nm += 5, i++) {
         const w = nm === FACADE_SPECTRAL_RANGE_NANOMETERS.minimum || nm === FACADE_SPECTRAL_RANGE_NANOMETERS.maximum ? 2.5 : 5;
-        sum += w * radiance(nm) * estimateCie1931ColorMatchingFunctions(nm).y;
+        sum += w * radiance(nm) * cmfY[i];
     }
     return PHOTOPIC_MAXIMUM_LUMINOUS_EFFICACY_LM_PER_W * sum;
 }
@@ -409,14 +474,29 @@ async function developAhd(v, raw, repeatWidth, repeatHeight, width, height, at,
     host.onDemosaicMs?.(clockMs() - demosaicStarted);
     const demosaiced = task.takeOutput().data, rgb = new Float64Array(width * height * 3);
     const counts = { saturatedPixelCount: 0, whiteBalanceClippedSampleCount: 0, reconstructedPixelCount: 0 };
+    // #420: a pixel is clipped when a saturated site lies within AHD_VALUE_REACH of it, clipped to the raster. The sites within
+    // that reach of each column are found once per row (`near`, a horizontal dilation of `saturated`), so a pixel reads one
+    // column of 2·reach + 1 rows instead of the whole square; with no saturated site at all no pixel is clipped.
+    let anySaturated = false;
+    for (let k = 0; k < saturated.length && !anySaturated; k++)
+        anySaturated = saturated[k] !== 0;
+    const near = anySaturated ? new Uint8Array(W * H) : undefined;
+    if (near)
+        for (let y = 0; y < H; y++) {
+            const row = y * W;
+            for (let x = 0; x < W; x++)
+                if (saturated[row + x] !== 0)
+                    near.fill(1, row + Math.max(0, x - AHD_VALUE_REACH), row + Math.min(W, x + AHD_VALUE_REACH + 1));
+        }
     for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            const p = at(x, y), i = p.y * W + p.x;
+        // The oriented-to-native map is affine in x with whole-site steps (as the bilinear path's developRun uses): two points give the row.
+        const first = at(0, y), second = width > 1 ? at(1, y) : first, stepX = second.x - first.x, stepY = second.y - first.y;
+        for (let x = 0, px = first.x, py = first.y; x < width; x++, px += stepX, py += stepY) {
+            const i = py * W + px;
             let clipped = false;
-            for (let dy = -AHD_VALUE_REACH; dy <= AHD_VALUE_REACH && !clipped; dy++)
-                for (let dx = -AHD_VALUE_REACH; dx <= AHD_VALUE_REACH; dx++) {
-                    const sx = p.x + dx, sy = p.y + dy;
-                    if (sx >= 0 && sy >= 0 && sx < W && sy < H && saturated[sy * W + sx] !== 0) {
+            if (near)
+                for (let sy = Math.max(0, py - AHD_VALUE_REACH), last = Math.min(H - 1, py + AHD_VALUE_REACH); sy <= last; sy++) {
+                    if (near[sy * W + px] !== 0) {
                         clipped = true;
                         break;
                     }
@@ -485,6 +565,74 @@ function encodeSdrFromLinear(rgb, encoding, bitDepth, mapping) {
 export async function simulateCapture(options) {
     return await runCapture(options, "capture");
 }
+/**
+ * Writes the whole-frame DNG of `options` (`output.format: "dng"`, no `output.region`) from the packed RAW of region renders of
+ * the same request (#391), so the RAW can render in parallel. A region render's native sites are the same sites as the whole
+ * render's (each site's seeds come from its index in the whole raster), so the joined RAW is the whole render's RAW, and the
+ * request is resolved and written exactly as `simulateCapture` writes its DNG: the bytes are the same. The parts must cover
+ * every native site of the frame; where they overlap (each region carries the demosaic margin) their sites must agree. Region
+ * renders of the request with any format serve (a region's own `output.format` does not change its RAW). A region cannot take
+ * `output.whiteBalance: "auto"` or `output.dng`: render the parts with a fixed white balance (the RAW codes do not depend on the
+ * white-balance intent) and pass the DNG's own options here, where auto white balance is measured over the joined frame.
+ * @returns The DNG (its `bytes` are those of `SimulateCaptureResult.image.dng` for the same options), with its stored levels and identifiers.
+ */
+export async function serializeSimulatedCaptureDngFromParts(options, parts) {
+    return await runCapture(options, "dng-from-parts", parts);
+}
+/** The whole frame's packed RAW from region parts (see `serializeSimulatedCaptureDngFromParts`). */
+function joinNativeRawParts(value, plan, width, height) {
+    if (!Array.isArray(value) || value.length === 0)
+        throw new InvalidConfigurationError("serializeSimulatedCaptureDngFromParts needs at least one part.");
+    const parts = value, count = width * height;
+    const codes = new Uint16Array(count), blackLevels = new Uint16Array(count), digitalSaturationCodes = new Uint16Array(count), saturationFlags = new Uint8Array(count);
+    const covered = new Uint8Array(count), white = new Uint16Array(4);
+    const bad = (k, what) => { throw new InvalidConfigurationError("DNG part " + k + ": " + what); };
+    parts.forEach((part, k) => {
+        const rect = part?.region?.nativeRect, raw = part?.raw;
+        if (!rect || !raw)
+            bad(k, "needs raw and region.nativeRect (a region render's result).");
+        const { x, y, width: w, height: h } = rect;
+        if (![x, y, w, h].every(Number.isSafeInteger) || x < 0 || y < 0 || w < 1 || h < 1 || x + w > width || y + h > height)
+            bad(k, "its nativeRect is not inside the frame's native raster.");
+        const n = w * h;
+        if (!(raw.codes instanceof Uint16Array) || raw.codes.length !== n || !(raw.blackLevels instanceof Uint16Array) || raw.blackLevels.length !== n ||
+            !(raw.digitalSaturationCodes instanceof Uint16Array) || raw.digitalSaturationCodes.length !== n || !(raw.saturationFlags instanceof Uint8Array) || raw.saturationFlags.length !== n)
+            bad(k, "its RAW arrays do not match its nativeRect.");
+        const phases = raw.effectiveSaturationCodes;
+        if (!(phases instanceof Uint16Array) || phases.length !== 4)
+            bad(k, "needs four per-phase white levels.");
+        // Per-phase white levels are in the whole raster's CFA phases (0 for a phase the part has no site of); all parts agree.
+        for (let phase = 0; phase < 4; phase++) {
+            const code = phases[phase];
+            if (code === 0)
+                continue;
+            if (white[phase] === 0)
+                white[phase] = code;
+            else if (white[phase] !== code)
+                bad(k, "its white level differs from another part's: not the same request.");
+        }
+        for (let row = 0; row < h; row++)
+            for (let column = 0; column < w; column++) {
+                const from = row * w + column, to = (y + row) * width + x + column;
+                if (covered[to]) {
+                    if (codes[to] !== raw.codes[from] || blackLevels[to] !== raw.blackLevels[from] || digitalSaturationCodes[to] !== raw.digitalSaturationCodes[from] ||
+                        saturationFlags[to] !== raw.saturationFlags[from])
+                        bad(k, "a site differs from another part's at the same place: not the same request.");
+                    continue;
+                }
+                covered[to] = 1;
+                codes[to] = raw.codes[from];
+                blackLevels[to] = raw.blackLevels[from];
+                digitalSaturationCodes[to] = raw.digitalSaturationCodes[from];
+                saturationFlags[to] = raw.saturationFlags[from];
+            }
+    });
+    if (covered.includes(0))
+        throw new InvalidConfigurationError("The DNG parts do not cover every native site of the frame.");
+    if (white.includes(0))
+        throw new InvalidConfigurationError("The DNG parts lack a white level for a CFA phase.");
+    return { plan, codes, blackLevels, digitalSaturationCodes, saturationFlags, effectiveSaturationCodes: white };
+}
 /**
  * The ideal reference of a capture request (2.3): the same scene, framing, chart size, output size, region and pixel
  * grid as `simulateCapture(options)` would use, rendered with no camera effects (no lens blur, diffraction, defocus,
@@ -527,7 +675,7 @@ export async function runCapture(options, run, viewOption, renderView) {
     const started = Date.now(), idealReference = run === "ideal-reference", displayView = run === "display-view";
     requireInputObject(options, "simulateCapture options");
     const top = allowKeys(options, "simulateCapture options", ["camera", "lens", "exposure", "scene", "subjectDistanceM", "chartSize", "illuminant",
-        "illuminanceLux", "output", "sensor", "motion", "signal", "onProgress"]);
+        "illuminanceLux", "output", "sensor", "motion", "fast", "signal", "onProgress"]);
     const signal = top.signal, onProgress = top.onProgress;
     if (signal !== undefined && (typeof signal !== "object" || signal === null || typeof signal.aborted !== "boolean"))
         fail("signal must be an AbortSignal.");
@@ -631,16 +779,21 @@ export async function runCapture(options, run, viewOption, renderView) {
         lensPsf = p;
     }
     // Diffraction (2.1): validated here, built once the f-number is resolved.
-    let diffractionRadiusOption;
+    let diffractionRadiusOption, diffractionFast;
     if (lensOptions.diffraction !== undefined) {
         const d = lensOptions.diffraction;
         if (d === "circular-aperture")
             diffractionRadiusOption = null;
         else {
-            const record = allowKeys(d, "lens.diffraction", ["aperture", "kernelRadiusSamples"]);
-            if (record.aperture !== "circular-aperture")
-                fail("lens.diffraction must be \"circular-aperture\" or { aperture: \"circular-aperture\", kernelRadiusSamples }.");
+            const record = allowKeys(d, "lens.diffraction", ["kind", "aperture", "kernelRadiusSamples", "fast"]);
+            // #395: the record names the model by `kind`; `aperture` is its deprecated alias (until 3.0.0).
+            if (record.kind !== undefined && record.aperture !== undefined)
+                fail("lens.diffraction takes kind or its deprecated alias aperture, not both.");
+            const model = record.kind !== undefined ? record.kind : record.aperture;
+            if (model !== "circular-aperture")
+                fail("lens.diffraction must be \"circular-aperture\" or { kind: \"circular-aperture\", kernelRadiusSamples, fast }.");
             diffractionRadiusOption = record.kernelRadiusSamples === undefined ? null : integerIn(record.kernelRadiusSamples, "lens.diffraction.kernelRadiusSamples", 0, 32);
+            diffractionFast = fastOverride(record, "lens.diffraction");
         }
         if (lensPsf)
             fail("lens.diffraction cannot be combined with lens.psf: diffraction would be counted twice.");
@@ -690,6 +843,8 @@ export async function runCapture(options, run, viewOption, renderView) {
     }
     else if (outputOptions.dng !== undefined)
         fail("output.dng applies only to output.format \"dng\".");
+    if (run === "dng-from-parts" && format !== "dng")
+        fail("serializeSimulatedCaptureDngFromParts needs output.format \"dng\".");
     const textMetadata = parseOutputTextMetadata(outputOptions.metadata, "output.metadata");
     if (textMetadata && format !== "jpeg" && format !== "png" && format !== "dng")
         fail("output.metadata applies only to output.format \"jpeg\", \"png\" or \"dng\".");
@@ -739,16 +894,18 @@ export async function runCapture(options, run, viewOption, renderView) {
         pick(sensorOptions, "temporalSampleCount", "sensor.temporalSampleCount", DEFAULTS.temporalSampleCount, "One temporal sample: the static scene and still camera make more samples unnecessary."), "sensor.temporalSampleCount", 1, 256);
     const noiseSeed = integerIn(pick(sensorOptions, "noiseSeed", "sensor.noiseSeed", DEFAULTS.noiseSeed, "Fixed noise seed 1 (deterministic output)."), "sensor.noiseSeed", 0, 0xffffffff);
     const antiAliasing = sensorOptions.antiAliasing === undefined ? undefined : parseAntiAliasing(sensorOptions.antiAliasing, pitch);
+    const antiAliasingFast = antiAliasing ? fastOverride(sensorOptions.antiAliasing, "sensor.antiAliasing") : undefined;
     // Pixel aperture (2.3): N × N midpoint nodes over the square photosite; 1 = the default centre sample.
-    let boxSamples = 1;
+    let boxSamples = 1, boxFast;
     if (sensorOptions.pixelAperture !== undefined && sensorOptions.pixelAperture !== "point") {
         const a = sensorOptions.pixelAperture;
         if (a === "box")
             boxSamples = SIMULATE_CAPTURE_BOX_APERTURE_DEFAULT_SAMPLES;
         else {
-            const record = allowKeys(a, "sensor.pixelAperture", ["kind", "samplesPerAxis"]);
+            const record = allowKeys(a, "sensor.pixelAperture", ["kind", "samplesPerAxis", "fast"]);
             if (record.kind !== "box")
-                fail("sensor.pixelAperture must be \"point\", \"box\" or { kind: \"box\", samplesPerAxis }.");
+                fail("sensor.pixelAperture must be \"point\", \"box\" or { kind: \"box\", samplesPerAxis, fast }.");
+            boxFast = fastOverride(record, "sensor.pixelAperture");
             boxSamples = record.samplesPerAxis === undefined ? SIMULATE_CAPTURE_BOX_APERTURE_DEFAULT_SAMPLES : integerIn(record.samplesPerAxis, "sensor.pixelAperture.samplesPerAxis", 1, 16);
         }
     }
@@ -780,10 +937,35 @@ export async function runCapture(options, run, viewOption, renderView) {
         layout: { kind: "periodic-mosaic", repeatWidthSites: 2, repeatHeightSites: 2, siteChannelIds: ["red", "green", "green", "blue"], anchor: "native-sensor-top-left-site" } };
     // Demosaic (2.0): built-in Bayer kernels and border handling. Omitted, the 1.0 bilinear kernels and a
     // one-site rendered border are used unchanged.
-    const demosaicOption = outputOptions.demosaic, borderOption = outputOptions.borderHandling;
+    // #395: the record form { kind, fast } names the same demosaic.
+    let demosaicOption, demosaicFast;
+    if (outputOptions.demosaic !== undefined && typeof outputOptions.demosaic === "object" && outputOptions.demosaic !== null) {
+        const record = allowKeys(outputOptions.demosaic, "output.demosaic", ["kind", "fast"]);
+        if (record.kind !== "bilinear" && record.kind !== "ahd")
+            fail("output.demosaic must be bilinear or ahd, or { kind, fast }.");
+        demosaicOption = record.kind;
+        demosaicFast = fastOverride(record, "output.demosaic");
+    }
+    else
+        demosaicOption = outputOptions.demosaic;
+    const borderOption = outputOptions.borderHandling;
     if (demosaicOption !== undefined && demosaicOption !== "bilinear" && demosaicOption !== "ahd")
         fail("output.demosaic must be bilinear or ahd.");
     const ahd = demosaicOption === "ahd";
+    // #395: exact or fast per option. No option has a fast method yet, so each runs exact and reports false.
+    if (top.fast !== undefined && typeof top.fast !== "boolean")
+        fail("fast must be true or false.");
+    const fastTop = top.fast === true;
+    const fastInUse = [["lens.diffraction", diffractionRadiusOption !== undefined, diffractionFast],
+        ["sensor.antiAliasing", antiAliasing !== undefined, antiAliasingFast], ["sensor.pixelAperture.box", boxAperture, boxFast], ["output.demosaic.ahd", ahd, demosaicFast]];
+    const fastApplied = {};
+    for (const [option, used] of fastInUse)
+        if (used)
+            fastApplied[option] = false;
+    const fastReport = Object.freeze({
+        requested: fastTop || [diffractionFast, antiAliasingFast, boxFast, demosaicFast].some((value) => value === true),
+        applied: Object.freeze(fastApplied), assurance: "engine-reference"
+    });
     if (borderOption !== undefined && borderOption !== "margin" && borderOption !== "mirror")
         fail("output.borderHandling must be margin or mirror.");
     const builtInDemosaic = demosaicOption === undefined ? undefined : createBuiltInBayerDemosaicProfiles({ kernel: "bilinear",
@@ -1258,13 +1440,18 @@ export async function runCapture(options, run, viewOption, renderView) {
         // larger tail energy outside it is listed per wavelength like any other (2.2.1 states the cap in the explanation).
         const thirdRingSites = Math.max(1, Math.ceil(AIRY_THIRD_ZERO_PER_LAMBDA_N * lambdaN / pitch));
         const kernelRadiusSamples = diffractionRadiusOption ?? Math.min(32, thirdRingSites);
-        diffraction = createDiffractionLimitedPsfProfile({ aperture: "circular", focalLengthMm, apertureFNumber: fNumber, focus: { kind: "finite", distanceM: focusDistanceM },
+        const profileInput = { aperture: "circular", focalLengthMm, apertureFNumber: fNumber, focus: { kind: "finite", distanceM: focusDistanceM },
             wavelengthsNm: wavelengths, samplePitchMicrometers: pitch, kernelRadiusSamples, fieldHalfExtentMm: aaReachMm === 0 ? { x: imagingArea.widthMm / 2, y: imagingArea.heightMm / 2 } :
                 { x: imagingArea.widthMm / 2 + aaReachMm, y: imagingArea.heightMm / 2 + aaReachMm },
-            profileId: "facade-diffraction-airy" }).value;
+            profileId: "facade-diffraction-airy" };
+        // #449: a copy of the profile kept for this input; it equals createDiffractionLimitedPsfProfile(profileInput).value field by
+        // field, so the registration below (keyed by profileInput) holds for it.
+        diffraction = cachedDiffractionProfile(profileInput);
         diffractionPsf = { kind: "sampled-local", configuration: { psf: { profile: diffraction.profile, focalLengthMm, focus: { kind: "finite", distanceM: focusDistanceM },
                     apertureFNumber: fNumber, signedDefocusImagePlaneMicrometers: 0 }, psfWavelengthBasis: { value: "vacuum", evidence },
                 spatialModel: { kind: "destination-local-shift-invariant-approximation", evidence, limitation: "Diffraction-limited Airy PSF, the same at every field point." } } };
+        // Requests with the same profile input and PSF fields share their site diffraction kernels (optics/site-diffraction-kernel.ts).
+        registerDiffractionPsfKey(diffractionPsf.configuration.psf, profileInput);
         assume("lens.diffraction", "model", { model: diffraction.model, aperture: "circular-aperture", fNumber, workingFNumber: diffraction.workingFNumber,
             kernelRadiusSamples, samplePitchMicrometers: pitch, maximumTruncatedEnergyFraction: diffraction.maximumTruncatedEnergyFraction,
             truncatedEnergyByWavelength: diffraction.wavelengths.map((w) => ({ wavelengthNm: w.wavelengthNm, truncatedEnergyFraction: w.truncatedEnergyFraction })),
@@ -1356,9 +1543,11 @@ export async function runCapture(options, run, viewOption, renderView) {
             delete environment.evaluateApertureRadiance;
             environments[channel] = environment;
         }
-        // The responses are a function of these records alone (the radiance is replaced per node), and a request split into region
-        // tiles builds the same records for every tile, so they are kept across calls (the last CHANNEL_RESPONSE_CACHE_SIZE).
-        const key = JSON.stringify(CHANNELS.map((c) => environments[c]));
+        // The responses are a function of these records without their scene bindings: the radiance is replaced at every node,
+        // and the bindings (provider, illumination and material profiles) are only checked, never enter a number. So a chart,
+        // illuminant or illuminance change keeps the entry (#443). A request split into region tiles builds the same records for
+        // every tile. The entries are kept across calls (the last CHANNEL_RESPONSE_CACHE_SIZE).
+        const key = JSON.stringify(CHANNELS.map((c) => ({ ...environments[c], sceneBindings: undefined })));
         const copy = (responses) => Object.fromEntries(CHANNELS.map((c) => [c, new Map(responses[c])]));
         const cached = channelResponseCache.get(key);
         let electronsPerRadiance;
@@ -1369,15 +1558,10 @@ export async function runCapture(options, run, viewOption, renderView) {
         }
         else {
             electronsPerRadiance = {};
-            for (const channel of CHANNELS) {
-                // Planned once per channel and executed per spectral node: calculateEnvironmentSensorPhotoSignal is this plan and execution.
-                const photoPlan = planEnvironmentSensorPhotoSignal(environments[channel]);
-                const electrons = (radiance) => executeEnvironmentSensorPhotoSignal(photoPlan, (request) => ({ ...provider.evaluateRadiance(request), spectralRadianceWattsPerSquareMeterSteradianNanometer: radiance(request.wavelengthNanometers) })).value
-                    .photo.value.photoSignal.expectedGeneratedElectronCount;
-                const nodes = new Set();
-                electrons((nm) => { nodes.add(nm); return 1; });
-                electronsPerRadiance[channel] = new Map([...nodes].sort((a, b) => a - b).map((node) => [node, electrons((nm) => (nm === node ? 1 : 0))]));
-            }
+            // One chain execution per channel, each node's electrons read from its own rate term (#443; exact, see channel-response.ts).
+            // The records are built above for this call only, so they are planned as engine-owned data.
+            for (const channel of CHANNELS)
+                electronsPerRadiance[channel] = calculateChannelElectronsPerRadiance(environments[channel], (request) => provider.evaluateRadiance(request), caller);
             // Callers get their own maps; the cached ones are never handed out.
             channelResponseCache.set(key, copy(electronsPerRadiance));
             if (channelResponseCache.size > CHANNEL_RESPONSE_CACHE_SIZE)
@@ -1400,7 +1584,7 @@ export async function runCapture(options, run, viewOption, renderView) {
     // Display view: the renderer that simulate-display-view.ts passes in reads this request's resolved state, so a bundle
     // that only captures does not contain the display view.
     if (displayView)
-        return await renderView({ ahd, antiAliasing, aspect, assume, assumptions, axisChannelResponse, boxSamples, buildProvider, callerScene, chart, chartReport, chartSize, diffraction, diffractionPsf, fNumber, focalLengthMm, focusDistanceM, height, highlightMode, illuminanceLux, illuminant, illuminantOption, imagingArea, intentOf, metresPerFrameUnit, noiseSeed, outputOptions, parsedView, pitch, preset, provider, regimeByChannel, resolvedIso, sceneOption, scenePreset, shutterSeconds, started, subjectDistanceM, toneCurve, whiteBalanceOption, whiteBalanceState, width, checkAbort, margin, mode, nativeHeight, nativeWidth, sourceSha256, yieldControl, kelvinWhiteBalanceInput });
+        return await renderView({ ahd, fastReport, antiAliasing, aspect, assume, assumptions, axisChannelResponse, boxSamples, buildProvider, callerScene, chart, chartReport, chartSize, diffraction, diffractionPsf, fNumber, focalLengthMm, focusDistanceM, height, highlightMode, illuminanceLux, illuminant, illuminantOption, imagingArea, intentOf, metresPerFrameUnit, noiseSeed, outputOptions, parsedView, pitch, preset, provider, regimeByChannel, resolvedIso, sceneOption, scenePreset, shutterSeconds, started, subjectDistanceM, toneCurve, whiteBalanceOption, whiteBalanceState, width, checkAbort, margin, mode, nativeHeight, nativeWidth, sourceSha256, yieldControl, kelvinWhiteBalanceInput });
     // Ideal reference (2.3): the scene without camera effects, at the capture's own exposure, white balance and encoding.
     if (idealReference) {
         const referenceStarted = clockMs();
@@ -1516,8 +1700,12 @@ export async function runCapture(options, run, viewOption, renderView) {
     // #394 step 2: an engine-built planar scene (chart preset or caller material scene; still, rectilinear, no distortion, vignetting,
     // pupil rays or caller PSF) takes its expected electrons from the tabulated signal, verified per CFA phase against the chain.
     const tabulatedScene = chart !== undefined || callerScene?.kind === "material-function";
+    // #391: a DNG from region parts takes the whole frame's RAW from the parts instead of rendering it.
+    if (run === "dng-from-parts" && regionNative)
+        fail("serializeSimulatedCaptureDngFromParts writes the whole frame: the options take no output.region.");
+    const dngParts = run === "dng-from-parts" ? viewOption : undefined;
     let tabulated;
-    if (tabulatedScene && !pupil && !lensFieldMapping && !vignetting && !lensPsf && !rotating && (!diffraction || diffractionObjectSpace) && provider.chartMaterialAt && provider.materialRadiance) {
+    if (dngParts === undefined && tabulatedScene && !pupil && !lensFieldMapping && !vignetting && !lensPsf && !rotating && (!diffraction || diffractionObjectSpace) && provider.chartMaterialAt && provider.materialRadiance) {
         const { electronsPerRadiance, wavelengths } = axisChannelResponse("simulateCapture");
         const perNode = CHANNELS.map((c) => Float64Array.from(wavelengths, (nm) => electronsPerRadiance[c].get(nm) ?? 0));
         const sceneMaterials = chart ? chart.materials : callerScene.materials, materialRadiance = provider.materialRadiance;
@@ -1534,7 +1722,9 @@ export async function runCapture(options, run, viewOption, renderView) {
             electrons: createDisplayViewExpectedSignal(signalInput), onTile: rawTick, tileWidth, yieldControl: () => yieldControl(), checkAbort });
     }
     let rawOutput;
-    if (tabulated) {
+    if (dngParts !== undefined)
+        rawOutput = { raw: joinNativeRawParts(dngParts, plan, nativeWidth, nativeHeight), providerEvaluationCount: 0 };
+    else if (tabulated) {
         rawOutput = { raw: tabulated.raw, providerEvaluationCount: tabulated.providerEvaluationCount };
         // The verification's relative difference itself is not reported: it is a last-bits quantity, and captures use the JavaScript
         // engine's own Math functions, so it differs between engines while the results are the same.
@@ -1582,7 +1772,7 @@ export async function runCapture(options, run, viewOption, renderView) {
             sampleSet: { imageStateId: "facade-pre-wb-raw", inputDomain: "relative-pre-wb-camera-linear-rgb", samples } });
         finalRawInput = { raw: buildRawInput(intentOf(whiteBalanceState)), sceneBinding, maximumProviderEvaluations: environmentRaw.maximumProviderEvaluations };
         const wbTick = progress("white-balance", plan.tileCount);
-        if (tabulated) {
+        if (tabulated || dngParts !== undefined) {
             // #394: the RAW codes do not depend on the white-balance intent (it is development metadata), so the tabulated RAW is
             // kept with the plan of the measured intent instead of being rendered again.
             rawOutput = { ...rawOutput, raw: { ...rawOutput.raw, plan: calculateNativeRawPlan(finalRawInput.raw) } };
@@ -1623,6 +1813,8 @@ export async function runCapture(options, run, viewOption, renderView) {
         assume("output.dng", "model", { writer: "serializeNativeRawDng", schemaVersion: dng.schemaVersion, whiteLevel: dng.whiteLevel, blackLevels: dng.blackLevels,
             noiseProfile: dng.noiseProfile, unrepresentedSaturationFlagCount: dng.unrepresentedSaturationFlagCount }, "Lossless uncompressed 16-bit CFA DNG of exactly the packed native RAW codes: per-phase BlackLevel, WhiteLevel = smallest per-phase effective white, ActiveArea and DefaultCrop from the capture geometry, ColorMatrix1/ForwardMatrix1 from the facade's diagonal camera→XYZ profile (D65), AsShotNeutral from the white-balance intent, BaselineExposure 0, and NoiseProfile from each channel's readout regime (conversion gain ÷ digital gain, combined read noise; Poisson + Gaussian + quantization only). No linear master or developed image is declared; saturation flags below WhiteLevel are not representable and are counted.");
     }
+    if (dngParts !== undefined)
+        return dng;
     // Development
     const development = { phaseProfiles, colorProfile,
         whiteBalance: developmentWhiteBalance, rendering, highlightMode, ...(mirrorBorder ? { borderHandling: "mirror" } : {}),
@@ -1756,7 +1948,7 @@ export async function runCapture(options, run, viewOption, renderView) {
             timingsMs: { raw: rawMs, whiteBalance: wbMs, development: devMs, jpeg: jpegMs, total: Date.now() - started,
                 ...(diffraction && diffractionObjectSpace ? { diffraction: diffractionMs } : {}), ...(demosaicMs === undefined ? {} : { demosaic: demosaicMs }),
                 ...(encodeMs === undefined ? {} : { encode: encodeMs }) },
-            options: Object.freeze(SIMULATE_CAPTURE_COST_OPTIONS.filter((option) => ranOptions.has(option))) },
+            options: Object.freeze(SIMULATE_CAPTURE_COST_OPTIONS.filter((option) => ranOptions.has(option))), fast: fastReport },
         provenance: { scientificStatus: "approximation", cameraPresetId: preset.presetId, cameraPresetVersion: preset.presetVersion,
             evidence: [...FACADE_EVIDENCE, ...preset.evidence],
             composedContracts: ["resolveGenericEquipmentExposureCapabilities", "meterRelativeExposure", "createExposureMeterTargetFromMeteringResult",