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

package/esm2022/lib/implementations/simple-slice-access.service.mjs

@@ -0,0 +1,99 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Shared access to a "simple" (`IImageInfo.tiled === false`) stack — a
+ * self-contained per-slice-URL image, as opposed to one server-tiled file
+ * with an internal z dimension (the tile-pyramid case each backend already
+ * handles on its own, since the tiling protocol itself IS backend-specific).
+ * A numbered image series assembled client-side from separate files (the
+ * jit-ui folder-stack feature) is the current producer of this shape.
+ *
+ * Every backend that can render a 2D image (OSD, napari-js) needs the exact
+ * same three things for this case — detect it, resolve `urls[z]`, and fetch
+ * that URL with the app's auth applied — so they live here once instead of
+ * being reimplemented per backend. Plotly needs no equivalent: its `load()`
+ * already fetches `urls[i]` generically for every plot type, with no
+ * tile-server concept to route around.
+ *
+ * Fetches go through Angular's `HttpClient` so the app's auth interceptor
+ * (Bearer token) applies — a raw `fetch()`/`<img src>` bypasses it and, behind
+ * an OAuth2-proxied deployment, gets redirected to the login page and then
+ * CORS-fails. Mirrors `PlotlyService.loadImage`, the reference
+ * implementation this generalizes for the other backends.
+ */
+export class SimpleSliceAccessService {
+    constructor(http) {
+        this.http = http;
+        /** raw slice URL → already-fetched blob: URL, so a backend that opens a
+         *  URL (OSD) doesn't repeat the auth round-trip revisiting a slice (scrub
+         *  back, the small→large tier re-fetch). Shared across backends: switching
+         *  plot types on the same file (e.g. Image → Volume) reuses entries. */
+        this.blobUrls = new Map();
+    }
+    /** True when `imageInfo` is a self-contained per-slice-URL stack with no
+     *  server tile pyramid to route to. */
+    isSimple(imageInfo) {
+        return imageInfo?.tiled === false;
+    }
+    /** The URL for slice `z` of a simple stack (falls back to slice 0 if `z`
+     *  is out of range or unset). */
+    urlFor(imageInfo, z) {
+        return imageInfo.urls?.[z] ?? imageInfo.urls?.[0];
+    }
+    /** Call once per backend `load()` so the blob cache is evicted when a
+     *  genuinely different file is selected — not on every phase/z-scrub of
+     *  the SAME file, and not wrongly evicted by a second backend loading the
+     *  same file for a different plot type. */
+    noteActiveFile(fileName) {
+        if (fileName && this.currentFileName && fileName !== this.currentFileName) {
+            this.revokeAll();
+        }
+        this.currentFileName = fileName;
+    }
+    /** Fetch a slice's own URL and hand back a blob: URL — for backends (OSD)
+     *  that open a URL rather than decode bytes directly. A true in-memory
+     *  blob:/data: URL (the processing-pipeline's original tiled:false use
+     *  case) is already self-contained and returned as-is, no fetch/cache. */
+    async fetchAsBlobUrl(rawUrl) {
+        if (rawUrl.startsWith('blob:') || rawUrl.startsWith('data:'))
+            return rawUrl;
+        const cached = this.blobUrls.get(rawUrl);
+        if (cached)
+            return cached;
+        const blob = await firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' }));
+        const blobUrl = URL.createObjectURL(blob);
+        this.blobUrls.set(rawUrl, blobUrl);
+        return blobUrl;
+    }
+    /** Fetch a slice's own URL and decode it as an `ImageBitmap` — for
+     *  backends (napari-js) that upload pixels directly rather than opening a
+     *  URL. Not cached (ImageBitmaps are consumed once and closed by the
+     *  caller); the underlying HTTP response may still hit the browser cache.
+     *
+     *  A self-contained blob:/data: URL (e.g. the processing-pipeline's
+     *  in-memory preview, which also emits `tiled:false`) needs no auth and
+     *  isn't a server URL to route through the interceptor — read it directly
+     *  via the browser. Only real server URLs go through HttpClient so the auth
+     *  interceptor applies. Mirrors {@link fetchAsBlobUrl}'s blob:/data: branch. */
+    async fetchAsBitmap(rawUrl) {
+        const blob = rawUrl.startsWith('blob:') || rawUrl.startsWith('data:')
+            ? await (await fetch(rawUrl)).blob()
+            : await firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' }));
+        return createImageBitmap(blob);
+    }
+    revokeAll() {
+        for (const url of this.blobUrls.values())
+            URL.revokeObjectURL(url);
+        this.blobUrls.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SimpleSliceAccessService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SimpleSliceAccessService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SimpleSliceAccessService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-slice-access.service.js","sourceRoot":"","sources":["../../../../src/lib/implementations/simple-slice-access.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;;;AAItC;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,OAAO,wBAAwB;IAQnC,YAAoB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;QAPpC;;;gFAGwE;QACvD,aAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAGf,CAAC;IAExC;2CACuC;IACvC,QAAQ,CAAC,SAAwC;QAC/C,OAAO,SAAS,EAAE,KAAK,KAAK,KAAK,CAAC;IACpC,CAAC;IAED;qCACiC;IACjC,MAAM,CAAC,SAAqB,EAAE,CAAS;QACrC,OAAO,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC;IAED;;;+CAG2C;IAC3C,cAAc,CAAC,QAA4B;QACzC,IAAI,QAAQ,IAAI,IAAI,CAAC,eAAe,IAAI,QAAQ,KAAK,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1E,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;IAClC,CAAC;IAED;;;8EAG0E;IAC1E,KAAK,CAAC,cAAc,CAAC,MAAc;QACjC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC;YAAE,OAAO,MAAM,CAAC;QAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;QAC1B,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;QACnF,MAAM,OAAO,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;;oFASgF;IAChF,KAAK,CAAC,aAAa,CAAC,MAAc;QAChC,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC;YACnE,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE;YACpC,CAAC,CAAC,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;QAC1E,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEO,SAAS;QACf,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YAAE,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QACnE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;8GAnEU,wBAAwB;kHAAxB,wBAAwB,cADX,MAAM;;2FACnB,wBAAwB;kBADpC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\n\nimport { IImageInfo } from '../contracts/image.contract';\n\n/**\n * Shared access to a \"simple\" (`IImageInfo.tiled === false`) stack — a\n * self-contained per-slice-URL image, as opposed to one server-tiled file\n * with an internal z dimension (the tile-pyramid case each backend already\n * handles on its own, since the tiling protocol itself IS backend-specific).\n * A numbered image series assembled client-side from separate files (the\n * jit-ui folder-stack feature) is the current producer of this shape.\n *\n * Every backend that can render a 2D image (OSD, napari-js) needs the exact\n * same three things for this case — detect it, resolve `urls[z]`, and fetch\n * that URL with the app's auth applied — so they live here once instead of\n * being reimplemented per backend. Plotly needs no equivalent: its `load()`\n * already fetches `urls[i]` generically for every plot type, with no\n * tile-server concept to route around.\n *\n * Fetches go through Angular's `HttpClient` so the app's auth interceptor\n * (Bearer token) applies — a raw `fetch()`/`<img src>` bypasses it and, behind\n * an OAuth2-proxied deployment, gets redirected to the login page and then\n * CORS-fails. Mirrors `PlotlyService.loadImage`, the reference\n * implementation this generalizes for the other backends.\n */\n@Injectable({ providedIn: 'root' })\nexport class SimpleSliceAccessService {\n  /** raw slice URL → already-fetched blob: URL, so a backend that opens a\n   *  URL (OSD) doesn't repeat the auth round-trip revisiting a slice (scrub\n   *  back, the small→large tier re-fetch). Shared across backends: switching\n   *  plot types on the same file (e.g. Image → Volume) reuses entries. */\n  private readonly blobUrls = new Map<string, string>();\n  private currentFileName: string | undefined;\n\n  constructor(private http: HttpClient) {}\n\n  /** True when `imageInfo` is a self-contained per-slice-URL stack with no\n   *  server tile pyramid to route to. */\n  isSimple(imageInfo: IImageInfo | null | undefined): boolean {\n    return imageInfo?.tiled === false;\n  }\n\n  /** The URL for slice `z` of a simple stack (falls back to slice 0 if `z`\n   *  is out of range or unset). */\n  urlFor(imageInfo: IImageInfo, z: number): string | undefined {\n    return imageInfo.urls?.[z] ?? imageInfo.urls?.[0];\n  }\n\n  /** Call once per backend `load()` so the blob cache is evicted when a\n   *  genuinely different file is selected — not on every phase/z-scrub of\n   *  the SAME file, and not wrongly evicted by a second backend loading the\n   *  same file for a different plot type. */\n  noteActiveFile(fileName: string | undefined): void {\n    if (fileName && this.currentFileName && fileName !== this.currentFileName) {\n      this.revokeAll();\n    }\n    this.currentFileName = fileName;\n  }\n\n  /** Fetch a slice's own URL and hand back a blob: URL — for backends (OSD)\n   *  that open a URL rather than decode bytes directly. A true in-memory\n   *  blob:/data: URL (the processing-pipeline's original tiled:false use\n   *  case) is already self-contained and returned as-is, no fetch/cache. */\n  async fetchAsBlobUrl(rawUrl: string): Promise<string> {\n    if (rawUrl.startsWith('blob:') || rawUrl.startsWith('data:')) return rawUrl;\n    const cached = this.blobUrls.get(rawUrl);\n    if (cached) return cached;\n    const blob = await firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' }));\n    const blobUrl = URL.createObjectURL(blob);\n    this.blobUrls.set(rawUrl, blobUrl);\n    return blobUrl;\n  }\n\n  /** Fetch a slice's own URL and decode it as an `ImageBitmap` — for\n   *  backends (napari-js) that upload pixels directly rather than opening a\n   *  URL. Not cached (ImageBitmaps are consumed once and closed by the\n   *  caller); the underlying HTTP response may still hit the browser cache.\n   *\n   *  A self-contained blob:/data: URL (e.g. the processing-pipeline's\n   *  in-memory preview, which also emits `tiled:false`) needs no auth and\n   *  isn't a server URL to route through the interceptor — read it directly\n   *  via the browser. Only real server URLs go through HttpClient so the auth\n   *  interceptor applies. Mirrors {@link fetchAsBlobUrl}'s blob:/data: branch. */\n  async fetchAsBitmap(rawUrl: string): Promise<ImageBitmap> {\n    const blob = rawUrl.startsWith('blob:') || rawUrl.startsWith('data:')\n      ? await (await fetch(rawUrl)).blob()\n      : await firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' }));\n    return createImageBitmap(blob);\n  }\n\n  private revokeAll(): void {\n    for (const url of this.blobUrls.values()) URL.revokeObjectURL(url);\n    this.blobUrls.clear();\n  }\n}\n"]}

