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

package/dist/esm/tools/displayTools/Surface/addOrUpdateSurfaceToElement.js

@@ -3,9 +3,9 @@ import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
 import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
-import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport';
-function addOrUpdateSurfaceToElement(element, surface, segmentationRepresentationUID) {
-    const actorUID = getSurfaceActorUID(segmentationRepresentationUID, surface.id);
+import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
+    const actorUID = getSurfaceActorUID(segmentationId);
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const surfaceActor = viewport.getActor(actorUID)?.actor;

package/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.d.ts

@@ -1,2 +1,2 @@
-declare function removeContourFromElement(element: HTMLDivElement, segmentationRepresentationUID: string, removeFromCache?: boolean): void;
-export default removeContourFromElement;
+declare function removeSurfaceFromElement(element: HTMLDivElement, segmentationId: string): void;
+export default removeSurfaceFromElement;

package/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.js

@@ -1,11 +1,13 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
+import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function removeSurfaceFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const actorEntries = viewport.getActors();
+    const actorUID = getSurfaceActorUID(segmentationId);
     const actorUIDsToRemove = actorEntries
-        .map(({ uid }) => uid.startsWith(segmentationRepresentationUID) ? uid : undefined)
+        .map(({ uid }) => (uid.startsWith(actorUID) ? uid : undefined))
         .filter(Boolean);
     viewport.removeActors(actorUIDsToRemove);
 }
-export default removeContourFromElement;
+export default removeSurfaceFromElement;

package/dist/esm/tools/displayTools/Surface/surfaceConfig.d.ts

@@ -1,3 +1,3 @@
-import type { SurfaceRenderingConfig } from '../../../types/SurfaceTypes';
-declare function getDefaultSurfaceConfig(): SurfaceRenderingConfig;
-export default getDefaultSurfaceConfig;
+import type { SurfaceStyle } from '../../../types/SurfaceTypes';
+declare function getDefaultSurfaceStyle(): SurfaceStyle;
+export default getDefaultSurfaceStyle;

package/dist/esm/tools/displayTools/Surface/surfaceConfig.js

@@ -2,7 +2,7 @@ const defaultSurfaceConfig = {
     renderFill: true,
     fillAlpha: 1,
 };
