@cornerstonejs/tools 2.0.5 → 2.1.1

package/dist/esm/index.d.ts

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, };

package/dist/esm/index.js

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, };

package/dist/esm/stateManagement/segmentation/SegmentationStateManager.d.ts

@@ -66,6 +66,10 @@ export default class SegmentationStateManager {
         viewportId: string;
         representations: SegmentationRepresentation[];
     }>;
+    getSegmentationRepresentationsBySegmentationId(segmentationId: string): {
+        viewportId: string;
+        representations: SegmentationRepresentation[];
+    }[];
 }
 declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
     imageIds: string[];

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

@@ -424,6 +424,16 @@ export default class SegmentationStateManager {
             representations,
         }));
     }
+    getSegmentationRepresentationsBySegmentationId(segmentationId) {
+        const result = [];
+        Object.entries(this.state.viewportSegRepresentations).forEach(([viewportId, viewportReps]) => {
+            const filteredReps = viewportReps.filter((representation) => representation.segmentationId === segmentationId);
+            if (filteredReps.length > 0) {
+                result.push({ viewportId, representations: filteredReps });
+            }
+        });
+        return result;
+    }
 }
 async function internalComputeVolumeLabelmapFromStack({ imageIds, options, }) {
     const segmentationImageIds = imageIds;

package/dist/esm/stateManagement/segmentation/getSegmentationRepresentation.d.ts

@@ -8,3 +8,7 @@ export declare function getSegmentationRepresentation(viewportId: string, specif
     segmentationId: string;
     type: SegmentationRepresentations;
 }): SegmentationRepresentation | undefined;
+export declare function getSegmentationRepresentationsBySegmentationId(segmentationId: string): {
+    viewportId: string;
+    representations: SegmentationRepresentation[];
+}[];

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

@@ -11,3 +11,7 @@ export function getSegmentationRepresentation(viewportId, specifier) {
     const representations = segmentationStateManager.getSegmentationRepresentations(viewportId, specifier);
     return representations?.[0];
 }
+export function getSegmentationRepresentationsBySegmentationId(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentationRepresentationsBySegmentationId(segmentationId);
+}

package/dist/esm/stateManagement/segmentation/segmentationState.d.ts

@@ -12,6 +12,6 @@ import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
-import { getSegmentationRepresentation, getSegmentationRepresentations } from './getSegmentationRepresentation';
+import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId } from './getSegmentationRepresentation';
 declare function destroy(): void;
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, destroy, };
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };

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

@@ -12,9 +12,9 @@ import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
-import { getSegmentationRepresentation, getSegmentationRepresentations, } from './getSegmentationRepresentation';
+import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId, } from './getSegmentationRepresentation';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 function destroy() {
     defaultSegmentationStateManager.resetState();
 }
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, destroy, };
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };

package/dist/esm/tools/OrientationMarkerTool.d.ts