package/esm2022/lib/models/bezier.mjs

@@ -0,0 +1,120 @@
+/**
+ * Bezier-curve helpers (no external dependency).
+ *
+ * JIT supports true bezier regions: a polygon's vertices are the editable
+ * *anchors*, and the smooth curve through them is derived here with the
+ * Catmull-Rom construction — the same algorithm paper.js uses in
+ * `path.smooth()`. The curve interpolates every anchor and
+ * each anchor's two handles are colinear (a smooth tangent).
+ *
+ * The OSD overlay renders the curve as a true cubic SVG path + draggable handles
+ * (see {@link bezierAnchorHandles}); GeoJSON export flattens the *same* cubics
+ * into a dense point list (see {@link bezierCurve}) so a viewer without bezier
+ * support (e.g. QuPath, which just draws the coordinate list) still shows the
+ * smooth shape. Using one algorithm for both keeps what JIT draws identical to
+ * what it exports.
+ *
+ * Pure functions: no DOM, no service state. Coordinates are image pixels.
+ */
+/** How many points to sample per cubic segment when flattening for export. */
+const SAMPLES_PER_SEGMENT = 16;
+/**
+ * Per-anchor cubic-bezier control points using the Catmull-Rom construction
+ * (tension 1: control = anchor ± (next − prev) / 6). Matches paper.js
+ * `path.smooth()`: the resulting cubic interpolates every anchor and the two
+ * handles of each anchor are colinear. Coordinates are in the input space.
+ */
+export function bezierAnchorHandles(xs, ys, closed) {
+    const n = Math.min(xs.length, ys.length);
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const prev = closed ? (i - 1 + n) % n : Math.max(0, i - 1);
+        const next = closed ? (i + 1) % n : Math.min(n - 1, i + 1);
+        const tx = (xs[next] - xs[prev]) / 6;
+        const ty = (ys[next] - ys[prev]) / 6;
+        out.push({
+            out: [xs[i] + tx, ys[i] + ty],
+            in: [xs[i] - tx, ys[i] - ty],
+            hasOut: closed || i < n - 1,
+            hasIn: closed || i > 0,
+        });
+    }
+    return out;
+}
+/** The Catmull-Rom handles as **relative** offsets `[dx, dy]` per anchor — used
+ *  to initialise a region's editable handles when bezier is turned on. */
+export function defaultHandleOffsets(xs, ys, closed) {
+    const h = bezierAnchorHandles(xs, ys, closed);
+    return {
+        in: h.map((a, i) => [a.in[0] - xs[i], a.in[1] - ys[i]]),
+        out: h.map((a, i) => [a.out[0] - xs[i], a.out[1] - ys[i]]),
+    };
+}
+/** Absolute handles from stored relative offsets (anchor + offset). */
+export function handlesFromOffsets(xs, ys, inOff, outOff, closed) {
+    const n = Math.min(xs.length, ys.length);
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        out.push({
+            in: [xs[i] + (inOff[i]?.[0] ?? 0), ys[i] + (inOff[i]?.[1] ?? 0)],
+            out: [xs[i] + (outOff[i]?.[0] ?? 0), ys[i] + (outOff[i]?.[1] ?? 0)],
+            hasOut: closed || i < n - 1,
+            hasIn: closed || i > 0,
+        });
+    }
+    return out;
+}
+/** A region's handles: from its stored (editable) offsets when present, else the
+ *  Catmull-Rom default. The single source of truth for both rendering and export. */
+export function resolveHandles(xs, ys, closed, inOff, outOff) {
+    if (inOff && outOff && inOff.length === xs.length && outOff.length === xs.length) {
+        return handlesFromOffsets(xs, ys, inOff, outOff, closed);
+    }
+    return bezierAnchorHandles(xs, ys, closed);
+}
+/**
+ * Flatten a cubic bezier (defined by explicit per-anchor handles) into a dense
+ * point list by sampling each segment. The curve passes through every anchor; a
+ * closed ring returns to its first point.
+ */
+export function bezierCurveFromHandles(xs, ys, handles, closed) {
+    const n = Math.min(xs.length, ys.length);
+    if (n < 3)
+        return { xs: xs.slice(), ys: ys.slice() };
+    const outX = [];
+    const outY = [];
+    const segs = closed ? n : n - 1;
+    for (let i = 0; i < segs; i++) {
+        const j = (i + 1) % n;
+        const p0x = xs[i], p0y = ys[i];
+        const c1 = handles[i].out, c2 = handles[j].in;
+        const p3x = xs[j], p3y = ys[j];
+        for (let s = 0; s < SAMPLES_PER_SEGMENT; s++) {
+            const t = s / SAMPLES_PER_SEGMENT;
+            const u = 1 - t;
+            const w0 = u * u * u, w1 = 3 * u * u * t, w2 = 3 * u * t * t, w3 = t * t * t;
+            outX.push(w0 * p0x + w1 * c1[0] + w2 * c2[0] + w3 * p3x);
+            outY.push(w0 * p0y + w1 * c1[1] + w2 * c2[1] + w3 * p3y);
+        }
+    }
+    if (closed) {
+        outX.push(xs[0]);
+        outY.push(ys[0]);
+    }
+    else {
+        outX.push(xs[n - 1]);
+        outY.push(ys[n - 1]);
+    }
+    return { xs: outX, ys: outY };
+}
+/**
+ * Flatten the smooth Catmull-Rom bezier through the anchors (no custom handles).
+ * Falls back to the anchors when there are too few to form a curve.
+ */
+export function bezierCurve(xs, ys, closed) {
+    const n = Math.min(xs.length, ys.length);
+    if (n < 3)
+        return { xs: xs.slice(), ys: ys.slice() };
+    return bezierCurveFromHandles(xs, ys, bezierAnchorHandles(xs, ys, closed), closed);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bezier.js","sourceRoot":"","sources":["../../../../src/lib/models/bezier.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bezier-curve helpers (no external dependency).\n *\n * JIT supports true bezier regions: a polygon's vertices are the editable\n * *anchors*, and the smooth curve through them is derived here with the\n * Catmull-Rom construction — the same algorithm paper.js uses in\n * `path.smooth()`. The curve interpolates every anchor and\n * each anchor's two handles are colinear (a smooth tangent).\n *\n * The OSD overlay renders the curve as a true cubic SVG path + draggable handles\n * (see {@link bezierAnchorHandles}); GeoJSON export flattens the *same* cubics\n * into a dense point list (see {@link bezierCurve}) so a viewer without bezier\n * support (e.g. QuPath, which just draws the coordinate list) still shows the\n * smooth shape. Using one algorithm for both keeps what JIT draws identical to\n * what it exports.\n *\n * Pure functions: no DOM, no service state. Coordinates are image pixels.\n */\n\nexport interface CurvePoints {\n  xs: number[];\n  ys: number[];\n}\n\n/** A vertex's two cubic-bezier control points (absolute coords) plus whether\n *  each side has a handle (open-path endpoints have only one). */\nexport interface AnchorHandle {\n  in: [number, number];\n  out: [number, number];\n  hasIn: boolean;\n  hasOut: boolean;\n}\n\n/** How many points to sample per cubic segment when flattening for export. */\nconst SAMPLES_PER_SEGMENT = 16;\n\n/**\n * Per-anchor cubic-bezier control points using the Catmull-Rom construction\n * (tension 1: control = anchor ± (next − prev) / 6). Matches paper.js\n * `path.smooth()`: the resulting cubic interpolates every anchor and the two\n * handles of each anchor are colinear. Coordinates are in the input space.\n */\nexport function bezierAnchorHandles(xs: number[], ys: number[], closed: boolean): AnchorHandle[] {\n  const n = Math.min(xs.length, ys.length);\n  const out: AnchorHandle[] = [];\n  for (let i = 0; i < n; i++) {\n    const prev = closed ? (i - 1 + n) % n : Math.max(0, i - 1);\n    const next = closed ? (i + 1) % n : Math.min(n - 1, i + 1);\n    const tx = (xs[next] - xs[prev]) / 6;\n    const ty = (ys[next] - ys[prev]) / 6;\n    out.push({\n      out: [xs[i] + tx, ys[i] + ty],\n      in: [xs[i] - tx, ys[i] - ty],\n      hasOut: closed || i < n - 1,\n      hasIn: closed || i > 0,\n    });\n  }\n  return out;\n}\n\n/** The Catmull-Rom handles as **relative** offsets `[dx, dy]` per anchor — used\n *  to initialise a region's editable handles when bezier is turned on. */\nexport function defaultHandleOffsets(xs: number[], ys: number[], closed: boolean):\n  { in: number[][]; out: number[][] } {\n  const h = bezierAnchorHandles(xs, ys, closed);\n  return {\n    in: h.map((a, i) => [a.in[0] - xs[i], a.in[1] - ys[i]]),\n    out: h.map((a, i) => [a.out[0] - xs[i], a.out[1] - ys[i]]),\n  };\n}\n\n/** Absolute handles from stored relative offsets (anchor + offset). */\nexport function handlesFromOffsets(xs: number[], ys: number[],\n                                   inOff: number[][], outOff: number[][], closed: boolean): AnchorHandle[] {\n  const n = Math.min(xs.length, ys.length);\n  const out: AnchorHandle[] = [];\n  for (let i = 0; i < n; i++) {\n    out.push({\n      in: [xs[i] + (inOff[i]?.[0] ?? 0), ys[i] + (inOff[i]?.[1] ?? 0)],\n      out: [xs[i] + (outOff[i]?.[0] ?? 0), ys[i] + (outOff[i]?.[1] ?? 0)],\n      hasOut: closed || i < n - 1,\n      hasIn: closed || i > 0,\n    });\n  }\n  return out;\n}\n\n/** A region's handles: from its stored (editable) offsets when present, else the\n *  Catmull-Rom default. The single source of truth for both rendering and export. */\nexport function resolveHandles(xs: number[], ys: number[], closed: boolean,\n                               inOff?: number[][], outOff?: number[][]): AnchorHandle[] {\n  if (inOff && outOff && inOff.length === xs.length && outOff.length === xs.length) {\n    return handlesFromOffsets(xs, ys, inOff, outOff, closed);\n  }\n  return bezierAnchorHandles(xs, ys, closed);\n}\n\n/**\n * Flatten a cubic bezier (defined by explicit per-anchor handles) into a dense\n * point list by sampling each segment. The curve passes through every anchor; a\n * closed ring returns to its first point.\n */\nexport function bezierCurveFromHandles(xs: number[], ys: number[],\n                                       handles: AnchorHandle[], closed: boolean): CurvePoints {\n  const n = Math.min(xs.length, ys.length);\n  if (n < 3) return { xs: xs.slice(), ys: ys.slice() };\n\n  const outX: number[] = [];\n  const outY: number[] = [];\n  const segs = closed ? n : n - 1;\n  for (let i = 0; i < segs; i++) {\n    const j = (i + 1) % n;\n    const p0x = xs[i], p0y = ys[i];\n    const c1 = handles[i].out, c2 = handles[j].in;\n    const p3x = xs[j], p3y = ys[j];\n    for (let s = 0; s < SAMPLES_PER_SEGMENT; s++) {\n      const t = s / SAMPLES_PER_SEGMENT;\n      const u = 1 - t;\n      const w0 = u * u * u, w1 = 3 * u * u * t, w2 = 3 * u * t * t, w3 = t * t * t;\n      outX.push(w0 * p0x + w1 * c1[0] + w2 * c2[0] + w3 * p3x);\n      outY.push(w0 * p0y + w1 * c1[1] + w2 * c2[1] + w3 * p3y);\n    }\n  }\n  if (closed) {\n    outX.push(xs[0]); outY.push(ys[0]);\n  } else {\n    outX.push(xs[n - 1]); outY.push(ys[n - 1]);\n  }\n  return { xs: outX, ys: outY };\n}\n\n/**\n * Flatten the smooth Catmull-Rom bezier through the anchors (no custom handles).\n * Falls back to the anchors when there are too few to form a curve.\n */\nexport function bezierCurve(xs: number[], ys: number[], closed: boolean): CurvePoints {\n  const n = Math.min(xs.length, ys.length);\n  if (n < 3) return { xs: xs.slice(), ys: ys.slice() };\n  return bezierCurveFromHandles(xs, ys, bezierAnchorHandles(xs, ys, closed), closed);\n}\n"]}

package/esm2022/lib/models/class-preset.mjs

@@ -0,0 +1,46 @@
+/**
+ * Preset annotation classes (jit-ui#70).
+ *
+ * A class is a flat `{ name, color }` pair (v1: no hierarchy, no special-class semantics).
+ * The `PresetSet` is the per-user, server-persisted source of truth for region colours;
+ * see `class-color.util.ts` for the deterministic colour-resolution engine.
+ */
+/**
+ * Fallback palette for classes not present in the preset set — reasonably distinct hues.
+ * Colours are assigned by a stable hash of the class name, so the same unknown class always
+ * gets the same colour with no stored state.
+ */
+export const DEFAULT_FALLBACK_PALETTE = [
+    '#6C8EBF', '#82B366', '#B85450', '#9673A6', '#D79B00',
+    '#3C948B', '#A64CA6', '#CC6677', '#4477AA', '#228833',
+];
+/** Seed classes — mirrors the historical hard-coded `classificationColors` map. */
+const DEFAULT_CLASSES = [
+    { name: 'Fragmented-embryo', color: '#FF8C00', source: 'default' },
+    { name: 'Dying-embryo', color: '#FF3333', source: 'default' },
+    { name: 'Two-cell-embryo', color: '#33CC66', source: 'default' },
+    { name: 'One-cell-embryo', color: '#3399FF', source: 'default' },
+    { name: 'Unknown', color: '#888888', source: 'default' },
+    { name: 'Tumor', color: '#FF4444', source: 'default' },
+    { name: 'Stroma', color: '#44AAFF', source: 'default' },
+    { name: 'Immune cells', color: '#FFDD00', source: 'default' },
+    { name: 'Necrosis', color: '#AA6633', source: 'default' },
+    { name: 'Region', color: '#00FFFF', source: 'default' },
+    { name: 'Ignore', color: '#AAAAAA', source: 'default' },
+    { name: 'Positive', color: '#00CC44', source: 'default' },
+    { name: 'Negative', color: '#CC0000', source: 'default' },
+];
+/** A fresh default preset set (deep-copied so callers can mutate safely). */
+export function defaultPresetSet() {
+    return {
+        classes: DEFAULT_CLASSES.map((c) => ({ ...c })),
+        fallbackPalette: [...DEFAULT_FALLBACK_PALETTE],
+        autoPromote: false,
+        matchMode: 'exact',
+    };
+}
+/** True when the set has no usable classes (e.g. the server returned an empty/blank record). */
+export function isEmptyPresetSet(set) {
+    return !set || !Array.isArray(set.classes) || set.classes.length === 0;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/geometry.mjs

@@ -0,0 +1,198 @@
+/**
+ * Pure geometry helpers extracted from PlotlyService.
+ *
+ * No DOM access, no service state, no `this` — every function is testable
+ * in isolation. Keep it that way: this module is the dumping ground for
+ * shape/mask/SVG-path utilities the wand, vertex eraser, and region editor
+ * share. If a helper grows a `this.shapes` reference, it doesn't belong here.
+ */
+// ── SVG path parsing / building ──────────────────────────────────────
+/**
+ * Parse a single-subpath `M x,y L x,y ... Z` path into vertex arrays.
+ *
+ * Returns null for paths we can't safely round-trip (multi-subpath, curves,
+ * fewer than three vertices). The wand only adopts shapes it produced or
+ * that Plotly's drawclosedpath produces, both of which are single-subpath
+ * polygons.
+ */
+export function parseSvgPathPolygon(path) {
+    if (!path || path[0] !== 'M')
+        return null;
+    if (path.indexOf('M', 1) !== -1)
+        return null; // multi-subpath
+    const trimmed = path.endsWith('Z') ? path.slice(1, -1) : path.slice(1);
+    const segs = trimmed.split('L');
+    const xpoints = [];
+    const ypoints = [];
+    for (const seg of segs) {
+        const [sx, sy] = seg.split(',');
+        const x = parseFloat(sx);
+        const y = parseFloat(sy);
+        if (!Number.isFinite(x) || !Number.isFinite(y))
+            return null;
+        xpoints.push(x);
+        ypoints.push(y);
+    }
+    if (xpoints.length < 3)
+        return null;
+    return { xpoints, ypoints };
+}
+/**
+ * Build a closed SVG path string `M x,y L x,y L ... Z` from vertex arrays.
+ * Returns '' for fewer than three vertices (degenerate).
+ */
+export function polygonToSvgPath(xpoints, ypoints) {
+    if (xpoints.length < 3)
+        return '';
+    let path = 'M';
+    for (let i = 0; i < xpoints.length; i++) {
+        path += `${xpoints[i]},${ypoints[i]}`;
+        path += i < xpoints.length - 1 ? 'L' : 'Z';
+    }
+    return path;
+}
+/**
+ * Build an SVG path string from vertex arrays. Closed polygons end with `Z`,
+ * open polylines do not. Returns '' for fewer than two vertices (degenerate).
+ */
+export function verticesToSvgPath(xs, ys, closed) {
+    if (xs.length < 2)
+        return '';
+    let path = 'M';
+    for (let i = 0; i < xs.length; i++) {
+        path += `${xs[i]},${ys[i]}`;
+        if (i < xs.length - 1)
+            path += 'L';
+    }
+    if (closed)
+        path += 'Z';
+    return path;
+}
+// ── Region equality ──────────────────────────────────────────────────
+/**
+ * Compare two Plotly shape objects for "same region" — used by the wand to
+ * avoid appending duplicates when the user pushes the same find result more
+ * than once. Polygons compare by SVG path string, rectangles compare by
+ * (x0, y0, x1, y1).
+ */
+export function shapesEqual(a, b) {
+    if (a.path && b.path) {
+        return a.path === b.path;
+    }
+    if (a.x0 !== undefined && a.y0 !== undefined &&
+        a.x1 !== undefined && a.y1 !== undefined &&
+        b.x0 !== undefined && b.y0 !== undefined &&
+        b.x1 !== undefined && b.y1 !== undefined) {
+        return a.x0 === b.x0 &&
+            a.y0 === b.y0 &&
+            a.x1 === b.x1 &&
+            a.y1 === b.y1;
+    }
+    return false;
+}
+// ── BBox-mask operations (used by the wand stroke accumulator) ───────
+/** Returns true if the two bbox-relative masks share at least one set pixel. */
+export function masksOverlap(a, b) {
+    const ix0 = Math.max(a.bx, b.bx);
+    const iy0 = Math.max(a.by, b.by);
+    const ix1 = Math.min(a.bx + a.bw, b.bx + b.bw);
+    const iy1 = Math.min(a.by + a.bh, b.by + b.bh);
+    if (ix0 >= ix1 || iy0 >= iy1)
+        return false;
+    for (let y = iy0; y < iy1; y++) {
+        const ar = (y - a.by) * a.bw;
+        const br = (y - b.by) * b.bw;
+        for (let x = ix0; x < ix1; x++) {
+            if (a.mask[ar + (x - a.bx)] && b.mask[br + (x - b.bx)])
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Allocate a fresh accumulator covering both masks and OR them in. The
+ * resulting mask's bbox is the smallest rectangle containing both inputs.
+ */
+export function unionMasks(a, b) {
+    const ux0 = Math.min(a.bx, b.bx);
+    const uy0 = Math.min(a.by, b.by);
+    const ux1 = Math.max(a.bx + a.bw, b.bx + b.bw);
+    const uy1 = Math.max(a.by + a.bh, b.by + b.bh);
+    const ubw = ux1 - ux0;
+    const ubh = uy1 - uy0;
+    const umask = new Uint8Array(ubw * ubh);
+    const dax = a.bx - ux0;
+    const day = a.by - uy0;
+    for (let row = 0; row < a.bh; row++) {
+        const src = row * a.bw;
+        const dst = (row + day) * ubw + dax;
+        umask.set(a.mask.subarray(src, src + a.bw), dst);
+    }
+    const dbx = b.bx - ux0;
+    const dby = b.by - uy0;
+    for (let row = 0; row < b.bh; row++) {
+        const srcRow = row * b.bw;
+        const dstRow = (row + dby) * ubw;
+        for (let col = 0; col < b.bw; col++) {
+            if (b.mask[srcRow + col])
+                umask[dstRow + (dbx + col)] = 1;
+        }
+    }
+    return { bx: ux0, by: uy0, bw: ubw, bh: ubh, mask: umask };
+}
+// ── Ring simplification (Douglas–Peucker) ───────────────────────────────
+/** Perpendicular distance from (px,py) to the segment (ax,ay)–(bx,by). */
+function perpDistance(px, py, ax, ay, bx, by) {
+    const dx = bx - ax, dy = by - ay;
+    const len2 = dx * dx + dy * dy;
+    if (len2 === 0)
+        return Math.hypot(px - ax, py - ay);
+    let t = ((px - ax) * dx + (py - ay) * dy) / len2;
+    t = Math.max(0, Math.min(1, t));
+    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+/**
+ * Simplify a closed ring with the Douglas–Peucker algorithm (jit-ui#85):
+ * drop every vertex that lies within `epsilon` pixels (the "altitude
+ * threshold") of the line between its kept neighbours. Anchored at vertex 0
+ * (the ring is closed by appending it). Rings of ≤ 3 vertices, or a
+ * non-positive epsilon, are returned unchanged. Output keeps the closed-ring
+ * convention (no repeated closing point).
+ */
+export function simplifyRing(xs, ys, epsilon) {
+    const n = xs.length;
+    if (n <= 3 || !(epsilon > 0))
+        return { xs: xs.slice(), ys: ys.slice() };
+    // Close the ring so both endpoints of the DP run are vertex 0.
+    const px = [...xs, xs[0]];
+    const py = [...ys, ys[0]];
+    const m = px.length;
+    const keep = new Array(m).fill(false);
+    keep[0] = true;
+    keep[m - 1] = true;
+    const stack = [[0, m - 1]];
+    while (stack.length) {
+        const [a, b] = stack.pop();
+        let maxD = -1, idx = -1;
+        for (let i = a + 1; i < b; i++) {
+            const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);
+            if (d > maxD) {
+                maxD = d;
+                idx = i;
+            }
+        }
+        if (maxD > epsilon && idx > a) {
+            keep[idx] = true;
+            stack.push([a, idx], [idx, b]);
+        }
+    }
+    const outX = [], outY = [];
+    for (let i = 0; i < m - 1; i++) { // drop the duplicated closing vertex
+        if (keep[i]) {
+            outX.push(px[i]);
+            outY.push(py[i]);
+        }
+    }
+    return { xs: outX, ys: outY };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../../src/lib/models/geometry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure geometry helpers extracted from PlotlyService.\n *\n * No DOM access, no service state, no `this` — every function is testable\n * in isolation. Keep it that way: this module is the dumping ground for\n * shape/mask/SVG-path utilities the wand, vertex eraser, and region editor\n * share. If a helper grows a `this.shapes` reference, it doesn't belong here.\n */\n\n/** A bbox-relative binary mask (1 = filled, 0 = empty). */\nexport interface BBoxMask {\n  bx: number;\n  by: number;\n  bw: number;\n  bh: number;\n  mask: Uint8Array;\n}\n\n/** Parsed single-subpath polygon vertices. */\nexport interface PolygonVertices {\n  xpoints: number[];\n  ypoints: number[];\n}\n\n// ── SVG path parsing / building ──────────────────────────────────────\n\n/**\n * Parse a single-subpath `M x,y L x,y ... Z` path into vertex arrays.\n *\n * Returns null for paths we can't safely round-trip (multi-subpath, curves,\n * fewer than three vertices). The wand only adopts shapes it produced or\n * that Plotly's drawclosedpath produces, both of which are single-subpath\n * polygons.\n */\nexport function parseSvgPathPolygon(path: string): PolygonVertices | null {\n  if (!path || path[0] !== 'M') return null;\n  if (path.indexOf('M', 1) !== -1) return null; // multi-subpath\n  const trimmed = path.endsWith('Z') ? path.slice(1, -1) : path.slice(1);\n  const segs = trimmed.split('L');\n  const xpoints: number[] = [];\n  const ypoints: number[] = [];\n  for (const seg of segs) {\n    const [sx, sy] = seg.split(',');\n    const x = parseFloat(sx);\n    const y = parseFloat(sy);\n    if (!Number.isFinite(x) || !Number.isFinite(y)) return null;\n    xpoints.push(x);\n    ypoints.push(y);\n  }\n  if (xpoints.length < 3) return null;\n  return { xpoints, ypoints };\n}\n\n/**\n * Build a closed SVG path string `M x,y L x,y L ... Z` from vertex arrays.\n * Returns '' for fewer than three vertices (degenerate).\n */\nexport function polygonToSvgPath(xpoints: number[], ypoints: number[]): string {\n  if (xpoints.length < 3) return '';\n  let path = 'M';\n  for (let i = 0; i < xpoints.length; i++) {\n    path += `${xpoints[i]},${ypoints[i]}`;\n    path += i < xpoints.length - 1 ? 'L' : 'Z';\n  }\n  return path;\n}\n\n/**\n * Build an SVG path string from vertex arrays. Closed polygons end with `Z`,\n * open polylines do not. Returns '' for fewer than two vertices (degenerate).\n */\nexport function verticesToSvgPath(xs: number[], ys: number[], closed: boolean): string {\n  if (xs.length < 2) return '';\n  let path = 'M';\n  for (let i = 0; i < xs.length; i++) {\n    path += `${xs[i]},${ys[i]}`;\n    if (i < xs.length - 1) path += 'L';\n  }\n  if (closed) path += 'Z';\n  return path;\n}\n\n// ── Region equality ──────────────────────────────────────────────────\n\n/**\n * Compare two Plotly shape objects for \"same region\" — used by the wand to\n * avoid appending duplicates when the user pushes the same find result more\n * than once. Polygons compare by SVG path string, rectangles compare by\n * (x0, y0, x1, y1).\n */\nexport function shapesEqual(a: any, b: any): boolean {\n  if (a.path && b.path) {\n    return a.path === b.path;\n  }\n  if (\n    a.x0 !== undefined && a.y0 !== undefined &&\n    a.x1 !== undefined && a.y1 !== undefined &&\n    b.x0 !== undefined && b.y0 !== undefined &&\n    b.x1 !== undefined && b.y1 !== undefined\n  ) {\n    return a.x0 === b.x0 &&\n           a.y0 === b.y0 &&\n           a.x1 === b.x1 &&\n           a.y1 === b.y1;\n  }\n  return false;\n}\n\n// ── BBox-mask operations (used by the wand stroke accumulator) ───────\n\n/** Returns true if the two bbox-relative masks share at least one set pixel. */\nexport function masksOverlap(a: BBoxMask, b: BBoxMask): boolean {\n  const ix0 = Math.max(a.bx, b.bx);\n  const iy0 = Math.max(a.by, b.by);\n  const ix1 = Math.min(a.bx + a.bw, b.bx + b.bw);\n  const iy1 = Math.min(a.by + a.bh, b.by + b.bh);\n  if (ix0 >= ix1 || iy0 >= iy1) return false;\n  for (let y = iy0; y < iy1; y++) {\n    const ar = (y - a.by) * a.bw;\n    const br = (y - b.by) * b.bw;\n    for (let x = ix0; x < ix1; x++) {\n      if (a.mask[ar + (x - a.bx)] && b.mask[br + (x - b.bx)]) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Allocate a fresh accumulator covering both masks and OR them in. The\n * resulting mask's bbox is the smallest rectangle containing both inputs.\n */\nexport function unionMasks(a: BBoxMask, b: BBoxMask): BBoxMask {\n  const ux0 = Math.min(a.bx, b.bx);\n  const uy0 = Math.min(a.by, b.by);\n  const ux1 = Math.max(a.bx + a.bw, b.bx + b.bw);\n  const uy1 = Math.max(a.by + a.bh, b.by + b.bh);\n  const ubw = ux1 - ux0;\n  const ubh = uy1 - uy0;\n  const umask = new Uint8Array(ubw * ubh);\n\n  const dax = a.bx - ux0;\n  const day = a.by - uy0;\n  for (let row = 0; row < a.bh; row++) {\n    const src = row * a.bw;\n    const dst = (row + day) * ubw + dax;\n    umask.set(a.mask.subarray(src, src + a.bw), dst);\n  }\n  const dbx = b.bx - ux0;\n  const dby = b.by - uy0;\n  for (let row = 0; row < b.bh; row++) {\n    const srcRow = row * b.bw;\n    const dstRow = (row + dby) * ubw;\n    for (let col = 0; col < b.bw; col++) {\n      if (b.mask[srcRow + col]) umask[dstRow + (dbx + col)] = 1;\n    }\n  }\n  return { bx: ux0, by: uy0, bw: ubw, bh: ubh, mask: umask };\n}\n\n// ── Ring simplification (Douglas–Peucker) ───────────────────────────────\n\n/** Perpendicular distance from (px,py) to the segment (ax,ay)–(bx,by). */\nfunction perpDistance(px: number, py: number,\n                      ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax, dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) return Math.hypot(px - ax, py - ay);\n  let t = ((px - ax) * dx + (py - ay) * dy) / len2;\n  t = Math.max(0, Math.min(1, t));\n  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));\n}\n\n/**\n * Simplify a closed ring with the Douglas–Peucker algorithm (jit-ui#85):\n * drop every vertex that lies within `epsilon` pixels (the \"altitude\n * threshold\") of the line between its kept neighbours. Anchored at vertex 0\n * (the ring is closed by appending it). Rings of ≤ 3 vertices, or a\n * non-positive epsilon, are returned unchanged. Output keeps the closed-ring\n * convention (no repeated closing point).\n */\nexport function simplifyRing(xs: number[], ys: number[], epsilon: number)\n  : { xs: number[]; ys: number[] } {\n  const n = xs.length;\n  if (n <= 3 || !(epsilon > 0)) return { xs: xs.slice(), ys: ys.slice() };\n\n  // Close the ring so both endpoints of the DP run are vertex 0.\n  const px = [...xs, xs[0]];\n  const py = [...ys, ys[0]];\n  const m = px.length;\n  const keep = new Array<boolean>(m).fill(false);\n  keep[0] = true;\n  keep[m - 1] = true;\n\n  const stack: Array<[number, number]> = [[0, m - 1]];\n  while (stack.length) {\n    const [a, b] = stack.pop() as [number, number];\n    let maxD = -1, idx = -1;\n    for (let i = a + 1; i < b; i++) {\n      const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);\n      if (d > maxD) { maxD = d; idx = i; }\n    }\n    if (maxD > epsilon && idx > a) {\n      keep[idx] = true;\n      stack.push([a, idx], [idx, b]);\n    }\n  }\n\n  const outX: number[] = [], outY: number[] = [];\n  for (let i = 0; i < m - 1; i++) {      // drop the duplicated closing vertex\n    if (keep[i]) { outX.push(px[i]); outY.push(py[i]); }\n  }\n  return { xs: outX, ys: outY };\n}\n"]}