@cornerstonejs/tools 2.0.0-beta.26 → 2.0.0-beta.28

package/dist/esm/tools/AdvancedMagnifyTool.js

@@ -15,7 +15,7 @@ import { vec2, vec3 } from 'gl-matrix';
 import { getToolGroupForViewport } from '../store/ToolGroupManager';
 import debounce from '../utilities/debounce';
 import { distanceToPoint } from '../utilities/math/point';
-import { addSegmentationRepresentations } from '../stateManagement';
+import { addSegmentationRepresentations } from '../stateManagement/segmentation';
 const MAGNIFY_CLASSNAME = 'advancedMagnifyTool';
 const MAGNIFY_VIEWPORT_INITIAL_RADIUS = 125;
 const { Events: csEvents } = Enums;

package/dist/esm/tools/CrosshairsTool.js

@@ -2,7 +2,7 @@ import { vec2, vec3 } from 'gl-matrix';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import vtkMatrixBuilder from '@kitware/vtk.js/Common/Core/MatrixBuilder';
 import { AnnotationTool } from './base';
-import { getEnabledElementByIds, getEnabledElement, utilities as csUtils, Enums, } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, utilities as csUtils, Enums, CONSTANTS, } from '@cornerstonejs/core';
 import { getToolGroup, getToolGroupForViewport, } from '../store/ToolGroupManager';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement/annotation/annotationState';
 import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLine as drawLineSvg, } from '../drawingSvg';
@@ -14,7 +14,6 @@ import liangBarksyClip from '../utilities/math/vec2/liangBarksyClip';
 import * as lineSegment from '../utilities/math/line';
 import { isAnnotationLocked } from '../stateManagement/annotation/annotationLocking';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
