@cornerstonejs/tools 3.1.0 → 3.1.1

package/dist/esm/tools/annotation/RegionSegmentPlusTool.js

@@ -6,11 +6,12 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            isPartialVolume: false,
             positiveSeedVariance: 0.4,
             negativeSeedVariance: 0.9,
             subVolumePaddingPercentage: 0.1,
             islandRemoval: {
-                enabled: true,
+                enabled: false,
             },
         },
     }) {
@@ -41,7 +42,7 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         };
     }
     async getGrowCutLabelmap(growCutData) {
-        const { segmentation: { referencedVolumeId }, renderingEngineId, viewportId, worldPoint, options, } = growCutData;
+        const { segmentation: { referencedVolumeId, labelmapVolumeId }, renderingEngineId, viewportId, worldPoint, options, } = growCutData;
         const renderingEngine = getRenderingEngine(renderingEngineId);
         const viewport = renderingEngine.getViewport(viewportId);
         const { subVolumePaddingPercentage } = this.configuration;
@@ -49,7 +50,11 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
             ...options,
             subVolumePaddingPercentage,
         };
-        return growCut.runOneClickGrowCut(referencedVolumeId, worldPoint, viewport, mergedOptions);
+        return growCut.runOneClickGrowCut({
+            referencedVolumeId,
+            worldPosition: worldPoint,
+            options: mergedOptions,
+        });
     }
 }
 export default RegionSegmentPlusTool;

package/dist/esm/tools/annotation/RegionSegmentTool.js

@@ -11,6 +11,7 @@ class RegionSegmentTool extends GrowCutBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            isPartialVolume: true,
             positiveSeedVariance: 0.5,
             negativeSeedVariance: 0.9,
         },

package/dist/esm/tools/annotation/WholeBodySegmentTool.js

