@cornerstonejs/tools 3.0.2 → 3.0.4

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

@@ -0,0 +1,53 @@
+import { vec3 } from 'gl-matrix';
+export function getPoint(points, idx) {
+    const idx3 = idx * 3;
+    if (idx3 < points.length) {
+        return vec3.fromValues(points[idx3], points[idx3 + 1], points[idx3 + 2]);
+    }
+}
+export function getPolyDataPointIndexes(polyData) {
+    const linesData = polyData.getLines().getData();
+    let idx = 0;
+    const lineSegments = new Map();
+    while (idx < linesData.length) {
+        const segmentSize = linesData[idx++];
+        const segment = [];
+        for (let i = 0; i < segmentSize; i++) {
+            segment.push(linesData[idx + i]);
+        }
+        lineSegments.set(segment[0], segment);
+        idx += segmentSize;
+    }
+    const contours = [];
+    const findStartingPoint = (map) => {
+        for (const [key, value] of map.entries()) {
+            if (value !== undefined) {
+                return key;
+            }
+        }
+        return -1;
+    };
+    let startPoint = findStartingPoint(lineSegments);
+    while (startPoint !== -1) {
+        const contour = [startPoint];
+        while (lineSegments.has(startPoint)) {
+            const nextPoint = lineSegments.get(startPoint)[1];
+            if (lineSegments.has(nextPoint)) {
+                contour.push(nextPoint);
+            }
+            lineSegments.delete(startPoint);
+            startPoint = nextPoint;
+        }
+        contours.push(contour);
+        startPoint = findStartingPoint(lineSegments);
+    }
+    return contours.length ? contours : undefined;
+}
+export function getPolyDataPoints(polyData) {
+    const contoursIndexes = getPolyDataPointIndexes(polyData);
+    if (!contoursIndexes) {
+        return;
+    }
+    const rawPointsData = polyData.getPoints().getData();
+    return contoursIndexes.map((contourIndexes) => contourIndexes.map((index) => getPoint(rawPointsData, index)));
+}

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

@@ -0,0 +1,44 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { getBoundingBoxAroundShapeIJK } from '../boundingBox/getBoundingBoxAroundShape';
+import extend2DBoundingBoxInViewAxis from '../boundingBox/extend2DBoundingBoxInViewAxis';
+function getBoundsIJKFromRectangleAnnotations(annotations, referenceVolume, options = {}) {
+    const AllBoundsIJK = [];
+    annotations.forEach((annotation) => {
+        const { data } = annotation;
+        const { points } = data.handles;
+        const { imageData, dimensions } = referenceVolume;
+        let pointsToUse = points;
+        if (data.cachedStats?.projectionPoints) {
+            const { projectionPoints } = data.cachedStats;
+            pointsToUse = [].concat(...projectionPoints);
+        }
+        const rectangleCornersIJK = pointsToUse.map((world) => csUtils.transformWorldToIndex(imageData, world));
+        let boundsIJK = getBoundingBoxAroundShapeIJK(rectangleCornersIJK, dimensions);
+        if (options.numSlicesToProject && !data.cachedStats?.projectionPoints) {
+            boundsIJK = extend2DBoundingBoxInViewAxis(boundsIJK, options.numSlicesToProject);
+        }
+        AllBoundsIJK.push(boundsIJK);
+    });
+    if (AllBoundsIJK.length === 1) {
+        return AllBoundsIJK[0];
+    }
+    const boundsIJK = AllBoundsIJK.reduce((accumulator, currentValue) => {
+        return {
+            iMin: Math.min(accumulator.iMin, currentValue.iMin),
+            jMin: Math.min(accumulator.jMin, currentValue.jMin),
+            kMin: Math.min(accumulator.kMin, currentValue.kMin),
+            iMax: Math.max(accumulator.iMax, currentValue.iMax),
+            jMax: Math.max(accumulator.jMax, currentValue.jMax),
+            kMax: Math.max(accumulator.kMax, currentValue.kMax),
+        };
+    }, {
+        iMin: Infinity,
+        jMin: Infinity,
+        kMin: Infinity,
+        iMax: -Infinity,
+        jMax: -Infinity,
+        kMax: -Infinity,
+    });
+    return boundsIJK;
+}
+export default getBoundsIJKFromRectangleAnnotations;

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

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

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