@@ -44,6 +44,7 @@ declare class OrientationMarkerTool extends BaseTool {
     static AXIS: number;
     static VTPFILE: number;
     orientationMarkers: any;
+    updatingOrientationMarker: any;
     polyDataURL: any;
     _resizeObservers: Map<any, any>;
     static OVERLAY_MARKER_TYPES: typeof OverlayMarkerType;

package/dist/esm/tools/OrientationMarkerTool.js

@@ -91,6 +91,7 @@ class OrientationMarkerTool extends BaseTool {
             orientationWidget.updateViewport();
         };
         this.orientationMarkers = {};
+        this.updatingOrientationMarker = {};
     }
     _unsubscribeToViewportNewVolumeSet() {
         const unsubscribe = () => {
@@ -173,53 +174,58 @@ class OrientationMarkerTool extends BaseTool {
         let viewports = renderingEngine.getViewports();
         viewports = filterViewportsWithToolEnabled(viewports, this.getToolName());
         viewports.forEach((viewport) => {
-            if (!viewport.getWidget(this.getToolName())) {
+            const widget = viewport.getWidget(this.getToolName());
+            if (!widget || widget.isDeleted()) {
                 this.addAxisActorInViewport(viewport);
             }
         });
     }
     async addAxisActorInViewport(viewport) {
         const viewportId = viewport.id;
-        const type = this.configuration.overlayMarkerType;
-        const overlayConfiguration = this.configuration.overlayConfiguration[type];
-        if (this.orientationMarkers[viewportId]) {
-            const { actor, orientationWidget } = this.orientationMarkers[viewportId];
-            viewport.getRenderer().removeActor(actor);
-            orientationWidget.setEnabled(false);
-        }
-        let actor;
-        if (type === 1) {
-            actor = this.createAnnotationCube(overlayConfiguration);
-        }
-        else if (type === 2) {
-            actor = vtkAxesActor.newInstance();
-        }
-        else if (type === 3) {
-            actor = await this.createCustomActor();
+        if (!this.updatingOrientationMarker[viewportId]) {
+            this.updatingOrientationMarker[viewportId] = true;
+            const type = this.configuration.overlayMarkerType;
+            const overlayConfiguration = this.configuration.overlayConfiguration[type];
+            if (this.orientationMarkers[viewportId]) {
+                const { actor, orientationWidget } = this.orientationMarkers[viewportId];
+                viewport.getRenderer().removeActor(actor);
+                orientationWidget.setEnabled(false);
+            }
+            let actor;
+            if (type === 1) {
+                actor = this.createAnnotationCube(overlayConfiguration);
+            }
+            else if (type === 2) {
+                actor = vtkAxesActor.newInstance();
+            }
+            else if (type === 3) {
+                actor = await this.createCustomActor();
+            }
+            const renderer = viewport.getRenderer();
+            const renderWindow = viewport
+                .getRenderingEngine()
+                .offscreenMultiRenderWindow.getRenderWindow();
+            const { enabled, viewportCorner, viewportSize, minPixelSize, maxPixelSize, } = this.configuration.orientationWidget;
+            const orientationWidget = vtkOrientationMarkerWidget.newInstance({
+                actor,
+                interactor: renderWindow.getInteractor(),
+                parentRenderer: renderer,
+            });
+            orientationWidget.setEnabled(enabled);
+            orientationWidget.setViewportCorner(viewportCorner);
+            orientationWidget.setViewportSize(viewportSize);
+            orientationWidget.setMinPixelSize(minPixelSize);
+            orientationWidget.setMaxPixelSize(maxPixelSize);
+            orientationWidget.updateMarkerOrientation();
+            this.orientationMarkers[viewportId] = {
+                orientationWidget,
+                actor,
+            };
+            viewport.addWidget(this.getToolName(), orientationWidget);
+            renderWindow.render();
+            viewport.getRenderingEngine().render();
+            this.updatingOrientationMarker[viewportId] = false;
         }
-        const renderer = viewport.getRenderer();
-        const renderWindow = viewport
-            .getRenderingEngine()
-            .offscreenMultiRenderWindow.getRenderWindow();
-        const { enabled, viewportCorner, viewportSize, minPixelSize, maxPixelSize, } = this.configuration.orientationWidget;
-        const orientationWidget = vtkOrientationMarkerWidget.newInstance({
-            actor,
-            interactor: renderWindow.getInteractor(),
-            parentRenderer: renderer,
-        });
-        orientationWidget.setEnabled(enabled);
-        orientationWidget.setViewportCorner(viewportCorner);
-        orientationWidget.setViewportSize(viewportSize);
-        orientationWidget.setMinPixelSize(minPixelSize);
-        orientationWidget.setMaxPixelSize(maxPixelSize);
-        orientationWidget.updateMarkerOrientation();
-        this.orientationMarkers[viewportId] = {
-            orientationWidget,
-            actor,
-        };
-        viewport.addWidget(this.getToolName(), orientationWidget);
-        renderWindow.render();
-        viewport.getRenderingEngine().render();
     }
     async createCustomActor() {
         const url = this.configuration.overlayConfiguration[OverlayMarkerType.CUSTOM]

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

@@ -0,0 +1,41 @@
+import { AnnotationTool } from '../base';
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
+import type { Annotation } from '../../types/AnnotationTypes';
+export interface ETDRSGridAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: [Types.Point3];
+        };
+    };
+}
+declare class ETDRSGridTool extends AnnotationTool {
+    static toolName: any;
+    touchDragCallback: unknown;
+    mouseDragCallback: unknown;
+    editData: {
+        annotation: Annotation;
+        viewportIdsToRender: Array<string>;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => ETDRSGridAnnotation;
+    worldMeasureToCanvas(measurement: any, viewport: any): number;
+    isPointNearTool: (element: HTMLDivElement, annotation: ETDRSGridAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: ETDRSGridAnnotation) => void;
+    handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: ETDRSGridAnnotation) => void;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragDrawCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragModifyCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragHandle: (evt: EventTypes.InteractionEventType) => void;
+    cancel: (element: HTMLDivElement) => string;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+}
+export default ETDRSGridTool;

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

@@ -0,0 +1,354 @@
+import { AnnotationTool } from '../base';
+import { getEnabledElement } from '@cornerstonejs/core';
+import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
+import { triggerAnnotationCompleted } from '../../stateManagement/annotation/helpers/state';
+import { drawCircle as drawCircleSvg, drawLine } from '../../drawingSvg';
+import { state } from '../../store/state';
+import { Events } from '../../enums';
+import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
+import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { getCanvasCircleRadius } from '../../utilities/math/circle';
+import { vec3 } from 'gl-matrix';
+const CROSSHAIR_SIZE = 5;
+class ETDRSGridTool extends AnnotationTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            shadow: true,
+            preventHandleOutsideImage: false,
+            degrees: [45, 135, 225, 315],
+            diameters: [10, 30, 60],
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.isHandleOutsideImage = false;
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = getEnabledElement(element);
+            const { viewport, renderingEngine } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    toolName: this.getToolName(),
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
+                },
+                data: {
+                    label: '',
+                    handles: {
+                        points: [[...worldPos]],
+                    },
+                },
+            };
+            addAnnotation(annotation, element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                newAnnotation: true,
+            };
+            this._activateDraw(element);
+            hideElementCursor(element);
+            evt.preventDefault();
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            return annotation;
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const { data } = annotation;
+            const { points } = data.handles;
+            const center = viewport.worldToCanvas(points[0]);
+            const radius = getCanvasCircleRadius([center, canvasCoords]);
+            if (Math.abs(radius) < 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,
+            };
+            hideElementCursor(element);
+            this._activateModify(element);
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine } = enabledElement;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this.handleSelectedCallback = (evt, annotation) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+            };
+            this._activateModify(element);
+            hideElementCursor(element);
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine } = enabledElement;
+            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;
+            }
+            annotation.highlighted = false;
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            resetElementCursor(element);
+            const { renderingEngine } = getEnabledElement(element);
+            this.editData = null;
+            this.isDrawing = false;
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                removeAnnotation(annotation.annotationUID);
+            }
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            if (newAnnotation) {
+                triggerAnnotationCompleted(annotation);
+            }
+        };
+        this._dragDrawCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { currentPoints } = eventDetail;
+            const currentCanvasPoints = currentPoints.canvas;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine, viewport } = enabledElement;
+            const { canvasToWorld } = viewport;
+            const { annotation, viewportIdsToRender } = this.editData;
+            const { data } = annotation;
+            data.handles.points = [
+                canvasToWorld(currentCanvasPoints),
+                canvasToWorld(currentCanvasPoints),
+            ];
+            annotation.invalidated = true;
+            this.editData.hasMoved = true;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        };
+        this._dragModifyCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender } = this.editData;
+            const { data } = annotation;
+            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;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine } = enabledElement;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        };
+        this._dragHandle = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const enabledElement = getEnabledElement(element);
+            const { canvasToWorld, worldToCanvas } = enabledElement.viewport;
+            const { annotation } = this.editData;
+            const { data } = annotation;
+            const { points } = data.handles;
+            const canvasCoordinates = points.map((p) => worldToCanvas(p));
+            const { currentPoints } = eventDetail;
+            const currentCanvasPoints = currentPoints.canvas;
+            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);
+        };
+        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 { renderingEngine } = 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._dragModifyCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragModifyCallback);
+            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._dragModifyCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragModifyCallback);
+            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._dragDrawCallback);
+            element.addEventListener(Events.MOUSE_MOVE, this._dragDrawCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragDrawCallback);
+            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._dragDrawCallback);
+            element.removeEventListener(Events.MOUSE_MOVE, this._dragDrawCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragDrawCallback);
+            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 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 { handles } = data;
+                const { points } = handles;
+                styleSpecifier.annotationUID = annotationUID;
+                const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                const center = canvasCoordinates[0];
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                if (!isAnnotationVisible(annotationUID)) {
+                    continue;
+                }
+                let lineUID = `${annotationUID}-crosshair-vertical`;
+                let start = [center[0], center[1] + CROSSHAIR_SIZE];
+                let end = [center[0], center[1] - CROSSHAIR_SIZE];
+                drawLine(svgDrawingHelper, annotationUID, lineUID, start, end, {
+                    color,
+                    lineDash,
+                    lineWidth,
+                });
+                lineUID = `${annotationUID}-crosshair-horizontal`;
+                start = [center[0] + CROSSHAIR_SIZE, center[1]];
+                end = [center[0] - CROSSHAIR_SIZE, center[1]];
+                drawLine(svgDrawingHelper, annotationUID, lineUID, start, end, {
+                    color,
+                    lineDash,
+                    lineWidth,
+                });
+                const diametersCanvas = this.configuration.diameters.map((diameter) => this.worldMeasureToCanvas(diameter, viewport));
+                for (let i = 0; i < diametersCanvas.length; i++) {
+                    const dataId = `${annotationUID}-circle-${i}`;
+                    const circleUID = `${annotationUID}-circle-${i}`;
+                    drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, diametersCanvas[i] / 2, {
+                        color,
+                        lineDash,
+                        lineWidth,
+                    }, dataId);
+                }
+                const degreesRad = (x) => (x * Math.PI) / 180;
+                const angleRadians = this.configuration.degrees.map((degree) => degreesRad(degree));
+                for (let i = 0; i < angleRadians.length; i++) {
+                    const lineUID = `${annotationUID}-line-${i}`;
+                    const start = [
+                        (Math.cos(angleRadians[i]) * diametersCanvas[0]) / 2 + center[0],
+                        (Math.sin(angleRadians[i]) * diametersCanvas[0]) / 2 + center[1],
+                    ];
+                    const end = [
+                        (Math.cos(angleRadians[i]) * diametersCanvas[2]) / 2 + center[0],
+                        (Math.sin(angleRadians[i]) * diametersCanvas[2]) / 2 + center[1],
+                    ];
+                    drawLine(svgDrawingHelper, annotationUID, lineUID, start, end, {
+                        color,
+                        lineDash,
+                        lineWidth,
+                    });
+                }
+                renderStatus = true;
+            }
+            return renderStatus;
+        };
+    }
+    worldMeasureToCanvas(measurement, viewport) {
+        const p1 = viewport.canvasToWorld([
+            viewport.canvas.width / 2,
+            viewport.canvas.height / 2,
+        ]);
+        const { viewUp } = viewport.getCamera();
+        const p2 = vec3.scaleAndAdd(vec3.create(), p1, viewUp, measurement);
+        const p1Canvas = viewport.worldToCanvas(p1);
+        const p2Canvas = viewport.worldToCanvas(p2);
+        const distance = Math.sqrt(Math.pow(p2Canvas[0] - p1Canvas[0], 2) +
+            Math.pow(p2Canvas[1] - p1Canvas[1], 2));
+        return distance;
+    }
+}
+ETDRSGridTool.toolName = 'ETDRSGrid';
+export default ETDRSGridTool;

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

