@cornerstonejs/tools 3.25.0 → 3.26.0

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

@@ -19,6 +19,7 @@ import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScale
 import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/math/circle';
 import { pointInEllipse } from '../../utilities/math/ellipse';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
+import { vec2, vec3 } from 'gl-matrix';
 const { transformWorldToIndex } = csUtils;
 class CircleROITool extends AnnotationTool {
     static { this.toolName = 'CircleROI'; }
@@ -32,6 +33,7 @@ class CircleROITool extends AnnotationTool {
             calculateStats: true,
             getTextLines: defaultGetTextLines,
             statsCalculator: BasicStatsCalculator,
+            simplified: true,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -41,12 +43,25 @@ class CircleROITool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            let points;
+            if (this.configuration.simplified) {
+                points = [[...worldPos], [...worldPos]];
+            }
+            else {
+                points = [
+                    [...worldPos],
+                    [...worldPos],
+                    [...worldPos],
+                    [...worldPos],
+                    [...worldPos],
+                ];
+            }
             const annotation = {
                 highlighted: true,
                 invalidated: true,
@@ -71,7 +86,7 @@ class CircleROITool extends AnnotationTool {
                                 bottomRight: [0, 0, 0],
                             },
                         },
-                        points: [[...worldPos], [...worldPos]],
+                        points,
                         activeHandleIndex: null,
                     },
                     cachedStats: {},
@@ -94,18 +109,12 @@ class CircleROITool extends AnnotationTool {
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            const { data } = annotation;
-            const { points } = data.handles;
-            const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-            const radius = getCanvasCircleRadius(canvasCoordinates);
-            const radiusPoint = getCanvasCircleRadius([
-                canvasCoordinates[0],
-                canvasCoords,
-            ]);
-            if (Math.abs(radiusPoint - radius) < proximity / 2) {
-                return true;
-            }
-            return false;
+            const { points } = annotation.data.handles;
+            const canvasHandles = points.map((p) => viewport.worldToCanvas(p));
+            const canvasCenter = canvasHandles[0];
+            const radius = getCanvasCircleRadius([canvasCenter, canvasHandles[1]]);
+            const radiusPoint = getCanvasCircleRadius([canvasCenter, canvasCoords]);
+            return Math.abs(radiusPoint - radius) < proximity / 2;
         };
         this.toolSelectedCallback = (evt, annotation) => {
             const eventDetail = evt.detail;
@@ -119,8 +128,6 @@ class CircleROITool extends AnnotationTool {
             };
             hideElementCursor(element);
             this._activateModify(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
@@ -147,8 +154,6 @@ class CircleROITool extends AnnotationTool {
             };
             this._activateModify(element);
             hideElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
@@ -166,7 +171,6 @@ class CircleROITool extends AnnotationTool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const { renderingEngine } = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -181,19 +185,39 @@ class CircleROITool extends AnnotationTool {
         this._dragDrawCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            const { currentPoints } = eventDetail;
-            const currentCanvasPoints = currentPoints.canvas;
+            const { element, currentPoints } = eventDetail;
+            const { world: worldPos, canvas: currentCanvasPoints } = currentPoints;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             const { canvasToWorld } = viewport;
             const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
             this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
-            data.handles.points = [
-                data.handles.points[0],
-                canvasToWorld(currentCanvasPoints),
-            ];
+            const centerWorld = data.handles.points[0];
+            const centerCanvas = viewport.worldToCanvas(centerWorld);
+            if (this.configuration.simplified) {
+                data.handles.points[1] = worldPos;
+            }
+            else {
+                const radiusCanvas = vec2.distance(centerCanvas, currentCanvasPoints);
+                data.handles.points[0] = [...centerWorld];
+                data.handles.points[1] = canvasToWorld([
+                    centerCanvas[0],
+                    centerCanvas[1] - radiusCanvas,
+                ]);
+                data.handles.points[2] = canvasToWorld([
+                    centerCanvas[0],
+                    centerCanvas[1] + radiusCanvas,
+                ]);
+                data.handles.points[3] = canvasToWorld([
+                    centerCanvas[0] - radiusCanvas,
+                    centerCanvas[1],
+                ]);
+                data.handles.points[4] = canvasToWorld([
+                    centerCanvas[0] + radiusCanvas,
+                    centerCanvas[1],
+                ]);
+            }
             annotation.invalidated = true;
             this.editData.hasMoved = true;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
@@ -231,8 +255,6 @@ class CircleROITool extends AnnotationTool {
                 this._dragHandle(evt);
                 annotation.invalidated = true;
             }
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (annotation.invalidated) {
                 triggerAnnotationModified(annotation, element, ChangeTypes.HandlesUpdated);
@@ -246,23 +268,36 @@ class CircleROITool extends AnnotationTool {
             const { annotation, handleIndex } = this.editData;
             const { data } = annotation;
             const { points } = data.handles;
-            const canvasCoordinates = points.map((p) => worldToCanvas(p));
-            const { currentPoints } = eventDetail;
-            const currentCanvasPoints = currentPoints.canvas;
+            const { currentPoints, deltaPoints } = eventDetail;
             if (handleIndex === 0) {
-                const dXCanvas = currentCanvasPoints[0] - canvasCoordinates[0][0];
-                const dYCanvas = currentCanvasPoints[1] - canvasCoordinates[0][1];
-                const canvasCenter = currentCanvasPoints;
-                const canvasEnd = [
-                    canvasCoordinates[1][0] + dXCanvas,
-                    canvasCoordinates[1][1] + dYCanvas,
-                ];
-                points[0] = canvasToWorld(canvasCenter);
-                points[1] = canvasToWorld(canvasEnd);
+                const worldPosDelta = deltaPoints.world;
+                points.forEach((point) => {
+                    vec3.add(point, point, worldPosDelta);
+                });
             }
             else {
-                points[1] = canvasToWorld(currentCanvasPoints);
+                const centerWorld = points[0];
+                const centerCanvas = worldToCanvas(centerWorld);
+                const currentCanvasPoint = currentPoints.canvas;
+                const newRadiusCanvas = vec2.distance(centerCanvas, currentCanvasPoint);
+                points[1] = canvasToWorld([
+                    centerCanvas[0],
+                    centerCanvas[1] - newRadiusCanvas,
+                ]);
+                points[2] = canvasToWorld([
+                    centerCanvas[0],
+                    centerCanvas[1] + newRadiusCanvas,
+                ]);
+                points[3] = canvasToWorld([
+                    centerCanvas[0] - newRadiusCanvas,
+                    centerCanvas[1],
+                ]);
+                points[4] = canvasToWorld([
+                    centerCanvas[0] + newRadiusCanvas,
+                    centerCanvas[1],
+                ]);
             }
+            annotation.invalidated = true;
         };
         this.cancel = (element) => {
             if (this.isDrawing) {
@@ -271,9 +306,8 @@ class CircleROITool extends AnnotationTool {
                 this._deactivateModify(element);
                 resetElementCursor(element);
                 const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
-                const { data } = annotation;
                 annotation.highlighted = false;
-                data.handles.activeHandleIndex = null;
+                annotation.data.handles.activeHandleIndex = null;
                 triggerAnnotationRenderForViewportIds(viewportIdsToRender);
                 if (newAnnotation) {
                     triggerAnnotationCompleted(annotation);
@@ -351,8 +385,11 @@ class CircleROITool extends AnnotationTool {
                 });
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 const center = canvasCoordinates[0];
-                const radius = getCanvasCircleRadius(canvasCoordinates);
-                const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
+                const radius = getCanvasCircleRadius([center, canvasCoordinates[1]]);
+                const canvasCorners = getCanvasCircleCorners([
+                    center,
+                    canvasCoordinates[1],
+                ]);
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
                     data.cachedStats[targetId].areaUnit == null) {
@@ -400,7 +437,12 @@ class CircleROITool extends AnnotationTool {
                 if (!isAnnotationLocked(annotationUID) &&
                     !this.editData &&
                     activeHandleIndex !== null) {
-                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                    if (this.configuration.simplified) {
+                        activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                    }
+                    else {
+                        activeHandleCanvasCoords = canvasCoordinates;
+                    }
                 }
                 if (activeHandleCanvasCoords) {
                     const handleGroupUID = '0';
@@ -451,7 +493,7 @@ class CircleROITool extends AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, [center, canvasCoordinates[1]], {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -471,8 +513,10 @@ class CircleROITool extends AnnotationTool {
             const wasInvalidated = annotation.invalidated;
             const { points } = data.handles;
             const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+            const canvasCenter = canvasCoordinates[0];
+            const canvasTop = canvasCoordinates[1];
             const { viewPlaneNormal, viewUp } = viewport.getCamera();
-            const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners(canvasCoordinates));
+            const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners([canvasCenter, canvasTop]));
             const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
             const { cachedStats } = data;
@@ -506,11 +550,7 @@ class CircleROITool extends AnnotationTool {
                         [jMin, jMax],
                         [kMin, kMax],
                     ];
-                    const center = [
-                        (topLeftWorld[0] + bottomRightWorld[0]) / 2,
-                        (topLeftWorld[1] + bottomRightWorld[1]) / 2,
-                        (topLeftWorld[2] + bottomRightWorld[2]) / 2,
-                    ];
+                    const center = points[0];
                     const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
                     const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
                     const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;

package/dist/esm/tools/segmentation/CircleROIStartEndThresholdTool.d.ts

@@ -44,7 +44,7 @@ declare class CircleROIStartEndThresholdTool extends CircleROITool {
                         bottomRight: Types.Point3;
                     };
                 };
-                points: [Types.Point3, Types.Point3];
+                points: any;
                 activeHandleIndex: any;
             };
             cachedStats: {

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

@@ -25,6 +25,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            simplified: true,
             storePointData: false,
             numSlicesToPropagate: 10,
             calculatePointsInsideVolume: true,
@@ -59,6 +60,19 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             const startCoord = this._getStartCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            let points;
+            if (this.configuration.simplified) {
+                points = [[...worldPos], [...worldPos]];
+            }
+            else {
+                points = [
+                    [...worldPos],
+                    [...worldPos],
+                    [...worldPos],
+                    [...worldPos],
+                    [...worldPos],
+                ];
+            }
             const annotation = {
                 highlighted: true,
                 invalidated: true,
@@ -87,7 +101,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                                 bottomRight: [0, 0, 0],
                             },
                         },
-                        points: [[...worldPos], [...worldPos]],
+                        points,
                         activeHandleIndex: null,
                     },
                     cachedStats: {
@@ -168,9 +182,15 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 const color = this.getStyle('color', styleSpecifier, annotation);
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 const center = canvasCoordinates[0];
-                const radius = getCanvasCircleRadius(canvasCoordinates);
+                const radius = getCanvasCircleRadius([
+                    canvasCoordinates[0],
+                    canvasCoordinates[1],
+                ]);
                 const { centerPointRadius } = this.configuration;
-                const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
+                const canvasCorners = getCanvasCircleCorners([
+                    canvasCoordinates[0],
+                    canvasCoordinates[1],
+                ]);
                 const focalPoint = viewport.getCamera().focalPoint;
                 const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
                 let tempStartCoordinate = startCoordinate;
@@ -214,7 +234,12 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     !this.editData &&
                     activeHandleIndex !== null &&
                     isMiddleSlice) {
-                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                    if (this.configuration.simplified) {
+                        activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                    }
+                    else {
+                        activeHandleCanvasCoords = canvasCoordinates;
+                    }
                 }
                 if (activeHandleCanvasCoords) {
                     const handleGroupUID = '0';
@@ -274,7 +299,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     }
                     const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                     const textBoxUID = '1';
-                    const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                    const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, [canvasCoordinates[0], canvasCoordinates[1]], {}, options);
                     const { x: left, y: top, width, height } = boundingBox;
                     data.handles.textBox.worldBoundingBox = {
                         topLeft: viewport.canvasToWorld([left, top]),
@@ -296,45 +321,26 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
     _computeProjectionPoints(annotation, imageVolume) {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, spacingInNormal } = metadata;
-        const { imageData } = imageVolume;
         const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
-        const startIJK = transformWorldToIndex(imageData, points[0]);
-        const endIJK = transformWorldToIndex(imageData, points[0]);
         const handlesToStart = csUtils.deepClone(points);
-        const startWorld = vec3.create();
-        imageData.indexToWorldVec3(startIJK, startWorld);
-        const endWorld = vec3.create();
-        imageData.indexToWorldVec3(endIJK, endWorld);
-        const projectionAxisIndex = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
-        if (projectionAxisIndex == 2) {
-            startWorld[2] = startCoordinate;
-            endWorld[2] = endCoordinate;
-            handlesToStart[0][2] = startCoordinate;
-            handlesToStart[1][2] = startCoordinate;
-        }
-        else if (projectionAxisIndex == 0) {
-            startWorld[0] = startCoordinate;
-            endWorld[0] = endCoordinate;
-            handlesToStart[0][0] = startCoordinate;
-            handlesToStart[1][0] = startCoordinate;
-        }
-        else if (projectionAxisIndex == 1) {
-            startWorld[1] = startCoordinate;
-            endWorld[1] = endCoordinate;
-            handlesToStart[0][1] = startCoordinate;
-            handlesToStart[1][1] = startCoordinate;
-        }
-        const direction = vec3.create();
-        vec3.subtract(direction, endWorld, startWorld);
-        const distance = vec3.length(direction);
-        vec3.normalize(direction, direction);
+        const startWorld = vec3.clone(points[0]);
+        const endWorld = vec3.clone(points[0]);
+        const indexOfNormal = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+        startWorld[indexOfNormal] = startCoordinate;
+        endWorld[indexOfNormal] = endCoordinate;
+        handlesToStart.forEach((handlePoint) => {
+            handlePoint[indexOfNormal] = startCoordinate;
+        });
+        const distance = vec3.distance(startWorld, endWorld);
         const newProjectionPoints = [];
-        const basePoints = points;
-        for (let dist = 0; dist < distance; dist += spacingInNormal) {
-            newProjectionPoints.push(basePoints.map((point) => {
+        if (distance >= 0) {
+            newProjectionPoints.push(handlesToStart.map((p) => Array.from(p)));
+        }
+        for (let dist = spacingInNormal; dist <= distance; dist += spacingInNormal) {
+            newProjectionPoints.push(handlesToStart.map((point) => {
                 const newPoint = vec3.create();
-                vec3.scaleAndAdd(newPoint, point, direction, dist);
+                vec3.scaleAndAdd(newPoint, point, viewPlaneNormal, dist);
                 return Array.from(newPoint);
             }));
         }
@@ -348,11 +354,18 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         const pointsInsideVolume = [[]];
         const image = this.getTargetImageData(targetId);
         const canvasCoordinates = data.handles.points.map((p) => viewport.worldToCanvas(p));
-        const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners(canvasCoordinates));
-        const pos1 = viewport.canvasToWorld(topLeftCanvas);
-        const pos2 = viewport.canvasToWorld(bottomRightCanvas);
-        const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, pos1, pos2);
-        const measureInfo = getCalibratedLengthUnitsAndScale(image, data.handles);
+        const baseTopLeftCanvas = getCanvasCircleCorners([
+            canvasCoordinates[0],
+            canvasCoordinates[1],
+        ])[0];
+        const baseBottomRightCanvas = getCanvasCircleCorners([
+            canvasCoordinates[0],
+            canvasCoordinates[1],
+        ])[1];
+        const basePos1 = viewport.canvasToWorld(baseTopLeftCanvas);
+        const basePos2 = viewport.canvasToWorld(baseBottomRightCanvas);
+        const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, basePos1, basePos2);
+        const measureInfo = getCalibratedLengthUnitsAndScale(image, data.handles.points);
         const aspect = getCalibratedAspect(image);
         const area = Math.abs(Math.PI *
             (worldWidth / measureInfo.scale / 2) *
@@ -367,8 +380,11 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 continue;
             }
             const centerWorld = projectionPoints[i][0];
-            const canvasCoordinates = projectionPoints[i].map((p) => viewport.worldToCanvas(p));
-            const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners(canvasCoordinates));
+            const currentCanvasCoordinates = projectionPoints[i].map((p) => viewport.worldToCanvas(p));
+            const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners([
+                currentCanvasCoordinates[0],
+                currentCanvasCoordinates[1],
+            ]));
             const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
             const worldPos1 = topLeftWorld;

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

@@ -109,7 +109,13 @@ export interface AdvancedMagnifyAnnotation extends Annotation {
 export interface CircleROIAnnotation extends Annotation {
     data: {
         handles: {
-            points: [Types.Point3, Types.Point3];
+            points: [
+                Types.Point3,
+                Types.Point3,
+                Types.Point3,
+                Types.Point3,
+                Types.Point3
+            ];
             activeHandleIndex: number | null;
             textBox?: {
                 hasMoved: boolean;
@@ -287,7 +293,7 @@ export interface CircleROIStartEndThresholdAnnotation extends Annotation {
             statistics?: ROICachedStats;
         };
         handles: {
-            points: [Types.Point3, Types.Point3];
+            points: Types.Point3[];
             activeHandleIndex: number | null;
             textBox?: {
                 hasMoved: boolean;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.25.0";
+export declare const version = "3.26.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.25.0';
+export const version = '3.26.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.25.0",
+  "version": "3.26.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.25.0",
+    "@cornerstonejs/core": "^3.26.0",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b79637cd89f913f17f69cd25b94a5c730fe54d8e"
+  "gitHead": "a851443310a66ee3620011723733112128c2a7ba"
 }