@cornerstonejs/tools 2.0.0-beta.8 → 2.0.1

package/dist/esm/utilities/pointInSurroundingSphereCallback.d.ts

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+export declare function pointInSurroundingSphereCallback(imageData: vtkImageData, circlePoints: [Types.Point3, Types.Point3], callback: (args: {
+    value: unknown;
+    index: number;
+    pointIJK: Types.Point3;
+    pointLPS: Types.Point3;
+}) => void, viewport?: Types.IVolumeViewport): void;

package/dist/esm/utilities/pointInSurroundingSphereCallback.js

@@ -1,16 +1,24 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { pointInSphere } from './math/sphere';
-import pointInShapeCallback from './pointInShapeCallback';
 import { getBoundingBoxAroundShape } from './boundingBox';
 const { transformWorldToIndex } = csUtils;
-export default function pointInSurroundingSphereCallback(imageData, circlePoints, callback, viewport) {
+export function pointInSurroundingSphereCallback(imageData, circlePoints, callback, viewport) {
     const { boundsIJK, centerWorld, radiusWorld } = _getBounds(circlePoints, imageData, viewport);
     const sphereObj = {
         center: centerWorld,
         radius: radiusWorld,
     };
-    pointInShapeCallback(imageData, (pointLPS) => pointInSphere(sphereObj, pointLPS), callback, boundsIJK);
+    const dimensions = imageData.getDimensions();
+    const voxelManager = csUtils.VoxelManager.createScalarVolumeVoxelManager({
+        dimensions: dimensions,
+        scalarData: imageData.getPointData().getScalars().getData(),
+    });
+    voxelManager.forEach(callback, {
+        boundsIJK,
+        isInObject: (pointLPS) => pointInSphere(sphereObj, pointLPS),
+        imageData,
+    });
 }
 function _getBounds(circlePoints, imageData, viewport) {
     const [bottom, top] = circlePoints;
@@ -61,4 +69,3 @@ function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWo
     const boundsIJK = getBoundingBoxAroundShape(sphereCornersIJK, dimensions);
     return boundsIJK;
 }
-//# sourceMappingURL=pointInSurroundingSphereCallback.js.map

package/dist/esm/utilities/pointToString.d.ts

@@ -0,0 +1 @@
+export declare function pointToString(point: any, decimals?: number): string;

package/dist/esm/utilities/pointToString.js

@@ -6,4 +6,3 @@ export function pointToString(point, decimals = 5) {
         parseFloat(point[2]).toFixed(decimals) +
         ',');
 }
-//# sourceMappingURL=pointToString.js.map

package/dist/esm/utilities/polyData/utils.d.ts

@@ -0,0 +1,5 @@
+import type vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import type { Types } from '@cornerstonejs/core';
+export declare function getPoint(points: any, idx: any): Types.Point3;
+export declare function getPolyDataPointIndexes(polyData: vtkPolyData): any[];
+export declare function getPolyDataPoints(polyData: vtkPolyData): any[];

package/dist/esm/utilities/polyData/utils.js

@@ -51,4 +51,3 @@ export function getPolyDataPoints(polyData) {
     const rawPointsData = polyData.getPoints().getData();
     return contoursIndexes.map((contourIndexes) => contourIndexes.map((index) => getPoint(rawPointsData, index)));
 }
-//# sourceMappingURL=utils.js.map

package/dist/esm/utilities/rectangleROITool/getBoundsIJKFromRectangleAnnotations.d.ts

@@ -0,0 +1,5 @@
+type Options = {
+    numSlicesToProject?: number;
+};
+declare function getBoundsIJKFromRectangleAnnotations(annotations: any, referenceVolume: any, options?: Options): any;
+export default getBoundsIJKFromRectangleAnnotations;

package/dist/esm/utilities/rectangleROITool/getBoundsIJKFromRectangleAnnotations.js

@@ -42,4 +42,3 @@ function getBoundsIJKFromRectangleAnnotations(annotations, referenceVolume, opti
     return boundsIJK;
 }
 export default getBoundsIJKFromRectangleAnnotations;
-//# sourceMappingURL=getBoundsIJKFromRectangleAnnotations.js.map

package/dist/esm/utilities/rectangleROITool/index.d.ts