@@ -426,7 +426,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 return;
             }
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             const { cachedStats } = data;
             const { polyline: points } = data.contour;
             const targetIds = Object.keys(cachedStats);
@@ -555,7 +555,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 points: splinePolylineCanvas,
                 closed: data.contour.closed,
                 targetWindingDirection: ContourWindingDirection.Clockwise,
-            }, viewport);
+            }, viewport, { updateWindingDirection: data.contour.closed });
         });
         super.renderAnnotationInstance(renderContext);
         if (!data.cachedStats[targetId] ||

package/dist/esm/tools/base/ContourBaseTool.d.ts

@@ -16,6 +16,8 @@ declare abstract class ContourBaseTool extends AnnotationTool {
     }, transforms: {
         canvasToWorld: (point: Types.Point2) => Types.Point3;
         worldToCanvas: (point: Types.Point3) => Types.Point2;
+    }, options?: {
+        updateWindingDirection?: boolean;
     }): void;
     protected getPolylinePoints(annotation: ContourAnnotation): Types.Point3[];
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;

package/dist/esm/tools/base/ContourBaseTool.js

@@ -112,13 +112,14 @@ class ContourBaseTool extends AnnotationTool {
         annotation.invalidated = true;
         getChildAnnotations(annotation).forEach((childAnnotation) => this.moveAnnotation(childAnnotation, worldPosDelta));
     }
