@cornerstonejs/tools 3.0.2 → 3.0.3

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/createLabelmapMemo.d.ts

@@ -0,0 +1,44 @@
+import { utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import type { InitializedOperationData } from '../../tools/segmentation/strategies/BrushStrategy';
+export type LabelmapMemo = Types.Memo & {
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    voxelManager: Types.IVoxelManager<number>;
+    redoVoxelManager?: Types.IVoxelManager<number>;
+    undoVoxelManager?: Types.IVoxelManager<number>;
+    memo?: LabelmapMemo;
+};
+export declare function createLabelmapMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>, preview?: InitializedOperationData): {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    voxelManager: Types.IVoxelManager<number>;
+    memo: LabelmapMemo;
+    preview: InitializedOperationData;
+} | {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<T>;
+    voxelManager: utilities.VoxelManager<T>;
+};
+export declare function restoreMemo(isUndo?: boolean): void;
+export declare function createRleMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>): {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<T>;
+    voxelManager: utilities.VoxelManager<T>;
+};
+export declare function createPreviewMemo(segmentationId: string, preview: InitializedOperationData): {
+    segmentationId: string;
+    restoreMemo: typeof restoreMemo;
+    commitMemo: typeof commitMemo;
+    segmentationVoxelManager: Types.IVoxelManager<number>;
+    voxelManager: Types.IVoxelManager<number>;
+    memo: LabelmapMemo;
+    preview: InitializedOperationData;
+};
+declare function commitMemo(): boolean;
+export {};

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

@@ -0,0 +1,68 @@
+import { utilities } from '@cornerstonejs/core';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+const { VoxelManager, RLEVoxelMap } = utilities;
+export function createLabelmapMemo(segmentationId, segmentationVoxelManager, preview) {
+    return preview
+        ? createPreviewMemo(segmentationId, preview)
+        : createRleMemo(segmentationId, segmentationVoxelManager);
+}
+export function restoreMemo(isUndo) {
+    const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
+    const useVoxelManager = isUndo === false ? redoVoxelManager : undoVoxelManager;
+    useVoxelManager.forEach(({ value, pointIJK }) => {
+        segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
+    });
+    const slices = useVoxelManager.getArrayOfModifiedSlices();
+    triggerSegmentationDataModified(this.segmentationId, slices);
+}
+export function createRleMemo(segmentationId, segmentationVoxelManager) {
+    const voxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+    const state = {
+        segmentationId,
+        restoreMemo,
+        commitMemo,
+        segmentationVoxelManager,
+        voxelManager,
+    };
+    return state;
+}
+export function createPreviewMemo(segmentationId, preview) {
+    const { memo: previewMemo, segmentationVoxelManager, previewVoxelManager, } = preview;
+    const state = {
+        segmentationId,
+        restoreMemo,
+        commitMemo,
+        segmentationVoxelManager,
+        voxelManager: previewVoxelManager,
+        memo: previewMemo,
+        preview,
+    };
+    return state;
+}
+function commitMemo() {
+    if (this.redoVoxelManager) {
+        return true;
+    }
+    if (!this.voxelManager.modifiedSlices.size) {
+        return false;
+    }
+    const { segmentationVoxelManager } = this;
+    const undoVoxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+    RLEVoxelMap.copyMap(undoVoxelManager.map, this.voxelManager.map);
+    for (const key of this.voxelManager.modifiedSlices.keys()) {
+        undoVoxelManager.modifiedSlices.add(key);
+    }
+    this.undoVoxelManager = undoVoxelManager;
+    const redoVoxelManager = VoxelManager.createRLEVolumeVoxelManager({
+        dimensions: this.segmentationVoxelManager.dimensions,
+    });
+    this.redoVoxelManager = redoVoxelManager;
+    undoVoxelManager.forEach(({ index, pointIJK, value }) => {
+        const currentValue = segmentationVoxelManager.getAtIJKPoint(pointIJK);
+        if (currentValue === value) {
+            return;
+        }
+        redoVoxelManager.setAtIndex(index, currentValue);
+    });
+    return true;
+}

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

@@ -0,0 +1,28 @@
+import { getEnabledElementByIds, volumeLoader, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
+export default async function createLabelmapVolumeForViewport(input) {
+    const { viewportId, renderingEngineId, options } = input;
+    let { segmentationId } = input;
+    const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+    if (!enabledElement) {
+        throw new Error('element disabled');
+    }
+    const { viewport } = enabledElement;
+    if (!(viewport instanceof VolumeViewport)) {
+        throw new Error('Segmentation only supports VolumeViewport');
+    }
+    const { uid } = viewport.getDefaultActor();
+    if (segmentationId === undefined) {
+        segmentationId = `${uid}-based-segmentation-${options?.volumeId ?? csUtils.uuidv4().slice(0, 8)}`;
+    }
+    if (options) {
+        const properties = structuredClone(options);
+        await volumeLoader.createLocalVolume(segmentationId, properties);
+    }
+    else {
+        const volumeId = viewport.getVolumeId();
+        volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
+            volumeId: segmentationId,
+        });
+    }
+    return segmentationId;
+}

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

