@cornerstonejs/tools 3.24.0 → 3.26.0

package/dist/esm/stateManagement/segmentation/utilities/convertContourHoles.d.ts

@@ -0,0 +1 @@
+export default function convertContourHoles(segmentationId: string, segmentIndex: number, targetSegmentationId?: string, targetSegmentationIndex?: number): void;

package/dist/esm/stateManagement/segmentation/utilities/convertContourHoles.js

@@ -0,0 +1,66 @@
+import { findContourHoles } from '../../../utilities/contours';
+import { getAnnotation, clearParentAnnotation, } from '../../annotation/annotationState';
+import { getSegmentation } from '../getSegmentation';
+import { extractSegmentPolylines } from './extractSegmentPolylines';
+export default function convertContourHoles(segmentationId, segmentIndex, targetSegmentationId, targetSegmentationIndex) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        console.warn(`No contour representation found for segmentation ${segmentationId}`);
+        return;
+    }
+    const { annotationUIDsMap } = segmentation?.representationData.Contour || {};
+    if (!annotationUIDsMap) {
+        console.warn(`No annotation map found for segmentation ${segmentationId}`);
+        return;
+    }
+    const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
+    if (!annotationsUIDsSet) {
+        console.warn(`Segmentation index ${segmentIndex} has no annotations in segmentation ${segmentationId}`);
+        return;
+    }
+    let targetUIDsSet;
+    if (targetSegmentationId && typeof targetSegmentationIndex === 'number') {
+        const targetSegmentation = getSegmentation(targetSegmentationId);
+        if (!targetSegmentation) {
+            console.warn(`Target segmentation ${targetSegmentationId} does not exist.`);
+            return;
+        }
+        if (!targetSegmentation.representationData.Contour) {
+            console.warn(`No contour representation found for target segmentation ${targetSegmentationId}`);
+            return;
+        }
+        targetUIDsSet =
+            targetSegmentation.representationData.Contour.annotationUIDsMap.get(targetSegmentationIndex);
+        if (!targetUIDsSet) {
+            targetUIDsSet = new Set();
+            targetSegmentation.representationData.Contour.annotationUIDsMap.set(targetSegmentationIndex, targetUIDsSet);
+        }
+    }
+    const polylinesCanvasMap = extractSegmentPolylines(segmentationId, segmentIndex);
+    if (!polylinesCanvasMap) {
+        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
+        return;
+    }
+    const keys = Array.from(polylinesCanvasMap?.keys());
+    const polylines = keys.map((key) => polylinesCanvasMap.get(key));
+    const holeDetectionResults = findContourHoles(polylines);
+    if (holeDetectionResults?.length > 0) {
+        holeDetectionResults.forEach((hole) => {
+            hole.holeIndexes.forEach((index) => {
+                const annotation = getAnnotation(keys[index]);
+                clearParentAnnotation(annotation);
+                if (targetSegmentationId &&
+                    typeof targetSegmentationIndex === 'number') {
+                    targetUIDsSet.add(annotation.annotationUID);
+                }
+                else {
+                    annotationsUIDsSet.add(annotation.annotationUID);
+                }
+            });
+        });
+    }
+}

package/dist/esm/stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation.d.ts

@@ -0,0 +1 @@
+export declare function getAnnotationsUIDMapFromSegmentation(segmentationId: string): Map<number, Set<string>>;

package/dist/esm/stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation.js

@@ -0,0 +1,17 @@
+import { getSegmentation } from '../getSegmentation';
+export function getAnnotationsUIDMapFromSegmentation(segmentationId) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    const contourRepresentationData = segmentation.representationData
+        ?.Contour;
+    if (!contourRepresentationData) {
+        return;
+    }
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    return annotationUIDsMap;
+}

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

@@ -1,4 +1,5 @@
 export { getViewportAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export { getAnnotationsUIDMapFromSegmentation } from './getAnnotationsUIDMapFromSegmentation';
 export { getAnnotationMapFromSegmentation } from './getAnnotationMapFromSegmentation';
 export { default as decimateContours } from './decimateContours';
 export { extractSegmentPolylines } from './extractSegmentPolylines';
@@ -6,3 +7,4 @@ export { removeCompleteContourAnnotation } from './removeCompleteContourAnnotati
 export { default as removeContourHoles } from './removeContourHoles';
 export { default as removeContourIslands } from './removeContourIslands';
 export { default as smoothContours } from './smoothContours';
+export { default as convertContourHoles } from './convertContourHoles';

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

@@ -1,4 +1,6 @@
+import { getAnnotationsUIDMapFromSegmentation } from './getAnnotationsUIDMapFromSegmentation';
 export { getViewportAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export { getAnnotationsUIDMapFromSegmentation } from './getAnnotationsUIDMapFromSegmentation';
 export { getAnnotationMapFromSegmentation } from './getAnnotationMapFromSegmentation';
 export { default as decimateContours } from './decimateContours';
 export { extractSegmentPolylines } from './extractSegmentPolylines';
@@ -6,3 +8,4 @@ export { removeCompleteContourAnnotation } from './removeCompleteContourAnnotati
 export { default as removeContourHoles } from './removeContourHoles';
 export { default as removeContourIslands } from './removeContourIslands';
 export { default as smoothContours } from './smoothContours';
+export { default as convertContourHoles } from './convertContourHoles';

package/dist/esm/stateManagement/segmentation/utilities/removeContourHoles.js

@@ -1,6 +1,5 @@
 import { findContourHoles } from '../../../utilities/contours';
 import { getAnnotation } from '../../annotation/annotationState';
-import { triggerAnnotationRemoved } from '../../annotation/helpers/state';
 import { getSegmentation } from '../getSegmentation';
 import { extractSegmentPolylines } from './extractSegmentPolylines';
 import { removeCompleteContourAnnotation } from './removeCompleteContourAnnotation';

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/annotation/SplineROITool.d.ts

@@ -64,6 +64,8 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     protected isContourSegmentationTool(): boolean;
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     protected createInterpolatedSplineControl(annotation: any): void;
+    isSplineAnnotation(annotation: ContourAnnotation): boolean;
+    createSplineObjectFromType(annotation: ContourAnnotation, splineType: string): void;
     protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
     private _renderStats;
     addControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;

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

@@ -41,6 +41,12 @@ var SplineToolActions;
     SplineToolActions["AddControlPoint"] = "addControlPoint";
     SplineToolActions["DeleteControlPoint"] = "deleteControlPoint";
 })(SplineToolActions || (SplineToolActions = {}));
+const splineToolNames = [
+    'CatmullRomSplineROI',
+    'LinearSplineROI',
+    'BSplineROI',
+    'CardinalSplineROI',
+];
 class SplineROITool extends ContourSegmentationBaseTool {
     static { this.toolName = 'SplineROI'; }
     static { this.SplineTypes = SplineTypesEnum; }
@@ -684,6 +690,18 @@ class SplineROITool extends ContourSegmentationBaseTool {
         }
         points.push(polyline[polyline.length - 1]);
     }
+    isSplineAnnotation(annotation) {
+        return splineToolNames.includes(annotation?.metadata?.toolName);
+    }
+    createSplineObjectFromType(annotation, splineType) {
+        const splineConfig = this._getSplineConfig(splineType);
+        const spline = new splineConfig.Class();
+        annotation.data.spline = {
+            type: splineConfig.type,
+            instance: spline,
+            resolution: splineConfig.resolution,
+        };
+    }
     createAnnotation(evt) {
         const contourAnnotation = super.createAnnotation(evt);
         const { world: worldPos } = evt.detail.currentPoints;

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;