@vitessce/spatial-accelerated 3.8.0

package/dist-tsc/VolumeDataManager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=VolumeDataManager.test.d.ts.map

package/dist-tsc/VolumeDataManager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VolumeDataManager.test.d.ts","sourceRoot":"","sources":["../src/VolumeDataManager.test.js"],"names":[],"mappings":""}

package/dist-tsc/VolumeDataManager.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import { _initMRMCPT, _resolutionStatsToBrickLayout, _packPT, _ptToZarr, _requestBufferToRequestObjects, } from './VolumeDataManager.js';
+describe('spatial-accelerated data utils', () => {
+    describe('initialization of page table and brick cache', () => {
+        it('Can compute brick layout per resolution', () => {
+            // TODO: also add test for calculation of brick layout from zarr metadata
+            const multiResolutionStats = [
+                {
+                    height: 3181,
+                    width: 4045,
+                    depth: 194,
+                },
+                {
+                    height: 1590,
+                    width: 2022,
+                    depth: 194,
+                },
+                {
+                    height: 795,
+                    width: 1011,
+                    depth: 194,
+                },
+                {
+                    height: 398,
+                    width: 506,
+                    depth: 194,
+                },
+                {
+                    height: 199,
+                    width: 253,
+                    depth: 194,
+                },
+                {
+                    height: 99,
+                    width: 126,
+                    depth: 97,
+                },
+                {
+                    height: 50,
+                    width: 63,
+                    depth: 48,
+                },
+                {
+                    height: 25,
+                    width: 32,
+                    depth: 24,
+                },
+            ];
+            const zarrStoreBrickLayout = [
+                [7, 100, 127],
+                [7, 50, 64],
+                [7, 25, 32],
+                [7, 13, 16],
+                [7, 7, 8],
+                [4, 4, 4],
+                [2, 2, 2],
+                [1, 1, 1],
+            ];
+            const result = _resolutionStatsToBrickLayout(multiResolutionStats);
+            expect(result).toEqual(zarrStoreBrickLayout);
+        });
+        it('Initializes page table based on data extent', () => {
+            const zarrStoreBrickLayout = [
+                [7, 100, 127],
+                [7, 50, 64],
+                [7, 25, 32],
+                [7, 13, 16],
+                [7, 7, 8],
+                [4, 4, 4],
+                [2, 2, 2],
+                [1, 1, 1],
+            ];
+            const channelsZarrMappingsLength = 7;
+            const { PT, ptTHREE, bcTHREE } = _initMRMCPT(zarrStoreBrickLayout, channelsZarrMappingsLength);
+            expect(PT).toEqual({
+                channelOffsets: [
+                    [0, 0, 1],
+                    [0, 1, 0],
+                    [0, 1, 1],
+                    [1, 0, 0],
+                    [1, 0, 1],
+                    [1, 1, 0],
+                    [1, 1, 1],
+                ],
+                anchors: [
+                    [0, 0, 36],
+                    [64, 53, 29],
+                    [32, 28, 22],
+                    [16, 15, 15],
+                    [8, 8, 8],
+                    [4, 4, 4],
+                    [2, 2, 2],
+                    [1, 1, 1],
+                ],
+                offsets: [],
+                xExtent: 128,
+                yExtent: 103,
+                zExtent: 36,
+                z0Extent: 7,
+                zTotal: 85,
+                lowestDataRes: 7,
+            });
+            expect(ptTHREE.isTexture).toEqual(true);
+            expect(ptTHREE.source.data.width).toEqual(128);
+            expect(ptTHREE.source.data.height).toEqual(103);
+            expect(ptTHREE.source.data.depth).toEqual(85);
+            expect(ptTHREE.source.data.data).toBeInstanceOf(Uint32Array);
+            expect(ptTHREE.source.data.data.length).toEqual(1120640);
+            expect(bcTHREE.isTexture).toEqual(true);
+            expect(bcTHREE.source.data.width).toEqual(2048);
+            expect(bcTHREE.source.data.height).toEqual(2048);
+            expect(bcTHREE.source.data.depth).toEqual(128);
+            expect(bcTHREE.source.data.data).toBeInstanceOf(Uint8Array);
+            expect(bcTHREE.source.data.data.length).toEqual(536870912);
+        });
+    });
+    describe('_packPT packs page table properties for a brick', () => {
+        it('correctly packs the properties', () => {
+            expect(_packPT(0, 80, 1, 0, 0)).toEqual(3223847936);
+            expect(_packPT(0, 56, 2, 0, 0)).toEqual(3223062528);
+            expect(_packPT(0, 0, 27, 0, 0)).toEqual(3221253120);
+            expect(_packPT(0, 111, 61, 0, 0)).toEqual(3224892416);
+            expect(_packPT(0, 3, 14, 1, 0)).toEqual(3221305360);
+            expect(_packPT(0, 41, 60, 1, 0)).toEqual(3222597648);
+        });
+    });
+    describe('_ptToZarr returns channel, res., xyz coordinates for a page table coord.', () => {
+        it('correctly converts page table coordinates to image pyramid chunk keys', () => {
+            const ptInfo = {
+                PT_zExtent: 36,
+                PT_z0Extent: 7,
+                PT_anchors: [
+                    [0, 0, 36],
+                    [64, 53, 29],
+                    [32, 28, 22],
+                    [16, 15, 15],
+                    [8, 8, 8],
+                    [4, 4, 4],
+                    [2, 2, 2],
+                    [1, 1, 1],
+                ],
+            };
+            expect(_ptToZarr(4, 1, 13, ptInfo)).toEqual({ channel: 0, resolution: 4, x: 4, y: 1, z: 5 });
+            expect(_ptToZarr(7, 1, 14, ptInfo)).toEqual({ channel: 0, resolution: 4, x: 7, y: 1, z: 6 });
+            expect(_ptToZarr(2, 1, 4, ptInfo)).toEqual({ channel: 0, resolution: 5, x: 2, y: 1, z: 0 });
+            expect(_ptToZarr(0, 4, 14, ptInfo)).toEqual({ channel: 0, resolution: 4, x: 0, y: 4, z: 6 });
+        });
+    });
+    describe('_requestBufferToRequestObjects', () => {
+        it('correctly converts a buffer to request objects', () => {
+            const buffer = new Uint8Array([
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 128, 16, 13,
+                0, 0, 0, 0,
+            ]);
+            const k = 40;
+            const { requests: result } = _requestBufferToRequestObjects(buffer, k);
+            expect(result).toEqual([
+                { x: 2, y: 1, z: 13 },
+            ]);
+        });
+    });
+});

