@jax-data-science/sci-image-visualizer 0.17.0 → 0.18.1

package/esm2022/lib/implementations/napari-js/napari-spatial-3d-cells.mjs

@@ -0,0 +1,746 @@
+import { regionTilesInRect } from '../../region-source/region-tiles';
+import { placeInWorker, reconstructCellsInWorker } from '../../region-source/worker-region-source';
+import { cellOutlinesFromTiles, observationIndex } from '../../spatial/plane-cells';
+import { typicalCellDiameter } from '../../spatial/lod';
+import { datasetRegionSet } from '../../visualizer/spatial-region-set';
+import { REGION_MESH_DIMMED_OPACITY, toWorld } from './napari-volume-region-meshes';
+/**
+ * A 3D segmentation's cells in the spatial 3D view, each reconstructed by itself (see
+ * `geometry/cell-meshes`), where the region classes are otherwise one merged surface per class.
+ *
+ * Built to stay out of the way of the UI thread and the GPU:
+ *  - the space is cut into chunks (a grid over the region set's bounds); each chunk is one surface
+ *    layer of its cells, meshed in the cells' own worker, a few hundred cells per call, so the
+ *    work is cancelled between calls when the view moves on (and the region tiles the 2D view
+ *    reads never wait behind it);
+ *  - level of detail by chunk: a coarse mesh everywhere first, then the chunks on screen are meshed
+ *    finer as the camera comes close, within a triangle budget for the whole scene; the region
+ *    set's tiles are read at the level of detail that mesh needs;
+ *  - at most {@link CELLS_3D_MAX_CELLS} cells and {@link CELLS_3D_TRIANGLE_BUDGET} triangles, the
+ *    chunks nearest the centre of the view first (one chunk over either by itself is meshed in
+ *    part), planned again as each chunk's real size is learnt; the status says when cells are left
+ *    out, so the view never claims to show them all;
+ *  - colour and visibility change no geometry: colours are per vertex (each vertex's cell), and a
+ *    hidden cell's triangles are left out of what is drawn.
+ * Builds report on the canvas's loading badge.
+ */
+/** The most cells drawn at once. */
+export const CELLS_3D_MAX_CELLS = 20_000;
+/** The most triangles every chunk together may have. */
+export const CELLS_3D_TRIANGLE_BUDGET = 3_000_000;
+/** Chunks across the longer side of the region set's bounds. */
+const CHUNKS_ACROSS = 8;
+/** A redraw yields the main thread after this long. */
+const REDRAW_SLICE_MS = 8;
+/** Cells per worker call: the build can be dropped between calls. */
+const BATCH = 400;
+/** A pause in the camera's movement this long re-plans the detail. */
+const CAMERA_IDLE_MS = 250;
+/** A voxel at least this many screen pixels across is detail enough. */
+const MIN_VOXEL_PX = 3;
+/** Each tier's voxel edge, as a fraction of a cell's diameter: coarse to fine. */
+const TIER_FRACTIONS = [1 / 4, 1 / 8, 1 / 16];
+/** A first guess at a coarse cell's triangles, before any chunk was built. */
+const COARSE_TRIANGLES_PER_CELL = 300;
+export class Spatial3dCells {
+    constructor(host) {
+        this.host = host;
+        this.dataset = null;
+        this.source = null;
+        this.classes = null;
+        this.hidden = new Set();
+        this.colors = null;
+        this.visible = null;
+        /** The selection (null: none): the cells it leaves out fade, keeping their colours. */
+        this.selected = null;
+        this.opacity = 1;
+        this.placement = null;
+        this.zScale = 1;
+        this.chunks = [];
+        this.byLayer = new Map();
+        this.generation = 0;
+        this.timer = null;
+        this.running = false;
+        this.disposed = false;
+        /** Each surface's geometry as last set: a recolour that leaves it so uploads none again. */
+        this.installed = new WeakMap();
+        this.redrawGeneration = 0;
+        /** Tell the host how the cells stand, only when that changed (the camera re-plans often). */
+        this.lastStatus = 'null';
+        this.cameraOff = host.viewer.camera3d.changed.connect(() => this.schedule(CAMERA_IDLE_MS));
+    }
+    /** The dataset whose region set the cells are read from. */
+    setDataset(dataset) {
+        if (dataset === this.dataset)
+            return;
+        const id = datasetRegionSet(dataset);
+        const sameSet = !!id && id === this.source?.id && dataset?.id === this.dataset?.id;
+        this.dataset = dataset;
+        if (sameSet)
+            return;
+        this.reset();
+        this.closeSource();
+        if (id && this.host.port?.openRegionSet) {
+            const open = this.host.port.openRegionSet(id);
+            this.source = { id, open };
+            open.catch(() => {
+                if (this.source?.open === open)
+                    this.source = null;
+            });
+        }
+        this.schedule(0);
+    }
+    /** The classes drawn as cells (none: the cells are not drawn). */
+    setClasses(classes) {
+        const next = classes?.size ? classes : null;
+        if (sameSet(next, this.classes))
+            return;
+        this.classes = next;
+        this.reset();
+        this.schedule(0);
+    }
+    /** Classes hidden (the Region Editor's eyes): their cells are left out of what is drawn. */
+    setHiddenClasses(classes) {
+        const next = new Set(classes);
+        if (sameSet(next, this.hidden))
+            return;
+        this.hidden = next;
+        this.redraw();
+    }
+    /**
+     * Each observation's colour (RGBA 0..1) and whether it is shown (null: all), and the surfaces'
+     * opacity: the panel's Cell Color, groups and selection. Changes no geometry.
+     */
+    setStyle(colors, visible, opacity, selected = null) {
+        this.colors = colors;
+        this.visible = visible;
+        this.opacity = opacity;
+        this.selected = selected;
+        this.redraw();
+    }
+    /** Where the planes are among the observations (null: nowhere, nothing drawn), and the Z stretch. */
+    setPlacement(placement, zScale) {
+        const moved = !samePlacement(placement, this.placement);
+        // The same placement kept as it was (a scene passes a new object each time): a placement in
+        // flight for it is still good when it lands.
+        if (moved)
+            this.placement = placement;
+        this.zScale = zScale;
+        for (const c of this.chunks) {
+            if (c.layer)
+                c.layer.scale3d = [1, 1, zScale];
+            if (c.selectedLayer)
+                c.selectedLayer.scale3d = [1, 1, zScale];
+        }
+        if (!moved)
+            return;
+        for (const c of this.chunks) {
+            c.world = null;
+            c.placing = null; // one in flight was for the old placement: it is dropped when it lands
+        }
+        if (!placement) {
+            for (const c of this.chunks)
+                this.dropLayer(c);
+        }
+        else {
+            this.redraw();
+        }
+        this.schedule(0);
+    }
+    /** The observation of the cell drawn under canvas point (`x`, `y`) (CSS px), or -1. */
+    pick(x, y) {
+        if (!this.byLayer.size)
+            return -1;
+        const hit = this.host.viewer.pickSurface(x, y, { pickable: (l) => this.byLayer.has(l) });
+        const chunk = hit ? this.byLayer.get(hit.layer) : undefined;
+        const faces = hit && chunk && hit.layer === chunk.selectedLayer ? chunk.drawnSelected : chunk?.drawn;
+        if (!hit || !faces || !chunk?.mesh)
+            return -1;
+        const vertex = faces[hit.face * 3];
+        return vertex === undefined ? -1 : chunk.mesh.vertexCell[vertex];
+    }
+    /** Whether `layer` is one of the cells' surfaces. */
+    owns(layer) {
+        return this.byLayer.has(layer);
+    }
+    dispose() {
+        this.disposed = true;
+        this.cameraOff?.();
+        this.cameraOff = null;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.reset();
+        this.closeSource();
+        this.emit(null);
+    }
+    // ── planning ──────────────────────────────────────────────────────────────────────
+    schedule(delay) {
+        if (this.disposed)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.plan();
+        }, delay);
+    }
+    /** Drop every chunk (their layers) and any build in flight. */
+    reset() {
+        this.generation++;
+        for (const c of this.chunks)
+            this.dropLayer(c);
+        this.chunks = [];
+    }
+    closeSource() {
+        const s = this.source;
+        this.source = null;
+        void s?.open.then((src) => src.dispose(), () => undefined);
+    }
+    /** Decide each chunk's detail (and whether it is drawn at all), then build what changed. */
+    async plan() {
+        const dataset = this.dataset;
+        const index = dataset ? observationIndex(dataset.observations) : null;
+        if (!this.classes || !this.source || !dataset || !index || !this.placement) {
+            if (this.chunks.length)
+                this.reset();
+            this.emit(null);
+            return;
+        }
+        const generation = this.generation;
+        let source;
+        try {
+            source = await this.source.open;
+        }
+        catch (err) {
+            console.warn("[napari-js] the cells' region set could not be opened", err);
+            this.emit(null);
+            return;
+        }
+        if (generation !== this.generation)
+            return;
+        if (!this.chunks.length)
+            this.chunks = makeChunks(source);
+        const steps = this.steps(dataset);
+        this.replanTiers(steps);
+        this.report(false);
+        if (!this.running)
+            void this.run(source, index, steps);
+    }
+    /** {@link assignTiers} from the view as it is now, taking down what it leaves out. */
+    replanTiers(steps) {
+        this.assignTiers(this.priority(), steps);
+        for (const c of this.chunks)
+            if (c.want < 0)
+                this.dropLayer(c);
+    }
+    /** Voxel edge of each tier, image px: fractions of a typical cell's diameter. */
+    steps(dataset) {
+        const sx = dataset.imageRef?.scale?.[0] ?? 1;
+        const d = Math.max(4, typicalCellDiameter(dataset.observations.radius) * Math.abs(sx || 1));
+        return TIER_FRACTIONS.map((f) => Math.max(1, d * f));
+    }
+    /**
+     * The chunks, nearest the centre of the view first, with how many screen pixels an image pixel
+     * of each takes (0 off screen).
+     */
+    priority() {
+        const viewer = this.host.viewer;
+        const [vw, vh] = viewer.viewportSize();
+        const pts = new Float32Array(this.chunks.length * 6);
+        const zMid = this.placement ? midZ(this.placement) : 0;
+        this.chunks.forEach((c, i) => {
+            const [x0, y0, x1, y1] = c.box;
+            const cy = (y0 + y1) / 2;
+            const a = this.toWorldPoint((x0 + x1) / 2, cy, zMid);
+            const b = this.toWorldPoint(x1, cy, zMid);
+            pts.set(a, i * 6);
+            pts.set(b, i * 6 + 3);
+        });
+        const proj = vw > 0 && vh > 0 ? viewer.projectPoints(pts) : null;
+        const out = this.chunks.map((chunk, i) => {
+            const sx = proj?.screen[i * 4] ?? NaN;
+            const sy = proj?.screen[i * 4 + 1] ?? NaN;
+            const ex = proj?.screen[i * 4 + 2] ?? NaN;
+            const ey = proj?.screen[i * 4 + 3] ?? NaN;
+            const half = Math.hypot(ex - sx, ey - sy);
+            const width = (chunk.box[2] - chunk.box[0]) / 2;
+            const ppi = Number.isFinite(half) && width > 0 ? half / width : 0;
+            const onScreen = Number.isFinite(sx) && sx > -half && sx < vw + half && sy > -half && sy < vh + half && ppi > 0;
+            const d2 = Number.isFinite(sx) ? (sx - vw / 2) ** 2 + (sy - vh / 2) ** 2 : Number.MAX_VALUE;
+            return { chunk, ppi: onScreen ? ppi : 0, onScreen, d2 };
+        });
+        return out.sort((a, b) => Number(b.onScreen) - Number(a.onScreen) || a.d2 - b.d2);
+    }
+    /**
+     * Each chunk's tier: in order, within the cell cap, as fine as the screen asks within the
+     * triangle budget. The chunks last in order give up their detail first, then are left out; the
+     * first is never left out, but one over the cap or the budget by itself meshes only the cells
+     * that fit (its {@link Chunk.limit}).
+     */
+    assignTiers(order, steps) {
+        const known = this.chunks.filter((c) => c.cells >= 0);
+        const avgCells = known.length ? known.reduce((s, c) => s + c.cells, 0) / known.length : 200;
+        let cells = 0;
+        const included = [];
+        for (const { chunk, ppi } of order) {
+            const n = chunk.cells >= 0 ? chunk.cells : avgCells;
+            const room = CELLS_3D_MAX_CELLS - cells;
+            if (n > room && included.length) {
+                chunk.want = -1;
+                continue;
+            }
+            const take = Math.min(n, room);
+            cells += take;
+            let tier = 0;
+            for (let t = steps.length - 1; t > 0; t--) {
+                if (ppi * steps[t] >= MIN_VOXEL_PX) {
+                    tier = t;
+                    break;
+                }
+            }
+            included.push({ chunk, tier, take, room });
+        }
+        const triangles = (e) => this.trianglesAt(e.chunk, e.tier, steps, avgCells);
+        // The budget: the chunks last in order give up their detail first, then their place.
+        let total = included.reduce((s, e) => s + triangles(e), 0);
+        for (let i = included.length - 1; i >= 0 && total > CELLS_3D_TRIANGLE_BUDGET; i--) {
+            const e = included[i];
+            while (e.tier > 0 && total > CELLS_3D_TRIANGLE_BUDGET) {
+                total -= triangles(e) - triangles({ chunk: e.chunk, tier: e.tier - 1 });
+                e.tier--;
+            }
+        }
+        while (included.length > 1 && total > CELLS_3D_TRIANGLE_BUDGET) {
+            const e = included.pop();
+            total -= triangles(e);
+            e.chunk.want = -1;
+        }
+        for (const e of included) {
+            const n = e.chunk.cells >= 0 ? e.chunk.cells : avgCells;
+            let take = e.take;
+            // The first chunk alone over the budget, at its coarsest: as many cells as fit in it.
+            const all = triangles(e);
+            if (all > CELLS_3D_TRIANGLE_BUDGET) {
+                const perCell = all / Math.max(1, e.chunk.meshed > 0 ? e.chunk.meshed : n);
+                take = Math.min(take, CELLS_3D_TRIANGLE_BUDGET / perCell);
+            }
+            e.chunk.want = e.tier;
+            // Cut short when over; and one not built yet, which may have more cells than the guess, to
+            // the room the cap leaves it.
+            const most = take < n ? take : e.chunk.cells < 0 ? e.room : Infinity;
+            e.chunk.limit = Number.isFinite(most) ? Math.max(1, Math.floor(most)) : Infinity;
+        }
+    }
+    /** A chunk's triangles at `tier`: as built, else scaled from a tier built (by the step's square). */
+    trianglesAt(chunk, tier, steps, avgCells) {
+        const at = chunk.triangles.get(tier);
+        if (at !== undefined)
+            return at;
+        for (const [t, n] of chunk.triangles)
+            return n * (steps[t] / steps[tier]) ** 2;
+        const cells = chunk.cells >= 0 ? chunk.cells : avgCells;
+        return cells * COARSE_TRIANGLES_PER_CELL * (steps[0] / steps[tier]) ** 2;
+    }
+    // ── building ──────────────────────────────────────────────────────────────────────
+    /** Build every chunk whose tier changed, nearest first, one at a time, until none is left. */
+    async run(source, index, steps) {
+        this.running = true;
+        let stale = false;
+        const end = this.host.beginTask('Cells');
+        try {
+            for (;;) {
+                const generation = this.generation;
+                const next = this.priority()
+                    .map((e) => e.chunk)
+                    .find((c) => needsBuild(c));
+                if (!next)
+                    break;
+                this.report(true);
+                try {
+                    await this.build(next, next.want, source, index, steps, generation);
+                }
+                catch (err) {
+                    console.warn('[napari-js] cells could not be built in 3D', err);
+                    next.want = next.tier; // not retried until the view asks again
+                }
+                if (generation !== this.generation) {
+                    // Superseded (other classes, another dataset): the plan made for those found this run
+                    // still going and started none of its own. Plan again, now that it has stopped.
+                    stale = true;
+                    break;
+                }
+                // The chunk's real size is known now, where the plan guessed: plan again by it.
+                this.replanTiers(steps);
+            }
+        }
+        finally {
+            end();
+            this.running = false;
+            this.report(false);
+            if (stale)
+                this.schedule(0);
+        }
+    }
+    async build(chunk, tier, source, index, steps, generation) {
+        const info = source.info;
+        const step = steps[tier];
+        const level = Math.max(0, Math.min(info.levels - 1, Math.floor(Math.log2(step))));
+        // Tiles around the chunk: a cell crossing its edge is the chunk's its centre is in.
+        const margin = steps[0] * 8;
+        const [x0, y0, x1, y1] = chunk.box;
+        const keys = regionTilesInRect([x0 - margin, y0 - margin, x1 + margin, y1 + margin], level, info.tileSize, info.bounds);
+        const planes = await Promise.all(info.planes.map(async (z, slice) => ({
+            slice,
+            tiles: await Promise.all(keys.map((k) => source.getTile(z, k))),
+        })));
+        if (generation !== this.generation)
+            return;
+        const found = cellOutlinesFromTiles(planes, index, this.classes, chunk.box);
+        const limit = chunk.limit;
+        const cells = found.length > limit ? found.slice(0, limit) : found;
+        const labels = new Map(cells.map((c) => [c.cell, c.label]));
+        const parts = [];
+        for (let i = 0; i < cells.length; i += BATCH) {
+            const batch = cells.slice(i, i + BATCH).map((c) => ({ cell: c.cell, slices: c.slices }));
+            parts.push(await reconstructCellsInWorker(batch, { pixelStep: step }));
+            if (generation !== this.generation)
+                return;
+        }
+        const mesh = concatMeshes(parts);
+        chunk.mesh = mesh;
+        chunk.labels = labels;
+        chunk.tier = tier;
+        chunk.cells = found.length;
+        chunk.meshed = mesh.cells.length;
+        chunk.builtLimit = limit;
+        chunk.triangles.set(tier, mesh.faces.length / 3);
+        chunk.world = null;
+        this.draw(chunk);
+    }
+    // ── drawing ───────────────────────────────────────────────────────────────────────
+    /**
+     * Draw every chunk again (a recolour, a hidden class, a selection): a few at a time, yielding the
+     * main thread between them so that a click selecting a cell never holds a frame; a newer redraw
+     * takes over from this one.
+     */
+    redraw() {
+        const generation = ++this.redrawGeneration;
+        const chunks = this.chunks.filter((c) => c.mesh);
+        void (async () => {
+            let start = performance.now();
+            for (const c of chunks) {
+                if (generation !== this.redrawGeneration)
+                    return;
+                this.draw(c);
+                if (performance.now() - start > REDRAW_SLICE_MS) {
+                    this.host.viewer.requestRender();
+                    await new Promise((r) => setTimeout(r));
+                    start = performance.now();
+                }
+            }
+            this.host.viewer.requestRender();
+        })();
+    }
+    /** Place a chunk's vertices in the world, in the cells' worker, then draw it (unless superseded). */
+    placeChunk(chunk, placement) {
+        const mesh = chunk.mesh;
+        if (!mesh || (chunk.placing?.mesh === mesh && chunk.placing.placement === placement))
+            return;
+        // This request's own token: one superseded (another mesh, or placement) is dropped when it
+        // lands, without dropping the request that replaced it.
+        const placing = { mesh, placement };
+        chunk.placing = placing;
+        placeInWorker(mesh.vertices, { size: [1, 1, 1], world: [1, 1, 1], planes: placement }).then((world) => {
+            if (chunk.placing !== placing)
+                return;
+            chunk.placing = null;
+            if (chunk.mesh !== mesh || this.placement !== placement)
+                return;
+            chunk.world = world;
+            this.draw(chunk);
+            this.host.viewer.requestRender();
+        }, (err) => {
+            if (chunk.placing === placing)
+                chunk.placing = null;
+            console.warn('[napari-js] cells could not be placed in 3D', err);
+        });
+    }
+    /** Draw a chunk's visible cells, in their colours: its layer updated in place, or added. */
+    draw(chunk) {
+        const mesh = chunk.mesh;
+        const placement = this.placement;
+        if (!mesh || !placement || chunk.want < 0) {
+            this.dropLayer(chunk);
+            return;
+        }
+        if (!chunk.world) {
+            // Placed off the main thread; drawn when it lands.
+            this.placeChunk(chunk, placement);
+            return;
+        }
+        const visible = this.visibleFaces(chunk);
+        // With a selection, its cells in a surface of their own (see Chunk.selectedLayer).
+        const [selected, rest] = this.selected
+            ? splitFaces(visible, mesh.vertexCell, this.selected)
+            : [new Uint32Array(0), visible];
+        chunk.drawn = rest;
+        chunk.drawnSelected = selected;
+        chunk.layer = this.drawSurface(chunk, chunk.layer, rest, this.vertexColors(mesh), this.opacity, 'cells');
+        chunk.selectedLayer = this.drawSurface(chunk, chunk.selectedLayer, selected, selected.length ? this.vertexColors(mesh, true) : null, 1, 'selected cells');
+    }
+    /**
+     * One of a chunk's surfaces with these triangles and colours: updated in place, added, or hidden
+     * when it has none. Returns the layer (null: none was ever needed).
+     */
+    drawSurface(chunk, layer, faces, colors, opacity, name) {
+        if (!faces.length || !colors || !chunk.world) {
+            if (layer)
+                layer.visible = false;
+            return layer;
+        }
+        if (layer) {
+            // A recolour, a new opacity: the geometry stays as uploaded.
+            const had = this.installed.get(layer);
+            if (!had || had.world !== chunk.world || !sameFaces(had.faces, faces)) {
+                layer.setData(chunk.world, faces);
+                this.installed.set(layer, { world: chunk.world, faces });
+            }
+            layer.vertexColors = colors;
+            layer.opacity = opacity;
+            layer.visible = true;
+            return layer;
+        }
+        const added = this.host.viewer.addSurface(chunk.world, faces, undefined, {
+            name: `${name} ${chunk.key}`,
+            vertexColors: colors,
+            opacity,
+            blending: 'translucent',
+            scale3d: [1, 1, this.zScale],
+            fit: 'never',
+        });
+        this.byLayer.set(added, chunk);
+        this.installed.set(added, { world: chunk.world, faces });
+        return added;
+    }
+    /** The triangles of the cells shown: their class not hidden, the observation shown. */
+    visibleFaces(chunk) {
+        const mesh = chunk.mesh;
+        const { faces, vertexCell } = mesh;
+        const visible = this.visible;
+        const hidden = this.hidden;
+        const shown = new Map();
+        const isShown = (cell) => {
+            let s = shown.get(cell);
+            if (s === undefined) {
+                const label = chunk.labels.get(cell) ?? null;
+                s = !(label !== null && hidden.has(label)) && (!visible || !!visible[cell]);
+                shown.set(cell, s);
+            }
+            return s;
+        };
+        if (!hidden.size && !visible)
+            return faces;
+        const out = new Uint32Array(faces.length);
+        let n = 0;
+        for (let f = 0; f < faces.length; f += 3) {
+            if (!isShown(vertexCell[faces[f]]))
+                continue;
+            out[n++] = faces[f];
+            out[n++] = faces[f + 1];
+            out[n++] = faces[f + 2];
+        }
+        return n === faces.length ? faces : out.slice(0, n);
+    }
+    /**
+     * Each vertex its cell's colour (white without colours). With a selection, a cell it leaves out
+     * keeps its colour and fades, as a picked region fades the others: its alpha brought down to the
+     * dimmed regions' opacity. `solid`: the selected cells' own surface, every vertex opaque.
+     */
+    vertexColors(mesh, solid = false) {
+        const out = new Float32Array(mesh.vertexCell.length * 4);
+        const colors = this.colors;
+        const selected = this.selected;
+        const o = this.opacity > 0 ? this.opacity : 1;
+        const dim = Math.min(1, REGION_MESH_DIMMED_OPACITY / o);
+        for (let v = 0; v < mesh.vertexCell.length; v++) {
+            const o = mesh.vertexCell[v] * 4;
+            if (colors && o + 3 < colors.length) {
+                out[v * 4] = colors[o];
+                out[v * 4 + 1] = colors[o + 1];
+                out[v * 4 + 2] = colors[o + 2];
+                out[v * 4 + 3] = colors[o + 3];
+            }
+            else {
+                out.fill(1, v * 4, v * 4 + 4);
+            }
+            if (solid)
+                out[v * 4 + 3] = 1;
+            else if (selected && !selected[mesh.vertexCell[v]])
+                out[v * 4 + 3] *= dim;
+        }
+        return out;
+    }
+    dropLayer(chunk) {
+        for (const layer of [chunk.layer, chunk.selectedLayer]) {
+            if (!layer)
+                continue;
+            this.byLayer.delete(layer);
+            this.host.viewer.layers.remove(layer);
+        }
+        chunk.layer = null;
+        chunk.selectedLayer = null;
+    }
+    report(building) {
+        if (!this.classes) {
+            this.emit(null);
+            return;
+        }
+        const drawn = this.chunks.filter((c) => c.layer && c.want >= 0);
+        const shown = drawn.reduce((s, c) => s + Math.max(0, c.meshed), 0);
+        const capped = this.chunks.some((c) => c.want < 0 || (c.want >= 0 && c.builtLimit < c.cells));
+        this.emit({ shown, capped, building: building || this.running });
+    }
+    emit(status) {
+        const key = JSON.stringify(status);
+        if (key === this.lastStatus)
+            return;
+        this.lastStatus = key;
+        this.host.status(status);
+    }
+    toWorldPoint(x, y, z) {
+        return this.placement
+            ? toWorld(Float32Array.of(x, y, z), { size: [1, 1, 1], world: [1, 1, 1], planes: this.placement })
+            : Float32Array.of(x, y, z);
+    }
+}
+/** The chunk grid over a region set's bounds, {@link CHUNKS_ACROSS} along its longer side. */
+function makeChunks(source) {
+    const b = source.info.bounds;
+    if (!b)
+        return [];
+    const size = Math.max(b[2] - b[0], b[3] - b[1]) / CHUNKS_ACROSS || 1;
+    const out = [];
+    for (let y = b[1]; y < b[3]; y += size) {
+        for (let x = b[0]; x < b[2]; x += size) {
+            // The last chunk of a row (column) reaches past the bounds: a cell centred on them is in it.
+            const x1 = x + size >= b[2] ? b[2] + 1 : x + size;
+            const y1 = y + size >= b[3] ? b[3] + 1 : y + size;
+            out.push({
+                key: `${Math.round(x)},${Math.round(y)}`,
+                box: [x, y, x1, y1],
+                tier: -1,
+                want: -1,
+                cells: -1,
+                triangles: new Map(),
+                limit: Infinity,
+                builtLimit: Infinity,
+                meshed: -1,
+                mesh: null,
+                labels: new Map(),
+                world: null,
+                drawn: null,
+                drawnSelected: null,
+                selectedLayer: null,
+                layer: null,
+            });
+        }
+    }
+    return out;
+}
+/** Meshes concatenated, each vertex keeping its cell. */
+function concatMeshes(parts) {
+    if (parts.length === 1)
+        return parts[0];
+    const nv = parts.reduce((s, p) => s + p.vertexCell.length, 0);
+    const nf = parts.reduce((s, p) => s + p.faces.length, 0);
+    const nc = parts.reduce((s, p) => s + p.cells.length, 0);
+    const out = {
+        vertices: new Float32Array(nv * 3),
+        faces: new Uint32Array(nf),
+        vertexCell: new Uint32Array(nv),
+        cells: new Uint32Array(nc),
+    };
+    let v = 0;
+    let f = 0;
+    let c = 0;
+    for (const p of parts) {
+        out.vertices.set(p.vertices, v * 3);
+        out.vertexCell.set(p.vertexCell, v);
+        for (let i = 0; i < p.faces.length; i++)
+            out.faces[f + i] = p.faces[i] + v;
+        out.cells.set(p.cells, c);
+        v += p.vertexCell.length;
+        f += p.faces.length;
+        c += p.cells.length;
+    }
+    return out;
+}
+/** The middle of the planes' slice range (slice units). */
+function midZ(p) {
+    return (p.z.length - 1) / 2;
+}
+/**
+ * Whether a chunk is to be built (again): its tier changed, or it was meshed in part and the plan
+ * now lets it have more of its cells, or fewer.
+ */
+function needsBuild(c) {
+    if (c.want < 0)
+        return false;
+    if (c.want !== c.tier)
+        return true;
+    return c.cells >= 0 && Math.min(c.builtLimit, c.cells) !== Math.min(c.limit, c.cells);
+}
+/** Whether two face lists are the same triangles. */
+function sameFaces(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function sameSet(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b || a.size !== b.size)
+        return false;
+    for (const x of a)
+        if (!b.has(x))
+            return false;
+    return true;
+}
+function samePlacement(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b || a.z.length !== b.z.length)
+        return false;
+    return (a.z.every((v, i) => v === b.z[i]) &&
+        a.scale.every((v, i) => v === b.scale[i]) &&
+        a.offset.every((v, i) => v === b.offset[i]));
+}
+/**
+ * Triangles `faces` split by whether their cell (`vertexCell` of their first vertex) is selected:
+ * the selected cells' triangles, then the others'.
+ */
+export function splitFaces(faces, vertexCell, selected) {
+    const sel = new Uint32Array(faces.length);
+    const rest = new Uint32Array(faces.length);
+    let s = 0;
+    let r = 0;
+    for (let f = 0; f < faces.length; f += 3) {
+        const out = selected[vertexCell[faces[f]]] ? sel : rest;
+        const at = out === sel ? s : r;
+        out[at] = faces[f];
+        out[at + 1] = faces[f + 1];
+        out[at + 2] = faces[f + 2];
+        if (out === sel)
+            s += 3;
+        else
+            r += 3;
+    }
+    return [sel.slice(0, s), rest.slice(0, r)];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-3d-cells.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-3d-cells.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Layer, SurfaceLayer, Viewer } from 'napari-js';\n\nimport type { Cells3dStatus } from '../../contracts/display-types';\nimport type { SpatialDataPort } from '../../contracts/ports/spatial-data.port';\nimport type { SpatialDataset } from '../../contracts/spatial-dataset.contract';\nimport type { CellsMesh } from '../../geometry/cell-meshes';\nimport type { RegionSource } from '../../region-source/region-source';\nimport { regionTilesInRect } from '../../region-source/region-tiles';\nimport { placeInWorker, reconstructCellsInWorker } from '../../region-source/worker-region-source';\nimport { cellOutlinesFromTiles, observationIndex } from '../../spatial/plane-cells';\nimport { typicalCellDiameter } from '../../spatial/lod';\nimport { datasetRegionSet } from '../../visualizer/spatial-region-set';\nimport { PlanePlacement, REGION_MESH_DIMMED_OPACITY, toWorld } from './napari-volume-region-meshes';\n\n/**\n * A 3D segmentation's cells in the spatial 3D view, each reconstructed by itself (see\n * `geometry/cell-meshes`), where the region classes are otherwise one merged surface per class.\n *\n * Built to stay out of the way of the UI thread and the GPU:\n *  - the space is cut into chunks (a grid over the region set's bounds); each chunk is one surface\n *    layer of its cells, meshed in the cells' own worker, a few hundred cells per call, so the\n *    work is cancelled between calls when the view moves on (and the region tiles the 2D view\n *    reads never wait behind it);\n *  - level of detail by chunk: a coarse mesh everywhere first, then the chunks on screen are meshed\n *    finer as the camera comes close, within a triangle budget for the whole scene; the region\n *    set's tiles are read at the level of detail that mesh needs;\n *  - at most {@link CELLS_3D_MAX_CELLS} cells and {@link CELLS_3D_TRIANGLE_BUDGET} triangles, the\n *    chunks nearest the centre of the view first (one chunk over either by itself is meshed in\n *    part), planned again as each chunk's real size is learnt; the status says when cells are left\n *    out, so the view never claims to show them all;\n *  - colour and visibility change no geometry: colours are per vertex (each vertex's cell), and a\n *    hidden cell's triangles are left out of what is drawn.\n * Builds report on the canvas's loading badge.\n */\n\n/** The most cells drawn at once. */\nexport const CELLS_3D_MAX_CELLS = 20_000;\n/** The most triangles every chunk together may have. */\nexport const CELLS_3D_TRIANGLE_BUDGET = 3_000_000;\n/** Chunks across the longer side of the region set's bounds. */\nconst CHUNKS_ACROSS = 8;\n/** A redraw yields the main thread after this long. */\nconst REDRAW_SLICE_MS = 8;\n/** Cells per worker call: the build can be dropped between calls. */\nconst BATCH = 400;\n/** A pause in the camera's movement this long re-plans the detail. */\nconst CAMERA_IDLE_MS = 250;\n/** A voxel at least this many screen pixels across is detail enough. */\nconst MIN_VOXEL_PX = 3;\n/** Each tier's voxel edge, as a fraction of a cell's diameter: coarse to fine. */\nconst TIER_FRACTIONS = [1 / 4, 1 / 8, 1 / 16] as const;\n/** A first guess at a coarse cell's triangles, before any chunk was built. */\nconst COARSE_TRIANGLES_PER_CELL = 300;\n\nexport interface Cells3dHost {\n  readonly viewer: Viewer;\n  readonly port: SpatialDataPort | null;\n  /** Show the cells loading on the canvas until the returned function is called. */\n  beginTask(label: 'Cells'): () => void;\n  status(status: Cells3dStatus | null): void;\n}\n\ninterface Chunk {\n  key: string;\n  /** Image px. */\n  box: [number, number, number, number];\n  /** The tier built (-1: none), and wanted by the last plan (-1: none, out of the cap). */\n  tier: number;\n  want: number;\n  /** Cells it has (-1 until built), and its triangles by tier built. */\n  cells: number;\n  triangles: Map<number, number>;\n  /** The most cells it may mesh (the cap, or the budget, left for it; Infinity: all). */\n  limit: number;\n  /** The limit it was built with, and the cells it meshed (-1 until built). */\n  builtLimit: number;\n  meshed: number;\n  mesh: CellsMesh | null;\n  /** Each meshed cell's class. */\n  labels: Map<number, string | null>;\n  world: Float32Array | null;\n  /**\n   * The triangles drawn in {@link layer} (the visible cells', or with a selection those it leaves\n   * out), as indices into the mesh's vertices.\n   */\n  drawn: Uint32Array | null;\n  layer: SurfaceLayer | null;\n  /**\n   * With a selection, its cells' triangles, drawn in {@link selectedLayer}: an opaque surface of\n   * their own, so the faded cells in front of them (a translucent surface draws only its nearest\n   * faces) show them through rather than hide them.\n   */\n  drawnSelected: Uint32Array | null;\n  selectedLayer: SurfaceLayer | null;\n  /** The placement in flight (its mesh and where it places it), if any. */\n  placing?: { mesh: CellsMesh; placement: PlanePlacement } | null;\n}\n\nexport type { Cells3dStatus };\n\nexport class Spatial3dCells {\n  private dataset: SpatialDataset | null = null;\n  private source: { id: string; open: Promise<RegionSource> } | null = null;\n  private classes: ReadonlySet<string> | null = null;\n  private hidden: ReadonlySet<string> = new Set();\n  private colors: Float32Array | null = null;\n  private visible: Uint8Array | null = null;\n  /** The selection (null: none): the cells it leaves out fade, keeping their colours. */\n  private selected: Uint8Array | null = null;\n  private opacity = 1;\n  private placement: PlanePlacement | null = null;\n  private zScale = 1;\n  private chunks: Chunk[] = [];\n  private readonly byLayer = new Map<Layer, Chunk>();\n  private generation = 0;\n  private timer: ReturnType<typeof setTimeout> | null = null;\n  private running = false;\n  private disposed = false;\n  /** Each surface's geometry as last set: a recolour that leaves it so uploads none again. */\n  private readonly installed = new WeakMap<SurfaceLayer, { world: Float32Array; faces: Uint32Array }>();\n  private cameraOff: (() => void) | null;\n\n  constructor(private readonly host: Cells3dHost) {\n    this.cameraOff = host.viewer.camera3d.changed.connect(() => this.schedule(CAMERA_IDLE_MS));\n  }\n\n  /** The dataset whose region set the cells are read from. */\n  setDataset(dataset: SpatialDataset | null): void {\n    if (dataset === this.dataset) return;\n    const id = datasetRegionSet(dataset);\n    const sameSet = !!id && id === this.source?.id && dataset?.id === this.dataset?.id;\n    this.dataset = dataset;\n    if (sameSet) return;\n    this.reset();\n    this.closeSource();\n    if (id && this.host.port?.openRegionSet) {\n      const open = this.host.port.openRegionSet(id);\n      this.source = { id, open };\n      open.catch(() => {\n        if (this.source?.open === open) this.source = null;\n      });\n    }\n    this.schedule(0);\n  }\n\n  /** The classes drawn as cells (none: the cells are not drawn). */\n  setClasses(classes: ReadonlySet<string> | null): void {\n    const next = classes?.size ? classes : null;\n    if (sameSet(next, this.classes)) return;\n    this.classes = next;\n    this.reset();\n    this.schedule(0);\n  }\n\n  /** Classes hidden (the Region Editor's eyes): their cells are left out of what is drawn. */\n  setHiddenClasses(classes: readonly string[]): void {\n    const next = new Set(classes);\n    if (sameSet(next, this.hidden)) return;\n    this.hidden = next;\n    this.redraw();\n  }\n\n  /**\n   * Each observation's colour (RGBA 0..1) and whether it is shown (null: all), and the surfaces'\n   * opacity: the panel's Cell Color, groups and selection. Changes no geometry.\n   */\n  setStyle(\n    colors: Float32Array | null,\n    visible: Uint8Array | null,\n    opacity: number,\n    selected: Uint8Array | null = null,\n  ): void {\n    this.colors = colors;\n    this.visible = visible;\n    this.opacity = opacity;\n    this.selected = selected;\n    this.redraw();\n  }\n\n  /** Where the planes are among the observations (null: nowhere, nothing drawn), and the Z stretch. */\n  setPlacement(placement: PlanePlacement | null, zScale: number): void {\n    const moved = !samePlacement(placement, this.placement);\n    // The same placement kept as it was (a scene passes a new object each time): a placement in\n    // flight for it is still good when it lands.\n    if (moved) this.placement = placement;\n    this.zScale = zScale;\n    for (const c of this.chunks) {\n      if (c.layer) c.layer.scale3d = [1, 1, zScale];\n      if (c.selectedLayer) c.selectedLayer.scale3d = [1, 1, zScale];\n    }\n    if (!moved) return;\n    for (const c of this.chunks) {\n      c.world = null;\n      c.placing = null; // one in flight was for the old placement: it is dropped when it lands\n    }\n    if (!placement) {\n      for (const c of this.chunks) this.dropLayer(c);\n    } else {\n      this.redraw();\n    }\n    this.schedule(0);\n  }\n\n  /** The observation of the cell drawn under canvas point (`x`, `y`) (CSS px), or -1. */\n  pick(x: number, y: number): number {\n    if (!this.byLayer.size) return -1;\n    const hit = this.host.viewer.pickSurface(x, y, { pickable: (l) => this.byLayer.has(l) });\n    const chunk = hit ? this.byLayer.get(hit.layer) : undefined;\n    const faces = hit && chunk && hit.layer === chunk.selectedLayer ? chunk.drawnSelected : chunk?.drawn;\n    if (!hit || !faces || !chunk?.mesh) return -1;\n    const vertex = faces[hit.face * 3];\n    return vertex === undefined ? -1 : chunk.mesh.vertexCell[vertex];\n  }\n\n  /** Whether `layer` is one of the cells' surfaces. */\n  owns(layer: Layer): boolean {\n    return this.byLayer.has(layer);\n  }\n\n  dispose(): void {\n    this.disposed = true;\n    this.cameraOff?.();\n    this.cameraOff = null;\n    if (this.timer) clearTimeout(this.timer);\n    this.timer = null;\n    this.reset();\n    this.closeSource();\n    this.emit(null);\n  }\n\n  // ── planning ──────────────────────────────────────────────────────────────────────\n\n  private schedule(delay: number): void {\n    if (this.disposed) return;\n    if (this.timer) clearTimeout(this.timer);\n    this.timer = setTimeout(() => {\n      this.timer = null;\n      void this.plan();\n    }, delay);\n  }\n\n  /** Drop every chunk (their layers) and any build in flight. */\n  private reset(): void {\n    this.generation++;\n    for (const c of this.chunks) this.dropLayer(c);\n    this.chunks = [];\n  }\n\n  private closeSource(): void {\n    const s = this.source;\n    this.source = null;\n    void s?.open.then(\n      (src) => src.dispose(),\n      () => undefined,\n    );\n  }\n\n  /** Decide each chunk's detail (and whether it is drawn at all), then build what changed. */\n  private async plan(): Promise<void> {\n    const dataset = this.dataset;\n    const index = dataset ? observationIndex(dataset.observations) : null;\n    if (!this.classes || !this.source || !dataset || !index || !this.placement) {\n      if (this.chunks.length) this.reset();\n      this.emit(null);\n      return;\n    }\n    const generation = this.generation;\n    let source: RegionSource;\n    try {\n      source = await this.source.open;\n    } catch (err) {\n      console.warn(\"[napari-js] the cells' region set could not be opened\", err);\n      this.emit(null);\n      return;\n    }\n    if (generation !== this.generation) return;\n    if (!this.chunks.length) this.chunks = makeChunks(source);\n    const steps = this.steps(dataset);\n    this.replanTiers(steps);\n    this.report(false);\n    if (!this.running) void this.run(source, index, steps);\n  }\n\n  /** {@link assignTiers} from the view as it is now, taking down what it leaves out. */\n  private replanTiers(steps: number[]): void {\n    this.assignTiers(this.priority(), steps);\n    for (const c of this.chunks) if (c.want < 0) this.dropLayer(c);\n  }\n\n  /** Voxel edge of each tier, image px: fractions of a typical cell's diameter. */\n  private steps(dataset: SpatialDataset): number[] {\n    const sx = dataset.imageRef?.scale?.[0] ?? 1;\n    const d = Math.max(4, typicalCellDiameter(dataset.observations.radius) * Math.abs(sx || 1));\n    return TIER_FRACTIONS.map((f) => Math.max(1, d * f));\n  }\n\n  /**\n   * The chunks, nearest the centre of the view first, with how many screen pixels an image pixel\n   * of each takes (0 off screen).\n   */\n  private priority(): { chunk: Chunk; ppi: number; onScreen: boolean; d2: number }[] {\n    const viewer = this.host.viewer;\n    const [vw, vh] = viewer.viewportSize();\n    const pts = new Float32Array(this.chunks.length * 6);\n    const zMid = this.placement ? midZ(this.placement) : 0;\n    this.chunks.forEach((c, i) => {\n      const [x0, y0, x1, y1] = c.box;\n      const cy = (y0 + y1) / 2;\n      const a = this.toWorldPoint((x0 + x1) / 2, cy, zMid);\n      const b = this.toWorldPoint(x1, cy, zMid);\n      pts.set(a, i * 6);\n      pts.set(b, i * 6 + 3);\n    });\n    const proj = vw > 0 && vh > 0 ? viewer.projectPoints(pts) : null;\n    const out = this.chunks.map((chunk, i) => {\n      const sx = proj?.screen[i * 4] ?? NaN;\n      const sy = proj?.screen[i * 4 + 1] ?? NaN;\n      const ex = proj?.screen[i * 4 + 2] ?? NaN;\n      const ey = proj?.screen[i * 4 + 3] ?? NaN;\n      const half = Math.hypot(ex - sx, ey - sy);\n      const width = (chunk.box[2] - chunk.box[0]) / 2;\n      const ppi = Number.isFinite(half) && width > 0 ? half / width : 0;\n      const onScreen =\n        Number.isFinite(sx) && sx > -half && sx < vw + half && sy > -half && sy < vh + half && ppi > 0;\n      const d2 = Number.isFinite(sx) ? (sx - vw / 2) ** 2 + (sy - vh / 2) ** 2 : Number.MAX_VALUE;\n      return { chunk, ppi: onScreen ? ppi : 0, onScreen, d2 };\n    });\n    return out.sort((a, b) => Number(b.onScreen) - Number(a.onScreen) || a.d2 - b.d2);\n  }\n\n  /**\n   * Each chunk's tier: in order, within the cell cap, as fine as the screen asks within the\n   * triangle budget. The chunks last in order give up their detail first, then are left out; the\n   * first is never left out, but one over the cap or the budget by itself meshes only the cells\n   * that fit (its {@link Chunk.limit}).\n   */\n  private assignTiers(order: { chunk: Chunk; ppi: number }[], steps: number[]): void {\n    const known = this.chunks.filter((c) => c.cells >= 0);\n    const avgCells = known.length ? known.reduce((s, c) => s + c.cells, 0) / known.length : 200;\n    let cells = 0;\n    const included: { chunk: Chunk; tier: number; take: number; room: number }[] = [];\n    for (const { chunk, ppi } of order) {\n      const n = chunk.cells >= 0 ? chunk.cells : avgCells;\n      const room = CELLS_3D_MAX_CELLS - cells;\n      if (n > room && included.length) {\n        chunk.want = -1;\n        continue;\n      }\n      const take = Math.min(n, room);\n      cells += take;\n      let tier = 0;\n      for (let t = steps.length - 1; t > 0; t--) {\n        if (ppi * steps[t] >= MIN_VOXEL_PX) {\n          tier = t;\n          break;\n        }\n      }\n      included.push({ chunk, tier, take, room });\n    }\n    const triangles = (e: { chunk: Chunk; tier: number }) => this.trianglesAt(e.chunk, e.tier, steps, avgCells);\n    // The budget: the chunks last in order give up their detail first, then their place.\n    let total = included.reduce((s, e) => s + triangles(e), 0);\n    for (let i = included.length - 1; i >= 0 && total > CELLS_3D_TRIANGLE_BUDGET; i--) {\n      const e = included[i];\n      while (e.tier > 0 && total > CELLS_3D_TRIANGLE_BUDGET) {\n        total -= triangles(e) - triangles({ chunk: e.chunk, tier: e.tier - 1 });\n        e.tier--;\n      }\n    }\n    while (included.length > 1 && total > CELLS_3D_TRIANGLE_BUDGET) {\n      const e = included.pop()!;\n      total -= triangles(e);\n      e.chunk.want = -1;\n    }\n    for (const e of included) {\n      const n = e.chunk.cells >= 0 ? e.chunk.cells : avgCells;\n      let take = e.take;\n      // The first chunk alone over the budget, at its coarsest: as many cells as fit in it.\n      const all = triangles(e);\n      if (all > CELLS_3D_TRIANGLE_BUDGET) {\n        const perCell = all / Math.max(1, e.chunk.meshed > 0 ? e.chunk.meshed : n);\n        take = Math.min(take, CELLS_3D_TRIANGLE_BUDGET / perCell);\n      }\n      e.chunk.want = e.tier;\n      // Cut short when over; and one not built yet, which may have more cells than the guess, to\n      // the room the cap leaves it.\n      const most = take < n ? take : e.chunk.cells < 0 ? e.room : Infinity;\n      e.chunk.limit = Number.isFinite(most) ? Math.max(1, Math.floor(most)) : Infinity;\n    }\n  }\n\n  /** A chunk's triangles at `tier`: as built, else scaled from a tier built (by the step's square). */\n  private trianglesAt(chunk: Chunk, tier: number, steps: number[], avgCells: number): number {\n    const at = chunk.triangles.get(tier);\n    if (at !== undefined) return at;\n    for (const [t, n] of chunk.triangles) return n * (steps[t] / steps[tier]) ** 2;\n    const cells = chunk.cells >= 0 ? chunk.cells : avgCells;\n    return cells * COARSE_TRIANGLES_PER_CELL * (steps[0] / steps[tier]) ** 2;\n  }\n\n  // ── building ──────────────────────────────────────────────────────────────────────\n\n  /** Build every chunk whose tier changed, nearest first, one at a time, until none is left. */\n  private async run(source: RegionSource, index: ReadonlyMap<string, number>, steps: number[]): Promise<void> {\n    this.running = true;\n    let stale = false;\n    const end = this.host.beginTask('Cells');\n    try {\n      for (;;) {\n        const generation = this.generation;\n        const next = this.priority()\n          .map((e) => e.chunk)\n          .find((c) => needsBuild(c));\n        if (!next) break;\n        this.report(true);\n        try {\n          await this.build(next, next.want, source, index, steps, generation);\n        } catch (err) {\n          console.warn('[napari-js] cells could not be built in 3D', err);\n          next.want = next.tier; // not retried until the view asks again\n        }\n        if (generation !== this.generation) {\n          // Superseded (other classes, another dataset): the plan made for those found this run\n          // still going and started none of its own. Plan again, now that it has stopped.\n          stale = true;\n          break;\n        }\n        // The chunk's real size is known now, where the plan guessed: plan again by it.\n        this.replanTiers(steps);\n      }\n    } finally {\n      end();\n      this.running = false;\n      this.report(false);\n      if (stale) this.schedule(0);\n    }\n  }\n\n  private async build(\n    chunk: Chunk,\n    tier: number,\n    source: RegionSource,\n    index: ReadonlyMap<string, number>,\n    steps: number[],\n    generation: number,\n  ): Promise<void> {\n    const info = source.info;\n    const step = steps[tier];\n    const level = Math.max(0, Math.min(info.levels - 1, Math.floor(Math.log2(step))));\n    // Tiles around the chunk: a cell crossing its edge is the chunk's its centre is in.\n    const margin = steps[0] * 8;\n    const [x0, y0, x1, y1] = chunk.box;\n    const keys = regionTilesInRect(\n      [x0 - margin, y0 - margin, x1 + margin, y1 + margin],\n      level,\n      info.tileSize,\n      info.bounds,\n    );\n    const planes = await Promise.all(\n      info.planes.map(async (z, slice) => ({\n        slice,\n        tiles: await Promise.all(keys.map((k) => source.getTile(z, k))),\n      })),\n    );\n    if (generation !== this.generation) return;\n    const found = cellOutlinesFromTiles(planes, index, this.classes, chunk.box);\n    const limit = chunk.limit;\n    const cells = found.length > limit ? found.slice(0, limit) : found;\n    const labels = new Map(cells.map((c) => [c.cell, c.label] as [number, string | null]));\n    const parts: CellsMesh[] = [];\n    for (let i = 0; i < cells.length; i += BATCH) {\n      const batch = cells.slice(i, i + BATCH).map((c) => ({ cell: c.cell, slices: c.slices }));\n      parts.push(await reconstructCellsInWorker(batch, { pixelStep: step }));\n      if (generation !== this.generation) return;\n    }\n    const mesh = concatMeshes(parts);\n    chunk.mesh = mesh;\n    chunk.labels = labels;\n    chunk.tier = tier;\n    chunk.cells = found.length;\n    chunk.meshed = mesh.cells.length;\n    chunk.builtLimit = limit;\n    chunk.triangles.set(tier, mesh.faces.length / 3);\n    chunk.world = null;\n    this.draw(chunk);\n  }\n\n  // ── drawing ───────────────────────────────────────────────────────────────────────\n\n  /**\n   * Draw every chunk again (a recolour, a hidden class, a selection): a few at a time, yielding the\n   * main thread between them so that a click selecting a cell never holds a frame; a newer redraw\n   * takes over from this one.\n   */\n  private redraw(): void {\n    const generation = ++this.redrawGeneration;\n    const chunks = this.chunks.filter((c) => c.mesh);\n    void (async () => {\n      let start = performance.now();\n      for (const c of chunks) {\n        if (generation !== this.redrawGeneration) return;\n        this.draw(c);\n        if (performance.now() - start > REDRAW_SLICE_MS) {\n          this.host.viewer.requestRender();\n          await new Promise((r) => setTimeout(r));\n          start = performance.now();\n        }\n      }\n      this.host.viewer.requestRender();\n    })();\n  }\n  private redrawGeneration = 0;\n\n  /** Place a chunk's vertices in the world, in the cells' worker, then draw it (unless superseded). */\n  private placeChunk(chunk: Chunk, placement: PlanePlacement): void {\n    const mesh = chunk.mesh;\n    if (!mesh || (chunk.placing?.mesh === mesh && chunk.placing.placement === placement)) return;\n    // This request's own token: one superseded (another mesh, or placement) is dropped when it\n    // lands, without dropping the request that replaced it.\n    const placing = { mesh, placement };\n    chunk.placing = placing;\n    placeInWorker(mesh.vertices, { size: [1, 1, 1], world: [1, 1, 1], planes: placement }).then(\n      (world) => {\n        if (chunk.placing !== placing) return;\n        chunk.placing = null;\n        if (chunk.mesh !== mesh || this.placement !== placement) return;\n        chunk.world = world;\n        this.draw(chunk);\n        this.host.viewer.requestRender();\n      },\n      (err) => {\n        if (chunk.placing === placing) chunk.placing = null;\n        console.warn('[napari-js] cells could not be placed in 3D', err);\n      },\n    );\n  }\n\n  /** Draw a chunk's visible cells, in their colours: its layer updated in place, or added. */\n  private draw(chunk: Chunk): void {\n    const mesh = chunk.mesh;\n    const placement = this.placement;\n    if (!mesh || !placement || chunk.want < 0) {\n      this.dropLayer(chunk);\n      return;\n    }\n    if (!chunk.world) {\n      // Placed off the main thread; drawn when it lands.\n      this.placeChunk(chunk, placement);\n      return;\n    }\n    const visible = this.visibleFaces(chunk);\n    // With a selection, its cells in a surface of their own (see Chunk.selectedLayer).\n    const [selected, rest] = this.selected\n      ? splitFaces(visible, mesh.vertexCell, this.selected)\n      : [new Uint32Array(0), visible];\n    chunk.drawn = rest;\n    chunk.drawnSelected = selected;\n    chunk.layer = this.drawSurface(chunk, chunk.layer, rest, this.vertexColors(mesh), this.opacity, 'cells');\n    chunk.selectedLayer = this.drawSurface(\n      chunk,\n      chunk.selectedLayer,\n      selected,\n      selected.length ? this.vertexColors(mesh, true) : null,\n      1,\n      'selected cells',\n    );\n  }\n\n  /**\n   * One of a chunk's surfaces with these triangles and colours: updated in place, added, or hidden\n   * when it has none. Returns the layer (null: none was ever needed).\n   */\n  private drawSurface(\n    chunk: Chunk,\n    layer: SurfaceLayer | null,\n    faces: Uint32Array,\n    colors: Float32Array | null,\n    opacity: number,\n    name: string,\n  ): SurfaceLayer | null {\n    if (!faces.length || !colors || !chunk.world) {\n      if (layer) layer.visible = false;\n      return layer;\n    }\n    if (layer) {\n      // A recolour, a new opacity: the geometry stays as uploaded.\n      const had = this.installed.get(layer);\n      if (!had || had.world !== chunk.world || !sameFaces(had.faces, faces)) {\n        layer.setData(chunk.world, faces);\n        this.installed.set(layer, { world: chunk.world, faces });\n      }\n      layer.vertexColors = colors;\n      layer.opacity = opacity;\n      layer.visible = true;\n      return layer;\n    }\n    const added = this.host.viewer.addSurface(chunk.world, faces, undefined, {\n      name: `${name} ${chunk.key}`,\n      vertexColors: colors,\n      opacity,\n      blending: 'translucent',\n      scale3d: [1, 1, this.zScale],\n      fit: 'never',\n    });\n    this.byLayer.set(added, chunk);\n    this.installed.set(added, { world: chunk.world, faces });\n    return added;\n  }\n\n  /** The triangles of the cells shown: their class not hidden, the observation shown. */\n  private visibleFaces(chunk: Chunk): Uint32Array {\n    const mesh = chunk.mesh!;\n    const { faces, vertexCell } = mesh;\n    const visible = this.visible;\n    const hidden = this.hidden;\n    const shown = new Map<number, boolean>();\n    const isShown = (cell: number) => {\n      let s = shown.get(cell);\n      if (s === undefined) {\n        const label = chunk.labels.get(cell) ?? null;\n        s = !(label !== null && hidden.has(label)) && (!visible || !!visible[cell]);\n        shown.set(cell, s);\n      }\n      return s;\n    };\n    if (!hidden.size && !visible) return faces;\n    const out = new Uint32Array(faces.length);\n    let n = 0;\n    for (let f = 0; f < faces.length; f += 3) {\n      if (!isShown(vertexCell[faces[f]])) continue;\n      out[n++] = faces[f];\n      out[n++] = faces[f + 1];\n      out[n++] = faces[f + 2];\n    }\n    return n === faces.length ? faces : out.slice(0, n);\n  }\n\n  /**\n   * Each vertex its cell's colour (white without colours). With a selection, a cell it leaves out\n   * keeps its colour and fades, as a picked region fades the others: its alpha brought down to the\n   * dimmed regions' opacity. `solid`: the selected cells' own surface, every vertex opaque.\n   */\n  private vertexColors(mesh: CellsMesh, solid = false): Float32Array {\n    const out = new Float32Array(mesh.vertexCell.length * 4);\n    const colors = this.colors;\n    const selected = this.selected;\n    const o = this.opacity > 0 ? this.opacity : 1;\n    const dim = Math.min(1, REGION_MESH_DIMMED_OPACITY / o);\n    for (let v = 0; v < mesh.vertexCell.length; v++) {\n      const o = mesh.vertexCell[v] * 4;\n      if (colors && o + 3 < colors.length) {\n        out[v * 4] = colors[o];\n        out[v * 4 + 1] = colors[o + 1];\n        out[v * 4 + 2] = colors[o + 2];\n        out[v * 4 + 3] = colors[o + 3];\n      } else {\n        out.fill(1, v * 4, v * 4 + 4);\n      }\n      if (solid) out[v * 4 + 3] = 1;\n      else if (selected && !selected[mesh.vertexCell[v]]) out[v * 4 + 3] *= dim;\n    }\n    return out;\n  }\n\n  private dropLayer(chunk: Chunk): void {\n    for (const layer of [chunk.layer, chunk.selectedLayer]) {\n      if (!layer) continue;\n      this.byLayer.delete(layer);\n      this.host.viewer.layers.remove(layer);\n    }\n    chunk.layer = null;\n    chunk.selectedLayer = null;\n  }\n\n  private report(building: boolean): void {\n    if (!this.classes) {\n      this.emit(null);\n      return;\n    }\n    const drawn = this.chunks.filter((c) => c.layer && c.want >= 0);\n    const shown = drawn.reduce((s, c) => s + Math.max(0, c.meshed), 0);\n    const capped = this.chunks.some((c) => c.want < 0 || (c.want >= 0 && c.builtLimit < c.cells));\n    this.emit({ shown, capped, building: building || this.running });\n  }\n\n  /** Tell the host how the cells stand, only when that changed (the camera re-plans often). */\n  private lastStatus = 'null';\n  private emit(status: Cells3dStatus | null): void {\n    const key = JSON.stringify(status);\n    if (key === this.lastStatus) return;\n    this.lastStatus = key;\n    this.host.status(status);\n  }\n\n  private toWorldPoint(x: number, y: number, z: number): Float32Array {\n    return this.placement\n      ? toWorld(Float32Array.of(x, y, z), { size: [1, 1, 1], world: [1, 1, 1], planes: this.placement })\n      : Float32Array.of(x, y, z);\n  }\n}\n\n/** The chunk grid over a region set's bounds, {@link CHUNKS_ACROSS} along its longer side. */\nfunction makeChunks(source: RegionSource): Chunk[] {\n  const b = source.info.bounds;\n  if (!b) return [];\n  const size = Math.max(b[2] - b[0], b[3] - b[1]) / CHUNKS_ACROSS || 1;\n  const out: Chunk[] = [];\n  for (let y = b[1]; y < b[3]; y += size) {\n    for (let x = b[0]; x < b[2]; x += size) {\n      // The last chunk of a row (column) reaches past the bounds: a cell centred on them is in it.\n      const x1 = x + size >= b[2] ? b[2] + 1 : x + size;\n      const y1 = y + size >= b[3] ? b[3] + 1 : y + size;\n      out.push({\n        key: `${Math.round(x)},${Math.round(y)}`,\n        box: [x, y, x1, y1],\n        tier: -1,\n        want: -1,\n        cells: -1,\n        triangles: new Map(),\n        limit: Infinity,\n        builtLimit: Infinity,\n        meshed: -1,\n        mesh: null,\n        labels: new Map(),\n        world: null,\n        drawn: null,\n        drawnSelected: null,\n        selectedLayer: null,\n        layer: null,\n      });\n    }\n  }\n  return out;\n}\n\n/** Meshes concatenated, each vertex keeping its cell. */\nfunction concatMeshes(parts: readonly CellsMesh[]): CellsMesh {\n  if (parts.length === 1) return parts[0];\n  const nv = parts.reduce((s, p) => s + p.vertexCell.length, 0);\n  const nf = parts.reduce((s, p) => s + p.faces.length, 0);\n  const nc = parts.reduce((s, p) => s + p.cells.length, 0);\n  const out: CellsMesh = {\n    vertices: new Float32Array(nv * 3),\n    faces: new Uint32Array(nf),\n    vertexCell: new Uint32Array(nv),\n    cells: new Uint32Array(nc),\n  };\n  let v = 0;\n  let f = 0;\n  let c = 0;\n  for (const p of parts) {\n    out.vertices.set(p.vertices, v * 3);\n    out.vertexCell.set(p.vertexCell, v);\n    for (let i = 0; i < p.faces.length; i++) out.faces[f + i] = p.faces[i] + v;\n    out.cells.set(p.cells, c);\n    v += p.vertexCell.length;\n    f += p.faces.length;\n    c += p.cells.length;\n  }\n  return out;\n}\n\n/** The middle of the planes' slice range (slice units). */\nfunction midZ(p: PlanePlacement): number {\n  return (p.z.length - 1) / 2;\n}\n\n/**\n * Whether a chunk is to be built (again): its tier changed, or it was meshed in part and the plan\n * now lets it have more of its cells, or fewer.\n */\nfunction needsBuild(c: Chunk): boolean {\n  if (c.want < 0) return false;\n  if (c.want !== c.tier) return true;\n  return c.cells >= 0 && Math.min(c.builtLimit, c.cells) !== Math.min(c.limit, c.cells);\n}\n\n/** Whether two face lists are the same triangles. */\nfunction sameFaces(a: Uint32Array, b: Uint32Array): boolean {\n  if (a === b) return true;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n\nfunction sameSet(a: ReadonlySet<string> | null, b: ReadonlySet<string> | null): boolean {\n  if (a === b) return true;\n  if (!a || !b || a.size !== b.size) return false;\n  for (const x of a) if (!b.has(x)) return false;\n  return true;\n}\n\nfunction samePlacement(a: PlanePlacement | null, b: PlanePlacement | null): boolean {\n  if (a === b) return true;\n  if (!a || !b || a.z.length !== b.z.length) return false;\n  return (\n    a.z.every((v, i) => v === b.z[i]) &&\n    a.scale.every((v, i) => v === b.scale[i]) &&\n    a.offset.every((v, i) => v === b.offset[i])\n  );\n}\n\n/**\n * Triangles `faces` split by whether their cell (`vertexCell` of their first vertex) is selected:\n * the selected cells' triangles, then the others'.\n */\nexport function splitFaces(\n  faces: Uint32Array,\n  vertexCell: Uint32Array,\n  selected: Uint8Array,\n): [Uint32Array, Uint32Array] {\n  const sel = new Uint32Array(faces.length);\n  const rest = new Uint32Array(faces.length);\n  let s = 0;\n  let r = 0;\n  for (let f = 0; f < faces.length; f += 3) {\n    const out = selected[vertexCell[faces[f]]] ? sel : rest;\n    const at = out === sel ? s : r;\n    out[at] = faces[f];\n    out[at + 1] = faces[f + 1];\n    out[at + 2] = faces[f + 2];\n    if (out === sel) s += 3;\n    else r += 3;\n  }\n  return [sel.slice(0, s), rest.slice(0, r)];\n}\n"]}