@cornerstonejs/tools 2.7.4 → 2.8.0

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

@@ -8,7 +8,8 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
 import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-class SphereScissorsTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+class SphereScissorsTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -25,6 +26,7 @@ class SphereScissorsTool extends BaseTool {
             if (this.isDrawing === true) {
                 return;
             }
+            this.doneEditMemo();
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
@@ -165,10 +167,12 @@ class SphereScissorsTool extends BaseTool {
                 segmentsLocked,
                 viewPlaneNormal,
                 viewUp,
+                createMemo: this.createMemo.bind(this),
             };
             this.editData = null;
             this.isDrawing = false;
             this.applyActiveStrategy(enabledElement, operationData);
+            this.doneEditMemo();
         };
         this._activateDraw = (element) => {
             element.addEventListener(Events.MOUSE_UP, this._endCallback);

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -2,6 +2,7 @@ import type { Types } from '@cornerstonejs/core';
 import { StrategyCallbacks } from '../../../enums';
 import type { LabelmapToolOperationDataAny } from '../../../types/LabelmapToolOperationData';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { LabelmapMemo } from '../../../utilities/segmentation/createLabelmapMemo';
 export type InitializedOperationData = LabelmapToolOperationDataAny & {
     operationName?: string;
     enabledElement: Types.IEnabledElement;
@@ -17,6 +18,7 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
     previewSegmentIndex?: number;
     brushStrategy: BrushStrategy;
     configuration?: Record<string, any>;
+    memo?: LabelmapMemo;
 };
 export type StrategyFunction = (operationData: InitializedOperationData, ...args: any[]) => unknown;
 export type CompositionInstance = {

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

@@ -29,8 +29,9 @@ export default {
         return preview;
     },
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, previewColors, preview } = operationData;
-        if (previewColors === undefined) {
+        const { segmentIndex, previewSegmentIndex, previewColors, preview, segmentationId, segmentationVoxelManager, } = operationData;
+        if (previewColors === undefined || !previewSegmentIndex) {
+            operationData.memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
             return;
         }
         if (preview) {
@@ -38,9 +39,7 @@ export default {
                 operationData.segmentationVoxelManager;
             operationData.previewVoxelManager = preview.previewVoxelManager;
         }
-        if (segmentIndex === undefined ||
-            segmentIndex === null ||
-            !previewSegmentIndex) {
+        if (segmentIndex === null) {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
@@ -52,24 +51,27 @@ export default {
         setSegmentIndexColor(operationData.viewport.id, operationData.segmentationId, previewSegmentIndex, previewColor);
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
-        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};
+        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, segmentationId, preview, } = operationData || {};
         if (previewSegmentIndex === undefined) {
             return;
         }
         const segmentIndex = preview?.segmentIndex ?? operationData.segmentIndex;
-        const tracking = previewVoxelManager;
-        if (!tracking || tracking.modifiedSlices.size === 0) {
+        if (!previewVoxelManager || previewVoxelManager.modifiedSlices.size === 0) {
             return;
         }
-        const callback = ({ index }) => {
+        const memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
+        operationData.memo = memo;
+        const { voxelManager } = memo;
+        const callback = ({ index, value }) => {
             const oldValue = segmentationVoxelManager.getAtIndex(index);
             if (oldValue === previewSegmentIndex) {
-                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+                segmentationVoxelManager.setAtIndex(index, value);
+                voxelManager.setAtIndex(index, segmentIndex);
             }
         };
-        tracking.forEach(callback, {});
-        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices(), preview.segmentIndex);
-        tracking.clear();
+        previewVoxelManager.forEach(callback, {});
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), preview.segmentIndex);
+        previewVoxelManager.clear();
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
         const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, } = operationData;

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

@@ -1,7 +1,8 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
+        const { segmentsLocked, segmentIndex, previewSegmentIndex, segmentationVoxelManager, memo, } = operationData;
+        const previewVoxelManager = memo?.voxelManager || operationData.previewVoxelManager;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
         let changed = false;
         if (segmentIndex === null) {

package/dist/esm/tools/segmentation/strategies/fillRectangle.d.ts

@@ -1,8 +1,6 @@
-import type { Types } from '@cornerstonejs/core';
-import type { LabelmapToolOperationData } from '../../../types';
-type OperationData = LabelmapToolOperationData & {
-    points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
-};
-export declare function fillInsideRectangle(enabledElement: Types.IEnabledElement, operationData: OperationData): void;
-export declare function fillOutsideRectangle(enabledElement: Types.IEnabledElement, operationData: OperationData): void;
-export {};
+import BrushStrategy from './BrushStrategy';
+declare const RECTANGLE_STRATEGY: BrushStrategy;
+declare const RECTANGLE_THRESHOLD_STRATEGY: BrushStrategy;
+declare const fillInsideRectangle: (enabledElement: any, operationData: any) => unknown;
+declare const thresholdInsideRectangle: (enabledElement: any, operationData: any) => unknown;
+export { RECTANGLE_STRATEGY, RECTANGLE_THRESHOLD_STRATEGY, fillInsideRectangle, thresholdInsideRectangle, };

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

@@ -1,21 +1,32 @@
+import { vec3 } from 'gl-matrix';
 import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
 import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from '../../../utilities/boundingBox';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { getStrategyData } from './utils/getStrategyData';
 import { isAxisAlignedRectangle } from '../../../utilities/rectangleROITool/isAxisAlignedRectangle';
+import BrushStrategy from './BrushStrategy';
+import { StrategyCallbacks } from '../../../enums';
+import compositions from './compositions';
 const { transformWorldToIndex } = csUtils;
-function fillRectangle(enabledElement, operationData) {
-    const { points, segmentsLocked, segmentIndex, segmentationId } = operationData;
-    const { viewport } = enabledElement;
-    const strategyData = getStrategyData({
-        operationData,
-        viewport: enabledElement.viewport,
-    });
-    if (!strategyData) {
-        console.warn('No data found for fillRectangle');
-        return;
-    }
-    const { segmentationImageData, segmentationVoxelManager } = strategyData;
+const initializeRectangle = {
+    [StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
+        if (!points) {
+            return;
+        }
+        const center = vec3.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            vec3.add(center, center, point);
+        });
+        vec3.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
+        const { boundsIJK, pointInShapeFn } = createPointInRectangle(viewport, points, segmentationImageData);
+        operationData.isInObject = pointInShapeFn;
+        operationData.isInObjectBoundsIJK = boundsIJK;
+    },
+};
+function createPointInRectangle(viewport, points, segmentationImageData) {
     let rectangleCornersIJK = points.map((world) => {
         return transformWorldToIndex(segmentationImageData, world);
     });
@@ -51,22 +62,10 @@ function fillRectangle(enabledElement, operationData) {
             const zInside = z >= zMin && z <= zMax;
             return xInside && yInside && zInside;
         };
-    const callback = ({ value, index }) => {
-        if (segmentsLocked.includes(value)) {
-            return;
-        }
-        segmentationVoxelManager.setAtIndex(index, segmentIndex);
-    };
-    segmentationVoxelManager.forEach(callback, {
-        isInObject: pointInShapeFn,
-        boundsIJK,
-        imageData: segmentationImageData,
-    });
-    triggerSegmentationDataModified(segmentationId);
-}
-export function fillInsideRectangle(enabledElement, operationData) {
-    fillRectangle(enabledElement, operationData);
-}
-export function fillOutsideRectangle(enabledElement, operationData) {
-    fillRectangle(enabledElement, operationData);
+    return { boundsIJK, pointInShapeFn };
 }
+const RECTANGLE_STRATEGY = new BrushStrategy('Rectangle', compositions.regionFill, compositions.setValue, initializeRectangle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
+const RECTANGLE_THRESHOLD_STRATEGY = new BrushStrategy('RectangleThreshold', compositions.regionFill, compositions.setValue, initializeRectangle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);
+const fillInsideRectangle = RECTANGLE_STRATEGY.strategyFunction;
+const thresholdInsideRectangle = RECTANGLE_THRESHOLD_STRATEGY.strategyFunction;
+export { RECTANGLE_STRATEGY, RECTANGLE_THRESHOLD_STRATEGY, fillInsideRectangle, thresholdInsideRectangle, };

package/dist/esm/tools/segmentation/strategies/index.d.ts

@@ -1,3 +1,3 @@
-import { fillInsideRectangle, fillOutsideRectangle } from './fillRectangle';
+import { fillInsideRectangle, thresholdInsideRectangle } from './fillRectangle';
 import { fillInsideCircle, fillOutsideCircle } from './fillCircle';
-export { fillInsideRectangle, fillOutsideRectangle, fillInsideCircle, fillOutsideCircle, };
+export { fillInsideRectangle, thresholdInsideRectangle, fillInsideCircle, fillOutsideCircle, };

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

@@ -1,3 +1,3 @@
-import { fillInsideRectangle, fillOutsideRectangle } from './fillRectangle';
+import { fillInsideRectangle, thresholdInsideRectangle } from './fillRectangle';
 import { fillInsideCircle, fillOutsideCircle } from './fillCircle';
-export { fillInsideRectangle, fillOutsideRectangle, fillInsideCircle, fillOutsideCircle, };
+export { fillInsideRectangle, thresholdInsideRectangle, fillInsideCircle, fillOutsideCircle, };

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

@@ -7,10 +7,12 @@ export declare enum ContourWindingDirection {
 }
 export type ContourAnnotationData = {
     data: {
+        cachedStats?: Record<string, unknown>;
         contour: {
             polyline: Types.Point3[];
             closed: boolean;
             windingDirection?: ContourWindingDirection;
+            pointsManager?: Types.IPointsManager<Types.Point3>;
         };
     };
     onInterpolationComplete?: () => void;

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

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { LabelmapMemo } from '../utilities/segmentation/createLabelmapMemo';
 type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
@@ -17,6 +18,7 @@ type LabelmapToolOperationData = {
     };
     preview: any;
     toolGroupId: string;
+    createMemo: (segmentId: any, segmentVoxels: any, previewVoxels?: any, previewMemo?: any) => LabelmapMemo;
 };
 type LabelmapToolOperationDataStack = LabelmapToolOperationData & LabelmapSegmentationDataStack;
 type LabelmapToolOperationDataVolume = LabelmapToolOperationData & LabelmapSegmentationDataVolume;

package/dist/esm/utilities/math/polyline/planarFreehandROIInternalTypes.d.ts

@@ -12,6 +12,7 @@ type PlanarFreehandROIEditData = {
     startCrossingIndex?: Types.Point2;
     editIndex: number;
     snapIndex?: number;
+    newAnnotation?: boolean;
 };
 type PlanarFreehandROICommonData = {
     annotation: PlanarFreehandROIAnnotation;

package/dist/esm/utilities/planar/filterAnnotationsWithinSlice.js

@@ -32,6 +32,10 @@ export default function filterAnnotationsWithinSlice(annotations, camera, spacin
             continue;
         }
         const dir = vec3.create();
+        if (!point) {
+            annotationsWithinSlice.push(annotation);
+            return;
+        }
         vec3.sub(dir, focalPoint, point);
         const dot = vec3.dot(dir, viewPlaneNormal);
         if (Math.abs(dot) < halfSpacingInNormalDirection) {

package/dist/esm/utilities/segmentation/createLabelmapMemo.d.ts

@@ -0,0 +1,44 @@
+import { utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import type { InitializedOperationData } from '../../tools/segmentation/strategies/BrushStrategy';
+export type LabelmapMemo = Types.Memo & {
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    voxelManager: Types.IVoxelManager<number>;
+    redoVoxelManager?: Types.IVoxelManager<number>;
+    undoVoxelManager?: Types.IVoxelManager<number>;
+    memo?: LabelmapMemo;
+};
+export declare function createLabelmapMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>, preview?: InitializedOperationData): {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    voxelManager: Types.IVoxelManager<number>;
+    memo: LabelmapMemo;
+    preview: InitializedOperationData;
+} | {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<T>;
+    voxelManager: utilities.VoxelManager<T>;
+};
+export declare function restoreMemo(isUndo?: boolean): void;
+export declare function createRleMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>): {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<T>;
+    voxelManager: utilities.VoxelManager<T>;
+};
+export declare function createPreviewMemo(segmentationId: string, preview: InitializedOperationData): {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    voxelManager: Types.IVoxelManager<number>;
+    memo: LabelmapMemo;
+    preview: InitializedOperationData;
+};
+declare function commitMemo(): boolean;
+export {};

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

@@ -0,0 +1,68 @@
+import { utilities } from '@cornerstonejs/core';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+const { VoxelManager, RLEVoxelMap } = utilities;
+export function createLabelmapMemo(segmentationId, segmentationVoxelManager, preview) {
+    return preview
+        ? createPreviewMemo(segmentationId, preview)
+        : createRleMemo(segmentationId, segmentationVoxelManager);
+}
+export function restoreMemo(isUndo) {
+    const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
+    const useVoxelManager = isUndo === false ? redoVoxelManager : undoVoxelManager;
+    useVoxelManager.forEach(({ value, pointIJK }) => {
+        segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
+    });
+    const slices = useVoxelManager.getArrayOfModifiedSlices();
+    triggerSegmentationDataModified(this.segmentationId, slices);
+}
+export function createRleMemo(segmentationId, segmentationVoxelManager) {
+    const voxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+    const state = {
+        segmentationId,
+        restoreMemo,
+        commitMemo,
+        segmentationVoxelManager,
+        voxelManager,
+    };
+    return state;
+}
+export function createPreviewMemo(segmentationId, preview) {
+    const { memo: previewMemo, segmentationVoxelManager, previewVoxelManager, } = preview;
+    const state = {
+        segmentationId,
+        restoreMemo,
+        commitMemo,
+        segmentationVoxelManager,
+        voxelManager: previewVoxelManager,
+        memo: previewMemo,
+        preview,
+    };
+    return state;
+}
+function commitMemo() {
+    if (this.redoVoxelManager) {
+        return true;
+    }
+    if (!this.voxelManager.modifiedSlices.size) {
+        return false;
+    }
+    const { segmentationVoxelManager } = this;
+    const undoVoxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+    RLEVoxelMap.copyMap(undoVoxelManager.map, this.voxelManager.map);
+    for (const key of this.voxelManager.modifiedSlices.keys()) {
+        undoVoxelManager.modifiedSlices.add(key);
+    }
+    this.undoVoxelManager = undoVoxelManager;
+    const redoVoxelManager = VoxelManager.createRLEVolumeVoxelManager({
+        dimensions: this.segmentationVoxelManager.dimensions,
+    });
+    this.redoVoxelManager = redoVoxelManager;
+    undoVoxelManager.forEach(({ index, pointIJK, value }) => {
+        const currentValue = segmentationVoxelManager.getAtIJKPoint(pointIJK);
+        if (currentValue === value) {
+            return;
+        }
+        redoVoxelManager.setAtIndex(index, currentValue);
+    });
+    return true;
+}

package/dist/esm/utilities/segmentation/index.d.ts

@@ -18,4 +18,5 @@ import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBord
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './getBrushToolInstances';
 import * as growCut from './growCut';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, };
+import * as LabelmapMemo from './createLabelmapMemo';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, };

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

@@ -18,4 +18,5 @@ import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBord
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './getBrushToolInstances';
 import * as growCut from './growCut';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, };
+import * as LabelmapMemo from './createLabelmapMemo';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.7.4",
+  "version": "2.8.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.7.4",
+    "@cornerstonejs/core": "^2.8.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": "d386daf61a0fe0fb2f049e8456c3497839e7e4fa"
+  "gitHead": "64b1f664e114d73546cf88099bf427a4f563aabd"
 }