@@ -0,0 +1,34 @@
+import { volumeLoader, utilities as csUtils } from '@cornerstonejs/core';
+function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'mergedLabelmap') {
+    labelmaps.forEach(({ direction, dimensions, origin, spacing }) => {
+        if (!csUtils.isEqual(dimensions, labelmaps[0].dimensions) ||
+            !csUtils.isEqual(direction, labelmaps[0].direction) ||
+            !csUtils.isEqual(spacing, labelmaps[0].spacing) ||
+            !csUtils.isEqual(origin, labelmaps[0].origin)) {
+            throw new Error('labelmaps must have the same size and shape');
+        }
+    });
+    const labelmap = labelmaps[0];
+    const arrayType = labelmap.voxelManager.getConstructor();
+    const outputData = new arrayType(labelmap.voxelManager.getScalarDataLength());
+    labelmaps.forEach((labelmap) => {
+        const voxelManager = labelmap.voxelManager;
+        const scalarDataLength = voxelManager.getScalarDataLength();
+        for (let i = 0; i < scalarDataLength; i++) {
+            if (voxelManager.getAtIndex(i) === segmentIndex) {
+                outputData[i] = segmentIndex;
+            }
+        }
+    });
+    const options = {
+        scalarData: outputData,
+        metadata: labelmap.metadata,
+        spacing: labelmap.spacing,
+        origin: labelmap.origin,
+        direction: labelmap.direction,
+        dimensions: labelmap.dimensions,
+    };
+    const mergedVolume = volumeLoader.createLocalVolume(volumeId, options);
+    return mergedVolume;
+}
+export default createMergedLabelmapForIndex;

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

@@ -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

