@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/region-overlay/region-source-layer.mjs

@@ -0,0 +1,378 @@
+import { isAbortError } from '../region-source/region-source';
+import { featureAt, featuresInRect, regionLevelFor, regionTileId, regionTilesInRect, } from '../region-source/region-tiles';
+import { IDENTITY_AFFINE, ScreenLayer, applyAffine, svgEl } from './svg-region-renderer';
+import { isFilled, placeInsideLabel, shapePaint } from './region-style';
+/** Wait this long after the last camera change before planning tiles (ms). */
+export const SOURCE_REPLAN_MS = 90;
+/** The view is padded by this fraction on each side, so a short pan finds its tiles loaded. */
+export const SOURCE_VIEW_MARGIN = 0.25;
+/** At most this many tiles in view. */
+export const SOURCE_MAX_TILES = 256;
+/** A rubber band takes at most this many source features into the working set. */
+export const SOURCE_MARQUEE_LIMIT = 2000;
+/** Loaded tiles kept by the layer for drawing (the source caches more). */
+const LAYER_TILE_LIMIT = 512;
+/** Stroke width of a source outline, screen px (an unselected region's). */
+const SOURCE_STROKE_PX = 2;
+export class RegionSourceLayer {
+    constructor(svg, view$, size = () => svgSize(svg)) {
+        this.svg = svg;
+        this.size = size;
+        this.group = svgEl('g');
+        this.camera = IDENTITY_AFFINE;
+        /** Class labels inside the features, in screen space over the outlines. */
+        this.labelLayer = new ScreenLayer(svgEl('g'), (x, y) => applyAffine(this.camera, x, y));
+        /** Class name → depth in the source's class hierarchy (parents draw under their children). */
+        this.depthOf = new Map();
+        /** Class name → its parent class in the source's class hierarchy. */
+        this.parentOf = new Map();
+        this.view = null;
+        this.visible = true;
+        /** Loaded tiles of the current source and plane, by id, least recently used first. */
+        this.tiles = new Map();
+        /** The tiles the view wants now. */
+        this.wanted = [];
+        /** The features drawn, by id (each at the finest level loaded). */
+        this.drawn = new Map();
+        this.loading = null;
+        this.replanTimer = null;
+        this.drawFrame = null;
+        this.group.setAttribute('data-layer', 'region-source');
+        this.group.setAttribute('pointer-events', 'none');
+        this.labelLayer.group.setAttribute('data-layer', 'region-source-labels');
+        this.sub = view$.subscribe((view) => this.setView(view));
+    }
+    /** Follow the camera: rewrite the transform now, re-plan the tiles once it settles. */
+    setCamera(affine) {
+        if (!affine.every(Number.isFinite))
+            return;
+        if (affine.every((v, i) => v === this.camera[i]))
+            return;
+        this.camera = affine;
+        this.applyCamera();
+        this.labelLayer.reproject();
+        if (!this.view)
+            return;
+        if (this.replanTimer)
+            clearTimeout(this.replanTimer);
+        this.replanTimer = setTimeout(() => {
+            this.replanTimer = null;
+            this.replan();
+        }, SOURCE_REPLAN_MS);
+    }
+    /** Show or hide the source with the regions. */
+    setVisible(visible) {
+        if (visible === this.visible)
+            return;
+        this.visible = visible;
+        this.attach();
+    }
+    /**
+     * The source feature under world point (x, y) — inside an area, or within `tolerancePx`
+     * screen pixels of a polyline — from the features drawn; the innermost of nested ones.
+     */
+    featureAt(x, y, tolerancePx = 4) {
+        if (!this.view || !this.visible)
+            return null;
+        return featureAt(this.drawn.values(), x, y, tolerancePx / this.scale());
+    }
+    /** The drawn source features whose box meets the world box (the rubber band's rule). */
+    featuresInRect(x0, y0, x1, y1) {
+        if (!this.view || !this.visible)
+            return [];
+        return featuresInRect(this.drawn.values(), [x0, y0, x1, y1]);
+    }
+    destroy() {
+        this.sub.unsubscribe();
+        this.loading?.abort();
+        if (this.replanTimer)
+            clearTimeout(this.replanTimer);
+        if (this.drawFrame !== null)
+            cancelFrame(this.drawFrame);
+        this.group.parentNode?.removeChild(this.group);
+        this.labelLayer.group.parentNode?.removeChild(this.labelLayer.group);
+    }
+    setView(view) {
+        const prev = this.view;
+        this.view = view;
+        if (!view || prev?.source !== view.source || prev.plane !== view.plane) {
+            this.tiles.clear();
+            this.loading?.abort();
+            this.loading = null;
+        }
+        if (view && prev?.source !== view.source) {
+            const hierarchy = view.source.info.hierarchy ?? [];
+            this.depthOf = hierarchyDepths(hierarchy);
+            this.parentOf = new Map(hierarchy.filter((n) => n.parent).map((n) => [n.name, n.parent]));
+        }
+        this.attach();
+        if (view)
+            this.replan();
+        else
+            this.draw();
+    }
+    /** The layer is the svg's first child (under the regions) while it shows a source. */
+    attach() {
+        const show = !!this.view && this.visible;
+        const labels = this.labelLayer.group;
+        if (!show) {
+            this.group.parentNode?.removeChild(this.group);
+            labels.parentNode?.removeChild(labels);
+            return;
+        }
+        if (this.svg.firstChild !== this.group)
+            this.svg.insertBefore(this.group, this.svg.firstChild);
+        if (this.group.nextSibling !== labels)
+            this.svg.insertBefore(labels, this.group.nextSibling);
+    }
+    applyCamera() {
+        this.group.setAttribute('transform', `matrix(${this.camera.join(' ')})`);
+    }
+    /** Screen px per world unit. */
+    scale() {
+        const [a, b, c, d] = this.camera;
+        return Math.sqrt(Math.abs(a * d - b * c)) || 1;
+    }
+    /** The world box in view, padded by the margin; null when the svg has no size yet. */
+    viewRect() {
+        const { width, height } = this.size();
+        if (!(width > 0) || !(height > 0))
+            return null;
+        const [a, b, c, d, e, f] = this.camera;
+        const det = a * d - b * c;
+        if (!det)
+            return null;
+        const toWorld = (sx, sy) => {
+            const x = sx - e, y = sy - f;
+            return [(d * x - c * y) / det, (a * y - b * x) / det];
+        };
+        const mx = width * SOURCE_VIEW_MARGIN, my = height * SOURCE_VIEW_MARGIN;
+        const corners = [
+            toWorld(-mx, -my),
+            toWorld(width + mx, -my),
+            toWorld(-mx, height + my),
+            toWorld(width + mx, height + my),
+        ];
+        const xs = corners.map((p) => p[0]), ys = corners.map((p) => p[1]);
+        return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+    }
+    /** Work out the tiles the view needs, draw what is loaded, and load the rest. */
+    replan() {
+        const view = this.view;
+        if (!view)
+            return;
+        const rect = this.viewRect();
+        if (!rect) {
+            this.wanted = [];
+            this.draw();
+            return;
+        }
+        const info = view.source.info;
+        const level = regionLevelFor(this.scale(), info.levels);
+        this.wanted = regionTilesInRect(rect, level, info.tileSize, info.bounds, SOURCE_MAX_TILES);
+        this.scheduleDraw();
+        const missing = this.wanted.filter((k) => !this.tiles.has(regionTileId(k)));
+        this.loading?.abort();
+        this.loading = null;
+        if (!missing.length)
+            return;
+        const loading = new AbortController();
+        this.loading = loading;
+        for (const key of missing) {
+            view.source.getTile(view.plane, key, loading.signal).then((tile) => {
+                if (this.view?.source !== view.source || this.view.plane !== view.plane)
+                    return;
+                this.keep(tile);
+                this.scheduleDraw();
+            }, (err) => {
+                if (!isAbortError(err))
+                    console.warn('[regions] region tile failed', err);
+            });
+        }
+    }
+    keep(tile) {
+        const id = regionTileId(tile);
+        this.tiles.delete(id);
+        this.tiles.set(id, tile);
+        while (this.tiles.size > LAYER_TILE_LIMIT)
+            this.tiles.delete(this.tiles.keys().next().value);
+    }
+    scheduleDraw() {
+        if (this.drawFrame !== null)
+            return;
+        this.drawFrame = requestFrame(() => {
+            this.drawFrame = null;
+            this.draw();
+        });
+    }
+    /**
+     * Rebuild the paths from the wanted tiles that are loaded, a missing tile's nearest loaded
+     * ancestor standing in for it; each feature once, at the finest level loaded.
+     */
+    draw() {
+        const view = this.view;
+        const drawn = new Map();
+        const level = new Map();
+        if (view) {
+            const used = new Set();
+            for (const key of this.wanted) {
+                const tile = this.loadedOrAncestor(key);
+                if (!tile || used.has(regionTileId(tile)))
+                    continue;
+                used.add(regionTileId(tile));
+                for (const f of tile.features) {
+                    if (view.taken.has(f.id) || view.isHidden?.(f.label))
+                        continue;
+                    const had = level.get(f.id);
+                    if (had !== undefined && had <= tile.level)
+                        continue;
+                    drawn.set(f.id, f);
+                    level.set(f.id, tile.level);
+                }
+            }
+        }
+        this.drawn = drawn;
+        const filled = !!view && isFilled(view.style);
+        const frag = document.createDocumentFragment();
+        for (const run of this.runs(drawn, filled)) {
+            const path = svgEl('path');
+            path.setAttribute('d', run.features.flatMap((f) => f.rings.map((r) => ringD(r, !f.open))).join(''));
+            path.setAttribute('fill-rule', 'evenodd');
+            path.setAttribute('stroke-linejoin', 'round');
+            path.setAttribute('vector-effect', 'non-scaling-stroke');
+            if (filled && view) {
+                const paint = shapePaint(run.color, false, view.style);
+                path.setAttribute('fill', paint.fill);
+                path.setAttribute('fill-opacity', `${paint.fillOpacity}`);
+                path.setAttribute('stroke', paint.stroke);
+                path.setAttribute('stroke-width', `${paint.strokeWidth}`);
+            }
+            else {
+                path.setAttribute('fill', 'none');
+                path.setAttribute('stroke', run.color);
+                path.setAttribute('stroke-width', `${SOURCE_STROKE_PX}`);
+            }
+            frag.appendChild(path);
+        }
+        while (this.group.firstChild)
+            this.group.removeChild(this.group.firstChild);
+        this.group.appendChild(frag);
+        this.applyCamera();
+        this.drawLabels(filled);
+    }
+    /**
+     * The drawn features as paths: one per colour when outlined; filled, in paint order — parents
+     * (by the class hierarchy) and then larger features first, so what lies inside paints over
+     * them — one path per run of a colour.
+     */
+    runs(drawn, filled) {
+        const view = this.view;
+        const colorOf = (f) => view?.colorOf(f) ?? '#00FFFF';
+        if (!filled) {
+            const byColor = new Map();
+            for (const f of drawn.values()) {
+                const color = colorOf(f);
+                const list = byColor.get(color);
+                if (list)
+                    list.push(f);
+                else
+                    byColor.set(color, [f]);
+            }
+            return Array.from(byColor, ([color, features]) => ({ color, features }));
+        }
+        const area = (f) => (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]);
+        const depth = (f) => this.depthOf.get(f.label ?? '') ?? 0;
+        const order = Array.from(drawn.values()).sort((a, b) => depth(a) - depth(b) || area(b) - area(a));
+        const runs = [];
+        for (const f of order) {
+            const color = colorOf(f);
+            const last = runs[runs.length - 1];
+            if (last && last.color === color)
+                last.features.push(f);
+            else
+                runs.push({ color, features: [f] });
+        }
+        return runs;
+    }
+    /** Class labels inside the drawn features (each part where it fits), when labels are on. */
+    drawLabels(filled) {
+        this.labelLayer.clear();
+        const view = this.view;
+        if (!view?.labels)
+            return;
+        // Only the deepest classes drawn are labelled: a class whose subclasses are drawn too (an
+        // atlas's "Isocortex" under its areas) would only repeat over them.
+        const covered = new Set();
+        for (const f of this.drawn.values()) {
+            let p = f.label ? this.parentOf.get(f.label) : undefined;
+            while (p && !covered.has(p)) {
+                covered.add(p);
+                p = this.parentOf.get(p);
+            }
+        }
+        for (const f of this.drawn.values()) {
+            const at = f.labels;
+            if (!at || !f.label || covered.has(f.label))
+                continue;
+            const color = filled ? '#111' : view.colorOf(f);
+            for (let k = 0; k + 2 < at.length; k += 3) {
+                placeInsideLabel(this.labelLayer, f.label, { x: at[k], y: at[k + 1], room: at[k + 2] }, color);
+            }
+        }
+    }
+    /** The loaded tile for `key`, else its nearest loaded coarser ancestor. */
+    loadedOrAncestor(key) {
+        const levels = this.view?.source.info.levels ?? 0;
+        let { gx, gy } = key;
+        for (let level = key.level; level < levels; level++) {
+            const tile = this.tiles.get(regionTileId({ level, gx, gy }));
+            if (tile)
+                return tile;
+            gx = Math.floor(gx / 2);
+            gy = Math.floor(gy / 2);
+        }
+        return null;
+    }
+}
+/** Path data of one ring (`closed`) or polyline, in world units to 1/100. */
+function ringD(ring, closed) {
+    const n = ring.length >> 1;
+    if (n < 2)
+        return '';
+    let d = `M${r2(ring[0])} ${r2(ring[1])}`;
+    for (let i = 1; i < n; i++)
+        d += `L${r2(ring[2 * i])} ${r2(ring[2 * i + 1])}`;
+    return closed ? `${d}Z` : d;
+}
+function r2(v) {
+    return Math.round(v * 100) / 100;
+}
+function svgSize(svg) {
+    const width = svg.clientWidth || svg.getBoundingClientRect().width;
+    const height = svg.clientHeight || svg.getBoundingClientRect().height;
+    return { width, height };
+}
+const requestFrame = (fn) => typeof requestAnimationFrame === 'function'
+    ? requestAnimationFrame(fn)
+    : setTimeout(fn, 16);
+const cancelFrame = (id) => typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame(id) : clearTimeout(id);
+/** Depth of each class in a class hierarchy (a root is 0); empty without one. */
+function hierarchyDepths(hierarchy) {
+    const depths = new Map();
+    if (!hierarchy)
+        return depths;
+    const parent = new Map(hierarchy.map((n) => [n.name, n.parent ?? null]));
+    for (const n of hierarchy) {
+        let d = 0;
+        let p = parent.get(n.name);
+        const seen = new Set([n.name]);
+        while (p && !seen.has(p)) {
+            seen.add(p);
+            d++;
+            p = parent.get(p) ?? null;
+        }
+        depths.set(n.name, d);
+    }
+    return depths;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-source-layer.js","sourceRoot":"","sources":["../../../../src/lib/region-overlay/region-source-layer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Draws a region source (see `region-source`) under the editable regions, at the level of detail\n * the zoom calls for, from the tiles in view only — the way the spatial views draw cell outlines.\n * Shared by the OpenSeadragon and napari overlays: both hand it their svg and their world → svg\n * camera affine, as they do their {@link SvgRegionRenderer}.\n *\n * One `<path>` per colour (every ring of every feature of that colour, even-odd), in world\n * coordinates inside one transformed group, so a camera move rewrites one attribute. The tiles in\n * view are re-planned once the camera settles; while a finer tile loads its coarser parent is\n * drawn instead, so zooming in sharpens the outlines rather than blanking them. Features taken\n * into the working set (selected, edited) or deleted are not drawn: the region renderer draws the\n * taken ones as ordinary regions.\n *\n * It also answers what is under a point, from the features drawn, for the overlays' selection.\n */\nimport type { Observable, Subscription } from 'rxjs';\n\nimport { RegionSourceView, isAbortError } from '../region-source/region-source';\nimport {\n  Bbox,\n  RegionTile,\n  RegionTileKey,\n  TileFeature,\n  featureAt,\n  featuresInRect,\n  regionLevelFor,\n  regionTileId,\n  regionTilesInRect,\n} from '../region-source/region-tiles';\nimport { Affine, IDENTITY_AFFINE, ScreenLayer, applyAffine, svgEl } from './svg-region-renderer';\nimport { isFilled, placeInsideLabel, shapePaint } from './region-style';\n\n/** Wait this long after the last camera change before planning tiles (ms). */\nexport const SOURCE_REPLAN_MS = 90;\n/** The view is padded by this fraction on each side, so a short pan finds its tiles loaded. */\nexport const SOURCE_VIEW_MARGIN = 0.25;\n/** At most this many tiles in view. */\nexport const SOURCE_MAX_TILES = 256;\n/** A rubber band takes at most this many source features into the working set. */\nexport const SOURCE_MARQUEE_LIMIT = 2000;\n/** Loaded tiles kept by the layer for drawing (the source caches more). */\nconst LAYER_TILE_LIMIT = 512;\n/** Stroke width of a source outline, screen px (an unselected region's). */\nconst SOURCE_STROKE_PX = 2;\n\n/** The svg size (local px), for the part of the world in view. */\nexport type SvgSize = () => { width: number; height: number };\n\nexport class RegionSourceLayer {\n  private readonly group = svgEl('g');\n  private camera: Affine = IDENTITY_AFFINE;\n  /** Class labels inside the features, in screen space over the outlines. */\n  private readonly labelLayer = new ScreenLayer(svgEl('g'), (x, y) => applyAffine(this.camera, x, y));\n  /** Class name → depth in the source's class hierarchy (parents draw under their children). */\n  private depthOf = new Map<string, number>();\n  /** Class name → its parent class in the source's class hierarchy. */\n  private parentOf = new Map<string, string>();\n  private view: RegionSourceView | null = null;\n  private visible = true;\n  private readonly sub: Subscription;\n  /** Loaded tiles of the current source and plane, by id, least recently used first. */\n  private readonly tiles = new Map<string, RegionTile>();\n  /** The tiles the view wants now. */\n  private wanted: RegionTileKey[] = [];\n  /** The features drawn, by id (each at the finest level loaded). */\n  private drawn = new Map<string, TileFeature>();\n  private loading: AbortController | null = null;\n  private replanTimer: ReturnType<typeof setTimeout> | null = null;\n  private drawFrame: number | null = null;\n\n  constructor(\n    private readonly svg: SVGSVGElement,\n    view$: Observable<RegionSourceView | null>,\n    private readonly size: SvgSize = () => svgSize(svg),\n  ) {\n    this.group.setAttribute('data-layer', 'region-source');\n    this.group.setAttribute('pointer-events', 'none');\n    this.labelLayer.group.setAttribute('data-layer', 'region-source-labels');\n    this.sub = view$.subscribe((view) => this.setView(view));\n  }\n\n  /** Follow the camera: rewrite the transform now, re-plan the tiles once it settles. */\n  setCamera(affine: Affine): void {\n    if (!affine.every(Number.isFinite)) return;\n    if (affine.every((v, i) => v === this.camera[i])) return;\n    this.camera = affine;\n    this.applyCamera();\n    this.labelLayer.reproject();\n    if (!this.view) return;\n    if (this.replanTimer) clearTimeout(this.replanTimer);\n    this.replanTimer = setTimeout(() => {\n      this.replanTimer = null;\n      this.replan();\n    }, SOURCE_REPLAN_MS);\n  }\n\n  /** Show or hide the source with the regions. */\n  setVisible(visible: boolean): void {\n    if (visible === this.visible) return;\n    this.visible = visible;\n    this.attach();\n  }\n\n  /**\n   * The source feature under world point (x, y) — inside an area, or within `tolerancePx`\n   * screen pixels of a polyline — from the features drawn; the innermost of nested ones.\n   */\n  featureAt(x: number, y: number, tolerancePx = 4): TileFeature | null {\n    if (!this.view || !this.visible) return null;\n    return featureAt(this.drawn.values(), x, y, tolerancePx / this.scale());\n  }\n\n  /** The drawn source features whose box meets the world box (the rubber band's rule). */\n  featuresInRect(x0: number, y0: number, x1: number, y1: number): TileFeature[] {\n    if (!this.view || !this.visible) return [];\n    return featuresInRect(this.drawn.values(), [x0, y0, x1, y1]);\n  }\n\n  destroy(): void {\n    this.sub.unsubscribe();\n    this.loading?.abort();\n    if (this.replanTimer) clearTimeout(this.replanTimer);\n    if (this.drawFrame !== null) cancelFrame(this.drawFrame);\n    this.group.parentNode?.removeChild(this.group);\n    this.labelLayer.group.parentNode?.removeChild(this.labelLayer.group);\n  }\n\n  private setView(view: RegionSourceView | null): void {\n    const prev = this.view;\n    this.view = view;\n    if (!view || prev?.source !== view.source || prev.plane !== view.plane) {\n      this.tiles.clear();\n      this.loading?.abort();\n      this.loading = null;\n    }\n    if (view && prev?.source !== view.source) {\n      const hierarchy = view.source.info.hierarchy ?? [];\n      this.depthOf = hierarchyDepths(hierarchy);\n      this.parentOf = new Map(hierarchy.filter((n) => n.parent).map((n) => [n.name, n.parent as string]));\n    }\n    this.attach();\n    if (view) this.replan();\n    else this.draw();\n  }\n\n  /** The layer is the svg's first child (under the regions) while it shows a source. */\n  private attach(): void {\n    const show = !!this.view && this.visible;\n    const labels = this.labelLayer.group;\n    if (!show) {\n      this.group.parentNode?.removeChild(this.group);\n      labels.parentNode?.removeChild(labels);\n      return;\n    }\n    if (this.svg.firstChild !== this.group) this.svg.insertBefore(this.group, this.svg.firstChild);\n    if (this.group.nextSibling !== labels) this.svg.insertBefore(labels, this.group.nextSibling);\n  }\n\n  private applyCamera(): void {\n    this.group.setAttribute('transform', `matrix(${this.camera.join(' ')})`);\n  }\n\n  /** Screen px per world unit. */\n  private scale(): number {\n    const [a, b, c, d] = this.camera;\n    return Math.sqrt(Math.abs(a * d - b * c)) || 1;\n  }\n\n  /** The world box in view, padded by the margin; null when the svg has no size yet. */\n  private viewRect(): Bbox | null {\n    const { width, height } = this.size();\n    if (!(width > 0) || !(height > 0)) return null;\n    const [a, b, c, d, e, f] = this.camera;\n    const det = a * d - b * c;\n    if (!det) return null;\n    const toWorld = (sx: number, sy: number): [number, number] => {\n      const x = sx - e,\n        y = sy - f;\n      return [(d * x - c * y) / det, (a * y - b * x) / det];\n    };\n    const mx = width * SOURCE_VIEW_MARGIN,\n      my = height * SOURCE_VIEW_MARGIN;\n    const corners = [\n      toWorld(-mx, -my),\n      toWorld(width + mx, -my),\n      toWorld(-mx, height + my),\n      toWorld(width + mx, height + my),\n    ];\n    const xs = corners.map((p) => p[0]),\n      ys = corners.map((p) => p[1]);\n    return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];\n  }\n\n  /** Work out the tiles the view needs, draw what is loaded, and load the rest. */\n  private replan(): void {\n    const view = this.view;\n    if (!view) return;\n    const rect = this.viewRect();\n    if (!rect) {\n      this.wanted = [];\n      this.draw();\n      return;\n    }\n    const info = view.source.info;\n    const level = regionLevelFor(this.scale(), info.levels);\n    this.wanted = regionTilesInRect(rect, level, info.tileSize, info.bounds, SOURCE_MAX_TILES);\n    this.scheduleDraw();\n    const missing = this.wanted.filter((k) => !this.tiles.has(regionTileId(k)));\n    this.loading?.abort();\n    this.loading = null;\n    if (!missing.length) return;\n    const loading = new AbortController();\n    this.loading = loading;\n    for (const key of missing) {\n      view.source.getTile(view.plane, key, loading.signal).then(\n        (tile) => {\n          if (this.view?.source !== view.source || this.view.plane !== view.plane) return;\n          this.keep(tile);\n          this.scheduleDraw();\n        },\n        (err) => {\n          if (!isAbortError(err)) console.warn('[regions] region tile failed', err);\n        },\n      );\n    }\n  }\n\n  private keep(tile: RegionTile): void {\n    const id = regionTileId(tile);\n    this.tiles.delete(id);\n    this.tiles.set(id, tile);\n    while (this.tiles.size > LAYER_TILE_LIMIT) this.tiles.delete(this.tiles.keys().next().value as string);\n  }\n\n  private scheduleDraw(): void {\n    if (this.drawFrame !== null) return;\n    this.drawFrame = requestFrame(() => {\n      this.drawFrame = null;\n      this.draw();\n    });\n  }\n\n  /**\n   * Rebuild the paths from the wanted tiles that are loaded, a missing tile's nearest loaded\n   * ancestor standing in for it; each feature once, at the finest level loaded.\n   */\n  private draw(): void {\n    const view = this.view;\n    const drawn = new Map<string, TileFeature>();\n    const level = new Map<string, number>();\n    if (view) {\n      const used = new Set<string>();\n      for (const key of this.wanted) {\n        const tile = this.loadedOrAncestor(key);\n        if (!tile || used.has(regionTileId(tile))) continue;\n        used.add(regionTileId(tile));\n        for (const f of tile.features) {\n          if (view.taken.has(f.id) || view.isHidden?.(f.label)) continue;\n          const had = level.get(f.id);\n          if (had !== undefined && had <= tile.level) continue;\n          drawn.set(f.id, f);\n          level.set(f.id, tile.level);\n        }\n      }\n    }\n    this.drawn = drawn;\n    const filled = !!view && isFilled(view.style);\n    const frag = document.createDocumentFragment();\n    for (const run of this.runs(drawn, filled)) {\n      const path = svgEl('path');\n      path.setAttribute('d', run.features.flatMap((f) => f.rings.map((r) => ringD(r, !f.open))).join(''));\n      path.setAttribute('fill-rule', 'evenodd');\n      path.setAttribute('stroke-linejoin', 'round');\n      path.setAttribute('vector-effect', 'non-scaling-stroke');\n      if (filled && view) {\n        const paint = shapePaint(run.color, false, view.style);\n        path.setAttribute('fill', paint.fill);\n        path.setAttribute('fill-opacity', `${paint.fillOpacity}`);\n        path.setAttribute('stroke', paint.stroke);\n        path.setAttribute('stroke-width', `${paint.strokeWidth}`);\n      } else {\n        path.setAttribute('fill', 'none');\n        path.setAttribute('stroke', run.color);\n        path.setAttribute('stroke-width', `${SOURCE_STROKE_PX}`);\n      }\n      frag.appendChild(path);\n    }\n    while (this.group.firstChild) this.group.removeChild(this.group.firstChild);\n    this.group.appendChild(frag);\n    this.applyCamera();\n    this.drawLabels(filled);\n  }\n\n  /**\n   * The drawn features as paths: one per colour when outlined; filled, in paint order — parents\n   * (by the class hierarchy) and then larger features first, so what lies inside paints over\n   * them — one path per run of a colour.\n   */\n  private runs(\n    drawn: Map<string, TileFeature>,\n    filled: boolean,\n  ): Array<{ color: string; features: TileFeature[] }> {\n    const view = this.view;\n    const colorOf = (f: TileFeature) => view?.colorOf(f) ?? '#00FFFF';\n    if (!filled) {\n      const byColor = new Map<string, TileFeature[]>();\n      for (const f of drawn.values()) {\n        const color = colorOf(f);\n        const list = byColor.get(color);\n        if (list) list.push(f);\n        else byColor.set(color, [f]);\n      }\n      return Array.from(byColor, ([color, features]) => ({ color, features }));\n    }\n    const area = (f: TileFeature) => (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]);\n    const depth = (f: TileFeature) => this.depthOf.get(f.label ?? '') ?? 0;\n    const order = Array.from(drawn.values()).sort((a, b) => depth(a) - depth(b) || area(b) - area(a));\n    const runs: Array<{ color: string; features: TileFeature[] }> = [];\n    for (const f of order) {\n      const color = colorOf(f);\n      const last = runs[runs.length - 1];\n      if (last && last.color === color) last.features.push(f);\n      else runs.push({ color, features: [f] });\n    }\n    return runs;\n  }\n\n  /** Class labels inside the drawn features (each part where it fits), when labels are on. */\n  private drawLabels(filled: boolean): void {\n    this.labelLayer.clear();\n    const view = this.view;\n    if (!view?.labels) return;\n    // Only the deepest classes drawn are labelled: a class whose subclasses are drawn too (an\n    // atlas's \"Isocortex\" under its areas) would only repeat over them.\n    const covered = new Set<string>();\n    for (const f of this.drawn.values()) {\n      let p = f.label ? this.parentOf.get(f.label) : undefined;\n      while (p && !covered.has(p)) {\n        covered.add(p);\n        p = this.parentOf.get(p);\n      }\n    }\n    for (const f of this.drawn.values()) {\n      const at = f.labels;\n      if (!at || !f.label || covered.has(f.label)) continue;\n      const color = filled ? '#111' : view.colorOf(f);\n      for (let k = 0; k + 2 < at.length; k += 3) {\n        placeInsideLabel(this.labelLayer, f.label, { x: at[k], y: at[k + 1], room: at[k + 2] }, color);\n      }\n    }\n  }\n\n  /** The loaded tile for `key`, else its nearest loaded coarser ancestor. */\n  private loadedOrAncestor(key: RegionTileKey): RegionTile | null {\n    const levels = this.view?.source.info.levels ?? 0;\n    let { gx, gy } = key;\n    for (let level = key.level; level < levels; level++) {\n      const tile = this.tiles.get(regionTileId({ level, gx, gy }));\n      if (tile) return tile;\n      gx = Math.floor(gx / 2);\n      gy = Math.floor(gy / 2);\n    }\n    return null;\n  }\n}\n\n/** Path data of one ring (`closed`) or polyline, in world units to 1/100. */\nfunction ringD(ring: Float32Array, closed: boolean): string {\n  const n = ring.length >> 1;\n  if (n < 2) return '';\n  let d = `M${r2(ring[0])} ${r2(ring[1])}`;\n  for (let i = 1; i < n; i++) d += `L${r2(ring[2 * i])} ${r2(ring[2 * i + 1])}`;\n  return closed ? `${d}Z` : d;\n}\n\nfunction r2(v: number): number {\n  return Math.round(v * 100) / 100;\n}\n\nfunction svgSize(svg: SVGSVGElement): { width: number; height: number } {\n  const width = svg.clientWidth || svg.getBoundingClientRect().width;\n  const height = svg.clientHeight || svg.getBoundingClientRect().height;\n  return { width, height };\n}\n\nconst requestFrame = (fn: () => void): number =>\n  typeof requestAnimationFrame === 'function'\n    ? requestAnimationFrame(fn)\n    : (setTimeout(fn, 16) as unknown as number);\n\nconst cancelFrame = (id: number): void =>\n  typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame(id) : clearTimeout(id);\n\n/** Depth of each class in a class hierarchy (a root is 0); empty without one. */\nfunction hierarchyDepths(\n  hierarchy: ReadonlyArray<{ name: string; parent?: string | null }> | undefined,\n): Map<string, number> {\n  const depths = new Map<string, number>();\n  if (!hierarchy) return depths;\n  const parent = new Map(hierarchy.map((n) => [n.name, n.parent ?? null]));\n  for (const n of hierarchy) {\n    let d = 0;\n    let p = parent.get(n.name);\n    const seen = new Set<string>([n.name]);\n    while (p && !seen.has(p)) {\n      seen.add(p);\n      d++;\n      p = parent.get(p) ?? null;\n    }\n    depths.set(n.name, d);\n  }\n  return depths;\n}\n"]}

package/esm2022/lib/region-overlay/region-style.mjs

@@ -0,0 +1,97 @@
+/**
+ * How regions are drawn, shared by the OpenSeadragon and napari overlays and the region-source
+ * layer, so a feature looks the same before and after it is taken into the regions.
+ *
+ * Two looks: **outlines** (the default — each region stroked in its colour, filled only while
+ * selected) and **filled**, an atlas's look (each region filled in its colour, with thin outlines,
+ * the selection in a highlight colour, labels centred inside each part).
+ */
+import { MultiPolygon, Polygon, Rectangle } from '../models/region';
+import { polylabel } from '../geometry/polylabel';
+import { svgEl } from './svg-region-renderer';
+export const DEFAULT_REGION_STYLE = {
+    fillOpacity: 0,
+    stroke: null,
+    strokeWidth: null,
+    highlight: null,
+};
+/** A selected region's fill in the filled look, unless the style names one (the Allen atlas's). */
+export const DEFAULT_HIGHLIGHT = '#a020f0';
+/** Whether `style` is the filled look. */
+export function isFilled(style) {
+    return style.fillOpacity > 0;
+}
+/** The paint of a region of colour `color`, selected or not, in `style`. */
+export function shapePaint(color, selected, style = DEFAULT_REGION_STYLE) {
+    if (!isFilled(style)) {
+        return selected
+            ? { fill: color, fillOpacity: 0.35, stroke: color, strokeWidth: 4 }
+            : { fill: 'none', fillOpacity: 0, stroke: color, strokeWidth: 2 };
+    }
+    const width = style.strokeWidth ?? 1;
+    return selected
+        ? {
+            fill: style.highlight ?? DEFAULT_HIGHLIGHT,
+            fillOpacity: Math.max(style.fillOpacity, 0.85),
+            stroke: style.stroke ?? color,
+            strokeWidth: width + 1,
+        }
+        : { fill: color, fillOpacity: style.fillOpacity, stroke: style.stroke ?? color, strokeWidth: width };
+}
+/** Set `paint` on an SVG shape. */
+export function applyPaint(el, paint) {
+    el.setAttribute('fill', paint.fill);
+    el.setAttribute('fill-opacity', `${paint.fillOpacity}`);
+    el.setAttribute('stroke', paint.stroke);
+    el.setAttribute('stroke-width', `${paint.strokeWidth}`);
+}
+/** Where to label `region`: each part's pole of inaccessibility (a rectangle's centre). */
+export function regionLabelSpots(region) {
+    const b = region.bounds;
+    if (b instanceof Rectangle) {
+        const room = Math.min(Math.abs(b.width), Math.abs(b.height)) / 2;
+        return [{ x: b.x + b.width / 2, y: b.y + b.height / 2, room }];
+    }
+    const parts = b instanceof MultiPolygon ? b.polygons : b instanceof Polygon && b.closed !== false ? [b] : [];
+    const spots = [];
+    for (const p of parts) {
+        const rings = [Float64Array.from(p.xpoints.flatMap((x, i) => [x, p.ypoints[i]]))];
+        for (const hole of p.holes ?? [])
+            rings.push(Float64Array.from(hole.flat()));
+        const pole = polylabel(rings);
+        if (pole && pole.distance > 0)
+            spots.push({ x: pole.x, y: pole.y, room: pole.distance });
+    }
+    return spots;
+}
+/** Font size of a centred label, px. */
+const INSIDE_LABEL_PX = 10;
+/**
+ * A class label centred at `spot`, shown only while it fits: the room around the spot, on screen,
+ * at least half the text's width (and a few pixels). Re-checked on every camera move.
+ */
+export function placeInsideLabel(layer, text, spot, color = '#111') {
+    const el = svgEl('text');
+    el.setAttribute('fill', color);
+    el.setAttribute('font-size', `${INSIDE_LABEL_PX}`);
+    el.setAttribute('font-family', 'sans-serif');
+    el.setAttribute('text-anchor', 'middle');
+    el.setAttribute('dominant-baseline', 'central');
+    el.setAttribute('pointer-events', 'none');
+    el.textContent = text;
+    const halfWidth = (text.length * INSIDE_LABEL_PX * 0.6) / 2;
+    return layer.place(el, (e, project) => {
+        const [sx, sy] = project(spot.x, spot.y);
+        e.setAttribute('x', `${sx}`);
+        e.setAttribute('y', `${sy}`);
+        e.style.display = labelFits(project, spot, halfWidth) ? '' : 'none';
+    });
+}
+/** Whether a label `halfWidth` px wide fits around `spot` through `project`. */
+export function labelFits(project, spot, halfWidth) {
+    const [ax, ay] = project(spot.x, spot.y);
+    const [bx, by] = project(spot.x + spot.room, spot.y);
+    const roomPx = Math.hypot(bx - ax, by - ay);
+    return roomPx >= Math.max(halfWidth * 0.8, INSIDE_LABEL_PX * 0.6);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-style.js","sourceRoot":"","sources":["../../../../src/lib/region-overlay/region-style.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS,EAAU,MAAM,kBAAkB,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAc9C,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,WAAW,EAAE,CAAC;IACd,MAAM,EAAE,IAAI;IACZ,WAAW,EAAE,IAAI;IACjB,SAAS,EAAE,IAAI;CAChB,CAAC;AAEF,mGAAmG;AACnG,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAC;AAE3C,0CAA0C;AAC1C,MAAM,UAAU,QAAQ,CAAC,KAAkB;IACzC,OAAO,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;AAC/B,CAAC;AAUD,4EAA4E;AAC5E,MAAM,UAAU,UAAU,CACxB,KAAa,EACb,QAAiB,EACjB,QAAqB,oBAAoB;IAEzC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,QAAQ;YACb,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE;YACnE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;IACtE,CAAC;IACD,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,IAAI,CAAC,CAAC;IACrC,OAAO,QAAQ;QACb,CAAC,CAAC;YACE,IAAI,EAAE,KAAK,CAAC,SAAS,IAAI,iBAAiB;YAC1C,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC;YAC9C,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,KAAK;YAC7B,WAAW,EAAE,KAAK,GAAG,CAAC;SACvB;QACH,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AACzG,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,UAAU,CAAC,EAAc,EAAE,KAAiB;IAC1D,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IACpC,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IACxD,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxC,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;AAC1D,CAAC;AASD,2FAA2F;AAC3F,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACxB,IAAI,CAAC,YAAY,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;QACjE,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACjE,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,YAAY,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,OAAO,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7G,MAAM,KAAK,GAAgB,EAAE,CAAC;IAC9B,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,MAAM,KAAK,GAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClG,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE;YAAE,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAC7E,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC;YAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC3F,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,wCAAwC;AACxC,MAAM,eAAe,GAAG,EAAE,CAAC;AAE3B;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAkB,EAClB,IAAY,EACZ,IAAe,EACf,KAAK,GAAG,MAAM;IAEd,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC/B,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,eAAe,EAAE,CAAC,CAAC;IACnD,EAAE,CAAC,YAAY,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;IAC7C,EAAE,CAAC,YAAY,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IACzC,EAAE,CAAC,YAAY,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;IAChD,EAAE,CAAC,YAAY,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;IAC1C,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC;IACtB,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,eAAe,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;IAC5D,OAAO,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE;QACpC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QAC7B,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QAC7B,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,SAAS,CAAC,OAAgB,EAAE,IAAe,EAAE,SAAiB;IAC5E,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACzC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACrD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAC5C,OAAO,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,GAAG,EAAE,eAAe,GAAG,GAAG,CAAC,CAAC;AACpE,CAAC","sourcesContent":["/**\n * How regions are drawn, shared by the OpenSeadragon and napari overlays and the region-source\n * layer, so a feature looks the same before and after it is taken into the regions.\n *\n * Two looks: **outlines** (the default — each region stroked in its colour, filled only while\n * selected) and **filled**, an atlas's look (each region filled in its colour, with thin outlines,\n * the selection in a highlight colour, labels centred inside each part).\n */\nimport { MultiPolygon, Polygon, Rectangle, Region } from '../models/region';\nimport { polylabel } from '../geometry/polylabel';\nimport type { Project, ScreenLayer } from './svg-region-renderer';\nimport { svgEl } from './svg-region-renderer';\n\n/** The region look (see the module doc). */\nexport interface RegionStyle {\n  /** Fill each region at this opacity; 0 draws outlines only. */\n  fillOpacity: number;\n  /** Outline colour of a filled region; null: its own colour. */\n  stroke: string | null;\n  /** Outline width of a filled region, screen px; null: 1. */\n  strokeWidth: number | null;\n  /** Fill colour of a selected filled region; null: {@link DEFAULT_HIGHLIGHT}. */\n  highlight: string | null;\n}\n\nexport const DEFAULT_REGION_STYLE: RegionStyle = {\n  fillOpacity: 0,\n  stroke: null,\n  strokeWidth: null,\n  highlight: null,\n};\n\n/** A selected region's fill in the filled look, unless the style names one (the Allen atlas's). */\nexport const DEFAULT_HIGHLIGHT = '#a020f0';\n\n/** Whether `style` is the filled look. */\nexport function isFilled(style: RegionStyle): boolean {\n  return style.fillOpacity > 0;\n}\n\n/** The paint of one region shape. */\nexport interface ShapePaint {\n  fill: string;\n  fillOpacity: number;\n  stroke: string;\n  strokeWidth: number;\n}\n\n/** The paint of a region of colour `color`, selected or not, in `style`. */\nexport function shapePaint(\n  color: string,\n  selected: boolean,\n  style: RegionStyle = DEFAULT_REGION_STYLE,\n): ShapePaint {\n  if (!isFilled(style)) {\n    return selected\n      ? { fill: color, fillOpacity: 0.35, stroke: color, strokeWidth: 4 }\n      : { fill: 'none', fillOpacity: 0, stroke: color, strokeWidth: 2 };\n  }\n  const width = style.strokeWidth ?? 1;\n  return selected\n    ? {\n        fill: style.highlight ?? DEFAULT_HIGHLIGHT,\n        fillOpacity: Math.max(style.fillOpacity, 0.85),\n        stroke: style.stroke ?? color,\n        strokeWidth: width + 1,\n      }\n    : { fill: color, fillOpacity: style.fillOpacity, stroke: style.stroke ?? color, strokeWidth: width };\n}\n\n/** Set `paint` on an SVG shape. */\nexport function applyPaint(el: SVGElement, paint: ShapePaint): void {\n  el.setAttribute('fill', paint.fill);\n  el.setAttribute('fill-opacity', `${paint.fillOpacity}`);\n  el.setAttribute('stroke', paint.stroke);\n  el.setAttribute('stroke-width', `${paint.strokeWidth}`);\n}\n\n/** A point to label a part at, and the room around it (image px). */\nexport interface LabelSpot {\n  x: number;\n  y: number;\n  room: number;\n}\n\n/** Where to label `region`: each part's pole of inaccessibility (a rectangle's centre). */\nexport function regionLabelSpots(region: Region): LabelSpot[] {\n  const b = region.bounds;\n  if (b instanceof Rectangle) {\n    const room = Math.min(Math.abs(b.width), Math.abs(b.height)) / 2;\n    return [{ x: b.x + b.width / 2, y: b.y + b.height / 2, room }];\n  }\n  const parts = b instanceof MultiPolygon ? b.polygons : b instanceof Polygon && b.closed !== false ? [b] : [];\n  const spots: LabelSpot[] = [];\n  for (const p of parts) {\n    const rings: Float64Array[] = [Float64Array.from(p.xpoints.flatMap((x, i) => [x, p.ypoints[i]]))];\n    for (const hole of p.holes ?? []) rings.push(Float64Array.from(hole.flat()));\n    const pole = polylabel(rings);\n    if (pole && pole.distance > 0) spots.push({ x: pole.x, y: pole.y, room: pole.distance });\n  }\n  return spots;\n}\n\n/** Font size of a centred label, px. */\nconst INSIDE_LABEL_PX = 10;\n\n/**\n * A class label centred at `spot`, shown only while it fits: the room around the spot, on screen,\n * at least half the text's width (and a few pixels). Re-checked on every camera move.\n */\nexport function placeInsideLabel(\n  layer: ScreenLayer,\n  text: string,\n  spot: LabelSpot,\n  color = '#111',\n): SVGTextElement {\n  const el = svgEl('text');\n  el.setAttribute('fill', color);\n  el.setAttribute('font-size', `${INSIDE_LABEL_PX}`);\n  el.setAttribute('font-family', 'sans-serif');\n  el.setAttribute('text-anchor', 'middle');\n  el.setAttribute('dominant-baseline', 'central');\n  el.setAttribute('pointer-events', 'none');\n  el.textContent = text;\n  const halfWidth = (text.length * INSIDE_LABEL_PX * 0.6) / 2;\n  return layer.place(el, (e, project) => {\n    const [sx, sy] = project(spot.x, spot.y);\n    e.setAttribute('x', `${sx}`);\n    e.setAttribute('y', `${sy}`);\n    e.style.display = labelFits(project, spot, halfWidth) ? '' : 'none';\n  });\n}\n\n/** Whether a label `halfWidth` px wide fits around `spot` through `project`. */\nexport function labelFits(project: Project, spot: LabelSpot, halfWidth: number): boolean {\n  const [ax, ay] = project(spot.x, spot.y);\n  const [bx, by] = project(spot.x + spot.room, spot.y);\n  const roomPx = Math.hypot(bx - ax, by - ay);\n  return roomPx >= Math.max(halfWidth * 0.8, INSIDE_LABEL_PX * 0.6);\n}\n"]}