@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,5 +1,5 @@
-import { StackViewport, utilities, BaseVolumeViewport, } from '@cornerstonejs/core';
-import { ToolModes } from '../../enums';
+import { utilities, BaseVolumeViewport } from '@cornerstonejs/core';
+import ToolModes from '../../enums/ToolModes';
 class BaseTool {
     constructor(toolProps, defaultToolProps) {
         const initialProps = utilities.deepMerge(defaultToolProps, toolProps);
@@ -20,7 +20,14 @@ class BaseTool {
     }
     applyActiveStrategy(enabledElement, operationData) {
         const { strategies, activeStrategy } = this.configuration;
-        return strategies[activeStrategy].call(this, enabledElement, operationData);
+        return strategies[activeStrategy]?.call(this, enabledElement, operationData);
+    }
+    applyActiveStrategyCallback(enabledElement, operationData, callbackType) {
+        const { strategies, activeStrategy } = this.configuration;
+        if (!strategies[activeStrategy]) {
+            throw new Error(`applyActiveStrategyCallback: active strategy ${activeStrategy} not found, check tool configuration or spellings`);
+        }
+        return strategies[activeStrategy][callbackType]?.call(this, enabledElement, operationData);
     }
     setConfiguration(newConfiguration) {
         this.configuration = utilities.deepMerge(this.configuration, newConfiguration);
@@ -28,21 +35,11 @@ class BaseTool {
     setActiveStrategy(strategyName) {
         this.setConfiguration({ activeStrategy: strategyName });
     }
-    getTargetVolumeId(viewport) {
-        if (this.configuration.volumeId) {
-            return this.configuration.volumeId;
-        }
-        const actorEntries = viewport.getActors();
-        if (!actorEntries) {
-            return;
-        }
-        return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
-    }
-    getTargetIdImage(targetId, renderingEngine) {
+    getTargetImageData(targetId) {
         if (targetId.startsWith('imageId:')) {
             const imageId = targetId.split('imageId:')[1];
             const imageURI = utilities.imageIdToURI(imageId);
-            let viewports = utilities.getViewportsWithImageURI(imageURI, renderingEngine.id);
+            let viewports = utilities.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -55,8 +52,16 @@ class BaseTool {
             return viewports[0].getImageData();
         }
         else if (targetId.startsWith('volumeId:')) {
-            const volumeId = targetId.split('volumeId:')[1];
-            const viewports = utilities.getViewportsWithVolumeId(volumeId, renderingEngine.id);
+            const volumeId = utilities.getVolumeId(targetId);
+            const viewports = utilities.getViewportsWithVolumeId(volumeId);
+            if (!viewports || !viewports.length) {
+                return;
+            }
+            return viewports[0].getImageData();
+        }
+        else if (targetId.startsWith('videoId:')) {
+            const imageURI = utilities.imageIdToURI(targetId);
+            const viewports = utilities.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -67,17 +72,12 @@ class BaseTool {
         }
     }
     getTargetId(viewport) {
-        if (viewport instanceof StackViewport) {
-            return `imageId:${viewport.getCurrentImageId()}`;
-        }
-        else if (viewport instanceof BaseVolumeViewport) {
-            return `volumeId:${this.getTargetVolumeId(viewport)}`;
-        }
-        else {
-            throw new Error('getTargetId: viewport must be a StackViewport or VolumeViewport');
+        const targetId = viewport.getViewReferenceId?.();
+        if (targetId) {
+            return targetId;
         }
+        throw new Error('getTargetId: viewport must have a getViewReferenceId method');
     }
 }
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;
-//# sourceMappingURL=BaseTool.js.map

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

@@ -0,0 +1,23 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation, ContourAnnotation, EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, AnnotationRenderContext } from '../../types';
+import AnnotationTool from './AnnotationTool';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
+declare abstract class ContourBaseTool extends AnnotationTool {
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected addAnnotation(annotation: Annotation, element: HTMLDivElement): string;
+    protected cancelAnnotation(annotation: Annotation): void;
+    protected moveAnnotation(annotation: Annotation, worldPosDelta: Types.Point3): void;
+    protected updateContourPolyline(annotation: ContourAnnotation, polylineData: {
+        points: Types.Point2[];
+        closed?: boolean;
+        targetWindingDirection?: ContourWindingDirection;
+    }, transforms: {
+        canvasToWorld: (point: Types.Point2) => Types.Point3;
+        worldToCanvas: (point: Types.Point3) => Types.Point2;
+    }): void;
+    protected getPolylinePoints(annotation: ContourAnnotation): Types.Point3[];
+    protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
+}
+export { ContourBaseTool as default, ContourBaseTool };

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

@@ -0,0 +1,150 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { addAnnotation, getAnnotations, getChildAnnotations, } from '../../stateManagement/annotation/annotationState';
+import { drawPath as drawPathSvg } from '../../drawingSvg';
+import AnnotationTool from './AnnotationTool';
+import updateContourPolyline from '../../utilities/contours/updateContourPolyline';
+import getContourHolesDataCanvas from '../../utilities/contours/getContourHolesDataCanvas';
+class ContourBaseTool extends AnnotationTool {
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+    }
+    renderAnnotation(enabledElement, svgDrawingHelper) {
+        let renderStatus = false;
+        const { viewport } = enabledElement;
+        const { element } = viewport;
+        if (!viewport.getRenderingEngine()) {
+            console.warn('Rendering Engine has been destroyed');
+            return renderStatus;
+        }
+        let annotations = getAnnotations(this.getToolName(), element);
+        if (!annotations?.length) {
+            return renderStatus;
+        }
+        annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+        if (!annotations?.length) {
+            return renderStatus;
+        }
+        const targetId = this.getTargetId(viewport);
+        const styleSpecifier = {
+            toolGroupId: this.toolGroupId,
+            toolName: this.getToolName(),
+            viewportId: enabledElement.viewport.id,
+        };
+        for (let i = 0; i < annotations.length; i++) {
+            const annotation = annotations[i];
+            styleSpecifier.annotationUID = annotation.annotationUID;
+            const annotationStyle = this.getAnnotationStyle({
+                annotation,
+                styleSpecifier,
+            });
+            if (!annotationStyle.visibility) {
+                continue;
+            }
+            const annotationRendered = this.renderAnnotationInstance({
+                enabledElement,
+                targetId,
+                annotation,
+                annotationStyle,
+                svgDrawingHelper,
+            });
+            renderStatus ||= annotationRendered;
+            annotation.invalidated = false;
+        }
+        return renderStatus;
+    }
+    createAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { currentPoints, element } = eventDetail;
+        const { world: worldPos } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp, position: cameraPosition } = camera;
+        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+        const viewReference = viewport.getViewReference({ points: [worldPos] });
+        return {
+            highlighted: true,
+            invalidated: true,
+            metadata: {
+                toolName: this.getToolName(),
+                ...viewReference,
+                referencedImageId,
+                viewUp,
+                cameraPosition,
+            },
+            data: {
+                handles: {
+                    points: [],
+                    activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                },
+                contour: {
+                    polyline: [],
+                    closed: false,
+                },
+            },
+            interpolationUID: '',
+            autoGenerated: false,
+        };
+    }
+    addAnnotation(annotation, element) {
+        return addAnnotation(annotation, element);
+    }
+    cancelAnnotation(annotation) {
+    }
+    moveAnnotation(annotation, worldPosDelta) {
+        const { points } = annotation.data.handles;
+        for (let i = 0, numPoints = points.length; i < numPoints; i++) {
+            const point = points[i];
+            point[0] += worldPosDelta[0];
+            point[1] += worldPosDelta[1];
+            point[2] += worldPosDelta[2];
+        }
+        annotation.invalidated = true;
+        getChildAnnotations(annotation).forEach((childAnnotation) => this.moveAnnotation(childAnnotation, worldPosDelta));
+    }
+    updateContourPolyline(annotation, polylineData, transforms) {
+        const decimateConfig = this.configuration?.decimate || {};
+        updateContourPolyline(annotation, polylineData, transforms, {
+            decimate: {
+                enabled: !!decimateConfig.enabled,
+                epsilon: decimateConfig.epsilon,
+            },
+        });
+    }
+    getPolylinePoints(annotation) {
+        return annotation.data.contour?.polyline ?? annotation.data.polyline;
+    }
+    renderAnnotationInstance(renderContext) {
+        const { enabledElement, annotationStyle, svgDrawingHelper } = renderContext;
+        const annotation = renderContext.annotation;
+        if (annotation.parentAnnotationUID) {
+            return;
+        }
+        const { annotationUID } = annotation;
+        const { viewport } = enabledElement;
+        const { worldToCanvas } = viewport;
+        const polylineCanvasPoints = this.getPolylinePoints(annotation).map((point) => worldToCanvas(point));
+        const { lineWidth, lineDash, color, fillColor, fillOpacity } = annotationStyle;
+        const childContours = getContourHolesDataCanvas(annotation, viewport);
+        const allContours = [polylineCanvasPoints, ...childContours];
+        drawPathSvg(svgDrawingHelper, annotationUID, 'contourPolyline', allContours, {
+            color: color,
+            lineDash: lineDash,
+            lineWidth: Math.max(0.1, lineWidth),
+            fillColor: fillColor,
+            fillOpacity: fillOpacity,
+        });
+        return true;
+    }
+}
+export { ContourBaseTool as default, ContourBaseTool };

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

@@ -0,0 +1,17 @@
+import type { Annotation, EventTypes, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
+import type { StyleSpecifier } from '../../types/AnnotationStyle';
+import ContourBaseTool from './ContourBaseTool';
+declare abstract class ContourSegmentationBaseTool extends ContourBaseTool {
+    constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    protected isContourSegmentationTool(): boolean;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected addAnnotation(annotation: Annotation, element: HTMLDivElement): string;
+    protected cancelAnnotation(annotation: Annotation): void;
+    protected getAnnotationStyle(context: {
+        annotation: Annotation;
+        styleSpecifier: StyleSpecifier;
+    }): any;
+    protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
+    private _getContourSegmentationStyle;
+}
+export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

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

@@ -0,0 +1,179 @@
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { SegmentationRepresentations } from '../../enums';
+import ContourBaseTool from './ContourBaseTool';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import InterpolationManager from '../../utilities/segmentation/InterpolationManager/InterpolationManager';
+import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../utilities/contourSegmentation';
+import { triggerAnnotationRenderForToolGroupIds } from '../../utilities/triggerAnnotationRenderForToolGroupIds';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
+import { getSegmentationRepresentationVisibility } from '../../stateManagement/segmentation/getSegmentationRepresentationVisibility';
+import { getViewportIdsWithSegmentation } from '../../stateManagement/segmentation/getViewportIdsWithSegmentation';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
+import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
+import { internalGetHiddenSegmentIndices } from '../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+class ContourSegmentationBaseTool extends ContourBaseTool {
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+        if (this.configuration.interpolation?.enabled) {
+            InterpolationManager.addTool(this.getToolName());
+        }
+    }
+    isContourSegmentationTool() {
+        return true;
+    }
+    createAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { element } = eventDetail;
+        const enabledElement = getEnabledElement(element);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const contourAnnotation = super.createAnnotation(evt);
+        if (!this.isContourSegmentationTool()) {
+            return contourAnnotation;
+        }
+        const activeSeg = getActiveSegmentation(viewport.id);
+        if (!activeSeg) {
+            throw new Error('No active segmentation detected, create one before using scissors tool');
+        }
+        if (!activeSeg.representationData.Contour) {
+            throw new Error(`A contour segmentation must be active`);
+        }
+        const { segmentationId } = activeSeg;
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
+        return utilities.deepMerge(contourAnnotation, {
+            data: {
+                segmentation: {
+                    segmentationId,
+                    segmentIndex,
+                },
+            },
+        });
+    }
+    addAnnotation(annotation, element) {
+        const annotationUID = super.addAnnotation(annotation, element);
+        if (this.isContourSegmentationTool()) {
+            const contourSegAnnotation = annotation;
+            addContourSegmentationAnnotation(contourSegAnnotation);
+        }
+        return annotationUID;
+    }
+    cancelAnnotation(annotation) {
+        if (this.isContourSegmentationTool()) {
+            removeContourSegmentationAnnotation(annotation);
+        }
+        super.cancelAnnotation(annotation);
+    }
+    getAnnotationStyle(context) {
+        const annotationStyle = super.getAnnotationStyle(context);
+        if (!this.isContourSegmentationTool()) {
+            return annotationStyle;
+        }
+        const contourSegmentationStyle = this._getContourSegmentationStyle(context);
+        return utilities.deepMerge(annotationStyle, contourSegmentationStyle);
+    }
+    renderAnnotationInstance(renderContext) {
+        const { annotation } = renderContext;
+        const { invalidated } = annotation;
+        const renderResult = super.renderAnnotationInstance(renderContext);
+        if (invalidated && this.isContourSegmentationTool()) {
+            const { segmentationId } = (annotation).data.segmentation;
+            triggerSegmentationDataModified(segmentationId);
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+            const toolGroupIds = viewportIds.map((viewportId) => {
+                const toolGroup = getToolGroupForViewport(viewportId);
+                return toolGroup.id;
+            });
+            triggerAnnotationRenderForToolGroupIds(toolGroupIds);
+        }
+        return renderResult;
+    }
+    _getContourSegmentationStyle(context) {
+        const annotation = context.annotation;
+        const { segmentationId, segmentIndex } = annotation.data.segmentation;
+        const segmentation = getSegmentation(segmentationId);
+        const { viewportId } = context.styleSpecifier;
+        const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
+        if (!segmentationRepresentations?.length) {
+            return {};
+        }
+        let segmentationRepresentation;
+        if (segmentationRepresentations.length > 1) {
+            segmentationRepresentation = segmentationRepresentations.find((rep) => rep.segmentationId === segmentationId &&
+                rep.type === SegmentationRepresentations.Contour);
+        }
+        else {
+            segmentationRepresentation = segmentationRepresentations[0];
+        }
+        const { autoGenerated } = annotation;
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
+        const annotationLocked = segmentsLocked.includes(segmentIndex);
+        const segmentColor = getSegmentIndexColor(context.styleSpecifier.viewportId, segmentationId, segmentIndex);
+        const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, {
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+        });
+        const activeSegmentation = getActiveSegmentation(viewportId);
+        const isActive = activeSegmentation?.segmentationId === segmentationId;
+        const style = segmentationStyle.getStyle({
+            viewportId,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
+        const mergedConfig = style;
+        let lineWidth = 1;
+        let lineDash = undefined;
+        let lineOpacity = 1;
+        let fillOpacity = 0;
+        if (autoGenerated) {
+            lineWidth = mergedConfig.outlineWidthAutoGenerated ?? lineWidth;
+            lineDash = mergedConfig.outlineDashAutoGenerated ?? lineDash;
+            lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+            fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
+        }
+        else if (isActive) {
+            lineWidth = mergedConfig.outlineWidth ?? lineWidth;
+            lineDash = mergedConfig.outlineDash ?? lineDash;
+            lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+            fillOpacity = mergedConfig.fillAlpha ?? fillOpacity;
+        }
+        else {
+            lineWidth = mergedConfig.outlineWidthInactive ?? lineWidth;
+            lineDash = mergedConfig.outlineDashInactive ?? lineDash;
+            lineOpacity = mergedConfig.outlineOpacityInactive ?? lineOpacity;
+            fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
+        }
+        if (getActiveSegmentIndex(segmentationId) === segmentIndex) {
+            lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
+        }
+        lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
+        fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
+        const color = `rgba(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]}, ${lineOpacity})`;
+        const fillColor = `rgb(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]})`;
+        const hiddenSegments = internalGetHiddenSegmentIndices(viewportId, {
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+        });
+        const isVisible = !hiddenSegments.has(segmentIndex);
+        return {
+            color,
+            fillColor,
+            lineWidth,
+            fillOpacity,
+            lineDash,
+            textbox: {
+                color,
+            },
+            visibility: segmentationVisible && isVisible,
+            locked: annotationLocked,
+        };
+    }
+}
+export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

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

@@ -2,4 +2,3 @@ import BaseTool from './BaseTool';
 import AnnotationTool from './AnnotationTool';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 export { BaseTool, AnnotationTool, AnnotationDisplayTool };
-//# sourceMappingURL=index.js.map

package/dist/esm/tools/displayTools/Contour/contourConfig.d.ts

@@ -1,3 +1,3 @@
-import { ContourConfig } from '../../../types/ContourTypes';
-declare function getDefaultContourConfig(): ContourConfig;
-export default getDefaultContourConfig;
+import type { ContourStyle } from '../../../types/ContourTypes';
+declare function getDefaultContourStyle(): ContourStyle;
+export default getDefaultContourStyle;

package/dist/esm/tools/displayTools/Contour/contourConfig.js

@@ -1,15 +1,20 @@
 const defaultContourConfig = {
     renderOutline: true,
-    outlineWidthActive: 2,
-    outlineWidthInactive: 2,
+    outlineWidthAutoGenerated: 3,
+    outlineWidth: 1,
+    outlineWidthInactive: 1,
     outlineOpacity: 1,
     outlineOpacityInactive: 0.85,
+    outlineDash: undefined,
+    outlineDashInactive: undefined,
+    outlineDashAutoGenerated: '5,3',
+    activeSegmentOutlineWidthDelta: 0,
     renderFill: true,
-    fillAlpha: 1,
-    fillAlphaInactive: 0,
+    fillAlpha: 0.5,
+    fillAlphaInactive: 0.3,
+    fillAlphaAutoGenerated: 0.3,
 };
-function getDefaultContourConfig() {
+function getDefaultContourStyle() {
     return defaultContourConfig;
 }
-export default getDefaultContourConfig;
-//# sourceMappingURL=contourConfig.js.map
+export default getDefaultContourStyle;

package/dist/esm/tools/displayTools/Contour/contourDisplay.d.ts

@@ -1,11 +1,9 @@
-import { Types } from '@cornerstonejs/core';
-import { RepresentationPublicInput, SegmentationRepresentationConfig, ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
-declare function addSegmentationRepresentation(toolGroupId: string, representationInput: RepresentationPublicInput, toolGroupSpecificConfig?: SegmentationRepresentationConfig): Promise<string>;
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
-declare function render(viewport: Types.IVolumeViewport, representationConfig: ToolGroupSpecificRepresentation, toolGroupConfig: SegmentationRepresentationConfig): Promise<void>;
+import type { StackViewport, Types } from '@cornerstonejs/core';
+import type { ContourRepresentation } from '../../../types/SegmentationStateTypes';
+declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
+declare function render(viewport: StackViewport | Types.IVolumeViewport, contourRepresentation: ContourRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;
-    addSegmentationRepresentation: typeof addSegmentationRepresentation;
-    removeSegmentationRepresentation: typeof removeSegmentationRepresentation;
+    removeRepresentation: typeof removeRepresentation;
 };
 export default _default;

package/dist/esm/tools/displayTools/Contour/contourDisplay.js

@@ -1,82 +1,46 @@
-import { getEnabledElementByIds, utilities as csUtils, StackViewport, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
-import { addOrUpdateContourSets } from './addOrUpdateContourSets';
+import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
+import { computeAndAddContourRepresentation } from '../../../stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation';
 import removeContourFromElement from './removeContourFromElement';
-import { deleteConfigCache } from './contourConfigCache';
-async function addSegmentationRepresentation(toolGroupId, representationInput, toolGroupSpecificConfig) {
-    const { segmentationId } = representationInput;
-    const segmentationRepresentationUID = csUtils.uuidv4();
-    const segmentsHidden = new Set();
-    const visibility = true;
-    const colorLUTIndex = 0;
-    const active = true;
-    const toolGroupSpecificRepresentation = {
-        segmentationId,
-        segmentationRepresentationUID,
-        type: Representations.Contour,
-        segmentsHidden,
-        colorLUTIndex,
-        active,
-        segmentationRepresentationSpecificConfig: {},
-        segmentSpecificConfig: {},
-        config: {},
-    };
-    if (toolGroupSpecificConfig) {
-        const currentToolGroupConfig = SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-        const mergedConfig = csUtils.deepMerge(currentToolGroupConfig, toolGroupSpecificConfig);
-        SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
-            renderInactiveSegmentations: mergedConfig.renderInactiveSegmentations || true,
-            representations: {
-                ...mergedConfig.representations,
-            },
-        });
+let polySegConversionInProgress = false;
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
     }
-    SegmentationState.addSegmentationRepresentation(toolGroupId, toolGroupSpecificRepresentation);
-    return segmentationRepresentationUID;
-}
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, renderImmediate = false) {
-    _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID);
-    SegmentationState.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    deleteConfigCache(segmentationRepresentationUID);
-    if (renderImmediate) {
-        const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-            enabledElement.viewport.render();
-        });
+    const { viewport } = enabledElement;
+    if (!renderImmediate) {
+        return;
     }
+    removeContourFromElement(viewportId, segmentationId);
+    viewport.render();
 }
