@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/implementations/region-centroids.mjs

@@ -0,0 +1,47 @@
+/**
+ * Region centroids for the backends' "region centroid" scatter views (napari-js points, Plotly
+ * markers), computed once here instead of in each backend. The centroid is the VERTEX MEAN, not the
+ * area centroid: cheap, and what both views have always shown.
+ */
+/** Vertex mean of one ring, or null when it has no vertices. */
+export function polygonCentroid(xs, ys) {
+    const n = xs.length;
+    if (n === 0)
+        return null;
+    let cx = 0;
+    let cy = 0;
+    for (let i = 0; i < n; i++) {
+        cx += xs[i];
+        cy += ys[i];
+    }
+    return [cx / n, cy / n];
+}
+/**
+ * Centroids of `regions` as flat `[x, y, x, y, …]` data coordinates: a rectangle's centre, a
+ * polygon's vertex mean, and one point per part of a multipolygon. Regions without geometry (or
+ * with an empty ring) contribute nothing.
+ */
+export function regionCentroids(regions) {
+    const out = [];
+    const push = (c) => {
+        if (c)
+            out.push(c[0], c[1]);
+    };
+    for (const r of regions) {
+        const b = r.bounds;
+        if (!b)
+            continue;
+        if ('width' in b && 'x' in b) {
+            out.push(b.x + b.width / 2, b.y + b.height / 2);
+        }
+        else if ('xpoints' in b) {
+            push(polygonCentroid(b.xpoints, b.ypoints));
+        }
+        else if ('polygons' in b) {
+            for (const p of b.polygons)
+                push(polygonCentroid(p.xpoints, p.ypoints));
+        }
+    }
+    return new Float32Array(out);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaW9uLWNlbnRyb2lkcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvaW1wbGVtZW50YXRpb25zL3JlZ2lvbi1jZW50cm9pZHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7R0FJRztBQUVILGdFQUFnRTtBQUNoRSxNQUFNLFVBQVUsZUFBZSxDQUFDLEVBQXFCLEVBQUUsRUFBcUI7SUFDMUUsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQztJQUNwQixJQUFJLENBQUMsS0FBSyxDQUFDO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDekIsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ1gsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ1gsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQzNCLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDWixFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2QsQ0FBQztJQUNELE9BQU8sQ0FBQyxFQUFFLEdBQUcsQ0FBQyxFQUFFLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztBQUMxQixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsT0FBOEM7SUFDNUUsTUFBTSxHQUFHLEdBQWEsRUFBRSxDQUFDO0lBQ3pCLE1BQU0sSUFBSSxHQUFHLENBQUMsQ0FBMEIsRUFBUSxFQUFFO1FBQ2hELElBQUksQ0FBQztZQUFFLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzlCLENBQUMsQ0FBQztJQUNGLEtBQUssTUFBTSxDQUFDLElBQUksT0FBTyxFQUFFLENBQUM7UUFDeEIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BS0MsQ0FBQztRQUNkLElBQUksQ0FBQyxDQUFDO1lBQUUsU0FBUztRQUNqQixJQUFJLE9BQU8sSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQzdCLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDbEQsQ0FBQzthQUFNLElBQUksU0FBUyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQzFCLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUM5QyxDQUFDO2FBQU0sSUFBSSxVQUFVLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDM0IsS0FBSyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUTtnQkFBRSxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7UUFDMUUsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLElBQUksWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQy9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWdpb24gfSBmcm9tICcuLi9tb2RlbHMvcmVnaW9uJztcblxuLyoqXG4gKiBSZWdpb24gY2VudHJvaWRzIGZvciB0aGUgYmFja2VuZHMnIFwicmVnaW9uIGNlbnRyb2lkXCIgc2NhdHRlciB2aWV3cyAobmFwYXJpLWpzIHBvaW50cywgUGxvdGx5XG4gKiBtYXJrZXJzKSwgY29tcHV0ZWQgb25jZSBoZXJlIGluc3RlYWQgb2YgaW4gZWFjaCBiYWNrZW5kLiBUaGUgY2VudHJvaWQgaXMgdGhlIFZFUlRFWCBNRUFOLCBub3QgdGhlXG4gKiBhcmVhIGNlbnRyb2lkOiBjaGVhcCwgYW5kIHdoYXQgYm90aCB2aWV3cyBoYXZlIGFsd2F5cyBzaG93bi5cbiAqL1xuXG4vKiogVmVydGV4IG1lYW4gb2Ygb25lIHJpbmcsIG9yIG51bGwgd2hlbiBpdCBoYXMgbm8gdmVydGljZXMuICovXG5leHBvcnQgZnVuY3Rpb24gcG9seWdvbkNlbnRyb2lkKHhzOiBBcnJheUxpa2U8bnVtYmVyPiwgeXM6IEFycmF5TGlrZTxudW1iZXI+KTogW251bWJlciwgbnVtYmVyXSB8IG51bGwge1xuICBjb25zdCBuID0geHMubGVuZ3RoO1xuICBpZiAobiA9PT0gMCkgcmV0dXJuIG51bGw7XG4gIGxldCBjeCA9IDA7XG4gIGxldCBjeSA9IDA7XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgbjsgaSsrKSB7XG4gICAgY3ggKz0geHNbaV07XG4gICAgY3kgKz0geXNbaV07XG4gIH1cbiAgcmV0dXJuIFtjeCAvIG4sIGN5IC8gbl07XG59XG5cbi8qKlxuICogQ2VudHJvaWRzIG9mIGByZWdpb25zYCBhcyBmbGF0IGBbeCwgeSwgeCwgeSwg4oCmXWAgZGF0YSBjb29yZGluYXRlczogYSByZWN0YW5nbGUncyBjZW50cmUsIGFcbiAqIHBvbHlnb24ncyB2ZXJ0ZXggbWVhbiwgYW5kIG9uZSBwb2ludCBwZXIgcGFydCBvZiBhIG11bHRpcG9seWdvbi4gUmVnaW9ucyB3aXRob3V0IGdlb21ldHJ5IChvclxuICogd2l0aCBhbiBlbXB0eSByaW5nKSBjb250cmlidXRlIG5vdGhpbmcuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWdpb25DZW50cm9pZHMocmVnaW9uczogUmVhZG9ubHlBcnJheTxQaWNrPFJlZ2lvbiwgJ2JvdW5kcyc+Pik6IEZsb2F0MzJBcnJheSB7XG4gIGNvbnN0IG91dDogbnVtYmVyW10gPSBbXTtcbiAgY29uc3QgcHVzaCA9IChjOiBbbnVtYmVyLCBudW1iZXJdIHwgbnVsbCk6IHZvaWQgPT4ge1xuICAgIGlmIChjKSBvdXQucHVzaChjWzBdLCBjWzFdKTtcbiAgfTtcbiAgZm9yIChjb25zdCByIG9mIHJlZ2lvbnMpIHtcbiAgICBjb25zdCBiID0gci5ib3VuZHMgYXNcbiAgICAgIHwgeyB4OiBudW1iZXI7IHk6IG51bWJlcjsgd2lkdGg6IG51bWJlcjsgaGVpZ2h0OiBudW1iZXIgfVxuICAgICAgfCB7IHhwb2ludHM6IG51bWJlcltdOyB5cG9pbnRzOiBudW1iZXJbXSB9XG4gICAgICB8IHsgcG9seWdvbnM6IHsgeHBvaW50czogbnVtYmVyW107IHlwb2ludHM6IG51bWJlcltdIH1bXSB9XG4gICAgICB8IG51bGxcbiAgICAgIHwgdW5kZWZpbmVkO1xuICAgIGlmICghYikgY29udGludWU7XG4gICAgaWYgKCd3aWR0aCcgaW4gYiAmJiAneCcgaW4gYikge1xuICAgICAgb3V0LnB1c2goYi54ICsgYi53aWR0aCAvIDIsIGIueSArIGIuaGVpZ2h0IC8gMik7XG4gICAgfSBlbHNlIGlmICgneHBvaW50cycgaW4gYikge1xuICAgICAgcHVzaChwb2x5Z29uQ2VudHJvaWQoYi54cG9pbnRzLCBiLnlwb2ludHMpKTtcbiAgICB9IGVsc2UgaWYgKCdwb2x5Z29ucycgaW4gYikge1xuICAgICAgZm9yIChjb25zdCBwIG9mIGIucG9seWdvbnMpIHB1c2gocG9seWdvbkNlbnRyb2lkKHAueHBvaW50cywgcC55cG9pbnRzKSk7XG4gICAgfVxuICB9XG4gIHJldHVybiBuZXcgRmxvYXQzMkFycmF5KG91dCk7XG59XG4iXX0=

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

@@ -27,10 +27,12 @@ import * as i1 from "@angular/common/http";
 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. */
+        /** raw slice URL → its (possibly still in-flight) 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), and two concurrent
+         *  requests for one slice share a fetch (and a blob: URL). 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
@@ -48,7 +50,9 @@ export class SimpleSliceAccessService {
      *  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) {
+        if (!fileName)
+            return; // an unnamed load says nothing about the active file
+        if (this.currentFileName && fileName !== this.currentFileName) {
             this.revokeAll();
         }
         this.currentFileName = fileName;
@@ -63,10 +67,14 @@ export class SimpleSliceAccessService {
         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;
+        const pending = firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' })).then((blob) => URL.createObjectURL(blob));
+        this.blobUrls.set(rawUrl, pending);
+        // A failed fetch is forgotten so the next call retries it.
+        pending.catch(() => {
+            if (this.blobUrls.get(rawUrl) === pending)
+                this.blobUrls.delete(rawUrl);
+        });
+        return pending;
     }
     /** Fetch a slice's own URL and decode it as an `ImageBitmap` — for
      *  backends (napari-js) that upload pixels directly rather than opening a
@@ -84,9 +92,11 @@ export class SimpleSliceAccessService {
             : await firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' }));
         return createImageBitmap(blob);
     }
+    /** Revoke every cached blob: URL — an in-flight one once it resolves. */
     revokeAll() {
-        for (const url of this.blobUrls.values())
-            URL.revokeObjectURL(url);
+        for (const pending of this.blobUrls.values()) {
+            pending.then((url) => URL.revokeObjectURL(url), () => undefined);
+        }
         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 }); }
