@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.21

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

@@ -0,0 +1,435 @@
+import { Events } from '../../enums';
+import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
+import { roundNumber } from '../../utilities';
+import { AnnotationTool } from '../base';
+import throttle from '../../utilities/throttle';
+import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
+import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
+import * as lineSegment from '../../utilities/math/line';
+import { drawHandles as drawHandlesSvg, drawHeight as drawHeightSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { state } from '../../store';
+import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
+import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
+const { transformWorldToIndex } = csUtils;
+class HeightTool extends AnnotationTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            preventHandleOutsideImage: false,
+            getTextLines: defaultGetTextLines,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = getEnabledElement(element);
+            const { viewport, renderingEngine } = enabledElement;
+            hideElementCursor(element);
+            this.isDrawing = true;
+            const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    ...viewport.getViewReference({ points: [worldPos] }),
+                    toolName: this.getToolName(),
+                    referencedImageId,
+                    viewUp,
+                    cameraPosition,
+                },
+                data: {
+                    handles: {
+                        points: [[...worldPos], [...worldPos]],
+                        activeHandleIndex: null,
+                        textBox: {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        },
+                    },
+                    label: '',
+                    cachedStats: {},
+                },
+            };
+            addAnnotation(annotation, element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                handleIndex: 1,
+                movingTextBox: false,
+                newAnnotation: true,
+                hasMoved: false,
+            };
+            this._activateDraw(element);
+            evt.preventDefault();
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            return annotation;
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const { data } = annotation;
+            const [point1, point2] = data.handles.points;
+            const canvasPoint1 = viewport.worldToCanvas(point1);
+            const canvasPoint2 = viewport.worldToCanvas(point2);
+            const line = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            const distanceToPoint = lineSegment.distanceToPoint([line.start.x, line.start.y], [line.end.x, line.end.y], [canvasCoords[0], canvasCoords[1]]);
+            if (distanceToPoint <= proximity) {
+                return true;
+            }
+            return false;
+        };
+        this.toolSelectedCallback = (evt, annotation) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                movingTextBox: false,
+            };
+            this._activateModify(element);
+            hideElementCursor(element);
+            const enabledElement = getEnabledElement(element);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, newAnnotation, hasMoved } = this.editData;
+            const { data } = annotation;
+            if (newAnnotation && !hasMoved) {
+                return;
+            }
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            resetElementCursor(element);
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine } = enabledElement;
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                removeAnnotation(annotation.annotationUID);
+            }
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            if (newAnnotation) {
+                triggerAnnotationCompleted(annotation);
+            }
+            this.editData = null;
+            this.isDrawing = false;
+        };
+        this._dragCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { data } = annotation;
+            if (movingTextBox) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const { textBox } = data.handles;
+                const { worldPosition } = textBox;
+                worldPosition[0] += worldPosDelta[0];
+                worldPosition[1] += worldPosDelta[1];
+                worldPosition[2] += worldPosDelta[2];
+                textBox.hasMoved = true;
+            }
+            else if (handleIndex === undefined) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const points = data.handles.points;
+                points.forEach((point) => {
+                    point[0] += worldPosDelta[0];
+                    point[1] += worldPosDelta[1];
+                    point[2] += worldPosDelta[2];
+                });
+                annotation.invalidated = true;
+            }
+            else {
+                const { currentPoints } = eventDetail;
+                const worldPos = currentPoints.world;
+                data.handles.points[handleIndex] = [...worldPos];
+                annotation.invalidated = true;
+            }
+            this.editData.hasMoved = true;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine } = enabledElement;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        };
+        this.cancel = (element) => {
+            if (this.isDrawing) {
+                this.isDrawing = false;
+                this._deactivateDraw(element);
+                this._deactivateModify(element);
+                resetElementCursor(element);
+                const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+                const { data } = annotation;
+                annotation.highlighted = false;
+                data.handles.activeHandleIndex = null;
+                const enabledElement = getEnabledElement(element);
+                triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+                if (newAnnotation) {
+                    triggerAnnotationCompleted(annotation);
+                }
+                this.editData = null;
+                return annotation.annotationUID;
+            }
+        };
+        this._activateModify = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateModify = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._activateDraw = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateDraw = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = getAnnotations(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const targetId = this.getTargetId(viewport);
+            const renderingEngine = viewport.getRenderingEngine();
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { points, activeHandleIndex } = data.handles;
+                styleSpecifier.annotationUID = annotationUID;
+                const { color, lineWidth, lineDash, shadow } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                let activeHandleCanvasCoords;
+                if (!data.cachedStats[targetId] ||
+                    data.cachedStats[targetId].unit == null) {
+                    data.cachedStats[targetId] = {
+                        length: null,
+                        unit: null,
+                    };
+                    this._calculateCachedStats(annotation, renderingEngine, enabledElement);
+                }
+                else if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, renderingEngine, enabledElement);
+                }
+                if (!isAnnotationVisible(annotationUID)) {
+                    continue;
+                }
+                if (!isAnnotationLocked(annotation) &&
+                    !this.editData &&
+                    activeHandleIndex !== null) {
+                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                }
+                if (activeHandleCanvasCoords) {
+                    const handleGroupUID = '0';
+                    drawHandlesSvg(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
+                        color,
+                        lineDash,
+                        lineWidth,
+                    });
+                }
+                const heightUID = '0';
+                drawHeightSvg(svgDrawingHelper, annotationUID, heightUID, canvasCoordinates[0], canvasCoordinates[1], {
+                    color,
+                    width: lineWidth,
+                    lineDash: lineDash,
+                });
+                renderStatus = true;
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.handles.textBox = {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    };
+                    continue;
+                }
+                const textLines = this.configuration.getTextLines(data, targetId);
+                if (!data.handles.textBox.hasMoved) {
+                    const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
+                    data.handles.textBox.worldPosition =
+                        viewport.canvasToWorld(canvasTextBoxCoords);
+                }
+                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                const textBoxUID = '1';
+                const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                const { x: left, y: top, width, height } = boundingBox;
+                data.handles.textBox.worldBoundingBox = {
+                    topLeft: viewport.canvasToWorld([left, top]),
+                    topRight: viewport.canvasToWorld([left + width, top]),
+                    bottomLeft: viewport.canvasToWorld([left, top + height]),
+                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
+                };
+            }
+            return renderStatus;
+        };
+        this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
+    }
+    handleSelectedCallback(evt, annotation, handle) {
+        const eventDetail = evt.detail;
+        const { element } = eventDetail;
+        const { data } = annotation;
+        annotation.highlighted = true;
+        let movingTextBox = false;
+        let handleIndex;
+        if (handle.worldPosition) {
+            movingTextBox = true;
+        }
+        else {
+            handleIndex = data.handles.points.findIndex((p) => p === handle);
+        }
+        const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+        this.editData = {
+            annotation,
+            viewportIdsToRender,
+            handleIndex,
+            movingTextBox,
+        };
+        this._activateModify(element);
+        hideElementCursor(element);
+        const enabledElement = getEnabledElement(element);
+        const { renderingEngine } = enabledElement;
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        evt.preventDefault();
+    }
+    _calculateHeight(pos1, pos2) {
+        const dx = pos2[0] - pos1[0];
+        const dy = pos2[1] - pos1[1];
+        const dz = pos2[2] - pos1[2];
+        if (dx == 0) {
+            if (dy != 0) {
+                return Math.abs(dz);
+            }
+            else {
+                return 0;
+            }
+        }
+        else if (dy == 0) {
+            return Math.abs(dz);
+        }
+        else if (dz == 0) {
+            return Math.abs(dy);
+        }
+    }
+    _calculateCachedStats(annotation, renderingEngine, enabledElement) {
+        const data = annotation.data;
+        const { element } = enabledElement.viewport;
+        const worldPos1 = data.handles.points[0];
+        const worldPos2 = data.handles.points[1];
+        const { cachedStats } = data;
+        const targetIds = Object.keys(cachedStats);
+        for (let i = 0; i < targetIds.length; i++) {
+            const targetId = targetIds[i];
+            const image = this.getTargetIdImage(targetId, renderingEngine);
+            if (!image) {
+                continue;
+            }
+            const { imageData, dimensions } = image;
+            const index1 = transformWorldToIndex(imageData, worldPos1);
+            const index2 = transformWorldToIndex(imageData, worldPos2);
+            const handles = [index1, index2];
+            const { scale, lengthUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+            const height = this._calculateHeight(worldPos1, worldPos2) / scale;
+            const outside = this._isInsideVolume(index1, index2, dimensions);
+            this.isHandleOutsideImage = outside;
+            cachedStats[targetId] = {
+                height,
+                lengthUnits,
+            };
+        }
+        annotation.invalidated = false;
+        triggerAnnotationModified(annotation, element);
+        return cachedStats;
+    }
+    _isInsideVolume(index1, index2, dimensions) {
+        return (csUtils.indexWithinDimensions(index1, dimensions) &&
+            csUtils.indexWithinDimensions(index2, dimensions));
+    }
+}
+function defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { height, lengthUnits } = cachedVolumeStats;
+    if (height === undefined || height === null || isNaN(height)) {
+        return;
+    }
+    const textLines = [`${roundNumber(height)} ${lengthUnits}`];
+    return textLines;
+}
+HeightTool.toolName = 'Height';
+export default HeightTool;

