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

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationDataModifiedEventType } from '../../types/EventTypes';
+import type { SegmentationDataModifiedEventType } from '../../types/EventTypes';
 declare const onSegmentationDataModified: (evt: SegmentationDataModifiedEventType) => void;
 export default onSegmentationDataModified;

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.js

@@ -1,6 +1,6 @@
-import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
+import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
 import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified';
 const onSegmentationDataModified = function (evt) {
     const { segmentationId } = evt.detail;
@@ -8,6 +8,6 @@ const onSegmentationDataModified = function (evt) {
     if (type === SegmentationRepresentations.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }
-    triggerSegmentationRender(segmentationId);
+    triggerSegmentationRenderBySegmentationId(segmentationId);
 };
 export default onSegmentationDataModified;

package/dist/esm/eventListeners/segmentation/segmentationModifiedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationModifiedEventType } from '../../types/EventTypes';
+import type { SegmentationModifiedEventType } from '../../types/EventTypes';
 declare const segmentationModifiedListener: (evt: SegmentationModifiedEventType) => void;
 export default segmentationModifiedListener;

package/dist/esm/eventListeners/segmentation/segmentationModifiedEventListener.js

@@ -1,6 +1,7 @@
-import { triggerSegmentationRender } from '../../utilities/segmentation';
+import {} from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
 const segmentationModifiedListener = function (evt) {
     const { segmentationId } = evt.detail;
-    triggerSegmentationRender(segmentationId);
+    triggerSegmentationRenderBySegmentationId(segmentationId);
 };
 export default segmentationModifiedListener;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationModifiedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationRepresentationModifiedEventType } from '../../types/EventTypes';
+import type { SegmentationRepresentationModifiedEventType } from '../../types/EventTypes';
 declare const segmentationRepresentationModifiedListener: (evt: SegmentationRepresentationModifiedEventType) => void;
 export default segmentationRepresentationModifiedListener;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationModifiedEventListener.js

@@ -1,14 +1,14 @@
-import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
-import { getRepresentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation } from '../../stateManagement/segmentation/segmentationState';
+import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
 const segmentationRepresentationModifiedListener = function (evt) {
     const { segmentationRepresentationUID } = evt.detail;
-    const segmentationRepresentation = getRepresentation
-        ? getRepresentation(segmentationRepresentationUID)
+    const segmentationRepresentation = getSegmentationRepresentation
+        ? getSegmentationRepresentation(segmentationRepresentationUID)
         : null;
     if (!segmentationRepresentation) {
         return;
     }
     const segmentationId = segmentationRepresentation?.segmentationId;
-    triggerSegmentationRender(segmentationId);
+    triggerSegmentationRenderBySegmentationId(segmentationId);
 };
 export default segmentationRepresentationModifiedListener;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationRemovedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationRepresentationRemovedEventType } from '../../types/EventTypes';
+import type { SegmentationRepresentationRemovedEventType } from '../../types/EventTypes';
 declare const segmentationRepresentationRemovedEventListener: (evt: SegmentationRepresentationRemovedEventType) => void;
 export default segmentationRepresentationRemovedEventListener;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationRemovedEventListener.js

@@ -1,6 +1,8 @@
-import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
+import { getSegmentationRepresentation } from '../../stateManagement/segmentation/segmentationState';
+import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
 const segmentationRepresentationRemovedEventListener = function (evt) {
     const { segmentationRepresentationUID } = evt.detail;
-    triggerSegmentationRender();
+    const segmentation = getSegmentationRepresentation(segmentationRepresentationUID);
+    triggerSegmentationRenderBySegmentationId(segmentation.segmentationId);
 };
 export default segmentationRepresentationRemovedEventListener;

package/dist/esm/eventListeners/touch/getTouchEventPoints.d.ts

@@ -1,2 +1,2 @@
-import { ITouchPoints } from '../../types';
+import type { ITouchPoints } from '../../types';
 export default function getTouchEventPoints(evt: TouchEvent, element?: HTMLDivElement): ITouchPoints[];

package/dist/esm/index.d.ts

@@ -8,7 +8,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, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } 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, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, 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, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, 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, ReferenceLines, 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, };

package/dist/esm/index.js

@@ -8,7 +8,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, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, 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, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } 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, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, 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, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, 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, ReferenceLines, 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, };

package/dist/esm/stateManagement/annotation/AnnotationRenderingEngine.d.ts