@@ -0,0 +1,3 @@
+import getBoundsIJKFromRectangleAnnotations from './getBoundsIJKFromRectangleAnnotations';
+import { isAxisAlignedRectangle } from './isAxisAlignedRectangle';
+export { getBoundsIJKFromRectangleAnnotations, isAxisAlignedRectangle };

package/dist/esm/utilities/rectangleROITool/index.js

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

package/dist/esm/utilities/rectangleROITool/isAxisAlignedRectangle.d.ts

@@ -0,0 +1,2 @@
+declare function isAxisAlignedRectangle(rectangleCornersIJK: any): boolean;
+export { isAxisAlignedRectangle };

package/dist/esm/utilities/rectangleROITool/isAxisAlignedRectangle.js

@@ -20,4 +20,3 @@ function calculateAnglesWithAxes(vec, axes) {
     return axes.map((axis) => (vec3.angle(vec, axis) * 180) / Math.PI);
 }
 export { isAxisAlignedRectangle };
-//# sourceMappingURL=isAxisAlignedRectangle.js.map

package/dist/esm/utilities/segmentation/InterpolationManager/InterpolationManager.d.ts

@@ -0,0 +1,11 @@
+import type { AnnotationCompletedEventType, AnnotationModifiedEventType, AnnotationRemovedEventType } from '../../../types/EventTypes';
+import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector';
+import type { AcceptInterpolationSelector } from '../../../types/InterpolationTypes';
+export default class InterpolationManager {
+    static toolNames: any[];
+    static addTool(toolName: string): void;
+    static acceptAutoGenerated(annotationGroupSelector: AnnotationGroupSelector, selector?: AcceptInterpolationSelector): void;
+    static handleAnnotationCompleted: (evt: AnnotationCompletedEventType) => void;
+    static handleAnnotationUpdate: (evt: AnnotationModifiedEventType) => void;
+    static handleAnnotationDelete: (evt: AnnotationRemovedEventType) => void;
+}

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

@@ -175,4 +175,3 @@ function getSliceData(viewport) {
     };
     return sliceData;
 }
-//# sourceMappingURL=InterpolationManager.js.map

package/dist/esm/utilities/segmentation/InterpolationManager/deleteRelatedAnnotations.d.ts

@@ -0,0 +1,2 @@
+import type { InterpolationViewportData } from '../../../types/InterpolationTypes';
+export default function deleteRelatedAnnotations(viewportData: InterpolationViewportData): void;

package/dist/esm/utilities/segmentation/InterpolationManager/deleteRelatedAnnotations.js

@@ -64,4 +64,3 @@ export default function deleteRelatedAnnotations(viewportData) {
         interpolate(viewportNewData);
     }
 }
-//# sourceMappingURL=deleteRelatedAnnotations.js.map

package/dist/esm/utilities/segmentation/brushSizeForToolGroup.d.ts

@@ -0,0 +1,2 @@
+export declare function setBrushSizeForToolGroup(toolGroupId: string, brushSize: number, toolName?: string): void;
+export declare function getBrushSizeForToolGroup(toolGroupId: string, toolName?: string): void;

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
@@ -20,7 +20,7 @@ export function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
     const { renderingEngineId } = viewportsInfoArray[0];
     const viewportIds = toolGroup.getViewportIds();
     const renderingEngine = getRenderingEngine(renderingEngineId);
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
+    triggerAnnotationRenderForViewportIds(viewportIds);
 }
 export function getBrushSizeForToolGroup(toolGroupId, toolName) {
     const toolGroup = getToolGroup(toolGroupId);
@@ -38,4 +38,3 @@ export function getBrushSizeForToolGroup(toolGroupId, toolName) {
     }
     return brushToolInstance.configuration.brushSize;
 }
-//# sourceMappingURL=brushSizeForToolGroup.js.map