-import { CONSTANTS } from '@cornerstonejs/core';
 const { RENDERING_DEFAULTS } = CONSTANTS;
 function defaultReferenceLineColor() {
     return 'rgb(0, 200, 0)';

package/dist/esm/tools/MIPJumpToClickTool.js

@@ -17,7 +17,7 @@ class MIPJumpToClickTool extends BaseTool {
         const { element, currentPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
-        const volumeId = this.getTargetVolumeId(viewport);
+        const volumeId = viewport.getVolumeId();
         if (!volumeId) {
             throw new Error(`MIPJumpToClickTool: targetId is not a volumeId, you should only use MIPJumpToClickTool with a volumeId as the targetId`);
         }

package/dist/esm/tools/ReferenceLinesTool.js

@@ -32,7 +32,7 @@ class ReferenceLines extends AnnotationDisplayTool {
             const { element } = sourceViewport;
             const { viewUp, viewPlaneNormal } = sourceViewport.getCamera();
             const sourceViewportCanvasCornersInWorld = csUtils.getViewportImageCornersInWorld(sourceViewport);
-            let annotation = this.editData.annotation;
+            let annotation = this.editData?.annotation;
             const FrameOfReferenceUID = sourceViewport.getFrameOfReferenceUID();
             if (!annotation) {
                 const newAnnotation = {
@@ -78,6 +78,9 @@ class ReferenceLines extends AnnotationDisplayTool {
         };
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             const { viewport: targetViewport } = enabledElement;
+            if (!this.editData) {
+                return false;
+            }
             const { annotation, sourceViewportId } = this.editData;
             let renderStatus = false;
             const { viewport: sourceViewport } = getEnabledElementByViewportId(sourceViewportId) || {};
@@ -153,7 +156,7 @@ class ReferenceLines extends AnnotationDisplayTool {
     handleFullDimension(targetViewport, lineStartWorld, viewPlaneNormal, viewUp, lineEndWorld, canvasCoordinates) {
         const renderingEngine = targetViewport.getRenderingEngine();
         const targetId = this.getTargetId(targetViewport);
-        const targetImage = this.getTargetIdImage(targetId, renderingEngine);
+        const targetImage = this.getTargetImageData(targetId);
         const referencedImageId = this.getReferencedImageId(targetViewport, lineStartWorld, viewPlaneNormal, viewUp);
         if (referencedImageId && targetImage) {
             try {

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

@@ -8,6 +8,10 @@ declare class StackScrollTool extends BaseTool {
     mouseDragCallback(evt: EventTypes.InteractionEventType): void;
     touchDragCallback(evt: EventTypes.InteractionEventType): void;
     _dragCallback(evt: EventTypes.InteractionEventType): void;
+    _rotateDrag(evt: EventTypes.InteractionEventType): void;
+    _scrollDrag(evt: EventTypes.InteractionEventType): void;
+    _rotate(evt: any): void;
+    _scroll(evt: EventTypes.MouseWheelEventType): void;
     _getPixelPerImage(viewport: any): number;
 }
 export default StackScrollTool;

package/dist/esm/tools/StackScrollTool.js

@@ -1,6 +1,13 @@
-import { getEnabledElementByIds, getEnabledElement, VolumeViewport, } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, VolumeViewport, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from './base';
 import { scroll } from '../utilities';
+import { mat4, vec3 } from 'gl-matrix';
+const DIRECTIONS = {
+    X: [1, 0, 0],
+    Y: [0, 1, 0],
+    Z: [0, 0, 1],
+    CUSTOM: [],
+};
 class StackScrollTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -8,25 +15,23 @@ class StackScrollTool extends BaseTool {
             invert: false,
             debounceIfNotLoaded: true,
             loop: false,
+            rotate: {
+                enabled: false,
+                direction: DIRECTIONS.Z,
+                rotateIncrementDegrees: 30,
+            },
         },
     }) {
         super(toolProps, defaultToolProps);
         this.deltaY = 1;
     }
     mouseWheelCallback(evt) {
-        const { wheel, element } = evt.detail;
-        const { direction } = wheel;
-        const { invert } = this.configuration;
-        const { viewport } = getEnabledElement(element);
-        const delta = direction * (invert ? -1 : 1);
-        const volumeId = this.getTargetVolumeId(viewport);
-        scroll(viewport, {
-            delta,
-            debounceLoading: this.configuration.debounceIfNotLoaded,
-            loop: this.configuration.loop,
-            volumeId,
-            scrollSlabs: this.configuration.scrollSlabs,
-        });
+        if (this.configuration.rotate.enabled) {
+            this._rotate(evt);
+        }
+        else {
+            this._scroll(evt);
+        }
     }
     mouseDragCallback(evt) {
         this._dragCallback(evt);
@@ -35,13 +40,51 @@ class StackScrollTool extends BaseTool {
         this._dragCallback(evt);
     }
     _dragCallback(evt) {
+        if (this.configuration.rotate.enabled) {
+            this._rotateDrag(evt);
+        }
+        else {
+            this._scrollDrag(evt);
+        }
+    }
+    _rotateDrag(evt) {
+        const { deltaPoints, element } = evt.detail;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const { direction, rotateIncrementDegrees } = this.configuration.rotate;
+        const camera = viewport.getCamera();
+        const { viewUp, position, focalPoint } = camera;
+        const deltaY = deltaPoints.canvas[1];
+        const [cx, cy, cz] = focalPoint;
+        const [ax, ay, az] = direction;
+        const angle = (deltaY * (rotateIncrementDegrees * Math.PI)) / 180;
+        const newPosition = [0, 0, 0];
+        const newFocalPoint = [0, 0, 0];
+        const newViewUp = [0, 0, 0];
+        const transform = mat4.identity(new Float32Array(16));
+        mat4.translate(transform, transform, [cx, cy, cz]);
+        mat4.rotate(transform, transform, angle, [ax, ay, az]);
+        mat4.translate(transform, transform, [-cx, -cy, -cz]);
+        vec3.transformMat4(newPosition, position, transform);
+        vec3.transformMat4(newFocalPoint, focalPoint, transform);
+        mat4.identity(transform);
+        mat4.rotate(transform, transform, angle, [ax, ay, az]);
+        vec3.transformMat4(newViewUp, viewUp, transform);
+        viewport.setCamera({
+            position: newPosition,
+            viewUp: newViewUp,
+            focalPoint: newFocalPoint,
+        });
+        viewport.render();
+    }
+    _scrollDrag(evt) {
         const { deltaPoints, viewportId, renderingEngineId } = evt.detail;
         const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
         const { debounceIfNotLoaded, invert, loop } = this.configuration;
         const deltaPointY = deltaPoints.canvas[1];
         let volumeId;
         if (viewport instanceof VolumeViewport) {
-            volumeId = this.getTargetVolumeId(viewport);
+            volumeId = viewport.getVolumeId();
         }
         const pixelsPerImage = this._getPixelPerImage(viewport);
         const deltaY = deltaPointY + this.deltaY;
@@ -62,6 +105,52 @@ class StackScrollTool extends BaseTool {
             this.deltaY = deltaY;
         }
     }
+    _rotate(evt) {
+        const { element, wheel } = evt.detail;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const { direction, rotateIncrementDegrees } = this.configuration.rotate;
+        const camera = viewport.getCamera();
+        const { viewUp, position, focalPoint } = camera;
+        const { direction: deltaY } = wheel;
+        const [cx, cy, cz] = focalPoint;
+        const [ax, ay, az] = direction;
+        const angle = (deltaY * (rotateIncrementDegrees * Math.PI)) / 180;
+        const newPosition = [0, 0, 0];
+        const newFocalPoint = [0, 0, 0];
+        const newViewUp = [0, 0, 0];
+        const transform = mat4.identity(new Float32Array(16));
+        mat4.translate(transform, transform, [cx, cy, cz]);
+        mat4.rotate(transform, transform, angle, [ax, ay, az]);
+        mat4.translate(transform, transform, [-cx, -cy, -cz]);
+        vec3.transformMat4(newPosition, position, transform);
+        vec3.transformMat4(newFocalPoint, focalPoint, transform);
+        mat4.identity(transform);
+        mat4.rotate(transform, transform, angle, [ax, ay, az]);
+        vec3.transformMat4(newViewUp, viewUp, transform);
+        viewport.setCamera({
+            position: newPosition,
+            viewUp: newViewUp,
+            focalPoint: newFocalPoint,
+        });
+        viewport.render();
+    }
+    _scroll(evt) {
+        const { wheel, element } = evt.detail;
+        const { direction } = wheel;
+        const { invert } = this.configuration;
+        const { viewport } = getEnabledElement(element);
+        const delta = direction * (invert ? -1 : 1);
+        scroll(viewport, {
+            delta,
+            debounceLoading: this.configuration.debounceIfNotLoaded,
+            loop: this.configuration.loop,
+            volumeId: viewport instanceof BaseVolumeViewport
+                ? viewport.getVolumeId()
+                : undefined,
+            scrollSlabs: this.configuration.scrollSlabs,
+        });
+    }
     _getPixelPerImage(viewport) {
         const { element } = viewport;
         const numberOfSlices = viewport.getNumberOfSlices();

package/dist/esm/tools/WindowLevelTool.js

@@ -47,8 +47,9 @@ class WindowLevelTool extends BaseTool {
         let isPreScaled = false;
         const properties = viewport.getProperties();
         if (viewport instanceof VolumeViewport) {
-            volumeId = this.getTargetVolumeId(viewport);
-            viewportsContainingVolumeUID = utilities.getViewportsWithVolumeId(volumeId, renderingEngine.id);
+            volumeId = viewport.getVolumeId();
+            viewportsContainingVolumeUID =
+                utilities.getViewportsWithVolumeId(volumeId);
             ({ lower, upper } = properties.voiRange);
             const volume = cache.getVolume(volumeId);
             if (!volume) {

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

@@ -418,7 +418,7 @@ class AngleTool extends AnnotationTool {
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
             const angle = angleBetweenLines([worldPos1, worldPos2], [worldPos2, worldPos3]);
-            const { dimensions, imageData } = this.getTargetIdImage(targetId, renderingEngine);
+            const { dimensions, imageData } = this.getTargetImageData(targetId);
             this.isHandleOutsideImage = [worldPos1, worldPos2, worldPos3]
                 .map((worldPos) => csUtils.transformWorldToIndex(imageData, worldPos))
                 .some((index) => !csUtils.indexWithinDimensions(index, dimensions));

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

@@ -597,7 +597,7 @@ class BidirectionalTool extends AnnotationTool {
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }

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

@@ -468,7 +468,7 @@ class CircleROITool extends AnnotationTool {
             const worldPos2 = bottomRightWorld;
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }

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

@@ -548,7 +548,7 @@ class EllipticalROITool extends AnnotationTool {
             const worldPos2 = bottomRightWorld;
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }

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

@@ -395,7 +395,7 @@ class HeightTool extends AnnotationTool {
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
-            const image = this.getTargetIdImage(targetId, renderingEngine);
+            const image = this.getTargetImageData(targetId);
             if (!image) {
                 continue;
             }

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

@@ -386,7 +386,7 @@ class LengthTool extends AnnotationTool {
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
-            const image = this.getTargetIdImage(targetId, renderingEngine);
+            const image = this.getTargetImageData(targetId);
             if (!image) {
                 continue;
             }

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

@@ -319,7 +319,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }
@@ -414,8 +414,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         let width;
         let height;
         let scalarData;
-        if (!(viewport instanceof VolumeViewport) && scalarData) {
-            ({ scalarData } = viewportImageData);
+        if (!(viewport instanceof VolumeViewport)) {
             width = viewportImageData.dimensions[0];
             height = viewportImageData.dimensions[1];
             worldToSlice = (point) => {
@@ -423,6 +422,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
                 return [ijkPoint[0], ijkPoint[1]];
             };
             sliceToWorld = (point) => csUtils.transformIndexToWorld(vtkImageData, [point[0], point[1], 0]);
+            scalarData = viewportImageData.scalarData;
         }
         else if (viewport instanceof VolumeViewport) {
             const sliceImageData = csUtils.getCurrentVolumeViewportSlice(viewport);

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

@@ -138,7 +138,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }

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

@@ -260,7 +260,7 @@ class ProbeTool extends AnnotationTool {
                 isPreScaled: isViewportPreScaled(viewport, targetId),
                 isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
             };
-            const image = this.getTargetIdImage(targetId, renderingEngine);
+            const image = this.getTargetImageData(targetId);
             if (!image) {
                 continue;
             }
@@ -274,7 +274,7 @@ class ProbeTool extends AnnotationTool {
                 if (targetId.startsWith('imageId:')) {
                     const imageId = targetId.split('imageId:')[1];
                     const imageURI = csUtils.imageIdToURI(imageId);
-                    const viewports = csUtils.getViewportsWithImageURI(imageURI, renderingEngineId);
+                    const viewports = csUtils.getViewportsWithImageURI(imageURI);
                     const viewport = viewports[0];
                     ijk[2] = viewport.getCurrentImageIdIndex();
                 }

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

@@ -459,7 +459,7 @@ class RectangleROITool extends AnnotationTool {
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }

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

@@ -160,8 +160,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
             this._deactivateDraw(element);
             resetElementCursor(element);
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
-            const image = this.getTargetIdImage(this.getTargetId(enabledElement.viewport), enabledElement.renderingEngine);
+            const image = this.getTargetImageData(this.getTargetId(enabledElement.viewport));
             const { imageData, dimensions } = image;
             this.isHandleOutsideImage = data.handles.points
                 .map((p) => utilities.transformWorldToIndex(imageData, p))
@@ -433,7 +432,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
-                const image = this.getTargetIdImage(targetId, renderingEngine);
+                const image = this.getTargetImageData(targetId);
                 if (!image) {
                     continue;
                 }

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

@@ -389,7 +389,7 @@ class UltrasoundDirectionalTool extends AnnotationTool {
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
-            const image = this.getTargetIdImage(targetId, renderingEngine);
+            const image = this.getTargetImageData(targetId);
             if (!image) {
                 continue;
             }

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

@@ -14,8 +14,7 @@ declare abstract class BaseTool {
     applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string): any;
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
-    protected getTargetVolumeId(viewport: Types.IViewport): string | undefined;
-    protected getTargetIdImage(targetId: string, renderingEngine: Types.IRenderingEngine): Types.IImageData | Types.CPUIImageData | Types.IImageVolume;
+    protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;
     protected getTargetId(viewport: Types.IViewport): string | undefined;
 }
 export default BaseTool;

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

@@ -35,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;
             }
@@ -63,7 +53,7 @@ class BaseTool {
         }
         else if (targetId.startsWith('volumeId:')) {
             const volumeId = utilities.getVolumeId(targetId);
-            const viewports = utilities.getViewportsWithVolumeId(volumeId, renderingEngine.id);
+            const viewports = utilities.getViewportsWithVolumeId(volumeId);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -71,7 +61,7 @@ class BaseTool {
         }
         else if (targetId.startsWith('videoId:')) {
             const imageURI = utilities.imageIdToURI(targetId);
-            const viewports = utilities.getViewportsWithImageURI(imageURI, renderingEngine.id);
+            const viewports = utilities.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -86,10 +76,7 @@ class BaseTool {
         if (targetId) {
             return targetId;
         }
-        if (viewport instanceof BaseVolumeViewport) {
-            return `volumeId:${this.getTargetVolumeId(viewport)}`;
-        }
-        throw new Error('getTargetId: viewport must have a getReferenceId method');
+        throw new Error('getTargetId: viewport must have a getViewReferenceId method');
     }
 }
 BaseTool.toolName = 'BaseTool';

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

@@ -1,5 +1,4 @@
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
-import { getGlobalConfig, getSegmentationRepresentationConfig, getSegmentIndexConfig, } from '../../stateManagement/segmentation/config/segmentationConfig';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
@@ -9,14 +8,14 @@ import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation,
 import { triggerAnnotationRenderForToolGroupIds } from '../../utilities/triggerAnnotationRenderForToolGroupIds';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
-import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentations';
-import { getSegmentationRepresentationsForSegmentation } from '../../stateManagement/segmentation/getSegmentationRepresentationsForSegmentation';
-import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/getActiveSegmentationRepresentation';
+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 { getSegmentIndexVisibility } from '../../stateManagement/segmentation/config/segmentationVisibility';
+import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -39,12 +38,11 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (!this.isContourSegmentationTool()) {
             return contourAnnotation;
         }
-        const activeSeg = getActiveSegmentationRepresentation(viewport.id);
+        const activeSeg = getActiveSegmentation(viewport.id);
         if (!activeSeg) {
             throw new Error('No active segmentation detected, create one before using scissors tool');
         }
-        const { type: segmentationType } = activeSeg;
-        if (segmentationType !== SegmentationRepresentations.Contour) {
+        if (!activeSeg.representationData.Contour) {
             throw new Error(`A contour segmentation must be active`);
         }
         const { segmentationId } = activeSeg;
@@ -100,35 +98,36 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
         const segmentation = getSegmentation(segmentationId);
-        const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentationId);
+        const { viewportId } = context.styleSpecifier;
+        const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
         if (!segmentationRepresentations?.length) {
             return {};
         }
-        const allUIDs = segmentationRepresentations.map((rep) => rep.segmentationRepresentationUID);
         let segmentationRepresentation;
         if (segmentationRepresentations.length > 1) {
-            const viewportReps = getSegmentationRepresentations(context.styleSpecifier.viewportId);
-            segmentationRepresentation = viewportReps.find((rep) => rep.segmentationId === segmentationId &&
-                allUIDs.includes(rep.segmentationRepresentationUID));
+            segmentationRepresentation = segmentationRepresentations.find((rep) => rep.segmentationId === segmentationId &&
+                rep.type === SegmentationRepresentations.Contour);
         }
         else {
             segmentationRepresentation = segmentationRepresentations[0];
         }
-        const { segmentationRepresentationUID } = segmentationRepresentation;
         const { autoGenerated } = annotation;
         const segmentsLocked = getLockedSegmentIndices(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
-        const viewportId = context.styleSpecifier.viewportId;
-        const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
-        const globalConfig = getGlobalConfig();
-        const segmentationRepresentationConfig = getSegmentationRepresentationConfig(segmentationRepresentationUID);
-        const segmentConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
-        const segmentVisible = getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
-        const activeSegRep = getActiveSegmentationRepresentation(viewportId);
-        const isActive = activeSegRep.segmentationRepresentationUID ===
-            segmentationRepresentationUID;
-        const mergedConfig = Object.assign({}, globalConfig?.representations?.Contour ?? {}, segmentationRepresentationConfig ?? {}, segmentConfig ?? {});
+        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;
@@ -167,7 +166,11 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             textbox: {
                 color,
             },
-            visibility: segmentationVisible && segmentVisible,
+            visibility: segmentationVisible &&
+                getSegmentIndexVisibility(viewportId, {
+                    segmentationId,
+                    type: SegmentationRepresentations.Contour,
+                }, segmentIndex),
             locked: annotationLocked,
         };
     }

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

@@ -1,3 +1,3 @@
-import type { 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

@@ -14,7 +14,7 @@ const defaultContourConfig = {
     fillAlphaInactive: 0.3,
     fillAlphaAutoGenerated: 0.3,
 };
-function getDefaultContourConfig() {
+function getDefaultContourStyle() {
     return defaultContourConfig;
 }
-export default getDefaultContourConfig;
+export default getDefaultContourStyle;

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

@@ -1,6 +1,6 @@
 import type { StackViewport, Types } from '@cornerstonejs/core';
 import type { ContourRepresentation } from '../../../types/SegmentationStateTypes';
-declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+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;