Reduce noise by luminance and color strength, before demosaicing for RAW photos

API.md

@@ -72,6 +72,8 @@ Create an empty Paint layer with `addLayer("paint")`. `addPaintStroke(id, stroke
 
 For RAW sources, `setWhiteBalance({ temperature, tint })` sets absolute Kelvin and DNG tint, preserving unspecified values. Temperature accepts 2000–25000 K and tint accepts -150–150, extending either range to include the file's As Shot value. `setWhiteBalance()` restores that value (the decoder's daylight fallback if camera multipliers are unavailable). Non-RAW sources and invalid values throw. Incremental temperature/tint remain separate RGB adjustments.
 
+`setNoiseReduction({ luminance, color })` reduces the photo's noise before its adjustments, keeping the strength it omits: a RAW photo's on its Bayer mosaic before demosaicing, any other image's in its encoded color. Each strength goes from 0, none, to 100; near 50 the result comes closest to the clean photo, and higher smooths further. Luminance reduces noise in light, color in color, so color alone leaves a monochrome grain. A photo's first reduction runs once on the GPU and takes a moment while the editor keeps showing the photo as it was; later strengths, white balance, and every other edit reuse it, so they apply at once. The original comparison shows the photo as decoded. RAW files without a 2 × 2 mosaic, such as Fujifilm X-Trans, and invalid values throw.
+
 `autoWhiteBalance()` neutralizes the photo's color cast as one edit and resolves once it is made. The GPU measures the cast of the source before any edit, as its edges' average color, so calling it again gives the same balance. A RAW photo's white balance moves from As Shot; any other photo's incremental temperature and tint are replaced. When another photo opens first, it resolves without an edit.
 
 Edits update the scene and history synchronously. Rendering may finish later, particularly RAW development. Tests should wait for visible results; `exportImage()` renders and waits for its captured scene independently of the preview.
@@ -185,7 +187,7 @@ The image renders at the document dimensions and downsamples to `longEdge` with
 
 `scene` is the `getState()` scene; each image layer's `source` names an entry in `sources`, and each Remove patch's `field` an entry in `fields`: where its texels sit, or `{}` for a field not yet synthesized. Version 1 files, which kept each Remove field inside its patch, open as version 2. Opening the file with `loadScene`, `openFile`, a drop, or the file picker decodes the stored source again and restores the frame and every layer as a new document with empty history. Preview settings and history are not saved.
 
-Opening validates every value as the matching command does, and a file that fails leaves the workspace in its error state with a message naming the first invalid field. Fields OpenLight does not know are dropped. A parameter missing from `adjustments`, `details`, `vignette`, `grain`, `fill`, or `colorMixer` takes its default, so older files still open when a group gains a parameter; a RAW image without a white balance uses its As Shot value, and a frame without `perspective` has none. `version` increases only when older files can no longer open as written, or an older OpenLight would drop what a file holds: a scene that corrects perspective is version 3, which OpenLight before perspective correction rejects, and every other scene stays version 2. A newer version is rejected.
+Opening validates every value as the matching command does, and a file that fails leaves the workspace in its error state with a message naming the first invalid field. Fields OpenLight does not know are dropped. A parameter missing from `adjustments`, `details`, `vignette`, `grain`, `fill`, or `colorMixer` takes its default, so older files still open when a group gains a parameter; a RAW image without a white balance uses its As Shot value, an image without `noiseReduction` has none, and a frame without `perspective` has none. `version` increases only when older files can no longer open as written, or an older OpenLight would drop what a file holds: a scene that corrects perspective is version 3, which OpenLight before perspective correction rejects, and every other scene stays version 2. A newer version is rejected.
 
 ## Drafts
 
@@ -218,14 +220,15 @@ editor.run({
 | `set-adjustments` | adjustments, `layerId?` | Like `setAdjustments`. |
 | `set-tone-curve` | `points?`, `layerId?` | Like `setToneCurve`. |
 | `set-white-balance` | `temperature?`, `tint?` | Like `setWhiteBalance` with a change. |
+| `set-noise-reduction` | `luminance?`, `color?` | Like `setNoiseReduction`. |
 | `set-color-mixer` | `color`, `hue?`, `saturation?`, `luminance?`, `layerId?` | Like `setColorMixer`. |
 | `set-details` | `clarity?`, `sharpening?`, `sharpenRadius?`, `layerId?` | Like `setDetails`. |
 | `set-vignette` | `intensity?`, `softness?`, `layerId?` | Like `setVignette`. |
 | `set-grain` | `amount?`, `size?`, `roughness?`, `layerId?` | Like `setGrain`. |
 | `add-mask` | `mask`, `adjustments?` | Adds a mask layer with those adjustments on top of the stack as one edit. |
 | `delete-layer` | `layerId` | Like `deleteLayer`. |
 | `set-crop` | `aspectRatio?`, `straighten?` | Replaces the frame with the largest centered crop of the source at `aspectRatio`, width over height, straightened by −45 to 45 degrees, keeping the frame's perspective. Without either, it removes the crop. |
-| `reset` | none | Removes every layer and returns adjustments, the tone curve, white balance, and the frame, perspective included, to how the photo opened, as one edit. |
+| `reset` | none | Removes every layer and returns adjustments, the tone curve, white balance, noise reduction, and the frame, perspective included, to how the photo opened, as one edit. |
 | `undo`, `redo` | none | Like `undo` and `redo`. |
 | `set-preview` | `comparison` | Shows `"edited"`, `"original"`, or `"split"`. |
 

ARCHITECTURE.md

@@ -94,4 +94,5 @@ Dependencies point downward. Features do not import each other; `app/` connects
 - A mask without child effects renders its adjustments, curve, and mix in one pass over the image below, so no full-size texture holds its edited image; while it is inspected, its curve input reads the adjusted image, so the three render separately. A mask that only gradients shape needs no texture: the mix pass computes it, children included. A mask with a painted brush or a range combines in the render graph: each child's coverage, a brush's cached raster, a gradient drawn by a node, or a range read from the image below the mask, folds into the group's in stored order through one combine pass, and the mix pass shares its add, subtract, and intersect. The group takes the image's resolution when a range takes part, since a range follows the photo's edges, and the brushes' otherwise. The renderer gives it out, with each range's own coverage, for the overlay and thumbnails. While a color is picked, renders also keep the image below the mask group, which the picker reads through one GPU pass and 16 bytes of readback per pick.
 - Renders reduce the source by the largest whole factor that still gives every device pixel a texel, a proxy, in gestures or not, so the photo's own size renders once the display shows more than half a device pixel per source pixel; the main canvas writes that density into the preview state, and the provider renders again when it changes. A proxy that lacks a Remove patch's field synthesizes it apart, outside a gesture: the layers below the patch render in full for the field alone, and the proxy composes again with it, so the display never shows a full render for it. The export view renders its own full snapshot, which its preview and the saved file both encode. Every render image carries `scale`, its source pixels per texel; shaders that take document coordinates or radii apply it.
 - The scene's frame maps output to source in one homogeneous transform, `frameTransform` in `core/image/frame.ts`: crop, rotation, flips, and scale, then the perspective correction about the source's center. Layers, paint, masks, and patches stay in source pixels, so correcting perspective leaves them in place; `transformImage` resamples the composite once, the display draws the comparison and the mask overlay from the source through the same transform, and a frame that changes nothing adds no pass. The proxy follows the frame's strongest magnification, perspective's included. `lib/projective.ts` holds the plane projective geometry the frame, the Crop tool's coverage, and the canvas mapping share.
-- TIFF and camera RAW decode through `raw-webgpu`; OpenLight adapts its resources to document ownership. A RAW source keeps its as-shot development, which a renderer shows as long as that balance is selected; another balance develops into the renderer's own texture.
+- TIFF and camera RAW decode through `raw-webgpu`; OpenLight adapts its resources to document ownership. A RAW source keeps its as-shot development, which a renderer shows as long as that balance is selected and noise reduction is off, and the original comparison always shows; another balance, or noise reduction, develops into the renderer's own texture.
+- Noise reduction works before the image layer's adjustments, on a RAW photo's 2 × 2 mosaic before demosaicing or on any other image's encoded color, at the layer's luminance and color strengths. `features/noise-reduction` reduces the noise on the GPU once per source, the first time a renderer or control asks; the image source keeps the reduction until it closes and shares it with every renderer, and each renderer composes it at the layer's strengths in one pass into a texture of its own. A RAW photo develops the composed samples: the package develops only its own sensor texture, so `core/image/decode/raw.ts` moves the decoded samples to a copy the first time and, right before each development, writes the samples that development takes into that texture, in the same task, so no other renderer's write falls between. Any other image's composition takes the composed image in place of the source. Changing a strength composes and develops again, as a white balance does, without reducing noise again; a newer request need not wait for a first reduction. `app/editor/renderer.ts` gives the renderer the feature's reduction, so the core imports no feature. See [the algorithm](src/features/noise-reduction/algorithm.md).

CONTEXT.md

@@ -10,6 +10,7 @@ OpenLight edits documents containing image content and adjustments.
 | **Stroke** | One brush drag: paint or erase, size, feather, flow, and points with pressure in source pixels; a Paint layer's strokes also carry a color. Strokes are content; the renderer rasterizes them into a cached texture at half the source's resolution, coverage for a mask and premultiplied color for a Paint layer, and the latest stroke into a shared stroke buffer until the next one starts. A Paint layer's or brush mask's strokes settle into pixels every 100 strokes, which it then paints over; undo still reaches every stroke. A Healing patch stores ordered hard paint/erase strokes, rasterized over only the tiles its paint reaches, and feathers its accumulated shape separately. |
 | **Range** | A mask that selects pixels of the image below its mask group by lightness, a luminance range, or by color, a color range, rather than by position. A new color range has no coverage until it takes a color from a click on the photo. |
 | **Healing patch** | One painted, non-destructive repair in a Healing layer. Its Heal mode copies a nearby donor, found automatically or set by hand, with a bounded boundary color correction. Clone mode copies the donor without color correction. Remove mode synthesizes many local donor patches from surrounding texture and has no donor offset; it keeps where each pixel copies from as its field, so the layers below change only the copied colors, and a stroke added or erased synthesizes its whole new shape. Patches replay in order and each sees the result of the preceding patches. Each gesture keeps its recorded size and separate path; Shift adds and Alt/Option subtracts on the selected patch. Feather and opacity remain editable on its accumulated shape. |
+| **Noise reduction** | The image layer's luminance and color strengths, each 0 to 100, that remove noise before its adjustments: from a RAW photo's color filter mosaic before demosaicing, from any other image's color. The photo's first reduction takes a moment; changing a strength or editing anything else afterwards applies at once, and the original comparison shows the photo as decoded. RAW photos without a 2 × 2 Bayer mosaic have none. |
 | **Perspective correction** | Part of the frame: Vertical and Horizontal keystone that makes lines converging in the photo, such as a building's edges, parallel, before the crop, rotation, and flips. Layers keep their source pixels and follow it; tools draw and place them as it maps them. |
 | **Image source** | An image used as input to the document's composition. It is content within a document. |
 | **LUT** | A 3D color lookup table, such as a creative grade, read from a `.cube` file. A LUT layer holds one and applies it to the image below, at the layer's opacity. |

src/app/commands.ts

@@ -16,6 +16,8 @@ import { setGrain } from "@/features/grain/edits";
 import { grainSchema } from "@/features/grain/model";
 import { addLayer, deleteLayer } from "@/features/layers/edits";
 import { maskSchema } from "@/features/layers/model";
+import { setNoiseReduction } from "@/features/noise-reduction/edits";
+import { noiseReductionSchema } from "@/features/noise-reduction/model";
 import { curveSchema, defaultCurve } from "@/features/tone-curves/curve";
 import { setToneCurve } from "@/features/tone-curves/edits";
 import { setVignette } from "@/features/vignette/edits";
@@ -65,6 +67,7 @@ function reset(document: EditorDocument) {
         adjustments: { ...defaultAdjustments },
         toneCurve: defaultCurve,
         whiteBalance: source.raw?.asShot,
+        noiseReduction: undefined,
       },
     ],
   });
@@ -104,6 +107,14 @@ export const commands = {
       return { layerId: image(document).id };
     },
   ),
+  "set-noise-reduction": command(
+    "Reduces the photo's noise before its adjustments, a RAW photo's before demosaicing: luminance and color from 0, none, to 100, keeping omitted values. 50 removes the noise the photo measures; more smooths further. The first reduction of a photo takes a moment; later strengths apply at once. RAW files without a 2 × 2 mosaic, such as Fujifilm X-Trans, have none.",
+    change(noiseReductionSchema),
+    (document, change) => {
+      setNoiseReduction(document, change);
+      return { layerId: image(document).id };
+    },
+  ),
   "set-color-mixer": command(
     "Shifts one color range's hue, saturation, or luminance from -100 to 100, keeping other colors and omitted values. Neutral grays are unaffected. Without layerId it edits the first Color Mixer layer, creating one when there is none.",
     z.extend(mixerChange, { color: mixerColor, layerId }),

src/app/controls.ts

@@ -28,7 +28,7 @@ import type {
   ToneCurve,
   Vignette,
 } from "@/core/document";
-import type { WhiteBalance } from "@/core/image";
+import type { NoiseReduction, WhiteBalance } from "@/core/image";
 import { decode } from "@/core/image/decode";
 import type { ImageFrame, Point } from "@/core/image/frame";
 import { setAdjustments, setExposure } from "@/features/adjustments/edits";
@@ -62,6 +62,7 @@ import {
   setMaskOperation,
 } from "@/features/layers/edits";
 import { defaultGradient } from "@/features/layers/gradient";
+import { setNoiseReduction } from "@/features/noise-reduction/edits";
 import { addPaintStroke, setPaintBlend } from "@/features/paint/edits";
 import { defaultCurve } from "@/features/tone-curves/curve";
 import { setToneCurve } from "@/features/tone-curves/edits";
@@ -123,6 +124,8 @@ export function createControls(
     setWhiteBalance: (change?: Partial<WhiteBalance>) =>
       setWhiteBalance(workspace.getDocument(), change),
     autoWhiteBalance: () => autoWhiteBalance(workspace.getDocument(), gpu),
+    setNoiseReduction: (change: Partial<NoiseReduction>) =>
+      setNoiseReduction(workspace.getDocument(), change),
     setToneCurve: (curve?: ToneCurve, id?: string) =>
       setToneCurve(workspace.getDocument(), curve, id),
     setColorMixer(color: MixerColor, change: MixerChange, id?: string) {

src/app/editor/adjust/index.tsx

@@ -1,5 +1,6 @@
 import { Button } from "@roprgm/ui/button";
 import { Slider } from "@roprgm/ui/slider";
+import { Spinner } from "@roprgm/ui/spinner";
 import { type ReactNode, useCallback, useState } from "react";
 import { useStore } from "zustand";
 import { effectKinds } from "@/app/editor/layers";
@@ -41,6 +42,10 @@ import { Histogram } from "@/features/histogram";
 import { setLayer } from "@/features/layers/edits";
 import { OverlayToggle } from "@/features/layers/overlay-toggle";
 import { LutCurves } from "@/features/lut/curves";
+import {
+  NoiseReductionControls,
+  useNoiseReduction,
+} from "@/features/noise-reduction/controls";
 import { PaintControls } from "@/features/paint/controls";
 import { defaultCurve } from "@/features/tone-curves/curve";
 import { setToneCurve } from "@/features/tone-curves/edits";
@@ -148,7 +153,9 @@ function SelectedControls({ layer }: { layer: Layer }) {
             id={layer.id}
             adjustments={layer.adjustments}
             whiteBalance={<WhiteBalanceControls layer={layer} />}
-          />
+          >
+            {layer.kind === "image" && <NoiseReductionControls layer={layer} />}
+          </AdjustmentControls>
           <div className="px-3.5 pb-3.5">
             <LayerCurve id={layer.id} toneCurve={layer.toneCurve} />
           </div>
@@ -240,6 +247,7 @@ function AdjustmentDials({
 }) {
   const document = useDocument();
   const whiteBalance = useWhiteBalance(layer);
+  const noiseReduction = useNoiseReduction(layer);
   const header = (
     <DockChips
       label="Adjustment group"
@@ -298,11 +306,19 @@ function AdjustmentDials({
       />
     );
   }
+  // Noise reduction follows the tone, with a spinner while the first reduction runs.
   return (
     <DockControls
       header={header}
-      action={action}
-      parameters={adjustments(tone)}
+      action={
+        <>
+          {noiseReduction?.reducing && (
+            <Spinner aria-label="Reducing noise" className="size-3" />
+          )}
+          {action}
+        </>
+      }
+      parameters={[...adjustments(tone), ...(noiseReduction?.parameters ?? [])]}
     />
   );
 }

src/app/editor/renderer.ts

@@ -24,6 +24,7 @@ import { grain } from "@/features/grain/pass";
 import { heal, retainHealPatches } from "@/features/heal/pass";
 import { histogramGrid } from "@/features/histogram/histogram";
 import { lut } from "@/features/lut/pass";
+import { reduceNoise } from "@/features/noise-reduction/reduce";
 import { paint } from "@/features/paint/pass";
 import { toneCurves } from "@/features/tone-curves/pass";
 import { vignette } from "@/features/vignette/pass";
@@ -181,7 +182,8 @@ function composeLayers(
 
 /**
  * Pure layer composition shares the same graph for preview, crop, and export.
- * The image layer develops the photo first; layers above it process that floating-point result.
+ * The image layer develops the photo first, after its noise reduction; layers above it process that
+ * floating-point result.
  * Display and export encode only after composition, so later layers can recover HDR headroom.
  */
 export function createEditorRenderer(
@@ -220,6 +222,9 @@ export function createEditorRenderer(
         rangeSource: children.rangeSource ?? composite.rangeSource,
       };
     },
-    options,
+    {
+      ...options,
+      reduceNoise: (source, signal) => reduceNoise(gpu, source, signal),
+    },
   );
 }