@cornerstonejs/tools 2.9.0 → 2.10.0

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -10,6 +10,7 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
     const { segmentationId, config } = representationInput;
     const renderingConfig = {
         colorLUTIndex: getColorLUTIndex(config),
+        ...config,
     };
     defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
     if (representationInput.type === SegmentationRepresentations.Contour) {

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -35,7 +35,9 @@ export async function computeLabelmapData(segmentationId, options = {}) {
     return rawLabelmapData;
 }
 async function computeLabelmapFromContourSegmentation(segmentationId, options = {}) {
-    const isVolume = options.viewport instanceof VolumeViewport ?? true;
+    const isVolume = options.viewport
+        ? options.viewport instanceof VolumeViewport
+        : true;
     if (isVolume && !options.viewport) {
         throw new Error('Cannot compute labelmap from contour segmentation without providing the viewport');
     }
@@ -55,7 +57,7 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
 }
 async function computeLabelmapFromSurfaceSegmentation(segmentationId, options = {}) {
     const { viewport } = options;
-    const isVolume = viewport instanceof VolumeViewport ?? true;
+    const isVolume = viewport ? viewport instanceof VolumeViewport : true;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.d.ts

@@ -1,3 +1,7 @@
 import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
-declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string): Promise<void>;
+import type { LabelmapRenderingConfig } from '../../../types/SegmentationStateTypes';
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<void | {
+    uid: string;
+    actor: any;
+}>;
 export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -3,8 +3,9 @@ import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/s
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { SegmentationRepresentations } from '../../../enums';
+import { addVolumesAsIndependentComponents } from './addVolumesAsIndependentComponents';
 const { uuidv4 } = utilities;
-async function addLabelmapToElement(element, labelMapData, segmentationId) {
+async function addLabelmapToElement(element, labelMapData, segmentationId, config) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
     const { id: viewportId } = viewport;
@@ -17,15 +18,28 @@ async function addLabelmapToElement(element, labelMapData, segmentationId) {
         if (!cache.getVolume(volumeId)) {
             await _handleMissingVolume(labelMapData);
         }
+        const blendMode = config?.blendMode ?? Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+        const useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
         const volumeInputs = [
             {
                 volumeId,
                 visibility,
-                blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
                 representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+                useIndependentComponents,
+                blendMode,
             },
         ];
-        await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
+        if (!volumeInputs[0].useIndependentComponents) {
+            await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
+        }
+        else {
+            const result = await addVolumesAsIndependentComponents({
+                viewport,
+                volumeInputs,
+                segmentationId,
+            });
+            return result;
+        }
     }
     else {
         const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);

package/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.d.ts

@@ -0,0 +1,10 @@
+import { type Types } from '@cornerstonejs/core';
+import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+export declare function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }: {
+    viewport: Types.IVolumeViewport;
+    volumeInputs: Types.IVolumeInput[];
+    segmentationId: string;
+}): Promise<{
+    uid: string;
+    actor: vtkVolume;
+}>;

package/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.js

