@photivra/engine 2.19.0 → 2.21.0

package/dist/facade/representative-light-sources.js

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Representative light sources (#557): four relative spectral power distributions designed by Photivra for indoor
+ * light presets, so that two lights at the same correlated color temperature (CCT) can render colors differently.
+ *
+ * Every spectrum is an engine-defined analytic function of wavelength, not measured or copied data: a constant plus a
+ * sum of Gaussian bands,
+ *
+ *   S(λ) = b + Σₖ aₖ·exp(−½·((λ − μₖ)/σₖ)²),
+ *
+ * with λ in nanometers on 360–830 nm (the CIE 1931 observer's domain), in relative units (the capture facade scales an
+ * illuminant to its lux). Each source's band shapes were chosen by Photivra to represent a kind of lamp; two amplitudes
+ * (or one amplitude and one band center) were then solved so the chromaticity lies on the Planckian locus at the stated
+ * CCT, and rounded (amplitudes to 0.001, wavelengths to 0.1 nm). Those rounded values are the definition. The CCT and
+ * Duv of every rounded spectrum are checked with the engine's own `calculateCorrelatedColorTemperature` and
+ * `estimateCorrelatedColorTemperatureMcCamy` (docs/LIGHT_SOURCES.md, test/representative-light-sources.test.ts).
+ *
+ * These are representative constructions, not named products: no CIE, IES or manufacturer spectral data, names or
+ * tables are used. The bands are wider than the emission lines of real fluorescent phosphors so that the 5 nm sensor
+ * quadrature recommended for color work integrates them; real lamps of each kind vary widely.
+ *
+ * The exponentials use the portable `portableExp`, so a spectrum's values have the same bits in every JavaScript
+ * engine, in captures and in the display view alike.
+ *
+ * The module is not reached by `simulateCapture` itself: an application passes a spectrum as
+ * `illuminant: { kind: "spectrum", spectrum }` (or {@link createRepresentativeLightSourceIlluminant}), so bundles that
+ * do not use the sources do not contain them.
+ */
+import { InvalidConfigurationError } from "../core/configuration-error.js";
+import { InvalidScientificInputError } from "../core/validation.js";
+import { requireInputKeys } from "../core/record-validation.js";
+import { portableExp } from "../core/portable-math.js";
+/** Identity of the built-in light-source set. */
+export const REPRESENTATIVE_LIGHT_SOURCE_SET_ID = "photivra-representative-light-sources";
+/** Version of the set's spectra; a change to any spectrum changes it. */
+export const REPRESENTATIVE_LIGHT_SOURCE_SET_VERSION = "1.0.0";
+/** Domain of every spectrum, nm (the CIE 1931 observer's domain; the capture facade uses 380–780 nm of it). */
+export const REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS = /* @__PURE__ */ Object.freeze({ minimum: 360, maximum: 830 });
+/** The source ids, in set order. */
+export const REPRESENTATIVE_LIGHT_SOURCE_IDS = /* @__PURE__ */ Object.freeze([
+    "tri-phosphor-fluorescent-4000k", "white-led-low-rendering-4000k", "white-led-high-rendering-4000k", "warm-white-led-2700k"
+]);
+const LABEL = "representative, not a named product";
+/* Photivra's design (docs/LIGHT_SOURCES.md, "The spectra"); the solved values were rounded and are the definition. */
+const ROWS = [
+    ["tri-phosphor-fluorescent-4000k", "Tri-phosphor fluorescent, 4000 K", "fluorescent", 4000,
+        "Three narrow emission bands in the blue, green and red on a low continuum, the construction of a tri-phosphor fluorescent tube, which leaves gaps between the bands.",
+        0.02, [["blue phosphor band", 0.285, 450, 6], ["green phosphor line", 1, 544, 3.5], ["red phosphor line", 1.02, 611, 3.5]]],
+    ["white-led-low-rendering-4000k", "White LED, low color rendering, 4000 K", "led", 4000,
+        "A blue pump peak and one broad yellow phosphor band, the simplest white LED, which is weak in the cyan and the deep red.",
+        0, [["blue pump", 1.123, 450, 9], ["yellow phosphor", 1, 579.1, 50]]],
+    ["white-led-high-rendering-4000k", "White LED, high color rendering, 4000 K", "led", 4000,
+        "A blue pump with a green and a red phosphor band that fill the cyan and the red, a white LED built for high color rendering at the same CCT as the low-rendering one.",
+        0, [["blue pump", 1.306, 450, 9], ["green phosphor", 1, 530, 35], ["red phosphor", 1.264, 630, 40]]],
+    ["warm-white-led-2700k", "Warm white LED, 2700 K", "led", 2700,
+        "The same pump and two-phosphor construction with more red phosphor and less pump, a warm white LED for home lighting.",
+        0, [["blue pump", 0.795, 450, 9], ["green phosphor", 1, 540, 38], ["red phosphor", 2.133, 630, 40]]]
+];
+const SET = /* @__PURE__ */ (() => Object.freeze({
+    setId: REPRESENTATIVE_LIGHT_SOURCE_SET_ID,
+    setVersion: REPRESENTATIVE_LIGHT_SOURCE_SET_VERSION,
+    wavelengthRangeNanometers: REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS,
+    sources: Object.freeze(ROWS.map(([sourceId, name, family, cct, reason, base, bands]) => Object.freeze({
+        sourceId, name, family, nominalCorrelatedColorTemperatureKelvin: cct, label: LABEL, reason, base,
+        bands: Object.freeze(bands.map(([role, amplitude, centerNanometers, standardDeviationNanometers]) => Object.freeze({ kind: "gaussian", role, amplitude, centerNanometers, standardDeviationNanometers })))
+    })))
+}))();
+/**
+ * The built-in representative light sources: Photivra's own parametric spectra of a tri-phosphor fluorescent tube and
+ * three white LEDs (low and high color rendering at 4000 K, warm at 2700 K). A static, deeply frozen engine contract.
+ * Each is "representative, not a named product"; docs/LIGHT_SOURCES.md gives every formula and the reasons for it.
+ */
+export function getRepresentativeLightSourceSet() {
+    return SET;
+}
+function findSource(input, functionName) {
+    requireInputKeys(input, functionName, ["sourceId"]);
+    const id = input.sourceId;
+    const source = typeof id === "string" ? SET.sources.find((s) => s.sourceId === id) : undefined;
+    if (!source)
+        throw new InvalidConfigurationError("sourceId must be one of the built-in representative light sources (REPRESENTATIVE_LIGHT_SOURCE_IDS).");
+    return source;
+}
+/** Most wavelengths whose values one spectrum keeps (a capture uses a few hundred). */
+const CACHE_LIMIT = 4096;
+/**
+ * A source's relative spectral power distribution S(λ) = b + Σ aₖ·exp(−½((λ − μₖ)/σₖ)²) as a function spectrum on
+ * 360–830 nm (relative units; values memoized per wavelength). Pass it to a capture as
+ * `illuminant: { kind: "spectrum", spectrum }`; for color work use `sensor.spectralStepNanometers: 5` or finer
+ * (docs/LIGHT_SOURCES.md, "Quadrature"). Throws `InvalidScientificInputError` outside 360–830 nm.
+ */
+export function createRepresentativeLightSourceSpectrum(input) {
+    const source = findSource(input, "createRepresentativeLightSourceSpectrum");
+    const range = REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS, cache = new Map();
+    return {
+        kind: "function",
+        wavelengthRangeNanometers: { minimum: range.minimum, maximum: range.maximum },
+        evaluate(nm) {
+            const hit = cache.get(nm);
+            if (hit !== undefined)
+                return hit;
+            if (typeof nm !== "number" || !(nm >= range.minimum && nm <= range.maximum)) {
+                throw new InvalidScientificInputError("Representative light source " + source.sourceId + " is defined on 360–830 nm.");
+            }
+            let value = source.base;
+            for (const band of source.bands) {
+                const z = (nm - band.centerNanometers) / band.standardDeviationNanometers;
+                value += band.amplitude * portableExp(-0.5 * z * z);
+            }
+            if (cache.size < CACHE_LIMIT)
+                cache.set(nm, value);
+            return value;
+        }
+    };
+}
+/**
+ * A capture illuminant for a source: `{ kind: "spectrum", spectrum, label }` with the spectrum of
+ * {@link createRepresentativeLightSourceSpectrum} and the label "<name> (representative, not a named product)".
+ */
+export function createRepresentativeLightSourceIlluminant(input) {
+    const source = findSource(input, "createRepresentativeLightSourceIlluminant");
+    return { kind: "spectrum", spectrum: createRepresentativeLightSourceSpectrum({ sourceId: source.sourceId }), label: source.name + " (" + LABEL + ")" };
+}
+//# sourceMappingURL=representative-light-sources.js.map

package/dist/facade/representative-light-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"representative-light-sources.js","sourceRoot":"","sources":["../../src/facade/representative-light-sources.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Representative light sources (#557): four relative spectral power distributions designed by Photivra for indoor\n * light presets, so that two lights at the same correlated color temperature (CCT) can render colors differently.\n *\n * Every spectrum is an engine-defined analytic function of wavelength, not measured or copied data: a constant plus a\n * sum of Gaussian bands,\n *\n *   S(λ) = b + Σₖ aₖ·exp(−½·((λ − μₖ)/σₖ)²),\n *\n * with λ in nanometers on 360–830 nm (the CIE 1931 observer's domain), in relative units (the capture facade scales an\n * illuminant to its lux). Each source's band shapes were chosen by Photivra to represent a kind of lamp; two amplitudes\n * (or one amplitude and one band center) were then solved so the chromaticity lies on the Planckian locus at the stated\n * CCT, and rounded (amplitudes to 0.001, wavelengths to 0.1 nm). Those rounded values are the definition. The CCT and\n * Duv of every rounded spectrum are checked with the engine's own `calculateCorrelatedColorTemperature` and\n * `estimateCorrelatedColorTemperatureMcCamy` (docs/LIGHT_SOURCES.md, test/representative-light-sources.test.ts).\n *\n * These are representative constructions, not named products: no CIE, IES or manufacturer spectral data, names or\n * tables are used. The bands are wider than the emission lines of real fluorescent phosphors so that the 5 nm sensor\n * quadrature recommended for color work integrates them; real lamps of each kind vary widely.\n *\n * The exponentials use the portable `portableExp`, so a spectrum's values have the same bits in every JavaScript\n * engine, in captures and in the display view alike.\n *\n * The module is not reached by `simulateCapture` itself: an application passes a spectrum as\n * `illuminant: { kind: \"spectrum\", spectrum }` (or {@link createRepresentativeLightSourceIlluminant}), so bundles that\n * do not use the sources do not contain them.\n */\n\nimport { InvalidConfigurationError } from \"../core/configuration-error.js\";\nimport { InvalidScientificInputError } from \"../core/validation.js\";\nimport { requireInputKeys } from \"../core/record-validation.js\";\nimport { portableExp } from \"../core/portable-math.js\";\nimport type { ColorimetricSpectrum } from \"../color/color-matching-functions.js\";\nimport type { CaptureIlluminant } from \"./scene-radiance.js\";\n\n/** Identity of the built-in light-source set. */\nexport const REPRESENTATIVE_LIGHT_SOURCE_SET_ID = \"photivra-representative-light-sources\";\n/** Version of the set's spectra; a change to any spectrum changes it. */\nexport const REPRESENTATIVE_LIGHT_SOURCE_SET_VERSION = \"1.0.0\";\n/** Domain of every spectrum, nm (the CIE 1931 observer's domain; the capture facade uses 380–780 nm of it). */\nexport const REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS = /* @__PURE__ */ Object.freeze({ minimum: 360, maximum: 830 });\n\n/** The source ids, in set order. */\nexport const REPRESENTATIVE_LIGHT_SOURCE_IDS = /* @__PURE__ */ Object.freeze([\n  \"tri-phosphor-fluorescent-4000k\", \"white-led-low-rendering-4000k\", \"white-led-high-rendering-4000k\", \"warm-white-led-2700k\"\n] as const);\nexport type RepresentativeLightSourceId = (typeof REPRESENTATIVE_LIGHT_SOURCE_IDS)[number];\n\n/** One Gaussian band a·exp(−½((λ − μ)/σ)²) of a source spectrum. */\nexport interface RepresentativeLightSourceBand {\n  kind: \"gaussian\";\n  /** What the band represents, for example \"blue pump\" or \"green phosphor line\". */\n  role: string;\n  amplitude: number;\n  centerNanometers: number;\n  standardDeviationNanometers: number;\n}\n\n/** One built-in source: its id, name, design reason and spectrum definition. */\nexport interface RepresentativeLightSource {\n  sourceId: RepresentativeLightSourceId;\n  /** Photivra's descriptive name, for example \"White LED, high color rendering, 4000 K\". */\n  name: string;\n  family: \"fluorescent\" | \"led\";\n  /** The CCT the spectrum was designed for, K (its computed CCT is within 1 K of it, Duv within 0.0001; docs/LIGHT_SOURCES.md). */\n  nominalCorrelatedColorTemperatureKelvin: number;\n  /** Always \"representative, not a named product\". */\n  label: \"representative, not a named product\";\n  /** One sentence: what the source represents and why it is built this way. */\n  reason: string;\n  /** The constant b (a low continuum), relative units. */\n  base: number;\n  bands: readonly RepresentativeLightSourceBand[];\n}\n\nexport interface RepresentativeLightSourceSet {\n  setId: typeof REPRESENTATIVE_LIGHT_SOURCE_SET_ID;\n  setVersion: typeof REPRESENTATIVE_LIGHT_SOURCE_SET_VERSION;\n  wavelengthRangeNanometers: { readonly minimum: number; readonly maximum: number };\n  sources: readonly RepresentativeLightSource[];\n}\n\nconst LABEL = \"representative, not a named product\" as const;\ntype BandRow = readonly [role: string, amplitude: number, centerNanometers: number, standardDeviationNanometers: number];\n/* Photivra's design (docs/LIGHT_SOURCES.md, \"The spectra\"); the solved values were rounded and are the definition. */\nconst ROWS: readonly (readonly [RepresentativeLightSourceId, string, \"fluorescent\" | \"led\", number, string, number, readonly BandRow[]])[] = [\n  [\"tri-phosphor-fluorescent-4000k\", \"Tri-phosphor fluorescent, 4000 K\", \"fluorescent\", 4000,\n    \"Three narrow emission bands in the blue, green and red on a low continuum, the construction of a tri-phosphor fluorescent tube, which leaves gaps between the bands.\",\n    0.02, [[\"blue phosphor band\", 0.285, 450, 6], [\"green phosphor line\", 1, 544, 3.5], [\"red phosphor line\", 1.02, 611, 3.5]]],\n  [\"white-led-low-rendering-4000k\", \"White LED, low color rendering, 4000 K\", \"led\", 4000,\n    \"A blue pump peak and one broad yellow phosphor band, the simplest white LED, which is weak in the cyan and the deep red.\",\n    0, [[\"blue pump\", 1.123, 450, 9], [\"yellow phosphor\", 1, 579.1, 50]]],\n  [\"white-led-high-rendering-4000k\", \"White LED, high color rendering, 4000 K\", \"led\", 4000,\n    \"A blue pump with a green and a red phosphor band that fill the cyan and the red, a white LED built for high color rendering at the same CCT as the low-rendering one.\",\n    0, [[\"blue pump\", 1.306, 450, 9], [\"green phosphor\", 1, 530, 35], [\"red phosphor\", 1.264, 630, 40]]],\n  [\"warm-white-led-2700k\", \"Warm white LED, 2700 K\", \"led\", 2700,\n    \"The same pump and two-phosphor construction with more red phosphor and less pump, a warm white LED for home lighting.\",\n    0, [[\"blue pump\", 0.795, 450, 9], [\"green phosphor\", 1, 540, 38], [\"red phosphor\", 2.133, 630, 40]]]\n];\n\nconst SET: RepresentativeLightSourceSet = /* @__PURE__ */ ((): RepresentativeLightSourceSet => Object.freeze({\n  setId: REPRESENTATIVE_LIGHT_SOURCE_SET_ID,\n  setVersion: REPRESENTATIVE_LIGHT_SOURCE_SET_VERSION,\n  wavelengthRangeNanometers: REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS,\n  sources: Object.freeze(ROWS.map(([sourceId, name, family, cct, reason, base, bands]) => Object.freeze({\n    sourceId, name, family, nominalCorrelatedColorTemperatureKelvin: cct, label: LABEL, reason, base,\n    bands: Object.freeze(bands.map(([role, amplitude, centerNanometers, standardDeviationNanometers]) =>\n      Object.freeze({ kind: \"gaussian\" as const, role, amplitude, centerNanometers, standardDeviationNanometers })))\n  })))\n}))();\n\n/**\n * The built-in representative light sources: Photivra's own parametric spectra of a tri-phosphor fluorescent tube and\n * three white LEDs (low and high color rendering at 4000 K, warm at 2700 K). A static, deeply frozen engine contract.\n * Each is \"representative, not a named product\"; docs/LIGHT_SOURCES.md gives every formula and the reasons for it.\n */\nexport function getRepresentativeLightSourceSet(): RepresentativeLightSourceSet {\n  return SET;\n}\n\nfunction findSource(input: unknown, functionName: string): RepresentativeLightSource {\n  requireInputKeys(input, functionName, [\"sourceId\"]);\n  const id = (input as { sourceId?: unknown }).sourceId;\n  const source = typeof id === \"string\" ? SET.sources.find((s) => s.sourceId === id) : undefined;\n  if (!source) throw new InvalidConfigurationError(\"sourceId must be one of the built-in representative light sources (REPRESENTATIVE_LIGHT_SOURCE_IDS).\");\n  return source;\n}\n\n/** Most wavelengths whose values one spectrum keeps (a capture uses a few hundred). */\nconst CACHE_LIMIT = 4096;\n\n/**\n * A source's relative spectral power distribution S(λ) = b + Σ aₖ·exp(−½((λ − μₖ)/σₖ)²) as a function spectrum on\n * 360–830 nm (relative units; values memoized per wavelength). Pass it to a capture as\n * `illuminant: { kind: \"spectrum\", spectrum }`; for color work use `sensor.spectralStepNanometers: 5` or finer\n * (docs/LIGHT_SOURCES.md, \"Quadrature\"). Throws `InvalidScientificInputError` outside 360–830 nm.\n */\nexport function createRepresentativeLightSourceSpectrum(input: { sourceId: RepresentativeLightSourceId }): ColorimetricSpectrum {\n  const source = findSource(input, \"createRepresentativeLightSourceSpectrum\");\n  const range = REPRESENTATIVE_LIGHT_SOURCE_WAVELENGTH_RANGE_NANOMETERS, cache = new Map<number, number>();\n  return {\n    kind: \"function\",\n    wavelengthRangeNanometers: { minimum: range.minimum, maximum: range.maximum },\n    evaluate(nm: number): number {\n      const hit = cache.get(nm);\n      if (hit !== undefined) return hit;\n      if (typeof nm !== \"number\" || !(nm >= range.minimum && nm <= range.maximum)) {\n        throw new InvalidScientificInputError(\"Representative light source \" + source.sourceId + \" is defined on 360–830 nm.\");\n      }\n      let value = source.base;\n      for (const band of source.bands) {\n        const z = (nm - band.centerNanometers) / band.standardDeviationNanometers;\n        value += band.amplitude * portableExp(-0.5 * z * z);\n      }\n      if (cache.size < CACHE_LIMIT) cache.set(nm, value);\n      return value;\n    }\n  };\n}\n\n/**\n * A capture illuminant for a source: `{ kind: \"spectrum\", spectrum, label }` with the spectrum of\n * {@link createRepresentativeLightSourceSpectrum} and the label \"<name> (representative, not a named product)\".\n */\nexport function createRepresentativeLightSourceIlluminant(input: { sourceId: RepresentativeLightSourceId }): Extract<CaptureIlluminant, { kind: \"spectrum\" }> {\n  const source = findSource(input, \"createRepresentativeLightSourceIlluminant\");\n  return { kind: \"spectrum\", spectrum: createRepresentativeLightSourceSpectrum({ sourceId: source.sourceId }), label: source.name + \" (\" + LABEL + \")\" };\n}\n"]}

