@jax-data-science/sci-image-visualizer 0.1.0

package/esm2022/lib/processing/image-converter.service.mjs

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import { ProcessingImage } from './processing-image';
+import * as i0 from "@angular/core";
+/**
+ * Converts between various image representations. Bridges image-js, browser
+ * canvas/image elements, and the neutral {@link ProcessingImage}. Generic image
+ * plumbing — no app/pipeline coupling.
+ */
+export class ImageConverterService {
+    /**
+     * Convert an image-js Image instance to ProcessingImage.
+     * image-js stores pixel data in a typed array with shape (width*height*channels).
+     */
+    fromImageJs(image) {
+        const width = image.width;
+        const height = image.height;
+        const channels = image.channels;
+        // image-js data is Uint8Array or Uint16Array; normalize to Uint8ClampedArray
+        let data;
+        if (image.bitDepth > 8) {
+            // Normalize 16-bit to 8-bit
+            const src = image.data;
+            const max = (1 << image.bitDepth) - 1;
+            data = new Uint8ClampedArray(src.length);
+            for (let i = 0; i < src.length; i++) {
+                data[i] = Math.round((src[i] / max) * 255);
+            }
+        }
+        else {
+            data = new Uint8ClampedArray(image.data);
+        }
+        return new ProcessingImage(width, height, channels, data);
+    }
+    /** Convert from an HTMLCanvasElement. */
+    fromCanvas(canvas) {
+        const ctx = canvas.getContext('2d');
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        return ProcessingImage.fromImageData(imageData);
+    }
+    /** Convert from an HTMLImageElement. */
+    fromHtmlImage(img) {
+        const canvas = document.createElement('canvas');
+        canvas.width = img.naturalWidth;
+        canvas.height = img.naturalHeight;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        return this.fromCanvas(canvas);
+    }
+    /** Convert ProcessingImage to a 2D array suitable for Plotly heatmap (grayscale). */
+    toPlotlyHeatmapZ(image) {
+        const z = [];
+        for (let y = 0; y < image.height; y++) {
+            const row = [];
+            for (let x = 0; x < image.width; x++) {
+                const idx = (y * image.width + x) * image.channels;
+                row.push(image.data[idx]);
+            }
+            z.push(row);
+        }
+        return z;
+    }
+    /** Convert ProcessingImage to Plotly RGB arrays [r[][], g[][], b[][]]. */
+    toPlotlyRgbArrays(image) {
+        const r = [];
+        const g = [];
+        const b = [];
+        for (let y = 0; y < image.height; y++) {
+            const rRow = [];
+            const gRow = [];
+            const bRow = [];
+            for (let x = 0; x < image.width; x++) {
+                const idx = (y * image.width + x) * image.channels;
+                rRow.push(image.data[idx]);
+                gRow.push(image.data[idx + 1]);
+                bRow.push(image.data[idx + 2]);
+            }
+            r.push(rRow);
+            g.push(gRow);
+            b.push(bRow);
+        }
+        return { r, g, b };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ImageConverterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ImageConverterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ImageConverterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-converter.service.js","sourceRoot":"","sources":["../../../../src/lib/processing/image-converter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ProcessingImage } from './processing-image';\n\n/**\n * Converts between various image representations. Bridges image-js, browser\n * canvas/image elements, and the neutral {@link ProcessingImage}. Generic image\n * plumbing — no app/pipeline coupling.\n */\n@Injectable({ providedIn: 'root' })\nexport class ImageConverterService {\n  /**\n   * Convert an image-js Image instance to ProcessingImage.\n   * image-js stores pixel data in a typed array with shape (width*height*channels).\n   */\n  fromImageJs(image: any): ProcessingImage {\n    const width = image.width as number;\n    const height = image.height as number;\n    const channels = image.channels as number;\n\n    // image-js data is Uint8Array or Uint16Array; normalize to Uint8ClampedArray\n    let data: Uint8ClampedArray;\n    if (image.bitDepth > 8) {\n      // Normalize 16-bit to 8-bit\n      const src = image.data as Uint16Array;\n      const max = (1 << image.bitDepth) - 1;\n      data = new Uint8ClampedArray(src.length);\n      for (let i = 0; i < src.length; i++) {\n        data[i] = Math.round((src[i] / max) * 255);\n      }\n    } else {\n      data = new Uint8ClampedArray(image.data);\n    }\n\n    return new ProcessingImage(width, height, channels, data);\n  }\n\n  /** Convert from an HTMLCanvasElement. */\n  fromCanvas(canvas: HTMLCanvasElement): ProcessingImage {\n    const ctx = canvas.getContext('2d')!;\n    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);\n    return ProcessingImage.fromImageData(imageData);\n  }\n\n  /** Convert from an HTMLImageElement. */\n  fromHtmlImage(img: HTMLImageElement): ProcessingImage {\n    const canvas = document.createElement('canvas');\n    canvas.width = img.naturalWidth;\n    canvas.height = img.naturalHeight;\n    const ctx = canvas.getContext('2d')!;\n    ctx.drawImage(img, 0, 0);\n    return this.fromCanvas(canvas);\n  }\n\n  /** Convert ProcessingImage to a 2D array suitable for Plotly heatmap (grayscale). */\n  toPlotlyHeatmapZ(image: ProcessingImage): number[][] {\n    const z: number[][] = [];\n    for (let y = 0; y < image.height; y++) {\n      const row: number[] = [];\n      for (let x = 0; x < image.width; x++) {\n        const idx = (y * image.width + x) * image.channels;\n        row.push(image.data[idx]);\n      }\n      z.push(row);\n    }\n    return z;\n  }\n\n  /** Convert ProcessingImage to Plotly RGB arrays [r[][], g[][], b[][]]. */\n  toPlotlyRgbArrays(image: ProcessingImage): { r: number[][]; g: number[][]; b: number[][] } {\n    const r: number[][] = [];\n    const g: number[][] = [];\n    const b: number[][] = [];\n    for (let y = 0; y < image.height; y++) {\n      const rRow: number[] = [];\n      const gRow: number[] = [];\n      const bRow: number[] = [];\n      for (let x = 0; x < image.width; x++) {\n        const idx = (y * image.width + x) * image.channels;\n        rRow.push(image.data[idx]);\n        gRow.push(image.data[idx + 1]);\n        bRow.push(image.data[idx + 2]);\n      }\n      r.push(rRow);\n      g.push(gRow);\n      b.push(bRow);\n    }\n    return { r, g, b };\n  }\n}\n"]}

package/esm2022/lib/processing/image-crop.mjs

@@ -0,0 +1,62 @@
+import { ProcessingImage } from './processing-image';
+/** Copy a clamped rectangle of an RGBA source into a fresh, tightly-packed buffer. */
+function cropRgba(src, srcWidth, srcHeight, x, y, w, h) {
+    // Clamp the rectangle to the image so bad params snap to the valid region
+    // instead of reading out of bounds.
+    const x0 = Math.max(0, Math.min(srcWidth - 1, Math.floor(x)));
+    const y0 = Math.max(0, Math.min(srcHeight - 1, Math.floor(y)));
+    const width = Math.max(1, Math.min(srcWidth - x0, Math.floor(w)));
+    const height = Math.max(1, Math.min(srcHeight - y0, Math.floor(h)));
+    const out = new Uint8ClampedArray(width * height * 4);
+    for (let row = 0; row < height; row++) {
+        const srcRow = (y0 + row) * srcWidth + x0;
+        const dstRow = row * width;
+        for (let col = 0; col < width; col++) {
+            const si = (srcRow + col) * 4;
+            const di = (dstRow + col) * 4;
+            out[di] = src[si];
+            out[di + 1] = src[si + 1];
+            out[di + 2] = src[si + 2];
+            out[di + 3] = src[si + 3];
+        }
+    }
+    return { data: out, width, height };
+}
+/** Nearest-neighbour downsample by an integer factor (≥1). factor=1 is a no-op. */
+function downsampleRgba(src, srcWidth, srcHeight, factor) {
+    if (factor <= 1)
+        return { data: src, width: srcWidth, height: srcHeight };
+    const width = Math.max(1, Math.floor(srcWidth / factor));
+    const height = Math.max(1, Math.floor(srcHeight / factor));
+    const out = new Uint8ClampedArray(width * height * 4);
+    for (let row = 0; row < height; row++) {
+        const sy = Math.min(srcHeight - 1, row * factor);
+        for (let col = 0; col < width; col++) {
+            const sx = Math.min(srcWidth - 1, col * factor);
+            const si = (sy * srcWidth + sx) * 4;
+            const di = (row * width + col) * 4;
+            out[di] = src[si];
+            out[di + 1] = src[si + 1];
+            out[di + 2] = src[si + 2];
+            out[di + 3] = src[si + 3];
+        }
+    }
+    return { data: out, width, height };
+}
+/**
+ * Crop a rectangular region out of a {@link ProcessingImage} (browser-side, the
+ * counterpart of the JIT server's Slide Crop), optionally downsampling the crop
+ * by `2^level`. The rectangle is in source pixels and clamped to the image, so
+ * out-of-range values snap to the valid region rather than throwing. Always
+ * returns a 4-channel (RGBA) image.
+ */
+export function cropImage(image, opts = {}) {
+    // Work on RGBA so the crop is channel-count agnostic.
+    const src = image.channels === 4 ? image.data : image.toImageData().data;
+    const cropped = cropRgba(src, image.width, image.height, Number(opts.x ?? 0), Number(opts.y ?? 0), Number(opts.width ?? image.width), Number(opts.height ?? image.height));
+    const level = Math.max(0, Math.floor(Number(opts.level ?? 0)));
+    const factor = level > 0 ? 2 ** level : 1;
+    const final = downsampleRgba(cropped.data, cropped.width, cropped.height, factor);
+    return new ProcessingImage(final.width, final.height, 4, final.data);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-crop.js","sourceRoot":"","sources":["../../../../src/lib/processing/image-crop.ts"],"names":[],"mappings":"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","sourcesContent":["import { ProcessingImage } from './processing-image';\n\n/** Crop options in source-image pixels. Out-of-range values are clamped. */\nexport interface CropImageOptions {\n  x?: number;\n  y?: number;\n  width?: number;\n  height?: number;\n  /** Power-of-two downsample level applied to the crop (0 = full resolution). */\n  level?: number;\n}\n\n/** Copy a clamped rectangle of an RGBA source into a fresh, tightly-packed buffer. */\nfunction cropRgba(\n  src: Uint8ClampedArray, srcWidth: number, srcHeight: number,\n  x: number, y: number, w: number, h: number,\n): { data: Uint8ClampedArray; width: number; height: number } {\n  // Clamp the rectangle to the image so bad params snap to the valid region\n  // instead of reading out of bounds.\n  const x0 = Math.max(0, Math.min(srcWidth - 1, Math.floor(x)));\n  const y0 = Math.max(0, Math.min(srcHeight - 1, Math.floor(y)));\n  const width = Math.max(1, Math.min(srcWidth - x0, Math.floor(w)));\n  const height = Math.max(1, Math.min(srcHeight - y0, Math.floor(h)));\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let row = 0; row < height; row++) {\n    const srcRow = (y0 + row) * srcWidth + x0;\n    const dstRow = row * width;\n    for (let col = 0; col < width; col++) {\n      const si = (srcRow + col) * 4;\n      const di = (dstRow + col) * 4;\n      out[di]     = src[si]     as number;\n      out[di + 1] = src[si + 1] as number;\n      out[di + 2] = src[si + 2] as number;\n      out[di + 3] = src[si + 3] as number;\n    }\n  }\n  return { data: out, width, height };\n}\n\n/** Nearest-neighbour downsample by an integer factor (≥1). factor=1 is a no-op. */\nfunction downsampleRgba(\n  src: Uint8ClampedArray, srcWidth: number, srcHeight: number, factor: number,\n): { data: Uint8ClampedArray; width: number; height: number } {\n  if (factor <= 1) return { data: src, width: srcWidth, height: srcHeight };\n  const width = Math.max(1, Math.floor(srcWidth / factor));\n  const height = Math.max(1, Math.floor(srcHeight / factor));\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let row = 0; row < height; row++) {\n    const sy = Math.min(srcHeight - 1, row * factor);\n    for (let col = 0; col < width; col++) {\n      const sx = Math.min(srcWidth - 1, col * factor);\n      const si = (sy * srcWidth + sx) * 4;\n      const di = (row * width + col) * 4;\n      out[di]     = src[si]     as number;\n      out[di + 1] = src[si + 1] as number;\n      out[di + 2] = src[si + 2] as number;\n      out[di + 3] = src[si + 3] as number;\n    }\n  }\n  return { data: out, width, height };\n}\n\n/**\n * Crop a rectangular region out of a {@link ProcessingImage} (browser-side, the\n * counterpart of the JIT server's Slide Crop), optionally downsampling the crop\n * by `2^level`. The rectangle is in source pixels and clamped to the image, so\n * out-of-range values snap to the valid region rather than throwing. Always\n * returns a 4-channel (RGBA) image.\n */\nexport function cropImage(image: ProcessingImage, opts: CropImageOptions = {}): ProcessingImage {\n  // Work on RGBA so the crop is channel-count agnostic.\n  const src = image.channels === 4 ? image.data : image.toImageData().data;\n  const cropped = cropRgba(\n    src, image.width, image.height,\n    Number(opts.x ?? 0), Number(opts.y ?? 0),\n    Number(opts.width ?? image.width), Number(opts.height ?? image.height),\n  );\n  const level = Math.max(0, Math.floor(Number(opts.level ?? 0)));\n  const factor = level > 0 ? 2 ** level : 1;\n  const final = downsampleRgba(cropped.data, cropped.width, cropped.height, factor);\n  return new ProcessingImage(final.width, final.height, 4, final.data);\n}\n"]}

package/esm2022/lib/processing/processing-image.mjs

@@ -0,0 +1,50 @@
+/**
+ * Unified image container used throughout the processing pipeline.
+ * Decouples pipeline logic from any specific library's image format.
+ */
+export class ProcessingImage {
+    /** Create from browser ImageData. */
+    static fromImageData(imageData) {
+        return new ProcessingImage(imageData.width, imageData.height, 4, new Uint8ClampedArray(imageData.data));
+    }
+    constructor(width, height, channels, data) {
+        this.width = width;
+        this.height = height;
+        this.channels = channels;
+        this.data = data;
+    }
+    /** Convert to browser-native ImageData (RGBA). */
+    toImageData() {
+        if (this.channels === 4) {
+            return new ImageData(this.data, this.width, this.height);
+        }
+        // Expand grayscale or RGB to RGBA
+        const rgba = new Uint8ClampedArray(this.width * this.height * 4);
+        for (let i = 0; i < this.width * this.height; i++) {
+            if (this.channels === 1) {
+                rgba[i * 4] = this.data[i];
+                rgba[i * 4 + 1] = this.data[i];
+                rgba[i * 4 + 2] = this.data[i];
+            }
+            else if (this.channels === 3) {
+                rgba[i * 4] = this.data[i * 3];
+                rgba[i * 4 + 1] = this.data[i * 3 + 1];
+                rgba[i * 4 + 2] = this.data[i * 3 + 2];
+            }
+            rgba[i * 4 + 3] = 255;
+        }
+        return new ImageData(rgba, this.width, this.height);
+    }
+    /** Convert to Blob for saving/downloading. */
+    async toBlob(mime = 'image/png') {
+        const canvas = document.createElement('canvas');
+        canvas.width = this.width;
+        canvas.height = this.height;
+        const ctx = canvas.getContext('2d');
+        ctx.putImageData(this.toImageData(), 0, 0);
+        return new Promise((resolve) => {
+            canvas.toBlob((blob) => resolve(blob), mime);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/provide-visualization.mjs

@@ -0,0 +1,63 @@
+import { RoutingVisualizerService } from './routing-visualizer.service';
+import { PlotlyService } from './implementations/plotly/plotly.service';
+import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
+import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
+import { VisualizerStore } from './store/visualizer-store.service';
+import { RegionStore } from './store/region-store.service';
+import { WandToolService } from './toolbar/wand/wand-tool.service';
+import { VertexEraserToolService } from './toolbar/vertex-eraser/vertex-eraser-tool.service';
+import { ZoomToBoxToolService } from './toolbar/zoom-to-box/zoom-to-box-tool.service';
+import { VISUALIZER } from './contracts/visualizer.contract';
+import { REGION_EDITOR_API } from './contracts/region-editor-api.contract';
+import { CHANNEL_HISTOGRAM_API } from './contracts/channel-histogram-api.contract';
+/**
+ * A self-contained, isolated visualization backend chain for a component subtree.
+ *
+ * The chain services are `providedIn: 'root'` singletons, so by default the whole
+ * app shares one viewer's state (regions, image, channels, render handles) — which
+ * is correct for the single main viewer. A consumer that needs a SECOND, independent
+ * viewer (e.g. a modal that mounts `<visualizer>` over the live main view
+ * and must not clobber its regions/image) drops this into its component `providers`:
+ *
+ * ```ts
+ * @Component({
+ *   ...,
+ *   providers: [
+ *     ...provideVisualization(),                 // isolated chain instance
+ *     // plus the host ports + config for THIS viewer:
+ *     { provide: IMAGE_STATE_PORT, useClass: MyImageStateAdapter },
+ *     { provide: TILE_ACCESS_PORT, useClass: MyTileAccessAdapter },
+ *     { provide: REGION_IO_PORT,   useClass: MyRegionIoAdapter },
+ *     { provide: VIZ_CONFIG,       useValue: { slideCropServer: '' } },
+ *   ],
+ * })
+ * ```
+ *
+ * Component-scoped providers shadow the root singletons for that subtree, so the
+ * embedded viewer gets its own router/Plotly/OSD/stores/tools while the rest of the
+ * app keeps the default root instance.
+ *
+ * Lists EVERY stateful service in the chain. Stateless collaborators (HttpClient,
+ * MessageService, WandService) deliberately resolve to root — they hold no
+ * per-viewer state, so sharing them is correct and keeps this list minimal. When a
+ * new stateful service joins the rendering chain, add it here too.
+ */
+export function provideVisualization() {
+    return [
+        RoutingVisualizerService,
+        PlotlyService,
+        OpenSeadragonVisualizerService,
+        NapariVisualizerService,
+        VisualizerStore,
+        RegionStore,
+        WandToolService,
+        VertexEraserToolService,
+        ZoomToBoxToolService,
+        // The three host-facing contracts are all served by the router — bound here at
+        // the SAME (component) scope so they resolve to the isolated instance, not root.
+        { provide: VISUALIZER, useExisting: RoutingVisualizerService },
+        { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },
+        { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/region-editor/mask-raster.mjs

@@ -0,0 +1,95 @@
+import { Rectangle, Polygon, MultiPolygon } from '../models/region';
+/**
+ * The largest mask we will allocate, in pixels. A single-channel 8-bit mask is
+ * one byte per pixel, so this is also its byte size. Whole-slide level-0 images
+ * (e.g. 119040×90112 ≈ 1.07e10 px) blow past both the JS typed-array length cap
+ * (~4.29e9) and available memory, so masks for images larger than this are
+ * rasterized at a proportionally downscaled resolution. ~100 MP ≈ 100 MB.
+ */
+export const MAX_MASK_PIXELS = 100_000_000;
+/** Downscale factor (≤ 1) to keep `width * height` within {@link MAX_MASK_PIXELS}.
+ *  1 when the image already fits. */
+export function maskScaleFor(width, height) {
+    const total = width * height;
+    if (!Number.isFinite(total) || total <= MAX_MASK_PIXELS)
+        return 1;
+    return Math.sqrt(MAX_MASK_PIXELS / total);
+}
+/** Multiply every coordinate (and hole coordinate) of a region's parts by
+ *  `scale`, for rasterizing into a downscaled mask. Returns the parts unchanged
+ *  when `scale` is 1. */
+export function scaleParts(parts, scale) {
+    if (scale === 1)
+        return parts;
+    return parts.map((p) => ({
+        xpoints: p.xpoints.map((x) => x * scale),
+        ypoints: p.ypoints.map((y) => y * scale),
+        holes: p.holes?.map((ring) => ring.map(([x, y]) => [x * scale, y * scale])),
+    }));
+}
+/** Flatten a region's geometry to plain rings. Rectangles become a 4-point ring;
+ *  polygons keep their points + holes; multi-polygons expand to one part each. */
+export function regionToParts(region) {
+    const b = region.bounds;
+    if (b instanceof Rectangle) {
+        return [{
+                xpoints: [b.x, b.x + b.width, b.x + b.width, b.x],
+                ypoints: [b.y, b.y, b.y + b.height, b.y + b.height],
+            }];
+    }
+    if (b instanceof Polygon) {
+        return [{ xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes }];
+    }
+    if (b instanceof MultiPolygon) {
+        return b.polygons.map((p) => ({ xpoints: p.xpoints, ypoints: p.ypoints, holes: p.holes }));
+    }
+    return [];
+}
+/**
+ * Rasterize regions (as plain parts) to a full image-size label mask (row-major,
+ * `W * H` samples; pixel `(x, y)` at `y * W + x`). Background is 0.
+ *
+ * - `'binary'` — every region pixel is 255 (standard 8-bit black/white mask:
+ *   `> 0` = foreground; also directly viewable).
+ * - `'multiclass'` — each region gets a distinct 1-based id (its index + 1).
+ *   Stays 8-bit for ≤255 regions; promotes to 16-bit beyond that. Ids are
+ *   distinct up to the 16-bit ceiling (65535 regions); a selection larger than
+ *   that exceeds the PNG's representable range and ids wrap (not a realistic
+ *   hand-annotation case, but called out so the limit is explicit).
+ *
+ * Later regions paint over earlier ones where they overlap. `onProgress` is
+ * called after each region (1-based) so a caller can drive a progress bar.
+ * Returns null when nothing rasterises (no regions, zero/insane size).
+ */
+export function regionsToMask(regions, imageWidth, imageHeight, mode, rasterize, onProgress) {
+    const W = Math.round(imageWidth);
+    const H = Math.round(imageHeight);
+    if (!Number.isFinite(W) || !Number.isFinite(H) || W <= 0 || H <= 0 || !regions?.length) {
+        return null;
+    }
+    const multiclass = mode === 'multiclass';
+    const bitDepth = multiclass && regions.length > 255 ? 16 : 8;
+    const out = bitDepth === 16 ? new Uint16Array(W * H) : new Uint8Array(W * H);
+    let painted = false;
+    for (let i = 0; i < regions.length; i++) {
+        // Binary → 255 (viewable, standard). Multi-class → 1-based class id.
+        const value = multiclass ? i + 1 : 255;
+        for (const part of regions[i]) {
+            const m = rasterize(part.xpoints, part.ypoints, W, H, part.holes);
+            if (!m)
+                continue;
+            painted = true;
+            for (let y = 0; y < m.bh; y++) {
+                const srcRow = y * m.bw;
+                const dstRow = (m.by + y) * W + m.bx;
+                for (let x = 0; x < m.bw; x++) {
+                    if (m.mask[srcRow + x])
+                        out[dstRow + x] = value;
+                }
+            }
+        }
+        onProgress?.(i + 1, regions.length);
+    }
+    return painted ? { data: out, bitDepth } : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mask-raster.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/mask-raster.ts"],"names":[],"mappings":"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","sourcesContent":["import { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';\n\n/** A single closed ring (+ optional holes) in image-pixel coordinates. A region\n *  rasterizes as the union of its parts. Plain data so it survives a\n *  `postMessage` structured clone into the mask worker. */\nexport interface MaskPart {\n  xpoints: number[];\n  ypoints: number[];\n  holes?: number[][][];\n}\n\n/** A bbox-relative binary mask, as returned by `WandService.rasterizePolygon`. */\nexport interface BBoxMask {\n  bx: number;\n  by: number;\n  bw: number;\n  bh: number;\n  mask: Uint8Array;\n}\n\n/** Polygon-fill function (the wand's scanline rasterizer), injected so this\n *  module stays free of Angular/DOM and can run inside a worker. */\nexport type RasterizeFn = (\n  xpoints: number[],\n  ypoints: number[],\n  imageWidth: number,\n  imageHeight: number,\n  holes?: number[][][],\n) => BBoxMask | null;\n\n/**\n * The largest mask we will allocate, in pixels. A single-channel 8-bit mask is\n * one byte per pixel, so this is also its byte size. Whole-slide level-0 images\n * (e.g. 119040×90112 ≈ 1.07e10 px) blow past both the JS typed-array length cap\n * (~4.29e9) and available memory, so masks for images larger than this are\n * rasterized at a proportionally downscaled resolution. ~100 MP ≈ 100 MB.\n */\nexport const MAX_MASK_PIXELS = 100_000_000;\n\n/** Downscale factor (≤ 1) to keep `width * height` within {@link MAX_MASK_PIXELS}.\n *  1 when the image already fits. */\nexport function maskScaleFor(width: number, height: number): number {\n  const total = width * height;\n  if (!Number.isFinite(total) || total <= MAX_MASK_PIXELS) return 1;\n  return Math.sqrt(MAX_MASK_PIXELS / total);\n}\n\n/** Multiply every coordinate (and hole coordinate) of a region's parts by\n *  `scale`, for rasterizing into a downscaled mask. Returns the parts unchanged\n *  when `scale` is 1. */\nexport function scaleParts(parts: MaskPart[], scale: number): MaskPart[] {\n  if (scale === 1) return parts;\n  return parts.map((p) => ({\n    xpoints: p.xpoints.map((x) => x * scale),\n    ypoints: p.ypoints.map((y) => y * scale),\n    holes: p.holes?.map((ring) => ring.map(([x, y]) => [x * scale, y * scale])),\n  }));\n}\n\n/** Flatten a region's geometry to plain rings. Rectangles become a 4-point ring;\n *  polygons keep their points + holes; multi-polygons expand to one part each. */\nexport function regionToParts(region: Region): MaskPart[] {\n  const b = region.bounds;\n  if (b instanceof Rectangle) {\n    return [{\n      xpoints: [b.x, b.x + b.width, b.x + b.width, b.x],\n      ypoints: [b.y, b.y, b.y + b.height, b.y + b.height],\n    }];\n  }\n  if (b instanceof Polygon) {\n    return [{ xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes }];\n  }\n  if (b instanceof MultiPolygon) {\n    return b.polygons.map((p) => ({ xpoints: p.xpoints, ypoints: p.ypoints, holes: p.holes }));\n  }\n  return [];\n}\n\n/** A rasterized label mask plus the PNG bit depth it should be encoded at. */\nexport interface LabelMask {\n  data: Uint8Array | Uint16Array;\n  /** 8 for ≤255 distinct values, 16 for a multi-class mask with >255 regions. */\n  bitDepth: 8 | 16;\n}\n\n/**\n * Rasterize regions (as plain parts) to a full image-size label mask (row-major,\n * `W * H` samples; pixel `(x, y)` at `y * W + x`). Background is 0.\n *\n * - `'binary'` — every region pixel is 255 (standard 8-bit black/white mask:\n *   `> 0` = foreground; also directly viewable).\n * - `'multiclass'` — each region gets a distinct 1-based id (its index + 1).\n *   Stays 8-bit for ≤255 regions; promotes to 16-bit beyond that. Ids are\n *   distinct up to the 16-bit ceiling (65535 regions); a selection larger than\n *   that exceeds the PNG's representable range and ids wrap (not a realistic\n *   hand-annotation case, but called out so the limit is explicit).\n *\n * Later regions paint over earlier ones where they overlap. `onProgress` is\n * called after each region (1-based) so a caller can drive a progress bar.\n * Returns null when nothing rasterises (no regions, zero/insane size).\n */\nexport function regionsToMask(\n  regions: MaskPart[][],\n  imageWidth: number,\n  imageHeight: number,\n  mode: 'binary' | 'multiclass',\n  rasterize: RasterizeFn,\n  onProgress?: (done: number, total: number) => void,\n): LabelMask | null {\n  const W = Math.round(imageWidth);\n  const H = Math.round(imageHeight);\n  if (!Number.isFinite(W) || !Number.isFinite(H) || W <= 0 || H <= 0 || !regions?.length) {\n    return null;\n  }\n\n  const multiclass = mode === 'multiclass';\n  const bitDepth: 8 | 16 = multiclass && regions.length > 255 ? 16 : 8;\n  const out: Uint8Array | Uint16Array =\n    bitDepth === 16 ? new Uint16Array(W * H) : new Uint8Array(W * H);\n  let painted = false;\n  for (let i = 0; i < regions.length; i++) {\n    // Binary → 255 (viewable, standard). Multi-class → 1-based class id.\n    const value = multiclass ? i + 1 : 255;\n    for (const part of regions[i]) {\n      const m = rasterize(part.xpoints, part.ypoints, W, H, part.holes);\n      if (!m) continue;\n      painted = true;\n      for (let y = 0; y < m.bh; y++) {\n        const srcRow = y * m.bw;\n        const dstRow = (m.by + y) * W + m.bx;\n        for (let x = 0; x < m.bw; x++) {\n          if (m.mask[srcRow + x]) out[dstRow + x] = value;\n        }\n      }\n    }\n    onProgress?.(i + 1, regions.length);\n  }\n  return painted ? { data: out, bitDepth } : null;\n}\n"]}

package/esm2022/lib/region-editor/mask-worker.mjs

@@ -0,0 +1,10 @@
+/**
+ * Factory for the mask-export Web Worker, isolated in its own module so the
+ * `import.meta.url` reference (required by the bundler to locate the worker) is
+ * never pulled into the ts-jest CommonJS compile of the component — the unit
+ * tests `jest.mock` this module instead.
+ */
+export function createMaskWorker() {
+    return new Worker(new URL('./mask.worker', import.meta.url), { type: 'module' });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFzay13b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlZ2lvbi1lZGl0b3IvbWFzay13b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCO0lBQzlCLE9BQU8sSUFBSSxNQUFNLENBQUMsSUFBSSxHQUFHLENBQUMsZUFBZSxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztBQUNuRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGYWN0b3J5IGZvciB0aGUgbWFzay1leHBvcnQgV2ViIFdvcmtlciwgaXNvbGF0ZWQgaW4gaXRzIG93biBtb2R1bGUgc28gdGhlXG4gKiBgaW1wb3J0Lm1ldGEudXJsYCByZWZlcmVuY2UgKHJlcXVpcmVkIGJ5IHRoZSBidW5kbGVyIHRvIGxvY2F0ZSB0aGUgd29ya2VyKSBpc1xuICogbmV2ZXIgcHVsbGVkIGludG8gdGhlIHRzLWplc3QgQ29tbW9uSlMgY29tcGlsZSBvZiB0aGUgY29tcG9uZW50IOKAlCB0aGUgdW5pdFxuICogdGVzdHMgYGplc3QubW9ja2AgdGhpcyBtb2R1bGUgaW5zdGVhZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1hc2tXb3JrZXIoKTogV29ya2VyIHtcbiAgcmV0dXJuIG5ldyBXb3JrZXIobmV3IFVSTCgnLi9tYXNrLndvcmtlcicsIGltcG9ydC5tZXRhLnVybCksIHsgdHlwZTogJ21vZHVsZScgfSk7XG59XG4iXX0=