@@ -0,0 +1,22 @@
+import { vec3 } from 'gl-matrix';
+import { utilities as csUtils } from '@cornerstonejs/core';
+const { isEqual } = csUtils;
+const iAxis = vec3.fromValues(1, 0, 0);
+const jAxis = vec3.fromValues(0, 1, 0);
+const kAxis = vec3.fromValues(0, 0, 1);
+const axisList = [iAxis, jAxis, kAxis];
+function isAxisAlignedRectangle(rectangleCornersIJK) {
+    const rectangleVec1 = vec3.subtract(vec3.create(), rectangleCornersIJK[0], rectangleCornersIJK[1]);
+    const rectangleVec2 = vec3.subtract(vec3.create(), rectangleCornersIJK[0], rectangleCornersIJK[2]);
+    const anglesVec1 = calculateAnglesWithAxes(rectangleVec1, axisList);
+    const anglesVec2 = calculateAnglesWithAxes(rectangleVec2, axisList);
+    const isAligned = [...anglesVec1, ...anglesVec2].every((angle) => isEqual(angle, 0) ||
+        isEqual(angle, 90) ||
+        isEqual(angle, 180) ||
+        isEqual(angle, 270));
+    return isAligned;
+}
+function calculateAnglesWithAxes(vec, axes) {
+    return axes.map((axis) => (vec3.angle(vec, axis) * 180) / Math.PI);
+}
+export { isAxisAlignedRectangle };

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

@@ -0,0 +1 @@
+export declare function registerComputeWorker(): void;

package/dist/esm/utilities/registerComputeWorker.js

@@ -0,0 +1,23 @@
+import { getWebWorkerManager } from '@cornerstonejs/core';
+let registered = false;
+export function registerComputeWorker() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    const workerFn = () => {
+        return new Worker(new URL('../workers/computeWorker.js', import.meta.url), {
+            name: 'compute',
+            type: 'module',
+        });
+    };
+    const workerManager = getWebWorkerManager();
+    const options = {
+        maxWorkerInstances: 1,
+        autoTerminateOnIdle: {
+            enabled: true,
+            idleTimeThreshold: 2000,
+        },
+    };
+    workerManager.registerWorker('compute', workerFn, options);
+}

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