package/dist/esm/utilities/segmentation/brushThresholdForToolGroup.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function setBrushThresholdForToolGroup(toolGroupId: string, threshold: Types.Point2, otherArgs?: Record<string, unknown>): void;
+export declare function getBrushThresholdForToolGroup(toolGroupId: string): any;

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs = { isDynamic: false }) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
@@ -25,7 +25,7 @@ export function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs
     const { renderingEngineId } = viewportsInfo[0];
     const viewportIds = toolGroup.getViewportIds();
     const renderingEngine = getRenderingEngine(renderingEngineId);
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
+    triggerAnnotationRenderForViewportIds(viewportIds);
 }
 export function getBrushThresholdForToolGroup(toolGroupId) {
     const toolGroup = getToolGroup(toolGroupId);
@@ -44,4 +44,3 @@ export function getBrushThresholdForToolGroup(toolGroupId) {
     return brushToolInstance.configuration.strategySpecificConfiguration.THRESHOLD
         .threshold;
 }
-//# sourceMappingURL=brushThresholdForToolGroup.js.map

package/dist/esm/utilities/segmentation/contourAndFindLargestBidirectional.d.ts

@@ -0,0 +1 @@
+export default function contourAndFindLargestBidirectional(segmentation: any): any;

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

@@ -21,4 +21,3 @@ export default function contourAndFindLargestBidirectional(segmentation) {
     segments[segmentIndex].segmentIndex = segmentIndex;
     return findLargestBidirectional(contours[0], segVolumeId, segments[segmentIndex]);
 }
-//# sourceMappingURL=contourAndFindLargestBidirectional.js.map

package/dist/esm/utilities/segmentation/createBidirectionalToolData.d.ts

@@ -0,0 +1,14 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types/AnnotationTypes';
+export type BidirectionalData = {
+    majorAxis: [Types.Point3, Types.Point3];
+    minorAxis: [Types.Point3, Types.Point3];
+    maxMajor: number;
+    maxMinor: number;
+    segmentIndex: number;
+    label?: string;
+    color?: string | number[];
+    referencedImageId: string;
+    sliceIndex: number;
+};
+export default function createBidirectionalToolData(bidirectionalData: BidirectionalData, viewport: any): Annotation;

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

@@ -33,4 +33,3 @@ export default function createBidirectionalToolData(bidirectionalData, viewport)
     };
     return bidirectionalToolData;
 }
-//# sourceMappingURL=createBidirectionalToolData.js.map

package/dist/esm/utilities/segmentation/createLabelmapVolumeForViewport.d.ts

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+export default function createLabelmapVolumeForViewport(input: {
+    viewportId: string;
+    renderingEngineId: string;
+    segmentationId?: string;
+    options?: Types.LocalVolumeOptions & {
+        volumeId?: string;
+    };
+}): Promise<string>;

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

@@ -16,14 +16,13 @@ export default async function createLabelmapVolumeForViewport(input) {
     }
     if (options) {
         const properties = structuredClone(options);
-        await volumeLoader.createLocalVolume(properties, segmentationId);
+        await volumeLoader.createLocalVolume(segmentationId, properties);
     }
     else {
-        const { uid: volumeId } = viewport.getDefaultActor();
-        await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId, {
+        const volumeId = viewport.getVolumeId();
+        await volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
             volumeId: segmentationId,
         });
     }
     return segmentationId;
 }
-//# sourceMappingURL=createLabelmapVolumeForViewport.js.map

package/dist/esm/utilities/segmentation/createMergedLabelmapForIndex.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function createMergedLabelmapForIndex(labelmaps: Array<Types.IImageVolume>, segmentIndex?: number, volumeId?: string): Types.IImageVolume;
+export default createMergedLabelmapForIndex;

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

@@ -9,12 +9,13 @@ function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'm
         }
     });
     const labelmap = labelmaps[0];
