@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

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

@@ -1,11 +1,10 @@
-import { cache, getEnabledElement, utilities as csUtils, } from '@cornerstonejs/core';
+import { cache, getEnabledElement, utilities as csUtils, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, } from '../../stateManagement/segmentation';
 import floodFill from '../../utilities/segmentation/floodFill';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 const { transformWorldToIndex, isEqual } = csUtils;
 class PaintFillTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -20,39 +19,36 @@ class PaintFillTool extends BaseTool {
             const { viewport } = enabledElement;
             const camera = viewport.getCamera();
             const { viewPlaneNormal } = camera;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-            const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+            const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
             const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             let dimensions;
             let direction;
             let scalarData;
             let index;
-            if (isVolumeSegmentation(labelmapData, viewport)) {
-                const { volumeId } = representationData[type];
+            let voxelManager;
+            if (viewport instanceof BaseVolumeViewport) {
+                const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
                 const segmentation = cache.getVolume(volumeId);
                 ({ dimensions, direction } = segmentation);
-                scalarData = segmentation.getScalarData();
+                voxelManager = segmentation.voxelManager;
                 index = transformWorldToIndex(segmentation.imageData, worldPos);
             }
             else {
-                const { imageIdReferenceMap } = labelmapData;
-                const currentImageId = enabledElement.viewport.getCurrentImageId();
-                const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
+                const currentSegmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 if (!currentSegmentationImageId) {
                     throw new Error('No active segmentation imageId detected, create one before using scissors tool');
                 }
-                const segmentationImage = cache.getImage(currentSegmentationImageId);
-                scalarData = segmentationImage.getPixelData();
                 const { imageData } = viewport.getImageData();
                 dimensions = imageData.getDimensions();
                 direction = imageData.getDirection();
+                const image = cache.getImage(currentSegmentationImageId);
+                voxelManager = image.voxelManager;
                 index = transformWorldToIndex(imageData, worldPos);
             }
             const fixedDimension = this.getFixedDimension(viewPlaneNormal, direction);
@@ -60,7 +56,7 @@ class PaintFillTool extends BaseTool {
                 console.warn('Oblique paint fill not yet supported');
                 return;
             }
-            const { floodFillGetter, getLabelValue, getScalarDataPositionFromPlane, inPlaneSeedPoint, fixedDimensionValue, } = this.generateHelpers(scalarData, dimensions, index, fixedDimension);
+            const { floodFillGetter, getLabelValue, getScalarDataPositionFromPlane, inPlaneSeedPoint, fixedDimensionValue, } = this.generateHelpers(voxelManager, dimensions, index, fixedDimension);
             if (index[0] < 0 ||
                 index[0] >= dimensions[0] ||
                 index[1] < 0 ||
@@ -76,8 +72,8 @@ class PaintFillTool extends BaseTool {
             const floodFillResult = floodFill(floodFillGetter, inPlaneSeedPoint);
             const { flooded } = floodFillResult;
             flooded.forEach((index) => {
-                const scalarDataPosition = getScalarDataPositionFromPlane(index[0], index[1]);
-                scalarData[scalarDataPosition] = segmentIndex;
+                const scalarDataIndex = getScalarDataPositionFromPlane(index[0], index[1]);
+                voxelManager.setAtIndex(scalarDataIndex, segmentIndex);
             });
             const framesModified = this.getFramesModified(fixedDimension, fixedDimensionValue, floodFillResult);
             triggerSegmentationDataModified(segmentationId, framesModified);
@@ -105,7 +101,7 @@ class PaintFillTool extends BaseTool {
             }
             return framesModified;
         };
-        this.generateHelpers = (scalarData, dimensions, seedIndex3D, fixedDimension = 2) => {
+        this.generateHelpers = (voxelManager, dimensions, seedIndex3D, fixedDimension = 2) => {
             let fixedDimensionValue;
             let inPlaneSeedPoint;
             switch (fixedDimension) {
@@ -125,10 +121,10 @@ class PaintFillTool extends BaseTool {
                     throw new Error(`Invalid fixedDimension: ${fixedDimension}`);
             }
             const getScalarDataPosition = (x, y, z) => {
-                return z * dimensions[1] * dimensions[0] + y * dimensions[0] + x;
+                return voxelManager.toIndex([x, y, z]);
             };
             const getLabelValue = (x, y, z) => {
-                return scalarData[getScalarDataPosition(x, y, z)];
+                return voxelManager.getAtIJK(x, y, z);
             };
             const floodFillGetter = this.generateFloodFillGetter(dimensions, fixedDimension, fixedDimensionValue, getLabelValue);
             const getScalarDataPositionFromPlane = this.generateGetScalarDataPositionFromPlane(getScalarDataPosition, fixedDimension, fixedDimensionValue);
@@ -233,4 +229,3 @@ class PaintFillTool extends BaseTool {
 }
 PaintFillTool.toolName = 'PaintFill';
 export default PaintFillTool;
-//# sourceMappingURL=PaintFillTool.js.map

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

@@ -0,0 +1,69 @@
+import type { Types } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
+import type { RectangleROIStartEndThresholdAnnotation, ROICachedStats } from '../../types/ToolSpecificAnnotationTypes';
+import RectangleROITool from '../annotation/RectangleROITool';
+declare class RectangleROIStartEndThresholdTool extends RectangleROITool {
+    static toolName: any;
+    _throttledCalculateCachedStats: Function;
+    editData: {
+        annotation: Annotation;
+        viewportIdsToRender: string[];
+        handleIndex?: number;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => {
+        highlighted: boolean;
+        invalidated: boolean;
+        metadata: {
+            viewPlaneNormal: Types.Point3;
+            enabledElement: Types.IEnabledElement;
+            viewUp: Types.Point3;
+            FrameOfReferenceUID: string;
+            referencedImageId: any;
+            toolName: string;
+            volumeId: any;
+            spacingInNormal: number;
+        };
+        data: {
+            label: string;
+            startCoordinate: number;
+            endCoordinate: number;
+            cachedStats: {
+                pointsInVolume: any[];
+                projectionPoints: any[];
+                projectionPointsImageIds: any[];
+                statistics: ROICachedStats;
+            };
+            handles: {
+                textBox: {
+                    hasMoved: boolean;
+                    worldPosition: Types.Point3;
+                    worldBoundingBox: {
+                        topLeft: Types.Point3;
+                        topRight: Types.Point3;
+                        bottomLeft: Types.Point3;
+                        bottomRight: Types.Point3;
+                    };
+                };
+                points: Types.Point3[];
+                activeHandleIndex: any;
+            };
+            labelmapUID: any;
+        };
+    };
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    _computeProjectionPoints(annotation: RectangleROIStartEndThresholdAnnotation, imageVolume: Types.IImageVolume): void;
+    _computePointsInsideVolume(annotation: any, targetId: any, imageVolume: any, enabledElement: any): void;
+    _calculateCachedStatsTool(annotation: any, enabledElement: any): any;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    _getStartCoordinate(worldPos: Types.Point3, viewPlaneNormal: Types.Point3): number | undefined;
+    _getEndCoordinate(worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal: Types.Point3): number;
+    _getCoordinateForViewplaneNormal(pos: vec3 | number, viewPlaneNormal: Types.Point3): number | undefined;
+}
+export default RectangleROIStartEndThresholdTool;

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

@@ -1,23 +1,32 @@
-import { getEnabledElement, cache, StackViewport, metaData, utilities as csUtils, } from '@cornerstonejs/core';
+import { getEnabledElement, cache, StackViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
-import { drawHandles as drawHandlesSvg, drawRect as drawRectSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawRect as drawRectSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import throttle from '../../utilities/throttle';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
+import getWorldWidthAndHeightFromCorners from '../../utilities/planar/getWorldWidthAndHeightFromCorners';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { hideElementCursor, resetElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { triggerAnnotationCompleted } from '../../stateManagement/annotation/helpers/state';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import RectangleROITool from '../annotation/RectangleROITool';
-import { pointInShapeCallback } from '../../utilities/';
+import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
+import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 const { transformWorldToIndex } = csUtils;
 class RectangleROIStartEndThresholdTool extends RectangleROITool {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
+            storePointData: false,
             numSlicesToPropagate: 10,
             computePointsInsideVolume: false,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
+            showTextBox: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -40,12 +49,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 imageVolume = cache.getVolume(volumeId);
                 referencedImageId = csUtils.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
             }
-            if (!referencedImageId) {
-                throw new Error('This tool does not work on non-acquisition planes');
-            }
-            const startIndex = viewport.getCurrentImageIdIndex();
             const spacingInNormal = csUtils.getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
-            const endIndex = this._getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal);
+            const startCoord = this._getStartCoordinate(worldPos, viewPlaneNormal);
+            const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             const annotation = {
                 highlighted: true,
@@ -62,18 +68,24 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 },
                 data: {
                     label: '',
-                    startSlice: startIndex,
-                    endSlice: endIndex,
+                    startCoordinate: startCoord,
+                    endCoordinate: endCoord,
                     cachedStats: {
                         pointsInVolume: [],
                         projectionPoints: [],
                         projectionPointsImageIds: [referencedImageId],
+                        statistics: [],
                     },
                     handles: {
                         textBox: {
                             hasMoved: false,
-                            worldPosition: null,
-                            worldBoundingBox: null,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
                         },
                         points: [
                             [...worldPos],
@@ -99,7 +111,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return annotation;
         };
         this._endCallback = (evt) => {
@@ -124,9 +136,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             const targetId = this.getTargetId(enabledElement.viewport);
             const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
             if (this.configuration.calculatePointsInsideVolume) {
-                this._computePointsInsideVolume(annotation, imageVolume, enabledElement);
+                this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
             }
-            triggerAnnotationRenderForViewportIds(enabledElement.renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
                 triggerAnnotationCompleted(annotation);
             }
@@ -134,11 +146,11 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             let renderStatus = false;
             const { viewport } = enabledElement;
-            const annotations = getAnnotations(this.getToolName(), viewport.element);
+            let annotations = getAnnotations(this.getToolName(), viewport.element);
             if (!annotations?.length) {
                 return renderStatus;
             }
-            const sliceIndex = viewport.getCurrentImageIdIndex();
+            annotations = filterAnnotationsWithinSamePlane(annotations, viewport.getCamera());
             const styleSpecifier = {
                 toolGroupId: this.toolGroupId,
                 toolName: this.getToolName(),
@@ -147,22 +159,43 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             for (let i = 0; i < annotations.length; i++) {
                 const annotation = annotations[i];
                 const { annotationUID, data } = annotation;
-                const { startSlice, endSlice } = data;
+                const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
                 const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
                 const color = this.getStyle('color', styleSpecifier, annotation);
-                if (sliceIndex < Math.min(startSlice, endSlice) ||
-                    sliceIndex > Math.max(startSlice, endSlice)) {
+                const focalPoint = viewport.getCamera().focalPoint;
+                const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+                let startCoord = startCoordinate;
+                let endCoord = endCoordinate;
+                if (Array.isArray(startCoordinate)) {
+                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
+                }
+                if (Array.isArray(endCoordinate)) {
+                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                    data.endCoordinate = endCoord;
+                    data.endCoordinate = endCoord;
+                }
+                const roundedStartCoord = csUtils.roundToPrecision(startCoord);
+                const roundedEndCoord = csUtils.roundToPrecision(endCoord);
+                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCoord = csUtils.roundToPrecision(coord);
+                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
                 }
                 if (annotation.invalidated) {
                     this._throttledCalculateCachedStats(annotation, enabledElement);
                 }
                 let firstOrLastSlice = false;
-                if (sliceIndex === startSlice || sliceIndex === endSlice) {
+                if (roundedCoord === roundedStartCoord ||
+                    roundedCoord === roundedEndCoord) {
                     firstOrLastSlice = true;
                 }
                 if (!viewport.getRenderingEngine()) {
@@ -173,7 +206,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 if (!isAnnotationVisible(annotationUID)) {
                     continue;
                 }
-                if (!isAnnotationLocked(annotation) &&
+                if (!isAnnotationLocked(annotationUID) &&
                     !this.editData &&
                     activeHandleIndex !== null &&
                     firstOrLastSlice) {
@@ -196,6 +229,42 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                     lineWidth,
                 });
                 renderStatus = true;
+                if (this.configuration.showTextBox &&
+                    this.configuration.calculatePointsInsideVolume) {
+                    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);
+                    if (!textLines || textLines.length === 0) {
+                        continue;
+                    }
+                    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;
         };
@@ -205,17 +274,26 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { imageData } = imageVolume;
-        const { startSlice, endSlice } = data;
+        const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
         const startIJK = transformWorldToIndex(imageData, points[0]);
-        if (startIJK[2] !== startSlice) {
-            throw new Error('Start slice does not match');
-        }
-        const endIJK = vec3.fromValues(startIJK[0], startIJK[1], endSlice);
+        const endIJK = transformWorldToIndex(imageData, points[0]);
         const startWorld = vec3.create();
         imageData.indexToWorldVec3(startIJK, startWorld);
         const endWorld = vec3.create();
         imageData.indexToWorldVec3(endIJK, endWorld);
+        if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 2) {
+            startWorld[2] = startCoordinate;
+            endWorld[2] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0) {
+            startWorld[0] = startCoordinate;
+            endWorld[0] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1) {
+            startWorld[1] = startCoordinate;
+            endWorld[1] = endCoordinate;
+        }
         const distance = vec3.distance(startWorld, endWorld);
         const newProjectionPoints = [];
         for (let dist = 0; dist < distance; dist += spacingInNormal) {
@@ -226,34 +304,45 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             }));
         }
         data.cachedStats.projectionPoints = newProjectionPoints;
-        const projectionPointsImageIds = [];
-        for (const RectanglePoints of newProjectionPoints) {
-            const imageId = csUtils.getClosestImageId(imageVolume, RectanglePoints[0], viewPlaneNormal);
-            projectionPointsImageIds.push(imageId);
-        }
-        data.cachedStats.projectionPointsImageIds = projectionPointsImageIds;
     }
-    _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-        const { data } = annotation;
+    _computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, viewUp } = metadata;
+        const { viewport } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
+        const image = this.getTargetImageData(targetId);
+        const worldPos1 = data.handles.points[0];
+        const worldPos2 = data.handles.points[3];
+        const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+        const measureInfo = getCalibratedLengthUnitsAndScale(image, data.habdles);
+        const area = Math.abs(worldWidth * worldHeight) /
+            (measureInfo.scale * measureInfo.scale);
+        const modalityUnitOptions = {
+            isPreScaled: isViewportPreScaled(viewport, targetId),
+            isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+        };
+        const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
             }
             const projectionPoint = projectionPoints[i][0];
-            const worldPos1 = data.handles.points[0];
-            const worldPos2 = data.handles.points[3];
-            const { dimensions, imageData } = imageVolume;
+            const { dimensions, imageData, voxelManager } = imageVolume;
             const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
             const worldProjectionPointIndex = transformWorldToIndex(imageData, projectionPoint);
+            const indexOfProjection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
             worldPos1Index[0] = Math.floor(worldPos1Index[0]);
             worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-            worldPos1Index[2] = Math.floor(worldProjectionPointIndex[2]);
+            worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+            worldPos1Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
             worldPos2Index[0] = Math.floor(worldPos2Index[0]);
             worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-            worldPos2Index[2] = Math.floor(worldProjectionPointIndex[2]);
+            worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+            worldPos2Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
                 this.isHandleOutsideImage = false;
                 const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
@@ -267,11 +356,26 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                     [jMin, jMax],
                     [kMin, kMax],
                 ];
-                const pointsInShape = pointInShapeCallback(imageData, () => true, null, boundsIJK);
+                const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                    boundsIJK,
+                    imageData,
+                    returnPoints: this.configuration.storePointData,
+                });
                 pointsInsideVolume.push(pointsInShape);
             }
         }
+        const stats = this.configuration.statsCalculator.getStatistics();
         data.cachedStats.pointsInVolume = pointsInsideVolume;
+        data.cachedStats.statistics = {
+            Modality: metadata.Modality,
+            area,
+            mean: stats.mean?.value,
+            stdDev: stats.stdDev?.value,
+            max: stats.max?.value,
+            statsArray: stats.array,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
+        };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
         const data = annotation.data;
@@ -280,30 +384,54 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         const targetId = this.getTargetId(viewport);
         const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
         this._computeProjectionPoints(annotation, imageVolume);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
         annotation.invalidated = false;
         triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;
     }
-    _getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal) {
+    _getStartCoordinate(worldPos, viewPlaneNormal) {
+        const startPos = worldPos;
+        const startCoord = this._getCoordinateForViewplaneNormal(startPos, viewPlaneNormal);
+        return startCoord;
+    }
+    _getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
         const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
         const endPos = vec3.create();
         vec3.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagate * spacingInNormal);
-        const halfSpacingInNormalDirection = spacingInNormal / 2;
-        const { imageIds } = imageVolume;
-        let imageIdIndex;
-        for (let i = 0; i < imageIds.length; i++) {
-            const imageId = imageIds[i];
-            const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
-            const dir = vec3.create();
-            vec3.sub(dir, endPos, imagePositionPatient);
-            const dot = vec3.dot(dir, viewPlaneNormal);
-            if (Math.abs(dot) < halfSpacingInNormalDirection) {
-                imageIdIndex = i;
-            }
-        }
-        return imageIdIndex;
+        const endCoord = this._getCoordinateForViewplaneNormal(endPos, viewPlaneNormal);
+        return endCoord;
+    }
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) {
+        const viewplaneNormalAbs = [
+            Math.abs(viewPlaneNormal[0]),
+            Math.abs(viewPlaneNormal[1]),
+            Math.abs(viewPlaneNormal[2]),
+        ];
+        const indexOfDirection = viewplaneNormalAbs.indexOf(Math.max(...viewplaneNormalAbs));
+        return indexOfDirection;
+    }
+    _getCoordinateForViewplaneNormal(pos, viewPlaneNormal) {
+        const indexOfDirection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+        return pos[indexOfDirection];
+    }
+}
+function defaultGetTextLines(data) {
+    const cachedVolumeStats = data.cachedStats.statistics;
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
     }