package/dist-tsc/VolumeRenderManager.d.ts

@@ -0,0 +1,265 @@
+/**
+ * Manages the volume rendering state, shader setup, and uniform management
+ * Serves as a replacement for many functions from three-utils.js
+ */
+export class VolumeRenderManager {
+    uniforms: any;
+    shader: {
+        uniforms: {
+            u_size: {
+                value: import("three").Vector3;
+            };
+            clim0: {
+                value: Vector2;
+            };
+            clim1: {
+                value: Vector2;
+            };
+            clim2: {
+                value: Vector2;
+            };
+            clim3: {
+                value: Vector2;
+            };
+            clim4: {
+                value: Vector2;
+            };
+            clim5: {
+                value: Vector2;
+            };
+            clim6: {
+                value: Vector2;
+            };
+            clim7: {
+                value: Vector2;
+            };
+            xClip: {
+                value: Vector2;
+            };
+            yClip: {
+                value: Vector2;
+            };
+            zClip: {
+                value: Vector2;
+            };
+            u_window_size: {
+                value: Vector2;
+            };
+            u_vol_scale: {
+                value: import("three").Vector3;
+            };
+            u_renderstyle: {
+                value: number;
+            };
+            brickCacheTex: {
+                type: string;
+                value: null;
+            };
+            pageTableTex: {
+                type: string;
+                value: null;
+            };
+            color0: {
+                value: import("three").Vector4;
+            };
+            color1: {
+                value: import("three").Vector4;
+            };
+            color2: {
+                value: import("three").Vector4;
+            };
+            color3: {
+                value: import("three").Vector4;
+            };
+            color4: {
+                value: import("three").Vector4;
+            };
+            color5: {
+                value: import("three").Vector4;
+            };
+            color6: {
+                value: import("three").Vector4;
+            };
+            channelMapping: {
+                value: number[];
+            };
+            resGlobal: {
+                value: Vector2;
+            };
+            res0: {
+                value: Vector2;
+            };
+            res1: {
+                value: Vector2;
+            };
+            res2: {
+                value: Vector2;
+            };
+            res3: {
+                value: Vector2;
+            };
+            res4: {
+                value: Vector2;
+            };
+            res5: {
+                value: Vector2;
+            };
+            res6: {
+                value: Vector2;
+            };
+            maxChannels: {
+                value: number;
+            };
+            lodFactor: {
+                value: number;
+            };
+            near: {
+                value: number;
+            };
+            far: {
+                value: number;
+            };
+            opacity: {
+                value: number;
+            };
+            volumeCount: {
+                value: number;
+            };
+            boxSize: {
+                value: import("three").Vector3;
+            };
+            renderRes: {
+                value: number;
+            };
+            voxelExtents: {
+                value: import("three").Vector3;
+            };
+            anchor0: {
+                value: import("three").Vector3;
+            };
+            anchor1: {
+                value: import("three").Vector3;
+            };
+            anchor2: {
+                value: import("three").Vector3;
+            };
+            anchor3: {
+                value: import("three").Vector3;
+            };
+            anchor4: {
+                value: import("three").Vector3;
+            };
+            anchor5: {
+                value: import("three").Vector3;
+            };
+            anchor6: {
+                value: import("three").Vector3;
+            };
+            anchor7: {
+                value: import("three").Vector3;
+            };
+            anchor8: {
+                value: import("three").Vector3;
+            };
+            anchor9: {
+                value: import("three").Vector3;
+            };
+            scale0: {
+                value: import("three").Vector3;
+            };
+            scale1: {
+                value: import("three").Vector3;
+            };
+            scale2: {
+                value: import("three").Vector3;
+            };
+            scale3: {
+                value: import("three").Vector3;
+            };
+            scale4: {
+                value: import("three").Vector3;
+            };
+            scale5: {
+                value: import("three").Vector3;
+            };
+            scale6: {
+                value: import("three").Vector3;
+            };
+            scale7: {
+                value: import("three").Vector3;
+            };
+            scale8: {
+                value: import("three").Vector3;
+            };
+            scale9: {
+                value: import("three").Vector3;
+            };
+        };
+        vertexShader: string;
+        fragmentShader: string;
+    } | null;
+    meshScale: number[];
+    geometrySize: number[];
+    boxSize: number[];
+    zarrInit: boolean;
+    channelsVisible: any[];
+    channelTargetC: any[];
+    zarrStoreNumResolutions: any;
+    channelMaxResolutionIndex: any[];
+    colors: any[];
+    contrastLimits: any[];
+    layerTransparency: number;
+    xSlice: Vector2;
+    ySlice: Vector2;
+    zSlice: Vector2;
+    originalScale: number[];
+    physicalDimensions: number[];
+    maxResolution: number[];
+    maxRange: number;
+    maxRangeSet: boolean;
+    /**
+     * Initialize shader and uniform objects
+     */
+    initializeShader(): void;
+    /**
+     * Extract rendering settings from coordination props
+     * @param {Object} props - Component props
+     * @returns {Object} Extracted rendering settings
+     */
+    extractRenderingSettingsFromProps(props: Object): Object;
+    /**
+     * Update the render settings from the given props
+     * @param {Object} props - Component props
+     * @returns {boolean} True if settings were successfully updated
+     */
+    updateFromProps(props: Object): boolean;
+    renderingMode: any;
+    /**
+     * Update the rendering based on the current volume data from the data manager
+     * @param {object} volumeDataManagerProps - Params derived from the volume data manager
+     * @returns {Object|null} Updated rendering settings or null if rendering is not possible
+     */
+    updateRendering({ zarrStoreShapes, originalScaleXYZ, physicalDimensionsXYZ, maxResolutionXYZ, boxDimensionsXYZ, normalizedScaleXYZ, bcTHREE, ptTHREE, }: object): Object | null;
+    normalizedScale: any;
+    /**
+     * Update shader uniforms with current rendering values
+     * @param {Array} textures - List of 3D textures
+     * @param {Object} dimensions - Dimensions object
+     * @param {number} renderstyle - Rendering mode value
+     * @param {Array} contrastLimits - List of contrast limits for each channel
+     * @param {Array} colors - List of colors for each channel
+     * @param {number} layerTransparency - Overall transparency value
+     * @param {Vector2} xSlice - X clipping plane
+     * @param {Vector2} ySlice - Y clipping plane
+     * @param {Vector2} zSlice - Z clipping plane
+     */
+    updateUniforms(textures: any[], dimensions: Object, renderstyle: number, contrastLimits: any[], colors: any[], layerTransparency: number, xSlice: Vector2, ySlice: Vector2, zSlice: Vector2, brickCacheTexture: any, pageTableTexture: any): void;
+    /**
+     * Sets the processing render target
+     * @param {WebGLMultipleRenderTargets} mrt - Multiple render targets object with 3 attachments
+     */
+    setChannelMapping(channelMapping: any): void;
+    setZarrUniforms(zarrStore: any, PT: any): void;
+}
+import { Vector2 } from 'three';
+//# sourceMappingURL=VolumeRenderManager.d.ts.map

