@cornerstonejs/tools 2.0.0-beta.23 → 2.0.0-beta.25

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

@@ -10,10 +10,11 @@ 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, } from '../../stateManagement/segmentation/segmentationState';
+import { getActiveSegmentationRepresentation, 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';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -141,7 +142,6 @@ class BrushTool extends BaseTool {
             const eventData = evt.detail;
             const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             this.updateCursor(evt);
             const { viewportIdsToRender } = this._hoverData;
             triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
@@ -235,12 +235,45 @@ class BrushTool extends BaseTool {
                 return;
             }
             if (this.configuration.activeStrategy.includes('SPHERE')) {
-                throw new Error('Sphere manipulation is not supported for stacks of image segmentations yet');
+                const referencedImageIds = viewport.getImageIds();
+                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+                if (!isValidVolumeForSphere) {
+                    throw new Error('Volume is not reconstructable for sphere manipulation');
+                }
+                const labelmapImageIds = getStackSegmentationImageIdsForViewport(viewport.id, segmentationId);
+                if (!labelmapImageIds || labelmapImageIds.length === 1) {
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                    };
+                }
+                const tempVolumeId = 'tempVolumeId';
+                const { dimensions, direction, origin, spacing, numberOfComponents, imageIds: sortedLabelmapImageIds, } = csUtils.generateVolumePropsFromImageIds(labelmapImageIds, tempVolumeId);
+                const newVoxelManager = csUtils.VoxelManager.createImageVolumeVoxelManager({
+                    dimensions,
+                    imageIds: sortedLabelmapImageIds,
+                    numberOfComponents,
+                });
+                const newImageData = vtkImageData.newInstance();
+                newImageData.setDimensions(dimensions);
+                newImageData.setSpacing(spacing);
+                newImageData.setDirection(direction);
+                newImageData.setOrigin(origin);
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                    override: {
+                        voxelManager: newVoxelManager,
+                        imageData: newImageData,
+                    },
+                };
+            }
+            else {
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                };
             }
-            return {
-                imageId: segmentationImageId,
-                segmentsLocked,
-            };
         }
     }
     createHoverData(element, centerCanvas) {

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

@@ -171,30 +171,35 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
                 const focalPoint = viewport.getCamera().focalPoint;
                 const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
-                let startCoord = startCoordinate;
-                let endCoord = endCoordinate;
+                let tempStartCoordinate = startCoordinate;
+                let tempEndCoordinate = endCoordinate;
                 if (Array.isArray(startCoordinate)) {
-                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                    tempStartCoordinate = this._getCoordinateForViewplaneNormal(tempStartCoordinate, viewplaneNormal);
+                    data.startCoordinate = tempStartCoordinate;
                 }
                 if (Array.isArray(endCoordinate)) {
-                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                    tempEndCoordinate = this._getCoordinateForViewplaneNormal(tempEndCoordinate, viewplaneNormal);
+                    data.endCoordinate = tempEndCoordinate;
                 }
-                const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
-                const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
-                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
-                const roundedCoord = coreUtils.roundToPrecision(coord);
-                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
-                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
+                const roundedStartCoordinate = coreUtils.roundToPrecision(data.startCoordinate);
+                const roundedEndCoordinate = coreUtils.roundToPrecision(data.endCoordinate);
+                const cameraCoordinate = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCameraCoordinate = coreUtils.roundToPrecision(cameraCoordinate);
+                if (roundedCameraCoordinate <
+                    Math.min(roundedStartCoordinate, roundedEndCoordinate) ||
+                    roundedCameraCoordinate >
+                        Math.max(roundedStartCoordinate, roundedEndCoordinate)) {
                     continue;
                 }
-                if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, enabledElement);
-                }
-                const middleCoord = coreUtils.roundToPrecision((startCoord + endCoord) / 2);
+                const middleCoordinate = coreUtils.roundToPrecision((data.startCoordinate + data.endCoordinate) / 2);
                 let isMiddleSlice = false;