+    const textLines = [];
+    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
+    return textLines;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 export default RectangleROIStartEndThresholdTool;
-//# sourceMappingURL=RectangleROIStartEndThresholdTool.js.map

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

@@ -0,0 +1,45 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
+import RectangleROITool from '../annotation/RectangleROITool';
+declare class RectangleROIThresholdTool extends RectangleROITool {
+    static toolName: any;
+    _throttledCalculateCachedStats: Function;
+    editData: {
+        annotation: Annotation;
+        viewportIdsToRender: string[];
+        handleIndex?: number;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => {
+        highlighted: boolean;
+        invalidated: boolean;
+        metadata: {
+            viewPlaneNormal: Types.Point3;
+            enabledElement: Types.IEnabledElement;
+            viewUp: Types.Point3;
+            FrameOfReferenceUID: string;
+            referencedImageId: any;
+            toolName: string;
+            volumeId: any;
+        };
+        data: {
+            label: string;
+            handles: {
+                textBox: {
+                    hasMoved: boolean;
+                    worldPosition: any;
+                    worldBoundingBox: any;
+                };
+                points: Types.Point3[];
+                activeHandleIndex: any;
+            };
+            segmentationId: any;
+        };
+    };
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+}
+export default RectangleROIThresholdTool;

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

@@ -80,7 +80,7 @@ class RectangleROIThresholdTool extends RectangleROITool {
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return annotation;
         };
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
@@ -118,7 +118,7 @@ class RectangleROIThresholdTool extends RectangleROITool {
                 if (!isAnnotationVisible(annotationUID)) {
                     continue;
                 }
-                if (!isAnnotationLocked(annotation) &&
+                if (!isAnnotationLocked(annotationUID) &&
                     !this.editData &&
                     activeHandleIndex !== null) {
                     activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
@@ -143,4 +143,3 @@ class RectangleROIThresholdTool extends RectangleROITool {
 }
 RectangleROIThresholdTool.toolName = 'RectangleROIThreshold';
 export default RectangleROIThresholdTool;
-//# sourceMappingURL=RectangleROIThresholdTool.js.map