copper3d 3.2.0 → 3.2.1

package/dist/bundle.esm.js

@@ -71387,6 +71387,17 @@ class MaskVolume {
     getChannels() {
         return this.numChannels;
     }
+    /**
+     * Return the number of bytes in one complete z-slice.
+     *
+     * Equal to `width × height × channels`. Useful for direct buffer
+     * index arithmetic in performance-critical code paths.
+     *
+     * @returns Bytes per z-slice.
+     */
+    getBytesPerSlice() {
+        return this.bytesPerSlice;
+    }
     /**
      * Return total memory used by the backing buffer, in bytes.
      *
@@ -73204,8 +73215,8 @@ class DragSliceTool extends BaseTool {
                         }
                     }
                 }
-                // Composite all layers to master canvas
-                this.compositeAllLayers();
+                // Composite all layers to master canvas (uses per-layer alpha)
+                this.callbacks.compositeAllLayers();
             }
             // Refresh sphere overlay from volume for the new slice
             if (this.ctx.gui_states.mode.sphere) {
@@ -73214,23 +73225,6 @@ class DragSliceTool extends BaseTool {
             view.switchSliceFlag = false;
         }
     }
-    /**
-     * Composite all visible layer canvases to the master display canvas.
-     */
-    compositeAllLayers() {
-        const masterCtx = this.ctx.protectedData.ctxes.drawingLayerMasterCtx;
-        const width = this.ctx.nrrd_states.view.changedWidth;
-        const height = this.ctx.nrrd_states.view.changedHeight;
-        masterCtx.clearRect(0, 0, width, height);
-        // Master stores full-alpha composite; globalAlpha applied in start() render loop.
-        for (const layerId of this.ctx.nrrd_states.image.layers) {
-            if (!this.ctx.gui_states.layerChannel.layerVisibility[layerId])
-                continue;
-            const target = this.ctx.protectedData.layerTargets.get(layerId);
-            if (target)
-                masterCtx.drawImage(target.canvas, 0, 0, width, height);
-        }
-    }
     // ===== Canvas Cleanup =====
     cleanCanvases(flag) {
         if (flag) {
@@ -73272,7 +73266,7 @@ class DragSliceTool extends BaseTool {
 }
 
 class DragOperator {
-    constructor(container, nrrd_sates, gui_states, protectedData, drawingPrameters, setSyncsliceNum, setIsDrawFalse, flipDisplayImageByAxis, setEmptyCanvasSize, getOrCreateSliceBuffer, renderSliceToCanvas) {
+    constructor(container, nrrd_sates, gui_states, protectedData, drawingPrameters, setSyncsliceNum, setIsDrawFalse, flipDisplayImageByAxis, setEmptyCanvasSize, getOrCreateSliceBuffer, renderSliceToCanvas, compositeAllLayers) {
         this.dragPrameters = {
             move: 0,
             y: 0,
@@ -73308,6 +73302,7 @@ class DragOperator {
         this.setEmptyCanvasSize = setEmptyCanvasSize;
         this.getOrCreateSliceBuffer = getOrCreateSliceBuffer;
         this.renderSliceToCanvas = renderSliceToCanvas;
+        this.compositeAllLayers = compositeAllLayers;
         this.showDragNumberDiv = createShowSliceNumberDiv();
         this.init();
     }
@@ -73333,6 +73328,7 @@ class DragOperator {
             setEmptyCanvasSize: (axis) => this.setEmptyCanvasSize(axis),
             getOrCreateSliceBuffer: (axis) => this.getOrCreateSliceBuffer(axis),
             renderSliceToCanvas: (layer, axis, sliceIndex, buffer, targetCtx, w, h) => this.renderSliceToCanvas(layer, axis, sliceIndex, buffer, targetCtx, w, h),
+            compositeAllLayers: () => this.compositeAllLayers(),
             refreshSphereOverlay: () => { var _a; return (_a = this.refreshSphereOverlayCb) === null || _a === void 0 ? void 0 : _a.call(this); },
         }, this.showDragNumberDiv, dragEffectCanvases);
     }
@@ -76460,6 +76456,216 @@ class CanvasState {
     }
 }
 
+/**
+ * GaussianSmoother — 3D Gaussian smoothing for segmentation masks.
+ *
+ * Applies a separable 3D Gaussian blur to a single label channel within a
+ * MaskVolume, then thresholds the result back to a binary mask. This smooths
+ * jagged edges and fills small holes in segmentation annotations.
+ *
+ * Pure, stateless utility — no DOM/Canvas/GUI dependencies.
+ *
+ * Performance: uses direct typed-array access (bypassing getVoxel/setVoxel
+ * boundary checks) and branch-free convolution for the interior region.
+ */
+class GaussianSmoother {
+    /**
+     * Smooth a single label channel in-place using separable 3D Gaussian blur.
+     *
+     * Steps:
+     *  1. Extract — create a Float32Array with 1.0 where voxel === channel, 0.0 elsewhere.
+     *  2. Blur — apply separable Gaussian (X → Y → Z) on the float buffer.
+     *  3. Threshold — binarize at 0.5.
+     *  4. Write back — overwrite/erase voxels according to the thresholded result.
+     *
+     * @param volume  The MaskVolume to operate on (modified in-place).
+     * @param channel The label value to smooth (must be > 0).
+     * @param sigma   Base Gaussian sigma in voxel units (default 1.0).
+     * @param spacing Optional voxel spacing [sx, sy, sz]. When provided, per-axis
+     *                sigma is computed as `sigma / spacing[axis]` so that the
+     *                physical smoothing radius is isotropic.
+     */
+    static gaussianSmooth3D(volume, channel, sigma = 1.0, spacing) {
+        const dims = volume.getDimensions();
+        const { width, height, depth } = dims;
+        const totalVoxels = width * height * depth;
+        // Direct access to underlying buffer — bypasses getVoxel/setVoxel
+        // boundary checks for ~10x speedup in hot loops.
+        const rawData = volume.getRawData();
+        const channels = volume.getChannels();
+        const bytesPerSlice = volume.getBytesPerSlice();
+        const rowStride = width * channels;
+        // Compute per-axis sigma (normalized to voxel units)
+        const sigmaX = spacing ? sigma / spacing[0] : sigma;
+        const sigmaY = spacing ? sigma / spacing[1] : sigma;
+        const sigmaZ = spacing ? sigma / spacing[2] : sigma;
+        // 1. Extract binary float buffer — direct array access
+        const buffer = new Float32Array(totalVoxels);
+        for (let z = 0; z < depth; z++) {
+            const zOffset = z * bytesPerSlice;
+            for (let y = 0; y < height; y++) {
+                const zyOffset = zOffset + y * rowStride;
+                for (let x = 0; x < width; x++) {
+                    const bufIdx = z * height * width + y * width + x;
+                    buffer[bufIdx] = rawData[zyOffset + x * channels] === channel ? 1.0 : 0.0;
+                }
+            }
+        }
+        // 2. Separable Gaussian blur: X → Y → Z
+        const kernelX = GaussianSmoother.generateKernel1D(sigmaX);
+        const kernelY = GaussianSmoother.generateKernel1D(sigmaY);
+        const kernelZ = GaussianSmoother.generateKernel1D(sigmaZ);
+        GaussianSmoother.convolve1D(buffer, width, height, depth, 0, kernelX); // X axis
+        GaussianSmoother.convolve1D(buffer, width, height, depth, 1, kernelY); // Y axis
+        GaussianSmoother.convolve1D(buffer, width, height, depth, 2, kernelZ); // Z axis
+        // 3 & 4. Threshold and write back — direct array access
+        for (let z = 0; z < depth; z++) {
+            const zOffset = z * bytesPerSlice;
+            for (let y = 0; y < height; y++) {
+                const zyOffset = zOffset + y * rowStride;
+                for (let x = 0; x < width; x++) {
+                    const bufIdx = z * height * width + y * width + x;
+                    const smoothed = buffer[bufIdx] >= 0.5 ? 1 : 0;
+                    const rawIdx = zyOffset + x * channels;
+                    const original = rawData[rawIdx];
+                    if (smoothed === 1 && original !== channel) {
+                        // Smoothed region expands into this voxel — overwrite
+                        rawData[rawIdx] = channel;
+                    }
+                    else if (smoothed === 0 && original === channel) {
+                        // Smoothed region retreats — erase
+                        rawData[rawIdx] = 0;
+                    }
+                    // Otherwise leave unchanged
+                }
+            }
+        }
+    }
+    /**
+     * Generate a normalized 1D Gaussian kernel truncated at ±3σ.
+     *
+     * @param sigma Standard deviation (in voxels). Must be > 0.
+     * @returns Normalized Float32Array of odd length.
+     */
+    static generateKernel1D(sigma) {
+        if (sigma <= 0) {
+            return new Float32Array([1.0]);
+        }
+        const radius = Math.ceil(sigma * 3);
+        const size = 2 * radius + 1;
+        const kernel = new Float32Array(size);
+        const twoSigmaSq = 2 * sigma * sigma;
+        let sum = 0;
+        for (let i = 0; i < size; i++) {
+            const x = i - radius;
+            kernel[i] = Math.exp(-(x * x) / twoSigmaSq);
+            sum += kernel[i];
+        }
+        // Normalize
+        for (let i = 0; i < size; i++) {
+            kernel[i] /= sum;
+        }
+        return kernel;
+    }
+    /**
+     * In-place single-axis convolution with zero-padding at boundaries.
+     *
+     * Uses a 3-segment approach: left boundary (with bounds check),
+     * middle interior (branch-free, ~95% of work), right boundary
+     * (with bounds check). This eliminates per-element branching
+     * in the hot inner loop.
+     *
+     * @param data   Flat float buffer (width × height × depth).
+     * @param width  X dimension.
+     * @param height Y dimension.
+     * @param depth  Z dimension.
+     * @param axis   0 = X, 1 = Y, 2 = Z.
+     * @param kernel 1D convolution kernel (odd length).
+     */
+    static convolve1D(data, width, height, depth, axis, kernel) {
+        const kLen = kernel.length;
+        const radius = (kLen - 1) / 2;
+        // Determine the dimension length along the convolution axis
+        // and the stride between consecutive elements along that axis
+        let axisLen;
+        let stride;
+        let outerCount;
+        if (axis === 0) {
+            // X axis: stride = 1, iterate over all (y, z) lines
+            axisLen = width;
+            stride = 1;
+            outerCount = height * depth;
+        }
+        else if (axis === 1) {
+            // Y axis: stride = width, iterate over all (x, z) lines
+            axisLen = height;
+            stride = width;
+            outerCount = width * depth;
+        }
+        else {
+            // Z axis: stride = width * height, iterate over all (x, y) lines
+            axisLen = depth;
+            stride = width * height;
+            outerCount = width * height;
+        }
+        // Precompute middle segment bounds
+        const midStart = radius;
+        const midEnd = axisLen - radius;
+        // Temporary line buffer to avoid read-after-write issues
+        const line = new Float32Array(axisLen);
+        for (let outer = 0; outer < outerCount; outer++) {
+            // Compute the starting index for this line
+            let lineStart;
+            if (axis === 0) {
+                lineStart = outer * width;
+            }
+            else if (axis === 1) {
+                const z = Math.floor(outer / width);
+                const x = outer % width;
+                lineStart = z * width * height + x;
+            }
+            else {
+                lineStart = outer;
+            }
+            // Read the line
+            for (let i = 0; i < axisLen; i++) {
+                line[i] = data[lineStart + i * stride];
+            }
+            // Left boundary segment (i = 0 .. radius-1): lower bound check
+            for (let i = 0; i < midStart; i++) {
+                let sum = 0;
+                for (let k = 0; k < kLen; k++) {
+                    const j = i + k - radius;
+                    if (j >= 0) {
+                        sum += line[j] * kernel[k];
+                    }
+                }
+                data[lineStart + i * stride] = sum;
+            }
+            // Middle segment (i = radius .. axisLen-radius-1): NO bounds check
+            for (let i = midStart; i < midEnd; i++) {
+                let sum = 0;
+                const lineOffset = i - radius;
+                for (let k = 0; k < kLen; k++) {
+                    sum += line[lineOffset + k] * kernel[k];
+                }
+                data[lineStart + i * stride] = sum;
+            }
+            // Right boundary segment (i = axisLen-radius .. axisLen-1): upper bound check
+            for (let i = midEnd; i < axisLen; i++) {
+                let sum = 0;
+                for (let k = 0; k < kLen; k++) {
+                    const j = i + k - radius;
+                    if (j < axisLen) {
+                        sum += line[j] * kernel[k];
+                    }
+                }
+                data[lineStart + i * stride] = sum;
+            }
+        }
+    }
+}
+
 /**
  * Manages layer/channel state: active selection, visibility, and channel colors.
  *
@@ -76976,6 +77182,8 @@ class SliceRenderPipeline extends BaseTool {
      * Then update the changedWidth and changedHeight based on the sizeFactor.
      */
     updateOriginAndChangedWH() {
+        const prevW = this.ctx.nrrd_states.image.originWidth;
+        const prevH = this.ctx.nrrd_states.image.originHeight;
         this.ctx.nrrd_states.image.originWidth =
             this.ctx.protectedData.canvases.originCanvas.width;
         this.ctx.nrrd_states.image.originHeight =
@@ -76984,7 +77192,12 @@ class SliceRenderPipeline extends BaseTool {
         // Setting them here would defeat the sizeChanged detection in resizePaintArea,
         // causing canvas elements to keep stale dimensions after axis switches.
         this.resizePaintArea(this.ctx.nrrd_states.view.sizeFactor);
-        this.resetPaintAreaUIPosition();
+        // Only re-center when origin dimensions changed (e.g. axis switch).
+        // Contrast toggle doesn't change origin size, so skip to preserve user's pan/zoom.
+        if (prevW !== this.ctx.nrrd_states.image.originWidth ||
+            prevH !== this.ctx.nrrd_states.image.originHeight) {
+            this.resetPaintAreaUIPosition();
+        }
     }
     /**
      * Keep all contrast slice index to same.
@@ -77198,7 +77411,7 @@ class NrrdTools {
         // Wire RenderingUtils' setEmptyCanvasSize callback
         this.drawCore.renderer.setEmptyCanvasSize = (axis) => this.setEmptyCanvasSize(axis);
         this.init();
-        this.dragOperator = new DragOperator(this.container, this.state.nrrd_states, this.state.gui_states, this.state.protectedData, this.drawCore.drawingPrameters, this.setSyncsliceNum.bind(this), this.setIsDrawFalse.bind(this), this.flipDisplayImageByAxis.bind(this), this.setEmptyCanvasSize.bind(this), this.drawCore.renderer.getOrCreateSliceBuffer.bind(this.drawCore.renderer), this.drawCore.renderer.renderSliceToCanvas.bind(this.drawCore.renderer));
+        this.dragOperator = new DragOperator(this.container, this.state.nrrd_states, this.state.gui_states, this.state.protectedData, this.drawCore.drawingPrameters, this.setSyncsliceNum.bind(this), this.setIsDrawFalse.bind(this), this.flipDisplayImageByAxis.bind(this), this.setEmptyCanvasSize.bind(this), this.drawCore.renderer.getOrCreateSliceBuffer.bind(this.drawCore.renderer), this.drawCore.renderer.renderSliceToCanvas.bind(this.drawCore.renderer), this.drawCore.renderer.compositeAllLayers.bind(this.drawCore.renderer));
         // Inject EventRouter into DragOperator for centralized event handling
         if (this.drawCore.eventRouter) {
             this.dragOperator.setEventRouter(this.drawCore.eventRouter);
@@ -77517,7 +77730,8 @@ class NrrdTools {
     getPencilColor() {
         return this.state.gui_states.drawing.color;
     }
-    executeAction(action) {
+    executeAction(action, opts) {
+        var _a;
         switch (action) {
             case "undo":
                 this.undo();
@@ -77555,6 +77769,48 @@ class NrrdTools {
                 enableDownload(config);
                 break;
             }
+            case "gaussianSmooth": {
+                const layerId = this.state.gui_states.layerChannel.layer;
+                const channel = this.state.gui_states.layerChannel.activeChannel;
+                const volume = this.drawCore.renderer.getVolumeForLayer(layerId);
+                if (volume && channel > 0) {
+                    const dims = volume.getDimensions();
+                    // 1. Snapshot all Z-slices before mutation (undo support)
+                    const deltas = [];
+                    for (let z = 0; z < dims.depth; z++) {
+                        const sliceData = volume.getSliceUint8(z, "z").data;
+                        const hasChannel = sliceData.some((v) => v === channel);
+                        if (hasChannel) {
+                            deltas.push({
+                                layerId,
+                                axis: "z",
+                                sliceIndex: z,
+                                oldSlice: sliceData.slice(),
+                                newSlice: new Uint8Array(0), // placeholder, filled after smoothing
+                            });
+                        }
+                    }
+                    // 2. Apply smoothing with anisotropic spacing
+                    const spacing = this.state.nrrd_states.image.voxelSpacing;
+                    const spacingTuple = spacing.length >= 3 ? [spacing[0], spacing[1], spacing[2]] : undefined;
+                    const sigma = (_a = opts === null || opts === void 0 ? void 0 : opts.sigma) !== null && _a !== void 0 ? _a : 1.0;
+                    GaussianSmoother.gaussianSmooth3D(volume, channel, sigma, spacingTuple);
+                    // 3. Capture newSlice data after smoothing and push undo group
+                    for (const delta of deltas) {
+                        delta.newSlice = volume.getSliceUint8(delta.sliceIndex, "z").data.slice();
+                    }
+                    if (deltas.length > 0) {
+                        this.drawCore.undoManager.pushGroup(deltas);
+                    }
+                    // 4. Notify backend for each changed slice
+                    for (const delta of deltas) {
+                        const { data: sliceData, width, height } = volume.getSliceUint8(delta.sliceIndex, "z");
+                        this.state.annotationCallbacks.onMaskChanged(sliceData, layerId, channel, delta.sliceIndex, "z", width, height, false);
+                    }
+                    this.reloadMasksFromVolume();
+                }
+                break;
+            }
         }
     }
     // ═══════════════════════════════════════════════════════════════════════════
@@ -78269,7 +78525,7 @@ function evaluateElement(element, weights) {
 }
 
 // import * as kiwrious from "copper3d_plugin_heart_k";
-const REVISION = "v3.2.0-beta";
+const REVISION = "v3.2.1-beta";
 console.log(`%cCopper3D Visualisation %cBeta:${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
 
-export { CHANNEL_COLORS, CHANNEL_HEX_COLORS, CameraViewPoint, Copper3dTrackballControls, MeshNodeTool, NrrdTools, REVISION, addBoxHelper, addLabelToScene, configKiwriousHeart, convert3DPostoScreenPos, convertScreenPosto3DPos, copperMScene, copperMSceneRenderer, copperRenderer, copperRendererOnDemond, copperScene, copperSceneOnDemond, createTexture2D_NRRD, fullScreenListenner, kiwrious, loading, removeGuiFolderChilden, rgbaToCss, rgbaToHex, setHDRFilePath, throttle };
+export { CHANNEL_COLORS, CHANNEL_HEX_COLORS, CameraViewPoint, Copper3dTrackballControls, GaussianSmoother, MeshNodeTool, NrrdTools, REVISION, addBoxHelper, addLabelToScene, configKiwriousHeart, convert3DPostoScreenPos, convertScreenPosto3DPos, copperMScene, copperMSceneRenderer, copperRenderer, copperRendererOnDemond, copperScene, copperSceneOnDemond, createTexture2D_NRRD, fullScreenListenner, kiwrious, loading, removeGuiFolderChilden, rgbaToCss, rgbaToHex, setHDRFilePath, throttle };