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

package/esm2022/lib/visualizer/volume-sections.mjs

@@ -0,0 +1,175 @@
+import { BehaviorSubject } from 'rxjs';
+import { resliceImage } from '../geometry/reslice-image';
+import { indexOutlines, sectionOutlines } from '../geometry/section';
+import { toNapariGamma } from '../implementations/napari-js/napari-helpers';
+const NONE = { x: null, y: null };
+/** How long the regions must rest after an edit before the sections cut them again (ms). */
+const REGIONS_SETTLE_MS = 150;
+/**
+ * The sections beside a split volume view: the planes x = const and y = const (image px), each cut
+ * from the assembled volume as an image, displayed like the 2D view displays a slice (the channel
+ * windows, tints and invert), with every class's outlines cut by the same plane and the other two
+ * planes as a crosshair. Recut when a plane moves, the slice changes, the regions or their
+ * visibility change, the display changes or the volume is assembled again — once per frame at most.
+ */
+export class VolumeSections {
+    constructor(deps) {
+        this.deps = deps;
+        this.views$ = new BehaviorSubject(NONE);
+        this.open = false;
+        this.planes = { x: null, y: null };
+        /** Every class's outlines at a level, read and indexed once until the regions change. */
+        this.outlines = null;
+        this.scheduled = null;
+        /** Bumped per cut, so a cut that waited on the outlines is dropped when a newer one starts. */
+        this.request = 0;
+    }
+    /** Both sections as they are cut; nulls while closed. */
+    getViews$() {
+        return this.views$.asObservable();
+    }
+    /** Show the sections (their planes through the middle of the image at first). */
+    start() {
+        this.open = true;
+        this.schedule();
+    }
+    stop() {
+        this.open = false;
+        this.request++;
+        // Regions may change while closed with nothing told: read them again on the next start.
+        this.outlines = null;
+        if (this.scheduled)
+            clearTimeout(this.scheduled);
+        this.scheduled = null;
+        this.deps.showPlanes({ x: null, y: null, z: null });
+        this.views$.next(NONE);
+    }
+    /** Move a section's plane to `at` (image px; clamped into the image). */
+    setPlane(axis, at) {
+        const size = this.deps.volume()?.frame.size;
+        const max = size ? size[axis === 'x' ? 0 : 1] - 1 : Infinity;
+        this.planes[axis] = Math.min(max, Math.max(0, at));
+        this.schedule();
+    }
+    /** The planes as they are (image px), the z plane being the slice. */
+    getPlanes() {
+        return { ...this.planes, z: this.open ? this.deps.slice() : null };
+    }
+    /** The regions changed (an edit): their outlines are read again, once the edits pause. */
+    regionsChanged() {
+        this.outlines = null;
+        if (!this.open)
+            return;
+        if (this.scheduled)
+            clearTimeout(this.scheduled);
+        this.scheduled = setTimeout(() => {
+            this.scheduled = null;
+            void this.cut();
+        }, REGIONS_SETTLE_MS);
+    }
+    /** Something the sections show changed (the slice, the display, the visible classes, the volume). */
+    schedule() {
+        if (!this.open || this.scheduled)
+            return;
+        this.scheduled = setTimeout(() => {
+            this.scheduled = null;
+            void this.cut();
+        });
+    }
+    async cut() {
+        const request = ++this.request;
+        const vol = this.deps.volume();
+        if (!this.open || !vol) {
+            this.views$.next(NONE);
+            return;
+        }
+        const image = this.deps.image();
+        if (image !== this.image) {
+            this.image = image;
+            this.outlines = null;
+            this.planes = { x: null, y: null };
+        }
+        const [w, h] = vol.frame.size;
+        this.planes.x = Math.min(w - 1, Math.max(0, this.planes.x ?? Math.floor(w / 2)));
+        this.planes.y = Math.min(h - 1, Math.max(0, this.planes.y ?? Math.floor(h / 2)));
+        this.deps.showPlanes(this.getPlanes());
+        // The outlines at the volume's resolution (image px per voxel).
+        const step = w / Math.max(1, vol.width);
+        const level = Math.max(0, Math.floor(Math.log2(Math.max(1, step))));
+        if (!this.outlines || this.outlines.level !== level) {
+            this.outlines = { level, read: this.deps.outlinesByClass(level).then(indexOutlines) };
+        }
+        const outlines = this.outlines;
+        let index;
+        try {
+            index = await outlines.read;
+        }
+        catch (err) {
+            // Not kept: the next cut reads them again.
+            if (this.outlines === outlines)
+                this.outlines = null;
+            console.warn('[visualizer] The regions could not be cut for the sections.', err);
+            index = indexOutlines(new Map());
+        }
+        if (request !== this.request || !this.open)
+            return;
+        const shown = {
+            classes: new Map([...index.classes].filter(([label]) => !this.deps.isClassHidden(label))),
+        };
+        const voxels = this.voxels(vol);
+        this.views$.next({
+            x: this.view('x', vol, voxels, shown, step),
+            y: this.view('y', vol, voxels, shown, step),
+        });
+    }
+    view(axis, vol, voxels, index, step) {
+        const [w, h, d] = vol.frame.size;
+        const [ww, wh, wd] = vol.frame.world;
+        const at = this.planes[axis];
+        const voxel = axis === 'x' ? (at / w) * vol.width : (at / h) * vol.height;
+        const cut = sectionOutlines(index, axis, at, { depth: d, extent: axis === 'x' ? h : w, step });
+        const regions = Array.from(cut, ([label, c]) => ({
+            label,
+            color: this.deps.colorOf(label),
+            ...c,
+        }));
+        const z = this.deps.slice() + 0.5;
+        return {
+            axis,
+            at,
+            image: resliceImage(voxels, axis, Math.floor(voxel)),
+            size: axis === 'x' ? [d, h] : [w, d],
+            scale: axis === 'x' ? [wd / d, wh / h] : [ww / w, wd / d],
+            regions,
+            crosshair: axis === 'x' ? { u: z, v: this.planes.y } : { u: this.planes.x, v: z },
+        };
+    }
+    /** The volume's channels as displayed now. */
+    voxels(vol) {
+        const states = this.deps.channelStates();
+        const channels = vol.multichannel
+            ? Array.from(vol.channels, ([c, data]) => {
+                const st = states.find((s) => s.index === c);
+                return {
+                    data,
+                    colormap: this.deps.colormap(st, true),
+                    min: st?.min ?? 0,
+                    max: st?.max ?? 255,
+                    gamma: toNapariGamma(st?.gamma),
+                    visible: st?.visible ?? true,
+                };
+            })
+            : [
+                {
+                    data: vol.channels.get(0),
+                    colormap: this.deps.colormap(states[0], false),
+                    min: states[0]?.min ?? 0,
+                    max: states[0]?.max ?? 255,
+                    gamma: toNapariGamma(states[0]?.gamma),
+                    visible: true,
+                },
+            ];
+        return { width: vol.width, height: vol.height, depth: vol.depth, channels, invert: this.deps.invert() };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"volume-sections.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/volume-sections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAc,MAAM,MAAM,CAAC;AAOnD,OAAO,EAAgB,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAgB,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAwB5E,MAAM,IAAI,GAAiB,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC;AAChD,4FAA4F;AAC5F,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IAYzB,YAA6B,IAAwB;QAAxB,SAAI,GAAJ,IAAI,CAAoB;QAXpC,WAAM,GAAG,IAAI,eAAe,CAAe,IAAI,CAAC,CAAC;QAC1D,SAAI,GAAG,KAAK,CAAC;QACb,WAAM,GAA2C,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC;QAG9E,yFAAyF;QACjF,aAAQ,GAA0D,IAAI,CAAC;QACvE,cAAS,GAAyC,IAAI,CAAC;QAC/D,+FAA+F;QACvF,YAAO,GAAG,CAAC,CAAC;IAEoC,CAAC;IAEzD,yDAAyD;IACzD,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IACpC,CAAC;IAED,iFAAiF;IACjF,KAAK;QACH,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,IAAI;QACF,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,wFAAwF;QACxF,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,IAAI,CAAC,SAAS;YAAE,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACjD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAED,yEAAyE;IACzE,QAAQ,CAAC,IAAiB,EAAE,EAAU;QACpC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC;QAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC7D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,sEAAsE;IACtE,SAAS;QACP,OAAO,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACrE,CAAC;IAED,0FAA0F;IAC1F,cAAc;QACZ,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QACvB,IAAI,IAAI,CAAC,SAAS;YAAE,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACjD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;QAClB,CAAC,EAAE,iBAAiB,CAAC,CAAC;IACxB,CAAC;IAED,qGAAqG;IACrG,QAAQ;QACN,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QACzC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,GAAG;QACf,MAAM,OAAO,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC;QAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvB,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;QAC9B,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACjF,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACjF,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QACvC,gEAAgE;QAChE,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACpE,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YACpD,IAAI,CAAC,QAAQ,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;QACxF,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC/B,IAAI,KAAmB,CAAC;QACxB,IAAI,CAAC;YACH,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC;QAC9B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,2CAA2C;YAC3C,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ;gBAAE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrD,OAAO,CAAC,IAAI,CAAC,6DAA6D,EAAE,GAAG,CAAC,CAAC;YACjF,KAAK,GAAG,aAAa,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,OAAO,KAAK,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QACnD,MAAM,KAAK,GAAiB;YAC1B,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;SAC1F,CAAC;QACF,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACf,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;YAC3C,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;SAC5C,CAAC,CAAC;IACL,CAAC;IAEO,IAAI,CACV,IAAiB,EACjB,GAAyB,EACzB,MAAoB,EACpB,KAAmB,EACnB,IAAY;QAEZ,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;QACjC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC;QACrC,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAW,CAAC;QACvC,MAAM,KAAK,GAAG,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;QAC1E,MAAM,GAAG,GAAG,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/F,MAAM,OAAO,GAAqB,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACjE,KAAK;YACL,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YAC/B,GAAG,CAAC;SACL,CAAC,CAAC,CAAC;QACJ,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,GAAG,CAAC;QAClC,OAAO;YACL,IAAI;YACJ,EAAE;YACF,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACpD,IAAI,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACpC,KAAK,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;YACzD,OAAO;YACP,SAAS,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;SAClF,CAAC;IACJ,CAAC;IAED,8CAA8C;IACtC,MAAM,CAAC,GAAyB;QACtC,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;QACzC,MAAM,QAAQ,GAAG,GAAG,CAAC,YAAY;YAC/B,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE;gBACrC,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;gBAC7C,OAAO;oBACL,IAAI;oBACJ,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;oBACtC,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;oBACjB,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI,GAAG;oBACnB,KAAK,EAAE,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC;oBAC/B,OAAO,EAAE,EAAE,EAAE,OAAO,IAAI,IAAI;iBAC7B,CAAC;YACJ,CAAC,CAAC;YACJ,CAAC,CAAC;gBACE;oBACE,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAe;oBACvC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;oBAC9C,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC;oBACxB,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,GAAG;oBAC1B,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;oBACtC,OAAO,EAAE,IAAI;iBACd;aACF,CAAC;QACN,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;IAC1G,CAAC;CACF","sourcesContent":["import { BehaviorSubject, Observable } from 'rxjs';\n\nimport type { IChannelState } from '../contracts/channel-histogram-api.contract';\nimport type { Colormap } from 'napari-js';\n\nimport type { SectionAxis, SectionRegions, SectionView, SectionViews } from '../contracts/section-view.contract';\nimport type { SliceOutlines } from '../geometry/reconstruct';\nimport { VolumeVoxels, resliceImage } from '../geometry/reslice-image';\nimport { SectionIndex, indexOutlines, sectionOutlines } from '../geometry/section';\nimport { toNapariGamma } from '../implementations/napari-js/napari-helpers';\nimport type { VolumeVoxelsOnScreen } from '../implementations/napari-js/napari-scene';\nimport type { SlicePlanes } from '../implementations/napari-js/napari-volume-slice-planes';\n\n/** What the sections are cut from and shown with. */\nexport interface VolumeSectionsDeps {\n  /** The volume on screen as assembled, or null (not a volume view, or not assembled yet). */\n  volume(): VolumeVoxelsOnScreen | null;\n  /** The image the volume is of: another one drops the outlines read and puts the planes back. */\n  image(): string | undefined;\n  /** Show the planes in the volume (null: hide one). */\n  showPlanes(planes: SlicePlanes): void;\n  /** Every class's outlines on every slice (see RegionStore.outlinesByClass). */\n  outlinesByClass(level: number): Promise<Map<string, SliceOutlines[]>>;\n  isClassHidden(label: string): boolean;\n  colorOf(label: string): string;\n  channelStates(): IChannelState[];\n  /** The colormap the 3D view draws a channel with: its tint in a multichannel volume, else the volume's. */\n  colormap(channel: IChannelState | undefined, multichannel: boolean): Colormap;\n  invert(): boolean;\n  /** The slice shown and edited. */\n  slice(): number;\n}\n\nconst NONE: SectionViews = { x: null, y: null };\n/** How long the regions must rest after an edit before the sections cut them again (ms). */\nconst REGIONS_SETTLE_MS = 150;\n\n/**\n * The sections beside a split volume view: the planes x = const and y = const (image px), each cut\n * from the assembled volume as an image, displayed like the 2D view displays a slice (the channel\n * windows, tints and invert), with every class's outlines cut by the same plane and the other two\n * planes as a crosshair. Recut when a plane moves, the slice changes, the regions or their\n * visibility change, the display changes or the volume is assembled again — once per frame at most.\n */\nexport class VolumeSections {\n  private readonly views$ = new BehaviorSubject<SectionViews>(NONE);\n  private open = false;\n  private planes: { x: number | null; y: number | null } = { x: null, y: null };\n  /** The image the planes and outlines are of. */\n  private image: string | undefined;\n  /** Every class's outlines at a level, read and indexed once until the regions change. */\n  private outlines: { level: number; read: Promise<SectionIndex> } | null = null;\n  private scheduled: ReturnType<typeof setTimeout> | null = null;\n  /** Bumped per cut, so a cut that waited on the outlines is dropped when a newer one starts. */\n  private request = 0;\n\n  constructor(private readonly deps: VolumeSectionsDeps) {}\n\n  /** Both sections as they are cut; nulls while closed. */\n  getViews$(): Observable<SectionViews> {\n    return this.views$.asObservable();\n  }\n\n  /** Show the sections (their planes through the middle of the image at first). */\n  start(): void {\n    this.open = true;\n    this.schedule();\n  }\n\n  stop(): void {\n    this.open = false;\n    this.request++;\n    // Regions may change while closed with nothing told: read them again on the next start.\n    this.outlines = null;\n    if (this.scheduled) clearTimeout(this.scheduled);\n    this.scheduled = null;\n    this.deps.showPlanes({ x: null, y: null, z: null });\n    this.views$.next(NONE);\n  }\n\n  /** Move a section's plane to `at` (image px; clamped into the image). */\n  setPlane(axis: SectionAxis, at: number): void {\n    const size = this.deps.volume()?.frame.size;\n    const max = size ? size[axis === 'x' ? 0 : 1] - 1 : Infinity;\n    this.planes[axis] = Math.min(max, Math.max(0, at));\n    this.schedule();\n  }\n\n  /** The planes as they are (image px), the z plane being the slice. */\n  getPlanes(): SlicePlanes {\n    return { ...this.planes, z: this.open ? this.deps.slice() : null };\n  }\n\n  /** The regions changed (an edit): their outlines are read again, once the edits pause. */\n  regionsChanged(): void {\n    this.outlines = null;\n    if (!this.open) return;\n    if (this.scheduled) clearTimeout(this.scheduled);\n    this.scheduled = setTimeout(() => {\n      this.scheduled = null;\n      void this.cut();\n    }, REGIONS_SETTLE_MS);\n  }\n\n  /** Something the sections show changed (the slice, the display, the visible classes, the volume). */\n  schedule(): void {\n    if (!this.open || this.scheduled) return;\n    this.scheduled = setTimeout(() => {\n      this.scheduled = null;\n      void this.cut();\n    });\n  }\n\n  private async cut(): Promise<void> {\n    const request = ++this.request;\n    const vol = this.deps.volume();\n    if (!this.open || !vol) {\n      this.views$.next(NONE);\n      return;\n    }\n    const image = this.deps.image();\n    if (image !== this.image) {\n      this.image = image;\n      this.outlines = null;\n      this.planes = { x: null, y: null };\n    }\n    const [w, h] = vol.frame.size;\n    this.planes.x = Math.min(w - 1, Math.max(0, this.planes.x ?? Math.floor(w / 2)));\n    this.planes.y = Math.min(h - 1, Math.max(0, this.planes.y ?? Math.floor(h / 2)));\n    this.deps.showPlanes(this.getPlanes());\n    // The outlines at the volume's resolution (image px per voxel).\n    const step = w / Math.max(1, vol.width);\n    const level = Math.max(0, Math.floor(Math.log2(Math.max(1, step))));\n    if (!this.outlines || this.outlines.level !== level) {\n      this.outlines = { level, read: this.deps.outlinesByClass(level).then(indexOutlines) };\n    }\n    const outlines = this.outlines;\n    let index: SectionIndex;\n    try {\n      index = await outlines.read;\n    } catch (err) {\n      // Not kept: the next cut reads them again.\n      if (this.outlines === outlines) this.outlines = null;\n      console.warn('[visualizer] The regions could not be cut for the sections.', err);\n      index = indexOutlines(new Map());\n    }\n    if (request !== this.request || !this.open) return;\n    const shown: SectionIndex = {\n      classes: new Map([...index.classes].filter(([label]) => !this.deps.isClassHidden(label))),\n    };\n    const voxels = this.voxels(vol);\n    this.views$.next({\n      x: this.view('x', vol, voxels, shown, step),\n      y: this.view('y', vol, voxels, shown, step),\n    });\n  }\n\n  private view(\n    axis: SectionAxis,\n    vol: VolumeVoxelsOnScreen,\n    voxels: VolumeVoxels,\n    index: SectionIndex,\n    step: number,\n  ): SectionView {\n    const [w, h, d] = vol.frame.size;\n    const [ww, wh, wd] = vol.frame.world;\n    const at = this.planes[axis] as number;\n    const voxel = axis === 'x' ? (at / w) * vol.width : (at / h) * vol.height;\n    const cut = sectionOutlines(index, axis, at, { depth: d, extent: axis === 'x' ? h : w, step });\n    const regions: SectionRegions[] = Array.from(cut, ([label, c]) => ({\n      label,\n      color: this.deps.colorOf(label),\n      ...c,\n    }));\n    const z = this.deps.slice() + 0.5;\n    return {\n      axis,\n      at,\n      image: resliceImage(voxels, axis, Math.floor(voxel)),\n      size: axis === 'x' ? [d, h] : [w, d],\n      scale: axis === 'x' ? [wd / d, wh / h] : [ww / w, wd / d],\n      regions,\n      crosshair: axis === 'x' ? { u: z, v: this.planes.y } : { u: this.planes.x, v: z },\n    };\n  }\n\n  /** The volume's channels as displayed now. */\n  private voxels(vol: VolumeVoxelsOnScreen): VolumeVoxels {\n    const states = this.deps.channelStates();\n    const channels = vol.multichannel\n      ? Array.from(vol.channels, ([c, data]) => {\n          const st = states.find((s) => s.index === c);\n          return {\n            data,\n            colormap: this.deps.colormap(st, true),\n            min: st?.min ?? 0,\n            max: st?.max ?? 255,\n            gamma: toNapariGamma(st?.gamma),\n            visible: st?.visible ?? true,\n          };\n        })\n      : [\n          {\n            data: vol.channels.get(0) as Uint8Array,\n            colormap: this.deps.colormap(states[0], false),\n            min: states[0]?.min ?? 0,\n            max: states[0]?.max ?? 255,\n            gamma: toNapariGamma(states[0]?.gamma),\n            visible: true,\n          },\n        ];\n    return { width: vol.width, height: vol.height, depth: vol.depth, channels, invert: this.deps.invert() };\n  }\n}\n"]}