package/dist/facade/scene-radiance.d.ts

@@ -101,6 +101,115 @@ export interface CallerMaterialScene {
 }
 /** Most materials a {@link CallerMaterialScene} may list. */
 export declare const CALLER_MATERIAL_SCENE_MAX_MATERIALS = 65536;
+/**
+ * 2.21 (#581): an image the caller supplies, for an {@link ImagePlaneScene}. `data` holds `width × height` pixels row by row
+ * from the top, `channels` (3: RGB, 4: RGBA) samples each, in the encoding's type: `srgb-8` Uint8Array or Uint8ClampedArray
+ * (canvas `ImageData.data`), `srgb-16` Uint16Array, `linear-srgb` Float32Array. sRGB primaries and white (IEC 61966-2-1) in
+ * every encoding; `srgb-8` and `srgb-16` are decoded with the sRGB transfer function, `linear-srgb` is already linear and is
+ * clipped to [0, 1] (the clipped samples are counted). Alpha is linear coverage over the paper. The array is read, never
+ * changed or kept beyond the call.
+ */
+export interface ImagePlaneImage {
+    width: number;
+    height: number;
+    channels: 3 | 4;
+    encoding: "srgb-8" | "srgb-16" | "linear-srgb";
+    data: Uint8Array | Uint8ClampedArray | Uint16Array | Float32Array;
+}
+/**
+ * 2.21 (#581): a photo as a flat matte print on the scene plane, lit by the request's illuminant like a chart. Each pixel's
+ * color becomes a reflectance spectrum through the engine's print reflectance lattice (docs/IMAGE_PLANE.md): an
+ * approximation, a print of an image that was already processed, clipped and blurred by the camera that took it. The print's
+ * physical size is `chartSize` (its height defaults to the image's aspect); without it the print is fitted inside the frame,
+ * centered, on the 18 % surround.
+ */
+export interface ImagePlaneScene {
+    kind: "image-plane";
+    sceneId: string;
+    image: ImagePlaneImage;
+    /** The paper and the deepest ink: reflectances of sRGB white and black, 0 ≤ black < white ≤ 1. Defaults 0.90 and 0.01. */
+    paper?: {
+        whiteReflectance?: number;
+        blackReflectance?: number;
+    };
+    /** How the print is reconstructed between pixel centers. Default `bilinear` (the pixels' spectra, bilinearly weighted). */
+    interpolation?: "bilinear" | "nearest";
+    /** Opt-in raised pixel limit: an integer up to the full-resolution ceiling. Default 24 000 000 pixels. */
+    maximumPixels?: number;
+}
+/**
+ * Internal (#581): what a pixel's signals are integrated from (`ResolvedImagePlaneScene.pixelSignals`): the lattice's node spectra at
+ * the N spectral nodes (node k's reflectance at λ_n at k·N + n), the white radiance and the channel responses per node.
+ */
+export interface ImagePlaneSpectralNodes {
+    count: number;
+    nodeSpectra: Float64Array;
+    whiteRadiance: Float64Array;
+    response: readonly Float64Array[];
+}
+/**
+ * Internal (#581): an image-plane print as the tabulated expected signal's scene (`ResolvedImagePlaneScene.signalScene`): its radiance
+ * per node, the direct path's signal (each pixel's Σ_n A_c(λ_n)·L_n integrated from its reconstructed spectrum, `pixelSignals`, then
+ * interpolated between pixels), and (for the GPU module) the scene, its spectral nodes and the surround's channel signals.
+ */
+export interface ImagePlaneSignalScene {
+    kind: "radiance";
+    radianceAt(u: number, v: number, nm: number): number;
+    signalAt(u: number, v: number, c: number): number;
+    image: {
+        scene: ResolvedImagePlaneScene;
+        nodes: ImagePlaneSpectralNodes;
+        surround: readonly [number, number, number];
+        whiteRadiance: Float64Array;
+        surroundReflectance: number;
+    };
+}
+/**
+ * Internal (#581): a validated image-plane scene (src/facade/image-plane.ts, a lazily loaded module), placed on a print of
+ * aspect `aspect` (height / width). Print-local coordinates are the chart's: cu = ±1 at the print's left and right edges, cv up
+ * on the same scale, ±aspect at its top and bottom.
+ */
+export interface ResolvedImagePlaneScene {
+    kind: "image-plane";
+    sceneId: string;
+    width: number;
+    height: number;
+    aspect: number;
+    channels: 3 | 4;
+    encoding: ImagePlaneImage["encoding"];
+    interpolation: "bilinear" | "nearest";
+    paperWhiteReflectance: number;
+    paperBlackReflectance: number;
+    maximumPixels: number;
+    /** `linear-srgb` samples (color and alpha) clipped to [0, 1]; 0 for the integer encodings. */
+    clippedSampleCount: number;
+    /** SHA-256 of the image data's bytes, hex. */
+    dataSha256: string;
+    /** The print's reflectance at a print-local point and wavelength (nm, 380–780). */
+    reflectanceAt(cu: number, cv: number, nm: number): number;
+    /**
+     * One pixel's three channel signals Σ_n A_c(λ_n)·ρ_n·W_n, integrated from its reconstructed spectrum ρ_n (its cell's node spectra
+     * blended, then the paper) at the time of use, into `out[at..at + 2]`. No per-channel values of the lattice nodes are formed.
+     */
+    pixelSignals(index: number, nodes: ImagePlaneSpectralNodes, out: Float64Array, at: number): void;
+    /** The print at a print-local point in node values (`nodeValues[k]` of node k, `neutral` of the flat reflectance 1). */
+    sampleAt(cu: number, cv: number, nodeValues: Float64Array, neutral: number): number;
+    /** One pixel (row-major index) in node values. */
+    pixelValue(index: number, nodeValues: Float64Array, neutral: number): number;
+    /** One pixel's lattice cell (its base node r·25 + g·5 + b, returned) and its fractions within the cell per channel (written to `out[0..2]`). */
+    pixelLattice(index: number, out: Float64Array): number;
+    /** Every lattice node's reflectance at one wavelength (nm, 380–780). */
+    nodeReflectances(nm: number): Float64Array;
+    /**
+     * The print placed on the plane (frame point → print-local cu = u·scale/half, cv = v·scale/half; outside |cu| ≤ 1, |cv| ≤ aspect the
+     * surround) as the expected signal's scene at these nodes, responses and white radiance (see `ImagePlaneSignalScene`).
+     */
+    signalScene(wavelengths: readonly number[], perNode: readonly Float64Array[], whiteRadiance: Float64Array, radianceAt: (u: number, v: number, nm: number) => number, scale: number, half: number, surroundReflectance: number): ImagePlaneSignalScene;
+    /** The scene's form in the facade's source digest (the image's SHA-256 and shape, the paper, the interpolation, the lattice version). */
+    digestForm: Readonly<Record<string, unknown>>;
+    /** The result's `scene.parameters`: the image, paper and interpolation, the clipped samples and the image's SHA-256. */
+    parameters: Readonly<Record<string, unknown>>;
+}
 /** Internal: a validated material scene with its materials prepared (and the caller inputs, for the scene digest). */
 export interface ResolvedCallerMaterialScene {
     kind: "material-function";
@@ -110,7 +219,7 @@ export interface ResolvedCallerMaterialScene {
     materialAt(point: Readonly<SceneMaterialPoint>): number;
 }
 /** Internal: a validated caller scene. */
-export type ResolvedCallerScene = CallerReflectanceScene | CallerRadianceScene | ResolvedCallerMaterialScene;
+export type ResolvedCallerScene = CallerReflectanceScene | CallerRadianceScene | ResolvedCallerMaterialScene | ResolvedImagePlaneScene;
 export interface PlanarSceneGeometry {
     distanceM: number;
     /** Metres per frame unit on the plane (half the framed width). */
@@ -131,8 +240,11 @@ export interface PlanarSceneRadianceProvider {
     providerProfileId: string;
     evaluateRadiance(request: Readonly<SceneRadianceEvaluationRequest>): SceneRadianceEvaluationResult;
     evaluateApertureRadiance(request: Readonly<SceneRadianceEvaluationRequest>, ray: Readonly<SensorApertureRay>): SceneRadianceEvaluationResult;
-    /** Spectral radiance at a plane point (frame units), the same value the callbacks return. */
-    radianceAt(u: number, v: number, wavelengthNanometers: number): number;
+    /**
+     * Spectral radiance at a plane point (frame units), the same value the callbacks return. #551: a moving subject's provider
+     * reads it at time `t` (seconds from the first opening, default 0); a still scene ignores it.
+     */
+    radianceAt(u: number, v: number, wavelengthNanometers: number, t?: number): number;
     /**
      * 2.3, chart scenes only: the chart material at a plane point (frame units), or `materials.length` for the
      * surround of a fixed-size chart; `materialRadiance` gives that material's spectral radiance, the same value
@@ -140,6 +252,12 @@ export interface PlanarSceneRadianceProvider {
      */
     chartMaterialAt?(u: number, v: number): number;
     materialRadiance?(material: number, wavelengthNanometers: number): number;
+    /**
+     * 2.21 (#581), image-plane scenes only: the tabulated expected signal's scene at these spectral nodes and channel responses, its
+     * radiance per node and, for the direct path, Σ_n A_c(λ_n)·L(λ_n) integrated from each pixel's reconstructed spectrum
+     * (`ResolvedImagePlaneScene.pixelSignals`, the surround's reflectance times the neutral signal outside the print).
+     */
+    imageSignalScene?(wavelengths: readonly number[], perNode: readonly Float64Array[]): ImagePlaneSignalScene;
 }
 /** Internal (#394): the material lookup of a provider built by {@link buildPlanarSceneRadianceProvider}, if it has one. */
 export declare function planarProviderMaterialOfDirection(provider: PlanarSceneRadianceProvider): ((direction: Readonly<{
@@ -171,6 +289,12 @@ export declare function buildPlanarSceneRadianceProvider(input: {
      * radiance instead of failing; the plane fills the forward hemisphere only. Omitted: such a query fails, as before.
      */
     zeroBeyondHorizon?: true;
+    /**
+     * #550, mixed illumination: the plane's spectral irradiance at a plane point, given in chart units (chart-local with a fixed-size
+     * chart, frame units without) and in metres from the optical axis, used instead of `irradianceScale`·S(λ). The provider then has no material access (the radiance at a point is
+     * no longer a function of its material alone), so every renderer reads `radianceAt`. A radiance-function scene is refused.
+     */
+    irradianceAt?: (u: number, v: number, xM: number, yM: number, wavelengthNanometers: number) => number;
 }): PlanarSceneRadianceProvider;
 /** 2.3: a chart's physical size on the scene plane (`simulateCapture` `chartSize`, `createPlanarSceneRadianceProvider` `chartSize`). */
 export interface ChartSizeOption {
@@ -199,7 +323,8 @@ export declare function resolveChartSizeOption(value: unknown, frameAspect: numb
  * provider `providerProfileId`.
  */
 export declare function createPlanarSceneRadianceProvider(input: {
-    scene: ChartScene | ChartMaterialLayerScene | CallerReflectanceScene | CallerRadianceScene | CallerMaterialScene;
+    /** An `image-plane` scene (#581) is refused: it is taken by the facade's capture and display-view functions, which load its module. */
+    scene: ChartScene | ChartMaterialLayerScene | CallerReflectanceScene | CallerRadianceScene | CallerMaterialScene | ImagePlaneScene;
     illuminant: CaptureIlluminant;
     illuminanceLux: number;
     distanceM: number;

package/dist/facade/scene-radiance.js

@@ -164,6 +164,7 @@ export function buildPlanarSceneRadianceProvider(input) {
     const evidence = input.evidence, limitations = input.limitations;
     const caller = "kind" in scene ? scene : undefined, chart = caller ? undefined : scene;
     const materialScene = caller?.kind === "material-function" ? caller : undefined, materials = chart ? chart.materials : materialScene?.materials;
+    const imageScene = caller?.kind === "image-plane" ? caller : undefined;
     const placed = geometry.chart, half = placed ? placed.widthM / 2 : 0, chartAspect = placed ? placed.heightM / placed.widthM : 0;
     const shapeAt = tabulatedSpectrum(illuminant.shape);
     /** A material scene's material at a frame point: the caller's index, or `materials.length` for a fixed-size chart's surround. */
@@ -183,6 +184,29 @@ export function buildPlanarSceneRadianceProvider(input) {
             throw new InvalidConfigurationError("Scene materialAt must return an index into its materials.");
         return index;
     }
+    const light = input.irradianceAt;
+    if (light && caller?.kind === "radiance-function")
+        throw new InvalidConfigurationError("illumination needs a lit scene; a radiance-function scene ignores the illuminant.");
+    // #581 with #550: a print's signals are integrated per pixel under one light (its spectral nodes); mixed light over a print is not modelled.
+    if (light && imageScene)
+        throw new InvalidConfigurationError("illumination cannot light an image-plane scene yet: the print's signals are integrated under one illuminant.");
+    /** #550: reflectance × the blended irradiance at the point (chart-local units with a fixed-size chart) / π. */
+    function litRadianceAt(u, v, nm) {
+        let cu = u, cv = v, reflectance;
+        if (placed) {
+            cu = u * scale / half;
+            cv = v * scale / half;
+        }
+        if (materialScene)
+            reflectance = materialReflectanceOf(callerMaterialAt(u, v), nm);
+        else if (placed && !(Math.abs(cu) <= 1 && Math.abs(cv) <= chartAspect))
+            reflectance = placed.surroundReflectance;
+        else if (chart)
+            reflectance = chart.reflectanceAt(cu, cv, nm);
+        else
+            reflectance = callerReflectance(placed ? { xM: u * scale, yM: v * scale, u, v, wavelengthNanometers: nm, chartU: cu, chartV: cv } : { xM: u * scale, yM: v * scale, u, v, wavelengthNanometers: nm });
+        return reflectance * light(cu, cv, u * scale, v * scale, nm) / Math.PI;
+    }
     function radianceAt(u, v, nm) {
         if (materialScene)
             return materialRadianceOf(callerMaterialAt(u, v), nm);
@@ -191,21 +215,26 @@ export function buildPlanarSceneRadianceProvider(input) {
             const xM = u * scale, yM = v * scale, cu = xM / half, cv = yM / half;
             if (!(Math.abs(cu) <= 1 && Math.abs(cv) <= chartAspect))
                 return placed.surroundReflectance * irradianceScale * shapeAt(nm) / Math.PI;
-            if (chart)
-                return chart.reflectanceAt(cu, cv, nm) * irradianceScale * shapeAt(nm) / Math.PI;
+            // #581: an image-plane print, like a chart, in print-local units.
+            const planar = chart ?? imageScene;
+            if (planar)
+                return planar.reflectanceAt(cu, cv, nm) * irradianceScale * shapeAt(nm) / Math.PI;
             return callerValue({ xM, yM, u, v, wavelengthNanometers: nm, chartU: cu, chartV: cv }, nm);
         }
         if (chart)
             return chart.reflectanceAt(u, v, nm) * irradianceScale * shapeAt(nm) / Math.PI;
         return callerValue({ xM: u * scale, yM: v * scale, u, v, wavelengthNanometers: nm }, nm);
     }
+    function callerReflectance(point) {
+        const value = caller.evaluate(point);
+        if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1)
+            throw new InvalidConfigurationError("Scene reflectance function must return a value in [0, 1].");
+        return value;
+    }
     function callerValue(point, nm) {
+        if (caller.kind === "reflectance-function")
+            return callerReflectance(point) * irradianceScale * shapeAt(nm) / Math.PI;
         const value = caller.evaluate(point);
-        if (caller.kind === "reflectance-function") {
-            if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1)
-                throw new InvalidConfigurationError("Scene reflectance function must return a value in [0, 1].");
-            return value * irradianceScale * shapeAt(nm) / Math.PI;
-        }
         if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
             throw new InvalidConfigurationError("Scene radiance function must return a finite non-negative radiance.");
         return value;
@@ -217,6 +246,9 @@ export function buildPlanarSceneRadianceProvider(input) {
     }
     /** Spectral radiance of material `material` (`materials.length`: a fixed-size chart's surround), in the chart's expression order. */
     function materialRadianceOf(material, nm) {
+        return materialReflectanceOf(material, nm) * irradianceScale * shapeAt(nm) / Math.PI;
+    }
+    function materialReflectanceOf(material, nm) {
         const m = materials[material];
         let value;
         if (m === undefined)
@@ -230,7 +262,7 @@ export function buildPlanarSceneRadianceProvider(input) {
         }
         if (!(value >= 0))
             throw new InvalidConfigurationError("Unknown chart material.");
-        return value * irradianceScale * shapeAt(nm) / Math.PI;
+        return value;
     }
     function chartMaterialAt(u, v) {
         if (!placed)
@@ -238,10 +270,12 @@ export function buildPlanarSceneRadianceProvider(input) {
         const cu = u * scale / half, cv = v * scale / half;
         return Math.abs(cu) <= 1 && Math.abs(cv) <= chartAspect ? chart.materialAt(cu, cv) : chart.materials.length;
     }
-    const chartAccess = chart ? { chartMaterialAt, materialRadiance: materialRadianceOf } :
+    const chartAccess = light ? {} : chart ? { chartMaterialAt, materialRadiance: materialRadianceOf } :
         materialScene ? { chartMaterialAt: callerMaterialAt, materialRadiance: materialRadianceOf } : {};
+    // #581: an image-plane print in node values at a frame point (the surround outside it), for the tabulated expected signal.
+    const imageAccess = imageScene ? { imageSignalScene: (wavelengths, perNode) => imageScene.signalScene(wavelengths, perNode, Float64Array.from(wavelengths, (nm) => irradianceScale * shapeAt(nm) / Math.PI), radianceAt, scale, half, placed.surroundReflectance) } : {};
     // #394: evaluateRadiance's own plane-point arithmetic; radianceAt is then materialRadianceOf(material, nm) for both scene forms.
-    const materialAtPoint = chart ? chartMaterialAt : materialScene ? callerMaterialAt : undefined;
+    const materialAtPoint = light ? undefined : chart ? chartMaterialAt : materialScene ? callerMaterialAt : undefined;
     const materialOfDirection = materialAtPoint === undefined ? undefined : (o) => {
         const lz = -o.z;
         if (!(lz > 0))
@@ -249,8 +283,9 @@ export function buildPlanarSceneRadianceProvider(input) {
         const t = distance / lz;
         return materialAtPoint(-o.x * t / scale, -o.y * t / scale);
     };
+    const radiance = light ? litRadianceAt : radianceAt;
     const provider = {
-        sceneId, providerProfileId, radianceAt, ...chartAccess,
+        sceneId, providerProfileId, radianceAt: radiance, ...chartAccess, ...imageAccess,
         evaluateRadiance(request) {
             const target = request.target;
             if (target.kind !== "environment-direction")
@@ -262,14 +297,14 @@ export function buildPlanarSceneRadianceProvider(input) {
                 throw new InvalidConfigurationError("Planar scene query does not point toward the scene plane.");
             }
             const t = distance / lz;
-            return result(request, radianceAt(-o.x * t / scale, -o.y * t / scale, request.wavelengthNanometers));
+            return result(request, radiance(-o.x * t / scale, -o.y * t / scale, request.wavelengthNanometers));
         },
         evaluateApertureRadiance(request, ray) {
             const d = ray.directionUnitVector, origin = ray.originM;
             if (!(d.z > 0))
                 throw new InvalidConfigurationError("Planar scene pupil ray does not point toward the scene plane.");
             const t = (distance - origin.z) / d.z;
-            return result(request, radianceAt((origin.x + d.x * t) / scale, (origin.y + d.y * t) / scale, request.wavelengthNanometers));
+            return result(request, radiance((origin.x + d.x * t) / scale, (origin.y + d.y * t) / scale, request.wavelengthNanometers));
         }
     };
     if (materialOfDirection)