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

package/esm2022/lib/toolbar/segmentation/sam-prompt.mjs

@@ -0,0 +1,94 @@
+/**
+ * Pure helpers for SAM inference — no DOM, no ORT, no `this` — so they're unit
+ * testable. The session uses these to assemble decoder inputs and to convert
+ * the cached image frame into the RGBA buffer the encoder preprocesses.
+ */
+/**
+ * Build an RGBA buffer (the encoder's input image) from a cached image frame.
+ * Grayscale frames are replicated across R/G/B; RGB tuples are copied through.
+ * Out-of-range/missing pixels become opaque black.
+ */
+export function frameToRgba(cached, frameIndex) {
+    const { width, height } = cached;
+    const frame = cached.frames[frameIndex] ?? cached.frames[0];
+    const rgba = new Uint8ClampedArray(width * height * 4);
+    for (let y = 0; y < height; y++) {
+        const row = frame?.[y];
+        for (let x = 0; x < width; x++) {
+            const o = (y * width + x) * 4;
+            const px = row?.[x];
+            if (px == null) {
+                rgba[o + 3] = 255;
+                continue;
+            }
+            if (cached.isGrayscale) {
+                const v = px;
+                rgba[o] = v;
+                rgba[o + 1] = v;
+                rgba[o + 2] = v;
+            }
+            else {
+                const t = px;
+                rgba[o] = t[0];
+                rgba[o + 1] = t[1];
+                rgba[o + 2] = t[2];
+            }
+            rgba[o + 3] = 255;
+        }
+    }
+    return rgba;
+}
+/**
+ * Assemble the SAM decoder's `point_coords` / `point_labels` from a prompt.
+ *
+ * Coordinates are scaled into the encoder's resized space (`scale =
+ * inputSize / max(imageW, imageH)`). A box is encoded as two points labelled
+ * `2` (top-left) and `3` (bottom-right); positive/negative points use `1`/`0`.
+ * When there are points but no box, a padding point `[0,0]` labelled `-1` is
+ * appended (the decoder expects the box slots padded when absent).
+ */
+export function buildDecoderPrompt(prompt, scale) {
+    const coords = [];
+    const labels = [];
+    for (const p of prompt.points ?? []) {
+        coords.push(p.x * scale, p.y * scale);
+        labels.push(p.label);
+    }
+    if (prompt.box) {
+        const b = prompt.box;
+        coords.push(b.x0 * scale, b.y0 * scale);
+        labels.push(2);
+        coords.push(b.x1 * scale, b.y1 * scale);
+        labels.push(3);
+    }
+    else if (labels.length > 0) {
+        // Points-only: pad the (absent) box slot.
+        coords.push(0, 0);
+        labels.push(-1);
+    }
+    return {
+        pointCoords: Float32Array.from(coords),
+        pointLabels: Float32Array.from(labels),
+        numPoints: labels.length,
+    };
+}
+/**
+ * Binarize SAM mask logits (`> threshold`, default 0 per SAM's mask_threshold)
+ * into a 0/1 mask the contour tracer (WandService.maskToPolygons) consumes.
+ */
+export function binarizeMask(logits, threshold = 0) {
+    const out = new Uint8Array(logits.length);
+    for (let i = 0; i < logits.length; i++)
+        out[i] = logits[i] > threshold ? 1 : 0;
+    return out;
+}
+/** Index of the highest-scoring mask in a multimask decoder output. */
+export function bestMaskIndex(iouPredictions) {
+    let best = 0;
+    for (let i = 1; i < iouPredictions.length; i++) {
+        if (iouPredictions[i] > iouPredictions[best])
+            best = i;
+    }
+    return best;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-prompt.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-prompt.ts"],"names":[],"mappings":"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","sourcesContent":["import { CachedImageData } from '../wand/wand-tool.service';\nimport { SamPrompt } from '../../contracts/sam.contract';\n\n/**\n * Pure helpers for SAM inference — no DOM, no ORT, no `this` — so they're unit\n * testable. The session uses these to assemble decoder inputs and to convert\n * the cached image frame into the RGBA buffer the encoder preprocesses.\n */\n\n/**\n * Build an RGBA buffer (the encoder's input image) from a cached image frame.\n * Grayscale frames are replicated across R/G/B; RGB tuples are copied through.\n * Out-of-range/missing pixels become opaque black.\n */\nexport function frameToRgba(cached: CachedImageData, frameIndex: number): Uint8ClampedArray {\n  const { width, height } = cached;\n  const frame = cached.frames[frameIndex] ?? cached.frames[0];\n  const rgba = new Uint8ClampedArray(width * height * 4);\n  for (let y = 0; y < height; y++) {\n    const row = frame?.[y];\n    for (let x = 0; x < width; x++) {\n      const o = (y * width + x) * 4;\n      const px = row?.[x];\n      if (px == null) {\n        rgba[o + 3] = 255;\n        continue;\n      }\n      if (cached.isGrayscale) {\n        const v = px as number;\n        rgba[o] = v; rgba[o + 1] = v; rgba[o + 2] = v;\n      } else {\n        const t = px as number[];\n        rgba[o] = t[0]; rgba[o + 1] = t[1]; rgba[o + 2] = t[2];\n      }\n      rgba[o + 3] = 255;\n    }\n  }\n  return rgba;\n}\n\n/**\n * Assemble the SAM decoder's `point_coords` / `point_labels` from a prompt.\n *\n * Coordinates are scaled into the encoder's resized space (`scale =\n * inputSize / max(imageW, imageH)`). A box is encoded as two points labelled\n * `2` (top-left) and `3` (bottom-right); positive/negative points use `1`/`0`.\n * When there are points but no box, a padding point `[0,0]` labelled `-1` is\n * appended (the decoder expects the box slots padded when absent).\n */\nexport function buildDecoderPrompt(\n  prompt: SamPrompt,\n  scale: number,\n): { pointCoords: Float32Array; pointLabels: Float32Array; numPoints: number } {\n  const coords: number[] = [];\n  const labels: number[] = [];\n\n  for (const p of prompt.points ?? []) {\n    coords.push(p.x * scale, p.y * scale);\n    labels.push(p.label);\n  }\n\n  if (prompt.box) {\n    const b = prompt.box;\n    coords.push(b.x0 * scale, b.y0 * scale);\n    labels.push(2);\n    coords.push(b.x1 * scale, b.y1 * scale);\n    labels.push(3);\n  } else if (labels.length > 0) {\n    // Points-only: pad the (absent) box slot.\n    coords.push(0, 0);\n    labels.push(-1);\n  }\n\n  return {\n    pointCoords: Float32Array.from(coords),\n    pointLabels: Float32Array.from(labels),\n    numPoints: labels.length,\n  };\n}\n\n/**\n * Binarize SAM mask logits (`> threshold`, default 0 per SAM's mask_threshold)\n * into a 0/1 mask the contour tracer (WandService.maskToPolygons) consumes.\n */\nexport function binarizeMask(logits: Float32Array | number[], threshold = 0): Uint8Array {\n  const out = new Uint8Array(logits.length);\n  for (let i = 0; i < logits.length; i++) out[i] = logits[i] > threshold ? 1 : 0;\n  return out;\n}\n\n/** Index of the highest-scoring mask in a multimask decoder output. */\nexport function bestMaskIndex(iouPredictions: Float32Array | number[]): number {\n  let best = 0;\n  for (let i = 1; i < iouPredictions.length; i++) {\n    if (iouPredictions[i] > iouPredictions[best]) best = i;\n  }\n  return best;\n}\n"]}

package/esm2022/lib/toolbar/segmentation/sam-tool.service.mjs

@@ -0,0 +1,188 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { WandService } from '../wand/wand.service';
+import { frameToRgba } from './sam-prompt';
+import { getSamModel, isSamModelReady } from './sam-model-registry';
+import { Region, Polygon, Rectangle } from '../../models/region';
+import * as i0 from "@angular/core";
+import * as i1 from "../wand/wand.service";
+/**
+ * Box-prompted SAM segmentation tool (jit-ui#90, P0). On `segmentBoxes()` it
+ * reads every rectangle region, runs the (cached) encoder once for the image,
+ * then runs the decoder per box, traces each mask to a polygon (reusing
+ * WandService.maskToPolygons) and commits them as regions.
+ *
+ * Inference is abstracted behind {@link ISamSession}: production uses the
+ * onnxruntime-web session (lazy-imported so ORT never loads in unit tests);
+ * tests inject a fake via {@link useSession}.
+ */
+export class SamToolService {
+    constructor(wandService) {
+        this.wandService = wandService;
+        this.session = null;
+        this.model = getSamModel();
+        /** Cached encoder embedding + the key (image identity) it was computed for. */
+        this.embedding = null;
+        this.embeddingKey = null;
+        /** Status text + busy flag for a spinner / toast in the host. */
+        this.status$ = new BehaviorSubject('');
+        this.busy$ = new BehaviorSubject(false);
+        /** Encoder-download progress: -1 = not downloading, 0..1 = downloading. */
+        this.progress$ = new BehaviorSubject(-1);
+    }
+    /** Bind to the active backend's host (called by the backend, like the wand). */
+    bindHost(host) {
+        this.host = host;
+    }
+    /** Choose the registered model to use; invalidates any cached embedding. */
+    setModel(id) {
+        const next = getSamModel(id);
+        if (next.id === this.model.id)
+            return;
+        this.model = next;
+        this.invalidateEmbedding();
+        // Drop the loaded session so the next run reloads the newly-picked model's
+        // ONNX pair — ensureSession() returns the cached session as-is, so without
+        // this a model switch would keep running the previous model.
+        this.session?.dispose();
+        this.session = null;
+    }
+    /** Drop the cached embedding (e.g. after the image/slice changes). */
+    invalidateEmbedding() {
+        this.embedding = null;
+        this.embeddingKey = null;
+    }
+    /** Test seam: inject a fake/alternate inference session. */
+    useSession(session) {
+        this.session = session;
+    }
+    /**
+     * Segment every rectangle region with a box prompt and append the resulting
+     * masks as new polygon regions. Returns how many regions were added.
+     */
+    async segmentBoxes() {
+        if (!this.host)
+            return 0;
+        // Re-entrancy guard: a second Segment press while the first run is still
+        // downloading/encoding would launch a concurrent model download + GPU
+        // encode (and can freeze the tab on a heavy WebGPU ViT-B). Ignore it.
+        if (this.busy$.value)
+            return 0;
+        const cached = this.host.getCachedImageData();
+        if (!cached || cached.frames.length === 0) {
+            this.status$.next('No image loaded.');
+            return 0;
+        }
+        const regions = this.host.getRegions();
+        const rects = regions.filter((r) => r.bounds instanceof Rectangle);
+        if (rects.length === 0) {
+            this.status$.next('Draw one or more rectangles, then press Segment.');
+            return 0;
+        }
+        const rx = cached.ratios[0] || 1;
+        const ry = cached.ratios[0] || 1;
+        const ox = cached.originX ?? 0;
+        const oy = cached.originY ?? 0;
+        let session;
+        try {
+            session = await this.ensureSession();
+        }
+        catch (err) {
+            this.busy$.next(false);
+            this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');
+            return 0;
+        }
+        this.busy$.next(true);
+        try {
+            // Encode once per image; reuse the embedding across all boxes.
+            const key = [
+                this.host.getFileName() ?? '',
+                this.host.getActiveFrameIndex(),
+                `${cached.width}x${cached.height}`,
+                `${ox},${oy},${rx}`,
+                this.model.id,
+            ].join('|');
+            if (!this.embedding || this.embeddingKey !== key) {
+                this.status$.next('Encoding image…');
+                const rgba = frameToRgba(cached, this.host.getActiveFrameIndex());
+                this.embedding = await session.embed({ data: rgba, width: cached.width, height: cached.height });
+                this.embeddingKey = key;
+            }
+            const masks = [];
+            const consumed = new Set(); // prompt rectangles that produced a mask
+            let added = 0;
+            for (let i = 0; i < rects.length; i++) {
+                this.status$.next(`Segmenting ${i + 1}/${rects.length}…`);
+                const b = rects[i].bounds;
+                // Rectangle is in data coords → convert to image (matrix) coords.
+                const box = {
+                    x0: (b.x - ox) / rx,
+                    y0: (b.y - oy) / ry,
+                    x1: (b.x + b.width - ox) / rx,
+                    y1: (b.y + b.height - oy) / ry,
+                };
+                const res = await session.decode(this.embedding, { box });
+                const polys = this.wandService.maskToPolygons(res.mask, res.width, res.height, cached.width, cached.height, 0, 0);
+                if (polys.length === 0)
+                    continue;
+                // Keep the largest connected piece (maskToPolygons returns largest-first).
+                const poly = polys[0];
+                masks.push(this.makeRegion(poly.xpoints.map((x) => ox + x * rx), poly.ypoints.map((y) => oy + y * ry), rects[i].color));
+                consumed.add(rects[i]); // this rectangle is now represented by its mask
+                added++;
+            }
+            // Replace each segmented prompt rectangle with its mask region; keep any
+            // rectangle that produced no mask (so it can be retried) + other regions.
+            const out = regions.filter((r) => !consumed.has(r)).concat(masks);
+            this.host.setRegions(out);
+            this.status$.next(added > 0 ? `Added ${added} region(s).` : 'No masks found.');
+            return added;
+        }
+        catch (err) {
+            this.status$.next(err instanceof Error ? err.message : 'Segmentation failed.');
+            return 0;
+        }
+        finally {
+            this.busy$.next(false);
+            this.progress$.next(-1);
+        }
+    }
+    makeRegion(xData, yData, color) {
+        const poly = new Polygon();
+        poly.npoints = xData.length;
+        poly.xpoints = xData;
+        poly.ypoints = yData;
+        poly.coordinates = xData.map((x, i) => [x, yData[i]]);
+        poly.closed = true;
+        const region = new Region();
+        region.bounds = poly;
+        // Inherit the source prompt rectangle's color; fall back to the host default.
+        region.color = color || this.host.getShapeColor();
+        // Default class/annotation name, matching the wand/brush + overlay-drawn regions.
+        region.label = 'sam';
+        return region;
+    }
+    async ensureSession() {
+        if (this.session)
+            return this.session;
+        if (!isSamModelReady(this.model)) {
+            throw new Error(`SAM model "${this.model.id}" is not configured yet (no ONNX URLs). ` +
+                'Host it and call setSamModelUrls(), then retry.');
+        }
+        // Lazy-import so onnxruntime-web is never pulled into unit tests / the
+        // initial bundle — only when segmentation actually runs.
+        const { OnnxSamSession } = await import('./onnx-sam-session');
+        const session = new OnnxSamSession();
+        this.progress$.next(0);
+        await session.loadModel(this.model, (f) => this.progress$.next(f));
+        this.session = session;
+        return session;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WandService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { WandService } from '../wand/wand.service';\nimport { WandToolHost } from '../wand/wand-tool.service';\nimport { frameToRgba } from './sam-prompt';\nimport { getSamModel, isSamModelReady } from './sam-model-registry';\nimport { ISamSession, SamEmbedding, SamModelDef } from '../../contracts/sam.contract';\nimport { Region, Polygon, Rectangle } from '../../models/region';\n\n/** The SAM tool binds to the same host the wand/brush use, so each backend\n *  reuses its existing pixel readback + coordinate transform + region store. */\nexport type SamToolHost = WandToolHost;\n\n/**\n * Box-prompted SAM segmentation tool (jit-ui#90, P0). On `segmentBoxes()` it\n * reads every rectangle region, runs the (cached) encoder once for the image,\n * then runs the decoder per box, traces each mask to a polygon (reusing\n * WandService.maskToPolygons) and commits them as regions.\n *\n * Inference is abstracted behind {@link ISamSession}: production uses the\n * onnxruntime-web session (lazy-imported so ORT never loads in unit tests);\n * tests inject a fake via {@link useSession}.\n */\n@Injectable({ providedIn: 'root' })\nexport class SamToolService {\n  private host!: SamToolHost;\n  private session: ISamSession | null = null;\n  private model: SamModelDef = getSamModel();\n\n  /** Cached encoder embedding + the key (image identity) it was computed for. */\n  private embedding: SamEmbedding | null = null;\n  private embeddingKey: string | null = null;\n\n  /** Status text + busy flag for a spinner / toast in the host. */\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  /** Encoder-download progress: -1 = not downloading, 0..1 = downloading. */\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  constructor(private wandService: WandService) {}\n\n  /** Bind to the active backend's host (called by the backend, like the wand). */\n  bindHost(host: SamToolHost): void {\n    this.host = host;\n  }\n\n  /** Choose the registered model to use; invalidates any cached embedding. */\n  setModel(id: string): void {\n    const next = getSamModel(id);\n    if (next.id === this.model.id) return;\n    this.model = next;\n    this.invalidateEmbedding();\n    // Drop the loaded session so the next run reloads the newly-picked model's\n    // ONNX pair — ensureSession() returns the cached session as-is, so without\n    // this a model switch would keep running the previous model.\n    this.session?.dispose();\n    this.session = null;\n  }\n\n  /** Drop the cached embedding (e.g. after the image/slice changes). */\n  invalidateEmbedding(): void {\n    this.embedding = null;\n    this.embeddingKey = null;\n  }\n\n  /** Test seam: inject a fake/alternate inference session. */\n  useSession(session: ISamSession): void {\n    this.session = session;\n  }\n\n  /**\n   * Segment every rectangle region with a box prompt and append the resulting\n   * masks as new polygon regions. Returns how many regions were added.\n   */\n  async segmentBoxes(): Promise<number> {\n    if (!this.host) return 0;\n    // Re-entrancy guard: a second Segment press while the first run is still\n    // downloading/encoding would launch a concurrent model download + GPU\n    // encode (and can freeze the tab on a heavy WebGPU ViT-B). Ignore it.\n    if (this.busy$.value) return 0;\n    const cached = this.host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) {\n      this.status$.next('No image loaded.');\n      return 0;\n    }\n\n    const regions = this.host.getRegions();\n    const rects = regions.filter((r) => r.bounds instanceof Rectangle);\n    if (rects.length === 0) {\n      this.status$.next('Draw one or more rectangles, then press Segment.');\n      return 0;\n    }\n\n    const rx = cached.ratios[0] || 1;\n    const ry = cached.ratios[0] || 1;\n    const ox = cached.originX ?? 0;\n    const oy = cached.originY ?? 0;\n\n    let session: ISamSession;\n    try {\n      session = await this.ensureSession();\n    } catch (err) {\n      this.busy$.next(false);\n      this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');\n      return 0;\n    }\n\n    this.busy$.next(true);\n    try {\n      // Encode once per image; reuse the embedding across all boxes.\n      const key = [\n        this.host.getFileName() ?? '',\n        this.host.getActiveFrameIndex(),\n        `${cached.width}x${cached.height}`,\n        `${ox},${oy},${rx}`,\n        this.model.id,\n      ].join('|');\n      if (!this.embedding || this.embeddingKey !== key) {\n        this.status$.next('Encoding image…');\n        const rgba = frameToRgba(cached, this.host.getActiveFrameIndex());\n        this.embedding = await session.embed({ data: rgba, width: cached.width, height: cached.height });\n        this.embeddingKey = key;\n      }\n\n      const masks: Region[] = [];\n      const consumed = new Set<Region>(); // prompt rectangles that produced a mask\n      let added = 0;\n      for (let i = 0; i < rects.length; i++) {\n        this.status$.next(`Segmenting ${i + 1}/${rects.length}…`);\n        const b = rects[i].bounds as Rectangle;\n        // Rectangle is in data coords → convert to image (matrix) coords.\n        const box = {\n          x0: (b.x - ox) / rx,\n          y0: (b.y - oy) / ry,\n          x1: (b.x + b.width - ox) / rx,\n          y1: (b.y + b.height - oy) / ry,\n        };\n        const res = await session.decode(this.embedding, { box });\n        const polys = this.wandService.maskToPolygons(\n          res.mask, res.width, res.height, cached.width, cached.height, 0, 0,\n        );\n        if (polys.length === 0) continue;\n        // Keep the largest connected piece (maskToPolygons returns largest-first).\n        const poly = polys[0];\n        masks.push(this.makeRegion(\n          poly.xpoints.map((x) => ox + x * rx),\n          poly.ypoints.map((y) => oy + y * ry),\n          rects[i].color, // inherit the prompt rectangle's color\n        ));\n        consumed.add(rects[i]); // this rectangle is now represented by its mask\n        added++;\n      }\n\n      // Replace each segmented prompt rectangle with its mask region; keep any\n      // rectangle that produced no mask (so it can be retried) + other regions.\n      const out = regions.filter((r) => !consumed.has(r)).concat(masks);\n      this.host.setRegions(out);\n      this.status$.next(added > 0 ? `Added ${added} region(s).` : 'No masks found.');\n      return added;\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'Segmentation failed.');\n      return 0;\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  private makeRegion(xData: number[], yData: number[], color?: string): Region {\n    const poly = new Polygon();\n    poly.npoints = xData.length;\n    poly.xpoints = xData;\n    poly.ypoints = yData;\n    poly.coordinates = xData.map((x, i) => [x, yData[i]]);\n    poly.closed = true;\n\n    const region = new Region();\n    region.bounds = poly;\n    // Inherit the source prompt rectangle's color; fall back to the host default.\n    region.color = color || this.host.getShapeColor();\n    // Default class/annotation name, matching the wand/brush + overlay-drawn regions.\n    region.label = 'sam';\n    return region;\n  }\n\n  private async ensureSession(): Promise<ISamSession> {\n    if (this.session) return this.session;\n    if (!isSamModelReady(this.model)) {\n      throw new Error(\n        `SAM model \"${this.model.id}\" is not configured yet (no ONNX URLs). ` +\n        'Host it and call setSamModelUrls(), then retry.',\n      );\n    }\n    // Lazy-import so onnxruntime-web is never pulled into unit tests / the\n    // initial bundle — only when segmentation actually runs.\n    const { OnnxSamSession } = await import('./onnx-sam-session');\n    const session = new OnnxSamSession();\n    this.progress$.next(0);\n    await session.loadModel(this.model, (f) => this.progress$.next(f));\n    this.session = session;\n    return session;\n  }\n}\n"]}