@photivra/engine 1.4.0 → 2.0.0

package/dist/processing/processing-task.js

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: Apache-2.0
+import { InvalidConfigurationError } from "../core/configuration-error.js";
+import { InvalidScientificInputError, InvalidScientificResultError } from "../core/validation.js";
+import { requireAllowlistedRecord } from "../core/record-validation.js";
+import { DEFAULT_HOST_YIELD_CADENCE, createHostYieldGate } from "../capture/host-yield-cadence.js";
+/** Largest image (pixels per frame) any processing operator accepts. */
+export const PROCESSING_MAX_PIXELS = 1 << 26;
+/** Largest number of input frames (brackets, focus slices, panorama frames). */
+export const PROCESSING_MAX_FRAMES = 32;
+/** Default working-memory bound when `maximumWorkingBytes` is omitted (1 GiB). */
+export const PROCESSING_DEFAULT_MAXIMUM_WORKING_BYTES = 1 << 30;
+export const PROCESSING_MODEL_VERSION = "1.0.0";
+export function processingProvenance(model, assumptions) {
+    return { kind: "approximation", model, modelVersion: PROCESSING_MODEL_VERSION, assumptions: [...assumptions] };
+}
+/** Internal: wraps a row generator in the shared cancellable task contract. */
+export function createProcessingTask(spec) {
+    const hooks = requireProvider(spec.provider);
+    if (spec.estimatedWorkingBytes > spec.maximumWorkingBytes) {
+        throw new InvalidConfigurationError("Processing working memory estimate (" + spec.estimatedWorkingBytes + " bytes) exceeds maximumWorkingBytes.");
+    }
+    const yieldControl = hooks.yieldControl.bind(hooks), onProgress = hooks.onProgress?.bind(hooks);
+    const abort = new AbortController(), total = spec.totalTileCount;
+    let state = "ready", completed = 0, output = null;
+    const check = () => { if (abort.signal.aborted)
+        throw new InvalidConfigurationError("Processing task aborted."); };
+    return {
+        get state() { return state; },
+        get completedTileCount() { return completed; },
+        totalTileCount: total,
+        estimatedWorkingBytes: spec.estimatedWorkingBytes,
+        async run() {
+            if (state !== "ready")
+                throw new InvalidConfigurationError("Processing task is single-use.");
+            state = "running";
+            try {
+                const gate = createHostYieldGate(spec.cadence ?? DEFAULT_HOST_YIELD_CADENCE), body = spec.body();
+                for (;;) {
+                    check();
+                    const step = body.next();
+                    if (step.done === true) {
+                        output = step.value;
+                        break;
+                    }
+                    completed++;
+                    onProgress?.({ completedTileCount: completed, totalTileCount: total });
+                    if (gate.due()) {
+                        await yieldControl(abort.signal);
+                        check();
+                        gate.restart();
+                    }
+                }
+                if (completed !== total)
+                    throw new InvalidScientificResultError("Processing progress accounting disagrees with its plan.");
+                await yieldControl(abort.signal);
+                check();
+                state = "completed";
+            }
+            catch (error) {
+                output = null;
+                if (!abort.signal.aborted) {
+                    state = "failed";
+                    abort.abort();
+                }
+                throw error;
+            }
+        },
+        cancel() { if (state === "ready" || state === "running" || state === "completed") {
+            state = "cancelled";
+            abort.abort();
+            output = null;
+        } },
+        dispose() { if (state !== "transferred") {
+            state = "disposed";
+            abort.abort();
+            output = null;
+        } },
+        takeOutput() {
+            if (state !== "completed" || output === null)
+                throw new InvalidConfigurationError("Processing output unavailable.");
+            const value = output;
+            output = null;
+            state = "transferred";
+            return value;
+        }
+    };
+}
+function requireProvider(provider) {
+    const hooks = provider;
+    if (hooks === null || typeof hooks !== "object" || typeof hooks.yieldControl !== "function" ||
+        (hooks.onProgress !== undefined && typeof hooks.onProgress !== "function")) {
+        throw new InvalidConfigurationError("Processing requires a provider { yieldControl, onProgress? }.");
+    }
+    return hooks;
+}
+// ------------------------------------------------------------------ validation helpers (internal)
+export function requireOptions(value, keys, label) {
+    return requireAllowlistedRecord(value, keys, label + " must be an object with only the documented fields.");
+}
+export function requireFiniteIn(value, label, min, max, exclusiveMin = false) {
+    if (typeof value !== "number" || !Number.isFinite(value) || (exclusiveMin ? value <= min : value < min) || value > max) {
+        throw new InvalidScientificInputError(label + " must be a finite number in " + (exclusiveMin ? "(" : "[") + min + ", " + max + "].");
+    }
+    return value;
+}
+export function optionalFiniteIn(value, fallback, label, min, max, exclusiveMin = false) {
+    return value === undefined ? fallback : requireFiniteIn(value, label, min, max, exclusiveMin);
+}
+export function requireIntegerIn(value, label, min, max) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+        throw new InvalidConfigurationError(label + " must be an integer in [" + min + ", " + max + "].");
+    }
+    return value;
+}
+export function optionalIntegerIn(value, fallback, label, min, max) {
+    return value === undefined ? fallback : requireIntegerIn(value, label, min, max);
+}
+export function requireEnum(value, allowed, label, fallback) {
+    if (value === undefined && fallback !== undefined)
+        return fallback;
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        throw new InvalidConfigurationError(label + " must be one of " + allowed.join(", ") + ".");
+    }
+    return value;
+}
+export function maximumWorkingBytes(value) {
+    return optionalIntegerIn(value, PROCESSING_DEFAULT_MAXIMUM_WORKING_BYTES, "maximumWorkingBytes", 1, Number.MAX_SAFE_INTEGER);
+}
+/** Validates the shape (not the values) of an interleaved image; values are checked by `finiteRows`. */
+export function requireImage(value, label, channels = 3) {
+    const r = requireOptions(value, ["width", "height", "data"], label);
+    const width = requireIntegerIn(r.width, label + ".width", 1, PROCESSING_MAX_PIXELS);
+    const height = requireIntegerIn(r.height, label + ".height", 1, PROCESSING_MAX_PIXELS);
+    if (width * height > PROCESSING_MAX_PIXELS)
+        throw new InvalidConfigurationError(label + " exceeds " + PROCESSING_MAX_PIXELS + " pixels.");
+    if (!(r.data instanceof Float32Array) || r.data.length !== width * height * channels) {
+        throw new InvalidConfigurationError(label + ".data must be a Float32Array of width·height·" + channels + " samples.");
+    }
+    return { width, height, data: r.data };
+}
+/** Validates 1..PROCESSING_MAX_FRAMES same-size images. */
+export function requireImageList(value, label, minimum) {
+    if (!Array.isArray(value) || value.length < minimum || value.length > PROCESSING_MAX_FRAMES) {
+        throw new InvalidConfigurationError(label + " must contain " + minimum + " to " + PROCESSING_MAX_FRAMES + " images.");
+    }
+    const images = value.map((v, i) => requireImage(v, label + "[" + i + "]"));
+    if (images.some((im) => im.width !== images[0].width || im.height !== images[0].height)) {
+        throw new InvalidConfigurationError(label + " images must share one size.");
+    }
+    return images;
+}
+/** Row generator rejecting non-finite samples (one tile per row). */
+export function* finiteRows(data, width, height, channels, label, minimum = -Infinity) {
+    const stride = width * channels;
+    for (let y = 0; y < height; y++) {
+        for (let i = y * stride, end = i + stride; i < end; i++) {
+            const v = data[i];
+            if (!Number.isFinite(v) || v < minimum)
+                throw new InvalidScientificInputError(label + " samples must be finite" + (minimum > -Infinity ? " and ≥ " + minimum : "") + ".");
+        }
+        yield;
+    }
+}
+//# sourceMappingURL=processing-task.js.map