-                if (roundedCoord === middleCoord) {
+                if (roundedCameraCoordinate === middleCoordinate) {
                     isMiddleSlice = true;
                 }
+                data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = middleCoordinate;
+                if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                }
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
@@ -420,6 +425,9 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         const targetId = this.getTargetId(viewport);
         const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
         this._computeProjectionPoints(annotation, imageVolume);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement);
+        }
         annotation.invalidated = false;
         triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;

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

@@ -172,9 +172,12 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 let endCoord = endCoordinate;
                 if (Array.isArray(startCoordinate)) {
                     startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
                 }
                 if (Array.isArray(endCoordinate)) {
                     endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                    data.endCoordinate = endCoord;
                 }
                 const roundedStartCoord = csUtils.roundToPrecision(startCoord);
                 const roundedEndCoord = csUtils.roundToPrecision(endCoord);
@@ -378,6 +381,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         const targetId = this.getTargetId(viewport);
         const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
         this._computeProjectionPoints(annotation, imageVolume);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
         annotation.invalidated = false;
         triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -37,7 +37,8 @@ export default class BrushStrategy {
             }
             this._fill.forEach((func) => func(initializedData));
             const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
-            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfSlices());
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices());
+            segmentationVoxelManager.resetModifiedSlices();
             if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
                 return null;
             }
@@ -69,7 +70,9 @@ export default class BrushStrategy {
                 BrushStrategy.childFunctions[key](this, result[key]);
             }
         });
-        this.strategyFunction = (enabledElement, operationData) => this.fill(enabledElement, operationData);
+        this.strategyFunction = (enabledElement, operationData) => {
+            return this.fill(enabledElement, operationData);
+        };
         for (const key of Object.keys(BrushStrategy.childFunctions)) {
             this.strategyFunction[key] = this[key];
         }
@@ -82,9 +85,11 @@ export default class BrushStrategy {
             return operationData.preview;
         }
         const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
+        const segmentationVoxelManagerToUse = operationData.override?.voxelManager || segmentationVoxelManager;
+        const segmentationImageDataToUse = operationData.override?.imageData || segmentationImageData;
         const previewVoxelManager = operationData.preview?.previewVoxelManager ||
             VoxelManager.createHistoryVoxelManager({
-                sourceVoxelManager: segmentationVoxelManager,
+                sourceVoxelManager: segmentationVoxelManagerToUse,
             });
         const previewEnabled = !!operationData.previewColors;
         const previewSegmentIndex = previewEnabled ? 255 : undefined;
@@ -94,8 +99,8 @@ export default class BrushStrategy {
             ...operationData,
             enabledElement,
             imageVoxelManager,
-            segmentationVoxelManager,
-            segmentationImageData,
+            segmentationVoxelManager: segmentationVoxelManagerToUse,
+            segmentationImageData: segmentationImageDataToUse,
             previewVoxelManager,
             viewport,
             centerWorld: null,

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -118,6 +118,6 @@ export default {
                 }
             }
         }
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -66,7 +66,7 @@ export default {
             }
         };
         tracking.forEach(callback, {});
-        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices());
         tracking.clear();
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
@@ -78,7 +78,7 @@ export default {
             segmentationVoxelManager.setAtIndex(index, value);
         };
         previewVoxelManager.forEach(callback);
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
         previewVoxelManager.clear();
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/setValue.js

@@ -1,12 +1,14 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
+        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, segmentationId, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
+        let changed = false;
         if (segmentIndex === null) {
             const oldValue = previewVoxelManager.getAtIndex(index);
             if (oldValue !== undefined) {
-                previewVoxelManager.setAtIndex(index, oldValue);
+                changed = previewVoxelManager.setAtIndex(index, oldValue);
             }
             return;
         }
@@ -15,13 +17,13 @@ export default {
         }
         if (existingValue === previewSegmentIndex) {
             if (previewVoxelManager.getAtIndex(index) === undefined) {
-                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+                changed = segmentationVoxelManager.setAtIndex(index, segmentIndex);
             }
             else {
                 return;
             }
         }
         const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
