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

package/esm2022/lib/region-source/region-tiles.mjs

@@ -0,0 +1,708 @@
+/**
+ * The pure core of a tiled region source: a large GeoJSON region set cut into tiles per level
+ * of detail, the outlines simplified per level, so a view only ever holds and draws what is on
+ * screen at the detail the zoom can show.
+ *
+ * Levels: level 0 is exact; a level-k tile covers `tileSize · 2ᵏ` image pixels and its outlines
+ * are simplified (Douglas–Peucker) to `2ᵏ⁻¹` image pixels — half to one screen pixel at the zooms
+ * that pick that level ({@link regionLevelFor}). A feature under `2ᵏ` image pixels (one to two
+ * screen pixels there) is left out of the level. A tile holds the WHOLE simplified feature (not
+ * clipped) for every feature whose box meets it, so a view de-duplicates features by id, and at
+ * level 0 the tiles in view hold the exact outline of everything visible.
+ *
+ * No DOM, no Angular: the same code runs in the region-source worker and, where workers do not
+ * exist, on the main thread.
+ */
+import { rgbToHex } from '../contracts/color';
+import { simplifyRing } from '../geometry/ring';
+import { polylabel } from '../geometry/polylabel';
+import { ringsArea } from '../geometry/reconstruct';
+/** Edge of a level-0 tile, in image pixels. */
+export const REGION_TILE_SIZE = 512;
+/**
+ * The level whose tiles suit a zoom of `pxPerImagePx` screen pixels per image pixel: exact (0)
+ * at 1:1 and closer, else level k for zooms in [2⁻ᵏ, 2¹⁻ᵏ), where its tolerance is half to one
+ * screen pixel and the features it leaves out are under one or two.
+ */
+export function regionLevelFor(pxPerImagePx, levels) {
+    if (!(pxPerImagePx > 0) || levels <= 1)
+        return 0;
+    const level = Math.ceil(-Math.log2(pxPerImagePx) - 1e-9);
+    return Math.max(0, Math.min(levels - 1, level));
+}
+/** Simplification tolerance of a level, in image pixels (0 = exact). */
+export function levelTolerance(level) {
+    return level <= 0 ? 0 : 2 ** (level - 1);
+}
+/** Features smaller than this (their box's longer side, image pixels) are left out of a level. */
+export function levelMinExtent(level) {
+    return level <= 0 ? 0 : 2 ** level;
+}
+/** Tile edge of a level, in image pixels. */
+export function levelTileSize(level, tileSize = REGION_TILE_SIZE) {
+    return tileSize * 2 ** level;
+}
+/**
+ * Tiles of `level` that meet `rect`, clipped to `bounds` (none past the data), ordered from the
+ * rectangle's centre outward so the middle of the screen fills first. At most `limit`.
+ */
+export function regionTilesInRect(rect, level, tileSize, bounds, limit = Infinity) {
+    if (!bounds)
+        return [];
+    const x0 = Math.max(rect[0], bounds[0]);
+    const y0 = Math.max(rect[1], bounds[1]);
+    const x1 = Math.min(rect[2], bounds[2]);
+    const y1 = Math.min(rect[3], bounds[3]);
+    if (x1 < x0 || y1 < y0)
+        return [];
+    const size = levelTileSize(level, tileSize);
+    const gx0 = Math.floor(x0 / size);
+    const gy0 = Math.floor(y0 / size);
+    const gx1 = Math.floor(x1 / size);
+    const gy1 = Math.floor(y1 / size);
+    const cx = (rect[0] + rect[2]) / 2 / size;
+    const cy = (rect[1] + rect[3]) / 2 / size;
+    const out = [];
+    for (let gy = gy0; gy <= gy1; gy++) {
+        for (let gx = gx0; gx <= gx1; gx++)
+            out.push({ level, gx, gy });
+    }
+    const d = (k) => (k.gx + 0.5 - cx) ** 2 + (k.gy + 0.5 - cy) ** 2;
+    out.sort((a, b) => d(a) - d(b));
+    return out.length > limit ? out.slice(0, limit) : out;
+}
+/** `level/gx/gy`, a tile's id within one plane. */
+export function regionTileId(k) {
+    return `${k.level}/${k.gx}/${k.gy}`;
+}
+/** The tile of `level` holding image point (x, y). */
+export function tileAt(x, y, level, tileSize = REGION_TILE_SIZE) {
+    const size = levelTileSize(level, tileSize);
+    return { level, gx: Math.floor(x / size), gy: Math.floor(y / size) };
+}
+/** True when two boxes meet (edges included). */
+export function bboxesMeet(a, b) {
+    return a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];
+}
+// ── Picking ──────────────────────────────────────────────────────────────────────────────
+/**
+ * The feature under image point (x, y): inside an area (even-odd over its rings, so holes are
+ * outside) or within `tolerance` image pixels of a polyline. Of several, the one with the
+ * smallest box — the innermost of nested outlines. Null when none is.
+ */
+export function featureAt(features, x, y, tolerance = 0) {
+    let best = null;
+    let bestArea = Infinity;
+    for (const f of features) {
+        const b = f.bbox;
+        if (x < b[0] - tolerance || x > b[2] + tolerance || y < b[1] - tolerance || y > b[3] + tolerance)
+            continue;
+        const hit = f.open ? nearPolylines(f.rings, x, y, tolerance) : insideRings(f.rings, x, y);
+        if (!hit)
+            continue;
+        const area = (b[2] - b[0]) * (b[3] - b[1]);
+        if (area < bestArea) {
+            best = f;
+            bestArea = area;
+        }
+    }
+    return best;
+}
+/** Features whose box meets `rect` (the rubber band's rule for regions). */
+export function featuresInRect(features, rect) {
+    const out = [];
+    for (const f of features)
+        if (bboxesMeet(f.bbox, rect))
+            out.push(f);
+    return out;
+}
+/** Even-odd containment over interleaved rings. */
+export function insideRings(rings, x, y) {
+    let inside = false;
+    for (const r of rings) {
+        const n = r.length >> 1;
+        if (n < 3)
+            continue;
+        for (let i = 0, j = n - 1; i < n; j = i++) {
+            const xi = r[2 * i], yi = r[2 * i + 1], xj = r[2 * j], yj = r[2 * j + 1];
+            if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi)
+                inside = !inside;
+        }
+    }
+    return inside;
+}
+function nearPolylines(lines, x, y, tolerance) {
+    for (const l of lines) {
+        for (let i = 2; i + 1 < l.length; i += 2) {
+            if (segmentDistance(x, y, l[i - 2], l[i - 1], l[i], l[i + 1]) <= tolerance)
+                return true;
+        }
+    }
+    return false;
+}
+function segmentDistance(px, py, ax, ay, bx, by) {
+    const dx = bx - ax, dy = by - ay;
+    const len2 = dx * dx + dy * dy;
+    const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / len2));
+    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+// ── Simplification ───────────────────────────────────────────────────────────────────────
+/** Douglas–Peucker over an open polyline (both ends kept). */
+export function simplifyPolyline(xs, ys, epsilon) {
+    const n = xs.length;
+    if (n <= 2 || !(epsilon > 0))
+        return { xs: xs.slice(), ys: ys.slice() };
+    const keep = new Uint8Array(n);
+    keep[0] = keep[n - 1] = 1;
+    const stack = [[0, n - 1]];
+    while (stack.length) {
+        const [a, b] = stack.pop();
+        let maxD = -1, idx = -1;
+        for (let i = a + 1; i < b; i++) {
+            const d = segmentDistance(xs[i], ys[i], xs[a], ys[a], xs[b], ys[b]);
+            if (d > maxD) {
+                maxD = d;
+                idx = i;
+            }
+        }
+        if (maxD > epsilon) {
+            keep[idx] = 1;
+            stack.push([a, idx], [idx, b]);
+        }
+    }
+    const ox = [], oy = [];
+    for (let i = 0; i < n; i++) {
+        if (keep[i]) {
+            ox.push(xs[i]);
+            oy.push(ys[i]);
+        }
+    }
+    return { xs: ox, ys: oy };
+}
+/**
+ * Rings simplified for a level: every ring through Douglas–Peucker at the level's tolerance,
+ * rings whose box is under the level's minimum extent dropped, and rings left with too few
+ * vertices to draw (3 for a closed ring, 2 for a polyline) dropped. Level 0 returns the rings
+ * as they are.
+ */
+export function simplifyRings(rings, open, level) {
+    const tol = levelTolerance(level);
+    const minExtent = levelMinExtent(level);
+    const minVertices = open ? 2 : 3;
+    const out = [];
+    for (const ring of rings) {
+        const n = ring.length >> 1;
+        if (n < minVertices)
+            continue;
+        if (tol === 0) {
+            out.push(Float32Array.from(ring));
+            continue;
+        }
+        const xs = new Array(n), ys = new Array(n);
+        let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+        for (let i = 0; i < n; i++) {
+            const x = ring[2 * i], y = ring[2 * i + 1];
+            xs[i] = x;
+            ys[i] = y;
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+        }
+        if (Math.max(x1 - x0, y1 - y0) < minExtent)
+            continue;
+        const s = open ? simplifyPolyline(xs, ys, tol) : simplifyRing(xs, ys, tol);
+        if (s.xs.length < minVertices)
+            continue;
+        const flat = new Float32Array(s.xs.length * 2);
+        for (let i = 0; i < s.xs.length; i++) {
+            flat[2 * i] = s.xs[i];
+            flat[2 * i + 1] = s.ys[i];
+        }
+        out.push(flat);
+    }
+    return out;
+}
+// ── The feature table ────────────────────────────────────────────────────────────────────
+/** Features (and their simplified outlines) cached per level, past which the oldest go. */
+const SIMPLIFIED_CACHE_LIMIT = 200_000;
+/**
+ * A parsed GeoJSON region set, indexed for tiles. Holds the raw features (for the exact
+ * geometry and the export), each feature's rings, box, plane and class, and builds a level's
+ * tile buckets the first time that level of a plane is asked for.
+ */
+export class RegionFeatureTable {
+    constructor(raw, tileSize = REGION_TILE_SIZE) {
+        this.raw = raw;
+        this.tileSize = tileSize;
+        this.ids = [];
+        this.labels = [];
+        this.colors = [];
+        this.planes = [];
+        this.boxes = [];
+        this.rings = [];
+        this.open = [];
+        /** Per feature, its parts as ring indices (the exterior first, then its holes). */
+        this.parts = [];
+        this.labelPoints = new Map();
+        /** Each feature's area, worked out the first time its row is asked for. */
+        this.areas = new Map();
+        this.byId = new Map();
+        this.buckets = new Map();
+        this.simplified = new Map();
+        let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+        raw.forEach((feature, i) => {
+            const own = featureIdOf(feature);
+            let id = own;
+            if (id === undefined || this.byId.has(id)) {
+                // Its position, unless a feature already has that id (an explicit "#1", say): ids are unique,
+                // or a take, an exclusion or an export would act on both.
+                id = `#${i}`;
+                for (let k = 1; this.byId.has(id); k++)
+                    id = `#${i}-${k}`;
+            }
+            this.byId.set(id, i);
+            this.ids.push(id);
+            const { label, color } = classificationOf(feature);
+            this.labels.push(label);
+            this.colors.push(color);
+            this.planes.push(feature?.geometry?.plane?.z ?? 0);
+            const { rings, open, parts } = ringsOf(feature);
+            this.rings.push(rings);
+            this.open.push(open);
+            this.parts.push(parts);
+            const box = ringsBox(rings);
+            this.boxes.push(box);
+            if (rings.length) {
+                x0 = Math.min(x0, box[0]);
+                y0 = Math.min(y0, box[1]);
+                x1 = Math.max(x1, box[2]);
+                y1 = Math.max(y1, box[3]);
+            }
+        });
+        this.bounds = x0 <= x1 ? [x0, y0, x1, y1] : null;
+        const extent = this.bounds ? Math.max(Math.abs(x0), Math.abs(y0), Math.abs(x1), Math.abs(y1)) : 0;
+        this.levels = 1 + Math.max(0, Math.ceil(Math.log2(Math.max(extent, tileSize) / tileSize)));
+    }
+    /** Parse a GeoJSON FeatureCollection string. Throws on invalid JSON or no `features`. */
+    static fromGeoJson(text, tileSize = REGION_TILE_SIZE) {
+        const parsed = JSON.parse(text);
+        if (!parsed || !Array.isArray(parsed.features)) {
+            throw new Error("Invalid GeoJson file: must contain the 'features' key.");
+        }
+        const table = new RegionFeatureTable(parsed.features, tileSize);
+        table.describe(parsed.classHierarchy, parsed.style);
+        return table;
+    }
+    /** Attach a class hierarchy and a style hint (each ignored when not well formed). */
+    describe(hierarchy, style) {
+        this.hierarchy = readHierarchy(hierarchy) ?? this.hierarchy;
+        this.style = readStyle(style) ?? this.style;
+    }
+    /**
+     * The outlines of every feature of these classes, plane by plane, simplified for `level` (what a
+     * 3D reconstruction of the classes stacks), without the `exclude`d ids: closed features' rings,
+     * open features' polylines as `lines`, each ring with its feature (`ringGroups`). Planes without
+     * one are left out. `classes` null reads every labelled feature, each outline with its class
+     * (`ringLabels`, `lineLabels`).
+     */
+    classOutlines(classes, level, exclude = []) {
+        const wanted = classes ? new Set(classes) : null;
+        const skip = new Set(exclude);
+        const byPlane = new Map();
+        for (let i = 0; i < this.ids.length; i++) {
+            const label = this.labels[i];
+            if (!label || (wanted && !wanted.has(label)) || skip.has(this.ids[i]))
+                continue;
+            const rings = this.ringsAt(i, level);
+            if (!rings.length)
+                continue;
+            const z = this.planes[i];
+            let plane = byPlane.get(z);
+            if (!plane)
+                byPlane.set(z, (plane = { z, rings: [] }));
+            if (this.open[i]) {
+                (plane.lines ??= []).push(...rings);
+                if (!wanted)
+                    (plane.lineLabels ??= []).push(...rings.map(() => label));
+            }
+            else {
+                plane.rings.push(...rings);
+                (plane.ringGroups ??= []).push(...rings.map(() => i));
+                if (!wanted)
+                    (plane.ringLabels ??= []).push(...rings.map(() => label));
+            }
+        }
+        return Array.from(byPlane.values()).sort((a, b) => a.z - b.z);
+    }
+    /** Features per class on plane `z` (null: on every plane), without the `exclude`d ids. */
+    classCounts(z, exclude = []) {
+        const skip = new Set(exclude);
+        const counts = {};
+        for (let i = 0; i < this.ids.length; i++) {
+            const label = this.labels[i];
+            if ((z !== null && this.planes[i] !== z) || !label || skip.has(this.ids[i]))
+                continue;
+            counts[label] = (counts[label] ?? 0) + 1;
+        }
+        return counts;
+    }
+    info() {
+        const classColors = {};
+        this.labels.forEach((label, i) => {
+            const color = this.colors[i];
+            if (label && color && !(label in classColors))
+                classColors[label] = color;
+        });
+        return {
+            featureCount: this.ids.length,
+            bounds: this.bounds,
+            tileSize: this.tileSize,
+            levels: this.levels,
+            planes: Array.from(new Set(this.planes)).sort((a, b) => a - b),
+            classColors,
+            ...(this.hierarchy ? { hierarchy: this.hierarchy } : {}),
+            ...(this.style ? { style: this.style } : {}),
+        };
+    }
+    /** One tile of plane `z`. */
+    tile(z, level, gx, gy) {
+        const { cells, wide } = this.bucketsFor(z, level);
+        const bucket = cells.get(`${gx}/${gy}`) ?? [];
+        const size = levelTileSize(level, this.tileSize);
+        const features = [];
+        // The tile's cell features and the wide ones that meet it, merged back into file order.
+        const order = [];
+        for (let a = 0, w = 0; a < bucket.length || w < wide.length;) {
+            if (w >= wide.length || (a < bucket.length && bucket[a] < wide[w]))
+                order.push(bucket[a++]);
+            else {
+                const i = wide[w++];
+                if (cellMeets(this.boxes[i], size, gx, gy))
+                    order.push(i);
+            }
+        }
+        for (const i of order) {
+            const rings = this.ringsAt(i, level);
+            if (!rings.length)
+                continue;
+            const labels = this.labelsAt(i, level);
+            features.push({
+                id: this.ids[i],
+                label: this.labels[i],
+                color: this.colors[i],
+                bbox: this.boxes[i],
+                rings,
+                open: this.open[i],
+                ...(labels ? { labels } : {}),
+            });
+        }
+        return { z, level, gx, gy, features };
+    }
+    /** The raw GeoJSON features with these ids, in the order asked (unknown ids skipped). */
+    features(ids) {
+        const out = [];
+        for (const id of ids) {
+            const i = this.byId.get(id);
+            if (i !== undefined)
+                out.push({ id, feature: this.raw[i] });
+        }
+        return out;
+    }
+    /** Feature `i`'s area in px² (0 for a polyline). */
+    areaOf(i) {
+        let area = this.areas.get(i);
+        if (area === undefined) {
+            area = this.open[i] ? 0 : ringsArea(this.rings[i]);
+            this.areas.set(i, area);
+        }
+        return area;
+    }
+    /** A page of plane `z`'s features, in file order. */
+    index(z, query) {
+        const exclude = new Set(query.exclude ?? []);
+        const classes = query.classes ? new Set(query.classes) : null;
+        const needle = query.label?.trim().toLowerCase() || null;
+        const rows = [];
+        let total = 0;
+        for (let i = 0; i < this.ids.length; i++) {
+            if (this.planes[i] !== z || exclude.has(this.ids[i]))
+                continue;
+            if (needle && !(this.labels[i] ?? '').toLowerCase().includes(needle))
+                continue;
+            if (classes && !classes.has(this.labels[i] ?? ''))
+                continue;
+            if (total >= query.offset && rows.length < query.limit) {
+                rows.push({
+                    id: this.ids[i],
+                    label: this.labels[i],
+                    color: this.colors[i],
+                    bbox: this.boxes[i],
+                    area: this.areaOf(i),
+                });
+            }
+            total++;
+        }
+        return { total, rows };
+    }
+    /**
+     * The source as a GeoJSON FeatureCollection string, through the working set: features whose
+     * id is in `exclude` (taken for editing, or deleted) are left out, `extra` (the working set's
+     * features) appended. Every feature keeps an `id`; the set keeps its hierarchy and style.
+     */
+    exportGeoJson(exclude, extra) {
+        const skip = new Set(exclude);
+        const parts = [];
+        this.raw.forEach((feature, i) => {
+            const id = this.ids[i];
+            if (skip.has(id))
+                return;
+            parts.push(JSON.stringify(feature.id === undefined ? { type: 'Feature', id, ...feature } : feature));
+        });
+        for (const f of extra)
+            parts.push(JSON.stringify(f));
+        return featureCollectionJson(parts, this.hierarchy, this.style);
+    }
+    /**
+     * Feature `i`'s label points (one per part with room for a label at `level`: a part under the
+     * level's minimum extent is not drawn there), from the exact geometry, computed once.
+     */
+    labelsAt(i, level) {
+        if (this.open[i] || !this.labels[i])
+            return null;
+        let points = this.labelPoints.get(i);
+        if (!points) {
+            const out = [];
+            for (const part of this.parts[i]) {
+                const pole = polylabel(part.map((r) => this.rings[i][r]));
+                if (pole && pole.distance > 0)
+                    out.push(pole.x, pole.y, pole.distance);
+            }
+            points = Float32Array.from(out);
+            this.labelPoints.set(i, points);
+        }
+        const min = levelMinExtent(level) / 2;
+        if (!min)
+            return points.length ? points : null;
+        const kept = [];
+        for (let k = 0; k + 2 < points.length; k += 3)
+            if (points[k + 2] >= min)
+                kept.push(points[k], points[k + 1], points[k + 2]);
+        return kept.length ? Float32Array.from(kept) : null;
+    }
+    /** Feature `i`'s rings at `level`, simplified once and cached. */
+    ringsAt(i, level) {
+        const key = `${level}/${i}`;
+        let rings = this.simplified.get(key);
+        if (!rings) {
+            rings = simplifyRings(this.rings[i], this.open[i], level);
+            if (this.simplified.size >= SIMPLIFIED_CACHE_LIMIT) {
+                const oldest = this.simplified.keys().next().value;
+                this.simplified.delete(oldest);
+            }
+            this.simplified.set(key, rings);
+        }
+        return rings;
+    }
+    /** Entries in plane `z`'s level-`level` index: cell listings plus wide features (tests). */
+    indexEntries(z, level) {
+        const { cells, wide } = this.bucketsFor(z, level);
+        let n = wide.length;
+        for (const list of cells.values())
+            n += list.length;
+        return n;
+    }
+    /**
+     * Plane `z`'s level-`level` index, built on first use: features by tile cell (`gx/gy` → feature
+     * indices), and the wide ones (more than {@link MAX_CELLS_PER_FEATURE} cells, or past the
+     * number range), tested against a tile when it is asked for.
+     */
+    bucketsFor(z, level) {
+        const key = `${z}/${level}`;
+        let index = this.buckets.get(key);
+        if (index)
+            return index;
+        const cells = new Map();
+        const wide = [];
+        const size = levelTileSize(level, this.tileSize);
+        const minExtent = levelMinExtent(level);
+        for (let i = 0; i < this.ids.length; i++) {
+            if (this.planes[i] !== z || !this.rings[i].length)
+                continue;
+            const b = this.boxes[i];
+            if (Math.max(b[2] - b[0], b[3] - b[1]) < minExtent)
+                continue;
+            const gx0 = Math.floor(b[0] / size), gx1 = Math.floor(b[2] / size), gy0 = Math.floor(b[1] / size), gy1 = Math.floor(b[3] / size);
+            // A box with a NaN coordinate meets no tile.
+            if ([gx0, gx1, gy0, gy1].some(Number.isNaN))
+                continue;
+            const count = (gx1 - gx0 + 1) * (gy1 - gy0 + 1);
+            if (!(count <= MAX_CELLS_PER_FEATURE) || ![gx0, gx1, gy0, gy1].every(Number.isSafeInteger)) {
+                wide.push(i);
+                continue;
+            }
+            for (let gy = gy0; gy <= gy1; gy++) {
+                for (let gx = gx0; gx <= gx1; gx++) {
+                    const id = `${gx}/${gy}`;
+                    const list = cells.get(id);
+                    if (list)
+                        list.push(i);
+                    else
+                        cells.set(id, [i]);
+                }
+            }
+        }
+        index = { cells, wide };
+        this.buckets.set(key, index);
+        return index;
+    }
+}
+/**
+ * A feature spanning more tiles than this is not listed in each of them but kept aside and tested
+ * against a tile when one is asked for: one huge box (an outline around a whole slide, or a corrupt
+ * coordinate) must not make a plane's index millions of entries.
+ */
+export const MAX_CELLS_PER_FEATURE = 64;
+/** Whether box `b` meets cell (gx, gy) of tiles `size` pixels wide, as a cell lists it. */
+function cellMeets(b, size, gx, gy) {
+    return (Math.floor(b[0] / size) <= gx &&
+        gx <= Math.floor(b[2] / size) &&
+        Math.floor(b[1] / size) <= gy &&
+        gy <= Math.floor(b[3] / size));
+}
+/** A feature's own id (`id`, else `properties.id`) as a string. */
+export function featureIdOf(feature) {
+    const id = feature?.id ?? feature?.properties?.id;
+    return typeof id === 'string' || typeof id === 'number' ? String(id) : undefined;
+}
+/** Class name and colour from QuPath's `classification` (`{name, color}`, or a bare name). */
+function classificationOf(feature) {
+    const c = feature?.properties?.classification;
+    if (!c)
+        return { label: 'Cell', color: null };
+    if (typeof c === 'string')
+        return { label: c, color: null };
+    const color = Array.isArray(c.color) && c.color.length >= 3 ? rgbToHex([c.color[0], c.color[1], c.color[2]]) : null;
+    return { label: c.name ?? null, color };
+}
+/**
+ * A feature's rings, interleaved, without the closing vertex; whether it is a polyline; and its
+ * parts as ring indices (each part's exterior first, then its holes).
+ */
+function ringsOf(feature) {
+    const g = feature?.geometry;
+    const coords = g?.coordinates;
+    if (!g || !Array.isArray(coords))
+        return { rings: [], open: false, parts: [] };
+    const polygons = (list) => {
+        const rings = [];
+        const parts = [];
+        for (const polygon of list) {
+            const part = [];
+            for (const r of polygon) {
+                part.push(rings.length);
+                rings.push(flatRing(r, true));
+            }
+            if (part.length)
+                parts.push(part);
+        }
+        return { rings, open: false, parts };
+    };
+    switch (g.type) {
+        case 'Polygon':
+            return polygons([coords]);
+        case 'MultiPolygon':
+            return polygons(coords);
+        case 'LineString':
+            return { rings: [flatRing(coords, false)], open: true, parts: [] };
+        case 'MultiLineString':
+            return { rings: coords.map((r) => flatRing(r, false)), open: true, parts: [] };
+        default:
+            return { rings: [], open: false, parts: [] };
+    }
+}
+/**
+ * A FeatureCollection string of `features` (each a feature's JSON), with the set's class hierarchy
+ * and style as its `classHierarchy` and `style` members when it has them: what
+ * {@link RegionFeatureTable.fromGeoJson} reads back.
+ */
+export function featureCollectionJson(features, hierarchy, style) {
+    const head = ['"type":"FeatureCollection"'];
+    if (hierarchy?.length)
+        head.push(`"classHierarchy":${JSON.stringify(hierarchy)}`);
+    if (style)
+        head.push(`"style":${JSON.stringify(style)}`);
+    return `{${head.join(',')},"features":[${features.join(',')}]}`;
+}
+/** A well-formed class hierarchy from a file (colours as `#rrggbb` or `[r, g, b]`), else undefined. */
+export function readHierarchy(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const n of raw) {
+        if (!n || typeof n.name !== 'string')
+            continue;
+        const color = Array.isArray(n.color) ? rgbToHex([+n.color[0], +n.color[1], +n.color[2]]) : n.color;
+        out.push({
+            name: n.name,
+            ...(typeof n.title === 'string' ? { title: n.title } : {}),
+            ...(typeof n.parent === 'string' ? { parent: n.parent } : {}),
+            ...(typeof color === 'string' ? { color } : {}),
+            ...(typeof n.order === 'number' ? { order: n.order } : {}),
+        });
+    }
+    return out.length ? out : undefined;
+}
+/** A well-formed style hint from a file, else undefined. */
+export function readStyle(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const r = raw;
+    const style = {};
+    if (typeof r.fillOpacity === 'number')
+        style.fillOpacity = Math.max(0, Math.min(1, r.fillOpacity));
+    if (typeof r.stroke === 'string')
+        style.stroke = r.stroke;
+    if (typeof r.strokeWidth === 'number' && r.strokeWidth > 0)
+        style.strokeWidth = r.strokeWidth;
+    if (typeof r.labels === 'boolean')
+        style.labels = r.labels;
+    if (typeof r.highlight === 'string')
+        style.highlight = r.highlight;
+    return Object.keys(style).length ? style : undefined;
+}
+function flatRing(points, closed) {
+    let n = points?.length ?? 0;
+    if (closed && n > 1) {
+        const a = points[0], b = points[n - 1];
+        if (a[0] === b[0] && a[1] === b[1])
+            n--;
+    }
+    const out = new Float64Array(n * 2);
+    for (let i = 0; i < n; i++) {
+        out[2 * i] = +points[i][0];
+        out[2 * i + 1] = +points[i][1];
+    }
+    return out;
+}
+function ringsBox(rings) {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const r of rings) {
+        for (let i = 0; i + 1 < r.length; i += 2) {
+            if (r[i] < x0)
+                x0 = r[i];
+            if (r[i] > x1)
+                x1 = r[i];
+            if (r[i + 1] < y0)
+                y0 = r[i + 1];
+            if (r[i + 1] > y1)
+                y1 = r[i + 1];
+        }
+    }
+    return [x0, y0, x1, y1];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-tiles.js","sourceRoot":"","sources":["../../../../src/lib/region-source/region-tiles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The pure core of a tiled region source: a large GeoJSON region set cut into tiles per level\n * of detail, the outlines simplified per level, so a view only ever holds and draws what is on\n * screen at the detail the zoom can show.\n *\n * Levels: level 0 is exact; a level-k tile covers `tileSize · 2ᵏ` image pixels and its outlines\n * are simplified (Douglas–Peucker) to `2ᵏ⁻¹` image pixels — half to one screen pixel at the zooms\n * that pick that level ({@link regionLevelFor}). A feature under `2ᵏ` image pixels (one to two\n * screen pixels there) is left out of the level. A tile holds the WHOLE simplified feature (not\n * clipped) for every feature whose box meets it, so a view de-duplicates features by id, and at\n * level 0 the tiles in view hold the exact outline of everything visible.\n *\n * No DOM, no Angular: the same code runs in the region-source worker and, where workers do not\n * exist, on the main thread.\n */\nimport { rgbToHex } from '../contracts/color';\nimport { simplifyRing } from '../geometry/ring';\nimport { polylabel } from '../geometry/polylabel';\nimport { ringsArea } from '../geometry/reconstruct';\n\n/** An axis-aligned box `[x0, y0, x1, y1]` in image pixels. */\nexport type Bbox = [number, number, number, number];\n\n/** Edge of a level-0 tile, in image pixels. */\nexport const REGION_TILE_SIZE = 512;\n\n/**\n * One class of a class hierarchy (e.g. a brain-atlas ontology): the class name the features use,\n * its long name, its parent class and its colour. A region set may carry one (a GeoJSON\n * FeatureCollection's `classHierarchy` member); the Region Editor then lists the set as a tree.\n */\nexport interface RegionClassNode {\n  /** The class name, as features use it (`classification.name`): an atlas acronym, say. */\n  name: string;\n  /** The long name, e.g. \"Somatomotor areas, Layer 5\". */\n  title?: string;\n  /** The parent class's name; absent for a root. */\n  parent?: string | null;\n  /** `#rrggbb`. */\n  color?: string;\n  /** Position among its siblings (an atlas's graph order); file order without one. */\n  order?: number;\n}\n\n/**\n * How a region set wants to be drawn, a hint the viewer applies when the set opens (a GeoJSON\n * FeatureCollection's `style` member): an atlas fills its structures and labels them.\n */\nexport interface RegionSourceStyle {\n  /** Fill regions in their colour at this opacity (0 = outlines only). */\n  fillOpacity?: number;\n  /** Outline colour when filled (default: the region's colour). */\n  stroke?: string;\n  /** Outline width in screen px. */\n  strokeWidth?: number;\n  /** Show class labels inside the regions. */\n  labels?: boolean;\n  /** Fill colour of selected regions. */\n  highlight?: string;\n}\n\n/** What a region source holds, known once it is open. */\nexport interface RegionSourceInfo {\n  /** Features in the source, over every plane. */\n  featureCount: number;\n  /** The box around every feature's geometry; null when none has any. */\n  bounds: Bbox | null;\n  /** Edge of a level-0 tile, in image pixels. */\n  tileSize: number;\n  /** Number of levels; the last one's tiles cover {@link bounds} in a few tiles. */\n  levels: number;\n  /** The z planes features are on (QuPath's `geometry.plane.z`, 0 without one), ascending. */\n  planes: number[];\n  /** The colour the file gives each class (its first feature's), by class name. */\n  classColors: Record<string, string>;\n  /** The set's class hierarchy, when it has one. */\n  hierarchy?: RegionClassNode[];\n  /** How the set wants to be drawn, when it says. */\n  style?: RegionSourceStyle;\n}\n\n/** One feature as a tile carries it: identity, class and outline at the tile's level. */\nexport interface TileFeature {\n  id: string;\n  /** The class name. */\n  label: string | null;\n  /** The feature's own colour (`#rrggbb`), from its classification. */\n  color: string | null;\n  /** The box around the exact geometry. */\n  bbox: Bbox;\n  /** Rings as interleaved `x, y` (no repeated closing vertex): exteriors and holes of every\n   *  part, drawn and hit-tested even-odd. For an open feature, its polylines. */\n  rings: Float32Array[];\n  /** A polyline (LineString) rather than an area. */\n  open: boolean;\n  /**\n   * Where to label the feature, per part big enough: `x, y, room` triples, `room` the distance\n   * from the point to the part's nearest edge (image px), so a label shows once it fits.\n   */\n  labels?: Float32Array;\n}\n\n/**\n * A class's outlines on one plane: rings as interleaved `x, y` image px (holes included), and its\n * open features' polylines, likewise (absent from a server that predates them). Read for every\n * class at once, each ring's and line's class comes with it (`ringLabels`, `lineLabels`).\n */\nexport interface ClassOutlines {\n  z: number;\n  rings: Float32Array[];\n  /**\n   * The feature each ring is part of (see SliceOutlines.ringGroups): a feature's rings fill\n   * even-odd, the features as their union. Absent from a server that predates them.\n   */\n  ringGroups?: number[];\n  lines?: Float32Array[];\n  ringLabels?: string[];\n  lineLabels?: string[];\n}\n\n/** One tile of one level of one plane. */\nexport interface RegionTile {\n  z: number;\n  level: number;\n  gx: number;\n  gy: number;\n  features: TileFeature[];\n}\n\n/** A tile's address. */\nexport interface RegionTileKey {\n  level: number;\n  gx: number;\n  gy: number;\n}\n\n/** One row of a source's feature index (the Region Editor's table). */\nexport interface RegionIndexRow {\n  id: string;\n  label: string | null;\n  color: string | null;\n  bbox: Bbox;\n  /** The area inside the exact outline (holes left out), image px²; 0 for a polyline. Absent from a\n   *  server that predates it. */\n  area?: number;\n}\n\n/** A page of a plane's feature index. */\nexport interface RegionIndexPage {\n  /** Rows matching the query, over the whole plane. */\n  total: number;\n  rows: RegionIndexRow[];\n}\n\n/** Which rows a page of the index holds. */\nexport interface RegionIndexQuery {\n  offset: number;\n  limit: number;\n  /** Only rows whose class name contains this (case-insensitive). */\n  label?: string;\n  /** Leave these ids out (taken into the working set, or deleted). */\n  exclude?: readonly string[];\n  /** Only rows of exactly these classes. */\n  classes?: readonly string[];\n}\n\n/** The parts of a GeoJSON feature the tiler reads. Parsed from a file: nothing is guaranteed. */\nexport interface GeoJsonFeatureLike {\n  type?: string;\n  id?: string | number;\n  geometry?: { type?: string; coordinates?: unknown; plane?: { z?: number } } | null;\n  properties?: { id?: string | number; classification?: unknown } & Record<string, unknown>;\n}\n\n/**\n * The level whose tiles suit a zoom of `pxPerImagePx` screen pixels per image pixel: exact (0)\n * at 1:1 and closer, else level k for zooms in [2⁻ᵏ, 2¹⁻ᵏ), where its tolerance is half to one\n * screen pixel and the features it leaves out are under one or two.\n */\nexport function regionLevelFor(pxPerImagePx: number, levels: number): number {\n  if (!(pxPerImagePx > 0) || levels <= 1) return 0;\n  const level = Math.ceil(-Math.log2(pxPerImagePx) - 1e-9);\n  return Math.max(0, Math.min(levels - 1, level));\n}\n\n/** Simplification tolerance of a level, in image pixels (0 = exact). */\nexport function levelTolerance(level: number): number {\n  return level <= 0 ? 0 : 2 ** (level - 1);\n}\n\n/** Features smaller than this (their box's longer side, image pixels) are left out of a level. */\nexport function levelMinExtent(level: number): number {\n  return level <= 0 ? 0 : 2 ** level;\n}\n\n/** Tile edge of a level, in image pixels. */\nexport function levelTileSize(level: number, tileSize = REGION_TILE_SIZE): number {\n  return tileSize * 2 ** level;\n}\n\n/**\n * Tiles of `level` that meet `rect`, clipped to `bounds` (none past the data), ordered from the\n * rectangle's centre outward so the middle of the screen fills first. At most `limit`.\n */\nexport function regionTilesInRect(\n  rect: Bbox,\n  level: number,\n  tileSize: number,\n  bounds: Bbox | null,\n  limit = Infinity,\n): RegionTileKey[] {\n  if (!bounds) return [];\n  const x0 = Math.max(rect[0], bounds[0]);\n  const y0 = Math.max(rect[1], bounds[1]);\n  const x1 = Math.min(rect[2], bounds[2]);\n  const y1 = Math.min(rect[3], bounds[3]);\n  if (x1 < x0 || y1 < y0) return [];\n  const size = levelTileSize(level, tileSize);\n  const gx0 = Math.floor(x0 / size);\n  const gy0 = Math.floor(y0 / size);\n  const gx1 = Math.floor(x1 / size);\n  const gy1 = Math.floor(y1 / size);\n  const cx = (rect[0] + rect[2]) / 2 / size;\n  const cy = (rect[1] + rect[3]) / 2 / size;\n  const out: RegionTileKey[] = [];\n  for (let gy = gy0; gy <= gy1; gy++) {\n    for (let gx = gx0; gx <= gx1; gx++) out.push({ level, gx, gy });\n  }\n  const d = (k: RegionTileKey) => (k.gx + 0.5 - cx) ** 2 + (k.gy + 0.5 - cy) ** 2;\n  out.sort((a, b) => d(a) - d(b));\n  return out.length > limit ? out.slice(0, limit) : out;\n}\n\n/** `level/gx/gy`, a tile's id within one plane. */\nexport function regionTileId(k: RegionTileKey): string {\n  return `${k.level}/${k.gx}/${k.gy}`;\n}\n\n/** The tile of `level` holding image point (x, y). */\nexport function tileAt(x: number, y: number, level: number, tileSize = REGION_TILE_SIZE): RegionTileKey {\n  const size = levelTileSize(level, tileSize);\n  return { level, gx: Math.floor(x / size), gy: Math.floor(y / size) };\n}\n\n/** True when two boxes meet (edges included). */\nexport function bboxesMeet(a: Readonly<Bbox>, b: Readonly<Bbox>): boolean {\n  return a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];\n}\n\n// ── Picking ──────────────────────────────────────────────────────────────────────────────\n\n/**\n * The feature under image point (x, y): inside an area (even-odd over its rings, so holes are\n * outside) or within `tolerance` image pixels of a polyline. Of several, the one with the\n * smallest box — the innermost of nested outlines. Null when none is.\n */\nexport function featureAt(\n  features: Iterable<TileFeature>,\n  x: number,\n  y: number,\n  tolerance = 0,\n): TileFeature | null {\n  let best: TileFeature | null = null;\n  let bestArea = Infinity;\n  for (const f of features) {\n    const b = f.bbox;\n    if (x < b[0] - tolerance || x > b[2] + tolerance || y < b[1] - tolerance || y > b[3] + tolerance) continue;\n    const hit = f.open ? nearPolylines(f.rings, x, y, tolerance) : insideRings(f.rings, x, y);\n    if (!hit) continue;\n    const area = (b[2] - b[0]) * (b[3] - b[1]);\n    if (area < bestArea) {\n      best = f;\n      bestArea = area;\n    }\n  }\n  return best;\n}\n\n/** Features whose box meets `rect` (the rubber band's rule for regions). */\nexport function featuresInRect(features: Iterable<TileFeature>, rect: Readonly<Bbox>): TileFeature[] {\n  const out: TileFeature[] = [];\n  for (const f of features) if (bboxesMeet(f.bbox, rect)) out.push(f);\n  return out;\n}\n\n/** Even-odd containment over interleaved rings. */\nexport function insideRings(rings: readonly ArrayLike<number>[], x: number, y: number): boolean {\n  let inside = false;\n  for (const r of rings) {\n    const n = r.length >> 1;\n    if (n < 3) continue;\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n      const xi = r[2 * i],\n        yi = r[2 * i + 1],\n        xj = r[2 * j],\n        yj = r[2 * j + 1];\n      if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;\n    }\n  }\n  return inside;\n}\n\nfunction nearPolylines(lines: readonly ArrayLike<number>[], x: number, y: number, tolerance: number): boolean {\n  for (const l of lines) {\n    for (let i = 2; i + 1 < l.length; i += 2) {\n      if (segmentDistance(x, y, l[i - 2], l[i - 1], l[i], l[i + 1]) <= tolerance) return true;\n    }\n  }\n  return false;\n}\n\nfunction segmentDistance(px: number, py: number, ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax,\n    dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / len2));\n  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));\n}\n\n// ── Simplification ───────────────────────────────────────────────────────────────────────\n\n/** Douglas–Peucker over an open polyline (both ends kept). */\nexport function simplifyPolyline(xs: number[], ys: number[], epsilon: number): { xs: number[]; ys: number[] } {\n  const n = xs.length;\n  if (n <= 2 || !(epsilon > 0)) return { xs: xs.slice(), ys: ys.slice() };\n  const keep = new Uint8Array(n);\n  keep[0] = keep[n - 1] = 1;\n  const stack: Array<[number, number]> = [[0, n - 1]];\n  while (stack.length) {\n    const [a, b] = stack.pop() as [number, number];\n    let maxD = -1,\n      idx = -1;\n    for (let i = a + 1; i < b; i++) {\n      const d = segmentDistance(xs[i], ys[i], xs[a], ys[a], xs[b], ys[b]);\n      if (d > maxD) {\n        maxD = d;\n        idx = i;\n      }\n    }\n    if (maxD > epsilon) {\n      keep[idx] = 1;\n      stack.push([a, idx], [idx, b]);\n    }\n  }\n  const ox: number[] = [],\n    oy: number[] = [];\n  for (let i = 0; i < n; i++) {\n    if (keep[i]) {\n      ox.push(xs[i]);\n      oy.push(ys[i]);\n    }\n  }\n  return { xs: ox, ys: oy };\n}\n\n/**\n * Rings simplified for a level: every ring through Douglas–Peucker at the level's tolerance,\n * rings whose box is under the level's minimum extent dropped, and rings left with too few\n * vertices to draw (3 for a closed ring, 2 for a polyline) dropped. Level 0 returns the rings\n * as they are.\n */\nexport function simplifyRings(rings: readonly Float64Array[], open: boolean, level: number): Float32Array[] {\n  const tol = levelTolerance(level);\n  const minExtent = levelMinExtent(level);\n  const minVertices = open ? 2 : 3;\n  const out: Float32Array[] = [];\n  for (const ring of rings) {\n    const n = ring.length >> 1;\n    if (n < minVertices) continue;\n    if (tol === 0) {\n      out.push(Float32Array.from(ring));\n      continue;\n    }\n    const xs = new Array<number>(n),\n      ys = new Array<number>(n);\n    let x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n    for (let i = 0; i < n; i++) {\n      const x = ring[2 * i],\n        y = ring[2 * i + 1];\n      xs[i] = x;\n      ys[i] = y;\n      if (x < x0) x0 = x;\n      if (x > x1) x1 = x;\n      if (y < y0) y0 = y;\n      if (y > y1) y1 = y;\n    }\n    if (Math.max(x1 - x0, y1 - y0) < minExtent) continue;\n    const s = open ? simplifyPolyline(xs, ys, tol) : simplifyRing(xs, ys, tol);\n    if (s.xs.length < minVertices) continue;\n    const flat = new Float32Array(s.xs.length * 2);\n    for (let i = 0; i < s.xs.length; i++) {\n      flat[2 * i] = s.xs[i];\n      flat[2 * i + 1] = s.ys[i];\n    }\n    out.push(flat);\n  }\n  return out;\n}\n\n// ── The feature table ────────────────────────────────────────────────────────────────────\n\n/** Features (and their simplified outlines) cached per level, past which the oldest go. */\nconst SIMPLIFIED_CACHE_LIMIT = 200_000;\n\n/**\n * A parsed GeoJSON region set, indexed for tiles. Holds the raw features (for the exact\n * geometry and the export), each feature's rings, box, plane and class, and builds a level's\n * tile buckets the first time that level of a plane is asked for.\n */\nexport class RegionFeatureTable {\n  readonly ids: string[] = [];\n  readonly labels: Array<string | null> = [];\n  readonly colors: Array<string | null> = [];\n  readonly planes: number[] = [];\n  readonly boxes: Bbox[] = [];\n  readonly rings: Float64Array[][] = [];\n  readonly open: boolean[] = [];\n  /** Per feature, its parts as ring indices (the exterior first, then its holes). */\n  readonly parts: number[][][] = [];\n  private readonly labelPoints = new Map<number, Float32Array>();\n  /** Each feature's area, worked out the first time its row is asked for. */\n  private readonly areas = new Map<number, number>();\n  private hierarchy?: RegionClassNode[];\n  private style?: RegionSourceStyle;\n  private readonly byId = new Map<string, number>();\n  private readonly buckets = new Map<string, LevelIndex>();\n  private readonly simplified = new Map<string, Float32Array[]>();\n  private readonly bounds: Bbox | null;\n  private readonly levels: number;\n\n  constructor(\n    readonly raw: GeoJsonFeatureLike[],\n    readonly tileSize = REGION_TILE_SIZE,\n  ) {\n    let x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n    raw.forEach((feature, i) => {\n      const own = featureIdOf(feature);\n      let id = own;\n      if (id === undefined || this.byId.has(id)) {\n        // Its position, unless a feature already has that id (an explicit \"#1\", say): ids are unique,\n        // or a take, an exclusion or an export would act on both.\n        id = `#${i}`;\n        for (let k = 1; this.byId.has(id); k++) id = `#${i}-${k}`;\n      }\n      this.byId.set(id, i);\n      this.ids.push(id);\n      const { label, color } = classificationOf(feature);\n      this.labels.push(label);\n      this.colors.push(color);\n      this.planes.push(feature?.geometry?.plane?.z ?? 0);\n      const { rings, open, parts } = ringsOf(feature);\n      this.rings.push(rings);\n      this.open.push(open);\n      this.parts.push(parts);\n      const box = ringsBox(rings);\n      this.boxes.push(box);\n      if (rings.length) {\n        x0 = Math.min(x0, box[0]);\n        y0 = Math.min(y0, box[1]);\n        x1 = Math.max(x1, box[2]);\n        y1 = Math.max(y1, box[3]);\n      }\n    });\n    this.bounds = x0 <= x1 ? [x0, y0, x1, y1] : null;\n    const extent = this.bounds ? Math.max(Math.abs(x0), Math.abs(y0), Math.abs(x1), Math.abs(y1)) : 0;\n    this.levels = 1 + Math.max(0, Math.ceil(Math.log2(Math.max(extent, tileSize) / tileSize)));\n  }\n\n  /** Parse a GeoJSON FeatureCollection string. Throws on invalid JSON or no `features`. */\n  static fromGeoJson(text: string, tileSize = REGION_TILE_SIZE): RegionFeatureTable {\n    const parsed = JSON.parse(text);\n    if (!parsed || !Array.isArray(parsed.features)) {\n      throw new Error(\"Invalid GeoJson file: must contain the 'features' key.\");\n    }\n    const table = new RegionFeatureTable(parsed.features, tileSize);\n    table.describe(parsed.classHierarchy, parsed.style);\n    return table;\n  }\n\n  /** Attach a class hierarchy and a style hint (each ignored when not well formed). */\n  describe(hierarchy?: unknown, style?: unknown): void {\n    this.hierarchy = readHierarchy(hierarchy) ?? this.hierarchy;\n    this.style = readStyle(style) ?? this.style;\n  }\n\n  /**\n   * The outlines of every feature of these classes, plane by plane, simplified for `level` (what a\n   * 3D reconstruction of the classes stacks), without the `exclude`d ids: closed features' rings,\n   * open features' polylines as `lines`, each ring with its feature (`ringGroups`). Planes without\n   * one are left out. `classes` null reads every labelled feature, each outline with its class\n   * (`ringLabels`, `lineLabels`).\n   */\n  classOutlines(\n    classes: readonly string[] | null,\n    level: number,\n    exclude: readonly string[] = [],\n  ): ClassOutlines[] {\n    const wanted = classes ? new Set(classes) : null;\n    const skip = new Set(exclude);\n    const byPlane = new Map<number, ClassOutlines>();\n    for (let i = 0; i < this.ids.length; i++) {\n      const label = this.labels[i];\n      if (!label || (wanted && !wanted.has(label)) || skip.has(this.ids[i])) continue;\n      const rings = this.ringsAt(i, level);\n      if (!rings.length) continue;\n      const z = this.planes[i];\n      let plane = byPlane.get(z);\n      if (!plane) byPlane.set(z, (plane = { z, rings: [] }));\n      if (this.open[i]) {\n        (plane.lines ??= []).push(...rings);\n        if (!wanted) (plane.lineLabels ??= []).push(...rings.map(() => label));\n      } else {\n        plane.rings.push(...rings);\n        (plane.ringGroups ??= []).push(...rings.map(() => i));\n        if (!wanted) (plane.ringLabels ??= []).push(...rings.map(() => label));\n      }\n    }\n    return Array.from(byPlane.values()).sort((a, b) => a.z - b.z);\n  }\n\n  /** Features per class on plane `z` (null: on every plane), without the `exclude`d ids. */\n  classCounts(z: number | null, exclude: readonly string[] = []): Record<string, number> {\n    const skip = new Set(exclude);\n    const counts: Record<string, number> = {};\n    for (let i = 0; i < this.ids.length; i++) {\n      const label = this.labels[i];\n      if ((z !== null && this.planes[i] !== z) || !label || skip.has(this.ids[i])) continue;\n      counts[label] = (counts[label] ?? 0) + 1;\n    }\n    return counts;\n  }\n\n  info(): RegionSourceInfo {\n    const classColors: Record<string, string> = {};\n    this.labels.forEach((label, i) => {\n      const color = this.colors[i];\n      if (label && color && !(label in classColors)) classColors[label] = color;\n    });\n    return {\n      featureCount: this.ids.length,\n      bounds: this.bounds,\n      tileSize: this.tileSize,\n      levels: this.levels,\n      planes: Array.from(new Set(this.planes)).sort((a, b) => a - b),\n      classColors,\n      ...(this.hierarchy ? { hierarchy: this.hierarchy } : {}),\n      ...(this.style ? { style: this.style } : {}),\n    };\n  }\n\n  /** One tile of plane `z`. */\n  tile(z: number, level: number, gx: number, gy: number): RegionTile {\n    const { cells, wide } = this.bucketsFor(z, level);\n    const bucket = cells.get(`${gx}/${gy}`) ?? [];\n    const size = levelTileSize(level, this.tileSize);\n    const features: TileFeature[] = [];\n    // The tile's cell features and the wide ones that meet it, merged back into file order.\n    const order: number[] = [];\n    for (let a = 0, w = 0; a < bucket.length || w < wide.length;) {\n      if (w >= wide.length || (a < bucket.length && bucket[a] < wide[w])) order.push(bucket[a++]);\n      else {\n        const i = wide[w++];\n        if (cellMeets(this.boxes[i], size, gx, gy)) order.push(i);\n      }\n    }\n    for (const i of order) {\n      const rings = this.ringsAt(i, level);\n      if (!rings.length) continue;\n      const labels = this.labelsAt(i, level);\n      features.push({\n        id: this.ids[i],\n        label: this.labels[i],\n        color: this.colors[i],\n        bbox: this.boxes[i],\n        rings,\n        open: this.open[i],\n        ...(labels ? { labels } : {}),\n      });\n    }\n    return { z, level, gx, gy, features };\n  }\n\n  /** The raw GeoJSON features with these ids, in the order asked (unknown ids skipped). */\n  features(ids: readonly string[]): Array<{ id: string; feature: GeoJsonFeatureLike }> {\n    const out: Array<{ id: string; feature: GeoJsonFeatureLike }> = [];\n    for (const id of ids) {\n      const i = this.byId.get(id);\n      if (i !== undefined) out.push({ id, feature: this.raw[i] });\n    }\n    return out;\n  }\n\n  /** Feature `i`'s area in px² (0 for a polyline). */\n  private areaOf(i: number): number {\n    let area = this.areas.get(i);\n    if (area === undefined) {\n      area = this.open[i] ? 0 : ringsArea(this.rings[i]);\n      this.areas.set(i, area);\n    }\n    return area;\n  }\n\n  /** A page of plane `z`'s features, in file order. */\n  index(z: number, query: RegionIndexQuery): RegionIndexPage {\n    const exclude = new Set(query.exclude ?? []);\n    const classes = query.classes ? new Set(query.classes) : null;\n    const needle = query.label?.trim().toLowerCase() || null;\n    const rows: RegionIndexRow[] = [];\n    let total = 0;\n    for (let i = 0; i < this.ids.length; i++) {\n      if (this.planes[i] !== z || exclude.has(this.ids[i])) continue;\n      if (needle && !(this.labels[i] ?? '').toLowerCase().includes(needle)) continue;\n      if (classes && !classes.has(this.labels[i] ?? '')) continue;\n      if (total >= query.offset && rows.length < query.limit) {\n        rows.push({\n          id: this.ids[i],\n          label: this.labels[i],\n          color: this.colors[i],\n          bbox: this.boxes[i],\n          area: this.areaOf(i),\n        });\n      }\n      total++;\n    }\n    return { total, rows };\n  }\n\n  /**\n   * The source as a GeoJSON FeatureCollection string, through the working set: features whose\n   * id is in `exclude` (taken for editing, or deleted) are left out, `extra` (the working set's\n   * features) appended. Every feature keeps an `id`; the set keeps its hierarchy and style.\n   */\n  exportGeoJson(exclude: readonly string[], extra: readonly object[]): string {\n    const skip = new Set(exclude);\n    const parts: string[] = [];\n    this.raw.forEach((feature, i) => {\n      const id = this.ids[i];\n      if (skip.has(id)) return;\n      parts.push(JSON.stringify(feature.id === undefined ? { type: 'Feature', id, ...feature } : feature));\n    });\n    for (const f of extra) parts.push(JSON.stringify(f));\n    return featureCollectionJson(parts, this.hierarchy, this.style);\n  }\n\n  /**\n   * Feature `i`'s label points (one per part with room for a label at `level`: a part under the\n   * level's minimum extent is not drawn there), from the exact geometry, computed once.\n   */\n  private labelsAt(i: number, level: number): Float32Array | null {\n    if (this.open[i] || !this.labels[i]) return null;\n    let points = this.labelPoints.get(i);\n    if (!points) {\n      const out: number[] = [];\n      for (const part of this.parts[i]) {\n        const pole = polylabel(part.map((r) => this.rings[i][r]));\n        if (pole && pole.distance > 0) out.push(pole.x, pole.y, pole.distance);\n      }\n      points = Float32Array.from(out);\n      this.labelPoints.set(i, points);\n    }\n    const min = levelMinExtent(level) / 2;\n    if (!min) return points.length ? points : null;\n    const kept: number[] = [];\n    for (let k = 0; k + 2 < points.length; k += 3)\n      if (points[k + 2] >= min) kept.push(points[k], points[k + 1], points[k + 2]);\n    return kept.length ? Float32Array.from(kept) : null;\n  }\n\n  /** Feature `i`'s rings at `level`, simplified once and cached. */\n  private ringsAt(i: number, level: number): Float32Array[] {\n    const key = `${level}/${i}`;\n    let rings = this.simplified.get(key);\n    if (!rings) {\n      rings = simplifyRings(this.rings[i], this.open[i], level);\n      if (this.simplified.size >= SIMPLIFIED_CACHE_LIMIT) {\n        const oldest = this.simplified.keys().next().value as string;\n        this.simplified.delete(oldest);\n      }\n      this.simplified.set(key, rings);\n    }\n    return rings;\n  }\n\n  /** Entries in plane `z`'s level-`level` index: cell listings plus wide features (tests). */\n  indexEntries(z: number, level: number): number {\n    const { cells, wide } = this.bucketsFor(z, level);\n    let n = wide.length;\n    for (const list of cells.values()) n += list.length;\n    return n;\n  }\n\n  /**\n   * Plane `z`'s level-`level` index, built on first use: features by tile cell (`gx/gy` → feature\n   * indices), and the wide ones (more than {@link MAX_CELLS_PER_FEATURE} cells, or past the\n   * number range), tested against a tile when it is asked for.\n   */\n  private bucketsFor(z: number, level: number): LevelIndex {\n    const key = `${z}/${level}`;\n    let index = this.buckets.get(key);\n    if (index) return index;\n    const cells = new Map<string, number[]>();\n    const wide: number[] = [];\n    const size = levelTileSize(level, this.tileSize);\n    const minExtent = levelMinExtent(level);\n    for (let i = 0; i < this.ids.length; i++) {\n      if (this.planes[i] !== z || !this.rings[i].length) continue;\n      const b = this.boxes[i];\n      if (Math.max(b[2] - b[0], b[3] - b[1]) < minExtent) continue;\n      const gx0 = Math.floor(b[0] / size),\n        gx1 = Math.floor(b[2] / size),\n        gy0 = Math.floor(b[1] / size),\n        gy1 = Math.floor(b[3] / size);\n      // A box with a NaN coordinate meets no tile.\n      if ([gx0, gx1, gy0, gy1].some(Number.isNaN)) continue;\n      const count = (gx1 - gx0 + 1) * (gy1 - gy0 + 1);\n      if (!(count <= MAX_CELLS_PER_FEATURE) || ![gx0, gx1, gy0, gy1].every(Number.isSafeInteger)) {\n        wide.push(i);\n        continue;\n      }\n      for (let gy = gy0; gy <= gy1; gy++) {\n        for (let gx = gx0; gx <= gx1; gx++) {\n          const id = `${gx}/${gy}`;\n          const list = cells.get(id);\n          if (list) list.push(i);\n          else cells.set(id, [i]);\n        }\n      }\n    }\n    index = { cells, wide };\n    this.buckets.set(key, index);\n    return index;\n  }\n}\n\n/**\n * A feature spanning more tiles than this is not listed in each of them but kept aside and tested\n * against a tile when one is asked for: one huge box (an outline around a whole slide, or a corrupt\n * coordinate) must not make a plane's index millions of entries.\n */\nexport const MAX_CELLS_PER_FEATURE = 64;\n\n/** A plane's level: features by tile cell, and the wide ones (ascending), tested per tile. */\ninterface LevelIndex {\n  cells: Map<string, number[]>;\n  wide: number[];\n}\n\n/** Whether box `b` meets cell (gx, gy) of tiles `size` pixels wide, as a cell lists it. */\nfunction cellMeets(b: Readonly<Bbox>, size: number, gx: number, gy: number): boolean {\n  return (\n    Math.floor(b[0] / size) <= gx &&\n    gx <= Math.floor(b[2] / size) &&\n    Math.floor(b[1] / size) <= gy &&\n    gy <= Math.floor(b[3] / size)\n  );\n}\n\n/** A feature's own id (`id`, else `properties.id`) as a string. */\nexport function featureIdOf(feature: GeoJsonFeatureLike): string | undefined {\n  const id = feature?.id ?? feature?.properties?.id;\n  return typeof id === 'string' || typeof id === 'number' ? String(id) : undefined;\n}\n\n/** Class name and colour from QuPath's `classification` (`{name, color}`, or a bare name). */\nfunction classificationOf(feature: GeoJsonFeatureLike): { label: string | null; color: string | null } {\n  const c = feature?.properties?.classification as { name?: string; color?: number[] } | string | undefined;\n  if (!c) return { label: 'Cell', color: null };\n  if (typeof c === 'string') return { label: c, color: null };\n  const color =\n    Array.isArray(c.color) && c.color.length >= 3 ? rgbToHex([c.color[0], c.color[1], c.color[2]]) : null;\n  return { label: c.name ?? null, color };\n}\n\n/**\n * A feature's rings, interleaved, without the closing vertex; whether it is a polyline; and its\n * parts as ring indices (each part's exterior first, then its holes).\n */\nfunction ringsOf(feature: GeoJsonFeatureLike): { rings: Float64Array[]; open: boolean; parts: number[][] } {\n  const g = feature?.geometry;\n  const coords = g?.coordinates as unknown;\n  if (!g || !Array.isArray(coords)) return { rings: [], open: false, parts: [] };\n  const polygons = (list: number[][][][]) => {\n    const rings: Float64Array[] = [];\n    const parts: number[][] = [];\n    for (const polygon of list) {\n      const part: number[] = [];\n      for (const r of polygon) {\n        part.push(rings.length);\n        rings.push(flatRing(r, true));\n      }\n      if (part.length) parts.push(part);\n    }\n    return { rings, open: false, parts };\n  };\n  switch (g.type) {\n    case 'Polygon':\n      return polygons([coords as number[][][]]);\n    case 'MultiPolygon':\n      return polygons(coords as number[][][][]);\n    case 'LineString':\n      return { rings: [flatRing(coords as number[][], false)], open: true, parts: [] };\n    case 'MultiLineString':\n      return { rings: (coords as number[][][]).map((r) => flatRing(r, false)), open: true, parts: [] };\n    default:\n      return { rings: [], open: false, parts: [] };\n  }\n}\n\n/**\n * A FeatureCollection string of `features` (each a feature's JSON), with the set's class hierarchy\n * and style as its `classHierarchy` and `style` members when it has them: what\n * {@link RegionFeatureTable.fromGeoJson} reads back.\n */\nexport function featureCollectionJson(\n  features: readonly string[],\n  hierarchy?: readonly RegionClassNode[],\n  style?: RegionSourceStyle,\n): string {\n  const head = ['\"type\":\"FeatureCollection\"'];\n  if (hierarchy?.length) head.push(`\"classHierarchy\":${JSON.stringify(hierarchy)}`);\n  if (style) head.push(`\"style\":${JSON.stringify(style)}`);\n  return `{${head.join(',')},\"features\":[${features.join(',')}]}`;\n}\n\n/** A well-formed class hierarchy from a file (colours as `#rrggbb` or `[r, g, b]`), else undefined. */\nexport function readHierarchy(raw: unknown): RegionClassNode[] | undefined {\n  if (!Array.isArray(raw)) return undefined;\n  const out: RegionClassNode[] = [];\n  for (const n of raw as Array<Record<string, unknown>>) {\n    if (!n || typeof n.name !== 'string') continue;\n    const color = Array.isArray(n.color) ? rgbToHex([+n.color[0], +n.color[1], +n.color[2]]) : n.color;\n    out.push({\n      name: n.name,\n      ...(typeof n.title === 'string' ? { title: n.title } : {}),\n      ...(typeof n.parent === 'string' ? { parent: n.parent } : {}),\n      ...(typeof color === 'string' ? { color } : {}),\n      ...(typeof n.order === 'number' ? { order: n.order } : {}),\n    });\n  }\n  return out.length ? out : undefined;\n}\n\n/** A well-formed style hint from a file, else undefined. */\nexport function readStyle(raw: unknown): RegionSourceStyle | undefined {\n  if (!raw || typeof raw !== 'object') return undefined;\n  const r = raw as Record<string, unknown>;\n  const style: RegionSourceStyle = {};\n  if (typeof r.fillOpacity === 'number') style.fillOpacity = Math.max(0, Math.min(1, r.fillOpacity));\n  if (typeof r.stroke === 'string') style.stroke = r.stroke;\n  if (typeof r.strokeWidth === 'number' && r.strokeWidth > 0) style.strokeWidth = r.strokeWidth;\n  if (typeof r.labels === 'boolean') style.labels = r.labels;\n  if (typeof r.highlight === 'string') style.highlight = r.highlight;\n  return Object.keys(style).length ? style : undefined;\n}\n\nfunction flatRing(points: number[][], closed: boolean): Float64Array {\n  let n = points?.length ?? 0;\n  if (closed && n > 1) {\n    const a = points[0],\n      b = points[n - 1];\n    if (a[0] === b[0] && a[1] === b[1]) n--;\n  }\n  const out = new Float64Array(n * 2);\n  for (let i = 0; i < n; i++) {\n    out[2 * i] = +points[i][0];\n    out[2 * i + 1] = +points[i][1];\n  }\n  return out;\n}\n\nfunction ringsBox(rings: readonly Float64Array[]): Bbox {\n  let x0 = Infinity,\n    y0 = Infinity,\n    x1 = -Infinity,\n    y1 = -Infinity;\n  for (const r of rings) {\n    for (let i = 0; i + 1 < r.length; i += 2) {\n      if (r[i] < x0) x0 = r[i];\n      if (r[i] > x1) x1 = r[i];\n      if (r[i + 1] < y0) y0 = r[i + 1];\n      if (r[i + 1] > y1) y1 = r[i + 1];\n    }\n  }\n  return [x0, y0, x1, y1];\n}\n"]}