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

package/esm2022/lib/region-editor/mask-export.service.mjs

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { maskScaleFor, regionToParts, scaleParts } from './mask-raster';
+import * as i0 from "@angular/core";
+/**
+ * Rasterizes regions to a label-mask PNG in a Web Worker (jit-ui#95), so the
+ * full-resolution rasterize and PNG encode never freeze the UI and the job can
+ * be cancelled. Component-agnostic: {@link export} returns a cold Observable —
+ * subscribing starts a worker, unsubscribing terminates it (cancel), and a
+ * worker failure is an error carrying a user-facing message. Whole-slide
+ * images are capped to a safe pixel budget (the geometry is scaled to match).
+ */
+export class MaskExportService {
+    export(request) {
+        return new Observable((subscriber) => {
+            const { imageSize: size } = request;
+            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));
+            subscriber.next({ type: 'planned', width, height, scale });
+            const payload = {
+                width,
+                height,
+                originalWidth: size.width,
+                originalHeight: size.height,
+                scale,
+                mode: request.mode,
+                sourceName: request.sourceName,
+                regions: request.regions.map((r) => scaleParts(regionToParts(r), scale)),
+            };
+            let worker;
+            let closed = false;
+            const stop = () => {
+                worker?.terminate();
+                worker = undefined;
+            };
+            const fail = (message) => {
+                stop();
+                subscriber.error(new Error(message));
+            };
+            // The worker is created asynchronously; a cancel while it loads
+            // terminates it as soon as it resolves, before it is sent any work.
+            this.createWorker()
+                .then((w) => {
+                if (closed) {
+                    w.terminate();
+                    return;
+                }
+                worker = w;
+                w.onmessage = ({ data }) => {
+                    switch (data?.type) {
+                        case 'progress':
+                            subscriber.next({
+                                type: 'progress',
+                                percent: data.total ? Math.round((data.done / data.total) * 100) : 0,
+                            });
+                            break;
+                        case 'encoding':
+                            subscriber.next({ type: 'encoding' });
+                            break;
+                        case 'done':
+                            stop();
+                            subscriber.next({ type: 'done', blob: new Blob([data.png], { type: 'image/png' }) });
+                            subscriber.complete();
+                            break;
+                        case 'error':
+                            fail(data.error || 'The mask could not be generated.');
+                            break;
+                    }
+                };
+                w.onerror = () => fail('The mask worker failed.');
+                w.postMessage(payload);
+            })
+                .catch(() => {
+                if (!closed)
+                    fail('The mask worker failed to start.');
+            });
+            return () => {
+                closed = true;
+                stop();
+            };
+        });
+    }
+    /** Worker factory: a dynamic import, so the worker module (and its
+     *  `import.meta.url`, which the CommonJS test compile rejects) loads lazily.
+     *  Overridable in tests. */
+    async createWorker() {
+        const { createMaskWorker } = await import('./mask-worker');
+        return createMaskWorker();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: MaskExportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: MaskExportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: MaskExportService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mask-export.service.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/mask-export.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { Region } from '../models/region';\nimport { maskScaleFor, regionToParts, scaleParts } from './mask-raster';\n\n/** Mask type: one foreground value, or a distinct id per region. */\nexport type MaskMode = 'binary' | 'multiclass';\n\n/** What to rasterize, at the full image size. */\nexport interface MaskExportRequest {\n  regions: Region[];\n  imageSize: { width: number; height: number };\n  mode: MaskMode;\n  /** Recorded in the PNG metadata. */\n  sourceName?: string;\n}\n\n/** Progress of one mask export, in order: planned → progress* → encoding → done. */\nexport type MaskExportEvent =\n  /** The mask size; `scale` < 1 when the image exceeds the pixel budget. */\n  | { type: 'planned'; width: number; height: number; scale: number }\n  /** 0–100 rasterization progress. */\n  | { type: 'progress'; percent: number }\n  /** Rasterizing finished; the PNG is being encoded. */\n  | { type: 'encoding' }\n  | { type: 'done'; blob: Blob };\n\n/**\n * Rasterizes regions to a label-mask PNG in a Web Worker (jit-ui#95), so the\n * full-resolution rasterize and PNG encode never freeze the UI and the job can\n * be cancelled. Component-agnostic: {@link export} returns a cold Observable —\n * subscribing starts a worker, unsubscribing terminates it (cancel), and a\n * worker failure is an error carrying a user-facing message. Whole-slide\n * images are capped to a safe pixel budget (the geometry is scaled to match).\n */\n@Injectable({ providedIn: 'root' })\nexport class MaskExportService {\n  export(request: MaskExportRequest): Observable<MaskExportEvent> {\n    return new Observable<MaskExportEvent>((subscriber) => {\n      const { imageSize: size } = request;\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      subscriber.next({ type: 'planned', width, height, scale });\n\n      const payload = {\n        width,\n        height,\n        originalWidth: size.width,\n        originalHeight: size.height,\n        scale,\n        mode: request.mode,\n        sourceName: request.sourceName,\n        regions: request.regions.map((r) => scaleParts(regionToParts(r), scale)),\n      };\n\n      let worker: Worker | undefined;\n      let closed = false;\n      const stop = () => {\n        worker?.terminate();\n        worker = undefined;\n      };\n      const fail = (message: string) => {\n        stop();\n        subscriber.error(new Error(message));\n      };\n\n      // The worker is created asynchronously; a cancel while it loads\n      // terminates it as soon as it resolves, before it is sent any work.\n      this.createWorker()\n        .then((w) => {\n          if (closed) {\n            w.terminate();\n            return;\n          }\n          worker = w;\n          w.onmessage = ({ data }: MessageEvent) => {\n            switch (data?.type) {\n              case 'progress':\n                subscriber.next({\n                  type: 'progress',\n                  percent: data.total ? Math.round((data.done / data.total) * 100) : 0,\n                });\n                break;\n              case 'encoding':\n                subscriber.next({ type: 'encoding' });\n                break;\n              case 'done':\n                stop();\n                subscriber.next({ type: 'done', blob: new Blob([data.png], { type: 'image/png' }) });\n                subscriber.complete();\n                break;\n              case 'error':\n                fail(data.error || 'The mask could not be generated.');\n                break;\n            }\n          };\n          w.onerror = () => fail('The mask worker failed.');\n          w.postMessage(payload);\n        })\n        .catch(() => {\n          if (!closed) fail('The mask worker failed to start.');\n        });\n\n      return () => {\n        closed = true;\n        stop();\n      };\n    });\n  }\n\n  /** Worker factory: a dynamic import, so the worker module (and its\n   *  `import.meta.url`, which the CommonJS test compile rejects) loads lazily.\n   *  Overridable in tests. */\n  protected async createWorker(): Promise<Worker> {\n    const { createMaskWorker } = await import('./mask-worker');\n    return createMaskWorker();\n  }\n}\n"]}

package/esm2022/lib/region-editor/mask-raster.mjs

@@ -32,10 +32,12 @@ export function scaleParts(parts, scale) {
 export function regionToParts(region) {
     const b = region.bounds;
     if (b instanceof Rectangle) {
-        return [{
+        return [
+            {
                 xpoints: [b.x, b.x + b.width, b.x + b.width, b.x],
                 ypoints: [b.y, b.y, b.y + b.height, b.y + b.height],
-            }];
+            },
+        ];
     }
     if (b instanceof Polygon) {
         return [{ xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes }];
@@ -79,10 +81,14 @@ export function regionsToMask(regions, imageWidth, imageHeight, mode, rasterize,
             if (!m)
                 continue;
             painted = true;
-            for (let y = 0; y < m.bh; y++) {
+            // The raster keeps a region's full extent: paint only its part inside the image (a row
+            // offset past either side would wrap into the neighbouring row).
+            const x0 = Math.max(0, -m.bx), x1 = Math.min(m.bw, W - m.bx);
+            const y0 = Math.max(0, -m.by), y1 = Math.min(m.bh, H - m.by);
+            for (let y = y0; y < y1; y++) {
                 const srcRow = y * m.bw;
                 const dstRow = (m.by + y) * W + m.bx;
-                for (let x = 0; x < m.bw; x++) {
+                for (let x = x0; x < x1; x++) {
                     if (m.mask[srcRow + x])
                         out[dstRow + x] = value;
                 }
@@ -92,4 +98,4 @@ export function regionsToMask(regions, imageWidth, imageHeight, mode, rasterize,
     }
     return painted ? { data: out, bitDepth } : null;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mask-raster.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/mask-raster.ts"],"names":[],"mappings":"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","sourcesContent":["import { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';\n\n/** A single closed ring (+ optional holes) in image-pixel coordinates. A region\n *  rasterizes as the union of its parts. Plain data so it survives a\n *  `postMessage` structured clone into the mask worker. */\nexport interface MaskPart {\n  xpoints: number[];\n  ypoints: number[];\n  holes?: number[][][];\n}\n\n/** A bbox-relative binary mask, as returned by `WandService.rasterizePolygon`. */\nexport interface BBoxMask {\n  bx: number;\n  by: number;\n  bw: number;\n  bh: number;\n  mask: Uint8Array;\n}\n\n/** Polygon-fill function (the wand's scanline rasterizer), injected so this\n *  module stays free of Angular/DOM and can run inside a worker. */\nexport type RasterizeFn = (\n  xpoints: number[],\n  ypoints: number[],\n  imageWidth: number,\n  imageHeight: number,\n  holes?: number[][][],\n) => BBoxMask | null;\n\n/**\n * The largest mask we will allocate, in pixels. A single-channel 8-bit mask is\n * one byte per pixel, so this is also its byte size. Whole-slide level-0 images\n * (e.g. 119040×90112 ≈ 1.07e10 px) blow past both the JS typed-array length cap\n * (~4.29e9) and available memory, so masks for images larger than this are\n * rasterized at a proportionally downscaled resolution. ~100 MP ≈ 100 MB.\n */\nexport const MAX_MASK_PIXELS = 100_000_000;\n\n/** Downscale factor (≤ 1) to keep `width * height` within {@link MAX_MASK_PIXELS}.\n *  1 when the image already fits. */\nexport function maskScaleFor(width: number, height: number): number {\n  const total = width * height;\n  if (!Number.isFinite(total) || total <= MAX_MASK_PIXELS) return 1;\n  return Math.sqrt(MAX_MASK_PIXELS / total);\n}\n\n/** Multiply every coordinate (and hole coordinate) of a region's parts by\n *  `scale`, for rasterizing into a downscaled mask. Returns the parts unchanged\n *  when `scale` is 1. */\nexport function scaleParts(parts: MaskPart[], scale: number): MaskPart[] {\n  if (scale === 1) return parts;\n  return parts.map((p) => ({\n    xpoints: p.xpoints.map((x) => x * scale),\n    ypoints: p.ypoints.map((y) => y * scale),\n    holes: p.holes?.map((ring) => ring.map(([x, y]) => [x * scale, y * scale])),\n  }));\n}\n\n/** Flatten a region's geometry to plain rings. Rectangles become a 4-point ring;\n *  polygons keep their points + holes; multi-polygons expand to one part each. */\nexport function regionToParts(region: Region): MaskPart[] {\n  const b = region.bounds;\n  if (b instanceof Rectangle) {\n    return [{\n      xpoints: [b.x, b.x + b.width, b.x + b.width, b.x],\n      ypoints: [b.y, b.y, b.y + b.height, b.y + b.height],\n    }];\n  }\n  if (b instanceof Polygon) {\n    return [{ xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes }];\n  }\n  if (b instanceof MultiPolygon) {\n    return b.polygons.map((p) => ({ xpoints: p.xpoints, ypoints: p.ypoints, holes: p.holes }));\n  }\n  return [];\n}\n\n/** A rasterized label mask plus the PNG bit depth it should be encoded at. */\nexport interface LabelMask {\n  data: Uint8Array | Uint16Array;\n  /** 8 for ≤255 distinct values, 16 for a multi-class mask with >255 regions. */\n  bitDepth: 8 | 16;\n}\n\n/**\n * Rasterize regions (as plain parts) to a full image-size label mask (row-major,\n * `W * H` samples; pixel `(x, y)` at `y * W + x`). Background is 0.\n *\n * - `'binary'` — every region pixel is 255 (standard 8-bit black/white mask:\n *   `> 0` = foreground; also directly viewable).\n * - `'multiclass'` — each region gets a distinct 1-based id (its index + 1).\n *   Stays 8-bit for ≤255 regions; promotes to 16-bit beyond that. Ids are\n *   distinct up to the 16-bit ceiling (65535 regions); a selection larger than\n *   that exceeds the PNG's representable range and ids wrap (not a realistic\n *   hand-annotation case, but called out so the limit is explicit).\n *\n * Later regions paint over earlier ones where they overlap. `onProgress` is\n * called after each region (1-based) so a caller can drive a progress bar.\n * Returns null when nothing rasterises (no regions, zero/insane size).\n */\nexport function regionsToMask(\n  regions: MaskPart[][],\n  imageWidth: number,\n  imageHeight: number,\n  mode: 'binary' | 'multiclass',\n  rasterize: RasterizeFn,\n  onProgress?: (done: number, total: number) => void,\n): LabelMask | null {\n  const W = Math.round(imageWidth);\n  const H = Math.round(imageHeight);\n  if (!Number.isFinite(W) || !Number.isFinite(H) || W <= 0 || H <= 0 || !regions?.length) {\n    return null;\n  }\n\n  const multiclass = mode === 'multiclass';\n  const bitDepth: 8 | 16 = multiclass && regions.length > 255 ? 16 : 8;\n  const out: Uint8Array | Uint16Array =\n    bitDepth === 16 ? new Uint16Array(W * H) : new Uint8Array(W * H);\n  let painted = false;\n  for (let i = 0; i < regions.length; i++) {\n    // Binary → 255 (viewable, standard). Multi-class → 1-based class id.\n    const value = multiclass ? i + 1 : 255;\n    for (const part of regions[i]) {\n      const m = rasterize(part.xpoints, part.ypoints, W, H, part.holes);\n      if (!m) continue;\n      painted = true;\n      for (let y = 0; y < m.bh; y++) {\n        const srcRow = y * m.bw;\n        const dstRow = (m.by + y) * W + m.bx;\n        for (let x = 0; x < m.bw; x++) {\n          if (m.mask[srcRow + x]) out[dstRow + x] = value;\n        }\n      }\n    }\n    onProgress?.(i + 1, regions.length);\n  }\n  return painted ? { data: out, bitDepth } : null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mask-raster.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/mask-raster.ts"],"names":[],"mappings":"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","sourcesContent":["import { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';\nimport type { BBoxMask } from '../geometry/raster';\n\nexport type { BBoxMask };\n\n/** A single closed ring (+ optional holes) in image-pixel coordinates. A region\n *  rasterizes as the union of its parts. Plain data so it survives a\n *  `postMessage` structured clone into the mask worker. */\nexport interface MaskPart {\n  xpoints: number[];\n  ypoints: number[];\n  holes?: number[][][];\n}\n\n/** Polygon-fill function (the wand's scanline rasterizer), injected so this\n *  module stays free of Angular/DOM and can run inside a worker. */\nexport type RasterizeFn = (\n  xpoints: number[],\n  ypoints: number[],\n  imageWidth: number,\n  imageHeight: number,\n  holes?: number[][][],\n) => BBoxMask | null;\n\n/**\n * The largest mask we will allocate, in pixels. A single-channel 8-bit mask is\n * one byte per pixel, so this is also its byte size. Whole-slide level-0 images\n * (e.g. 119040×90112 ≈ 1.07e10 px) blow past both the JS typed-array length cap\n * (~4.29e9) and available memory, so masks for images larger than this are\n * rasterized at a proportionally downscaled resolution. ~100 MP ≈ 100 MB.\n */\nexport const MAX_MASK_PIXELS = 100_000_000;\n\n/** Downscale factor (≤ 1) to keep `width * height` within {@link MAX_MASK_PIXELS}.\n *  1 when the image already fits. */\nexport function maskScaleFor(width: number, height: number): number {\n  const total = width * height;\n  if (!Number.isFinite(total) || total <= MAX_MASK_PIXELS) return 1;\n  return Math.sqrt(MAX_MASK_PIXELS / total);\n}\n\n/** Multiply every coordinate (and hole coordinate) of a region's parts by\n *  `scale`, for rasterizing into a downscaled mask. Returns the parts unchanged\n *  when `scale` is 1. */\nexport function scaleParts(parts: MaskPart[], scale: number): MaskPart[] {\n  if (scale === 1) return parts;\n  return parts.map((p) => ({\n    xpoints: p.xpoints.map((x) => x * scale),\n    ypoints: p.ypoints.map((y) => y * scale),\n    holes: p.holes?.map((ring) => ring.map(([x, y]) => [x * scale, y * scale])),\n  }));\n}\n\n/** Flatten a region's geometry to plain rings. Rectangles become a 4-point ring;\n *  polygons keep their points + holes; multi-polygons expand to one part each. */\nexport function regionToParts(region: Region): MaskPart[] {\n  const b = region.bounds;\n  if (b instanceof Rectangle) {\n    return [\n      {\n        xpoints: [b.x, b.x + b.width, b.x + b.width, b.x],\n        ypoints: [b.y, b.y, b.y + b.height, b.y + b.height],\n      },\n    ];\n  }\n  if (b instanceof Polygon) {\n    return [{ xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes }];\n  }\n  if (b instanceof MultiPolygon) {\n    return b.polygons.map((p) => ({ xpoints: p.xpoints, ypoints: p.ypoints, holes: p.holes }));\n  }\n  return [];\n}\n\n/** A rasterized label mask plus the PNG bit depth it should be encoded at. */\nexport interface LabelMask {\n  data: Uint8Array | Uint16Array;\n  /** 8 for ≤255 distinct values, 16 for a multi-class mask with >255 regions. */\n  bitDepth: 8 | 16;\n}\n\n/**\n * Rasterize regions (as plain parts) to a full image-size label mask (row-major,\n * `W * H` samples; pixel `(x, y)` at `y * W + x`). Background is 0.\n *\n * - `'binary'` — every region pixel is 255 (standard 8-bit black/white mask:\n *   `> 0` = foreground; also directly viewable).\n * - `'multiclass'` — each region gets a distinct 1-based id (its index + 1).\n *   Stays 8-bit for ≤255 regions; promotes to 16-bit beyond that. Ids are\n *   distinct up to the 16-bit ceiling (65535 regions); a selection larger than\n *   that exceeds the PNG's representable range and ids wrap (not a realistic\n *   hand-annotation case, but called out so the limit is explicit).\n *\n * Later regions paint over earlier ones where they overlap. `onProgress` is\n * called after each region (1-based) so a caller can drive a progress bar.\n * Returns null when nothing rasterises (no regions, zero/insane size).\n */\nexport function regionsToMask(\n  regions: MaskPart[][],\n  imageWidth: number,\n  imageHeight: number,\n  mode: 'binary' | 'multiclass',\n  rasterize: RasterizeFn,\n  onProgress?: (done: number, total: number) => void,\n): LabelMask | null {\n  const W = Math.round(imageWidth);\n  const H = Math.round(imageHeight);\n  if (!Number.isFinite(W) || !Number.isFinite(H) || W <= 0 || H <= 0 || !regions?.length) {\n    return null;\n  }\n\n  const multiclass = mode === 'multiclass';\n  const bitDepth: 8 | 16 = multiclass && regions.length > 255 ? 16 : 8;\n  const out: Uint8Array | Uint16Array = bitDepth === 16 ? new Uint16Array(W * H) : new Uint8Array(W * H);\n  let painted = false;\n  for (let i = 0; i < regions.length; i++) {\n    // Binary → 255 (viewable, standard). Multi-class → 1-based class id.\n    const value = multiclass ? i + 1 : 255;\n    for (const part of regions[i]) {\n      const m = rasterize(part.xpoints, part.ypoints, W, H, part.holes);\n      if (!m) continue;\n      painted = true;\n      // The raster keeps a region's full extent: paint only its part inside the image (a row\n      // offset past either side would wrap into the neighbouring row).\n      const x0 = Math.max(0, -m.bx),\n        x1 = Math.min(m.bw, W - m.bx);\n      const y0 = Math.max(0, -m.by),\n        y1 = Math.min(m.bh, H - m.by);\n      for (let y = y0; y < y1; y++) {\n        const srcRow = y * m.bw;\n        const dstRow = (m.by + y) * W + m.bx;\n        for (let x = x0; x < x1; x++) {\n          if (m.mask[srcRow + x]) out[dstRow + x] = value;\n        }\n      }\n    }\n    onProgress?.(i + 1, regions.length);\n  }\n  return painted ? { data: out, bitDepth } : null;\n}\n"]}

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

@@ -0,0 +1,56 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SharedModule } from 'primeng/api';
+import { ButtonModule } from 'primeng/button';
+import { DialogModule } from 'primeng/dialog';
+import { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "primeng/api";
+import * as i3 from "primeng/button";
+import * as i4 from "primeng/dialog";
+/**
+ * "Edit colour of selected regions": one picker per class among the selection.
+ * Edits a private copy of `edits` and reports the result on Apply; the editor
+ * applies it to the regions (copy-on-write) and commits.
+ */
+export class RegionColorDialogComponent {
+    constructor() {
+        /** The dialog is open. */
+        this.visible = false;
+        /** The dialog was closed (`false`); two-way with {@link visible}. */
+        this.visibleChange = new EventEmitter();
+        /** Number of selected regions, for the caption. */
+        this.selectedCount = 0;
+        /** Apply clicked: the edited colours per class. */
+        this.apply = new EventEmitter();
+        this.draft = [];
+    }
+    /** The seeded colours; the dialog edits a copy. */
+    set edits(value) {
+        this.draft = (value ?? []).map((e) => ({ ...e }));
+    }
+    setColor(i, color) {
+        this.draft = this.draft.map((e, k) => (k === i ? { ...e, color } : e));
+    }
+    close() {
+        this.visibleChange.emit(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionColorDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: RegionColorDialogComponent, isStandalone: true, selector: "region-color-dialog", inputs: { visible: "visible", selectedCount: "selectedCount", edits: "edits" }, outputs: { visibleChange: "visibleChange", apply: "apply" }, ngImport: i0, template: "<p-dialog\n  header=\"Region colour\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [modal]=\"false\"\n  appendTo=\"body\"\n  [style]=\"{ width: '24rem' }\"\n  [draggable]=\"true\"\n  [resizable]=\"false\"\n>\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <span\n      >Outline colour per class for the <b>{{ selectedCount }}</b> selected region(s):</span\n    >\n    <div *ngFor=\"let edit of draft; let i = index\" 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\" (colorChange)=\"setColor(i, $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)=\"close()\"> </p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"apply.emit(draft)\"> </p-button>\n  </ng-template>\n</p-dialog>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "ngmodule", type: SharedModule }, { kind: "directive", type: i2.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i3.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: "ngmodule", type: DialogModule }, { kind: "component", type: i4.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: HexColorPickerComponent, selector: "hex-color-picker", inputs: ["color"], outputs: ["colorChange", "colorInput"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionColorDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'region-color-dialog', standalone: true, imports: [CommonModule, SharedModule, ButtonModule, DialogModule, HexColorPickerComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: "<p-dialog\n  header=\"Region colour\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [modal]=\"false\"\n  appendTo=\"body\"\n  [style]=\"{ width: '24rem' }\"\n  [draggable]=\"true\"\n  [resizable]=\"false\"\n>\n  <div class=\"flex flex-column gap-3 pt-2\">\n    <span\n      >Outline colour per class for the <b>{{ selectedCount }}</b> selected region(s):</span\n    >\n    <div *ngFor=\"let edit of draft; let i = index\" 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\" (colorChange)=\"setColor(i, $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)=\"close()\"> </p-button>\n    <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"apply.emit(draft)\"> </p-button>\n  </ng-template>\n</p-dialog>\n" }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }], selectedCount: [{
+                type: Input
+            }], edits: [{
+                type: Input
+            }], apply: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,28 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { SharedModule } from 'primeng/api';
+import { ButtonModule } from 'primeng/button';
+import { DialogModule } from 'primeng/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "primeng/button";
+import * as i3 from "primeng/dialog";
+/** The Region Editor's help dialog (static content). */
+export class RegionEditorHelpComponent {
+    constructor() {
+        /** The dialog is open. */
+        this.visible = false;
+        /** The dialog was closed (`false`); two-way with {@link visible}. */
+        this.visibleChange = new EventEmitter();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionEditorHelpComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: RegionEditorHelpComponent, isStandalone: true, selector: "region-editor-help", inputs: { visible: "visible" }, outputs: { visibleChange: "visibleChange" }, ngImport: i0, template: "<p-dialog\n  header=\"Region editor help\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [style]=\"{ width: '50vw' }\"\n  [maximizable]=\"true\"\n  [draggable]=\"true\"\n  appendTo=\"body\"\n>\n  <p>\n    The Region Editor lists every region drawn on the currently displayed image. 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, resize, and leave open while you\n    draw on the image. Regions are tracked <b>per image</b>: switching to another image hides these and shows that\n    image's regions; switching back restores them. Edits in the table apply <b>live</b> to the diagram \u2014 there is\n    no save or 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    <img src=\"assets/plotting/polyline.svg\" width=\"14\" height=\"14\" alt=\"\" /> polyline,\n    <i class=\"pi pi-pencil\"></i> freeform path, brush, or\n    <img src=\"assets/plotting/wand.svg\" width=\"14\" height=\"14\" alt=\"\" /> wand. Anything you draw appears\n    immediately in the table, with the class name \"<b>Region</b>\" by default.\n  </p>\n\n  <h3>The table columns</h3>\n  <ul>\n    <li>\n      <b>Class</b> \u2014 the region's class. Pick a class from the dropdown (its colour follows), or use the\n      <i class=\"pi pi-pencil\"></i> for a free-form name.\n    </li>\n    <li>\n      <b>Surface</b> \u2014 the region's area, in \u00B5m\u00B2/mm\u00B2 when the image carries a physical pixel size, otherwise in\n      px\u00B2. Holes (donuts) and multi-part regions are accounted for.\n    </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 nearest multiple of 512.</li>\n  </ul>\n  <p>\n    Region geometry is edited on the diagram itself (drag vertices, the vertex tools, brush/wand, and the\n    right-click region actions), not in this table.\n  </p>\n\n  <h3>Selecting rows</h3>\n  <ul>\n    <li>\n      Click a row to select it. The corresponding region is highlighted in the diagram (Plotly shows its edit\n      handles; the OpenSeadragon image view highlights it and shows its handles in select mode).\n    </li>\n    <li>\n      <kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+click to add or remove a row from the selection. <kbd>Shift</kbd>+click to\n      extend the selection in a range.\n    </li>\n    <li>Selecting a region in the diagram highlights the matching row in the table.</li>\n    <li>\n      Clicks on the colour picker, the trash icon, or the active class-edit input do not change the selection \u2014\n      that's standard PrimeNG behaviour.\n    </li>\n  </ul>\n\n  <h3>Bulk actions on the selected rows</h3>\n  <ul>\n    <li>\n      <i class=\"pi pi-check-square\"></i> Select every region in the table at once (also a right-click action on the\n      image).\n    </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 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 that class name is drawn in\n    that colour, <b>including regions loaded from a GeoJSON later</b>. The preset colour is the source of truth: on\n    load it <b>overrides the colour stored in the file</b>, so a given annotation type always looks the same across\n    images and sessions.\n  </p>\n  <p>Set up your classes in the annotation-class manager \u2014 <i class=\"pi pi-cog\"></i> <b>Manage</b>:</p>\n  <ol>\n    <li>\n      <b>Add class</b>, then type the class <b>name exactly as it appears in your data</b> (e.g.\n      <code>Tumor</code>) and pick its <b>colour</b> from the swatch. Repeat for each class.\n    </li>\n    <li>\n      Optionally: edit the <b>fallback palette</b> (colours given to classes that aren't in your list), toggle\n      <b>auto-add</b> (adds unmatched classes found on load), and choose <b>exact</b> vs. <b>normalized</b> name\n      matching \u2014 normalized ignores case and surrounding spaces, so <code>tumor</code> matches <code>Tumor</code>.\n    </li>\n    <li>\n      <b>Apply.</b> Presets are saved <b>per user</b> on the server, so they follow you across images and sessions.\n      You can also <b>reset to defaults</b> or <b>import / export</b> the set as JSON to share it.\n    </li>\n  </ol>\n  <p>\n    Next time you open or <i class=\"pi pi-upload\"></i> import a GeoJSON whose regions carry those class names, each\n    region is shown in its preset colour automatically \u2014 no re-colouring needed. A class that isn't in your list\n    instead gets a stable colour from the fallback palette.\n  </p>\n  <p>Day to day:</p>\n  <ul>\n    <li>\n      The <b>class strip</b> above the table lists your presets with their colours. Click a class to make it\n      <b>active</b> (new regions inherit it); with rows selected, clicking a class re-classifies them.\n    </li>\n    <li>\n      The <b>Class</b> column dropdown re-classifies one region to a preset (its colour follows), or use the\n      <i class=\"pi pi-pencil\"></i> for a free-form name.\n    </li>\n    <li>\n      Recolour a class from its swatch (class strip or Manage) and every region of that class updates at once.\n    </li>\n    <li>Deleting a class reassigns its regions to the default <b>Region</b> class.</li>\n    <li>\n      A colour you set on a <b>single</b> region (<i class=\"pi pi-palette\"></i> Selected regions) is kept and is\n      not overridden by its class.\n    </li>\n  </ul>\n\n  <h3>Region actions (right-click the diagram)</h3>\n  <p>\n    Right-click a region \u2014 or the current multi-selection \u2014 on the diagram for the \"Selected region(s)\" actions:\n  </p>\n  <ul>\n    <li>\n      <b>Merge / group</b> \u2014 combine 2+ selected regions into one (it may end up multi-part if the pieces don't\n      touch).\n    </li>\n    <li><b>Ungroup</b> \u2014 split a multi-part region back into separate regions.</li>\n    <li>\n      <b>Inverse</b> \u2014 replace the selection with everything outside it (the regions become holes in the image\n      rectangle).\n    </li>\n    <li>\n      <b>Simplify</b> \u2014 reduce the vertex count (Douglas\u2013Peucker) by a pixel threshold; pick a preset or a custom\n      value.\n    </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>\n      <i class=\"pi pi-tag\"></i> Toggle showing class labels on every region in the diagram (slower with many\n      regions).\n    </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>\n      <i class=\"pi pi-download\"></i> Export the current image's regions to a GeoJSON file. (The per-image cache is\n      in-memory only \u2014 exporting is how you persist regions across sessions.)\n    </li>\n  </ul>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button icon=\"pi pi-check\" (click)=\"visibleChange.emit(false)\" label=\"Ok\" styleClass=\"p-button-text\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n", styles: ["kbd{background:#e8e8e8;border:1px solid #bbb;border-radius:3px;padding:1px 5px;font-family:monospace;font-size:.85em}\n"], dependencies: [{ kind: "ngmodule", type: SharedModule }, { kind: "directive", type: i1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i2.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: "ngmodule", type: DialogModule }, { kind: "component", type: i3.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"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionEditorHelpComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'region-editor-help', standalone: true, imports: [SharedModule, ButtonModule, DialogModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<p-dialog\n  header=\"Region editor help\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [style]=\"{ width: '50vw' }\"\n  [maximizable]=\"true\"\n  [draggable]=\"true\"\n  appendTo=\"body\"\n>\n  <p>\n    The Region Editor lists every region drawn on the currently displayed image. 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, resize, and leave open while you\n    draw on the image. Regions are tracked <b>per image</b>: switching to another image hides these and shows that\n    image's regions; switching back restores them. Edits in the table apply <b>live</b> to the diagram \u2014 there is\n    no save or 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    <img src=\"assets/plotting/polyline.svg\" width=\"14\" height=\"14\" alt=\"\" /> polyline,\n    <i class=\"pi pi-pencil\"></i> freeform path, brush, or\n    <img src=\"assets/plotting/wand.svg\" width=\"14\" height=\"14\" alt=\"\" /> wand. Anything you draw appears\n    immediately in the table, with the class name \"<b>Region</b>\" by default.\n  </p>\n\n  <h3>The table columns</h3>\n  <ul>\n    <li>\n      <b>Class</b> \u2014 the region's class. Pick a class from the dropdown (its colour follows), or use the\n      <i class=\"pi pi-pencil\"></i> for a free-form name.\n    </li>\n    <li>\n      <b>Surface</b> \u2014 the region's area, in \u00B5m\u00B2/mm\u00B2 when the image carries a physical pixel size, otherwise in\n      px\u00B2. Holes (donuts) and multi-part regions are accounted for.\n    </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 nearest multiple of 512.</li>\n  </ul>\n  <p>\n    Region geometry is edited on the diagram itself (drag vertices, the vertex tools, brush/wand, and the\n    right-click region actions), not in this table.\n  </p>\n\n  <h3>Selecting rows</h3>\n  <ul>\n    <li>\n      Click a row to select it. The corresponding region is highlighted in the diagram (Plotly shows its edit\n      handles; the OpenSeadragon image view highlights it and shows its handles in select mode).\n    </li>\n    <li>\n      <kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+click to add or remove a row from the selection. <kbd>Shift</kbd>+click to\n      extend the selection in a range.\n    </li>\n    <li>Selecting a region in the diagram highlights the matching row in the table.</li>\n    <li>\n      Clicks on the colour picker, the trash icon, or the active class-edit input do not change the selection \u2014\n      that's standard PrimeNG behaviour.\n    </li>\n  </ul>\n\n  <h3>Bulk actions on the selected rows</h3>\n  <ul>\n    <li>\n      <i class=\"pi pi-check-square\"></i> Select every region in the table at once (also a right-click action on the\n      image).\n    </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 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 that class name is drawn in\n    that colour, <b>including regions loaded from a GeoJSON later</b>. The preset colour is the source of truth: on\n    load it <b>overrides the colour stored in the file</b>, so a given annotation type always looks the same across\n    images and sessions.\n  </p>\n  <p>Set up your classes in the annotation-class manager \u2014 <i class=\"pi pi-cog\"></i> <b>Manage</b>:</p>\n  <ol>\n    <li>\n      <b>Add class</b>, then type the class <b>name exactly as it appears in your data</b> (e.g.\n      <code>Tumor</code>) and pick its <b>colour</b> from the swatch. Repeat for each class.\n    </li>\n    <li>\n      Optionally: edit the <b>fallback palette</b> (colours given to classes that aren't in your list), toggle\n      <b>auto-add</b> (adds unmatched classes found on load), and choose <b>exact</b> vs. <b>normalized</b> name\n      matching \u2014 normalized ignores case and surrounding spaces, so <code>tumor</code> matches <code>Tumor</code>.\n    </li>\n    <li>\n      <b>Apply.</b> Presets are saved <b>per user</b> on the server, so they follow you across images and sessions.\n      You can also <b>reset to defaults</b> or <b>import / export</b> the set as JSON to share it.\n    </li>\n  </ol>\n  <p>\n    Next time you open or <i class=\"pi pi-upload\"></i> import a GeoJSON whose regions carry those class names, each\n    region is shown in its preset colour automatically \u2014 no re-colouring needed. A class that isn't in your list\n    instead gets a stable colour from the fallback palette.\n  </p>\n  <p>Day to day:</p>\n  <ul>\n    <li>\n      The <b>class strip</b> above the table lists your presets with their colours. Click a class to make it\n      <b>active</b> (new regions inherit it); with rows selected, clicking a class re-classifies them.\n    </li>\n    <li>\n      The <b>Class</b> column dropdown re-classifies one region to a preset (its colour follows), or use the\n      <i class=\"pi pi-pencil\"></i> for a free-form name.\n    </li>\n    <li>\n      Recolour a class from its swatch (class strip or Manage) and every region of that class updates at once.\n    </li>\n    <li>Deleting a class reassigns its regions to the default <b>Region</b> class.</li>\n    <li>\n      A colour you set on a <b>single</b> region (<i class=\"pi pi-palette\"></i> Selected regions) is kept and is\n      not overridden by its class.\n    </li>\n  </ul>\n\n  <h3>Region actions (right-click the diagram)</h3>\n  <p>\n    Right-click a region \u2014 or the current multi-selection \u2014 on the diagram for the \"Selected region(s)\" actions:\n  </p>\n  <ul>\n    <li>\n      <b>Merge / group</b> \u2014 combine 2+ selected regions into one (it may end up multi-part if the pieces don't\n      touch).\n    </li>\n    <li><b>Ungroup</b> \u2014 split a multi-part region back into separate regions.</li>\n    <li>\n      <b>Inverse</b> \u2014 replace the selection with everything outside it (the regions become holes in the image\n      rectangle).\n    </li>\n    <li>\n      <b>Simplify</b> \u2014 reduce the vertex count (Douglas\u2013Peucker) by a pixel threshold; pick a preset or a custom\n      value.\n    </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>\n      <i class=\"pi pi-tag\"></i> Toggle showing class labels on every region in the diagram (slower with many\n      regions).\n    </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>\n      <i class=\"pi pi-download\"></i> Export the current image's regions to a GeoJSON file. (The per-image cache is\n      in-memory only \u2014 exporting is how you persist regions across sessions.)\n    </li>\n  </ul>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button icon=\"pi pi-check\" (click)=\"visibleChange.emit(false)\" label=\"Ok\" styleClass=\"p-button-text\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n", styles: ["kbd{background:#e8e8e8;border:1px solid #bbb;border-radius:3px;padding:1px 5px;font-family:monospace;font-size:.85em}\n"] }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-editor-help.component.js","sourceRoot":"","sources":["../../../../../src/lib/region-editor/region-editor-help/region-editor-help.component.ts","../../../../../src/lib/region-editor/region-editor-help/region-editor-help.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;;;;;AAE9C,wDAAwD;AASxD,MAAM,OAAO,yBAAyB;IARtC;QASE,0BAA0B;QACjB,YAAO,GAAG,KAAK,CAAC;QACzB,qEAAqE;QAC3D,kBAAa,GAAG,IAAI,YAAY,EAAW,CAAC;KACvD;8GALY,yBAAyB;kGAAzB,yBAAyB,2JCdtC,i4OAqKA,gLD5JY,YAAY,qIAAE,YAAY,6XAAE,YAAY;;2FAKvC,yBAAyB;kBARrC,SAAS;+BACE,oBAAoB,cAClB,IAAI,WACP,CAAC,YAAY,EAAE,YAAY,EAAE,YAAY,CAAC,mBAGlC,uBAAuB,CAAC,MAAM;8BAItC,OAAO;sBAAf,KAAK;gBAEI,aAAa;sBAAtB,MAAM","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';\nimport { SharedModule } from 'primeng/api';\nimport { ButtonModule } from 'primeng/button';\nimport { DialogModule } from 'primeng/dialog';\n\n/** The Region Editor's help dialog (static content). */\n@Component({\n  selector: 'region-editor-help',\n  standalone: true,\n  imports: [SharedModule, ButtonModule, DialogModule],\n  templateUrl: './region-editor-help.component.html',\n  styleUrls: ['./region-editor-help.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class RegionEditorHelpComponent {\n  /** The dialog is open. */\n  @Input() visible = false;\n  /** The dialog was closed (`false`); two-way with {@link visible}. */\n  @Output() visibleChange = new EventEmitter<boolean>();\n}\n","<p-dialog\n  header=\"Region editor help\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [style]=\"{ width: '50vw' }\"\n  [maximizable]=\"true\"\n  [draggable]=\"true\"\n  appendTo=\"body\"\n>\n  <p>\n    The Region Editor lists every region drawn on the currently displayed image. 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, resize, and leave open while you\n    draw on the image. Regions are tracked <b>per image</b>: switching to another image hides these and shows that\n    image's regions; switching back restores them. Edits in the table apply <b>live</b> to the diagram — there is\n    no save or 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    <img src=\"assets/plotting/polyline.svg\" width=\"14\" height=\"14\" alt=\"\" /> polyline,\n    <i class=\"pi pi-pencil\"></i> freeform path, brush, or\n    <img src=\"assets/plotting/wand.svg\" width=\"14\" height=\"14\" alt=\"\" /> wand. Anything you draw appears\n    immediately in the table, with the class name \"<b>Region</b>\" by default.\n  </p>\n\n  <h3>The table columns</h3>\n  <ul>\n    <li>\n      <b>Class</b> — the region's class. Pick a class from the dropdown (its colour follows), or use the\n      <i class=\"pi pi-pencil\"></i> for a free-form name.\n    </li>\n    <li>\n      <b>Surface</b> — the region's area, in µm²/mm² when the image carries a physical pixel size, otherwise in\n      px². Holes (donuts) and multi-part regions are accounted for.\n    </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 nearest multiple of 512.</li>\n  </ul>\n  <p>\n    Region geometry is edited on the diagram itself (drag vertices, the vertex tools, brush/wand, and the\n    right-click region actions), not in this table.\n  </p>\n\n  <h3>Selecting rows</h3>\n  <ul>\n    <li>\n      Click a row to select it. The corresponding region is highlighted in the diagram (Plotly shows its edit\n      handles; the OpenSeadragon image view highlights it and shows its handles in select mode).\n    </li>\n    <li>\n      <kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+click to add or remove a row from the selection. <kbd>Shift</kbd>+click to\n      extend the selection in a range.\n    </li>\n    <li>Selecting a region in the diagram highlights the matching row in the table.</li>\n    <li>\n      Clicks on the colour picker, the trash icon, or the active class-edit input do not change the selection —\n      that's standard PrimeNG behaviour.\n    </li>\n  </ul>\n\n  <h3>Bulk actions on the selected rows</h3>\n  <ul>\n    <li>\n      <i class=\"pi pi-check-square\"></i> Select every region in the table at once (also a right-click action on the\n      image).\n    </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 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 that class name is drawn in\n    that colour, <b>including regions loaded from a GeoJSON later</b>. The preset colour is the source of truth: on\n    load it <b>overrides the colour stored in the file</b>, so a given annotation type always looks the same across\n    images and sessions.\n  </p>\n  <p>Set up your classes in the annotation-class manager — <i class=\"pi pi-cog\"></i> <b>Manage</b>:</p>\n  <ol>\n    <li>\n      <b>Add class</b>, then type the class <b>name exactly as it appears in your data</b> (e.g.\n      <code>Tumor</code>) and pick its <b>colour</b> from the swatch. Repeat for each class.\n    </li>\n    <li>\n      Optionally: edit the <b>fallback palette</b> (colours given to classes that aren't in your list), toggle\n      <b>auto-add</b> (adds unmatched classes found on load), and choose <b>exact</b> vs. <b>normalized</b> name\n      matching — normalized ignores case and surrounding spaces, so <code>tumor</code> matches <code>Tumor</code>.\n    </li>\n    <li>\n      <b>Apply.</b> Presets are saved <b>per user</b> on the server, so they follow you across images and sessions.\n      You can also <b>reset to defaults</b> or <b>import / export</b> the set as JSON to share it.\n    </li>\n  </ol>\n  <p>\n    Next time you open or <i class=\"pi pi-upload\"></i> import a GeoJSON whose regions carry those class names, each\n    region is shown in its preset colour automatically — no re-colouring needed. A class that isn't in your list\n    instead gets a stable colour from the fallback palette.\n  </p>\n  <p>Day to day:</p>\n  <ul>\n    <li>\n      The <b>class strip</b> above the table lists your presets with their colours. Click a class to make it\n      <b>active</b> (new regions inherit it); with rows selected, clicking a class re-classifies them.\n    </li>\n    <li>\n      The <b>Class</b> column dropdown re-classifies one region to a preset (its colour follows), or use the\n      <i class=\"pi pi-pencil\"></i> for a free-form name.\n    </li>\n    <li>\n      Recolour a class from its swatch (class strip or Manage) and every region of that class updates at once.\n    </li>\n    <li>Deleting a class reassigns its regions to the default <b>Region</b> class.</li>\n    <li>\n      A colour you set on a <b>single</b> region (<i class=\"pi pi-palette\"></i> Selected regions) is kept and is\n      not overridden by its class.\n    </li>\n  </ul>\n\n  <h3>Region actions (right-click the diagram)</h3>\n  <p>\n    Right-click a region — or the current multi-selection — on the diagram for the \"Selected region(s)\" actions:\n  </p>\n  <ul>\n    <li>\n      <b>Merge / group</b> — combine 2+ selected regions into one (it may end up multi-part if the pieces don't\n      touch).\n    </li>\n    <li><b>Ungroup</b> — split a multi-part region back into separate regions.</li>\n    <li>\n      <b>Inverse</b> — replace the selection with everything outside it (the regions become holes in the image\n      rectangle).\n    </li>\n    <li>\n      <b>Simplify</b> — reduce the vertex count (Douglas–Peucker) by a pixel threshold; pick a preset or a custom\n      value.\n    </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>\n      <i class=\"pi pi-tag\"></i> Toggle showing class labels on every region in the diagram (slower with many\n      regions).\n    </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>\n      <i class=\"pi pi-download\"></i> Export the current image's regions to a GeoJSON file. (The per-image cache is\n      in-memory only — exporting is how you persist regions across sessions.)\n    </li>\n  </ul>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button icon=\"pi pi-check\" (click)=\"visibleChange.emit(false)\" label=\"Ok\" styleClass=\"p-button-text\">\n    </p-button>\n  </ng-template>\n</p-dialog>\n"]}