@cornerstonejs/tools 2.0.0-beta.2 → 2.0.0-beta.21

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

@@ -0,0 +1,23 @@
+import { generateContourSetsFromLabelmap } from '../contours';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import findLargestBidirectional from './findLargestBidirectional';
+const { Labelmap } = SegmentationRepresentations;
+export default function contourAndFindLargestBidirectional(segmentation) {
+    const contours = generateContourSetsFromLabelmap({
+        segmentations: segmentation,
+    });
+    if (!contours?.length || !contours[0].sliceContours.length) {
+        return;
+    }
+    const { representationData, segments = [
+        null,
+        { label: 'Unspecified', color: null, containedSegmentIndices: null },
+    ], } = segmentation;
+    const { volumeId: segVolumeId } = representationData[Labelmap];
+    const segmentIndex = segments.findIndex((it) => !!it);
+    if (segmentIndex === -1) {
+        return;
+    }
+    segments[segmentIndex].segmentIndex = segmentIndex;
+    return findLargestBidirectional(contours[0], segVolumeId, segments[segmentIndex]);
+}

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

@@ -0,0 +1,35 @@
+export default function createBidirectionalToolData(bidirectionalData, viewport) {
+    const { majorAxis, minorAxis, label = '', sliceIndex } = bidirectionalData;
+    const [major0, major1] = majorAxis;
+    const [minor0, minor1] = minorAxis;
+    const points = [major0, major1, minor0, minor1];
+    const bidirectionalToolData = {
+        highlighted: true,
+        invalidated: true,
+        metadata: {
+            toolName: 'Bidirectional',
+            ...viewport.getViewReference({ sliceIndex }),
+        },
+        data: {
+            handles: {
+                points,
+                textBox: {
+                    hasMoved: false,
+                    worldPosition: [0, 0, 0],
+                    worldBoundingBox: {
+                        topLeft: [0, 0, 0],
+                        topRight: [0, 0, 0],
+                        bottomLeft: [0, 0, 0],
+                        bottomRight: [0, 0, 0],
+                    },
+                },
+                activeHandleIndex: null,
+            },
+            label,
+            cachedStats: {},
+        },
+        isLocked: false,
+        isVisible: true,
+    };
+    return bidirectionalToolData;
+}

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

