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

package/esm2022/lib/region-ops.service.mjs

@@ -0,0 +1,301 @@
+import { Injectable } from '@angular/core';
+import { Region, Rectangle, Polygon, MultiPolygon } from './models/region';
+import { unionMasks, simplifyRing } from './models/geometry';
+import { WandService } from './toolbar/wand/wand.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./toolbar/wand/wand.service";
+/**
+ * Pure (DOM-free) region set-operations — merge / inverse / ungroup (jit-ui#85).
+ *
+ * Raster-based, reusing the wand/brush mask pipeline
+ * ({@link WandService.rasterizePolygon} → {@link WandService.maskToPolygons}),
+ * so "select + merge" yields the same geometry as brushing regions together:
+ * one engine, one set of behaviours, holes + multi-part results for free.
+ *
+ * Every method takes the current regions plus the image dimensions and returns
+ * new {@link Region}(s); it never mutates the store. Callers commit the result
+ * through the normal region-write path (so undo/redo applies). Coordinates are
+ * image pixels throughout.
+ */
+export class RegionOpsService {
+    /**
+     * Largest raster (in pixels) a region set-op will allocate on the main thread.
+     * Selections whose clipped bbox exceeds this are rasterized at a proportional
+     * downscale (then the traced geometry is scaled back), so merge/inverse stay
+     * responsive on gigapixel slides. ~16 MP keeps the synchronous contour trace
+     * well under a second; the downscale only affects boundary fidelity of very
+     * large-extent selections (small selections keep full resolution).
+     */
+    static { this.MAX_OP_PIXELS = 16_000_000; }
+    constructor(wand) {
+        this.wand = wand;
+    }
+    /**
+     * Geometric union of `regions` into a single region: a {@link Polygon} when
+     * the union is one connected piece, a {@link MultiPolygon} when it stays
+     * disjoint, with holes preserved. Returns null when nothing rasterises (e.g.
+     * only open polylines were selected).
+     */
+    merge(regions, imageWidth, imageHeight) {
+        // The raster is bounded by the selection's bbox, not the image — but on a
+        // whole-slide image a large-extent selection still spans billions of pixels,
+        // which freezes (or overflows the typed-array limit) on the main thread.
+        // Rasterize at a capped resolution and scale the traced polygons back up.
+        const scale = this.opRasterScale(regions, imageWidth, imageHeight);
+        const mask = this.unionMask(regions, imageWidth, imageHeight, scale);
+        if (!mask)
+            return null;
+        const sw = Math.max(1, Math.round(imageWidth * scale));
+        const sh = Math.max(1, Math.round(imageHeight * scale));
+        let polys = this.wand.maskToPolygons(mask.mask, mask.bw, mask.bh, sw, sh, mask.bx, mask.by, 1, 1);
+        if (scale !== 1)
+            polys = polys.map((p) => this.scalePolygon(p, 1 / scale));
+        return this.regionFromParts(polys, regions[0]);
+    }
+    /** Downscale factor (≤ 1) keeping the selection's clipped bbox within
+     *  {@link MAX_OP_PIXELS}; 1 when it already fits. */
+    opRasterScale(regions, W, H) {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        const scan = (xs, ys) => {
+            for (const x of xs) {
+                if (x < minX)
+                    minX = x;
+                if (x > maxX)
+                    maxX = x;
+            }
+            for (const y of ys) {
+                if (y < minY)
+                    minY = y;
+                if (y > maxY)
+                    maxY = y;
+            }
+        };
+        for (const r of regions || []) {
+            const b = r?.bounds;
+            if (b instanceof Rectangle)
+                scan([b.x, b.x + b.width], [b.y, b.y + b.height]);
+            else if (b instanceof Polygon)
+                scan(b.xpoints, b.ypoints);
+            else if (b instanceof MultiPolygon)
+                for (const p of b.polygons)
+                    scan(p.xpoints, p.ypoints);
+        }
+        if (!Number.isFinite(minX))
+            return 1;
+        const bw = Math.min(W, maxX) - Math.max(0, minX);
+        const bh = Math.min(H, maxY) - Math.max(0, minY);
+        const area = bw * bh;
+        if (!(area > RegionOpsService.MAX_OP_PIXELS))
+            return 1;
+        return Math.sqrt(RegionOpsService.MAX_OP_PIXELS / area);
+    }
+    /** A copy of `p` with every coordinate (and hole coordinate) multiplied by `s`. */
+    scalePolygon(p, s) {
+        const poly = new Polygon();
+        poly.xpoints = p.xpoints.map((x) => x * s);
+        poly.ypoints = p.ypoints.map((y) => y * s);
+        poly.npoints = poly.xpoints.length;
+        poly.closed = p.closed;
+        poly.coordinates = poly.xpoints.map((x, i) => [x, poly.ypoints[i]]);
+        if (p.holes)
+            poly.holes = p.holes.map((ring) => ring.map(([x, y]) => [x * s, y * s]));
+        return poly;
+    }
+    /**
+     * Replace `regions` with their inverse inside the image rectangle: the image
+     * minus the selection's union (the former regions become holes). Returns null
+     * for a degenerate image or an empty selection.
+     *
+     * Done *vectorially* so it scales to gigapixel images: the selection is
+     * unioned first (raster, bounded by the ROIs' extent — never the whole image),
+     * then the result is the image rectangle as the exterior with each union
+     * component's outline punched out as a hole. A component's own hole (a donut)
+     * becomes a solid island part. Only the image's corner coordinates are used —
+     * no full-image buffer is ever allocated.
+     */
+    inverse(regions, imageWidth, imageHeight) {
+        if (imageWidth <= 0 || imageHeight <= 0)
+            return null;
+        const merged = this.merge(regions, imageWidth, imageHeight);
+        if (!merged)
+            return null;
+        const comps = merged.bounds instanceof MultiPolygon
+            ? merged.bounds.polygons
+            : merged.bounds instanceof Polygon ? [merged.bounds] : [];
+        if (comps.length === 0)
+            return null;
+        // Image rectangle exterior with every component outline as a hole.
+        const rect = this.ringPolygon([0, imageWidth, imageWidth, 0], [0, 0, imageHeight, imageHeight]);
+        rect.holes = comps.map((c) => c.xpoints.map((x, i) => [x, c.ypoints[i]]));
+        // Each component's own hole (donut interior) is *outside* the region, so it
+        // stays solid in the inverse — emit it as its own island part.
+        const parts = [rect];
+        for (const c of comps) {
+            if (c.holes) {
+                for (const ring of c.holes) {
+                    parts.push(this.ringPolygon(ring.map((p) => p[0]), ring.map((p) => p[1])));
+                }
+            }
+        }
+        const bounds = parts.length === 1 ? parts[0] : Object.assign(new MultiPolygon(), { polygons: parts });
+        return this.makeRegion(bounds, regions[0]);
+    }
+    /** A closed straight-edged Polygon from parallel coord arrays. */
+    ringPolygon(xs, ys) {
+        const p = new Polygon();
+        p.xpoints = xs.slice();
+        p.ypoints = ys.slice();
+        p.npoints = xs.length;
+        p.coordinates = xs.map((x, i) => [x, ys[i]]);
+        p.closed = true;
+        return p;
+    }
+    /**
+     * Split a region into its disjoint parts — one region per {@link MultiPolygon}
+     * part. A single connected {@link Polygon}/{@link Rectangle} has nothing to
+     * split and is returned unchanged (as a one-element list).
+     */
+    ungroup(region) {
+        const b = region.bounds;
+        if (b instanceof MultiPolygon) {
+            return b.polygons
+                .filter((p) => p.xpoints.length >= 3)
+                .map((p) => this.makeRegion(this.clonePolygon(p), region));
+        }
+        return [region];
+    }
+    /** True when ungrouping `region` would actually split it (≥2 parts). */
+    canUngroup(region) {
+        return region.bounds instanceof MultiPolygon && region.bounds.polygons.length > 1;
+    }
+    /**
+     * Simplify a region's outline(s) with Douglas–Peucker — drop vertices within
+     * `altitudePx` pixels of the line between their kept neighbours. Applies to
+     * the exterior and every hole, of a polygon or each part of a MultiPolygon; a
+     * ring that would degenerate below a triangle is left at its previous detail
+     * (the part/hole is kept, not dropped). Rectangles and open polylines are
+     * returned unchanged. Result is always a straight-edged polygon (any Bézier
+     * smoothing is dropped, since the anchor set changes).
+     */
+    simplify(region, altitudePx) {
+        const b = region.bounds;
+        if (!(altitudePx > 0))
+            return region;
+        if (b instanceof Polygon && b.closed !== false) {
+            return this.makeRegion(this.simplifyPolygon(b, altitudePx), region);
+        }
+        if (b instanceof MultiPolygon) {
+            const mp = new MultiPolygon();
+            mp.polygons = b.polygons.map((p) => this.simplifyPolygon(p, altitudePx));
+            return this.makeRegion(mp, region);
+        }
+        return region;
+    }
+    /** Douglas–Peucker the exterior + each hole of one polygon. A ring that
+     *  collapses below 3 vertices keeps its original points (never degenerates). */
+    simplifyPolygon(p, eps) {
+        const keepOrSrc = (xs, ys) => {
+            const s = simplifyRing(xs, ys, eps);
+            return s.xs.length >= 3 ? s : { xs: xs.slice(), ys: ys.slice() };
+        };
+        const ext = keepOrSrc(p.xpoints, p.ypoints);
+        const poly = new Polygon();
+        poly.npoints = ext.xs.length;
+        poly.xpoints = ext.xs;
+        poly.ypoints = ext.ys;
+        poly.coordinates = ext.xs.map((x, i) => [x, ext.ys[i]]);
+        poly.closed = true;
+        if (p.holes) {
+            const holes = p.holes.map((ring) => {
+                const s = keepOrSrc(ring.map((q) => q[0]), ring.map((q) => q[1]));
+                return s.xs.map((x, i) => [x, s.ys[i]]);
+            });
+            if (holes.length)
+                poly.holes = holes;
+        }
+        return poly;
+    }
+    // ── internals ──────────────────────────────────────────────────────────
+    /** Union of every region's filled mask (exterior minus holes), or null.
+     *  `scale` (≤ 1) downscales the raster for large selections; coordinates and
+     *  the clip bounds are scaled to match. */
+    unionMask(regions, W, H, scale = 1) {
+        let acc = null;
+        for (const region of regions || []) {
+            const m = this.rasterizeRegion(region, W, H, scale);
+            if (!m)
+                continue;
+            acc = acc ? unionMasks(acc, m) : m;
+        }
+        return acc;
+    }
+    /** Rasterise any region (rect / closed polygon / multi-polygon, holes punched
+     *  out) into a bbox mask. Null for open polylines or degenerate geometry.
+     *  `scale` (≤ 1) shrinks the coordinates and clip bounds for a downscaled raster. */
+    rasterizeRegion(region, W, H, scale = 1) {
+        const sw = scale === 1 ? W : Math.max(1, Math.round(W * scale));
+        const sh = scale === 1 ? H : Math.max(1, Math.round(H * scale));
+        const sc = (arr) => (scale === 1 ? arr : arr.map((v) => v * scale));
+        const scHoles = (holes) => !holes || scale === 1 ? holes : holes.map((ring) => ring.map(([x, y]) => [x * scale, y * scale]));
+        const b = region?.bounds;
+        if (b instanceof Rectangle) {
+            const xs = [b.x, b.x + b.width, b.x + b.width, b.x];
+            const ys = [b.y, b.y, b.y + b.height, b.y + b.height];
+            return this.wand.rasterizePolygon(sc(xs), sc(ys), sw, sh);
+        }
+        if (b instanceof Polygon) {
+            if (b.closed === false || b.xpoints.length < 3)
+                return null;
+            return this.wand.rasterizePolygon(sc(b.xpoints), sc(b.ypoints), sw, sh, scHoles(b.holes));
+        }
+        if (b instanceof MultiPolygon) {
+            let acc = null;
+            for (const part of b.polygons) {
+                if (part.xpoints.length < 3)
+                    continue;
+                const m = this.wand.rasterizePolygon(sc(part.xpoints), sc(part.ypoints), sw, sh, scHoles(part.holes));
+                if (m)
+                    acc = acc ? unionMasks(acc, m) : m;
+            }
+            return acc;
+        }
+        return null;
+    }
+    /** Wrap traced parts as one region (Polygon if single, else MultiPolygon),
+     *  inheriting colour/label from `proto`. Null when there are no parts. */
+    regionFromParts(polys, proto) {
+        if (!polys || polys.length === 0)
+            return null;
+        if (polys.length === 1)
+            return this.makeRegion(polys[0], proto);
+        const mp = new MultiPolygon();
+        mp.polygons = polys;
+        return this.makeRegion(mp, proto);
+    }
+    makeRegion(bounds, proto) {
+        const r = new Region();
+        r.bounds = bounds;
+        r.color = proto?.color;
+        r.label = proto?.label ?? 'Region';
+        return r;
+    }
+    clonePolygon(p) {
+        const poly = new Polygon();
+        poly.npoints = p.npoints;
+        poly.xpoints = p.xpoints.slice();
+        poly.ypoints = p.ypoints.slice();
+        poly.coordinates = p.coordinates.map((c) => c.slice());
+        poly.closed = p.closed;
+        poly.bezier = p.bezier;
+        if (p.holes)
+            poly.holes = p.holes.map((ring) => ring.map((pt) => pt.slice()));
+        return poly;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionOpsService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionOpsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionOpsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WandService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-ops.service.js","sourceRoot":"","sources":["../../../src/lib/region-ops.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { Region, Rectangle, Polygon, MultiPolygon } from './models/region';\nimport { BBoxMask, unionMasks, simplifyRing } from './models/geometry';\nimport { WandService } from './toolbar/wand/wand.service';\n\n/**\n * Pure (DOM-free) region set-operations — merge / inverse / ungroup (jit-ui#85).\n *\n * Raster-based, reusing the wand/brush mask pipeline\n * ({@link WandService.rasterizePolygon} → {@link WandService.maskToPolygons}),\n * so \"select + merge\" yields the same geometry as brushing regions together:\n * one engine, one set of behaviours, holes + multi-part results for free.\n *\n * Every method takes the current regions plus the image dimensions and returns\n * new {@link Region}(s); it never mutates the store. Callers commit the result\n * through the normal region-write path (so undo/redo applies). Coordinates are\n * image pixels throughout.\n */\n@Injectable({ providedIn: 'root' })\nexport class RegionOpsService {\n  /**\n   * Largest raster (in pixels) a region set-op will allocate on the main thread.\n   * Selections whose clipped bbox exceeds this are rasterized at a proportional\n   * downscale (then the traced geometry is scaled back), so merge/inverse stay\n   * responsive on gigapixel slides. ~16 MP keeps the synchronous contour trace\n   * well under a second; the downscale only affects boundary fidelity of very\n   * large-extent selections (small selections keep full resolution).\n   */\n  private static readonly MAX_OP_PIXELS = 16_000_000;\n\n  constructor(private wand: WandService) {}\n\n  /**\n   * Geometric union of `regions` into a single region: a {@link Polygon} when\n   * the union is one connected piece, a {@link MultiPolygon} when it stays\n   * disjoint, with holes preserved. Returns null when nothing rasterises (e.g.\n   * only open polylines were selected).\n   */\n  merge(regions: Region[], imageWidth: number, imageHeight: number): Region | null {\n    // The raster is bounded by the selection's bbox, not the image — but on a\n    // whole-slide image a large-extent selection still spans billions of pixels,\n    // which freezes (or overflows the typed-array limit) on the main thread.\n    // Rasterize at a capped resolution and scale the traced polygons back up.\n    const scale = this.opRasterScale(regions, imageWidth, imageHeight);\n    const mask = this.unionMask(regions, imageWidth, imageHeight, scale);\n    if (!mask) return null;\n    const sw = Math.max(1, Math.round(imageWidth * scale));\n    const sh = Math.max(1, Math.round(imageHeight * scale));\n    let polys = this.wand.maskToPolygons(mask.mask, mask.bw, mask.bh, sw, sh, mask.bx, mask.by, 1, 1);\n    if (scale !== 1) polys = polys.map((p) => this.scalePolygon(p, 1 / scale));\n    return this.regionFromParts(polys, regions[0]);\n  }\n\n  /** Downscale factor (≤ 1) keeping the selection's clipped bbox within\n   *  {@link MAX_OP_PIXELS}; 1 when it already fits. */\n  private opRasterScale(regions: Region[], W: number, H: number): number {\n    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n    const scan = (xs: number[], ys: number[]) => {\n      for (const x of xs) { if (x < minX) minX = x; if (x > maxX) maxX = x; }\n      for (const y of ys) { if (y < minY) minY = y; if (y > maxY) maxY = y; }\n    };\n    for (const r of regions || []) {\n      const b = r?.bounds;\n      if (b instanceof Rectangle) scan([b.x, b.x + b.width], [b.y, b.y + b.height]);\n      else if (b instanceof Polygon) scan(b.xpoints, b.ypoints);\n      else if (b instanceof MultiPolygon) for (const p of b.polygons) scan(p.xpoints, p.ypoints);\n    }\n    if (!Number.isFinite(minX)) return 1;\n    const bw = Math.min(W, maxX) - Math.max(0, minX);\n    const bh = Math.min(H, maxY) - Math.max(0, minY);\n    const area = bw * bh;\n    if (!(area > RegionOpsService.MAX_OP_PIXELS)) return 1;\n    return Math.sqrt(RegionOpsService.MAX_OP_PIXELS / area);\n  }\n\n  /** A copy of `p` with every coordinate (and hole coordinate) multiplied by `s`. */\n  private scalePolygon(p: Polygon, s: number): Polygon {\n    const poly = new Polygon();\n    poly.xpoints = p.xpoints.map((x) => x * s);\n    poly.ypoints = p.ypoints.map((y) => y * s);\n    poly.npoints = poly.xpoints.length;\n    poly.closed = p.closed;\n    poly.coordinates = poly.xpoints.map((x, i) => [x, poly.ypoints[i]]);\n    if (p.holes) poly.holes = p.holes.map((ring) => ring.map(([x, y]) => [x * s, y * s]));\n    return poly;\n  }\n\n  /**\n   * Replace `regions` with their inverse inside the image rectangle: the image\n   * minus the selection's union (the former regions become holes). Returns null\n   * for a degenerate image or an empty selection.\n   *\n   * Done *vectorially* so it scales to gigapixel images: the selection is\n   * unioned first (raster, bounded by the ROIs' extent — never the whole image),\n   * then the result is the image rectangle as the exterior with each union\n   * component's outline punched out as a hole. A component's own hole (a donut)\n   * becomes a solid island part. Only the image's corner coordinates are used —\n   * no full-image buffer is ever allocated.\n   */\n  inverse(regions: Region[], imageWidth: number, imageHeight: number): Region | null {\n    if (imageWidth <= 0 || imageHeight <= 0) return null;\n    const merged = this.merge(regions, imageWidth, imageHeight);\n    if (!merged) return null;\n    const comps: Polygon[] = merged.bounds instanceof MultiPolygon\n      ? merged.bounds.polygons\n      : merged.bounds instanceof Polygon ? [merged.bounds] : [];\n    if (comps.length === 0) return null;\n\n    // Image rectangle exterior with every component outline as a hole.\n    const rect = this.ringPolygon(\n      [0, imageWidth, imageWidth, 0], [0, 0, imageHeight, imageHeight]);\n    rect.holes = comps.map((c) => c.xpoints.map((x, i) => [x, c.ypoints[i]]));\n\n    // Each component's own hole (donut interior) is *outside* the region, so it\n    // stays solid in the inverse — emit it as its own island part.\n    const parts: Polygon[] = [rect];\n    for (const c of comps) {\n      if (c.holes) {\n        for (const ring of c.holes) {\n          parts.push(this.ringPolygon(ring.map((p) => p[0]), ring.map((p) => p[1])));\n        }\n      }\n    }\n    const bounds = parts.length === 1 ? parts[0] : Object.assign(new MultiPolygon(), { polygons: parts });\n    return this.makeRegion(bounds, regions[0]);\n  }\n\n  /** A closed straight-edged Polygon from parallel coord arrays. */\n  private ringPolygon(xs: number[], ys: number[]): Polygon {\n    const p = new Polygon();\n    p.xpoints = xs.slice();\n    p.ypoints = ys.slice();\n    p.npoints = xs.length;\n    p.coordinates = xs.map((x, i) => [x, ys[i]]);\n    p.closed = true;\n    return p;\n  }\n\n  /**\n   * Split a region into its disjoint parts — one region per {@link MultiPolygon}\n   * part. A single connected {@link Polygon}/{@link Rectangle} has nothing to\n   * split and is returned unchanged (as a one-element list).\n   */\n  ungroup(region: Region): Region[] {\n    const b = region.bounds;\n    if (b instanceof MultiPolygon) {\n      return b.polygons\n        .filter((p) => p.xpoints.length >= 3)\n        .map((p) => this.makeRegion(this.clonePolygon(p), region));\n    }\n    return [region];\n  }\n\n  /** True when ungrouping `region` would actually split it (≥2 parts). */\n  canUngroup(region: Region): boolean {\n    return region.bounds instanceof MultiPolygon && region.bounds.polygons.length > 1;\n  }\n\n  /**\n   * Simplify a region's outline(s) with Douglas–Peucker — drop vertices within\n   * `altitudePx` pixels of the line between their kept neighbours. Applies to\n   * the exterior and every hole, of a polygon or each part of a MultiPolygon; a\n   * ring that would degenerate below a triangle is left at its previous detail\n   * (the part/hole is kept, not dropped). Rectangles and open polylines are\n   * returned unchanged. Result is always a straight-edged polygon (any Bézier\n   * smoothing is dropped, since the anchor set changes).\n   */\n  simplify(region: Region, altitudePx: number): Region {\n    const b = region.bounds;\n    if (!(altitudePx > 0)) return region;\n    if (b instanceof Polygon && b.closed !== false) {\n      return this.makeRegion(this.simplifyPolygon(b, altitudePx), region);\n    }\n    if (b instanceof MultiPolygon) {\n      const mp = new MultiPolygon();\n      mp.polygons = b.polygons.map((p) => this.simplifyPolygon(p, altitudePx));\n      return this.makeRegion(mp, region);\n    }\n    return region;\n  }\n\n  /** Douglas–Peucker the exterior + each hole of one polygon. A ring that\n   *  collapses below 3 vertices keeps its original points (never degenerates). */\n  private simplifyPolygon(p: Polygon, eps: number): Polygon {\n    const keepOrSrc = (xs: number[], ys: number[]): { xs: number[]; ys: number[] } => {\n      const s = simplifyRing(xs, ys, eps);\n      return s.xs.length >= 3 ? s : { xs: xs.slice(), ys: ys.slice() };\n    };\n    const ext = keepOrSrc(p.xpoints, p.ypoints);\n    const poly = new Polygon();\n    poly.npoints = ext.xs.length;\n    poly.xpoints = ext.xs;\n    poly.ypoints = ext.ys;\n    poly.coordinates = ext.xs.map((x, i) => [x, ext.ys[i]]);\n    poly.closed = true;\n    if (p.holes) {\n      const holes = p.holes.map((ring) => {\n        const s = keepOrSrc(ring.map((q) => q[0]), ring.map((q) => q[1]));\n        return s.xs.map((x, i) => [x, s.ys[i]]);\n      });\n      if (holes.length) poly.holes = holes;\n    }\n    return poly;\n  }\n\n  // ── internals ──────────────────────────────────────────────────────────\n\n  /** Union of every region's filled mask (exterior minus holes), or null.\n   *  `scale` (≤ 1) downscales the raster for large selections; coordinates and\n   *  the clip bounds are scaled to match. */\n  private unionMask(regions: Region[], W: number, H: number, scale = 1): BBoxMask | null {\n    let acc: BBoxMask | null = null;\n    for (const region of regions || []) {\n      const m = this.rasterizeRegion(region, W, H, scale);\n      if (!m) continue;\n      acc = acc ? unionMasks(acc, m) : m;\n    }\n    return acc;\n  }\n\n  /** Rasterise any region (rect / closed polygon / multi-polygon, holes punched\n   *  out) into a bbox mask. Null for open polylines or degenerate geometry.\n   *  `scale` (≤ 1) shrinks the coordinates and clip bounds for a downscaled raster. */\n  private rasterizeRegion(region: Region, W: number, H: number, scale = 1): BBoxMask | null {\n    const sw = scale === 1 ? W : Math.max(1, Math.round(W * scale));\n    const sh = scale === 1 ? H : Math.max(1, Math.round(H * scale));\n    const sc = (arr: number[]) => (scale === 1 ? arr : arr.map((v) => v * scale));\n    const scHoles = (holes?: number[][][]) =>\n      !holes || scale === 1 ? holes : holes.map((ring) => ring.map(([x, y]) => [x * scale, y * scale]));\n    const b = region?.bounds;\n    if (b instanceof Rectangle) {\n      const xs = [b.x, b.x + b.width, b.x + b.width, b.x];\n      const ys = [b.y, b.y, b.y + b.height, b.y + b.height];\n      return this.wand.rasterizePolygon(sc(xs), sc(ys), sw, sh);\n    }\n    if (b instanceof Polygon) {\n      if (b.closed === false || b.xpoints.length < 3) return null;\n      return this.wand.rasterizePolygon(sc(b.xpoints), sc(b.ypoints), sw, sh, scHoles(b.holes));\n    }\n    if (b instanceof MultiPolygon) {\n      let acc: BBoxMask | null = null;\n      for (const part of b.polygons) {\n        if (part.xpoints.length < 3) continue;\n        const m = this.wand.rasterizePolygon(sc(part.xpoints), sc(part.ypoints), sw, sh, scHoles(part.holes));\n        if (m) acc = acc ? unionMasks(acc, m) : m;\n      }\n      return acc;\n    }\n    return null;\n  }\n\n  /** Wrap traced parts as one region (Polygon if single, else MultiPolygon),\n   *  inheriting colour/label from `proto`. Null when there are no parts. */\n  private regionFromParts(polys: Polygon[], proto: Region | undefined): Region | null {\n    if (!polys || polys.length === 0) return null;\n    if (polys.length === 1) return this.makeRegion(polys[0], proto);\n    const mp = new MultiPolygon();\n    mp.polygons = polys;\n    return this.makeRegion(mp, proto);\n  }\n\n  private makeRegion(bounds: Polygon | MultiPolygon, proto: Region | undefined): Region {\n    const r = new Region();\n    r.bounds = bounds;\n    r.color = proto?.color;\n    r.label = proto?.label ?? 'Region';\n    return r;\n  }\n\n  private clonePolygon(p: Polygon): Polygon {\n    const poly = new Polygon();\n    poly.npoints = p.npoints;\n    poly.xpoints = p.xpoints.slice();\n    poly.ypoints = p.ypoints.slice();\n    poly.coordinates = p.coordinates.map((c) => c.slice());\n    poly.closed = p.closed;\n    poly.bezier = p.bezier;\n    if (p.holes) poly.holes = p.holes.map((ring) => ring.map((pt) => pt.slice()));\n    return poly;\n  }\n}\n"]}

package/esm2022/lib/render-orchestrator.mjs

@@ -0,0 +1,87 @@
+export class RenderOrchestrator {
+    constructor(host, retryDelayMs = 1000) {
+        this.host = host;
+        this.retryDelayMs = retryDelayMs;
+    }
+    /** Run the render: single-pass when `smallInfo` is null, two-pass otherwise. */
+    async render(info, smallInfo) {
+        if (!smallInfo) {
+            try {
+                await this.host.renderPhase(info, false);
+                this.host.finished(false, 'finished plotting');
+            }
+            catch (err) {
+                console.error('Preview failed', err);
+                this.host.finished(false, 'plotting aborted');
+            }
+            return;
+        }
+        let smallReleasedOverlay = false;
+        try {
+            await this.host.renderPhase(smallInfo, false);
+            this.host.smallShown();
+            smallReleasedOverlay = true;
+            console.log('multi-tier: small tier rendered, starting large');
+        }
+        catch (err) {
+            // Small-tier render failed (older backend without tier support, transient
+            // error, …). Continue with large only; the overlay stays up until it lands.
+            console.warn('Small-tier preview failed, falling back to large', err);
+        }
+        try {
+            await this.renderLargeWithRetry(info);
+            this.host.sharpenSettled();
+            if (smallReleasedOverlay) {
+                this.host.finished(true, 'multi-tier: large tier rendered, sharpening complete');
+            }
+            else {
+                this.host.finished(false, 'finished plotting (large only after small fallback)');
+            }
+        }
+        catch (err) {
+            this.host.sharpenSettled();
+            console.error('Large-tier preview failed after retry', err);
+            this.host.sharpenFailed(err);
+        }
+    }
+    /** One retry after a brief delay before giving up on the large tier. */
+    renderLargeWithRetry(info) {
+        return this.host.renderPhase(info, true).catch((err) => {
+            console.warn('Large-tier preview failed on first try, retrying in 1s', err);
+            return new Promise((resolve) => setTimeout(resolve, this.retryDelayMs)).then(() => this.host.renderPhase(info, true));
+        });
+    }
+}
+/**
+ * Debounced z-slice scrubbing (extracted with the orchestrator): coalesce the
+ * rapid changes a slider drag fires so a slice swap doesn't run on every
+ * pixel; the final value lands immediately via {@link commit} (onSlideEnd).
+ */
+export class SliceScrubber {
+    constructor(apply, delayMs = 120) {
+        this.apply = apply;
+        this.delayMs = delayMs;
+        this.timer = null;
+    }
+    /** Debounced application of z while dragging. */
+    scrub(z) {
+        this.cancel();
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.apply(z);
+        }, this.delayMs);
+    }
+    /** Apply z immediately (slide end / keyboard step), dropping any pending scrub. */
+    commit(z) {
+        this.cancel();
+        this.apply(z);
+    }
+    /** Drop a pending scrub without applying (teardown). */
+    cancel() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-orchestrator.js","sourceRoot":"","sources":["../../../src/lib/render-orchestrator.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from './contracts/image.contract';\n\n/**\n * Two-pass (small→large) render sequencing, extracted from\n * VisualizerComponent (refactoring plan, Step 7 — a pure move of the\n * orchestration; the component keeps the UI flags and supplies them through\n * the host callbacks).\n *\n * When the file has small-tier URLs we render the small tier first for a fast\n * blurry preview, release the loading overlay (keeping a translucent\n * \"sharpening\" spinner), then sharpen by re-rendering the canonical large tier\n * in place. Without a small tier it's the original single pass. The large pass\n * retries once after a short delay — the preview endpoint can hit a transient\n * 503 or a lock-contention window, and the second attempt usually lands on\n * fresh pre-gen-cached PNGs.\n */\nexport interface TwoPassRenderHost {\n  /** Load + plot one phase (the component owns div/screen/plot-type/z and the\n   *  newer-click filename guard). `inPlace` updates the existing render so the\n   *  canvas doesn't blank during the small→large swap. */\n  renderPhase(info: IImageInfo, inPlace: boolean): Promise<unknown>;\n  /** The small tier is on screen — drop the full loading overlay so the user\n   *  sees the blurry preview, and show the sharpening spinner. */\n  smallShown(): void;\n  /** The large render settled (either way) — sharpening spinner off. */\n  sharpenSettled(): void;\n  /** Rendering finished. `viaSmall` = the overlay was already released by the\n   *  small tier (so only release the running guard + apply the ROI); otherwise\n   *  do the full finalize (overlay + running + ROI). */\n  finished(viaSmall: boolean, logTag: string): void;\n  /** Both large-tier attempts failed; the small tier stays on screen as the\n   *  fallback. Surface it to the user and release the running guard + ROI. */\n  sharpenFailed(err: unknown): void;\n}\n\nexport class RenderOrchestrator {\n  constructor(\n    private host: TwoPassRenderHost,\n    private retryDelayMs = 1000,\n  ) {}\n\n  /** Run the render: single-pass when `smallInfo` is null, two-pass otherwise. */\n  async render(info: IImageInfo, smallInfo: IImageInfo | null): Promise<void> {\n    if (!smallInfo) {\n      try {\n        await this.host.renderPhase(info, false);\n        this.host.finished(false, 'finished plotting');\n      } catch (err) {\n        console.error('Preview failed', err);\n        this.host.finished(false, 'plotting aborted');\n      }\n      return;\n    }\n\n    let smallReleasedOverlay = false;\n    try {\n      await this.host.renderPhase(smallInfo, false);\n      this.host.smallShown();\n      smallReleasedOverlay = true;\n      console.log('multi-tier: small tier rendered, starting large');\n    } catch (err) {\n      // Small-tier render failed (older backend without tier support, transient\n      // error, …). Continue with large only; the overlay stays up until it lands.\n      console.warn('Small-tier preview failed, falling back to large', err);\n    }\n\n    try {\n      await this.renderLargeWithRetry(info);\n      this.host.sharpenSettled();\n      if (smallReleasedOverlay) {\n        this.host.finished(true, 'multi-tier: large tier rendered, sharpening complete');\n      } else {\n        this.host.finished(false, 'finished plotting (large only after small fallback)');\n      }\n    } catch (err) {\n      this.host.sharpenSettled();\n      console.error('Large-tier preview failed after retry', err);\n      this.host.sharpenFailed(err);\n    }\n  }\n\n  /** One retry after a brief delay before giving up on the large tier. */\n  private renderLargeWithRetry(info: IImageInfo): Promise<unknown> {\n    return this.host.renderPhase(info, true).catch((err) => {\n      console.warn('Large-tier preview failed on first try, retrying in 1s', err);\n      return new Promise<void>((resolve) => setTimeout(resolve, this.retryDelayMs)).then(() =>\n        this.host.renderPhase(info, true),\n      );\n    });\n  }\n}\n\n/**\n * Debounced z-slice scrubbing (extracted with the orchestrator): coalesce the\n * rapid changes a slider drag fires so a slice swap doesn't run on every\n * pixel; the final value lands immediately via {@link commit} (onSlideEnd).\n */\nexport class SliceScrubber {\n  private timer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor(\n    private apply: (z: number) => void,\n    private delayMs = 120,\n  ) {}\n\n  /** Debounced application of z while dragging. */\n  scrub(z: number): void {\n    this.cancel();\n    this.timer = setTimeout(() => {\n      this.timer = null;\n      this.apply(z);\n    }, this.delayMs);\n  }\n\n  /** Apply z immediately (slide end / keyboard step), dropping any pending scrub. */\n  commit(z: number): void {\n    this.cancel();\n    this.apply(z);\n  }\n\n  /** Drop a pending scrub without applying (teardown). */\n  cancel(): void {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = null;\n    }\n  }\n}\n"]}