-async function render(viewport, representationConfig, toolGroupConfig) {
-    const { segmentationId } = representationConfig;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
-    const contourData = segmentation.representationData[Representations.Contour];
-    const { geometryIds } = contourData;
-    if (viewport instanceof StackViewport) {
+async function render(viewport, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
         return;
     }
-    if (!geometryIds?.length) {
-        console.warn(`No contours found for segmentationId ${segmentationId}. Skipping render.`);
+    let contourData = segmentation.representationData[Representations.Contour];
+    if (!contourData &&
+        canComputeRequestedRepresentation(segmentationId, Representations.Contour) &&
+        !polySegConversionInProgress) {
+        polySegConversionInProgress = true;
+        contourData = await computeAndAddContourRepresentation(segmentationId, {
+            viewport,
+        });
     }
-    addOrUpdateContourSets(viewport, geometryIds, representationConfig, toolGroupConfig);
-}
-function _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID) {
-    const toolGroup = getToolGroup(toolGroupId);
-    if (toolGroup === undefined) {
-        throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
+    if (!contourData) {
+        return;
     }
-    const { viewportsInfo } = toolGroup;
-    for (const viewportInfo of viewportsInfo) {
-        const { viewportId, renderingEngineId } = viewportInfo;
-        const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-        removeContourFromElement(enabledElement.viewport.element, segmentationRepresentationUID);
+    if (contourData?.geometryIds?.length) {
+        handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, contourRepresentation);
     }
 }
 export default {
     render,
-    addSegmentationRepresentation,
-    removeSegmentationRepresentation,
+    removeRepresentation,
 };
-//# sourceMappingURL=contourDisplay.js.map

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.d.ts

@@ -0,0 +1,6 @@
+import type { Types, StackViewport } from '@cornerstonejs/core';
+import type { ContourRepresentation } from '../../../../types/SegmentationStateTypes';
+declare function handleContourSegmentation(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], annotationUIDsMap: Map<number, Set<string>>, contourRepresentation: ContourRepresentation): void;
+declare function updateContourSets(viewport: Types.IVolumeViewport | StackViewport, geometryIds: string[], contourRepresentation: ContourRepresentation): void;
+declare function addContourSetsToElement(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], contourRepresentation: ContourRepresentation): void;
+export { handleContourSegmentation, updateContourSets, addContourSetsToElement, };