@@ -3,16 +3,7 @@ export default function createLabelmapVolumeForViewport(input: {
     viewportId: string;
     renderingEngineId: string;
     segmentationId?: string;
-    options?: {
+    options?: Types.LocalVolumeOptions & {
         volumeId?: string;
-        scalarData?: Float32Array | Uint8Array | Uint16Array | Int16Array;
-        targetBuffer?: {
-            type: 'Float32Array' | 'Uint8Array' | 'Uint16Array' | 'Int8Array';
-        };
-        metadata?: any;
-        dimensions?: Types.Point3;
-        spacing?: Types.Point3;
-        origin?: Types.Point3;
-        direction?: Float32Array;
     };
 }): Promise<string>;

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

@@ -1,4 +1,3 @@
-import { _cloneDeep } from 'lodash.clonedeep';
 import { getEnabledElementByIds, volumeLoader, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
 export default async function createLabelmapVolumeForViewport(input) {
     const { viewportId, renderingEngineId, options } = input;
@@ -16,15 +15,14 @@ export default async function createLabelmapVolumeForViewport(input) {
         segmentationId = `${uid}-based-segmentation-${options?.volumeId ?? csUtils.uuidv4().slice(0, 8)}`;
     }
     if (options) {
-        const properties = _cloneDeep(options);
-        await volumeLoader.createLocalVolume(properties, segmentationId);
+        const properties = structuredClone(options);
+        await volumeLoader.createLocalVolume(segmentationId, properties);
     }
     else {
         const { uid: volumeId } = viewport.getDefaultActor();
-        await volumeLoader.createAndCacheDerivedVolume(volumeId, {
+        await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId, {
             volumeId: segmentationId,
         });
     }
     return segmentationId;
 }
-//# sourceMappingURL=createLabelmapVolumeForViewport.js.map

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

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
+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

@@ -0,0 +1,95 @@
+import { vec3 } from 'gl-matrix';
+import { createIsInSegment, isLineInSegment } from './isLineInSegment';
+const EPSILON = 1e-2;
+export default function findLargestBidirectional(contours, segVolumeId, segment) {
+    const { sliceContours } = contours;
+    const { segmentIndex, containedSegmentIndices } = segment;
+    let maxBidirectional;
+    const isInSegment = createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices);
+    for (const sliceContour of sliceContours) {
+        const bidirectional = createBidirectionalForSlice(sliceContour, isInSegment, maxBidirectional);
+        if (!bidirectional) {
+            continue;
+        }
+        maxBidirectional = bidirectional;
+    }
+    if (maxBidirectional) {
+        Object.assign(maxBidirectional, segment);
+    }
+    return maxBidirectional;
+}
+function createBidirectionalForSlice(sliceContour, isInSegment, currentMax = { maxMajor: 0, maxMinor: 0 }) {
+    const { points } = sliceContour.polyData;
+    const { maxMinor: currentMaxMinor, maxMajor: currentMaxMajor } = currentMax;
+    let maxMajor = currentMaxMajor * currentMaxMajor;
+    let maxMinor = currentMaxMinor * currentMaxMinor;
+    let maxMajorPoints;
+    for (let index1 = 0; index1 < points.length; index1++) {
+        for (let index2 = index1 + 1; index2 < points.length; index2++) {
+            const point1 = points[index1];
+            const point2 = points[index2];
+            const distance2 = vec3.sqrDist(point1, point2);
+            if (distance2 < maxMajor) {
+                continue;
+            }
+            if (distance2 - EPSILON < maxMajor + EPSILON && maxMajorPoints) {
+                continue;
+            }
+            if (!isInSegment.testCenter(point1, point2)) {
+                continue;
+            }
+            if (!isLineInSegment(point1, point2, isInSegment)) {
+                continue;
+            }
+            maxMajor = distance2 - EPSILON;
+            maxMajorPoints = [index1, index2];
+            maxMinor = 0;
+        }
+    }
+    if (!maxMajorPoints) {
+        return;
+    }
+    maxMajor = Math.sqrt(maxMajor + EPSILON);
+    const handle0 = points[maxMajorPoints[0]];
+    const handle1 = points[maxMajorPoints[1]];
+    const unitMajor = vec3.sub(vec3.create(), handle0, handle1);
+    vec3.scale(unitMajor, unitMajor, 1 / maxMajor);
+    let maxMinorPoints;
+    for (let index1 = 0; index1 < points.length; index1++) {
+        for (let index2 = index1 + 1; index2 < points.length; index2++) {
+            const point1 = points[index1];
+            const point2 = points[index2];
+            const distance2 = vec3.sqrDist(point1, point2);
+            if (distance2 <= maxMinor) {
+                continue;
+            }
+            const delta = vec3.sub(vec3.create(), point1, point2);
+            const dot = Math.abs(vec3.dot(delta, unitMajor)) / Math.sqrt(distance2);
+            if (dot > EPSILON) {
+                continue;
+            }
+            if (!isInSegment.testCenter(point1, point2)) {
+                continue;
+            }
+            if (!isLineInSegment(point1, point2, isInSegment)) {
+                continue;
+            }
+            maxMinor = distance2;
+            maxMinorPoints = [index1, index2];
+        }
+    }
+    if (!maxMinorPoints) {
+        return;
+    }
+    maxMinor = Math.sqrt(maxMinor);
+    const handle2 = points[maxMinorPoints[0]];
+    const handle3 = points[maxMinorPoints[1]];
+    const bidirectional = {
+        majorAxis: [handle0, handle1],
+        minorAxis: [handle2, handle3],
+        maxMajor,
+        maxMinor,
+        ...sliceContour,
+    };
+    return bidirectional;
+}

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

@@ -1,4 +1,4 @@
 import type { FloodFillResult, FloodFillGetter, FloodFillOptions } from '../../types';
-import { Types } from '@cornerstonejs/core';
+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

@@ -1,14 +1,14 @@
 function floodFill(getter, seed, options = {}) {
     const onFlood = options.onFlood;
     const onBoundary = options.onBoundary;
-    const equals = options.equals || defaultEquals;
+    const equals = options.equals;
     const diagonals = options.diagonals || false;
     const startNode = get(seed);
     const permutations = prunedPermutations();
     const stack = [];
     const flooded = [];
-    const visits = {};
-    const bounds = {};
+    const visits = new Set();
+    const bounds = new Map();
     stack.push({ currentArgs: seed });
     while (stack.length > 0) {
         flood(stack.pop());
@@ -33,14 +33,18 @@ function floodFill(getter, seed, options = {}) {
         }
     }
     function visited(key) {
-        return visits[key] === true;
+        const [x, y, z = 0] = key;
+        const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+        return visits.has(iKey);
     }
     function markAsVisited(key) {
-        visits[key] = true;
+        const [x, y, z = 0] = key;
+        const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+        visits.add(iKey);
     }
     function member(getArgs) {
-        const node = safely(get, [getArgs]);
-        return safely(equals, [node, startNode]);
+        const node = get(getArgs);
+        return equals ? equals(node, startNode) : node === startNode;
     }
     function markAsFlooded(getArgs) {
         flooded.push(getArgs);
@@ -49,7 +53,9 @@ function floodFill(getter, seed, options = {}) {
         }
     }
     function markAsBoundary(prevArgs) {
-        bounds[prevArgs] = prevArgs;
+        const [x, y, z = 0] = prevArgs;
+        const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+        bounds.set(iKey, prevArgs);
         if (onBoundary) {
             onBoundary(...prevArgs);
         }
@@ -70,14 +76,6 @@ function floodFill(getter, seed, options = {}) {
     function get(getArgs) {
         return getter(...getArgs);
     }
-    function safely(f, args) {
-        try {
-            return f(...args);
-        }
-        catch (error) {
-            return;
-        }
-    }
     function prunedPermutations() {
         const permutations = permute(seed.length);
         return permutations.filter(function (perm) {
@@ -99,12 +97,8 @@ function floodFill(getter, seed, options = {}) {
         return perms;
     }
     function boundaries() {
-        const array = [];
-        for (const key in bounds) {
-            if (bounds[key] !== undefined) {
-                array.unshift(bounds[key]);
-            }
-        }
+        const array = Array.from(bounds.values());
+        array.reverse();
         return array;
     }
 }
@@ -126,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/getDefaultRepresentationConfig.d.ts

@@ -1,2 +1,2 @@
-import { Segmentation } from '../../types/SegmentationStateTypes';
+import type { Segmentation } from '../../types/SegmentationStateTypes';
 export default function getDefaultRepresentationConfig(segmentation: Segmentation): import("../../types/LabelmapTypes").LabelmapConfig;

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

@@ -9,4 +9,3 @@ export default function getDefaultRepresentationConfig(segmentation) {
             throw new Error(`Unknown representation type: ${representationType}`);
     }
 }
-//# sourceMappingURL=getDefaultRepresentationConfig.js.map

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

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

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,75 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import { getSegmentation, getSegmentationRepresentationsForSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+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 { volumeId } = labelmapData;
+        const segmentationVolume = cache.getVolume(volumeId);
+        if (!segmentationVolume) {
+            return;
+        }
+        const imageData = segmentationVolume.imageData;
+        const segmentIndex = imageData.getScalarValueFromWorld(worldPoint);
+        const canvasPoint = viewport.worldToCanvas(worldPoint);
+        const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
+        return onEdge ? segmentIndex : undefined;
+    }
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+    const currentImageId = viewport.getCurrentImageId();
+    const image = cache.getImage(segmentationImageId);
+    if (!image) {
+        return;
+    }
+    const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentation.segmentationId);
+    const { segmentationRepresentationUID } = segmentationRepresentations[0];
+    const segmentationActor = viewport.getActor(segmentationRepresentationUID);
+    const imageData = segmentationActor?.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);
+        return imageData.getScalarValueFromWorld(worldPoint);
+    };
+    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,76 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentation, getSegmentationRepresentationsForSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+import { getAnnotation } from '../../stateManagement';
+import { isPointInsidePolyline3D } from '../math/polyline';
+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 (isVolumeSegmentation(labelmapData)) {
+        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 segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentation.segmentationId);
+    const { segmentationRepresentationUID } = segmentationRepresentations[0];
+    const segmentationActor = viewport.getActor(segmentationRepresentationUID);
+    const imageData = segmentationActor?.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,4 @@
+export declare const setSegmentationDirty: (segmentationId: string) => void;
+export declare const setSegmentationClean: (segmentationId: string) => void;
+declare function getUniqueSegmentIndices(segmentationId: any): any;
+export { getUniqueSegmentIndices };

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

@@ -0,0 +1,101 @@
+import { cache } from '@cornerstonejs/core';
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+import { SegmentationRepresentations } from '../../enums';
+const segmentIndicesCache = new Map();
+export const setSegmentationDirty = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached) {
+        cached.isDirty = true;
+    }
+};
+export const setSegmentationClean = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached) {
+        cached.isDirty = false;
+    }
+};
+function getCachedSegmentIndices(segmentationId) {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached && !cached.isDirty) {
+        return cached.indices;
+    }
+    return null;
+}
+function getUniqueSegmentIndices(segmentationId) {
+    const cachedResult = getCachedSegmentIndices(segmentationId);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        throw new Error(`No segmentation found for segmentationId ${segmentationId}`);
+    }
+    let indices;
+    switch (segmentation.type) {
+        case SegmentationRepresentations.Labelmap:
+            indices = handleLabelmapSegmentation(segmentation, segmentationId);
+            break;
+        case SegmentationRepresentations.Contour:
+            indices = handleContourSegmentation(segmentation);
+            break;
+        case SegmentationRepresentations.Surface:
+            indices = handleSurfaceSegmentation(segmentation);
+            break;
+        default:
+            throw new Error(`Unsupported segmentation type: ${segmentation.type}`);
+    }
+    segmentIndicesCache.set(segmentationId, { indices, isDirty: false });
+    return indices;
+}
+function handleLabelmapSegmentation(segmentation, segmentationId) {
+    const labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
+    const keySet = new Set();
+    if (isVolumeSegmentation(labelmapData)) {
+        addVolumeSegmentIndices(keySet, segmentationId);
+    }
+    else {
+        addImageSegmentIndices(keySet, labelmapData.imageIds);
+    }
+    return Array.from(keySet)
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+function addVolumeSegmentIndices(keySet, segmentationId) {
+    const volume = cache.getVolume(segmentationId);
+    volume.voxelManager.forEach(({ value }) => {
+        if (value !== 0) {
+            keySet.add(value);
+        }
+    });
+}
+function addImageSegmentIndices(keySet, imageIds) {
+    imageIds.forEach((segmentationImageId) => {
+        const image = cache.getImage(segmentationImageId);
+        const scalarData = image.voxelManager.getScalarData();
+        scalarData.forEach((segmentIndex) => {
+            if (segmentIndex !== 0) {
+                keySet.add(segmentIndex);
+            }
+        });
+    });
+}
+function handleContourSegmentation(segmentation) {
+    const { annotationUIDsMap, geometryIds } = segmentation.representationData.CONTOUR || {};
+    if (!geometryIds) {
+        throw new Error(`No geometryIds found for segmentationId ${segmentation.segmentationId}`);
+    }
+    const indices = new Set([...annotationUIDsMap.keys()]);
+    geometryIds.forEach((geometryId) => {
+        const geometry = cache.getGeometry(geometryId);
+        indices.add(geometry.data.getSegmentIndex());
+    });
+    return Array.from(indices).sort((a, b) => a - b);
+}
+function handleSurfaceSegmentation(segmentation) {
+    const geometryIds = segmentation.representationData.SURFACE?.geometryIds ?? [];
+    return Array.from(geometryIds.keys())
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+export { getUniqueSegmentIndices };