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

package/esm2022/lib/visualizer.component.mjs

@@ -0,0 +1,1597 @@
+import { ChangeDetectorRef, Component, EventEmitter, HostListener, Inject, Input, NgZone, Optional, Output, ViewChild } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { MessageService } from 'primeng/api';
+import { ContextMenu } from 'primeng/contextmenu';
+import { IMAGE_STATE_PORT } from './contracts/ports/image-state.port';
+import { Polygon, Rectangle, MultiPolygon } from './models/region';
+import { RegionOpsService } from './region-ops.service';
+import { VisualizerStore } from './store/visualizer-store.service';
+import { RenderOrchestrator, SliceScrubber } from './render-orchestrator';
+import { PlotType, isNapari3d, NAPARI_DEFAULT_DECIMATE, } from './contracts/plot-type';
+import { ViewerFeature } from './contracts/capabilities.contract';
+import { VISUALIZER } from './contracts/visualizer.contract';
+import { SAM_MODELS, getDefaultSamModelId, isSamModelReady } from './toolbar/segmentation/sam-model-registry';
+import { SamToolService } from './toolbar/segmentation/sam-tool.service';
+import { SamPointToolService } from './toolbar/segmentation/sam-point-tool.service';
+import { CellSegmentToolService } from './toolbar/segmentation/cell-segment-tool.service';
+import { ALL_TOOLBAR_TOOLS } from './contracts/toolbar-config';
+import { VIZ_CONFIG } from './contracts/viz-config';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "./store/visualizer-store.service";
+import * as i3 from "./toolbar/segmentation/sam-tool.service";
+import * as i4 from "./toolbar/segmentation/cell-segment-tool.service";
+import * as i5 from "./toolbar/segmentation/sam-point-tool.service";
+import * as i6 from "./region-ops.service";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/forms";
+import * as i9 from "primeng/button";
+import * as i10 from "primeng/tooltip";
+import * as i11 from "primeng/slider";
+import * as i12 from "primeng/dialog";
+import * as i13 from "primeng/contextmenu";
+import * as i14 from "primeng/progressbar";
+import * as i15 from "primeng/toast";
+import * as i16 from "./toolbar/toolbar.component";
+import * as i17 from "./region-editor/region-editor.component";
+import * as i18 from "./channel-histogram/channel-histogram.component";
+/** Per-instance plot-div id source. The mount element's id must be unique so two
+ *  live viewers (e.g. the main diagram + a modal preview) don't collide on the
+ *  same DOM id — `getElementById` would otherwise return whichever came first.
+ *  Styling hangs off the `.viz-plot` class instead of the id. */
+let plotInstanceSeq = 0;
+export class VisualizerComponent {
+    /** Per-instance toast key. MessageService is a global singleton, so two live
+     *  `<visualizer>` instances (main viewer + pipeline-dialog preview) sharing
+     *  one key would each render the same message — a duplicate toast. A unique
+     *  key per instance scopes the toast to the component that raised it. */
+    static { this.nextToastId = 0; }
+    /** Which toolbar groups to show. A partial override merges over the full set,
+     *  so `{ specialTools: false }` hides only that group. Defaults to everything. */
+    set toolbarTools(v) {
+        this._toolbarTools = { ...ALL_TOOLBAR_TOOLS, ...(v ?? {}) };
+    }
+    get toolbarTools() {
+        return this._toolbarTools;
+    }
+    /** A jit-service cache copy is actively in progress (determinate 0..99). Drives the cache
+     *  progress bar independently of `imgLoading` so the bar can't be dropped — or masked by the
+     *  "Sharpening preview..." overlay — mid-download if the loading flag flips early. */
+    get isCaching() {
+        return this.cacheProgress !== null && this.cacheProgress < 100;
+    }
+    /** LINE plot type shows the image + draggable line ROI + intensity inset. */
+    get isProfileMode() {
+        return this.selectedPlotType === PlotType.LINE;
+    }
+    /** True for the Image plot type, which renders as a natively pan/zoom-able
+     *  raster — so the backend-agnostic zoom/pan toolbar tools are hidden. The
+     *  component drives this off the plot type, not the active backend. */
+    get isImageView() {
+        return this.selectedPlotType === PlotType.IMAGE;
+    }
+    constructor(state, plotService, messageService, ngZone, cdr, session, samTool, cellSegmentTool, samPointTool, regionOps, vizConfig) {
+        this.state = state;
+        this.plotService = plotService;
+        this.messageService = messageService;
+        this.ngZone = ngZone;
+        this.cdr = cdr;
+        this.session = session;
+        this.samTool = samTool;
+        this.cellSegmentTool = cellSegmentTool;
+        this.samPointTool = samPointTool;
+        this.regionOps = regionOps;
+        this.vizConfig = vizConfig;
+        this.isStackEvent = new EventEmitter(false);
+        this.isGrayscaleEvent = new EventEmitter(false);
+        this._toolbarTools = ALL_TOOLBAR_TOOLS;
+        /** Expose test-only plot modes in the selector (e.g. the napari `Image`
+         *  mode, otherwise hidden). The host app sets this from a `?test=1` URL
+         *  toggle. Off by default, so production users never see them. */
+        this.testMode = false;
+        /** Image-smoothing state for the toolbar's Smoothen toggle (OSD only).
+         *  Defaults to `false` so OSD shows raw pixels (nearest-neighbour). */
+        this.imageSmoothingEnabled = false;
+        this.loadingMessage = 'Loading image...';
+        this.zoom = false;
+        this.unsub = new Subject();
+        this.previewSubscription = new Subscription();
+        this.stackLoading = false;
+        this.imgLoading = false;
+        this.loadingPercentage = 0;
+        // Non-null (0..100) while jit-service is copying the source file into the
+        // local cache PVC on first click. When set, the loading overlay swaps the
+        // spinner for a determinate progress bar with a "Caching image" message.
+        this.cacheProgress = null;
+        // True between the small-tier render landing and the large-tier render
+        // landing in the multi-tier rendering path. The template uses this to
+        // overlay a translucent spinner on top of the blurry small-tier image so
+        // the user doesn't mistake it for the final preview.
+        this.sharpening = false;
+        this.running = false;
+        this.zIndex = 0;
+        this.maxIndex = 0;
+        this.contextMenuItems = [];
+        this.activeDragMode = null;
+        /** Whether a region action is available to undo (jit-ui#85). Mirrors the
+         *  shared RegionStore's history depth; drives the toolbar Undo button. */
+        this.canUndoRegion = false;
+        /** Whether an undone region action is available to redo (jit-ui#85). */
+        this.canRedoRegion = false;
+        /** Custom-threshold Simplify dialog (jit-ui#85). */
+        this.displaySimplifyDialog = false;
+        this.simplifyThreshold = 3;
+        /** Current region selection (array indices) — mirrored from the store so the
+         *  context-menu region actions can read it synchronously (jit-ui#85). */
+        this.selectedIndices = [];
+        /** Wand sensitivity — higher = stricter (smaller selection). Matches QuPath default. */
+        this.wandSensitivity = 2.0;
+        /** Brush diameter in image-pixel coordinates (drives the painted disc size). */
+        this.brushSize = 40;
+        /** SAM model picker options + current selection (jit-ui#90 P1). Only models
+         *  with a hosted ONNX pair (configured via setSamModelUrls at app init) are
+         *  offered, so the picker can't select a model that can't run. */
+        this.samModels = SAM_MODELS.filter(isSamModelReady).map((m) => ({ id: m.id, label: m.label }));
+        this.samModelId = getDefaultSamModelId();
+        /** SAM download/segment toast state (bound by the `sam` p-toast template). */
+        this.samStatus = '';
+        this.samProgress = 0; // 0..100, encoder download
+        this.samDownloading = false;
+        this.samBusy = false; // any SAM work in flight (drives the indeterminate spinner)
+        /** Whether the shared `sam` toast is currently shown (avoids stacking it on
+         *  every point click, which re-runs inference). */
+        this.samToastShown = false;
+        this.samToastKey = `sam-${VisualizerComponent.nextToastId++}`;
+        /** Subscriptions to the point tool's live feeds (status/busy/download). */
+        this.samPointSub = new Subscription();
+        /** Vertex eraser radius in image-pixel coordinates. */
+        this.vertexEraserRadius = 20;
+        this.reversescale = false;
+        /** Channels & Histogram dialog visibility (opened from the toolbar). */
+        this.showChannelHistogram = false;
+        /** Region Editor dialog visibility (opened from the toolbar). */
+        this.showRegionEditor = false;
+        /** Region Editor dialog width. On open it is set to the configured host
+         *  element's current width, or — when no selector is configured / the element
+         *  isn't found — to a quarter of the page (see openRegionEditor). */
+        this.regionEditorWidth = '25vw';
+        this.stackOptions = [
+            { name: 'Single image', val: 'false' },
+            { name: 'Stack', val: 'true' },
+        ];
+        this.selectedStackOption = this.stackOptions[0];
+        this.plotDivName = `viz-plot-${plotInstanceSeq++}`;
+        this.plotType = PlotType.IMAGE;
+        this.isHeatmap = true;
+        this.activeSurface3dMode = 'turntable';
+        /** Whether the napari 3D coordinate-axes / scale gizmo is shown (volume/isosurface). */
+        this.axesVisible = true;
+        this.wireframeActive = false;
+        /** napari 3D decimate factor (1 = Full … 8 = ⅛; default ½); changing it re-plots. */
+        this.resolutionScale = NAPARI_DEFAULT_DECIMATE;
+        /** Plot types the active backend advertises (3D gated by capability). */
+        this.plotTypeOptions = [];
+        this.selectedPlotType = PlotType.IMAGE;
+        /** Floating intensity-profile inset (LINE mode). */
+        this.intensityInsetDiv = 'intensity-inset-plot';
+        this.profilePanelPos = { x: 20, y: 70 };
+        this.profilePanelDragging = false;
+        this.profilePanelStart = { mx: 0, my: 0, x: 0, y: 0 };
+        /** Toolbar docking: docked across the top by default; dragging its handle
+         *  detaches it into a floating, movable window (frees the top row for the
+         *  visualization). */
+        this.toolbarFloating = false;
+        this.toolbarPos = { x: 8, y: 8 };
+        this.toolbarDragging = false;
+        this.toolbarStart = { mx: 0, my: 0, x: 0, y: 0 };
+        this.latestProfiles = [];
+        /** Drives the intensity inset panel's visibility — true whenever any
+         *  intensity-profile line exists (independent of the current plot type). */
+        this.hasProfiles = false;
+        /** Isosurface band as a 0–255 slider position, mapped onto the volume's real
+         *  intensity range by the renderer. Defaults to the full range. */
+        this.isoRange = [0, 255];
+        /** Debounced z-slice scrubbing (see SliceScrubber — refactoring plan Step 7). */
+        this.scrubber = new SliceScrubber((z) => {
+            this.plotService.setZIndex(z);
+            // In a per-slice z-stack session the store swaps the live region set to this
+            // slice (preserving edits made on the previous one); outside stack mode this
+            // just records the slice, leaving single-plane regions untouched (jit-ui#93).
+            this.plotService.setDisplaySlice(z);
+        });
+        this.colormapsOptions = plotService.getColormapOptions();
+        this.computePlotTypeOptions();
+    }
+    /**
+     * Plot types offered in the selector for the current image:
+     *  - Outside **test mode**, only the curated default set (descriptors with a
+     *    `productionLabel`) is offered, shown under suffix-free names — Image,
+     *    Heatmap, Contour and the napari Surface / Volume / Isosurface. Test mode
+     *    exposes every backend's type under its full (backend-suffixed) label.
+     *  - 3D types hidden when the backend can't render a 3D scene.
+     *  - stack-only types (volume, isosurface) hidden unless the file is a stack —
+     *    a volume needs multiple z-slices.
+     *  - scalar-intensity types (contour, surface, isosurface) hidden for RGB
+     *    images — they map a single intensity per pixel. Image and Heatmap render
+     *    any image.
+     */
+    computePlotTypeOptions() {
+        const caps = this.plotService.capabilities;
+        const isStack = !!this.imageInfo?.isStack;
+        const isGrayscale = !!this.imageInfo?.isGrayscale;
+        this.plotTypeOptions = this.plotService.getPlotTypeDescriptors()
+            .filter((d) => {
+            // Outside test mode, only the curated set (those with a productionLabel)
+            // is offered; test mode exposes every backend's type.
+            if (!this.testMode && !d.productionLabel)
+                return false;
+            if (d.dimensions === '3d' && !caps.has(ViewerFeature.Surface3D))
+                return false;
+            if (d.requiresStack && !isStack)
+                return false;
+            if (d.requiresGrayscale && !isGrayscale)
+                return false;
+            return true;
+        })
+            // Default selector shows the suffix-free productionLabel; test mode keeps
+            // the full backend-suffixed label so same-named modes stay distinguishable.
+            .map((d) => (this.testMode ? d : { ...d, label: d.productionLabel }));
+    }
+    ngOnChanges(changes) {
+        // The constructor computes the options with testMode still at its default;
+        // recompute once the host binds it (and on any later change) so the selector
+        // reflects test mode immediately, without waiting for an image to (re)load.
+        if (changes['testMode']) {
+            this.computePlotTypeOptions();
+            // If test mode is turned off while a test-only type (e.g. NAPARI_IMAGE) is
+            // active, that type is no longer offered — fall back to Image.
+            this.reconcileSelectedPlotType();
+        }
+    }
+    /** If the active plot type is no longer in the offered options (e.g. test mode
+     *  turned off while a test-only type was active, or a scalar type carried onto
+     *  an RGB image), fall back to the default 2D Image view. */
+    reconcileSelectedPlotType() {
+        if (!this.plotTypeOptions.some((d) => d.type === this.selectedPlotType)) {
+            this.selectedPlotType = PlotType.IMAGE;
+            this.plotType = PlotType.IMAGE;
+            this.isHeatmap = true;
+            this.plotService.setPlotType(PlotType.IMAGE);
+        }
+    }
+    ngOnInit() {
+        this.state.setDiagram(this);
+        this.selectedColormap =
+            this.colormapsOptions[0].children.find((c) => c.label === 'Greys Inv') ??
+                this.colormapsOptions[0].children[0];
+        this.stackOptions = [
+            { name: 'Single image', val: 'false' },
+            { name: 'Stack', val: 'true' },
+        ];
+        this.selectedStackOption = this.stackOptions[0];
+        this.autoscaleSubscription = this.plotService.getAutoscaleEvent().subscribe(() => {
+            // reset the image mode to single image
+            this.selectedStackOption = { name: 'Single image', val: 'false' };
+            this.activeDragMode = null;
+            this.session.setActiveTool(null);
+        });
+        this.imageLoadingSubscription = this.state.isImageLoading$().subscribe((isImageLoading) => {
+            this.imgLoading = isImageLoading;
+        });
+        // Undo availability (jit-ui#85): the shared RegionStore emits whenever its
+        // history depth changes; greys out the toolbar Undo button accordingly.
+        this.plotService
+            .getCanUndo$()
+            .pipe(takeUntil(this.unsub))
+            .subscribe((canUndo) => {
+            this.canUndoRegion = canUndo;
+            this.cdr.detectChanges();
+        });
+        this.plotService
+            .getCanRedo$()
+            .pipe(takeUntil(this.unsub))
+            .subscribe((canRedo) => {
+            this.canRedoRegion = canRedo;
+            this.cdr.detectChanges();
+        });
+        // Mirror the region selection so the right-click action group (jit-ui#85)
+        // can read it synchronously when the menu is built.
+        this.plotService
+            .getSelectedShapeIndices$()
+            .pipe(takeUntil(this.unsub))
+            .subscribe((indices) => {
+            this.selectedIndices = indices || [];
+        });
+        // Interactive point-prompt segmentation runs inside the renderer on each
+        // click; surface its live status + download progress in the shared `sam`
+        // toast so the user sees it working (the first click pulls the encoder).
+        this.samPointSub.add(this.samPointTool.progress$.subscribe((f) => {
+            this.samDownloading = f >= 0 && f < 1;
+            if (f >= 0)
+                this.samProgress = Math.min(100, Math.round(f * 100));
+            this.cdr.detectChanges();
+        }));
+        this.samPointSub.add(this.samPointTool.status$.subscribe((m) => {
+            this.samStatus = m;
+            this.cdr.detectChanges();
+        }));
+        this.samPointSub.add(this.samPointTool.busy$.subscribe((busy) => {
+            this.samBusy = busy;
+            if (busy)
+                this.showSamToast('SAM point segmentation');
+            this.cdr.detectChanges();
+        }));
+        this.plotService.getStackLoadingProgress().subscribe((loadingProgress) => {
+            this.loadingPercentage = loadingProgress;
+        });
+        this.plotService.isStackLoading().subscribe((stackLoading) => {
+            this.stackLoading = stackLoading;
+        });
+        this.plotWidthSubscription = this.state.getPanelWidth$().subscribe(() => {
+            this.plotService.relayout();
+            // The intensity inset is a separate Plotly chart in a floating panel; reflow
+            // it to its current size when the canvas resizes, else it keeps the stale
+            // size and blanks out. Defer a tick so the panel layout has settled.
+            if (this.hasProfiles) {
+                setTimeout(() => this.renderIntensityInset(), 0);
+            }
+        });
+        this.imgLoadingMessageSubscription = this.state.getImageLoadingMessage$().subscribe((message) => {
+            this.loadingMessage = message;
+        });
+        this.state
+            .getCacheProgress$()
+            .pipe(takeUntil(this.unsub))
+            .subscribe((progress) => {
+            this.cacheProgress = progress;
+        });
+        this.isZoomSubscription = this.state.isZoom$().subscribe((zoom) => {
+            this.zoom = zoom;
+        });
+        this.filenameSubscription = this.state.getFilename$().subscribe((filename) => {
+            if (filename) {
+                this.fileName = filename;
+            }
+        });
+        this.plotService.getColormap().subscribe((colormap) => {
+            this.selectedColormap = colormap;
+        });
+        this.plotService.getReverseScale().subscribe((reversescale) => {
+            this.reversescale = reversescale;
+        });
+        this.intensityProfileSub = this.plotService.getIntensityProfile$().subscribe((profiles) => {
+            this.latestProfiles = profiles;
+            this.hasProfiles = profiles.length > 0;
+            // The panel div is behind *ngIf="hasProfiles". detectChanges() materializes
+            // it synchronously (the subscription may fire outside Angular's zone — e.g.
+            // from an OSD drag — so CD wouldn't run on its own). Then render on the next
+            // animation frame, AFTER the browser lays the panel out: a synchronous draw
+            // hits a zero-size container on first create and Plotly keeps that size, so
+            // the inset stays blank and live updates redraw into the same zero box.
+            this.cdr.detectChanges();
+            requestAnimationFrame(() => this.renderIntensityInset());
+        });
+        // When the OSD view settles at a new zoom/pan, re-sample the intensity lines
+        // from a crop of the visible region so the inset reflects the zoom-level
+        // resolution (Plotly's own high-def zoom updates the sampling cache inline).
+        this.viewportChangeSub = this.plotService.getViewportChange$().subscribe((roi) => {
+            if (this.hasProfiles && this.isImageView) {
+                this.plotService.refreshIntensitySamplingForRoi(roi.x, roi.y, roi.width, roi.height, this.zIndex);
+            }
+        });
+        this.previewSubscription = this.state.getImageInfo$().subscribe({
+            next: (imgInfo) => {
+                if (imgInfo) {
+                    this.imageInfo = imgInfo;
+                    // Stack-only plot types (isosurface, scatter3d) depend on whether this
+                    // file is a stack — recompute the selector options.
+                    this.computePlotTypeOptions();
+                    // If the active plot type isn't valid for this image (e.g. a scalar
+                    // type like Contour carried over to an RGB image), fall back to Image.
+                    this.reconcileSelectedPlotType();
+                    // reset stack options selection
+                    this.selectedStackOption = imgInfo.showStack ? this.stackOptions[1] : this.stackOptions[0];
+                    this.isGrayscaleEvent.emit(this.imageInfo.isGrayscale);
+                    this.isStackEvent.emit(this.imageInfo.isStack);
+                    // Reset to the default 2D Image view when a different image is
+                    // selected while a 3D type is active.
+                    if (!this.isHeatmap && imgInfo.fileName !== this.loadedFileName) {
+                        this.isHeatmap = true;
+                        this.plotType = PlotType.IMAGE;
+                        this.selectedPlotType = PlotType.IMAGE;
+                        this.plotService.setPlotType(this.plotType);
+                        this.activeSurface3dMode = 'turntable';
+                    }
+                    this.loadedFileName = imgInfo.fileName;
+                    this.plotService.setImageMeta(this.imageInfo.imageMeta);
+                    const urls = imgInfo.urls;
+                    if (!this.running) {
+                        // image size — measure the plot div directly so the toolbar height is excluded
+                        const plotDiv = document.getElementById(this.plotDivName);
+                        const screenHeight = plotDiv?.offsetHeight || 500;
+                        if (urls) {
+                            this.plotService.reset();
+                            this.stackLoading = imgInfo.isStack && imgInfo.showStack;
+                            // set max index of stack — computed before updateZIndex so a
+                            // fresh stack (shorter or longer than whatever was previously
+                            // loaded) clamps against ITS bounds, not the stale ones.
+                            // One URL per slice (0-indexed), so the last reachable index is
+                            // length-1 — earlier `length-2` dropped the final slice.
+                            this.maxIndex = urls.length > 1 ? urls.length - 1 : 0;
+                            // One-shot hint: jump straight to a specific slice (e.g. the
+                            // file the user actually clicked within a numbered series).
+                            // Consumed immediately so redelivering the same ImageInfo later
+                            // (a plot-type switch, reloadAndPlot) doesn't reset the user's
+                            // current scrub position back to it.
+                            if (imgInfo.initialZIndex !== undefined) {
+                                this.zIndex = imgInfo.initialZIndex;
+                                imgInfo.initialZIndex = undefined;
+                            }
+                            // make sure the zindex is within bounds
+                            this.updateZIndex(urls);
+                            this.running = true;
+                            // Multi-tier rendering (small blurry tier first, then sharpen in
+                            // place) — sequencing lives in RenderOrchestrator; this component
+                            // supplies the phase render and owns the UI flags via callbacks.
+                            // 3D plot types render single-pass: the in-place large pass doesn't
+                            // rebuild a 3D gl-mesh isosurface, so the sharpen step blanked it.
+                            const hasSmallTier = this.isHeatmap &&
+                                (imgInfo.smallUrls?.length ?? 0) === urls.length &&
+                                (imgInfo.smallUrls?.length ?? 0) > 0;
+                            const smallImgInfo = hasSmallTier ? { ...imgInfo, urls: imgInfo.smallUrls } : null;
+                            // Enter per-slice stack mode with the given slice→regions map and
+                            // seed the "previous shapes" from the now-live slice. enterStackMode
+                            // makes zIndex's slice live and resets undo (jit-ui#93).
+                            const enterStack = (slices, layout) => {
+                                this.plotService.enterStackMode(slices, this.zIndex, layout);
+                                const shapes = this.plotService
+                                    .getRegions()
+                                    .map((region) => region.getShape(this.plotService.getShowShapeLabel()));
+                                this.plotService.setPreviousShapes(shapes);
+                            };
+                            const applyRoi = () => {
+                                // Folder stack: a stack of self-contained per-slice files
+                                // (tiled === false; see loadSeriesAsStack). Each slice-file may
+                                // carry its own sibling "<stem>.geojson" (roiJsonStrs[z]), but a
+                                // fresh folder with none yet leaves roiJsonStrs undefined — key
+                                // off `tiled === false`, NOT roiJsonStrs, so an unannotated
+                                // folder stack still enters the per-slice-file layout (and saves
+                                // back one geojson per slice-file) rather than falling through to
+                                // the single-file combined path (jit-ui#93).
+                                if (imgInfo.isStack && imgInfo.tiled === false) {
+                                    const perSlice = imgInfo.roiJsonStrs;
+                                    const sliceCount = imgInfo.urls?.length ?? perSlice?.length ?? 0;
+                                    const slices = new Map();
+                                    for (let z = 0; z < sliceCount; z++) {
+                                        const json = perSlice?.[z] ?? null;
+                                        slices.set(z, json ? this.plotService.importRegions(json) : []);
+                                    }
+                                    enterStack(slices, 'per-slice-file');
+                                    return;
+                                }
+                                // Single-file z-stack: one sibling geojson holding every slice's
+                                // regions indexed by QuPath's geometry.plane.z. Enter per-slice
+                                // mode (saving back one combined z-indexed geojson) when the
+                                // geojson actually carries slice indices, or when there's nothing
+                                // yet to author against. A legacy geojson whose regions are all on
+                                // the default plane stays global (shown on every slice) so
+                                // existing single-plane annotations aren't confined to slice 0.
+                                const roiJson = imgInfo.roiJsonStr;
+                                if (imgInfo.isStack) {
+                                    const regions = roiJson ? this.plotService.importRegions(roiJson) : [];
+                                    const hasSliceInfo = regions.some((r) => (r.z ?? 0) !== 0);
+                                    if (!roiJson || hasSliceInfo) {
+                                        const slices = new Map();
+                                        for (const r of regions) {
+                                            const z = r.z ?? 0;
+                                            const bucket = slices.get(z);
+                                            if (bucket)
+                                                bucket.push(r);
+                                            else
+                                                slices.set(z, [r]);
+                                        }
+                                        enterStack(slices, 'combined');
+                                        return;
+                                    }
+                                }
+                                // Single-plane image (or a legacy global z-stack geojson): one
+                                // region set for the whole image.
+                                if (roiJson) {
+                                    const regions = this.plotService.importRegions(roiJson);
+                                    this.plotService.setRegions(regions);
+                                    const shapes = regions.map((region) => region.getShape(this.plotService.getShowShapeLabel()));
+                                    this.plotService.setPreviousShapes(shapes);
+                                }
+                                // Loading an image's saved ROIs is not a user edit — start the
+                                // undo history fresh so the first undo can't wipe them (jit-ui#85).
+                                this.plotService.resetUndoHistory();
+                            };
+                            let overlayReleased = false;
+                            const releaseOverlay = () => {
+                                if (overlayReleased)
+                                    return;
+                                overlayReleased = true;
+                                if (imgInfo.isStack && imgInfo.showStack)
+                                    this.stackLoading = false;
+                                this.state.setImageLoading(false);
+                            };
+                            new RenderOrchestrator({
+                                // inPlace=true updates the existing render instead of rebuilding
+                                // it, so the canvas doesn't blank during the small→large swap.
+                                renderPhase: (phaseInfo, inPlace) => this.plotService.load(phaseInfo, this.zIndex).then((loadedImage) => {
+                                    // Guard against a newer click reaching us mid-render.
+                                    if (phaseInfo.fileName !== loadedImage.filename)
+                                        return null;
+                                    return this.plotService.plot(this.plotDivName, loadedImage, phaseInfo, screenHeight, this.plotType, inPlace);
+                                }),
+                                smallShown: () => {
+                                    // If the file is still being cached/prepared server-side, keep the full
+                                    // cache-progress overlay up instead of dropping to the translucent "Sharpening
+                                    // preview..." spinner over a blank canvas (a large uncached image renders its
+                                    // small preview before its tiles exist). finished() releases the overlay once
+                                    // the real render lands.
+                                    if (this.isCaching)
+                                        return;
+                                    // Small tier on screen — drop the full overlay but keep a translucent spinner so
+                                    // the blurry render isn't mistaken for the final image.
+                                    releaseOverlay();
+                                    this.sharpening = true;
+                                },
+                                sharpenSettled: () => {
+                                    this.sharpening = false;
+                                },
+                                finished: (_viaSmall, logTag) => {
+                                    // Idempotent — releases now if smallShown deferred it (caching) or was skipped.
+                                    releaseOverlay();
+                                    this.running = false;
+                                    applyRoi();
+                                    console.log(logTag);
+                                },
+                                sharpenFailed: (err) => {
+                                    // The small tier stays on screen as the fallback — tell the
+                                    // user the sharper version isn't coming.
+                                    const msg = err?.error?.message || err?.message || err?.statusText || String(err);
+                                    this.messageService.add({
+                                        key: 'center-toast',
+                                        severity: 'warn',
+                                        summary: 'Preview not sharpened',
+                                        detail: `The full-resolution preview did not load (${msg}). The low-resolution preview is still shown. Try clicking the image again.`,
+                                    });
+                                    this.running = false;
+                                    applyRoi();
+                                },
+                            }).render(imgInfo, smallImgInfo);
+                        }
+                    }
+                }
+            },
+            error: (err) => {
+                const msg = err?.error?.message || err?.message || err?.statusText || String(err);
+                console.error('Error occured when getting image info', err);
+                this.messageService.add({
+                    key: 'center-toast',
+                    sticky: true,
+                    severity: 'error',
+                    summary: 'An error occured',
+                    detail: `The following error occured while getting image info: ${msg}.
+                   Please try to open the image again through the file navigator.`,
+                });
+                this.stackLoading = false;
+                this.state.setImageLoading(false);
+                this.running = false;
+                this.plotService.reset();
+            },
+        });
+    }
+    ngAfterViewInit() {
+        this.plotContextMenuListener = (event) => {
+            const plotEl = document.getElementById(this.plotDivName);
+            if (!plotEl?.contains(event.target))
+                return;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            this.ngZone.run(() => {
+                this.contextMenuItems = this.buildContextMenuItems();
+                this.cdr.detectChanges();
+                this.contextMenu.show(event);
+            });
+        };
+        window.addEventListener('contextmenu', this.plotContextMenuListener, true);
+        this.keydownListener = (event) => {
+            const target = event.target;
+            if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable)
+                return;
+            // SAM point mode: Enter commits the object, Esc clears the prompt.
+            if (this.activeDragMode === 'samPoint' && (event.key === 'Enter' || event.key === 'Escape')) {
+                this.ngZone.run(() => {
+                    if (event.key === 'Enter')
+                        this.plotService.commitSamPoints();
+                    else
+                        this.plotService.clearSamPoints();
+                    this.hideSamToast(); // prompt resolved → dismiss the status toast
+                });
+                return;
+            }
+            // Region history (jit-ui#85): Ctrl/Cmd+Z undoes; Ctrl/Cmd+Shift+Z or
+            // Ctrl/Cmd+Y redoes.
+            if (event.ctrlKey || event.metaKey) {
+                const k = event.key.toLowerCase();
+                if (k === 'z' && !event.shiftKey) {
+                    event.preventDefault();
+                    this.ngZone.run(() => this.undoRegion());
+                    return;
+                }
+                if ((k === 'z' && event.shiftKey) || k === 'y') {
+                    event.preventDefault();
+                    this.ngZone.run(() => this.redoRegion());
+                    return;
+                }
+            }
+            if (event.key === 'Delete' || event.key === 'Backspace' || event.key === 'd' || event.key === 'D') {
+                this.ngZone.run(() => this.deleteRegion());
+            }
+            else if (event.key === '+' || event.key === '=') {
+                this.ngZone.run(() => this.zoomIn());
+            }
+            else if (event.key === '-' || event.key === '_') {
+                this.ngZone.run(() => this.zoomOut());
+            }
+            else if (event.key === 'p') {
+                this.ngZone.run(() => this.toggleDragMode('pan'));
+            }
+            else if (event.key === 'b') {
+                this.ngZone.run(() => this.toggleDragMode('zoomToBox'));
+            }
+            else if (event.key === 'r') {
+                this.ngZone.run(() => this.toggleDragMode('drawrect'));
+            }
+            else if (event.key === 'f') {
+                this.ngZone.run(() => this.toggleDragMode('drawclosedpath'));
+            }
+            else if (event.key === 'w') {
+                this.ngZone.run(() => this.toggleDragMode('wand'));
+            }
+            else if (event.key === 'e') {
+                this.ngZone.run(() => this.toggleDragMode('eraseVertex'));
+            }
+            else if (event.key === 's') {
+                this.ngZone.run(() => this.toggleDragMode('select'));
+            }
+            else if (event.key === 'l') {
+                this.ngZone.run(() => this.toggleDragMode('drawopenpath'));
+            }
+        };
+        window.addEventListener('keydown', this.keydownListener);
+        this.wheelListener = (event) => {
+            const plotEl = document.getElementById(this.plotDivName);
+            if (!plotEl?.contains(event.target))
+                return;
+            // The Image view handles scroll-zoom natively (it respects the scroll
+            // delta). Intercepting here would fire a fixed zoom step per wheel
+            // event — far too sensitive — so let the renderer own it.
+            if (this.isImageView)
+                return;
+            // 3D plot types (surface, scatter3d, isosurface) render in a Plotly scene
+            // that orbits/zooms natively on scroll. The 2D step-zoom doesn't apply and
+            // would throw (no xaxis on a scene), so let Plotly handle the wheel.
+            if (!this.isHeatmap)
+                return;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            if (event.deltaY < 0) {
+                this.ngZone.run(() => this.zoomIn());
+            }
+            else if (event.deltaY > 0) {
+                this.ngZone.run(() => this.zoomOut());
+            }
+        };
+        window.addEventListener('wheel', this.wheelListener, { capture: true, passive: false });
+        // Drag handling for the floating intensity-profile panel.
+        this.profileDragMoveListener = (e) => {
+            if (this.profilePanelDragging) {
+                this.ngZone.run(() => {
+                    this.profilePanelPos = {
+                        x: this.profilePanelStart.x + (e.clientX - this.profilePanelStart.mx),
+                        y: this.profilePanelStart.y + (e.clientY - this.profilePanelStart.my),
+                    };
+                });
+            }
+            else if (this.toolbarDragging) {
+                this.ngZone.run(() => {
+                    this.toolbarPos = {
+                        x: this.toolbarStart.x + (e.clientX - this.toolbarStart.mx),
+                        y: this.toolbarStart.y + (e.clientY - this.toolbarStart.my),
+                    };
+                });
+            }
+        };
+        this.profileDragUpListener = () => {
+            this.profilePanelDragging = false;
+            this.toolbarDragging = false;
+        };
+        window.addEventListener('mousemove', this.profileDragMoveListener);
+        window.addEventListener('mouseup', this.profileDragUpListener);
+        // On any window resize, reflow the intensity inset to its (fixed) panel size
+        // on the next frame, once layout has settled. Without this the inset can be
+        // left at a stale/zero size by a mid-reflow resize and stop showing.
+        this.profileResizeListener = () => {
+            if (!this.hasProfiles)
+                return;
+            requestAnimationFrame(() => this.renderIntensityInset());
+        };
+        window.addEventListener('resize', this.profileResizeListener);
+    }
+    onProfilePanelDragStart(e) {
+        this.profilePanelDragging = true;
+        this.profilePanelStart = {
+            mx: e.clientX,
+            my: e.clientY,
+            x: this.profilePanelPos.x,
+            y: this.profilePanelPos.y,
+        };
+        e.preventDefault();
+    }
+    /** Grab the toolbar handle: detach it into a floating window (if still docked)
+     *  and start dragging. */
+    onToolbarDragStart(e) {
+        if (!this.toolbarFloating) {
+            this.toolbarFloating = true;
+            this.toolbarPos = { x: 8, y: 8 };
+        }
+        this.toolbarDragging = true;
+        this.toolbarStart = {
+            mx: e.clientX,
+            my: e.clientY,
+            x: this.toolbarPos.x,
+            y: this.toolbarPos.y,
+        };
+        e.preventDefault();
+    }
+    /** Snap the floating toolbar back to its docked position across the top. */
+    dockToolbar() {
+        this.toolbarFloating = false;
+    }
+    /** Render the intensity inset chart from the latest profile data. The actual
+     *  charting is owned by the visualizer service — the component just decides
+     *  when (profile mode + a fresh profile). */
+    renderIntensityInset() {
+        if (!this.hasProfiles)
+            return;
+        this.plotService.renderIntensityInset(this.intensityInsetDiv, this.latestProfiles);
+    }
+    /** Toolbar "Intensity" group: add another line ROI (next bright colour). */
+    async addProfileLine() {
+        // Park the floating inset near the plot's top-right when the first line is
+        // added (it's position:fixed, so use viewport coords from the plot rect).
+        if (!this.hasProfiles) {
+            const rect = document.getElementById(this.plotDivName)?.getBoundingClientRect();
+            this.profilePanelPos = rect
+                ? { x: Math.max(10, rect.right - 300), y: rect.top + 10 }
+                : { x: 20, y: 70 };
+        }
+        // Image (OSD) mode: Plotly never rendered, so it has no pixel cache / extent.
+        // Load the current slice's frames for sampling + line placement first.
+        if (this.isImageView && this.imageInfo) {
+            await this.plotService.ensureIntensitySampling(this.imageInfo, this.zIndex);
+        }
+        const region = this.plotService.getIntensityControls()?.addProfileLine();
+        // Auto-select the new line on the active backend (Plotly handles / OSD
+        // highlight) so it's ready to move or delete immediately.
+        if (region) {
+            this.plotService.selectRegion(region);
+            // OSD only draws a selected region's handles in an edit mode, so a line in
+            // 'none' mode looks unselected. Switch to 'select' so the new line shows
+            // its endpoint handles and can be dragged/deleted right away.
+            if (this.isImageView && this.activeDragMode !== 'select') {
+                this.toggleDragMode('select');
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.scrubber.cancel();
+        this.samPointSub.unsubscribe();
+        if (this.plotContextMenuListener) {
+            window.removeEventListener('contextmenu', this.plotContextMenuListener, true);
+        }
+        if (this.keydownListener) {
+            window.removeEventListener('keydown', this.keydownListener);
+        }
+        if (this.wheelListener) {
+            window.removeEventListener('wheel', this.wheelListener, true);
+        }
+        if (this.profileDragMoveListener) {
+            window.removeEventListener('mousemove', this.profileDragMoveListener);
+        }
+        if (this.profileDragUpListener) {
+            window.removeEventListener('mouseup', this.profileDragUpListener);
+        }
+        if (this.profileResizeListener) {
+            window.removeEventListener('resize', this.profileResizeListener);
+        }
+        if (this.intensityProfileSub) {
+            this.intensityProfileSub.unsubscribe();
+        }
+        if (this.viewportChangeSub) {
+            this.viewportChangeSub.unsubscribe();
+        }
+        this.unsub.next();
+        this.unsub.complete();
+        if (this.previewSubscription) {
+            this.previewSubscription.unsubscribe();
+        }
+        if (this.plotWidthSubscription) {
+            this.plotWidthSubscription.unsubscribe();
+        }
+        if (this.imageLoadingSubscription) {
+            this.imageLoadingSubscription.unsubscribe();
+        }
+        if (this.imgLoadingMessageSubscription) {
+            this.imgLoadingMessageSubscription.unsubscribe();
+        }
+        if (this.isZoomSubscription) {
+            this.isZoomSubscription.unsubscribe();
+        }
+        if (this.autoscaleSubscription) {
+            this.autoscaleSubscription.unsubscribe();
+        }
+        if (this.filenameSubscription) {
+            this.filenameSubscription.unsubscribe();
+        }
+        this.plotService.unsubscribe();
+    }
+    hasRegions() {
+        // Use the contract's framework-neutral region accessor, not the raw
+        // Plotly-shaped getShapes() — the component only needs to know whether any
+        // region exists, and must not depend on a backend's wire format.
+        return this.plotService.getRegions().length > 0;
+    }
+    /**
+     * This method is called in mainFacade.configRequest() - DO NOT DELETE
+     */
+    getRegionPolygons() {
+        return this.plotService.getRegionPolygons();
+    }
+    /**
+     * Select the color scale type: called by the color scale select button
+     * @param event
+     */
+    toggleReverseScale() {
+        this.reversescale = !this.reversescale;
+        this.plotService.setReverseScale(this.reversescale);
+    }
+    /**
+     * Select a color map: called by the color map dropdown button
+     * @param colormapNode
+     */
+    selectColormap(colormapNode) {
+        if (!colormapNode.children) {
+            this.plotService.setColormap(colormapNode);
+        }
+    }
+    /** Open the Channels & Histogram dialog (toolbar button). */
+    openChannelHistogram() {
+        this.showChannelHistogram = true;
+    }
+    /** Open the Region Editor dialog (toolbar button). The editor stays linked to
+     *  this plotting instance through the root RegionStore singleton, so it works
+     *  the same as the former right-panel Regions tab. */
+    openRegionEditor() {
+        // Size the dialog to match the host's configured element (e.g. the app's
+        // right panel) at open time. Measured once — it intentionally does not
+        // track later browser/split resizes. Falls back to a quarter of the page
+        // when no selector is configured or the element isn't present.
+        const selector = this.vizConfig?.regionEditorWidthSelector;
+        const width = selector
+            ? document.querySelector(selector)?.getBoundingClientRect().width
+            : undefined;
+        this.regionEditorWidth = width && width > 0 ? `${Math.round(width)}px` : '25vw';
+        this.showRegionEditor = true;
+    }
+    /**
+     * Called by the stack/single image dropdown button
+     * @param showstack
+     */
+    selectStackOption(selectedStackOption) {
+        const showstack = selectedStackOption.val === 'true';
+        this.selectedStackOption = selectedStackOption;
+        console.log('selected stack option' + JSON.stringify(this.selectedStackOption));
+        this.stackLoading = showstack;
+        this.state.setImageLoading(!showstack);
+        // Stack mode is always a 2D heatmap — reset surface mode if active
+        if (!this.isHeatmap) {
+            this.isHeatmap = true;
+            this.plotType = PlotType.HEATMAP;
+            this.selectedPlotType = PlotType.HEATMAP;
+            this.plotService.setPlotType(this.plotType);
+        }
+        this.plotService.setShowStack(showstack);
+    }
+    updateZIndex(urls) {
+        if (this.zIndex > this.maxIndex) {
+            this.zIndex = this.maxIndex;
+        }
+        if (this.zIndex < 0) {
+            this.zIndex = 0;
+        }
+        if (urls) {
+            if (this.zIndex > urls?.length) {
+                this.zIndex = 0;
+                this.maxIndex = urls.length - 1;
+            }
+        }
+        this.plotService.setZIndex(this.zIndex);
+    }
+    /**
+     * Live z-slice scrub for the Image view: the renderer swaps the displayed
+     * slice in place (no re-mount), so dragging the slider steps through the
+     * stack the same way the heatmap frame slider does.
+     */
+    onZSlide(z) {
+        if (z === undefined)
+            return;
+        this.zIndex = z;
+        this.scrubber.commit(z);
+        // Keep the intensity inset in sync with the displayed slice (Image/OSD mode,
+        // where the profile sampler is fed from the loaded preview frames).
+        if (this.hasProfiles && this.isImageView && this.imageInfo) {
+            this.plotService.ensureIntensitySampling(this.imageInfo, z);
+        }
+    }
+    /**
+     * Live (debounced) scrub while dragging the Image-view z-slider: update the
+     * slice as the user drags, but coalesce rapid changes so we don't fire a
+     * slice swap on every pixel. The final value also lands via onZSlide (onSlideEnd).
+     */
+    onZScrub(z) {
+        if (z === undefined)
+            return;
+        this.zIndex = z;
+        this.scrubber.scrub(z);
+    }
+    /**
+     * Keyboard stack navigation: ←/→ step the z-slice in the Image view, the same
+     * way the slider does. Only active for a loaded stack in Image view, and
+     * ignored while a form field is focused so typing isn't hijacked. Up/Down are
+     * left to OpenSeadragon (panning).
+     */
+    onKeydown(e) {
+        if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight')
+            return;
+        if (!this.imageInfo?.isStack || !this.isImageView)
+            return;
+        const t = e.target;
+        if (t && (/^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName) || t.isContentEditable))
+            return;
+        // The slice slider handles arrows natively when focused (also a +1 step) —
+        // skip here so we don't double-step it.
+        if (t && (t.getAttribute('role') === 'slider' || t.closest('.p-slider')))
+            return;
+        e.preventDefault();
+        this.stepSlice(e.key === 'ArrowRight' ? 1 : -1);
+    }
+    /** Move the displayed slice by `delta`, clamped to the stack bounds. */
+    stepSlice(delta) {
+        const next = Math.min(this.maxIndex, Math.max(0, this.zIndex + delta));
+        if (next === this.zIndex)
+            return;
+        this.onZSlide(next);
+    }
+    reloadAndPlot() {
+        this.state.setImageLoading(true);
+        // Re-drive the render pipeline from the current image info (the source of
+        // truth, with real urls/fileName). Don't use plotService.reloadAndPlot():
+        // that rebuilds the info from the renderer's internal state, which can be
+        // stale (e.g. after switching plot type Image -> Heatmap) and re-emit
+        // empty/old urls, failing to hand the div over to the new renderer.
+        if (this.imageInfo) {
+            this.state.setImageInfo(this.imageInfo);
+        }
+        else {
+            this.plotService.reloadAndPlot();
+        }
+    }
+    cancelLoading() {
+        // Stop any in-flight frame streaming (napari-js volume/surface preload) so the fetch loops
+        // actually abort — clearing the flag alone only routed to Plotly and left napari fetching.
+        this.plotService.cancelLoading?.();
+        this.stackLoading = false;
+        this.imgLoading = false;
+        this.state.setImageLoading(false);
+        this.zIndex = 0;
+        this.plotService.setZIndex(this.zIndex);
+        this.running = false;
+        this.plotService.setStackLoading(false);
+    }
+    downloadImage() {
+        this.plotService.downloadImage();
+    }
+    autoscaleImage() {
+        this.plotService.autoscale();
+    }
+    /** Toolbar pixel/smooth toggle: flip smoothing and apply to the active backend. */
+    onToggleImageSmoothing() {
+        this.imageSmoothingEnabled = !this.imageSmoothingEnabled;
+        this.plotService.setImageSmoothingEnabled(this.imageSmoothingEnabled);
+    }
+    resetAxes() {
+        this.plotService.resetAxes();
+    }
+    toggleDragMode(mode) {
+        // Toggle off if the same mode is re-selected.
+        this.activeDragMode = this.activeDragMode === mode ? null : mode;
+        const active = this.activeDragMode;
+        // Record the armed tool in the shared session store.
+        this.session.setActiveTool(active);
+        // Region draw/select run through the renderer's region overlay.
+        this.plotService
+            .getRegionOverlay()
+            ?.setMode(this.isRegionMode(active) ? active : 'none');
+        // Viewport drag modes (pan/box-zoom). Region modes own the drag mode via
+        // the overlay, so don't also set one here.
+        if (!this.isRegionMode(active)) {
+            const viewportDrag = active === 'pan' || active === 'zoom';
+            this.plotService.setDragMode(viewportDrag ? active : false);
+        }
+        // On-canvas tool overlays.
+        this.plotService.setZoomToBoxMode(active === 'zoomToBox');
+        this.plotService.setWandMode(active === 'wand', { sensitivity: this.wandSensitivity });
+        this.plotService.setBrushMode(active === 'brush', { size: this.brushSize });
+        this.plotService.setSamPointMode(active === 'samPoint');
+        // Leaving point mode dismisses any lingering status toast.
+        if (active !== 'samPoint')
+            this.hideSamToast();
+        this.plotService.setVertexEraserMode(active === 'eraseVertex');
+        if (active === 'eraseVertex') {
+            this.plotService.setVertexEraserRadius(this.vertexEraserRadius);
+        }
+    }
+    /** Region draw/select/edit modes routed through the region overlay. The
+     *  The vertex tools (drawpolygon/addpoint/deletepoint/move) are
+     *  handled by the OpenSeadragon overlay; Plotly's overlay maps them to no-op. */
+    isRegionMode(mode) {
+        return (mode === 'drawrect' ||
+            mode === 'drawclosedpath' ||
+            mode === 'drawopenpath' ||
+            mode === 'select' ||
+            mode === 'drawpolygon' ||
+            mode === 'addpoint' ||
+            mode === 'deletepoint' ||
+            mode === 'move');
+    }
+    /** Live-update the isosurface as the range slider moves. The control is only
+     *  available when the active backend renders isosurfaces (ISOSURFACE mode). */
+    onIsoRangeChange(values) {
+        if (!values || values.length < 2)
+            return;
+        this.isoRange = values;
+        this.plotService.getIsosurfaceControls()?.setIsoRange(values[0], values[1]);
+    }
+    onWandSensitivityChange(value) {
+        if (value === undefined || !Number.isFinite(value))
+            return;
+        this.wandSensitivity = value;
+        this.plotService.setWandOptions({ sensitivity: value });
+    }
+    onBrushSizeChange(value) {
+        if (value === undefined || !Number.isFinite(value))
+            return;
+        this.brushSize = value;
+        this.plotService.setBrushOptions({ size: value });
+    }
+    onVertexEraserRadiusChange(value) {
+        if (value === undefined || !Number.isFinite(value))
+            return;
+        this.vertexEraserRadius = value;
+        this.plotService.setVertexEraserRadius(value);
+    }
+    zoomIn() {
+        this.plotService.zoomIn();
+    }
+    zoomOut() {
+        this.plotService.zoomOut();
+    }
+    deleteRegion() {
+        this.plotService.deleteActiveShape();
+    }
+    /** Undo the most recent region action (jit-ui#85). Up to 10 steps back. */
+    undoRegion() {
+        this.plotService.undo();
+    }
+    /** Redo the most recently undone region action (jit-ui#85). */
+    redoRegion() {
+        this.plotService.redo();
+    }
+    // ── Region set-operations on the current selection (jit-ui#85) ──────────
+    /** The currently-selected regions (live store instances). */
+    get selectedRegions() {
+        const all = this.plotService.getRegions();
+        return this.selectedIndices
+            .map((i) => all[i])
+            .filter((r) => !!r);
+    }
+    /** Regions eligible for set-ops: closed areas (rect / closed polygon /
+     *  multi-polygon), excluding intensity-profile lines. */
+    opEligible(regions) {
+        return regions.filter((r) => r.kind !== 'profile' && (r.bounds instanceof Rectangle ||
+            r.bounds instanceof MultiPolygon ||
+            (r.bounds instanceof Polygon && r.bounds.closed !== false)));
+    }
+    /** Image pixel dimensions for the raster ops; falls back to the selection's
+     *  extent when the image size isn't known (keeps clamping sane). */
+    opImageDims(regions) {
+        let [w, h] = this.imageInfo?.trueImageSize ?? [0, 0];
+        if (!(w > 0) || !(h > 0)) {
+            let maxX = 0, maxY = 0;
+            const scan = (xs, ys) => {
+                for (const x of xs)
+                    maxX = Math.max(maxX, x);
+                for (const y of ys)
+                    maxY = Math.max(maxY, y);
+            };
+            for (const r of regions) {
+                const b = r.bounds;
+                if (b instanceof Rectangle)
+                    scan([b.x + b.width], [b.y + b.height]);
+                else if (b instanceof Polygon)
+                    scan(b.xpoints, b.ypoints);
+                else if (b instanceof MultiPolygon)
+                    for (const p of b.polygons)
+                        scan(p.xpoints, p.ypoints);
+            }
+            w = Math.max(w, Math.ceil(maxX) + 2);
+            h = Math.max(h, Math.ceil(maxY) + 2);
+        }
+        return { w, h };
+    }
+    /** True when ≥2 eligible regions are selected (Merge available). */
+    get canMergeRegions() { return this.opEligible(this.selectedRegions).length >= 2; }
+    /** True when any selected region is multi-part (Ungroup available). */
+    get canUngroupRegions() { return this.selectedRegions.some((r) => this.regionOps.canUngroup(r)); }
+    /** True when ≥1 eligible region is selected (Inverse / Simplify available). */
+    get hasEligibleSelection() { return this.opEligible(this.selectedRegions).length >= 1; }
+    /** Select every region on the image (excludes intensity-profile lines). */
+    selectAllRegions() {
+        const all = this.plotService.getRegions();
+        const indices = [];
+        all.forEach((r, i) => { if (r.kind !== 'profile')
+            indices.push(i); });
+        this.plotService.setSelectedShapeIndices(indices);
+    }
+    /** Merge the selected regions into a single (possibly multi-part) region. */
+    mergeRegions() {
+        const sel = this.opEligible(this.selectedRegions);
+        if (sel.length < 2)
+            return;
+        const { w, h } = this.opImageDims(sel);
+        const merged = this.regionOps.merge(sel, w, h);
+        if (merged)
+            this.replaceRegions(sel, [merged]);
+    }
+    /** Split each selected multi-part region into one region per part. */
+    ungroupRegions() {
+        const sel = this.selectedRegions.filter((r) => this.regionOps.canUngroup(r));
+        if (sel.length === 0)
+            return;
+        const results = [];
+        for (const r of sel)
+            results.push(...this.regionOps.ungroup(r));
+        this.replaceRegions(sel, results);
+    }
+    /** Replace the selection with its inverse inside the image rectangle. */
+    inverseRegions() {
+        const sel = this.opEligible(this.selectedRegions);
+        if (sel.length === 0)
+            return;
+        const { w, h } = this.opImageDims(sel);
+        const inv = this.regionOps.inverse(sel, w, h);
+        if (!inv) {
+            this.messageService.add({
+                severity: 'warn', summary: 'Inverse',
+                detail: 'Nothing to invert — select one or more closed regions first.',
+            });
+            return;
+        }
+        this.replaceRegions(sel, [inv]);
+    }
+    /** Douglas–Peucker simplify each selected region by `thresholdPx`. */
+    simplifyRegions(thresholdPx) {
+        const sel = this.opEligible(this.selectedRegions);
+        if (sel.length === 0)
+            return;
+        this.replaceRegions(sel, sel.map((r) => this.regionOps.simplify(r, thresholdPx)));
+        this.displaySimplifyDialog = false;
+    }
+    /** Open the custom-threshold simplify dialog. */
+    openSimplifyDialog() { this.displaySimplifyDialog = true; }
+    /**
+     * Commit a set-op: drop the `remove` regions, append `add`, and select the
+     * results. Goes through setRegions so it's undo-tracked and re-rendered;
+     * profile lines and unselected regions are preserved.
+     */
+    replaceRegions(remove, add) {
+        if (add.length === 0)
+            return;
+        const removeSet = new Set(remove);
+        const kept = this.plotService.getRegions().filter((r) => !removeSet.has(r));
+        this.plotService.setRegions([...kept, ...add]); // mints ids on `add`, records undo
+        const stored = this.plotService.getRegions();
+        const sel = add.map((r) => stored.indexOf(r)).filter((i) => i >= 0);
+        this.plotService.setSelectedShapeIndices(sel);
+    }
+    /** Box-prompted SAM segmentation of the drawn rectangles (jit-ui#90). A sticky
+     *  `sam` toast shows live status + a download progress bar (first run pulls the
+     *  encoder, ~170 MB); it stays open until the run finishes (bar hits 100%). */
+    async segmentRegions() {
+        await this.runSegmentWithToast('SAM', this.samTool, () => this.plotService.segmentRectangles());
+    }
+    /** Auto-segment cells inside each drawn rectangle with cellpose-SAM, client-side
+     *  (jit-ui#90). Each box is cropped (browser slide-crop) then run through the
+     *  cellpose-js model; the same sticky `sam` toast + progress bar is reused. */
+    async segmentCellpose() {
+        await this.runSegmentWithToast('Cellpose', this.cellSegmentTool, () => this.plotService.segmentRectanglesCellpose());
+    }
+    /** Shared driver for the box-prompt segment tools: wires the tool's status +
+     *  download progress into the sticky `sam` toast, runs `op`, and reports the
+     *  region count. Keeps the toast open until the run settles (bar hits 100%). */
+    async runSegmentWithToast(label, tool, op) {
+        this.samStatus = 'Starting…';
+        this.samProgress = 0;
+        this.samDownloading = false;
+        this.samBusy = true;
+        const psub = tool.progress$.subscribe((f) => {
+            this.samDownloading = f >= 0 && f < 1;
+            if (f >= 0)
+                this.samProgress = Math.min(100, Math.round(f * 100));
+            this.cdr.detectChanges();
+        });
+        const ssub = tool.status$.subscribe((m) => {
+            if (m) {
+                this.samStatus = m;
+                this.cdr.detectChanges();
+            }
+        });
+        this.showSamToast(label);
+        try {
+            const n = await op();
+            this.messageService.add({
+                severity: n > 0 ? 'success' : 'warn',
+                summary: label,
+                detail: tool.status$.value || (n > 0 ? `Added ${n} region(s).` : 'No regions added.'),
+            });
+        }
+        catch (e) {
+            this.messageService.add({ severity: 'error', summary: `${label} failed`, detail: String(e) });
+        }
+        finally {
+            psub.unsubscribe();
+            ssub.unsubscribe();
+            this.hideSamToast();
+        }
+    }
+    /** Show the shared sticky `sam` toast once (idempotent — re-adding would stack
+     *  a new toast on every point click). */
+    showSamToast(summary) {
+        if (this.samToastShown)
+            return;
+        this.samToastShown = true;
+        this.messageService.add({ key: this.samToastKey, sticky: true, severity: 'info', summary });
+    }
+    /** Dismiss the shared `sam` toast and reset its progress/spinner state. */
+    hideSamToast() {
+        this.samToastShown = false;
+        this.samBusy = false;
+        this.samDownloading = false;
+        this.samProgress = 0;
+        this.messageService.clear(this.samToastKey);
+        this.cdr.detectChanges();
+    }
+    /** Pick the SAM model the segment tools use (jit-ui#90 P1). */
+    onSamModelChange(id) {
+        this.samModelId = id;
+        this.plotService.setSamModel(id);
+    }
+    /** Convert the selected region to a smooth bezier curve. */
+    toBezierRegion() {
+        this.plotService.getRegionOverlay()?.setSelectedBezier(true);
+    }
+    /** Convert the selected region back to a straight-edged polygon. */
+    toPolygonRegion() {
+        this.plotService.getRegionOverlay()?.setSelectedBezier(false);
+    }
+    /**
+     * Immediate region actions on the current selection (jit-ui#85): merge,
+     * ungroup, inverse, simplify, the Bézier conversions, and delete — the
+     * one-shot geometry transforms, grouped apart from the tool/mode toggles and
+     * shown only when something is selected. Each item is gated on what the
+     * selection supports.
+     */
+    buildRegionActionItems() {
+        const all = this.plotService.getRegions();
+        const selectable = all.filter((r) => r.kind !== 'profile');
+        if (selectable.length === 0)
+            return [];
+        const items = [];
+        // Select all — available whenever the image has regions, regardless of the
+        // current selection.
+        items.push({
+            label: 'Select all regions', icon: 'pi pi-check-square',
+            command: () => this.selectAllRegions(),
+        });
+        const selAll = this.selectedRegions;
+        if (selAll.length === 0)
+            return items;
+        const eligible = this.opEligible(selAll);
+        if (eligible.length >= 2) {
+            items.push({ label: 'Merge / group', icon: 'pi pi-link', command: () => this.mergeRegions() });
+        }
+        if (selAll.some((r) => this.regionOps.canUngroup(r))) {
+            items.push({ label: 'Ungroup', icon: 'pi pi-sitemap', command: () => this.ungroupRegions() });
+        }
+        if (eligible.length >= 1) {
+            items.push({ label: 'Inverse', icon: 'pi pi-clone', command: () => this.inverseRegions() }, {
+                label: 'Simplify', icon: 'pi pi-chart-line',
+                items: [
+                    { label: 'Light (1 px)', command: () => this.simplifyRegions(1) },
+                    { label: 'Medium (3 px)', command: () => this.simplifyRegions(3) },
+                    { label: 'Strong (8 px)', command: () => this.simplifyRegions(8) },
+                    { separator: true },
+                    { label: 'Custom…', command: () => this.openSimplifyDialog() },
+                ],
+            });
+        }
+        // Bézier conversions are vertex-level edits — Image (OpenSeadragon) view
+        // only — gated on the selection's current form.
+        if (this.selectedPlotType === PlotType.IMAGE) {
+            const hasStraight = selAll.some((r) => (r.bounds instanceof Polygon && !r.bounds.bezier) || r.bounds instanceof Rectangle);
+            const hasBezier = selAll.some((r) => r.bounds instanceof Polygon && r.bounds.bezier);
+            if (hasStraight) {
+                items.push({ label: 'Convert to Bézier', icon: 'to-bezier-icon', command: () => this.toBezierRegion() });
+            }
+            if (hasBezier) {
+                items.push({ label: 'Convert to polygon', icon: 'to-polygon-icon', command: () => this.toPolygonRegion() });
+            }
+        }
+        items.push({ label: 'Delete region', icon: 'pi pi-trash', command: () => this.deleteRegion() });
+        return items;
+    }
+    buildContextMenuItems() {
+        const active = this.activeDragMode;
+        const activeClass = 'context-menu-active';
+        const items = [];
+        // Selected-region actions lead the menu (separated from the tool toggles).
+        if (this.isHeatmap) {
+            const actions = this.buildRegionActionItems();
+            if (actions.length)
+                items.push(...actions, { separator: true });
+        }
+        if (this.isHeatmap) {
+            items.push({ label: 'Autoscale', icon: 'pi pi-window-maximize', command: () => this.autoscaleImage() }, { separator: true });
+            // 'Zoom selection' is Plotly's rubber-band zoom; it doesn't apply to the
+            // OpenSeadragon-backed Image view (use 'Zoom to box' there instead).
+            if (!this.isImageView) {
+                items.push({
+                    label: 'Zoom selection',
+                    icon: 'pi pi-search',
+                    styleClass: active === 'zoom' ? activeClass : '',
+                    command: () => this.toggleDragMode('zoom'),
+                });
+            }
+            items.push({
+                label: 'Zoom to box',
+                icon: 'zoom-box-off-icon',
+                styleClass: active === 'zoomToBox' ? activeClass : '',
+                command: () => this.toggleDragMode('zoomToBox'),
+            });
+        }
+        if (this.isHeatmap) {
+            items.push({
+                label: 'Pan',
+                icon: 'pi pi-arrows-alt',
+                styleClass: active === 'pan' ? activeClass : '',
+                command: () => this.toggleDragMode('pan'),
+            });
+        }
+        else {
+            const s3d = this.activeSurface3dMode;
+            items.push({
+                label: 'Zoom',
+                icon: 'pi pi-search',
+                styleClass: s3d === 'zoom' ? activeClass : '',
+                command: () => this.toggleSurface3dMode('zoom'),
+            }, {
+                label: 'Pan',
+                icon: 'pi pi-arrows-alt',
+                styleClass: s3d === 'pan' ? activeClass : '',
+                command: () => this.toggleSurface3dMode('pan'),
+            }, {
+                label: 'Orbital rotation',
+                icon: 'pi pi-globe',
+                styleClass: s3d === 'orbit' ? activeClass : '',
+                command: () => this.toggleSurface3dMode('orbit'),
+            }, {
+                label: 'Turntable rotation',
+                icon: 'pi pi-sync',
+                styleClass: s3d === 'turntable' ? activeClass : '',
+                command: () => this.toggleSurface3dMode('turntable'),
+            }, { separator: true }, { label: 'Reset camera', icon: 'pi pi-home', command: () => this.resetSurfaceCamera() });
+        }
+        if (this.isHeatmap) {
+            items.push({ label: 'Zoom in', icon: 'pi pi-search-plus', command: () => this.zoomIn() }, { label: 'Zoom out', icon: 'pi pi-search-minus', command: () => this.zoomOut() }, { separator: true }, {
+                label: 'Select',
+                icon: 'pi pi-arrow-up-right',
+                styleClass: active === 'select' ? activeClass : '',
+                command: () => this.toggleDragMode('select'),
+            }, {
+                label: 'Freeform',
+                icon: 'pi pi-pencil',
+                styleClass: active === 'drawclosedpath' ? activeClass : '',
+                command: () => this.toggleDragMode('drawclosedpath'),
+            }, {
+                label: 'Brush',
+                icon: 'brush-icon',
+                styleClass: active === 'brush' ? activeClass : '',
+                command: () => this.toggleDragMode('brush'),
+            }, {
+                label: 'Polyline',
+                icon: 'polyline-icon',
+                styleClass: active === 'drawopenpath' ? activeClass : '',
+                command: () => this.toggleDragMode('drawopenpath'),
+            }, {
+                label: 'Rectangle',
+                icon: 'pi pi-stop',
+                styleClass: active === 'drawrect' ? activeClass : '',
+                command: () => this.toggleDragMode('drawrect'),
+            }, {
+                label: 'Wand',
+                icon: 'wand-icon',
+                styleClass: active === 'wand' ? activeClass : '',
+                command: () => this.toggleDragMode('wand'),
+            }, {
+                label: 'Vertex eraser',
+                icon: 'pi pi-eraser',
+                styleClass: active === 'eraseVertex' ? activeClass : '',
+                command: () => this.toggleDragMode('eraseVertex'),
+            });
+            // Vertex editing runs on the OpenSeadragon overlay, which
+            // backs the Image plot type. Hidden for other 2D types (Plotly), where
+            // these modes are no-ops.
+            if (this.selectedPlotType === PlotType.IMAGE) {
+                items.push({
+                    label: 'Polygon (click vertices)',
+                    icon: 'polygon-vertices-icon',
+                    styleClass: active === 'drawpolygon' ? activeClass : '',
+                    command: () => this.toggleDragMode('drawpolygon'),
+                }, {
+                    label: 'Add vertex',
+                    icon: 'vertex-add-icon',
+                    styleClass: active === 'addpoint' ? activeClass : '',
+                    command: () => this.toggleDragMode('addpoint'),
+                }, {
+                    label: 'Delete vertex',
+                    icon: 'vertex-delete-icon',
+                    styleClass: active === 'deletepoint' ? activeClass : '',
+                    command: () => this.toggleDragMode('deletepoint'),
+                });
+            }
+            // Bézier conversions + Delete are immediate selection *actions*, now in the
+            // "Selected region(s)" group at the top (see buildRegionActionItems).
+        }
+        return items;
+    }
+    toggleSurface3dMode(mode) {
+        this.activeSurface3dMode = mode;
+        this.plotService.setSurfaceDragMode(mode);
+    }
+    resetSurfaceCamera() {
+        this.plotService.resetSurfaceCamera();
+    }
+    /** Toggle the napari 3D coordinate-axes / scale gizmo (volume/isosurface). No-op on backends
+     *  that don't render one (the control method is optional). */
+    toggleAxes() {
+        this.axesVisible = !this.axesVisible;
+        this.plotService.getSurface3dControls()?.setAxesVisible?.(this.axesVisible);
+    }
+    /** Toggle the napari surface wireframe (edges vs filled). No-op on backends without a surface. */
+    toggleWireframe() {
+        this.wireframeActive = !this.wireframeActive;
+        this.plotService.getSurface3dControls()?.setWireframe?.(this.wireframeActive);
+    }
+    /** Change the napari 3D decimate factor. Decimation changes the fetched/assembled data, so this
+     *  re-plots the current 3D type at the new resolution (unlike axes/wireframe, which are live). */
+    selectResolution(scale) {
+        if (scale === this.resolutionScale)
+            return;
+        this.resolutionScale = scale;
+        this.plotService.setResolutionScale?.(scale);
+        this.reloadAndPlot();
+    }
+    /**
+     * Switch the active plot type (heatmap, surface, contour, scatter, line,
+     * scatter3d, isosurface). Keeps `isHeatmap` as the 2D-vs-3D flag the rest of
+     * the toolbar/context-menu logic relies on, deactivates 2D-only tools when
+     * moving to a 3D type, then re-plots.
+     */
+    onSelectPlotType(type) {
+        this.plotType = type;
+        this.selectedPlotType = type;
+        const descriptor = this.plotTypeOptions.find((d) => d.type === type);
+        const is3d = descriptor?.dimensions === '3d';
+        this.isHeatmap = !is3d;
+        this.plotService.setPlotType(type);
+        // Switching plot type cancels the active tool — not every type supports the
+        // same tools (line/scatter charts and 3D scenes have no box zoom or region
+        // drawing), so leaving a tool armed would misbehave on the new plot.
+        this.deactivateActiveTool();
+        if (is3d) {
+            this.activeSurface3dMode = 'turntable';
+        }
+        // napari-js volume/isosurface assemble their own 3D texture from the slice endpoint, so
+        // they take the normal re-plot path — NOT Plotly's stack-frame loader (whose "Loading
+        // frames" overlay would never clear, since Plotly isn't the active backend) (jit-ui#102).
+        const isNapari = type === PlotType.NAPARI_IMAGE || isNapari3d(type);
+        if (descriptor?.requiresStack && !isNapari) {
+            // Volume types (isosurface, scatter3d) need the whole z-stack loaded as a
+            // 3D array, and they always render on Plotly. Drive the stack reload
+            // directly through the image-info stream rather than the active renderer's
+            // setShowStack: when OpenSeadragon owns the Image view its setShowStack is
+            // a no-op, so the reload never fired and the loader spun forever. We arm
+            // Plotly's stack-loading flag (keeps its frame-fetch loop alive) and
+            // re-emit the image info with showStack on so the pipeline reloads on
+            // Plotly regardless of which backend was on screen.
+            this.selectedStackOption = this.stackOptions[1];
+            this.stackLoading = true;
+            this.plotService.setStackLoading(true);
+            if (this.imageInfo) {
+                this.imageInfo.showStack = true;
+                this.state.setImageInfo(this.imageInfo);
+            }
+            return;
+        }
+        this.reloadAndPlot();
+    }
+    /** Deactivate whatever tool is armed and clear every tool mode. */
+    deactivateActiveTool() {
+        this.activeDragMode = null;
+        this.session.setActiveTool(null);
+        this.plotService.getRegionOverlay()?.setMode('none');
+        this.plotService.setDragMode(false);
+        this.plotService.setZoomToBoxMode(false);
+        this.plotService.setWandMode(false);
+        this.plotService.setBrushMode(false);
+        this.plotService.setSamPointMode(false);
+        this.plotService.setVertexEraserMode(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizerComponent, deps: [{ token: IMAGE_STATE_PORT }, { token: VISUALIZER }, { token: i1.MessageService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i2.VisualizerStore }, { token: i3.SamToolService }, { token: i4.CellSegmentToolService }, { token: i5.SamPointToolService }, { token: i6.RegionOpsService }, { token: VIZ_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: VisualizerComponent, selector: "visualizer", inputs: { toolbarTools: "toolbarTools", testMode: "testMode" }, outputs: { isStackEvent: "isStackEvent", isGrayscaleEvent: "isGrayscaleEvent" }, host: { listeners: { "window:keydown": "onKeydown($event)" } }, viewQueries: [{ propertyName: "contextMenu", first: true, predicate: ["cm"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<!-- SAM toast: live status + encoder-download progress bar (jit-ui#90). Sticky\n     while a segment runs; stays open until the bar reaches 100% and the run ends. -->\n<p-toast [key]=\"samToastKey\" position=\"bottom-right\">\n  <ng-template let-message pTemplate=\"message\">\n    <div style=\"flex: 1; min-width: 16rem\">\n      <div class=\"font-bold mb-1\">{{ message.summary }}</div>\n      <div>{{ samStatus || message.detail }}</div>\n      <p-progressBar *ngIf=\"samDownloading\" [value]=\"samProgress\" styleClass=\"mt-2 sam-progress\"></p-progressBar>\n      <p-progressBar *ngIf=\"samBusy && !samDownloading\" mode=\"indeterminate\" styleClass=\"mt-2\"\n                     [style]=\"{ height: '4px' }\"></p-progressBar>\n    </div>\n  </ng-template>\n</p-toast>\n\n<!-- Toolbar dock: docked across the top by default; drag the handle to detach\n     it into a floating, movable window (frees the top row for the image). -->\n<div class=\"toolbar-dock\" [class.floating]=\"toolbarFloating\"\n     [style.left.px]=\"toolbarFloating ? toolbarPos.x : null\"\n     [style.top.px]=\"toolbarFloating ? toolbarPos.y : null\">\n  <div class=\"toolbar-drag-handle\" (mousedown)=\"onToolbarDragStart($event)\"\n       pTooltip=\"Drag to float the toolbar\" tooltipPosition=\"bottom\">\n    <i class=\"pi pi-bars\"></i>\n  </div>\n<plotting-toolbar\n  [imageInfo]=\"imageInfo\"\n  [plotTypeOptions]=\"plotTypeOptions\"\n  [selectedPlotType]=\"selectedPlotType\"\n  [isoRange]=\"isoRange\"\n  [maxIndex]=\"maxIndex\"\n  [zIndex]=\"zIndex\"\n  [isHeatmap]=\"isHeatmap\"\n  [activeDragMode]=\"activeDragMode\"\n  [activeSurface3dMode]=\"activeSurface3dMode\"\n  [axesVisible]=\"axesVisible\"\n  [wireframeActive]=\"wireframeActive\"\n  [resolutionScale]=\"resolutionScale\"\n  [wandSensitivity]=\"wandSensitivity\"\n  [brushSize]=\"brushSize\"\n  [samModels]=\"samModels\"\n  [samModelId]=\"samModelId\"\n  [vertexEraserRadius]=\"vertexEraserRadius\"\n  [canUndo]=\"canUndoRegion\"\n  [canRedo]=\"canRedoRegion\"\n  [stackOptions]=\"stackOptions\"\n  [tools]=\"toolbarTools\"\n  [imageSmoothingEnabled]=\"imageSmoothingEnabled\"\n  (selectPlotType)=\"onSelectPlotType($event)\"\n  (toggleImageSmoothing)=\"onToggleImageSmoothing()\"\n  (addProfileLine)=\"addProfileLine()\"\n  (isoRangeChange)=\"onIsoRangeChange($event)\"\n  (openChannelHistogram)=\"openChannelHistogram()\"\n  (openRegionEditor)=\"openRegionEditor()\"\n  (selectStackOption)=\"selectStackOption($event)\"\n  (zScrub)=\"onZScrub($event)\"\n  (zSlide)=\"onZSlide($event)\"\n  (zIndexInput)=\"zIndex = $event; updateZIndex()\"\n  (reloadAndPlot)=\"reloadAndPlot()\"\n  (downloadImage)=\"downloadImage()\"\n  (autoscaleImage)=\"autoscaleImage()\"\n  (toggleDragMode)=\"toggleDragMode($event)\"\n  (zoomIn)=\"zoomIn()\"\n  (zoomOut)=\"zoomOut()\"\n  (toggleSurface3dMode)=\"toggleSurface3dMode($event)\"\n  (resetSurfaceCamera)=\"resetSurfaceCamera()\"\n  (toggleAxes)=\"toggleAxes()\"\n  (toggleWireframe)=\"toggleWireframe()\"\n  (selectResolution)=\"selectResolution($event)\"\n  (deleteRegion)=\"deleteRegion()\"\n  (undoRegion)=\"undoRegion()\"\n  (redoRegion)=\"redoRegion()\"\n  (segmentRegions)=\"segmentRegions()\"\n  (segmentCellpose)=\"segmentCellpose()\"\n  (samModelChange)=\"onSamModelChange($event)\"\n  (wandSensitivityChange)=\"onWandSensitivityChange($event)\"\n  (brushSizeChange)=\"onBrushSizeChange($event)\"\n  (vertexEraserRadiusChange)=\"onVertexEraserRadiusChange($event)\">\n  <!-- Host-projected custom toolbar buttons, forwarded into the toolbar. -->\n  <ng-content></ng-content>\n</plotting-toolbar>\n  <p-button *ngIf=\"toolbarFloating\" class=\"toolbar-dock-btn\" icon=\"pi pi-thumbtack\" size=\"small\" [text]=\"true\"\n            pTooltip=\"Dock to top\" tooltipPosition=\"bottom\" (onClick)=\"dockToolbar()\">\n  </p-button>\n</div>\n\n<p-contextMenu #cm [model]=\"contextMenuItems\" appendTo=\"body\"></p-contextMenu>\n<!-- No `h-full` here: PrimeFlex's height:100% !important made #plot as tall as\n     the whole host, so under the docked toolbar its bottom toolbar-height strip\n     (incl. the OSD scale bar at bottom-left) was clipped by the host's\n     overflow:hidden. The component stylesheet sizes it (.viz-plot { flex: 1 }). -->\n<div class=\"w-full relative viz-plot\" [id]=\"plotDivName\">\n  <div *ngIf=\"imgLoading || stackLoading || isCaching\" id=\"overlay\">\n    <!-- Determinate stack/volume progress takes precedence: while it's active show ONLY the\n         progress bar + \"Loading frames...\", not the generic spinner/\"Loading image...\" on top of\n         it (both were rendering at once for napari volume/isosurface loads). -->\n    <ng-container *ngIf=\"stackLoading; else imgLoadingTpl\">\n      <p-progressBar class=\"progress\" [value]=\"loadingPercentage\"></p-progressBar>\n      <span class=\"text-loading\">Loading frames...</span>\n    </ng-container>\n    <ng-template #imgLoadingTpl>\n      <!-- Cache-copy progress is shown whenever a cache download is active (isCaching), independent\n           of `imgLoading`, so it's never dropped/masked mid-download. -->\n      <ng-container *ngIf=\"isCaching; else spinnerLoading\">\n        <!-- Stage-aware message comes from CacheProgressService updating\n             imageLoadingMessage$ (\"Caching image...\" during the GCS download,\n             then \"Generating preview...\" during per-slice thumbnail gen). Once the\n             download hits 100% the remaining work (server preview/tile generation)\n             has no determinate progress, so fall through to the spinner template\n             rather than parking a full bar under \"Loading image...\". -->\n        <p-progressBar class=\"progress\" [value]=\"cacheProgress\"></p-progressBar>\n        <span class=\"text-loading\">{{loadingMessage}}</span>\n      </ng-container>\n      <ng-template #spinnerLoading>\n        <div *ngIf=\"imgLoading\" class=\"spinner\"></div>\n        <span *ngIf=\"imgLoading && !zoom\" class=\"text-loading\">{{loadingMessage}}</span>\n        <span *ngIf=\"imgLoading && zoom\" class=\"zoom-text-loading\">{{loadingMessage}}</span>\n      </ng-template>\n    </ng-template>\n    <p-button *ngIf=\"stackLoading || imgLoading\" class=\"cancel-loading \" label=\"Cancel\"\n              (onClick)=\"cancelLoading()\">\n    </p-button>\n  </div>\n  <!-- Translucent \"sharpening\" overlay shown after the small-tier preview is\n       on screen while the large-tier render is still loading in the\n       background. Lets the user see the blurry image underneath but makes\n       it clear something is still loading so they don't mistake the\n       low-res render for the final image. -->\n  <div *ngIf=\"sharpening && !imgLoading && !stackLoading && !isCaching\" id=\"sharpening-overlay\">\n    <div class=\"spinner\"></div>\n    <span class=\"text-loading\">Sharpening preview...</span>\n  </div>\n\n</div>\n\n<!-- Floating, draggable intensity-profile inset. Shown in LINE mode; the chart\n     updates live as the line ROI on the image is moved. Kept OUTSIDE #plot and\n     positioned fixed so it floats over the whole page (not clipped to the\n     diagram/canvas area). -->\n<div *ngIf=\"hasProfiles\" class=\"intensity-panel\"\n     [style.left.px]=\"profilePanelPos.x\" [style.top.px]=\"profilePanelPos.y\">\n  <div class=\"intensity-panel-header\" (mousedown)=\"onProfilePanelDragStart($event)\">\n    <span>Intensity profile</span>\n    <i class=\"pi pi-arrows-alt\"></i>\n  </div>\n  <div [id]=\"intensityInsetDiv\" class=\"intensity-panel-plot\"></div>\n</div>\n\n<!-- Channels & Histogram: non-modal floating dialog opened from the toolbar. -->\n<channel-histogram [(visible)]=\"showChannelHistogram\"></channel-histogram>\n\n<!-- Region Editor: non-modal, draggable, resizable floating dialog opened from\n     the toolbar (formerly the right-panel Regions tab). Modeless so regions can\n     still be drawn/selected on the plot while it's open; stays linked to this\n     plotting instance via the root RegionStore singleton. Opens over the right\n     side of the view. -->\n<p-dialog header=\"Region Editor\" [(visible)]=\"showRegionEditor\"\n          [modal]=\"false\" [resizable]=\"true\" [draggable]=\"true\"\n          [maximizable]=\"true\" appendTo=\"body\" position=\"right\"\n          [style]=\"{ width: regionEditorWidth, height: '85vh' }\"\n          [contentStyle]=\"{ overflow: 'auto' }\">\n  <region-editor></region-editor>\n</p-dialog>\n\n<!-- Simplify (Douglas\u2013Peucker): custom px-threshold picker for the selected\n     region(s), opened from the right-click \"Simplify \u25B8 Custom\u2026\" action. -->\n<p-dialog header=\"Simplify region(s)\" [(visible)]=\"displaySimplifyDialog\" [modal]=\"true\"\n          [style]=\"{width: '22rem'}\" [draggable]=\"false\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-2\">\n    <span>Altitude threshold: <b>{{ simplifyThreshold }} px</b></span>\n    <p-slider [(ngModel)]=\"simplifyThreshold\" [min]=\"1\" [max]=\"20\" [step]=\"1\"></p-slider>\n    <small>Vertices within this distance of the line between their neighbours are removed.</small>\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" [text]=\"true\" (onClick)=\"displaySimplifyDialog = false\"></p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"simplifyRegions(simplifyThreshold)\"></p-button>\n  </ng-template>\n</p-dialog>\n\n", styles: [":host{display:flex;flex-direction:column;height:100%;overflow:hidden}.viz-plot{flex:1;min-height:0;height:auto!important}.toolbar-dock{display:flex;align-items:stretch;width:100%}.toolbar-dock plotting-toolbar{flex:1;min-width:0}.toolbar-dock.floating{position:fixed;z-index:1000;width:auto;max-width:calc(100% - 16px);background:var(--surface-card, #ffffff);border:1px solid var(--surface-border, #cccccc);border-radius:6px;box-shadow:0 4px 16px #0000004d}.toolbar-dock.floating plotting-toolbar{flex:0 1 auto}.toolbar-dock.floating .toolbar-drag-handle{border-radius:6px 0 0 6px}.toolbar-drag-handle{display:flex;align-items:center;justify-content:center;padding:0 .4rem;cursor:move;color:var(--primary-color);background:var(--surface-100, rgba(0, 0, 0, .04));border-right:1px solid var(--surface-border, #cccccc);-webkit-user-select:none;user-select:none}.toolbar-dock-btn{align-self:center}:host ::ng-deep .navigator{margin-bottom:80px!important;margin-right:12px!important}kbd{background:#e8e8e8;border:1px solid #bbb;border-radius:3px;padding:1px 5px;font-family:monospace;font-size:.85em}::ng-deep .context-menu-active>.p-menuitem-content{background-color:var(--primary-color)!important}::ng-deep .context-menu-active>.p-menuitem-content .p-menuitem-icon,::ng-deep .context-menu-active>.p-menuitem-content .p-menuitem-text{color:#fff!important}::ng-deep .context-menu-active>.p-menuitem-content .zoom-box-off-icon,::ng-deep .context-menu-active>.p-menuitem-content .wand-icon,::ng-deep .context-menu-active>.p-menuitem-content .polyline-icon,::ng-deep .context-menu-active>.p-menuitem-content .polygon-vertices-icon,::ng-deep .context-menu-active>.p-menuitem-content .vertex-add-icon,::ng-deep .context-menu-active>.p-menuitem-content .vertex-delete-icon,::ng-deep .context-menu-active>.p-menuitem-content .region-move-icon,::ng-deep .context-menu-active>.p-menuitem-content .to-bezier-icon,::ng-deep .context-menu-active>.p-menuitem-content .to-polygon-icon{filter:brightness(0) invert(1)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}.progress{position:absolute;width:50%;left:25%;top:55%}.text-loading{position:absolute;margin:0 auto;left:45%;top:60%;font-weight:700}.zoom-text-loading{position:absolute;margin:0 auto;left:35%;top:60%;font-weight:700;display:inline-block;width:350px}.cancel-loading{position:absolute;margin:0 auto;left:46%;top:70%}.spinner{position:absolute;left:45%;top:45%;height:100px;width:100px;margin:0 auto;-webkit-animation:rotation .6s infinite linear;-moz-animation:rotation .6s infinite linear;-o-animation:rotation .6s infinite linear;animation:rotation .6s infinite linear;border-left:6px solid rgba(0,174,239,.15);border-right:6px solid rgba(0,174,239,.15);border-bottom:6px solid rgba(0,174,239,.15);border-top:6px solid rgb(82,107,178);border-radius:100%}#overlay{position:absolute;top:0;left:0;width:100%;height:100%;background-color:#ffffff80;z-index:1000}#sharpening-overlay{position:absolute;top:0;left:0;width:100%;height:100%;background-color:#ffffff2e;pointer-events:none;z-index:1000}#sharpening-overlay .spinner{height:60px;width:60px;border-width:4px;left:calc(50% - 30px);top:calc(50% - 60px)}#sharpening-overlay .text-loading{position:absolute;left:0;right:0;width:auto;text-align:center;top:calc(50% + 35px);font-size:.9rem;color:#526bb2}@-webkit-keyframes rotation{0%{-webkit-transform:rotate(0deg)}to{-webkit-transform:rotate(359deg)}}@-moz-keyframes rotation{0%{-moz-transform:rotate(0deg)}to{-moz-transform:rotate(359deg)}}@-o-keyframes rotation{0%{-o-transform:rotate(0deg)}to{-o-transform:rotate(359deg)}}@keyframes rotation{0%{transform:rotate(0)}to{transform:rotate(359deg)}}::ng-deep .zoom-box-off-icon{background:url('data:image/svg+xml,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 100 100\" fill=\"black\" fill-rule=\"evenodd\">%0A  <!-- Rectangle outline -->%0A  <rect x=\"2\" y=\"2\" width=\"56\" height=\"56\"/>%0A  <rect x=\"9\" y=\"9\" width=\"42\" height=\"42\"/>%0A  <!-- Magnifying glass ring -->%0A  <circle cx=\"70\" cy=\"70\" r=\"23\"/>%0A  <circle cx=\"70\" cy=\"70\" r=\"14\"/>%0A  <!-- Handle -->%0A  <polygon points=\"81,81 97,97 92,100 77,85\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .wand-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<svg%0A   viewBox=\"0 0 100 100\"%0A   fill=\"black\"%0A   fill-rule=\"evenodd\"%0A   version=\"1.1\"%0A   id=\"svg4\"%0A   sodipodi:docname=\"wand.svg\"%0A   inkscape:version=\"1.4.3 (0d15f75, 2025-12-25)\"%0A   xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\"%0A   xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\"%0A   xmlns=\"http://www.w3.org/2000/svg\"%0A   xmlns:svg=\"http://www.w3.org/2000/svg\">%0A  <defs%0A     id=\"defs4\" />%0A  <sodipodi:namedview%0A     id=\"namedview4\"%0A     pagecolor=\"%23ffffff\"%0A     bordercolor=\"%23000000\"%0A     borderopacity=\"0.25\"%0A     inkscape:showpageshadow=\"2\"%0A     inkscape:pageopacity=\"0.0\"%0A     inkscape:pagecheckerboard=\"0\"%0A     inkscape:deskcolor=\"%23d1d1d1\"%0A     inkscape:zoom=\"8.74\"%0A     inkscape:cx=\"50\"%0A     inkscape:cy=\"49.942792\"%0A     inkscape:window-width=\"1024\"%0A     inkscape:window-height=\"1186\"%0A     inkscape:window-x=\"3560\"%0A     inkscape:window-y=\"131\"%0A     inkscape:window-maximized=\"0\"%0A     inkscape:current-layer=\"svg4\" />%0A  <!-- Wand handle: thin diagonal stick from lower-left to upper-right -->%0A  <polygon%0A     points=\"12,92 78,26 74,22 8,88 \"%0A     id=\"polygon1\"%0A     transform=\"matrix(1.0375192,0.05799445,0.25179496,0.91871864,-17.85351,5.6289793)\" />%0A  <!-- 4-pointed star at the wand tip -->%0A  <polygon%0A     points=\"62,34 76,30 80,6 84,30 98,34 84,38 80,62 76,38 \"%0A     id=\"polygon2\"%0A     transform=\"matrix(1.3082889,0,0,1.0245178,-38.907958,-1.4056881)\" />%0A  <!-- Small sparkle to the upper-left -->%0A  <polygon%0A     points=\"46,30 36,32 34,42 32,32 22,30 32,28 34,18 36,28 \"%0A     id=\"polygon3\"%0A     transform=\"translate(-9.610984,-6.7505721)\" />%0A  <!-- Small sparkle to the lower-right -->%0A  <polygon%0A     points=\"62,80 70,82 62,84 60,92 58,84 50,82 58,80 60,72 \"%0A     id=\"polygon4\"%0A     transform=\"translate(0,-1.6018307)\" />%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .brush-icon{background:url('data:image/svg+xml,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 640 640\"><!--!Font Awesome Free 7.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d=\"M512.5 74.3L291.1 222C262 241.4 243.5 272.9 240.5 307.3C302.8 320.1 351.9 369.2 364.8 431.6C399.3 428.6 430.7 410.1 450.1 381L597.7 159.5C604.4 149.4 608 137.6 608 125.4C608 91.5 580.5 64 546.6 64C534.5 64 522.6 67.6 512.5 74.3zM320 464C320 402.1 269.9 352 208 352C146.1 352 96 402.1 96 464C96 467.9 96.2 471.8 96.6 475.6C98.4 493.1 86.4 512 68.8 512L64 512C46.3 512 32 526.3 32 544C32 561.7 46.3 576 64 576L208 576C269.9 576 320 525.9 320 464z\"/></svg>') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .polyline-icon{background:url('data:image/svg+xml,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\">%0A  <polyline points=\"1,14 5,3 10,11 15,2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .polygon-vertices-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Polygon (click-to-place) tool icon: a traced polyline with vertex dots. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <g transform=\"matrix(1.4740709,0,0,1.4740709,-6.0268793,-6.8086826)\">%0A    <polyline points=\"23.877,16.627 14.657,10.767 5.25,21.551 12.757,29.397\"%0A              fill=\"none\" stroke=\"%23000000\" stroke-width=\"1.6\"%0A              stroke-linejoin=\"round\" stroke-linecap=\"round\"/>%0A    <circle cx=\"23.877\" cy=\"16.627\" r=\"1.9\"/>%0A    <circle cx=\"14.657\" cy=\"10.767\" r=\"1.9\"/>%0A    <circle cx=\"5.25\" cy=\"21.551\" r=\"1.9\"/>%0A    <circle cx=\"12.757\" cy=\"29.397\" r=\"1.9\"/>%0A  </g>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .vertex-add-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Add-vertex tool icon: a region blob with three corner vertices and a plus glyph. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <g transform=\"matrix(1.5222969,0,0,1.5222969,-8.2143505,-7.6146399)\">%0A    <path d=\"m 9.35834,12.33267 c 1.78,-2.53 4.93,-3.56 7.86,-3.98 3.98,-0.72 8.33,0.08 11.52,2.67 2.62,1.98 4.71,5.1 4.53,8.49 -0.29,2.27 -2.5,3.81 -4.66,4.01 -2.75,0.43 -5.54,0.07 -8.28,-0.26 -3.99,-0.68 -8.05,-2.16 -10.93,-5.12 -1.32,-1.63 -1.39,-4.17 -0.04,-5.81 z\"%0A          fill=\"none\" stroke=\"%23000000\" stroke-width=\"1.6\" stroke-miterlimit=\"10\"/>%0A    <circle cx=\"8.294\" cy=\"15.248\" r=\"2.63\"/>%0A    <circle cx=\"19.781\" cy=\"8.287\" r=\"2.63\"/>%0A    <circle cx=\"25.044\" cy=\"23.748\" r=\"2.63\"/>%0A  </g>%0A  <path d=\"M 9.65,29.0 H 5.85 v 5.3 H 0.55 v 3.4 H 5.85 v 5.3 H 9.65 V 37.7 H 14.95 V 34.3 H 9.65 Z\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .vertex-delete-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Delete-vertex tool icon: a region blob with three corner vertices and a minus glyph. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <g transform=\"matrix(1.5222969,0,0,1.5222969,-8.2143505,-7.6146399)\">%0A    <path d=\"m 9.35834,12.33267 c 1.78,-2.53 4.93,-3.56 7.86,-3.98 3.98,-0.72 8.33,0.08 11.52,2.67 2.62,1.98 4.71,5.1 4.53,8.49 -0.29,2.27 -2.5,3.81 -4.66,4.01 -2.75,0.43 -5.54,0.07 -8.28,-0.26 -3.99,-0.68 -8.05,-2.16 -10.93,-5.12 -1.32,-1.63 -1.39,-4.17 -0.04,-5.81 z\"%0A          fill=\"none\" stroke=\"%23000000\" stroke-width=\"1.6\" stroke-miterlimit=\"10\"/>%0A    <circle cx=\"8.294\" cy=\"15.248\" r=\"2.63\"/>%0A    <circle cx=\"19.781\" cy=\"8.287\" r=\"2.63\"/>%0A    <circle cx=\"25.044\" cy=\"23.748\" r=\"2.63\"/>%0A  </g>%0A  <path d=\"M 0.55,34.3 v 3.4 H 14.95 V 34.3 Z\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .region-move-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Region-move tool icon: a region blob with a drag arrow. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <path d=\"m 17.115582,8.9648664 c 1.707597,-3.3276806 4.729468,-4.6824281 7.540287,-5.2348498 3.827703,-0.947008 7.991169,0.1052238 11.051414,3.5118228 2.523022,2.604273 4.518416,6.7079726 4.345738,11.1668036 -0.278204,2.985704 -2.398311,5.011251 -4.470451,5.274308 -2.638142,0.565574 -5.314655,0.09206 -7.943203,-0.341976 C 23.811664,22.446579 19.916808,20.499952 17.153955,16.606696 15.89724,14.462775 15.820494,11.12194 17.115585,8.9648664 Z\"%0A        fill=\"none\" stroke=\"%23000000\" stroke-width=\"2.1\" stroke-miterlimit=\"10\"/>%0A  <path d=\"m 26.741429,13.966963 6.746922,16.786269 3.229398,-4.060758 3.583857,3.583857 2.761195,-2.761196 -3.583856,-3.571852 4.060758,-3.2354 z\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .to-bezier-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Convert-to-bezier tool icon: a smooth curve through two anchor points with control handles. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <!-- smooth cubic curve between the two anchors -->%0A  <path d=\"M 7,34 C 7,16 37,28 37,10\" fill=\"none\" stroke=\"%23000000\" stroke-width=\"2.4\"%0A        stroke-linecap=\"round\"/>%0A  <!-- control handles -->%0A  <line x1=\"7\" y1=\"34\" x2=\"7\" y2=\"22\" stroke=\"%23000000\" stroke-width=\"1.4\"/>%0A  <line x1=\"37\" y1=\"10\" x2=\"37\" y2=\"22\" stroke=\"%23000000\" stroke-width=\"1.4\"/>%0A  <circle cx=\"7\" cy=\"22\" r=\"2.2\"/>%0A  <circle cx=\"37\" cy=\"22\" r=\"2.2\"/>%0A  <!-- anchor points -->%0A  <rect x=\"4\" y=\"31\" width=\"6\" height=\"6\" rx=\"1\"/>%0A  <rect x=\"34\" y=\"7\" width=\"6\" height=\"6\" rx=\"1\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .to-polygon-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Convert-to-polygon tool icon: endpoints joined by straight segments through a vertex. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <!-- straight-segment path through the vertices -->%0A  <polyline points=\"7,34 22,12 37,10\" fill=\"none\" stroke=\"%23000000\" stroke-width=\"2.4\"%0A            stroke-linecap=\"round\" stroke-linejoin=\"round\"/>%0A  <!-- vertices -->%0A  <rect x=\"4\" y=\"31\" width=\"6\" height=\"6\" rx=\"1\"/>%0A  <rect x=\"19\" y=\"9\" width=\"6\" height=\"6\" rx=\"1\"/>%0A  <rect x=\"34\" y=\"7\" width=\"6\" height=\"6\" rx=\"1\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.intensity-panel{position:fixed;z-index:1100;width:280px;height:180px;background:#191919e6;border:1px solid var(--primary-color, #3399ff);border-radius:6px;box-shadow:0 4px 14px #00000073;display:flex;flex-direction:column;overflow:hidden}.intensity-panel-header{display:flex;align-items:center;justify-content:space-between;padding:.25rem .5rem;cursor:move;-webkit-user-select:none;user-select:none;background:#ffffff14;color:#eee;font-size:.75rem;font-weight:600}.intensity-panel-header i{opacity:.6;font-size:.7rem}.intensity-panel-plot{flex:1 1 auto;width:100%}:host ::ng-deep .sam-progress .p-progressbar-value{transition:none}\n"], dependencies: [{ kind: "directive", type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i8.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i8.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i9.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "directive", type: i10.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: i11.Slider, selector: "p-slider", inputs: ["animate", "disabled", "min", "max", "orientation", "step", "range", "style", "styleClass", "ariaLabel", "ariaLabelledBy", "tabindex", "autofocus"], outputs: ["onChange", "onSlideEnd"] }, { kind: "component", type: i12.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "visible", "style", "position"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "component", type: i13.ContextMenu, selector: "p-contextMenu", inputs: ["model", "triggerEvent", "target", "global", "style", "styleClass", "appendTo", "autoZIndex", "baseZIndex", "id", "ariaLabel", "ariaLabelledBy", "pressDelay"], outputs: ["onShow", "onHide"] }, { kind: "component", type: i14.ProgressBar, selector: "p-progressBar", inputs: ["value", "showValue", "styleClass", "style", "unit", "mode", "color"] }, { kind: "component", type: i15.Toast, selector: "p-toast", inputs: ["key", "autoZIndex", "baseZIndex", "life", "style", "styleClass", "position", "preventOpenDuplicates", "preventDuplicates", "showTransformOptions", "hideTransformOptions", "showTransitionOptions", "hideTransitionOptions", "breakpoints"], outputs: ["onClose"] }, { kind: "component", type: i16.ToolbarComponent, selector: "plotting-toolbar", inputs: ["imageInfo", "plotTypeOptions", "selectedPlotType", "isoRange", "maxIndex", "zIndex", "isHeatmap", "activeDragMode", "activeSurface3dMode", "axesVisible", "wireframeActive", "resolutionScale", "wandSensitivity", "brushSize", "vertexEraserRadius", "canUndo", "canRedo", "stackOptions", "tools", "imageSmoothingEnabled", "samModels", "samModelId"], outputs: ["selectPlotType", "addProfileLine", "toggleImageSmoothing", "isoRangeChange", "openChannelHistogram", "openRegionEditor", "selectStackOption", "zScrub", "zSlide", "zIndexInput", "reloadAndPlot", "downloadImage", "autoscaleImage", "toggleDragMode", "zoomIn", "zoomOut", "toggleSurface3dMode", "resetSurfaceCamera", "toggleAxes", "toggleWireframe", "selectResolution", "deleteRegion", "undoRegion", "redoRegion", "segmentRegions", "segmentCellpose", "samModelChange", "wandSensitivityChange", "brushSizeChange", "vertexEraserRadiusChange"] }, { kind: "component", type: i17.RegionEditorComponent, selector: "region-editor" }, { kind: "component", type: i18.ChannelHistogramComponent, selector: "channel-histogram", inputs: ["visible"], outputs: ["visibleChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: VisualizerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'visualizer', template: "<!-- SAM toast: live status + encoder-download progress bar (jit-ui#90). Sticky\n     while a segment runs; stays open until the bar reaches 100% and the run ends. -->\n<p-toast [key]=\"samToastKey\" position=\"bottom-right\">\n  <ng-template let-message pTemplate=\"message\">\n    <div style=\"flex: 1; min-width: 16rem\">\n      <div class=\"font-bold mb-1\">{{ message.summary }}</div>\n      <div>{{ samStatus || message.detail }}</div>\n      <p-progressBar *ngIf=\"samDownloading\" [value]=\"samProgress\" styleClass=\"mt-2 sam-progress\"></p-progressBar>\n      <p-progressBar *ngIf=\"samBusy && !samDownloading\" mode=\"indeterminate\" styleClass=\"mt-2\"\n                     [style]=\"{ height: '4px' }\"></p-progressBar>\n    </div>\n  </ng-template>\n</p-toast>\n\n<!-- Toolbar dock: docked across the top by default; drag the handle to detach\n     it into a floating, movable window (frees the top row for the image). -->\n<div class=\"toolbar-dock\" [class.floating]=\"toolbarFloating\"\n     [style.left.px]=\"toolbarFloating ? toolbarPos.x : null\"\n     [style.top.px]=\"toolbarFloating ? toolbarPos.y : null\">\n  <div class=\"toolbar-drag-handle\" (mousedown)=\"onToolbarDragStart($event)\"\n       pTooltip=\"Drag to float the toolbar\" tooltipPosition=\"bottom\">\n    <i class=\"pi pi-bars\"></i>\n  </div>\n<plotting-toolbar\n  [imageInfo]=\"imageInfo\"\n  [plotTypeOptions]=\"plotTypeOptions\"\n  [selectedPlotType]=\"selectedPlotType\"\n  [isoRange]=\"isoRange\"\n  [maxIndex]=\"maxIndex\"\n  [zIndex]=\"zIndex\"\n  [isHeatmap]=\"isHeatmap\"\n  [activeDragMode]=\"activeDragMode\"\n  [activeSurface3dMode]=\"activeSurface3dMode\"\n  [axesVisible]=\"axesVisible\"\n  [wireframeActive]=\"wireframeActive\"\n  [resolutionScale]=\"resolutionScale\"\n  [wandSensitivity]=\"wandSensitivity\"\n  [brushSize]=\"brushSize\"\n  [samModels]=\"samModels\"\n  [samModelId]=\"samModelId\"\n  [vertexEraserRadius]=\"vertexEraserRadius\"\n  [canUndo]=\"canUndoRegion\"\n  [canRedo]=\"canRedoRegion\"\n  [stackOptions]=\"stackOptions\"\n  [tools]=\"toolbarTools\"\n  [imageSmoothingEnabled]=\"imageSmoothingEnabled\"\n  (selectPlotType)=\"onSelectPlotType($event)\"\n  (toggleImageSmoothing)=\"onToggleImageSmoothing()\"\n  (addProfileLine)=\"addProfileLine()\"\n  (isoRangeChange)=\"onIsoRangeChange($event)\"\n  (openChannelHistogram)=\"openChannelHistogram()\"\n  (openRegionEditor)=\"openRegionEditor()\"\n  (selectStackOption)=\"selectStackOption($event)\"\n  (zScrub)=\"onZScrub($event)\"\n  (zSlide)=\"onZSlide($event)\"\n  (zIndexInput)=\"zIndex = $event; updateZIndex()\"\n  (reloadAndPlot)=\"reloadAndPlot()\"\n  (downloadImage)=\"downloadImage()\"\n  (autoscaleImage)=\"autoscaleImage()\"\n  (toggleDragMode)=\"toggleDragMode($event)\"\n  (zoomIn)=\"zoomIn()\"\n  (zoomOut)=\"zoomOut()\"\n  (toggleSurface3dMode)=\"toggleSurface3dMode($event)\"\n  (resetSurfaceCamera)=\"resetSurfaceCamera()\"\n  (toggleAxes)=\"toggleAxes()\"\n  (toggleWireframe)=\"toggleWireframe()\"\n  (selectResolution)=\"selectResolution($event)\"\n  (deleteRegion)=\"deleteRegion()\"\n  (undoRegion)=\"undoRegion()\"\n  (redoRegion)=\"redoRegion()\"\n  (segmentRegions)=\"segmentRegions()\"\n  (segmentCellpose)=\"segmentCellpose()\"\n  (samModelChange)=\"onSamModelChange($event)\"\n  (wandSensitivityChange)=\"onWandSensitivityChange($event)\"\n  (brushSizeChange)=\"onBrushSizeChange($event)\"\n  (vertexEraserRadiusChange)=\"onVertexEraserRadiusChange($event)\">\n  <!-- Host-projected custom toolbar buttons, forwarded into the toolbar. -->\n  <ng-content></ng-content>\n</plotting-toolbar>\n  <p-button *ngIf=\"toolbarFloating\" class=\"toolbar-dock-btn\" icon=\"pi pi-thumbtack\" size=\"small\" [text]=\"true\"\n            pTooltip=\"Dock to top\" tooltipPosition=\"bottom\" (onClick)=\"dockToolbar()\">\n  </p-button>\n</div>\n\n<p-contextMenu #cm [model]=\"contextMenuItems\" appendTo=\"body\"></p-contextMenu>\n<!-- No `h-full` here: PrimeFlex's height:100% !important made #plot as tall as\n     the whole host, so under the docked toolbar its bottom toolbar-height strip\n     (incl. the OSD scale bar at bottom-left) was clipped by the host's\n     overflow:hidden. The component stylesheet sizes it (.viz-plot { flex: 1 }). -->\n<div class=\"w-full relative viz-plot\" [id]=\"plotDivName\">\n  <div *ngIf=\"imgLoading || stackLoading || isCaching\" id=\"overlay\">\n    <!-- Determinate stack/volume progress takes precedence: while it's active show ONLY the\n         progress bar + \"Loading frames...\", not the generic spinner/\"Loading image...\" on top of\n         it (both were rendering at once for napari volume/isosurface loads). -->\n    <ng-container *ngIf=\"stackLoading; else imgLoadingTpl\">\n      <p-progressBar class=\"progress\" [value]=\"loadingPercentage\"></p-progressBar>\n      <span class=\"text-loading\">Loading frames...</span>\n    </ng-container>\n    <ng-template #imgLoadingTpl>\n      <!-- Cache-copy progress is shown whenever a cache download is active (isCaching), independent\n           of `imgLoading`, so it's never dropped/masked mid-download. -->\n      <ng-container *ngIf=\"isCaching; else spinnerLoading\">\n        <!-- Stage-aware message comes from CacheProgressService updating\n             imageLoadingMessage$ (\"Caching image...\" during the GCS download,\n             then \"Generating preview...\" during per-slice thumbnail gen). Once the\n             download hits 100% the remaining work (server preview/tile generation)\n             has no determinate progress, so fall through to the spinner template\n             rather than parking a full bar under \"Loading image...\". -->\n        <p-progressBar class=\"progress\" [value]=\"cacheProgress\"></p-progressBar>\n        <span class=\"text-loading\">{{loadingMessage}}</span>\n      </ng-container>\n      <ng-template #spinnerLoading>\n        <div *ngIf=\"imgLoading\" class=\"spinner\"></div>\n        <span *ngIf=\"imgLoading && !zoom\" class=\"text-loading\">{{loadingMessage}}</span>\n        <span *ngIf=\"imgLoading && zoom\" class=\"zoom-text-loading\">{{loadingMessage}}</span>\n      </ng-template>\n    </ng-template>\n    <p-button *ngIf=\"stackLoading || imgLoading\" class=\"cancel-loading \" label=\"Cancel\"\n              (onClick)=\"cancelLoading()\">\n    </p-button>\n  </div>\n  <!-- Translucent \"sharpening\" overlay shown after the small-tier preview is\n       on screen while the large-tier render is still loading in the\n       background. Lets the user see the blurry image underneath but makes\n       it clear something is still loading so they don't mistake the\n       low-res render for the final image. -->\n  <div *ngIf=\"sharpening && !imgLoading && !stackLoading && !isCaching\" id=\"sharpening-overlay\">\n    <div class=\"spinner\"></div>\n    <span class=\"text-loading\">Sharpening preview...</span>\n  </div>\n\n</div>\n\n<!-- Floating, draggable intensity-profile inset. Shown in LINE mode; the chart\n     updates live as the line ROI on the image is moved. Kept OUTSIDE #plot and\n     positioned fixed so it floats over the whole page (not clipped to the\n     diagram/canvas area). -->\n<div *ngIf=\"hasProfiles\" class=\"intensity-panel\"\n     [style.left.px]=\"profilePanelPos.x\" [style.top.px]=\"profilePanelPos.y\">\n  <div class=\"intensity-panel-header\" (mousedown)=\"onProfilePanelDragStart($event)\">\n    <span>Intensity profile</span>\n    <i class=\"pi pi-arrows-alt\"></i>\n  </div>\n  <div [id]=\"intensityInsetDiv\" class=\"intensity-panel-plot\"></div>\n</div>\n\n<!-- Channels & Histogram: non-modal floating dialog opened from the toolbar. -->\n<channel-histogram [(visible)]=\"showChannelHistogram\"></channel-histogram>\n\n<!-- Region Editor: non-modal, draggable, resizable floating dialog opened from\n     the toolbar (formerly the right-panel Regions tab). Modeless so regions can\n     still be drawn/selected on the plot while it's open; stays linked to this\n     plotting instance via the root RegionStore singleton. Opens over the right\n     side of the view. -->\n<p-dialog header=\"Region Editor\" [(visible)]=\"showRegionEditor\"\n          [modal]=\"false\" [resizable]=\"true\" [draggable]=\"true\"\n          [maximizable]=\"true\" appendTo=\"body\" position=\"right\"\n          [style]=\"{ width: regionEditorWidth, height: '85vh' }\"\n          [contentStyle]=\"{ overflow: 'auto' }\">\n  <region-editor></region-editor>\n</p-dialog>\n\n<!-- Simplify (Douglas\u2013Peucker): custom px-threshold picker for the selected\n     region(s), opened from the right-click \"Simplify \u25B8 Custom\u2026\" action. -->\n<p-dialog header=\"Simplify region(s)\" [(visible)]=\"displaySimplifyDialog\" [modal]=\"true\"\n          [style]=\"{width: '22rem'}\" [draggable]=\"false\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-2\">\n    <span>Altitude threshold: <b>{{ simplifyThreshold }} px</b></span>\n    <p-slider [(ngModel)]=\"simplifyThreshold\" [min]=\"1\" [max]=\"20\" [step]=\"1\"></p-slider>\n    <small>Vertices within this distance of the line between their neighbours are removed.</small>\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" [text]=\"true\" (onClick)=\"displaySimplifyDialog = false\"></p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"simplifyRegions(simplifyThreshold)\"></p-button>\n  </ng-template>\n</p-dialog>\n\n", styles: [":host{display:flex;flex-direction:column;height:100%;overflow:hidden}.viz-plot{flex:1;min-height:0;height:auto!important}.toolbar-dock{display:flex;align-items:stretch;width:100%}.toolbar-dock plotting-toolbar{flex:1;min-width:0}.toolbar-dock.floating{position:fixed;z-index:1000;width:auto;max-width:calc(100% - 16px);background:var(--surface-card, #ffffff);border:1px solid var(--surface-border, #cccccc);border-radius:6px;box-shadow:0 4px 16px #0000004d}.toolbar-dock.floating plotting-toolbar{flex:0 1 auto}.toolbar-dock.floating .toolbar-drag-handle{border-radius:6px 0 0 6px}.toolbar-drag-handle{display:flex;align-items:center;justify-content:center;padding:0 .4rem;cursor:move;color:var(--primary-color);background:var(--surface-100, rgba(0, 0, 0, .04));border-right:1px solid var(--surface-border, #cccccc);-webkit-user-select:none;user-select:none}.toolbar-dock-btn{align-self:center}:host ::ng-deep .navigator{margin-bottom:80px!important;margin-right:12px!important}kbd{background:#e8e8e8;border:1px solid #bbb;border-radius:3px;padding:1px 5px;font-family:monospace;font-size:.85em}::ng-deep .context-menu-active>.p-menuitem-content{background-color:var(--primary-color)!important}::ng-deep .context-menu-active>.p-menuitem-content .p-menuitem-icon,::ng-deep .context-menu-active>.p-menuitem-content .p-menuitem-text{color:#fff!important}::ng-deep .context-menu-active>.p-menuitem-content .zoom-box-off-icon,::ng-deep .context-menu-active>.p-menuitem-content .wand-icon,::ng-deep .context-menu-active>.p-menuitem-content .polyline-icon,::ng-deep .context-menu-active>.p-menuitem-content .polygon-vertices-icon,::ng-deep .context-menu-active>.p-menuitem-content .vertex-add-icon,::ng-deep .context-menu-active>.p-menuitem-content .vertex-delete-icon,::ng-deep .context-menu-active>.p-menuitem-content .region-move-icon,::ng-deep .context-menu-active>.p-menuitem-content .to-bezier-icon,::ng-deep .context-menu-active>.p-menuitem-content .to-polygon-icon{filter:brightness(0) invert(1)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}.progress{position:absolute;width:50%;left:25%;top:55%}.text-loading{position:absolute;margin:0 auto;left:45%;top:60%;font-weight:700}.zoom-text-loading{position:absolute;margin:0 auto;left:35%;top:60%;font-weight:700;display:inline-block;width:350px}.cancel-loading{position:absolute;margin:0 auto;left:46%;top:70%}.spinner{position:absolute;left:45%;top:45%;height:100px;width:100px;margin:0 auto;-webkit-animation:rotation .6s infinite linear;-moz-animation:rotation .6s infinite linear;-o-animation:rotation .6s infinite linear;animation:rotation .6s infinite linear;border-left:6px solid rgba(0,174,239,.15);border-right:6px solid rgba(0,174,239,.15);border-bottom:6px solid rgba(0,174,239,.15);border-top:6px solid rgb(82,107,178);border-radius:100%}#overlay{position:absolute;top:0;left:0;width:100%;height:100%;background-color:#ffffff80;z-index:1000}#sharpening-overlay{position:absolute;top:0;left:0;width:100%;height:100%;background-color:#ffffff2e;pointer-events:none;z-index:1000}#sharpening-overlay .spinner{height:60px;width:60px;border-width:4px;left:calc(50% - 30px);top:calc(50% - 60px)}#sharpening-overlay .text-loading{position:absolute;left:0;right:0;width:auto;text-align:center;top:calc(50% + 35px);font-size:.9rem;color:#526bb2}@-webkit-keyframes rotation{0%{-webkit-transform:rotate(0deg)}to{-webkit-transform:rotate(359deg)}}@-moz-keyframes rotation{0%{-moz-transform:rotate(0deg)}to{-moz-transform:rotate(359deg)}}@-o-keyframes rotation{0%{-o-transform:rotate(0deg)}to{-o-transform:rotate(359deg)}}@keyframes rotation{0%{transform:rotate(0)}to{transform:rotate(359deg)}}::ng-deep .zoom-box-off-icon{background:url('data:image/svg+xml,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 100 100\" fill=\"black\" fill-rule=\"evenodd\">%0A  <!-- Rectangle outline -->%0A  <rect x=\"2\" y=\"2\" width=\"56\" height=\"56\"/>%0A  <rect x=\"9\" y=\"9\" width=\"42\" height=\"42\"/>%0A  <!-- Magnifying glass ring -->%0A  <circle cx=\"70\" cy=\"70\" r=\"23\"/>%0A  <circle cx=\"70\" cy=\"70\" r=\"14\"/>%0A  <!-- Handle -->%0A  <polygon points=\"81,81 97,97 92,100 77,85\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .wand-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<svg%0A   viewBox=\"0 0 100 100\"%0A   fill=\"black\"%0A   fill-rule=\"evenodd\"%0A   version=\"1.1\"%0A   id=\"svg4\"%0A   sodipodi:docname=\"wand.svg\"%0A   inkscape:version=\"1.4.3 (0d15f75, 2025-12-25)\"%0A   xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\"%0A   xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\"%0A   xmlns=\"http://www.w3.org/2000/svg\"%0A   xmlns:svg=\"http://www.w3.org/2000/svg\">%0A  <defs%0A     id=\"defs4\" />%0A  <sodipodi:namedview%0A     id=\"namedview4\"%0A     pagecolor=\"%23ffffff\"%0A     bordercolor=\"%23000000\"%0A     borderopacity=\"0.25\"%0A     inkscape:showpageshadow=\"2\"%0A     inkscape:pageopacity=\"0.0\"%0A     inkscape:pagecheckerboard=\"0\"%0A     inkscape:deskcolor=\"%23d1d1d1\"%0A     inkscape:zoom=\"8.74\"%0A     inkscape:cx=\"50\"%0A     inkscape:cy=\"49.942792\"%0A     inkscape:window-width=\"1024\"%0A     inkscape:window-height=\"1186\"%0A     inkscape:window-x=\"3560\"%0A     inkscape:window-y=\"131\"%0A     inkscape:window-maximized=\"0\"%0A     inkscape:current-layer=\"svg4\" />%0A  <!-- Wand handle: thin diagonal stick from lower-left to upper-right -->%0A  <polygon%0A     points=\"12,92 78,26 74,22 8,88 \"%0A     id=\"polygon1\"%0A     transform=\"matrix(1.0375192,0.05799445,0.25179496,0.91871864,-17.85351,5.6289793)\" />%0A  <!-- 4-pointed star at the wand tip -->%0A  <polygon%0A     points=\"62,34 76,30 80,6 84,30 98,34 84,38 80,62 76,38 \"%0A     id=\"polygon2\"%0A     transform=\"matrix(1.3082889,0,0,1.0245178,-38.907958,-1.4056881)\" />%0A  <!-- Small sparkle to the upper-left -->%0A  <polygon%0A     points=\"46,30 36,32 34,42 32,32 22,30 32,28 34,18 36,28 \"%0A     id=\"polygon3\"%0A     transform=\"translate(-9.610984,-6.7505721)\" />%0A  <!-- Small sparkle to the lower-right -->%0A  <polygon%0A     points=\"62,80 70,82 62,84 60,92 58,84 50,82 58,80 60,72 \"%0A     id=\"polygon4\"%0A     transform=\"translate(0,-1.6018307)\" />%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .brush-icon{background:url('data:image/svg+xml,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 640 640\"><!--!Font Awesome Free 7.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d=\"M512.5 74.3L291.1 222C262 241.4 243.5 272.9 240.5 307.3C302.8 320.1 351.9 369.2 364.8 431.6C399.3 428.6 430.7 410.1 450.1 381L597.7 159.5C604.4 149.4 608 137.6 608 125.4C608 91.5 580.5 64 546.6 64C534.5 64 522.6 67.6 512.5 74.3zM320 464C320 402.1 269.9 352 208 352C146.1 352 96 402.1 96 464C96 467.9 96.2 471.8 96.6 475.6C98.4 493.1 86.4 512 68.8 512L64 512C46.3 512 32 526.3 32 544C32 561.7 46.3 576 64 576L208 576C269.9 576 320 525.9 320 464z\"/></svg>') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .polyline-icon{background:url('data:image/svg+xml,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\">%0A  <polyline points=\"1,14 5,3 10,11 15,2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .polygon-vertices-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Polygon (click-to-place) tool icon: a traced polyline with vertex dots. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <g transform=\"matrix(1.4740709,0,0,1.4740709,-6.0268793,-6.8086826)\">%0A    <polyline points=\"23.877,16.627 14.657,10.767 5.25,21.551 12.757,29.397\"%0A              fill=\"none\" stroke=\"%23000000\" stroke-width=\"1.6\"%0A              stroke-linejoin=\"round\" stroke-linecap=\"round\"/>%0A    <circle cx=\"23.877\" cy=\"16.627\" r=\"1.9\"/>%0A    <circle cx=\"14.657\" cy=\"10.767\" r=\"1.9\"/>%0A    <circle cx=\"5.25\" cy=\"21.551\" r=\"1.9\"/>%0A    <circle cx=\"12.757\" cy=\"29.397\" r=\"1.9\"/>%0A  </g>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .vertex-add-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Add-vertex tool icon: a region blob with three corner vertices and a plus glyph. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <g transform=\"matrix(1.5222969,0,0,1.5222969,-8.2143505,-7.6146399)\">%0A    <path d=\"m 9.35834,12.33267 c 1.78,-2.53 4.93,-3.56 7.86,-3.98 3.98,-0.72 8.33,0.08 11.52,2.67 2.62,1.98 4.71,5.1 4.53,8.49 -0.29,2.27 -2.5,3.81 -4.66,4.01 -2.75,0.43 -5.54,0.07 -8.28,-0.26 -3.99,-0.68 -8.05,-2.16 -10.93,-5.12 -1.32,-1.63 -1.39,-4.17 -0.04,-5.81 z\"%0A          fill=\"none\" stroke=\"%23000000\" stroke-width=\"1.6\" stroke-miterlimit=\"10\"/>%0A    <circle cx=\"8.294\" cy=\"15.248\" r=\"2.63\"/>%0A    <circle cx=\"19.781\" cy=\"8.287\" r=\"2.63\"/>%0A    <circle cx=\"25.044\" cy=\"23.748\" r=\"2.63\"/>%0A  </g>%0A  <path d=\"M 9.65,29.0 H 5.85 v 5.3 H 0.55 v 3.4 H 5.85 v 5.3 H 9.65 V 37.7 H 14.95 V 34.3 H 9.65 Z\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .vertex-delete-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Delete-vertex tool icon: a region blob with three corner vertices and a minus glyph. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <g transform=\"matrix(1.5222969,0,0,1.5222969,-8.2143505,-7.6146399)\">%0A    <path d=\"m 9.35834,12.33267 c 1.78,-2.53 4.93,-3.56 7.86,-3.98 3.98,-0.72 8.33,0.08 11.52,2.67 2.62,1.98 4.71,5.1 4.53,8.49 -0.29,2.27 -2.5,3.81 -4.66,4.01 -2.75,0.43 -5.54,0.07 -8.28,-0.26 -3.99,-0.68 -8.05,-2.16 -10.93,-5.12 -1.32,-1.63 -1.39,-4.17 -0.04,-5.81 z\"%0A          fill=\"none\" stroke=\"%23000000\" stroke-width=\"1.6\" stroke-miterlimit=\"10\"/>%0A    <circle cx=\"8.294\" cy=\"15.248\" r=\"2.63\"/>%0A    <circle cx=\"19.781\" cy=\"8.287\" r=\"2.63\"/>%0A    <circle cx=\"25.044\" cy=\"23.748\" r=\"2.63\"/>%0A  </g>%0A  <path d=\"M 0.55,34.3 v 3.4 H 14.95 V 34.3 Z\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .region-move-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Region-move tool icon: a region blob with a drag arrow. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <path d=\"m 17.115582,8.9648664 c 1.707597,-3.3276806 4.729468,-4.6824281 7.540287,-5.2348498 3.827703,-0.947008 7.991169,0.1052238 11.051414,3.5118228 2.523022,2.604273 4.518416,6.7079726 4.345738,11.1668036 -0.278204,2.985704 -2.398311,5.011251 -4.470451,5.274308 -2.638142,0.565574 -5.314655,0.09206 -7.943203,-0.341976 C 23.811664,22.446579 19.916808,20.499952 17.153955,16.606696 15.89724,14.462775 15.820494,11.12194 17.115585,8.9648664 Z\"%0A        fill=\"none\" stroke=\"%23000000\" stroke-width=\"2.1\" stroke-miterlimit=\"10\"/>%0A  <path d=\"m 26.741429,13.966963 6.746922,16.786269 3.229398,-4.060758 3.583857,3.583857 2.761195,-2.761196 -3.583856,-3.571852 4.060758,-3.2354 z\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .to-bezier-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Convert-to-bezier tool icon: a smooth curve through two anchor points with control handles. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <!-- smooth cubic curve between the two anchors -->%0A  <path d=\"M 7,34 C 7,16 37,28 37,10\" fill=\"none\" stroke=\"%23000000\" stroke-width=\"2.4\"%0A        stroke-linecap=\"round\"/>%0A  <!-- control handles -->%0A  <line x1=\"7\" y1=\"34\" x2=\"7\" y2=\"22\" stroke=\"%23000000\" stroke-width=\"1.4\"/>%0A  <line x1=\"37\" y1=\"10\" x2=\"37\" y2=\"22\" stroke=\"%23000000\" stroke-width=\"1.4\"/>%0A  <circle cx=\"7\" cy=\"22\" r=\"2.2\"/>%0A  <circle cx=\"37\" cy=\"22\" r=\"2.2\"/>%0A  <!-- anchor points -->%0A  <rect x=\"4\" y=\"31\" width=\"6\" height=\"6\" rx=\"1\"/>%0A  <rect x=\"34\" y=\"7\" width=\"6\" height=\"6\" rx=\"1\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}::ng-deep .to-polygon-icon{background:url('data:image/svg+xml,<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>%0A<!-- Convert-to-polygon tool icon: endpoints joined by straight segments through a vertex. -->%0A<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 44 44\" width=\"44\" height=\"44\" fill=\"%23000000\">%0A  <!-- straight-segment path through the vertices -->%0A  <polyline points=\"7,34 22,12 37,10\" fill=\"none\" stroke=\"%23000000\" stroke-width=\"2.4\"%0A            stroke-linecap=\"round\" stroke-linejoin=\"round\"/>%0A  <!-- vertices -->%0A  <rect x=\"4\" y=\"31\" width=\"6\" height=\"6\" rx=\"1\"/>%0A  <rect x=\"19\" y=\"9\" width=\"6\" height=\"6\" rx=\"1\"/>%0A  <rect x=\"34\" y=\"7\" width=\"6\" height=\"6\" rx=\"1\"/>%0A</svg>%0A') no-repeat center center;background-size:contain;width:1.25rem;height:1.25rem;display:inline-block;filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.intensity-panel{position:fixed;z-index:1100;width:280px;height:180px;background:#191919e6;border:1px solid var(--primary-color, #3399ff);border-radius:6px;box-shadow:0 4px 14px #00000073;display:flex;flex-direction:column;overflow:hidden}.intensity-panel-header{display:flex;align-items:center;justify-content:space-between;padding:.25rem .5rem;cursor:move;-webkit-user-select:none;user-select:none;background:#ffffff14;color:#eee;font-size:.75rem;font-weight:600}.intensity-panel-header i{opacity:.6;font-size:.7rem}.intensity-panel-plot{flex:1 1 auto;width:100%}:host ::ng-deep .sam-progress .p-progressbar-value{transition:none}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IMAGE_STATE_PORT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VISUALIZER]
+                }] }, { type: i1.MessageService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i2.VisualizerStore }, { type: i3.SamToolService }, { type: i4.CellSegmentToolService }, { type: i5.SamPointToolService }, { type: i6.RegionOpsService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [VIZ_CONFIG]
+                }] }], propDecorators: { isStackEvent: [{
+                type: Output
+            }], isGrayscaleEvent: [{
+                type: Output
+            }], toolbarTools: [{
+                type: Input
+            }], testMode: [{
+                type: Input
+            }], contextMenu: [{
+                type: ViewChild,
+                args: ['cm']
+            }], onKeydown: [{
+                type: HostListener,
+                args: ['window:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"visualizer.component.js","sourceRoot":"","sources":["../../../src/lib/visualizer.component.ts","../../../src/lib/visualizer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, AfterViewInit, EventEmitter, HostListener, Inject, Input, NgZone, OnChanges, OnDestroy, OnInit, Optional, Output, SimpleChanges, ViewChild } from '@angular/core';\n\nimport { BehaviorSubject, Subject, Subscription } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { MenuItem, MessageService, TreeNode } from 'primeng/api';\nimport { ContextMenu } from 'primeng/contextmenu';\nimport { IImageInfo } from './contracts/image.contract';\nimport { ImageStatePort, IMAGE_STATE_PORT } from './contracts/ports/image-state.port';\nimport { Polygon, Rectangle, MultiPolygon, Region } from './models/region';\nimport { RegionOpsService } from './region-ops.service';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { RenderOrchestrator, SliceScrubber } from './render-orchestrator';\nimport {\n  PlotType,\n  PlotTypeDescriptor,\n  isNapari3d,\n  NAPARI_DEFAULT_DECIMATE,\n} from './contracts/plot-type';\nimport { ViewerFeature } from './contracts/capabilities.contract';\nimport { IntensityProfile, IVisualizer, VISUALIZER } from './contracts/visualizer.contract';\nimport { SAM_MODELS, getDefaultSamModelId, isSamModelReady } from './toolbar/segmentation/sam-model-registry';\nimport { SamToolService } from './toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from './toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from './toolbar/segmentation/cell-segment-tool.service';\nimport { RegionToolMode } from './contracts/region-overlay.contract';\nimport { ToolbarToolVisibility, ALL_TOOLBAR_TOOLS } from './contracts/toolbar-config';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\n\n/** Per-instance plot-div id source. The mount element's id must be unique so two\n *  live viewers (e.g. the main diagram + a modal preview) don't collide on the\n *  same DOM id — `getElementById` would otherwise return whichever came first.\n *  Styling hangs off the `.viz-plot` class instead of the id. */\nlet plotInstanceSeq = 0;\n\n@Component({\n  // Canonical prefixed selector first; the unprefixed original is kept as an\n  // alias for one release (pre-publication back-compat).\n  selector: 'visualizer',\n  templateUrl: './visualizer.component.html',\n  styleUrls: ['./visualizer.component.scss'],\n})\nexport class VisualizerComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {\n  /** Per-instance toast key. MessageService is a global singleton, so two live\n   *  `<visualizer>` instances (main viewer + pipeline-dialog preview) sharing\n   *  one key would each render the same message — a duplicate toast. A unique\n   *  key per instance scopes the toast to the component that raised it. */\n  private static nextToastId = 0;\n\n  @Output()\n  isStackEvent = new EventEmitter(false);\n  @Output()\n  isGrayscaleEvent = new EventEmitter(false);\n\n  /** Which toolbar groups to show. A partial override merges over the full set,\n   *  so `{ specialTools: false }` hides only that group. Defaults to everything. */\n  @Input()\n  set toolbarTools(v: ToolbarToolVisibility | undefined) {\n    this._toolbarTools = { ...ALL_TOOLBAR_TOOLS, ...(v ?? {}) };\n  }\n\n  get toolbarTools(): Required<ToolbarToolVisibility> {\n    return this._toolbarTools;\n  }\n  private _toolbarTools: Required<ToolbarToolVisibility> = ALL_TOOLBAR_TOOLS;\n\n  /** Expose test-only plot modes in the selector (e.g. the napari `Image`\n   *  mode, otherwise hidden). The host app sets this from a `?test=1` URL\n   *  toggle. Off by default, so production users never see them. */\n  @Input()\n  testMode = false;\n\n  /** Image-smoothing state for the toolbar's Smoothen toggle (OSD only).\n   *  Defaults to `false` so OSD shows raw pixels (nearest-neighbour). */\n  imageSmoothingEnabled = false;\n  loadingMessage = 'Loading image...';\n  zoom = false;\n  fileName: string | undefined;\n  private loadedFileName: string | undefined;\n  imageInfo: IImageInfo | undefined;\n\n  private unsub = new Subject<void>();\n  private previewSubscription = new Subscription();\n\n  public stackLoading = false;\n  public imgLoading = false;\n  public loadingPercentage = 0;\n  // Non-null (0..100) while jit-service is copying the source file into the\n  // local cache PVC on first click. When set, the loading overlay swaps the\n  // spinner for a determinate progress bar with a \"Caching image\" message.\n  public cacheProgress: number | null = null;\n  // True between the small-tier render landing and the large-tier render\n  // landing in the multi-tier rendering path. The template uses this to\n  // overlay a translucent spinner on top of the blurry small-tier image so\n  // the user doesn't mistake it for the final preview.\n  public sharpening = false;\n  /** A jit-service cache copy is actively in progress (determinate 0..99). Drives the cache\n   *  progress bar independently of `imgLoading` so the bar can't be dropped — or masked by the\n   *  \"Sharpening preview...\" overlay — mid-download if the loading flag flips early. */\n  get isCaching(): boolean {\n    return this.cacheProgress !== null && this.cacheProgress < 100;\n  }\n  private running = false;\n  public zIndex = 0;\n  public maxIndex = 0;\n\n  @ViewChild('cm') contextMenu!: ContextMenu;\n  contextMenuItems: MenuItem[] = [];\n\n  activeDragMode: string | null = null;\n\n  /** Whether a region action is available to undo (jit-ui#85). Mirrors the\n   *  shared RegionStore's history depth; drives the toolbar Undo button. */\n  canUndoRegion = false;\n  /** Whether an undone region action is available to redo (jit-ui#85). */\n  canRedoRegion = false;\n\n  /** Custom-threshold Simplify dialog (jit-ui#85). */\n  displaySimplifyDialog = false;\n  simplifyThreshold = 3;\n  /** Current region selection (array indices) — mirrored from the store so the\n   *  context-menu region actions can read it synchronously (jit-ui#85). */\n  private selectedIndices: number[] = [];\n\n  /** Wand sensitivity — higher = stricter (smaller selection). Matches QuPath default. */\n  wandSensitivity = 2.0;\n  /** Brush diameter in image-pixel coordinates (drives the painted disc size). */\n  brushSize = 40;\n  /** SAM model picker options + current selection (jit-ui#90 P1). Only models\n   *  with a hosted ONNX pair (configured via setSamModelUrls at app init) are\n   *  offered, so the picker can't select a model that can't run. */\n  samModels = SAM_MODELS.filter(isSamModelReady).map((m) => ({ id: m.id, label: m.label }));\n  samModelId = getDefaultSamModelId();\n  /** SAM download/segment toast state (bound by the `sam` p-toast template). */\n  samStatus = '';\n  samProgress = 0; // 0..100, encoder download\n  samDownloading = false;\n  samBusy = false; // any SAM work in flight (drives the indeterminate spinner)\n  /** Whether the shared `sam` toast is currently shown (avoids stacking it on\n   *  every point click, which re-runs inference). */\n  private samToastShown = false;\n\n  readonly samToastKey = `sam-${VisualizerComponent.nextToastId++}`;\n  /** Subscriptions to the point tool's live feeds (status/busy/download). */\n  private samPointSub = new Subscription();\n  /** Vertex eraser radius in image-pixel coordinates. */\n  vertexEraserRadius = 20;\n\n  colormapsOptions!: any;\n  reversescale = false;\n  selectedColormap!: any;\n  /** Channels & Histogram dialog visibility (opened from the toolbar). */\n  showChannelHistogram = false;\n  /** Region Editor dialog visibility (opened from the toolbar). */\n  showRegionEditor = false;\n  /** Region Editor dialog width. On open it is set to the configured host\n   *  element's current width, or — when no selector is configured / the element\n   *  isn't found — to a quarter of the page (see openRegionEditor). */\n  regionEditorWidth = '25vw';\n  stackOptions = [\n    { name: 'Single image', val: 'false' },\n    { name: 'Stack', val: 'true' },\n  ];\n  selectedStackOption: { name: string; val: string } | undefined = this.stackOptions[0];\n  readonly plotDivName = `viz-plot-${plotInstanceSeq++}`;\n  plotType = PlotType.IMAGE;\n  isHeatmap = true;\n  activeSurface3dMode = 'turntable';\n  /** Whether the napari 3D coordinate-axes / scale gizmo is shown (volume/isosurface). */\n  axesVisible = true;\n  wireframeActive = false;\n  /** napari 3D decimate factor (1 = Full … 8 = ⅛; default ½); changing it re-plots. */\n  resolutionScale = NAPARI_DEFAULT_DECIMATE;\n\n  /** Plot types the active backend advertises (3D gated by capability). */\n  plotTypeOptions: PlotTypeDescriptor[] = [];\n  selectedPlotType: PlotType = PlotType.IMAGE;\n\n  /** Floating intensity-profile inset (LINE mode). */\n  readonly intensityInsetDiv = 'intensity-inset-plot';\n  profilePanelPos = { x: 20, y: 70 };\n  private profilePanelDragging = false;\n  private profilePanelStart = { mx: 0, my: 0, x: 0, y: 0 };\n\n  /** Toolbar docking: docked across the top by default; dragging its handle\n   *  detaches it into a floating, movable window (frees the top row for the\n   *  visualization). */\n  toolbarFloating = false;\n  toolbarPos = { x: 8, y: 8 };\n  private toolbarDragging = false;\n  private toolbarStart = { mx: 0, my: 0, x: 0, y: 0 };\n  private latestProfiles: IntensityProfile[] = [];\n  /** Drives the intensity inset panel's visibility — true whenever any\n   *  intensity-profile line exists (independent of the current plot type). */\n  hasProfiles = false;\n  private intensityProfileSub?: Subscription;\n  private viewportChangeSub?: Subscription;\n  private profileDragMoveListener?: (e: MouseEvent) => void;\n  private profileDragUpListener?: () => void;\n  private profileResizeListener?: () => void;\n\n  /** LINE plot type shows the image + draggable line ROI + intensity inset. */\n  get isProfileMode(): boolean {\n    return this.selectedPlotType === PlotType.LINE;\n  }\n\n  /** True for the Image plot type, which renders as a natively pan/zoom-able\n   *  raster — so the backend-agnostic zoom/pan toolbar tools are hidden. The\n   *  component drives this off the plot type, not the active backend. */\n  get isImageView(): boolean {\n    return this.selectedPlotType === PlotType.IMAGE;\n  }\n\n  /** Isosurface band as a 0–255 slider position, mapped onto the volume's real\n   *  intensity range by the renderer. Defaults to the full range. */\n  isoRange: number[] = [0, 255];\n\n  plotWidthSubscription?: Subscription;\n  imageLoadingSubscription?: Subscription;\n  imgLoadingMessageSubscription?: Subscription;\n  isZoomSubscription?: Subscription;\n  filenameSubscription?: Subscription;\n  autoscaleSubscription?: Subscription;\n\n  private plotContextMenuListener?: (e: MouseEvent) => void;\n  private keydownListener?: (e: KeyboardEvent) => void;\n  private wheelListener?: (e: WheelEvent) => void;\n\n  /** Debounced z-slice scrubbing (see SliceScrubber — refactoring plan Step 7). */\n  private readonly scrubber = new SliceScrubber((z) => {\n    this.plotService.setZIndex(z);\n    // In a per-slice z-stack session the store swaps the live region set to this\n    // slice (preserving edits made on the previous one); outside stack mode this\n    // just records the slice, leaving single-plane regions untouched (jit-ui#93).\n    this.plotService.setDisplaySlice(z);\n  });\n\n  constructor(\n    @Inject(IMAGE_STATE_PORT) private state: ImageStatePort,\n    @Inject(VISUALIZER) public plotService: IVisualizer,\n    public messageService: MessageService,\n    private ngZone: NgZone,\n    private cdr: ChangeDetectorRef,\n    private session: VisualizerStore,\n    private samTool: SamToolService,\n    private cellSegmentTool: CellSegmentToolService,\n    private samPointTool: SamPointToolService,\n    private regionOps: RegionOpsService,\n    @Optional() @Inject(VIZ_CONFIG) private vizConfig?: VizConfig,\n  ) {\n    this.colormapsOptions = plotService.getColormapOptions();\n    this.computePlotTypeOptions();\n  }\n\n  /**\n   * Plot types offered in the selector for the current image:\n   *  - Outside **test mode**, only the curated default set (descriptors with a\n   *    `productionLabel`) is offered, shown under suffix-free names — Image,\n   *    Heatmap, Contour and the napari Surface / Volume / Isosurface. Test mode\n   *    exposes every backend's type under its full (backend-suffixed) label.\n   *  - 3D types hidden when the backend can't render a 3D scene.\n   *  - stack-only types (volume, isosurface) hidden unless the file is a stack —\n   *    a volume needs multiple z-slices.\n   *  - scalar-intensity types (contour, surface, isosurface) hidden for RGB\n   *    images — they map a single intensity per pixel. Image and Heatmap render\n   *    any image.\n   */\n  private computePlotTypeOptions() {\n    const caps = this.plotService.capabilities;\n    const isStack = !!this.imageInfo?.isStack;\n    const isGrayscale = !!this.imageInfo?.isGrayscale;\n    this.plotTypeOptions = this.plotService.getPlotTypeDescriptors()\n      .filter((d) => {\n        // Outside test mode, only the curated set (those with a productionLabel)\n        // is offered; test mode exposes every backend's type.\n        if (!this.testMode && !d.productionLabel) return false;\n        if (d.dimensions === '3d' && !caps.has(ViewerFeature.Surface3D)) return false;\n        if (d.requiresStack && !isStack) return false;\n        if (d.requiresGrayscale && !isGrayscale) return false;\n        return true;\n      })\n      // Default selector shows the suffix-free productionLabel; test mode keeps\n      // the full backend-suffixed label so same-named modes stay distinguishable.\n      .map((d) => (this.testMode ? d : { ...d, label: d.productionLabel! }));\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // The constructor computes the options with testMode still at its default;\n    // recompute once the host binds it (and on any later change) so the selector\n    // reflects test mode immediately, without waiting for an image to (re)load.\n    if (changes['testMode']) {\n      this.computePlotTypeOptions();\n      // If test mode is turned off while a test-only type (e.g. NAPARI_IMAGE) is\n      // active, that type is no longer offered — fall back to Image.\n      this.reconcileSelectedPlotType();\n    }\n  }\n\n  /** If the active plot type is no longer in the offered options (e.g. test mode\n   *  turned off while a test-only type was active, or a scalar type carried onto\n   *  an RGB image), fall back to the default 2D Image view. */\n  private reconcileSelectedPlotType(): void {\n    if (!this.plotTypeOptions.some((d) => d.type === this.selectedPlotType)) {\n      this.selectedPlotType = PlotType.IMAGE;\n      this.plotType = PlotType.IMAGE;\n      this.isHeatmap = true;\n      this.plotService.setPlotType(PlotType.IMAGE);\n    }\n  }\n\n  ngOnInit(): void {\n    this.state.setDiagram(this);\n    this.selectedColormap =\n      this.colormapsOptions[0].children.find((c: any) => c.label === 'Greys Inv') ??\n      this.colormapsOptions[0].children[0];\n    this.stackOptions = [\n      { name: 'Single image', val: 'false' },\n      { name: 'Stack', val: 'true' },\n    ];\n    this.selectedStackOption = this.stackOptions[0];\n    this.autoscaleSubscription = this.plotService.getAutoscaleEvent().subscribe(() => {\n      // reset the image mode to single image\n      this.selectedStackOption = { name: 'Single image', val: 'false' };\n      this.activeDragMode = null;\n      this.session.setActiveTool(null);\n    });\n    this.imageLoadingSubscription = this.state.isImageLoading$().subscribe((isImageLoading) => {\n      this.imgLoading = isImageLoading;\n    });\n    // Undo availability (jit-ui#85): the shared RegionStore emits whenever its\n    // history depth changes; greys out the toolbar Undo button accordingly.\n    this.plotService\n      .getCanUndo$()\n      .pipe(takeUntil(this.unsub))\n      .subscribe((canUndo) => {\n        this.canUndoRegion = canUndo;\n        this.cdr.detectChanges();\n      });\n    this.plotService\n      .getCanRedo$()\n      .pipe(takeUntil(this.unsub))\n      .subscribe((canRedo) => {\n        this.canRedoRegion = canRedo;\n        this.cdr.detectChanges();\n      });\n    // Mirror the region selection so the right-click action group (jit-ui#85)\n    // can read it synchronously when the menu is built.\n    this.plotService\n      .getSelectedShapeIndices$()\n      .pipe(takeUntil(this.unsub))\n      .subscribe((indices) => {\n        this.selectedIndices = indices || [];\n      });\n    // Interactive point-prompt segmentation runs inside the renderer on each\n    // click; surface its live status + download progress in the shared `sam`\n    // toast so the user sees it working (the first click pulls the encoder).\n    this.samPointSub.add(\n      this.samPointTool.progress$.subscribe((f) => {\n        this.samDownloading = f >= 0 && f < 1;\n        if (f >= 0) this.samProgress = Math.min(100, Math.round(f * 100));\n        this.cdr.detectChanges();\n      }),\n    );\n    this.samPointSub.add(\n      this.samPointTool.status$.subscribe((m) => {\n        this.samStatus = m;\n        this.cdr.detectChanges();\n      }),\n    );\n    this.samPointSub.add(\n      this.samPointTool.busy$.subscribe((busy) => {\n        this.samBusy = busy;\n        if (busy) this.showSamToast('SAM point segmentation');\n        this.cdr.detectChanges();\n      }),\n    );\n    this.plotService.getStackLoadingProgress().subscribe((loadingProgress) => {\n      this.loadingPercentage = loadingProgress;\n    });\n    this.plotService.isStackLoading().subscribe((stackLoading) => {\n      this.stackLoading = stackLoading;\n    });\n    this.plotWidthSubscription = this.state.getPanelWidth$().subscribe(() => {\n      this.plotService.relayout();\n      // The intensity inset is a separate Plotly chart in a floating panel; reflow\n      // it to its current size when the canvas resizes, else it keeps the stale\n      // size and blanks out. Defer a tick so the panel layout has settled.\n      if (this.hasProfiles) {\n        setTimeout(() => this.renderIntensityInset(), 0);\n      }\n    });\n    this.imgLoadingMessageSubscription = this.state.getImageLoadingMessage$().subscribe((message) => {\n      this.loadingMessage = message;\n    });\n    this.state\n      .getCacheProgress$()\n      .pipe(takeUntil(this.unsub))\n      .subscribe((progress) => {\n        this.cacheProgress = progress;\n      });\n    this.isZoomSubscription = this.state.isZoom$().subscribe((zoom) => {\n      this.zoom = zoom;\n    });\n    this.filenameSubscription = this.state.getFilename$().subscribe((filename) => {\n      if (filename) {\n        this.fileName = filename;\n      }\n    });\n    this.plotService.getColormap().subscribe((colormap) => {\n      this.selectedColormap = colormap;\n    });\n    this.plotService.getReverseScale().subscribe((reversescale) => {\n      this.reversescale = reversescale;\n    });\n    this.intensityProfileSub = this.plotService.getIntensityProfile$().subscribe((profiles) => {\n      this.latestProfiles = profiles;\n      this.hasProfiles = profiles.length > 0;\n      // The panel div is behind *ngIf=\"hasProfiles\". detectChanges() materializes\n      // it synchronously (the subscription may fire outside Angular's zone — e.g.\n      // from an OSD drag — so CD wouldn't run on its own). Then render on the next\n      // animation frame, AFTER the browser lays the panel out: a synchronous draw\n      // hits a zero-size container on first create and Plotly keeps that size, so\n      // the inset stays blank and live updates redraw into the same zero box.\n      this.cdr.detectChanges();\n      requestAnimationFrame(() => this.renderIntensityInset());\n    });\n    // When the OSD view settles at a new zoom/pan, re-sample the intensity lines\n    // from a crop of the visible region so the inset reflects the zoom-level\n    // resolution (Plotly's own high-def zoom updates the sampling cache inline).\n    this.viewportChangeSub = this.plotService.getViewportChange$().subscribe((roi) => {\n      if (this.hasProfiles && this.isImageView) {\n        this.plotService.refreshIntensitySamplingForRoi(roi.x, roi.y, roi.width, roi.height, this.zIndex);\n      }\n    });\n    this.previewSubscription = this.state.getImageInfo$().subscribe({\n      next: (imgInfo) => {\n        if (imgInfo) {\n          this.imageInfo = imgInfo;\n          // Stack-only plot types (isosurface, scatter3d) depend on whether this\n          // file is a stack — recompute the selector options.\n          this.computePlotTypeOptions();\n          // If the active plot type isn't valid for this image (e.g. a scalar\n          // type like Contour carried over to an RGB image), fall back to Image.\n          this.reconcileSelectedPlotType();\n          // reset stack options selection\n          this.selectedStackOption = imgInfo.showStack ? this.stackOptions[1] : this.stackOptions[0];\n\n          this.isGrayscaleEvent.emit(this.imageInfo.isGrayscale);\n          this.isStackEvent.emit(this.imageInfo.isStack);\n          // Reset to the default 2D Image view when a different image is\n          // selected while a 3D type is active.\n          if (!this.isHeatmap && imgInfo.fileName !== this.loadedFileName) {\n            this.isHeatmap = true;\n            this.plotType = PlotType.IMAGE;\n            this.selectedPlotType = PlotType.IMAGE;\n            this.plotService.setPlotType(this.plotType);\n            this.activeSurface3dMode = 'turntable';\n          }\n          this.loadedFileName = imgInfo.fileName;\n          this.plotService.setImageMeta(this.imageInfo.imageMeta);\n          const urls = imgInfo.urls;\n          if (!this.running) {\n            // image size — measure the plot div directly so the toolbar height is excluded\n            const plotDiv: HTMLElement | null = document.getElementById(this.plotDivName);\n            const screenHeight = plotDiv?.offsetHeight || 500;\n            if (urls) {\n              this.plotService.reset();\n              this.stackLoading = imgInfo.isStack && imgInfo.showStack;\n              // set max index of stack — computed before updateZIndex so a\n              // fresh stack (shorter or longer than whatever was previously\n              // loaded) clamps against ITS bounds, not the stale ones.\n              // One URL per slice (0-indexed), so the last reachable index is\n              // length-1 — earlier `length-2` dropped the final slice.\n              this.maxIndex = urls.length > 1 ? urls.length - 1 : 0;\n              // One-shot hint: jump straight to a specific slice (e.g. the\n              // file the user actually clicked within a numbered series).\n              // Consumed immediately so redelivering the same ImageInfo later\n              // (a plot-type switch, reloadAndPlot) doesn't reset the user's\n              // current scrub position back to it.\n              if (imgInfo.initialZIndex !== undefined) {\n                this.zIndex = imgInfo.initialZIndex;\n                imgInfo.initialZIndex = undefined;\n              }\n              // make sure the zindex is within bounds\n              this.updateZIndex(urls);\n              this.running = true;\n              // Multi-tier rendering (small blurry tier first, then sharpen in\n              // place) — sequencing lives in RenderOrchestrator; this component\n              // supplies the phase render and owns the UI flags via callbacks.\n              // 3D plot types render single-pass: the in-place large pass doesn't\n              // rebuild a 3D gl-mesh isosurface, so the sharpen step blanked it.\n              const hasSmallTier =\n                this.isHeatmap &&\n                (imgInfo.smallUrls?.length ?? 0) === urls.length &&\n                (imgInfo.smallUrls?.length ?? 0) > 0;\n              const smallImgInfo = hasSmallTier ? { ...imgInfo, urls: imgInfo.smallUrls as string[] } : null;\n\n              // Enter per-slice stack mode with the given slice→regions map and\n              // seed the \"previous shapes\" from the now-live slice. enterStackMode\n              // makes zIndex's slice live and resets undo (jit-ui#93).\n              const enterStack = (\n                slices: Map<number, Region[]>,\n                layout: 'combined' | 'per-slice-file',\n              ) => {\n                this.plotService.enterStackMode(slices, this.zIndex, layout);\n                const shapes = this.plotService\n                  .getRegions()\n                  .map((region) => region.getShape(this.plotService.getShowShapeLabel()));\n                this.plotService.setPreviousShapes(shapes);\n              };\n\n              const applyRoi = () => {\n                // Folder stack: a stack of self-contained per-slice files\n                // (tiled === false; see loadSeriesAsStack). Each slice-file may\n                // carry its own sibling \"<stem>.geojson\" (roiJsonStrs[z]), but a\n                // fresh folder with none yet leaves roiJsonStrs undefined — key\n                // off `tiled === false`, NOT roiJsonStrs, so an unannotated\n                // folder stack still enters the per-slice-file layout (and saves\n                // back one geojson per slice-file) rather than falling through to\n                // the single-file combined path (jit-ui#93).\n                if (imgInfo.isStack && imgInfo.tiled === false) {\n                  const perSlice = imgInfo.roiJsonStrs;\n                  const sliceCount = imgInfo.urls?.length ?? perSlice?.length ?? 0;\n                  const slices = new Map<number, Region[]>();\n                  for (let z = 0; z < sliceCount; z++) {\n                    const json = perSlice?.[z] ?? null;\n                    slices.set(z, json ? this.plotService.importRegions(json) : []);\n                  }\n                  enterStack(slices, 'per-slice-file');\n                  return;\n                }\n                // Single-file z-stack: one sibling geojson holding every slice's\n                // regions indexed by QuPath's geometry.plane.z. Enter per-slice\n                // mode (saving back one combined z-indexed geojson) when the\n                // geojson actually carries slice indices, or when there's nothing\n                // yet to author against. A legacy geojson whose regions are all on\n                // the default plane stays global (shown on every slice) so\n                // existing single-plane annotations aren't confined to slice 0.\n                const roiJson = imgInfo.roiJsonStr;\n                if (imgInfo.isStack) {\n                  const regions = roiJson ? this.plotService.importRegions(roiJson) : [];\n                  const hasSliceInfo = regions.some((r) => (r.z ?? 0) !== 0);\n                  if (!roiJson || hasSliceInfo) {\n                    const slices = new Map<number, Region[]>();\n                    for (const r of regions) {\n                      const z = r.z ?? 0;\n                      const bucket = slices.get(z);\n                      if (bucket) bucket.push(r);\n                      else slices.set(z, [r]);\n                    }\n                    enterStack(slices, 'combined');\n                    return;\n                  }\n                }\n                // Single-plane image (or a legacy global z-stack geojson): one\n                // region set for the whole image.\n                if (roiJson) {\n                  const regions = this.plotService.importRegions(roiJson);\n                  this.plotService.setRegions(regions);\n                  const shapes = regions.map((region) =>\n                    region.getShape(this.plotService.getShowShapeLabel()),\n                  );\n                  this.plotService.setPreviousShapes(shapes);\n                }\n                // Loading an image's saved ROIs is not a user edit — start the\n                // undo history fresh so the first undo can't wipe them (jit-ui#85).\n                this.plotService.resetUndoHistory();\n              };\n              let overlayReleased = false;\n              const releaseOverlay = () => {\n                if (overlayReleased) return;\n                overlayReleased = true;\n                if (imgInfo.isStack && imgInfo.showStack) this.stackLoading = false;\n                this.state.setImageLoading(false);\n              };\n\n              new RenderOrchestrator({\n                // inPlace=true updates the existing render instead of rebuilding\n                // it, so the canvas doesn't blank during the small→large swap.\n                renderPhase: (phaseInfo, inPlace) =>\n                  this.plotService.load(phaseInfo, this.zIndex).then((loadedImage) => {\n                    // Guard against a newer click reaching us mid-render.\n                    if (phaseInfo.fileName !== loadedImage.filename) return null;\n                    return this.plotService.plot(\n                      this.plotDivName,\n                      loadedImage,\n                      phaseInfo,\n                      screenHeight,\n                      this.plotType,\n                      inPlace,\n                    );\n                  }),\n                smallShown: () => {\n                  // If the file is still being cached/prepared server-side, keep the full\n                  // cache-progress overlay up instead of dropping to the translucent \"Sharpening\n                  // preview...\" spinner over a blank canvas (a large uncached image renders its\n                  // small preview before its tiles exist). finished() releases the overlay once\n                  // the real render lands.\n                  if (this.isCaching) return;\n                  // Small tier on screen — drop the full overlay but keep a translucent spinner so\n                  // the blurry render isn't mistaken for the final image.\n                  releaseOverlay();\n                  this.sharpening = true;\n                },\n                sharpenSettled: () => {\n                  this.sharpening = false;\n                },\n                finished: (_viaSmall, logTag) => {\n                  // Idempotent — releases now if smallShown deferred it (caching) or was skipped.\n                  releaseOverlay();\n                  this.running = false;\n                  applyRoi();\n                  console.log(logTag);\n                },\n                sharpenFailed: (err: any) => {\n                  // The small tier stays on screen as the fallback — tell the\n                  // user the sharper version isn't coming.\n                  const msg = err?.error?.message || err?.message || err?.statusText || String(err);\n                  this.messageService.add({\n                    key: 'center-toast',\n                    severity: 'warn',\n                    summary: 'Preview not sharpened',\n                    detail: `The full-resolution preview did not load (${msg}). The low-resolution preview is still shown. Try clicking the image again.`,\n                  });\n                  this.running = false;\n                  applyRoi();\n                },\n              }).render(imgInfo, smallImgInfo);\n            }\n          }\n        }\n      },\n      error: (err) => {\n        const msg = err?.error?.message || err?.message || err?.statusText || String(err);\n        console.error('Error occured when getting image info', err);\n        this.messageService.add({\n          key: 'center-toast',\n          sticky: true,\n          severity: 'error',\n          summary: 'An error occured',\n          detail: `The following error occured while getting image info: ${msg}.\n                   Please try to open the image again through the file navigator.`,\n        });\n        this.stackLoading = false;\n        this.state.setImageLoading(false);\n        this.running = false;\n        this.plotService.reset();\n      },\n    });\n  }\n\n  ngAfterViewInit() {\n    this.plotContextMenuListener = (event: MouseEvent) => {\n      const plotEl = document.getElementById(this.plotDivName);\n      if (!plotEl?.contains(event.target as Node)) return;\n      event.preventDefault();\n      event.stopImmediatePropagation();\n      this.ngZone.run(() => {\n        this.contextMenuItems = this.buildContextMenuItems();\n        this.cdr.detectChanges();\n        this.contextMenu.show(event);\n      });\n    };\n    window.addEventListener('contextmenu', this.plotContextMenuListener, true);\n\n    this.keydownListener = (event: KeyboardEvent) => {\n      const target = event.target as HTMLElement;\n      if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) return;\n      // SAM point mode: Enter commits the object, Esc clears the prompt.\n      if (this.activeDragMode === 'samPoint' && (event.key === 'Enter' || event.key === 'Escape')) {\n        this.ngZone.run(() => {\n          if (event.key === 'Enter') this.plotService.commitSamPoints();\n          else this.plotService.clearSamPoints();\n          this.hideSamToast(); // prompt resolved → dismiss the status toast\n        });\n        return;\n      }\n      // Region history (jit-ui#85): Ctrl/Cmd+Z undoes; Ctrl/Cmd+Shift+Z or\n      // Ctrl/Cmd+Y redoes.\n      if (event.ctrlKey || event.metaKey) {\n        const k = event.key.toLowerCase();\n        if (k === 'z' && !event.shiftKey) {\n          event.preventDefault();\n          this.ngZone.run(() => this.undoRegion());\n          return;\n        }\n        if ((k === 'z' && event.shiftKey) || k === 'y') {\n          event.preventDefault();\n          this.ngZone.run(() => this.redoRegion());\n          return;\n        }\n      }\n      if (event.key === 'Delete' || event.key === 'Backspace' || event.key === 'd' || event.key === 'D') {\n        this.ngZone.run(() => this.deleteRegion());\n      } else if (event.key === '+' || event.key === '=') {\n        this.ngZone.run(() => this.zoomIn());\n      } else if (event.key === '-' || event.key === '_') {\n        this.ngZone.run(() => this.zoomOut());\n      } else if (event.key === 'p') {\n        this.ngZone.run(() => this.toggleDragMode('pan'));\n      } else if (event.key === 'b') {\n        this.ngZone.run(() => this.toggleDragMode('zoomToBox'));\n      } else if (event.key === 'r') {\n        this.ngZone.run(() => this.toggleDragMode('drawrect'));\n      } else if (event.key === 'f') {\n        this.ngZone.run(() => this.toggleDragMode('drawclosedpath'));\n      } else if (event.key === 'w') {\n        this.ngZone.run(() => this.toggleDragMode('wand'));\n      } else if (event.key === 'e') {\n        this.ngZone.run(() => this.toggleDragMode('eraseVertex'));\n      } else if (event.key === 's') {\n        this.ngZone.run(() => this.toggleDragMode('select'));\n      } else if (event.key === 'l') {\n        this.ngZone.run(() => this.toggleDragMode('drawopenpath'));\n      }\n    };\n    window.addEventListener('keydown', this.keydownListener);\n\n    this.wheelListener = (event: WheelEvent) => {\n      const plotEl = document.getElementById(this.plotDivName);\n      if (!plotEl?.contains(event.target as Node)) return;\n      // The Image view handles scroll-zoom natively (it respects the scroll\n      // delta). Intercepting here would fire a fixed zoom step per wheel\n      // event — far too sensitive — so let the renderer own it.\n      if (this.isImageView) return;\n      // 3D plot types (surface, scatter3d, isosurface) render in a Plotly scene\n      // that orbits/zooms natively on scroll. The 2D step-zoom doesn't apply and\n      // would throw (no xaxis on a scene), so let Plotly handle the wheel.\n      if (!this.isHeatmap) return;\n      event.preventDefault();\n      event.stopImmediatePropagation();\n      if (event.deltaY < 0) {\n        this.ngZone.run(() => this.zoomIn());\n      } else if (event.deltaY > 0) {\n        this.ngZone.run(() => this.zoomOut());\n      }\n    };\n    window.addEventListener('wheel', this.wheelListener, { capture: true, passive: false });\n\n    // Drag handling for the floating intensity-profile panel.\n    this.profileDragMoveListener = (e: MouseEvent) => {\n      if (this.profilePanelDragging) {\n        this.ngZone.run(() => {\n          this.profilePanelPos = {\n            x: this.profilePanelStart.x + (e.clientX - this.profilePanelStart.mx),\n            y: this.profilePanelStart.y + (e.clientY - this.profilePanelStart.my),\n          };\n        });\n      } else if (this.toolbarDragging) {\n        this.ngZone.run(() => {\n          this.toolbarPos = {\n            x: this.toolbarStart.x + (e.clientX - this.toolbarStart.mx),\n            y: this.toolbarStart.y + (e.clientY - this.toolbarStart.my),\n          };\n        });\n      }\n    };\n    this.profileDragUpListener = () => {\n      this.profilePanelDragging = false;\n      this.toolbarDragging = false;\n    };\n    window.addEventListener('mousemove', this.profileDragMoveListener);\n    window.addEventListener('mouseup', this.profileDragUpListener);\n\n    // On any window resize, reflow the intensity inset to its (fixed) panel size\n    // on the next frame, once layout has settled. Without this the inset can be\n    // left at a stale/zero size by a mid-reflow resize and stop showing.\n    this.profileResizeListener = () => {\n      if (!this.hasProfiles) return;\n      requestAnimationFrame(() => this.renderIntensityInset());\n    };\n    window.addEventListener('resize', this.profileResizeListener);\n  }\n\n  onProfilePanelDragStart(e: MouseEvent) {\n    this.profilePanelDragging = true;\n    this.profilePanelStart = {\n      mx: e.clientX,\n      my: e.clientY,\n      x: this.profilePanelPos.x,\n      y: this.profilePanelPos.y,\n    };\n    e.preventDefault();\n  }\n\n  /** Grab the toolbar handle: detach it into a floating window (if still docked)\n   *  and start dragging. */\n  onToolbarDragStart(e: MouseEvent) {\n    if (!this.toolbarFloating) {\n      this.toolbarFloating = true;\n      this.toolbarPos = { x: 8, y: 8 };\n    }\n    this.toolbarDragging = true;\n    this.toolbarStart = {\n      mx: e.clientX,\n      my: e.clientY,\n      x: this.toolbarPos.x,\n      y: this.toolbarPos.y,\n    };\n    e.preventDefault();\n  }\n\n  /** Snap the floating toolbar back to its docked position across the top. */\n  dockToolbar() {\n    this.toolbarFloating = false;\n  }\n\n  /** Render the intensity inset chart from the latest profile data. The actual\n   *  charting is owned by the visualizer service — the component just decides\n   *  when (profile mode + a fresh profile). */\n  private renderIntensityInset(): void {\n    if (!this.hasProfiles) return;\n    this.plotService.renderIntensityInset(this.intensityInsetDiv, this.latestProfiles);\n  }\n\n  /** Toolbar \"Intensity\" group: add another line ROI (next bright colour). */\n  async addProfileLine(): Promise<void> {\n    // Park the floating inset near the plot's top-right when the first line is\n    // added (it's position:fixed, so use viewport coords from the plot rect).\n    if (!this.hasProfiles) {\n      const rect = document.getElementById(this.plotDivName)?.getBoundingClientRect();\n      this.profilePanelPos = rect\n        ? { x: Math.max(10, rect.right - 300), y: rect.top + 10 }\n        : { x: 20, y: 70 };\n    }\n    // Image (OSD) mode: Plotly never rendered, so it has no pixel cache / extent.\n    // Load the current slice's frames for sampling + line placement first.\n    if (this.isImageView && this.imageInfo) {\n      await this.plotService.ensureIntensitySampling(this.imageInfo, this.zIndex);\n    }\n    const region = this.plotService.getIntensityControls()?.addProfileLine();\n    // Auto-select the new line on the active backend (Plotly handles / OSD\n    // highlight) so it's ready to move or delete immediately.\n    if (region) {\n      this.plotService.selectRegion(region);\n      // OSD only draws a selected region's handles in an edit mode, so a line in\n      // 'none' mode looks unselected. Switch to 'select' so the new line shows\n      // its endpoint handles and can be dragged/deleted right away.\n      if (this.isImageView && this.activeDragMode !== 'select') {\n        this.toggleDragMode('select');\n      }\n    }\n  }\n\n  ngOnDestroy() {\n    this.scrubber.cancel();\n    this.samPointSub.unsubscribe();\n    if (this.plotContextMenuListener) {\n      window.removeEventListener('contextmenu', this.plotContextMenuListener, true);\n    }\n    if (this.keydownListener) {\n      window.removeEventListener('keydown', this.keydownListener);\n    }\n    if (this.wheelListener) {\n      window.removeEventListener('wheel', this.wheelListener, true);\n    }\n    if (this.profileDragMoveListener) {\n      window.removeEventListener('mousemove', this.profileDragMoveListener);\n    }\n    if (this.profileDragUpListener) {\n      window.removeEventListener('mouseup', this.profileDragUpListener);\n    }\n    if (this.profileResizeListener) {\n      window.removeEventListener('resize', this.profileResizeListener);\n    }\n    if (this.intensityProfileSub) {\n      this.intensityProfileSub.unsubscribe();\n    }\n    if (this.viewportChangeSub) {\n      this.viewportChangeSub.unsubscribe();\n    }\n    this.unsub.next();\n    this.unsub.complete();\n    if (this.previewSubscription) {\n      this.previewSubscription.unsubscribe();\n    }\n    if (this.plotWidthSubscription) {\n      this.plotWidthSubscription.unsubscribe();\n    }\n    if (this.imageLoadingSubscription) {\n      this.imageLoadingSubscription.unsubscribe();\n    }\n    if (this.imgLoadingMessageSubscription) {\n      this.imgLoadingMessageSubscription.unsubscribe();\n    }\n    if (this.isZoomSubscription) {\n      this.isZoomSubscription.unsubscribe();\n    }\n    if (this.autoscaleSubscription) {\n      this.autoscaleSubscription.unsubscribe();\n    }\n    if (this.filenameSubscription) {\n      this.filenameSubscription.unsubscribe();\n    }\n    this.plotService.unsubscribe();\n  }\n\n  public hasRegions(): boolean {\n    // Use the contract's framework-neutral region accessor, not the raw\n    // Plotly-shaped getShapes() — the component only needs to know whether any\n    // region exists, and must not depend on a backend's wire format.\n    return this.plotService.getRegions().length > 0;\n  }\n\n  /**\n   * This method is called in mainFacade.configRequest() - DO NOT DELETE\n   */\n  public getRegionPolygons(): Polygon[] {\n    return this.plotService.getRegionPolygons();\n  }\n\n  /**\n   * Select the color scale type: called by the color scale select button\n   * @param event\n   */\n  toggleReverseScale() {\n    this.reversescale = !this.reversescale;\n    this.plotService.setReverseScale(this.reversescale);\n  }\n\n  /**\n   * Select a color map: called by the color map dropdown button\n   * @param colormapNode\n   */\n  selectColormap(colormapNode: TreeNode) {\n    if (!colormapNode.children) {\n      this.plotService.setColormap(colormapNode);\n    }\n  }\n\n  /** Open the Channels & Histogram dialog (toolbar button). */\n  openChannelHistogram() {\n    this.showChannelHistogram = true;\n  }\n\n  /** Open the Region Editor dialog (toolbar button). The editor stays linked to\n   *  this plotting instance through the root RegionStore singleton, so it works\n   *  the same as the former right-panel Regions tab. */\n  openRegionEditor() {\n    // Size the dialog to match the host's configured element (e.g. the app's\n    // right panel) at open time. Measured once — it intentionally does not\n    // track later browser/split resizes. Falls back to a quarter of the page\n    // when no selector is configured or the element isn't present.\n    const selector = this.vizConfig?.regionEditorWidthSelector;\n    const width = selector\n      ? document.querySelector<HTMLElement>(selector)?.getBoundingClientRect().width\n      : undefined;\n    this.regionEditorWidth = width && width > 0 ? `${Math.round(width)}px` : '25vw';\n    this.showRegionEditor = true;\n  }\n\n  /**\n   * Called by the stack/single image dropdown button\n   * @param showstack\n   */\n  selectStackOption(selectedStackOption: any) {\n    const showstack = selectedStackOption.val === 'true';\n    this.selectedStackOption = selectedStackOption;\n    console.log('selected stack option' + JSON.stringify(this.selectedStackOption));\n    this.stackLoading = showstack;\n    this.state.setImageLoading(!showstack);\n    // Stack mode is always a 2D heatmap — reset surface mode if active\n    if (!this.isHeatmap) {\n      this.isHeatmap = true;\n      this.plotType = PlotType.HEATMAP;\n      this.selectedPlotType = PlotType.HEATMAP;\n      this.plotService.setPlotType(this.plotType);\n    }\n    this.plotService.setShowStack(showstack);\n  }\n\n  updateZIndex(urls?: string[]) {\n    if (this.zIndex > this.maxIndex) {\n      this.zIndex = this.maxIndex;\n    }\n    if (this.zIndex < 0) {\n      this.zIndex = 0;\n    }\n    if (urls) {\n      if (this.zIndex > urls?.length) {\n        this.zIndex = 0;\n        this.maxIndex = urls.length - 1;\n      }\n    }\n    this.plotService.setZIndex(this.zIndex);\n  }\n\n  /**\n   * Live z-slice scrub for the Image view: the renderer swaps the displayed\n   * slice in place (no re-mount), so dragging the slider steps through the\n   * stack the same way the heatmap frame slider does.\n   */\n  onZSlide(z: number | undefined) {\n    if (z === undefined) return;\n    this.zIndex = z;\n    this.scrubber.commit(z);\n    // Keep the intensity inset in sync with the displayed slice (Image/OSD mode,\n    // where the profile sampler is fed from the loaded preview frames).\n    if (this.hasProfiles && this.isImageView && this.imageInfo) {\n      this.plotService.ensureIntensitySampling(this.imageInfo, z);\n    }\n  }\n\n  /**\n   * Live (debounced) scrub while dragging the Image-view z-slider: update the\n   * slice as the user drags, but coalesce rapid changes so we don't fire a\n   * slice swap on every pixel. The final value also lands via onZSlide (onSlideEnd).\n   */\n  onZScrub(z: number | undefined) {\n    if (z === undefined) return;\n    this.zIndex = z;\n    this.scrubber.scrub(z);\n  }\n\n  /**\n   * Keyboard stack navigation: ←/→ step the z-slice in the Image view, the same\n   * way the slider does. Only active for a loaded stack in Image view, and\n   * ignored while a form field is focused so typing isn't hijacked. Up/Down are\n   * left to OpenSeadragon (panning).\n   */\n  @HostListener('window:keydown', ['$event'])\n  onKeydown(e: KeyboardEvent): void {\n    if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return;\n    if (!this.imageInfo?.isStack || !this.isImageView) return;\n    const t = e.target as HTMLElement | null;\n    if (t && (/^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName) || t.isContentEditable)) return;\n    // The slice slider handles arrows natively when focused (also a +1 step) —\n    // skip here so we don't double-step it.\n    if (t && (t.getAttribute('role') === 'slider' || t.closest('.p-slider'))) return;\n    e.preventDefault();\n    this.stepSlice(e.key === 'ArrowRight' ? 1 : -1);\n  }\n\n  /** Move the displayed slice by `delta`, clamped to the stack bounds. */\n  stepSlice(delta: number): void {\n    const next = Math.min(this.maxIndex, Math.max(0, this.zIndex + delta));\n    if (next === this.zIndex) return;\n    this.onZSlide(next);\n  }\n\n  reloadAndPlot() {\n    this.state.setImageLoading(true);\n    // Re-drive the render pipeline from the current image info (the source of\n    // truth, with real urls/fileName). Don't use plotService.reloadAndPlot():\n    // that rebuilds the info from the renderer's internal state, which can be\n    // stale (e.g. after switching plot type Image -> Heatmap) and re-emit\n    // empty/old urls, failing to hand the div over to the new renderer.\n    if (this.imageInfo) {\n      this.state.setImageInfo(this.imageInfo);\n    } else {\n      this.plotService.reloadAndPlot();\n    }\n  }\n  cancelLoading() {\n    // Stop any in-flight frame streaming (napari-js volume/surface preload) so the fetch loops\n    // actually abort — clearing the flag alone only routed to Plotly and left napari fetching.\n    this.plotService.cancelLoading?.();\n    this.stackLoading = false;\n    this.imgLoading = false;\n    this.state.setImageLoading(false);\n    this.zIndex = 0;\n    this.plotService.setZIndex(this.zIndex);\n    this.running = false;\n    this.plotService.setStackLoading(false);\n  }\n\n  downloadImage() {\n    this.plotService.downloadImage();\n  }\n\n  autoscaleImage() {\n    this.plotService.autoscale();\n  }\n\n  /** Toolbar pixel/smooth toggle: flip smoothing and apply to the active backend. */\n  onToggleImageSmoothing(): void {\n    this.imageSmoothingEnabled = !this.imageSmoothingEnabled;\n    this.plotService.setImageSmoothingEnabled(this.imageSmoothingEnabled);\n  }\n\n  resetAxes() {\n    this.plotService.resetAxes();\n  }\n\n  toggleDragMode(mode: string) {\n    // Toggle off if the same mode is re-selected.\n    this.activeDragMode = this.activeDragMode === mode ? null : mode;\n    const active = this.activeDragMode;\n    // Record the armed tool in the shared session store.\n    this.session.setActiveTool(active);\n\n    // Region draw/select run through the renderer's region overlay.\n    this.plotService\n      .getRegionOverlay()\n      ?.setMode(this.isRegionMode(active) ? (active as RegionToolMode) : 'none');\n\n    // Viewport drag modes (pan/box-zoom). Region modes own the drag mode via\n    // the overlay, so don't also set one here.\n    if (!this.isRegionMode(active)) {\n      const viewportDrag = active === 'pan' || active === 'zoom';\n      this.plotService.setDragMode(viewportDrag ? active : false);\n    }\n\n    // On-canvas tool overlays.\n    this.plotService.setZoomToBoxMode(active === 'zoomToBox');\n    this.plotService.setWandMode(active === 'wand', { sensitivity: this.wandSensitivity });\n    this.plotService.setBrushMode(active === 'brush', { size: this.brushSize });\n    this.plotService.setSamPointMode(active === 'samPoint');\n    // Leaving point mode dismisses any lingering status toast.\n    if (active !== 'samPoint') this.hideSamToast();\n    this.plotService.setVertexEraserMode(active === 'eraseVertex');\n    if (active === 'eraseVertex') {\n      this.plotService.setVertexEraserRadius(this.vertexEraserRadius);\n    }\n  }\n\n  /** Region draw/select/edit modes routed through the region overlay. The\n   *  The vertex tools (drawpolygon/addpoint/deletepoint/move) are\n   *  handled by the OpenSeadragon overlay; Plotly's overlay maps them to no-op. */\n  private isRegionMode(mode: string | null): boolean {\n    return (\n      mode === 'drawrect' ||\n      mode === 'drawclosedpath' ||\n      mode === 'drawopenpath' ||\n      mode === 'select' ||\n      mode === 'drawpolygon' ||\n      mode === 'addpoint' ||\n      mode === 'deletepoint' ||\n      mode === 'move'\n    );\n  }\n\n  /** Live-update the isosurface as the range slider moves. The control is only\n   *  available when the active backend renders isosurfaces (ISOSURFACE mode). */\n  onIsoRangeChange(values: number[] | undefined) {\n    if (!values || values.length < 2) return;\n    this.isoRange = values;\n    this.plotService.getIsosurfaceControls()?.setIsoRange(values[0], values[1]);\n  }\n\n  onWandSensitivityChange(value: number | undefined) {\n    if (value === undefined || !Number.isFinite(value)) return;\n    this.wandSensitivity = value;\n    this.plotService.setWandOptions({ sensitivity: value });\n  }\n\n  onBrushSizeChange(value: number | undefined) {\n    if (value === undefined || !Number.isFinite(value)) return;\n    this.brushSize = value;\n    this.plotService.setBrushOptions({ size: value });\n  }\n\n  onVertexEraserRadiusChange(value: number | undefined) {\n    if (value === undefined || !Number.isFinite(value)) return;\n    this.vertexEraserRadius = value;\n    this.plotService.setVertexEraserRadius(value);\n  }\n\n  zoomIn() {\n    this.plotService.zoomIn();\n  }\n\n  zoomOut() {\n    this.plotService.zoomOut();\n  }\n\n  deleteRegion() {\n    this.plotService.deleteActiveShape();\n  }\n\n  /** Undo the most recent region action (jit-ui#85). Up to 10 steps back. */\n  undoRegion() {\n    this.plotService.undo();\n  }\n\n  /** Redo the most recently undone region action (jit-ui#85). */\n  redoRegion() {\n    this.plotService.redo();\n  }\n\n  // ── Region set-operations on the current selection (jit-ui#85) ──────────\n\n  /** The currently-selected regions (live store instances). */\n  private get selectedRegions(): Region[] {\n    const all = this.plotService.getRegions();\n    return this.selectedIndices\n      .map((i) => all[i])\n      .filter((r): r is Region => !!r);\n  }\n\n  /** Regions eligible for set-ops: closed areas (rect / closed polygon /\n   *  multi-polygon), excluding intensity-profile lines. */\n  private opEligible(regions: Region[]): Region[] {\n    return regions.filter((r) => r.kind !== 'profile' && (\n      r.bounds instanceof Rectangle ||\n      r.bounds instanceof MultiPolygon ||\n      (r.bounds instanceof Polygon && r.bounds.closed !== false)\n    ));\n  }\n\n  /** Image pixel dimensions for the raster ops; falls back to the selection's\n   *  extent when the image size isn't known (keeps clamping sane). */\n  private opImageDims(regions: Region[]): { w: number; h: number } {\n    let [w, h] = this.imageInfo?.trueImageSize ?? [0, 0];\n    if (!(w > 0) || !(h > 0)) {\n      let maxX = 0, maxY = 0;\n      const scan = (xs: number[], ys: number[]) => {\n        for (const x of xs) maxX = Math.max(maxX, x);\n        for (const y of ys) maxY = Math.max(maxY, y);\n      };\n      for (const r of regions) {\n        const b = r.bounds;\n        if (b instanceof Rectangle) scan([b.x + b.width], [b.y + b.height]);\n        else if (b instanceof Polygon) scan(b.xpoints, b.ypoints);\n        else if (b instanceof MultiPolygon) for (const p of b.polygons) scan(p.xpoints, p.ypoints);\n      }\n      w = Math.max(w, Math.ceil(maxX) + 2);\n      h = Math.max(h, Math.ceil(maxY) + 2);\n    }\n    return { w, h };\n  }\n\n  /** True when ≥2 eligible regions are selected (Merge available). */\n  get canMergeRegions(): boolean { return this.opEligible(this.selectedRegions).length >= 2; }\n  /** True when any selected region is multi-part (Ungroup available). */\n  get canUngroupRegions(): boolean { return this.selectedRegions.some((r) => this.regionOps.canUngroup(r)); }\n  /** True when ≥1 eligible region is selected (Inverse / Simplify available). */\n  get hasEligibleSelection(): boolean { return this.opEligible(this.selectedRegions).length >= 1; }\n\n  /** Select every region on the image (excludes intensity-profile lines). */\n  selectAllRegions(): void {\n    const all = this.plotService.getRegions();\n    const indices: number[] = [];\n    all.forEach((r, i) => { if (r.kind !== 'profile') indices.push(i); });\n    this.plotService.setSelectedShapeIndices(indices);\n  }\n\n  /** Merge the selected regions into a single (possibly multi-part) region. */\n  mergeRegions(): void {\n    const sel = this.opEligible(this.selectedRegions);\n    if (sel.length < 2) return;\n    const { w, h } = this.opImageDims(sel);\n    const merged = this.regionOps.merge(sel, w, h);\n    if (merged) this.replaceRegions(sel, [merged]);\n  }\n\n  /** Split each selected multi-part region into one region per part. */\n  ungroupRegions(): void {\n    const sel = this.selectedRegions.filter((r) => this.regionOps.canUngroup(r));\n    if (sel.length === 0) return;\n    const results: Region[] = [];\n    for (const r of sel) results.push(...this.regionOps.ungroup(r));\n    this.replaceRegions(sel, results);\n  }\n\n  /** Replace the selection with its inverse inside the image rectangle. */\n  inverseRegions(): void {\n    const sel = this.opEligible(this.selectedRegions);\n    if (sel.length === 0) return;\n    const { w, h } = this.opImageDims(sel);\n    const inv = this.regionOps.inverse(sel, w, h);\n    if (!inv) {\n      this.messageService.add({\n        severity: 'warn', summary: 'Inverse',\n        detail: 'Nothing to invert — select one or more closed regions first.',\n      });\n      return;\n    }\n    this.replaceRegions(sel, [inv]);\n  }\n\n  /** Douglas–Peucker simplify each selected region by `thresholdPx`. */\n  simplifyRegions(thresholdPx: number): void {\n    const sel = this.opEligible(this.selectedRegions);\n    if (sel.length === 0) return;\n    this.replaceRegions(sel, sel.map((r) => this.regionOps.simplify(r, thresholdPx)));\n    this.displaySimplifyDialog = false;\n  }\n\n  /** Open the custom-threshold simplify dialog. */\n  openSimplifyDialog(): void { this.displaySimplifyDialog = true; }\n\n  /**\n   * Commit a set-op: drop the `remove` regions, append `add`, and select the\n   * results. Goes through setRegions so it's undo-tracked and re-rendered;\n   * profile lines and unselected regions are preserved.\n   */\n  private replaceRegions(remove: Region[], add: Region[]): void {\n    if (add.length === 0) return;\n    const removeSet = new Set(remove);\n    const kept = this.plotService.getRegions().filter((r) => !removeSet.has(r));\n    this.plotService.setRegions([...kept, ...add]); // mints ids on `add`, records undo\n    const stored = this.plotService.getRegions();\n    const sel = add.map((r) => stored.indexOf(r)).filter((i) => i >= 0);\n    this.plotService.setSelectedShapeIndices(sel);\n  }\n\n  /** Box-prompted SAM segmentation of the drawn rectangles (jit-ui#90). A sticky\n   *  `sam` toast shows live status + a download progress bar (first run pulls the\n   *  encoder, ~170 MB); it stays open until the run finishes (bar hits 100%). */\n  async segmentRegions() {\n    await this.runSegmentWithToast('SAM', this.samTool, () => this.plotService.segmentRectangles());\n  }\n\n  /** Auto-segment cells inside each drawn rectangle with cellpose-SAM, client-side\n   *  (jit-ui#90). Each box is cropped (browser slide-crop) then run through the\n   *  cellpose-js model; the same sticky `sam` toast + progress bar is reused. */\n  async segmentCellpose() {\n    await this.runSegmentWithToast('Cellpose', this.cellSegmentTool, () =>\n      this.plotService.segmentRectanglesCellpose(),\n    );\n  }\n\n  /** Shared driver for the box-prompt segment tools: wires the tool's status +\n   *  download progress into the sticky `sam` toast, runs `op`, and reports the\n   *  region count. Keeps the toast open until the run settles (bar hits 100%). */\n  private async runSegmentWithToast(\n    label: string,\n    tool: { status$: BehaviorSubject<string>; progress$: BehaviorSubject<number> },\n    op: () => Promise<number>,\n  ) {\n    this.samStatus = 'Starting…';\n    this.samProgress = 0;\n    this.samDownloading = false;\n    this.samBusy = true;\n    const psub = tool.progress$.subscribe((f) => {\n      this.samDownloading = f >= 0 && f < 1;\n      if (f >= 0) this.samProgress = Math.min(100, Math.round(f * 100));\n      this.cdr.detectChanges();\n    });\n    const ssub = tool.status$.subscribe((m) => {\n      if (m) {\n        this.samStatus = m;\n        this.cdr.detectChanges();\n      }\n    });\n    this.showSamToast(label);\n    try {\n      const n = await op();\n      this.messageService.add({\n        severity: n > 0 ? 'success' : 'warn',\n        summary: label,\n        detail: tool.status$.value || (n > 0 ? `Added ${n} region(s).` : 'No regions added.'),\n      });\n    } catch (e) {\n      this.messageService.add({ severity: 'error', summary: `${label} failed`, detail: String(e) });\n    } finally {\n      psub.unsubscribe();\n      ssub.unsubscribe();\n      this.hideSamToast();\n    }\n  }\n\n  /** Show the shared sticky `sam` toast once (idempotent — re-adding would stack\n   *  a new toast on every point click). */\n  private showSamToast(summary: string): void {\n    if (this.samToastShown) return;\n    this.samToastShown = true;\n    this.messageService.add({ key: this.samToastKey, sticky: true, severity: 'info', summary });\n  }\n\n  /** Dismiss the shared `sam` toast and reset its progress/spinner state. */\n  private hideSamToast(): void {\n    this.samToastShown = false;\n    this.samBusy = false;\n    this.samDownloading = false;\n    this.samProgress = 0;\n    this.messageService.clear(this.samToastKey);\n    this.cdr.detectChanges();\n  }\n\n  /** Pick the SAM model the segment tools use (jit-ui#90 P1). */\n  onSamModelChange(id: string) {\n    this.samModelId = id;\n    this.plotService.setSamModel(id);\n  }\n\n  /** Convert the selected region to a smooth bezier curve. */\n  toBezierRegion() {\n    this.plotService.getRegionOverlay()?.setSelectedBezier(true);\n  }\n\n  /** Convert the selected region back to a straight-edged polygon. */\n  toPolygonRegion() {\n    this.plotService.getRegionOverlay()?.setSelectedBezier(false);\n  }\n\n  /**\n   * Immediate region actions on the current selection (jit-ui#85): merge,\n   * ungroup, inverse, simplify, the Bézier conversions, and delete — the\n   * one-shot geometry transforms, grouped apart from the tool/mode toggles and\n   * shown only when something is selected. Each item is gated on what the\n   * selection supports.\n   */\n  private buildRegionActionItems(): MenuItem[] {\n    const all = this.plotService.getRegions();\n    const selectable = all.filter((r) => r.kind !== 'profile');\n    if (selectable.length === 0) return [];\n    const items: MenuItem[] = [];\n\n    // Select all — available whenever the image has regions, regardless of the\n    // current selection.\n    items.push({\n      label: 'Select all regions', icon: 'pi pi-check-square',\n      command: () => this.selectAllRegions(),\n    });\n\n    const selAll = this.selectedRegions;\n    if (selAll.length === 0) return items;\n    const eligible = this.opEligible(selAll);\n\n    if (eligible.length >= 2) {\n      items.push({ label: 'Merge / group', icon: 'pi pi-link', command: () => this.mergeRegions() });\n    }\n    if (selAll.some((r) => this.regionOps.canUngroup(r))) {\n      items.push({ label: 'Ungroup', icon: 'pi pi-sitemap', command: () => this.ungroupRegions() });\n    }\n    if (eligible.length >= 1) {\n      items.push(\n        { label: 'Inverse', icon: 'pi pi-clone', command: () => this.inverseRegions() },\n        {\n          label: 'Simplify', icon: 'pi pi-chart-line',\n          items: [\n            { label: 'Light (1 px)', command: () => this.simplifyRegions(1) },\n            { label: 'Medium (3 px)', command: () => this.simplifyRegions(3) },\n            { label: 'Strong (8 px)', command: () => this.simplifyRegions(8) },\n            { separator: true },\n            { label: 'Custom…', command: () => this.openSimplifyDialog() },\n          ],\n        },\n      );\n    }\n    // Bézier conversions are vertex-level edits — Image (OpenSeadragon) view\n    // only — gated on the selection's current form.\n    if (this.selectedPlotType === PlotType.IMAGE) {\n      const hasStraight = selAll.some((r) =>\n        (r.bounds instanceof Polygon && !r.bounds.bezier) || r.bounds instanceof Rectangle);\n      const hasBezier = selAll.some((r) => r.bounds instanceof Polygon && r.bounds.bezier);\n      if (hasStraight) {\n        items.push({ label: 'Convert to Bézier', icon: 'to-bezier-icon', command: () => this.toBezierRegion() });\n      }\n      if (hasBezier) {\n        items.push({ label: 'Convert to polygon', icon: 'to-polygon-icon', command: () => this.toPolygonRegion() });\n      }\n    }\n    items.push({ label: 'Delete region', icon: 'pi pi-trash', command: () => this.deleteRegion() });\n    return items;\n  }\n\n  private buildContextMenuItems(): MenuItem[] {\n    const active = this.activeDragMode;\n    const activeClass = 'context-menu-active';\n    const items: MenuItem[] = [];\n    // Selected-region actions lead the menu (separated from the tool toggles).\n    if (this.isHeatmap) {\n      const actions = this.buildRegionActionItems();\n      if (actions.length) items.push(...actions, { separator: true });\n    }\n    if (this.isHeatmap) {\n      items.push(\n        { label: 'Autoscale', icon: 'pi pi-window-maximize', command: () => this.autoscaleImage() },\n        { separator: true },\n      );\n      // 'Zoom selection' is Plotly's rubber-band zoom; it doesn't apply to the\n      // OpenSeadragon-backed Image view (use 'Zoom to box' there instead).\n      if (!this.isImageView) {\n        items.push({\n          label: 'Zoom selection',\n          icon: 'pi pi-search',\n          styleClass: active === 'zoom' ? activeClass : '',\n          command: () => this.toggleDragMode('zoom'),\n        });\n      }\n      items.push({\n        label: 'Zoom to box',\n        icon: 'zoom-box-off-icon',\n        styleClass: active === 'zoomToBox' ? activeClass : '',\n        command: () => this.toggleDragMode('zoomToBox'),\n      });\n    }\n    if (this.isHeatmap) {\n      items.push({\n        label: 'Pan',\n        icon: 'pi pi-arrows-alt',\n        styleClass: active === 'pan' ? activeClass : '',\n        command: () => this.toggleDragMode('pan'),\n      });\n    } else {\n      const s3d = this.activeSurface3dMode;\n      items.push(\n        {\n          label: 'Zoom',\n          icon: 'pi pi-search',\n          styleClass: s3d === 'zoom' ? activeClass : '',\n          command: () => this.toggleSurface3dMode('zoom'),\n        },\n        {\n          label: 'Pan',\n          icon: 'pi pi-arrows-alt',\n          styleClass: s3d === 'pan' ? activeClass : '',\n          command: () => this.toggleSurface3dMode('pan'),\n        },\n        {\n          label: 'Orbital rotation',\n          icon: 'pi pi-globe',\n          styleClass: s3d === 'orbit' ? activeClass : '',\n          command: () => this.toggleSurface3dMode('orbit'),\n        },\n        {\n          label: 'Turntable rotation',\n          icon: 'pi pi-sync',\n          styleClass: s3d === 'turntable' ? activeClass : '',\n          command: () => this.toggleSurface3dMode('turntable'),\n        },\n        { separator: true },\n        { label: 'Reset camera', icon: 'pi pi-home', command: () => this.resetSurfaceCamera() },\n      );\n    }\n    if (this.isHeatmap) {\n      items.push(\n        { label: 'Zoom in', icon: 'pi pi-search-plus', command: () => this.zoomIn() },\n        { label: 'Zoom out', icon: 'pi pi-search-minus', command: () => this.zoomOut() },\n        { separator: true },\n        {\n          label: 'Select',\n          icon: 'pi pi-arrow-up-right',\n          styleClass: active === 'select' ? activeClass : '',\n          command: () => this.toggleDragMode('select'),\n        },\n        {\n          label: 'Freeform',\n          icon: 'pi pi-pencil',\n          styleClass: active === 'drawclosedpath' ? activeClass : '',\n          command: () => this.toggleDragMode('drawclosedpath'),\n        },\n        {\n          label: 'Brush',\n          icon: 'brush-icon',\n          styleClass: active === 'brush' ? activeClass : '',\n          command: () => this.toggleDragMode('brush'),\n        },\n        {\n          label: 'Polyline',\n          icon: 'polyline-icon',\n          styleClass: active === 'drawopenpath' ? activeClass : '',\n          command: () => this.toggleDragMode('drawopenpath'),\n        },\n        {\n          label: 'Rectangle',\n          icon: 'pi pi-stop',\n          styleClass: active === 'drawrect' ? activeClass : '',\n          command: () => this.toggleDragMode('drawrect'),\n        },\n        {\n          label: 'Wand',\n          icon: 'wand-icon',\n          styleClass: active === 'wand' ? activeClass : '',\n          command: () => this.toggleDragMode('wand'),\n        },\n        {\n          label: 'Vertex eraser',\n          icon: 'pi pi-eraser',\n          styleClass: active === 'eraseVertex' ? activeClass : '',\n          command: () => this.toggleDragMode('eraseVertex'),\n        },\n      );\n      // Vertex editing runs on the OpenSeadragon overlay, which\n      // backs the Image plot type. Hidden for other 2D types (Plotly), where\n      // these modes are no-ops.\n      if (this.selectedPlotType === PlotType.IMAGE) {\n        items.push(\n          {\n            label: 'Polygon (click vertices)',\n            icon: 'polygon-vertices-icon',\n            styleClass: active === 'drawpolygon' ? activeClass : '',\n            command: () => this.toggleDragMode('drawpolygon'),\n          },\n          {\n            label: 'Add vertex',\n            icon: 'vertex-add-icon',\n            styleClass: active === 'addpoint' ? activeClass : '',\n            command: () => this.toggleDragMode('addpoint'),\n          },\n          {\n            label: 'Delete vertex',\n            icon: 'vertex-delete-icon',\n            styleClass: active === 'deletepoint' ? activeClass : '',\n            command: () => this.toggleDragMode('deletepoint'),\n          },\n        );\n      }\n      // Bézier conversions + Delete are immediate selection *actions*, now in the\n      // \"Selected region(s)\" group at the top (see buildRegionActionItems).\n    }\n    return items;\n  }\n\n  toggleSurface3dMode(mode: string) {\n    this.activeSurface3dMode = mode;\n    this.plotService.setSurfaceDragMode(mode);\n  }\n\n  resetSurfaceCamera() {\n    this.plotService.resetSurfaceCamera();\n  }\n\n  /** Toggle the napari 3D coordinate-axes / scale gizmo (volume/isosurface). No-op on backends\n   *  that don't render one (the control method is optional). */\n  toggleAxes() {\n    this.axesVisible = !this.axesVisible;\n    this.plotService.getSurface3dControls()?.setAxesVisible?.(this.axesVisible);\n  }\n\n  /** Toggle the napari surface wireframe (edges vs filled). No-op on backends without a surface. */\n  toggleWireframe() {\n    this.wireframeActive = !this.wireframeActive;\n    this.plotService.getSurface3dControls()?.setWireframe?.(this.wireframeActive);\n  }\n\n  /** Change the napari 3D decimate factor. Decimation changes the fetched/assembled data, so this\n   *  re-plots the current 3D type at the new resolution (unlike axes/wireframe, which are live). */\n  selectResolution(scale: number) {\n    if (scale === this.resolutionScale) return;\n    this.resolutionScale = scale;\n    this.plotService.setResolutionScale?.(scale);\n    this.reloadAndPlot();\n  }\n\n  /**\n   * Switch the active plot type (heatmap, surface, contour, scatter, line,\n   * scatter3d, isosurface). Keeps `isHeatmap` as the 2D-vs-3D flag the rest of\n   * the toolbar/context-menu logic relies on, deactivates 2D-only tools when\n   * moving to a 3D type, then re-plots.\n   */\n  onSelectPlotType(type: PlotType) {\n    this.plotType = type;\n    this.selectedPlotType = type;\n    const descriptor = this.plotTypeOptions.find((d) => d.type === type);\n    const is3d = descriptor?.dimensions === '3d';\n    this.isHeatmap = !is3d;\n    this.plotService.setPlotType(type);\n    // Switching plot type cancels the active tool — not every type supports the\n    // same tools (line/scatter charts and 3D scenes have no box zoom or region\n    // drawing), so leaving a tool armed would misbehave on the new plot.\n    this.deactivateActiveTool();\n    if (is3d) {\n      this.activeSurface3dMode = 'turntable';\n    }\n    // napari-js volume/isosurface assemble their own 3D texture from the slice endpoint, so\n    // they take the normal re-plot path — NOT Plotly's stack-frame loader (whose \"Loading\n    // frames\" overlay would never clear, since Plotly isn't the active backend) (jit-ui#102).\n    const isNapari = type === PlotType.NAPARI_IMAGE || isNapari3d(type);\n    if (descriptor?.requiresStack && !isNapari) {\n      // Volume types (isosurface, scatter3d) need the whole z-stack loaded as a\n      // 3D array, and they always render on Plotly. Drive the stack reload\n      // directly through the image-info stream rather than the active renderer's\n      // setShowStack: when OpenSeadragon owns the Image view its setShowStack is\n      // a no-op, so the reload never fired and the loader spun forever. We arm\n      // Plotly's stack-loading flag (keeps its frame-fetch loop alive) and\n      // re-emit the image info with showStack on so the pipeline reloads on\n      // Plotly regardless of which backend was on screen.\n      this.selectedStackOption = this.stackOptions[1];\n      this.stackLoading = true;\n      this.plotService.setStackLoading(true);\n      if (this.imageInfo) {\n        this.imageInfo.showStack = true;\n        this.state.setImageInfo(this.imageInfo);\n      }\n      return;\n    }\n    this.reloadAndPlot();\n  }\n\n  /** Deactivate whatever tool is armed and clear every tool mode. */\n  private deactivateActiveTool() {\n    this.activeDragMode = null;\n    this.session.setActiveTool(null);\n    this.plotService.getRegionOverlay()?.setMode('none');\n    this.plotService.setDragMode(false);\n    this.plotService.setZoomToBoxMode(false);\n    this.plotService.setWandMode(false);\n    this.plotService.setBrushMode(false);\n    this.plotService.setSamPointMode(false);\n    this.plotService.setVertexEraserMode(false);\n  }\n}\n\n","<!-- SAM toast: live status + encoder-download progress bar (jit-ui#90). Sticky\n     while a segment runs; stays open until the bar reaches 100% and the run ends. -->\n<p-toast [key]=\"samToastKey\" position=\"bottom-right\">\n  <ng-template let-message pTemplate=\"message\">\n    <div style=\"flex: 1; min-width: 16rem\">\n      <div class=\"font-bold mb-1\">{{ message.summary }}</div>\n      <div>{{ samStatus || message.detail }}</div>\n      <p-progressBar *ngIf=\"samDownloading\" [value]=\"samProgress\" styleClass=\"mt-2 sam-progress\"></p-progressBar>\n      <p-progressBar *ngIf=\"samBusy && !samDownloading\" mode=\"indeterminate\" styleClass=\"mt-2\"\n                     [style]=\"{ height: '4px' }\"></p-progressBar>\n    </div>\n  </ng-template>\n</p-toast>\n\n<!-- Toolbar dock: docked across the top by default; drag the handle to detach\n     it into a floating, movable window (frees the top row for the image). -->\n<div class=\"toolbar-dock\" [class.floating]=\"toolbarFloating\"\n     [style.left.px]=\"toolbarFloating ? toolbarPos.x : null\"\n     [style.top.px]=\"toolbarFloating ? toolbarPos.y : null\">\n  <div class=\"toolbar-drag-handle\" (mousedown)=\"onToolbarDragStart($event)\"\n       pTooltip=\"Drag to float the toolbar\" tooltipPosition=\"bottom\">\n    <i class=\"pi pi-bars\"></i>\n  </div>\n<plotting-toolbar\n  [imageInfo]=\"imageInfo\"\n  [plotTypeOptions]=\"plotTypeOptions\"\n  [selectedPlotType]=\"selectedPlotType\"\n  [isoRange]=\"isoRange\"\n  [maxIndex]=\"maxIndex\"\n  [zIndex]=\"zIndex\"\n  [isHeatmap]=\"isHeatmap\"\n  [activeDragMode]=\"activeDragMode\"\n  [activeSurface3dMode]=\"activeSurface3dMode\"\n  [axesVisible]=\"axesVisible\"\n  [wireframeActive]=\"wireframeActive\"\n  [resolutionScale]=\"resolutionScale\"\n  [wandSensitivity]=\"wandSensitivity\"\n  [brushSize]=\"brushSize\"\n  [samModels]=\"samModels\"\n  [samModelId]=\"samModelId\"\n  [vertexEraserRadius]=\"vertexEraserRadius\"\n  [canUndo]=\"canUndoRegion\"\n  [canRedo]=\"canRedoRegion\"\n  [stackOptions]=\"stackOptions\"\n  [tools]=\"toolbarTools\"\n  [imageSmoothingEnabled]=\"imageSmoothingEnabled\"\n  (selectPlotType)=\"onSelectPlotType($event)\"\n  (toggleImageSmoothing)=\"onToggleImageSmoothing()\"\n  (addProfileLine)=\"addProfileLine()\"\n  (isoRangeChange)=\"onIsoRangeChange($event)\"\n  (openChannelHistogram)=\"openChannelHistogram()\"\n  (openRegionEditor)=\"openRegionEditor()\"\n  (selectStackOption)=\"selectStackOption($event)\"\n  (zScrub)=\"onZScrub($event)\"\n  (zSlide)=\"onZSlide($event)\"\n  (zIndexInput)=\"zIndex = $event; updateZIndex()\"\n  (reloadAndPlot)=\"reloadAndPlot()\"\n  (downloadImage)=\"downloadImage()\"\n  (autoscaleImage)=\"autoscaleImage()\"\n  (toggleDragMode)=\"toggleDragMode($event)\"\n  (zoomIn)=\"zoomIn()\"\n  (zoomOut)=\"zoomOut()\"\n  (toggleSurface3dMode)=\"toggleSurface3dMode($event)\"\n  (resetSurfaceCamera)=\"resetSurfaceCamera()\"\n  (toggleAxes)=\"toggleAxes()\"\n  (toggleWireframe)=\"toggleWireframe()\"\n  (selectResolution)=\"selectResolution($event)\"\n  (deleteRegion)=\"deleteRegion()\"\n  (undoRegion)=\"undoRegion()\"\n  (redoRegion)=\"redoRegion()\"\n  (segmentRegions)=\"segmentRegions()\"\n  (segmentCellpose)=\"segmentCellpose()\"\n  (samModelChange)=\"onSamModelChange($event)\"\n  (wandSensitivityChange)=\"onWandSensitivityChange($event)\"\n  (brushSizeChange)=\"onBrushSizeChange($event)\"\n  (vertexEraserRadiusChange)=\"onVertexEraserRadiusChange($event)\">\n  <!-- Host-projected custom toolbar buttons, forwarded into the toolbar. -->\n  <ng-content></ng-content>\n</plotting-toolbar>\n  <p-button *ngIf=\"toolbarFloating\" class=\"toolbar-dock-btn\" icon=\"pi pi-thumbtack\" size=\"small\" [text]=\"true\"\n            pTooltip=\"Dock to top\" tooltipPosition=\"bottom\" (onClick)=\"dockToolbar()\">\n  </p-button>\n</div>\n\n<p-contextMenu #cm [model]=\"contextMenuItems\" appendTo=\"body\"></p-contextMenu>\n<!-- No `h-full` here: PrimeFlex's height:100% !important made #plot as tall as\n     the whole host, so under the docked toolbar its bottom toolbar-height strip\n     (incl. the OSD scale bar at bottom-left) was clipped by the host's\n     overflow:hidden. The component stylesheet sizes it (.viz-plot { flex: 1 }). -->\n<div class=\"w-full relative viz-plot\" [id]=\"plotDivName\">\n  <div *ngIf=\"imgLoading || stackLoading || isCaching\" id=\"overlay\">\n    <!-- Determinate stack/volume progress takes precedence: while it's active show ONLY the\n         progress bar + \"Loading frames...\", not the generic spinner/\"Loading image...\" on top of\n         it (both were rendering at once for napari volume/isosurface loads). -->\n    <ng-container *ngIf=\"stackLoading; else imgLoadingTpl\">\n      <p-progressBar class=\"progress\" [value]=\"loadingPercentage\"></p-progressBar>\n      <span class=\"text-loading\">Loading frames...</span>\n    </ng-container>\n    <ng-template #imgLoadingTpl>\n      <!-- Cache-copy progress is shown whenever a cache download is active (isCaching), independent\n           of `imgLoading`, so it's never dropped/masked mid-download. -->\n      <ng-container *ngIf=\"isCaching; else spinnerLoading\">\n        <!-- Stage-aware message comes from CacheProgressService updating\n             imageLoadingMessage$ (\"Caching image...\" during the GCS download,\n             then \"Generating preview...\" during per-slice thumbnail gen). Once the\n             download hits 100% the remaining work (server preview/tile generation)\n             has no determinate progress, so fall through to the spinner template\n             rather than parking a full bar under \"Loading image...\". -->\n        <p-progressBar class=\"progress\" [value]=\"cacheProgress\"></p-progressBar>\n        <span class=\"text-loading\">{{loadingMessage}}</span>\n      </ng-container>\n      <ng-template #spinnerLoading>\n        <div *ngIf=\"imgLoading\" class=\"spinner\"></div>\n        <span *ngIf=\"imgLoading && !zoom\" class=\"text-loading\">{{loadingMessage}}</span>\n        <span *ngIf=\"imgLoading && zoom\" class=\"zoom-text-loading\">{{loadingMessage}}</span>\n      </ng-template>\n    </ng-template>\n    <p-button *ngIf=\"stackLoading || imgLoading\" class=\"cancel-loading \" label=\"Cancel\"\n              (onClick)=\"cancelLoading()\">\n    </p-button>\n  </div>\n  <!-- Translucent \"sharpening\" overlay shown after the small-tier preview is\n       on screen while the large-tier render is still loading in the\n       background. Lets the user see the blurry image underneath but makes\n       it clear something is still loading so they don't mistake the\n       low-res render for the final image. -->\n  <div *ngIf=\"sharpening && !imgLoading && !stackLoading && !isCaching\" id=\"sharpening-overlay\">\n    <div class=\"spinner\"></div>\n    <span class=\"text-loading\">Sharpening preview...</span>\n  </div>\n\n</div>\n\n<!-- Floating, draggable intensity-profile inset. Shown in LINE mode; the chart\n     updates live as the line ROI on the image is moved. Kept OUTSIDE #plot and\n     positioned fixed so it floats over the whole page (not clipped to the\n     diagram/canvas area). -->\n<div *ngIf=\"hasProfiles\" class=\"intensity-panel\"\n     [style.left.px]=\"profilePanelPos.x\" [style.top.px]=\"profilePanelPos.y\">\n  <div class=\"intensity-panel-header\" (mousedown)=\"onProfilePanelDragStart($event)\">\n    <span>Intensity profile</span>\n    <i class=\"pi pi-arrows-alt\"></i>\n  </div>\n  <div [id]=\"intensityInsetDiv\" class=\"intensity-panel-plot\"></div>\n</div>\n\n<!-- Channels & Histogram: non-modal floating dialog opened from the toolbar. -->\n<channel-histogram [(visible)]=\"showChannelHistogram\"></channel-histogram>\n\n<!-- Region Editor: non-modal, draggable, resizable floating dialog opened from\n     the toolbar (formerly the right-panel Regions tab). Modeless so regions can\n     still be drawn/selected on the plot while it's open; stays linked to this\n     plotting instance via the root RegionStore singleton. Opens over the right\n     side of the view. -->\n<p-dialog header=\"Region Editor\" [(visible)]=\"showRegionEditor\"\n          [modal]=\"false\" [resizable]=\"true\" [draggable]=\"true\"\n          [maximizable]=\"true\" appendTo=\"body\" position=\"right\"\n          [style]=\"{ width: regionEditorWidth, height: '85vh' }\"\n          [contentStyle]=\"{ overflow: 'auto' }\">\n  <region-editor></region-editor>\n</p-dialog>\n\n<!-- Simplify (Douglas–Peucker): custom px-threshold picker for the selected\n     region(s), opened from the right-click \"Simplify ▸ Custom…\" action. -->\n<p-dialog header=\"Simplify region(s)\" [(visible)]=\"displaySimplifyDialog\" [modal]=\"true\"\n          [style]=\"{width: '22rem'}\" [draggable]=\"false\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-2\">\n    <span>Altitude threshold: <b>{{ simplifyThreshold }} px</b></span>\n    <p-slider [(ngModel)]=\"simplifyThreshold\" [min]=\"1\" [max]=\"20\" [step]=\"1\"></p-slider>\n    <small>Vertices within this distance of the line between their neighbours are removed.</small>\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" [text]=\"true\" (onClick)=\"displaySimplifyDialog = false\"></p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"simplifyRegions(simplifyThreshold)\"></p-button>\n  </ng-template>\n</p-dialog>\n\n"]}