@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.0

package/esm2022/lib/toolbar/wand/wand-region-grow.mjs

@@ -0,0 +1,321 @@
+import { floodFill } from 'napari-js/geometry';
+import { maskToPolygons } from '../../geometry/contour';
+import { bt601Luminance } from '../../contracts/intensity';
+import { framePixels, isPackedFrame } from '../tool-kit/frame-pixels';
+const DEFAULT_PATCH_SIZE = 149;
+const DEFAULT_SIGMA = 4.0;
+const DEFAULT_SENSITIVITY = 2.0;
+/**
+ * Grow a region from a click and trace it.
+ *
+ * @param image full-image pixel matrix (already in memory).
+ * @param cx click x in image-pixel coordinates.
+ * @param cy click y in image-pixel coordinates.
+ * @param options wand parameters; missing fields fall back to defaults.
+ * @returns a Polygon in image-pixel coordinates, or null if no region grew.
+ */
+export function computeWandRegion(image, cx, cy, options = {}) {
+    const patch = computeWandPatchMask(image, cx, cy, options);
+    if (!patch)
+        return null;
+    // The largest traced piece (with holes of 4+ px, as the tools trace); single pixels still count.
+    return (maskToPolygons(patch.mask, patch.size, patch.size, Math.floor(cx) - (patch.size - 1) / 2, Math.floor(cy) - (patch.size - 1) / 2, 1, 4)[0] ?? null);
+}
+/**
+ * The wand's per-click flood-fill mask in patch-local coordinates: the same
+ * pipeline as {@link computeWandRegion}, stopping before contour tracing (the
+ * tools accumulate per-tick masks across a brush-style stroke).
+ *
+ * @throws when `options.patchSize` is even.
+ */
+export function computeWandPatchMask(image, cx, cy, options = {}) {
+    const W = options.patchSize ?? DEFAULT_PATCH_SIZE;
+    if (W % 2 === 0) {
+        throw new Error(`patchSize must be odd, got ${W}`);
+    }
+    const sigma = options.sigma ?? DEFAULT_SIGMA;
+    const sensitivity = options.sensitivity ?? DEFAULT_SENSITIVITY;
+    const isGrayscale = image.isGrayscale;
+    const type = options.type ?? (isGrayscale ? 'GRAY' : 'RGB');
+    const simple = !!options.simpleMode;
+    // extractPatch always interleaves 1 channel for GRAY, 3 for RGB/LAB_DISTANCE.
+    const inputChannels = type === 'GRAY' ? 1 : 3;
+    let buf = extractPatch(image, cx, cy, W, type);
+    // Flood fill operates on whatever buffer we end up with: the raw patch in
+    // simple mode (so multi-channel exact-match), the blurred patch for
+    // GRAY/RGB, or the single-channel CIELAB distance map for LAB_DISTANCE.
+    let floodChannels;
+    let threshold;
+    if (simple) {
+        // Skip blur + threshold computation. Flood-fill the raw patch at
+        // exact-match per channel — same as QuPath's doSimpleSelection.
+        floodChannels = inputChannels;
+        threshold = new Array(floodChannels).fill(0);
+    }
+    else {
+        const blurSigma = Math.max(0.5, sigma);
+        buf = gaussianBlur(buf, W, inputChannels, blurSigma);
+        if (type === 'LAB_DISTANCE') {
+            // Convert blurred 3-channel patch to a single-channel distance map,
+            // then flood-fill on that single channel.
+            const distance = labDistanceMap(buf, W);
+            const max = distance.max > 0 ? distance.max : 1;
+            const scaled = new Float32Array(W * W);
+            for (let i = 0; i < scaled.length; i++)
+                scaled[i] = (distance.values[i] * 255.0) / max;
+            buf = scaled;
+            floodChannels = 1;
+            threshold = [(distance.mean * sensitivity * 255.0) / max];
+        }
+        else {
+            floodChannels = inputChannels;
+            threshold = perChannelThreshold(buf, W, inputChannels, sensitivity);
+        }
+    }
+    // Fixed-range flood fill from the patch centre (napari-js's fill bucket): a pixel is taken
+    // when every channel is within its threshold of the SEED's, 4-connected.
+    const centre = (W - 1) / 2;
+    const mask = floodFill({ data: buf, width: W, height: W }, centre, centre, {
+        channels: floodChannels,
+        tolerance: threshold,
+    });
+    const closed = simple ? mask : morphClose(mask, W, 5);
+    return { mask: closed, size: W };
+}
+// ── Patch extraction ────────────────────────────────────────────────
+function extractPatch(image, cx, cy, W, type) {
+    const channels = type === 'GRAY' ? 1 : 3;
+    const half = (W - 1) / 2;
+    // The patch centres on the pixel under the click: pixel x covers [x, x + 1) on every backend.
+    const x0 = Math.floor(cx) - half;
+    const y0 = Math.floor(cy) - half;
+    const buf = new Float32Array(W * W * channels);
+    const pixels = framePixels(image.data, image.isGrayscale);
+    // A grayscale nested frame reads as (v, v, v): its value is rgb[0].
+    const gray = image.isGrayscale && !isPackedFrame(image.data);
+    const rgb = [0, 0, 0];
+    for (let py = 0; py < W; py++) {
+        const iy = y0 + py;
+        if (iy < 0 || iy >= image.height)
+            continue;
+        for (let px = 0; px < W; px++) {
+            const ix = x0 + px;
+            if (ix < 0 || ix >= image.width)
+                continue;
+            if (!pixels.rgb(ix, iy, rgb))
+                continue;
+            const dst = (py * W + px) * channels;
+            if (gray) {
+                const v = rgb[0];
+                if (channels === 1) {
+                    buf[dst] = v;
+                }
+                else {
+                    buf[dst] = v;
+                    buf[dst + 1] = v;
+                    buf[dst + 2] = v;
+                }
+            }
+            else if (channels === 1) {
+                // GRAY type forced on RGB image: convert with luminance.
+                buf[dst] = bt601Luminance(rgb[0], rgb[1], rgb[2]);
+            }
+            else {
+                buf[dst] = rgb[0];
+                buf[dst + 1] = rgb[1];
+                buf[dst + 2] = rgb[2];
+            }
+        }
+    }
+    return buf;
+}
+// ── Gaussian blur (separable) ───────────────────────────────────────
+function gaussianBlur(buf, W, channels, sigma) {
+    const radius = Math.max(1, Math.ceil(sigma * 2));
+    const size = radius * 2 + 1;
+    const kernel = new Float32Array(size);
+    let sum = 0;
+    const inv2s2 = 1 / (2 * sigma * sigma);
+    for (let i = 0; i < size; i++) {
+        const x = i - radius;
+        kernel[i] = Math.exp(-x * x * inv2s2);
+        sum += kernel[i];
+    }
+    for (let i = 0; i < size; i++)
+        kernel[i] /= sum;
+    const horiz = new Float32Array(buf.length);
+    // Horizontal pass.
+    for (let y = 0; y < W; y++) {
+        for (let x = 0; x < W; x++) {
+            for (let c = 0; c < channels; c++) {
+                let acc = 0;
+                for (let k = 0; k < size; k++) {
+                    let xx = x + k - radius;
+                    if (xx < 0)
+                        xx = 0;
+                    else if (xx >= W)
+                        xx = W - 1;
+                    acc += kernel[k] * buf[(y * W + xx) * channels + c];
+                }
+                horiz[(y * W + x) * channels + c] = acc;
+            }
+        }
+    }
+    const out = new Float32Array(buf.length);
+    // Vertical pass.
+    for (let y = 0; y < W; y++) {
+        for (let x = 0; x < W; x++) {
+            for (let c = 0; c < channels; c++) {
+                let acc = 0;
+                for (let k = 0; k < size; k++) {
+                    let yy = y + k - radius;
+                    if (yy < 0)
+                        yy = 0;
+                    else if (yy >= W)
+                        yy = W - 1;
+                    acc += kernel[k] * horiz[(yy * W + x) * channels + c];
+                }
+                out[(y * W + x) * channels + c] = acc;
+            }
+        }
+    }
+    return out;
+}
+// ── Threshold computation ───────────────────────────────────────────
+function perChannelThreshold(buf, W, channels, sensitivity) {
+    const n = W * W;
+    const sums = new Array(channels).fill(0);
+    const sqs = new Array(channels).fill(0);
+    for (let i = 0; i < n; i++) {
+        for (let c = 0; c < channels; c++) {
+            const v = buf[i * channels + c];
+            sums[c] += v;
+            sqs[c] += v * v;
+        }
+    }
+    const scale = sensitivity > 0 ? 1 / sensitivity : 100;
+    const threshold = new Array(channels);
+    for (let c = 0; c < channels; c++) {
+        const mean = sums[c] / n;
+        const variance = Math.max(0, sqs[c] / n - mean * mean);
+        const stddev = Math.sqrt(variance);
+        threshold[c] = stddev * scale;
+    }
+    return threshold;
+}
+function labDistanceMap(buf, W) {
+    const n = W * W;
+    const lab = new Float32Array(n * 3);
+    for (let i = 0; i < n; i++) {
+        const r = buf[i * 3] / 255;
+        const g = buf[i * 3 + 1] / 255;
+        const b = buf[i * 3 + 2] / 255;
+        const [L, A, B] = srgbToLab(r, g, b);
+        lab[i * 3] = L;
+        lab[i * 3 + 1] = A;
+        lab[i * 3 + 2] = B;
+    }
+    const mid = Math.floor(n / 2);
+    const cL = lab[mid * 3];
+    const cA = lab[mid * 3 + 1];
+    const cB = lab[mid * 3 + 2];
+    const values = new Float32Array(n);
+    let max = 0;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        const dL = lab[i * 3] - cL;
+        const dA = lab[i * 3 + 1] - cA;
+        const dB = lab[i * 3 + 2] - cB;
+        const d = Math.sqrt(dL * dL + dA * dA + dB * dB);
+        values[i] = d;
+        if (d > max)
+            max = d;
+        sum += d;
+    }
+    return { values, mean: sum / n, max };
+}
+// ── Morphological close (dilate then erode) ─────────────────────────
+function morphClose(mask, W, kernelSize) {
+    const r = (kernelSize - 1) / 2;
+    const dil = dilate(mask, W, r);
+    return erode(dil, W, r);
+}
+function dilate(mask, W, r) {
+    const out = new Uint8Array(W * W);
+    for (let y = 0; y < W; y++) {
+        for (let x = 0; x < W; x++) {
+            let hit = 0;
+            for (let dy = -r; dy <= r && !hit; dy++) {
+                const yy = y + dy;
+                if (yy < 0 || yy >= W)
+                    continue;
+                for (let dx = -r; dx <= r; dx++) {
+                    const xx = x + dx;
+                    if (xx < 0 || xx >= W)
+                        continue;
+                    if (mask[yy * W + xx]) {
+                        hit = 1;
+                        break;
+                    }
+                }
+            }
+            out[y * W + x] = hit;
+        }
+    }
+    return out;
+}
+function erode(mask, W, r) {
+    const out = new Uint8Array(W * W);
+    for (let y = 0; y < W; y++) {
+        for (let x = 0; x < W; x++) {
+            let all = 1;
+            for (let dy = -r; dy <= r && all; dy++) {
+                const yy = y + dy;
+                if (yy < 0 || yy >= W) {
+                    all = 0;
+                    break;
+                }
+                for (let dx = -r; dx <= r; dx++) {
+                    const xx = x + dx;
+                    if (xx < 0 || xx >= W) {
+                        all = 0;
+                        break;
+                    }
+                    if (!mask[yy * W + xx]) {
+                        all = 0;
+                        break;
+                    }
+                }
+            }
+            out[y * W + x] = all;
+        }
+    }
+    return out;
+}
+// ── sRGB → CIELAB (D65) ───────────────────────────────────────────────
+function srgbToLinear(c) {
+    return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function srgbToLab(r, g, b) {
+    const R = srgbToLinear(r);
+    const G = srgbToLinear(g);
+    const B = srgbToLinear(b);
+    // sRGB → XYZ (D65)
+    const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;
+    const Y = R * 0.2126729 + G * 0.7151522 + B * 0.072175;
+    const Z = R * 0.0193339 + G * 0.119192 + B * 0.9503041;
+    // Reference white (D65)
+    const Xn = 0.95047, Yn = 1.0, Zn = 1.08883;
+    const fx = labF(X / Xn);
+    const fy = labF(Y / Yn);
+    const fz = labF(Z / Zn);
+    const L = 116 * fy - 16;
+    const A = 500 * (fx - fy);
+    const Bv = 200 * (fy - fz);
+    return [L, A, Bv];
+}
+function labF(t) {
+    const d = 6 / 29;
+    return t > d * d * d ? Math.cbrt(t) : t / (3 * d * d) + 4 / 29;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wand-region-grow.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/wand/wand-region-grow.ts"],"names":[],"mappings":"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","sourcesContent":["import { floodFill } from 'napari-js/geometry';\n\nimport { Polygon } from '../../models/region';\nimport { maskToPolygons } from '../../geometry/contour';\nimport { IWandOptions, WandType } from '../../contracts/display-types';\nimport { bt601Luminance } from '../../contracts/intensity';\nimport { CachedFrame, framePixels, isPackedFrame } from '../tool-kit/frame-pixels';\n\n/**\n * Wand region-grow pipeline (pure, DOM- and DI-free), modelled after QuPath's\n * WandToolEventHandler: extract a square patch around the click, optionally\n * blur it, compute a local threshold (per channel, or a CIELAB distance map),\n * run a fixed-range flood fill from the centre, close the mask, and (for\n * {@link computeWandRegion}) trace it to a polygon in image coordinates.\n *\n * `WandService` delegates here; workers and new code should import these\n * functions directly.\n */\n\nexport type { WandType };\nexport type WandOptions = IWandOptions;\n\nexport interface WandImage {\n  /**\n   * Grayscale: number[][] where data[y][x] is intensity.\n   * RGB: [r,g,b][][] where data[y][x] is a 3-tuple.\n   * Or a packed RGBA readback, read as RGB (see `tool-kit/frame-pixels`).\n   */\n  data: CachedFrame;\n  width: number;\n  height: number;\n  isGrayscale: boolean;\n}\n\n/** A wand patch mask: `size`×`size` 0/1 cells in patch-local coordinates. */\nexport interface WandPatchMask {\n  mask: Uint8Array;\n  size: number;\n}\n\nconst DEFAULT_PATCH_SIZE = 149;\nconst DEFAULT_SIGMA = 4.0;\nconst DEFAULT_SENSITIVITY = 2.0;\n\n/**\n * Grow a region from a click and trace it.\n *\n * @param image full-image pixel matrix (already in memory).\n * @param cx click x in image-pixel coordinates.\n * @param cy click y in image-pixel coordinates.\n * @param options wand parameters; missing fields fall back to defaults.\n * @returns a Polygon in image-pixel coordinates, or null if no region grew.\n */\nexport function computeWandRegion(\n  image: WandImage,\n  cx: number,\n  cy: number,\n  options: WandOptions = {},\n): Polygon | null {\n  const patch = computeWandPatchMask(image, cx, cy, options);\n  if (!patch) return null;\n  // The largest traced piece (with holes of 4+ px, as the tools trace); single pixels still count.\n  return (\n    maskToPolygons(\n      patch.mask,\n      patch.size,\n      patch.size,\n      Math.floor(cx) - (patch.size - 1) / 2,\n      Math.floor(cy) - (patch.size - 1) / 2,\n      1,\n      4,\n    )[0] ?? null\n  );\n}\n\n/**\n * The wand's per-click flood-fill mask in patch-local coordinates: the same\n * pipeline as {@link computeWandRegion}, stopping before contour tracing (the\n * tools accumulate per-tick masks across a brush-style stroke).\n *\n * @throws when `options.patchSize` is even.\n */\nexport function computeWandPatchMask(\n  image: WandImage,\n  cx: number,\n  cy: number,\n  options: WandOptions = {},\n): WandPatchMask | null {\n  const W = options.patchSize ?? DEFAULT_PATCH_SIZE;\n  if (W % 2 === 0) {\n    throw new Error(`patchSize must be odd, got ${W}`);\n  }\n  const sigma = options.sigma ?? DEFAULT_SIGMA;\n  const sensitivity = options.sensitivity ?? DEFAULT_SENSITIVITY;\n  const isGrayscale = image.isGrayscale;\n  const type: WandType = options.type ?? (isGrayscale ? 'GRAY' : 'RGB');\n  const simple = !!options.simpleMode;\n  // extractPatch always interleaves 1 channel for GRAY, 3 for RGB/LAB_DISTANCE.\n  const inputChannels = type === 'GRAY' ? 1 : 3;\n\n  let buf = extractPatch(image, cx, cy, W, type);\n\n  // Flood fill operates on whatever buffer we end up with: the raw patch in\n  // simple mode (so multi-channel exact-match), the blurred patch for\n  // GRAY/RGB, or the single-channel CIELAB distance map for LAB_DISTANCE.\n  let floodChannels: number;\n  let threshold: number[];\n\n  if (simple) {\n    // Skip blur + threshold computation. Flood-fill the raw patch at\n    // exact-match per channel — same as QuPath's doSimpleSelection.\n    floodChannels = inputChannels;\n    threshold = new Array(floodChannels).fill(0);\n  } else {\n    const blurSigma = Math.max(0.5, sigma);\n    buf = gaussianBlur(buf, W, inputChannels, blurSigma);\n\n    if (type === 'LAB_DISTANCE') {\n      // Convert blurred 3-channel patch to a single-channel distance map,\n      // then flood-fill on that single channel.\n      const distance = labDistanceMap(buf, W);\n      const max = distance.max > 0 ? distance.max : 1;\n      const scaled = new Float32Array(W * W);\n      for (let i = 0; i < scaled.length; i++) scaled[i] = (distance.values[i] * 255.0) / max;\n      buf = scaled;\n      floodChannels = 1;\n      threshold = [(distance.mean * sensitivity * 255.0) / max];\n    } else {\n      floodChannels = inputChannels;\n      threshold = perChannelThreshold(buf, W, inputChannels, sensitivity);\n    }\n  }\n\n  // Fixed-range flood fill from the patch centre (napari-js's fill bucket): a pixel is taken\n  // when every channel is within its threshold of the SEED's, 4-connected.\n  const centre = (W - 1) / 2;\n  const mask = floodFill({ data: buf, width: W, height: W }, centre, centre, {\n    channels: floodChannels,\n    tolerance: threshold,\n  });\n  const closed = simple ? mask : morphClose(mask, W, 5);\n  return { mask: closed, size: W };\n}\n\n// ── Patch extraction ────────────────────────────────────────────────\n\nfunction extractPatch(image: WandImage, cx: number, cy: number, W: number, type: WandType): Float32Array {\n  const channels = type === 'GRAY' ? 1 : 3;\n  const half = (W - 1) / 2;\n  // The patch centres on the pixel under the click: pixel x covers [x, x + 1) on every backend.\n  const x0 = Math.floor(cx) - half;\n  const y0 = Math.floor(cy) - half;\n  const buf = new Float32Array(W * W * channels);\n  const pixels = framePixels(image.data, image.isGrayscale);\n  // A grayscale nested frame reads as (v, v, v): its value is rgb[0].\n  const gray = image.isGrayscale && !isPackedFrame(image.data);\n  const rgb = [0, 0, 0];\n\n  for (let py = 0; py < W; py++) {\n    const iy = y0 + py;\n    if (iy < 0 || iy >= image.height) continue;\n    for (let px = 0; px < W; px++) {\n      const ix = x0 + px;\n      if (ix < 0 || ix >= image.width) continue;\n      if (!pixels.rgb(ix, iy, rgb)) continue;\n      const dst = (py * W + px) * channels;\n      if (gray) {\n        const v = rgb[0];\n        if (channels === 1) {\n          buf[dst] = v;\n        } else {\n          buf[dst] = v;\n          buf[dst + 1] = v;\n          buf[dst + 2] = v;\n        }\n      } else if (channels === 1) {\n        // GRAY type forced on RGB image: convert with luminance.\n        buf[dst] = bt601Luminance(rgb[0], rgb[1], rgb[2]);\n      } else {\n        buf[dst] = rgb[0];\n        buf[dst + 1] = rgb[1];\n        buf[dst + 2] = rgb[2];\n      }\n    }\n  }\n  return buf;\n}\n\n// ── Gaussian blur (separable) ───────────────────────────────────────\n\nfunction gaussianBlur(buf: Float32Array, W: number, channels: number, sigma: number): Float32Array {\n  const radius = Math.max(1, Math.ceil(sigma * 2));\n  const size = radius * 2 + 1;\n  const kernel = new Float32Array(size);\n  let sum = 0;\n  const inv2s2 = 1 / (2 * sigma * sigma);\n  for (let i = 0; i < size; i++) {\n    const x = i - radius;\n    kernel[i] = Math.exp(-x * x * inv2s2);\n    sum += kernel[i];\n  }\n  for (let i = 0; i < size; i++) kernel[i] /= sum;\n\n  const horiz = new Float32Array(buf.length);\n  // Horizontal pass.\n  for (let y = 0; y < W; y++) {\n    for (let x = 0; x < W; x++) {\n      for (let c = 0; c < channels; c++) {\n        let acc = 0;\n        for (let k = 0; k < size; k++) {\n          let xx = x + k - radius;\n          if (xx < 0) xx = 0;\n          else if (xx >= W) xx = W - 1;\n          acc += kernel[k] * buf[(y * W + xx) * channels + c];\n        }\n        horiz[(y * W + x) * channels + c] = acc;\n      }\n    }\n  }\n  const out = new Float32Array(buf.length);\n  // Vertical pass.\n  for (let y = 0; y < W; y++) {\n    for (let x = 0; x < W; x++) {\n      for (let c = 0; c < channels; c++) {\n        let acc = 0;\n        for (let k = 0; k < size; k++) {\n          let yy = y + k - radius;\n          if (yy < 0) yy = 0;\n          else if (yy >= W) yy = W - 1;\n          acc += kernel[k] * horiz[(yy * W + x) * channels + c];\n        }\n        out[(y * W + x) * channels + c] = acc;\n      }\n    }\n  }\n  return out;\n}\n\n// ── Threshold computation ───────────────────────────────────────────\n\nfunction perChannelThreshold(buf: Float32Array, W: number, channels: number, sensitivity: number): number[] {\n  const n = W * W;\n  const sums = new Array(channels).fill(0);\n  const sqs = new Array(channels).fill(0);\n  for (let i = 0; i < n; i++) {\n    for (let c = 0; c < channels; c++) {\n      const v = buf[i * channels + c];\n      sums[c] += v;\n      sqs[c] += v * v;\n    }\n  }\n  const scale = sensitivity > 0 ? 1 / sensitivity : 100;\n  const threshold = new Array(channels);\n  for (let c = 0; c < channels; c++) {\n    const mean = sums[c] / n;\n    const variance = Math.max(0, sqs[c] / n - mean * mean);\n    const stddev = Math.sqrt(variance);\n    threshold[c] = stddev * scale;\n  }\n  return threshold;\n}\n\nfunction labDistanceMap(buf: Float32Array, W: number): { values: Float32Array; mean: number; max: number } {\n  const n = W * W;\n  const lab = new Float32Array(n * 3);\n  for (let i = 0; i < n; i++) {\n    const r = buf[i * 3] / 255;\n    const g = buf[i * 3 + 1] / 255;\n    const b = buf[i * 3 + 2] / 255;\n    const [L, A, B] = srgbToLab(r, g, b);\n    lab[i * 3] = L;\n    lab[i * 3 + 1] = A;\n    lab[i * 3 + 2] = B;\n  }\n  const mid = Math.floor(n / 2);\n  const cL = lab[mid * 3];\n  const cA = lab[mid * 3 + 1];\n  const cB = lab[mid * 3 + 2];\n\n  const values = new Float32Array(n);\n  let max = 0;\n  let sum = 0;\n  for (let i = 0; i < n; i++) {\n    const dL = lab[i * 3] - cL;\n    const dA = lab[i * 3 + 1] - cA;\n    const dB = lab[i * 3 + 2] - cB;\n    const d = Math.sqrt(dL * dL + dA * dA + dB * dB);\n    values[i] = d;\n    if (d > max) max = d;\n    sum += d;\n  }\n  return { values, mean: sum / n, max };\n}\n\n// ── Morphological close (dilate then erode) ─────────────────────────\n\nfunction morphClose(mask: Uint8Array, W: number, kernelSize: number): Uint8Array {\n  const r = (kernelSize - 1) / 2;\n  const dil = dilate(mask, W, r);\n  return erode(dil, W, r);\n}\n\nfunction dilate(mask: Uint8Array, W: number, r: number): Uint8Array {\n  const out = new Uint8Array(W * W);\n  for (let y = 0; y < W; y++) {\n    for (let x = 0; x < W; x++) {\n      let hit = 0;\n      for (let dy = -r; dy <= r && !hit; dy++) {\n        const yy = y + dy;\n        if (yy < 0 || yy >= W) continue;\n        for (let dx = -r; dx <= r; dx++) {\n          const xx = x + dx;\n          if (xx < 0 || xx >= W) continue;\n          if (mask[yy * W + xx]) {\n            hit = 1;\n            break;\n          }\n        }\n      }\n      out[y * W + x] = hit;\n    }\n  }\n  return out;\n}\n\nfunction erode(mask: Uint8Array, W: number, r: number): Uint8Array {\n  const out = new Uint8Array(W * W);\n  for (let y = 0; y < W; y++) {\n    for (let x = 0; x < W; x++) {\n      let all = 1;\n      for (let dy = -r; dy <= r && all; dy++) {\n        const yy = y + dy;\n        if (yy < 0 || yy >= W) {\n          all = 0;\n          break;\n        }\n        for (let dx = -r; dx <= r; dx++) {\n          const xx = x + dx;\n          if (xx < 0 || xx >= W) {\n            all = 0;\n            break;\n          }\n          if (!mask[yy * W + xx]) {\n            all = 0;\n            break;\n          }\n        }\n      }\n      out[y * W + x] = all;\n    }\n  }\n  return out;\n}\n\n// ── sRGB → CIELAB (D65) ───────────────────────────────────────────────\n\nfunction srgbToLinear(c: number): number {\n  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);\n}\n\nfunction srgbToLab(r: number, g: number, b: number): [number, number, number] {\n  const R = srgbToLinear(r);\n  const G = srgbToLinear(g);\n  const B = srgbToLinear(b);\n  // sRGB → XYZ (D65)\n  const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;\n  const Y = R * 0.2126729 + G * 0.7151522 + B * 0.072175;\n  const Z = R * 0.0193339 + G * 0.119192 + B * 0.9503041;\n  // Reference white (D65)\n  const Xn = 0.95047,\n    Yn = 1.0,\n    Zn = 1.08883;\n  const fx = labF(X / Xn);\n  const fy = labF(Y / Yn);\n  const fz = labF(Z / Zn);\n  const L = 116 * fy - 16;\n  const A = 500 * (fx - fy);\n  const Bv = 200 * (fy - fz);\n  return [L, A, Bv];\n}\n\nfunction labF(t: number): number {\n  const d = 6 / 29;\n  return t > d * d * d ? Math.cbrt(t) : t / (3 * d * d) + 4 / 29;\n}\n"]}