@cornerstonejs/tools 2.3.2 → 2.4.0

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

@@ -529,9 +529,9 @@ class CircleROITool extends AnnotationTool {
                         area,
                         mean: stats.mean?.value,
                         max: stats.max?.value,
+                        pointsInShape,
                         stdDev: stats.stdDev?.value,
                         statsArray: stats.array,
-                        pointsInShape: pointsInShape,
                         isEmptyArea,
                         areaUnit,
                         radius: worldWidth / 2 / scale,

package/dist/esm/tools/segmentation/PaintFillTool.js

@@ -80,7 +80,7 @@ class PaintFillTool extends BaseTool {
             return true;
         };
         this.getFramesModified = (fixedDimension, fixedDimensionValue, floodFillResult) => {
-            const { boundaries } = floodFillResult;
+            const { flooded: boundaries } = floodFillResult;
             if (fixedDimension === 2) {
                 return [fixedDimensionValue];
             }

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -90,9 +90,7 @@ export default class BrushStrategy {
         const segmentationVoxelManagerToUse = operationData.override?.voxelManager || segmentationVoxelManager;
         const segmentationImageDataToUse = operationData.override?.imageData || segmentationImageData;
         const previewVoxelManager = operationData.preview?.previewVoxelManager ||
-            VoxelManager.createHistoryVoxelManager({
-                sourceVoxelManager: segmentationVoxelManagerToUse,
-            });
+            VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
         const previewEnabled = !!operationData.previewColors;
         const previewSegmentIndex = previewEnabled ? 255 : undefined;
         const initializedData = {

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js

@@ -2,7 +2,7 @@ import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, } = operationData;
+        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, viewport, } = operationData;
         const { THRESHOLD } = strategySpecificConfiguration;
         if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
             return;
@@ -14,6 +14,7 @@ export default {
         const boundsIJK = segmentationVoxelManager.getBoundsIJK();
         const { threshold: oldThreshold, dynamicRadius = 0 } = THRESHOLD;
         const useDelta = oldThreshold ? 0 : dynamicRadius;
+        const { viewPlaneNormal } = viewport.getCamera();
         const nestedBounds = boundsIJK.map((ijk, idx) => {
             const [min, max] = ijk;
             return [
@@ -21,8 +22,22 @@ export default {
                 Math.min(max, centerIJK[idx] + useDelta),
             ];
         });
+        if (Math.abs(viewPlaneNormal[0]) > 0.8) {
+            nestedBounds[0] = [centerIJK[0], centerIJK[0]];
+        }
+        else if (Math.abs(viewPlaneNormal[1]) > 0.8) {
+            nestedBounds[1] = [centerIJK[1], centerIJK[1]];
+        }
+        else if (Math.abs(viewPlaneNormal[2]) > 0.8) {
+            nestedBounds[2] = [centerIJK[2], centerIJK[2]];
+        }
         const threshold = oldThreshold || [Infinity, -Infinity];
-        const callback = ({ value }) => {
+        const useDeltaSqr = useDelta * useDelta;
+        const callback = ({ value, pointIJK }) => {
+            const distance = vec3.sqrDist(centerIJK, pointIJK);
+            if (distance > useDeltaSqr) {
+                return;
+            }
             const gray = Array.isArray(value) ? vec3.len(value) : value;
             threshold[0] = Math.min(gray, threshold[0]);
             threshold[1] = Math.max(gray, threshold[1]);
@@ -62,6 +77,6 @@ export default {
             strategySpecificConfiguration[activeStrategy] = {};
         }
         strategySpecificConfiguration[activeStrategy].dynamicRadiusInCanvas =
-            dynamicRadiusInCanvas;
+            3 + dynamicRadiusInCanvas;
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.d.ts

@@ -1,5 +1,14 @@
+import { utilities } from '@cornerstonejs/core';
 import type { InitializedOperationData } from '../BrushStrategy';
+export declare enum SegmentationEnum {
+    SEGMENT = 1,
+    ISLAND = 2,
+    INTERIOR = 3,
+    EXTERIOR = 4
+}
 declare const _default: {
     onInteractionEnd: (operationData: InitializedOperationData) => void;
 };
 export default _default;
+export declare function createSegmentSet(operationData: InitializedOperationData): utilities.RLEVoxelMap<SegmentationEnum>;
+export declare function covers(rle: any, row: any): boolean;

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -1,123 +1,157 @@
-import floodFill from '../../../../utilities/segmentation/floodFill';
+import { utilities } from '@cornerstonejs/core';
 import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import normalizeViewportPlane from '../utils/normalizeViewportPlane';
+const { RLEVoxelMap } = utilities;
+const MAX_IMAGE_SIZE = 65535;
+export var SegmentationEnum;
+(function (SegmentationEnum) {
+    SegmentationEnum[SegmentationEnum["SEGMENT"] = 1] = "SEGMENT";
+    SegmentationEnum[SegmentationEnum["ISLAND"] = 2] = "ISLAND";
+    SegmentationEnum[SegmentationEnum["INTERIOR"] = 3] = "INTERIOR";
+    SegmentationEnum[SegmentationEnum["EXTERIOR"] = 4] = "EXTERIOR";
+})(SegmentationEnum || (SegmentationEnum = {}));
 export default {
     [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
-        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, strategySpecificConfiguration, previewSegmentIndex, segmentIndex, } = operationData;
-        if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+        const { strategySpecificConfiguration, previewSegmentIndex, segmentIndex } = operationData;
+        if (!strategySpecificConfiguration.THRESHOLD ||
+            segmentIndex === null ||
+            previewSegmentIndex === undefined) {
             return;
         }
-        const clickedPoints = previewVoxelManager.getPoints();
-        if (!clickedPoints?.length) {
+        const segmentSet = createSegmentSet(operationData);
+        if (!segmentSet) {
             return;
         }
-        if (previewSegmentIndex === undefined) {
+        const externalRemoved = removeExternalIslands(operationData, segmentSet);
+        if (externalRemoved === undefined) {
             return;
         }
-        const boundsIJK = previewVoxelManager
-            .getBoundsIJK()
-            .map((bound, i) => [
-            Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
-            Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
-        ]);
-        if (boundsIJK.find((it) => it[0] < 0 || it[1] > 65535)) {
+        const arrayOfSlices = removeInternalIslands(operationData, segmentSet);
+        if (!arrayOfSlices) {
             return;
         }
-        const floodedSet = new Set();
-        const getter = (i, j, k) => {
-            if (i < boundsIJK[0][0] ||
-                i > boundsIJK[0][1] ||
-                j < boundsIJK[1][0] ||
-                j > boundsIJK[1][1] ||
-                k < boundsIJK[2][0] ||
-                k > boundsIJK[2][1]) {
-                return -1;
-            }
-            const index = segmentationVoxelManager.toIndex([i, j, k]);
-            if (floodedSet.has(index)) {
-                return -2;
-            }
-            const oldVal = segmentationVoxelManager.getAtIndex(index);
-            const isIn = oldVal === previewSegmentIndex || oldVal === segmentIndex ? 1 : 0;
-            if (!isIn) {
-                segmentationVoxelManager.addPoint(index);
-            }
-            return isIn;
-        };
-        let floodedCount = 0;
-        const onFlood = (i, j, k) => {
-            const index = segmentationVoxelManager.toIndex([i, j, k]);
-            if (floodedSet.has(index)) {
-                return;
-            }
-            previewVoxelManager.setAtIJK(i, j, k, previewSegmentIndex);
-            floodedSet.add(index);
-            floodedCount++;
-        };
-        clickedPoints.forEach((clickedPoint) => {
-            if (getter(...clickedPoint) === 1) {
-                floodFill(getter, clickedPoint, {
-                    onFlood,
-                    diagonals: true,
-                });
-            }
-        });
-        let clearedCount = 0;
-        let previewCount = 0;
-        const callback = ({ index, pointIJK, value: trackValue }) => {
-            const value = segmentationVoxelManager.getAtIndex(index);
-            if (floodedSet.has(index)) {
-                previewCount++;
-                const newValue = trackValue === segmentIndex ? segmentIndex : previewSegmentIndex;
-                previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
-            }
-            else if (value === previewSegmentIndex) {
-                clearedCount++;
-                const newValue = trackValue ?? 0;
-                previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
-            }
-        };
-        previewVoxelManager.forEach(callback, {});
-        if (floodedCount - previewCount !== 0) {
-            console.warn('There were flooded=', floodedCount, 'cleared=', clearedCount, 'preview count=', previewCount, 'not handled', floodedCount - previewCount);
+        triggerSegmentationDataModified(operationData.segmentationId, arrayOfSlices, previewSegmentIndex);
+    },
+};
+export function createSegmentSet(operationData) {
+    const { segmentationVoxelManager, previewSegmentIndex, previewVoxelManager, segmentIndex, viewport, } = operationData;
+    const clickedPoints = previewVoxelManager.getPoints();
+    if (!clickedPoints?.length) {
+        return;
+    }
+    const boundsIJK = previewVoxelManager
+        .getBoundsIJK()
+        .map((bound, i) => [
+        Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
+        Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
+    ]);
+    if (boundsIJK.find((it) => it[0] < 0 || it[1] > MAX_IMAGE_SIZE)) {
+        return;
+    }
+    const { toIJK, fromIJK, boundsIJKPrime, error } = normalizeViewportPlane(viewport, boundsIJK);
+    if (error) {
+        console.warn('Not performing island removal for planes not orthogonal to acquisition plane', error);
+        return;
+    }
+    const [width, height, depth] = fromIJK(segmentationVoxelManager.dimensions);
+    const floodedSet = new RLEVoxelMap(width, height, depth);
+    const getter = (i, j, k) => {
+        const index = segmentationVoxelManager.toIndex(toIJK([i, j, k]));
+        const oldVal = segmentationVoxelManager.getAtIndex(index);
+        if (oldVal === previewSegmentIndex || oldVal === segmentIndex) {
+            return SegmentationEnum.SEGMENT;
         }
-        const islandMap = new Set(segmentationVoxelManager.points || []);
-        floodedSet.clear();
-        for (const index of islandMap.keys()) {
-            if (floodedSet.has(index)) {
+    };
+    floodedSet.fillFrom(getter, boundsIJKPrime);
+    floodedSet.normalizer = { toIJK, fromIJK, boundsIJKPrime };
+    return floodedSet;
+}
+function removeInternalIslands(operationData, floodedSet) {
+    const { height, normalizer } = floodedSet;
+    const { toIJK } = normalizer;
+    const { previewVoxelManager, previewSegmentIndex } = operationData;
+    floodedSet.forEachRow((baseIndex, row) => {
+        let lastRle;
+        for (const rle of [...row]) {
+            if (rle.value !== SegmentationEnum.ISLAND) {
                 continue;
             }
-            let isInternal = true;
-            const internalSet = new Set();
-            const onFloodInternal = (i, j, k) => {
-                const floodIndex = previewVoxelManager.toIndex([i, j, k]);
-                floodedSet.add(floodIndex);
-                if ((boundsIJK[0][0] !== boundsIJK[0][1] &&
-                    (i === boundsIJK[0][0] || i === boundsIJK[0][1])) ||
-                    (boundsIJK[1][0] !== boundsIJK[1][1] &&
-                        (j === boundsIJK[1][0] || j === boundsIJK[1][1])) ||
-                    (boundsIJK[2][0] !== boundsIJK[2][1] &&
-                        (k === boundsIJK[2][0] || k === boundsIJK[2][1]))) {
-                    isInternal = false;
-                }
-                if (isInternal) {
-                    internalSet.add(floodIndex);
-                }
-            };
-            const pointIJK = previewVoxelManager.toIJK(index);
-            if (getter(...pointIJK) !== 0) {
+            if (!lastRle) {
+                lastRle = rle;
                 continue;
             }
-            floodFill(getter, pointIJK, {
-                onFlood: onFloodInternal,
-                diagonals: false,
-            });
-            if (isInternal) {
-                for (const index of internalSet) {
-                    previewVoxelManager.setAtIndex(index, previewSegmentIndex);
-                }
+            for (let iPrime = lastRle.end; iPrime < rle.start; iPrime++) {
+                floodedSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
             }
+            lastRle = rle;
         }
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), previewSegmentIndex);
-    },
-};
+    });
+    floodedSet.forEach((baseIndex, rle) => {
+        if (rle.value !== SegmentationEnum.INTERIOR) {
+            return;
+        }
+        const [, jPrime, kPrime] = floodedSet.toIJK(baseIndex);
+        const rowPrev = jPrime > 0 ? floodedSet.getRun(jPrime - 1, kPrime) : null;
+        const rowNext = jPrime + 1 < height ? floodedSet.getRun(jPrime + 1, kPrime) : null;
+        const prevCovers = covers(rle, rowPrev);
+        const nextCovers = covers(rle, rowNext);
+        if (rle.end - rle.start > 2 && (!prevCovers || !nextCovers)) {
+            floodedSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.EXTERIOR, { singlePlane: true });
+        }
+    });
+    floodedSet.forEach((baseIndex, rle) => {
+        if (rle.value !== SegmentationEnum.INTERIOR) {
+            return;
+        }
+        for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+            const clearPoint = toIJK(floodedSet.toIJK(baseIndex + iPrime));
+            previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
+        }
+    });
+    return previewVoxelManager.getArrayOfModifiedSlices();
+}
+function removeExternalIslands(operationData, floodedSet) {
+    const { previewVoxelManager } = operationData;
+    const { toIJK, fromIJK } = floodedSet.normalizer;
+    const clickedPoints = previewVoxelManager.getPoints();
+    let floodedCount = 0;
+    clickedPoints.forEach((clickedPoint) => {
+        const ijkPrime = fromIJK(clickedPoint);
+        const index = floodedSet.toIndex(ijkPrime);
+        const [iPrime, jPrime, kPrime] = ijkPrime;
+        if (floodedSet.get(index) === SegmentationEnum.SEGMENT) {
+            floodedCount += floodedSet.floodFill(iPrime, jPrime, kPrime, SegmentationEnum.ISLAND);
+        }
+    });
+    if (floodedCount === 0) {
+        return;
+    }
+    const callback = (index, rle) => {
+        const [, jPrime, kPrime] = floodedSet.toIJK(index);
+        if (rle.value !== SegmentationEnum.ISLAND) {
+            for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                previewVoxelManager.setAtIJKPoint(clearPoint, null);
+            }
+        }
+    };
+    floodedSet.forEach(callback, { rowModified: true });
+    return floodedCount;
+}
+export function covers(rle, row) {
+    if (!row) {
+        return false;
+    }
+    let { start } = rle;
+    const { end } = rle;
+    for (const rowRle of row) {
+        if (start >= rowRle.start && start < rowRle.end) {
+            start = rowRle.end;
+            if (start >= end) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -38,7 +38,9 @@ export default {
                 operationData.segmentationVoxelManager;
             operationData.previewVoxelManager = preview.previewVoxelManager;
         }
-        if (segmentIndex === null || !previewSegmentIndex) {
+        if (segmentIndex === undefined ||
+            segmentIndex === null ||
+            !previewSegmentIndex) {
             return;
         }
         const configColor = previewColors?.[segmentIndex];

package/dist/esm/tools/segmentation/strategies/compositions/regionFill.js

@@ -1,7 +1,7 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Fill]: (operationData) => {
-        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager: previewVoxelManager, brushStrategy, centerIJK, } = operationData;
+        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager, brushStrategy, centerIJK, } = operationData;
         const isWithinThreshold = brushStrategy.createIsInThreshold?.(operationData);
         const { setValue } = brushStrategy;
         const callback = isWithinThreshold

package/dist/esm/tools/segmentation/strategies/compositions/setValue.js

@@ -1,5 +1,4 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
-import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
         const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;

package/dist/esm/tools/segmentation/strategies/utils/normalizeViewportPlane.d.ts

@@ -0,0 +1,19 @@
+import type { Types } from '@cornerstonejs/core';
+export default function normalizeViewportPlane(viewport: Types.IViewport, boundsIJK: Types.BoundsIJK): {
+    toIJK: any;
+    boundsIJKPrime: any;
+    fromIJK: any;
+    error: string;
+} | {
+    boundsIJKPrime: any;
+    toIJK: (ijkPrime: any) => any;
+    fromIJK: (ijk: any) => any;
+    type: string;
+    error?: undefined;
+} | {
+    boundsIJKPrime: any;
+    toIJK: ([j, k, i]: [any, any, any]) => any[];
+    fromIJK: ([i, j, k]: [any, any, any]) => any[];
+    type: string;
+    error?: undefined;
+};

package/dist/esm/tools/segmentation/strategies/utils/normalizeViewportPlane.js

@@ -0,0 +1,35 @@
+import { BaseVolumeViewport, utilities } from '@cornerstonejs/core';
+const { isEqual } = utilities;
+const acquisitionMapping = {
+    toIJK: (ijkPrime) => ijkPrime,
+    fromIJK: (ijk) => ijk,
+    type: 'acquistion',
+};
+const jkMapping = {
+    toIJK: ([j, k, i]) => [i, j, k],
+    fromIJK: ([i, j, k]) => [j, k, i],
+    type: 'jk',
+};
+const ikMapping = {
+    toIJK: ([i, k, j]) => [i, j, k],
+    fromIJK: ([i, j, k]) => [i, k, j],
+    type: 'ik',
+};
+export default function normalizeViewportPlane(viewport, boundsIJK) {
+    if (!(viewport instanceof BaseVolumeViewport)) {
+        return { ...acquisitionMapping, boundsIJKPrime: boundsIJK };
+    }
+    const { viewPlaneNormal } = viewport.getCamera();
+    const mapping = (isEqual(Math.abs(viewPlaneNormal[0]), 1) && jkMapping) ||
+        (isEqual(Math.abs(viewPlaneNormal[1]), 1) && ikMapping) ||
+        (isEqual(Math.abs(viewPlaneNormal[2]), 1) && acquisitionMapping);
+    if (!mapping) {
+        return {
+            toIJK: null,
+            boundsIJKPrime: null,
+            fromIJK: null,
+            error: `Only mappings orthogonal to acquisition plane are permitted, but requested ${viewPlaneNormal}`,
+        };
+    }
+    return { ...mapping, boundsIJKPrime: mapping.fromIJK(boundsIJK) };
+}

package/dist/esm/types/FloodFillTypes.d.ts

@@ -1,7 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 type FloodFillResult = {
     flooded: Types.Point2[] | Types.Point3[];
-    boundaries: Types.Point2[] | Types.Point3[];
 };
 type FloodFillGetter3D = (x: number, y: number, z: number) => unknown;
 type FloodFillGetter2D = (x: number, y: number) => unknown;
@@ -11,5 +10,7 @@ type FloodFillOptions = {
     onBoundary?: (x: number, y: number, z?: number) => void;
     equals?: (a: any, b: any) => boolean;
     diagonals?: boolean;
+    bounds?: Map<number, Types.Point2 | Types.Point3>;
+    filter?: (point: any) => boolean;
 };
 export type { FloodFillResult, FloodFillGetter, FloodFillOptions };

package/dist/esm/utilities/segmentation/VolumetricCalculator.js

@@ -4,7 +4,9 @@ export default class VolumetricCalculator extends BasicStatsCalculator {
         const { spacing } = options;
         const stats = BasicStatsCalculator.getStatistics();
         const volumeUnit = spacing ? 'mm\xb3' : 'voxels\xb3';
-        const volumeScale = spacing ? spacing[0] * spacing[1] * spacing[2] : 1;
+        const volumeScale = spacing
+            ? spacing[0] * spacing[1] * spacing[2] * 1000
+            : 1;
         stats.volume = {
             value: Array.isArray(stats.count.value)
                 ? stats.count.value.map((v) => v * volumeScale)

package/dist/esm/utilities/segmentation/floodFill.js

@@ -2,20 +2,20 @@ function floodFill(getter, seed, options = {}) {
     const onFlood = options.onFlood;
     const onBoundary = options.onBoundary;
     const equals = options.equals;
+    const filter = options.filter;
     const diagonals = options.diagonals || false;
     const startNode = get(seed);
     const permutations = prunedPermutations();
     const stack = [];
     const flooded = [];
     const visits = new Set();
-    const bounds = new Map();
+    const bounds = options.bounds;
     stack.push({ currentArgs: seed });
     while (stack.length > 0) {
         flood(stack.pop());
     }
     return {
         flooded,
-        boundaries: boundaries(),
     };
     function flood(job) {
         const getArgs = job.currentArgs;
@@ -55,7 +55,7 @@ function floodFill(getter, seed, options = {}) {
     function markAsBoundary(prevArgs) {
         const [x, y, z = 0] = prevArgs;
         const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
-        bounds.set(iKey, prevArgs);
+        bounds?.set(iKey, prevArgs);
         if (onBoundary) {
             onBoundary(...prevArgs);
         }
@@ -67,6 +67,12 @@ function floodFill(getter, seed, options = {}) {
             for (let j = 0; j < getArgs.length; j += 1) {
                 nextArgs[j] += perm[j];
             }
+            if (filter?.(nextArgs) === false) {
+                continue;
+            }
+            if (visited(nextArgs)) {
+                continue;
+            }
             stack.push({
                 currentArgs: nextArgs,
                 previousArgs: getArgs,
@@ -96,14 +102,6 @@ function floodFill(getter, seed, options = {}) {
         }
         return perms;
     }
-    function boundaries() {
-        const array = Array.from(bounds.values());
-        array.reverse();
-        return array;
-    }
-}
-function defaultEquals(a, b) {
-    return a === b;
 }
 function countNonZeroes(array) {
     let count = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -104,7 +104,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^2.3.2",
+    "@cornerstonejs/core": "^2.4.0",
     "@kitware/vtk.js": "32.1.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -123,5 +123,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "3bbd9ea2a093e186c2bc2485d57ad8e52bef89ae"
+  "gitHead": "70fc2826230875c1c5f3533953fac9a3025833c0"
 }