@@ -0,0 +1,177 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { state as annotationState } from '../../../stateManagement/annotation';
+import getInterpolationDataCollection from '../../contours/interpolation/getInterpolationDataCollection';
+import interpolate from '../../contours/interpolation/interpolate';
+import deleteRelatedAnnotations from './deleteRelatedAnnotations';
+import ChangeTypes from '../../../enums/ChangeTypes';
+import getViewportForAnnotation from '../../getViewportForAnnotation';
+import { addContourSegmentationAnnotation } from '../../contourSegmentation/addContourSegmentationAnnotation';
+const { uuidv4 } = csUtils;
+const ChangeTypesForInterpolation = [
+    ChangeTypes.HandlesUpdated,
+    ChangeTypes.InterpolationUpdated,
+];
+export default class InterpolationManager {
+    static { this.toolNames = []; }
+    static addTool(toolName) {
+        if (!this.toolNames.includes(toolName)) {
+            this.toolNames.push(toolName);
+        }
+    }
+    static acceptAutoGenerated(annotationGroupSelector, selector = {}) {
+        const { toolNames, segmentationId, segmentIndex, sliceIndex } = selector;
+        for (const toolName of toolNames || InterpolationManager.toolNames) {
+            const annotations = annotationState.getAnnotations(toolName, annotationGroupSelector);
+            if (!annotations?.length) {
+                continue;
+            }
+            for (const annotation of annotations) {
+                const { interpolationUID, data, autoGenerated, metadata } = annotation;
+                if (interpolationUID) {
+                    annotation.interpolationCompleted = true;
+                }
+                if (!autoGenerated) {
+                    continue;
+                }
+                if (segmentIndex && segmentIndex !== data.segmentation.segmentIndex) {
+                    continue;
+                }
+                if (sliceIndex !== undefined &&
+                    metadata &&
+                    sliceIndex !== metadata.sliceIndex) {
+                    continue;
+                }
+                if (segmentationId &&
+                    segmentationId !== data.segmentation.segmentationId) {
+                    continue;
+                }
+                addContourSegmentationAnnotation(annotation);
+                annotation.autoGenerated = false;
+            }
+        }
+    }
+    static { this.handleAnnotationCompleted = (evt) => {
+        const annotation = evt.detail.annotation;
+        if (!annotation?.metadata) {
+            return;
+        }
+        const { toolName, originalToolName } = annotation.metadata;
+        if (!this.toolNames.includes(toolName) &&
+            !this.toolNames.includes(originalToolName)) {
+            return;
+        }
+        const viewport = getViewportForAnnotation(annotation);
+        if (!viewport) {
+            console.warn('Unable to find viewport for', annotation);
+            return;
+        }
+        const sliceData = getSliceData(viewport);
+        const viewportData = {
+            viewport,
+            sliceData,
+            annotation,
+            interpolationUID: annotation.interpolationUID,
+        };
+        const hasInterpolationUID = !!annotation.interpolationUID;
+        annotation.autoGenerated = false;
+        if (hasInterpolationUID) {
+            deleteRelatedAnnotations(viewportData);
+            interpolate(viewportData);
+            return;
+        }
+        const filterData = [
+            {
+                key: 'segmentIndex',
+                value: annotation.data.segmentation.segmentIndex,
+                parentKey: (annotation) => annotation.data.segmentation,
+            },
+            {
+                key: 'viewPlaneNormal',
+                value: annotation.metadata.viewPlaneNormal,
+                parentKey: (annotation) => annotation.metadata,
+            },
+            {
+                key: 'viewUp',
+                value: annotation.metadata.viewUp,
+                parentKey: (annotation) => annotation.metadata,
+            },
+        ];
+        let interpolationAnnotations = getInterpolationDataCollection(viewportData, filterData);
+        const { sliceIndex } = annotation.metadata;
+        const skipUIDs = new Set();
+        interpolationAnnotations.forEach((interpolationAnnotation) => {
+            if (interpolationAnnotation.interpolationCompleted ||
+                interpolationAnnotation.metadata.sliceIndex === sliceIndex) {
+                const { interpolationUID } = interpolationAnnotation;
+                skipUIDs.add(interpolationUID);
+            }
+        });
+        interpolationAnnotations = interpolationAnnotations.filter((interpolationAnnotation) => !skipUIDs.has(interpolationAnnotation.interpolationUID));
+        annotation.interpolationUID =
+            interpolationAnnotations[0]?.interpolationUID || uuidv4();
+        viewportData.interpolationUID = annotation.interpolationUID;
+        interpolate(viewportData);
+    }; }
+    static { this.handleAnnotationUpdate = (evt) => {
+        const annotation = evt.detail.annotation;
+        const { changeType = ChangeTypes.HandlesUpdated } = evt.detail;
+        if (!annotation?.metadata) {
+            return;
+        }
+        const { toolName, originalToolName } = annotation.metadata;
+        if ((!this.toolNames.includes(toolName) &&
+            !this.toolNames.includes(originalToolName)) ||
+            !ChangeTypesForInterpolation.includes(changeType)) {
+            return;
+        }
+        const viewport = getViewportForAnnotation(annotation);
+        if (!viewport) {
+            console.warn('Unable to find matching viewport for annotation interpolation', annotation);
+            return;
+        }
+        if (annotation.autoGenerated) {
+            addContourSegmentationAnnotation(annotation);
+            annotation.autoGenerated = false;
+        }
+        const sliceData = getSliceData(viewport);
+        const viewportData = {
+            viewport,
+            sliceData,
+            annotation,
+            interpolationUID: annotation.interpolationUID,
+            isInterpolationUpdate: changeType === ChangeTypes.InterpolationUpdated,
+        };
+        interpolate(viewportData);
+    }; }
+    static { this.handleAnnotationDelete = (evt) => {
+        const annotation = evt.detail.annotation;
+        if (!annotation?.metadata) {
+            return;
+        }
+        const { toolName } = annotation.metadata;
+        if (!this.toolNames.includes(toolName) || annotation.autoGenerated) {
+            return;
+        }
+        const viewport = getViewportForAnnotation(annotation);
+        if (!viewport) {
+            console.warn("No viewport, can't delete interpolated results", annotation);
+            return;
+        }
+        const sliceData = getSliceData(viewport);
+        const viewportData = {
+            viewport,
+            sliceData,
+            annotation,
+            interpolationUID: annotation.interpolationUID,
+        };
+        annotation.autoGenerated = false;
+        deleteRelatedAnnotations(viewportData);
+    }; }
+}
+function getSliceData(viewport) {
+    const sliceData = {
+        numberOfSlices: viewport.getNumberOfSlices(),
+        imageIndex: viewport.getCurrentImageIdIndex(),
+    };
+    return sliceData;
+}

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