package/dist/processing/processing-task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing-task.js","sourceRoot":"","sources":["../../src/processing/processing-task.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared cancellable task wrapper and typed-image contracts for the standalone image-processing\n * operators: demosaic, HDR merge and encode, tone mapping, exposure fusion, focus stacking, panorama,\n * denoise, sharpening and synthetic grain.\n *\n * Each operator is a synchronous row generator. This wrapper steps through it and reports one\n * progress tile for each processed row of every pass. It awaits the host's `yieldControl` on the same\n * time budget as the native RAW tasks. How often it yields never changes the output.\n *\n * Inputs are read during `run()` and never written. Callers must not change them until `run()`\n * settles. Working memory is estimated in advance and capped by `maximumWorkingBytes`.\n * @see docs/PROCESSING.md for algorithms, sources, approximation status and limits.\n */\n\nimport type { CalculationProvenance } from \"../core/calculation-result.js\";\nimport { InvalidConfigurationError } from \"../core/configuration-error.js\";\nimport { InvalidScientificInputError, InvalidScientificResultError } from \"../core/validation.js\";\nimport { requireAllowlistedRecord } from \"../core/record-validation.js\";\nimport { DEFAULT_HOST_YIELD_CADENCE, createHostYieldGate, type HostYieldCadence } from \"../capture/host-yield-cadence.js\";\nimport type { NativeTaskProgress } from \"../output/native-capture-sdr.js\";\n\n/** Largest image (pixels per frame) any processing operator accepts. */\nexport const PROCESSING_MAX_PIXELS = 1 << 26;\n/** Largest number of input frames (brackets, focus slices, panorama frames). */\nexport const PROCESSING_MAX_FRAMES = 32;\n/** Default working-memory bound when `maximumWorkingBytes` is omitted (1 GiB). */\nexport const PROCESSING_DEFAULT_MAXIMUM_WORKING_BYTES = 1 << 30;\nexport const PROCESSING_MODEL_VERSION = \"1.0.0\" as const;\n\n/** Host hooks, the same shape as the native task providers. */\nexport interface ProcessingProvider {\n  /** Must yield to the host event loop, allowing cancellation/input events between rows. */\n  yieldControl(signal: AbortSignal): Promise<void>;\n  /** Optional observer called after each processed row of each pass; cannot change output. */\n  onProgress?(progress: NativeTaskProgress): void;\n}\n\nexport type ProcessingTaskState = \"ready\" | \"running\" | \"completed\" | \"cancelled\" | \"failed\" | \"disposed\" | \"transferred\";\n\n/** Single-use cancellable processing task. */\nexport interface ProcessingTask<T> {\n  readonly state: ProcessingTaskState;\n  /** Rows processed so far across every pass. */\n  readonly completedTileCount: number;\n  /** Total rows of every pass; known before `run()`. */\n  readonly totalTileCount: number;\n  /** Upper estimate of typed-array bytes allocated by the task, including its output. */\n  readonly estimatedWorkingBytes: number;\n  run(): Promise<void>;\n  cancel(): void;\n  dispose(): void;\n  takeOutput(): T;\n}\n\n/** Interleaved RGB image: `data[(y·width + x)·3 + c]`, row-major, +Y down. */\nexport interface ProcessingRgbImage {\n  width: number;\n  height: number;\n  data: Float32Array;\n}\n\n/** Linear RGB encodings the colour-aware operators accept (all D65). */\nexport type ProcessingLinearColorSpace = \"linear-srgb-d65\" | \"linear-display-p3-d65\" | \"linear-rec2020-d65\";\n\n/** Result provenance of a processing operator; processing outputs are never calibrated. */\nexport interface ProcessingProvenance extends CalculationProvenance {\n  kind: \"approximation\";\n  assumptions: readonly string[];\n}\n\nexport function processingProvenance(model: string, assumptions: readonly string[]): ProcessingProvenance {\n  return { kind: \"approximation\", model, modelVersion: PROCESSING_MODEL_VERSION, assumptions: [...assumptions] };\n}\n\n/** Internal: a processing body yields once per processed row of every pass. */\nexport type ProcessingBody<T> = Generator<void, T, void>;\n\ninterface TaskSpec<T> {\n  provider: unknown;\n  totalTileCount: number;\n  estimatedWorkingBytes: number;\n  maximumWorkingBytes: number;\n  body: () => ProcessingBody<T>;\n  cadence?: HostYieldCadence;\n}\n\n/** Internal: wraps a row generator in the shared cancellable task contract. */\nexport function createProcessingTask<T>(spec: TaskSpec<T>): ProcessingTask<T> {\n  const hooks = requireProvider(spec.provider);\n  if (spec.estimatedWorkingBytes > spec.maximumWorkingBytes) {\n    throw new InvalidConfigurationError(\"Processing working memory estimate (\" + spec.estimatedWorkingBytes + \" bytes) exceeds maximumWorkingBytes.\");\n  }\n  const yieldControl = hooks.yieldControl.bind(hooks), onProgress = hooks.onProgress?.bind(hooks);\n  const abort = new AbortController(), total = spec.totalTileCount;\n  let state: ProcessingTaskState = \"ready\", completed = 0, output: T | null = null;\n  const check = (): void => { if (abort.signal.aborted) throw new InvalidConfigurationError(\"Processing task aborted.\"); };\n  return {\n    get state(): ProcessingTaskState { return state; },\n    get completedTileCount(): number { return completed; },\n    totalTileCount: total,\n    estimatedWorkingBytes: spec.estimatedWorkingBytes,\n    async run(): Promise<void> {\n      if (state !== \"ready\") throw new InvalidConfigurationError(\"Processing task is single-use.\");\n      state = \"running\";\n      try {\n        const gate = createHostYieldGate(spec.cadence ?? DEFAULT_HOST_YIELD_CADENCE), body = spec.body();\n        for (;;) {\n          check();\n          const step = body.next();\n          if (step.done === true) { output = step.value; break; }\n          completed++;\n          onProgress?.({ completedTileCount: completed, totalTileCount: total });\n          if (gate.due()) { await yieldControl(abort.signal); check(); gate.restart(); }\n        }\n        if (completed !== total) throw new InvalidScientificResultError(\"Processing progress accounting disagrees with its plan.\");\n        await yieldControl(abort.signal); check();\n        state = \"completed\";\n      } catch (error) {\n        output = null;\n        if (!abort.signal.aborted) { state = \"failed\"; abort.abort(); }\n        throw error;\n      }\n    },\n    cancel(): void { if (state === \"ready\" || state === \"running\" || state === \"completed\") { state = \"cancelled\"; abort.abort(); output = null; } },\n    dispose(): void { if (state !== \"transferred\") { state = \"disposed\"; abort.abort(); output = null; } },\n    takeOutput(): T {\n      if (state !== \"completed\" || output === null) throw new InvalidConfigurationError(\"Processing output unavailable.\");\n      const value = output; output = null; state = \"transferred\";\n      return value;\n    }\n  };\n}\n\nfunction requireProvider(provider: unknown): ProcessingProvider {\n  const hooks = provider as ProcessingProvider | null | undefined;\n  if (hooks === null || typeof hooks !== \"object\" || typeof hooks.yieldControl !== \"function\" ||\n      (hooks.onProgress !== undefined && typeof hooks.onProgress !== \"function\")) {\n    throw new InvalidConfigurationError(\"Processing requires a provider { yieldControl, onProgress? }.\");\n  }\n  return hooks;\n}\n\n// ------------------------------------------------------------------ validation helpers (internal)\n\nexport function requireOptions(value: unknown, keys: readonly string[], label: string): Record<string, unknown> {\n  return requireAllowlistedRecord(value, keys, label + \" must be an object with only the documented fields.\");\n}\n\nexport function requireFiniteIn(value: unknown, label: string, min: number, max: number, exclusiveMin = false): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || (exclusiveMin ? value <= min : value < min) || value > max) {\n    throw new InvalidScientificInputError(label + \" must be a finite number in \" + (exclusiveMin ? \"(\" : \"[\") + min + \", \" + max + \"].\");\n  }\n  return value;\n}\n\nexport function optionalFiniteIn(value: unknown, fallback: number, label: string, min: number, max: number, exclusiveMin = false): number {\n  return value === undefined ? fallback : requireFiniteIn(value, label, min, max, exclusiveMin);\n}\n\nexport function requireIntegerIn(value: unknown, label: string, min: number, max: number): number {\n  if (typeof value !== \"number\" || !Number.isSafeInteger(value) || value < min || value > max) {\n    throw new InvalidConfigurationError(label + \" must be an integer in [\" + min + \", \" + max + \"].\");\n  }\n  return value;\n}\n\nexport function optionalIntegerIn(value: unknown, fallback: number, label: string, min: number, max: number): number {\n  return value === undefined ? fallback : requireIntegerIn(value, label, min, max);\n}\n\nexport function requireEnum<T extends string>(value: unknown, allowed: readonly T[], label: string, fallback?: T): T {\n  if (value === undefined && fallback !== undefined) return fallback;\n  if (typeof value !== \"string\" || !(allowed as readonly string[]).includes(value)) {\n    throw new InvalidConfigurationError(label + \" must be one of \" + allowed.join(\", \") + \".\");\n  }\n  return value as T;\n}\n\nexport function maximumWorkingBytes(value: unknown): number {\n  return optionalIntegerIn(value, PROCESSING_DEFAULT_MAXIMUM_WORKING_BYTES, \"maximumWorkingBytes\", 1, Number.MAX_SAFE_INTEGER);\n}\n\n/** Validates the shape (not the values) of an interleaved image; values are checked by `finiteRows`. */\nexport function requireImage(value: unknown, label: string, channels = 3): ProcessingRgbImage {\n  const r = requireOptions(value, [\"width\", \"height\", \"data\"], label);\n  const width = requireIntegerIn(r.width, label + \".width\", 1, PROCESSING_MAX_PIXELS);\n  const height = requireIntegerIn(r.height, label + \".height\", 1, PROCESSING_MAX_PIXELS);\n  if (width * height > PROCESSING_MAX_PIXELS) throw new InvalidConfigurationError(label + \" exceeds \" + PROCESSING_MAX_PIXELS + \" pixels.\");\n  if (!(r.data instanceof Float32Array) || r.data.length !== width * height * channels) {\n    throw new InvalidConfigurationError(label + \".data must be a Float32Array of width·height·\" + channels + \" samples.\");\n  }\n  return { width, height, data: r.data };\n}\n\n/** Validates 1..PROCESSING_MAX_FRAMES same-size images. */\nexport function requireImageList(value: unknown, label: string, minimum: number): ProcessingRgbImage[] {\n  if (!Array.isArray(value) || value.length < minimum || value.length > PROCESSING_MAX_FRAMES) {\n    throw new InvalidConfigurationError(label + \" must contain \" + minimum + \" to \" + PROCESSING_MAX_FRAMES + \" images.\");\n  }\n  const images = value.map((v, i) => requireImage(v, label + \"[\" + i + \"]\"));\n  if (images.some((im) => im.width !== images[0]!.width || im.height !== images[0]!.height)) {\n    throw new InvalidConfigurationError(label + \" images must share one size.\");\n  }\n  return images;\n}\n\n/** Row generator rejecting non-finite samples (one tile per row). */\nexport function* finiteRows(data: Float32Array, width: number, height: number, channels: number, label: string,\n  minimum = -Infinity): ProcessingBody<void> {\n  const stride = width * channels;\n  for (let y = 0; y < height; y++) {\n    for (let i = y * stride, end = i + stride; i < end; i++) {\n      const v = data[i]!;\n      if (!Number.isFinite(v) || v < minimum) throw new InvalidScientificInputError(label + \" samples must be finite\" + (minimum > -Infinity ? \" and ≥ \" + minimum : \"\") + \".\");\n    }\n    yield;\n  }\n}\n"]}

