@cornerstonejs/tools 2.0.0-beta.27 → 2.0.0-beta.29

package/dist/esm/tools/displayTools/Labelmap/removeLabelmapFromElement.js

@@ -1,8 +1,8 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-function removeLabelmapFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
+import { getLabelmapActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+function removeLabelmapFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
-    viewport.removeActors([segmentationRepresentationUID]);
+    viewport.removeActors([getLabelmapActorUID(segmentationId)]);
 }
 export default removeLabelmapFromElement;
-//# sourceMappingURL=removeLabelmapFromElement.js.map

package/dist/esm/tools/displayTools/Labelmap/validateLabelmap.js

@@ -30,4 +30,3 @@ export function validatePublic(segmentationInput) {
 export function validate(segmentationRepresentationData) {
     validateRepresentationData(segmentationRepresentationData);
 }
-//# sourceMappingURL=validateLabelmap.js.map

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

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-declare function addOrUpdateSurfaceToElement(element: HTMLDivElement, surface: Types.ISurface, segmentationRepresentationUID: string): void;
+declare function addOrUpdateSurfaceToElement(element: HTMLDivElement, surface: Types.ISurface, segmentationId: string): void;
 export default addOrUpdateSurfaceToElement;

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;
@@ -61,4 +61,3 @@ function addOrUpdateSurfaceToElement(element, surface, segmentationRepresentatio
     }, 0);
 }
 export default addOrUpdateSurfaceToElement;
-//# sourceMappingURL=addOrUpdateSurfaceToElement.js.map

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

@@ -1,3 +1,2 @@
 import surfaceDisplay from './surfaceDisplay';
 export { surfaceDisplay };
-//# sourceMappingURL=index.js.map

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,12 +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;
-//# sourceMappingURL=removeSurfaceFromElement.js.map
+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,8 +2,7 @@ const defaultSurfaceConfig = {
     renderFill: true,
     fillAlpha: 1,
 };
-function getDefaultSurfaceConfig() {
+function getDefaultSurfaceStyle() {
     return defaultSurfaceConfig;
 }
-export default getDefaultSurfaceConfig;
-//# sourceMappingURL=surfaceConfig.js.map
+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) {
+import { computeAndAddSurfaceRepresentation } from '../../../stateManagement/segmentation/polySeg/Surface/computeAndAddSurfaceRepresentation';
+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;
     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();
@@ -64,4 +63,3 @@ export default {
     removeRepresentation,
 };
 export { render, removeRepresentation };
-//# sourceMappingURL=surfaceDisplay.js.map

package/dist/esm/tools/distancePointToContour.js

@@ -16,4 +16,3 @@ export const distancePointToContour = (viewport, annotation, coords) => {
     }
     return distance;
 };
-//# sourceMappingURL=distancePointToContour.js.map

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,5 +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, };
-//# sourceMappingURL=index.js.map
+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'],
@@ -132,10 +132,10 @@ class BrushTool extends BaseTool {
             }
         };
         this.previewCallback = () => {
+            this._previewData.timer = null;
             if (this._previewData.preview) {
                 return;
             }
-            this._previewData.timer = null;
             this._previewData.preview = this.applyActiveStrategyCallback(getEnabledElement(this._previewData.element), this.getOperationData(this._previewData.element), StrategyCallbacks.Preview);
         };
         this._dragCallback = (evt) => {
@@ -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,26 @@ 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);
+        if (!segmentIndex) {
+            return;
+        }
+        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
         return {
             segmentIndex,
             segmentationId,
-            segmentationRepresentationUID,
             segmentColor,
         };
     }
@@ -336,7 +341,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 +354,6 @@ class BrushTool extends BaseTool {
             viewPlaneNormal,
             toolGroupId: this.toolGroupId,
             segmentationId,
-            segmentationRepresentationUID,
             viewUp,
             strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
             preview: this._previewData?.preview,
@@ -486,4 +490,3 @@ class BrushTool extends BaseTool {
 }
 BrushTool.toolName = 'Brush';
 export default BrushTool;
-//# sourceMappingURL=BrushTool.js.map

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);
@@ -477,4 +477,3 @@ function defaultGetTextLines(data) {
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';
 export default CircleROIStartEndThresholdTool;
-//# sourceMappingURL=CircleROIStartEndThresholdTool.js.map

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);
@@ -228,4 +229,3 @@ class CircleScissorsTool extends BaseTool {
 }
 CircleScissorsTool.toolName = 'CircleScissor';
 export default CircleScissorsTool;
-//# sourceMappingURL=CircleScissorsTool.js.map

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;
@@ -231,4 +229,3 @@ class PaintFillTool extends BaseTool {
 }
 PaintFillTool.toolName = 'PaintFill';
 export default PaintFillTool;
-//# sourceMappingURL=PaintFillTool.js.map

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);
@@ -435,4 +435,3 @@ function defaultGetTextLines(data) {
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 export default RectangleROIStartEndThresholdTool;
-//# sourceMappingURL=RectangleROIStartEndThresholdTool.js.map

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

@@ -143,4 +143,3 @@ class RectangleROIThresholdTool extends RectangleROITool {
 }
 RectangleROIThresholdTool.toolName = 'RectangleROIThreshold';
 export default RectangleROIThresholdTool;
-//# sourceMappingURL=RectangleROIThresholdTool.js.map

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) => {
@@ -223,4 +222,3 @@ class RectangleScissorsTool extends BaseTool {
 }
 RectangleScissorsTool.toolName = 'RectangleScissor';
 export default RectangleScissorsTool;
-//# sourceMappingURL=RectangleScissorsTool.js.map