package/dist/esm/tools/annotation/KeyImageTool.d.ts

@@ -1,14 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { Annotation } from '../../types';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
+import type { Annotation } from '../../types';
 declare class KeyImageTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;

package/dist/esm/tools/annotation/LengthTool.d.ts

@@ -1,14 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { LengthAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import type { LengthAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class LengthTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;
@@ -24,7 +22,7 @@ declare class LengthTool extends AnnotationTool {
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: LengthAnnotation, handle: ToolHandle): void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;
     _deactivateModify: (element: HTMLDivElement) => void;
     _activateDraw: (element: HTMLDivElement) => void;

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

@@ -178,8 +178,6 @@ class LengthTool extends AnnotationTool {
                 annotation.invalidated = true;
             }
             this.editData.hasMoved = true;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.cancel = (element) => {
@@ -267,7 +265,6 @@ class LengthTool extends AnnotationTool {
                     styleSpecifier,
                 });
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-                let activeHandleCanvasCoords;
                 if (!data.cachedStats[targetId] ||
                     data.cachedStats[targetId].unit == null) {
                     data.cachedStats[targetId] = {
@@ -279,6 +276,11 @@ class LengthTool extends AnnotationTool {
                 else if (annotation.invalidated) {
                     this._throttledCalculateCachedStats(annotation, renderingEngine, enabledElement);
                 }
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                let activeHandleCanvasCoords;
                 if (!isAnnotationVisible(annotationUID)) {
                     continue;
                 }
@@ -414,11 +416,11 @@ class LengthTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { length, unit } = cachedVolumeStats;
+    const { length, lengthUnits } = cachedVolumeStats;
     if (length === undefined || length === null || isNaN(length)) {
         return;
     }
-    const textLines = [`${roundNumber(length)} ${unit}`];
+    const textLines = [`${roundNumber(length)} ${lengthUnits}`];
     return textLines;
 }
 LengthTool.toolName = 'Length';

package/dist/esm/tools/annotation/LivewireContourTool.d.ts

@@ -1,16 +1,15 @@
 import type { Types } from '@cornerstonejs/core';
 import { ChangeTypes } from '../../enums';
 import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { LivewireContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { LivewireContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import { LivewireScissors } from '../../utilities/livewire/LivewireScissors';
 import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
+import type { AnnotationStyle } from '../../types/AnnotationStyle';
 declare class LivewireContourTool extends ContourSegmentationBaseTool {
     static toolName: string;
     protected scissors: LivewireScissors;
     protected scissorsNext: LivewireScissors;
-    touchDragCallback: any;
-    mouseDragCallback: any;
     editData: {
         annotation: LivewireContourAnnotation;
         viewportIdsToRender: Array<string>;
@@ -55,7 +54,7 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
         enabledElement: Types.IEnabledElement;
         targetId: string;
         annotation: LivewireContourAnnotation;
-        annotationStyle: Record<string, any>;
+        annotationStyle: AnnotationStyle;
         svgDrawingHelper: SVGDrawingHelper;
     }): boolean;
     protected updateAnnotation(livewirePath: LivewirePath): void;

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

@@ -287,10 +287,11 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         const { imageData: vtkImageData } = viewportImageData;
         let worldToSlice;
         let sliceToWorld;
-        let { scalarData } = viewportImageData;
         let width;
         let height;
+        let scalarData;
         if (!(viewport instanceof VolumeViewport) && scalarData) {
+            ({ scalarData } = viewportImageData);
             width = viewportImageData.dimensions[0];
             height = viewportImageData.dimensions[1];
             worldToSlice = (point) => {

package/dist/esm/tools/annotation/PlanarFreehandROITool.d.ts

@@ -1,12 +1,10 @@
 import type { Types } from '@cornerstonejs/core';
 import type { EventTypes, ToolHandle, Annotation, Annotations, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
-import { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     private commonData?;
     isDrawing: boolean;
     isEditingClosed: boolean;
@@ -37,6 +35,25 @@ declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     _calculateStatsIfActive(annotation: PlanarFreehandROIAnnotation, targetId: string, viewport: any, renderingEngine: any, enabledElement: any): void;
     private _calculateCachedStats;
+    protected updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, pixelValueUnits, canvasCoordinates, calibratedScale, }: {
+        viewport: any;
+        points: any;
+        imageData: any;
+        metadata: any;
+        cachedStats: any;
+        targetId: any;
+        pixelValueUnits: any;
+        canvasCoordinates: any;
+        calibratedScale: any;
+    }): void;
+    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, pixelValueUnits, calibratedScale, }: {
+        targetId: any;
+        metadata: any;
+        canvasCoordinates: any;
+        cachedStats: any;
+        pixelValueUnits: any;
+        calibratedScale: any;
+    }): void;
     private _renderStats;
 }
 export default PlanarFreehandROITool;