@@ -0,0 +1,66 @@
+import { triggerEvent } from '@cornerstonejs/core';
+import * as annotationStateManagement from '../../../stateManagement/annotation';
+import interpolate from '../../contours/interpolation/interpolate';
+import getInterpolationData from '../../contours/interpolation/getInterpolationData';
+import EventTypes from '../../../enums/Events';
+export default function deleteRelatedAnnotations(viewportData) {
+    const { annotation } = viewportData;
+    const interpolationAnnotations = getInterpolationData(viewportData, [
+        { key: 'interpolationUID', value: viewportData.interpolationUID },
+    ]);
+    const referencedSliceIndex = annotation.metadata.sliceIndex;
+    let minInterpolation = -1;
+    let maxInterpolation = viewportData.sliceData.numberOfSlices;
+    for (const [sliceIndex, annotations] of interpolationAnnotations.entries()) {
+        if (sliceIndex === referencedSliceIndex) {
+            continue;
+        }
+        const nonInterpolated = annotations.find((annotation) => !annotation.autoGenerated);
+        if (!nonInterpolated) {
+            continue;
+        }
+        if (sliceIndex < referencedSliceIndex) {
+            minInterpolation = Math.max(sliceIndex, minInterpolation);
+        }
+        else {
+            maxInterpolation = Math.min(sliceIndex, maxInterpolation);
+        }
+    }
+    const removedAnnotations = [];
+    for (const [sliceIndex, annotations] of interpolationAnnotations.entries()) {
+        if (sliceIndex <= minInterpolation ||
+            sliceIndex >= maxInterpolation ||
+            sliceIndex === referencedSliceIndex) {
+            continue;
+        }
+        annotations.forEach((annotationToDelete) => {
+            if (annotationToDelete.autoGenerated) {
+                annotationStateManagement.state.removeAnnotation(annotationToDelete.annotationUID);
+                removedAnnotations.push(annotationToDelete);
+            }
+        });
+    }
+    if (removedAnnotations.length) {
+        const eventDetails = {
+            annotations: removedAnnotations,
+            element: viewportData.viewport.element,
+            viewportId: viewportData.viewport.id,
+            renderingEngineId: viewportData.viewport.getRenderingEngine().id,
+        };
+        triggerEvent(viewportData.viewport.element, EventTypes.INTERPOLATED_ANNOTATIONS_REMOVED, eventDetails);
+    }
+    if (minInterpolation >= 0 &&
+        maxInterpolation < viewportData.sliceData.numberOfSlices) {
+        const nextAnnotation = interpolationAnnotations.get(maxInterpolation)[0];
+        const viewportNewData = {
+            viewport: viewportData.viewport,
+            sliceData: {
+                numberOfSlices: viewportData.sliceData.numberOfSlices,
+                imageIndex: nextAnnotation.metadata.sliceIndex,
+            },
+            annotation: nextAnnotation,
+            interpolationUID: nextAnnotation.interpolationUID,
+        };
+        interpolate(viewportNewData);
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+import type { NamedStatistics } from '../../types';
+import { BasicStatsCalculator } from '../math/basic';
+export default class VolumetricCalculator extends BasicStatsCalculator {
+    private static maxIJKs;
+    static getStatistics(options: {
+        spacing?: number;
+        unit?: string;
+    }): NamedStatistics;
+    static statsCallback(data: {
+        value: number | Types.RGB;
+        pointLPS?: Types.Point3;
+        pointIJK?: Types.Point3;
+    }): void;
+}

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

@@ -0,0 +1,48 @@
+import { BasicStatsCalculator } from '../math/basic';
+const TEST_MAX_LOCATIONS = 10;
+export default class VolumetricCalculator extends BasicStatsCalculator {
+    static { this.maxIJKs = []; }
+    static getStatistics(options) {
+        const { spacing } = options;
+        const stats = BasicStatsCalculator.getStatistics();
+        const volumeUnit = spacing ? 'mm\xb3' : 'voxels\xb3';
+        const volumeScale = spacing
+            ? spacing[0] * spacing[1] * spacing[2] * 1000
+            : 1;
+        stats.volume = {
+            value: Array.isArray(stats.count.value)
+                ? stats.count.value.map((v) => v * volumeScale)
+                : stats.count.value * volumeScale,
+            unit: volumeUnit,
+            name: 'volume',
+        };
+        stats.maxIJKs = this.maxIJKs;
+        stats.array.push(stats.volume);
+        this.maxIJKs = [];
+        return stats;
+    }
+    static statsCallback(data) {
+        BasicStatsCalculator.statsCallback(data);
+        const { value } = data;
+        const { maxIJKs } = this;
+        const { length } = maxIJKs;
+        if (typeof value !== 'number' ||
+            (length >= TEST_MAX_LOCATIONS && value < maxIJKs[0].value)) {
+            return;
+        }
+        if (!length || value >= maxIJKs[length - 1].value) {
+            maxIJKs.push(data);
+        }
+        else {
+            for (let i = 0; i < length; i++) {
+                if (value <= maxIJKs[i].value) {
+                    maxIJKs.splice(i, 0, data);
+                    break;
+                }
+            }
+        }
+        if (length >= TEST_MAX_LOCATIONS) {
+            maxIJKs.splice(0, 1);
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
+import { getRenderingEngine } from '@cornerstonejs/core';
+import { getBrushToolInstances } from './getBrushToolInstances';
+export function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId, toolName);
+    brushBasedToolInstances.forEach((tool) => {
+        tool.configuration.brushSize = brushSize;
+        tool.invalidateBrushCursor();
+    });
+    const viewportsInfo = toolGroup.getViewportsInfo();
+    const viewportsInfoArray = Object.keys(viewportsInfo).map((key) => viewportsInfo[key]);
+    if (!viewportsInfoArray.length) {
+        return;
+    }
+    const { renderingEngineId } = viewportsInfoArray[0];
+    const viewportIds = toolGroup.getViewportIds();
+    const renderingEngine = getRenderingEngine(renderingEngineId);
+    triggerAnnotationRenderForViewportIds(viewportIds);
+}
+export function getBrushSizeForToolGroup(toolGroupId, toolName) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const toolInstances = toolGroup._toolInstances;
+    if (!Object.keys(toolInstances).length) {
+        return;
+    }
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId, toolName);
+    const brushToolInstance = brushBasedToolInstances[0];
+    if (!brushToolInstance) {
+        return;
+    }
+    return brushToolInstance.configuration.brushSize;
+}

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

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function setBrushThresholdForToolGroup(toolGroupId: string, threshold: {
+    range: Types.Point2;
+    isDynamic: boolean;
+    dynamicRadius: number;
+}): void;
+export declare function getBrushThresholdForToolGroup(toolGroupId: string): any;

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

@@ -0,0 +1,45 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
+import { getBrushToolInstances } from './getBrushToolInstances';
+export function setBrushThresholdForToolGroup(toolGroupId, threshold) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+    brushBasedToolInstances.forEach((tool) => {
+        const activeStrategy = tool.configuration.activeStrategy;
+        if (!activeStrategy.toLowerCase().includes('threshold')) {
+            return;
+        }
+        tool.configuration = {
+            ...tool.configuration,
+            threshold: {
+                ...tool.configuration.threshold,
+                ...threshold,
+            },
+        };
+    });
+    const viewportsInfo = toolGroup.getViewportsInfo();
+    if (!viewportsInfo.length) {
+        return;
+    }
+    const viewportIds = toolGroup.getViewportIds();
+    triggerAnnotationRenderForViewportIds(viewportIds);
+}
+export function getBrushThresholdForToolGroup(toolGroupId) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const toolInstances = toolGroup._toolInstances;
+    if (!Object.keys(toolInstances).length) {
+        return;
+    }
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+    const brushToolInstance = brushBasedToolInstances[0];
+    if (!brushToolInstance) {
+        return;
+    }
+    return brushToolInstance.configuration.threshold.range;
+}

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentations } from '../../enums';
+declare function computeAndAddRepresentation<T>(segmentationId: string, type: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void, onComputationComplete?: () => void): Promise<T>;
+export { computeAndAddRepresentation };

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