-    updateContourPolyline(annotation, polylineData, transforms) {
+    updateContourPolyline(annotation, polylineData, transforms, options) {
         const decimateConfig = this.configuration?.decimate || {};
         updateContourPolyline(annotation, polylineData, transforms, {
             decimate: {
                 enabled: !!decimateConfig.enabled,
                 epsilon: decimateConfig.epsilon,
             },
+            updateWindingDirection: options?.updateWindingDirection,
         });
     }
     getPolylinePoints(annotation) {

package/dist/esm/tools/index.d.ts

@@ -25,6 +25,7 @@ import DragProbeTool from './annotation/DragProbeTool';
 import RectangleROITool from './annotation/RectangleROITool';
 import EllipticalROITool from './annotation/EllipticalROITool';
 import CircleROITool from './annotation/CircleROITool';
+import ETDRSGridTool from './annotation/ETDRSGridTool';
 import SplineROITool from './annotation/SplineROITool';
 import SplineContourSegmentationTool from './annotation/SplineContourSegmentationTool';
 import PlanarFreehandROITool from './annotation/PlanarFreehandROITool';
@@ -47,4 +48,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, };

package/dist/esm/tools/index.js

@@ -25,6 +25,7 @@ import DragProbeTool from './annotation/DragProbeTool';
 import RectangleROITool from './annotation/RectangleROITool';
 import EllipticalROITool from './annotation/EllipticalROITool';
 import CircleROITool from './annotation/CircleROITool';
+import ETDRSGridTool from './annotation/ETDRSGridTool';
 import SplineROITool from './annotation/SplineROITool';
 import SplineContourSegmentationTool from './annotation/SplineContourSegmentationTool';
 import PlanarFreehandROITool from './annotation/PlanarFreehandROITool';
@@ -47,4 +48,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, };

