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

package/esm2022/lib/implementations/tile-server/transport.mjs

@@ -0,0 +1,135 @@
+import { HttpErrorResponse } from '@angular/common/http';
+/** Resolve the host's auth headers; a failure means cookie / anonymous auth (`{}`). */
+export function resolveAuthHeaders(src) {
+    return src.getAuthHeaders().catch(() => ({}));
+}
+/** `fetch` with the host's auth headers (merged under any `init.headers`). */
+export async function fetchWithAuth(auth, url, init = {}) {
+    const headers = await resolveAuthHeaders(auth);
+    return fetch(url, { ...init, headers: { ...headers, ...init.headers } });
+}
+/** {@link FetchJson} over {@link fetchWithAuth}. */
+export function fetchJsonWithAuth(auth) {
+    return async (url, signal) => {
+        const resp = await fetchWithAuth(auth, url, signal ? { signal } : {});
+        if (resp.status !== 200)
+            return { status: resp.status, body: null };
+        return { status: resp.status, body: (await resp.json()) ?? null };
+    };
+}
+/**
+ * {@link FetchJson} over Angular's `HttpClient` (its interceptors apply). An HTTP error status is
+ * resolved, not thrown; status 0 (no response at all) stays a rejection. An abort unsubscribes,
+ * which cancels the XHR.
+ */
+export function httpFetchJson(http) {
+    return async (url, signal) => {
+        try {
+            const resp = await firstValueFromAbortable(http.get(url, { observe: 'response' }), signal);
+            return { status: resp.status, body: resp.body ?? null };
+        }
+        catch (err) {
+            if (err instanceof HttpErrorResponse && err.status > 0)
+                return { status: err.status, body: null };
+            throw err;
+        }
+    };
+}
+/**
+ * `firstValueFrom` that unsubscribes (for `HttpClient`, cancels the XHR) and rejects with an
+ * {@link abortError} as soon as `signal` aborts. The subscription is made synchronously.
+ */
+export function firstValueFromAbortable(source, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        let settled = false;
+        const settle = () => {
+            settled = true;
+            signal?.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            settle();
+            sub.unsubscribe();
+            reject(abortError());
+        };
+        const sub = source.subscribe({
+            next: (v) => {
+                if (settled)
+                    return;
+                settle();
+                resolve(v);
+                queueMicrotask(() => sub?.unsubscribe());
+            },
+            error: (err) => {
+                if (settled)
+                    return;
+                settle();
+                reject(err);
+            },
+            complete: () => {
+                if (settled)
+                    return;
+                settle();
+                reject(new Error('no elements in sequence'));
+            },
+        });
+        if (!settled)
+            signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+// ── AbortSignal helpers ─────────────────────────────────────────────────────
+/** The error an aborted operation rejects with (`name === 'AbortError'`, as `fetch` uses). */
+export function abortError() {
+    return new DOMException('The operation was aborted.', 'AbortError');
+}
+/** Whether `err` is an abort (from {@link abortError}, `fetch`, or `AbortSignal.reason`). */
+export function isAbortError(err) {
+    return err?.name === 'AbortError';
+}
+/** Throw an {@link abortError} when `signal` has aborted. */
+export function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+/** Resolve after `ms`, or reject with an {@link abortError} as soon as `signal` aborts. */
+export function abortableDelay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(abortError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * A signal that aborts when `parent` does, or after `timeoutMs`. Call `done()` once the guarded
+ * request settles, to clear the timer and the parent listener.
+ */
+export function timeoutSignal(parent, timeoutMs) {
+    const ctl = new AbortController();
+    const onAbort = () => ctl.abort();
+    if (parent?.aborted)
+        ctl.abort();
+    else
+        parent?.addEventListener('abort', onAbort, { once: true });
+    const timer = setTimeout(() => ctl.abort(), timeoutMs);
+    return {
+        signal: ctl.signal,
+        done: () => {
+            clearTimeout(timer);
+            parent?.removeEventListener('abort', onAbort);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/tile-server/transport.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Observable } from 'rxjs';\n\n/**\n * Transport for the jit-service tile protocol.\n *\n * Two transports exist on purpose, and each backend uses exactly one:\n *  - **napari-js** fetches with the browser's `fetch` (its tile loader, the worker-free slice\n *    stitcher and the volume preload all need a `Response`), through {@link fetchWithAuth}: the one\n *    place the host's `getAuthHeaders()` is resolved, with its \"no token → cookie auth\" fallback.\n *  - **OpenSeadragon** keeps Angular's `HttpClient`, so the host's interceptors (auth, retry,\n *    logging) apply exactly as before; {@link httpFetchJson} adapts it.\n *\n * The protocol helpers ({@link pollDescriptor}, {@link nativeHistogram}) take a {@link FetchJson}\n * and so run the same code over either one.\n */\n\n/** Auth header provider — the subset of `TileAccessPort` the transport needs. */\nexport interface AuthHeaderSource {\n  getAuthHeaders(): Promise<Record<string, string>>;\n}\n\n/** Resolve the host's auth headers; a failure means cookie / anonymous auth (`{}`). */\nexport function resolveAuthHeaders(src: AuthHeaderSource): Promise<Record<string, string>> {\n  return src.getAuthHeaders().catch(() => ({}) as Record<string, string>);\n}\n\n/** `fetch` with the host's auth headers (merged under any `init.headers`). */\nexport async function fetchWithAuth(\n  auth: AuthHeaderSource,\n  url: string,\n  init: RequestInit = {},\n): Promise<Response> {\n  const headers = await resolveAuthHeaders(auth);\n  return fetch(url, { ...init, headers: { ...headers, ...(init.headers as Record<string, string>) } });\n}\n\n/** A JSON GET's status and parsed body (null when there is none, or it is not JSON). */\nexport interface JsonResponse<T> {\n  status: number;\n  body: T | null;\n}\n\n/**\n * A JSON GET. Resolves with any HTTP status the server answered (2xx or not); rejects on a\n * transport failure (network error, CORS) and as soon as `signal` aborts.\n */\nexport type FetchJson = <T>(url: string, signal?: AbortSignal) => Promise<JsonResponse<T>>;\n\n/** {@link FetchJson} over {@link fetchWithAuth}. */\nexport function fetchJsonWithAuth(auth: AuthHeaderSource): FetchJson {\n  return async <T>(url: string, signal?: AbortSignal): Promise<JsonResponse<T>> => {\n    const resp = await fetchWithAuth(auth, url, signal ? { signal } : {});\n    if (resp.status !== 200) return { status: resp.status, body: null };\n    return { status: resp.status, body: ((await resp.json()) as T) ?? null };\n  };\n}\n\n/**\n * {@link FetchJson} over Angular's `HttpClient` (its interceptors apply). An HTTP error status is\n * resolved, not thrown; status 0 (no response at all) stays a rejection. An abort unsubscribes,\n * which cancels the XHR.\n */\nexport function httpFetchJson(http: HttpClient): FetchJson {\n  return async <T>(url: string, signal?: AbortSignal): Promise<JsonResponse<T>> => {\n    try {\n      const resp = await firstValueFromAbortable(http.get<T>(url, { observe: 'response' }), signal);\n      return { status: resp.status, body: resp.body ?? null };\n    } catch (err) {\n      if (err instanceof HttpErrorResponse && err.status > 0) return { status: err.status, body: null };\n      throw err;\n    }\n  };\n}\n\n/**\n * `firstValueFrom` that unsubscribes (for `HttpClient`, cancels the XHR) and rejects with an\n * {@link abortError} as soon as `signal` aborts. The subscription is made synchronously.\n */\nexport function firstValueFromAbortable<T>(source: Observable<T>, signal?: AbortSignal): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(abortError());\n      return;\n    }\n    let settled = false;\n    const settle = (): void => {\n      settled = true;\n      signal?.removeEventListener('abort', onAbort);\n    };\n    const onAbort = (): void => {\n      settle();\n      sub.unsubscribe();\n      reject(abortError());\n    };\n    const sub = source.subscribe({\n      next: (v) => {\n        if (settled) return;\n        settle();\n        resolve(v);\n        queueMicrotask(() => sub?.unsubscribe());\n      },\n      error: (err: unknown) => {\n        if (settled) return;\n        settle();\n        reject(err);\n      },\n      complete: () => {\n        if (settled) return;\n        settle();\n        reject(new Error('no elements in sequence'));\n      },\n    });\n    if (!settled) signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n\n// ── AbortSignal helpers ─────────────────────────────────────────────────────\n\n/** The error an aborted operation rejects with (`name === 'AbortError'`, as `fetch` uses). */\nexport function abortError(): Error {\n  return new DOMException('The operation was aborted.', 'AbortError');\n}\n\n/** Whether `err` is an abort (from {@link abortError}, `fetch`, or `AbortSignal.reason`). */\nexport function isAbortError(err: unknown): boolean {\n  return (err as { name?: unknown } | null)?.name === 'AbortError';\n}\n\n/** Throw an {@link abortError} when `signal` has aborted. */\nexport function throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) throw abortError();\n}\n\n/** Resolve after `ms`, or reject with an {@link abortError} as soon as `signal` aborts. */\nexport function abortableDelay(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(abortError());\n      return;\n    }\n    const onAbort = (): void => {\n      clearTimeout(timer);\n      reject(abortError());\n    };\n    const timer = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort);\n      resolve();\n    }, ms);\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n\n/**\n * A signal that aborts when `parent` does, or after `timeoutMs`. Call `done()` once the guarded\n * request settles, to clear the timer and the parent listener.\n */\nexport function timeoutSignal(\n  parent: AbortSignal | undefined,\n  timeoutMs: number,\n): { signal: AbortSignal; done(): void } {\n  const ctl = new AbortController();\n  const onAbort = (): void => ctl.abort();\n  if (parent?.aborted) ctl.abort();\n  else parent?.addEventListener('abort', onAbort, { once: true });\n  const timer = setTimeout(() => ctl.abort(), timeoutMs);\n  return {\n    signal: ctl.signal,\n    done: () => {\n      clearTimeout(timer);\n      parent?.removeEventListener('abort', onAbort);\n    },\n  };\n}\n"]}

package/esm2022/lib/intensity/intensity-profile.mjs

@@ -0,0 +1,107 @@
+import { bt601Luminance } from '../contracts/intensity';
+/**
+ * Pure intensity-profile math: sampling a line through a pixel frame, placing a
+ * new profile line, and the image's physical pixel size. Frames are row-major
+ * matrices: grayscale cells are numbers, RGB cells are `[r, g, b]`.
+ */
+/** Bright, well-separated colours cycled as the user adds profile lines.
+ *  The matching inset trace is drawn in the same colour. */
+export const PROFILE_PALETTE = [
+    '#FFD400', // yellow
+    '#00E5FF', // cyan
+    '#FF2D95', // magenta
+    '#39FF14', // green
+    '#FF9500', // orange
+    '#7C4DFF', // violet
+    '#FF3B30', // red
+    '#18FFFF', // aqua
+];
+/** Physical pixel size (microns/pixel), if known. mpp is constant across
+ *  frames/channels, so the first metadata entry with a positive mppX wins. */
+export function imageMpp(meta) {
+    const m = Array.isArray(meta) ? (meta.find((e) => e && (e.mppX ?? 0) > 0) ?? meta[0]) : undefined;
+    const mppX = m && (m.mppX ?? 0) > 0 ? m.mppX : null;
+    const mppY = m && (m.mppY ?? 0) > 0 ? m.mppY : null;
+    return { mppX, mppY };
+}
+/**
+ * Sample a frame's intensity (grayscale value or RGB luminance) along `line`.
+ * Positions are the distance along the line, in microns when `mpp` is known
+ * (anisotropic mppX/mppY applied per axis, so diagonals measure their true
+ * length), otherwise in image pixels. One sample per frame pixel along the line.
+ */
+export function sampleLine(src, line, mpp) {
+    const frame = src.frame;
+    if (!frame?.length)
+        return { positions: [], values: [] };
+    const rx = src.ratios[0] || 1;
+    const ry = src.ratios[1] || rx;
+    const [ox, oy] = src.origin;
+    const x0 = +line.x0, y0 = +line.y0, x1 = +line.x1, y1 = +line.y1;
+    const dxData = x1 - x0, dyData = y1 - y0;
+    const { mppX, mppY } = mpp;
+    const useMicrons = mppX != null;
+    const lenData = useMicrons ? Math.hypot(dxData * mppX, dyData * (mppY ?? mppX)) : Math.hypot(dxData, dyData);
+    const lenPx = Math.hypot(dxData / rx, dyData / ry);
+    const n = Math.max(2, Math.round(lenPx));
+    const h = frame.length;
+    const w = frame[0].length;
+    const positions = [];
+    const values = [];
+    for (let i = 0; i < n; i++) {
+        const t = i / (n - 1);
+        // Data coords → the frame's pixel grid, offset by its origin (a zoom crop). Frame pixel i
+        // covers [i, i + 1), as for the tools.
+        const px = Math.floor((x0 + t * dxData - ox) / rx);
+        const py = Math.floor((y0 + t * dyData - oy) / ry);
+        let v = 0;
+        if (px >= 0 && px < w && py >= 0 && py < h) {
+            const cell = frame[py][px];
+            v = Array.isArray(cell) ? bt601Luminance(cell[0], cell[1], cell[2]) : cell;
+        }
+        positions.push(t * lenData);
+        values.push(v);
+    }
+    return { positions, values, unit: useMicrons ? 'µm' : 'px' };
+}
+/** A profile-line region's two endpoints, or null when it has no polyline.
+ *  Duck-typed (not `instanceof Polygon`): after a drag round-trips through the
+ *  store the bounds can be a plain object, so this matches on the point arrays. */
+export function profileLineOf(region) {
+    const poly = region.bounds;
+    if (!poly ||
+        !Array.isArray(poly.xpoints) ||
+        !Array.isArray(poly.ypoints) ||
+        poly.xpoints.length < 2 ||
+        poly.ypoints.length < 2) {
+        return null;
+    }
+    return { x0: poly.xpoints[0], y0: poly.ypoints[0], x1: poly.xpoints[1], y1: poly.ypoints[1] };
+}
+/**
+ * Where the `count`-th profile line goes: a horizontal line spanning 2/3 of
+ * the visible part of the image (`roi`, when it overlaps the image extent
+ * `[x0, x1, y0, y1]`; else the whole image), centred, staggered down the visible
+ * band so successive lines stay distinct.
+ */
+export function placeProfileLine(extent, roi, count) {
+    const [imgX0, imgX1, imgTop, imgBottom] = extent;
+    const overlaps = !!roi &&
+        roi.width > 0 &&
+        roi.height > 0 &&
+        roi.x < imgX1 &&
+        roi.x + roi.width > imgX0 &&
+        roi.y < imgBottom &&
+        roi.y + roi.height > imgTop;
+    const x0v = overlaps ? Math.max(imgX0, roi.x) : imgX0;
+    const x1v = overlaps ? Math.min(imgX1, roi.x + roi.width) : imgX1;
+    const topV = overlaps ? Math.max(imgTop, roi.y) : imgTop;
+    const bottomV = overlaps ? Math.min(imgBottom, roi.y + roi.height) : imgBottom;
+    const cx = (x0v + x1v) / 2;
+    const half = ((x1v - x0v) * (2 / 3)) / 2;
+    const bandH = bottomV - topV;
+    const midY = (topV + bottomV) / 2;
+    const y = Math.min(bottomV, Math.max(topV, midY + count * bandH * 0.12));
+    return { x0: cx - half, x1: cx + half, y };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intensity-profile.js","sourceRoot":"","sources":["../../../../src/lib/intensity/intensity-profile.ts"],"names":[],"mappings":"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","sourcesContent":["import { IntensityProfile } from '../contracts/visualizer.contract';\nimport { IImageMetadata } from '../contracts/image.contract';\nimport { bt601Luminance } from '../contracts/intensity';\nimport { Region } from '../models/region';\n\n/**\n * Pure intensity-profile math: sampling a line through a pixel frame, placing a\n * new profile line, and the image's physical pixel size. Frames are row-major\n * matrices: grayscale cells are numbers, RGB cells are `[r, g, b]`.\n */\n\n/** Bright, well-separated colours cycled as the user adds profile lines.\n *  The matching inset trace is drawn in the same colour. */\nexport const PROFILE_PALETTE: readonly string[] = [\n  '#FFD400', // yellow\n  '#00E5FF', // cyan\n  '#FF2D95', // magenta\n  '#39FF14', // green\n  '#FF9500', // orange\n  '#7C4DFF', // violet\n  '#FF3B30', // red\n  '#18FFFF', // aqua\n];\n\n/** A sampling line in image (data) coordinates. */\nexport interface ProfileLine {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/** One frame to sample and how it maps onto the image. */\nexport interface SamplingFrame {\n  /** The pixel matrix (row-major). */\n  frame: any[];\n  /** [xRatio, yRatio]: image units per frame pixel. */\n  ratios: number[];\n  /** Image coordinate of the frame's pixel (0,0): [0,0] for the full image, a\n   *  crop's top-left for a zoom crop. */\n  origin: [number, number];\n}\n\n/** Physical pixel size (microns/pixel), if known. mpp is constant across\n *  frames/channels, so the first metadata entry with a positive mppX wins. */\nexport function imageMpp(meta: IImageMetadata[] | undefined): { mppX: number | null; mppY: number | null } {\n  const m = Array.isArray(meta) ? (meta.find((e) => e && (e.mppX ?? 0) > 0) ?? meta[0]) : undefined;\n  const mppX = m && (m.mppX ?? 0) > 0 ? (m.mppX as number) : null;\n  const mppY = m && (m.mppY ?? 0) > 0 ? (m.mppY as number) : null;\n  return { mppX, mppY };\n}\n\n/**\n * Sample a frame's intensity (grayscale value or RGB luminance) along `line`.\n * Positions are the distance along the line, in microns when `mpp` is known\n * (anisotropic mppX/mppY applied per axis, so diagonals measure their true\n * length), otherwise in image pixels. One sample per frame pixel along the line.\n */\nexport function sampleLine(\n  src: SamplingFrame,\n  line: ProfileLine,\n  mpp: { mppX: number | null; mppY: number | null },\n): IntensityProfile {\n  const frame = src.frame;\n  if (!frame?.length) return { positions: [], values: [] };\n  const rx = src.ratios[0] || 1;\n  const ry = src.ratios[1] || rx;\n  const [ox, oy] = src.origin;\n  const x0 = +line.x0,\n    y0 = +line.y0,\n    x1 = +line.x1,\n    y1 = +line.y1;\n  const dxData = x1 - x0,\n    dyData = y1 - y0;\n  const { mppX, mppY } = mpp;\n  const useMicrons = mppX != null;\n  const lenData = useMicrons ? Math.hypot(dxData * mppX, dyData * (mppY ?? mppX)) : Math.hypot(dxData, dyData);\n  const lenPx = Math.hypot(dxData / rx, dyData / ry);\n  const n = Math.max(2, Math.round(lenPx));\n  const h = frame.length;\n  const w = frame[0].length;\n  const positions: number[] = [];\n  const values: number[] = [];\n  for (let i = 0; i < n; i++) {\n    const t = i / (n - 1);\n    // Data coords → the frame's pixel grid, offset by its origin (a zoom crop). Frame pixel i\n    // covers [i, i + 1), as for the tools.\n    const px = Math.floor((x0 + t * dxData - ox) / rx);\n    const py = Math.floor((y0 + t * dyData - oy) / ry);\n    let v = 0;\n    if (px >= 0 && px < w && py >= 0 && py < h) {\n      const cell = frame[py][px];\n      v = Array.isArray(cell) ? bt601Luminance(cell[0], cell[1], cell[2]) : cell;\n    }\n    positions.push(t * lenData);\n    values.push(v);\n  }\n  return { positions, values, unit: useMicrons ? 'µm' : 'px' };\n}\n\n/** A profile-line region's two endpoints, or null when it has no polyline.\n *  Duck-typed (not `instanceof Polygon`): after a drag round-trips through the\n *  store the bounds can be a plain object, so this matches on the point arrays. */\nexport function profileLineOf(region: Region): ProfileLine | null {\n  const poly = region.bounds as { xpoints?: unknown; ypoints?: unknown } | undefined;\n  if (\n    !poly ||\n    !Array.isArray(poly.xpoints) ||\n    !Array.isArray(poly.ypoints) ||\n    poly.xpoints.length < 2 ||\n    poly.ypoints.length < 2\n  ) {\n    return null;\n  }\n  return { x0: poly.xpoints[0], y0: poly.ypoints[0], x1: poly.xpoints[1], y1: poly.ypoints[1] };\n}\n\n/** An image-pixel rectangle. */\nexport interface PixelRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Where the `count`-th profile line goes: a horizontal line spanning 2/3 of\n * the visible part of the image (`roi`, when it overlaps the image extent\n * `[x0, x1, y0, y1]`; else the whole image), centred, staggered down the visible\n * band so successive lines stay distinct.\n */\nexport function placeProfileLine(\n  extent: number[],\n  roi: PixelRect | null,\n  count: number,\n): { x0: number; x1: number; y: number } {\n  const [imgX0, imgX1, imgTop, imgBottom] = extent;\n  const overlaps =\n    !!roi &&\n    roi.width > 0 &&\n    roi.height > 0 &&\n    roi.x < imgX1 &&\n    roi.x + roi.width > imgX0 &&\n    roi.y < imgBottom &&\n    roi.y + roi.height > imgTop;\n  const x0v = overlaps ? Math.max(imgX0, roi!.x) : imgX0;\n  const x1v = overlaps ? Math.min(imgX1, roi!.x + roi!.width) : imgX1;\n  const topV = overlaps ? Math.max(imgTop, roi!.y) : imgTop;\n  const bottomV = overlaps ? Math.min(imgBottom, roi!.y + roi!.height) : imgBottom;\n  const cx = (x0v + x1v) / 2;\n  const half = ((x1v - x0v) * (2 / 3)) / 2;\n  const bandH = bottomV - topV;\n  const midY = (topV + bottomV) / 2;\n  const y = Math.min(bottomV, Math.max(topV, midY + count * bandH * 0.12));\n  return { x0: cx - half, x1: cx + half, y };\n}\n"]}

package/esm2022/lib/intensity/intensity-profile.service.mjs

@@ -0,0 +1,223 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Subject, Subscription } from 'rxjs';
+import { Image } from 'image-js';
+import { Buffer } from 'buffer';
+import { TILE_ACCESS_PORT } from '../contracts/ports/tile-access.port';
+import { IMAGE_STATE_PORT } from '../contracts/ports/image-state.port';
+import { Polygon, Rectangle, Region } from '../models/region';
+import { RegionStore } from '../store/region-store.service';
+import { PlotUtilities } from '../plot.utilities';
+import { PROFILE_PALETTE, imageMpp, placeProfileLine, profileLineOf, sampleLine, } from './intensity-profile';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../store/region-store.service";
+/**
+ * Intensity profiles along line ROIs (PlotType.LINE), for every backend.
+ *
+ * Profile lines are ordinary RegionStore regions tagged `kind: 'profile'`; any
+ * region change re-samples and re-emits every line's profile. The service owns
+ * its OWN sampling frames — a backend's tool readback never doubles as the
+ * profile source (OSD-PLOTLY-2) — filled by Plotly when it renders or high-def
+ * zooms, and fetched here for the other backends: the displayed slice
+ * ({@link ensureIntensitySampling}) and, on zoom/pan, a display-resolution
+ * crop of the visible region ({@link refreshIntensitySamplingForRoi}). Every
+ * sampling write supersedes the async ones before it.
+ *
+ * Per viewer: listed in `provideVisualization()` with the RegionStore it
+ * listens to.
+ */
+export class IntensityProfileService {
+    constructor(http, tiles, state, regionStore) {
+        this.http = http;
+        this.tiles = tiles;
+        this.regionStore = regionStore;
+        this.frames = null;
+        this.image = null;
+        /** The last visible image-pixel rect a backend reported (new lines go there). */
+        this.lastVisibleRoi = null;
+        /** Palette cursor (never reset on delete, so colours keep cycling). */
+        this.colorSeq = 0;
+        /** Bumped by every sampling write request: an async fetch lands only if no
+         *  newer one was requested meanwhile. */
+        this.gen = 0;
+        /** The element whose parent sizes a crop request (the viewer's plot div). */
+        this.elementId = '';
+        this.profiles$ = new Subject();
+        this.subs = new Subscription();
+        this.utils = new PlotUtilities();
+        this.subs.add(state.getFilename$().subscribe((f) => {
+            this.fileName = f;
+        }));
+        // Profile lines are store regions: any change (add/drag/delete, on any
+        // backend) refreshes the inset. The live-edit stream fires per frame during
+        // a drag (OSD coalesces regionUpdate$ until release), so the inset tracks it.
+        this.subs.add(regionStore.getRegionUpdateEvent().subscribe(() => this.emitProfiles()));
+        this.subs.add(regionStore.getRegionLiveEdit$().subscribe(() => this.emitProfiles()));
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+    /** Every profile line's profile, re-emitted whenever one is added, moved or removed. */
+    getIntensityProfile$() {
+        return this.profiles$.asObservable();
+    }
+    /** The element (by id) whose size a crop request is made for. */
+    setSamplingElement(id) {
+        this.elementId = id;
+    }
+    /** Supersede every sampling fetch in flight; returns the new generation. */
+    supersede() {
+        return ++this.gen;
+    }
+    /** Whether `gen` (from {@link supersede}) is still the latest sampling request. */
+    isCurrent(gen) {
+        return gen === this.gen;
+    }
+    /** Sample from these frames from now on — of `image`, or of the image already set. */
+    setFrames(frames, image) {
+        this.frames = { ...frames, origin: frames.origin ?? [0, 0] };
+        if (image)
+            this.image = image;
+    }
+    /**
+     * Fetch the displayed slice's preview for sampling (the same pixels a heatmap
+     * would sample), for a backend that has no frames of its own (OpenSeadragon,
+     * napari-js). Re-emits the profiles once loaded.
+     */
+    async ensureIntensitySampling(imageInfo, zIndex) {
+        if (!imageInfo?.urls?.length)
+            return;
+        const gen = this.supersede();
+        const slice = await this.loadSlice(imageInfo, zIndex || 0);
+        if (!this.isCurrent(gen))
+            return; // superseded (another image / a crop)
+        this.setFrames({ frames: [slice.frame], ratios: slice.ratios }, {
+            imageInfo,
+            extent: [0, imageInfo.trueImageSize[0], 0, imageInfo.trueImageSize[1]],
+        });
+        this.emitProfiles();
+    }
+    /**
+     * Re-fetch the given image-pixel ROI at the display resolution and sample from
+     * it, so the profile reflects the data at the current zoom level. Also
+     * remembers the ROI, so a new line is placed inside it.
+     */
+    refreshIntensitySamplingForRoi(x, y, width, height, zIndex) {
+        if (width <= 0 || height <= 0)
+            return;
+        this.lastVisibleRoi = { x, y, width, height };
+        const roi = Object.assign(new Rectangle(), {
+            x: Math.round(x),
+            y: Math.round(y),
+            width: Math.round(width),
+            height: Math.round(height),
+        });
+        // Sized from the viewer's own plot div, not a host element id (CORE-24).
+        const screen = this.utils.getDomRectangle(this.elementId);
+        const reqName = this.fileName;
+        const gen = this.supersede();
+        this.tiles.zoomOnRegion(roi, screen, zIndex || 0).subscribe({
+            next: (zoomData) => {
+                Image.load(Buffer.from(new Uint8Array(zoomData))).then((image) => {
+                    if (this.fileName !== reqName || !this.isCurrent(gen))
+                        return;
+                    const frame = this.toMatrix(image, !!this.image?.imageInfo?.isGrayscale);
+                    this.setFrames({
+                        frames: [frame],
+                        ratios: [roi.width / image.width, roi.height / image.height],
+                        origin: [roi.x, roi.y],
+                    });
+                    this.emitProfiles();
+                });
+            },
+            error: () => {
+                /* keep the previous sampling frame on a failed crop fetch */
+            },
+        });
+    }
+    /**
+     * Add another profile line: a horizontal open 2-point polyline in the next
+     * palette colour, placed by {@link placeProfileLine}, added to the shared
+     * store so every backend renders and drags it (and excluded from the Regions
+     * tab and exports by its kind). Null until an image extent is known.
+     */
+    addProfileLine() {
+        const extent = this.image?.extent;
+        if (!extent)
+            return null;
+        const { x0, x1, y } = placeProfileLine(extent, this.lastVisibleRoi, this.profileRegions().length);
+        const poly = new Polygon();
+        poly.npoints = 2;
+        poly.xpoints = [x0, x1];
+        poly.ypoints = [y, y];
+        poly.coordinates = [
+            [x0, y],
+            [x1, y],
+        ];
+        poly.closed = false;
+        const region = new Region();
+        region.bounds = poly;
+        region.kind = 'profile';
+        region.color = PROFILE_PALETTE[this.colorSeq++ % PROFILE_PALETTE.length];
+        // region.label stays undefined so applyClassificationColors won't recolor it.
+        this.regionStore.addRegion(region);
+        return region;
+    }
+    /** Recompute and broadcast every profile line's profile (tagged with the
+     *  line's id and colour, so the inset trace matches its line). */
+    emitProfiles() {
+        this.profiles$.next(this.profileRegions().map((r) => {
+            const line = profileLineOf(r);
+            return {
+                ...(line ? this.computeIntensityProfile(line) : { positions: [], values: [] }),
+                id: r.id,
+                color: r.color,
+            };
+        }));
+    }
+    /** Sample the active frame along `line` (see sampleLine). */
+    computeIntensityProfile(line) {
+        const empty = { positions: [], values: [] };
+        const frames = this.frames?.frames;
+        if (!frames?.length || !line)
+            return empty;
+        const index = frames.length <= 1 ? 0 : (this.image?.frameIndex?.() ?? 0);
+        const frame = frames[index] ?? frames[0];
+        if (!frame?.length)
+            return empty;
+        return sampleLine({ frame, ratios: this.frames.ratios, origin: this.frames.origin }, line, imageMpp(this.image?.imageInfo?.imageMeta));
+    }
+    /** The profile-line regions in the store. */
+    profileRegions() {
+        return this.regionStore.getRegions().filter((r) => r.kind === 'profile');
+    }
+    /** Fetch one slice through HttpClient (auth interceptors apply) and decode it. */
+    async loadSlice(imageInfo, z) {
+        const url = imageInfo.urls[z] || imageInfo.urls[0];
+        const buffer = await new Promise((resolve, reject) => this.http.get(url, { responseType: 'arraybuffer' }).subscribe({ next: resolve, error: reject }));
+        const image = await Image.load(Buffer.from(buffer));
+        return {
+            frame: this.toMatrix(image, !!imageInfo.isGrayscale),
+            ratios: [imageInfo.trueImageSize[0] / image.width, imageInfo.trueImageSize[1] / image.height],
+        };
+    }
+    toMatrix(image, isGrayscale) {
+        return isGrayscale
+            ? this.utils.arrayToMatrix(Array.from(image.grey().data), image.width)
+            : this.utils.arrayToMatrix(image.getPixelsArray(), image.width);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IntensityProfileService, deps: [{ token: i1.HttpClient }, { token: TILE_ACCESS_PORT }, { token: IMAGE_STATE_PORT }, { token: i2.RegionStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IntensityProfileService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IntensityProfileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TILE_ACCESS_PORT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IMAGE_STATE_PORT]
+                }] }, { type: i2.RegionStore }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intensity-profile.service.js","sourceRoot":"","sources":["../../../../src/lib/intensity/intensity-profile.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAc,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,OAAO,EAAkB,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAkB,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EACL,eAAe,EAGf,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,UAAU,GACX,MAAM,qBAAqB,CAAC;;;;AAsB7B;;;;;;;;;;;;;;GAcG;AAEH,MAAM,OAAO,uBAAuB;IAkBlC,YACmB,IAAgB,EACU,KAAqB,EACtC,KAAqB,EAC9B,WAAwB;QAHxB,SAAI,GAAJ,IAAI,CAAY;QACU,UAAK,GAAL,KAAK,CAAgB;QAE/C,gBAAW,GAAX,WAAW,CAAa;QArBnC,WAAM,GAA2B,IAAI,CAAC;QACtC,UAAK,GAA0B,IAAI,CAAC;QAC5C,iFAAiF;QACzE,mBAAc,GAAqB,IAAI,CAAC;QAChD,uEAAuE;QAC/D,aAAQ,GAAG,CAAC,CAAC;QACrB;iDACyC;QACjC,QAAG,GAAG,CAAC,CAAC;QAChB,6EAA6E;QACrE,cAAS,GAAG,EAAE,CAAC;QAGN,cAAS,GAAG,IAAI,OAAO,EAAsB,CAAC;QAC9C,SAAI,GAAG,IAAI,YAAY,EAAE,CAAC;QAC1B,UAAK,GAAG,IAAI,aAAa,EAAE,CAAC;QAQ3C,IAAI,CAAC,IAAI,CAAC,GAAG,CACX,KAAK,CAAC,YAAY,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YACnC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QACpB,CAAC,CAAC,CACH,CAAC;QACF,uEAAuE;QACvE,4EAA4E;QAC5E,8EAA8E;QAC9E,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;QACvF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;IACvF,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IAC1B,CAAC;IAED,wFAAwF;IACxF,oBAAoB;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;IACvC,CAAC;IAED,iEAAiE;IACjE,kBAAkB,CAAC,EAAU;QAC3B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,4EAA4E;IAC5E,SAAS;QACP,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC;IACpB,CAAC;IAED,mFAAmF;IACnF,SAAS,CAAC,GAAW;QACnB,OAAO,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC;IAC1B,CAAC;IAED,sFAAsF;IACtF,SAAS,CAAC,MAAuB,EAAE,KAAsB;QACvD,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAC7D,IAAI,KAAK;YAAE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,uBAAuB,CAAC,SAAqB,EAAE,MAAc;QACjE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM;YAAE,OAAO;QACrC,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;YAAE,OAAO,CAAC,sCAAsC;QACxE,IAAI,CAAC,SAAS,CACZ,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,EAC/C;YACE,SAAS;YACT,MAAM,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;SACvE,CACF,CAAC;QACF,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,8BAA8B,CAAC,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,MAAc,EAAE,MAAc;QAChG,IAAI,KAAK,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC;YAAE,OAAO;QACtC,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,SAAS,EAAE,EAAE;YACzC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAChB,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAChB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;YACxB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;SAC3B,CAAC,CAAC;QACH,yEAAyE;QACzE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC7B,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1D,IAAI,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACjB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAU,EAAE,EAAE;oBACpE,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;wBAAE,OAAO;oBAC9D,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;oBACzE,IAAI,CAAC,SAAS,CAAC;wBACb,MAAM,EAAE,CAAC,KAAK,CAAC;wBACf,MAAM,EAAE,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;wBAC5D,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;qBACvB,CAAC,CAAC;oBACH,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,CAAC,CAAC,CAAC;YACL,CAAC;YACD,KAAK,EAAE,GAAG,EAAE;gBACV,6DAA6D;YAC/D,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,cAAc;QACZ,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;QAClC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACzB,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,MAAM,CAAC,CAAC;QAClG,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,WAAW,GAAG;YACjB,CAAC,EAAE,EAAE,CAAC,CAAC;YACP,CAAC,EAAE,EAAE,CAAC,CAAC;SACR,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QAC5B,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,CAAC,IAAI,GAAG,SAAS,CAAC;QACxB,MAAM,CAAC,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;QACzE,8EAA8E;QAC9E,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACnC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;sEACkE;IAClE,YAAY;QACV,IAAI,CAAC,SAAS,CAAC,IAAI,CACjB,IAAI,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC9B,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;YAC9B,OAAO;gBACL,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;gBAC9E,EAAE,EAAE,CAAC,CAAC,EAAE;gBACR,KAAK,EAAE,CAAC,CAAC,KAAK;aACf,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,6DAA6D;IAC7D,uBAAuB,CAAC,IAAiB;QACvC,MAAM,KAAK,GAAqB,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;QACnC,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;QACzE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,CAAC,KAAK,EAAE,MAAM;YAAE,OAAO,KAAK,CAAC;QACjC,OAAO,UAAU,CACf,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAO,CAAC,MAAO,EAAE,EACpE,IAAI,EACJ,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAC3C,CAAC;IACJ,CAAC;IAED,6CAA6C;IACrC,cAAc;QACpB,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAC3E,CAAC;IAED,kFAAkF;IAC1E,KAAK,CAAC,SAAS,CAAC,SAAqB,EAAE,CAAS;QACtD,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACnD,MAAM,MAAM,GAAG,MAAM,IAAI,OAAO,CAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAChE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAChG,CAAC;QACF,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QACpD,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC;YACpD,MAAM,EAAE,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;SAC9F,CAAC;IACJ,CAAC;IAEO,QAAQ,CAAC,KAAU,EAAE,WAAoB;QAC/C,OAAO,WAAW;YAChB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;YACtE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACpE,CAAC;8GA3MU,uBAAuB,4CAoBxB,gBAAgB,aAChB,gBAAgB;kHArBf,uBAAuB,cADV,MAAM;;2FACnB,uBAAuB;kBADnC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAqB7B,MAAM;2BAAC,gBAAgB;;0BACvB,MAAM;2BAAC,gBAAgB","sourcesContent":["import { Inject, Injectable, OnDestroy } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, Subject, Subscription } from 'rxjs';\nimport { Image } from 'image-js';\nimport { Buffer } from 'buffer';\n\nimport { IIntensityControls, IntensityProfile } from '../contracts/visualizer.contract';\nimport { IImageInfo } from '../contracts/image.contract';\nimport { TileAccessPort, TILE_ACCESS_PORT } from '../contracts/ports/tile-access.port';\nimport { ImageStatePort, IMAGE_STATE_PORT } from '../contracts/ports/image-state.port';\nimport { Polygon, Rectangle, Region } from '../models/region';\nimport { RegionStore } from '../store/region-store.service';\nimport { PlotUtilities } from '../plot.utilities';\nimport {\n  PROFILE_PALETTE,\n  PixelRect,\n  ProfileLine,\n  imageMpp,\n  placeProfileLine,\n  profileLineOf,\n  sampleLine,\n} from './intensity-profile';\n\n/** The pixels the profiles are sampled from, and the image they belong to. */\nexport interface IntensityFrames {\n  /** Per-z-plane pixel matrices (grayscale numbers or `[r, g, b]` cells). */\n  frames: any[];\n  /** [xRatio, yRatio]: image units per frame pixel. */\n  ratios: number[];\n  /** Image coordinate of the frames' pixel (0,0); [0,0] unless a zoom crop. */\n  origin?: [number, number];\n}\n\n/** The image the frames come from: its extent (for line placement) and its\n *  metadata (pixel size, grayscale). */\nexport interface IntensityImage {\n  imageInfo: IImageInfo;\n  /** [x0, x1, y0, y1] in image units. */\n  extent: number[];\n  /** The displayed z-plane, when the frames hold a stack. */\n  frameIndex?: () => number;\n}\n\n/**\n * Intensity profiles along line ROIs (PlotType.LINE), for every backend.\n *\n * Profile lines are ordinary RegionStore regions tagged `kind: 'profile'`; any\n * region change re-samples and re-emits every line's profile. The service owns\n * its OWN sampling frames — a backend's tool readback never doubles as the\n * profile source (OSD-PLOTLY-2) — filled by Plotly when it renders or high-def\n * zooms, and fetched here for the other backends: the displayed slice\n * ({@link ensureIntensitySampling}) and, on zoom/pan, a display-resolution\n * crop of the visible region ({@link refreshIntensitySamplingForRoi}). Every\n * sampling write supersedes the async ones before it.\n *\n * Per viewer: listed in `provideVisualization()` with the RegionStore it\n * listens to.\n */\n@Injectable({ providedIn: 'root' })\nexport class IntensityProfileService implements IIntensityControls, OnDestroy {\n  private frames: IntensityFrames | null = null;\n  private image: IntensityImage | null = null;\n  /** The last visible image-pixel rect a backend reported (new lines go there). */\n  private lastVisibleRoi: PixelRect | null = null;\n  /** Palette cursor (never reset on delete, so colours keep cycling). */\n  private colorSeq = 0;\n  /** Bumped by every sampling write request: an async fetch lands only if no\n   *  newer one was requested meanwhile. */\n  private gen = 0;\n  /** The element whose parent sizes a crop request (the viewer's plot div). */\n  private elementId = '';\n  /** The host's selected file, so a crop for a previous file is dropped. */\n  private fileName: string | undefined;\n  private readonly profiles$ = new Subject<IntensityProfile[]>();\n  private readonly subs = new Subscription();\n  private readonly utils = new PlotUtilities();\n\n  constructor(\n    private readonly http: HttpClient,\n    @Inject(TILE_ACCESS_PORT) private readonly tiles: TileAccessPort,\n    @Inject(IMAGE_STATE_PORT) state: ImageStatePort,\n    private readonly regionStore: RegionStore,\n  ) {\n    this.subs.add(\n      state.getFilename$().subscribe((f) => {\n        this.fileName = f;\n      }),\n    );\n    // Profile lines are store regions: any change (add/drag/delete, on any\n    // backend) refreshes the inset. The live-edit stream fires per frame during\n    // a drag (OSD coalesces regionUpdate$ until release), so the inset tracks it.\n    this.subs.add(regionStore.getRegionUpdateEvent().subscribe(() => this.emitProfiles()));\n    this.subs.add(regionStore.getRegionLiveEdit$().subscribe(() => this.emitProfiles()));\n  }\n\n  ngOnDestroy(): void {\n    this.subs.unsubscribe();\n  }\n\n  /** Every profile line's profile, re-emitted whenever one is added, moved or removed. */\n  getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.profiles$.asObservable();\n  }\n\n  /** The element (by id) whose size a crop request is made for. */\n  setSamplingElement(id: string): void {\n    this.elementId = id;\n  }\n\n  /** Supersede every sampling fetch in flight; returns the new generation. */\n  supersede(): number {\n    return ++this.gen;\n  }\n\n  /** Whether `gen` (from {@link supersede}) is still the latest sampling request. */\n  isCurrent(gen: number): boolean {\n    return gen === this.gen;\n  }\n\n  /** Sample from these frames from now on — of `image`, or of the image already set. */\n  setFrames(frames: IntensityFrames, image?: IntensityImage): void {\n    this.frames = { ...frames, origin: frames.origin ?? [0, 0] };\n    if (image) this.image = image;\n  }\n\n  /**\n   * Fetch the displayed slice's preview for sampling (the same pixels a heatmap\n   * would sample), for a backend that has no frames of its own (OpenSeadragon,\n   * napari-js). Re-emits the profiles once loaded.\n   */\n  async ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    if (!imageInfo?.urls?.length) return;\n    const gen = this.supersede();\n    const slice = await this.loadSlice(imageInfo, zIndex || 0);\n    if (!this.isCurrent(gen)) return; // superseded (another image / a crop)\n    this.setFrames(\n      { frames: [slice.frame], ratios: slice.ratios },\n      {\n        imageInfo,\n        extent: [0, imageInfo.trueImageSize[0], 0, imageInfo.trueImageSize[1]],\n      },\n    );\n    this.emitProfiles();\n  }\n\n  /**\n   * Re-fetch the given image-pixel ROI at the display resolution and sample from\n   * it, so the profile reflects the data at the current zoom level. Also\n   * remembers the ROI, so a new line is placed inside it.\n   */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    if (width <= 0 || height <= 0) return;\n    this.lastVisibleRoi = { x, y, width, height };\n    const roi = Object.assign(new Rectangle(), {\n      x: Math.round(x),\n      y: Math.round(y),\n      width: Math.round(width),\n      height: Math.round(height),\n    });\n    // Sized from the viewer's own plot div, not a host element id (CORE-24).\n    const screen = this.utils.getDomRectangle(this.elementId);\n    const reqName = this.fileName;\n    const gen = this.supersede();\n    this.tiles.zoomOnRegion(roi, screen, zIndex || 0).subscribe({\n      next: (zoomData) => {\n        Image.load(Buffer.from(new Uint8Array(zoomData))).then((image: any) => {\n          if (this.fileName !== reqName || !this.isCurrent(gen)) return;\n          const frame = this.toMatrix(image, !!this.image?.imageInfo?.isGrayscale);\n          this.setFrames({\n            frames: [frame],\n            ratios: [roi.width / image.width, roi.height / image.height],\n            origin: [roi.x, roi.y],\n          });\n          this.emitProfiles();\n        });\n      },\n      error: () => {\n        /* keep the previous sampling frame on a failed crop fetch */\n      },\n    });\n  }\n\n  /**\n   * Add another profile line: a horizontal open 2-point polyline in the next\n   * palette colour, placed by {@link placeProfileLine}, added to the shared\n   * store so every backend renders and drags it (and excluded from the Regions\n   * tab and exports by its kind). Null until an image extent is known.\n   */\n  addProfileLine(): Region | null {\n    const extent = this.image?.extent;\n    if (!extent) return null;\n    const { x0, x1, y } = placeProfileLine(extent, this.lastVisibleRoi, this.profileRegions().length);\n    const poly = new Polygon();\n    poly.npoints = 2;\n    poly.xpoints = [x0, x1];\n    poly.ypoints = [y, y];\n    poly.coordinates = [\n      [x0, y],\n      [x1, y],\n    ];\n    poly.closed = false;\n    const region = new Region();\n    region.bounds = poly;\n    region.kind = 'profile';\n    region.color = PROFILE_PALETTE[this.colorSeq++ % PROFILE_PALETTE.length];\n    // region.label stays undefined so applyClassificationColors won't recolor it.\n    this.regionStore.addRegion(region);\n    return region;\n  }\n\n  /** Recompute and broadcast every profile line's profile (tagged with the\n   *  line's id and colour, so the inset trace matches its line). */\n  emitProfiles(): void {\n    this.profiles$.next(\n      this.profileRegions().map((r) => {\n        const line = profileLineOf(r);\n        return {\n          ...(line ? this.computeIntensityProfile(line) : { positions: [], values: [] }),\n          id: r.id,\n          color: r.color,\n        };\n      }),\n    );\n  }\n\n  /** Sample the active frame along `line` (see sampleLine). */\n  computeIntensityProfile(line: ProfileLine): IntensityProfile {\n    const empty: IntensityProfile = { positions: [], values: [] };\n    const frames = this.frames?.frames;\n    if (!frames?.length || !line) return empty;\n    const index = frames.length <= 1 ? 0 : (this.image?.frameIndex?.() ?? 0);\n    const frame = frames[index] ?? frames[0];\n    if (!frame?.length) return empty;\n    return sampleLine(\n      { frame, ratios: this.frames!.ratios, origin: this.frames!.origin! },\n      line,\n      imageMpp(this.image?.imageInfo?.imageMeta),\n    );\n  }\n\n  /** The profile-line regions in the store. */\n  private profileRegions(): Region[] {\n    return this.regionStore.getRegions().filter((r) => r.kind === 'profile');\n  }\n\n  /** Fetch one slice through HttpClient (auth interceptors apply) and decode it. */\n  private async loadSlice(imageInfo: IImageInfo, z: number): Promise<{ frame: any[]; ratios: number[] }> {\n    const url = imageInfo.urls[z] || imageInfo.urls[0];\n    const buffer = await new Promise<ArrayBuffer>((resolve, reject) =>\n      this.http.get(url, { responseType: 'arraybuffer' }).subscribe({ next: resolve, error: reject }),\n    );\n    const image = await Image.load(Buffer.from(buffer));\n    return {\n      frame: this.toMatrix(image, !!imageInfo.isGrayscale),\n      ratios: [imageInfo.trueImageSize[0] / image.width, imageInfo.trueImageSize[1] / image.height],\n    };\n  }\n\n  private toMatrix(image: any, isGrayscale: boolean): any[] {\n    return isGrayscale\n      ? this.utils.arrayToMatrix(Array.from(image.grey().data), image.width)\n      : this.utils.arrayToMatrix(image.getPixelsArray(), image.width);\n  }\n}\n"]}