copper3d 3.2.0 → 3.3.0

package/dist/bundle.umd.js

@@ -49812,8 +49812,8 @@ void main() {
 	            this.renderer.setSize(this.container.clientWidth, this.container.clientHeight);
 	        };
 	        this.renderer = renderer;
-	        this.ambientLight = new AmbientLight(0x202020, 0.3);
-	        this.directionalLight = new DirectionalLight(0xffffff, 0.3);
+	        this.ambientLight = new AmbientLight(0x606060, 0.8);
+	        this.directionalLight = new DirectionalLight(0xffffff, 1.0);
 	        if (!(opt === null || opt === void 0 ? void 0 : opt.alpha)) {
 	            this.vignette = createBackground({
 	                aspect: this.container.clientWidth / this.container.clientHeight,
@@ -49897,17 +49897,31 @@ void main() {
 	        this.scene.add(obj);
 	    }
 	    addLights() {
-	        const hemiLight = new HemisphereLight();
+	        // Hemisphere light: sky/ground for broad ambient fill
+	        const hemiLight = new HemisphereLight(0xddeeff, 0x0f0e0d, 0.6);
 	        hemiLight.name = "hemi_light";
 	        this.scene.add(hemiLight);
+	        // Main key light — front-right, slightly above
 	        this.ambientLight.name = "ambient_light";
 	        this.directionalLight.name = "main_light";
-	        this.directionalLight.position.set(0.5, 0, 0.866);
+	        this.directionalLight.position.set(0.5, 0.5, 0.866);
 	        this.camera.add(this.ambientLight);
 	        this.camera.add(this.directionalLight);
+	        // Fill light — opposite side to soften shadows
+	        const fillLight = new DirectionalLight(0xffffff, 0.4);
+	        fillLight.name = "fill_light";
+	        fillLight.position.set(-0.5, -0.2, -0.866);
+	        this.camera.add(fillLight);
+	        // Top light — illuminates the top surface that key/fill lights miss
+	        const topLight = new DirectionalLight(0xffffff, 0.5);
+	        topLight.name = "top_light";
+	        topLight.position.set(0, 1, 0.2);
+	        this.camera.add(topLight);
 	        this.lights.push(this.ambientLight);
 	        this.lights.push(this.directionalLight);
 	        this.lights.push(hemiLight);
+	        this.lights.push(fillLight);
+	        this.lights.push(topLight);
 	    }
 	    removeLights() {
 	        if (this.lights) {
@@ -50611,6 +50625,8 @@ void main() {
 	        }
 	        // this.renderer.useLegacyLights = true;
 	        this.renderer.outputColorSpace = SRGBColorSpace;
+	        this.renderer.toneMapping = ACESFilmicToneMapping;
+	        this.renderer.toneMappingExposure = 1.8;
 	        this.gui = null;
 	        this.stats = new Stats$1();
 	        this.pmremGenerator = new PMREMGenerator(this.renderer);
@@ -50636,9 +50652,9 @@ void main() {
 	            grid: false,
 	            // Lights
 	            addLights: true,
-	            exposure: 1.0,
-	            ambientIntensity: 0.3,
-	            ambientColor: 0x202020,
+	            exposure: 1.8,
+	            ambientIntensity: 0.8,
+	            ambientColor: 0x606060,
 	            directIntensity: 0.8 * Math.PI,
 	            directColor: 0xffffff,
 	            bgColor1: "#5454ad",
@@ -59435,12 +59451,25 @@ void main() {
 	        const loader = copperGltfLoader(this.renderer);
 	        loader.load(url, (glb) => {
 	            const content = glb.scene;
+	            // Enhance PBR materials for better visual quality
+	            if ((opts === null || opts === void 0 ? void 0 : opts.enhanceMaterial) !== false) {
+	                content.traverse((child) => {
+	                    if (child.isMesh) {
+	                        const mesh = child;
+	                        const mat = mesh.material;
+	                        if (mat.isMeshStandardMaterial) {
+	                            mat.roughness = Math.min(mat.roughness, 0.35);
+	                            mat.metalness = Math.max(mat.metalness, 0.05);
+	                            mat.envMapIntensity = 1.2;
+	                            mat.side = DoubleSide;
+	                            mat.needsUpdate = true;
+	                        }
+	                    }
+	                });
+	            }
 	            this.scene.add(content);
 	            !!callback && callback(content);
-	        }, // called when loading is in progresses
-	        (xhr) => { }, 
-	        // called when loading has errors
-	        (error) => {
+	        }, (xhr) => { }, (error) => {
 	            console.log("An error happened: ", error);
 	        });
 	    }
@@ -71395,6 +71424,17 @@ void main() {
 	    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.
 	     *
@@ -73212,8 +73252,8 @@ void main() {
 	                        }
 	                    }
 	                }
-	                // 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) {
@@ -73222,23 +73262,6 @@ void main() {
 	            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) {
@@ -73280,7 +73303,7 @@ void main() {
 	}
 
 	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,
@@ -73316,6 +73339,7 @@ void main() {
 	        this.setEmptyCanvasSize = setEmptyCanvasSize;
 	        this.getOrCreateSliceBuffer = getOrCreateSliceBuffer;
 	        this.renderSliceToCanvas = renderSliceToCanvas;
+	        this.compositeAllLayers = compositeAllLayers;
 	        this.showDragNumberDiv = createShowSliceNumberDiv();
 	        this.init();
 	    }
@@ -73341,6 +73365,7 @@ void main() {
 	            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);
 	    }
@@ -76468,6 +76493,216 @@ void main() {
 	    }
 	}
 
+	/**
+	 * 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.
 	 *
@@ -76984,6 +77219,8 @@ void main() {
 	     * 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 =
@@ -76992,7 +77229,12 @@ void main() {
 	        // 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.
@@ -77206,7 +77448,7 @@ void main() {
 	        // 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);
@@ -77525,7 +77767,8 @@ void main() {
 	    getPencilColor() {
 	        return this.state.gui_states.drawing.color;
 	    }
-	    executeAction(action) {
+	    executeAction(action, opts) {
+	        var _a;
 	        switch (action) {
 	            case "undo":
 	                this.undo();
@@ -77563,6 +77806,48 @@ void main() {
 	                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;
+	            }
 	        }
 	    }
 	    // ═══════════════════════════════════════════════════════════════════════════
@@ -78277,13 +78562,14 @@ void main() {
 	}
 
 	// import * as kiwrious from "copper3d_plugin_heart_k";
-	const REVISION = "v3.2.0-beta";
+	const REVISION = "v3.3.0-beta";
 	console.log(`%cCopper3D Visualisation %cBeta:${REVISION}`, "padding: 3px;color:white; background:#023047", "padding: 3px;color:white; background:#f50a25");
 
 	exports.CHANNEL_COLORS = CHANNEL_COLORS;
 	exports.CHANNEL_HEX_COLORS = CHANNEL_HEX_COLORS;
 	exports.CameraViewPoint = CameraViewPoint;
 	exports.Copper3dTrackballControls = Copper3dTrackballControls;
+	exports.GaussianSmoother = GaussianSmoother;
 	exports.MeshNodeTool = MeshNodeTool;
 	exports.NrrdTools = NrrdTools;
 	exports.REVISION = REVISION;

package/dist/index.d.ts

@@ -13,6 +13,7 @@ import { createTexture2D_NRRD } from "./Utils/texture2d";
 import { configKiwriousHeart } from "./Utils/kiwrious/configKiwrious";
 import kiwrious from "./Utils/kiwrious/configKiwrious";
 import { NrrdTools } from "./Utils/segmentation/NrrdTools";
+import { GaussianSmoother } from "./Utils/segmentation/core/GaussianSmoother";
 import { Copper3dTrackballControls } from "./Controls/Copper3dTrackballControls";
 import { MeshNodeTool } from "./Utils/MeshNodeTool";
 import { removeGuiFolderChilden } from "./Utils/segmentation/coreTools/gui";
@@ -24,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.2.0-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, };
+export declare const REVISION = "v3.3.0-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

@@ -14,13 +14,14 @@ import { createTexture2D_NRRD } from "./Utils/texture2d";
 import { configKiwriousHeart } from "./Utils/kiwrious/configKiwrious";
 import kiwrious from "./Utils/kiwrious/configKiwrious";
 import { NrrdTools } from "./Utils/segmentation/NrrdTools";
+import { GaussianSmoother } from "./Utils/segmentation/core/GaussianSmoother";
 // Phase 7: Segmentation Module - Unified exports
 import { Copper3dTrackballControls } from "./Controls/Copper3dTrackballControls";
 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.2.0-beta";
+export const REVISION = "v3.3.0-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, };
+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/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EACL,eAAe,EAGf,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAY,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,QAAQ,MAAM,iCAAiC,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,iDAAiD;AAEjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEjF,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAiB5E,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG3G,OAAO,iBAAiB,CAAC;AAEzB,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC;AAEtC,OAAO,CAAC,GAAG,CACT,mCAAmC,QAAQ,EAAE,EAC7C,8CAA8C,EAC9C,8CAA8C,CAC/C,CAAC;AAEF,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,QAAQ,EACR,SAAS,EACT,OAAO,EACP,yBAAyB,EACzB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,SAAS,EACT,SAAS,GACV,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EACL,eAAe,EAGf,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAY,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,QAAQ,MAAM,iCAAiC,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,iDAAiD;AAEjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEjF,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAiB5E,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG3G,OAAO,iBAAiB,CAAC;AAEzB,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC;AAEtC,OAAO,CAAC,GAAG,CACT,mCAAmC,QAAQ,EAAE,EAC7C,8CAA8C,EAC9C,8CAA8C,CAC/C,CAAC;AAEF,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,QAAQ,EACR,SAAS,EACT,OAAO,EACP,yBAAyB,EACzB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,SAAS,EACT,SAAS,EACT,gBAAgB,GACjB,CAAC"}

package/dist/types/Scene/copperScene.d.ts

@@ -18,6 +18,7 @@ export declare class copperScene extends baseScene {
     loadGltf(url: string, callback?: (content: THREE.Group) => void): void;
     loadPureGLB(url: string, callback?: (mesh: THREE.Group) => void, opts?: {
         color: string;
+        enhanceMaterial?: boolean;
     }): void;
     loadVtk(url: string): void;
     loadVtks(models: Array<vtkModels>): void;

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

@@ -18,9 +18,10 @@ export declare class DragOperator {
     private setEmptyCanvasSize;
     private getOrCreateSliceBuffer;
     private renderSliceToCanvas;
+    private compositeAllLayers;
     private refreshSphereOverlayCb;
     private eventRouter;
-    constructor(container: HTMLElement, nrrd_sates: NrrdState, gui_states: GuiState, protectedData: IProtected, drawingPrameters: IDrawingEvents, setSyncsliceNum: () => void, setIsDrawFalse: (target: number) => void, flipDisplayImageByAxis: () => void, setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void, getOrCreateSliceBuffer: (axis: "x" | "y" | "z") => ImageData | null, renderSliceToCanvas: (layer: string, axis: "x" | "y" | "z", sliceIndex: number, buffer: ImageData, targetCtx: CanvasRenderingContext2D, scaledWidth: number, scaledHeight: number) => void);
+    constructor(container: HTMLElement, nrrd_sates: NrrdState, gui_states: GuiState, protectedData: IProtected, drawingPrameters: IDrawingEvents, setSyncsliceNum: () => void, setIsDrawFalse: (target: number) => void, flipDisplayImageByAxis: () => void, setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void, getOrCreateSliceBuffer: (axis: "x" | "y" | "z") => ImageData | null, renderSliceToCanvas: (layer: string, axis: "x" | "y" | "z", sliceIndex: number, buffer: ImageData, targetCtx: CanvasRenderingContext2D, scaledWidth: number, scaledHeight: number) => void, compositeAllLayers: () => void);
     private init;
     setShowDragNumberDiv(sliceIndexContainer: HTMLDivElement): void;
     /**

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

@@ -88,7 +88,9 @@ export declare class NrrdTools {
     getSliderMeta(key: string): IGuiMeta | null;
     setPencilColor(hex: string): void;
     getPencilColor(): string;
-    executeAction(action: "undo" | "redo" | "clearActiveSliceMask" | "clearActiveLayerMask" | "resetZoom" | "downloadCurrentMask"): void;
+    executeAction(action: "undo" | "redo" | "clearActiveSliceMask" | "clearActiveLayerMask" | "resetZoom" | "downloadCurrentMask" | "gaussianSmooth", opts?: {
+        sigma?: number;
+    }): void;
     undo(): void;
     redo(): void;
     enterKeyboardConfig(): void;

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

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+import type { MaskVolume } from './MaskVolume';
+export declare 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: MaskVolume, channel: number, sigma?: number, spacing?: [number, number, number]): void;
+    /**
+     * 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: number): Float32Array;
+    /**
+     * 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).
+     */
+    private static convolve1D;
+}

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

@@ -250,6 +250,15 @@ export declare class MaskVolume {
      * @returns Channel count (≥ 1).
      */
     getChannels(): number;
+    /**
+     * 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(): number;
     /**
      * Return total memory used by the backing buffer, in bytes.
      *

package/dist/types/Utils/segmentation/tools/DragSliceTool.d.ts

@@ -26,10 +26,6 @@ export declare class DragSliceTool extends BaseTool {
     setShowDragNumberDiv(div: HTMLDivElement): void;
     updateIndex(move: number): void;
     private drawDragSlice;
-    /**
-     * Composite all visible layer canvases to the master display canvas.
-     */
-    private compositeAllLayers;
     private cleanCanvases;
     updateShowNumDiv(contrastNum: number): void;
     updateCurrentContrastSlice(): any;