@@ -0,0 +1,45 @@
+import { eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../enums';
+import addRepresentationData from '../../stateManagement/segmentation/internalAddRepresentationData';
+import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import debounce from '../debounce';
+const computedRepresentations = new Map();
+async function computeAndAddRepresentation(segmentationId, type, computeFunction, updateFunction, onComputationComplete) {
+    const data = await computeFunction();
+    addRepresentationData({
+        segmentationId,
+        type,
+        data,
+    });
+    onComputationComplete?.();
+    if (!computedRepresentations.has(segmentationId)) {
+        computedRepresentations.set(segmentationId, []);
+    }
+    const representations = computedRepresentations.get(segmentationId);
+    if (!representations.includes(type)) {
+        representations.push(type);
+    }
+    subscribeToSegmentationChanges(updateFunction);
+    triggerSegmentationModified(segmentationId);
+    return data;
+}
+function subscribeToSegmentationChanges(updateFunction) {
+    const debouncedUpdateFunction = (event) => {
+        _debouncedSegmentationModified(event, updateFunction);
+    };
+    updateFunction._debouncedUpdateFunction = debouncedUpdateFunction;
+    eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, updateFunction._debouncedUpdateFunction);
+    eventTarget.addEventListener(Events.SEGMENTATION_DATA_MODIFIED, updateFunction._debouncedUpdateFunction);
+}
+const _debouncedSegmentationModified = debounce((event, updateFunction) => {
+    const segmentationId = event.detail.segmentationId;
+    const representations = computedRepresentations.get(segmentationId);
+    if (!representations || !representations.length) {
+        return;
+    }
+    updateFunction(segmentationId);
+    if (representations.length) {
+        triggerSegmentationModified(segmentationId);
+    }
+}, 300);
+export { computeAndAddRepresentation };

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

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