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

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

@@ -0,0 +1,129 @@
+/** 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;
+/**
+ * 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`).
+ *
+ * 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) {
+        this.viewer = viewer;
+        this.layers = new Map();
+        this.highlighted = new Set();
+        this.hidden = new Set();
+        /** The meshes to show (kept while the volume has no frame yet). */
+        this.wanted = [];
+        this.frame = null;
+    }
+    /** 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. */
+    setFrame(frame) {
+        this.frame = frame;
+        for (const e of this.layers.values())
+            e.layer.setData(toWorld(e.mesh.vertices, frame), e.mesh.faces);
+        this.sync();
+    }
+    /** Highlight the surfaces of these keys (none: every surface as usual). */
+    setHighlight(keys) {
+        this.highlighted = new Set(keys);
+        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);
+        for (const [key, e] of this.layers)
+            e.layer.visible = !this.hidden.has(key);
+        this.viewer.requestRender();
+    }
+    /** The front-most surface under screen point (`x`, `y`) (canvas CSS px), or null. */
+    pickAt(x, y) {
+        if (!this.layers.size)
+            return null;
+        const ours = new Map([...this.layers.values()].map((e) => [e.layer, e.mesh]));
+        const hit = this.viewer.pickSurface(x, y, { pickable: (layer) => ours.has(layer) });
+        return hit ? (ours.get(hit.layer) ?? null) : null;
+    }
+    /** The meshes shown. */
+    get shown() {
+        return [...this.layers.values()].map((e) => e.mesh);
+    }
+    clear() {
+        for (const [key, e] of [...this.layers])
+            this.remove(key, e.layer);
+        this.wanted = [];
+    }
+    sync() {
+        const keep = new Map(this.wanted.map((m) => [m.key, m]));
+        for (const [key, e] of [...this.layers]) {
+            const want = keep.get(key);
+            if (!want || !want.faces.length) {
+                this.remove(key, e.layer);
+                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);
+            }
+            if (want.color !== e.mesh.color)
+                e.layer.color = want.color;
+            e.mesh = want;
+        }
+        if (this.frame) {
+            for (const mesh of this.wanted)
+                if (!this.layers.has(mesh.key) && mesh.faces.length)
+                    this.add(mesh);
+        }
+        this.viewer.requestRender();
+    }
+    add(mesh) {
+        const frame = this.frame;
+        const layer = this.viewer.addSurface(toWorld(mesh.vertices, frame), mesh.faces, undefined, {
+            name: `region ${mesh.key}`,
+            color: mesh.color,
+            opacity: this.opacityOf(mesh.key),
+            blending: 'translucent',
+            fit: 'never',
+        });
+        layer.visible = !this.hidden.has(mesh.key);
+        this.layers.set(mesh.key, { mesh, layer });
+    }
+    opacityOf(key) {
+        if (!this.highlighted.size)
+            return REGION_MESH_OPACITY;
+        return this.highlighted.has(key) ? REGION_MESH_HIGHLIGHT_OPACITY : REGION_MESH_DIMMED_OPACITY;
+    }
+    remove(key, layer) {
+        this.viewer.layers.remove(layer);
+        this.layers.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;
+}
+//# 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  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"]}