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

package/esm2022/lib/region-editor/region-editor.component.mjs

@@ -0,0 +1,1190 @@
+import { Component, Inject, ViewChild } from '@angular/core';
+import { OverlayPanel } from 'primeng/overlaypanel';
+import { saveAs } from 'file-saver';
+import { Subject, Subscription } from 'rxjs';
+import { debounceTime, switchMap } from 'rxjs/operators';
+import { Polygon, Rectangle, Region, MultiPolygon } from '../models/region';
+import { defaultPresetSet } from '../models/class-preset';
+import { colorForLabel } from '../store/class-color.util';
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { REGION_EDITOR_API } from '../contracts/region-editor-api.contract';
+import { REGION_IO_PORT } from '../contracts/ports/region-io.port';
+import { regionToParts, scaleParts, maskScaleFor } from './mask-raster';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "primeng/toolbar";
+import * as i5 from "primeng/button";
+import * as i6 from "primeng/tooltip";
+import * as i7 from "primeng/dropdown";
+import * as i8 from "primeng/dialog";
+import * as i9 from "primeng/progressbar";
+import * as i10 from "primeng/ripple";
+import * as i11 from "primeng/table";
+import * as i12 from "primeng/paginator";
+import * as i13 from "primeng/overlaypanel";
+import * as i14 from "primeng/confirmdialog";
+import * as i15 from "primeng/inputtext";
+import * as i16 from "primeng/checkbox";
+import * as i17 from "primeng/radiobutton";
+import * as i18 from "primeng/selectbutton";
+import * as i19 from "../hex-color-picker/hex-color-picker.component";
+export class RegionEditorComponent {
+    constructor(regionApi, messageService, confirmationService, regionIo) {
+        this.regionApi = regionApi;
+        this.messageService = messageService;
+        this.confirmationService = confirmationService;
+        this.regionIo = regionIo;
+        this.Array = Array;
+        this.regions = [];
+        this.regionsCopy = [];
+        this.selectedRegions = [];
+        this.displayHelpDialog = false;
+        this.showColorDialog = false;
+        /** One colour editor per unique class among the selected regions, shown in the
+         *  "edit colour of selected regions" dialog. Unclassified regions (no label)
+         *  are grouped under a single entry with an empty `label`. */
+        this.classColorEdits = [];
+        this.labelColors = new Map();
+        this.selectedLabelColor = '';
+        /** "Edit class on selected rows" popup: chosen existing class, and a new-class name. */
+        this.bulkClass = '';
+        this.newBulkClass = '';
+        // ── annotation-class presets (jit-ui#70) ──
+        /** Local mirror of the per-user preset set (chip strip, Class dropdown, dialog). */
+        this.presetSet = defaultPresetSet();
+        /** Class applied to newly drawn/added regions and to bulk chip-clicks. */
+        this.activeClass = null;
+        this.showManageDialog = false;
+        /** Working copy edited inside the Manage-classes dialog; committed on Apply/Done. */
+        this.presetDraft = null;
+        /** class name (match-mode keyed) → number of regions currently using it. */
+        this.classCounts = new Map();
+        /** Fallback class that a region reverts to when its class is deleted (jit-ui#70). */
+        this.defaultClassName = 'Region';
+        /** Classes as shown in the panel: sorted by region count (desc), then name. */
+        this.displayClasses = [];
+        this.matchModeOptions = [
+            { label: 'Exact', value: 'exact' },
+            { label: 'Normalized', value: 'normalized' },
+        ];
+        this.paginatorFirst = 0;
+        this.paginatorRows = 10;
+        this.rowsPerPageOptions = [10, 25, 50];
+        /** Regions whose Class cell is currently in edit mode.
+         *  Using object identity as the key avoids needing a unique id field. */
+        this.editingLabelRegions = new Set();
+        this.showSaveAsDialog = false;
+        this.saveAsFilename = '';
+        this.saveAsFileExists = false;
+        /** True while a GeoJSON persist is serializing/uploading — drives the dialog's
+         *  progress bar and Cancel button (parity with the Save-mask dialog). */
+        this.saveAsBusy = false;
+        this._saveAsCheck$ = new Subject();
+        this.showExportDialog = false;
+        this.exportFilename = '';
+        this.showSaveMaskDialog = false;
+        this.saveMaskFilename = '';
+        /** Mask type chosen in the Save-mask dialog: a binary foreground/background
+         *  mask, or a multi-class mask with a distinct id per region. */
+        this.maskMode = 'binary';
+        /** True while the mask worker is rasterizing/encoding — drives the progress
+         *  bar and the Cancel button in the dialog. */
+        this.maskBusy = false;
+        /** 0–100 rasterization progress; switches to indeterminate during encoding. */
+        this.maskProgress = 0;
+        this.maskEncoding = false;
+        this.pendingMaskFilename = '';
+        /**
+         * PrimeNG p-table multi-selection mode toggle. When true, single-click
+         * selects one row (replacing prior); meta/ctrl-click toggles a row in/out
+         * of the selection. When false, every click toggles. Default true to
+         * match the most common spreadsheet-like UX.
+         */
+        this.metaKey = true;
+        this._updatingFromEditor = false;
+        this._suppressSelectionSyncToPlot = false;
+        this._regionSub = new Subscription();
+        this._selectedIdxSub = new Subscription();
+        this._metaSub = new Subscription();
+        this._presetSub = new Subscription();
+        /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */
+        this.trackByClassName = (_, c) => c.name;
+    }
+    /**
+     * Deep copy of regions for dirty-tracking (`regionsCopy`). Returns plain-object
+     * clones — only structural equality matters here, not prototypes.
+     * TODO: replace with `structuredClone` once verified.
+     */
+    deepClone(items) {
+        return items.map((item) => {
+            if (Array.isArray(item)) {
+                return this.deepClone(item);
+            }
+            else if (typeof item === 'object' && item !== null) {
+                const cloned = {};
+                for (const key in item) {
+                    cloned[key] = this.deepClone([item[key]])[0];
+                }
+                return cloned;
+            }
+            return item;
+        });
+    }
+    ngOnInit() {
+        this.showShapeLabel = this.regionApi.getShowShapeLabel();
+        this.shapeColor = this.regionApi.getShapeColor();
+        this.fillColor = this.regionApi.getFillColor();
+        // Annotation-class presets (jit-ui#70): mirror the set for the chip strip,
+        // the Class dropdown and the manage dialog. Guarded with optional calls so
+        // partial API mocks in tests (which omit the preset methods) don't throw.
+        const initialPresets = this.regionApi.getPresetSet?.();
+        if (initialPresets)
+            this.presetSet = initialPresets;
+        const presets$ = this.regionApi.getPresetSet$?.();
+        if (presets$) {
+            this._presetSub = presets$.subscribe((set) => {
+                if (set)
+                    this.presetSet = set;
+                this.updateDisplayClasses();
+            });
+        }
+        // Seed from the visualizer's current regions — already scoped to the
+        // active image by the per-image cache, and handed back as neutral Region
+        // objects (no backend shape format involved).
+        // Annotation regions only — intensity-profile lines are owned by the
+        // intensity tool and excluded by the contract, so the editor never sees them.
+        this.regions = this.applyRegionColors(this.regionApi.getAnnotationRegions());
+        this.regionsCopy = this.deepClone(this.regions);
+        this.syncClassesFromRegions(this.regions);
+        this.recomputeClassCounts();
+        // The update event is just a change signal; re-read the regions from the
+        // visualizer rather than parsing whatever payload it carries.
+        this._regionSub = this.regionApi.getRegionUpdateEvent().subscribe(() => {
+            if (this._updatingFromEditor)
+                return;
+            const updated = this.applyRegionColors(this.regionApi.getAnnotationRegions());
+            // preserve selection for regions that still exist (by id, since name
+            // is a user-editable display label and may collide)
+            const selectedIds = new Set(this.selectedRegions.map((r) => r.id));
+            this.regions = updated;
+            this.regionsCopy = this.deepClone(this.regions);
+            this.selectedRegions = updated.filter((r) => selectedIds.has(r.id));
+            this.clampPaginatorFirst();
+            this.syncClassesFromRegions(updated);
+            this.recomputeClassCounts();
+        });
+        this._saveAsCheck$.pipe(debounceTime(400), switchMap(name => this.regionIo.roiFileExists(name))).subscribe({
+            next: exists => { this.saveAsFileExists = exists; },
+            error: () => { this.saveAsFileExists = false; },
+        });
+        // Physical pixel size of the active image (for region areas in µm²/mm²).
+        // Mirror PlotlyService.currentMpp: the calibration may sit on any channel
+        // entry, not necessarily [0], so pick the first entry with a positive mppX
+        // rather than reading [0] blindly. Fall back to square pixels (mppY = mppX)
+        // when only one axis is reported.
+        this._metaSub = this.regionApi.getImageMeta().subscribe((meta) => {
+            const { mppX, mppY } = this.pickMpp(meta);
+            this.mppX = mppX;
+            this.mppY = mppY;
+        });
+        this._selectedIdxSub = this.regionApi.getSelectedRegions$().subscribe((selected) => {
+            if (this._suppressSelectionSyncToPlot)
+                return;
+            // Map the contract's selected regions to the editor's own instances by id.
+            const next = selected
+                .map((s) => this.regions.find((r) => r.id === s.id))
+                .filter((r) => !!r);
+            const same = next.length === this.selectedRegions.length &&
+                next.every((r, i) => r.id === this.selectedRegions[i]?.id);
+            if (!same)
+                this.selectedRegions = next;
+            // Scroll the paginator so the most-recently-selected row is visible.
+            if (next.length > 0) {
+                const lastIdx = this.regions.findIndex((r) => r.id === next[next.length - 1].id);
+                if (lastIdx >= 0) {
+                    const pageStart = Math.floor(lastIdx / this.paginatorRows) * this.paginatorRows;
+                    if (pageStart !== this.paginatorFirst)
+                        this.paginatorFirst = pageStart;
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._regionSub.unsubscribe();
+        this._selectedIdxSub.unsubscribe();
+        this._metaSub.unsubscribe();
+        this._presetSub.unsubscribe();
+        if (this._saveAsTimer !== undefined)
+            clearTimeout(this._saveAsTimer);
+        this._saveAsSub?.unsubscribe();
+        this.teardownMaskWorker();
+    }
+    /**
+     * Table → Plot: PrimeNG fires onRowSelect/onRowUnselect after updating
+     * `selectedRegions`. Push the selected regions to the contract by identity —
+     * the package maps them to its internal index space (which includes the
+     * intensity-profile lines the editor never sees).
+     */
+    onSelectionChanged() {
+        this._suppressSelectionSyncToPlot = true;
+        try {
+            this.regionApi.setSelectedRegions(this.selectedRegions ?? []);
+        }
+        finally {
+            this._suppressSelectionSyncToPlot = false;
+        }
+    }
+    /**
+     * Apply classification colours and refresh the label→colour map for regions
+     * coming from the visualizer. The visualizer hands back neutral `Region`
+     * objects with bounds, colour and label already populated, so the editor no
+     * longer parses any backend-specific shape format — it only fills in a
+     * fallback colour and rebuilds its local label→colour lookup.
+     */
+    applyRegionColors(regions) {
+        for (const region of regions) {
+            region.color =
+                region.color ||
+                    this.regionApi.getClassificationColors().get(region.label ?? '') ||
+                    this.shapeColor;
+        }
+        // Rebuild labelColors: seed from persisted map, then overlay actual region colors
+        this.labelColors.clear();
+        for (const [label, color] of this.regionApi.getClassificationColors()) {
+            this.labelColors.set(label, color);
+        }
+        for (const region of regions) {
+            if (region.label && region.color) {
+                this.labelColors.set(region.label, region.color);
+            }
+        }
+        return regions;
+    }
+    /**
+     * Push edits from the editor to the diagram in live-edit mode (no save /
+     * cancel buttons). The `_updatingFromEditor` guard is still used so the
+     * resulting regionUpdateEvent doesn't bounce back as an external change.
+     */
+    setRegionsFromEditor(fillColor) {
+        this._updatingFromEditor = true;
+        // isRegionSaveOn=true so changes commit to the region store (and the per-image
+        // cache) immediately. setAnnotationRegions preserves the intensity-profile
+        // lines internally, so editor edits never disturb them.
+        this.regionApi.setAnnotationRegions(this.regions, this.showShapeLabel, true, fillColor ?? this.fillColor);
+        this._updatingFromEditor = false;
+        // The editor's own commit is ignored by the region-update subscription (the
+        // _updatingFromEditor guard), so refresh here: a class label typed in the
+        // Class column gets added to the list, and the panel counts/order stay in
+        // sync after any edit. (jit-ui#70)
+        this.syncClassesFromRegions(this.regions);
+        this.recomputeClassCounts();
+    }
+    /** Set one region's outline colour from the per-row picker and commit live.
+     *  Remembers it as the label's colour so same-class regions added later match
+     *  (jit-ui#85 — the Region Editor's per-region Color column). */
+    changeRegionColor(region, color) {
+        if (!color || region.color === color)
+            return;
+        region.color = color;
+        region.colorOverridden = true; // explicit per-region colour — preserve it against preset (re)apply (jit-ui#70)
+        if (region.label)
+            this.labelColors.set(region.label, color);
+        this.setRegionsFromEditor();
+    }
+    addRectangle() {
+        const region = new Region();
+        region.bounds = new Rectangle();
+        region.bounds.width = 512;
+        region.bounds.height = 512;
+        region.label = this.activeClass ?? 'Region';
+        // id and a non-colliding name are minted by the visualizer's setRegions
+        this.regions = [...this.regions, region];
+        this.setRegionsFromEditor();
+        this.regionsCopy = this.deepClone(this.regions);
+    }
+    /**
+     * Update the label of the region on enter key pressed (when editing a label cell in the table)
+     * @param region
+     * @param setRegion
+     */
+    labelRegionUpdate(region, setRegion = false) {
+        if (region.label) {
+            // if label doesn't exist
+            if (!this.labelColors.has(region.label)) {
+                this.labelColors.set(region.label, this.shapeColor);
+            }
+        }
+        // update colors of the regions
+        for (const reg of this.regions) {
+            if (!reg.color) {
+                if (reg.label && this.labelColors.has(reg.label)) {
+                    reg.color = this.labelColors.get(reg.label);
+                }
+            }
+        }
+        // update labels map
+        this.labelColors.clear();
+        for (const reg of this.regions) {
+            if (reg.label && reg.color) {
+                this.labelColors.set(reg.label, reg.color);
+            }
+        }
+        if (setRegion) {
+            this.setRegionsFromEditor();
+        }
+    }
+    xRectUpdate(region, event) {
+        const rectangle = region.bounds;
+        if (rectangle && rectangle instanceof Rectangle) {
+            rectangle.x = event.value;
+            this.setRegionsFromEditor();
+        }
+    }
+    yRectUpdate(region, event) {
+        const rectangle = region.bounds;
+        if (rectangle && rectangle instanceof Rectangle) {
+            rectangle.y = event.value;
+            this.setRegionsFromEditor();
+        }
+    }
+    widthRectUpdate(region, event) {
+        if (event.value === null || event.value === undefined)
+            return;
+        const rectangle = region.bounds;
+        if (rectangle && rectangle instanceof Rectangle) {
+            const reg = this.regionsCopy.filter((element) => element.id === region.id);
+            if (reg.length) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                const oldWidth = reg[0].bounds.width;
+                const diffWidth = event.value - oldWidth;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                rectangle.x = Math.round(reg[0].bounds.x - diffWidth / 2);
+            }
+            rectangle.width = event.value;
+            this.setRegionsFromEditor();
+            this.regionsCopy = this.deepClone(this.regions);
+        }
+    }
+    heightRectUpdate(region, event) {
+        if (event.value === null || event.value === undefined)
+            return;
+        const rectangle = region.bounds;
+        if (rectangle && rectangle instanceof Rectangle) {
+            const reg = this.regionsCopy.filter((element) => element.id === region.id);
+            if (reg.length) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                const oldHeight = reg[0].bounds.height;
+                const diffHeight = event.value - oldHeight;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                rectangle.y = Math.round(reg[0].bounds.y - diffHeight / 2);
+            }
+            rectangle.height = event.value;
+            this.setRegionsFromEditor();
+            this.regionsCopy = this.deepClone(this.regions);
+        }
+    }
+    onPageChange(event) {
+        this.paginatorFirst = event.first ?? 0;
+        this.paginatorRows = event.rows ?? this.paginatorRows;
+    }
+    /** Select every region in the table (and highlight them on the diagram). */
+    selectAllRegions() {
+        this.selectedRegions = [...this.regions];
+        this.onSelectionChanged();
+    }
+    deleteSelectedRegions() {
+        if (this.selectedRegions && this.selectedRegions.length > 0) {
+            // Filter by id — object identity isn't reliable across re-parses,
+            // and name is a user-editable label that may collide.
+            const removed = new Set(this.selectedRegions.map((r) => r.id));
+            this.regions = this.regions.filter((r) => !removed.has(r.id));
+            this.selectedRegions = [];
+            this.clampPaginatorFirst();
+            this.setRegionsFromEditor();
+            // Sync the cleared selection with the plot's highlight state.
+            this.onSelectionChanged();
+        }
+    }
+    clearAllRegions() {
+        this.confirmationService.confirm({
+            key: 'positionDialog',
+            message: 'Are you sure you want to delete all regions?',
+            accept: () => {
+                this.regions = [];
+                this.selectedRegions = [];
+                this.paginatorFirst = 0;
+                this.setRegionsFromEditor();
+                this.onSelectionChanged();
+            },
+        });
+    }
+    addPolygon() {
+        const region = new Region();
+        region.bounds = new Polygon();
+        region.label = this.activeClass ?? 'Region';
+        region.bounds.ypoints = [0, 0, 0];
+        region.bounds.xpoints = [0, 0, 0];
+        region.bounds.coordinates = [
+            [0, 0],
+            [0, 0],
+            [0, 0],
+        ];
+        region.bounds.npoints = 3;
+        this.regions = [...this.regions, region];
+        this.setRegionsFromEditor();
+        this.regionsCopy = this.deepClone(this.regions);
+    }
+    deleteRegion(shapeIdx) {
+        const removed = this.regions[shapeIdx];
+        this.regions = this.regions.filter((_, i) => i !== shapeIdx);
+        if (removed) {
+            this.selectedRegions = this.selectedRegions.filter((r) => r.id !== removed.id);
+        }
+        this.clampPaginatorFirst();
+        this.setRegionsFromEditor();
+        // Re-emit the (possibly trimmed) selection so the plot's highlight stays
+        // in sync with what's still in the table.
+        this.onSelectionChanged();
+    }
+    clampPaginatorFirst() {
+        const maxFirst = Math.max(0, Math.floor((this.regions.length - 1) / this.paginatorRows) * this.paginatorRows);
+        if (this.paginatorFirst > maxFirst) {
+            this.paginatorFirst = maxFirst;
+        }
+    }
+    changeShowShapeLabel(showLabel) {
+        this.setRegionsFromEditor();
+    }
+    isEditingLabel(region) {
+        return this.editingLabelRegions.has(region);
+    }
+    startEditLabel(region, event) {
+        event?.stopPropagation(); // don't toggle row selection
+        this.editingLabelRegions.add(region);
+    }
+    stopEditLabel(region, commit, event) {
+        event?.stopPropagation();
+        this.editingLabelRegions.delete(region);
+        if (commit) {
+            this.labelRegionUpdate(region, true);
+        }
+    }
+    isRectangle(region) {
+        return region.bounds instanceof Rectangle;
+    }
+    /**
+     * Region area for display: in µm² (or mm²) when the image reports a physical
+     * pixel size, otherwise in px². Empty string for degenerate regions.
+     */
+    regionArea(region) {
+        const px = this.areaInPixels(region);
+        if (px <= 0)
+            return '';
+        if (this.mppX && this.mppY && this.mppX > 0 && this.mppY > 0) {
+            const um2 = px * this.mppX * this.mppY;
+            return um2 >= 1e6 ? `${this.fmtArea(um2 / 1e6)} mm²` : `${this.fmtArea(um2)} µm²`;
+        }
+        return `${this.fmtArea(px)} px²`;
+    }
+    /**
+     * Choose the physical pixel size (µm/pixel) for area display from the image
+     * meta. The calibration may sit on any channel entry — not necessarily [0] —
+     * so pick the first entry with a positive mppX (mirrors
+     * PlotlyService.currentMpp). Falls back to square pixels (mppY = mppX) when
+     * only one axis is reported, so a scaled image shows µm²/mm² rather than px².
+     */
+    pickMpp(meta) {
+        const m = Array.isArray(meta)
+            ? (meta.find((e) => e && (e.mppX ?? 0) > 0) ?? meta[0])
+            : undefined;
+        const mx = m && (m.mppX ?? 0) > 0 ? m.mppX : undefined;
+        const my = m && (m.mppY ?? 0) > 0 ? m.mppY : undefined;
+        return { mppX: mx, mppY: my ?? mx };
+    }
+    /** Pixel area: width·height for rectangles, shoelace formula for polygons.
+     *  Interior rings (holes) are subtracted, so a donut reports the annulus area,
+     *  not the filled exterior (jit-ui#85). */
+    areaInPixels(region) {
+        const b = region.bounds;
+        if (b instanceof Rectangle)
+            return Math.abs(b.width * b.height);
+        if (b instanceof Polygon)
+            return this.polygonArea(b);
+        // Multi-part region: sum each part's (exterior − holes) area (jit-ui#85).
+        if (b instanceof MultiPolygon) {
+            return b.polygons.reduce((sum, p) => sum + this.polygonArea(p), 0);
+        }
+        return 0;
+    }
+    /** Polygon area: exterior shoelace minus each interior ring (hole). */
+    polygonArea(p) {
+        if ((p.xpoints?.length ?? 0) < 3)
+            return 0;
+        let a = this.ringArea(p.xpoints, p.ypoints);
+        if (p.holes) {
+            for (const ring of p.holes)
+                a -= this.ringArea(ring.map(pt => pt[0]), ring.map(pt => pt[1]));
+        }
+        return Math.max(0, a);
+    }
+    /** Absolute shoelace area of a single ring. */
+    ringArea(xs, ys) {
+        const n = xs?.length ?? 0;
+        if (n < 3)
+            return 0;
+        let a = 0;
+        for (let i = 0, j = n - 1; i < n; j = i++)
+            a += (xs[j] + xs[i]) * (ys[j] - ys[i]);
+        return Math.abs(a / 2);
+    }
+    fmtArea(n) {
+        return (n >= 1000 ? Math.round(n) : Math.round(n * 100) / 100).toLocaleString();
+    }
+    /**
+     * This method rounds all the rectangle regions lengths to multiple of 512
+     */
+    roundRectangleLengths() {
+        for (const region of this.regions) {
+            if (region.bounds instanceof Rectangle) {
+                const rect = region.bounds;
+                rect.height = Math.round(rect.height / 512) * 512;
+                rect.width = Math.round(rect.width / 512) * 512;
+            }
+        }
+        this.setRegionsFromEditor();
+    }
+    /**
+     * Stop key arrow event propagation
+     * @param event
+     */
+    disableArrowKeys(event) {
+        if (event.key === 'ArrowDown' ||
+            event.key === 'Down' ||
+            event.key === 'ArrowUp' ||
+            event.key === 'Up' ||
+            event.key === 'ArrowLeft' ||
+            event.key === 'Left' ||
+            event.key === 'ArrowRight' ||
+            event.key === 'Right') {
+            event.stopPropagation();
+        }
+    }
+    changeShapeColor(event) {
+        this.shapeColor = event.value;
+        for (const region of this.regions) {
+            if (region.label === this.selectedLabelColor && this.labelColors.has(region.label)) {
+                this.labelColors.set(region.label, this.shapeColor);
+                region.color = this.shapeColor;
+            }
+        }
+        this.setRegionsFromEditor(this.fillColor);
+    }
+    showHelp() {
+        this.displayHelpDialog = true;
+    }
+    /** Open the colour dialog for the currently-selected region(s), building one
+     *  colour picker per unique class in the selection. Each picker is seeded with
+     *  the class's current colour (the label→colour map, falling back to the first
+     *  selected region of that class). */
+    openColorDialog() {
+        if (!this.selectedRegions?.length)
+            return;
+        const seedByLabel = new Map();
+        for (const region of this.selectedRegions) {
+            const label = region.label?.trim() ?? '';
+            if (seedByLabel.has(label))
+                continue;
+            seedByLabel.set(label, (label ? this.labelColors.get(label) : undefined) ?? region.color ?? this.shapeColor);
+        }
+        this.classColorEdits = [...seedByLabel].map(([label, color]) => ({ label, color }));
+        this.showColorDialog = true;
+    }
+    /** Apply each class's chosen colour to the selected regions of that class and
+     *  commit live. Remembers the colour per class so same-class regions added
+     *  later match. */
+    applyColorToSelected() {
+        const colorByLabel = new Map(this.classColorEdits.map((e) => [e.label, e.color]));
+        for (const region of this.selectedRegions ?? []) {
+            const label = region.label?.trim() ?? '';
+            const color = colorByLabel.get(label);
+            if (!color)
+                continue;
+            region.color = color;
+            region.colorOverridden = true; // explicit colour — preserve against preset (re)apply (jit-ui#70)
+            if (label)
+                this.labelColors.set(label, color);
+        }
+        this.setRegionsFromEditor();
+        this.showColorDialog = false;
+    }
+    // ── annotation-class presets (jit-ui#70) ─────────────────────────────
+    /** Resolve the display colour for a class name (preset colour or deterministic fallback). */
+    colorForName(name) {
+        return name ? colorForLabel(name, this.presetSet) : this.shapeColor;
+    }
+    /**
+     * Ensure every class label present in the loaded regions exists in the preset
+     * list, auto-adding any that are missing (using the region's already-resolved
+     * colour). This makes classes carried in a loaded/imported GeoJSON show up as
+     * chips + Class-dropdown options (a p-dropdown can't display a value that isn't
+     * an option) and lets the user manage them. The placeholder 'legend' and empty
+     * labels are ignored. (jit-ui#70)
+     */
+    syncClassesFromRegions(regions) {
+        const normalized = this.presetSet.matchMode === 'normalized';
+        const keyOf = (l) => (normalized ? l.trim().toLowerCase() : l);
+        const known = new Set(this.presetSet.classes.map((c) => keyOf(c.name)));
+        const added = new Set();
+        for (const r of regions) {
+            const label = r.label?.trim();
+            if (!label || label === 'legend')
+                continue;
+            const k = keyOf(label);
+            if (known.has(k) || added.has(k))
+                continue;
+            added.add(k);
+            this.regionApi.upsertClass({
+                name: label,
+                color: r.color || colorForLabel(label, this.presetSet),
+                source: 'auto',
+            });
+        }
+    }
+    // ── Docked Classes panel (jit-ui#70) ─────────────────────────────────
+    /** Rebuild the per-class region counts shown in the panel. */
+    recomputeClassCounts() {
+        const normalized = this.presetSet.matchMode === 'normalized';
+        const counts = new Map();
+        for (const r of this.regions) {
+            if (!r.label)
+                continue;
+            const k = normalized ? r.label.trim().toLowerCase() : r.label;
+            counts.set(k, (counts.get(k) ?? 0) + 1);
+        }
+        this.classCounts = counts;
+        this.updateDisplayClasses();
+    }
+    /** Rebuild the panel's display order — most-used classes first, then by name. */
+    updateDisplayClasses() {
+        this.displayClasses = [...this.presetSet.classes].sort((a, b) => {
+            const d = this.classCount(b.name) - this.classCount(a.name);
+            return d !== 0 ? d : a.name.localeCompare(b.name);
+        });
+    }
+    /** Number of regions currently using a class (keyed by the active match mode). */
+    classCount(name) {
+        const k = this.presetSet.matchMode === 'normalized' ? name.trim().toLowerCase() : name;
+        return this.classCounts.get(k) ?? 0;
+    }
+    /** Recolour a class from its panel swatch and repaint its (non-overridden) regions. */
+    setClassColor(name, color) {
+        if (!color)
+            return;
+        this.regionApi.setClassificationColor(name, color);
+        this.setRegionsFromEditor();
+    }
+    /** Tooltip for a class's delete button in the panel. */
+    deleteClassTooltip(name) {
+        const inUse = this.classCount(name) > 0;
+        if (name === this.defaultClassName && inUse)
+            return 'The default class cannot be removed while in use';
+        return inUse ? 'Remove class — its regions revert to Region' : 'Remove class';
+    }
+    /** Remove a class. Any regions still using it fall back to the default
+     *  "Region" class, so they aren't orphaned (and the class isn't immediately
+     *  re-added from its regions by syncClassesFromRegions). */
+    deleteClass(name) {
+        this.reassignRegionsToDefaultClass([name]);
+        this.regionApi.removeClass(name);
+        if (this.activeClass === name)
+            this.activeClass = null;
+        this.setRegionsFromEditor();
+    }
+    /** Regions labelled with any of `removedNames` revert to the default
+     *  {@link defaultClassName} ("Region"): its class colour, override cleared.
+     *  Skips the default itself so deleting "Region" can't self-reassign. (jit-ui#70) */
+    reassignRegionsToDefaultClass(removedNames) {
+        const norm = this.presetSet.matchMode === 'normalized';
+        const keyOf = (s) => (norm ? s.trim().toLowerCase() : s);
+        const removed = new Set(removedNames.map(keyOf));
+        removed.delete(keyOf(this.defaultClassName));
+        if (!removed.size)
+            return;
+        const color = colorForLabel(this.defaultClassName, this.presetSet);
+        for (const r of this.regions) {
+            if (r.label && removed.has(keyOf(r.label))) {
+                r.label = this.defaultClassName;
+                r.colorOverridden = false;
+                r.color = color;
+            }
+        }
+    }
+    /** Stamp a class (and its preset/fallback colour) onto one region from the Class
+     *  dropdown; choosing a class opts the region back into the preset colour. */
+    applyPresetToRegion(region, className) {
+        const name = (className ?? '').trim();
+        region.label = name;
+        region.colorOverridden = false;
+        if (name)
+            region.color = colorForLabel(name, this.presetSet);
+        this.setRegionsFromEditor();
+    }
+    /** Make a class active (used for new regions) and, if rows are selected, apply
+     *  it to them in one commit. */
+    selectActiveClass(name) {
+        this.activeClass = name;
+        this.applyClassToSelected(name);
+    }
+    /** Apply a class (label + preset/fallback colour) to the current selection and commit. */
+    applyClassToSelected(name) {
+        const selected = this.selectedRegions ?? [];
+        if (!selected.length)
+            return;
+        for (const r of selected) {
+            r.label = name;
+            r.colorOverridden = false;
+            r.color = colorForLabel(name, this.presetSet);
+        }
+        this.setRegionsFromEditor();
+    }
+    /** "Edit class on selected rows" popup — apply the chosen existing class. */
+    applyBulkClass() {
+        if (!this.bulkClass)
+            return;
+        this.applyClassToSelected(this.bulkClass);
+        this.overlayPanel?.hide();
+    }
+    /** "Edit class on selected rows" popup — add a new class and set it on the selection. */
+    addAndApplyBulkClass() {
+        const name = this.newBulkClass.trim();
+        if (!name)
+            return;
+        const norm = this.presetSet.matchMode === 'normalized';
+        const exists = this.presetSet.classes.some((c) => norm ? c.name.trim().toLowerCase() === name.toLowerCase() : c.name === name);
+        if (!exists) {
+            this.regionApi.upsertClass({ name, color: colorForLabel(name, this.presetSet), source: 'user' });
+        }
+        this.applyClassToSelected(name);
+        this.bulkClass = name;
+        this.newBulkClass = '';
+        this.overlayPanel?.hide();
+    }
+    // ── Manage-classes dialog ──
+    openManageDialog() {
+        this.presetDraft = this.clonePresetSet(this.presetSet);
+        this.showManageDialog = true;
+    }
+    clonePresetSet(s) {
+        return {
+            classes: (s.classes ?? []).map((c) => ({ ...c })),
+            fallbackPalette: [...(s.fallbackPalette ?? [])],
+            autoPromote: !!s.autoPromote,
+            matchMode: s.matchMode === 'normalized' ? 'normalized' : 'exact',
+        };
+    }
+    addPresetClass() {
+        this.presetDraft?.classes.push({ name: '', color: '#888888', source: 'user' });
+    }
+    removePresetClass(i) {
+        this.presetDraft?.classes.splice(i, 1);
+    }
+    addFallbackColor() {
+        this.presetDraft?.fallbackPalette.push('#888888');
+    }
+    removeFallbackColor(i) {
+        this.presetDraft?.fallbackPalette.splice(i, 1);
+    }
+    /** Commit the draft: drop blank/duplicate names, persist, and recolour
+     *  non-overridden regions with the updated presets. */
+    applyManageDialog(close) {
+        if (!this.presetDraft)
+            return;
+        // De-duplicate using the active match mode's key so normalized mode can't keep
+        // both "Tumor" and "tumor" (which would collide at runtime in findPreset()).
+        const norm = this.presetDraft.matchMode === 'normalized';
+        const seen = new Set();
+        const classes = [];
+        for (const c of this.presetDraft.classes) {
+            const name = (c.name ?? '').trim();
+            const key = norm ? name.toLowerCase() : name;
+            if (!name || seen.has(key))
+                continue;
+            seen.add(key);
+            classes.push({ ...c, name });
+        }
+        this.presetDraft.classes = classes;
+        // Classes dropped in the dialog: their regions revert to the default "Region"
+        // class (else syncClassesFromRegions would just re-add them) (jit-ui#70).
+        const keyOf = (s) => (norm ? s.trim().toLowerCase() : s);
+        const kept = new Set(classes.map((c) => keyOf(c.name)));
+        const removed = this.presetSet.classes
+            .map((c) => c.name)
+            .filter((n) => !kept.has(keyOf(n)));
+        this.reassignRegionsToDefaultClass(removed);
+        this.regionApi.setPresetSet(this.presetDraft);
+        this.setRegionsFromEditor(); // recolour existing (non-overridden) regions from the new presets
+        if (close)
+            this.showManageDialog = false;
+    }
+    resetPresetsToDefaults() {
+        this.regionApi.resetPresets();
+        this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());
+        this.setRegionsFromEditor();
+    }
+    exportPresets() {
+        const json = JSON.stringify(this.regionApi.getPresetSet(), null, 2);
+        saveAs(new Blob([json], { type: 'application/json' }), 'annotation-classes.json');
+    }
+    importPresets(event) {
+        const input = event.target;
+        const file = input.files?.[0];
+        if (!file)
+            return;
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            try {
+                const set = JSON.parse(e.target.result);
+                this.regionApi.setPresetSet(set);
+                this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());
+                this.setRegionsFromEditor();
+                this.messageService.add({ key: 'app-toast', severity: 'success',
+                    summary: 'Classes imported', detail: 'Annotation classes loaded.' });
+            }
+            catch (err) {
+                this.messageService.add({ key: 'app-toast', severity: 'error',
+                    summary: 'Import failed', detail: `${err}` });
+            }
+        };
+        reader.readAsText(file);
+    }
+    importRois(event) {
+        const input = event.target;
+        const file = input.files?.[0];
+        if (!file)
+            return;
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            const fileContent = e.target.result;
+            try {
+                this.regions = this.regionApi.importRegions(fileContent);
+                // set label colors
+                for (const region of this.regions) {
+                    this.labelRegionUpdate(region, false);
+                }
+                this.syncClassesFromRegions(this.regions);
+                this.setRegionsFromEditor();
+            }
+            catch (event) {
+                this.messageService.add({
+                    severity: 'error',
+                    summary: 'Error importing the file',
+                    detail: `${event}`,
+                });
+                console.error('Error reading the file: ' + event);
+            }
+        };
+        reader.readAsText(file);
+    }
+    /**
+     * Regions to serialize on save/export. For a single-file z-stack the store
+     * keeps only the current slice live, so pull EVERY slice's annotations (each
+     * tagged with its zero-based Region.z) to write one combined z-indexed
+     * geojson (jit-ui#93). Otherwise (single-plane image, or a folder stack whose
+     * slices save to their own per-slice files) the current set. (jit-ui#93)
+     */
+    regionsForSave() {
+        if (this.regionApi.isStackMode() && this.regionApi.getStackSaveLayout() === 'combined') {
+            return this.regionApi.getSliceAnnotationRegions();
+        }
+        return this.regions;
+    }
+    exportRois() {
+        if (!this.regionsForSave().length)
+            return;
+        const name = this.regionIo.getSelectedFileName();
+        const stem = name ? name.substring(0, name.lastIndexOf('.')) : 'rois';
+        this.exportFilename = `${stem}.geojson`;
+        this.showExportDialog = true;
+    }
+    confirmExport() {
+        const filename = this.exportFilename.trim();
+        const regions = this.regionsForSave();
+        if (!filename || !regions.length)
+            return;
+        this.showExportDialog = false;
+        const jsonString = this.regionApi.getGeoJsonString(regions);
+        const blob = new Blob([jsonString], { type: 'application/json' });
+        saveAs(blob, filename);
+    }
+    /** Open the "Save mask" dialog, seeded with `<image-stem>_mask.png`. */
+    openSaveMaskDialog() {
+        if (!this.regions.length)
+            return;
+        const name = this.regionIo.getSelectedFileName();
+        // Strip the extension only when there is one; an extension-less name keeps
+        // its whole stem (a leading-dot dotfile is treated as having no extension)
+        // so we never produce a bare "_mask.png".
+        const dot = name ? name.lastIndexOf('.') : -1;
+        const stem = name ? (dot > 0 ? name.substring(0, dot) : name) : 'regions';
+        this.saveMaskFilename = `${stem}_mask.png`;
+        this.maskMode = 'binary';
+        this.showSaveMaskDialog = true;
+    }
+    /**
+     * Rasterize the regions to the chosen mask type and download as a PNG. The
+     * heavy work (full-res rasterize + PNG encode) runs in a Web Worker so the UI
+     * never freezes on large/whole-slide images and the job can be cancelled
+     * (jit-ui#95). The dialog stays open showing a progress bar until done.
+     */
+    confirmSaveMask() {
+        const filename = this.saveMaskFilename.trim();
+        if (!filename || !this.regions.length || this.maskBusy)
+            return;
+        const size = this.regionApi.getMaskImageSize();
+        if (!size) {
+            this.maskError('No image size is available, so the mask cannot be sized.');
+            return;
+        }
+        // Whole-slide images exceed the browser's typed-array/memory limits, so cap
+        // the mask to a safe pixel budget and scale the geometry to match.
+        const scale = maskScaleFor(size.width, size.height);
+        const width = Math.max(1, Math.round(size.width * scale));
+        const height = Math.max(1, Math.round(size.height * scale));
+        if (scale < 1) {
+            this.messageService.add({
+                key: 'app-toast',
+                severity: 'info',
+                summary: 'Mask downscaled',
+                detail: `Image too large for a full-resolution mask; saving at ${width}×${height}.`,
+            });
+        }
+        const regions = this.regions.map((r) => scaleParts(regionToParts(r), scale));
+        this.pendingMaskFilename = filename;
+        this.maskBusy = true;
+        this.maskEncoding = false;
+        this.maskProgress = 0;
+        const payload = {
+            width, height,
+            originalWidth: size.width, originalHeight: size.height, scale,
+            mode: this.maskMode,
+            sourceName: this.regionIo.getSelectedFileName(),
+            regions,
+        };
+        // createMaskWorker() is async (the worker module is imported dynamically so
+        // its import.meta never reaches the CommonJS test compile). Wire up once it
+        // resolves — unless the user cancelled while it was loading.
+        this.createMaskWorker().then((worker) => {
+            if (!this.maskBusy) {
+                worker.terminate();
+                return;
+            }
+            this.maskWorker = worker;
+            worker.onmessage = ({ data }) => {
+                switch (data?.type) {
+                    case 'progress':
+                        this.maskProgress = data.total ? Math.round((data.done / data.total) * 100) : 0;
+                        break;
+                    case 'encoding':
+                        this.maskEncoding = true;
+                        break;
+                    case 'done':
+                        this.finishMask(new Blob([data.png], { type: 'image/png' }));
+                        break;
+                    case 'error':
+                        this.maskError(data.error || 'The mask could not be generated.');
+                        break;
+                }
+            };
+            worker.onerror = () => this.maskError('The mask worker failed.');
+            worker.postMessage(payload);
+        }).catch(() => this.maskError('The mask worker failed to start.'));
+    }
+    /** Cancel an in-progress mask export: terminate the worker and reset state. */
+    cancelSaveMask() {
+        this.teardownMaskWorker();
+        this.maskBusy = false;
+        this.maskEncoding = false;
+        this.maskProgress = 0;
+    }
+    /** Worker factory — async so the worker module (and its `import.meta.url`,
+     *  which the CommonJS test compile rejects) is loaded via a dynamic import,
+     *  exactly like the segmentation worker. Overridable in tests. */
+    async createMaskWorker() {
+        const { createMaskWorker } = await import('./mask-worker');
+        return createMaskWorker();
+    }
+    finishMask(blob) {
+        this.teardownMaskWorker();
+        this.maskBusy = false;
+        this.maskEncoding = false;
+        this.showSaveMaskDialog = false;
+        saveAs(blob, this.pendingMaskFilename);
+    }
+    maskError(detail) {
+        this.teardownMaskWorker();
+        this.maskBusy = false;
+        this.maskEncoding = false;
+        this.messageService.add({
+            key: 'app-toast',
+            severity: 'error',
+            summary: 'Could not create mask',
+            detail,
+        });
+    }
+    teardownMaskWorker() {
+        this.maskWorker?.terminate();
+        this.maskWorker = undefined;
+    }
+    persistRegions() {
+        // Folder stack: write each slice's regions back to its own slice-file's
+        // sibling geojson — no single-filename prompt (the filenames are the slice
+        // files'). (jit-ui#93)
+        if (this.regionApi.isStackMode() && this.regionApi.getStackSaveLayout() === 'per-slice-file') {
+            this.saveStackSlices();
+            return;
+        }
+        const name = this.regionIo.getSelectedFileName();
+        if (!name || !this.regionsForSave().length)
+            return;
+        this.saveAsFilename = name.substring(0, name.lastIndexOf('.')) + '.geojson';
+        this.saveAsFileExists = false;
+        this.showSaveAsDialog = true;
+        this._saveAsCheck$.next(this.saveAsFilename);
+    }
+    /**
+     * Save a folder stack's regions as one geojson per slice-file (jit-ui#93).
+     * Groups the store's per-slice regions by slice index and serializes each on
+     * the default plane (z=0) — each slice-file is itself one plane, and the
+     * loader re-derives the slice index from the file's position in the series.
+     * Slices cleared since load are included (empty) so their file is overwritten.
+     */
+    saveStackSlices() {
+        const bySlice = this.regionApi.getStackSaveAnnotationSlices();
+        if (!bySlice.size)
+            return;
+        const slices = [];
+        for (const [z, regs] of bySlice) {
+            const flat = regs.map((r) => Object.assign(new Region(), r, { z: 0 }));
+            slices.push({ z, geoJsonStr: this.regionApi.getGeoJsonString(flat) });
+        }
+        this.saveAsBusy = true;
+        this._saveAsSub = this.regionIo.saveSliceGeoJsons(slices).subscribe({
+            next: () => {
+                this.saveAsBusy = false;
+                this.messageService.add({
+                    key: 'app-toast',
+                    severity: 'success',
+                    summary: 'Regions saved',
+                    detail: `Saved ROIs for ${slices.length} slice${slices.length === 1 ? '' : 's'}`,
+                });
+            },
+            error: (err) => {
+                this.saveAsBusy = false;
+                this.messageService.add({
+                    key: 'app-toast',
+                    severity: 'error',
+                    summary: 'Error saving regions',
+                    detail: `${err?.message ?? err}`,
+                });
+            },
+        });
+    }
+    checkSaveAsFileExists() {
+        this._saveAsCheck$.next(this.saveAsFilename);
+    }
+    confirmSaveAs() {
+        if (!this.regionIo.getSelectedFileName())
+            return;
+        const filename = this.saveAsFilename.trim();
+        if (!filename)
+            return;
+        const doSave = () => {
+            // Keep the dialog open showing an (indeterminate) progress bar while the
+            // regions serialize and upload, then close on success. Defer one tick so
+            // the bar paints before a large synchronous GeoJSON serialize.
+            this.saveAsBusy = true;
+            this._saveAsTimer = setTimeout(() => {
+                this._saveAsTimer = undefined;
+                let geoJsonStr;
+                try {
+                    geoJsonStr = this.regionApi.getGeoJsonString(this.regionsForSave());
+                }
+                catch (err) {
+                    this.saveAsBusy = false;
+                    this.messageService.add({
+                        key: 'app-toast',
+                        severity: 'error',
+                        summary: 'Error saving regions',
+                        detail: `${err?.message ?? err}`,
+                    });
+                    return;
+                }
+                this._saveAsSub = this.regionIo.saveGeoJson(geoJsonStr, filename).subscribe({
+                    next: () => {
+                        this.saveAsBusy = false;
+                        this.showSaveAsDialog = false;
+                        this.messageService.add({
+                            key: 'app-toast',
+                            severity: 'success',
+                            summary: 'Regions saved',
+                            detail: `Saved as ${filename}`,
+                        });
+                    },
+                    error: (err) => {
+                        this.saveAsBusy = false;
+                        this.messageService.add({
+                            key: 'app-toast',
+                            severity: 'error',
+                            summary: 'Error saving regions',
+                            detail: `${err.message || err}`,
+                        });
+                    },
+                });
+            });
+        };
+        if (this.saveAsFileExists) {
+            this.confirmationService.confirm({
+                message: `"${filename}" already exists. Do you want to overwrite it?`,
+                header: 'Confirm Overwrite',
+                icon: 'pi pi-exclamation-triangle',
+                accept: doSave,
+            });
+        }
+        else {
+            doSave();
+        }
+    }
+    /** Cancel an in-progress GeoJSON persist: abort the deferred serialize and/or
+     *  the in-flight upload, and reset state. */
+    cancelSaveAs() {
+        if (this._saveAsTimer !== undefined) {
+            clearTimeout(this._saveAsTimer);
+            this._saveAsTimer = undefined;
+        }
+        this._saveAsSub?.unsubscribe();
+        this._saveAsSub = undefined;
+        this.saveAsBusy = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionEditorComponent, deps: [{ token: REGION_EDITOR_API }, { token: i1.MessageService }, { token: i1.ConfirmationService }, { token: REGION_IO_PORT }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: RegionEditorComponent, selector: "region-editor", viewQueries: [{ propertyName: "overlayPanel", first: true, predicate: ["op"], descendants: true }], ngImport: i0, template: "\n<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button icon=\"pi pi-tag\" size=\"small\"\n              [text]=\"!showShapeLabel\"\n              pTooltip=\"Show region labels.\"\n              tooltipPosition=\"bottom\"\n              (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\">\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button icon=\"pi pi-upload\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Upload and display regions from geojson file.\"\n              tooltipPosition=\"bottom\"\n              (click)=\"roiFileInput.click()\">\n    </p-button>\n    <input #roiFileInput type=\"file\" accept=\".geojson,.json\" hidden\n           (change)=\"importRois($event); roiFileInput.value = ''\"/>\n    <p-button size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Download regions as geojson file.\"\n              tooltipPosition=\"bottom\" icon=\"pi pi-download\"\n              (click)=\"exportRois()\">\n    </p-button>\n    <p-button icon=\"pi pi-save\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Save regions to server.\"\n              tooltipPosition=\"bottom\"\n              (click)=\"persistRegions()\"\n              [disabled]=\"!regions || !regions.length\">\n    </p-button>\n    <p-button size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Download mask of the regions as PNG\"\n              tooltipPosition=\"bottom\"\n              (click)=\"openSaveMaskDialog()\"\n              [disabled]=\"!regions || !regions.length\">\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img src=\"assets/plotting/mask.svg\" class=\"toolbar-icon-dark\"\n           style=\"width: 1rem; height: 1rem; vertical-align: middle;\"\n           alt=\"Download mask\"/>\n    </p-button>\n    <p-button label=\"x512\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\" tooltipPosition=\"bottom\"\n              (click)=\"roundRectangleLengths()\">\n    </p-button>\n    <p-button icon=\"pi pi-check-square\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Select all regions\" tooltipPosition=\"bottom\"\n              (click)=\"selectAllRegions()\"\n              [disabled]=\"!regions || !regions.length\">\n    </p-button>\n    <p-button icon=\"pi pi-tags\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Edit class on selected rows\"\n              tooltipPosition=\"bottom\"\n              (click)=\"(!selectedRegions || !selectedRegions.length)? op.hide() : op.toggle($event)\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\">\n    </p-button>\n    <p-button icon=\"pi pi-palette\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Edit colour of selected regions\"\n              tooltipPosition=\"bottom\"\n              (click)=\"openColorDialog()\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\">\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass=''; newBulkClass=''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\">Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span>\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown styleClass=\"w-full\" appendTo=\"body\" [options]=\"presetSet.classes\"\n                    optionLabel=\"name\" optionValue=\"name\" [(ngModel)]=\"bulkClass\"\n                    placeholder=\"Choose a class\u2026\"\n                    [filter]=\"presetSet.classes.length > 8\" filterBy=\"name\"\n                    (onChange)=\"applyBulkClass()\">\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span>\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input type=\"text\" pInputText placeholder=\"\u2026or a new class\" [(ngModel)]=\"newBulkClass\"\n                 (keydown.enter)=\"addAndApplyBulkClass()\"/>\n          <button pButton type=\"button\" icon=\"pi pi-plus\" pTooltip=\"Add class &amp; set it\"\n                  tooltipPosition=\"bottom\" [disabled]=\"!newBulkClass.trim()\"\n                  (click)=\"addAndApplyBulkClass()\"></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button icon=\"pi pi-trash\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              (click)=\"deleteSelectedRegions()\"\n              pTooltip=\"Delete selected regions\" tooltipPosition=\"bottom\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\"></p-button>\n    <p-button icon=\"pi pi-times-circle\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              (click)=\"clearAllRegions()\"\n              pTooltip=\"Delete all regions\" tooltipPosition=\"bottom\"\n              [disabled]=\"!regions || !regions.length\"></p-button>\n    <p-button icon=\"pi pi-question\" size=\"small\" [text]=\"true\"\n              (click)=\"showHelp()\" pTooltip=\"Help\" tooltipPosition=\"bottom\"></p-button>\n  </div>\n</p-toolbar>\n\n<!-- Docked \"Classes\" panel (jit-ui#70): the always-visible list of annotation\n     classes above the regions table. Click a row to make it the active class\n     (new regions inherit it; with rows selected it re-classifies them); recolour\n     via the swatch; the badge shows how many regions use the class. \"Manage\"\n     opens the full editor (fallback palette, auto-add, matching, import/export). -->\n<div class=\"classes-panel\">\n  <div class=\"classes-panel-header\">\n    <span class=\"classes-panel-title\">Classes</span>\n    <button pButton type=\"button\" icon=\"pi pi-cog\" label=\"Manage\"\n            class=\"p-button-sm p-button-text\"\n            pTooltip=\"Manage classes \u2014 add / remove, palette, matching, import/export\"\n            tooltipPosition=\"bottom\" (click)=\"openManageDialog()\"></button>\n  </div>\n  <div class=\"classes-panel-body\">\n    <div *ngFor=\"let c of displayClasses; trackBy: trackByClassName\"\n         class=\"class-row\" [class.active]=\"activeClass === c.name\"\n         (click)=\"selectActiveClass(c.name)\"\n         [pTooltip]=\"selectedRegions?.length\n           ? 'Apply \u201C' + c.name + '\u201D to the selected region(s)'\n           : 'Set \u201C' + c.name + '\u201D active \u2014 new regions use it'\"\n         tooltipPosition=\"bottom\">\n      <span class=\"row-swatch\" (click)=\"$event.stopPropagation()\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"setClassColor(c.name, $event)\"></hex-color-picker>\n      </span>\n      <span class=\"row-name\">{{ c.name }}</span>\n      <span class=\"row-count\" [class.zero]=\"classCount(c.name) === 0\">{{ classCount(c.name) }}</span>\n      <button pButton type=\"button\" icon=\"pi pi-trash\"\n              class=\"p-button-sm p-button-text p-button-warning row-del\"\n              [disabled]=\"c.name === defaultClassName && classCount(c.name) > 0\"\n              [pTooltip]=\"deleteClassTooltip(c.name)\"\n              tooltipPosition=\"bottom\"\n              (click)=\"$event.stopPropagation(); deleteClass(c.name)\"></button>\n    </div>\n    <div *ngIf=\"!displayClasses.length\" class=\"classes-empty\">\n      No classes yet \u2014 add one from Manage.\n    </div>\n  </div>\n</div>\n\n<div class=\"region-editor-content\">\n    <p-table #dt [value]=\"regions.slice(paginatorFirst, paginatorFirst + paginatorRows)\"\n             [tableStyle]=\"{'width': '100%'}\" [(selection)]=\"selectedRegions\"\n             selectionMode=\"multiple\" [metaKeySelection]=\"metaKey\"\n             (onRowSelect)=\"onSelectionChanged()\" (onRowUnselect)=\"onSelectionChanged()\"\n             [resizableColumns]=\"true\"\n             [rowHover]=\"true\" dataKey=\"id\" styleClass=\"p-datatable-sm region-editor-table\"\n             [scrollable]=\"true\" scrollHeight=\"100%\">\n      <ng-template pTemplate=\"header\">\n        <!-- Hide the column header when there are no regions to show. -->\n        <tr *ngIf=\"regions.length > 0\">\n          <!-- Class column: shrinks to fit \"Region\" by default, grows with longer labels. -->\n          <th class=\"class-col-header\" pResizableColumn>Class <p-sortIcon field=\"label\"></p-sortIcon></th>\n          <th class=\"surface-col-header\" pResizableColumn>Surface</th>\n          <!-- Trash column: just enough for the icon. -->\n          <th style=\"width:2rem\"></th>\n        </tr>\n      </ng-template>\n      <ng-template pTemplate=\"body\" let-region let-shapeIdx=\"rowIndex\">\n        <tr [pSelectableRow]=\"region\" [pSelectableRowIndex]=\"shapeIdx\">\n          <td class=\"class-cell\">\n            <ng-container *ngIf=\"!isEditingLabel(region); else editLabelTpl\">\n              <span class=\"class-cell-display\">\n                <!-- Quick-pick a preset class (its colour follows); the pencil is for\n                     a free-form name / rename (jit-ui#70). -->\n                <p-dropdown class=\"class-dropdown\" appendTo=\"body\"\n                            [options]=\"presetSet.classes\" optionLabel=\"name\" optionValue=\"name\"\n                            [ngModel]=\"region.label\" [autoDisplayFirst]=\"false\"\n                            (onChange)=\"applyPresetToRegion(region, $event.value)\">\n                  <ng-template pTemplate=\"selectedItem\">\n                    <span class=\"dd-value\">\n                      <span class=\"chip-swatch\" [style.background]=\"colorForName(region.label)\"></span>\n                      <span class=\"class-name\" [pTooltip]=\"region.label\" tooltipPosition=\"bottom\">{{ region.label || '\u2014' }}</span>\n                    </span>\n                  </ng-template>\n                  <ng-template let-c pTemplate=\"item\">\n                    <span class=\"dd-value\">\n                      <span class=\"chip-swatch\" [style.background]=\"c.color\"></span>\n                      <span>{{ c.name }}</span>\n                    </span>\n                  </ng-template>\n                </p-dropdown>\n                <i class=\"pi pi-pencil icon-hover ml-2\"\n                   pTooltip=\"Rename / free-form label\" tooltipPosition=\"bottom\"\n                   (click)=\"startEditLabel(region, $event)\"></i>\n              </span>\n            </ng-container>\n            <ng-template #editLabelTpl>\n              <span class=\"p-input-icon-right class-cell-edit\">\n                <i class=\"pi pi-times icon-hover\"\n                   pTooltip=\"Close\" tooltipPosition=\"bottom\"\n                   (click)=\"stopEditLabel(region, false, $event)\"></i>\n                <input type=\"text\" pInputText class=\"p-inputtext-sm w-full\"\n                       [(ngModel)]=\"region.label\"\n                       (click)=\"$event.stopPropagation()\"\n                       (keydown.enter)=\"stopEditLabel(region, true, $event)\"\n                       (keydown.escape)=\"stopEditLabel(region, false, $event)\"/>\n              </span>\n            </ng-template>\n          </td>\n          <!-- Surface area (\u00B5m\u00B2/mm\u00B2 when the image is scaled, else px\u00B2). -->\n          <td class=\"surface-cell\">{{ regionArea(region) || '\u2014' }}</td>\n          <td>\n            <button pButton pRipple icon=\"pi pi-trash\"\n\t\t\t\t\t\t\tclass=\"p-button-sm p-button-rounded p-button-text p-button-warning\"\n                    (click)=\"deleteRegion(paginatorFirst + shapeIdx)\"></button>\n          </td>\n        </tr>\n      </ng-template>\n    </p-table>\n</div>\n\n<p-paginator *ngIf=\"regions.length > 0\"\n             [rows]=\"paginatorRows\" [totalRecords]=\"regions.length\"\n             [first]=\"paginatorFirst\"\n             [rowsPerPageOptions]=\"rowsPerPageOptions\"\n             [showCurrentPageReport]=\"true\"\n             currentPageReportTemplate=\"{first} to {last} of {totalRecords}\"\n             (onPageChange)=\"onPageChange($event)\"\n             styleClass=\"region-editor-paginator\">\n</p-paginator>\n\n<!-- Live-edit mode: no Save/Cancel \u2014 every edit commits immediately to the\n     active image's region cache. -->\n\n\n<p-confirmDialog #cd [style]=\"{width: '24rem', height: '14rem'}\" key=\"positionDialog\"\n                 [baseZIndex]=\"10000\" rejectButtonStyleClass=\"p-button-outlined\">\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button type=\"button\" class=\"p-button-outlined\" pButton icon=\"pi pi-times\" label=\"No\"\n            (click)=\"cd.reject()\"></button>\n  </ng-template>\n</p-confirmDialog>\n\n<p-dialog header=\"Save Regions As\" [(visible)]=\"showSaveAsDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\"\n          [closable]=\"!saveAsBusy\" [closeOnEscape]=\"!saveAsBusy\">\n  <!-- Idle: filename + overwrite warning. -->\n  <div *ngIf=\"!saveAsBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"geojson-filename\" class=\"font-medium\">GeoJSON filename</label>\n    <input id=\"geojson-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"saveAsFilename\"\n           (ngModelChange)=\"checkSaveAsFileExists()\"\n           class=\"w-full\" />\n    <small *ngIf=\"saveAsFileExists\" class=\"p-error\">\n      <i class=\"pi pi-exclamation-triangle mr-1\"></i>\n      This file already exists and will be overwritten.\n    </small>\n  </div>\n\n  <!-- Busy: progress while regions serialize + upload. -->\n  <div *ngIf=\"saveAsBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <span>Saving regions\u2026</span>\n    <p-progressBar mode=\"indeterminate\" [style]=\"{height: '0.75rem'}\"></p-progressBar>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button *ngIf=\"!saveAsBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showSaveAsDialog = false\"></p-button>\n    <p-button *ngIf=\"!saveAsBusy\" label=\"Save\" icon=\"pi pi-save\"\n              [disabled]=\"!saveAsFilename || !saveAsFilename.trim()\"\n              (onClick)=\"confirmSaveAs()\"></p-button>\n    <p-button *ngIf=\"saveAsBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"cancelSaveAs()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Export Regions\" [(visible)]=\"showExportDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"export-filename\" class=\"font-medium\">GeoJSON filename</label>\n    <input id=\"export-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"exportFilename\"\n           class=\"w-full\" />\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showExportDialog = false\"></p-button>\n    <p-button label=\"Export\" icon=\"pi pi-download\"\n              [disabled]=\"!exportFilename || !exportFilename.trim()\"\n              (onClick)=\"confirmExport()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Save Mask\" [(visible)]=\"showSaveMaskDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\"\n          [closable]=\"!maskBusy\" [closeOnEscape]=\"!maskBusy\">\n  <!-- Idle: filename + mask-type form. -->\n  <div *ngIf=\"!maskBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"mask-filename\" class=\"font-medium\">Mask filename</label>\n    <input id=\"mask-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"saveMaskFilename\"\n           class=\"w-full\" />\n    <span class=\"font-medium\">Mask type</span>\n    <div class=\"flex align-items-center gap-2\">\n      <p-radioButton inputId=\"mask-binary\" name=\"maskMode\" value=\"binary\"\n                     [(ngModel)]=\"maskMode\"></p-radioButton>\n      <label for=\"mask-binary\">Binary <span class=\"text-color-secondary\">(regions 1, background 0)</span></label>\n    </div>\n    <div class=\"flex align-items-center gap-2\">\n      <p-radioButton inputId=\"mask-multiclass\" name=\"maskMode\" value=\"multiclass\"\n                     [(ngModel)]=\"maskMode\"></p-radioButton>\n      <label for=\"mask-multiclass\">Multi-class <span class=\"text-color-secondary\">(unique id per region, background 0)</span></label>\n    </div>\n  </div>\n\n  <!-- Busy: progress while the worker rasterizes + encodes the PNG. -->\n  <div *ngIf=\"maskBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <span>{{ maskEncoding ? 'Encoding PNG\u2026' : 'Rasterizing regions\u2026' }}</span>\n    <p-progressBar [mode]=\"maskEncoding ? 'indeterminate' : 'determinate'\"\n                   [value]=\"maskProgress\"\n                   [style]=\"{height: '0.75rem'}\"></p-progressBar>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button *ngIf=\"!maskBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showSaveMaskDialog = false\"></p-button>\n    <p-button *ngIf=\"!maskBusy\" label=\"Download\" icon=\"pi pi-download\"\n              [disabled]=\"!saveMaskFilename || !saveMaskFilename.trim()\"\n              (onClick)=\"confirmSaveMask()\"></p-button>\n    <p-button *ngIf=\"maskBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"cancelSaveMask()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Region colour\" [(visible)]=\"showColorDialog\" [modal]=\"false\" appendTo=\"body\"\n          [style]=\"{width: '24rem'}\" [draggable]=\"true\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <span>Outline colour per class for the\n      <b>{{ selectedRegions?.length || 0 }}</b> selected region(s):</span>\n    <div *ngFor=\"let edit of classColorEdits; let i = index\"\n         class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium flex-1\">{{ edit.label || 'Unclassified' }}</span>\n      <hex-color-picker [color]=\"edit.color\"\n                        (colorChange)=\"classColorEdits[i].color = $event\"></hex-color-picker>\n    </div>\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\" (onClick)=\"showColorDialog = false\">\n    </p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"applyColorToSelected()\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): CRUD + fallback palette + matching/auto-add\n     settings + reset/import/export. Edits a working copy, committed on Apply/Done. -->\n<p-dialog header=\"Manage annotation classes\" [(visible)]=\"showManageDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '34rem'}\" [draggable]=\"true\" [resizable]=\"false\">\n  <div *ngIf=\"presetDraft\" class=\"manage-dialog flex flex-column gap-3 pt-2\">\n    <div class=\"manage-classes flex flex-column gap-2\">\n      <div *ngFor=\"let c of presetDraft.classes; let i = index\"\n           class=\"manage-class-row flex align-items-center gap-2\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"c.color = $event\"></hex-color-picker>\n        <input type=\"text\" pInputText class=\"p-inputtext-sm flex-1\"\n               [(ngModel)]=\"c.name\" placeholder=\"Class name\"/>\n        <button pButton type=\"button\" icon=\"pi pi-trash\"\n                class=\"p-button-sm p-button-text p-button-warning\"\n                pTooltip=\"Remove class\" tooltipPosition=\"bottom\"\n                (click)=\"removePresetClass(i)\"></button>\n      </div>\n      <button pButton type=\"button\" icon=\"pi pi-plus\" label=\"Add class\"\n              class=\"p-button-sm p-button-text align-self-start\" (click)=\"addPresetClass()\"></button>\n    </div>\n\n    <div class=\"manage-section flex flex-column gap-2\">\n      <span class=\"section-title font-medium\">Fallback palette\n        <small class=\"text-color-secondary\">\u2014 colours for classes not listed</small></span>\n      <div class=\"fallback-palette flex align-items-center flex-wrap gap-2\">\n        <span *ngFor=\"let col of presetDraft.fallbackPalette; let i = index\"\n              class=\"fallback-swatch flex align-items-center\">\n          <hex-color-picker [color]=\"col\" (colorChange)=\"presetDraft.fallbackPalette[i] = $event\"></hex-color-picker>\n          <i class=\"pi pi-times icon-hover ml-1\" pTooltip=\"Remove\" tooltipPosition=\"bottom\"\n             (click)=\"removeFallbackColor(i)\"></i>\n        </span>\n        <button pButton type=\"button\" icon=\"pi pi-plus\"\n                class=\"p-button-sm p-button-text\" pTooltip=\"Add fallback colour\"\n                tooltipPosition=\"bottom\" (click)=\"addFallbackColor()\"></button>\n      </div>\n    </div>\n\n    <div class=\"flex align-items-center gap-2\">\n      <p-checkbox [(ngModel)]=\"presetDraft.autoPromote\" [binary]=\"true\" inputId=\"autoPromote\"></p-checkbox>\n      <label for=\"autoPromote\">Auto-add detected classes to this list as they appear</label>\n    </div>\n\n    <div class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium\">Label matching</span>\n      <p-selectButton [options]=\"matchModeOptions\" [(ngModel)]=\"presetDraft.matchMode\"\n                      optionLabel=\"label\" optionValue=\"value\"></p-selectButton>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"manage-footer flex align-items-center flex-wrap gap-2 w-full\">\n      <span class=\"flex align-items-center flex-wrap gap-1\">\n        <p-button label=\"Reset\" icon=\"pi pi-refresh\" [text]=\"true\"\n                  (onClick)=\"resetPresetsToDefaults()\"></p-button>\n        <p-button label=\"Import\" icon=\"pi pi-upload\" [text]=\"true\"\n                  (onClick)=\"presetFileInput.click()\"></p-button>\n        <input #presetFileInput type=\"file\" accept=\".json,application/json\" hidden\n               (change)=\"importPresets($event); presetFileInput.value = ''\"/>\n        <p-button label=\"Export\" icon=\"pi pi-download\" [text]=\"true\"\n                  (onClick)=\"exportPresets()\"></p-button>\n      </span>\n      <span class=\"flex-1\"></span>\n      <!-- Apply persists to the server and closes; it replaces the old Apply+Done pair. -->\n      <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"applyManageDialog(true)\"></p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Region editor help\" [(visible)]=\"displayHelpDialog\" [style]=\"{width: '50vw'}\"\n          [maximizable]=\"true\" [draggable]=\"true\" appendTo=\"body\">\n  <p>\n    The Region Editor lists every region drawn on the currently displayed image.\n    Open it with the\n    <img src=\"assets/plotting/region-editor.svg\" width=\"14\" height=\"14\" alt=\"Region Editor\"/>\n    button in the diagram toolbar: it opens as a floating dialog you can drag,\n    resize, and leave open while you draw on the image.\n    Regions are tracked <b>per image</b>: switching to another image hides\n    these and shows that image's regions; switching back restores them.\n    Edits in the table apply <b>live</b> to the diagram \u2014 there is no save or\n    cancel.\n  </p>\n\n  <h3>Creating regions</h3>\n  <p>\n    Use the diagram toolbar tools to draw new regions:\n    <i class=\"pi pi-stop\"></i> rectangle,\n    <object data=\"assets/icons/polyline.svg\" width=\"14\" height=\"14\"></object> polyline,\n    <i class=\"pi pi-pencil\"></i> freeform path, brush, or\n    <object data=\"assets/icons/wand.svg\" width=\"14\" height=\"14\"></object> wand.\n    Anything you draw appears immediately in the table, with the class name\n    \"<b>Region</b>\" by default.\n  </p>\n\n  <h3>The table columns</h3>\n  <ul>\n    <li><b>Class</b> \u2014 the region's class. Pick a class from the dropdown (its\n      colour follows), or use the <i class=\"pi pi-pencil\"></i> for a free-form name.</li>\n    <li><b>Surface</b> \u2014 the region's area, in \u00B5m\u00B2/mm\u00B2 when the image carries a\n      physical pixel size, otherwise in px\u00B2. Holes (donuts) and multi-part\n      regions are accounted for.</li>\n    <li>The trash icon at the end of a row deletes that one region.</li>\n    <li>Use \"<b>x512</b>\" to round all rectangle widths/heights to the\n      nearest multiple of 512.</li>\n  </ul>\n  <p>Region geometry is edited on the diagram itself (drag vertices, the vertex\n    tools, brush/wand, and the right-click region actions), not in this table.</p>\n\n  <h3>Selecting rows</h3>\n  <ul>\n    <li>Click a row to select it. The corresponding region is highlighted in the\n      diagram (Plotly shows its edit handles; the OpenSeadragon image view\n      highlights it and shows its handles in select mode).</li>\n    <li><kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+click to add or remove a row from the\n      selection. <kbd>Shift</kbd>+click to extend the selection in a range.</li>\n    <li>Selecting a region in the diagram highlights the matching row in the\n      table.</li>\n    <li>Clicks on the colour picker, the trash icon, or the active class-edit\n      input do not change the selection \u2014 that's standard PrimeNG behaviour.</li>\n  </ul>\n\n  <h3>Bulk actions on the selected rows</h3>\n  <ul>\n    <li><i class=\"pi pi-check-square\"></i> Select every region in the table at once (also a\n      right-click action on the image).</li>\n    <li><i class=\"pi pi-tags\"></i> Edit the label on every selected row at once.</li>\n    <li><i class=\"pi pi-trash\"></i> Delete every selected region \u2014 both from\n      the table and the diagram.</li>\n    <li><i class=\"pi pi-times-circle\"></i> Delete every region on this image.</li>\n  </ul>\n\n  <h3>Annotation classes &amp; colours (presets)</h3>\n  <p>\n    Preset a class once \u2014 a <b>name</b> and a <b>colour</b> \u2014 and every region with\n    that class name is drawn in that colour, <b>including regions loaded from a\n    GeoJSON later</b>. The preset colour is the source of truth: on load it\n    <b>overrides the colour stored in the file</b>, so a given annotation type always\n    looks the same across images and sessions.\n  </p>\n  <p>Set up your classes in the annotation-class manager \u2014\n    <i class=\"pi pi-cog\"></i> <b>Manage</b>:</p>\n  <ol>\n    <li><b>Add class</b>, then type the class <b>name exactly as it appears in your\n      data</b> (e.g. <code>Tumor</code>) and pick its <b>colour</b> from the swatch.\n      Repeat for each class.</li>\n    <li>Optionally: edit the <b>fallback palette</b> (colours given to classes that\n      aren't in your list), toggle <b>auto-add</b> (adds unmatched classes found on\n      load), and choose <b>exact</b> vs. <b>normalized</b> name matching \u2014 normalized\n      ignores case and surrounding spaces, so <code>tumor</code> matches\n      <code>Tumor</code>.</li>\n    <li><b>Apply.</b> Presets are saved <b>per user</b> on the server, so they follow\n      you across images and sessions. You can also <b>reset to defaults</b> or\n      <b>import / export</b> the set as JSON to share it.</li>\n  </ol>\n  <p>\n    Next time you open or <i class=\"pi pi-upload\"></i> import a GeoJSON whose regions\n    carry those class names, each region is shown in its preset colour automatically \u2014\n    no re-colouring needed. A class that isn't in your list instead gets a stable\n    colour from the fallback palette.\n  </p>\n  <p>Day to day:</p>\n  <ul>\n    <li>The <b>class strip</b> above the table lists your presets with their colours.\n      Click a class to make it <b>active</b> (new regions inherit it); with rows\n      selected, clicking a class re-classifies them.</li>\n    <li>The <b>Class</b> column dropdown re-classifies one region to a preset (its\n      colour follows), or use the <i class=\"pi pi-pencil\"></i> for a free-form name.</li>\n    <li>Recolour a class from its swatch (class strip or Manage) and every region of\n      that class updates at once.</li>\n    <li>Deleting a class reassigns its regions to the default <b>Region</b> class.</li>\n    <li>A colour you set on a <b>single</b> region (<i class=\"pi pi-palette\"></i>\n      Selected regions) is kept and is not overridden by its class.</li>\n  </ul>\n\n  <h3>Region actions (right-click the diagram)</h3>\n  <p>Right-click a region \u2014 or the current multi-selection \u2014 on the diagram for\n    the \"Selected region(s)\" actions:</p>\n  <ul>\n    <li><b>Merge / group</b> \u2014 combine 2+ selected regions into one (it may end\n      up multi-part if the pieces don't touch).</li>\n    <li><b>Ungroup</b> \u2014 split a multi-part region back into separate regions.</li>\n    <li><b>Inverse</b> \u2014 replace the selection with everything outside it (the\n      regions become holes in the image rectangle).</li>\n    <li><b>Simplify</b> \u2014 reduce the vertex count (Douglas\u2013Peucker) by a pixel\n      threshold; pick a preset or a custom value.</li>\n    <li><b>Convert to B\u00E9zier / to polygon</b> and <b>Delete</b>.</li>\n  </ul>\n\n  <h3>Display options</h3>\n  <ul>\n    <li><i class=\"pi pi-tag\"></i> Toggle showing class labels on every\n      region in the diagram (slower with many regions).</li>\n  </ul>\n\n  <h3>Import / export</h3>\n  <ul>\n    <li><i class=\"pi pi-upload\"></i> Import regions from a GeoJSON file.</li>\n    <li><i class=\"pi pi-download\"></i> Export the current image's regions to\n      a GeoJSON file. (The per-image cache is in-memory only \u2014 exporting is\n      how you persist regions across sessions.)</li>\n  </ul>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button icon=\"pi pi-check\" (click)=\"displayHelpDialog=false\" label=\"Ok\" styleClass=\"p-button-text\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n\n", styles: ["@charset \"UTF-8\";:host{display:flex;flex-direction:column;height:100%;min-height:0;overflow:hidden}.region-editor-content{flex:1 1 auto;min-height:0;display:flex;flex-direction:column;overflow:hidden}::ng-deep .region-editor-content .p-3{padding:0!important}::ng-deep .region-editor-content>p-table{flex:1 1 auto;min-height:0;display:flex;flex-direction:column;overflow:hidden}::ng-deep .region-editor-content .p-datatable.region-editor-table{flex:1 1 auto;min-height:0;display:flex;flex-direction:column;overflow:hidden}::ng-deep .region-editor-content .p-datatable.region-editor-table>.p-datatable-header{flex:0 0 auto}::ng-deep .region-editor-content .p-datatable.region-editor-table>.p-datatable-wrapper,::ng-deep .region-editor-content .p-datatable.region-editor-table>.p-datatable-table-container,::ng-deep .region-editor-content .p-datatable.region-editor-table .p-scroller-viewport{flex:1 1 0;min-height:0;height:100%;max-height:100%;overflow:auto}:host>p-paginator{display:block;flex:0 0 auto;border-top:1px solid var(--surface-border);padding:.25rem 0}::ng-deep region-editor .p-toolbar.region-toolbar{padding:.25rem .5rem;border-radius:0;border-left:none;border-right:none;border-top:none}::ng-deep region-editor .p-toolbar.region-toolbar .p-button.p-button-icon-only{width:auto;padding:.25rem .5rem}::ng-deep region-editor .p-toolbar.region-toolbar .p-button{padding:.25rem .5rem}.toolbar-icon-dark{filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.class-col-header,.class-cell{white-space:nowrap;max-width:16rem}.class-cell .class-cell-display{display:flex;align-items:center;min-width:0}.class-cell .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}.class-cell .icon-hover{flex:0 0 auto}.class-cell .icon-hover{cursor:pointer;color:var(--text-color-secondary);transition:color .15s ease}.class-cell .icon-hover:hover{color:var(--primary-color)}.class-cell .class-cell-edit{display:inline-block;width:100%}::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-rounded,::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-icon-only{width:1.5rem;height:1.5rem;padding:0}::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-rounded .p-button-icon,::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-icon-only .p-button-icon{font-size:.75rem}::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-inputtext{padding:.25rem .5rem;font-size:.875rem}::ng-deep .p-datatable-sm .p-paginator{padding:.15rem .25rem!important;min-height:unset!important}::ng-deep .p-datatable-sm .p-paginator,::ng-deep .p-datatable-sm .p-paginator *{font-size:.75rem!important}::ng-deep .p-datatable-sm .p-paginator .p-paginator-element{min-width:1.5rem!important;height:1.5rem!important}::ng-deep .p-datatable-sm .p-paginator .p-paginator-current{font-size:.75rem!important;height:1.5rem!important;min-width:unset!important}::ng-deep .p-datatable-sm .p-paginator .p-dropdown{height:1.5rem!important}::ng-deep .p-datatable-sm .p-paginator .p-dropdown .p-dropdown-label{padding:.1rem .25rem!important;line-height:1.2!important}::ng-deep .p-datatable-sm .p-paginator .p-dropdown .p-dropdown-trigger{width:1.25rem!important}::ng-deep .p-paginator-rpp-options .p-dropdown-panel .p-dropdown-items .p-dropdown-item{padding:.25rem .5rem!important;font-size:.75rem!important}.region-area{font-size:.8rem;font-weight:600;color:var(--primary-color, #3399ff)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}kbd{background:#e8e8e8;border:1px solid #bbb;border-radius:3px;padding:1px 5px;font-family:monospace;font-size:.85em}.classes-panel{display:flex;flex-direction:column;flex:0 0 auto;border-bottom:1px solid var(--surface-border)}.classes-panel-header{display:flex;align-items:center;gap:.35rem;padding:.35rem .5rem;border-bottom:1px solid var(--surface-border)}.classes-panel-title{font-size:.75rem;font-weight:600;letter-spacing:.03em;text-transform:uppercase;color:var(--text-color-secondary);margin-right:auto}.classes-panel-body{height:7rem;min-height:2.5rem;max-height:60vh;overflow-x:hidden;overflow-y:auto;resize:vertical}::ng-deep .classes-panel-body .hex-picker-swatch{width:1.25rem;height:1.25rem;border-width:1px}.class-row{display:flex;align-items:center;gap:.5rem;padding:.1rem .5rem;cursor:pointer;border-left:3px solid transparent}.class-row:hover{background:var(--surface-hover, rgba(0, 0, 0, .04))}.class-row.active{background:var(--highlight-bg, rgba(51, 153, 255, .12));border-left-color:var(--primary-color)}.class-row .row-swatch{flex:0 0 auto;display:inline-flex}.class-row .row-name{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.85rem}.class-row.active .row-name{color:var(--primary-color);font-weight:600}.class-row .row-count{flex:0 0 auto;min-width:1.5rem;text-align:center;font-size:.72rem;font-variant-numeric:tabular-nums;color:var(--text-color-secondary);background:var(--surface-200, rgba(0, 0, 0, .06));border-radius:10px;padding:0 .4rem}.class-row .row-count.zero{opacity:.5}.class-row .row-del{flex:0 0 auto}.classes-empty{font-size:.8rem;color:var(--text-color-secondary);padding:.5rem}::ng-deep .classes-panel-body .class-row .p-button.p-button-icon-only{width:1.75rem;height:1.75rem;padding:0}.chip-swatch{display:inline-block;width:.75rem;height:.75rem;border-radius:50%;border:1px solid rgba(0,0,0,.2);flex:0 0 auto}.class-cell .class-dropdown{min-width:0;flex:1 1 auto}::ng-deep .class-cell .class-dropdown.p-dropdown{width:100%}::ng-deep .class-cell .class-dropdown .p-dropdown-label{padding:.15rem .5rem;display:flex;align-items:center}.dd-value{display:inline-flex;align-items:center;gap:.4rem;min-width:0}.dd-value .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.manage-dialog .manage-class-row hex-color-picker,.manage-dialog .fallback-palette hex-color-picker{flex:0 0 auto}.manage-dialog .fallback-palette .icon-hover{cursor:pointer;color:var(--text-color-secondary)}.manage-dialog .fallback-palette .icon-hover:hover{color:var(--primary-color)}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass", "ariaLabelledBy"] }, { kind: "directive", type: i1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "directive", type: i5.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain"] }, { kind: "component", type: i5.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: i6.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: i7.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "autoShowPanelOnPrintableCharacterKeyDown", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "component", type: i8.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: i9.ProgressBar, selector: "p-progressBar", inputs: ["value", "showValue", "styleClass", "style", "unit", "mode", "color"] }, { kind: "directive", type: i10.Ripple, selector: "[pRipple]" }, { kind: "component", type: i11.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorStyleClass", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "groupRowsByOrder", "responsiveLayout", "breakpoint", "paginatorLocale", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll", "virtualRowHeight"], outputs: ["contextMenuSelectionChange", "selectAllChange", "selectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i11.SelectableRow, selector: "[pSelectableRow]", inputs: ["pSelectableRow", "pSelectableRowIndex", "pSelectableRowDisabled"] }, { kind: "directive", type: i11.ResizableColumn, selector: "[pResizableColumn]", inputs: ["pResizableColumnDisabled"] }, { kind: "component", type: i11.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i12.Paginator, selector: "p-paginator", inputs: ["pageLinkSize", "style", "styleClass", "alwaysShow", "dropdownAppendTo", "templateLeft", "templateRight", "appendTo", "dropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showFirstLastIcon", "totalRecords", "rows", "rowsPerPageOptions", "showJumpToPageDropdown", "showJumpToPageInput", "jumpToPageItemTemplate", "showPageLinks", "locale", "dropdownItemTemplate", "first"], outputs: ["onPageChange"] }, { kind: "component", type: i13.OverlayPanel, selector: "p-overlayPanel", inputs: ["ariaLabel", "ariaLabelledBy", "dismissable", "showCloseIcon", "style", "styleClass", "appendTo", "autoZIndex", "ariaCloseLabel", "baseZIndex", "focusOnShow", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }, { kind: "component", type: i14.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "closeAriaLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }, { kind: "directive", type: i15.InputText, selector: "[pInputText]", inputs: ["variant"] }, { kind: "component", type: i16.Checkbox, selector: "p-checkbox", inputs: ["value", "name", "disabled", "binary", "label", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "styleClass", "labelStyleClass", "formControl", "checkboxIcon", "readonly", "required", "autofocus", "trueValue", "falseValue", "variant"], outputs: ["onChange", "onFocus", "onBlur"] }, { kind: "component", type: i17.RadioButton, selector: "p-radioButton", inputs: ["value", "formControlName", "name", "disabled", "label", "variant", "tabindex", "inputId", "ariaLabelledBy", "ariaLabel", "style", "styleClass", "labelStyleClass", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "component", type: i18.SelectButton, selector: "p-selectButton", inputs: ["options", "optionLabel", "optionValue", "optionDisabled", "unselectable", "tabindex", "multiple", "allowEmpty", "style", "styleClass", "ariaLabelledBy", "disabled", "dataKey", "autofocus"], outputs: ["onOptionClick", "onChange"] }, { kind: "component", type: i19.HexColorPickerComponent, selector: "hex-color-picker", inputs: ["color"], outputs: ["colorChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'region-editor', template: "\n<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button icon=\"pi pi-tag\" size=\"small\"\n              [text]=\"!showShapeLabel\"\n              pTooltip=\"Show region labels.\"\n              tooltipPosition=\"bottom\"\n              (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\">\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button icon=\"pi pi-upload\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Upload and display regions from geojson file.\"\n              tooltipPosition=\"bottom\"\n              (click)=\"roiFileInput.click()\">\n    </p-button>\n    <input #roiFileInput type=\"file\" accept=\".geojson,.json\" hidden\n           (change)=\"importRois($event); roiFileInput.value = ''\"/>\n    <p-button size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Download regions as geojson file.\"\n              tooltipPosition=\"bottom\" icon=\"pi pi-download\"\n              (click)=\"exportRois()\">\n    </p-button>\n    <p-button icon=\"pi pi-save\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Save regions to server.\"\n              tooltipPosition=\"bottom\"\n              (click)=\"persistRegions()\"\n              [disabled]=\"!regions || !regions.length\">\n    </p-button>\n    <p-button size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Download mask of the regions as PNG\"\n              tooltipPosition=\"bottom\"\n              (click)=\"openSaveMaskDialog()\"\n              [disabled]=\"!regions || !regions.length\">\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img src=\"assets/plotting/mask.svg\" class=\"toolbar-icon-dark\"\n           style=\"width: 1rem; height: 1rem; vertical-align: middle;\"\n           alt=\"Download mask\"/>\n    </p-button>\n    <p-button label=\"x512\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\" tooltipPosition=\"bottom\"\n              (click)=\"roundRectangleLengths()\">\n    </p-button>\n    <p-button icon=\"pi pi-check-square\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Select all regions\" tooltipPosition=\"bottom\"\n              (click)=\"selectAllRegions()\"\n              [disabled]=\"!regions || !regions.length\">\n    </p-button>\n    <p-button icon=\"pi pi-tags\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Edit class on selected rows\"\n              tooltipPosition=\"bottom\"\n              (click)=\"(!selectedRegions || !selectedRegions.length)? op.hide() : op.toggle($event)\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\">\n    </p-button>\n    <p-button icon=\"pi pi-palette\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Edit colour of selected regions\"\n              tooltipPosition=\"bottom\"\n              (click)=\"openColorDialog()\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\">\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass=''; newBulkClass=''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\">Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span>\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown styleClass=\"w-full\" appendTo=\"body\" [options]=\"presetSet.classes\"\n                    optionLabel=\"name\" optionValue=\"name\" [(ngModel)]=\"bulkClass\"\n                    placeholder=\"Choose a class\u2026\"\n                    [filter]=\"presetSet.classes.length > 8\" filterBy=\"name\"\n                    (onChange)=\"applyBulkClass()\">\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span>\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input type=\"text\" pInputText placeholder=\"\u2026or a new class\" [(ngModel)]=\"newBulkClass\"\n                 (keydown.enter)=\"addAndApplyBulkClass()\"/>\n          <button pButton type=\"button\" icon=\"pi pi-plus\" pTooltip=\"Add class &amp; set it\"\n                  tooltipPosition=\"bottom\" [disabled]=\"!newBulkClass.trim()\"\n                  (click)=\"addAndApplyBulkClass()\"></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button icon=\"pi pi-trash\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              (click)=\"deleteSelectedRegions()\"\n              pTooltip=\"Delete selected regions\" tooltipPosition=\"bottom\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\"></p-button>\n    <p-button icon=\"pi pi-times-circle\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              (click)=\"clearAllRegions()\"\n              pTooltip=\"Delete all regions\" tooltipPosition=\"bottom\"\n              [disabled]=\"!regions || !regions.length\"></p-button>\n    <p-button icon=\"pi pi-question\" size=\"small\" [text]=\"true\"\n              (click)=\"showHelp()\" pTooltip=\"Help\" tooltipPosition=\"bottom\"></p-button>\n  </div>\n</p-toolbar>\n\n<!-- Docked \"Classes\" panel (jit-ui#70): the always-visible list of annotation\n     classes above the regions table. Click a row to make it the active class\n     (new regions inherit it; with rows selected it re-classifies them); recolour\n     via the swatch; the badge shows how many regions use the class. \"Manage\"\n     opens the full editor (fallback palette, auto-add, matching, import/export). -->\n<div class=\"classes-panel\">\n  <div class=\"classes-panel-header\">\n    <span class=\"classes-panel-title\">Classes</span>\n    <button pButton type=\"button\" icon=\"pi pi-cog\" label=\"Manage\"\n            class=\"p-button-sm p-button-text\"\n            pTooltip=\"Manage classes \u2014 add / remove, palette, matching, import/export\"\n            tooltipPosition=\"bottom\" (click)=\"openManageDialog()\"></button>\n  </div>\n  <div class=\"classes-panel-body\">\n    <div *ngFor=\"let c of displayClasses; trackBy: trackByClassName\"\n         class=\"class-row\" [class.active]=\"activeClass === c.name\"\n         (click)=\"selectActiveClass(c.name)\"\n         [pTooltip]=\"selectedRegions?.length\n           ? 'Apply \u201C' + c.name + '\u201D to the selected region(s)'\n           : 'Set \u201C' + c.name + '\u201D active \u2014 new regions use it'\"\n         tooltipPosition=\"bottom\">\n      <span class=\"row-swatch\" (click)=\"$event.stopPropagation()\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"setClassColor(c.name, $event)\"></hex-color-picker>\n      </span>\n      <span class=\"row-name\">{{ c.name }}</span>\n      <span class=\"row-count\" [class.zero]=\"classCount(c.name) === 0\">{{ classCount(c.name) }}</span>\n      <button pButton type=\"button\" icon=\"pi pi-trash\"\n              class=\"p-button-sm p-button-text p-button-warning row-del\"\n              [disabled]=\"c.name === defaultClassName && classCount(c.name) > 0\"\n              [pTooltip]=\"deleteClassTooltip(c.name)\"\n              tooltipPosition=\"bottom\"\n              (click)=\"$event.stopPropagation(); deleteClass(c.name)\"></button>\n    </div>\n    <div *ngIf=\"!displayClasses.length\" class=\"classes-empty\">\n      No classes yet \u2014 add one from Manage.\n    </div>\n  </div>\n</div>\n\n<div class=\"region-editor-content\">\n    <p-table #dt [value]=\"regions.slice(paginatorFirst, paginatorFirst + paginatorRows)\"\n             [tableStyle]=\"{'width': '100%'}\" [(selection)]=\"selectedRegions\"\n             selectionMode=\"multiple\" [metaKeySelection]=\"metaKey\"\n             (onRowSelect)=\"onSelectionChanged()\" (onRowUnselect)=\"onSelectionChanged()\"\n             [resizableColumns]=\"true\"\n             [rowHover]=\"true\" dataKey=\"id\" styleClass=\"p-datatable-sm region-editor-table\"\n             [scrollable]=\"true\" scrollHeight=\"100%\">\n      <ng-template pTemplate=\"header\">\n        <!-- Hide the column header when there are no regions to show. -->\n        <tr *ngIf=\"regions.length > 0\">\n          <!-- Class column: shrinks to fit \"Region\" by default, grows with longer labels. -->\n          <th class=\"class-col-header\" pResizableColumn>Class <p-sortIcon field=\"label\"></p-sortIcon></th>\n          <th class=\"surface-col-header\" pResizableColumn>Surface</th>\n          <!-- Trash column: just enough for the icon. -->\n          <th style=\"width:2rem\"></th>\n        </tr>\n      </ng-template>\n      <ng-template pTemplate=\"body\" let-region let-shapeIdx=\"rowIndex\">\n        <tr [pSelectableRow]=\"region\" [pSelectableRowIndex]=\"shapeIdx\">\n          <td class=\"class-cell\">\n            <ng-container *ngIf=\"!isEditingLabel(region); else editLabelTpl\">\n              <span class=\"class-cell-display\">\n                <!-- Quick-pick a preset class (its colour follows); the pencil is for\n                     a free-form name / rename (jit-ui#70). -->\n                <p-dropdown class=\"class-dropdown\" appendTo=\"body\"\n                            [options]=\"presetSet.classes\" optionLabel=\"name\" optionValue=\"name\"\n                            [ngModel]=\"region.label\" [autoDisplayFirst]=\"false\"\n                            (onChange)=\"applyPresetToRegion(region, $event.value)\">\n                  <ng-template pTemplate=\"selectedItem\">\n                    <span class=\"dd-value\">\n                      <span class=\"chip-swatch\" [style.background]=\"colorForName(region.label)\"></span>\n                      <span class=\"class-name\" [pTooltip]=\"region.label\" tooltipPosition=\"bottom\">{{ region.label || '\u2014' }}</span>\n                    </span>\n                  </ng-template>\n                  <ng-template let-c pTemplate=\"item\">\n                    <span class=\"dd-value\">\n                      <span class=\"chip-swatch\" [style.background]=\"c.color\"></span>\n                      <span>{{ c.name }}</span>\n                    </span>\n                  </ng-template>\n                </p-dropdown>\n                <i class=\"pi pi-pencil icon-hover ml-2\"\n                   pTooltip=\"Rename / free-form label\" tooltipPosition=\"bottom\"\n                   (click)=\"startEditLabel(region, $event)\"></i>\n              </span>\n            </ng-container>\n            <ng-template #editLabelTpl>\n              <span class=\"p-input-icon-right class-cell-edit\">\n                <i class=\"pi pi-times icon-hover\"\n                   pTooltip=\"Close\" tooltipPosition=\"bottom\"\n                   (click)=\"stopEditLabel(region, false, $event)\"></i>\n                <input type=\"text\" pInputText class=\"p-inputtext-sm w-full\"\n                       [(ngModel)]=\"region.label\"\n                       (click)=\"$event.stopPropagation()\"\n                       (keydown.enter)=\"stopEditLabel(region, true, $event)\"\n                       (keydown.escape)=\"stopEditLabel(region, false, $event)\"/>\n              </span>\n            </ng-template>\n          </td>\n          <!-- Surface area (\u00B5m\u00B2/mm\u00B2 when the image is scaled, else px\u00B2). -->\n          <td class=\"surface-cell\">{{ regionArea(region) || '\u2014' }}</td>\n          <td>\n            <button pButton pRipple icon=\"pi pi-trash\"\n\t\t\t\t\t\t\tclass=\"p-button-sm p-button-rounded p-button-text p-button-warning\"\n                    (click)=\"deleteRegion(paginatorFirst + shapeIdx)\"></button>\n          </td>\n        </tr>\n      </ng-template>\n    </p-table>\n</div>\n\n<p-paginator *ngIf=\"regions.length > 0\"\n             [rows]=\"paginatorRows\" [totalRecords]=\"regions.length\"\n             [first]=\"paginatorFirst\"\n             [rowsPerPageOptions]=\"rowsPerPageOptions\"\n             [showCurrentPageReport]=\"true\"\n             currentPageReportTemplate=\"{first} to {last} of {totalRecords}\"\n             (onPageChange)=\"onPageChange($event)\"\n             styleClass=\"region-editor-paginator\">\n</p-paginator>\n\n<!-- Live-edit mode: no Save/Cancel \u2014 every edit commits immediately to the\n     active image's region cache. -->\n\n\n<p-confirmDialog #cd [style]=\"{width: '24rem', height: '14rem'}\" key=\"positionDialog\"\n                 [baseZIndex]=\"10000\" rejectButtonStyleClass=\"p-button-outlined\">\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button type=\"button\" class=\"p-button-outlined\" pButton icon=\"pi pi-times\" label=\"No\"\n            (click)=\"cd.reject()\"></button>\n  </ng-template>\n</p-confirmDialog>\n\n<p-dialog header=\"Save Regions As\" [(visible)]=\"showSaveAsDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\"\n          [closable]=\"!saveAsBusy\" [closeOnEscape]=\"!saveAsBusy\">\n  <!-- Idle: filename + overwrite warning. -->\n  <div *ngIf=\"!saveAsBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"geojson-filename\" class=\"font-medium\">GeoJSON filename</label>\n    <input id=\"geojson-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"saveAsFilename\"\n           (ngModelChange)=\"checkSaveAsFileExists()\"\n           class=\"w-full\" />\n    <small *ngIf=\"saveAsFileExists\" class=\"p-error\">\n      <i class=\"pi pi-exclamation-triangle mr-1\"></i>\n      This file already exists and will be overwritten.\n    </small>\n  </div>\n\n  <!-- Busy: progress while regions serialize + upload. -->\n  <div *ngIf=\"saveAsBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <span>Saving regions\u2026</span>\n    <p-progressBar mode=\"indeterminate\" [style]=\"{height: '0.75rem'}\"></p-progressBar>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button *ngIf=\"!saveAsBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showSaveAsDialog = false\"></p-button>\n    <p-button *ngIf=\"!saveAsBusy\" label=\"Save\" icon=\"pi pi-save\"\n              [disabled]=\"!saveAsFilename || !saveAsFilename.trim()\"\n              (onClick)=\"confirmSaveAs()\"></p-button>\n    <p-button *ngIf=\"saveAsBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"cancelSaveAs()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Export Regions\" [(visible)]=\"showExportDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"export-filename\" class=\"font-medium\">GeoJSON filename</label>\n    <input id=\"export-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"exportFilename\"\n           class=\"w-full\" />\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showExportDialog = false\"></p-button>\n    <p-button label=\"Export\" icon=\"pi pi-download\"\n              [disabled]=\"!exportFilename || !exportFilename.trim()\"\n              (onClick)=\"confirmExport()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Save Mask\" [(visible)]=\"showSaveMaskDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\"\n          [closable]=\"!maskBusy\" [closeOnEscape]=\"!maskBusy\">\n  <!-- Idle: filename + mask-type form. -->\n  <div *ngIf=\"!maskBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"mask-filename\" class=\"font-medium\">Mask filename</label>\n    <input id=\"mask-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"saveMaskFilename\"\n           class=\"w-full\" />\n    <span class=\"font-medium\">Mask type</span>\n    <div class=\"flex align-items-center gap-2\">\n      <p-radioButton inputId=\"mask-binary\" name=\"maskMode\" value=\"binary\"\n                     [(ngModel)]=\"maskMode\"></p-radioButton>\n      <label for=\"mask-binary\">Binary <span class=\"text-color-secondary\">(regions 1, background 0)</span></label>\n    </div>\n    <div class=\"flex align-items-center gap-2\">\n      <p-radioButton inputId=\"mask-multiclass\" name=\"maskMode\" value=\"multiclass\"\n                     [(ngModel)]=\"maskMode\"></p-radioButton>\n      <label for=\"mask-multiclass\">Multi-class <span class=\"text-color-secondary\">(unique id per region, background 0)</span></label>\n    </div>\n  </div>\n\n  <!-- Busy: progress while the worker rasterizes + encodes the PNG. -->\n  <div *ngIf=\"maskBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <span>{{ maskEncoding ? 'Encoding PNG\u2026' : 'Rasterizing regions\u2026' }}</span>\n    <p-progressBar [mode]=\"maskEncoding ? 'indeterminate' : 'determinate'\"\n                   [value]=\"maskProgress\"\n                   [style]=\"{height: '0.75rem'}\"></p-progressBar>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button *ngIf=\"!maskBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showSaveMaskDialog = false\"></p-button>\n    <p-button *ngIf=\"!maskBusy\" label=\"Download\" icon=\"pi pi-download\"\n              [disabled]=\"!saveMaskFilename || !saveMaskFilename.trim()\"\n              (onClick)=\"confirmSaveMask()\"></p-button>\n    <p-button *ngIf=\"maskBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"cancelSaveMask()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Region colour\" [(visible)]=\"showColorDialog\" [modal]=\"false\" appendTo=\"body\"\n          [style]=\"{width: '24rem'}\" [draggable]=\"true\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <span>Outline colour per class for the\n      <b>{{ selectedRegions?.length || 0 }}</b> selected region(s):</span>\n    <div *ngFor=\"let edit of classColorEdits; let i = index\"\n         class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium flex-1\">{{ edit.label || 'Unclassified' }}</span>\n      <hex-color-picker [color]=\"edit.color\"\n                        (colorChange)=\"classColorEdits[i].color = $event\"></hex-color-picker>\n    </div>\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\" (onClick)=\"showColorDialog = false\">\n    </p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"applyColorToSelected()\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): CRUD + fallback palette + matching/auto-add\n     settings + reset/import/export. Edits a working copy, committed on Apply/Done. -->\n<p-dialog header=\"Manage annotation classes\" [(visible)]=\"showManageDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '34rem'}\" [draggable]=\"true\" [resizable]=\"false\">\n  <div *ngIf=\"presetDraft\" class=\"manage-dialog flex flex-column gap-3 pt-2\">\n    <div class=\"manage-classes flex flex-column gap-2\">\n      <div *ngFor=\"let c of presetDraft.classes; let i = index\"\n           class=\"manage-class-row flex align-items-center gap-2\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"c.color = $event\"></hex-color-picker>\n        <input type=\"text\" pInputText class=\"p-inputtext-sm flex-1\"\n               [(ngModel)]=\"c.name\" placeholder=\"Class name\"/>\n        <button pButton type=\"button\" icon=\"pi pi-trash\"\n                class=\"p-button-sm p-button-text p-button-warning\"\n                pTooltip=\"Remove class\" tooltipPosition=\"bottom\"\n                (click)=\"removePresetClass(i)\"></button>\n      </div>\n      <button pButton type=\"button\" icon=\"pi pi-plus\" label=\"Add class\"\n              class=\"p-button-sm p-button-text align-self-start\" (click)=\"addPresetClass()\"></button>\n    </div>\n\n    <div class=\"manage-section flex flex-column gap-2\">\n      <span class=\"section-title font-medium\">Fallback palette\n        <small class=\"text-color-secondary\">\u2014 colours for classes not listed</small></span>\n      <div class=\"fallback-palette flex align-items-center flex-wrap gap-2\">\n        <span *ngFor=\"let col of presetDraft.fallbackPalette; let i = index\"\n              class=\"fallback-swatch flex align-items-center\">\n          <hex-color-picker [color]=\"col\" (colorChange)=\"presetDraft.fallbackPalette[i] = $event\"></hex-color-picker>\n          <i class=\"pi pi-times icon-hover ml-1\" pTooltip=\"Remove\" tooltipPosition=\"bottom\"\n             (click)=\"removeFallbackColor(i)\"></i>\n        </span>\n        <button pButton type=\"button\" icon=\"pi pi-plus\"\n                class=\"p-button-sm p-button-text\" pTooltip=\"Add fallback colour\"\n                tooltipPosition=\"bottom\" (click)=\"addFallbackColor()\"></button>\n      </div>\n    </div>\n\n    <div class=\"flex align-items-center gap-2\">\n      <p-checkbox [(ngModel)]=\"presetDraft.autoPromote\" [binary]=\"true\" inputId=\"autoPromote\"></p-checkbox>\n      <label for=\"autoPromote\">Auto-add detected classes to this list as they appear</label>\n    </div>\n\n    <div class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium\">Label matching</span>\n      <p-selectButton [options]=\"matchModeOptions\" [(ngModel)]=\"presetDraft.matchMode\"\n                      optionLabel=\"label\" optionValue=\"value\"></p-selectButton>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"manage-footer flex align-items-center flex-wrap gap-2 w-full\">\n      <span class=\"flex align-items-center flex-wrap gap-1\">\n        <p-button label=\"Reset\" icon=\"pi pi-refresh\" [text]=\"true\"\n                  (onClick)=\"resetPresetsToDefaults()\"></p-button>\n        <p-button label=\"Import\" icon=\"pi pi-upload\" [text]=\"true\"\n                  (onClick)=\"presetFileInput.click()\"></p-button>\n        <input #presetFileInput type=\"file\" accept=\".json,application/json\" hidden\n               (change)=\"importPresets($event); presetFileInput.value = ''\"/>\n        <p-button label=\"Export\" icon=\"pi pi-download\" [text]=\"true\"\n                  (onClick)=\"exportPresets()\"></p-button>\n      </span>\n      <span class=\"flex-1\"></span>\n      <!-- Apply persists to the server and closes; it replaces the old Apply+Done pair. -->\n      <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"applyManageDialog(true)\"></p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Region editor help\" [(visible)]=\"displayHelpDialog\" [style]=\"{width: '50vw'}\"\n          [maximizable]=\"true\" [draggable]=\"true\" appendTo=\"body\">\n  <p>\n    The Region Editor lists every region drawn on the currently displayed image.\n    Open it with the\n    <img src=\"assets/plotting/region-editor.svg\" width=\"14\" height=\"14\" alt=\"Region Editor\"/>\n    button in the diagram toolbar: it opens as a floating dialog you can drag,\n    resize, and leave open while you draw on the image.\n    Regions are tracked <b>per image</b>: switching to another image hides\n    these and shows that image's regions; switching back restores them.\n    Edits in the table apply <b>live</b> to the diagram \u2014 there is no save or\n    cancel.\n  </p>\n\n  <h3>Creating regions</h3>\n  <p>\n    Use the diagram toolbar tools to draw new regions:\n    <i class=\"pi pi-stop\"></i> rectangle,\n    <object data=\"assets/icons/polyline.svg\" width=\"14\" height=\"14\"></object> polyline,\n    <i class=\"pi pi-pencil\"></i> freeform path, brush, or\n    <object data=\"assets/icons/wand.svg\" width=\"14\" height=\"14\"></object> wand.\n    Anything you draw appears immediately in the table, with the class name\n    \"<b>Region</b>\" by default.\n  </p>\n\n  <h3>The table columns</h3>\n  <ul>\n    <li><b>Class</b> \u2014 the region's class. Pick a class from the dropdown (its\n      colour follows), or use the <i class=\"pi pi-pencil\"></i> for a free-form name.</li>\n    <li><b>Surface</b> \u2014 the region's area, in \u00B5m\u00B2/mm\u00B2 when the image carries a\n      physical pixel size, otherwise in px\u00B2. Holes (donuts) and multi-part\n      regions are accounted for.</li>\n    <li>The trash icon at the end of a row deletes that one region.</li>\n    <li>Use \"<b>x512</b>\" to round all rectangle widths/heights to the\n      nearest multiple of 512.</li>\n  </ul>\n  <p>Region geometry is edited on the diagram itself (drag vertices, the vertex\n    tools, brush/wand, and the right-click region actions), not in this table.</p>\n\n  <h3>Selecting rows</h3>\n  <ul>\n    <li>Click a row to select it. The corresponding region is highlighted in the\n      diagram (Plotly shows its edit handles; the OpenSeadragon image view\n      highlights it and shows its handles in select mode).</li>\n    <li><kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+click to add or remove a row from the\n      selection. <kbd>Shift</kbd>+click to extend the selection in a range.</li>\n    <li>Selecting a region in the diagram highlights the matching row in the\n      table.</li>\n    <li>Clicks on the colour picker, the trash icon, or the active class-edit\n      input do not change the selection \u2014 that's standard PrimeNG behaviour.</li>\n  </ul>\n\n  <h3>Bulk actions on the selected rows</h3>\n  <ul>\n    <li><i class=\"pi pi-check-square\"></i> Select every region in the table at once (also a\n      right-click action on the image).</li>\n    <li><i class=\"pi pi-tags\"></i> Edit the label on every selected row at once.</li>\n    <li><i class=\"pi pi-trash\"></i> Delete every selected region \u2014 both from\n      the table and the diagram.</li>\n    <li><i class=\"pi pi-times-circle\"></i> Delete every region on this image.</li>\n  </ul>\n\n  <h3>Annotation classes &amp; colours (presets)</h3>\n  <p>\n    Preset a class once \u2014 a <b>name</b> and a <b>colour</b> \u2014 and every region with\n    that class name is drawn in that colour, <b>including regions loaded from a\n    GeoJSON later</b>. The preset colour is the source of truth: on load it\n    <b>overrides the colour stored in the file</b>, so a given annotation type always\n    looks the same across images and sessions.\n  </p>\n  <p>Set up your classes in the annotation-class manager \u2014\n    <i class=\"pi pi-cog\"></i> <b>Manage</b>:</p>\n  <ol>\n    <li><b>Add class</b>, then type the class <b>name exactly as it appears in your\n      data</b> (e.g. <code>Tumor</code>) and pick its <b>colour</b> from the swatch.\n      Repeat for each class.</li>\n    <li>Optionally: edit the <b>fallback palette</b> (colours given to classes that\n      aren't in your list), toggle <b>auto-add</b> (adds unmatched classes found on\n      load), and choose <b>exact</b> vs. <b>normalized</b> name matching \u2014 normalized\n      ignores case and surrounding spaces, so <code>tumor</code> matches\n      <code>Tumor</code>.</li>\n    <li><b>Apply.</b> Presets are saved <b>per user</b> on the server, so they follow\n      you across images and sessions. You can also <b>reset to defaults</b> or\n      <b>import / export</b> the set as JSON to share it.</li>\n  </ol>\n  <p>\n    Next time you open or <i class=\"pi pi-upload\"></i> import a GeoJSON whose regions\n    carry those class names, each region is shown in its preset colour automatically \u2014\n    no re-colouring needed. A class that isn't in your list instead gets a stable\n    colour from the fallback palette.\n  </p>\n  <p>Day to day:</p>\n  <ul>\n    <li>The <b>class strip</b> above the table lists your presets with their colours.\n      Click a class to make it <b>active</b> (new regions inherit it); with rows\n      selected, clicking a class re-classifies them.</li>\n    <li>The <b>Class</b> column dropdown re-classifies one region to a preset (its\n      colour follows), or use the <i class=\"pi pi-pencil\"></i> for a free-form name.</li>\n    <li>Recolour a class from its swatch (class strip or Manage) and every region of\n      that class updates at once.</li>\n    <li>Deleting a class reassigns its regions to the default <b>Region</b> class.</li>\n    <li>A colour you set on a <b>single</b> region (<i class=\"pi pi-palette\"></i>\n      Selected regions) is kept and is not overridden by its class.</li>\n  </ul>\n\n  <h3>Region actions (right-click the diagram)</h3>\n  <p>Right-click a region \u2014 or the current multi-selection \u2014 on the diagram for\n    the \"Selected region(s)\" actions:</p>\n  <ul>\n    <li><b>Merge / group</b> \u2014 combine 2+ selected regions into one (it may end\n      up multi-part if the pieces don't touch).</li>\n    <li><b>Ungroup</b> \u2014 split a multi-part region back into separate regions.</li>\n    <li><b>Inverse</b> \u2014 replace the selection with everything outside it (the\n      regions become holes in the image rectangle).</li>\n    <li><b>Simplify</b> \u2014 reduce the vertex count (Douglas\u2013Peucker) by a pixel\n      threshold; pick a preset or a custom value.</li>\n    <li><b>Convert to B\u00E9zier / to polygon</b> and <b>Delete</b>.</li>\n  </ul>\n\n  <h3>Display options</h3>\n  <ul>\n    <li><i class=\"pi pi-tag\"></i> Toggle showing class labels on every\n      region in the diagram (slower with many regions).</li>\n  </ul>\n\n  <h3>Import / export</h3>\n  <ul>\n    <li><i class=\"pi pi-upload\"></i> Import regions from a GeoJSON file.</li>\n    <li><i class=\"pi pi-download\"></i> Export the current image's regions to\n      a GeoJSON file. (The per-image cache is in-memory only \u2014 exporting is\n      how you persist regions across sessions.)</li>\n  </ul>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button icon=\"pi pi-check\" (click)=\"displayHelpDialog=false\" label=\"Ok\" styleClass=\"p-button-text\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n\n", styles: ["@charset \"UTF-8\";:host{display:flex;flex-direction:column;height:100%;min-height:0;overflow:hidden}.region-editor-content{flex:1 1 auto;min-height:0;display:flex;flex-direction:column;overflow:hidden}::ng-deep .region-editor-content .p-3{padding:0!important}::ng-deep .region-editor-content>p-table{flex:1 1 auto;min-height:0;display:flex;flex-direction:column;overflow:hidden}::ng-deep .region-editor-content .p-datatable.region-editor-table{flex:1 1 auto;min-height:0;display:flex;flex-direction:column;overflow:hidden}::ng-deep .region-editor-content .p-datatable.region-editor-table>.p-datatable-header{flex:0 0 auto}::ng-deep .region-editor-content .p-datatable.region-editor-table>.p-datatable-wrapper,::ng-deep .region-editor-content .p-datatable.region-editor-table>.p-datatable-table-container,::ng-deep .region-editor-content .p-datatable.region-editor-table .p-scroller-viewport{flex:1 1 0;min-height:0;height:100%;max-height:100%;overflow:auto}:host>p-paginator{display:block;flex:0 0 auto;border-top:1px solid var(--surface-border);padding:.25rem 0}::ng-deep region-editor .p-toolbar.region-toolbar{padding:.25rem .5rem;border-radius:0;border-left:none;border-right:none;border-top:none}::ng-deep region-editor .p-toolbar.region-toolbar .p-button.p-button-icon-only{width:auto;padding:.25rem .5rem}::ng-deep region-editor .p-toolbar.region-toolbar .p-button{padding:.25rem .5rem}.toolbar-icon-dark{filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.class-col-header,.class-cell{white-space:nowrap;max-width:16rem}.class-cell .class-cell-display{display:flex;align-items:center;min-width:0}.class-cell .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}.class-cell .icon-hover{flex:0 0 auto}.class-cell .icon-hover{cursor:pointer;color:var(--text-color-secondary);transition:color .15s ease}.class-cell .icon-hover:hover{color:var(--primary-color)}.class-cell .class-cell-edit{display:inline-block;width:100%}::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-rounded,::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-icon-only{width:1.5rem;height:1.5rem;padding:0}::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-rounded .p-button-icon,::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-button.p-button-icon-only .p-button-icon{font-size:.75rem}::ng-deep .p-datatable-sm .p-datatable-tbody>tr>td .p-inputtext{padding:.25rem .5rem;font-size:.875rem}::ng-deep .p-datatable-sm .p-paginator{padding:.15rem .25rem!important;min-height:unset!important}::ng-deep .p-datatable-sm .p-paginator,::ng-deep .p-datatable-sm .p-paginator *{font-size:.75rem!important}::ng-deep .p-datatable-sm .p-paginator .p-paginator-element{min-width:1.5rem!important;height:1.5rem!important}::ng-deep .p-datatable-sm .p-paginator .p-paginator-current{font-size:.75rem!important;height:1.5rem!important;min-width:unset!important}::ng-deep .p-datatable-sm .p-paginator .p-dropdown{height:1.5rem!important}::ng-deep .p-datatable-sm .p-paginator .p-dropdown .p-dropdown-label{padding:.1rem .25rem!important;line-height:1.2!important}::ng-deep .p-datatable-sm .p-paginator .p-dropdown .p-dropdown-trigger{width:1.25rem!important}::ng-deep .p-paginator-rpp-options .p-dropdown-panel .p-dropdown-items .p-dropdown-item{padding:.25rem .5rem!important;font-size:.75rem!important}.region-area{font-size:.8rem;font-weight:600;color:var(--primary-color, #3399ff)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}kbd{background:#e8e8e8;border:1px solid #bbb;border-radius:3px;padding:1px 5px;font-family:monospace;font-size:.85em}.classes-panel{display:flex;flex-direction:column;flex:0 0 auto;border-bottom:1px solid var(--surface-border)}.classes-panel-header{display:flex;align-items:center;gap:.35rem;padding:.35rem .5rem;border-bottom:1px solid var(--surface-border)}.classes-panel-title{font-size:.75rem;font-weight:600;letter-spacing:.03em;text-transform:uppercase;color:var(--text-color-secondary);margin-right:auto}.classes-panel-body{height:7rem;min-height:2.5rem;max-height:60vh;overflow-x:hidden;overflow-y:auto;resize:vertical}::ng-deep .classes-panel-body .hex-picker-swatch{width:1.25rem;height:1.25rem;border-width:1px}.class-row{display:flex;align-items:center;gap:.5rem;padding:.1rem .5rem;cursor:pointer;border-left:3px solid transparent}.class-row:hover{background:var(--surface-hover, rgba(0, 0, 0, .04))}.class-row.active{background:var(--highlight-bg, rgba(51, 153, 255, .12));border-left-color:var(--primary-color)}.class-row .row-swatch{flex:0 0 auto;display:inline-flex}.class-row .row-name{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.85rem}.class-row.active .row-name{color:var(--primary-color);font-weight:600}.class-row .row-count{flex:0 0 auto;min-width:1.5rem;text-align:center;font-size:.72rem;font-variant-numeric:tabular-nums;color:var(--text-color-secondary);background:var(--surface-200, rgba(0, 0, 0, .06));border-radius:10px;padding:0 .4rem}.class-row .row-count.zero{opacity:.5}.class-row .row-del{flex:0 0 auto}.classes-empty{font-size:.8rem;color:var(--text-color-secondary);padding:.5rem}::ng-deep .classes-panel-body .class-row .p-button.p-button-icon-only{width:1.75rem;height:1.75rem;padding:0}.chip-swatch{display:inline-block;width:.75rem;height:.75rem;border-radius:50%;border:1px solid rgba(0,0,0,.2);flex:0 0 auto}.class-cell .class-dropdown{min-width:0;flex:1 1 auto}::ng-deep .class-cell .class-dropdown.p-dropdown{width:100%}::ng-deep .class-cell .class-dropdown .p-dropdown-label{padding:.15rem .5rem;display:flex;align-items:center}.dd-value{display:inline-flex;align-items:center;gap:.4rem;min-width:0}.dd-value .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.manage-dialog .manage-class-row hex-color-picker,.manage-dialog .fallback-palette hex-color-picker{flex:0 0 auto}.manage-dialog .fallback-palette .icon-hover{cursor:pointer;color:var(--text-color-secondary)}.manage-dialog .fallback-palette .icon-hover:hover{color:var(--primary-color)}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [REGION_EDITOR_API]
+                }] }, { type: i1.MessageService }, { type: i1.ConfirmationService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [REGION_IO_PORT]
+                }] }], propDecorators: { overlayPanel: [{
+                type: ViewChild,
+                args: ['op']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-editor.component.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/region-editor.component.ts","../../../../src/lib/region-editor/region-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, OnDestroy, OnInit, ViewChild } from '@angular/core';\nimport { OverlayPanel } from 'primeng/overlaypanel';\nimport { saveAs } from 'file-saver';\nimport { Subject, Subscription } from 'rxjs';\nimport { debounceTime, switchMap } from 'rxjs/operators';\n\nimport { Polygon, Rectangle, Region, MultiPolygon } from '../models/region';\nimport { PresetSet, ClassPreset, defaultPresetSet } from '../models/class-preset';\nimport { colorForLabel } from '../store/class-color.util';\nimport { IImageMetadata } from '../contracts/image.contract';\nimport { ConfirmationService, MessageService } from 'primeng/api';\nimport { IRegionEditorApi, REGION_EDITOR_API } from '../contracts/region-editor-api.contract';\nimport { RegionIoPort, REGION_IO_PORT } from '../contracts/ports/region-io.port';\nimport { regionToParts, scaleParts, maskScaleFor } from './mask-raster';\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: 'region-editor',\n  templateUrl: './region-editor.component.html',\n  styleUrls: ['./region-editor.component.scss'],\n})\nexport class RegionEditorComponent implements OnInit, OnDestroy {\n  protected readonly Array = Array;\n\n  @ViewChild('op') overlayPanel!: OverlayPanel;\n\n  regions: Region[] = [];\n  regionsCopy: Region[] = [];\n  selectedRegions: Region[] = [];\n  showShapeLabel!: boolean;\n  shapeColor!: string;\n  fillColor!: string;\n  displayHelpDialog = false;\n  showColorDialog = false;\n  /** One colour editor per unique class among the selected regions, shown in the\n   *  \"edit colour of selected regions\" dialog. Unclassified regions (no label)\n   *  are grouped under a single entry with an empty `label`. */\n  classColorEdits: { label: string; color: string }[] = [];\n  labelColors: Map<string, string> = new Map();\n  selectedLabelColor = '';\n  /** \"Edit class on selected rows\" popup: chosen existing class, and a new-class name. */\n  bulkClass = '';\n  newBulkClass = '';\n\n  // ── annotation-class presets (jit-ui#70) ──\n  /** Local mirror of the per-user preset set (chip strip, Class dropdown, dialog). */\n  presetSet: PresetSet = defaultPresetSet();\n  /** Class applied to newly drawn/added regions and to bulk chip-clicks. */\n  activeClass: string | null = null;\n  showManageDialog = false;\n  /** Working copy edited inside the Manage-classes dialog; committed on Apply/Done. */\n  presetDraft: PresetSet | null = null;\n  /** class name (match-mode keyed) → number of regions currently using it. */\n  classCounts = new Map<string, number>();\n  /** Fallback class that a region reverts to when its class is deleted (jit-ui#70). */\n  readonly defaultClassName = 'Region';\n  /** Classes as shown in the panel: sorted by region count (desc), then name. */\n  displayClasses: ClassPreset[] = [];\n  readonly matchModeOptions = [\n    { label: 'Exact', value: 'exact' },\n    { label: 'Normalized', value: 'normalized' },\n  ];\n\n  paginatorFirst = 0;\n  paginatorRows = 10;\n  readonly rowsPerPageOptions = [10, 25, 50];\n  /** Regions whose Class cell is currently in edit mode.\n   *  Using object identity as the key avoids needing a unique id field. */\n  editingLabelRegions = new Set<any>();\n\n  showSaveAsDialog = false;\n  saveAsFilename = '';\n  saveAsFileExists = false;\n  /** True while a GeoJSON persist is serializing/uploading — drives the dialog's\n   *  progress bar and Cancel button (parity with the Save-mask dialog). */\n  saveAsBusy = false;\n  private _saveAsCheck$ = new Subject<string>();\n  private _saveAsSub?: Subscription;\n  /** Handle for the deferred-serialize timer so Cancel/destroy can abort it\n   *  before it fires (otherwise the upload would still start). */\n  private _saveAsTimer?: ReturnType<typeof setTimeout>;\n\n  showExportDialog = false;\n  exportFilename = '';\n\n  showSaveMaskDialog = false;\n  saveMaskFilename = '';\n  /** Mask type chosen in the Save-mask dialog: a binary foreground/background\n   *  mask, or a multi-class mask with a distinct id per region. */\n  maskMode: 'binary' | 'multiclass' = 'binary';\n  /** True while the mask worker is rasterizing/encoding — drives the progress\n   *  bar and the Cancel button in the dialog. */\n  maskBusy = false;\n  /** 0–100 rasterization progress; switches to indeterminate during encoding. */\n  maskProgress = 0;\n  maskEncoding = false;\n  private maskWorker?: Worker;\n  private pendingMaskFilename = '';\n\n  /**\n   * PrimeNG p-table multi-selection mode toggle. When true, single-click\n   * selects one row (replacing prior); meta/ctrl-click toggles a row in/out\n   * of the selection. When false, every click toggles. Default true to\n   * match the most common spreadsheet-like UX.\n   */\n  metaKey = true;\n\n  private _updatingFromEditor = false;\n  private _suppressSelectionSyncToPlot = false;\n  private _regionSub = new Subscription();\n  private _selectedIdxSub = new Subscription();\n  private _metaSub = new Subscription();\n  private _presetSub = new Subscription();\n\n  /** Physical pixel size (µm/pixel) of the active image, for region areas in\n   *  µm². Undefined when the format reports no physical size. */\n  private mppX?: number;\n  private mppY?: number;\n\n  constructor(\n    @Inject(REGION_EDITOR_API) private regionApi: IRegionEditorApi,\n    public messageService: MessageService,\n    private confirmationService: ConfirmationService,\n    @Inject(REGION_IO_PORT) private regionIo: RegionIoPort,\n  ) {}\n\n  /**\n   * Deep copy of regions for dirty-tracking (`regionsCopy`). Returns plain-object\n   * clones — only structural equality matters here, not prototypes.\n   * TODO: replace with `structuredClone` once verified.\n   */\n  private deepClone<T>(items: T[]): T[] {\n    return items.map((item) => {\n      if (Array.isArray(item)) {\n        return this.deepClone(item) as unknown as T;\n      } else if (typeof item === 'object' && item !== null) {\n        const cloned: any = {};\n        for (const key in item) {\n          cloned[key] = this.deepClone([item[key]])[0];\n        }\n        return cloned;\n      }\n      return item;\n    });\n  }\n\n  ngOnInit() {\n    this.showShapeLabel = this.regionApi.getShowShapeLabel();\n    this.shapeColor = this.regionApi.getShapeColor();\n    this.fillColor = this.regionApi.getFillColor();\n\n    // Annotation-class presets (jit-ui#70): mirror the set for the chip strip,\n    // the Class dropdown and the manage dialog. Guarded with optional calls so\n    // partial API mocks in tests (which omit the preset methods) don't throw.\n    const initialPresets = this.regionApi.getPresetSet?.();\n    if (initialPresets) this.presetSet = initialPresets;\n    const presets$ = this.regionApi.getPresetSet$?.();\n    if (presets$) {\n      this._presetSub = presets$.subscribe((set) => {\n        if (set) this.presetSet = set;\n        this.updateDisplayClasses();\n      });\n    }\n    // Seed from the visualizer's current regions — already scoped to the\n    // active image by the per-image cache, and handed back as neutral Region\n    // objects (no backend shape format involved).\n    // Annotation regions only — intensity-profile lines are owned by the\n    // intensity tool and excluded by the contract, so the editor never sees them.\n    this.regions = this.applyRegionColors(this.regionApi.getAnnotationRegions());\n    this.regionsCopy = this.deepClone(this.regions);\n    this.syncClassesFromRegions(this.regions);\n    this.recomputeClassCounts();\n\n    // The update event is just a change signal; re-read the regions from the\n    // visualizer rather than parsing whatever payload it carries.\n    this._regionSub = this.regionApi.getRegionUpdateEvent().subscribe(() => {\n      if (this._updatingFromEditor) return;\n      const updated = this.applyRegionColors(this.regionApi.getAnnotationRegions());\n      // preserve selection for regions that still exist (by id, since name\n      // is a user-editable display label and may collide)\n      const selectedIds = new Set(this.selectedRegions.map((r) => r.id));\n      this.regions = updated;\n      this.regionsCopy = this.deepClone(this.regions);\n      this.selectedRegions = updated.filter((r) => selectedIds.has(r.id));\n      this.clampPaginatorFirst();\n      this.syncClassesFromRegions(updated);\n      this.recomputeClassCounts();\n    });\n\n    this._saveAsCheck$.pipe(\n      debounceTime(400),\n      switchMap(name => this.regionIo.roiFileExists(name)),\n    ).subscribe({\n      next: exists => { this.saveAsFileExists = exists; },\n      error: () => { this.saveAsFileExists = false; },\n    });\n\n    // Physical pixel size of the active image (for region areas in µm²/mm²).\n    // Mirror PlotlyService.currentMpp: the calibration may sit on any channel\n    // entry, not necessarily [0], so pick the first entry with a positive mppX\n    // rather than reading [0] blindly. Fall back to square pixels (mppY = mppX)\n    // when only one axis is reported.\n    this._metaSub = this.regionApi.getImageMeta().subscribe((meta) => {\n      const { mppX, mppY } = this.pickMpp(meta);\n      this.mppX = mppX;\n      this.mppY = mppY;\n    });\n\n    this._selectedIdxSub = this.regionApi.getSelectedRegions$().subscribe((selected) => {\n      if (this._suppressSelectionSyncToPlot) return;\n      // Map the contract's selected regions to the editor's own instances by id.\n      const next = selected\n        .map((s) => this.regions.find((r) => r.id === s.id))\n        .filter((r): r is Region => !!r);\n      const same =\n        next.length === this.selectedRegions.length &&\n        next.every((r, i) => r.id === this.selectedRegions[i]?.id);\n      if (!same) this.selectedRegions = next;\n      // Scroll the paginator so the most-recently-selected row is visible.\n      if (next.length > 0) {\n        const lastIdx = this.regions.findIndex((r) => r.id === next[next.length - 1].id);\n        if (lastIdx >= 0) {\n          const pageStart = Math.floor(lastIdx / this.paginatorRows) * this.paginatorRows;\n          if (pageStart !== this.paginatorFirst) this.paginatorFirst = pageStart;\n        }\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this._regionSub.unsubscribe();\n    this._selectedIdxSub.unsubscribe();\n    this._metaSub.unsubscribe();\n    this._presetSub.unsubscribe();\n    if (this._saveAsTimer !== undefined) clearTimeout(this._saveAsTimer);\n    this._saveAsSub?.unsubscribe();\n    this.teardownMaskWorker();\n  }\n\n  /**\n   * Table → Plot: PrimeNG fires onRowSelect/onRowUnselect after updating\n   * `selectedRegions`. Push the selected regions to the contract by identity —\n   * the package maps them to its internal index space (which includes the\n   * intensity-profile lines the editor never sees).\n   */\n  onSelectionChanged() {\n    this._suppressSelectionSyncToPlot = true;\n    try {\n      this.regionApi.setSelectedRegions(this.selectedRegions ?? []);\n    } finally {\n      this._suppressSelectionSyncToPlot = false;\n    }\n  }\n\n  /**\n   * Apply classification colours and refresh the label→colour map for regions\n   * coming from the visualizer. The visualizer hands back neutral `Region`\n   * objects with bounds, colour and label already populated, so the editor no\n   * longer parses any backend-specific shape format — it only fills in a\n   * fallback colour and rebuilds its local label→colour lookup.\n   */\n  private applyRegionColors(regions: Region[]): Region[] {\n    for (const region of regions) {\n      region.color =\n        region.color ||\n        this.regionApi.getClassificationColors().get(region.label ?? '') ||\n        this.shapeColor;\n    }\n    // Rebuild labelColors: seed from persisted map, then overlay actual region colors\n    this.labelColors.clear();\n    for (const [label, color] of this.regionApi.getClassificationColors()) {\n      this.labelColors.set(label, color);\n    }\n    for (const region of regions) {\n      if (region.label && region.color) {\n        this.labelColors.set(region.label, region.color);\n      }\n    }\n    return regions;\n  }\n\n  /**\n   * Push edits from the editor to the diagram in live-edit mode (no save /\n   * cancel buttons). The `_updatingFromEditor` guard is still used so the\n   * resulting regionUpdateEvent doesn't bounce back as an external change.\n   */\n  private setRegionsFromEditor(fillColor?: string) {\n    this._updatingFromEditor = true;\n    // isRegionSaveOn=true so changes commit to the region store (and the per-image\n    // cache) immediately. setAnnotationRegions preserves the intensity-profile\n    // lines internally, so editor edits never disturb them.\n    this.regionApi.setAnnotationRegions(this.regions, this.showShapeLabel, true, fillColor ?? this.fillColor);\n    this._updatingFromEditor = false;\n    // The editor's own commit is ignored by the region-update subscription (the\n    // _updatingFromEditor guard), so refresh here: a class label typed in the\n    // Class column gets added to the list, and the panel counts/order stay in\n    // sync after any edit. (jit-ui#70)\n    this.syncClassesFromRegions(this.regions);\n    this.recomputeClassCounts();\n  }\n\n  /** Set one region's outline colour from the per-row picker and commit live.\n   *  Remembers it as the label's colour so same-class regions added later match\n   *  (jit-ui#85 — the Region Editor's per-region Color column). */\n  changeRegionColor(region: Region, color: string): void {\n    if (!color || region.color === color) return;\n    region.color = color;\n    region.colorOverridden = true; // explicit per-region colour — preserve it against preset (re)apply (jit-ui#70)\n    if (region.label) this.labelColors.set(region.label, color);\n    this.setRegionsFromEditor();\n  }\n\n  addRectangle() {\n    const region = new Region();\n    region.bounds = new Rectangle();\n    region.bounds.width = 512;\n    region.bounds.height = 512;\n    region.label = this.activeClass ?? 'Region';\n    // id and a non-colliding name are minted by the visualizer's setRegions\n    this.regions = [...this.regions, region];\n    this.setRegionsFromEditor();\n    this.regionsCopy = this.deepClone(this.regions);\n  }\n\n  /**\n   * Update the label of the region on enter key pressed (when editing a label cell in the table)\n   * @param region\n   * @param setRegion\n   */\n  labelRegionUpdate(region: Region, setRegion = false) {\n    if (region.label) {\n      // if label doesn't exist\n      if (!this.labelColors.has(region.label)) {\n        this.labelColors.set(region.label, this.shapeColor);\n      }\n    }\n    // update colors of the regions\n    for (const reg of this.regions) {\n      if (!reg.color) {\n        if (reg.label && this.labelColors.has(reg.label)) {\n          reg.color = this.labelColors.get(reg.label);\n        }\n      }\n    }\n    // update labels map\n    this.labelColors.clear();\n    for (const reg of this.regions) {\n      if (reg.label && reg.color) {\n        this.labelColors.set(reg.label, reg.color);\n      }\n    }\n    if (setRegion) {\n      this.setRegionsFromEditor();\n    }\n  }\n  xRectUpdate(region: Region, event: any) {\n    const rectangle = region.bounds;\n    if (rectangle && rectangle instanceof Rectangle) {\n      rectangle.x = event.value;\n      this.setRegionsFromEditor();\n    }\n  }\n  yRectUpdate(region: Region, event: any) {\n    const rectangle = region.bounds;\n    if (rectangle && rectangle instanceof Rectangle) {\n      rectangle.y = event.value;\n      this.setRegionsFromEditor();\n    }\n  }\n  widthRectUpdate(region: Region, event: any) {\n    if (event.value === null || event.value === undefined) return;\n    const rectangle = region.bounds;\n    if (rectangle && rectangle instanceof Rectangle) {\n      const reg = this.regionsCopy.filter((element: Region) => element.id === region.id);\n      if (reg.length) {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        const oldWidth = reg[0].bounds.width;\n        const diffWidth = event.value - oldWidth;\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        rectangle.x = Math.round(reg[0].bounds.x - diffWidth / 2);\n      }\n      rectangle.width = event.value;\n      this.setRegionsFromEditor();\n      this.regionsCopy = this.deepClone(this.regions);\n    }\n  }\n  heightRectUpdate(region: Region, event: any) {\n    if (event.value === null || event.value === undefined) return;\n    const rectangle = region.bounds;\n    if (rectangle && rectangle instanceof Rectangle) {\n      const reg = this.regionsCopy.filter((element: Region) => element.id === region.id);\n      if (reg.length) {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        const oldHeight = reg[0].bounds.height;\n        const diffHeight = event.value - oldHeight;\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        rectangle.y = Math.round(reg[0].bounds.y - diffHeight / 2);\n      }\n      rectangle.height = event.value;\n      this.setRegionsFromEditor();\n      this.regionsCopy = this.deepClone(this.regions);\n    }\n  }\n\n  onPageChange(event: { first?: number; rows?: number }) {\n    this.paginatorFirst = event.first ?? 0;\n    this.paginatorRows = event.rows ?? this.paginatorRows;\n  }\n\n  /** Select every region in the table (and highlight them on the diagram). */\n  selectAllRegions() {\n    this.selectedRegions = [...this.regions];\n    this.onSelectionChanged();\n  }\n\n  deleteSelectedRegions() {\n    if (this.selectedRegions && this.selectedRegions.length > 0) {\n      // Filter by id — object identity isn't reliable across re-parses,\n      // and name is a user-editable label that may collide.\n      const removed = new Set(this.selectedRegions.map((r) => r.id));\n      this.regions = this.regions.filter((r) => !removed.has(r.id));\n      this.selectedRegions = [];\n      this.clampPaginatorFirst();\n      this.setRegionsFromEditor();\n      // Sync the cleared selection with the plot's highlight state.\n      this.onSelectionChanged();\n    }\n  }\n\n  clearAllRegions() {\n    this.confirmationService.confirm({\n      key: 'positionDialog',\n      message: 'Are you sure you want to delete all regions?',\n      accept: () => {\n        this.regions = [];\n        this.selectedRegions = [];\n        this.paginatorFirst = 0;\n        this.setRegionsFromEditor();\n        this.onSelectionChanged();\n      },\n    });\n  }\n\n  addPolygon() {\n    const region = new Region();\n    region.bounds = new Polygon();\n    region.label = this.activeClass ?? 'Region';\n    region.bounds.ypoints = [0, 0, 0];\n    region.bounds.xpoints = [0, 0, 0];\n    region.bounds.coordinates = [\n      [0, 0],\n      [0, 0],\n      [0, 0],\n    ];\n    region.bounds.npoints = 3;\n    this.regions = [...this.regions, region];\n    this.setRegionsFromEditor();\n    this.regionsCopy = this.deepClone(this.regions);\n  }\n  deleteRegion(shapeIdx: number) {\n    const removed = this.regions[shapeIdx];\n    this.regions = this.regions.filter((_, i) => i !== shapeIdx);\n    if (removed) {\n      this.selectedRegions = this.selectedRegions.filter((r) => r.id !== removed.id);\n    }\n    this.clampPaginatorFirst();\n    this.setRegionsFromEditor();\n    // Re-emit the (possibly trimmed) selection so the plot's highlight stays\n    // in sync with what's still in the table.\n    this.onSelectionChanged();\n  }\n\n  private clampPaginatorFirst() {\n    const maxFirst = Math.max(\n      0,\n      Math.floor((this.regions.length - 1) / this.paginatorRows) * this.paginatorRows,\n    );\n    if (this.paginatorFirst > maxFirst) {\n      this.paginatorFirst = maxFirst;\n    }\n  }\n  changeShowShapeLabel(showLabel: boolean) {\n    this.setRegionsFromEditor();\n  }\n\n  isEditingLabel(region: any): boolean {\n    return this.editingLabelRegions.has(region);\n  }\n\n  startEditLabel(region: any, event?: Event): void {\n    event?.stopPropagation(); // don't toggle row selection\n    this.editingLabelRegions.add(region);\n  }\n\n  stopEditLabel(region: any, commit: boolean, event?: Event): void {\n    event?.stopPropagation();\n    this.editingLabelRegions.delete(region);\n    if (commit) {\n      this.labelRegionUpdate(region, true);\n    }\n  }\n\n  isRectangle(region: Region) {\n    return region.bounds instanceof Rectangle;\n  }\n\n  /**\n   * Region area for display: in µm² (or mm²) when the image reports a physical\n   * pixel size, otherwise in px². Empty string for degenerate regions.\n   */\n  regionArea(region: Region): string {\n    const px = this.areaInPixels(region);\n    if (px <= 0) return '';\n    if (this.mppX && this.mppY && this.mppX > 0 && this.mppY > 0) {\n      const um2 = px * this.mppX * this.mppY;\n      return um2 >= 1e6 ? `${this.fmtArea(um2 / 1e6)} mm²` : `${this.fmtArea(um2)} µm²`;\n    }\n    return `${this.fmtArea(px)} px²`;\n  }\n\n  /**\n   * Choose the physical pixel size (µm/pixel) for area display from the image\n   * meta. The calibration may sit on any channel entry — not necessarily [0] —\n   * so pick the first entry with a positive mppX (mirrors\n   * PlotlyService.currentMpp). Falls back to square pixels (mppY = mppX) when\n   * only one axis is reported, so a scaled image shows µm²/mm² rather than px².\n   */\n  private pickMpp(meta: IImageMetadata[] | undefined): { mppX?: number; mppY?: number } {\n    const m = Array.isArray(meta)\n      ? (meta.find((e) => e && (e.mppX ?? 0) > 0) ?? meta[0])\n      : undefined;\n    const mx = m && (m.mppX ?? 0) > 0 ? (m.mppX as number) : undefined;\n    const my = m && (m.mppY ?? 0) > 0 ? (m.mppY as number) : undefined;\n    return { mppX: mx, mppY: my ?? mx };\n  }\n\n  /** Pixel area: width·height for rectangles, shoelace formula for polygons.\n   *  Interior rings (holes) are subtracted, so a donut reports the annulus area,\n   *  not the filled exterior (jit-ui#85). */\n  private areaInPixels(region: Region): number {\n    const b = region.bounds;\n    if (b instanceof Rectangle) return Math.abs(b.width * b.height);\n    if (b instanceof Polygon) return this.polygonArea(b);\n    // Multi-part region: sum each part's (exterior − holes) area (jit-ui#85).\n    if (b instanceof MultiPolygon) {\n      return b.polygons.reduce((sum, p) => sum + this.polygonArea(p), 0);\n    }\n    return 0;\n  }\n\n  /** Polygon area: exterior shoelace minus each interior ring (hole). */\n  private polygonArea(p: Polygon): number {\n    if ((p.xpoints?.length ?? 0) < 3) return 0;\n    let a = this.ringArea(p.xpoints, p.ypoints);\n    if (p.holes) {\n      for (const ring of p.holes) a -= this.ringArea(ring.map(pt => pt[0]), ring.map(pt => pt[1]));\n    }\n    return Math.max(0, a);\n  }\n\n  /** Absolute shoelace area of a single ring. */\n  private ringArea(xs: number[], ys: number[]): number {\n    const n = xs?.length ?? 0;\n    if (n < 3) return 0;\n    let a = 0;\n    for (let i = 0, j = n - 1; i < n; j = i++) a += (xs[j] + xs[i]) * (ys[j] - ys[i]);\n    return Math.abs(a / 2);\n  }\n\n  private fmtArea(n: number): string {\n    return (n >= 1000 ? Math.round(n) : Math.round(n * 100) / 100).toLocaleString();\n  }\n\n  /**\n   * This method rounds all the rectangle regions lengths to multiple of 512\n   */\n  roundRectangleLengths() {\n    for (const region of this.regions) {\n      if (region.bounds instanceof Rectangle) {\n        const rect = region.bounds;\n        rect.height = Math.round(rect.height / 512) * 512;\n        rect.width = Math.round(rect.width / 512) * 512;\n      }\n    }\n    this.setRegionsFromEditor();\n  }\n\n  /**\n   * Stop key arrow event propagation\n   * @param event\n   */\n  disableArrowKeys(event: any) {\n    if (\n      event.key === 'ArrowDown' ||\n      event.key === 'Down' ||\n      event.key === 'ArrowUp' ||\n      event.key === 'Up' ||\n      event.key === 'ArrowLeft' ||\n      event.key === 'Left' ||\n      event.key === 'ArrowRight' ||\n      event.key === 'Right'\n    ) {\n      event.stopPropagation();\n    }\n  }\n\n  changeShapeColor(event: any) {\n    this.shapeColor = event.value;\n    for (const region of this.regions) {\n      if (region.label === this.selectedLabelColor && this.labelColors.has(region.label)) {\n        this.labelColors.set(region.label, this.shapeColor);\n        region.color = this.shapeColor;\n      }\n    }\n    this.setRegionsFromEditor(this.fillColor);\n  }\n\n  showHelp() {\n    this.displayHelpDialog = true;\n  }\n\n  /** Open the colour dialog for the currently-selected region(s), building one\n   *  colour picker per unique class in the selection. Each picker is seeded with\n   *  the class's current colour (the label→colour map, falling back to the first\n   *  selected region of that class). */\n  openColorDialog() {\n    if (!this.selectedRegions?.length) return;\n    const seedByLabel = new Map<string, string>();\n    for (const region of this.selectedRegions) {\n      const label = region.label?.trim() ?? '';\n      if (seedByLabel.has(label)) continue;\n      seedByLabel.set(\n        label,\n        (label ? this.labelColors.get(label) : undefined) ?? region.color ?? this.shapeColor,\n      );\n    }\n    this.classColorEdits = [...seedByLabel].map(([label, color]) => ({ label, color }));\n    this.showColorDialog = true;\n  }\n\n  /** Apply each class's chosen colour to the selected regions of that class and\n   *  commit live. Remembers the colour per class so same-class regions added\n   *  later match. */\n  applyColorToSelected() {\n    const colorByLabel = new Map(this.classColorEdits.map((e) => [e.label, e.color]));\n    for (const region of this.selectedRegions ?? []) {\n      const label = region.label?.trim() ?? '';\n      const color = colorByLabel.get(label);\n      if (!color) continue;\n      region.color = color;\n      region.colorOverridden = true; // explicit colour — preserve against preset (re)apply (jit-ui#70)\n      if (label) this.labelColors.set(label, color);\n    }\n    this.setRegionsFromEditor();\n    this.showColorDialog = false;\n  }\n\n  // ── annotation-class presets (jit-ui#70) ─────────────────────────────\n\n  /** Resolve the display colour for a class name (preset colour or deterministic fallback). */\n  colorForName(name?: string): string {\n    return name ? colorForLabel(name, this.presetSet) : this.shapeColor;\n  }\n\n  /**\n   * Ensure every class label present in the loaded regions exists in the preset\n   * list, auto-adding any that are missing (using the region's already-resolved\n   * colour). This makes classes carried in a loaded/imported GeoJSON show up as\n   * chips + Class-dropdown options (a p-dropdown can't display a value that isn't\n   * an option) and lets the user manage them. The placeholder 'legend' and empty\n   * labels are ignored. (jit-ui#70)\n   */\n  private syncClassesFromRegions(regions: Region[]): void {\n    const normalized = this.presetSet.matchMode === 'normalized';\n    const keyOf = (l: string) => (normalized ? l.trim().toLowerCase() : l);\n    const known = new Set(this.presetSet.classes.map((c) => keyOf(c.name)));\n    const added = new Set<string>();\n    for (const r of regions) {\n      const label = r.label?.trim();\n      if (!label || label === 'legend') continue;\n      const k = keyOf(label);\n      if (known.has(k) || added.has(k)) continue;\n      added.add(k);\n      this.regionApi.upsertClass({\n        name: label,\n        color: r.color || colorForLabel(label, this.presetSet),\n        source: 'auto',\n      });\n    }\n  }\n\n  // ── Docked Classes panel (jit-ui#70) ─────────────────────────────────\n\n  /** Rebuild the per-class region counts shown in the panel. */\n  private recomputeClassCounts(): void {\n    const normalized = this.presetSet.matchMode === 'normalized';\n    const counts = new Map<string, number>();\n    for (const r of this.regions) {\n      if (!r.label) continue;\n      const k = normalized ? r.label.trim().toLowerCase() : r.label;\n      counts.set(k, (counts.get(k) ?? 0) + 1);\n    }\n    this.classCounts = counts;\n    this.updateDisplayClasses();\n  }\n\n  /** Rebuild the panel's display order — most-used classes first, then by name. */\n  private updateDisplayClasses(): void {\n    this.displayClasses = [...this.presetSet.classes].sort((a, b) => {\n      const d = this.classCount(b.name) - this.classCount(a.name);\n      return d !== 0 ? d : a.name.localeCompare(b.name);\n    });\n  }\n\n  /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */\n  trackByClassName = (_: number, c: ClassPreset): string => c.name;\n\n  /** Number of regions currently using a class (keyed by the active match mode). */\n  classCount(name: string): number {\n    const k = this.presetSet.matchMode === 'normalized' ? name.trim().toLowerCase() : name;\n    return this.classCounts.get(k) ?? 0;\n  }\n\n  /** Recolour a class from its panel swatch and repaint its (non-overridden) regions. */\n  setClassColor(name: string, color: string): void {\n    if (!color) return;\n    this.regionApi.setClassificationColor(name, color);\n    this.setRegionsFromEditor();\n  }\n\n  /** Tooltip for a class's delete button in the panel. */\n  deleteClassTooltip(name: string): string {\n    const inUse = this.classCount(name) > 0;\n    if (name === this.defaultClassName && inUse) return 'The default class cannot be removed while in use';\n    return inUse ? 'Remove class — its regions revert to Region' : 'Remove class';\n  }\n\n  /** Remove a class. Any regions still using it fall back to the default\n   *  \"Region\" class, so they aren't orphaned (and the class isn't immediately\n   *  re-added from its regions by syncClassesFromRegions). */\n  deleteClass(name: string): void {\n    this.reassignRegionsToDefaultClass([name]);\n    this.regionApi.removeClass(name);\n    if (this.activeClass === name) this.activeClass = null;\n    this.setRegionsFromEditor();\n  }\n\n  /** Regions labelled with any of `removedNames` revert to the default\n   *  {@link defaultClassName} (\"Region\"): its class colour, override cleared.\n   *  Skips the default itself so deleting \"Region\" can't self-reassign. (jit-ui#70) */\n  private reassignRegionsToDefaultClass(removedNames: string[]): void {\n    const norm = this.presetSet.matchMode === 'normalized';\n    const keyOf = (s: string) => (norm ? s.trim().toLowerCase() : s);\n    const removed = new Set(removedNames.map(keyOf));\n    removed.delete(keyOf(this.defaultClassName));\n    if (!removed.size) return;\n    const color = colorForLabel(this.defaultClassName, this.presetSet);\n    for (const r of this.regions) {\n      if (r.label && removed.has(keyOf(r.label))) {\n        r.label = this.defaultClassName;\n        r.colorOverridden = false;\n        r.color = color;\n      }\n    }\n  }\n\n  /** Stamp a class (and its preset/fallback colour) onto one region from the Class\n   *  dropdown; choosing a class opts the region back into the preset colour. */\n  applyPresetToRegion(region: Region, className: string): void {\n    const name = (className ?? '').trim();\n    region.label = name;\n    region.colorOverridden = false;\n    if (name) region.color = colorForLabel(name, this.presetSet);\n    this.setRegionsFromEditor();\n  }\n\n  /** Make a class active (used for new regions) and, if rows are selected, apply\n   *  it to them in one commit. */\n  selectActiveClass(name: string): void {\n    this.activeClass = name;\n    this.applyClassToSelected(name);\n  }\n\n  /** Apply a class (label + preset/fallback colour) to the current selection and commit. */\n  private applyClassToSelected(name: string): void {\n    const selected = this.selectedRegions ?? [];\n    if (!selected.length) return;\n    for (const r of selected) {\n      r.label = name;\n      r.colorOverridden = false;\n      r.color = colorForLabel(name, this.presetSet);\n    }\n    this.setRegionsFromEditor();\n  }\n\n  /** \"Edit class on selected rows\" popup — apply the chosen existing class. */\n  applyBulkClass(): void {\n    if (!this.bulkClass) return;\n    this.applyClassToSelected(this.bulkClass);\n    this.overlayPanel?.hide();\n  }\n\n  /** \"Edit class on selected rows\" popup — add a new class and set it on the selection. */\n  addAndApplyBulkClass(): void {\n    const name = this.newBulkClass.trim();\n    if (!name) return;\n    const norm = this.presetSet.matchMode === 'normalized';\n    const exists = this.presetSet.classes.some((c) =>\n      norm ? c.name.trim().toLowerCase() === name.toLowerCase() : c.name === name,\n    );\n    if (!exists) {\n      this.regionApi.upsertClass({ name, color: colorForLabel(name, this.presetSet), source: 'user' });\n    }\n    this.applyClassToSelected(name);\n    this.bulkClass = name;\n    this.newBulkClass = '';\n    this.overlayPanel?.hide();\n  }\n\n  // ── Manage-classes dialog ──\n  openManageDialog(): void {\n    this.presetDraft = this.clonePresetSet(this.presetSet);\n    this.showManageDialog = true;\n  }\n  private clonePresetSet(s: PresetSet): PresetSet {\n    return {\n      classes: (s.classes ?? []).map((c) => ({ ...c })),\n      fallbackPalette: [...(s.fallbackPalette ?? [])],\n      autoPromote: !!s.autoPromote,\n      matchMode: s.matchMode === 'normalized' ? 'normalized' : 'exact',\n    };\n  }\n  addPresetClass(): void {\n    this.presetDraft?.classes.push({ name: '', color: '#888888', source: 'user' });\n  }\n  removePresetClass(i: number): void {\n    this.presetDraft?.classes.splice(i, 1);\n  }\n  addFallbackColor(): void {\n    this.presetDraft?.fallbackPalette.push('#888888');\n  }\n  removeFallbackColor(i: number): void {\n    this.presetDraft?.fallbackPalette.splice(i, 1);\n  }\n  /** Commit the draft: drop blank/duplicate names, persist, and recolour\n   *  non-overridden regions with the updated presets. */\n  applyManageDialog(close: boolean): void {\n    if (!this.presetDraft) return;\n    // De-duplicate using the active match mode's key so normalized mode can't keep\n    // both \"Tumor\" and \"tumor\" (which would collide at runtime in findPreset()).\n    const norm = this.presetDraft.matchMode === 'normalized';\n    const seen = new Set<string>();\n    const classes: ClassPreset[] = [];\n    for (const c of this.presetDraft.classes) {\n      const name = (c.name ?? '').trim();\n      const key = norm ? name.toLowerCase() : name;\n      if (!name || seen.has(key)) continue;\n      seen.add(key);\n      classes.push({ ...c, name });\n    }\n    this.presetDraft.classes = classes;\n    // Classes dropped in the dialog: their regions revert to the default \"Region\"\n    // class (else syncClassesFromRegions would just re-add them) (jit-ui#70).\n    const keyOf = (s: string) => (norm ? s.trim().toLowerCase() : s);\n    const kept = new Set(classes.map((c) => keyOf(c.name)));\n    const removed = this.presetSet.classes\n      .map((c) => c.name)\n      .filter((n) => !kept.has(keyOf(n)));\n    this.reassignRegionsToDefaultClass(removed);\n    this.regionApi.setPresetSet(this.presetDraft);\n    this.setRegionsFromEditor(); // recolour existing (non-overridden) regions from the new presets\n    if (close) this.showManageDialog = false;\n  }\n  resetPresetsToDefaults(): void {\n    this.regionApi.resetPresets();\n    this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());\n    this.setRegionsFromEditor();\n  }\n  exportPresets(): void {\n    const json = JSON.stringify(this.regionApi.getPresetSet(), null, 2);\n    saveAs(new Blob([json], { type: 'application/json' }), 'annotation-classes.json');\n  }\n  importPresets(event: Event): void {\n    const input = event.target as HTMLInputElement;\n    const file = input.files?.[0];\n    if (!file) return;\n    const reader = new FileReader();\n    reader.onload = (e: any) => {\n      try {\n        const set = JSON.parse(e.target.result) as PresetSet;\n        this.regionApi.setPresetSet(set);\n        this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());\n        this.setRegionsFromEditor();\n        this.messageService.add({ key: 'app-toast', severity: 'success',\n          summary: 'Classes imported', detail: 'Annotation classes loaded.' });\n      } catch (err) {\n        this.messageService.add({ key: 'app-toast', severity: 'error',\n          summary: 'Import failed', detail: `${err}` });\n      }\n    };\n    reader.readAsText(file);\n  }\n\n  importRois(event: Event) {\n    const input = event.target as HTMLInputElement;\n    const file = input.files?.[0];\n    if (!file) return;\n    const reader = new FileReader();\n    reader.onload = (e: any) => {\n      const fileContent = e.target.result;\n      try {\n        this.regions = this.regionApi.importRegions(fileContent);\n        // set label colors\n        for (const region of this.regions) {\n          this.labelRegionUpdate(region, false);\n        }\n        this.syncClassesFromRegions(this.regions);\n        this.setRegionsFromEditor();\n      } catch (event) {\n        this.messageService.add({\n          severity: 'error',\n          summary: 'Error importing the file',\n          detail: `${event}`,\n        });\n        console.error('Error reading the file: ' + event);\n      }\n    };\n    reader.readAsText(file);\n  }\n\n  /**\n   * Regions to serialize on save/export. For a single-file z-stack the store\n   * keeps only the current slice live, so pull EVERY slice's annotations (each\n   * tagged with its zero-based Region.z) to write one combined z-indexed\n   * geojson (jit-ui#93). Otherwise (single-plane image, or a folder stack whose\n   * slices save to their own per-slice files) the current set. (jit-ui#93)\n   */\n  private regionsForSave(): Region[] {\n    if (this.regionApi.isStackMode() && this.regionApi.getStackSaveLayout() === 'combined') {\n      return this.regionApi.getSliceAnnotationRegions();\n    }\n    return this.regions;\n  }\n\n  exportRois() {\n    if (!this.regionsForSave().length) return;\n    const name = this.regionIo.getSelectedFileName();\n    const stem = name ? name.substring(0, name.lastIndexOf('.')) : 'rois';\n    this.exportFilename = `${stem}.geojson`;\n    this.showExportDialog = true;\n  }\n\n  confirmExport() {\n    const filename = this.exportFilename.trim();\n    const regions = this.regionsForSave();\n    if (!filename || !regions.length) return;\n    this.showExportDialog = false;\n    const jsonString = this.regionApi.getGeoJsonString(regions);\n    const blob = new Blob([jsonString], { type: 'application/json' });\n    saveAs(blob, filename);\n  }\n\n  /** Open the \"Save mask\" dialog, seeded with `<image-stem>_mask.png`. */\n  openSaveMaskDialog() {\n    if (!this.regions.length) return;\n    const name = this.regionIo.getSelectedFileName();\n    // Strip the extension only when there is one; an extension-less name keeps\n    // its whole stem (a leading-dot dotfile is treated as having no extension)\n    // so we never produce a bare \"_mask.png\".\n    const dot = name ? name.lastIndexOf('.') : -1;\n    const stem = name ? (dot > 0 ? name.substring(0, dot) : name) : 'regions';\n    this.saveMaskFilename = `${stem}_mask.png`;\n    this.maskMode = 'binary';\n    this.showSaveMaskDialog = true;\n  }\n\n  /**\n   * Rasterize the regions to the chosen mask type and download as a PNG. The\n   * heavy work (full-res rasterize + PNG encode) runs in a Web Worker so the UI\n   * never freezes on large/whole-slide images and the job can be cancelled\n   * (jit-ui#95). The dialog stays open showing a progress bar until done.\n   */\n  confirmSaveMask() {\n    const filename = this.saveMaskFilename.trim();\n    if (!filename || !this.regions.length || this.maskBusy) return;\n\n    const size = this.regionApi.getMaskImageSize();\n    if (!size) {\n      this.maskError('No image size is available, so the mask cannot be sized.');\n      return;\n    }\n\n    // Whole-slide images exceed the browser's typed-array/memory limits, so cap\n    // the mask to a safe pixel budget and scale the geometry to match.\n    const scale = maskScaleFor(size.width, size.height);\n    const width = Math.max(1, Math.round(size.width * scale));\n    const height = Math.max(1, Math.round(size.height * scale));\n    if (scale < 1) {\n      this.messageService.add({\n        key: 'app-toast',\n        severity: 'info',\n        summary: 'Mask downscaled',\n        detail: `Image too large for a full-resolution mask; saving at ${width}×${height}.`,\n      });\n    }\n    const regions = this.regions.map((r) => scaleParts(regionToParts(r), scale));\n\n    this.pendingMaskFilename = filename;\n    this.maskBusy = true;\n    this.maskEncoding = false;\n    this.maskProgress = 0;\n\n    const payload = {\n      width, height,\n      originalWidth: size.width, originalHeight: size.height, scale,\n      mode: this.maskMode,\n      sourceName: this.regionIo.getSelectedFileName(),\n      regions,\n    };\n    // createMaskWorker() is async (the worker module is imported dynamically so\n    // its import.meta never reaches the CommonJS test compile). Wire up once it\n    // resolves — unless the user cancelled while it was loading.\n    this.createMaskWorker().then((worker) => {\n      if (!this.maskBusy) { worker.terminate(); return; }\n      this.maskWorker = worker;\n      worker.onmessage = ({ data }: MessageEvent) => {\n        switch (data?.type) {\n          case 'progress':\n            this.maskProgress = data.total ? Math.round((data.done / data.total) * 100) : 0;\n            break;\n          case 'encoding':\n            this.maskEncoding = true;\n            break;\n          case 'done':\n            this.finishMask(new Blob([data.png], { type: 'image/png' }));\n            break;\n          case 'error':\n            this.maskError(data.error || 'The mask could not be generated.');\n            break;\n        }\n      };\n      worker.onerror = () => this.maskError('The mask worker failed.');\n      worker.postMessage(payload);\n    }).catch(() => this.maskError('The mask worker failed to start.'));\n  }\n\n  /** Cancel an in-progress mask export: terminate the worker and reset state. */\n  cancelSaveMask() {\n    this.teardownMaskWorker();\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.maskProgress = 0;\n  }\n\n  /** Worker factory — async so the worker module (and its `import.meta.url`,\n   *  which the CommonJS test compile rejects) is loaded via a dynamic import,\n   *  exactly like the segmentation worker. Overridable in tests. */\n  protected async createMaskWorker(): Promise<Worker> {\n    const { createMaskWorker } = await import('./mask-worker');\n    return createMaskWorker();\n  }\n\n  private finishMask(blob: Blob) {\n    this.teardownMaskWorker();\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.showSaveMaskDialog = false;\n    saveAs(blob, this.pendingMaskFilename);\n  }\n\n  private maskError(detail: string) {\n    this.teardownMaskWorker();\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.messageService.add({\n      key: 'app-toast',\n      severity: 'error',\n      summary: 'Could not create mask',\n      detail,\n    });\n  }\n\n  private teardownMaskWorker() {\n    this.maskWorker?.terminate();\n    this.maskWorker = undefined;\n  }\n\n  persistRegions() {\n    // Folder stack: write each slice's regions back to its own slice-file's\n    // sibling geojson — no single-filename prompt (the filenames are the slice\n    // files'). (jit-ui#93)\n    if (this.regionApi.isStackMode() && this.regionApi.getStackSaveLayout() === 'per-slice-file') {\n      this.saveStackSlices();\n      return;\n    }\n    const name = this.regionIo.getSelectedFileName();\n    if (!name || !this.regionsForSave().length) return;\n\n    this.saveAsFilename = name.substring(0, name.lastIndexOf('.')) + '.geojson';\n    this.saveAsFileExists = false;\n    this.showSaveAsDialog = true;\n    this._saveAsCheck$.next(this.saveAsFilename);\n  }\n\n  /**\n   * Save a folder stack's regions as one geojson per slice-file (jit-ui#93).\n   * Groups the store's per-slice regions by slice index and serializes each on\n   * the default plane (z=0) — each slice-file is itself one plane, and the\n   * loader re-derives the slice index from the file's position in the series.\n   * Slices cleared since load are included (empty) so their file is overwritten.\n   */\n  private saveStackSlices() {\n    const bySlice = this.regionApi.getStackSaveAnnotationSlices();\n    if (!bySlice.size) return;\n    const slices: { z: number; geoJsonStr: string }[] = [];\n    for (const [z, regs] of bySlice) {\n      const flat = regs.map((r) => Object.assign(new Region(), r, { z: 0 }));\n      slices.push({ z, geoJsonStr: this.regionApi.getGeoJsonString(flat) });\n    }\n    this.saveAsBusy = true;\n    this._saveAsSub = this.regionIo.saveSliceGeoJsons(slices).subscribe({\n      next: () => {\n        this.saveAsBusy = false;\n        this.messageService.add({\n          key: 'app-toast',\n          severity: 'success',\n          summary: 'Regions saved',\n          detail: `Saved ROIs for ${slices.length} slice${slices.length === 1 ? '' : 's'}`,\n        });\n      },\n      error: (err) => {\n        this.saveAsBusy = false;\n        this.messageService.add({\n          key: 'app-toast',\n          severity: 'error',\n          summary: 'Error saving regions',\n          detail: `${(err as Error)?.message ?? err}`,\n        });\n      },\n    });\n  }\n\n  checkSaveAsFileExists() {\n    this._saveAsCheck$.next(this.saveAsFilename);\n  }\n\n  confirmSaveAs() {\n    if (!this.regionIo.getSelectedFileName()) return;\n\n    const filename = this.saveAsFilename.trim();\n    if (!filename) return;\n\n    const doSave = () => {\n      // Keep the dialog open showing an (indeterminate) progress bar while the\n      // regions serialize and upload, then close on success. Defer one tick so\n      // the bar paints before a large synchronous GeoJSON serialize.\n      this.saveAsBusy = true;\n      this._saveAsTimer = setTimeout(() => {\n        this._saveAsTimer = undefined;\n        let geoJsonStr: string;\n        try {\n          geoJsonStr = this.regionApi.getGeoJsonString(this.regionsForSave());\n        } catch (err) {\n          this.saveAsBusy = false;\n          this.messageService.add({\n            key: 'app-toast',\n            severity: 'error',\n            summary: 'Error saving regions',\n            detail: `${(err as Error)?.message ?? err}`,\n          });\n          return;\n        }\n        this._saveAsSub = this.regionIo.saveGeoJson(geoJsonStr, filename).subscribe({\n          next: () => {\n            this.saveAsBusy = false;\n            this.showSaveAsDialog = false;\n            this.messageService.add({\n              key: 'app-toast',\n              severity: 'success',\n              summary: 'Regions saved',\n              detail: `Saved as ${filename}`,\n            });\n          },\n          error: (err) => {\n            this.saveAsBusy = false;\n            this.messageService.add({\n              key: 'app-toast',\n              severity: 'error',\n              summary: 'Error saving regions',\n              detail: `${err.message || err}`,\n            });\n          },\n        });\n      });\n    };\n\n    if (this.saveAsFileExists) {\n      this.confirmationService.confirm({\n        message: `\"${filename}\" already exists. Do you want to overwrite it?`,\n        header: 'Confirm Overwrite',\n        icon: 'pi pi-exclamation-triangle',\n        accept: doSave,\n      });\n    } else {\n      doSave();\n    }\n  }\n\n  /** Cancel an in-progress GeoJSON persist: abort the deferred serialize and/or\n   *  the in-flight upload, and reset state. */\n  cancelSaveAs() {\n    if (this._saveAsTimer !== undefined) {\n      clearTimeout(this._saveAsTimer);\n      this._saveAsTimer = undefined;\n    }\n    this._saveAsSub?.unsubscribe();\n    this._saveAsSub = undefined;\n    this.saveAsBusy = false;\n  }\n}\n","\n<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button icon=\"pi pi-tag\" size=\"small\"\n              [text]=\"!showShapeLabel\"\n              pTooltip=\"Show region labels.\"\n              tooltipPosition=\"bottom\"\n              (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\">\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button icon=\"pi pi-upload\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Upload and display regions from geojson file.\"\n              tooltipPosition=\"bottom\"\n              (click)=\"roiFileInput.click()\">\n    </p-button>\n    <input #roiFileInput type=\"file\" accept=\".geojson,.json\" hidden\n           (change)=\"importRois($event); roiFileInput.value = ''\"/>\n    <p-button size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Download regions as geojson file.\"\n              tooltipPosition=\"bottom\" icon=\"pi pi-download\"\n              (click)=\"exportRois()\">\n    </p-button>\n    <p-button icon=\"pi pi-save\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Save regions to server.\"\n              tooltipPosition=\"bottom\"\n              (click)=\"persistRegions()\"\n              [disabled]=\"!regions || !regions.length\">\n    </p-button>\n    <p-button size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Download mask of the regions as PNG\"\n              tooltipPosition=\"bottom\"\n              (click)=\"openSaveMaskDialog()\"\n              [disabled]=\"!regions || !regions.length\">\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img src=\"assets/plotting/mask.svg\" class=\"toolbar-icon-dark\"\n           style=\"width: 1rem; height: 1rem; vertical-align: middle;\"\n           alt=\"Download mask\"/>\n    </p-button>\n    <p-button label=\"x512\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\" tooltipPosition=\"bottom\"\n              (click)=\"roundRectangleLengths()\">\n    </p-button>\n    <p-button icon=\"pi pi-check-square\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Select all regions\" tooltipPosition=\"bottom\"\n              (click)=\"selectAllRegions()\"\n              [disabled]=\"!regions || !regions.length\">\n    </p-button>\n    <p-button icon=\"pi pi-tags\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Edit class on selected rows\"\n              tooltipPosition=\"bottom\"\n              (click)=\"(!selectedRegions || !selectedRegions.length)? op.hide() : op.toggle($event)\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\">\n    </p-button>\n    <p-button icon=\"pi pi-palette\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              pTooltip=\"Edit colour of selected regions\"\n              tooltipPosition=\"bottom\"\n              (click)=\"openColorDialog()\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\">\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass=''; newBulkClass=''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\">Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span>\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown styleClass=\"w-full\" appendTo=\"body\" [options]=\"presetSet.classes\"\n                    optionLabel=\"name\" optionValue=\"name\" [(ngModel)]=\"bulkClass\"\n                    placeholder=\"Choose a class…\"\n                    [filter]=\"presetSet.classes.length > 8\" filterBy=\"name\"\n                    (onChange)=\"applyBulkClass()\">\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span>\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input type=\"text\" pInputText placeholder=\"…or a new class\" [(ngModel)]=\"newBulkClass\"\n                 (keydown.enter)=\"addAndApplyBulkClass()\"/>\n          <button pButton type=\"button\" icon=\"pi pi-plus\" pTooltip=\"Add class &amp; set it\"\n                  tooltipPosition=\"bottom\" [disabled]=\"!newBulkClass.trim()\"\n                  (click)=\"addAndApplyBulkClass()\"></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button icon=\"pi pi-trash\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              (click)=\"deleteSelectedRegions()\"\n              pTooltip=\"Delete selected regions\" tooltipPosition=\"bottom\"\n              [disabled]=\"!selectedRegions || !selectedRegions.length\"></p-button>\n    <p-button icon=\"pi pi-times-circle\" size=\"small\" [text]=\"true\" styleClass=\"mr-2\"\n              (click)=\"clearAllRegions()\"\n              pTooltip=\"Delete all regions\" tooltipPosition=\"bottom\"\n              [disabled]=\"!regions || !regions.length\"></p-button>\n    <p-button icon=\"pi pi-question\" size=\"small\" [text]=\"true\"\n              (click)=\"showHelp()\" pTooltip=\"Help\" tooltipPosition=\"bottom\"></p-button>\n  </div>\n</p-toolbar>\n\n<!-- Docked \"Classes\" panel (jit-ui#70): the always-visible list of annotation\n     classes above the regions table. Click a row to make it the active class\n     (new regions inherit it; with rows selected it re-classifies them); recolour\n     via the swatch; the badge shows how many regions use the class. \"Manage\"\n     opens the full editor (fallback palette, auto-add, matching, import/export). -->\n<div class=\"classes-panel\">\n  <div class=\"classes-panel-header\">\n    <span class=\"classes-panel-title\">Classes</span>\n    <button pButton type=\"button\" icon=\"pi pi-cog\" label=\"Manage\"\n            class=\"p-button-sm p-button-text\"\n            pTooltip=\"Manage classes — add / remove, palette, matching, import/export\"\n            tooltipPosition=\"bottom\" (click)=\"openManageDialog()\"></button>\n  </div>\n  <div class=\"classes-panel-body\">\n    <div *ngFor=\"let c of displayClasses; trackBy: trackByClassName\"\n         class=\"class-row\" [class.active]=\"activeClass === c.name\"\n         (click)=\"selectActiveClass(c.name)\"\n         [pTooltip]=\"selectedRegions?.length\n           ? 'Apply “' + c.name + '” to the selected region(s)'\n           : 'Set “' + c.name + '” active — new regions use it'\"\n         tooltipPosition=\"bottom\">\n      <span class=\"row-swatch\" (click)=\"$event.stopPropagation()\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"setClassColor(c.name, $event)\"></hex-color-picker>\n      </span>\n      <span class=\"row-name\">{{ c.name }}</span>\n      <span class=\"row-count\" [class.zero]=\"classCount(c.name) === 0\">{{ classCount(c.name) }}</span>\n      <button pButton type=\"button\" icon=\"pi pi-trash\"\n              class=\"p-button-sm p-button-text p-button-warning row-del\"\n              [disabled]=\"c.name === defaultClassName && classCount(c.name) > 0\"\n              [pTooltip]=\"deleteClassTooltip(c.name)\"\n              tooltipPosition=\"bottom\"\n              (click)=\"$event.stopPropagation(); deleteClass(c.name)\"></button>\n    </div>\n    <div *ngIf=\"!displayClasses.length\" class=\"classes-empty\">\n      No classes yet — add one from Manage.\n    </div>\n  </div>\n</div>\n\n<div class=\"region-editor-content\">\n    <p-table #dt [value]=\"regions.slice(paginatorFirst, paginatorFirst + paginatorRows)\"\n             [tableStyle]=\"{'width': '100%'}\" [(selection)]=\"selectedRegions\"\n             selectionMode=\"multiple\" [metaKeySelection]=\"metaKey\"\n             (onRowSelect)=\"onSelectionChanged()\" (onRowUnselect)=\"onSelectionChanged()\"\n             [resizableColumns]=\"true\"\n             [rowHover]=\"true\" dataKey=\"id\" styleClass=\"p-datatable-sm region-editor-table\"\n             [scrollable]=\"true\" scrollHeight=\"100%\">\n      <ng-template pTemplate=\"header\">\n        <!-- Hide the column header when there are no regions to show. -->\n        <tr *ngIf=\"regions.length > 0\">\n          <!-- Class column: shrinks to fit \"Region\" by default, grows with longer labels. -->\n          <th class=\"class-col-header\" pResizableColumn>Class <p-sortIcon field=\"label\"></p-sortIcon></th>\n          <th class=\"surface-col-header\" pResizableColumn>Surface</th>\n          <!-- Trash column: just enough for the icon. -->\n          <th style=\"width:2rem\"></th>\n        </tr>\n      </ng-template>\n      <ng-template pTemplate=\"body\" let-region let-shapeIdx=\"rowIndex\">\n        <tr [pSelectableRow]=\"region\" [pSelectableRowIndex]=\"shapeIdx\">\n          <td class=\"class-cell\">\n            <ng-container *ngIf=\"!isEditingLabel(region); else editLabelTpl\">\n              <span class=\"class-cell-display\">\n                <!-- Quick-pick a preset class (its colour follows); the pencil is for\n                     a free-form name / rename (jit-ui#70). -->\n                <p-dropdown class=\"class-dropdown\" appendTo=\"body\"\n                            [options]=\"presetSet.classes\" optionLabel=\"name\" optionValue=\"name\"\n                            [ngModel]=\"region.label\" [autoDisplayFirst]=\"false\"\n                            (onChange)=\"applyPresetToRegion(region, $event.value)\">\n                  <ng-template pTemplate=\"selectedItem\">\n                    <span class=\"dd-value\">\n                      <span class=\"chip-swatch\" [style.background]=\"colorForName(region.label)\"></span>\n                      <span class=\"class-name\" [pTooltip]=\"region.label\" tooltipPosition=\"bottom\">{{ region.label || '—' }}</span>\n                    </span>\n                  </ng-template>\n                  <ng-template let-c pTemplate=\"item\">\n                    <span class=\"dd-value\">\n                      <span class=\"chip-swatch\" [style.background]=\"c.color\"></span>\n                      <span>{{ c.name }}</span>\n                    </span>\n                  </ng-template>\n                </p-dropdown>\n                <i class=\"pi pi-pencil icon-hover ml-2\"\n                   pTooltip=\"Rename / free-form label\" tooltipPosition=\"bottom\"\n                   (click)=\"startEditLabel(region, $event)\"></i>\n              </span>\n            </ng-container>\n            <ng-template #editLabelTpl>\n              <span class=\"p-input-icon-right class-cell-edit\">\n                <i class=\"pi pi-times icon-hover\"\n                   pTooltip=\"Close\" tooltipPosition=\"bottom\"\n                   (click)=\"stopEditLabel(region, false, $event)\"></i>\n                <input type=\"text\" pInputText class=\"p-inputtext-sm w-full\"\n                       [(ngModel)]=\"region.label\"\n                       (click)=\"$event.stopPropagation()\"\n                       (keydown.enter)=\"stopEditLabel(region, true, $event)\"\n                       (keydown.escape)=\"stopEditLabel(region, false, $event)\"/>\n              </span>\n            </ng-template>\n          </td>\n          <!-- Surface area (µm²/mm² when the image is scaled, else px²). -->\n          <td class=\"surface-cell\">{{ regionArea(region) || '—' }}</td>\n          <td>\n            <button pButton pRipple icon=\"pi pi-trash\"\n\t\t\t\t\t\t\tclass=\"p-button-sm p-button-rounded p-button-text p-button-warning\"\n                    (click)=\"deleteRegion(paginatorFirst + shapeIdx)\"></button>\n          </td>\n        </tr>\n      </ng-template>\n    </p-table>\n</div>\n\n<p-paginator *ngIf=\"regions.length > 0\"\n             [rows]=\"paginatorRows\" [totalRecords]=\"regions.length\"\n             [first]=\"paginatorFirst\"\n             [rowsPerPageOptions]=\"rowsPerPageOptions\"\n             [showCurrentPageReport]=\"true\"\n             currentPageReportTemplate=\"{first} to {last} of {totalRecords}\"\n             (onPageChange)=\"onPageChange($event)\"\n             styleClass=\"region-editor-paginator\">\n</p-paginator>\n\n<!-- Live-edit mode: no Save/Cancel — every edit commits immediately to the\n     active image's region cache. -->\n\n\n<p-confirmDialog #cd [style]=\"{width: '24rem', height: '14rem'}\" key=\"positionDialog\"\n                 [baseZIndex]=\"10000\" rejectButtonStyleClass=\"p-button-outlined\">\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button type=\"button\" class=\"p-button-outlined\" pButton icon=\"pi pi-times\" label=\"No\"\n            (click)=\"cd.reject()\"></button>\n  </ng-template>\n</p-confirmDialog>\n\n<p-dialog header=\"Save Regions As\" [(visible)]=\"showSaveAsDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\"\n          [closable]=\"!saveAsBusy\" [closeOnEscape]=\"!saveAsBusy\">\n  <!-- Idle: filename + overwrite warning. -->\n  <div *ngIf=\"!saveAsBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"geojson-filename\" class=\"font-medium\">GeoJSON filename</label>\n    <input id=\"geojson-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"saveAsFilename\"\n           (ngModelChange)=\"checkSaveAsFileExists()\"\n           class=\"w-full\" />\n    <small *ngIf=\"saveAsFileExists\" class=\"p-error\">\n      <i class=\"pi pi-exclamation-triangle mr-1\"></i>\n      This file already exists and will be overwritten.\n    </small>\n  </div>\n\n  <!-- Busy: progress while regions serialize + upload. -->\n  <div *ngIf=\"saveAsBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <span>Saving regions…</span>\n    <p-progressBar mode=\"indeterminate\" [style]=\"{height: '0.75rem'}\"></p-progressBar>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button *ngIf=\"!saveAsBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showSaveAsDialog = false\"></p-button>\n    <p-button *ngIf=\"!saveAsBusy\" label=\"Save\" icon=\"pi pi-save\"\n              [disabled]=\"!saveAsFilename || !saveAsFilename.trim()\"\n              (onClick)=\"confirmSaveAs()\"></p-button>\n    <p-button *ngIf=\"saveAsBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"cancelSaveAs()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Export Regions\" [(visible)]=\"showExportDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"export-filename\" class=\"font-medium\">GeoJSON filename</label>\n    <input id=\"export-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"exportFilename\"\n           class=\"w-full\" />\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showExportDialog = false\"></p-button>\n    <p-button label=\"Export\" icon=\"pi pi-download\"\n              [disabled]=\"!exportFilename || !exportFilename.trim()\"\n              (onClick)=\"confirmExport()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Save Mask\" [(visible)]=\"showSaveMaskDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '30rem'}\" [draggable]=\"false\" [resizable]=\"false\"\n          [closable]=\"!maskBusy\" [closeOnEscape]=\"!maskBusy\">\n  <!-- Idle: filename + mask-type form. -->\n  <div *ngIf=\"!maskBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <label for=\"mask-filename\" class=\"font-medium\">Mask filename</label>\n    <input id=\"mask-filename\" type=\"text\" pInputText\n           [(ngModel)]=\"saveMaskFilename\"\n           class=\"w-full\" />\n    <span class=\"font-medium\">Mask type</span>\n    <div class=\"flex align-items-center gap-2\">\n      <p-radioButton inputId=\"mask-binary\" name=\"maskMode\" value=\"binary\"\n                     [(ngModel)]=\"maskMode\"></p-radioButton>\n      <label for=\"mask-binary\">Binary <span class=\"text-color-secondary\">(regions 1, background 0)</span></label>\n    </div>\n    <div class=\"flex align-items-center gap-2\">\n      <p-radioButton inputId=\"mask-multiclass\" name=\"maskMode\" value=\"multiclass\"\n                     [(ngModel)]=\"maskMode\"></p-radioButton>\n      <label for=\"mask-multiclass\">Multi-class <span class=\"text-color-secondary\">(unique id per region, background 0)</span></label>\n    </div>\n  </div>\n\n  <!-- Busy: progress while the worker rasterizes + encodes the PNG. -->\n  <div *ngIf=\"maskBusy\" class=\"flex flex-column gap-3 pt-2\">\n    <span>{{ maskEncoding ? 'Encoding PNG…' : 'Rasterizing regions…' }}</span>\n    <p-progressBar [mode]=\"maskEncoding ? 'indeterminate' : 'determinate'\"\n                   [value]=\"maskProgress\"\n                   [style]=\"{height: '0.75rem'}\"></p-progressBar>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button *ngIf=\"!maskBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"showSaveMaskDialog = false\"></p-button>\n    <p-button *ngIf=\"!maskBusy\" label=\"Download\" icon=\"pi pi-download\"\n              [disabled]=\"!saveMaskFilename || !saveMaskFilename.trim()\"\n              (onClick)=\"confirmSaveMask()\"></p-button>\n    <p-button *ngIf=\"maskBusy\" label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\"\n              (onClick)=\"cancelSaveMask()\"></p-button>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Region colour\" [(visible)]=\"showColorDialog\" [modal]=\"false\" appendTo=\"body\"\n          [style]=\"{width: '24rem'}\" [draggable]=\"true\" [resizable]=\"false\">\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <span>Outline colour per class for the\n      <b>{{ selectedRegions?.length || 0 }}</b> selected region(s):</span>\n    <div *ngFor=\"let edit of classColorEdits; let i = index\"\n         class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium flex-1\">{{ edit.label || 'Unclassified' }}</span>\n      <hex-color-picker [color]=\"edit.color\"\n                        (colorChange)=\"classColorEdits[i].color = $event\"></hex-color-picker>\n    </div>\n  </div>\n  <ng-template pTemplate=\"footer\">\n    <p-button label=\"Cancel\" icon=\"pi pi-times\" [text]=\"true\" (onClick)=\"showColorDialog = false\">\n    </p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"applyColorToSelected()\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): CRUD + fallback palette + matching/auto-add\n     settings + reset/import/export. Edits a working copy, committed on Apply/Done. -->\n<p-dialog header=\"Manage annotation classes\" [(visible)]=\"showManageDialog\" [modal]=\"true\" appendTo=\"body\"\n          [style]=\"{width: '34rem'}\" [draggable]=\"true\" [resizable]=\"false\">\n  <div *ngIf=\"presetDraft\" class=\"manage-dialog flex flex-column gap-3 pt-2\">\n    <div class=\"manage-classes flex flex-column gap-2\">\n      <div *ngFor=\"let c of presetDraft.classes; let i = index\"\n           class=\"manage-class-row flex align-items-center gap-2\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"c.color = $event\"></hex-color-picker>\n        <input type=\"text\" pInputText class=\"p-inputtext-sm flex-1\"\n               [(ngModel)]=\"c.name\" placeholder=\"Class name\"/>\n        <button pButton type=\"button\" icon=\"pi pi-trash\"\n                class=\"p-button-sm p-button-text p-button-warning\"\n                pTooltip=\"Remove class\" tooltipPosition=\"bottom\"\n                (click)=\"removePresetClass(i)\"></button>\n      </div>\n      <button pButton type=\"button\" icon=\"pi pi-plus\" label=\"Add class\"\n              class=\"p-button-sm p-button-text align-self-start\" (click)=\"addPresetClass()\"></button>\n    </div>\n\n    <div class=\"manage-section flex flex-column gap-2\">\n      <span class=\"section-title font-medium\">Fallback palette\n        <small class=\"text-color-secondary\">— colours for classes not listed</small></span>\n      <div class=\"fallback-palette flex align-items-center flex-wrap gap-2\">\n        <span *ngFor=\"let col of presetDraft.fallbackPalette; let i = index\"\n              class=\"fallback-swatch flex align-items-center\">\n          <hex-color-picker [color]=\"col\" (colorChange)=\"presetDraft.fallbackPalette[i] = $event\"></hex-color-picker>\n          <i class=\"pi pi-times icon-hover ml-1\" pTooltip=\"Remove\" tooltipPosition=\"bottom\"\n             (click)=\"removeFallbackColor(i)\"></i>\n        </span>\n        <button pButton type=\"button\" icon=\"pi pi-plus\"\n                class=\"p-button-sm p-button-text\" pTooltip=\"Add fallback colour\"\n                tooltipPosition=\"bottom\" (click)=\"addFallbackColor()\"></button>\n      </div>\n    </div>\n\n    <div class=\"flex align-items-center gap-2\">\n      <p-checkbox [(ngModel)]=\"presetDraft.autoPromote\" [binary]=\"true\" inputId=\"autoPromote\"></p-checkbox>\n      <label for=\"autoPromote\">Auto-add detected classes to this list as they appear</label>\n    </div>\n\n    <div class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium\">Label matching</span>\n      <p-selectButton [options]=\"matchModeOptions\" [(ngModel)]=\"presetDraft.matchMode\"\n                      optionLabel=\"label\" optionValue=\"value\"></p-selectButton>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"manage-footer flex align-items-center flex-wrap gap-2 w-full\">\n      <span class=\"flex align-items-center flex-wrap gap-1\">\n        <p-button label=\"Reset\" icon=\"pi pi-refresh\" [text]=\"true\"\n                  (onClick)=\"resetPresetsToDefaults()\"></p-button>\n        <p-button label=\"Import\" icon=\"pi pi-upload\" [text]=\"true\"\n                  (onClick)=\"presetFileInput.click()\"></p-button>\n        <input #presetFileInput type=\"file\" accept=\".json,application/json\" hidden\n               (change)=\"importPresets($event); presetFileInput.value = ''\"/>\n        <p-button label=\"Export\" icon=\"pi pi-download\" [text]=\"true\"\n                  (onClick)=\"exportPresets()\"></p-button>\n      </span>\n      <span class=\"flex-1\"></span>\n      <!-- Apply persists to the server and closes; it replaces the old Apply+Done pair. -->\n      <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"applyManageDialog(true)\"></p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n\n<p-dialog header=\"Region editor help\" [(visible)]=\"displayHelpDialog\" [style]=\"{width: '50vw'}\"\n          [maximizable]=\"true\" [draggable]=\"true\" appendTo=\"body\">\n  <p>\n    The Region Editor lists every region drawn on the currently displayed image.\n    Open it with the\n    <img src=\"assets/plotting/region-editor.svg\" width=\"14\" height=\"14\" alt=\"Region Editor\"/>\n    button in the diagram toolbar: it opens as a floating dialog you can drag,\n    resize, and leave open while you draw on the image.\n    Regions are tracked <b>per image</b>: switching to another image hides\n    these and shows that image's regions; switching back restores them.\n    Edits in the table apply <b>live</b> to the diagram — there is no save or\n    cancel.\n  </p>\n\n  <h3>Creating regions</h3>\n  <p>\n    Use the diagram toolbar tools to draw new regions:\n    <i class=\"pi pi-stop\"></i> rectangle,\n    <object data=\"assets/icons/polyline.svg\" width=\"14\" height=\"14\"></object> polyline,\n    <i class=\"pi pi-pencil\"></i> freeform path, brush, or\n    <object data=\"assets/icons/wand.svg\" width=\"14\" height=\"14\"></object> wand.\n    Anything you draw appears immediately in the table, with the class name\n    \"<b>Region</b>\" by default.\n  </p>\n\n  <h3>The table columns</h3>\n  <ul>\n    <li><b>Class</b> — the region's class. Pick a class from the dropdown (its\n      colour follows), or use the <i class=\"pi pi-pencil\"></i> for a free-form name.</li>\n    <li><b>Surface</b> — the region's area, in µm²/mm² when the image carries a\n      physical pixel size, otherwise in px². Holes (donuts) and multi-part\n      regions are accounted for.</li>\n    <li>The trash icon at the end of a row deletes that one region.</li>\n    <li>Use \"<b>x512</b>\" to round all rectangle widths/heights to the\n      nearest multiple of 512.</li>\n  </ul>\n  <p>Region geometry is edited on the diagram itself (drag vertices, the vertex\n    tools, brush/wand, and the right-click region actions), not in this table.</p>\n\n  <h3>Selecting rows</h3>\n  <ul>\n    <li>Click a row to select it. The corresponding region is highlighted in the\n      diagram (Plotly shows its edit handles; the OpenSeadragon image view\n      highlights it and shows its handles in select mode).</li>\n    <li><kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+click to add or remove a row from the\n      selection. <kbd>Shift</kbd>+click to extend the selection in a range.</li>\n    <li>Selecting a region in the diagram highlights the matching row in the\n      table.</li>\n    <li>Clicks on the colour picker, the trash icon, or the active class-edit\n      input do not change the selection — that's standard PrimeNG behaviour.</li>\n  </ul>\n\n  <h3>Bulk actions on the selected rows</h3>\n  <ul>\n    <li><i class=\"pi pi-check-square\"></i> Select every region in the table at once (also a\n      right-click action on the image).</li>\n    <li><i class=\"pi pi-tags\"></i> Edit the label on every selected row at once.</li>\n    <li><i class=\"pi pi-trash\"></i> Delete every selected region — both from\n      the table and the diagram.</li>\n    <li><i class=\"pi pi-times-circle\"></i> Delete every region on this image.</li>\n  </ul>\n\n  <h3>Annotation classes &amp; colours (presets)</h3>\n  <p>\n    Preset a class once — a <b>name</b> and a <b>colour</b> — and every region with\n    that class name is drawn in that colour, <b>including regions loaded from a\n    GeoJSON later</b>. The preset colour is the source of truth: on load it\n    <b>overrides the colour stored in the file</b>, so a given annotation type always\n    looks the same across images and sessions.\n  </p>\n  <p>Set up your classes in the annotation-class manager —\n    <i class=\"pi pi-cog\"></i> <b>Manage</b>:</p>\n  <ol>\n    <li><b>Add class</b>, then type the class <b>name exactly as it appears in your\n      data</b> (e.g. <code>Tumor</code>) and pick its <b>colour</b> from the swatch.\n      Repeat for each class.</li>\n    <li>Optionally: edit the <b>fallback palette</b> (colours given to classes that\n      aren't in your list), toggle <b>auto-add</b> (adds unmatched classes found on\n      load), and choose <b>exact</b> vs. <b>normalized</b> name matching — normalized\n      ignores case and surrounding spaces, so <code>tumor</code> matches\n      <code>Tumor</code>.</li>\n    <li><b>Apply.</b> Presets are saved <b>per user</b> on the server, so they follow\n      you across images and sessions. You can also <b>reset to defaults</b> or\n      <b>import / export</b> the set as JSON to share it.</li>\n  </ol>\n  <p>\n    Next time you open or <i class=\"pi pi-upload\"></i> import a GeoJSON whose regions\n    carry those class names, each region is shown in its preset colour automatically —\n    no re-colouring needed. A class that isn't in your list instead gets a stable\n    colour from the fallback palette.\n  </p>\n  <p>Day to day:</p>\n  <ul>\n    <li>The <b>class strip</b> above the table lists your presets with their colours.\n      Click a class to make it <b>active</b> (new regions inherit it); with rows\n      selected, clicking a class re-classifies them.</li>\n    <li>The <b>Class</b> column dropdown re-classifies one region to a preset (its\n      colour follows), or use the <i class=\"pi pi-pencil\"></i> for a free-form name.</li>\n    <li>Recolour a class from its swatch (class strip or Manage) and every region of\n      that class updates at once.</li>\n    <li>Deleting a class reassigns its regions to the default <b>Region</b> class.</li>\n    <li>A colour you set on a <b>single</b> region (<i class=\"pi pi-palette\"></i>\n      Selected regions) is kept and is not overridden by its class.</li>\n  </ul>\n\n  <h3>Region actions (right-click the diagram)</h3>\n  <p>Right-click a region — or the current multi-selection — on the diagram for\n    the \"Selected region(s)\" actions:</p>\n  <ul>\n    <li><b>Merge / group</b> — combine 2+ selected regions into one (it may end\n      up multi-part if the pieces don't touch).</li>\n    <li><b>Ungroup</b> — split a multi-part region back into separate regions.</li>\n    <li><b>Inverse</b> — replace the selection with everything outside it (the\n      regions become holes in the image rectangle).</li>\n    <li><b>Simplify</b> — reduce the vertex count (Douglas–Peucker) by a pixel\n      threshold; pick a preset or a custom value.</li>\n    <li><b>Convert to Bézier / to polygon</b> and <b>Delete</b>.</li>\n  </ul>\n\n  <h3>Display options</h3>\n  <ul>\n    <li><i class=\"pi pi-tag\"></i> Toggle showing class labels on every\n      region in the diagram (slower with many regions).</li>\n  </ul>\n\n  <h3>Import / export</h3>\n  <ul>\n    <li><i class=\"pi pi-upload\"></i> Import regions from a GeoJSON file.</li>\n    <li><i class=\"pi pi-download\"></i> Export the current image's regions to\n      a GeoJSON file. (The per-image cache is in-memory only — exporting is\n      how you persist regions across sessions.)</li>\n  </ul>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button icon=\"pi pi-check\" (click)=\"displayHelpDialog=false\" label=\"Ok\" styleClass=\"p-button-text\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n\n"]}