@@ -0,0 +1,20 @@
+declare class AnnotationRenderingEngine {
+    hasBeenDestroyed: boolean;
+    private _needsRender;
+    private _animationFrameSet;
+    private _animationFrameHandle;
+    private _viewportElements;
+    constructor();
+    addViewportElement(viewportId: string, element: HTMLDivElement): void;
+    removeViewportElement(viewportId: string, element: HTMLDivElement): void;
+    renderViewport(element: HTMLDivElement): void;
+    private _throwIfDestroyed;
+    private _renderFlaggedViewports;
+    private _setAllViewportsToBeRenderedNextFrame;
+    private _setViewportsToBeRenderedNextFrame;
+    private _render;
+    _triggerRender(element: any): void;
+    private _reset;
+}
+declare const annotationRenderingEngine: AnnotationRenderingEngine;
+export { annotationRenderingEngine };

package/dist/esm/stateManagement/annotation/AnnotationRenderingEngine.js

@@ -0,0 +1,112 @@
+import { getEnabledElement, triggerEvent, getRenderingEngine, } from '@cornerstonejs/core';
+import { Events, ToolModes } from '../../enums';
+import { draw as drawSvg } from '../../drawingSvg';
+import getToolsWithModesForElement from '../../utilities/getToolsWithModesForElement';
+const { Active, Passive, Enabled } = ToolModes;
+class AnnotationRenderingEngine {
+    constructor() {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._renderFlaggedViewports = () => {
+            this._throwIfDestroyed();
+            const elements = Array.from(this._viewportElements.values());
+            for (let i = 0; i < elements.length; i++) {
+                const element = elements[i];
+                if (this._needsRender.has(element)) {
+                    this._triggerRender(element);
+                    this._needsRender.delete(element);
+                    if (this._needsRender.size === 0) {
+                        break;
+                    }
+                }
+            }
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+            this._render();
+        };
+        this._viewportElements = new Map();
+    }
+    addViewportElement(viewportId, element) {
+        this._viewportElements.set(viewportId, element);
+    }
+    removeViewportElement(viewportId, element) {
+        this._viewportElements.delete(viewportId);
+        this._needsRender.delete(element);
+        this._reset();
+    }
+    renderViewport(element) {
+        this._setViewportsToBeRenderedNextFrame([element]);
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+    _setAllViewportsToBeRenderedNextFrame() {
+        const elements = [...this._viewportElements.values()];
+        elements.forEach((element) => {
+            this._needsRender.add(element);
+        });
+        this._renderFlaggedViewports();
+    }
+    _setViewportsToBeRenderedNextFrame(elements) {
+        const elementsEnabled = [...this._viewportElements.values()];
+        elements.forEach((element) => {
+            if (elementsEnabled.indexOf(element) !== -1) {
+                this._needsRender.add(element);
+            }
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
+            this._animationFrameSet = true;
+        }
+    }
+    _triggerRender(element) {
+        const enabledElement = getEnabledElement(element);
+        if (!enabledElement) {
+            return;
+        }
+        const renderingEngine = getRenderingEngine(enabledElement.renderingEngineId);
+        if (!renderingEngine) {
+            console.warn('rendering Engine has been destroyed');
+            return;
+        }
+        const enabledTools = getToolsWithModesForElement(element, [
+            Active,
+            Passive,
+            Enabled,
+        ]);
+        const { renderingEngineId, viewportId } = enabledElement;
+        const eventDetail = {
+            element,
+            renderingEngineId,
+            viewportId,
+        };
+        drawSvg(element, (svgDrawingHelper) => {
+            let anyRendered = false;
+            const handleDrawSvg = (tool) => {
+                if (tool.renderAnnotation) {
+                    const rendered = tool.renderAnnotation(enabledElement, svgDrawingHelper);
+                    anyRendered = anyRendered || rendered;
+                }
+            };
+            enabledTools.forEach(handleDrawSvg);
+            if (anyRendered) {
+                triggerEvent(element, Events.ANNOTATION_RENDERED, { ...eventDetail });
+            }
+        });
+    }
+    _reset() {
+        window.cancelAnimationFrame(this._animationFrameHandle);
+        this._needsRender.clear();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._setAllViewportsToBeRenderedNextFrame();
+    }
+}
+const annotationRenderingEngine = new AnnotationRenderingEngine();
+export { annotationRenderingEngine };

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.d.ts

@@ -1,6 +1,6 @@
-import { Annotation, Annotations, AnnotationState, GroupSpecificAnnotations } from '../../types/AnnotationTypes';
-import { AnnotationGroupSelector, IAnnotationManager } from '../../types';
-import { Types } from '@cornerstonejs/core';
+import type { Annotation, Annotations, AnnotationState, GroupSpecificAnnotations } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector, IAnnotationManager } from '../../types';
+import type { Types } from '@cornerstonejs/core';
 declare class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     private annotations;
     readonly uid: string;

package/dist/esm/stateManagement/annotation/annotationLocking.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../types';
+import type { Annotation } from '../../types';
 declare function setAnnotationLocked(annotation: Annotation, locked?: boolean): void;
 declare function unlockAllAnnotations(): void;
 declare function getAnnotationsLocked(): Array<Annotation>;

package/dist/esm/stateManagement/annotation/annotationState.d.ts

@@ -1,5 +1,5 @@
-import { Annotations, Annotation } from '../../types/AnnotationTypes';
-import { AnnotationGroupSelector } from '../../types';
+import type { Annotations, Annotation } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector } from '../../types';
 declare function getAnnotationManager(): import("./FrameOfReferenceSpecificAnnotationManager").default;
 declare function setAnnotationManager(annotationManager: any): void;
 declare function resetAnnotationManager(): void;