@@ -14,6 +14,7 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            isPartialVolume: true,
             positivePixelRange: POSITIVE_PIXEL_RANGE,
             negativePixelRange: NEGATIVE_PIXEL_RANGE,
             islandRemoval: {

package/dist/esm/tools/base/GrowCutBaseTool.d.ts

@@ -33,6 +33,7 @@ declare class GrowCutBaseTool extends BaseTool {
     refresh(): void;
     protected getGrowCutLabelmap(_growCutData: GrowCutToolData): Promise<Types.IImageVolume>;
     protected runGrowCut(): Promise<void>;
+    protected applyPartialGrowCutLabelmap(segmentationId: string, segmentIndex: number, targetLabelmap: Types.IImageVolume, sourceLabelmap: Types.IImageVolume): void;
     protected applyGrowCutLabelmap(segmentationId: string, segmentIndex: number, targetLabelmap: Types.IImageVolume, sourceLabelmap: Types.IImageVolume): void;
     private _runLastCommand;
     protected getLabelmapSegmentationData(viewport: Types.IViewport): Promise<{
@@ -41,6 +42,7 @@ declare class GrowCutBaseTool extends BaseTool {
         labelmapVolumeId: string;
         referencedVolumeId: string;
     }>;
+    private _createFakeVolume;
     protected _isOrthogonalView(viewport: Types.IViewport, referencedVolumeId: string): boolean;
     protected getRemoveIslandData(_growCutData: GrowCutToolData): RemoveIslandData;
     private _removeIslands;

package/dist/esm/tools/base/GrowCutBaseTool.js

@@ -1,10 +1,12 @@
-import { getEnabledElement, utilities as csUtils, cache, getRenderingEngine, StackViewport, } from '@cornerstonejs/core';
+import { getEnabledElement, utilities as csUtils, cache, getRenderingEngine, volumeLoader, imageLoader, ImageVolume, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { SegmentationRepresentations } from '../../enums';
 import { segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 import IslandRemoval from '../../utilities/segmentation/islandRemoval';
+import { getOrCreateSegmentationVolume } from '../../utilities/segmentation';
+import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 const { transformWorldToIndex, transformIndexToWorld } = csUtils;
 class GrowCutBaseTool extends BaseTool {
     static { this.lastGrowCutCommand = null; }
@@ -90,7 +92,11 @@ class GrowCutBaseTool extends BaseTool {
                 },
             });
             const growcutLabelmap = await this.getGrowCutLabelmap(updatedGrowCutData);
-            this.applyGrowCutLabelmap(segmentationId, segmentIndex, labelmap, growcutLabelmap);
+            const { isPartialVolume } = config;
+            const fn = isPartialVolume
+                ? this.applyPartialGrowCutLabelmap
+                : this.applyGrowCutLabelmap;
+            fn(segmentationId, segmentIndex, labelmap, growcutLabelmap);
             this._removeIslands(growCutData);
         };
         await growCutCommand();
@@ -99,7 +105,7 @@ class GrowCutBaseTool extends BaseTool {
         }
         this.growCutData = null;
     }
-    applyGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {
+    applyPartialGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {
         const srcLabelmapData = sourceLabelmap.voxelManager.getCompleteScalarDataArray();
         const tgtVoxelManager = targetLabelmap.voxelManager;
         const [srcColumns, srcRows, srcNumSlices] = sourceLabelmap.dimensions;
@@ -124,6 +130,16 @@ class GrowCutBaseTool extends BaseTool {
         }
         triggerSegmentationDataModified(segmentationId);
     }
+    applyGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {
+        const tgtVoxelManager = targetLabelmap.voxelManager;
+        const srcVoxelManager = sourceLabelmap.voxelManager;
+        srcVoxelManager.forEach(({ value, index }) => {
+            if (value === segmentIndex) {
+                tgtVoxelManager.setAtIndex(index, value);
+            }
+        });
+        triggerSegmentationDataModified(segmentationId);
+    }
     _runLastCommand({ shrinkExpandAmount = 0 } = {}) {
         const cmd = GrowCutBaseTool.lastGrowCutCommand;
         if (cmd) {
@@ -139,9 +155,39 @@ class GrowCutBaseTool extends BaseTool {
         const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
         const { representationData } = segmentationState.getSegmentation(segmentationId);
         const labelmapData = representationData[SegmentationRepresentations.Labelmap];
-        const { volumeId: labelmapVolumeId, referencedVolumeId } = labelmapData;
+        let { volumeId: labelmapVolumeId, referencedVolumeId } = labelmapData;
         if (!labelmapVolumeId) {
-            throw new Error('Labelmap volume id not found - not implemented');
+            const referencedImageIds = viewport.getImageIds();
+            if (!csUtils.isValidVolume(referencedImageIds)) {
+                const currentImageId = viewport.getCurrentImageId();
+                const currentImage = cache.getImage(currentImageId);
+                const fakeImage = imageLoader.createAndCacheDerivedImage(currentImageId);
+                const fakeVolume = this._createFakeVolume([
+                    currentImage.imageId,
+                    fakeImage.imageId,
+                ]);
+                referencedVolumeId = fakeVolume.volumeId;
+                const currentLabelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+                const fakeDerivedImage = imageLoader.createAndCacheDerivedImage(currentLabelmapImageId);
+                const fakeLabelmapVolume = this._createFakeVolume([
+                    currentLabelmapImageId,
+                    fakeDerivedImage.imageId,
+                ]);
+                labelmapVolumeId = fakeLabelmapVolume.volumeId;
+            }
+            else {
+                const segVolume = getOrCreateSegmentationVolume(segmentationId);
+                labelmapVolumeId = segVolume.volumeId;
+            }
+        }
+        if (!referencedVolumeId) {
+            const { imageIds: segImageIds } = labelmapData;
+            const referencedImageIds = segImageIds.map((imageId) => cache.getImage(imageId).referencedImageId);
+            const volumeId = cache.generateVolumeId(referencedImageIds);
+            const imageVolume = cache.getVolume(volumeId);
+            referencedVolumeId = imageVolume
+                ? imageVolume.volumeId
+                : (await volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, referencedImageIds)).volumeId;
         }
         return {
             segmentationId,
@@ -150,6 +196,32 @@ class GrowCutBaseTool extends BaseTool {
             referencedVolumeId,
         };
     }
+    _createFakeVolume(imageIds) {
+        const volumeId = cache.generateVolumeId(imageIds);
+        const cachedVolume = cache.getVolume(volumeId);
+        if (cachedVolume) {
+            return cachedVolume;
+        }
+        const volumeProps = csUtils.generateVolumePropsFromImageIds(imageIds, volumeId);
+        const spacing = volumeProps.spacing;
+        if (spacing[2] === 0) {
+            spacing[2] = 1;
+        }
+        const derivedVolume = new ImageVolume({
+            volumeId,
+            dataType: volumeProps.dataType,
+            metadata: structuredClone(volumeProps.metadata),
+            dimensions: volumeProps.dimensions,
+            spacing: volumeProps.spacing,
+            origin: volumeProps.origin,
+            direction: volumeProps.direction,
+            referencedVolumeId: volumeProps.referencedVolumeId,
+            imageIds: volumeProps.imageIds,
+            referencedImageIds: volumeProps.referencedImageIds,
+        });
+        cache.putVolumeSync(volumeId, derivedVolume);
+        return derivedVolume;
+    }
     _isOrthogonalView(viewport, referencedVolumeId) {
         const volume = cache.getVolume(referencedVolumeId);
         const volumeImageData = volume.imageData;

package/dist/esm/utilities/segmentation/growCut/growCutShader.d.ts

@@ -1,2 +1,2 @@
-declare const shader = "\nconst MAX_STRENGTH = 65535f;\n\n// Workgroup soze - X*Y*Z must be multiple of 32 for better performance\n// otherwise warps are sub allocated and some threads will not process anything\noverride workGroupSizeX = 1u;\noverride workGroupSizeY = 1u;\noverride workGroupSizeZ = 1u;\n\n// Compare the current voxel to neighbors using a 9x9x9 window\noverride windowSize = 9i;\n\nstruct Params {\n  size: vec3u,\n  iteration: u32,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage> volumePixelData: array<f32>;\n@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;\n@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;\n@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;\n@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;\n@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;\n\nfn getPixelIndex(ijkPos: vec3u) -> u32 {\n  let numPixelsPerSlice = params.size.x * params.size.y;\n  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;\n}\n\n@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)\nfn main(\n  @builtin(global_invocation_id) globalId: vec3u,\n) {\n  // Make sure it will not get out of bounds for volume with sizes that\n  // are not multiple of workGroupSize\n  if (\n    globalId.x >= params.size.x ||\n    globalId.y >= params.size.y ||\n    globalId.z >= params.size.z\n  ) {\n    return;\n  }\n\n  let currentCoord = vec3i(globalId);\n  let currentPixelIndex = getPixelIndex(globalId);\n\n  let numPixels = arrayLength(&volumePixelData);\n  let currentPixelValue = volumePixelData[currentPixelIndex];\n\n  if (params.iteration == 0) {\n    // All non-zero initial labels are given maximum strength\n    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);\n    return;\n  }\n\n  // It should at least copy the values from previous state\n  var newLabel = prevLabelmap[currentPixelIndex];\n  var newStrength = prevStrengthData[currentPixelIndex];\n\n  let window = i32(ceil(f32(windowSize - 1) * .5));\n  let minWindow = -1i * window;\n  let maxWindow = 1i * window;\n\n  for (var k = minWindow; k <= maxWindow; k++) {\n    for (var j = minWindow; j <= maxWindow; j++) {\n      for (var i = minWindow; i <= maxWindow; i++) {\n        // Skip current voxel\n        if (i == 0 && j == 0 && k == 0) {\n          continue;\n        }\n\n        let neighborCoord = currentCoord + vec3i(i, j, k);\n\n        //  Boundary conditions. Do not grow outside of the volume\n        if (\n          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||\n          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||\n          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)\n        ) {\n          continue;\n        }\n\n        let neighborIndex = getPixelIndex(vec3u(neighborCoord));\n        let neighborPixelValue = volumePixelData[neighborIndex];\n        let prevNeighborStrength = prevStrengthData[neighborIndex];\n        let strengthCost = abs(neighborPixelValue - currentPixelValue);\n        let takeoverStrength = prevNeighborStrength - strengthCost;\n\n        if (takeoverStrength > newStrength) {\n          newLabel = prevLabelmap[neighborIndex];\n          newStrength = takeoverStrength;\n        }\n      }\n    }\n  }\n\n  if (labelmap[currentPixelIndex] != newLabel) {\n    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);\n  }\n\n  labelmap[currentPixelIndex] = newLabel;\n  strengthData[currentPixelIndex] = newStrength;\n}\n";
+declare const shader = "\nconst MAX_STRENGTH = 65535f;\n\n// Workgroup size - X*Y*Z must be multiple of 32 for better performance\noverride workGroupSizeX = 1u;\noverride workGroupSizeY = 1u;\noverride workGroupSizeZ = 1u;\n\n// Compare the current voxel to neighbors using a 9x9x9 window\noverride windowSize = 9i;\n\nstruct Params {\n  size: vec3u,\n  iteration: u32,\n}\n\n// New structure to track bounds of modified voxels\nstruct Bounds {\n  minX: atomic<i32>,\n  minY: atomic<i32>,\n  minZ: atomic<i32>,\n  maxX: atomic<i32>,\n  maxY: atomic<i32>,\n  maxZ: atomic<i32>,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage> volumePixelData: array<f32>;\n@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;\n@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;\n@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;\n@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;\n@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;\n@group(0) @binding(7) var<storage, read_write> modifiedBounds: Bounds;\n\nfn getPixelIndex(ijkPos: vec3u) -> u32 {\n  let numPixelsPerSlice = params.size.x * params.size.y;\n  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;\n}\n\nfn updateBounds(position: vec3i) {\n  // Atomically update min bounds (use min operation)\n  let oldMinX = atomicMin(&modifiedBounds.minX, position.x);\n  let oldMinY = atomicMin(&modifiedBounds.minY, position.y);\n  let oldMinZ = atomicMin(&modifiedBounds.minZ, position.z);\n\n  // Atomically update max bounds (use max operation)\n  let oldMaxX = atomicMax(&modifiedBounds.maxX, position.x);\n  let oldMaxY = atomicMax(&modifiedBounds.maxY, position.y);\n  let oldMaxZ = atomicMax(&modifiedBounds.maxZ, position.z);\n}\n\n@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)\nfn main(\n  @builtin(global_invocation_id) globalId: vec3u,\n) {\n  // Make sure it will not get out of bounds for volume with sizes that\n  // are not multiple of workGroupSize\n  if (\n    globalId.x >= params.size.x ||\n    globalId.y >= params.size.y ||\n    globalId.z >= params.size.z\n  ) {\n    return;\n  }\n\n  // Initialize bounds for the first iteration\n  if (params.iteration == 0 && globalId.x == 0 && globalId.y == 0 && globalId.z == 0) {\n    // Initialize to opposite extremes to ensure any update will improve the bounds\n    atomicStore(&modifiedBounds.minX, i32(params.size.x));\n    atomicStore(&modifiedBounds.minY, i32(params.size.y));\n    atomicStore(&modifiedBounds.minZ, i32(params.size.z));\n    atomicStore(&modifiedBounds.maxX, -1);\n    atomicStore(&modifiedBounds.maxY, -1);\n    atomicStore(&modifiedBounds.maxZ, -1);\n  }\n\n  let currentCoord = vec3i(globalId);\n  let currentPixelIndex = getPixelIndex(globalId);\n\n  let numPixels = arrayLength(&volumePixelData);\n  let currentPixelValue = volumePixelData[currentPixelIndex];\n\n  if (params.iteration == 0) {\n    // All non-zero initial labels are given maximum strength\n    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);\n\n    // Update bounds for non-zero initial labels\n    if (labelmap[currentPixelIndex] != 0) {\n      updateBounds(currentCoord);\n    }\n    return;\n  }\n\n  // It should at least copy the values from previous state\n  var newLabel = prevLabelmap[currentPixelIndex];\n  var newStrength = prevStrengthData[currentPixelIndex];\n\n  let window = i32(ceil(f32(windowSize - 1) * .5));\n  let minWindow = -1i * window;\n  let maxWindow = 1i * window;\n\n  for (var k = minWindow; k <= maxWindow; k++) {\n    for (var j = minWindow; j <= maxWindow; j++) {\n      for (var i = minWindow; i <= maxWindow; i++) {\n        // Skip current voxel\n        if (i == 0 && j == 0 && k == 0) {\n          continue;\n        }\n\n        let neighborCoord = currentCoord + vec3i(i, j, k);\n\n        //  Boundary conditions. Do not grow outside of the volume\n        if (\n          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||\n          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||\n          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)\n        ) {\n          continue;\n        }\n\n        let neighborIndex = getPixelIndex(vec3u(neighborCoord));\n        let neighborPixelValue = volumePixelData[neighborIndex];\n        let prevNeighborStrength = prevStrengthData[neighborIndex];\n        let strengthCost = abs(neighborPixelValue - currentPixelValue);\n        let takeoverStrength = prevNeighborStrength - strengthCost;\n\n        if (takeoverStrength > newStrength) {\n          newLabel = prevLabelmap[neighborIndex];\n          newStrength = takeoverStrength;\n        }\n      }\n    }\n  }\n\n  if (labelmap[currentPixelIndex] != newLabel) {\n    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);\n\n    // Update bounds for modified voxels\n    updateBounds(currentCoord);\n  }\n\n  labelmap[currentPixelIndex] = newLabel;\n  strengthData[currentPixelIndex] = newStrength;\n}\n";
 export default shader;

package/dist/esm/utilities/segmentation/growCut/growCutShader.js

@@ -1,8 +1,7 @@
 const shader = `
 const MAX_STRENGTH = 65535f;
 
-// Workgroup soze - X*Y*Z must be multiple of 32 for better performance
-// otherwise warps are sub allocated and some threads will not process anything
+// Workgroup size - X*Y*Z must be multiple of 32 for better performance
 override workGroupSizeX = 1u;
 override workGroupSizeY = 1u;
 override workGroupSizeZ = 1u;
@@ -15,6 +14,16 @@ struct Params {
   iteration: u32,
 }
 
+// New structure to track bounds of modified voxels
+struct Bounds {
+  minX: atomic<i32>,
+  minY: atomic<i32>,
+  minZ: atomic<i32>,
+  maxX: atomic<i32>,
+  maxY: atomic<i32>,
+  maxZ: atomic<i32>,
+}
+
 @group(0) @binding(0) var<uniform> params: Params;
 @group(0) @binding(1) var<storage> volumePixelData: array<f32>;
 @group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;
@@ -22,12 +31,25 @@ struct Params {
 @group(0) @binding(4) var<storage> prevLabelmap: array<u32>;
 @group(0) @binding(5) var<storage> prevStrengthData: array<f32>;
 @group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;
+@group(0) @binding(7) var<storage, read_write> modifiedBounds: Bounds;
 
 fn getPixelIndex(ijkPos: vec3u) -> u32 {
   let numPixelsPerSlice = params.size.x * params.size.y;
   return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;
 }
 
+fn updateBounds(position: vec3i) {
+  // Atomically update min bounds (use min operation)
+  let oldMinX = atomicMin(&modifiedBounds.minX, position.x);
+  let oldMinY = atomicMin(&modifiedBounds.minY, position.y);
+  let oldMinZ = atomicMin(&modifiedBounds.minZ, position.z);
+
+  // Atomically update max bounds (use max operation)
+  let oldMaxX = atomicMax(&modifiedBounds.maxX, position.x);
+  let oldMaxY = atomicMax(&modifiedBounds.maxY, position.y);
+  let oldMaxZ = atomicMax(&modifiedBounds.maxZ, position.z);
+}
+
 @compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)
 fn main(
   @builtin(global_invocation_id) globalId: vec3u,
@@ -42,6 +64,17 @@ fn main(
     return;
   }
 
+  // Initialize bounds for the first iteration
+  if (params.iteration == 0 && globalId.x == 0 && globalId.y == 0 && globalId.z == 0) {
+    // Initialize to opposite extremes to ensure any update will improve the bounds
+    atomicStore(&modifiedBounds.minX, i32(params.size.x));
+    atomicStore(&modifiedBounds.minY, i32(params.size.y));
+    atomicStore(&modifiedBounds.minZ, i32(params.size.z));
+    atomicStore(&modifiedBounds.maxX, -1);
+    atomicStore(&modifiedBounds.maxY, -1);
+    atomicStore(&modifiedBounds.maxZ, -1);
+  }
+
   let currentCoord = vec3i(globalId);
   let currentPixelIndex = getPixelIndex(globalId);
 
@@ -51,6 +84,11 @@ fn main(
   if (params.iteration == 0) {
     // All non-zero initial labels are given maximum strength
     strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);
+
+    // Update bounds for non-zero initial labels
+    if (labelmap[currentPixelIndex] != 0) {
+      updateBounds(currentCoord);
+    }
     return;
   }
 
@@ -97,6 +135,9 @@ fn main(
 
   if (labelmap[currentPixelIndex] != newLabel) {
     atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);
+
+    // Update bounds for modified voxels
+    updateBounds(currentCoord);
   }
 
   labelmap[currentPixelIndex] = newLabel;

package/dist/esm/utilities/segmentation/growCut/runGrowCut.js

@@ -23,7 +23,8 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
         labelmap.dimensions[2] !== numSlices) {
         throw new Error('Volume and labelmap must have the same size');
     }
-    const numIterations = Math.floor(Math.sqrt(rows ** 2 + columns ** 2 + numSlices ** 2) / 2);
+    let numIterations = Math.floor(Math.sqrt(rows ** 2 + columns ** 2 + numSlices ** 2) / 2);
+    numIterations = Math.min(numIterations, 500);
     const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
     let volumePixelData = volume.voxelManager.getCompleteScalarDataArray();
     if (!(volumePixelData instanceof Float32Array)) {
@@ -37,6 +38,7 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
     const device = await adapter.requestDevice({ requiredLimits });
     const BUFFER_SIZE = volumePixelData.byteLength;
     const UPDATED_VOXELS_COUNTER_BUFFER_SIZE = numIterations * Uint32Array.BYTES_PER_ELEMENT;
+    const BOUNDS_BUFFER_SIZE = 6 * Int32Array.BYTES_PER_ELEMENT;
     const shaderModule = device.createShaderModule({
         code: shaderCode,
     });
@@ -78,6 +80,21 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
             GPUBufferUsage.COPY_SRC |
             GPUBufferUsage.COPY_DST,
     });
+    const gpuBoundsBuffer = device.createBuffer({
+        size: BOUNDS_BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST,
+    });
+    const initialBounds = new Int32Array([
+        columns,
+        rows,
+        numSlices,
+        -1,
+        -1,
+        -1,
+    ]);
+    device.queue.writeBuffer(gpuBoundsBuffer, 0, initialBounds);
     const bindGroupLayout = device.createBindGroupLayout({
         entries: [
             {
@@ -129,6 +146,13 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
                     type: 'storage',
                 },
             },
+            {
+                binding: 7,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
         ],
     });
     const bindGroups = [0, 1].map((i) => {
@@ -181,6 +205,12 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
                         buffer: gpuCounterBuffer,
                     },
                 },
+                {
+                    binding: 7,
+                    resource: {
+                        buffer: gpuBoundsBuffer,
+                    },
+                },
             ],
         });
     });
@@ -208,10 +238,6 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
         size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
         usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
     });
-    const labelmapStagingBufferTemp = device.createBuffer({
-        size: BUFFER_SIZE,
-        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-    });
     const limitProcessingTime = maxProcessingTime
         ? performance.now() + maxProcessingTime
         : 0;
@@ -257,13 +283,34 @@ async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT
         size: BUFFER_SIZE,
         usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
     });
+    const boundsStagingBuffer = device.createBuffer({
+        size: BOUNDS_BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
     commandEncoder.copyBufferToBuffer(gpuLabelmapBuffers[outputLabelmapBufferIndex], 0, labelmapStagingBuffer, 0, BUFFER_SIZE);
+    commandEncoder.copyBufferToBuffer(gpuBoundsBuffer, 0, boundsStagingBuffer, 0, BOUNDS_BUFFER_SIZE);
     device.queue.submit([commandEncoder.finish()]);
     await labelmapStagingBuffer.mapAsync(GPUMapMode.READ, 0, BUFFER_SIZE);
     const labelmapResultBuffer = labelmapStagingBuffer.getMappedRange(0, BUFFER_SIZE);
     const labelmapResult = new Uint32Array(labelmapResultBuffer);
     labelmapData.set(labelmapResult);
     labelmapStagingBuffer.unmap();
+    await boundsStagingBuffer.mapAsync(GPUMapMode.READ, 0, BOUNDS_BUFFER_SIZE);
+    const boundsResultBuffer = boundsStagingBuffer.getMappedRange(0, BOUNDS_BUFFER_SIZE);
+    const boundsResult = new Int32Array(boundsResultBuffer.slice(0));
+    boundsStagingBuffer.unmap();
+    const minX = boundsResult[0];
+    const minY = boundsResult[1];
+    const minZ = boundsResult[2];
+    const maxX = boundsResult[3];
+    const maxY = boundsResult[4];
+    const maxZ = boundsResult[5];
     labelmap.voxelManager.setCompleteScalarDataArray(labelmapData);
+    labelmap.voxelManager.clearBounds();
+    labelmap.voxelManager.setBounds([
+        [minX, maxX],
+        [minY, maxY],
+        [minZ, maxZ],
+    ]);
 }
 export { runGrowCut as default, runGrowCut as run };

package/dist/esm/utilities/segmentation/growCut/runOneClickGrowCut.d.ts

@@ -3,7 +3,13 @@ import type { GrowCutOptions } from './runGrowCut';
 type GrowCutOneClickOptions = GrowCutOptions & {
     subVolumePaddingPercentage?: number | [number, number, number];
     subVolumeMinPadding?: number | [number, number, number];
+    negativeSeedMargin?: number;
+    negativeSeedsCount?: number;
 };
-declare function runOneClickGrowCut(referencedVolumeId: string, worldPosition: Types.Point3, viewport: Types.IViewport, options?: GrowCutOneClickOptions): Promise<Types.IImageVolume>;
+declare function runOneClickGrowCut({ referencedVolumeId, worldPosition, options, }: {
+    referencedVolumeId: string;
+    worldPosition: Types.Point3;
+    options?: GrowCutOneClickOptions;
+}): Promise<Types.IImageVolume>;
 export { runOneClickGrowCut as default, runOneClickGrowCut };
 export type { GrowCutOneClickOptions };

package/dist/esm/utilities/segmentation/growCut/runOneClickGrowCut.js

@@ -1,4 +1,3 @@
-import { vec3 } from 'gl-matrix';
 import { utilities as csUtils, cache, volumeLoader } from '@cornerstonejs/core';
 import { run } from './runGrowCut';
 const { transformWorldToIndex, transformIndexToWorld } = csUtils;
@@ -6,63 +5,25 @@ const POSITIVE_SEED_VALUE = 254;
 const NEGATIVE_SEED_VALUE = 255;
 const POSITIVE_SEED_VARIANCE = 0.1;
 const NEGATIVE_SEED_VARIANCE = 0.8;
-const SUBVOLUME_PADDING_PERCENTAGE = 0.2;
-const SUBVOLUME_MIN_PADDING = 5;
-function _createSubVolume(referencedVolume, positiveRegionData, options) {
-    const { dimensions } = referencedVolume;
-    const positiveRegionSize = vec3.sub(vec3.create(), positiveRegionData.boundingBox.bottomRight, positiveRegionData.boundingBox.topLeft);
-    let subVolumePaddingPercentage = options?.subVolumePaddingPercentage ?? SUBVOLUME_PADDING_PERCENTAGE;
-    let subVolumeMinPadding = options?.subVolumeMinPadding ?? SUBVOLUME_MIN_PADDING;
-    if (typeof subVolumePaddingPercentage === 'number') {
-        subVolumePaddingPercentage = [
-            subVolumePaddingPercentage,
-            subVolumePaddingPercentage,
-            subVolumePaddingPercentage,
-        ];
-    }
-    if (typeof subVolumeMinPadding === 'number') {
-        subVolumeMinPadding = [
-            subVolumeMinPadding,
-            subVolumeMinPadding,
-            subVolumeMinPadding,
-        ];
-    }
-    const padding = vec3.mul(vec3.create(), positiveRegionSize, subVolumePaddingPercentage);
-    vec3.round(padding, padding);
-    vec3.max(padding, padding, subVolumeMinPadding);
-    const subVolumeSize = vec3.scaleAndAdd(vec3.create(), positiveRegionSize, padding, 2);
-    const ijkTopLeft = vec3.sub(vec3.create(), positiveRegionData.boundingBox.topLeft, padding);
-    const ijkBottomRight = vec3.add(vec3.create(), ijkTopLeft, subVolumeSize);
-    vec3.max(ijkTopLeft, ijkTopLeft, [0, 0, 0]);
-    vec3.min(ijkTopLeft, ijkTopLeft, dimensions);
-    vec3.max(ijkBottomRight, ijkBottomRight, [0, 0, 0]);
-    vec3.min(ijkBottomRight, ijkBottomRight, dimensions);
-    const subVolumeBoundsIJK = {
-        minX: ijkTopLeft[0],
-        maxX: ijkBottomRight[0],
-        minY: ijkTopLeft[1],
-        maxY: ijkBottomRight[1],
-        minZ: ijkTopLeft[2],
-        maxZ: ijkBottomRight[2],
-    };
-    return csUtils.createSubVolume(referencedVolume.volumeId, subVolumeBoundsIJK, {
-        targetBuffer: {
-            type: 'Float32Array',
-        },
-    });
-}
-function _getPositiveRegionData(referencedVolume, worldPosition, options) {
+function _generateSeeds(referencedVolume, labelmap, worldPosition, options) {
     const [width, height, numSlices] = referencedVolume.dimensions;
     const subVolPixelData = referencedVolume.voxelManager.getCompleteScalarDataArray();
     const numPixelsPerSlice = width * height;
     const ijkStartPosition = transformWorldToIndex(referencedVolume.imageData, worldPosition);
-    const referencePixelValue = subVolPixelData[ijkStartPosition[2] * numPixelsPerSlice +
+    const startIndex = ijkStartPosition[2] * numPixelsPerSlice +
         ijkStartPosition[1] * width +
-        ijkStartPosition[0]];
+        ijkStartPosition[0];
+    const referencePixelValue = subVolPixelData[startIndex];
     const positiveSeedVariance = options.positiveSeedVariance ?? POSITIVE_SEED_VARIANCE;
     const positiveSeedVarianceValue = Math.abs(referencePixelValue * positiveSeedVariance);
     const minPositivePixelValue = referencePixelValue - positiveSeedVarianceValue;
     const maxPositivePixelValue = referencePixelValue + positiveSeedVarianceValue;
+    const negativeSeedVariance = options.negativeSeedVariance ?? NEGATIVE_SEED_VARIANCE;
+    const negativeSeedVarianceValue = Math.abs(referencePixelValue * negativeSeedVariance);
+    const minNegativePixelValue = referencePixelValue - negativeSeedVarianceValue;
+    const maxNegativePixelValue = referencePixelValue + negativeSeedVarianceValue;
+    const positiveSeedValue = options.positiveSeedValue ?? POSITIVE_SEED_VALUE;
+    const negativeSeedValue = options.negativeSeedValue ?? NEGATIVE_SEED_VALUE;
     const neighborsCoordDelta = [
         [-1, 0, 0],
         [1, 0, 0],
@@ -71,32 +32,23 @@ function _getPositiveRegionData(referencedVolume, worldPosition, options) {
         [0, 0, -1],
         [0, 0, 1],
     ];
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    let maxZ = -Infinity;
-    const startVoxelIndex = ijkStartPosition[2] * numPixelsPerSlice +
-        ijkStartPosition[1] * width +
-        ijkStartPosition[0];
-    const voxelIndexesSet = new Set([startVoxelIndex]);
-    const worldVoxelSet = new Set([worldPosition]);
+    let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    const voxelIndexesSet = new Set([startIndex]);
+    labelmap.voxelManager.setAtIndex(startIndex, positiveSeedValue);
     const queue = [ijkStartPosition];
     while (queue.length) {
-        const ijkVoxel = queue.shift();
-        const [x, y, z] = ijkVoxel;
-        minX = ijkVoxel[0] < minX ? ijkVoxel[0] : minX;
-        minY = ijkVoxel[1] < minY ? ijkVoxel[1] : minY;
-        minZ = ijkVoxel[2] < minZ ? ijkVoxel[2] : minZ;
-        maxX = ijkVoxel[0] > maxX ? ijkVoxel[0] : maxX;
-        maxY = ijkVoxel[1] > maxY ? ijkVoxel[1] : maxY;
-        maxZ = ijkVoxel[2] > maxZ ? ijkVoxel[2] : maxZ;
-        for (let i = 0, len = neighborsCoordDelta.length; i < len; i++) {
-            const neighborCoordDelta = neighborsCoordDelta[i];
-            const nx = x + neighborCoordDelta[0];
-            const ny = y + neighborCoordDelta[1];
-            const nz = z + neighborCoordDelta[2];
+        const [x, y, z] = queue.shift();
+        minX = x < minX ? x : minX;
+        minY = y < minY ? y : minY;
+        minZ = z < minZ ? z : minZ;
+        maxX = x > maxX ? x : maxX;
+        maxY = y > maxY ? y : maxY;
+        maxZ = z > maxZ ? z : maxZ;
+        for (let i = 0; i < neighborsCoordDelta.length; i++) {
+            const [dx, dy, dz] = neighborsCoordDelta[i];
+            const nx = x + dx;
+            const ny = y + dy;
+            const nz = z + dz;
             if (nx < 0 ||
                 nx >= width ||
                 ny < 0 ||
@@ -106,71 +58,51 @@ function _getPositiveRegionData(referencedVolume, worldPosition, options) {
                 continue;
             }
             const neighborVoxelIndex = nz * numPixelsPerSlice + ny * width + nx;
-            const neighborPixelValue = subVolPixelData[neighborVoxelIndex];
-            if (voxelIndexesSet.has(neighborVoxelIndex) ||
-                neighborPixelValue < minPositivePixelValue ||
-                neighborPixelValue > maxPositivePixelValue) {
+            if (voxelIndexesSet.has(neighborVoxelIndex)) {
                 continue;
             }
-            const ijkVoxel = [nx, ny, nz];
-            const worldVoxel = transformIndexToWorld(referencedVolume.imageData, ijkVoxel);
-            voxelIndexesSet.add(neighborVoxelIndex);
-            worldVoxelSet.add(worldVoxel);
-            queue.push(ijkVoxel);
+            const neighborPixelValue = subVolPixelData[neighborVoxelIndex];
+            if (neighborPixelValue >= minPositivePixelValue &&
+                neighborPixelValue <= maxPositivePixelValue) {
+                labelmap.voxelManager.setAtIndex(neighborVoxelIndex, positiveSeedValue);
+                voxelIndexesSet.add(neighborVoxelIndex);
+                queue.push([nx, ny, nz]);
+            }
         }
     }
-    return {
-        worldVoxels: Array.from(worldVoxelSet),
-        boundingBox: {
-            topLeft: [minX, minY, minZ],
-            bottomRight: [maxX, maxY, maxZ],
-        },
-    };
-}
-function _setPositiveSeedValues(labelmap, positiveRegionData, options) {
-    const { dimensions } = labelmap;
-    const [width, height] = dimensions;
-    const numPixelsPerSlice = width * height;
-    const positiveSeedValue = options.positiveSeedValue ?? POSITIVE_SEED_VALUE;
-    const { worldVoxels } = positiveRegionData;
-    for (let i = 0, len = worldVoxels.length; i < len; i++) {
-        const worldVoxel = worldVoxels[i];
-        const ijkVoxel = transformWorldToIndex(labelmap.imageData, worldVoxel);
-        const voxelIndex = ijkVoxel[2] * numPixelsPerSlice + ijkVoxel[1] * width + ijkVoxel[0];
-        labelmap.voxelManager.setAtIndex(voxelIndex, positiveSeedValue);
-    }
-}
-function _setNegativeSeedValues(subVolume, labelmap, worldPosition, options) {
-    const [width, height] = subVolume.dimensions;
-    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
-    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
-    const ijkPosition = transformWorldToIndex(subVolume.imageData, worldPosition);
-    const referencePixelValue = subVolPixelData[ijkPosition[2] * width * height + ijkPosition[1] * width + ijkPosition[0]];
-    const negativeSeedVariance = options.negativeSeedVariance ?? NEGATIVE_SEED_VARIANCE;
-    const negativeSeedValue = options.negativeSeedValue ?? NEGATIVE_SEED_VALUE;
-    const negativeSeedVarianceValue = Math.abs(referencePixelValue * negativeSeedVariance);
-    const minNegativePixelValue = referencePixelValue - negativeSeedVarianceValue;
-    const maxNegativePixelValue = referencePixelValue + negativeSeedVarianceValue;
-    for (let i = 0, len = subVolPixelData.length; i < len; i++) {
-        const pixelValue = subVolPixelData[i];
-        if (!labelmapData[i] &&
-            (pixelValue < minNegativePixelValue || pixelValue > maxNegativePixelValue)) {
-            labelmap.voxelManager.setAtIndex(i, negativeSeedValue);
+    const margin = options.negativeSeedMargin ?? 30;
+    const minXwMargin = Math.max(0, minX - margin);
+    const minYwMargin = Math.max(0, minY - margin);
+    const minZwMargin = Math.max(0, minZ - margin);
+    const maxXwMargin = Math.min(width - 1, maxX + margin);
+    const maxYwMargin = Math.min(height - 1, maxY + margin);
+    const maxZwMargin = Math.min(numSlices - 1, maxZ + margin);
+    const negativeSeedsCount = options.negativeSeedsCount ?? 70;
+    const negativeIndexesSet = new Set();
+    let attempts = 0;
+    while (negativeIndexesSet.size < negativeSeedsCount &&
+        attempts < negativeSeedsCount * 50) {
+        attempts++;
+        const rx = Math.floor(Math.random() * (maxXwMargin - minXwMargin + 1) + minXwMargin);
+        const ry = Math.floor(Math.random() * (maxYwMargin - minYwMargin + 1) + minYwMargin);
+        const rz = Math.floor(Math.random() * (maxZwMargin - minZwMargin + 1) + minZwMargin);
+        const randomIndex = rz * numPixelsPerSlice + ry * width + rx;
+        if (voxelIndexesSet.has(randomIndex)) {
+            continue;
+        }
+        const randomVal = subVolPixelData[randomIndex];
+        if (randomVal >= minNegativePixelValue &&
+            randomVal <= maxNegativePixelValue) {
+            labelmap.voxelManager.setAtIndex(randomIndex, negativeSeedValue);
+            negativeIndexesSet.add(randomIndex);
         }
     }
 }
-async function _createAndCacheSegmentation(subVolume, positiveRegionData, worldPosition, options) {
-    const labelmap = volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
-    _setPositiveSeedValues(labelmap, positiveRegionData, options);
-    _setNegativeSeedValues(subVolume, labelmap, worldPosition, options);
-    return labelmap;
-}
-async function runOneClickGrowCut(referencedVolumeId, worldPosition, viewport, options) {
+async function runOneClickGrowCut({ referencedVolumeId, worldPosition, options, }) {
     const referencedVolume = cache.getVolume(referencedVolumeId);
-    const positiveRegionData = _getPositiveRegionData(referencedVolume, worldPosition, options);
-    const subVolume = _createSubVolume(referencedVolume, positiveRegionData, options);
-    const labelmap = await _createAndCacheSegmentation(subVolume, positiveRegionData, worldPosition, options);
-    await run(subVolume.volumeId, labelmap.volumeId);
+    const labelmap = volumeLoader.createAndCacheDerivedLabelmapVolume(referencedVolumeId);
+    _generateSeeds(referencedVolume, labelmap, worldPosition, options);
+    await run(referencedVolumeId, labelmap.volumeId);
     return labelmap;
 }
 export { runOneClickGrowCut as default, runOneClickGrowCut };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.1.0",
+    "@cornerstonejs/core": "^3.1.1",
     "@kitware/vtk.js": "32.9.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "227a990a55bc2dbfb95757f0860ff1a52dd3ab86"
+  "gitHead": "91a215bf75b76f6cbd017a811b5dfcff60f7f060"
 }