package/dist/processing/tone-mapping.d.ts

@@ -0,0 +1,69 @@
+import { type ProcessingLinearColorSpace, type ProcessingProvenance, type ProcessingProvider, type ProcessingRgbImage, type ProcessingTask } from "./processing-task.js";
+export interface ToneMappedImage extends ProcessingRgbImage {
+    /** Output components above 1 (left unclipped for the downstream gamut/encoding stage). */
+    aboveOneSampleCount: number;
+    provenance: ProcessingProvenance;
+}
+export interface ReinhardGlobalToneMappingInput {
+    image: ProcessingRgbImage;
+    inputColorSpace: ProcessingLinearColorSpace;
+    /** Key value a; default 0.18. */
+    key?: number;
+    /** Smallest scaled luminance mapped to white; default the largest scaled luminance. */
+    whiteLuminance?: number;
+    /** δ in the log-average exp(mean(log(δ + L_w))); default 1e-6. */
+    logAverageDelta?: number;
+    maximumWorkingBytes?: number;
+}
+export interface ReinhardGlobalToneMappingOutput extends ToneMappedImage {
+    logAverageLuminance: number;
+    whiteLuminance: number;
+}
+/** Reinhard, Stark, Shirley & Ferwerda (2002) global photographic tone reproduction. */
+export declare function createReinhardGlobalToneMappingTask(input: ReinhardGlobalToneMappingInput, provider: ProcessingProvider): ProcessingTask<ReinhardGlobalToneMappingOutput>;
+export interface DurandDorseyToneMappingInput {
+    image: ProcessingRgbImage;
+    inputColorSpace: ProcessingLinearColorSpace;
+    /** Spatial σ in pixels; default 2% of the larger image side. */
+    spatialSigmaPixels?: number;
+    /** Range σ in log₁₀ luminance; default 0.4. */
+    rangeSigmaLog10?: number;
+    /** Target base-layer contrast ratio; default 5. */
+    targetContrast?: number;
+    /** Spatial downsampling factor of the fast bilateral filter; default max(1, round(σ_s/4)). */
+    downsampleFactor?: number;
+    maximumWorkingBytes?: number;
+}
+export interface DurandDorseyToneMappingOutput extends ToneMappedImage {
+    /** Bilateral base layer (log₁₀ luminance) per pixel; −Infinity for pixels with luminance ≤ 0, which are excluded from the filter. */
+    baseLog10: Float32Array;
+    compressionFactor: number;
+}
+/**
+ * Durand & Dorsey (2002) bilateral base/detail tone mapping. The fast bilateral filter is the paper's
+ * piecewise-linear scheme:
+ * 1. Place intensity nodes i_j no more than σ_r apart.
+ * 2. For each node, compute J_j = (f ⊗ (g_r(I − i_j)·I)) / (f ⊗ g_r(I − i_j)) on a box-downsampled grid.
+ * 3. Upsample bilinearly, then interpolate linearly between the two nodes on either side of each
+ *    full-resolution intensity.
+ */
+export declare function createDurandDorseyToneMappingTask(input: DurandDorseyToneMappingInput, provider: ProcessingProvider): ProcessingTask<DurandDorseyToneMappingOutput>;
+export interface ExposureFusionInput {
+    /** Display-referred (e.g. sRGB-encoded) frames with values nominally in [0, 1]. */
+    frames: readonly ProcessingRgbImage[];
+    contrastExponent?: number;
+    saturationExponent?: number;
+    wellExposednessExponent?: number;
+    /** Well-exposedness Gaussian σ; default 0.2. */
+    wellExposednessSigma?: number;
+    /** Pyramid levels; default down to a 1-pixel side (at most 12). */
+    pyramidLevels?: number;
+    maximumWorkingBytes?: number;
+}
+export interface ExposureFusionOutput extends ProcessingRgbImage {
+    /** Components clipped to [0, 1] after collapsing the blended pyramid. */
+    clippedSampleCount: number;
+    provenance: ProcessingProvenance;
+}
+/** Mertens, Kautz & Van Reeth (2007) exposure fusion with Laplacian-pyramid blending. */
+export declare function createExposureFusionTask(input: ExposureFusionInput, provider: ProcessingProvider): ProcessingTask<ExposureFusionOutput>;