-        previewVoxelManager.setAtIndex(index, useSegmentIndex);
+        changed = previewVoxelManager.setAtIndex(index, useSegmentIndex);
     },
 };

package/dist/esm/tools/segmentation/strategies/fillSphere.js

@@ -21,20 +21,11 @@ const sphereComposition = {
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
         const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfo(points.slice(0, 2), segmentationImageData, viewport);
         segmentationVoxelManager.boundsIJK = newBoundsIJK;
-        if (imageVoxelManager) {
-            imageVoxelManager.isInObject = createEllipseInPoint({
-                topLeftWorld,
-                bottomRightWorld,
-                center,
-            });
-        }
-        else {
-            segmentationVoxelManager.isInObject = createEllipseInPoint({
-                topLeftWorld,
-                bottomRightWorld,
-                center,
-            });
-        }
+        segmentationVoxelManager.isInObject = createEllipseInPoint({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
     },
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview);

package/dist/esm/types/EventTypes.d.ts

@@ -5,9 +5,8 @@ import type ITouchPoints from './ITouchPoints';
 import type IDistance from './IDistance';
 import type { SetToolBindingsType } from './ISetToolModeOptions';
 import type { Swipe } from '../enums/Touch';
-import type { ToolModes } from '../enums';
+import type { ToolModes, ChangeTypes } from '../enums';
 import type { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
-import type { ChangeTypes } from '../enums';
 type NormalizedInteractionEventDetail = {
     eventName: string;
     renderingEngineId: string;

package/dist/esm/types/IBaseTool.d.ts

@@ -0,0 +1,2 @@
+import type BaseTool from '../tools/base/BaseTool';
+export type IBaseTool = BaseTool;

package/dist/esm/types/IBaseTool.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/IToolGroup.d.ts

@@ -1,63 +1,3 @@
-import type { Types } from '@cornerstonejs/core';
-import type { IToolBinding, SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
-import type { MouseBindings } from '../enums';
-import type { ToolConfiguration } from '../types';
-export default interface IToolGroup {
-    _toolInstances: Record<string, unknown>;
-    id: string;
-    viewportsInfo: Array<Types.IViewportId>;
-    toolOptions: Record<string, unknown>;
-    getViewportIds: () => string[];
-    getViewportsInfo: () => Array<Types.IViewportId>;
-    getToolInstance: {
-        (toolName: string): unknown;
-    };
-    hasTool(toolName: string): boolean;
-    addTool: {
-        (toolName: string, toolConfiguration?: ToolConfiguration): void;
-    };
-    addToolInstance: {
-        (toolName: string, parentClassName: string, configuration?: unknown): void;
-    };
-    addViewport: {
-        (viewportId: string, renderingEngineId?: string): void;
-    };
-    removeViewports: {
-        (renderingEngineId: string, viewportId?: string): void;
-    };
-    setToolActive: {
-        (toolName: string, toolBindingsOption?: SetToolBindingsType): void;
-    };
-    setToolPassive: {
-        (toolName: string, options?: {
-            removeAllBindings?: boolean | IToolBinding[];
-        }): void;
-    };
-    setToolEnabled: {
-        (toolName: string): void;
-    };
-    setToolDisabled: {
-        (toolName: string): void;
-    };
-    getToolOptions: {
-        (toolName: string): ToolOptionsType;
-    };
-    getActivePrimaryMouseButtonTool: {
-        (): undefined | string;
-    };
-    setViewportsCursorByToolName: {
-        (toolName: string, strategyName?: string): void;
-    };
-    setToolConfiguration: {
-        (toolName: string, configuration: ToolConfiguration, overwrite?: boolean): void;
-    };
-    getToolConfiguration: {
-        (toolName: string, configurationPath?: string): unknown;
-    };
-    getDefaultMousePrimary: {
-        (): MouseBindings;
-    };
-    clone: {
-        (newToolGroupId: string, fnToolFilter: (toolName: string) => boolean): IToolGroup;
-    };
-}
+import type ToolGroup from '../store/ToolGroupManager/ToolGroup';
+type IToolGroup = ToolGroup;
+export type { IToolGroup as default };

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
@@ -11,6 +12,10 @@ type LabelmapToolOperationData = {
     segmentationRepresentationUID: string;
     points: Types.Point3[];
     voxelManager: any;
+    override: {
+        voxelManager: Types.IVoxelManager<number>;
+        imageData: vtkImageData;
+    };
     preview: any;
     toolGroupId: string;
 };

package/dist/esm/types/SegmentationStateTypes.d.ts

@@ -3,24 +3,23 @@ import type * as Enums from '../enums';
 import type { ContourConfig, ContourRenderingConfig, ContourSegmentationData } from './ContourTypes';
 import type { LabelmapConfig, LabelmapRenderingConfig, LabelmapSegmentationData } from './LabelmapTypes';
 import type { SurfaceSegmentationData, SurfaceRenderingConfig } from './SurfaceTypes';
-export type SegmentRepresentationConfig = {
-    [key: number | string]: RepresentationConfig;
-};
 export type SurfaceConfig = {};
-export type RepresentationConfig = {
-    LABELMAP?: LabelmapConfig;
-    CONTOUR?: ContourConfig;
-    SURFACE?: SurfaceConfig;
+export type RepresentationsConfig = {
+    [Enums.SegmentationRepresentations.Labelmap]?: LabelmapConfig;
+    [Enums.SegmentationRepresentations.Contour]?: ContourConfig;
+    [Enums.SegmentationRepresentations.Surface]?: SurfaceConfig;
 };
-export type SegmentationRepresentationConfig = {
+export type RepresentationConfig = LabelmapConfig | ContourConfig | SurfaceConfig;
+export type GlobalConfig = {
     renderInactiveRepresentations: boolean;
-    representations: RepresentationConfig;
+    representations: RepresentationsConfig;
 };
-export type SegmentationRepresentationData = {
-    LABELMAP?: LabelmapSegmentationData;
-    CONTOUR?: ContourSegmentationData;
-    SURFACE?: SurfaceSegmentationData;
+export type RepresentationsData = {
+    [Enums.SegmentationRepresentations.Labelmap]?: LabelmapSegmentationData;
+    [Enums.SegmentationRepresentations.Contour]?: ContourSegmentationData;
+    [Enums.SegmentationRepresentations.Surface]?: SurfaceSegmentationData;
 };
+export type RepresentationData = LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
 export type Segmentation = {
     segmentationId: string;
     type: Enums.SegmentationRepresentations;
@@ -33,7 +32,7 @@ export type Segmentation = {
     segmentLabels: {
         [key: string]: string;
     };
-    representationData: SegmentationRepresentationData;
+    representationData: RepresentationsData;
 };
 export type BaseSegmentationRepresentation = {
     segmentationRepresentationUID: string;
@@ -46,7 +45,7 @@ export type BaseSegmentationRepresentation = {
     };
     config: {
         allSegments?: RepresentationConfig;
-        perSegment?: SegmentRepresentationConfig;
+        perSegment?: RepresentationConfig;
     };
 };
 export type LabelmapRepresentation = BaseSegmentationRepresentation & {
@@ -62,7 +61,7 @@ export type SegmentationRepresentation = LabelmapRepresentation | ContourReprese
 export type SegmentationState = {
     colorLUT: Types.ColorLUT[];
     segmentations: Segmentation[];
-    globalConfig: SegmentationRepresentationConfig;
+    globalConfig: GlobalConfig;
     representations: {
         [key: string]: SegmentationRepresentation;
     };
@@ -80,14 +79,9 @@ export type SegmentationPublicInput = {
     segmentationId: string;
     representation: {
         type: Enums.SegmentationRepresentations;
-        data?: LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
+        data?: RepresentationData;
     };
 };
-export type RepresentationPublicInput = {
-    segmentationId: string;
-    type: Enums.SegmentationRepresentations;
-    options?: RepresentationPublicInputOptions;
-};
 export type RepresentationPublicInputOptions = {
     segmentationRepresentationUID?: string;
     colorLUTOrIndex?: Types.ColorLUT | number;
@@ -96,3 +90,9 @@ export type RepresentationPublicInputOptions = {
         options?: unknown;
     };
 };
+export type RepresentationPublicInput = {
+    segmentationId: string;
+    type: Enums.SegmentationRepresentations;
+    options?: RepresentationPublicInputOptions;
+    config?: RepresentationConfig;
+};

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

@@ -22,7 +22,7 @@ import type ScrollOptions from './ScrollOptions';
 import type BoundsIJK from './BoundsIJK';
 import type SVGDrawingHelper from './SVGDrawingHelper';
 import type * as CINETypes from './CINETypes';
-import type { RepresentationConfig, SegmentationRepresentationConfig, SegmentationRepresentationData, Segmentation, SegmentationState, RepresentationPublicInput } from './SegmentationStateTypes';
+import type { RepresentationConfig, RepresentationData, RepresentationsData, GlobalConfig, Segmentation, SegmentationState, RepresentationPublicInput } from './SegmentationStateTypes';
 import type { ISculptToolShape } from './ISculptToolShape';
 import type ISynchronizerEventHandler from './ISynchronizerEventHandler';
 import type { FloodFillGetter, FloodFillOptions, FloodFillResult } from './FloodFillTypes';
@@ -46,4 +46,5 @@ import type { SplineLineSegment } from './SplineLineSegment';
 import type { SplineProps } from './SplineProps';
 import type { BidirectionalData } from '../utilities/segmentation/createBidirectionalToolData';
 import type { PolySegConversionOptions } from './PolySeg';
-export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, JumpToSliceOptions, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationState, SegmentationRepresentationData, SegmentationRepresentationConfig, RepresentationConfig, RepresentationPublicInput, LabelmapTypes, SVGCursorDescriptor, SVGPoint, ScrollOptions, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, PolySegConversionOptions, };
+import type { IBaseTool } from './IBaseTool';
+export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, JumpToSliceOptions, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationState, RepresentationData, RepresentationsData, RepresentationConfig, RepresentationPublicInput, LabelmapTypes, SVGCursorDescriptor, SVGPoint, ScrollOptions, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, PolySegConversionOptions, IBaseTool, GlobalConfig, };

package/dist/esm/utilities/contourSegmentation/addContourSegmentationAnnotation.js

@@ -8,10 +8,10 @@ export function addContourSegmentationAnnotation(annotation) {
     }
     const { segmentationId, segmentIndex } = annotation.data.segmentation;
     const segmentation = getSegmentation(segmentationId);
-    if (!segmentation.representationData.CONTOUR) {
-        segmentation.representationData.CONTOUR = { annotationUIDsMap: new Map() };
+    if (!segmentation.representationData.Contour) {
+        segmentation.representationData.Contour = { annotationUIDsMap: new Map() };
     }
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+    const { annotationUIDsMap } = segmentation.representationData.Contour;
     let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
     if (!annotationsUIDsSet) {
         annotationsUIDsSet = new Set();

package/dist/esm/utilities/contourSegmentation/removeContourSegmentationAnnotation.js

@@ -5,7 +5,7 @@ export function removeContourSegmentationAnnotation(annotation) {
     }
     const { segmentationId, segmentIndex } = annotation.data.segmentation;
     const segmentation = getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation?.representationData.CONTOUR || {};
+    const { annotationUIDsMap } = segmentation?.representationData.Contour || {};
     const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
     if (!annotationsUIDsSet) {
         return;

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.js

@@ -15,13 +15,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         return;
     }
     const numSlices = vol.dimensions[2];
-    const segData = vol.imageData.getPointData().getScalars().getData();
+    const voxelManager = vol.voxelManager;
     const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
     for (let z = 0; z < numSlices; z++) {
         for (let y = 0; y < vol.dimensions[1]; y++) {
             const index = y * vol.dimensions[0] + z * pixelsPerSlice;
-            segData[index] = 0;
-            segData[index + vol.dimensions[0] - 1] = 0;
+            voxelManager.setAtIndex(index, 0);
+            voxelManager.setAtIndex(index + vol.dimensions[0] - 1, 0);
         }
     }
     const ContourSets = [];
@@ -41,13 +41,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         });
         const { containedSegmentIndices } = segment;
         for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
-            if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
+            if (isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex)) {
                 continue;
             }
             const frameStart = sliceIndex * pixelsPerSlice;
             try {
                 for (let i = 0; i < pixelsPerSlice; i++) {
-                    const value = segData[i + frameStart];
+                    const value = voxelManager.getAtIndex(i + frameStart);
                     if (value === segIndex || containedSegmentIndices?.has(value)) {
                         scalars.setValue(i + frameStart, 1);
                     }
@@ -96,11 +96,11 @@ function generateContourSetsFromLabelmap({ segmentations }) {
     }
     return ContourSets;
 }
-function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+function isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex) {
     const startIdx = sliceIndex * pixelsPerSlice;
     const endIdx = startIdx + pixelsPerSlice;
     for (let i = startIdx; i < endIdx; i++) {
-        if (segData[i] === segIndex) {
+        if (voxelManager.getAtIndex(i) === segIndex) {
             return false;
         }
     }

package/dist/esm/utilities/segmentation/getHoveredContourSegmentationAnnotation.js

@@ -2,7 +2,7 @@ import { getAnnotation } from '../../stateManagement';
 import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 export function getHoveredContourSegmentationAnnotation(segmentationId) {
     const segmentation = getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+    const { annotationUIDsMap } = segmentation.representationData.Contour;
     for (const [segmentIndex, annotationUIDs] of annotationUIDsMap.entries()) {
         const highlightedAnnotationUID = Array.from(annotationUIDs).find((annotationUID) => getAnnotation(annotationUID).highlighted);
         if (highlightedAnnotationUID) {

package/dist/esm/utilities/segmentation/getSegmentIndexAtLabelmapBorder.js

@@ -3,15 +3,17 @@ import { getSegmentation, getSegmentationRepresentationsForSegmentation, getCurr
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
-    const labelmapData = segmentation.representationData.LABELMAP;
-    if (isVolumeSegmentation(labelmapData)) {
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (isVolumeSegmentation(labelmapData, viewport)) {
         const { volumeId } = labelmapData;
         const segmentationVolume = cache.getVolume(volumeId);
         if (!segmentationVolume) {
             return;
         }
+        const voxelManager = segmentationVolume.voxelManager;
         const imageData = segmentationVolume.imageData;
-        const segmentIndex = imageData.getScalarValueFromWorld(worldPoint);
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        const segmentIndex = voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
         const canvasPoint = viewport.worldToCanvas(worldPoint);
         const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
         return onEdge ? segmentIndex : undefined;
@@ -69,7 +71,9 @@ function isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, s
     const getNeighborIndex = (deltaI, deltaJ) => {
         const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
         const worldPoint = viewport.canvasToWorld(neighborCanvas);
-        return imageData.getScalarValueFromWorld(worldPoint);
+        const voxelManager = imageData.get('voxelManager').voxelManager;
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        return voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
     };
     return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
 }

package/dist/esm/utilities/segmentation/getSegmentIndexAtWorldPoint.js

@@ -21,7 +21,7 @@ export function getSegmentIndexAtWorldPoint(segmentationId, worldPoint, options
     }
 }
 export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { viewport }) {
-    const labelmapData = segmentation.representationData.LABELMAP;
+    const labelmapData = segmentation.representationData.Labelmap;
     if (isVolumeSegmentation(labelmapData)) {
         const { volumeId } = labelmapData;
         const segmentationVolume = cache.getVolume(volumeId);
@@ -51,7 +51,7 @@ export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { vi
     return segmentIndex;
 }
 export function getSegmentIndexAtWorldForContour(segmentation, worldPoint, { viewport }) {
-    const contourData = segmentation.representationData.CONTOUR;
+    const contourData = segmentation.representationData.Contour;
     const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
     const { viewPlaneNormal } = viewport.getCamera();
     for (const segmentIndex of segmentIndices) {