copper3d 3.4.3 → 3.4.5

package/dist/bundle.umd.js

@@ -70879,6 +70879,17 @@ void main() {
 	     * @throws {RangeError} If any dimension or the channel count is < 1.
 	     */
 	    constructor(width, height, depth, channels = 1, customColorMap) {
+	        /**
+	         * Monotonic data-mutation counter.
+	         *
+	         * Incremented by every method that mutates voxel data (not color).
+	         * Consumers (e.g. the contour cache in RenderingUtils) key cached
+	         * derivations on this value so an edit automatically invalidates them —
+	         * it is impossible to forget an invalidation point because every write
+	         * bumps the version. Color-map changes do **not** bump it (colors are
+	         * applied at fill time, never cached).
+	         */
+	        this.version = 0;
 	        if (width < 1 || height < 1 || depth < 1) {
 	            throw new RangeError(`Dimensions must be ≥ 1, got (${width}, ${height}, ${depth})`);
 	        }
@@ -70968,6 +70979,16 @@ void main() {
 	     */
 	    setVoxel(x, y, z, value, channel = 0) {
 	        this.data[this.getIndex(x, y, z, channel)] = value;
+	        this.version++;
+	    }
+	    /**
+	     * Return the current data-mutation version.
+	     *
+	     * Increments on every voxel write. Use as a cache key so derived data
+	     * (e.g. extracted contours) is invalidated whenever the volume changes.
+	     */
+	    getVersion() {
+	        return this.version;
 	    }
 	    // ── Color map management ──────────────────────────────────────────
 	    /**
@@ -71124,6 +71145,7 @@ void main() {
 	            throw new Error(`ImageData size mismatch: expected ${expectedW}×${expectedH}, ` +
 	                `got ${imageData.width}×${imageData.height}`);
 	        }
+	        this.version++;
 	        const pixels = imageData.data;
 	        const { width, height } = this.dims;
 	        const ch = this.numChannels;
@@ -71225,6 +71247,7 @@ void main() {
 	            throw new Error(`ImageData size mismatch: expected ${expectedW}×${expectedH}, ` +
 	                `got ${imageData.width}×${imageData.height}`);
 	        }
+	        this.version++;
 	        // Build RGB→channel lookup map for O(1) reverse lookup
 	        const rgbToChannel = this.buildRgbToChannelMap();
 	        const pixels = imageData.data;
@@ -71489,6 +71512,7 @@ void main() {
 	            throw new Error(`Data length mismatch: expected ${this.data.length}, got ${newData.length}`);
 	        }
 	        this.data = newData;
+	        this.version++;
 	    }
 	    /**
 	     * Create an independent deep copy of this volume.
@@ -71528,6 +71552,7 @@ void main() {
 	     */
 	    clear() {
 	        this.data.fill(0);
+	        this.version++;
 	    }
 	    /**
 	     * Check if the volume contains any non-zero voxel data.
@@ -71580,6 +71605,7 @@ void main() {
 	     */
 	    clearSlice(sliceIndex, axis = 'z', channel) {
 	        this.validateSliceIndex(sliceIndex, axis);
+	        this.version++;
 	        const [sliceW, sliceH] = this.getSliceDimensions(axis);
 	        const volData = this.data;
 	        const nch = this.numChannels;
@@ -71691,6 +71717,7 @@ void main() {
 	     */
 	    setSliceUint8(sliceIndex, data, axis = 'z') {
 	        this.validateSliceIndex(sliceIndex, axis);
+	        this.version++;
 	        const [sliceW, sliceH] = this.getSliceDimensions(axis);
 	        const nch = this.numChannels;
 	        const rowStride = this.dims.width * nch;
@@ -72134,10 +72161,18 @@ void main() {
 	    /* 15 (full)  */ [[[0, 0], [1, 0], [1, 1], [0, 1]]],
 	];
 	/**
-	 * Emit all per-cell polygons covering the voxels where `labels === targetLabel`.
+	 * Emit polygons covering the voxels where `labels === targetLabel`.
 	 * Pure geometry function — no Canvas dependency. Consumers can build a Path2D
 	 * (see {@link extractLabelContours}) or walk the vertex arrays directly
 	 * (tests, export, stroke rendering).
+	 *
+	 * Boundary cells (marching-squares cases 1–14) emit their cut polygon as
+	 * usual. Solid interior (case 15) is **coalesced into horizontal run-length
+	 * rectangles** instead of one unit square per cell, collapsing the subpath
+	 * count from O(area) to ≈ O(perimeter + rows). The filled region is
+	 * pixel-identical (contiguous full-cell squares tile exactly into a rectangle
+	 * with the same TL→TR→BR→BL winding), which is what keeps slice-scrubbing
+	 * fast on large masks without changing the rendered silhouette.
 	 */
 	function extractLabelPolygons(labels, width, height, targetLabel, stride = 1, channelOffset = 0, bbox) {
 	    var _a, _b, _c, _d;
@@ -72159,7 +72194,25 @@ void main() {
 	    // map to voxel-square CENTERS in render space. Voxel (i, j) occupies
 	    // render square [i, i+1] × [j, j+1]; its center is (i+0.5, j+0.5).
 	    const SHIFT = 0.5;
+	    // Emit a single rectangle covering a contiguous run of full (code 15)
+	    // cells [runStart .. runEnd] on row j. A full cell i covers render square
+	    // [i+0.5, i+1.5] × [j+0.5, j+1.5]; consecutive full cells tile perfectly,
+	    // so the run is pixel-identical to the per-cell squares it replaces.
+	    // Vertices use the same TL→TR→BR→BL (CCW screen-space) winding as the
+	    // case-15 unit square, so the nonzero fill matches at shared edges.
+	    const pushFullRun = (runStart, runEnd, j) => {
+	        const x0 = runStart + SHIFT;
+	        const x1 = runEnd + 1 + SHIFT;
+	        const y0 = j + SHIFT;
+	        const y1 = j + 1 + SHIFT;
+	        out.push([[x0, y0], [x1, y0], [x1, y1], [x0, y1]]);
+	    };
 	    for (let j = j0; j < j1; j++) {
+	        // Index where the current contiguous run of full (code 15) cells began,
+	        // or -1 when no run is open. Coalescing the solid interior into row runs
+	        // drops the per-cell square count from O(area) to O(rows + perimeter),
+	        // which is what keeps fast slice-scrubbing smooth on large masks.
+	        let runStart = -1;
 	        for (let i = i0; i < i1; i++) {
 	            const tl = sample(i, j);
 	            const tr = sample(i + 1, j);
@@ -72169,6 +72222,17 @@ void main() {
 	                (tr ? 4 : 0) |
 	                (br ? 2 : 0) |
 	                (bl ? 1 : 0);
+	            if (code === 15) {
+	                // Extend (or open) the current full-cell run; defer emission.
+	                if (runStart === -1)
+	                    runStart = i;
+	                continue;
+	            }
+	            // Non-full cell ends any open run — flush it as one rectangle.
+	            if (runStart !== -1) {
+	                pushFullRun(runStart, i - 1, j);
+	                runStart = -1;
+	            }
 	            if (code === 0)
 	                continue;
 	            const polygons = CELL_POLYGONS[code];
@@ -72181,6 +72245,10 @@ void main() {
 	                out.push(abs);
 	            }
 	        }
+	        // Flush a run that reached the end of the row (last visited cell is i1-1).
+	        if (runStart !== -1) {
+	            pushFullRun(runStart, i1 - 1, j);
+	        }
 	    }
 	    return out;
 	}
@@ -73645,6 +73713,23 @@ void main() {
 	        this._reusableSliceBuffer = null;
 	        this._reusableBufferWidth = 0;
 	        this._reusableBufferHeight = 0;
+	        /**
+	         * Per-layer contour cache.
+	         *
+	         * Caches the *expensive* part of slice rendering — `getSliceUint8` +
+	         * `findLabelsInSlice` + `extractLabelContours` (Path2D build) — keyed by
+	         * `${axis}:${sliceIndex}:${volume.version}`. The contours live in voxel
+	         * coordinates; zoom only changes the `ctx.scale` transform, so on zoom /
+	         * recomposite we reuse the cached Path2D and just re-fill, skipping
+	         * marching-squares entirely. A volume edit bumps its version → cache miss
+	         * → recompute (correct, automatic). Colors and channel visibility are
+	         * applied at fill time and intentionally *not* cached, so toggling them
+	         * needs no recompute.
+	         *
+	         * One entry per layer (the current slice). Switching slice/axis or
+	         * editing overwrites it.
+	         */
+	        this._contourCache = new Map();
 	        this.state = state;
 	    }
 	    // ── Volume Accessor Helpers ──────────────────────────────────────
@@ -73743,14 +73828,27 @@ void main() {
 	            const volume = this.getVolumeForLayer(layer);
 	            if (!volume)
 	                return;
-	            const channelVis = this.state.gui_states.layerChannel.channelVisibility[layer];
-	            const slice = volume.getSliceUint8(sliceIndex, axis);
-	            const W = slice.width;
-	            const H = slice.height;
 	            const stride = volume.getChannels();
-	            const labels = findLabelsInSlice(slice.data, W, H, stride, 0);
-	            if (labels.length === 0)
+	            const cacheKey = `${axis}:${sliceIndex}:${volume.getVersion()}`;
+	            // Cache miss → run the expensive extraction once. Hits (zoom,
+	            // recomposite, contrast toggle) skip straight to the fill below.
+	            let entry = this._contourCache.get(layer);
+	            if (!entry || entry.key !== cacheKey) {
+	                const slice = volume.getSliceUint8(sliceIndex, axis);
+	                const W = slice.width;
+	                const H = slice.height;
+	                const labels = findLabelsInSlice(slice.data, W, H, stride, 0);
+	                const paths = new Map();
+	                for (const lbl of labels) {
+	                    paths.set(lbl, extractLabelContours(slice.data, W, H, lbl, stride, 0));
+	                }
+	                entry = { key: cacheKey, W, H, labels, paths };
+	                this._contourCache.set(layer, entry);
+	            }
+	            if (entry.labels.length === 0)
 	                return;
+	            const { W, H, labels, paths } = entry;
+	            const channelVis = this.state.gui_states.layerChannel.channelVisibility[layer];
 	            targetCtx.save();
 	            // Vector fill — imageSmoothingEnabled is irrelevant here, but keep
 	            // it off to match the rest of the pipeline.
@@ -73767,8 +73865,10 @@ void main() {
 	            for (const lbl of labels) {
 	                if (channelVis && channelVis[lbl] === false)
 	                    continue;
+	                const path = paths.get(lbl);
+	                if (!path)
+	                    continue;
 	                const color = volume.getChannelColor(lbl);
-	                const path = extractLabelContours(slice.data, W, H, lbl, stride, 0);
 	                targetCtx.fillStyle =
 	                    `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
 	                targetCtx.fill(path, 'nonzero');
@@ -73786,6 +73886,7 @@ void main() {
 	        this._reusableSliceBuffer = null;
 	        this._reusableBufferWidth = 0;
 	        this._reusableBufferHeight = 0;
+	        this._contourCache.clear();
 	    }
 	    /**
 	     * Apply the same flip transform used by flipDisplayImageByAxis() to any
@@ -74544,7 +74645,30 @@ void main() {
 	    }
 	    // ===== Zoom Wheel =====
 	    configMouseZoomWheel() {
-	        let moveDistance = 1;
+	        // Coalesce multiple wheel events fired within one frame into a single
+	        // resizePaintArea() call via requestAnimationFrame. Each resize triggers
+	        // a full display redraw (+ mask recomposite), so without coalescing a
+	        // fast scroll fires dozens of these per frame. The accumulation is done
+	        // on the logical zoom (sizeFactor) — not the DOM offsetWidth — so deltas
+	        // still compound correctly even though the DOM size hasn't updated yet.
+	        let rafId = null;
+	        let pending = null;
+	        const flush = () => {
+	            rafId = null;
+	            if (!pending)
+	                return;
+	            const p = pending;
+	            pending = null;
+	            if (p.recenter) {
+	                this.callbacks.resetPaintAreaUIPosition();
+	            }
+	            else {
+	                this.callbacks.resetPaintAreaUIPosition(p.l, p.t);
+	            }
+	            this.callbacks.resizePaintArea(p.moveDistance);
+	            this.callbacks.setIsDrawFalse(1000);
+	            this.ctx.nrrd_states.view.sizeFactor = p.moveDistance;
+	        };
 	        return (e) => {
 	            var _a, _b;
 	            if ((_a = this.ctx.eventRouter) === null || _a === void 0 ? void 0 : _a.isShiftHeld()) {
@@ -74559,36 +74683,38 @@ void main() {
 	            const delta = e.detail ? e.detail > 0 : e.wheelDelta < 0;
 	            this.ctx.protectedData.isDrawing = true;
 	            const rect = this.container.getBoundingClientRect();
-	            const ratioL = (e.clientX -
-	                rect.left -
-	                this.mainAreaContainer.offsetLeft -
-	                this.ctx.protectedData.canvases.drawingCanvas.offsetLeft) /
-	                this.ctx.protectedData.canvases.drawingCanvas.offsetWidth;
-	            const ratioT = (e.clientY -
-	                rect.top -
-	                this.mainAreaContainer.offsetTop -
-	                this.ctx.protectedData.canvases.drawingCanvas.offsetTop) /
-	                this.ctx.protectedData.canvases.drawingCanvas.offsetHeight;
+	            const drawingCanvas = this.ctx.protectedData.canvases.drawingCanvas;
+	            const ratioL = (e.clientX - rect.left - this.mainAreaContainer.offsetLeft - drawingCanvas.offsetLeft) /
+	                drawingCanvas.offsetWidth;
+	            const ratioT = (e.clientY - rect.top - this.mainAreaContainer.offsetTop - drawingCanvas.offsetTop) /
+	                drawingCanvas.offsetHeight;
 	            const ratioDelta = !delta ? 1 + 0.1 : 1 - 0.1;
-	            const w = this.ctx.protectedData.canvases.drawingCanvas.offsetWidth * ratioDelta;
-	            const h = this.ctx.protectedData.canvases.drawingCanvas.offsetHeight * ratioDelta;
-	            const l = Math.round(e.clientX - this.mainAreaContainer.offsetLeft - w * ratioL - rect.left);
-	            const t = Math.round(e.clientY - this.mainAreaContainer.offsetTop - h * ratioT - rect.top);
-	            moveDistance = w / this.ctx.nrrd_states.image.originWidth;
+	            // Compound from the latest pending target (this frame) or the current
+	            // committed sizeFactor.
+	            const base = pending ? pending.moveDistance : this.ctx.nrrd_states.view.sizeFactor;
+	            let moveDistance = base * ratioDelta;
 	            if (moveDistance > 8) {
+	                // Max zoom: original behaviour clamps without re-laying out.
 	                moveDistance = 8;
+	                this.ctx.nrrd_states.view.sizeFactor = moveDistance;
+	                this.callbacks.setIsDrawFalse(1000);
+	                return;
 	            }
-	            else if (moveDistance < 1) {
+	            if (moveDistance < 1) {
 	                moveDistance = 1;
-	                this.callbacks.resetPaintAreaUIPosition();
-	                this.callbacks.resizePaintArea(moveDistance);
+	                pending = { moveDistance, l: 0, t: 0, recenter: true };
 	            }
 	            else {
-	                this.callbacks.resetPaintAreaUIPosition(l, t);
-	                this.callbacks.resizePaintArea(moveDistance);
+	                // Target displayed size for this zoom level → keep cursor anchored.
+	                const w = this.ctx.nrrd_states.image.originWidth * moveDistance;
+	                const h = this.ctx.nrrd_states.image.originHeight * moveDistance;
+	                const l = Math.round(e.clientX - this.mainAreaContainer.offsetLeft - w * ratioL - rect.left);
+	                const t = Math.round(e.clientY - this.mainAreaContainer.offsetTop - h * ratioT - rect.top);
+	                pending = { moveDistance, l, t, recenter: false };
+	            }
+	            if (rafId === null) {
+	                rafId = requestAnimationFrame(flush);
 	            }
-	            this.callbacks.setIsDrawFalse(1000);
-	            this.ctx.nrrd_states.view.sizeFactor = moveDistance;
 	        };
 	    }
 	}
@@ -79332,7 +79458,7 @@ void main() {
 	}
 
 	// import * as kiwrious from "copper3d_plugin_heart_k";
-	const REVISION = "v3.4.3-beta";
+	const REVISION = "v3.4.5-beta";
 	console.log(`%cCopper3D Visualisation %cBeta:${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
 
 	exports.CHANNEL_COLORS = CHANNEL_COLORS;

package/dist/index.d.ts

@@ -25,6 +25,6 @@ import type { ToolMode, IAnnotationCallbacks } from "./Utils/segmentation/core/t
 import { CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss } from "./Utils/segmentation/core/index";
 import type { LayerId, ChannelValue } from "./Utils/segmentation/core/index";
 import "./css/style.css";
-export declare const REVISION = "v3.4.3-beta";
+export declare const REVISION = "v3.4.5-beta";
 export { copperRenderer, copperRendererOnDemond, copperMSceneRenderer, setHDRFilePath, addLabelToScene, convert3DPostoScreenPos, convertScreenPosto3DPos, addBoxHelper, fullScreenListenner, configKiwriousHeart, copperScene, copperSceneOnDemond, copperMScene, CameraViewPoint, kiwrious, NrrdTools, loading, Copper3dTrackballControls, createTexture2D_NRRD, MeshNodeTool, throttle, removeGuiFolderChilden, CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss, GaussianSmoother, };
 export type { positionType, screenPosType, optsType, nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, IPaintImage, exportPaintImageType, IOptVTKLoader, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, NrrdState, GuiState, IGuiMeta, ToolMode, IAnnotationCallbacks, LayerId, ChannelValue, };

package/dist/index.js

@@ -21,7 +21,7 @@ import { MeshNodeTool } from "./Utils/MeshNodeTool";
 import { removeGuiFolderChilden } from "./Utils/segmentation/coreTools/gui";
 import { CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss } from "./Utils/segmentation/core/index";
 import "./css/style.css";
-export const REVISION = "v3.4.3-beta";
+export const REVISION = "v3.4.5-beta";
 console.log(`%cCopper3D Visualisation %cBeta:${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
 export { copperRenderer, copperRendererOnDemond, copperMSceneRenderer, setHDRFilePath, addLabelToScene, convert3DPostoScreenPos, convertScreenPosto3DPos, addBoxHelper, fullScreenListenner, configKiwriousHeart, copperScene, copperSceneOnDemond, copperMScene, CameraViewPoint, kiwrious, NrrdTools, loading, Copper3dTrackballControls, createTexture2D_NRRD, MeshNodeTool, throttle, removeGuiFolderChilden, CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss, GaussianSmoother, };
 //# sourceMappingURL=index.js.map

package/dist/types/Utils/segmentation/RenderingUtils.d.ts

@@ -18,6 +18,23 @@ export declare class RenderingUtils {
     private _reusableSliceBuffer;
     private _reusableBufferWidth;
     private _reusableBufferHeight;
+    /**
+     * Per-layer contour cache.
+     *
+     * Caches the *expensive* part of slice rendering — `getSliceUint8` +
+     * `findLabelsInSlice` + `extractLabelContours` (Path2D build) — keyed by
+     * `${axis}:${sliceIndex}:${volume.version}`. The contours live in voxel
+     * coordinates; zoom only changes the `ctx.scale` transform, so on zoom /
+     * recomposite we reuse the cached Path2D and just re-fill, skipping
+     * marching-squares entirely. A volume edit bumps its version → cache miss
+     * → recompute (correct, automatic). Colors and channel visibility are
+     * applied at fill time and intentionally *not* cached, so toggling them
+     * needs no recompute.
+     *
+     * One entry per layer (the current slice). Switching slice/axis or
+     * editing overwrites it.
+     */
+    private _contourCache;
     constructor(state: CanvasState);
     /**
      * Get MaskVolume for a specific layer

package/dist/types/Utils/segmentation/core/MarchingSquares.d.ts

@@ -35,10 +35,18 @@ export interface ContourBBox {
 /** A single polygon's vertices in voxel-space coordinates. */
 export type ContourPolygon = ReadonlyArray<readonly [number, number]>;
 /**
- * Emit all per-cell polygons covering the voxels where `labels === targetLabel`.
+ * Emit polygons covering the voxels where `labels === targetLabel`.
  * Pure geometry function — no Canvas dependency. Consumers can build a Path2D
  * (see {@link extractLabelContours}) or walk the vertex arrays directly
  * (tests, export, stroke rendering).
+ *
+ * Boundary cells (marching-squares cases 1–14) emit their cut polygon as
+ * usual. Solid interior (case 15) is **coalesced into horizontal run-length
+ * rectangles** instead of one unit square per cell, collapsing the subpath
+ * count from O(area) to ≈ O(perimeter + rows). The filled region is
+ * pixel-identical (contiguous full-cell squares tile exactly into a rectangle
+ * with the same TL→TR→BR→BL winding), which is what keeps slice-scrubbing
+ * fast on large masks without changing the rendered silhouette.
  */
 export declare function extractLabelPolygons(labels: Uint8Array, width: number, height: number, targetLabel: number, stride?: number, channelOffset?: number, bbox?: ContourBBox): ContourPolygon[];
 /**

package/dist/types/Utils/segmentation/core/MaskVolume.d.ts

@@ -45,6 +45,17 @@ export declare class MaskVolume {
     private readonly bytesPerSlice;
     /** Per-channel color map used for colored rendering modes. */
     private colorMap;
+    /**
+     * Monotonic data-mutation counter.
+     *
+     * Incremented by every method that mutates voxel data (not color).
+     * Consumers (e.g. the contour cache in RenderingUtils) key cached
+     * derivations on this value so an edit automatically invalidates them —
+     * it is impossible to forget an invalidation point because every write
+     * bumps the version. Color-map changes do **not** bump it (colors are
+     * applied at fill time, never cached).
+     */
+    private version;
     /**
      * Create a new MaskVolume.
      *
@@ -105,6 +116,13 @@ export declare class MaskVolume {
      * @throws {RangeError} If any coordinate is out of bounds.
      */
     setVoxel(x: number, y: number, z: number, value: number, channel?: number): void;
+    /**
+     * Return the current data-mutation version.
+     *
+     * Increments on every voxel write. Use as a cache key so derived data
+     * (e.g. extracted contours) is invalidated whenever the volume changes.
+     */
+    getVersion(): number;
     /**
      * Update the color for a specific label/channel in the color map.
      *

package/dist/types/index.d.ts

@@ -25,6 +25,6 @@ import type { ToolMode, IAnnotationCallbacks } from "./Utils/segmentation/core/t
 import { CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss } from "./Utils/segmentation/core/index";
 import type { LayerId, ChannelValue } from "./Utils/segmentation/core/index";
 import "./css/style.css";
-export declare const REVISION = "v3.4.3-beta";
+export declare const REVISION = "v3.4.5-beta";
 export { copperRenderer, copperRendererOnDemond, copperMSceneRenderer, setHDRFilePath, addLabelToScene, convert3DPostoScreenPos, convertScreenPosto3DPos, addBoxHelper, fullScreenListenner, configKiwriousHeart, copperScene, copperSceneOnDemond, copperMScene, CameraViewPoint, kiwrious, NrrdTools, loading, Copper3dTrackballControls, createTexture2D_NRRD, MeshNodeTool, throttle, removeGuiFolderChilden, CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss, GaussianSmoother, };
 export type { positionType, screenPosType, optsType, nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, IPaintImage, exportPaintImageType, IOptVTKLoader, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, NrrdState, GuiState, IGuiMeta, ToolMode, IAnnotationCallbacks, LayerId, ChannelValue, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "copper3d",
   "description": "A 3d visualisation package base on threejs provides multiple scenes and Nrrd image load funtion.",
-  "version": "3.4.3",
+  "version": "3.4.5",
   "main": "dist/bundle.umd.js",
   "moudle": "dist/bundle.esm.js",
   "types": "dist/types/index.d.ts",