@@ -96,4 +106,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
             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"]}
+//# 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;IAUnC,YAAoB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;QATpC;;;;;8BAKsB;QACL,aAAQ,GAAG,IAAI,GAAG,EAA2B,CAAC;IAGxB,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,CAAC,QAAQ;YAAE,OAAO,CAAC,qDAAqD;QAC5E,IAAI,IAAI,CAAC,eAAe,IAAI,QAAQ,KAAK,IAAI,CAAC,eAAe,EAAE,CAAC;YAC9D,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,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5F,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAC1B,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,2DAA2D;QAC3D,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;YACjB,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,OAAO;gBAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;;oFASgF;IAChF,KAAK,CAAC,aAAa,CAAC,MAAc;QAChC,MAAM,IAAI,GACR,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC;YACtD,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;QAC5E,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,yEAAyE;IACjE,SAAS;QACf,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAC7C,OAAO,CAAC,IAAI,CACV,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,EACjC,GAAG,EAAE,CAAC,SAAS,CAChB,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;8GAlFU,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 → its (possibly still in-flight) blob: URL, so a backend\n   *  that opens a URL (OSD) doesn't repeat the auth round-trip revisiting a\n   *  slice (scrub back, the small→large tier re-fetch), and two concurrent\n   *  requests for one slice share a fetch (and a blob: URL). Shared across\n   *  backends: switching plot types on the same file (e.g. Image → Volume)\n   *  reuses entries. */\n  private readonly blobUrls = new Map<string, Promise<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) return; // an unnamed load says nothing about the active file\n    if (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 pending = firstValueFrom(this.http.get(rawUrl, { responseType: 'blob' })).then((blob) =>\n      URL.createObjectURL(blob),\n    );\n    this.blobUrls.set(rawUrl, pending);\n    // A failed fetch is forgotten so the next call retries it.\n    pending.catch(() => {\n      if (this.blobUrls.get(rawUrl) === pending) this.blobUrls.delete(rawUrl);\n    });\n    return pending;\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 =\n      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  /** Revoke every cached blob: URL — an in-flight one once it resolves. */\n  private revokeAll(): void {\n    for (const pending of this.blobUrls.values()) {\n      pending.then(\n        (url) => URL.revokeObjectURL(url),\n        () => undefined,\n      );\n    }\n    this.blobUrls.clear();\n  }\n}\n"]}