@@ -0,0 +1,123 @@
+import { cache, Enums, convertMapperToNotSharedMapper, volumeLoader, eventTarget, createVolumeActor, } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+const internalCache = new Map();
+const load = ({ cfun, ofun, actor }) => {
+    actor.getProperty().setRGBTransferFunction(1, cfun);
+    actor.getProperty().setScalarOpacity(1, ofun);
+};
+export async function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }) {
+    const defaultActor = viewport.getDefaultActor();
+    const { actor } = defaultActor;
+    const { uid, callback } = defaultActor;
+    const referenceVolumeId = viewport.getVolumeId();
+    if (internalCache.get(uid)?.added) {
+        return {
+            uid,
+            actor,
+        };
+    }
+    const volumeInputArray = volumeInputs;
+    const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
+    if (!firstImageVolume) {
+        throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
+    }
+    const { volumeId } = volumeInputArray[0];
+    const segImageVolume = await volumeLoader.loadVolume(volumeId);
+    if (!segImageVolume) {
+        throw new Error(`segImageVolume with id: ${segImageVolume.volumeId} does not exist`);
+    }
+    const segVoxelManager = segImageVolume.voxelManager;
+    const { imageData: segImageData } = segImageVolume;
+    const baseVolume = cache.getVolume(referenceVolumeId);
+    const baseVoxelManager = baseVolume.voxelManager;
+    const newComp = 2;
+    const cubeData = new Float32Array(newComp * baseVolume.voxelManager.getScalarDataLength());
+    const dims = segImageData.getDimensions();
+    for (let z = 0; z < dims[2]; ++z) {
+        for (let y = 0; y < dims[1]; ++y) {
+            for (let x = 0; x < dims[0]; ++x) {
+                const iTuple = x + dims[0] * (y + dims[1] * z);
+                cubeData[iTuple * newComp + 0] = baseVoxelManager.getAtIndex(iTuple);
+                cubeData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+            }
+        }
+    }
+    viewport.removeActors([uid]);
+    const oldMapper = actor.getMapper();
+    const mapper = convertMapperToNotSharedMapper(oldMapper);
+    actor.setMapper(mapper);
+    mapper.setBlendMode(Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND);
+    const arrayAgain = mapper.getInputData().getPointData().getArray(0);
+    arrayAgain.setData(cubeData);
+    arrayAgain.setNumberOfComponents(2);
+    actor.getProperty().setColorMixPreset(1);
+    actor.getProperty().setForceNearestInterpolation(1, true);
+    actor.getProperty().setIndependentComponents(true);
+    viewport.addActor({
+        actor,
+        uid,
+        callback,
+        referencedId: referenceVolumeId,
+        representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+    });
+    internalCache.set(uid, {
+        added: true,
+        segmentationRepresentationUID: `${segmentationId}`,
+        originalBlendMode: viewport.getBlendMode(),
+    });
+    actor.set({
+        preLoad: load,
+    });
+    function onSegmentationDataModified(evt) {
+        const { segmentationId, modifiedSlicesToUse } = evt.detail;
+        const { representationData } = getSegmentation(segmentationId);
+        const { volumeId: segVolumeId } = representationData.Labelmap;
+        if (segVolumeId !== segImageVolume.volumeId) {
+            return;
+        }
+        const segmentationVolume = cache.getVolume(segVolumeId);
+        const segVoxelManager = segmentationVolume.voxelManager;
+        const array = mapper.getInputData().getPointData().getArray(0);
+        const baseData = array.getData();
+        const newComp = 2;
+        const dims = segImageData.getDimensions();
+        const slices = modifiedSlicesToUse?.length
+            ? modifiedSlicesToUse
+            : Array.from({ length: dims[2] }, (_, i) => i);
+        for (const z of slices) {
+            for (let y = 0; y < dims[1]; ++y) {
+                for (let x = 0; x < dims[0]; ++x) {
+                    const iTuple = x + dims[0] * (y + dims[1] * z);
+                    baseData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+                }
+            }
+        }
+        array.setData(baseData);
+    }
+    eventTarget.addEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+    eventTarget.addEventListener(Events.SEGMENTATION_REPRESENTATION_REMOVED, async (evt) => {
+        eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+        const actorEntry = viewport.getActor(uid);
+        const { element, id } = viewport;
+        viewport.removeActors([uid]);
+        const actor = await createVolumeActor({
+            volumeId: uid,
+            blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
+            callback: ({ volumeActor }) => {
+                if (actorEntry.callback) {
+                    actorEntry.callback({
+                        volumeActor,
+                        volumeId,
+                    });
+                }
+            },
+        }, element, id);
+        viewport.addActor({ actor, uid });
+        viewport.render();
+    });
+    return {
+        uid,
+        actor,
+    };
+}

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.d.ts

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
+export declare const MAX_NUMBER_COLORS = 255;
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
 declare const _default: {

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js

@@ -12,7 +12,7 @@ import SegmentationRepresentations from '../../../enums/SegmentationRepresentati
 import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
 import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getLabelmapActorEntry } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
-const MAX_NUMBER_COLORS = 255;
+export const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
 let polySegConversionInProgress = false;
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
@@ -33,7 +33,7 @@ function removeRepresentation(viewportId, segmentationId, renderImmediate = fals
     viewport.render();
 }
 async function render(viewport, representation) {
-    const { segmentationId } = representation;
+    const { segmentationId, config } = representation;
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
@@ -58,7 +58,7 @@ async function render(viewport, representation) {
     }
     if (viewport instanceof VolumeViewport) {
         if (!labelmapActorEntry) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
         }
         labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
     }
@@ -68,7 +68,7 @@ async function render(viewport, representation) {
             return;
         }
         if (!labelmapActorEntry) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationId);