package/dist/esm/stateManagement/annotation/annotationVisibility.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../types';
+import type { Annotation } from '../../types';
 declare function setAnnotationVisibility(annotationUID: string, visible?: boolean): void;
 declare function showAllAnnotations(): void;
 declare function isAnnotationVisible(annotationUID: string): boolean | undefined;

package/dist/esm/stateManagement/annotation/config/ToolStyle.d.ts

@@ -1,4 +1,4 @@
-import { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
+import type { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
 declare class ToolStyle {
     config: StyleConfig;
     constructor();

package/dist/esm/stateManagement/annotation/config/getFont.d.ts

@@ -1,4 +1,4 @@
-import { ToolModes, AnnotationStyleStates } from '../../../enums';
-import { StyleSpecifier } from '../../../types/AnnotationStyle';
+import type { ToolModes, AnnotationStyleStates } from '../../../enums';
+import type { StyleSpecifier } from '../../../types/AnnotationStyle';
 declare function getFont(styleSpecifier: StyleSpecifier, state?: AnnotationStyleStates, mode?: ToolModes): string;
 export default getFont;

package/dist/esm/stateManagement/annotation/config/getState.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../../types';
+import type { Annotation } from '../../../types';
 import { AnnotationStyleStates } from '../../../enums';
 declare function getState(annotation?: Annotation): AnnotationStyleStates;
 export default getState;

package/dist/esm/stateManagement/annotation/config/helpers.d.ts

@@ -1,4 +1,4 @@
-import { StyleSpecifier } from '../../../types/AnnotationStyle';
-import { ToolModes, AnnotationStyleStates } from '../../../enums';
+import type { StyleSpecifier } from '../../../types/AnnotationStyle';
+import type { ToolModes, AnnotationStyleStates } from '../../../enums';
 declare function getStyleProperty(property: string, styleSpecifier: StyleSpecifier, state?: AnnotationStyleStates, mode?: ToolModes): string;
 export { getStyleProperty };

package/dist/esm/stateManagement/annotation/helpers/state.d.ts

@@ -1,6 +1,6 @@
 import { ChangeTypes } from '../../../enums';
-import { Annotation } from '../../../types/AnnotationTypes';
-import { AnnotationRemovedEventDetail } from '../../../types/EventTypes';
+import type { Annotation } from '../../../types/AnnotationTypes';
+import type { AnnotationRemovedEventDetail } from '../../../types/EventTypes';
 declare function triggerAnnotationAddedForElement(annotation: Annotation, element: HTMLDivElement): void;
 declare function triggerAnnotationAddedForFOR(annotation: Annotation): void;
 declare function triggerAnnotationRemoved(eventDetail: AnnotationRemovedEventDetail): void;

package/dist/esm/stateManagement/annotation/utilities/defineProperties.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../../types';
+import type { Annotation } from '../../../types';
 declare const checkAndDefineTextBoxProperty: (annotation: Annotation) => Annotation;
 declare const checkAndDefineCachedStatsProperty: (annotation: Annotation) => Annotation;
 export { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty };

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

@@ -15,6 +15,6 @@ import { setAnnotationManager } from './annotation/annotationState';
 import { getAnnotationManager } from './annotation/annotationState';
 import { resetAnnotationManager } from './annotation/annotationState';
 import { invalidateAnnotation } from './annotation/annotationState';
-import { addRepresentations } from './segmentation';
-import { removeRepresentationsFromViewport } from './segmentation';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addRepresentations, removeRepresentationsFromViewport };
+import { addSegmentationRepresentations } from './segmentation';
+import { removeSegmentationRepresentations } from './segmentation';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations };

package/dist/esm/stateManagement/index.js

@@ -2,5 +2,5 @@ import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpeci
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
 import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
-import { addRepresentations, removeRepresentationsFromViewport, } from './segmentation';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addRepresentations, removeRepresentationsFromViewport, };
+import { addSegmentationRepresentations, removeSegmentationRepresentations, } from './segmentation';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations, };