-    const arrayType = labelmap.getScalarData().constructor;
-    const outputData = new arrayType(labelmap.getScalarData().length);
+    const arrayType = labelmap.voxelManager.getConstructor();
+    const outputData = new arrayType(labelmap.voxelManager.getScalarDataLength());
     labelmaps.forEach((labelmap) => {
-        const scalarData = labelmap.getScalarData();
-        for (let i = 0; i < scalarData.length; i++) {
-            if (scalarData[i] === segmentIndex) {
+        const voxelManager = labelmap.voxelManager;
+        const scalarDataLength = voxelManager.getScalarDataLength();
+        for (let i = 0; i < scalarDataLength; i++) {
+            if (voxelManager.getAtIndex(i) === segmentIndex) {
                 outputData[i] = segmentIndex;
             }
         }
@@ -27,9 +28,7 @@ function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'm
         direction: labelmap.direction,
         dimensions: labelmap.dimensions,
     };
-    const preventCache = true;
-    const mergedVolume = volumeLoader.createLocalVolume(options, volumeId, preventCache);
+    const mergedVolume = volumeLoader.createLocalVolume(volumeId, options);
     return mergedVolume;
 }
 export default createMergedLabelmapForIndex;
-//# sourceMappingURL=createMergedLabelmapForIndex.js.map

package/dist/esm/utilities/segmentation/findLargestBidirectional.d.ts

@@ -0,0 +1 @@
+export default function findLargestBidirectional(contours: any, segVolumeId: string, segment: any): any;

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

@@ -93,4 +93,3 @@ function createBidirectionalForSlice(sliceContour, isInSegment, currentMax = { m
     };
     return bidirectional;
 }
-//# sourceMappingURL=findLargestBidirectional.js.map

package/dist/esm/utilities/segmentation/floodFill.d.ts

@@ -0,0 +1,4 @@
+import type { FloodFillResult, FloodFillGetter, FloodFillOptions } from '../../types';
+import type { Types } from '@cornerstonejs/core';
+declare function floodFill(getter: FloodFillGetter, seed: Types.Point2 | Types.Point3, options?: FloodFillOptions): FloodFillResult;
+export default floodFill;

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

@@ -120,4 +120,3 @@ function lpad(string, character, length) {
     return (pad + string).slice(-length);
 }
 export default floodFill;
-//# sourceMappingURL=floodFill.js.map

package/dist/esm/utilities/segmentation/getBrushToolInstances.d.ts

@@ -0,0 +1 @@
+export declare function getBrushToolInstances(toolGroupId: string, toolName?: string): any[];

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

@@ -0,0 +1,17 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import BrushTool from '../../tools/segmentation/BrushTool';
+export function getBrushToolInstances(toolGroupId, toolName) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const toolInstances = toolGroup._toolInstances;
+    if (!Object.keys(toolInstances).length) {
+        return;
+    }
+    if (toolName && toolInstances[toolName]) {
+        return [toolInstances[toolName]];
+    }
+    const brushBasedToolInstances = Object.values(toolInstances).filter((toolInstance) => toolInstance instanceof BrushTool);
+    return brushBasedToolInstances;
+}

package/dist/esm/utilities/segmentation/getHoveredContourSegmentationAnnotation.d.ts

@@ -0,0 +1 @@
+export declare function getHoveredContourSegmentationAnnotation(segmentationId: any): number;

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) {
@@ -11,4 +11,3 @@ export function getHoveredContourSegmentationAnnotation(segmentationId) {
     }
     return undefined;
 }
-//# sourceMappingURL=getHoveredContourSegmentationAnnotation.js.map

package/dist/esm/utilities/segmentation/getSegmentIndexAtLabelmapBorder.d.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+type Options = {
+    viewport?: Types.IViewport;
+    searchRadius?: number;
+};
+export declare function getSegmentIndexAtLabelmapBorder(segmentationId: string, worldPoint: Types.Point3, { viewport, searchRadius }: Options): number;
+export {};

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

