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

package/esm2022/lib/geometry/section.mjs

@@ -0,0 +1,215 @@
+/**
+ * A section through a stack of slices' outlines: where a plane across the slices (x = const or
+ * y = const) cuts each class's regions. A class's closed shapes cut into intervals on each slice
+ * they cross (each feature even-odd, the features as their union); stacked one slice thick, the
+ * intervals are traced into outlines. Its open lines
+ * (a layer boundary on each B-scan, say) cut into one point per slice they cross, joined slice to
+ * slice into the line the boundary draws across the stack (a slice without it breaks the line).
+ *
+ * Section coordinates `(u, v)`: through `x = at`, u is the slice (slice k spans [k, k + 1)) and
+ * v the image y; through `y = at`, u is the image x and v the slice.
+ *
+ * Pure: usable from workers.
+ */
+import { maskToPolygons } from './contour';
+import { featureRings } from './reconstruct';
+/** Index every class's outlines for cutting (see {@link SectionIndex}). */
+export function indexOutlines(byClass) {
+    const classes = new Map();
+    for (const [label, slices] of byClass) {
+        const box = [Infinity, Infinity, -Infinity, -Infinity];
+        const indexed = slices.map((s) => ({
+            z: s.z,
+            rings: s.rings.map((points) => withBox(points, box)),
+            ...(s.ringGroups ? { ringGroups: s.ringGroups } : {}),
+            lines: (s.lines ?? []).map((points) => withBox(points, box)),
+        }));
+        if (box[0] <= box[2])
+            classes.set(label, { box, slices: indexed });
+    }
+    return { classes };
+}
+function withBox(points, total) {
+    const box = [Infinity, Infinity, -Infinity, -Infinity];
+    for (let i = 0; i + 1 < points.length; i += 2) {
+        if (points[i] < box[0])
+            box[0] = points[i];
+        if (points[i] > box[2])
+            box[2] = points[i];
+        if (points[i + 1] < box[1])
+            box[1] = points[i + 1];
+        if (points[i + 1] > box[3])
+            box[3] = points[i + 1];
+    }
+    total[0] = Math.min(total[0], box[0]);
+    total[1] = Math.min(total[1], box[1]);
+    total[2] = Math.max(total[2], box[2]);
+    total[3] = Math.max(total[3], box[3]);
+    return { points, box };
+}
+/** Whether a box spans the plane `axis = at`. */
+function spans(box, axis, at) {
+    return axis === 'x' ? box[0] <= at && at <= box[2] : box[1] <= at && at <= box[3];
+}
+/**
+ * Each class's cut by the plane `axis = at`; classes the plane misses are left out. Pass an
+ * {@link indexOutlines} index to cut many sections of the same outlines.
+ */
+export function sectionOutlines(outlines, axis, at, opts) {
+    const index = outlines instanceof Map ? indexOutlines(outlines) : outlines;
+    const out = new Map();
+    for (const [label, { box, slices }] of index.classes) {
+        if (!spans(box, axis, at))
+            continue;
+        const rings = cutShapes(slices, axis, at, opts);
+        const lines = cutLines(slices, axis, at, opts);
+        if (rings.length || lines.length)
+            out.set(label, { rings, lines });
+    }
+    return out;
+}
+/** The closed shapes' cut: intervals per slice, rasterised one slice thick and traced. */
+function cutShapes(slices, axis, at, opts) {
+    const step = Math.max(opts.step ?? 1, 1e-6);
+    const depth = Math.max(1, Math.ceil(opts.depth));
+    const cells = Math.max(1, Math.ceil(opts.extent / step));
+    // Through x: columns are slices, rows in-plane cells. Through y: the other way round.
+    const w = axis === 'x' ? depth : cells;
+    const h = axis === 'x' ? cells : depth;
+    let mask = null;
+    for (const s of slices) {
+        if (!s.rings.length || s.z < 0 || s.z >= depth)
+            continue;
+        const crossed = [];
+        const groups = [];
+        s.rings.forEach((r, i) => {
+            if (!spans(r.box, axis, at))
+                return;
+            crossed.push(r.points);
+            groups.push(s.ringGroups?.[i] ?? 0);
+        });
+        if (!crossed.length)
+            continue;
+        // Each feature's intervals, set into the mask: the features as their union.
+        for (const feature of featureRings(crossed, s.ringGroups ? groups : undefined)) {
+            const crossings = ringCrossings(feature, axis, at);
+            for (let c = 0; c + 1 < crossings.length; c += 2) {
+                // Cells whose centre lies in the interval (the pixel-centre rule).
+                const from = Math.max(0, Math.ceil(crossings[c] / step - 0.5));
+                const to = Math.min(cells - 1, Math.floor(crossings[c + 1] / step - 0.5));
+                if (to < from)
+                    continue;
+                mask ??= new Uint8Array(w * h);
+                for (let k = from; k <= to; k++)
+                    mask[axis === 'x' ? k * w + s.z : s.z * w + k] = 1;
+            }
+        }
+    }
+    if (!mask)
+        return [];
+    const toSection = (cx, cy) => axis === 'x' ? [cx, cy * step] : [cx * step, cy];
+    const rings = [];
+    for (const p of maskToPolygons(mask, w, h, 0, 0, 1, 1)) {
+        rings.push(flat(p.xpoints.map((x, i) => toSection(x, p.ypoints[i]))));
+        for (const hole of p.holes ?? [])
+            rings.push(flat(hole.map(([x, y]) => toSection(x, y))));
+    }
+    return rings;
+}
+/** Where `rings` cross the plane, along the in-plane axis, sorted (even-odd: pairs are inside). */
+function ringCrossings(rings, axis, at) {
+    // Through x = at the crossings are y values; through y = at, x values.
+    const a = axis === 'x' ? 0 : 1;
+    const out = [];
+    for (const r of rings) {
+        const n = r.length >> 1;
+        for (let i = 0, j = n - 1; i < n; j = i++) {
+            const pi = r[2 * i + a], pj = r[2 * j + a];
+            if (pi > at !== pj > at) {
+                const qi = r[2 * i + 1 - a], qj = r[2 * j + 1 - a];
+                out.push(qi + ((at - pi) * (qj - qi)) / (pj - pi));
+            }
+        }
+    }
+    return out.sort((p, q) => p - q);
+}
+/** The open lines' cut: a point per crossing, joined slice to slice (nearest first, each once). */
+function cutLines(slices, axis, at, opts) {
+    const maxJump = opts.maxJump ?? opts.extent / 10;
+    const stack = slices
+        .map((s) => ({
+        z: s.z,
+        hits: lineCrossings(s.lines.filter((l) => spans(l.box, axis, at)).map((l) => l.points), axis, at),
+    }))
+        .filter((s) => s.hits.length)
+        .sort((p, q) => p.z - q.z);
+    const done = [];
+    let open = [];
+    let prevZ = -Infinity;
+    for (const { z, hits } of stack) {
+        // A slice without the line between: the chains end there, not bridged across it.
+        if (z !== prevZ + 1) {
+            for (const c of open)
+                done.push(c.points);
+            open = [];
+        }
+        prevZ = z;
+        const pairs = [];
+        open.forEach((c, ci) => hits.forEach((q, hi) => pairs.push({ chain: ci, hit: hi, d: Math.abs(q - c.last) })));
+        pairs.sort((p, q) => p.d - q.d);
+        const nextOpen = [];
+        const usedChain = new Set();
+        const usedHit = new Set();
+        for (const p of pairs) {
+            if (p.d > maxJump || usedChain.has(p.chain) || usedHit.has(p.hit))
+                continue;
+            usedChain.add(p.chain);
+            usedHit.add(p.hit);
+            const chain = open[p.chain];
+            chain.points.push(...point(axis, z, hits[p.hit]));
+            chain.last = hits[p.hit];
+            nextOpen.push(chain);
+        }
+        open.forEach((c, ci) => {
+            if (!usedChain.has(ci))
+                done.push(c.points);
+        });
+        hits.forEach((q, hi) => {
+            if (!usedHit.has(hi))
+                nextOpen.push({ points: point(axis, z, q), last: q });
+        });
+        open = nextOpen;
+    }
+    for (const c of open)
+        done.push(c.points);
+    return done.map((p) => Float64Array.from(p));
+}
+/** A line's crossing on slice `z` in section coordinates, at the slice's middle. */
+function point(axis, z, q) {
+    return axis === 'x' ? [z + 0.5, q] : [q, z + 0.5];
+}
+/** Where open `lines` cross the plane, along the in-plane axis. */
+function lineCrossings(lines, axis, at) {
+    const a = axis === 'x' ? 0 : 1;
+    const out = [];
+    for (const l of lines) {
+        for (let i = 2; i + 1 < l.length; i += 2) {
+            const p0 = l[i - 2 + a], p1 = l[i + a];
+            // Half-open, so a vertex on the plane counts once.
+            if (p0 > at !== p1 > at) {
+                const q0 = l[i - 1 - a], q1 = l[i + 1 - a];
+                out.push(q0 + ((at - p0) * (q1 - q0)) / (p1 - p0));
+            }
+        }
+    }
+    return out.sort((p, q) => p - q);
+}
+function flat(points) {
+    const out = new Float64Array(points.length * 2);
+    points.forEach(([u, v], i) => {
+        out[2 * i] = u;
+        out[2 * i + 1] = v;
+    });
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"section.js","sourceRoot":"","sources":["../../../../src/lib/geometry/section.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A section through a stack of slices' outlines: where a plane across the slices (x = const or\n * y = const) cuts each class's regions. A class's closed shapes cut into intervals on each slice\n * they cross (each feature even-odd, the features as their union); stacked one slice thick, the\n * intervals are traced into outlines. Its open lines\n * (a layer boundary on each B-scan, say) cut into one point per slice they cross, joined slice to\n * slice into the line the boundary draws across the stack (a slice without it breaks the line).\n *\n * Section coordinates `(u, v)`: through `x = at`, u is the slice (slice k spans [k, k + 1)) and\n * v the image y; through `y = at`, u is the image x and v the slice.\n *\n * Pure: usable from workers.\n */\nimport { maskToPolygons } from './contour';\nimport { SliceOutlines, featureRings } from './reconstruct';\n\n/** The plane: x = const (a section along y and the slices) or y = const (along x and the slices). */\nexport type SectionAxis = 'x' | 'y';\n\n/** A class's outlines in a section, as interleaved `u, v`. */\nexport interface ClassSection {\n  /** Closed outlines, holes included (even-odd). */\n  rings: Float64Array[];\n  /** Open lines; a line of one point is where the class crosses on one slice only. */\n  lines: Float64Array[];\n}\n\nexport interface SectionOptions {\n  /** Slices in the stack. */\n  depth: number;\n  /** Image px across the section's in-plane axis: the image height through x, its width through y. */\n  extent: number;\n  /** In-plane cell size of the closed shapes' cut, image px (default 1). */\n  step?: number;\n  /** Farthest a line moves between neighbouring slices and is still joined, image px (default extent / 10). */\n  maxJump?: number;\n}\n\n/** `[x0, y0, x1, y1]`, image px. */\ntype Box = [number, number, number, number];\n\n/** A ring or line with its extent. */\ninterface Indexed {\n  points: ArrayLike<number>;\n  box: Box;\n}\n\ninterface IndexedSlice {\n  z: number;\n  rings: Indexed[];\n  /** Each ring's feature (see SliceOutlines.ringGroups); absent: one feature. */\n  ringGroups?: ArrayLike<number>;\n  lines: Indexed[];\n}\n\n/**\n * Every class's outlines with each ring's and line's extent (and the class's): made once, it cuts\n * any number of sections visiting only the outlines a plane crosses.\n */\nexport interface SectionIndex {\n  readonly classes: ReadonlyMap<string, { box: Box; slices: readonly IndexedSlice[] }>;\n}\n\n/** Index every class's outlines for cutting (see {@link SectionIndex}). */\nexport function indexOutlines(byClass: ReadonlyMap<string, readonly SliceOutlines[]>): SectionIndex {\n  const classes = new Map<string, { box: Box; slices: IndexedSlice[] }>();\n  for (const [label, slices] of byClass) {\n    const box: Box = [Infinity, Infinity, -Infinity, -Infinity];\n    const indexed = slices.map((s) => ({\n      z: s.z,\n      rings: s.rings.map((points) => withBox(points, box)),\n      ...(s.ringGroups ? { ringGroups: s.ringGroups } : {}),\n      lines: (s.lines ?? []).map((points) => withBox(points, box)),\n    }));\n    if (box[0] <= box[2]) classes.set(label, { box, slices: indexed });\n  }\n  return { classes };\n}\n\nfunction withBox(points: ArrayLike<number>, total: Box): Indexed {\n  const box: Box = [Infinity, Infinity, -Infinity, -Infinity];\n  for (let i = 0; i + 1 < points.length; i += 2) {\n    if (points[i] < box[0]) box[0] = points[i];\n    if (points[i] > box[2]) box[2] = points[i];\n    if (points[i + 1] < box[1]) box[1] = points[i + 1];\n    if (points[i + 1] > box[3]) box[3] = points[i + 1];\n  }\n  total[0] = Math.min(total[0], box[0]);\n  total[1] = Math.min(total[1], box[1]);\n  total[2] = Math.max(total[2], box[2]);\n  total[3] = Math.max(total[3], box[3]);\n  return { points, box };\n}\n\n/** Whether a box spans the plane `axis = at`. */\nfunction spans(box: Box, axis: SectionAxis, at: number): boolean {\n  return axis === 'x' ? box[0] <= at && at <= box[2] : box[1] <= at && at <= box[3];\n}\n\n/**\n * Each class's cut by the plane `axis = at`; classes the plane misses are left out. Pass an\n * {@link indexOutlines} index to cut many sections of the same outlines.\n */\nexport function sectionOutlines(\n  outlines: SectionIndex | ReadonlyMap<string, readonly SliceOutlines[]>,\n  axis: SectionAxis,\n  at: number,\n  opts: SectionOptions,\n): Map<string, ClassSection> {\n  const index = outlines instanceof Map ? indexOutlines(outlines) : (outlines as SectionIndex);\n  const out = new Map<string, ClassSection>();\n  for (const [label, { box, slices }] of index.classes) {\n    if (!spans(box, axis, at)) continue;\n    const rings = cutShapes(slices, axis, at, opts);\n    const lines = cutLines(slices, axis, at, opts);\n    if (rings.length || lines.length) out.set(label, { rings, lines });\n  }\n  return out;\n}\n\n/** The closed shapes' cut: intervals per slice, rasterised one slice thick and traced. */\nfunction cutShapes(\n  slices: readonly IndexedSlice[],\n  axis: SectionAxis,\n  at: number,\n  opts: SectionOptions,\n): Float64Array[] {\n  const step = Math.max(opts.step ?? 1, 1e-6);\n  const depth = Math.max(1, Math.ceil(opts.depth));\n  const cells = Math.max(1, Math.ceil(opts.extent / step));\n  // Through x: columns are slices, rows in-plane cells. Through y: the other way round.\n  const w = axis === 'x' ? depth : cells;\n  const h = axis === 'x' ? cells : depth;\n  let mask: Uint8Array | null = null;\n  for (const s of slices) {\n    if (!s.rings.length || s.z < 0 || s.z >= depth) continue;\n    const crossed: ArrayLike<number>[] = [];\n    const groups: number[] = [];\n    s.rings.forEach((r, i) => {\n      if (!spans(r.box, axis, at)) return;\n      crossed.push(r.points);\n      groups.push(s.ringGroups?.[i] ?? 0);\n    });\n    if (!crossed.length) continue;\n    // Each feature's intervals, set into the mask: the features as their union.\n    for (const feature of featureRings(crossed, s.ringGroups ? groups : undefined)) {\n      const crossings = ringCrossings(feature, axis, at);\n      for (let c = 0; c + 1 < crossings.length; c += 2) {\n        // Cells whose centre lies in the interval (the pixel-centre rule).\n        const from = Math.max(0, Math.ceil(crossings[c] / step - 0.5));\n        const to = Math.min(cells - 1, Math.floor(crossings[c + 1] / step - 0.5));\n        if (to < from) continue;\n        mask ??= new Uint8Array(w * h);\n        for (let k = from; k <= to; k++) mask[axis === 'x' ? k * w + s.z : s.z * w + k] = 1;\n      }\n    }\n  }\n  if (!mask) return [];\n  const toSection = (cx: number, cy: number): [number, number] =>\n    axis === 'x' ? [cx, cy * step] : [cx * step, cy];\n  const rings: Float64Array[] = [];\n  for (const p of maskToPolygons(mask, w, h, 0, 0, 1, 1)) {\n    rings.push(flat(p.xpoints.map((x, i) => toSection(x, p.ypoints[i]))));\n    for (const hole of p.holes ?? []) rings.push(flat(hole.map(([x, y]) => toSection(x, y))));\n  }\n  return rings;\n}\n\n/** Where `rings` cross the plane, along the in-plane axis, sorted (even-odd: pairs are inside). */\nfunction ringCrossings(rings: readonly ArrayLike<number>[], axis: SectionAxis, at: number): number[] {\n  // Through x = at the crossings are y values; through y = at, x values.\n  const a = axis === 'x' ? 0 : 1;\n  const out: number[] = [];\n  for (const r of rings) {\n    const n = r.length >> 1;\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n      const pi = r[2 * i + a],\n        pj = r[2 * j + a];\n      if (pi > at !== pj > at) {\n        const qi = r[2 * i + 1 - a],\n          qj = r[2 * j + 1 - a];\n        out.push(qi + ((at - pi) * (qj - qi)) / (pj - pi));\n      }\n    }\n  }\n  return out.sort((p, q) => p - q);\n}\n\n/** The open lines' cut: a point per crossing, joined slice to slice (nearest first, each once). */\nfunction cutLines(\n  slices: readonly IndexedSlice[],\n  axis: SectionAxis,\n  at: number,\n  opts: SectionOptions,\n): Float64Array[] {\n  const maxJump = opts.maxJump ?? opts.extent / 10;\n  const stack = slices\n    .map((s) => ({\n      z: s.z,\n      hits: lineCrossings(\n        s.lines.filter((l) => spans(l.box, axis, at)).map((l) => l.points),\n        axis,\n        at,\n      ),\n    }))\n    .filter((s) => s.hits.length)\n    .sort((p, q) => p.z - q.z);\n  const done: number[][] = [];\n  let open: Array<{ points: number[]; last: number }> = [];\n  let prevZ = -Infinity;\n  for (const { z, hits } of stack) {\n    // A slice without the line between: the chains end there, not bridged across it.\n    if (z !== prevZ + 1) {\n      for (const c of open) done.push(c.points);\n      open = [];\n    }\n    prevZ = z;\n    const pairs: Array<{ chain: number; hit: number; d: number }> = [];\n    open.forEach((c, ci) => hits.forEach((q, hi) => pairs.push({ chain: ci, hit: hi, d: Math.abs(q - c.last) })));\n    pairs.sort((p, q) => p.d - q.d);\n    const nextOpen: typeof open = [];\n    const usedChain = new Set<number>();\n    const usedHit = new Set<number>();\n    for (const p of pairs) {\n      if (p.d > maxJump || usedChain.has(p.chain) || usedHit.has(p.hit)) continue;\n      usedChain.add(p.chain);\n      usedHit.add(p.hit);\n      const chain = open[p.chain];\n      chain.points.push(...point(axis, z, hits[p.hit]));\n      chain.last = hits[p.hit];\n      nextOpen.push(chain);\n    }\n    open.forEach((c, ci) => {\n      if (!usedChain.has(ci)) done.push(c.points);\n    });\n    hits.forEach((q, hi) => {\n      if (!usedHit.has(hi)) nextOpen.push({ points: point(axis, z, q), last: q });\n    });\n    open = nextOpen;\n  }\n  for (const c of open) done.push(c.points);\n  return done.map((p) => Float64Array.from(p));\n}\n\n/** A line's crossing on slice `z` in section coordinates, at the slice's middle. */\nfunction point(axis: SectionAxis, z: number, q: number): [number, number] {\n  return axis === 'x' ? [z + 0.5, q] : [q, z + 0.5];\n}\n\n/** Where open `lines` cross the plane, along the in-plane axis. */\nfunction lineCrossings(lines: readonly ArrayLike<number>[], axis: SectionAxis, at: number): number[] {\n  const a = axis === 'x' ? 0 : 1;\n  const out: number[] = [];\n  for (const l of lines) {\n    for (let i = 2; i + 1 < l.length; i += 2) {\n      const p0 = l[i - 2 + a],\n        p1 = l[i + a];\n      // Half-open, so a vertex on the plane counts once.\n      if (p0 > at !== p1 > at) {\n        const q0 = l[i - 1 - a],\n          q1 = l[i + 1 - a];\n        out.push(q0 + ((at - p0) * (q1 - q0)) / (p1 - p0));\n      }\n    }\n  }\n  return out.sort((p, q) => p - q);\n}\n\nfunction flat(points: ReadonlyArray<readonly [number, number]>): Float64Array {\n  const out = new Float64Array(points.length * 2);\n  points.forEach(([u, v], i) => {\n    out[2 * i] = u;\n    out[2 * i + 1] = v;\n  });\n  return out;\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-loading-badge.mjs

@@ -1,6 +1,7 @@
 /**
  * "Transcripts reloading…" at the bottom of the canvas while a layer's data is in flight: one
  * line naming every layer still loading, on a semi-opaque backing so it reads over any tissue.
+ * Longer work names itself ("Building HPF in 3D…") and joins the line.
  *
  * Shown only once something has been loading for {@link SHOW_AFTER_MS}, so a redraw served from
  * cache does not flash it.
@@ -9,6 +10,7 @@ export const SHOW_AFTER_MS = 150;
 export class NapariLoadingBadge {
     constructor(host) {
         this.names = [];
+        this.tasks = [];
         this.timer = null;
         if (getComputedStyle(host).position === 'static')
             host.style.position = 'relative';
@@ -33,28 +35,30 @@ export class NapariLoadingBadge {
         });
         host.appendChild(this.el);
     }
-    /** The layers loading now; empty hides the badge. */
-    set(names) {
+    /** The layers loading now, and the tasks running (their messages); both empty hides the badge. */
+    set(names, tasks = []) {
         this.names = [...new Set(names)];
-        if (!this.names.length) {
+        this.tasks = [...new Set(tasks)];
+        if (!this.names.length && !this.tasks.length) {
             if (this.timer)
                 clearTimeout(this.timer);
             this.timer = null;
             this.el.style.display = 'none';
             return;
         }
-        this.el.textContent = `${listOf(this.names)} reloading…`;
+        const parts = this.names.length ? [`${listOf(this.names)} reloading…`, ...this.tasks] : this.tasks;
+        this.el.textContent = parts.join(' · ');
         if (this.el.style.display === 'block' || this.timer)
             return;
         this.timer = setTimeout(() => {
             this.timer = null;
-            if (this.names.length)
+            if (this.names.length || this.tasks.length)
                 this.el.style.display = 'block';
         }, SHOW_AFTER_MS);
     }
     /** The text currently set (shown or about to be). */
     get text() {
-        return this.names.length ? (this.el.textContent ?? '') : '';
+        return this.names.length || this.tasks.length ? (this.el.textContent ?? '') : '';
     }
     destroy() {
         if (this.timer)
@@ -69,4 +73,4 @@ function listOf(names) {
     const all = [first, ...lower];
     return all.length === 1 ? all[0] : `${all.slice(0, -1).join(', ')} and ${all[all.length - 1]}`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/napari-loading-state.mjs

@@ -8,6 +8,9 @@ import { NapariLoadingBadge } from './napari-loading-badge';
  * the counts are dropped, and an `end` from a load that began before it is a no-op, so a load
  * that settles after a re-plot can neither un-count the new scene's work nor drive a count below
  * zero (which hid the next scene's "Observations reloading…" until a second load overlapped it).
+ *
+ * A {@link beginTask} is work that outlives a scene (a region's 3D reconstruction, built for
+ * whichever volume is on screen when it is done): its message stays across a reset.
  */
 export class LoadingBadgeState {
     constructor() {
@@ -16,10 +19,13 @@ export class LoadingBadgeState {
         this.counts = new Map();
         this.tileLayers = [];
         this.generation = 0;
+        this.tasks = new Map();
     }
     /** The element the badge is drawn into (the plot host); set per plot. */
     attach(host) {
         this.host = host;
+        if (this.tasks.size)
+            this.show();
     }
     /** One load of `source` started; call the returned function once it settles. */
     begin(source) {
@@ -35,6 +41,17 @@ export class LoadingBadgeState {
             this.show();
         };
     }
+    /** A task started, shown by its `message` ("Building HPF in 3D…"); call the returned function
+     *  once it settles. */
+    beginTask(message) {
+        const id = Symbol(message);
+        this.tasks.set(id, message);
+        this.show();
+        return () => {
+            if (this.tasks.delete(id))
+                this.show();
+        };
+    }
     /** The spatial tile layers still loading (their own names, in their order). */
     setTileLayers(layers) {
         this.tileLayers = layers;
@@ -44,7 +61,7 @@ export class LoadingBadgeState {
     get text() {
         return this.badge?.text ?? '';
     }
-    /** A new scene: forget every count and remove the badge. */
+    /** A new scene: forget every count and remove the badge (tasks show again on the next attach). */
     reset() {
         this.generation++;
         this.counts.clear();
@@ -60,7 +77,7 @@ export class LoadingBadgeState {
             ...((this.counts.get('Image') ?? 0) > 0 ? ['Image'] : []),
             ...((this.counts.get('Observations') ?? 0) > 0 ? ['Observations'] : []),
             ...this.tileLayers,
-        ]);
+        ], [...this.tasks.values()]);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/napari-region-mesh-pointer.mjs

@@ -0,0 +1,100 @@
+/** A press that moves farther than this (px) is an orbit drag, not a click. */
+const CLICK_SLOP_PX = 5;
+/** Hover picking waits for the pointer to rest this long (ms): a ray cast per move is wasted. */
+const HOVER_DELAY_MS = 60;
+/**
+ * Clicks and hover on the region surfaces of a volume view: a click (a press that does not orbit)
+ * picks the surface under it, or none; resting over a surface shows its name in a tooltip (and a
+ * pointer cursor when a click would pick it). Listens on the canvas without stopping events, so the
+ * camera still orbits.
+ */
+export class RegionMeshPointer {
+    constructor(canvas, host, opts) {
+        this.canvas = canvas;
+        this.opts = opts;
+        this.down = null;
+        this.hoverTimer = null;
+        this.onDown = (e) => {
+            this.down = e.button === 0 ? { x: e.clientX, y: e.clientY } : null;
+        };
+        this.onUp = (e) => {
+            const down = this.down;
+            this.down = null;
+            if (!down || e.button !== 0 || !this.opts.active())
+                return;
+            if (Math.hypot(e.clientX - down.x, e.clientY - down.y) > CLICK_SLOP_PX)
+                return;
+            const [x, y] = this.local(e);
+            const hit = this.opts.pickAt(x, y);
+            this.opts.onPick(hit?.key ?? null, e.shiftKey || e.ctrlKey || e.metaKey);
+        };
+        this.onMove = (e) => {
+            if (this.hoverTimer)
+                clearTimeout(this.hoverTimer);
+            this.hoverTimer = null;
+            // Dragging orbits the camera: no hover while a button is down.
+            if (e.buttons || !this.opts.hoverable()) {
+                this.hide();
+                return;
+            }
+            const [x, y] = this.local(e);
+            this.hoverTimer = setTimeout(() => {
+                this.hoverTimer = null;
+                const hit = this.opts.pickAt(x, y);
+                if (!hit) {
+                    this.hide();
+                    return;
+                }
+                this.canvas.style.cursor = this.opts.active() ? 'pointer' : '';
+                this.tip.textContent = hit.label ?? hit.key;
+                this.tip.style.left = `${x + 14}px`;
+                this.tip.style.top = `${y + 14}px`;
+                this.tip.style.display = 'block';
+            }, HOVER_DELAY_MS);
+        };
+        this.onLeave = () => {
+            if (this.hoverTimer)
+                clearTimeout(this.hoverTimer);
+            this.hoverTimer = null;
+            this.hide();
+        };
+        if (getComputedStyle(host).position === 'static')
+            host.style.position = 'relative';
+        this.tip = document.createElement('div');
+        this.tip.className = 'napari-region-mesh-tip';
+        Object.assign(this.tip.style, {
+            position: 'absolute',
+            padding: '2px 8px',
+            borderRadius: '4px',
+            background: 'rgba(0, 0, 0, 0.75)',
+            color: '#fff',
+            font: '12px/1.4 system-ui, sans-serif',
+            whiteSpace: 'nowrap',
+            pointerEvents: 'none',
+            zIndex: '6',
+            display: 'none',
+        });
+        host.appendChild(this.tip);
+        canvas.addEventListener('pointerdown', this.onDown);
+        canvas.addEventListener('pointerup', this.onUp);
+        canvas.addEventListener('pointermove', this.onMove);
+        canvas.addEventListener('pointerleave', this.onLeave);
+    }
+    destroy() {
+        this.canvas.removeEventListener('pointerdown', this.onDown);
+        this.canvas.removeEventListener('pointerup', this.onUp);
+        this.canvas.removeEventListener('pointermove', this.onMove);
+        this.canvas.removeEventListener('pointerleave', this.onLeave);
+        this.onLeave();
+        this.tip.remove();
+    }
+    local(e) {
+        const r = this.canvas.getBoundingClientRect();
+        return [e.clientX - r.left, e.clientY - r.top];
+    }
+    hide() {
+        this.tip.style.display = 'none';
+        this.canvas.style.cursor = '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-region-mesh-pointer.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-region-mesh-pointer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RegionMesh3D } from './napari-volume-region-meshes';\n\nexport interface RegionMeshPointerOptions {\n  /** The surface under canvas point (`x`, `y`) (CSS px), or null. */\n  pickAt(x: number, y: number): RegionMesh3D | null;\n  /** Whether a click picks (the selection tool armed, surfaces shown); otherwise clicks are left alone. */\n  active(): boolean;\n  /** Whether hovering names the surface under the pointer (surfaces shown, whatever the tool). */\n  hoverable(): boolean;\n  /** A click on a surface (its key), or on none (null); `additive` with Shift / Ctrl / ⌘. */\n  onPick(key: string | null, additive: boolean): void;\n}\n\n/** A press that moves farther than this (px) is an orbit drag, not a click. */\nconst CLICK_SLOP_PX = 5;\n/** Hover picking waits for the pointer to rest this long (ms): a ray cast per move is wasted. */\nconst HOVER_DELAY_MS = 60;\n\n/**\n * Clicks and hover on the region surfaces of a volume view: a click (a press that does not orbit)\n * picks the surface under it, or none; resting over a surface shows its name in a tooltip (and a\n * pointer cursor when a click would pick it). Listens on the canvas without stopping events, so the\n * camera still orbits.\n */\nexport class RegionMeshPointer {\n  private readonly tip: HTMLDivElement;\n  private down: { x: number; y: number } | null = null;\n  private hoverTimer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor(\n    private readonly canvas: HTMLElement,\n    host: HTMLElement,\n    private readonly opts: RegionMeshPointerOptions,\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n    this.tip = document.createElement('div');\n    this.tip.className = 'napari-region-mesh-tip';\n    Object.assign(this.tip.style, {\n      position: 'absolute',\n      padding: '2px 8px',\n      borderRadius: '4px',\n      background: 'rgba(0, 0, 0, 0.75)',\n      color: '#fff',\n      font: '12px/1.4 system-ui, sans-serif',\n      whiteSpace: 'nowrap',\n      pointerEvents: 'none',\n      zIndex: '6',\n      display: 'none',\n    } satisfies Partial<CSSStyleDeclaration>);\n    host.appendChild(this.tip);\n    canvas.addEventListener('pointerdown', this.onDown);\n    canvas.addEventListener('pointerup', this.onUp);\n    canvas.addEventListener('pointermove', this.onMove);\n    canvas.addEventListener('pointerleave', this.onLeave);\n  }\n\n  destroy(): void {\n    this.canvas.removeEventListener('pointerdown', this.onDown);\n    this.canvas.removeEventListener('pointerup', this.onUp);\n    this.canvas.removeEventListener('pointermove', this.onMove);\n    this.canvas.removeEventListener('pointerleave', this.onLeave);\n    this.onLeave();\n    this.tip.remove();\n  }\n\n  private local(e: PointerEvent): [number, number] {\n    const r = this.canvas.getBoundingClientRect();\n    return [e.clientX - r.left, e.clientY - r.top];\n  }\n\n  private readonly onDown = (e: PointerEvent): void => {\n    this.down = e.button === 0 ? { x: e.clientX, y: e.clientY } : null;\n  };\n\n  private readonly onUp = (e: PointerEvent): void => {\n    const down = this.down;\n    this.down = null;\n    if (!down || e.button !== 0 || !this.opts.active()) return;\n    if (Math.hypot(e.clientX - down.x, e.clientY - down.y) > CLICK_SLOP_PX) return;\n    const [x, y] = this.local(e);\n    const hit = this.opts.pickAt(x, y);\n    this.opts.onPick(hit?.key ?? null, e.shiftKey || e.ctrlKey || e.metaKey);\n  };\n\n  private readonly onMove = (e: PointerEvent): void => {\n    if (this.hoverTimer) clearTimeout(this.hoverTimer);\n    this.hoverTimer = null;\n    // Dragging orbits the camera: no hover while a button is down.\n    if (e.buttons || !this.opts.hoverable()) {\n      this.hide();\n      return;\n    }\n    const [x, y] = this.local(e);\n    this.hoverTimer = setTimeout(() => {\n      this.hoverTimer = null;\n      const hit = this.opts.pickAt(x, y);\n      if (!hit) {\n        this.hide();\n        return;\n      }\n      this.canvas.style.cursor = this.opts.active() ? 'pointer' : '';\n      this.tip.textContent = hit.label ?? hit.key;\n      this.tip.style.left = `${x + 14}px`;\n      this.tip.style.top = `${y + 14}px`;\n      this.tip.style.display = 'block';\n    }, HOVER_DELAY_MS);\n  };\n\n  private readonly onLeave = (): void => {\n    if (this.hoverTimer) clearTimeout(this.hoverTimer);\n    this.hoverTimer = null;\n    this.hide();\n  };\n\n  private hide(): void {\n    this.tip.style.display = 'none';\n    this.canvas.style.cursor = '';\n  }\n}\n"]}