package/dist/esm/utilities/cine/playClip.js

@@ -22,10 +22,9 @@ function playClip(element, playClipOptions) {
     playClipOptions.dynamicCineEnabled =
         playClipOptions.dynamicCineEnabled ?? true;
     const { viewport } = enabledElement;
-    const volume = _getVolumeFromViewport(viewport);
     const playClipContext = _createCinePlayContext(viewport, playClipOptions);
     let playClipData = getToolState(element);
-    const isDynamicCinePlaying = playClipOptions.dynamicCineEnabled && volume?.isDynamicVolume();
+    const isDynamicCinePlaying = playClipOptions.dynamicCineEnabled;
     if (isDynamicCinePlaying) {
         _stopDynamicVolumeCine(element);
     }
@@ -97,7 +96,10 @@ function playClip(element, playClipOptions) {
         }
     };
     if (isDynamicCinePlaying) {
-        dynamicVolumesPlayingMap.set(volume.volumeId, element);
+        const volume = _getVolumeFromViewport(viewport);
+        if (volume) {
+            dynamicVolumesPlayingMap.set(volume.volumeId, element);
+        }
     }
     if (playClipContext.play) {
         playClipData.framesPerSecond = playClipContext.play(playClipOptions.framesPerSecond);
@@ -210,10 +212,11 @@ function _stopClipWithData(playClipData) {
     }
 }
 function _getVolumesFromViewport(viewport) {
-    return viewport
-        .getActors()
-        .map((actor) => cache.getVolume(viewport.getVolumeId()))
-        .filter((volume) => !!volume);
+    if (!viewport || !viewport.getVolumeId) {
+        return [];
+    }
+    const volumeId = viewport.getVolumeId();
+    return [cache.getVolume(volumeId)];
 }
 function _getVolumeFromViewport(viewport) {
     const volumes = _getVolumesFromViewport(viewport);

package/dist/esm/utilities/contours/updateContourPolyline.d.ts

@@ -9,6 +9,7 @@ export default function updateContourPolyline(annotation: ContourAnnotation, pol
     canvasToWorld: (point: Types.Point2) => Types.Point3;
     worldToCanvas: (point: Types.Point3) => Types.Point2;
 }, options?: {
+    updateWindingDirection?: boolean;
     decimate?: {
         enabled?: boolean;
         epsilon?: number;

package/dist/esm/utilities/contours/updateContourPolyline.js

@@ -6,6 +6,7 @@ export default function updateContourPolyline(annotation, polylineData, transfor
     const { data } = annotation;
     const { targetWindingDirection } = polylineData;
     let { points: polyline } = polylineData;
+    let windingDirection = math.polyline.getWindingDirection(polyline);
     if (options?.decimate?.enabled) {
         polyline = math.polyline.decimate(polylineData.points, options?.decimate?.epsilon);
     }
@@ -22,24 +23,24 @@ export default function updateContourPolyline(annotation, polylineData, transfor
         }
         closed = currentClosedState;
     }
-    let windingDirection = parentAnnotation
-        ? parentAnnotation.data.contour.windingDirection * -1
-        : targetWindingDirection;
-    if (windingDirection === undefined) {
-        windingDirection = currentPolylineWindingDirection;
-    }
-    if (windingDirection !== currentPolylineWindingDirection) {
-        polyline.reverse();
-    }
-    if (!data.handles?.points?.length) {
-        return;
-    }
-    const handlePoints = data.handles.points.map((p) => worldToCanvas(p));
-    if (handlePoints.length > 2) {
-        const currentHandlesWindingDirection = math.polyline.getWindingDirection(handlePoints);
-        if (currentHandlesWindingDirection !== windingDirection) {
-            data.handles.points.reverse();
+    if (options?.updateWindingDirection !== false) {
+        let updatedWindingDirection = parentAnnotation
+            ? parentAnnotation.data.contour.windingDirection * -1
+            : targetWindingDirection;
+        if (updatedWindingDirection === undefined) {
+            updatedWindingDirection = windingDirection;
+        }
+        if (updatedWindingDirection !== windingDirection) {
+            polyline.reverse();
+        }
+        const handlePoints = data.handles.points.map((p) => worldToCanvas(p));
+        if (handlePoints.length > 2) {
+            const currentHandlesWindingDirection = math.polyline.getWindingDirection(handlePoints);
+            if (currentHandlesWindingDirection !== updatedWindingDirection) {
+                data.handles.points.reverse();
+            }
         }
+        windingDirection = updatedWindingDirection;
     }
     for (let i = 0; i < numPoints; i++) {
         polylineWorldPoints[i] = canvasToWorld(polyline[i]);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.0.5",
+  "version": "2.1.1",
   "description": "Cornerstone3D Tools",
-  "main": "./dist/umd/index.js",
+  "main": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
   "repository": "https://github.com/cornerstonejs/cornerstone3D",
@@ -105,7 +105,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^2.0.5",
+    "@cornerstonejs/core": "^2.1.1",
     "@kitware/vtk.js": "32.1.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -124,5 +124,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "fc2ac1cf4354f7555005436419996e7b89571e40"
+  "gitHead": "1a1d3b83e7513f7d72fb34d702a8260d1859883c"
 }