@@ -0,0 +1,76 @@
+import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
+import { getSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers';
+export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
+    const segmentation = getSegmentation(segmentationId);
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (viewport instanceof BaseVolumeViewport) {
+        const { volumeId } = labelmapData;
+        const segmentationVolume = cache.getVolume(volumeId);
+        if (!segmentationVolume) {
+            return;
+        }
+        const voxelManager = segmentationVolume.voxelManager;
+        const imageData = segmentationVolume.imageData;
+        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;
+    }
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+    const image = cache.getImage(segmentationImageId);
+    if (!image) {
+        return;
+    }
+    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
+    const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+    const dimensions = imageData.getDimensions();
+    const voxelManager = (imageData.voxelManager ||
+        utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData: imageData.getPointData().getScalars().getData(),
+        }));
+    const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
+    const onEdge = isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex);
+    return onEdge ? segmentIndex : undefined;
+}
+function isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius = 1) {
+    const neighborRange = Array.from({ length: 2 * searchRadius + 1 }, (_, i) => i - searchRadius);
+    for (const deltaI of neighborRange) {
+        for (const deltaJ of neighborRange) {
+            for (const deltaK of neighborRange) {
+                if (deltaI === 0 && deltaJ === 0 && deltaK === 0) {
+                    continue;
+                }
+                const neighborIndex = getNeighborIndex(deltaI, deltaJ, deltaK);
+                if (neighborIndex !== undefined && segmentIndex !== neighborIndex) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex, searchRadius) {
+    const getNeighborIndex = (deltaI, deltaJ, deltaK) => {
+        const neighborIJK = [
+            indexIJK[0] + deltaI,
+            indexIJK[1] + deltaJ,
+            indexIJK[2] + deltaK,
+        ];
+        return voxelManager.getAtIJK(neighborIJK[0], neighborIJK[1], neighborIJK[2]);
+    };
+    return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}
+function isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius) {
+    const getNeighborIndex = (deltaI, deltaJ) => {
+        const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
+        const worldPoint = viewport.canvasToWorld(neighborCanvas);
+        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.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import type { Segmentation } from '../../types';
+type Options = {
+    representationType?: SegmentationRepresentations;
+    viewport?: Types.IViewport;
+};
+export declare function getSegmentIndexAtWorldPoint(segmentationId: string, worldPoint: Types.Point3, options?: Options): number;
+export declare function getSegmentIndexAtWorldForLabelmap(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number | undefined;
+export declare function getSegmentIndexAtWorldForContour(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number;
+export {};

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

@@ -0,0 +1,74 @@
+import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getAnnotation } from '../../stateManagement';
+import { isPointInsidePolyline3D } from '../math/polyline';
+import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+export function getSegmentIndexAtWorldPoint(segmentationId, worldPoint, options = {}) {
+    const segmentation = getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    const desiredRepresentation = options?.representationType ?? Object.keys(representationData)[0];
+    if (!desiredRepresentation) {
+        throw new Error(`Segmentation ${segmentationId} does not have any representations`);
+    }
+    switch (desiredRepresentation) {
+        case SegmentationRepresentations.Labelmap:
+            return getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, options);
+        case SegmentationRepresentations.Contour:
+            return getSegmentIndexAtWorldForContour(segmentation, worldPoint, options);
+        default:
+            return;
+    }
+}
+export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { viewport }) {
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (viewport instanceof BaseVolumeViewport) {
+        const { volumeId } = labelmapData;
+        const segmentationVolume = cache.getVolume(volumeId);
+        if (!segmentationVolume) {
+            return;
+        }
+        const segmentIndex = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+        return segmentIndex;
+    }
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentation.segmentationId);
+    const image = cache.getImage(segmentationImageId);
+    if (!image) {
+        return;
+    }
+    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentation.segmentationId);
+    const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
+    const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+    const dimensions = imageData.getDimensions();
+    const voxelManager = (imageData.voxelManager ||
+        utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData: imageData.getPointData().getScalars().getData(),
+        }));
+    const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
+    return segmentIndex;
+}
+export function getSegmentIndexAtWorldForContour(segmentation, worldPoint, { viewport }) {
+    const contourData = segmentation.representationData.Contour;
+    const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
+    const { viewPlaneNormal } = viewport.getCamera();
+    for (const segmentIndex of segmentIndices) {
+        const annotationsSet = contourData.annotationUIDsMap.get(segmentIndex);
+        if (!annotationsSet) {
+            continue;
+        }
+        for (const annotationUID of annotationsSet) {
+            const annotation = getAnnotation(annotationUID);
+            if (!annotation) {
+                continue;
+            }
+            const { polyline } = annotation.data.contour;
+            if (!utilities.isEqual(viewPlaneNormal, annotation.metadata.viewPlaneNormal)) {
+                continue;
+            }
+            if (isPointInsidePolyline3D(worldPoint, polyline)) {
+                return Number(segmentIndex);
+            }
+        }
+    }
+}

package/dist/esm/utilities/segmentation/getUniqueSegmentIndices.d.ts

@@ -0,0 +1,2 @@
+declare function getUniqueSegmentIndices(segmentationId: any): any;
+export { getUniqueSegmentIndices };