+            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
         }
         labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
     }
@@ -133,11 +133,17 @@ function _setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentatio
             }
         }
     }
-    const labelmapActor = labelmapActorEntry.actor;
-    labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
     ofun.setClamping(false);
-    labelmapActor.getProperty().setScalarOpacity(0, ofun);
-    labelmapActor.getProperty().setInterpolationTypeToNearest();
+    const labelmapActor = labelmapActorEntry.actor;
+    const { preLoad } = labelmapActor.get('preLoad') || { preLoad: null };
+    if (preLoad) {
+        preLoad({ cfun, ofun, actor: labelmapActor });
+    }
+    else {
+        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
+        labelmapActor.getProperty().setScalarOpacity(0, ofun);
+        labelmapActor.getProperty().setInterpolationTypeToNearest();
+    }
     if (renderOutline) {
         labelmapActor.getProperty().setUseLabelOutline(renderOutline);
         labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
@@ -241,8 +247,9 @@ function _needsTransferFunctionUpdate(viewportId, segmentationId, segmentIndex,
         forceColorUpdate,
     };
 }
-async function _addLabelmapToViewport(viewport, labelmapData, segmentationId) {
-    await addLabelmapToElement(viewport.element, labelmapData, segmentationId);
+async function _addLabelmapToViewport(viewport, labelmapData, segmentationId, config) {
+    const result = await addLabelmapToElement(viewport.element, labelmapData, segmentationId, config);
+    return result || undefined;
 }
 export default {
     render,

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

@@ -7,7 +7,6 @@ import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
 import { state } from '../../store/state';
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 class SegmentSelectTool extends BaseTool {
     static { this.SelectMode = {
         Inside: 'Inside',

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

@@ -1,4 +1,4 @@
-import type { Types } from '@cornerstonejs/core';
+import type { Enums as coreEnums, Types } from '@cornerstonejs/core';
 import type * as Enums from '../enums';
 import type { ContourSegmentationData } from './ContourTypes';
 import type { LabelmapSegmentationData } from './LabelmapTypes';
@@ -35,6 +35,7 @@ export type LabelmapRenderingConfig = {
     cfun: vtkColorTransferFunction;
     ofun: vtkPiecewiseFunction;
     colorLUTIndex: number;
+    blendMode?: coreEnums.BlendModes;
 };
 export type ContourRenderingConfig = {};
 export type SurfaceRenderingConfig = {};
@@ -89,6 +90,7 @@ export type RepresentationPublicInput = {
     type?: Enums.SegmentationRepresentations;
     config?: {
         colorLUTOrIndex?: Types.ColorLUT | number;
+        blendMode?: coreEnums.BlendModes;
     };
 };
 export {};

package/dist/esm/utilities/planar/getPointInLineOfSightWithCriteria.d.ts

@@ -1,2 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-export default function getPointInLineOfSightWithCriteria(viewport: Types.IVolumeViewport, worldPos: Types.Point3, targetVolumeId: string, criteriaFunction: (intensity: number, point: Types.Point3) => Types.Point3, stepSize?: number): Types.Point3;
+export declare function getPointInLineOfSightWithCriteria(viewport: Types.IVolumeViewport, worldPos: Types.Point3, targetVolumeId: string, criteriaFunction: (intensity: number, point: Types.Point3) => Types.Point3, stepSize?: number): Types.Point3;
+export declare function getPointsInLineOfSight(viewport: Types.IVolumeViewport, worldPos: Types.Point3, { targetVolumeId, stepSize }: {
+    targetVolumeId: string;
+    stepSize: number;
+}): Types.Point3[];

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

@@ -1,38 +1,49 @@
-import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { utilities as csUtils } from '@cornerstonejs/core';
-export default function getPointInLineOfSightWithCriteria(viewport, worldPos, targetVolumeId, criteriaFunction, stepSize = 0.25) {
-    const camera = viewport.getCamera();
-    const { position: cameraPosition } = camera;
-    const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetVolumeId);
-    const step = spacingInNormalDirection * stepSize;
-    const bounds = viewport.getBounds();
-    const xMin = bounds[0];
-    const xMax = bounds[1];
-    const vector = [0, 0, 0];
-    let point = [0, 0, 0];
-    vtkMath.subtract(worldPos, cameraPosition, vector);
+export function getPointInLineOfSightWithCriteria(viewport, worldPos, targetVolumeId, criteriaFunction, stepSize = 0.25) {
+    const points = getPointsInLineOfSight(viewport, worldPos, {
+        targetVolumeId,
+        stepSize,
+    });
     let pickedPoint;
-    for (let pointT = xMin; pointT <= xMax; pointT = pointT + step) {
-        point = [pointT, 0, 0];
-        const t = (pointT - cameraPosition[0]) / vector[0];
-        point[1] = t * vector[1] + cameraPosition[1];
-        point[2] = t * vector[2] + cameraPosition[2];
-        if (_inBounds(point, bounds)) {
-            const intensity = viewport.getIntensityFromWorld(point);
-            const pointToPick = criteriaFunction(intensity, point);
-            if (pointToPick) {
-                pickedPoint = pointToPick;
-            }
+    for (const point of points) {
+        const intensity = viewport.getIntensityFromWorld(point);
+        const pointToPick = criteriaFunction(intensity, point);
+        if (pointToPick) {
+            pickedPoint = pointToPick;
         }
     }
     return pickedPoint;
 }
+export function getPointsInLineOfSight(viewport, worldPos, { targetVolumeId, stepSize }) {
+    const camera = viewport.getCamera();
+    const { viewPlaneNormal: normalDirection } = camera;
+    const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetVolumeId);
+    const step = spacingInNormalDirection * stepSize || 1;
+    const bounds = viewport.getBounds();
+    const points = [];
+    let currentPos = [...worldPos];
+    while (_inBounds(currentPos, bounds)) {
+        points.push([...currentPos]);
+        currentPos[0] += normalDirection[0] * step;
+        currentPos[1] += normalDirection[1] * step;
+        currentPos[2] += normalDirection[2] * step;
+    }
+    currentPos = [...worldPos];
+    while (_inBounds(currentPos, bounds)) {
+        points.push([...currentPos]);
+        currentPos[0] -= normalDirection[0] * step;
+        currentPos[1] -= normalDirection[1] * step;
+        currentPos[2] -= normalDirection[2] * step;
+    }
+    return points;
+}
 const _inBounds = function (point, bounds) {
     const [xMin, xMax, yMin, yMax, zMin, zMax] = bounds;
-    return (point[0] > xMin &&
-        point[0] < xMax &&
-        point[1] > yMin &&
-        point[1] < yMax &&
-        point[2] > zMin &&
-        point[2] < zMax);
+    const padding = 10;
+    return (point[0] > xMin + padding &&
+        point[0] < xMax - padding &&
+        point[1] > yMin + padding &&
+        point[1] < yMax - padding &&
+        point[2] > zMin + padding &&
+        point[2] < zMax - padding);
 };

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

@@ -1,7 +1,7 @@
 import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
-import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { getPointInLineOfSightWithCriteria, getPointsInLineOfSight } from './getPointInLineOfSightWithCriteria';
 import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
 import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 declare const _default: {
@@ -11,6 +11,7 @@ declare const _default: {
     getPointInLineOfSightWithCriteria: typeof getPointInLineOfSightWithCriteria;
     isPlaneIntersectingAABB: (origin: any, normal: any, minX: any, minY: any, minZ: any, maxX: any, maxY: any, maxZ: any) => boolean;
     filterAnnotationsWithinSamePlane: typeof filterAnnotationsWithinSamePlane;
+    getPointsInLineOfSight: typeof getPointsInLineOfSight;
 };
 export default _default;
-export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, };
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, getPointsInLineOfSight, };

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

@@ -1,7 +1,7 @@
 import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
-import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { getPointInLineOfSightWithCriteria, getPointsInLineOfSight, } from './getPointInLineOfSightWithCriteria';
 import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
 import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 export default {
@@ -11,5 +11,6 @@ export default {
     getPointInLineOfSightWithCriteria,
     isPlaneIntersectingAABB,
     filterAnnotationsWithinSamePlane,
+    getPointsInLineOfSight,
 };
-export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, };
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, getPointsInLineOfSight, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.9.0",
+  "version": "2.10.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.9.0",
+    "@cornerstonejs/core": "^2.10.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": "06611b57ab0630cae3487040cc3034d544d63a98"
+  "gitHead": "aab86e3f13a86bcd2d975a4cfbdf7eee7fa1627a"
 }