@photivra/engine 2.9.0 → 2.11.1

package/dist/facade/expected-signal-setup.d.ts

@@ -31,6 +31,11 @@ export interface ExpectedSignalSetupInput {
         psf: Psf;
         profileWavelengths: readonly number[];
     } | undefined;
+    /** Defocus (#492): the geometric disc on the site lattice, (2R + 1)² row-major weights; absent or null in focus. */
+    defocus?: {
+        radius: number;
+        weights: Float64Array;
+    } | null | undefined;
     /** Material scenes: the materials (neutral reflectances, or radiance per wavelength), the material lookup and the white radiance. */
     materials?: {
         list: readonly ({

package/dist/facade/expected-signal-setup.js

@@ -3,10 +3,20 @@
  * Internal (#394, not exported from the package): the input of the tabulated expected signal (`createDisplayViewExpectedSignal`)
  * for a resolved `simulateCapture` request, shared by the display view and the capture's tabulated RAW path so both build it
  * the same way: query offsets of each site, the environment's query points, the diffraction kernels and the scene tables.
+ *
+ * Defocus (#492, `lens.defocus`): the geometric disc D on the site lattice (`createDefocusDiscSiteKernel`) enters as a site
+ * kernel, so every query stays on the lattice. Without diffraction every spectral node takes D itself (a wavelength-independent
+ * kernel). With diffraction node λ takes K_λ ∗ D, the full 2-D convolution of the diffraction kernel with the disc (radius
+ * R_diff + R_defocus): a labelled approximation, since the defocused wave's PSF is not the in-focus Airy pattern convolved
+ * with a geometric disc. The convolution is linear, so Σ_t (K_λ ∗ D)(t)·L(p − t) is the diffracted radiance blurred by D, the
+ * order the capture's object-space convolutions apply them in. The kernels are built as the capture builds them
+ * (`siteDiffractionKernel`, then `convolveSiteKernels`), so the two have the same bits.
  */
 import { InvalidConfigurationError } from "../core/configuration-error.js";
 import { siteDiffractionKernel } from "../optics/site-diffraction-kernel.js";
+import { convolveSiteKernels } from "../optics/defocus-disc-kernel.js";
 import { resolveProjectionDistanceMm } from "../motion/camera-rotation.js";
+import { hypot3 } from "../core/portable-math.js";
 /** The query offsets of each site and the expected-signal input (see the module comment). */
 export function buildExpectedSignalInput(input) {
     const { boxSamples, pitch, wavelengths, imagingArea, subjectDistanceM, metresPerFrameUnit } = input;
@@ -25,6 +35,13 @@ export function buildExpectedSignalInput(input) {
                 return siteDiffractionKernel(diffraction.psf, wavelengthNm, pitch, radius, input.caller + ": diffraction kernels must sample the site pitch exactly.");
             }) };
     }
+    // Defocus (#492): the disc alone at every node (one shared array), or each node's diffraction kernel convolved with it.
+    const defocus = input.defocus;
+    if (defocus) {
+        const diffracted = kernels;
+        kernels = diffracted ? { radius: diffracted.radius + defocus.radius, perNode: diffracted.perNode.map((k) => convolveSiteKernels(k, diffracted.radius, defocus.weights, defocus.radius)) } :
+            { radius: defocus.radius, perNode: wavelengths.map(() => defocus.weights) };
+    }
     // Chart presets and (2.7) caller material scenes take the material path: each material tabulated once per node.
     const materials = input.materials;
     const scene = materials ? { kind: "materials", materialAt: materials.materialAt,
@@ -42,7 +59,7 @@ export function buildExpectedSignalInput(input) {
         const centerX = -imagingArea.widthMm / 2 + (pitch / 2 + x * pitch + 0) / 1000, centerY = -imagingArea.heightMm / 2 + (pitch / 2 + y * pitch + 0) / 1000;
         const sourceX = (centerX - siteWidthMm / 2 + node.xPhase * siteWidthMm) - node.aaX, sourceY = (centerY - siteWidthMm / 2 + node.yPhase * siteWidthMm) - node.aaY;
         const rx = projectionDistance * (sourceX / projectionDistance), ry = projectionDistance * (-sourceY / projectionDistance);
-        const length = Math.hypot(rx, ry, projectionDistance), t = subjectDistanceM / (projectionDistance / length);
+        const length = hypot3(rx, ry, projectionDistance), t = subjectDistanceM / (projectionDistance / length);
         out[0] = rx / length * t / metresPerFrameUnit;
         out[1] = ry / length * t / metresPerFrameUnit;
     };

package/dist/facade/expected-signal-setup.js.map

@@ -1 +1 @@
-{"version":3,"file":"expected-signal-setup.js","sourceRoot":"","sources":["../../src/facade/expected-signal-setup.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Internal (#394, not exported from the package): the input of the tabulated expected signal (`createDisplayViewExpectedSignal`)\n * for a resolved `simulateCapture` request, shared by the display view and the capture's tabulated RAW path so both build it\n * the same way: query offsets of each site, the environment's query points, the diffraction kernels and the scene tables.\n */\n\nimport { InvalidConfigurationError } from \"../core/configuration-error.js\";\nimport type { resolveLensPsfConvolutionKernels } from \"../optics/lens-psf-kernels.js\";\nimport { siteDiffractionKernel } from \"../optics/site-diffraction-kernel.js\";\nimport { resolveProjectionDistanceMm } from \"../motion/camera-rotation.js\";\nimport type { DisplayViewExpectedSignalInput, DisplayViewScene } from \"./display-view.js\";\n\ntype Psf = Parameters<typeof resolveLensPsfConvolutionKernels>[0][\"psf\"];\n\nexport interface ExpectedSignalSetupInput {\n  nativeWidth: number;\n  nativeHeight: number;\n  /** Frame output width (plane coordinates are 2 / width frame units per site). */\n  width: number;\n  wavelengths: readonly number[];\n  /** Per CFA channel (red, green, blue): expected electrons per unit spectral radiance at each node. */\n  perNode: readonly [Float64Array, Float64Array, Float64Array];\n  /** Pixel-aperture nodes in sites from the site centre (`apertureNodeOffsets(boxSamples)`) and the box sample count. */\n  apertureNodes: readonly { x: number; y: number }[];\n  boxSamples: number;\n  antiAliasing?: { components: readonly { offsetMicrometers: { x: number; y: number }; normalizedWeight: number }[] } | undefined;\n  pitch: number;\n  /** Object-space diffraction: the kernel radius, the PSF and its profile wavelengths. */\n  diffraction?: { radius: number; psf: Psf; profileWavelengths: readonly number[] } | undefined;\n  /** Material scenes: the materials (neutral reflectances, or radiance per wavelength), the material lookup and the white radiance. */\n  materials?: { list: readonly ({ neutral: number } | { radiance: (nm: number) => number })[]; materialAt(u: number, v: number): number; whiteRadiance(nm: number): number } | undefined;\n  radianceAt(u: number, v: number, nm: number): number;\n  imagingArea: { widthMm: number; heightMm: number };\n  focalLengthMm: number;\n  focusDistanceM: number;\n  subjectDistanceM: number;\n  metresPerFrameUnit: number;\n  /** Prefix of the error messages (\"simulateDisplayView\", \"simulateCapture\"). */\n  caller: string;\n}\n\n/** The query offsets of each site and the expected-signal input (see the module comment). */\nexport function buildExpectedSignalInput(input: ExpectedSignalSetupInput): { offsets: { x: number; y: number; weight: number }[]; signalInput: DisplayViewExpectedSignalInput } {\n  const { boxSamples, pitch, wavelengths, imagingArea, subjectDistanceM, metresPerFrameUnit } = input;\n  // Query offsets of each site: pixel-aperture nodes minus anti-aliasing split offsets (sites, +x right, +y down), as the environment forms them.\n  const spots = input.antiAliasing ? input.antiAliasing.components : [{ offsetMicrometers: { x: 0, y: 0 }, normalizedWeight: 1 }];\n  const offsets = input.apertureNodes.flatMap((node) => spots.map((c) => ({ x: node.x - c.offsetMicrometers.x / pitch, y: node.y - c.offsetMicrometers.y / pitch,\n    weight: c.normalizedWeight / (boxSamples * boxSamples) })));\n  // Diffraction: the same per-node site kernels as the object-space convolution (createDiffractedPlanarProvider).\n  let kernels: { radius: number; perNode: Float64Array[] } | undefined;\n  const diffraction = input.diffraction;\n  if (diffraction) {\n    const radius = diffraction.radius;\n    kernels = { radius, perNode: wavelengths.map((wavelengthNm) => {\n      if (!diffraction.profileWavelengths.includes(wavelengthNm)) throw new InvalidConfigurationError(input.caller + \": a spectral node has no diffraction kernel.\");\n      return siteDiffractionKernel(diffraction.psf, wavelengthNm, pitch, radius, input.caller + \": diffraction kernels must sample the site pitch exactly.\");\n    }) };\n  }\n  // Chart presets and (2.7) caller material scenes take the material path: each material tabulated once per node.\n  const materials = input.materials;\n  const scene: DisplayViewScene = materials ? { kind: \"materials\", materialAt: materials.materialAt,\n    materials: materials.list.map((m) => (\"neutral\" in m ? { neutral: m.neutral } : { radiance: Float64Array.from(wavelengths, (nm) => m.radiance(nm)) })),\n    whiteRadiance: Float64Array.from(wavelengths, (nm) => materials.whiteRadiance(nm)) } :\n    { kind: \"radiance\", radianceAt: input.radianceAt };\n  const channelIndex = (x: number, y: number): number => ((y & 1) === 0 ? ((x & 1) === 0 ? 0 : 1) : ((x & 1) === 0 ? 1 : 2));\n  // Without diffraction the environment's own query arithmetic (native-environment-lean.ts `geometry`, then the rectilinear\n  // still-camera ray and the planar provider's plane point), so boundary points resolve as in the capture.\n  const projectionDistance = resolveProjectionDistanceMm(input.focalLengthMm, input.focusDistanceM).projectionDistanceMm, siteWidthMm = pitch / 1000;\n  const nodePhases = input.apertureNodes.flatMap((_, index) => spots.map((c) => ({ xPhase: (index % boxSamples + 0.5) / boxSamples, yPhase: (Math.floor(index / boxSamples) + 0.5) / boxSamples,\n    aaX: c.offsetMicrometers.x / 1000, aaY: c.offsetMicrometers.y / 1000 })));\n  const queryPoint = (x: number, y: number, o: number, out: Float64Array): void => {\n    const node = nodePhases[o]!;\n    const centerX = -imagingArea.widthMm / 2 + (pitch / 2 + x * pitch + 0) / 1000, centerY = -imagingArea.heightMm / 2 + (pitch / 2 + y * pitch + 0) / 1000;\n    const sourceX = (centerX - siteWidthMm / 2 + node.xPhase * siteWidthMm) - node.aaX, sourceY = (centerY - siteWidthMm / 2 + node.yPhase * siteWidthMm) - node.aaY;\n    const rx = projectionDistance * (sourceX / projectionDistance), ry = projectionDistance * (-sourceY / projectionDistance);\n    const length = Math.hypot(rx, ry, projectionDistance), t = subjectDistanceM / (projectionDistance / length);\n    out[0] = rx / length * t / metresPerFrameUnit; out[1] = ry / length * t / metresPerFrameUnit;\n  };\n  return { offsets, signalInput: { nativeWidth: input.nativeWidth, nativeHeight: input.nativeHeight, outputWidth: input.width, wavelengthsNm: wavelengths,\n    electronsPerRadiance: input.perNode, offsets, ...(kernels ? { kernels } : { queryPoint }), scene, channelAt: channelIndex } };\n}\n"]}
+{"version":3,"file":"expected-signal-setup.js","sourceRoot":"","sources":["../../src/facade/expected-signal-setup.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Internal (#394, not exported from the package): the input of the tabulated expected signal (`createDisplayViewExpectedSignal`)\n * for a resolved `simulateCapture` request, shared by the display view and the capture's tabulated RAW path so both build it\n * the same way: query offsets of each site, the environment's query points, the diffraction kernels and the scene tables.\n *\n * Defocus (#492, `lens.defocus`): the geometric disc D on the site lattice (`createDefocusDiscSiteKernel`) enters as a site\n * kernel, so every query stays on the lattice. Without diffraction every spectral node takes D itself (a wavelength-independent\n * kernel). With diffraction node λ takes K_λ ∗ D, the full 2-D convolution of the diffraction kernel with the disc (radius\n * R_diff + R_defocus): a labelled approximation, since the defocused wave's PSF is not the in-focus Airy pattern convolved\n * with a geometric disc. The convolution is linear, so Σ_t (K_λ ∗ D)(t)·L(p − t) is the diffracted radiance blurred by D, the\n * order the capture's object-space convolutions apply them in. The kernels are built as the capture builds them\n * (`siteDiffractionKernel`, then `convolveSiteKernels`), so the two have the same bits.\n */\n\nimport { InvalidConfigurationError } from \"../core/configuration-error.js\";\nimport type { resolveLensPsfConvolutionKernels } from \"../optics/lens-psf-kernels.js\";\nimport { siteDiffractionKernel } from \"../optics/site-diffraction-kernel.js\";\nimport { convolveSiteKernels } from \"../optics/defocus-disc-kernel.js\";\nimport { resolveProjectionDistanceMm } from \"../motion/camera-rotation.js\";\nimport { hypot3 } from \"../core/portable-math.js\";\nimport type { DisplayViewExpectedSignalInput, DisplayViewScene } from \"./display-view.js\";\n\ntype Psf = Parameters<typeof resolveLensPsfConvolutionKernels>[0][\"psf\"];\n\nexport interface ExpectedSignalSetupInput {\n  nativeWidth: number;\n  nativeHeight: number;\n  /** Frame output width (plane coordinates are 2 / width frame units per site). */\n  width: number;\n  wavelengths: readonly number[];\n  /** Per CFA channel (red, green, blue): expected electrons per unit spectral radiance at each node. */\n  perNode: readonly [Float64Array, Float64Array, Float64Array];\n  /** Pixel-aperture nodes in sites from the site centre (`apertureNodeOffsets(boxSamples)`) and the box sample count. */\n  apertureNodes: readonly { x: number; y: number }[];\n  boxSamples: number;\n  antiAliasing?: { components: readonly { offsetMicrometers: { x: number; y: number }; normalizedWeight: number }[] } | undefined;\n  pitch: number;\n  /** Object-space diffraction: the kernel radius, the PSF and its profile wavelengths. */\n  diffraction?: { radius: number; psf: Psf; profileWavelengths: readonly number[] } | undefined;\n  /** Defocus (#492): the geometric disc on the site lattice, (2R + 1)² row-major weights; absent or null in focus. */\n  defocus?: { radius: number; weights: Float64Array } | null | undefined;\n  /** Material scenes: the materials (neutral reflectances, or radiance per wavelength), the material lookup and the white radiance. */\n  materials?: { list: readonly ({ neutral: number } | { radiance: (nm: number) => number })[]; materialAt(u: number, v: number): number; whiteRadiance(nm: number): number } | undefined;\n  radianceAt(u: number, v: number, nm: number): number;\n  imagingArea: { widthMm: number; heightMm: number };\n  focalLengthMm: number;\n  focusDistanceM: number;\n  subjectDistanceM: number;\n  metresPerFrameUnit: number;\n  /** Prefix of the error messages (\"simulateDisplayView\", \"simulateCapture\"). */\n  caller: string;\n}\n\n/** The query offsets of each site and the expected-signal input (see the module comment). */\nexport function buildExpectedSignalInput(input: ExpectedSignalSetupInput): { offsets: { x: number; y: number; weight: number }[]; signalInput: DisplayViewExpectedSignalInput } {\n  const { boxSamples, pitch, wavelengths, imagingArea, subjectDistanceM, metresPerFrameUnit } = input;\n  // Query offsets of each site: pixel-aperture nodes minus anti-aliasing split offsets (sites, +x right, +y down), as the environment forms them.\n  const spots = input.antiAliasing ? input.antiAliasing.components : [{ offsetMicrometers: { x: 0, y: 0 }, normalizedWeight: 1 }];\n  const offsets = input.apertureNodes.flatMap((node) => spots.map((c) => ({ x: node.x - c.offsetMicrometers.x / pitch, y: node.y - c.offsetMicrometers.y / pitch,\n    weight: c.normalizedWeight / (boxSamples * boxSamples) })));\n  // Diffraction: the same per-node site kernels as the object-space convolution (createDiffractedPlanarProvider).\n  let kernels: { radius: number; perNode: Float64Array[] } | undefined;\n  const diffraction = input.diffraction;\n  if (diffraction) {\n    const radius = diffraction.radius;\n    kernels = { radius, perNode: wavelengths.map((wavelengthNm) => {\n      if (!diffraction.profileWavelengths.includes(wavelengthNm)) throw new InvalidConfigurationError(input.caller + \": a spectral node has no diffraction kernel.\");\n      return siteDiffractionKernel(diffraction.psf, wavelengthNm, pitch, radius, input.caller + \": diffraction kernels must sample the site pitch exactly.\");\n    }) };\n  }\n  // Defocus (#492): the disc alone at every node (one shared array), or each node's diffraction kernel convolved with it.\n  const defocus = input.defocus;\n  if (defocus) {\n    const diffracted = kernels;\n    kernels = diffracted ? { radius: diffracted.radius + defocus.radius, perNode: diffracted.perNode.map((k) => convolveSiteKernels(k, diffracted.radius, defocus.weights, defocus.radius)) } :\n      { radius: defocus.radius, perNode: wavelengths.map(() => defocus.weights) };\n  }\n  // Chart presets and (2.7) caller material scenes take the material path: each material tabulated once per node.\n  const materials = input.materials;\n  const scene: DisplayViewScene = materials ? { kind: \"materials\", materialAt: materials.materialAt,\n    materials: materials.list.map((m) => (\"neutral\" in m ? { neutral: m.neutral } : { radiance: Float64Array.from(wavelengths, (nm) => m.radiance(nm)) })),\n    whiteRadiance: Float64Array.from(wavelengths, (nm) => materials.whiteRadiance(nm)) } :\n    { kind: \"radiance\", radianceAt: input.radianceAt };\n  const channelIndex = (x: number, y: number): number => ((y & 1) === 0 ? ((x & 1) === 0 ? 0 : 1) : ((x & 1) === 0 ? 1 : 2));\n  // Without diffraction the environment's own query arithmetic (native-environment-lean.ts `geometry`, then the rectilinear\n  // still-camera ray and the planar provider's plane point), so boundary points resolve as in the capture.\n  const projectionDistance = resolveProjectionDistanceMm(input.focalLengthMm, input.focusDistanceM).projectionDistanceMm, siteWidthMm = pitch / 1000;\n  const nodePhases = input.apertureNodes.flatMap((_, index) => spots.map((c) => ({ xPhase: (index % boxSamples + 0.5) / boxSamples, yPhase: (Math.floor(index / boxSamples) + 0.5) / boxSamples,\n    aaX: c.offsetMicrometers.x / 1000, aaY: c.offsetMicrometers.y / 1000 })));\n  const queryPoint = (x: number, y: number, o: number, out: Float64Array): void => {\n    const node = nodePhases[o]!;\n    const centerX = -imagingArea.widthMm / 2 + (pitch / 2 + x * pitch + 0) / 1000, centerY = -imagingArea.heightMm / 2 + (pitch / 2 + y * pitch + 0) / 1000;\n    const sourceX = (centerX - siteWidthMm / 2 + node.xPhase * siteWidthMm) - node.aaX, sourceY = (centerY - siteWidthMm / 2 + node.yPhase * siteWidthMm) - node.aaY;\n    const rx = projectionDistance * (sourceX / projectionDistance), ry = projectionDistance * (-sourceY / projectionDistance);\n    const length = hypot3(rx, ry, projectionDistance), t = subjectDistanceM / (projectionDistance / length);\n    out[0] = rx / length * t / metresPerFrameUnit; out[1] = ry / length * t / metresPerFrameUnit;\n  };\n  return { offsets, signalInput: { nativeWidth: input.nativeWidth, nativeHeight: input.nativeHeight, outputWidth: input.width, wavelengthsNm: wavelengths,\n    electronsPerRadiance: input.perNode, offsets, ...(kernels ? { kernels } : { queryPoint }), scene, channelAt: channelIndex } };\n}\n\n"]}

package/dist/facade/expected-signal.d.ts

@@ -29,7 +29,11 @@ export interface DisplayViewExpectedSignalInput {
     wavelengthsNm: readonly number[];
     electronsPerRadiance: readonly [Float64Array, Float64Array, Float64Array];
     offsets: readonly DisplayViewQueryOffset[];
-    /** Diffraction: per-node kernels on the site lattice, (2R + 1)² taps in row-major order, out(x) = Σ in(x − t)·K(t). */
+    /**
+     * Diffraction and (#492) defocus: per-node kernels on the site lattice, (2R + 1)² taps in row-major order,
+     * out(x) = Σ in(x − t)·K(t). With defocus each node's kernel is its diffraction kernel convolved with the disc, or the
+     * disc itself without diffraction (expected-signal-setup.ts).
+     */
     kernels?: {
         radius: number;
         perNode: readonly Float64Array[];
@@ -38,9 +42,10 @@ export interface DisplayViewExpectedSignalInput {
     /** CFA channel index (0 red, 1 green, 2 blue) of native site (x, y). */
     channelAt(x: number, y: number): number;
     /**
-     * Without diffraction: the plane point (frame units) that the environment queries for offset `o` of native site (x, y),
+     * Without kernels: the plane point (frame units) that the environment queries for offset `o` of native site (x, y),
      * computed with the environment's own arithmetic, so points that fall exactly on a chart boundary resolve to the same
-     * material as in the capture. With diffraction the facade's object-space convolution uses the lattice formula, as here.
+     * material as in the capture. With kernels (diffraction or defocus) the facade's object-space convolution uses the
+     * lattice formula, as here.
      */
     queryPoint?(x: number, y: number, offset: number, out: Float64Array): void;
 }
@@ -58,18 +63,87 @@ export interface DisplayViewExpectedSignal {
     /** Scene lookups performed so far (material or radiance queries), for diagnostics. */
     readonly lookups: number;
     /**
-     * The chart material that every kernel tap of the last `site` call read, when they all read one material (its value is
-     * then a function of that material and the site's CFA channel only); −1 when unknown or mixed.
+     * The chart material that every kernel tap (without diffraction: every query point) of the last `site` call read, when
+     * they all read one material (its value is then a function of that material and the site's CFA channel only); −1 when
+     * unknown or mixed.
      */
     readonly uniformMaterial: number;
-    /** Whether `uniformMaterial` is tracked in the current window (otherwise it is not meaningful). */
+    /**
+     * Whether `uniformMaterial` is tracked in the current window (otherwise it is not meaningful): chart materials in a
+     * filled window or, without diffraction, in a window the direct ring serves (#444); never for radiance scenes.
+     */
     readonly tracksMaterial: boolean;
     /**
      * Whether the current window caches its sites: a second `site` call for a site inside the window then returns the stored
      * value without any work or lookup (#392).
      */
     readonly cachesSites: boolean;
+    /**
+     * Whether `markReads` is available in the current window: a filled window (chart materials with diffraction kernels),
+     * whose lookup count comes from the sites it computed. False otherwise: for windows without kernels (whose sites the
+     * direct ring already serves cheaply) and for the lazy window caches (radiance scenes with diffraction), whose count
+     * depends on the lattice points each computed site reads.
+     */
+    readonly marksReads: boolean;
+    /**
+     * Records `count` sites as read in the current window without computing them: site n at (xs[n], ys[n]) with value values[n]
+     * (as `site` returned it for that site) and uniform material materials[n] (as `uniformMaterial` reported it). Sites outside
+     * the window and sites the window already holds are skipped. For the window's lookup count and for later `site` calls this
+     * is the same as reading each site with `site`. Only valid while `marksReads` is true; it must do for a site the
+     * bookkeeping `site` does for a site the window's cache does not hold yet.
+     */
+    markReads(xs: Int32Array, ys: Int32Array, values: Float64Array, materials: Int32Array, count: number): void;
 }
+/**
+ * The tables of `createDisplayViewExpectedSignal` (see there) that are a function of the input's numbers alone: the materials,
+ * the lattice groups' geometry and combined kernels, and the per-material sums. Written only while they are built, never after:
+ * they are shared by every render of an input and, for chart materials, by every input of the same content (#449). Everything a
+ * render changes (each group's window cache and its origin and size, the bands, rings and counts) lives in the render.
+ */
+export interface SignalTables {
+    readonly reflectance: Float64Array;
+    readonly spectralIndex: Int32Array;
+    readonly spectral: readonly Float64Array[];
+    readonly groups: readonly GroupTables[];
+    readonly neutralDirect: readonly number[];
+    readonly spectralDirect: readonly (readonly number[])[];
+    readonly uniformSite: readonly Float64Array[];
+}
+/** A lattice group's fixed part: its fractional shift, members, index bounds, rectangle and combined kernels. */
+export interface GroupTables {
+    fx: number;
+    fy: number;
+    members: {
+        ix: number;
+        iy: number;
+        weight: number;
+    }[];
+    minIx: number;
+    maxIx: number;
+    minIy: number;
+    maxIy: number;
+    cw: number;
+    ch: number;
+    neutral: Float64Array[];
+    spectral: Float64Array[][];
+    perNode: Float64Array[][];
+}
+/** Chart-material tables kept by content across input objects (#449), least recently used first. */
+export declare const EXPECTED_SIGNAL_TABLE_CACHE_SIZE = 4;
+/** Internal test hook: the kept table entries, and the tables built and found by content so far. */
+export declare function expectedSignalTableCacheState(): {
+    size: number;
+    builds: number;
+    hits: number;
+};
+/** Internal test hook: forgets the tables kept by content (inputs already prepared keep theirs). */
+export declare function clearExpectedSignalTableCache(): void;
+/**
+ * Internal (#479): the read-only tables of an input (the ones `createDisplayViewExpectedSignal` reads), for the GPU display view,
+ * which uploads the combined kernels and per-material sums the reference forms in float64. Prepared and cached as a render
+ * prepares them, so a GPU render of an input and a CPU render read the same doubles.
+ */
+export declare function displayViewSignalTables(input: DisplayViewExpectedSignalInput): SignalTables;
 /**
  * Expected photo electrons per site: μ_c(i, j) = Σ_o w_o Σ_λ A_c(λ) Σ_t K_λ(t)·L(p_o(i, j) − t, λ), where p_o is the
  * query point of offset o and K the diffraction kernel (a single unit tap without diffraction). This is the sum the

package/dist/facade/expected-signal.js

@@ -16,7 +16,93 @@ const BAND_LIMIT = 1 << 22;
  */
 const LATTICE_RING_ROWS = 128, LATTICE_RING_MAXIMUM_BAND_ROWS = 64, LATTICE_RING_MARGIN = 64;
 const PREPARED = new WeakMap();
+/** Chart-material tables kept by content across input objects (#449), least recently used first. */
+export const EXPECTED_SIGNAL_TABLE_CACHE_SIZE = 4;
+const tableCache = [];
+let tableBuilds = 0, tableHits = 0;
+/** Internal test hook: the kept table entries, and the tables built and found by content so far. */
+export function expectedSignalTableCacheState() { return { size: tableCache.length, builds: tableBuilds, hits: tableHits }; }
+/** Internal test hook: forgets the tables kept by content (inputs already prepared keep theirs). */
+export function clearExpectedSignalTableCache() { tableCache.length = 0; }
+/**
+ * Every number the tables read, with the lengths that delimit them, as the bits of doubles (so -0, NaN and every digit are kept
+ * apart): the spectral nodes, the three channel responses, the offsets, the kernel radius and taps, each material's reflectance or
+ * radiance, and the white radiance. Undefined for radiance scenes, whose tables are not kept by content.
+ */
+function tableSignature(input) {
+    const scene = input.scene;
+    if (scene.kind !== "materials")
+        return undefined;
+    const values = [];
+    const push = (a) => { values.push(a.length); for (let i = 0; i < a.length; i++)
+        values.push(a[i]); };
+    push(input.wavelengthsNm);
+    values.push(input.electronsPerRadiance.length);
+    for (const a of input.electronsPerRadiance)
+        push(a);
+    values.push(input.offsets.length);
+    for (const o of input.offsets)
+        values.push(o.x, o.y, o.weight);
+    if (input.kernels) {
+        values.push(1, input.kernels.radius, input.kernels.perNode.length);
+        for (const k of input.kernels.perNode)
+            push(k);
+    }
+    else
+        values.push(0);
+    values.push(scene.materials.length);
+    for (const m of scene.materials)
+        if ("neutral" in m)
+            values.push(0, m.neutral);
+        else {
+            values.push(1);
+            push(m.radiance);
+        }
+    push(scene.whiteRadiance);
+    return new Uint32Array(Float64Array.from(values).buffer);
+}
+function sameBits(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
 function prepareSignal(input) {
+    const signature = tableSignature(input);
+    let tables;
+    if (signature) {
+        const at = tableCache.findIndex((entry) => sameBits(entry.signature, signature));
+        if (at >= 0) {
+            const [entry] = tableCache.splice(at, 1);
+            tableCache.push(entry);
+            tables = entry.tables;
+            tableHits++;
+        }
+    }
+    if (!tables) {
+        tables = buildTables(input);
+        tableBuilds++;
+        if (signature) {
+            tableCache.push({ signature, tables });
+            while (tableCache.length > EXPECTED_SIGNAL_TABLE_CACHE_SIZE)
+                tableCache.shift();
+        }
+    }
+    const prepared = { tables, rings: tables.groups.map(() => undefined) };
+    PREPARED.set(input, prepared);
+    return prepared;
+}
+/**
+ * Internal (#479): the read-only tables of an input (the ones `createDisplayViewExpectedSignal` reads), for the GPU display view,
+ * which uploads the combined kernels and per-material sums the reference forms in float64. Prepared and cached as a render
+ * prepares them, so a GPU render of an input and a CPU render read the same doubles.
+ */
+export function displayViewSignalTables(input) {
+    return (PREPARED.get(input) ?? prepareSignal(input)).tables;
+}
+function buildTables(input) {
     const nodes = input.wavelengthsNm.length, R = input.kernels ? input.kernels.radius : 0, size = 2 * R + 1;
     const A = input.electronsPerRadiance, scene = input.scene, offsets = input.offsets;
     const kernelAt = (node, t) => (input.kernels ? input.kernels.perNode[node][t] : 1);
@@ -26,11 +112,12 @@ function prepareSignal(input) {
     if (scene.kind === "materials") {
         reflectance = new Float64Array(scene.materials.length);
         spectralIndex = new Int32Array(scene.materials.length).fill(-1);
+        // A copy of each spectral radiance: the tables may outlive the input and serve other inputs of the same content.
         scene.materials.forEach((m, index) => { if ("neutral" in m)
             reflectance[index] = m.neutral;
         else {
             spectralIndex[index] = spectral.length;
-            spectral.push(m.radiance);
+            spectral.push(Float64Array.from(m.radiance));
         } });
     }
     // Offsets grouped by fractional shift: offsets that differ by whole sites share one lattice.
@@ -40,7 +127,7 @@ function prepareSignal(input) {
         const fx = frac(o.x), fy = frac(o.y), ix = Math.round(o.x - fx), iy = Math.round(o.y - fy);
         let group = groups.find((q) => Math.abs(q.fx - fx) <= OFFSET_TOLERANCE && Math.abs(q.fy - fy) <= OFFSET_TOLERANCE);
         if (!group) {
-            group = { fx, fy, members: [], minIx: ix, maxIx: ix, minIy: iy, maxIy: iy, cw: 0, ch: 0, neutral: [], spectral: [], perNode: [], cache: new Int32Array(0), cx0: 0, cy0: 0, cpw: 0, cph: 0 };
+            group = { fx, fy, members: [], minIx: ix, maxIx: ix, minIy: iy, maxIy: iy, cw: 0, ch: 0, neutral: [], spectral: [], perNode: [] };
             groups.push(group);
         }
         group.members.push({ ix, iy, weight: o.weight });
@@ -93,9 +180,10 @@ function prepareSignal(input) {
         }
         return sum;
     })) : [];
-    const prepared = { reflectance, spectralIndex, spectral, groups, neutralDirect, spectralDirect, uniformSite, rings: groups.map(() => undefined) };
-    PREPARED.set(input, prepared);
-    return prepared;
+    // Frozen records: a render copies each group before it gives it a window (see createDisplayViewExpectedSignal).
+    for (const group of groups)
+        Object.freeze(group);
+    return Object.freeze({ reflectance, spectralIndex, spectral, groups, neutralDirect, spectralDirect, uniformSite });
 }
 /**
  * Expected photo electrons per site: μ_c(i, j) = Σ_o w_o Σ_λ A_c(λ) Σ_t K_λ(t)·L(p_o(i, j) − t, λ), where p_o is the
@@ -120,9 +208,10 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
     const A = input.electronsPerRadiance, scene = input.scene, offsets = input.offsets, channelAt = input.channelAt;
     // The request's tables (materials, lattice groups, combined kernels, per-material sums) are the same for every render of a
     // prepared view, which passes the same input object: computed once per input. Each render gets its own groups' window caches.
+    // Chart-material tables are also shared by inputs of the same content (#449): each render gets its own groups' window state.
     const prepared = PREPARED.get(input) ?? prepareSignal(input);
-    const { reflectance, spectralIndex, spectral, neutralDirect, spectralDirect, uniformSite } = prepared;
-    const groups = prepared.groups.map((group) => ({ ...group, cache: new Int32Array(0), cx0: 0, cy0: 0, cpw: 0, cph: 0 }));
+    const { reflectance, spectralIndex, spectral, neutralDirect, spectralDirect, uniformSite } = prepared.tables;
+    const groups = prepared.tables.groups.map((group) => ({ ...group, cache: new Int32Array(0), cx0: 0, cy0: 0, cpw: 0, cph: 0 }));
     let lookups = 0;
     const point = new Float64Array(2);
     const materialSignalDirect = (m, c) => {
@@ -131,15 +220,21 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
             throw new InvalidConfigurationError("Unknown chart material.");
         return si < 0 ? reflectance[m] * neutralDirect[c] : spectralDirect[c][si];
     };
-    /** Without diffraction: one site from the environment's own query points. */
+    /**
+     * Without diffraction: one site from the environment's own query points. Also sets lastMaterial: the chart material every
+     * query point read, or −1 when they read more than one (or the scene is a radiance scene). A site whose points all read
+     * material m sums the same operands in the same order as every other such site of its channel, so it holds the same value.
+     */
     function directSite(x, y) {
         const c = channelAt(x, y);
-        let sum = 0;
+        let sum = 0, uniform = -1;
         for (let o = 0; o < offsets.length; o++) {
             input.queryPoint(x, y, o, point);
             let value;
             if (scene.kind === "materials") {
-                value = materialSignalDirect(scene.materialAt(point[0], point[1]), c);
+                const m = scene.materialAt(point[0], point[1]);
+                uniform = o === 0 || uniform === m ? m : -2;
+                value = materialSignalDirect(m, c);
                 lookups++;
             }
             else {
@@ -150,6 +245,7 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
             }
             sum += offsets[o].weight * value;
         }
+        lastMaterial = uniform < 0 ? -1 : uniform;
         return sum;
     }
     // Lattice point (p, q) of a group: the facade's lattice formula (createDiffractedPlanarProvider).
@@ -226,7 +322,8 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
         changeLeft: new Int32Array(0), changeUp: new Int32Array(0), v: new Float64Array(0) }));
     // Lattice rows of material indices per group, kept across windows (filled windows only): rows LATTICE_RING_ROWS apart share a
     // slot; columns from −LATTICE_RING_MARGIN. Int16 when every index fits (about 3 MB for four groups of a 6000-site row). A
-    // lattice point's material depends only on the input, so the rings are kept with its prepared tables, across renders.
+    // lattice point's material depends only on the input, so the rings are kept per input object, across its renders (not with
+    // the tables kept by content: they depend on `materialAt` and the raster).
     const ringWide = scene.kind === "materials" && scene.materials.length <= 32767;
     const rings = prepared.rings;
     function latticeRing(g) {
@@ -412,8 +509,9 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
         return v;
     }
     // Without diffraction (#392): site values persist across windows the same way, in their own ring (a site's value does not
-    // depend on the window). A ring hit counts the lookups directSite would have made, so `lookups` is unchanged.
-    let directRows = 0, directOn = false, directRing = new Float64Array(0), directRowId = new Int32Array(0);
+    // depend on the window). A ring hit counts the lookups directSite would have made, so `lookups` is unchanged. The site's
+    // material (directSite's lastMaterial) is kept beside its value, so the display view's one-material memo applies (#444).
+    let directRows = 0, directOn = false, directRing = new Float64Array(0), directRowId = new Int32Array(0), directRingMaterial = new Int32Array(0);
     const directLookups = offsets.length * (scene.kind === "materials" ? 1 : nodes);
     function directRead(x, y) {
         const slot = y & (directRows - 1), q = slot * W + x;
@@ -421,6 +519,7 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
             const v = directRing[q];
             if (v === v) {
                 lookups += directLookups;
+                lastMaterial = directRingMaterial[q];
                 return v;
             }
         }
@@ -430,14 +529,17 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
         }
         const v = directSite(x, y);
         directRing[q] = v;
+        directRingMaterial[q] = lastMaterial;
         return v;
     }
     /** A site not in the window's site cache: from a ring, a filled window without the ring, the lazy window caches, or uncached. */
     function siteMiss(x, y, i, j, cached) {
         if (directOn) {
             const v = directRead(x, y);
-            if (cached)
+            if (cached) {
                 siteCache[j * sw + i] = v;
+                windowMaterial[j * sw + i] = lastMaterial;
+            }
             return v;
         }
         if (ringOn) {
@@ -464,22 +566,66 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
     /**
      * Lattice points of the closing window that kernelSite's lazy cache would have looked up: per group, the window cache points
      * covered by the rectangles of the computed sites (the site cache's filled entries and the outside sites), a box dilation.
+     * A group's count depends only on the computed sites and its geometry (cw, ch, cpw, cph), so a group shaped like an
+     * earlier one takes that group's count (the app's Quality groups all have one shape).
      */
+    const groupTotals = new Float64Array(groups.length);
+    function sameGeometry(g) {
+        const group = groups[g];
+        for (let h = 0; h < g; h++) {
+            const o = groups[h];
+            if (o.cw === group.cw && o.ch === group.ch && o.cpw === group.cpw && o.cph === group.cph)
+                return h;
+        }
+        return -1;
+    }
     function windowLookups() {
         let total = 0;
         if (outsideSites.length === 0 && filledCount === 0)
             return 0;
+        if (outsideSites.length === 0 && filledCount === sw * sh) {
+            // Every site computed (each once) and none outside: the marks at (i + cw − 1, j + ch − 1) cover cache columns
+            // 0 … sw + cw − 2 and rows 0 … sh + ch − 2, the whole cpw × cph cache of every group.
+            for (const group of groups)
+                total += group.cpw * group.cph;
+            return total;
+        }
         if (outsideSites.length === 0 && sw <= 31) {
             // Computed sites as a bit mask per window row. Cache point (ci, cj) is covered when a computed site (i, j) has
             // i ≤ ci < i + cw and j ≤ cj < j + ch; a union of dilations is the dilation of the union, so per cache row the
-            // covered columns are the dilation of the OR of the masks of window rows cj − ch + 1 … cj.
-            for (const group of groups) {
-                const cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, last = Math.min(cph - 1, fy1 + ch - 1);
+            // covered columns are the dilation of the OR of the masks of window rows cj − ch + 1 … cj. That OR is a prefix OR
+            // when the rows start at fy0 and a suffix OR when they end at fy1 (OR is associative and commutative).
+            if (prefixOr.length < sh) {
+                prefixOr = new Int32Array(sh);
+                suffixOr = new Int32Array(sh);
+            }
+            for (let j = fy0, m = 0; j <= fy1; j++) {
+                m |= rowMask[j];
+                prefixOr[j] = m;
+            }
+            for (let j = fy1, m = 0; j >= fy0; j--) {
+                m |= rowMask[j];
+                suffixOr[j] = m;
+            }
+            for (let g = 0; g < groups.length; g++) {
+                const same = sameGeometry(g);
+                if (same >= 0) {
+                    total += groupTotals[same];
+                    groupTotals[g] = groupTotals[same];
+                    continue;
+                }
+                const group = groups[g], cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, last = Math.min(cph - 1, fy1 + ch - 1), before = total;
                 let previous = -1, width = 0;
                 for (let cj = fy0; cj <= last; cj++) {
                     let m = 0;
-                    for (let j = Math.max(fy0, cj - ch + 1), top = Math.min(fy1, cj); j <= top; j++)
-                        m |= rowMask[j];
+                    const a = Math.max(fy0, cj - ch + 1), b = Math.min(fy1, cj);
+                    if (a === fy0)
+                        m = prefixOr[b];
+                    else if (b === fy1)
+                        m = suffixOr[a];
+                    else
+                        for (let j = a; j <= b; j++)
+                            m |= rowMask[j];
                     if (m !== previous) {
                         previous = m;
                         width = 0;
@@ -498,11 +644,20 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
                     }
                     total += width;
                 }
+                groupTotals[g] = total - before;
             }
             return total;
         }
-        for (const group of groups) {
-            const cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, ew = cpw + cw - 1, eh = cph + ch - 1;
+        for (let g = 0; g < groups.length; g++) {
+            // The marks are the computed sites shifted by (cw − 1, ch − 1), so the count depends on the group's geometry only.
+            const same = sameGeometry(g);
+            if (same >= 0) {
+                total += groupTotals[same];
+                groupTotals[g] = groupTotals[same];
+                continue;
+            }
+            const group = groups[g], cw = group.cw, ch = group.ch, cpw = group.cpw, cph = group.cph, ew = cpw + cw - 1, eh = cph + ch - 1, before = total;
+            groupTotals[g] = 0;
             // Top-left marks in extended coordinates (window coordinates + (cw − 1, ch − 1)), and their bounding box.
             if (marks.length < ew * eh) {
                 marks = new Uint8Array(ew * eh);
@@ -557,6 +712,7 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
                         total++;
                 }
             }
+            groupTotals[g] = total - before;
         }
         return total;
     }
@@ -564,7 +720,7 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
     // The computed entries of a filled window's site cache (windowLookups): their count, bounding box and a bit mask per row
     // (columns below 31).
     let filledCount = 0, fx0 = 0, fx1 = -1, fy0 = 0, fy1 = -1;
-    let rowMask = new Int32Array(0);
+    let rowMask = new Int32Array(0), prefixOr = new Int32Array(0), suffixOr = new Int32Array(0);
     function markFilled(i, j) {
         if (i < 31)
             rowMask[j] = rowMask[j] | (1 << i);
@@ -586,8 +742,25 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
     return {
         get lookups() { return lookups + (filled ? windowLookups() : 0); },
         get uniformMaterial() { return lastMaterial; },
-        get tracksMaterial() { return ringOn; },
+        // Chart materials are tracked on the filled path and, without diffraction, on the direct ring (radiance scenes never).
+        get tracksMaterial() { return ringOn || (directOn && scene.kind === "materials"); },
         get cachesSites() { return sw > 0; },
+        get marksReads() { return filled; },
+        markReads(xs, ys, values, materials, count) {
+            for (let n = 0; n < count; n++) {
+                const i = xs[n] - sx0, j = ys[n] - sy0;
+                if (!(i >= 0 && j >= 0 && i < sw && j < sh))
+                    continue;
+                const w = j * sw + i;
+                if (siteCache[w] === siteCache[w])
+                    continue;
+                // As siteMiss for a site inside a filled window: the computed site is marked (windowLookups counts from the marks)
+                // and its material kept.
+                siteCache[w] = values[n];
+                windowMaterial[w] = materials[n];
+                markFilled(i, j);
+            }
+        },
         window(x0, y0, x1, y1) {
             if (filled)
                 lookups += windowLookups();
@@ -619,9 +792,12 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
                         directRows = rows;
                         directRing = new Float64Array(rows * W).fill(NaN);
                         directRowId = new Int32Array(rows).fill(-1);
+                        directRingMaterial = new Int32Array(rows * W);
                     }
                 }
                 directOn = sh > 0 && directRows >= 2 * sh;
+                if (directOn && windowMaterial.length < sw * sh)
+                    windowMaterial = new Int32Array(sw * sh);
                 return;
             }
             for (const group of groups) {
@@ -675,7 +851,7 @@ export function createDisplayViewExpectedSignal(input, spanColumns = Infinity) {
             if (cached) {
                 const w = j * sw + i, v = siteCache[w];
                 if (v === v) {
-                    if (ringOn)
+                    if (ringOn || directOn)
                         lastMaterial = windowMaterial[w];
                     return v;
                 }