@@ -0,0 +1,120 @@
+function floodFill(getter, seed, options = {}) {
+    const onFlood = options.onFlood;
+    const onBoundary = options.onBoundary;
+    const equals = options.equals;
+    const filter = options.filter;
+    const diagonals = options.diagonals || false;
+    const startNode = get(seed);
+    const permutations = prunedPermutations();
+    const stack = [];
+    const flooded = [];
+    const visits = new Set();
+    const bounds = options.bounds;
+    stack.push({ currentArgs: seed });
+    while (stack.length > 0) {
+        flood(stack.pop());
+    }
+    return {
+        flooded,
+    };
+    function flood(job) {
+        const getArgs = job.currentArgs;
+        const prevArgs = job.previousArgs;
+        if (visited(getArgs)) {
+            return;
+        }
+        markAsVisited(getArgs);
+        if (member(getArgs)) {
+            markAsFlooded(getArgs);
+            pushAdjacent(getArgs);
+        }
+        else {
+            markAsBoundary(prevArgs);
+        }
+    }
+    function visited(key) {
+        const [x, y, z = 0] = key;
+        const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+        return visits.has(iKey);
+    }
+    function markAsVisited(key) {
+        const [x, y, z = 0] = key;
+        const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
+        visits.add(iKey);
+    }
+    function member(getArgs) {
+        const node = get(getArgs);
+        return equals ? equals(node, startNode) : node === startNode;
+    }
+    function markAsFlooded(getArgs) {
+        flooded.push(getArgs);
+        if (onFlood) {
+            onFlood(...getArgs);
+        }
+    }
+    function markAsBoundary(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);
+        }
+    }
+    function pushAdjacent(getArgs) {
+        for (let i = 0; i < permutations.length; i += 1) {
+            const perm = permutations[i];
+            const nextArgs = getArgs.slice(0);
+            for (let j = 0; j < getArgs.length; j += 1) {
+                nextArgs[j] += perm[j];
+            }
+            if (filter?.(nextArgs) === false) {
+                continue;
+            }
+            if (visited(nextArgs)) {
+                continue;
+            }
+            stack.push({
+                currentArgs: nextArgs,
+                previousArgs: getArgs,
+            });
+        }
+    }
+    function get(getArgs) {
+        return getter(...getArgs);
+    }
+    function prunedPermutations() {
+        const permutations = permute(seed.length);
+        return permutations.filter(function (perm) {
+            const count = countNonZeroes(perm);
+            return count !== 0 && (count === 1 || diagonals);
+        });
+    }
+    function permute(length) {
+        const perms = [];
+        const permutation = function (string) {
+            return string.split('').map(function (c) {
+                return parseInt(c, 10) - 1;
+            });
+        };
+        for (let i = 0; i < Math.pow(3, length); i += 1) {
+            const string = lpad(i.toString(3), '0', length);
+            perms.push(permutation(string));
+        }
+        return perms;
+    }
+}
+function countNonZeroes(array) {
+    let count = 0;
+    for (let i = 0; i < array.length; i += 1) {
+        if (array[i] !== 0) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function lpad(string, character, length) {
+    const array = new Array(length + 1);
+    const pad = array.join(character);
+    return (pad + string).slice(-length);
+}
+export default floodFill;

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

@@ -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/getOrCreateSegmentationVolume.d.ts

@@ -0,0 +1,2 @@
+declare function getOrCreateSegmentationVolume(segmentationId: any): any;
+export default getOrCreateSegmentationVolume;

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

@@ -0,0 +1,21 @@
+import { cache, volumeLoader } from '@cornerstonejs/core';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+function getOrCreateSegmentationVolume(segmentationId) {
+    const { representationData } = getSegmentation(segmentationId);
+    let { volumeId } = representationData.Labelmap;
+    let segVolume;
+    if (volumeId) {
+        segVolume = cache.getVolume(volumeId);
+        if (segVolume) {
+            return segVolume;
+        }
+    }
+    const { imageIds: labelmapImageIds } = representationData.Labelmap;
+    volumeId = cache.generateVolumeId(labelmapImageIds);
+    if (!labelmapImageIds || labelmapImageIds.length === 1) {
+        return;
+    }
+    segVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
+    return segVolume;
+}
+export default getOrCreateSegmentationVolume;

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

@@ -0,0 +1,17 @@
+export interface SVGStyleForSegmentParams {
+    segmentationId: string;
+    segmentIndex: number;
+    viewportId: string;
+    autoGenerated?: boolean;
+}
+export declare function getSVGStyleForSegment({ segmentationId, segmentIndex, viewportId, autoGenerated, }: SVGStyleForSegmentParams): {
+    color: string;
+    fillColor: string;
+    lineWidth: number;
+    fillOpacity: number;
+    lineDash: any;
+    textbox: {
+        color: string;
+    };
+    visibility: boolean;
+};

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

@@ -0,0 +1,68 @@
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentationRepresentationVisibility } from '../../stateManagement/segmentation/getSegmentationRepresentationVisibility';
+import { internalGetHiddenSegmentIndices } from '../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
+export function getSVGStyleForSegment({ segmentationId, segmentIndex, viewportId, autoGenerated = false, }) {
+    const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
+    const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+    });
+    const activeSegmentation = getActiveSegmentation(viewportId);
+    const isActive = activeSegmentation?.segmentationId === segmentationId;
+    const style = segmentationStyle.getStyle({
+        viewportId,
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+        segmentIndex,
+    });
+    const mergedConfig = style;
+    let lineWidth = 1;
+    let lineDash = undefined;
+    let lineOpacity = 1;
+    let fillOpacity = 0;
+    if (autoGenerated) {
+        lineWidth = mergedConfig.outlineWidthAutoGenerated ?? lineWidth;
+        lineDash = mergedConfig.outlineDashAutoGenerated ?? lineDash;
+        lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+        fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
+    }
+    else if (isActive) {
+        lineWidth = mergedConfig.outlineWidth ?? lineWidth;
+        lineDash = mergedConfig.outlineDash ?? lineDash;
+        lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+        fillOpacity = mergedConfig.fillAlpha ?? fillOpacity;
+    }
+    else {
+        lineWidth = mergedConfig.outlineWidthInactive ?? lineWidth;
+        lineDash = mergedConfig.outlineDashInactive ?? lineDash;
+        lineOpacity = mergedConfig.outlineOpacityInactive ?? lineOpacity;
+        fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
+    }
+    if (getActiveSegmentIndex(segmentationId) === segmentIndex) {
+        lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
+    }
+    lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
+    fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
+    const color = `rgba(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]}, ${lineOpacity})`;
+    const fillColor = `rgb(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]})`;
+    const hiddenSegments = internalGetHiddenSegmentIndices(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+    });
+    const isVisible = !hiddenSegments.has(segmentIndex);
+    return {
+        color,
+        fillColor,
+        lineWidth,
+        fillOpacity,
+        lineDash,
+        textbox: {
+            color,
+        },
+        visibility: segmentationVisible && isVisible,
+    };
+}

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 {};