package/dist/processing/tone-mapping.js

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * HDR → SDR tone-mapping operators, and exposure fusion. Each is a named rendering choice (an
+ * approximation), not a perceptual or display-calibrated model:
+ * - Reinhard et al. 2002 global photographic operator: log-average key, L = a·L_w/L̄_w,
+ *   L_d = L(1 + L/L_white²)/(1 + L); colour by the luminance ratio L_d/L_w (chromaticity-preserving).
+ * - Durand & Dorsey 2002 local operator: base = bilateral(log₁₀ L), detail = log₁₀ L − base,
+ *   output log = base·c + detail − max(base)·c with c = log₁₀(contrast)/(max(base) − min(base)); the
+ *   bilateral filter uses the paper's piecewise-linear acceleration with spatial downsampling.
+ * - Mertens, Kautz & Van Reeth 2007 exposure fusion of display-referred frames: per-pixel weight
+ *   W = C^ωc·S^ωs·E^ωe from Laplacian contrast, RGB standard deviation and well-exposedness
+ *   exp(−(v − 0.5)²/(2·0.2²)), normalized across frames and blended with Laplacian pyramids
+ *   (Burt & Adelson 1983).
+ * The HDR operators output display-referred linear RGB in the input primaries; encode it with the SDR
+ * rendering functions. Fusion output stays in the (encoded) domain of its inputs.
+ * @see docs/PROCESSING.md for equations, sources and limits.
+ */
+import { autoLevels, collapse, collapseRows, convolveRows, convolveSeparable, gaussianKernel, gaussianPyramid, gaussianPyramidRows, laplacianPyramid, laplacianPyramidRows, luminanceWeights, pyramidBytes, reflect } from "./image-ops.js";
+import { createProcessingTask, finiteRows, maximumWorkingBytes, optionalFiniteIn, optionalIntegerIn, processingProvenance, requireEnum, requireImage, requireImageList, requireOptions } from "./processing-task.js";
+const SPACES = ["linear-srgb-d65", "linear-display-p3-d65", "linear-rec2020-d65"];
+/** Reinhard, Stark, Shirley & Ferwerda (2002) global photographic tone reproduction. */
+export function createReinhardGlobalToneMappingTask(input, provider) {
+    const r = requireOptions(input, ["image", "inputColorSpace", "key", "whiteLuminance", "logAverageDelta", "maximumWorkingBytes"], "createReinhardGlobalToneMappingTask input");
+    const image = requireImage(r.image, "image"), space = requireEnum(r.inputColorSpace, SPACES, "inputColorSpace");
+    const key = optionalFiniteIn(r.key, 0.18, "key", 0, 1e6, true), delta = optionalFiniteIn(r.logAverageDelta, 1e-6, "logAverageDelta", 0, 1, true);
+    const white = r.whiteLuminance === undefined ? undefined : optionalFiniteIn(r.whiteLuminance, 1, "whiteLuminance", 0, 1e12, true);
+    const [wr, wg, wb] = luminanceWeights(space), h = image.height, stride = image.width * 3, n = image.width * h;
+    return createProcessingTask({
+        provider, totalTileCount: 3 * h, estimatedWorkingBytes: n * 12, maximumWorkingBytes: maximumWorkingBytes(r.maximumWorkingBytes),
+        body: function* () {
+            yield* finiteRows(image.data, image.width, h, 3, "image");
+            const d = image.data;
+            let logSum = 0, maxL = 0;
+            for (let y = 0; y < h; y++) {
+                for (let i = y * stride; i < (y + 1) * stride; i += 3) {
+                    const l = Math.max(0, wr * d[i] + wg * d[i + 1] + wb * d[i + 2]);
+                    logSum += Math.log(delta + l);
+                    maxL = Math.max(maxL, l);
+                }
+                yield;
+            }
+            const logAverage = Math.exp(logSum / n), scale = key / logAverage, lWhite = white ?? Math.max(maxL * scale, Number.MIN_VALUE);
+            const out = new Float32Array(3 * n);
+            let above = 0;
+            for (let y = 0; y < h; y++) {
+                for (let i = y * stride; i < (y + 1) * stride; i += 3) {
+                    const lw = wr * d[i] + wg * d[i + 1] + wb * d[i + 2];
+                    if (!(lw > 0)) {
+                        out[i] = 0;
+                        out[i + 1] = 0;
+                        out[i + 2] = 0;
+                        continue;
+                    }
+                    const l = scale * lw, ld = l * (1 + l / (lWhite * lWhite)) / (1 + l), ratio = ld / lw;
+                    for (let c = 0; c < 3; c++) {
+                        const v = (out[i + c] = Math.max(0, d[i + c]) * ratio);
+                        if (v > 1)
+                            above++;
+                    }
+                }
+                yield;
+            }
+            return { width: image.width, height: h, data: out, aboveOneSampleCount: above, logAverageLuminance: logAverage, whiteLuminance: lWhite,
+                provenance: processingProvenance("tone-reinhard-2002-global", [
+                    "Global photographic operator L_d = L(1 + L/L_white^2)/(1 + L) with L = a L_w / exp(mean log(delta + L_w)).",
+                    "Colour scaled by L_d/L_w (preserves chromaticity); negative components and non-positive luminance map to 0.",
+                    "Display-referred linear output; no dodging-and-burning (local) variant, gamut mapping or transfer encoding."
+                ]) };
+        }
+    });
+}
+/**
+ * Durand & Dorsey (2002) bilateral base/detail tone mapping. The fast bilateral filter is the paper's
+ * piecewise-linear scheme:
+ * 1. Place intensity nodes i_j no more than σ_r apart.
+ * 2. For each node, compute J_j = (f ⊗ (g_r(I − i_j)·I)) / (f ⊗ g_r(I − i_j)) on a box-downsampled grid.
+ * 3. Upsample bilinearly, then interpolate linearly between the two nodes on either side of each
+ *    full-resolution intensity.
+ */
+export function createDurandDorseyToneMappingTask(input, provider) {
+    const r = requireOptions(input, ["image", "inputColorSpace", "spatialSigmaPixels", "rangeSigmaLog10", "targetContrast", "downsampleFactor",
+        "maximumWorkingBytes"], "createDurandDorseyToneMappingTask input");
+    const image = requireImage(r.image, "image"), space = requireEnum(r.inputColorSpace, SPACES, "inputColorSpace");
+    const W = image.width, H = image.height, n = W * H;
+    const sigmaS = optionalFiniteIn(r.spatialSigmaPixels, Math.max(0.5, 0.02 * Math.max(W, H)), "spatialSigmaPixels", 0, 1e5, true);
+    const sigmaR = optionalFiniteIn(r.rangeSigmaLog10, 0.4, "rangeSigmaLog10", 0, 100, true);
+    const contrast = optionalFiniteIn(r.targetContrast, 5, "targetContrast", 1, 1e12, true);
+    const z = optionalIntegerIn(r.downsampleFactor, Math.max(1, Math.round(sigmaS / 4)), "downsampleFactor", 1, 1024);
+    const cw = Math.ceil(W / z), ch = Math.ceil(H / z), kernel = gaussianKernel(sigmaS / z);
+    const [wr, wg, wb] = luminanceWeights(space);
+    // Node count depends on the data range; the plan bounds it by the float32 log₁₀ range (≈ 90 decades).
+    const maxNodes = Math.ceil(90 / sigmaR) + 2;
+    const nodeRows = 2 * convolveRows(ch) + ch;
+    return createProcessingTask({
+        provider, totalTileCount: 4 * H + ch + maxNodes * nodeRows, estimatedWorkingBytes: n * (3 * 4 + 4 + 4) + cw * ch * 4 * 6 + Math.min(maxNodes, 4096) * cw * ch * 4,
+        maximumWorkingBytes: maximumWorkingBytes(r.maximumWorkingBytes),
+        body: function* () {
+            yield* finiteRows(image.data, W, H, 3, "image");
+            const d = image.data, logL = new Float32Array(n);
+            // Pixels with luminance ≤ 0 have no finite log₁₀; they are marked −∞, excluded from the filter and from the
+            // ranges below, and output as 0 by the colour pass.
+            for (let y = 0; y < H; y++) {
+                for (let x = 0; x < W; x++) {
+                    const i = y * W + x, l = wr * d[3 * i] + wg * d[3 * i + 1] + wb * d[3 * i + 2];
+                    logL[i] = l > 0 ? Math.log10(l) : -Infinity;
+                }
+                yield;
+            }
+            const coarse = new Float32Array(cw * ch);
+            let lo = Infinity, hi = -Infinity;
+            for (let y = 0; y < ch; y++) {
+                for (let x = 0; x < cw; x++) {
+                    let s = 0, c = 0;
+                    for (let yy = y * z; yy < Math.min(H, (y + 1) * z); yy++)
+                        for (let xx = x * z; xx < Math.min(W, (x + 1) * z); xx++) {
+                            const v = logL[yy * W + xx];
+                            if (v > -Infinity) {
+                                s += v;
+                                c++;
+                            }
+                        }
+                    // A cell with no positive-luminance pixel is NaN and carries zero filter weight.
+                    const v = (coarse[y * cw + x] = c > 0 ? s / c : NaN);
+                    if (c > 0) {
+                        lo = Math.min(lo, v);
+                        hi = Math.max(hi, v);
+                    }
+                }
+                yield;
+            }
+            for (let i = 0; i < n; i++)
+                if (logL[i] > -Infinity) {
+                    lo = Math.min(lo, logL[i]);
+                    hi = Math.max(hi, logL[i]);
+                }
+            if (!(hi >= lo)) {
+                lo = 0;
+                hi = 0;
+            } // all-zero image
+            const nodes = hi > lo ? Math.min(maxNodes, Math.ceil((hi - lo) / sigmaR) + 1) : 1;
+            const step = nodes > 1 ? (hi - lo) / (nodes - 1) : 0, J = [];
+            const g = new Float32Array(cw * ch), hgt = new Float32Array(cw * ch), tmp = new Float32Array(cw * ch), gs = new Float32Array(cw * ch), hs = new Float32Array(cw * ch);
+            for (let j = 0; j < maxNodes; j++) {
+                if (j >= nodes) {
+                    for (let k = 0; k < nodeRows; k++)
+                        yield;
+                    continue;
+                }
+                const node = lo + j * step;
+                for (let i = 0; i < cw * ch; i++) {
+                    const c = coarse[i];
+                    if (Number.isNaN(c)) {
+                        g[i] = 0;
+                        hgt[i] = 0;
+                        continue;
+                    }
+                    const w = Math.exp(-((c - node) ** 2) / (2 * sigmaR * sigmaR));
+                    g[i] = w;
+                    hgt[i] = w * c;
+                }
+                yield* convolveSeparable(g, cw, ch, 1, kernel, tmp, gs);
+                yield* convolveSeparable(hgt, cw, ch, 1, kernel, tmp, hs);
+                const out = new Float32Array(cw * ch);
+                for (let y = 0; y < ch; y++) {
+                    for (let i = y * cw; i < (y + 1) * cw; i++)
+                        out[i] = gs[i] > 0 ? hs[i] / gs[i] : node;
+                    yield;
+                }
+                J.push(out);
+            }
+            const sample = (plane, x, y) => {
+                const fx = Math.min(Math.max((x + 0.5) / z - 0.5, 0), cw - 1), fy = Math.min(Math.max((y + 0.5) / z - 0.5, 0), ch - 1);
+                const x0 = Math.floor(fx), y0 = Math.floor(fy), x1 = Math.min(x0 + 1, cw - 1), y1 = Math.min(y0 + 1, ch - 1), ax = fx - x0, ay = fy - y0;
+                return (1 - ay) * ((1 - ax) * plane[y0 * cw + x0] + ax * plane[y0 * cw + x1]) + ay * ((1 - ax) * plane[y1 * cw + x0] + ax * plane[y1 * cw + x1]);
+            };
+            const base = new Float32Array(n);
+            let bLo = Infinity, bHi = -Infinity;
+            for (let y = 0; y < H; y++) {
+                for (let x = 0; x < W; x++) {
+                    const i = y * W + x, v = logL[i];
+                    if (!(v > -Infinity)) {
+                        base[i] = -Infinity;
+                        continue;
+                    }
+                    let b;
+                    if (nodes === 1)
+                        b = sample(J[0], x, y);
+                    else {
+                        const t = Math.min(Math.max((v - lo) / step, 0), nodes - 1), j0 = Math.min(Math.floor(t), nodes - 2), a = t - j0;
+                        b = (1 - a) * sample(J[j0], x, y) + a * sample(J[j0 + 1], x, y);
+                    }
+                    base[i] = b;
+                    bLo = Math.min(bLo, b);
+                    bHi = Math.max(bHi, b);
+                }
+                yield;
+            }
+            if (!(bHi >= bLo)) {
+                bLo = 0;
+                bHi = 0;
+            } // all-zero image
+            const factor = bHi > bLo ? Math.log10(contrast) / (bHi - bLo) : 1, offset = bHi * factor, out = new Float32Array(3 * n);
+            let above = 0;
+            for (let y = 0; y < H; y++) {
+                for (let i = y * W; i < (y + 1) * W; i++) {
+                    const lw = wr * d[3 * i] + wg * d[3 * i + 1] + wb * d[3 * i + 2];
+                    if (!(lw > 0)) {
+                        out[3 * i] = 0;
+                        out[3 * i + 1] = 0;
+                        out[3 * i + 2] = 0;
+                        continue;
+                    }
+                    const ratio = 10 ** (base[i] * factor + (logL[i] - base[i]) - offset) / lw;
+                    for (let c = 0; c < 3; c++) {
+                        const v = (out[3 * i + c] = Math.max(0, d[3 * i + c]) * ratio);
+                        if (v > 1)
+                            above++;
+                    }
+                }
+                yield;
+            }
+            return { width: W, height: H, data: out, baseLog10: base, compressionFactor: factor, aboveOneSampleCount: above,
+                provenance: processingProvenance("tone-durand-dorsey-2002-bilateral", [
+                    "Base = fast piecewise-linear bilateral filter of log10 luminance (spatial sigma " + sigmaS + " px, range sigma " + sigmaR + ", downsampling " + z + ").",
+                    "Base compressed to a " + contrast + ":1 contrast, detail kept, largest base mapped to luminance 1.",
+                    "Colour scaled by the luminance ratio; display-referred linear output without gamut mapping or transfer encoding."
+                ]) };
+        }
+    });
+}
+// Patent note (public record, not legal advice): standard Mertens et al. Laplacian-pyramid fusion. CyberLink
+// US 8,885,976 (in force to 2034) claims a specific merged-pyramid variant that this implementation does not use;
+// see THIRD_PARTY.md.
+/** Mertens, Kautz & Van Reeth (2007) exposure fusion with Laplacian-pyramid blending. */
+export function createExposureFusionTask(input, provider) {
+    const r = requireOptions(input, ["frames", "contrastExponent", "saturationExponent", "wellExposednessExponent", "wellExposednessSigma",
+        "pyramidLevels", "maximumWorkingBytes"], "createExposureFusionTask input");
+    const frames = requireImageList(r.frames, "frames", 1), W = frames[0].width, H = frames[0].height, n = W * H, K = frames.length;
+    const wc = optionalFiniteIn(r.contrastExponent, 1, "contrastExponent", 0, 16), ws = optionalFiniteIn(r.saturationExponent, 1, "saturationExponent", 0, 16);
+    const we = optionalFiniteIn(r.wellExposednessExponent, 1, "wellExposednessExponent", 0, 16), sigma = optionalFiniteIn(r.wellExposednessSigma, 0.2, "wellExposednessSigma", 0, 10, true);
+    const levels = optionalIntegerIn(r.pyramidLevels, autoLevels(W, H, 12), "pyramidLevels", 1, autoLevels(W, H, 32));
+    const rows = K * H + H + K * (laplacianPyramidRows(W, H, levels) + gaussianPyramidRows(W, H, levels)) + collapseRows(W, H, levels) + H;
+    return createProcessingTask({
+        provider, totalTileCount: K * H + rows, estimatedWorkingBytes: K * n * 4 + 3 * pyramidBytes(W, H, 3, levels) + 2 * pyramidBytes(W, H, 1, levels) + n * 12,
+        maximumWorkingBytes: maximumWorkingBytes(r.maximumWorkingBytes),
+        body: function* () {
+            for (const [k, f] of frames.entries())
+                yield* finiteRows(f.data, W, H, 3, "frames[" + k + "]");
+            const weights = frames.map(() => new Float32Array(n)), [lr, lg, lb] = luminanceWeights("linear-srgb-d65");
+            for (const [k, f] of frames.entries()) {
+                const d = f.data, w = weights[k];
+                const gray = (x, y) => { const i = 3 * (reflect(y, H) * W + reflect(x, W)); return lr * d[i] + lg * d[i + 1] + lb * d[i + 2]; };
+                for (let y = 0; y < H; y++) {
+                    for (let x = 0; x < W; x++) {
+                        const i = y * W + x, R = d[3 * i], G = d[3 * i + 1], B = d[3 * i + 2];
+                        const c = Math.abs(gray(x - 1, y) + gray(x + 1, y) + gray(x, y - 1) + gray(x, y + 1) - 4 * gray(x, y));
+                        const mu = (R + G + B) / 3, s = Math.sqrt(((R - mu) ** 2 + (G - mu) ** 2 + (B - mu) ** 2) / 3);
+                        const e = Math.exp(-((R - 0.5) ** 2 + (G - 0.5) ** 2 + (B - 0.5) ** 2) / (2 * sigma * sigma));
+                        w[i] = c ** wc * s ** ws * e ** we + 1e-12;
+                    }
+                    yield;
+                }
+            }
+            for (let y = 0; y < H; y++) {
+                for (let i = y * W; i < (y + 1) * W; i++) {
+                    let sum = 0;
+                    for (const w of weights)
+                        sum += w[i];
+                    for (const w of weights)
+                        w[i] = w[i] / sum;
+                }
+                yield;
+            }
+            let acc = null, sizes = [];
+            for (const [k, f] of frames.entries()) {
+                const lap = yield* laplacianPyramid(f.data, W, H, 3, levels), gw = yield* gaussianPyramid(weights[k], W, H, 1, levels);
+                sizes = lap.sizes;
+                acc ??= lap.sizes.map((s) => new Float32Array(s.width * s.height * 3));
+                for (let l = 0; l < levels; l++) {
+                    const a = acc[l], L = lap.levels[l], G = gw.levels[l];
+                    for (let i = 0; i < G.length; i++)
+                        for (let c = 0; c < 3; c++)
+                            a[3 * i + c] = a[3 * i + c] + G[i] * L[3 * i + c];
+                }
+            }
+            const fused = yield* collapse({ levels: acc, sizes, channels: 3 });
+            let clipped = 0;
+            for (let y = 0; y < H; y++) {
+                for (let i = 3 * y * W; i < 3 * (y + 1) * W; i++) {
+                    const v = fused[i];
+                    if (v < 0) {
+                        fused[i] = 0;
+                        clipped++;
+                    }
+                    else if (v > 1) {
+                        fused[i] = 1;
+                        clipped++;
+                    }
+                }
+                yield;
+            }
+            return { width: W, height: H, data: fused, clippedSampleCount: clipped, provenance: processingProvenance("exposure-fusion-mertens-2007", [
+                    "Weights: |3x3 Laplacian of Rec.709 luma|^wc * RGB std^ws * prod exp(-(v-0.5)^2/(2 sigma^2))^we, normalized per pixel.",
+                    "Laplacian-pyramid blending with Burt-Adelson 5-tap kernel and reflect-101 borders; output clipped to [0, 1].",
+                    "Display-referred blending of registered frames; not a radiance estimate."
+                ]) };
+        }
+    });
+}
+//# sourceMappingURL=tone-mapping.js.map