-function getDefaultSurfaceConfig() {
+function getDefaultSurfaceStyle() {
     return defaultSurfaceConfig;
 }
-export default getDefaultSurfaceConfig;
+export default getDefaultSurfaceStyle;

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.d.ts

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { SegmentationRepresentation } 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: Types.IVolumeViewport | Types.IStackViewport, representation: SegmentationRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.js

@@ -1,27 +1,25 @@
 import { cache, getEnabledElementByViewportId, VolumeViewport3D, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
 import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
 import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
 import { computeAndAddSurfaceRepresentation } from '../../../stateManagement/segmentation/polySeg';
-function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     if (!enabledElement) {
         return;
     }
     const { viewport } = enabledElement;
-    removeSurfaceFromElement(viewport.element, segmentationRepresentationUID);
-    _removeRepresentation(segmentationRepresentationUID);
+    removeSurfaceFromElement(viewport.element, segmentationId);
     if (!renderImmediate) {
         return;
     }
     viewport.render();
 }
 async function render(viewport, representation) {
-    const { colorLUTIndex, segmentationId, segmentationRepresentationUID } = representation;
+    const { segmentationId } = representation;
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         return;
@@ -31,9 +29,9 @@ async function render(viewport, representation) {
     }
     let SurfaceData = segmentation.representationData[Representations.Surface];
     if (!SurfaceData &&
-        canComputeRequestedRepresentation(segmentationRepresentationUID)) {
+        canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
         SurfaceData = await computeAndAddSurfaceRepresentation(segmentationId, {
-            segmentationRepresentationUID,
+            viewport,
         });
         if (!SurfaceData) {
             throw new Error(`No Surface data found for segmentationId ${segmentationId}.`);
@@ -43,6 +41,7 @@ async function render(viewport, representation) {
     if (!geometryIds?.size) {
         console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);
     }
+    const colorLUTIndex = representation.config?.colorLUTIndex;
     const colorLUT = getColorLUT(colorLUTIndex);
     const surfaces = [];
     geometryIds.forEach((geometryId, segmentIndex) => {
@@ -54,7 +53,7 @@ async function render(viewport, representation) {
         const surface = geometry.data;
         const color = colorLUT[segmentIndex];
         surface.setColor(color.slice(0, 3));
-        addOrUpdateSurfaceToElement(viewport.element, surface, segmentationRepresentationUID);
+        addOrUpdateSurfaceToElement(viewport.element, surface, segmentationId);
         surfaces.push(surface);
     });
     viewport.render();

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

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

package/dist/esm/tools/index.js

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

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -56,7 +56,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
@@ -76,7 +75,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
@@ -92,7 +90,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
@@ -108,7 +105,6 @@ declare class BrushTool extends BaseTool {
         viewPlaneNormal: any;
         toolGroupId: string;
         segmentationId: string;
-        segmentationRepresentationUID: string;
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -1,4 +1,4 @@
-import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, } from '@cornerstonejs/core';
+import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
 import { BaseTool } from '../base';
 import { fillInsideSphere, thresholdInsideSphere, } from './strategies/fillSphere';
@@ -9,12 +9,12 @@ import { Events, ToolModes, SegmentationRepresentations, StrategyCallbacks, } fr
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -194,19 +194,23 @@ class BrushTool extends BaseTool {
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const activeRepresentation = getActiveSegmentationRepresentation(viewport.id);
-        if (!activeRepresentation) {
-            throw new Error('No active segmentation detected, create a segmentation representation before using the brush tool');
-        }
-        const { segmentationId, type } = activeRepresentation;
-        if (type === SegmentationRepresentations.Contour) {
-            throw new Error('Not implemented yet');
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
+            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                detail: {
+                    type: 'Segmentation',
+                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
+                },
+                cancelable: true,
+            });
+            eventTarget.dispatchEvent(event);
+            return null;
         }
+        const { segmentationId } = activeSegmentation;
         const segmentsLocked = getLockedSegmentIndices(segmentationId);
         const { representationData } = getSegmentation(segmentationId);
-        const labelmapData = representationData[SegmentationRepresentations.Labelmap];
-        if (isVolumeSegmentation(labelmapData, viewport)) {
-            const { volumeId } = representationData[type];
+        if (viewport instanceof BaseVolumeViewport) {
+            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
             const actors = viewport.getActors();
             const isStackViewport = viewport instanceof StackViewport;
             if (isStackViewport) {
@@ -220,7 +224,7 @@ class BrushTool extends BaseTool {
                 eventTarget.dispatchEvent(event);
                 return null;
             }
-            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId));
+            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId ?? actorEntry.uid));
             const segmentationVolume = cache.getVolume(volumeId);
             const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
             return {
@@ -282,7 +286,7 @@ class BrushTool extends BaseTool {
         const camera = viewport.getCamera();
         const { viewPlaneNormal, viewUp } = camera;
         const viewportIdsToRender = [viewport.id];
-        const { segmentIndex, segmentationId, segmentationRepresentationUID, segmentColor, } = this.getActiveSegmentationData(viewport) || {};
+        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
         const brushCursor = {
             metadata: {
                 viewPlaneNormal: [...viewPlaneNormal],
@@ -300,25 +304,23 @@ class BrushTool extends BaseTool {
             segmentIndex,
             viewport,
             segmentationId,
-            segmentationRepresentationUID,
             segmentColor,
             viewportIdsToRender,
         };
     }
     getActiveSegmentationData(viewport) {
         const viewportId = viewport.id;
-        const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
+        const activeRepresentation = getActiveSegmentation(viewportId);
         if (!activeRepresentation) {
             console.warn('No active segmentation detected, create one before using the brush tool');
             return;
         }
-        const { segmentationId, segmentationRepresentationUID } = activeRepresentation;
+        const { segmentationId } = activeRepresentation;
         const segmentIndex = getActiveSegmentIndex(segmentationId);
-        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
         return {
             segmentIndex,
             segmentationId,
-            segmentationRepresentationUID,
             segmentColor,
         };
     }
@@ -336,7 +338,7 @@ class BrushTool extends BaseTool {
     }
     getOperationData(element) {
         const editData = this._editData || this.createEditData(element);
-        const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, } = this._hoverData || this.createHoverData(element);
+        const { segmentIndex, segmentationId, brushCursor } = this._hoverData || this.createHoverData(element);
         const { data, metadata = {} } = brushCursor || {};
         const { viewPlaneNormal, viewUp } = metadata;
         const operationData = {
@@ -349,7 +351,6 @@ class BrushTool extends BaseTool {
             viewPlaneNormal,
             toolGroupId: this.toolGroupId,
             segmentationId,
-            segmentationRepresentationUID,
             viewUp,
             strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
             preview: this._previewData?.preview,

package/dist/esm/tools/segmentation/CircleROIStartEndThresholdTool.js

@@ -332,10 +332,10 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
     _computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement) {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, viewUp } = metadata;
-        const { viewport, renderingEngine } = enabledElement;
+        const { viewport } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
-        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const image = this.getTargetImageData(targetId);
         const canvasCoordinates = data.handles.points.map((p) => viewport.worldToCanvas(p));
         const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners(canvasCoordinates));
         const pos1 = viewport.canvasToWorld(topLeftCanvas);

package/dist/esm/tools/segmentation/CircleScissorsTool.d.ts

@@ -16,8 +16,8 @@ declare class CircleScissorsTool extends BaseTool {
         movingTextBox: boolean;
         newAnnotation?: boolean;
         hasMoved?: boolean;
+        imageId: string;
         centerCanvas?: Array<number>;
-        segmentationRepresentationUID?: string;
     } | null;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;

package/dist/esm/tools/segmentation/CircleScissorsTool.js

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideCircle } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
@@ -7,8 +7,7 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 class CircleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -35,16 +34,16 @@ class CircleScissorsTool extends BaseTool {
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
-            if (!activeSegmentationRepresentation) {
+            const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
+            if (!activeLabelmapSegmentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationRepresentationUID, segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId } = activeLabelmapSegmentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[type];
+            const labelmapData = representationData.Labelmap;
             if (!labelmapData) {
                 throw new Error('No labelmap data found for the active segmentation, create one before using scissors tool');
             }
@@ -86,11 +85,11 @@ class CircleScissorsTool extends BaseTool {
                 movingTextBox: false,
                 newAnnotation: true,
                 hasMoved: false,
-                segmentationRepresentationUID,
                 volumeId: null,
                 referencedVolumeId: null,
+                imageId: null,
             };
-            if (isVolumeSegmentation(labelmapData, viewport)) {
+            if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = labelmapData;
                 const segmentation = cache.getVolume(volumeId);
                 this.editData = {
@@ -100,8 +99,10 @@ class CircleScissorsTool extends BaseTool {
                 };
             }
             else {
+                const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 this.editData = {
                     ...this.editData,
+                    imageId: segmentationImageId,
                 };
             }
             this._activateDraw(element);

package/dist/esm/tools/segmentation/PaintFillTool.js

@@ -1,11 +1,10 @@
-import { cache, getEnabledElement, utilities as csUtils, } from '@cornerstonejs/core';
+import { cache, getEnabledElement, utilities as csUtils, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, } from '../../stateManagement/segmentation';
 import floodFill from '../../utilities/segmentation/floodFill';
 import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 const { transformWorldToIndex, isEqual } = csUtils;
 class PaintFillTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -20,22 +19,21 @@ class PaintFillTool extends BaseTool {
             const { viewport } = enabledElement;
             const camera = viewport.getCamera();
             const { viewPlaneNormal } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
             const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             let dimensions;
             let direction;
             let scalarData;
             let index;
             let voxelManager;
-            if (isVolumeSegmentation(labelmapData, viewport)) {
-                const { volumeId } = representationData[type];
+            if (viewport instanceof BaseVolumeViewport) {
+                const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
                 const segmentation = cache.getVolume(volumeId);
                 ({ dimensions, direction } = segmentation);
                 voxelManager = segmentation.voxelManager;

package/dist/esm/tools/segmentation/RectangleROIStartEndThresholdTool.js

@@ -308,10 +308,10 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     _computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement) {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, viewUp } = metadata;
-        const { viewport, renderingEngine } = enabledElement;
+        const { viewport } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
-        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const image = this.getTargetImageData(targetId);
         const worldPos1 = data.handles.points[0];
         const worldPos2 = data.handles.points[3];
         const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);

package/dist/esm/tools/segmentation/RectangleScissorsTool.d.ts

@@ -12,7 +12,6 @@ declare class RectangleScissorsTool extends BaseTool {
         segmentationId: string;
         segmentIndex: number;
         segmentsLocked: number[];
-        segmentationRepresentationUID: string;
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];
         handleIndex?: number;

package/dist/esm/tools/segmentation/RectangleScissorsTool.js

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideRectangle } from './strategies/fillRectangle';
 import { eraseInsideRectangle } from './strategies/eraseRectangle';
@@ -8,8 +8,7 @@ import { drawRect as drawRectSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 class RectangleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -35,14 +34,14 @@ class RectangleScissorsTool extends BaseTool {
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
-            if (!activeSegmentationRepresentation) {
+            const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
+            if (!activeLabelmapSegmentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationRepresentationUID, segmentationId } = activeSegmentationRepresentation;
+            const { segmentationId } = activeLabelmapSegmentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             const annotation = {
@@ -80,12 +79,11 @@ class RectangleScissorsTool extends BaseTool {
                 movingTextBox: false,
                 newAnnotation: true,
                 hasMoved: false,
-                segmentationRepresentationUID,
                 volumeId: null,
                 referencedVolumeId: null,
                 imageId: null,
             };
-            if (isVolumeSegmentation(labelmapData, viewport)) {
+            if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = labelmapData;
                 const segmentation = cache.getVolume(volumeId);
                 this.editData = {
@@ -95,8 +93,10 @@ class RectangleScissorsTool extends BaseTool {
                 };
             }
             else {
+                const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 this.editData = {
                     ...this.editData,
+                    imageId: segmentationImageId,
                 };
             }
             this._activateDraw(element);
@@ -154,7 +154,6 @@ class RectangleScissorsTool extends BaseTool {
             }
             annotation.invalidated = true;
             this.editData.hasMoved = true;
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._endCallback = (evt) => {

package/dist/esm/tools/segmentation/SegmentSelectTool.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import type { PublicToolProps, ToolProps, EventTypes } from '../../types';
-import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+import type { Segmentation } from '../../types/SegmentationStateTypes';
 declare class SegmentSelectTool extends BaseTool {
     static toolName: any;
     private hoverTimer;
@@ -15,6 +15,6 @@ declare class SegmentSelectTool extends BaseTool {
     onSetToolActive: () => void;
     onSetToolDisabled: () => void;
     _setActiveSegment(evt?: EventTypes.InteractionEventType): void;
-    _setActiveSegmentForType(activeSegmentationReps: SegmentationRepresentation, worldPoint: Types.Point3, viewport: Types.IStackViewport | Types.IVolumeViewport): void;
+    _setActiveSegmentForType(activeSegmentation: Segmentation, worldPoint: Types.Point3, viewport: Types.IStackViewport | Types.IVolumeViewport): void;
 }
 export default SegmentSelectTool;

package/dist/esm/tools/segmentation/SegmentSelectTool.js

@@ -2,7 +2,7 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/activeSegmentation';
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
@@ -54,27 +54,18 @@ class SegmentSelectTool extends BaseTool {
             return;
         }
         const { viewport } = enabledElement;
-        const activeSegmentationReps = getActiveSegmentationRepresentation(viewport.id);
-        if (!activeSegmentationReps) {
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
             return;
         }
-        const supportedTypes = [
-            RepresentationTypes.Labelmap,
-            RepresentationTypes.Contour,
-        ];
-        if (supportedTypes.includes(activeSegmentationReps.type)) {
-            this._setActiveSegmentForType(activeSegmentationReps, worldPoint, viewport);
-        }
-        else {
-            console.warn('SegmentSelectTool does not support the current segmentation type.');
-        }
+        this._setActiveSegmentForType(activeSegmentation, worldPoint, viewport);
     }
-    _setActiveSegmentForType(activeSegmentationReps, worldPoint, viewport) {
+    _setActiveSegmentForType(activeSegmentation, worldPoint, viewport) {
         const imageDataInfo = viewport.getImageData();
         if (!imageDataInfo) {
             return;
         }
-        const { segmentationId, type } = activeSegmentationReps;
+        const { segmentationId, representationData } = activeSegmentation;
         let hoveredSegmentIndex;
         if (this.configuration.mode === SegmentSelectTool.SelectMode.Inside) {
             hoveredSegmentIndex = getSegmentIndexAtWorldPoint(segmentationId, worldPoint, {
@@ -82,17 +73,17 @@ class SegmentSelectTool extends BaseTool {
             });
         }
         else {
-            switch (type) {
-                case SegmentationRepresentations.Labelmap:
-                    hoveredSegmentIndex = getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, {
-                        viewport,
-                        searchRadius: this.configuration.searchRadius,
-                    });
-                    break;
-                case SegmentationRepresentations.Contour:
-                    hoveredSegmentIndex =
-                        getHoveredContourSegmentationAnnotation(segmentationId);
-                    break;
+            if (representationData.Labelmap) {
+                hoveredSegmentIndex = getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, {
+                    viewport,
+                    searchRadius: this.configuration.searchRadius,
+                });
+            }
+            else if (representationData.Contour) {
+                hoveredSegmentIndex =
+                    getHoveredContourSegmentationAnnotation(segmentationId);
+            }
+            else if (representationData.Surface) {
             }
         }
         if (!hoveredSegmentIndex || hoveredSegmentIndex === 0) {

package/dist/esm/tools/segmentation/SphereScissorsTool.d.ts

@@ -7,7 +7,6 @@ declare class SphereScissorsTool extends BaseTool {
         annotation: Annotation;
         segmentIndex: number;
         segmentsLocked: number[];
-        segmentationRepresentationUID: string;
         segmentationId: string;
         volumeId: string;
         referencedVolumeId: string;