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

package/esm2022/lib/store/visualizer-store.service.mjs

@@ -0,0 +1,352 @@
+import { Injectable, Optional, Inject } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { defaultPresetSet } from '../models/class-preset';
+import { PREFERENCES_PORT } from '../contracts/ports/preferences.port';
+import { COLORMAP_OPTIONS } from '../plot.utilities';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Backend-neutral store for the **visualization session** — the state that
+ * describes *how* the current image is being viewed, independent of which
+ * rendering backend (Plotly or OpenSeadragon) is on screen:
+ *
+ *  - the active colormap / LUT and its reverse-scale toggle,
+ *  - the current image's physical metadata (µm/pixel etc.),
+ *  - the classification label → colour map,
+ *  - which on-canvas tool is currently active.
+ *
+ * Both backends read and write this single instance, so they stay in lock-step
+ * regardless of which one is rendering. Previously this state lived inside
+ * `PlotlyService`, which forced the OpenSeadragon backend to depend on the
+ * Plotly service purely to read the shared colormap; this store removes that
+ * coupling — neither backend owns the session state.
+ *
+ * NOTE: region *geometry* (the drawn shapes / per-image region cache) still
+ * lives in `PlotlyService` for now; extracting it into a sibling region store
+ * is a separate follow-up.
+ */
+export class VisualizerStore {
+    // Optional + null defaults so the store can be constructed both via DI and
+    // directly (`new VisualizerStore()` in unit tests); the LUT fetch and preset
+    // load/save no-op when their dependency is absent.
+    constructor(http = null, prefsPort = null) {
+        this.http = http;
+        this.prefsPort = prefsPort;
+        // ── Colormap / LUT ───────────────────────────────────────────────────
+        // Default to inverted greys (dark background → bright signal), which reads as
+        // the natural grayscale for these microscopy images.
+        this.colormap$ = new BehaviorSubject(COLORMAP_OPTIONS[0].children.find((c) => c.label === 'Greys Inv') ?? COLORMAP_OPTIONS[0].children[0]);
+        this.reverseScale$ = new BehaviorSubject(false);
+        // ── Image metadata (physical pixel size, channels, …) ────────────────
+        this.imageMeta$ = new BehaviorSubject([]);
+        // ── Channels & histogram display state ───────────────────────────────
+        // Per-channel display window/gamma/visibility/colour, derived from the image
+        // metadata on load (1 "Intensity" channel for grayscale; R/G/B for RGB). The
+        // Channels & Histogram pane edits these and both backends recolor live.
+        this.channelStates$ = new BehaviorSubject([]);
+        // The derived defaults (full window, gamma 1, default tint) for the current
+        // image, kept so "Reset" can restore a channel's window/gamma/colour.
+        this.defaultChannelStates = [];
+        // Grayscale display (ignore the channel tints) and inverted background — both
+        // global display flags, like the colormap.
+        this.grayscale$ = new BehaviorSubject(false);
+        this.invert$ = new BehaviorSubject(false);
+        // ── Annotation class presets (jit-ui#70) ─────────────────────────────
+        // The per-user, server-persisted source of truth for region colours, seeded
+        // from the historical default classes. Loaded/saved via the optional
+        // PreferencesPort (app-side adapter → jit-service). getClassificationColors()
+        // below stays as a name→colour view for the backends' region renderers.
+        this.presetSet = defaultPresetSet();
+        this.presetSet$ = new BehaviorSubject(this.presetSet);
+        this.savePresets$ = new Subject();
+        this.presetsLoaded = false;
+        // ── Active on-canvas tool ────────────────────────────────────────────
+        // Which tool the user has armed (pan, zoom, drawrect, wand, eraser, …) or
+        // null when none is active. The single source of truth for tool state across
+        // the toolbar and whichever backend's overlay handles the pointer.
+        this.activeTool$ = new BehaviorSubject(null);
+        this.loadColormapLuts();
+        this.initPresetPersistence();
+    }
+    /**
+     * Resolve the colormap tree's LUT keys (e.g. "GREYS_LUT") to their colour
+     * arrays from a served JSON asset. The ~630 KB of LUT data lives outside the
+     * bundle (as `/assets/plotting/colormap-luts.json`) so it never enters the TS
+     * / webpack module graph — that data-in-source was the main driver of the
+     * build's >2 GB heap. Named Plotly scales (e.g. "Viridis") aren't keys in the
+     * JSON, so they're left untouched. The default LUT ("Greys Inv" → the Plotly
+     * "Greys" scale) needs no JSON, so the first render works before this resolves.
+     */
+    loadColormapLuts() {
+        if (!this.http)
+            return;
+        this.http.get('assets/plotting/colormap-luts.json').subscribe({
+            next: (luts) => {
+                for (const group of COLORMAP_OPTIONS) {
+                    for (const child of group.children ?? []) {
+                        const key = child?.data?.value;
+                        if (typeof key === 'string' && luts[key])
+                            child.data.value = luts[key];
+                    }
+                }
+            },
+            error: () => { },
+        });
+    }
+    // ── Preset persistence (jit-ui#70) ───────────────────────────────────
+    initPresetPersistence() {
+        // Debounced write-back so a burst of edits collapses into one PUT.
+        this.savePresets$.pipe(debounceTime(800)).subscribe(() => {
+            this.prefsPort?.savePresetSet(this.presetSet).subscribe({ error: () => { } });
+        });
+        // Load the user's saved set (if any); otherwise keep the seeded defaults.
+        this.prefsPort?.loadPresetSet().subscribe({
+            next: (set) => {
+                if (set && Array.isArray(set.classes) && set.classes.length > 0) {
+                    this.presetSet = this.normalizePresetSet(set);
+                    this.presetSet$.next(this.presetSet);
+                }
+                this.presetsLoaded = true;
+            },
+            error: () => { this.presetsLoaded = true; },
+        });
+    }
+    normalizePresetSet(set) {
+        const defaults = defaultPresetSet();
+        // Clone the nested arrays/objects so outside callers can't mutate the store's
+        // internal state without going through setPresetSet()/upsertClass().
+        return {
+            classes: Array.isArray(set.classes) ? set.classes.map((c) => ({ ...c })) : [],
+            fallbackPalette: Array.isArray(set.fallbackPalette) && set.fallbackPalette.length
+                ? [...set.fallbackPalette]
+                : defaults.fallbackPalette,
+            autoPromote: !!set.autoPromote,
+            matchMode: set.matchMode === 'normalized' ? 'normalized' : 'exact',
+        };
+    }
+    /** Queue a debounced save. No-ops until the initial load resolves (and when no port is bound). */
+    queuePresetSave() {
+        if (this.presetsLoaded)
+            this.savePresets$.next();
+    }
+    /** Persist the current preset set immediately, bypassing the incremental-edit
+     *  debounce. Used for explicit bulk actions (Apply / Import / Reset). */
+    savePresetsNow() {
+        if (this.presetsLoaded) {
+            this.prefsPort?.savePresetSet(this.presetSet).subscribe({ error: () => { } });
+        }
+    }
+    /** The available colormap options (tree for the LUT dropdown). */
+    getColormapOptions() {
+        return COLORMAP_OPTIONS;
+    }
+    getColormap() {
+        return this.colormap$.asObservable();
+    }
+    /** Synchronous current value — for render paths that read it while building
+     *  a frame (e.g. Plotly's colorscale) rather than subscribing. */
+    currentColormap() {
+        return this.colormap$.value;
+    }
+    setColormap(colormap) {
+        this.colormap$.next(colormap);
+    }
+    getReverseScale() {
+        return this.reverseScale$.asObservable();
+    }
+    currentReverseScale() {
+        return this.reverseScale$.value;
+    }
+    setReverseScale(reverse) {
+        this.reverseScale$.next(reverse);
+    }
+    getImageMeta() {
+        return this.imageMeta$.asObservable();
+    }
+    /**
+     * Patch the physical pixel size (µm/pixel) onto the current image meta and
+     * re-emit, without touching the derived channels. The OSD tile descriptor
+     * (from the server's Bio-Formats `/tiles/info`) is authoritative for scaled
+     * images — `imageInfo.imageMeta` often carries no mpp — so the renderer feeds
+     * it here once the descriptor loads, letting area/scale consumers (the Region
+     * Editor) show µm²/mm² instead of px². No-op when neither axis is positive.
+     */
+    setPhysicalPixelSize(mppX, mppY) {
+        const hasX = (mppX ?? 0) > 0, hasY = (mppY ?? 0) > 0;
+        if (!hasX && !hasY)
+            return;
+        const cur = this.imageMeta$.value;
+        const meta = (cur && cur.length ? cur : [{}]).map((e) => ({ ...e }));
+        if (hasX)
+            meta[0].mppX = mppX;
+        if (hasY)
+            meta[0].mppY = mppY;
+        this.imageMeta$.next(meta);
+    }
+    setImageMeta(imageMeta) {
+        this.imageMeta$.next(imageMeta);
+        // Re-derive channels only when their structure changes (count), so a re-plot
+        // of the same image doesn't clobber the user's window/gamma edits.
+        const next = this.deriveChannels(imageMeta);
+        // Always refresh the reset baseline to the current image's derived defaults
+        // (names/colours can differ even at the same channel count).
+        this.defaultChannelStates = next.map((c) => ({ ...c }));
+        if (next.length !== this.channelStates$.value.length) {
+            this.channelStates$.next(next);
+        }
+    }
+    /** Channels for an image:
+     *   - RGB (rgbChannels ≥ 3) → Red/Green/Blue;
+     *   - multichannel fluorescence (channelCount > 1) → one channel per band,
+     *     named/tinted from the server `channelInfo` when present, else a palette;
+     *   - otherwise a single grayscale "Intensity" channel. */
+    deriveChannels(meta) {
+        const base = { min: 0, max: 255, gamma: 1, visible: true };
+        const m = meta?.[0];
+        if ((m?.rgbChannels ?? 1) >= 3) {
+            return [
+                { index: 0, name: 'Red', color: '#ff0000', ...base },
+                { index: 1, name: 'Green', color: '#00ff00', ...base },
+                { index: 2, name: 'Blue', color: '#0000ff', ...base },
+            ];
+        }
+        const count = m?.channelCount ?? 1;
+        if (count > 1) {
+            const info = m?.channelInfo;
+            // Fallback tints (Fiji-ish) when the server doesn't supply a color.
+            const palette = ['#ff0000', '#00ff00', '#0000ff', '#ffffff', '#00ffff', '#ff00ff', '#ffff00'];
+            return Array.from({ length: count }, (_, i) => ({
+                index: i,
+                name: info?.[i]?.name || `Channel ${i + 1}`,
+                color: info?.[i]?.color || palette[i % palette.length],
+                ...base,
+            }));
+        }
+        return [{ index: 0, name: 'Intensity', color: '#ffffff', ...base }];
+    }
+    // ── Channels & histogram state ───────────────────────────────────────
+    getChannelStates() {
+        return this.channelStates$.asObservable();
+    }
+    currentChannelStates() {
+        return this.channelStates$.value;
+    }
+    /** Patch one channel by index (immutable update). */
+    setChannelState(index, partial) {
+        const next = this.channelStates$.value.map((c) => c.index === index ? { ...c, ...partial, index: c.index } : c);
+        this.channelStates$.next(next);
+    }
+    /** Replace all channel states (used by auto/reset). */
+    setChannelStates(states) {
+        this.channelStates$.next(states);
+    }
+    /** Reset one channel's display window, gamma AND colour to the values derived
+     *  for the current image (full 0..255 range, gamma 1, the channel's default
+     *  tint). Falls back to neutral defaults if no baseline was captured. */
+    resetChannelState(index) {
+        const def = this.defaultChannelStates.find((c) => c.index === index);
+        this.setChannelState(index, {
+            min: def?.min ?? 0,
+            max: def?.max ?? 255,
+            gamma: def?.gamma ?? 1,
+            color: def?.color ?? '#ffffff',
+        });
+    }
+    getGrayscale() {
+        return this.grayscale$.asObservable();
+    }
+    currentGrayscale() {
+        return this.grayscale$.value;
+    }
+    setGrayscale(on) {
+        this.grayscale$.next(on);
+    }
+    getInvert() {
+        return this.invert$.asObservable();
+    }
+    currentInvert() {
+        return this.invert$.value;
+    }
+    setInvert(on) {
+        this.invert$.next(on);
+    }
+    /** Name→colour view of the current preset set (compat for backend renderers
+     *  that still read a Map). */
+    getClassificationColors() {
+        return new Map(this.presetSet.classes.map((c) => [c.name, c.color]));
+    }
+    /** Upsert a single class colour (used by the editor's per-class colour picker). */
+    setClassificationColor(label, color) {
+        this.upsertClass({ name: label, color });
+    }
+    // ── Annotation-class preset set accessors (jit-ui#70) ────────────────
+    getPresetSet() {
+        // Defensive copy: callers must not mutate the store's state in place —
+        // all changes go through setPresetSet()/upsertClass()/removeClass() so
+        // presetSet$ and persistence stay in sync.
+        return {
+            classes: this.presetSet.classes.map((c) => ({ ...c })),
+            fallbackPalette: [...this.presetSet.fallbackPalette],
+            autoPromote: this.presetSet.autoPromote,
+            matchMode: this.presetSet.matchMode,
+        };
+    }
+    getPresetSet$() {
+        return this.presetSet$.asObservable();
+    }
+    setPresetSet(set) {
+        this.presetSet = this.normalizePresetSet(set);
+        this.presetSet$.next(this.presetSet);
+        this.savePresetsNow(); // explicit bulk apply/import → persist immediately
+    }
+    /** Add or update a class (keyed by exact stored `name`). */
+    upsertClass(preset) {
+        const classes = [...this.presetSet.classes];
+        const i = classes.findIndex((c) => c.name === preset.name);
+        if (i >= 0)
+            classes[i] = { ...classes[i], ...preset };
+        else
+            classes.push({ ...preset });
+        this.presetSet = { ...this.presetSet, classes };
+        this.presetSet$.next(this.presetSet);
+        this.queuePresetSave();
+    }
+    removeClass(name) {
+        this.presetSet = { ...this.presetSet, classes: this.presetSet.classes.filter((c) => c.name !== name) };
+        this.presetSet$.next(this.presetSet);
+        this.queuePresetSave();
+    }
+    resetPresets() {
+        this.presetSet = defaultPresetSet();
+        this.presetSet$.next(this.presetSet);
+        this.savePresetsNow(); // explicit reset → persist immediately
+    }
+    /** Force a (debounced) write-back of the current preset set. */
+    persistPresets() {
+        this.queuePresetSave();
+    }
+    getActiveTool$() {
+        return this.activeTool$.asObservable();
+    }
+    getActiveTool() {
+        return this.activeTool$.value;
+    }
+    setActiveTool(tool) {
+        this.activeTool$.next(tool);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizerStore, deps: [{ token: i1.HttpClient, optional: true }, { token: PREFERENCES_PORT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizerStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizerStore, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PREFERENCES_PORT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"visualizer-store.service.js","sourceRoot":"","sources":["../../../../src/lib/store/visualizer-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional, Inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport { ClassPreset, PresetSet, defaultPresetSet } from '../models/class-preset';\nimport { PREFERENCES_PORT, PreferencesPort } from '../contracts/ports/preferences.port';\n\nimport { IImageMetadata } from '../contracts/image.contract';\nimport { IChannelState } from '../contracts/channel-histogram-api.contract';\nimport { COLORMAP_OPTIONS } from '../plot.utilities';\n\n/**\n * Backend-neutral store for the **visualization session** — the state that\n * describes *how* the current image is being viewed, independent of which\n * rendering backend (Plotly or OpenSeadragon) is on screen:\n *\n *  - the active colormap / LUT and its reverse-scale toggle,\n *  - the current image's physical metadata (µm/pixel etc.),\n *  - the classification label → colour map,\n *  - which on-canvas tool is currently active.\n *\n * Both backends read and write this single instance, so they stay in lock-step\n * regardless of which one is rendering. Previously this state lived inside\n * `PlotlyService`, which forced the OpenSeadragon backend to depend on the\n * Plotly service purely to read the shared colormap; this store removes that\n * coupling — neither backend owns the session state.\n *\n * NOTE: region *geometry* (the drawn shapes / per-image region cache) still\n * lives in `PlotlyService` for now; extracting it into a sibling region store\n * is a separate follow-up.\n */\n@Injectable({ providedIn: 'root' })\nexport class VisualizerStore {\n  // ── Colormap / LUT ───────────────────────────────────────────────────\n  // Default to inverted greys (dark background → bright signal), which reads as\n  // the natural grayscale for these microscopy images.\n  private readonly colormap$ = new BehaviorSubject<any>(\n    COLORMAP_OPTIONS[0].children.find((c: any) => c.label === 'Greys Inv') ?? COLORMAP_OPTIONS[0].children[0],\n  );\n  private readonly reverseScale$ = new BehaviorSubject<boolean>(false);\n\n  // ── Image metadata (physical pixel size, channels, …) ────────────────\n  private readonly imageMeta$ = new BehaviorSubject<IImageMetadata[]>([]);\n\n  // ── Channels & histogram display state ───────────────────────────────\n  // Per-channel display window/gamma/visibility/colour, derived from the image\n  // metadata on load (1 \"Intensity\" channel for grayscale; R/G/B for RGB). The\n  // Channels & Histogram pane edits these and both backends recolor live.\n  private readonly channelStates$ = new BehaviorSubject<IChannelState[]>([]);\n  // The derived defaults (full window, gamma 1, default tint) for the current\n  // image, kept so \"Reset\" can restore a channel's window/gamma/colour.\n  private defaultChannelStates: IChannelState[] = [];\n  // Grayscale display (ignore the channel tints) and inverted background — both\n  // global display flags, like the colormap.\n  private readonly grayscale$ = new BehaviorSubject<boolean>(false);\n  private readonly invert$ = new BehaviorSubject<boolean>(false);\n\n  // ── Annotation class presets (jit-ui#70) ─────────────────────────────\n  // The per-user, server-persisted source of truth for region colours, seeded\n  // from the historical default classes. Loaded/saved via the optional\n  // PreferencesPort (app-side adapter → jit-service). getClassificationColors()\n  // below stays as a name→colour view for the backends' region renderers.\n  private presetSet: PresetSet = defaultPresetSet();\n  private readonly presetSet$ = new BehaviorSubject<PresetSet>(this.presetSet);\n  private readonly savePresets$ = new Subject<void>();\n  private presetsLoaded = false;\n\n  // ── Active on-canvas tool ────────────────────────────────────────────\n  // Which tool the user has armed (pan, zoom, drawrect, wand, eraser, …) or\n  // null when none is active. The single source of truth for tool state across\n  // the toolbar and whichever backend's overlay handles the pointer.\n  private readonly activeTool$ = new BehaviorSubject<string | null>(null);\n\n  // Optional + null defaults so the store can be constructed both via DI and\n  // directly (`new VisualizerStore()` in unit tests); the LUT fetch and preset\n  // load/save no-op when their dependency is absent.\n  constructor(\n    @Optional() private readonly http: HttpClient | null = null,\n    @Optional() @Inject(PREFERENCES_PORT) private readonly prefsPort: PreferencesPort | null = null,\n  ) {\n    this.loadColormapLuts();\n    this.initPresetPersistence();\n  }\n\n  /**\n   * Resolve the colormap tree's LUT keys (e.g. \"GREYS_LUT\") to their colour\n   * arrays from a served JSON asset. The ~630 KB of LUT data lives outside the\n   * bundle (as `/assets/plotting/colormap-luts.json`) so it never enters the TS\n   * / webpack module graph — that data-in-source was the main driver of the\n   * build's >2 GB heap. Named Plotly scales (e.g. \"Viridis\") aren't keys in the\n   * JSON, so they're left untouched. The default LUT (\"Greys Inv\" → the Plotly\n   * \"Greys\" scale) needs no JSON, so the first render works before this resolves.\n   */\n  private loadColormapLuts(): void {\n    if (!this.http) return;\n    this.http.get<Record<string, [number, string][]>>('assets/plotting/colormap-luts.json').subscribe({\n      next: (luts) => {\n        for (const group of COLORMAP_OPTIONS as any[]) {\n          for (const child of group.children ?? []) {\n            const key = child?.data?.value;\n            if (typeof key === 'string' && luts[key]) child.data.value = luts[key];\n          }\n        }\n      },\n      error: () => { /* leave keys unresolved; named scales still work */ },\n    });\n  }\n\n  // ── Preset persistence (jit-ui#70) ───────────────────────────────────\n  private initPresetPersistence(): void {\n    // Debounced write-back so a burst of edits collapses into one PUT.\n    this.savePresets$.pipe(debounceTime(800)).subscribe(() => {\n      this.prefsPort?.savePresetSet(this.presetSet).subscribe({ error: () => { /* keep local copy */ } });\n    });\n    // Load the user's saved set (if any); otherwise keep the seeded defaults.\n    this.prefsPort?.loadPresetSet().subscribe({\n      next: (set) => {\n        if (set && Array.isArray(set.classes) && set.classes.length > 0) {\n          this.presetSet = this.normalizePresetSet(set);\n          this.presetSet$.next(this.presetSet);\n        }\n        this.presetsLoaded = true;\n      },\n      error: () => { this.presetsLoaded = true; },\n    });\n  }\n\n  private normalizePresetSet(set: PresetSet): PresetSet {\n    const defaults = defaultPresetSet();\n    // Clone the nested arrays/objects so outside callers can't mutate the store's\n    // internal state without going through setPresetSet()/upsertClass().\n    return {\n      classes: Array.isArray(set.classes) ? set.classes.map((c) => ({ ...c })) : [],\n      fallbackPalette:\n        Array.isArray(set.fallbackPalette) && set.fallbackPalette.length\n          ? [...set.fallbackPalette]\n          : defaults.fallbackPalette,\n      autoPromote: !!set.autoPromote,\n      matchMode: set.matchMode === 'normalized' ? 'normalized' : 'exact',\n    };\n  }\n\n  /** Queue a debounced save. No-ops until the initial load resolves (and when no port is bound). */\n  private queuePresetSave(): void {\n    if (this.presetsLoaded) this.savePresets$.next();\n  }\n\n  /** Persist the current preset set immediately, bypassing the incremental-edit\n   *  debounce. Used for explicit bulk actions (Apply / Import / Reset). */\n  private savePresetsNow(): void {\n    if (this.presetsLoaded) {\n      this.prefsPort?.savePresetSet(this.presetSet).subscribe({ error: () => { /* keep local copy */ } });\n    }\n  }\n\n  /** The available colormap options (tree for the LUT dropdown). */\n  getColormapOptions(): any {\n    return COLORMAP_OPTIONS;\n  }\n\n  getColormap(): Observable<any> {\n    return this.colormap$.asObservable();\n  }\n  /** Synchronous current value — for render paths that read it while building\n   *  a frame (e.g. Plotly's colorscale) rather than subscribing. */\n  currentColormap(): any {\n    return this.colormap$.value;\n  }\n  setColormap(colormap: any): void {\n    this.colormap$.next(colormap);\n  }\n\n  getReverseScale(): Observable<boolean> {\n    return this.reverseScale$.asObservable();\n  }\n  currentReverseScale(): boolean {\n    return this.reverseScale$.value;\n  }\n  setReverseScale(reverse: boolean): void {\n    this.reverseScale$.next(reverse);\n  }\n\n  getImageMeta(): Observable<IImageMetadata[]> {\n    return this.imageMeta$.asObservable();\n  }\n\n  /**\n   * Patch the physical pixel size (µm/pixel) onto the current image meta and\n   * re-emit, without touching the derived channels. The OSD tile descriptor\n   * (from the server's Bio-Formats `/tiles/info`) is authoritative for scaled\n   * images — `imageInfo.imageMeta` often carries no mpp — so the renderer feeds\n   * it here once the descriptor loads, letting area/scale consumers (the Region\n   * Editor) show µm²/mm² instead of px². No-op when neither axis is positive.\n   */\n  setPhysicalPixelSize(mppX?: number, mppY?: number): void {\n    const hasX = (mppX ?? 0) > 0, hasY = (mppY ?? 0) > 0;\n    if (!hasX && !hasY) return;\n    const cur = this.imageMeta$.value;\n    const meta = (cur && cur.length ? cur : [{} as IImageMetadata]).map((e) => ({ ...e }));\n    if (hasX) meta[0].mppX = mppX;\n    if (hasY) meta[0].mppY = mppY;\n    this.imageMeta$.next(meta);\n  }\n  setImageMeta(imageMeta: IImageMetadata[]): void {\n    this.imageMeta$.next(imageMeta);\n    // Re-derive channels only when their structure changes (count), so a re-plot\n    // of the same image doesn't clobber the user's window/gamma edits.\n    const next = this.deriveChannels(imageMeta);\n    // Always refresh the reset baseline to the current image's derived defaults\n    // (names/colours can differ even at the same channel count).\n    this.defaultChannelStates = next.map((c) => ({ ...c }));\n    if (next.length !== this.channelStates$.value.length) {\n      this.channelStates$.next(next);\n    }\n  }\n\n  /** Channels for an image:\n   *   - RGB (rgbChannels ≥ 3) → Red/Green/Blue;\n   *   - multichannel fluorescence (channelCount > 1) → one channel per band,\n   *     named/tinted from the server `channelInfo` when present, else a palette;\n   *   - otherwise a single grayscale \"Intensity\" channel. */\n  private deriveChannels(meta: IImageMetadata[]): IChannelState[] {\n    const base = { min: 0, max: 255, gamma: 1, visible: true };\n    const m = meta?.[0];\n    if ((m?.rgbChannels ?? 1) >= 3) {\n      return [\n        { index: 0, name: 'Red', color: '#ff0000', ...base },\n        { index: 1, name: 'Green', color: '#00ff00', ...base },\n        { index: 2, name: 'Blue', color: '#0000ff', ...base },\n      ];\n    }\n    const count = m?.channelCount ?? 1;\n    if (count > 1) {\n      const info = m?.channelInfo;\n      // Fallback tints (Fiji-ish) when the server doesn't supply a color.\n      const palette = ['#ff0000', '#00ff00', '#0000ff', '#ffffff', '#00ffff', '#ff00ff', '#ffff00'];\n      return Array.from({ length: count }, (_, i) => ({\n        index: i,\n        name: info?.[i]?.name || `Channel ${i + 1}`,\n        color: info?.[i]?.color || palette[i % palette.length],\n        ...base,\n      }));\n    }\n    return [{ index: 0, name: 'Intensity', color: '#ffffff', ...base }];\n  }\n\n  // ── Channels & histogram state ───────────────────────────────────────\n  getChannelStates(): Observable<IChannelState[]> {\n    return this.channelStates$.asObservable();\n  }\n  currentChannelStates(): IChannelState[] {\n    return this.channelStates$.value;\n  }\n  /** Patch one channel by index (immutable update). */\n  setChannelState(index: number, partial: Partial<IChannelState>): void {\n    const next = this.channelStates$.value.map((c) =>\n      c.index === index ? { ...c, ...partial, index: c.index } : c,\n    );\n    this.channelStates$.next(next);\n  }\n  /** Replace all channel states (used by auto/reset). */\n  setChannelStates(states: IChannelState[]): void {\n    this.channelStates$.next(states);\n  }\n  /** Reset one channel's display window, gamma AND colour to the values derived\n   *  for the current image (full 0..255 range, gamma 1, the channel's default\n   *  tint). Falls back to neutral defaults if no baseline was captured. */\n  resetChannelState(index: number): void {\n    const def = this.defaultChannelStates.find((c) => c.index === index);\n    this.setChannelState(index, {\n      min: def?.min ?? 0,\n      max: def?.max ?? 255,\n      gamma: def?.gamma ?? 1,\n      color: def?.color ?? '#ffffff',\n    });\n  }\n\n  getGrayscale(): Observable<boolean> {\n    return this.grayscale$.asObservable();\n  }\n  currentGrayscale(): boolean {\n    return this.grayscale$.value;\n  }\n  setGrayscale(on: boolean): void {\n    this.grayscale$.next(on);\n  }\n\n  getInvert(): Observable<boolean> {\n    return this.invert$.asObservable();\n  }\n  currentInvert(): boolean {\n    return this.invert$.value;\n  }\n  setInvert(on: boolean): void {\n    this.invert$.next(on);\n  }\n\n  /** Name→colour view of the current preset set (compat for backend renderers\n   *  that still read a Map). */\n  getClassificationColors(): Map<string, string> {\n    return new Map(this.presetSet.classes.map((c) => [c.name, c.color]));\n  }\n  /** Upsert a single class colour (used by the editor's per-class colour picker). */\n  setClassificationColor(label: string, color: string): void {\n    this.upsertClass({ name: label, color });\n  }\n\n  // ── Annotation-class preset set accessors (jit-ui#70) ────────────────\n  getPresetSet(): PresetSet {\n    // Defensive copy: callers must not mutate the store's state in place —\n    // all changes go through setPresetSet()/upsertClass()/removeClass() so\n    // presetSet$ and persistence stay in sync.\n    return {\n      classes: this.presetSet.classes.map((c) => ({ ...c })),\n      fallbackPalette: [...this.presetSet.fallbackPalette],\n      autoPromote: this.presetSet.autoPromote,\n      matchMode: this.presetSet.matchMode,\n    };\n  }\n  getPresetSet$(): Observable<PresetSet> {\n    return this.presetSet$.asObservable();\n  }\n  setPresetSet(set: PresetSet): void {\n    this.presetSet = this.normalizePresetSet(set);\n    this.presetSet$.next(this.presetSet);\n    this.savePresetsNow(); // explicit bulk apply/import → persist immediately\n  }\n  /** Add or update a class (keyed by exact stored `name`). */\n  upsertClass(preset: ClassPreset): void {\n    const classes = [...this.presetSet.classes];\n    const i = classes.findIndex((c) => c.name === preset.name);\n    if (i >= 0) classes[i] = { ...classes[i], ...preset };\n    else classes.push({ ...preset });\n    this.presetSet = { ...this.presetSet, classes };\n    this.presetSet$.next(this.presetSet);\n    this.queuePresetSave();\n  }\n  removeClass(name: string): void {\n    this.presetSet = { ...this.presetSet, classes: this.presetSet.classes.filter((c) => c.name !== name) };\n    this.presetSet$.next(this.presetSet);\n    this.queuePresetSave();\n  }\n  resetPresets(): void {\n    this.presetSet = defaultPresetSet();\n    this.presetSet$.next(this.presetSet);\n    this.savePresetsNow(); // explicit reset → persist immediately\n  }\n  /** Force a (debounced) write-back of the current preset set. */\n  persistPresets(): void {\n    this.queuePresetSave();\n  }\n\n  getActiveTool$(): Observable<string | null> {\n    return this.activeTool$.asObservable();\n  }\n  getActiveTool(): string | null {\n    return this.activeTool$.value;\n  }\n  setActiveTool(tool: string | null): void {\n    this.activeTool$.next(tool);\n  }\n}\n"]}