package/dist-tsc/VolumeRenderManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VolumeRenderManager.d.ts","sourceRoot":"","sources":["../src/VolumeRenderManager.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH;IAII,cAAoB;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAkB;IAClB,oBAA0B;IAC1B,uBAA6B;IAC7B,kBAAwB;IACxB,kBAAqB;IAGrB,uBAAyB;IACzB,sBAAwB;IACxB,6BAAmC;IACnC,iCAAmC;IACnC,cAAgB;IAChB,sBAAwB;IACxB,0BAA4B;IAC5B,gBAAqC;IACrC,gBAAqC;IACrC,gBAAqC;IACrC,wBAA8B;IAC9B,6BAAmC;IACnC,wBAA8B;IAE9B,iBAAmB;IACnB,qBAAwB;IAS1B;;OAEG;IACH,yBAIC;IAED;;;;OAIG;IACH,yCAHW,MAAM,GACJ,MAAM,CAqIlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,OAAO,CAsBnB;IAPC,mBAA2C;IAS7C;;;;OAIG;IACH,yJAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAsIvB;IAzCG,qBAAyC;IA2C7C;;;;;;;;;;;OAWG;IACH,4CATW,MAAM,eACN,MAAM,2DAGN,MAAM,UACN,OAAO,UACP,OAAO,UACP,OAAO,uDA4HjB;IAED;;;OAGG;IAQH,6CAIC;IAKD,+CAkDC;CACF;wBAxkBM,OAAO"}