package/dist/esm/{tools/displayTools → stateManagement/segmentation}/SegmentationRenderingEngine.d.ts

@@ -1,11 +1,11 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare class SegmentationRenderingEngine {
     private _needsRender;
     private _animationFrameSet;
     private _animationFrameHandle;
     hasBeenDestroyed: boolean;
-    renderSegmentations(segmentationId?: string): void;
-    renderSegmentationsForViewports(viewportIds?: string[]): void;
+    renderSegmentationsForViewport(viewportId?: string): void;
+    renderSegmentation(segmentationId: string): void;
     _getAllViewports: () => Types.IViewport[];
     _getViewportIdsForSegmentation(segmentationId?: string): string[];
     private _throwIfDestroyed;

package/dist/esm/{tools/displayTools → stateManagement/segmentation}/SegmentationRenderingEngine.js

@@ -1,12 +1,12 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
 import Representations from '../../enums/SegmentationRepresentations';
-import { getRepresentationsForViewport } from '../../stateManagement/segmentation/segmentationState';
-import { surfaceDisplay } from './Surface';
-import { contourDisplay } from './Contour';
-import { labelmapDisplay } from './Labelmap';
+import { getSegmentationRepresentations } from '../../stateManagement/segmentation/segmentationState';
+import { surfaceDisplay } from '../../tools/displayTools/Surface';
+import { contourDisplay } from '../../tools/displayTools/Contour';
+import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
 import { addTool, state } from '../../store';
-import PlanarFreehandContourSegmentationTool from '../annotation/PlanarFreehandContourSegmentationTool';
+import PlanarFreehandContourSegmentationTool from '../../tools/annotation/PlanarFreehandContourSegmentationTool';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 const renderers = {
     [Representations.Labelmap]: labelmapDisplay,
@@ -34,25 +34,22 @@ class SegmentationRenderingEngine {
             this._animationFrameHandle = null;
         };
     }
-    renderSegmentations(segmentationId) {
-        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+    renderSegmentationsForViewport(viewportId) {
+        const viewportIds = viewportId
+            ? [viewportId]
+            : this._getViewportIdsForSegmentation();
         this._setViewportsToBeRenderedNextFrame(viewportIds);
     }
-    renderSegmentationsForViewports(viewportIds) {
-        if (!viewportIds?.length) {
-            const allViewports = this._getAllViewports();
-            this._setViewportsToBeRenderedNextFrame(allViewports.map((viewport) => viewport.id));
-        }
-        else {
-            this._setViewportsToBeRenderedNextFrame(viewportIds);
-        }
+    renderSegmentation(segmentationId) {
+        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
     }
     _getViewportIdsForSegmentation(segmentationId) {
         const viewports = this._getAllViewports();
         const viewportIds = [];
         for (const viewport of viewports) {
             const viewportId = viewport.id;
-            const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+            const segmentationRepresentations = getSegmentationRepresentations(viewportId);
             if (segmentationId) {
                 const hasSegmentationRepresentation = segmentationRepresentations.some((representation) => representation.segmentationId === segmentationId);
                 if (hasSegmentationRepresentation) {
@@ -85,7 +82,7 @@ class SegmentationRenderingEngine {
         }
     }
     _triggerRender(viewportId) {
-        const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+        const segmentationRepresentations = getSegmentationRepresentations(viewportId);
         if (!segmentationRepresentations?.length) {
             return;
         }

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

@@ -12,28 +12,28 @@ export default class SegmentationStateManager {
     getSegmentation(segmentationId: string): Segmentation | undefined;
     addSegmentation(segmentation: Segmentation): void;
     removeSegmentation(segmentationId: string): void;
-    getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-    addRepresentation(segmentationRepresentation: SegmentationRepresentation): void;
-    addRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
-    updateSegmentationImageReferences(viewportId: any, segmentationId: any): string;
+    getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
+    addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
+    addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
+    updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
     private getLabelmapImageIds;
-    getLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string | undefined;
-    getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[];
+    getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
+    getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
     removeRepresentation(segmentationRepresentationUID: string): void;
-    setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
-    getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
+    setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
+    getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
     getGlobalConfig(): SegmentationRepresentationConfig;
     setGlobalConfig(config: SegmentationRepresentationConfig): void;
     _getRepresentationConfig(segmentationRepresentationUID: string): {
         allSegments?: RepresentationConfig;
         perSegment?: SegmentRepresentationConfig;
     };
-    getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
+    getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
     getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
-    setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+    setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
     setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
-    getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-    setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+    getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
+    setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
     _getStackIdForImageIds(imageIds: string[]): string;