@jax-data-science/sci-image-visualizer 0.16.0 → 0.18.0

package/esm2022/lib/implementations/napari-js/napari-volume-region-meshes.mjs

@@ -1,40 +1,77 @@
+import { sliceZ, toWorld } from '../../geometry/place';
+export { sliceZ, toWorld };
 /** Opacity of a region's surface in the volume. */
 export const REGION_MESH_OPACITY = 0.55;
 /** While some surfaces are highlighted: theirs (near opaque, so their shape reads) … */
 export const REGION_MESH_HIGHLIGHT_OPACITY = 0.9;
 /** … and the others' (ghosted: still there for context, not in the way). */
 export const REGION_MESH_DIMMED_OPACITY = 0.12;
+/**
+ * A selection's surfaces while the others are ghosted: opaque, so they are drawn first and write
+ * depth, and the ghosted surfaces in front of them are blended over them rather than hiding them
+ * (a translucent surface draws only its own nearest faces, and is drawn after the opaque ones).
+ */
+export const REGION_MESH_SELECTED_OPACITY = 1;
 /**
  * The region reconstructions shown in a volume view: one translucent surface per region, in its
  * colour, placed in the volume's world box (pixel x, y and slice z mapped onto it the way the
- * volume maps its voxels) and re-placed when the volume's Z is stretched. A surface is updated in
- * place (`setData`, `color`) rather than added again, and picked by napari-js (`pickSurface`).
+ * volume maps its voxels). The box's Z stretch is the surfaces' `scale3d` (a uniform), so a stretch
+ * alone changes no geometry; a new box re-places them. A surface is updated in place (`setData`,
+ * `color`, `scale3d`) rather than added again, and picked by napari-js (`pickSurface`), which
+ * picks it where it is drawn.
  *
  * Highlighting is focus + context: the highlighted surfaces turn near opaque and the others fade
  * to a ghost, so the selection stands out while staying in place among its neighbours.
  */
 export class VolumeRegionMeshes {
-    constructor(viewer) {
+    /**
+     * `placer`, when given, places a mesh's vertices in the world off the main thread (a worker, see
+     * `placeInWorker`): a class's surface has hundreds of thousands of vertices, and placing every
+     * one in a loop here held the UI for seconds. Each surface then comes up as its placement lands,
+     * the one it replaces kept until then. Without one, they are placed at once (the tests).
+     */
+    constructor(viewer, placer) {
         this.viewer = viewer;
+        this.placer = placer;
         this.layers = new Map();
         this.highlighted = new Set();
         this.hidden = new Set();
+        /** Surfaces faded: none of what is selected is in them. */
+        this.muted = new Set();
         /** The meshes to show (kept while the volume has no frame yet). */
         this.wanted = [];
         this.frame = null;
+        /** The placements in flight, by key: the mesh and box each is for. */
+        this.placing = new Map();
+        this.token = 0;
     }
     /** Show exactly `meshes` (adding, keeping or removing surfaces). */
     set(meshes) {
         this.wanted = meshes;
         this.sync();
     }
-    /** Follow the volume's frame (it opened, or its Z was stretched): re-place every surface. */
+    /**
+     * Follow the volume's frame. A new box (it opened, another volume) re-places every surface; a Z
+     * stretch of the same box only sets their `scale3d`, so nothing is re-uploaded while dragging.
+     */
     setFrame(frame) {
+        const placed = this.frame ? baseFrame(this.frame) : null;
+        const next = baseFrame(frame);
+        const sameBox = !!placed && sameFrame(placed, next);
         this.frame = frame;
-        for (const e of this.layers.values())
-            e.layer.setData(toWorld(e.mesh.vertices, frame), e.mesh.faces);
+        const scale = this.scale3d();
+        for (const e of this.layers.values()) {
+            if (!sameBox)
+                this.place(e.mesh);
+            e.layer.scale3d = scale;
+        }
         this.sync();
     }
+    /** The surfaces' GPU scale: the frame's Z stretch. */
+    scale3d() {
+        const s = this.frame?.zScale;
+        return [1, 1, s && s > 0 ? s : 1];
+    }
     /** Highlight the surfaces of these keys (none: every surface as usual). */
     setHighlight(keys) {
         this.highlighted = new Set(keys);
@@ -42,6 +79,20 @@ export class VolumeRegionMeshes {
             e.layer.opacity = this.opacityOf(key);
         this.viewer.requestRender();
     }
+    /**
+     * Fade the surfaces of these keys, as a picked region fades the others (none: each as usual):
+     * with a selection, the regions none of it is in fade and those it is in come forward, each
+     * keeping its colour.
+     */
+    setMuted(keys) {
+        const next = new Set(keys);
+        if (next.size === this.muted.size && [...next].every((k) => this.muted.has(k)))
+            return;
+        this.muted = next;
+        for (const [key, e] of this.layers)
+            e.layer.opacity = this.opacityOf(key);
+        this.viewer.requestRender();
+    }
     /** Hide the surfaces of these keys (they are kept, so showing them again is instant). */
     setHidden(keys) {
         this.hidden = new Set(keys);
@@ -85,24 +136,67 @@ export class VolumeRegionMeshes {
                 continue;
             }
             // Rebuilt or recoloured: the same surface, updated in place.
-            if (want.vertices !== e.mesh.vertices && this.frame) {
-                e.layer.setData(toWorld(want.vertices, this.frame), want.faces);
-            }
+            const rebuilt = want.vertices !== e.mesh.vertices;
             if (want.color !== e.mesh.color)
                 e.layer.color = want.color;
             e.mesh = want;
+            if (rebuilt && this.frame)
+                this.place(want);
         }
         if (this.frame) {
             for (const mesh of this.wanted)
                 if (!this.layers.has(mesh.key) && mesh.faces.length)
-                    this.add(mesh);
+                    this.place(mesh);
         }
         this.viewer.requestRender();
     }
-    add(mesh) {
+    /**
+     * Place `mesh` in the current box, adding its surface or updating it: at once, or through the
+     * placer, its result kept only if the mesh and the box are still the ones wanted. A placement
+     * already in flight for the same mesh and box is not asked again.
+     */
+    place(mesh) {
         const frame = this.frame;
-        const layer = this.viewer.addSurface(toWorld(mesh.vertices, frame), mesh.faces, undefined, {
+        if (!frame)
+            return;
+        const base = baseFrame(frame);
+        if (!this.placer) {
+            this.apply(mesh, toWorld(mesh.vertices, base));
+            return;
+        }
+        const pending = this.placing.get(mesh.key);
+        if (pending && pending.mesh === mesh && sameFrame(pending.frame, base))
+            return;
+        const token = ++this.token;
+        this.placing.set(mesh.key, { mesh, frame: base, token });
+        this.placer(mesh.vertices, base).then((world) => {
+            if (this.placing.get(mesh.key)?.token !== token)
+                return;
+            this.placing.delete(mesh.key);
+            const wanted = this.wanted.find((m) => m.key === mesh.key);
+            if (wanted !== mesh || !this.frame || !sameFrame(baseFrame(this.frame), base))
+                return;
+            this.apply(mesh, world);
+            this.viewer.requestRender();
+        }, (err) => {
+            if (this.placing.get(mesh.key)?.token === token)
+                this.placing.delete(mesh.key);
+            console.warn(`[napari-js] region ${mesh.key} could not be placed in 3D`, err);
+        });
+    }
+    /** `mesh`'s surface with its vertices placed at `world`: updated in place, or added. */
+    apply(mesh, world) {
+        const e = this.layers.get(mesh.key);
+        if (e) {
+            e.layer.setData(world, mesh.faces);
+            return;
+        }
+        this.add(mesh, world);
+    }
+    add(mesh, world) {
+        const layer = this.viewer.addSurface(world, mesh.faces, undefined, {
             name: `region ${mesh.key}`,
+            scale3d: this.scale3d(),
             color: mesh.color,
             opacity: this.opacityOf(mesh.key),
             blending: 'translucent',
@@ -112,28 +206,42 @@ export class VolumeRegionMeshes {
         this.layers.set(mesh.key, { mesh, layer });
     }
     opacityOf(key) {
+        if (this.muted.size)
+            return this.muted.has(key) ? REGION_MESH_DIMMED_OPACITY : REGION_MESH_SELECTED_OPACITY;
         if (!this.highlighted.size)
             return REGION_MESH_OPACITY;
-        return this.highlighted.has(key) ? REGION_MESH_HIGHLIGHT_OPACITY : REGION_MESH_DIMMED_OPACITY;
+        return this.highlighted.has(key) ? REGION_MESH_SELECTED_OPACITY : REGION_MESH_DIMMED_OPACITY;
     }
     remove(key, layer) {
         this.viewer.layers.remove(layer);
         this.layers.delete(key);
+        this.placing.delete(key);
     }
 }
-/**
- * Image px / slice coordinates → the volume's centred world box: pixel x of a `w`-wide image
- * spans the box's width, slice k sits at the middle of its share of the box's depth.
- */
-export function toWorld(vertices, frame) {
-    const [w, h, d] = frame.size;
-    const [ww, wh, wd] = frame.world;
-    const out = new Float32Array(vertices.length);
-    for (let i = 0; i < vertices.length; i += 3) {
-        out[i] = (vertices[i] / w - 0.5) * ww;
-        out[i + 1] = (vertices[i + 1] / h - 0.5) * wh;
-        out[i + 2] = ((vertices[i + 2] + 0.5) / d - 0.5) * wd;
-    }
-    return out;
+/** `frame` without its Z stretch: the box the surfaces' geometry is placed in. */
+function baseFrame(frame) {
+    const s = frame.zScale && frame.zScale > 0 ? frame.zScale : 1;
+    if (s === 1)
+        return frame;
+    return {
+        size: frame.size,
+        world: [frame.world[0], frame.world[1], frame.world[2] / s],
+        ...(frame.planes ? { planes: frame.planes } : {}),
+    };
+}
+/** Whether two unstretched frames place a surface alike. */
+function sameFrame(a, b) {
+    const near = (x, y) => Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x));
+    if (a.planes || b.planes) {
+        const p = a.planes;
+        const q = b.planes;
+        return (!!p &&
+            !!q &&
+            p.z.length === q.z.length &&
+            p.z.every((v, i) => near(v, q.z[i])) &&
+            p.scale.every((v, i) => near(v, q.scale[i])) &&
+            p.offset.every((v, i) => near(v, q.offset[i])));
+    }
+    return a.size.every((v, i) => v === b.size[i]) && a.world.every((v, i) => near(v, b.world[i]));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-region-meshes.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-region-meshes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SurfaceLayer, Viewer } from 'napari-js';\n\n/** A region's 3D reconstruction to show in the volume: a mesh in image px (x, y) and slices (z). */\nexport interface RegionMesh3D {\n  /** Identity (a class name): a mesh with the same key and arrays is kept, not rebuilt. */\n  key: string;\n  /** `#rrggbb`. */\n  color: string;\n  /** What hovering it shows (\"HPF · Hippocampal formation\"); default: the key. */\n  label?: string;\n  vertices: Float32Array;\n  faces: Uint32Array;\n}\n\n/** Where the stack sits in the volume's world: its full size, and the centred world box it fills. */\nexport interface VolumeFrame {\n  /** Image width, height (px) and slice count. */\n  size: [number, number, number];\n  /** The world box (centred on the origin), Z as currently stretched. */\n  world: [number, number, number];\n}\n\n/** Opacity of a region's surface in the volume. */\nexport const REGION_MESH_OPACITY = 0.55;\n/** While some surfaces are highlighted: theirs (near opaque, so their shape reads) … */\nexport const REGION_MESH_HIGHLIGHT_OPACITY = 0.9;\n/** … and the others' (ghosted: still there for context, not in the way). */\nexport const REGION_MESH_DIMMED_OPACITY = 0.12;\n\n/**\n * The region reconstructions shown in a volume view: one translucent surface per region, in its\n * colour, placed in the volume's world box (pixel x, y and slice z mapped onto it the way the\n * volume maps its voxels) and re-placed when the volume's Z is stretched. A surface is updated in\n * place (`setData`, `color`) rather than added again, and picked by napari-js (`pickSurface`).\n *\n * Highlighting is focus + context: the highlighted surfaces turn near opaque and the others fade\n * to a ghost, so the selection stands out while staying in place among its neighbours.\n */\nexport class VolumeRegionMeshes {\n  private readonly layers = new Map<string, { mesh: RegionMesh3D; layer: SurfaceLayer }>();\n  private highlighted: ReadonlySet<string> = new Set();\n  private hidden: ReadonlySet<string> = new Set();\n  /** The meshes to show (kept while the volume has no frame yet). */\n  private wanted: readonly RegionMesh3D[] = [];\n  private frame: VolumeFrame | null = null;\n\n  constructor(private readonly viewer: Viewer) {}\n\n  /** Show exactly `meshes` (adding, keeping or removing surfaces). */\n  set(meshes: readonly RegionMesh3D[]): void {\n    this.wanted = meshes;\n    this.sync();\n  }\n\n  /** Follow the volume's frame (it opened, or its Z was stretched): re-place every surface. */\n  setFrame(frame: VolumeFrame): void {\n    this.frame = frame;\n    for (const e of this.layers.values()) e.layer.setData(toWorld(e.mesh.vertices, frame), e.mesh.faces);\n    this.sync();\n  }\n\n  /** Highlight the surfaces of these keys (none: every surface as usual). */\n  setHighlight(keys: Iterable<string>): void {\n    this.highlighted = new Set(keys);\n    for (const [key, e] of this.layers) e.layer.opacity = this.opacityOf(key);\n    this.viewer.requestRender();\n  }\n\n  /** Hide the surfaces of these keys (they are kept, so showing them again is instant). */\n  setHidden(keys: Iterable<string>): void {\n    this.hidden = new Set(keys);\n    for (const [key, e] of this.layers) e.layer.visible = !this.hidden.has(key);\n    this.viewer.requestRender();\n  }\n\n  /** The front-most surface under screen point (`x`, `y`) (canvas CSS px), or null. */\n  pickAt(x: number, y: number): RegionMesh3D | null {\n    if (!this.layers.size) return null;\n    const ours = new Map([...this.layers.values()].map((e) => [e.layer, e.mesh]));\n    const hit = this.viewer.pickSurface(x, y, { pickable: (layer) => ours.has(layer) });\n    return hit ? (ours.get(hit.layer) ?? null) : null;\n  }\n\n  /** The meshes shown. */\n  get shown(): RegionMesh3D[] {\n    return [...this.layers.values()].map((e) => e.mesh);\n  }\n\n  clear(): void {\n    for (const [key, e] of [...this.layers]) this.remove(key, e.layer);\n    this.wanted = [];\n  }\n\n  /**\n   * The volume the surfaces sat in is gone (or no longer theirs): take every surface down, keeping\n   * the meshes wanted, so they come back when a frame is set again.\n   */\n  clearFrame(): void {\n    this.frame = null;\n    for (const [key, e] of [...this.layers]) this.remove(key, e.layer);\n    this.viewer.requestRender();\n  }\n\n  private sync(): void {\n    const keep = new Map(this.wanted.map((m) => [m.key, m]));\n    for (const [key, e] of [...this.layers]) {\n      const want = keep.get(key);\n      if (!want || !want.faces.length) {\n        this.remove(key, e.layer);\n        continue;\n      }\n      // Rebuilt or recoloured: the same surface, updated in place.\n      if (want.vertices !== e.mesh.vertices && this.frame) {\n        e.layer.setData(toWorld(want.vertices, this.frame), want.faces);\n      }\n      if (want.color !== e.mesh.color) e.layer.color = want.color;\n      e.mesh = want;\n    }\n    if (this.frame) {\n      for (const mesh of this.wanted) if (!this.layers.has(mesh.key) && mesh.faces.length) this.add(mesh);\n    }\n    this.viewer.requestRender();\n  }\n\n  private add(mesh: RegionMesh3D): void {\n    const frame = this.frame as VolumeFrame;\n    const layer = this.viewer.addSurface(toWorld(mesh.vertices, frame), mesh.faces, undefined, {\n      name: `region ${mesh.key}`,\n      color: mesh.color,\n      opacity: this.opacityOf(mesh.key),\n      blending: 'translucent',\n      fit: 'never',\n    });\n    layer.visible = !this.hidden.has(mesh.key);\n    this.layers.set(mesh.key, { mesh, layer });\n  }\n\n  private opacityOf(key: string): number {\n    if (!this.highlighted.size) return REGION_MESH_OPACITY;\n    return this.highlighted.has(key) ? REGION_MESH_HIGHLIGHT_OPACITY : REGION_MESH_DIMMED_OPACITY;\n  }\n\n  private remove(key: string, layer: SurfaceLayer): void {\n    this.viewer.layers.remove(layer);\n    this.layers.delete(key);\n  }\n}\n\n/**\n * Image px / slice coordinates → the volume's centred world box: pixel x of a `w`-wide image\n * spans the box's width, slice k sits at the middle of its share of the box's depth.\n */\nexport function toWorld(vertices: Float32Array, frame: VolumeFrame): Float32Array {\n  const [w, h, d] = frame.size;\n  const [ww, wh, wd] = frame.world;\n  const out = new Float32Array(vertices.length);\n  for (let i = 0; i < vertices.length; i += 3) {\n    out[i] = (vertices[i] / w - 0.5) * ww;\n    out[i + 1] = (vertices[i + 1] / h - 0.5) * wh;\n    out[i + 2] = ((vertices[i + 2] + 0.5) / d - 0.5) * wd;\n  }\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-region-meshes.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-region-meshes.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+B,MAAM,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGpF,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AAiB3B,mDAAmD;AACnD,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,CAAC;AACxC,wFAAwF;AACxF,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,CAAC;AACjD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAI,CAAC;AAC/C;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,OAAO,kBAAkB;IAc7B;;;;;OAKG;IACH,YACmB,MAAc,EACd,MAAqB;QADrB,WAAM,GAAN,MAAM,CAAQ;QACd,WAAM,GAAN,MAAM,CAAe;QArBvB,WAAM,GAAG,IAAI,GAAG,EAAuD,CAAC;QACjF,gBAAW,GAAwB,IAAI,GAAG,EAAE,CAAC;QAC7C,WAAM,GAAwB,IAAI,GAAG,EAAE,CAAC;QAChD,2DAA2D;QACnD,UAAK,GAAwB,IAAI,GAAG,EAAE,CAAC;QAC/C,mEAAmE;QAC3D,WAAM,GAA4B,EAAE,CAAC;QACrC,UAAK,GAAuB,IAAI,CAAC;QAEzC,sEAAsE;QACrD,YAAO,GAAG,IAAI,GAAG,EAAqE,CAAC;QAChG,UAAK,GAAG,CAAC,CAAC;IAWf,CAAC;IAEJ,oEAAoE;IACpE,GAAG,CAAC,MAA+B;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAkB;QACzB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACzD,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAC9B,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,IAAI,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,OAAO;gBAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACjC,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC;QAC1B,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,sDAAsD;IAC9C,OAAO;QACb,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;QAC7B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IAED,2EAA2E;IAC3E,YAAY,CAAC,IAAsB;QACjC,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;QACjC,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM;YAAE,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAC1E,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,IAAsB;QAC7B,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO;QACvF,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM;YAAE,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAC1E,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAED,yFAAyF;IACzF,SAAS,CAAC,IAAsB;QAC9B,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5B,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM;YAAE,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5E,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAED,qFAAqF;IACrF,MAAM,CAAC,CAAS,EAAE,CAAS;QACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACnC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC9E,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACpF,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACpD,CAAC;IAED,wBAAwB;IACxB,IAAI,KAAK;QACP,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED,KAAK;QACH,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QACnE,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QACnE,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAEO,IAAI;QACV,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;gBAChC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;gBAC1B,SAAS;YACX,CAAC;YACD,6DAA6D;YAC7D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;YAClD,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK;gBAAE,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAC5D,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;YACd,IAAI,OAAO,IAAI,IAAI,CAAC,KAAK;gBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,MAAM;gBAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM;oBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxG,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,IAAkB;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;YAC/C,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC;YAAE,OAAO;QAC/E,MAAM,KAAK,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,IAAI,CACnC,CAAC,KAAK,EAAE,EAAE;YACR,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,KAAK;gBAAE,OAAO;YACxD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3D,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC;gBAAE,OAAO;YACtF,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;QAC9B,CAAC,EACD,CAAC,GAAG,EAAE,EAAE;YACN,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,KAAK;gBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC/E,OAAO,CAAC,IAAI,CAAC,sBAAsB,IAAI,CAAC,GAAG,4BAA4B,EAAE,GAAG,CAAC,CAAC;QAChF,CAAC,CACF,CAAC;IACJ,CAAC;IAED,wFAAwF;IAChF,KAAK,CAAC,IAAkB,EAAE,KAAmB;QACnD,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,EAAE,CAAC;YACN,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACnC,OAAO;QACT,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACxB,CAAC;IAEO,GAAG,CAAC,IAAkB,EAAE,KAAmB;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE;YACjE,IAAI,EAAE,UAAU,IAAI,CAAC,GAAG,EAAE;YAC1B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE;YACvB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;YACjC,QAAQ,EAAE,aAAa;YACvB,GAAG,EAAE,OAAO;SACb,CAAC,CAAC;QACH,KAAK,CAAC,OAAO,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7C,CAAC;IAEO,SAAS,CAAC,GAAW;QAC3B,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,4BAA4B,CAAC;QAC5G,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI;YAAE,OAAO,mBAAmB,CAAC;QACvD,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAC,0BAA0B,CAAC;IAC/F,CAAC;IAEO,MAAM,CAAC,GAAW,EAAE,KAAmB;QAC7C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;CACF;AAED,kFAAkF;AAClF,SAAS,SAAS,CAAC,KAAkB;IACnC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC1B,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3D,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAClD,CAAC;AACJ,CAAC;AAED,4DAA4D;AAC5D,SAAS,SAAS,CAAC,CAAc,EAAE,CAAc;IAC/C,MAAM,IAAI,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1F,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QACnB,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QACnB,OAAO,CACL,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM;YACzB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5C,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAC/C,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjG,CAAC","sourcesContent":["import type { SurfaceLayer, Viewer } from 'napari-js';\n\nimport { PlanePlacement, VolumeFrame, sliceZ, toWorld } from '../../geometry/place';\n\nexport type { PlanePlacement, VolumeFrame };\nexport { sliceZ, toWorld };\n\n/** A region's 3D reconstruction to show in the volume: a mesh in image px (x, y) and slices (z). */\nexport interface RegionMesh3D {\n  /** Identity (a class name): a mesh with the same key and arrays is kept, not rebuilt. */\n  key: string;\n  /** `#rrggbb`. */\n  color: string;\n  /** What hovering it shows (\"HPF · Hippocampal formation\"); default: the key. */\n  label?: string;\n  vertices: Float32Array;\n  faces: Uint32Array;\n}\n\n/** Places a mesh's vertices (image px, slices) in a 3D view's world, off the main thread. */\nexport type RegionPlacer = (vertices: Float32Array, frame: VolumeFrame) => Promise<Float32Array>;\n\n/** Opacity of a region's surface in the volume. */\nexport const REGION_MESH_OPACITY = 0.55;\n/** While some surfaces are highlighted: theirs (near opaque, so their shape reads) … */\nexport const REGION_MESH_HIGHLIGHT_OPACITY = 0.9;\n/** … and the others' (ghosted: still there for context, not in the way). */\nexport const REGION_MESH_DIMMED_OPACITY = 0.12;\n/**\n * A selection's surfaces while the others are ghosted: opaque, so they are drawn first and write\n * depth, and the ghosted surfaces in front of them are blended over them rather than hiding them\n * (a translucent surface draws only its own nearest faces, and is drawn after the opaque ones).\n */\nexport const REGION_MESH_SELECTED_OPACITY = 1;\n\n/**\n * The region reconstructions shown in a volume view: one translucent surface per region, in its\n * colour, placed in the volume's world box (pixel x, y and slice z mapped onto it the way the\n * volume maps its voxels). The box's Z stretch is the surfaces' `scale3d` (a uniform), so a stretch\n * alone changes no geometry; a new box re-places them. A surface is updated in place (`setData`,\n * `color`, `scale3d`) rather than added again, and picked by napari-js (`pickSurface`), which\n * picks it where it is drawn.\n *\n * Highlighting is focus + context: the highlighted surfaces turn near opaque and the others fade\n * to a ghost, so the selection stands out while staying in place among its neighbours.\n */\nexport class VolumeRegionMeshes {\n  private readonly layers = new Map<string, { mesh: RegionMesh3D; layer: SurfaceLayer }>();\n  private highlighted: ReadonlySet<string> = new Set();\n  private hidden: ReadonlySet<string> = new Set();\n  /** Surfaces faded: none of what is selected is in them. */\n  private muted: ReadonlySet<string> = new Set();\n  /** The meshes to show (kept while the volume has no frame yet). */\n  private wanted: readonly RegionMesh3D[] = [];\n  private frame: VolumeFrame | null = null;\n\n  /** The placements in flight, by key: the mesh and box each is for. */\n  private readonly placing = new Map<string, { mesh: RegionMesh3D; frame: VolumeFrame; token: number }>();\n  private token = 0;\n\n  /**\n   * `placer`, when given, places a mesh's vertices in the world off the main thread (a worker, see\n   * `placeInWorker`): a class's surface has hundreds of thousands of vertices, and placing every\n   * one in a loop here held the UI for seconds. Each surface then comes up as its placement lands,\n   * the one it replaces kept until then. Without one, they are placed at once (the tests).\n   */\n  constructor(\n    private readonly viewer: Viewer,\n    private readonly placer?: RegionPlacer,\n  ) {}\n\n  /** Show exactly `meshes` (adding, keeping or removing surfaces). */\n  set(meshes: readonly RegionMesh3D[]): void {\n    this.wanted = meshes;\n    this.sync();\n  }\n\n  /**\n   * Follow the volume's frame. A new box (it opened, another volume) re-places every surface; a Z\n   * stretch of the same box only sets their `scale3d`, so nothing is re-uploaded while dragging.\n   */\n  setFrame(frame: VolumeFrame): void {\n    const placed = this.frame ? baseFrame(this.frame) : null;\n    const next = baseFrame(frame);\n    const sameBox = !!placed && sameFrame(placed, next);\n    this.frame = frame;\n    const scale = this.scale3d();\n    for (const e of this.layers.values()) {\n      if (!sameBox) this.place(e.mesh);\n      e.layer.scale3d = scale;\n    }\n    this.sync();\n  }\n\n  /** The surfaces' GPU scale: the frame's Z stretch. */\n  private scale3d(): [number, number, number] {\n    const s = this.frame?.zScale;\n    return [1, 1, s && s > 0 ? s : 1];\n  }\n\n  /** Highlight the surfaces of these keys (none: every surface as usual). */\n  setHighlight(keys: Iterable<string>): void {\n    this.highlighted = new Set(keys);\n    for (const [key, e] of this.layers) e.layer.opacity = this.opacityOf(key);\n    this.viewer.requestRender();\n  }\n\n  /**\n   * Fade the surfaces of these keys, as a picked region fades the others (none: each as usual):\n   * with a selection, the regions none of it is in fade and those it is in come forward, each\n   * keeping its colour.\n   */\n  setMuted(keys: Iterable<string>): void {\n    const next = new Set(keys);\n    if (next.size === this.muted.size && [...next].every((k) => this.muted.has(k))) return;\n    this.muted = next;\n    for (const [key, e] of this.layers) e.layer.opacity = this.opacityOf(key);\n    this.viewer.requestRender();\n  }\n\n  /** Hide the surfaces of these keys (they are kept, so showing them again is instant). */\n  setHidden(keys: Iterable<string>): void {\n    this.hidden = new Set(keys);\n    for (const [key, e] of this.layers) e.layer.visible = !this.hidden.has(key);\n    this.viewer.requestRender();\n  }\n\n  /** The front-most surface under screen point (`x`, `y`) (canvas CSS px), or null. */\n  pickAt(x: number, y: number): RegionMesh3D | null {\n    if (!this.layers.size) return null;\n    const ours = new Map([...this.layers.values()].map((e) => [e.layer, e.mesh]));\n    const hit = this.viewer.pickSurface(x, y, { pickable: (layer) => ours.has(layer) });\n    return hit ? (ours.get(hit.layer) ?? null) : null;\n  }\n\n  /** The meshes shown. */\n  get shown(): RegionMesh3D[] {\n    return [...this.layers.values()].map((e) => e.mesh);\n  }\n\n  clear(): void {\n    for (const [key, e] of [...this.layers]) this.remove(key, e.layer);\n    this.wanted = [];\n  }\n\n  /**\n   * The volume the surfaces sat in is gone (or no longer theirs): take every surface down, keeping\n   * the meshes wanted, so they come back when a frame is set again.\n   */\n  clearFrame(): void {\n    this.frame = null;\n    for (const [key, e] of [...this.layers]) this.remove(key, e.layer);\n    this.viewer.requestRender();\n  }\n\n  private sync(): void {\n    const keep = new Map(this.wanted.map((m) => [m.key, m]));\n    for (const [key, e] of [...this.layers]) {\n      const want = keep.get(key);\n      if (!want || !want.faces.length) {\n        this.remove(key, e.layer);\n        continue;\n      }\n      // Rebuilt or recoloured: the same surface, updated in place.\n      const rebuilt = want.vertices !== e.mesh.vertices;\n      if (want.color !== e.mesh.color) e.layer.color = want.color;\n      e.mesh = want;\n      if (rebuilt && this.frame) this.place(want);\n    }\n    if (this.frame) {\n      for (const mesh of this.wanted) if (!this.layers.has(mesh.key) && mesh.faces.length) this.place(mesh);\n    }\n    this.viewer.requestRender();\n  }\n\n  /**\n   * Place `mesh` in the current box, adding its surface or updating it: at once, or through the\n   * placer, its result kept only if the mesh and the box are still the ones wanted. A placement\n   * already in flight for the same mesh and box is not asked again.\n   */\n  private place(mesh: RegionMesh3D): void {\n    const frame = this.frame;\n    if (!frame) return;\n    const base = baseFrame(frame);\n    if (!this.placer) {\n      this.apply(mesh, toWorld(mesh.vertices, base));\n      return;\n    }\n    const pending = this.placing.get(mesh.key);\n    if (pending && pending.mesh === mesh && sameFrame(pending.frame, base)) return;\n    const token = ++this.token;\n    this.placing.set(mesh.key, { mesh, frame: base, token });\n    this.placer(mesh.vertices, base).then(\n      (world) => {\n        if (this.placing.get(mesh.key)?.token !== token) return;\n        this.placing.delete(mesh.key);\n        const wanted = this.wanted.find((m) => m.key === mesh.key);\n        if (wanted !== mesh || !this.frame || !sameFrame(baseFrame(this.frame), base)) return;\n        this.apply(mesh, world);\n        this.viewer.requestRender();\n      },\n      (err) => {\n        if (this.placing.get(mesh.key)?.token === token) this.placing.delete(mesh.key);\n        console.warn(`[napari-js] region ${mesh.key} could not be placed in 3D`, err);\n      },\n    );\n  }\n\n  /** `mesh`'s surface with its vertices placed at `world`: updated in place, or added. */\n  private apply(mesh: RegionMesh3D, world: Float32Array): void {\n    const e = this.layers.get(mesh.key);\n    if (e) {\n      e.layer.setData(world, mesh.faces);\n      return;\n    }\n    this.add(mesh, world);\n  }\n\n  private add(mesh: RegionMesh3D, world: Float32Array): void {\n    const layer = this.viewer.addSurface(world, mesh.faces, undefined, {\n      name: `region ${mesh.key}`,\n      scale3d: this.scale3d(),\n      color: mesh.color,\n      opacity: this.opacityOf(mesh.key),\n      blending: 'translucent',\n      fit: 'never',\n    });\n    layer.visible = !this.hidden.has(mesh.key);\n    this.layers.set(mesh.key, { mesh, layer });\n  }\n\n  private opacityOf(key: string): number {\n    if (this.muted.size) return this.muted.has(key) ? REGION_MESH_DIMMED_OPACITY : REGION_MESH_SELECTED_OPACITY;\n    if (!this.highlighted.size) return REGION_MESH_OPACITY;\n    return this.highlighted.has(key) ? REGION_MESH_SELECTED_OPACITY : REGION_MESH_DIMMED_OPACITY;\n  }\n\n  private remove(key: string, layer: SurfaceLayer): void {\n    this.viewer.layers.remove(layer);\n    this.layers.delete(key);\n    this.placing.delete(key);\n  }\n}\n\n/** `frame` without its Z stretch: the box the surfaces' geometry is placed in. */\nfunction baseFrame(frame: VolumeFrame): VolumeFrame {\n  const s = frame.zScale && frame.zScale > 0 ? frame.zScale : 1;\n  if (s === 1) return frame;\n  return {\n    size: frame.size,\n    world: [frame.world[0], frame.world[1], frame.world[2] / s],\n    ...(frame.planes ? { planes: frame.planes } : {}),\n  };\n}\n\n/** Whether two unstretched frames place a surface alike. */\nfunction sameFrame(a: VolumeFrame, b: VolumeFrame): boolean {\n  const near = (x: number, y: number) => Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x));\n  if (a.planes || b.planes) {\n    const p = a.planes;\n    const q = b.planes;\n    return (\n      !!p &&\n      !!q &&\n      p.z.length === q.z.length &&\n      p.z.every((v, i) => near(v, q.z[i])) &&\n      p.scale.every((v, i) => near(v, q.scale[i])) &&\n      p.offset.every((v, i) => near(v, q.offset[i]))\n    );\n  }\n  return a.size.every((v, i) => v === b.size[i]) && a.world.every((v, i) => near(v, b.world[i]));\n}\n"]}