@cornerstonejs/tools 2.8.6 → 2.10.0

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

@@ -11,17 +11,25 @@ import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { StrategyCallbacks } from '../../enums';
 import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
+import { getAllAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { filterAnnotationsForDisplay } from '../../utilities/planar';
+import { isPointInsidePolyline3D } from '../../utilities/math/polyline';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { fillInsideCircle } from './strategies';
 export default class LabelmapBaseTool extends BaseTool {
+    static { this.previewData = {
+        preview: null,
+        element: null,
+        timerStart: 0,
+        timer: null,
+        startPoint: [NaN, NaN],
+        isDrag: false,
+    }; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
-        this._previewData = {
-            preview: null,
-            element: null,
-            timerStart: 0,
-            timer: null,
-            startPoint: [NaN, NaN],
-            isDrag: false,
-        };
+    }
+    get _previewData() {
+        return LabelmapBaseTool.previewData;
     }
     createMemo(segmentId, segmentationVoxelManager, preview) {
         this.memo ||= LabelmapMemo.createLabelmapMemo(segmentId, segmentationVoxelManager, preview);
@@ -175,7 +183,7 @@ export default class LabelmapBaseTool extends BaseTool {
             points: data?.handles?.points,
             segmentIndex,
             previewColors: this.configuration.preview?.enabled || this._previewData.preview
-                ? this.configuration.preview.previewColors
+                ? this.configuration.preview?.previewColors
                 : null,
             viewPlaneNormal,
             toolGroupId: this.toolGroupId,
@@ -188,6 +196,7 @@ export default class LabelmapBaseTool extends BaseTool {
         return operationData;
     }
     addPreview(element = this._previewData.element, options) {
+        const { _previewData } = this;
         const acceptReject = options?.acceptReject;
         if (acceptReject === true) {
             this.acceptPreview(element);
@@ -196,9 +205,9 @@ export default class LabelmapBaseTool extends BaseTool {
             this.rejectPreview(element);
         }
         const enabledElement = getEnabledElement(element);
-        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
-        this._previewData.isDrag = true;
-        return this._previewData.preview;
+        _previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
+        _previewData.isDrag = true;
+        return _previewData.preview;
     }
     rejectPreview(element = this._previewData.element) {
         if (!element || !this._previewData.preview) {
@@ -220,4 +229,90 @@ export default class LabelmapBaseTool extends BaseTool {
         this._previewData.preview = null;
         this.doneEditMemo();
     }
+    static viewportContoursToLabelmap(viewport, options) {
+        const removeContours = options?.removeContours ?? true;
+        const annotations = getAllAnnotations();
+        const viewAnnotations = filterAnnotationsForDisplay(viewport, annotations);
+        if (!viewAnnotations?.length) {
+            return;
+        }
+        const contourAnnotations = viewAnnotations.filter((annotation) => annotation.data.contour?.polyline?.length);
+        if (!contourAnnotations.length) {
+            return;
+        }
+        const brushInstance = new LabelmapBaseTool({}, {
+            configuration: {
+                strategies: {
+                    FILL_INSIDE_CIRCLE: fillInsideCircle,
+                },
+                activeStrategy: 'FILL_INSIDE_CIRCLE',
+            },
+        });
+        const preview = brushInstance.addPreview(viewport.element);
+        const { memo, segmentationId } = preview;
+        const previewVoxels = memo?.voxelManager || preview.previewVoxelManager;
+        const segmentationVoxels = previewVoxels.sourceVoxelManager || previewVoxels;
+        const { dimensions } = previewVoxels;
+        const imageData = viewport
+            .getDefaultActor()
+            .actor.getMapper()
+            .getInputData();
+        for (const annotation of contourAnnotations) {
+            const boundsIJK = [
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+                [Infinity, -Infinity],
+            ];
+            const { polyline } = annotation.data.contour;
+            for (const point of polyline) {
+                const indexPoint = imageData.worldToIndex(point);
+                indexPoint.forEach((v, idx) => {
+                    boundsIJK[idx][0] = Math.min(boundsIJK[idx][0], v);
+                    boundsIJK[idx][1] = Math.max(boundsIJK[idx][1], v);
+                });
+            }
+            boundsIJK.forEach((bound, idx) => {
+                bound[0] = Math.round(Math.max(0, bound[0]));
+                bound[1] = Math.round(Math.min(dimensions[idx] - 1, bound[1]));
+            });
+            const activeIndex = getActiveSegmentIndex(segmentationId);
+            const startPoint = annotation.data.handles?.[0] || polyline[0];
+            const startIndex = imageData.worldToIndex(startPoint).map(Math.round);
+            const startValue = segmentationVoxels.getAtIJKPoint(startIndex) || 0;
+            let hasZeroIndex = false;
+            let hasPositiveIndex = false;
+            for (const polyPoint of polyline) {
+                const polyIndex = imageData.worldToIndex(polyPoint).map(Math.round);
+                const polyValue = segmentationVoxels.getAtIJKPoint(polyIndex);
+                if (polyValue === startValue) {
+                    hasZeroIndex = true;
+                }
+                else if (polyValue >= 0) {
+                    hasPositiveIndex = true;
+                }
+            }
+            const hasBoth = hasZeroIndex && hasPositiveIndex;
+            const segmentIndex = hasBoth
+                ? startValue
+                : startValue === 0
+                    ? activeIndex
+                    : 0;
+            for (let i = boundsIJK[0][0]; i <= boundsIJK[0][1]; i++) {
+                for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+                    for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+                        const worldPoint = imageData.indexToWorld([i, j, k]);
+                        const isContained = isPointInsidePolyline3D(worldPoint, polyline);
+                        if (isContained) {
+                            previewVoxels.setAtIJK(i, j, k, segmentIndex);
+                        }
+                    }
+                }
+            }
+            if (removeContours) {
+                removeAnnotation(annotation.annotationUID);
+            }
+        }
+        const slices = previewVoxels.getArrayOfModifiedSlices();
+        triggerSegmentationDataModified(segmentationId, slices);
+    }
 }

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

@@ -7,7 +7,6 @@ import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
 import { state } from '../../store/state';
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 class SegmentSelectTool extends BaseTool {
     static { this.SelectMode = {
         Inside: 'Inside',

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

@@ -1,7 +1,7 @@
 import determineSegmentIndex from './determineSegmentIndex';
 import dynamicThreshold from './dynamicThreshold';
 import erase from './erase';
-import islandRemoval from './islandRemoval';
+import islandRemoval from './islandRemovalComposition';
 import preview from './preview';
 import regionFill from './regionFill';
 import setValue from './setValue';

package/dist/esm/tools/segmentation/strategies/compositions/islandRemovalComposition.d.ts

@@ -0,0 +1,5 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    onInteractionEnd: (operationData: InitializedOperationData) => void;
+};
+export default _default;

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

@@ -0,0 +1,27 @@
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import IslandRemoval from '../../../../utilities/segmentation/islandRemoval';
+export default {
+    [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
+        const { strategySpecificConfiguration, previewSegmentIndex, segmentIndex, viewport, previewVoxelManager, segmentationVoxelManager, } = operationData;
+        if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+            return;
+        }
+        const islandRemoval = new IslandRemoval();
+        const voxelManager = previewVoxelManager ?? segmentationVoxelManager;
+        if (!islandRemoval.initialize(viewport, voxelManager, {
+            previewSegmentIndex,
+            segmentIndex,
+        })) {
+            return;
+        }
+        islandRemoval.floodFillSegmentIsland();
+        islandRemoval.removeExternalIslands();
+        islandRemoval.removeInternalIslands();
+        const arrayOfSlices = voxelManager.getArrayOfModifiedSlices();
+        if (!arrayOfSlices) {
+            return;
+        }
+        triggerSegmentationDataModified(operationData.segmentationId, arrayOfSlices, previewSegmentIndex);
+    },
+};

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

@@ -2,6 +2,11 @@ import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import VolumetricCalculator from '../../../../utilities/segmentation/VolumetricCalculator';
 import { getActiveSegmentIndex } from '../../../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getStrategyData } from '../utils/getStrategyData';
+import { utilities } from '@cornerstonejs/core';
+import { getPixelValueUnits } from '../../../../utilities/getPixelValueUnits';
+import { AnnotationTool } from '../../../base';
+import { isViewportPreScaled } from '../../../../utilities/viewport/isViewportPreScaled';
+const radiusForVol1 = Math.pow((3 * 1000) / (4 * Math.PI), 1 / 3);
 export default {
     [StrategyCallbacks.GetStatistics]: function (enabledElement, operationData, options) {
         const { viewport } = enabledElement;
@@ -29,8 +34,70 @@ export default {
                 return;
             }
             const imageValue = imageVoxelManager.getAtIJKPoint(pointIJK);
-            VolumetricCalculator.statsCallback({ value: imageValue });
+            VolumetricCalculator.statsCallback({ value: imageValue, pointIJK });
         });
-        return VolumetricCalculator.getStatistics({ spacing });
+        const targetId = viewport.getReferenceId();
+        const modalityUnitOptions = {
+            isPreScaled: isViewportPreScaled(viewport, targetId),
+            isSuvScaled: AnnotationTool.isSuvScaled(viewport, targetId, viewport.getCurrentImageId()),
+        };
+        const imageData = viewport.getImageData();
+        const unit = getPixelValueUnits(imageData.metadata.Modality, viewport.getCurrentImageId(), modalityUnitOptions);
+        const stats = VolumetricCalculator.getStatistics({ spacing, unit });
+        const { maxIJKs } = stats;
+        if (!maxIJKs?.length) {
+            return stats;
+        }
+        stats.mean.unit = unit;
+        stats.max.unit = unit;
+        stats.min.unit = unit;
+        if (unit !== 'SUV') {
+            return;
+        }
+        const radiusIJK = spacing.map((s) => Math.max(1, Math.round((1.1 * radiusForVol1) / s)));
+        for (const testMax of maxIJKs) {
+            const testStats = getSphereStats(testMax, radiusIJK, segmentationImageData, imageVoxelManager, spacing);
+            if (!testStats) {
+                continue;
+            }
+            const { mean } = testStats;
+            if (!stats.peakValue || stats.peakValue.value <= mean.value) {
+                stats.peakValue = {
+                    name: 'peakValue',
+                    label: 'Peak Value',
+                    value: mean.value,
+                    unit,
+                };
+            }
+        }
+        return stats;
     },
 };
+function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
+    const { pointIJK: centerIJK } = testMax;
+    const boundsIJK = centerIJK.map((ijk, idx) => [
+        ijk - radiusIJK[idx],
+        ijk + radiusIJK[idx],
+    ]);
+    const testFunction = (_pointLPS, pointIJK) => {
+        const i = (pointIJK[0] - centerIJK[0]) / radiusIJK[0];
+        const j = (pointIJK[1] - centerIJK[1]) / radiusIJK[1];
+        const k = (pointIJK[2] - centerIJK[2]) / radiusIJK[2];
+        const radius = i * i + j * j + k * k;
+        return radius <= 1;
+    };
+    const statsFunction = ({ pointIJK, pointLPS }) => {
+        const value = imageVoxels.getAtIJKPoint(pointIJK);
+        if (value === undefined) {
+            return;
+        }
+        VolumetricCalculator.statsCallback({ value, pointLPS, pointIJK });
+    };
+    VolumetricCalculator.statsInit({ storePointData: false });
+    utilities.pointInShapeCallback(segData, {
+        pointInShapeFn: testFunction,
+        callback: statsFunction,
+        boundsIJK,
+    });
+    return VolumetricCalculator.getStatistics({ spacing });
+}

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

@@ -31,6 +31,10 @@ type NamedStatistics = {
         name: 'circumference';
     };
     pointsInShape?: Types.IPointsManager<Types.Point3>;
+    maxIJKs?: Array<{
+        value: number;
+        pointIJK: Types.Point3;
+    }>;
     array: Statistics[];
 };
 export type { Statistics, NamedStatistics };

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

@@ -1,4 +1,4 @@
-import type { Types } from '@cornerstonejs/core';
+import type { Enums as coreEnums, Types } from '@cornerstonejs/core';
 import type * as Enums from '../enums';
 import type { ContourSegmentationData } from './ContourTypes';
 import type { LabelmapSegmentationData } from './LabelmapTypes';
@@ -35,6 +35,7 @@ export type LabelmapRenderingConfig = {
     cfun: vtkColorTransferFunction;
     ofun: vtkPiecewiseFunction;
     colorLUTIndex: number;
+    blendMode?: coreEnums.BlendModes;
 };
 export type ContourRenderingConfig = {};
 export type SurfaceRenderingConfig = {};
@@ -89,6 +90,7 @@ export type RepresentationPublicInput = {
     type?: Enums.SegmentationRepresentations;
     config?: {
         colorLUTOrIndex?: Types.ColorLUT | number;
+        blendMode?: coreEnums.BlendModes;
     };
 };
 export {};

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

@@ -11,8 +11,11 @@ export function addContourSegmentationAnnotation(annotation) {
     if (!segmentation.representationData.Contour) {
         segmentation.representationData.Contour = { annotationUIDsMap: new Map() };
     }
-    const { annotationUIDsMap } = segmentation.representationData.Contour;
-    let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+    let { annotationUIDsMap } = segmentation.representationData.Contour;
+    if (!annotationUIDsMap) {
+        annotationUIDsMap = new Map();
+    }
+    let annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
     if (!annotationsUIDsSet) {
         annotationsUIDsSet = new Set();
         annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);

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

@@ -33,4 +33,6 @@ import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 import { pointInSurroundingSphereCallback } from './pointInSurroundingSphereCallback';
 declare const roundNumber: typeof utilities.roundNumber;
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, };
+import normalizeViewportPlane from './normalizeViewportPlane';
+import IslandRemoval from './segmentation/islandRemoval';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, };

package/dist/esm/utilities/index.js

@@ -33,4 +33,6 @@ import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 import { pointInSurroundingSphereCallback } from './pointInSurroundingSphereCallback';
 const roundNumber = utilities.roundNumber;
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, };
+import normalizeViewportPlane from './normalizeViewportPlane';
+import IslandRemoval from './segmentation/islandRemoval';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, };

package/dist/esm/utilities/planar/filterAnnotationsWithinSlice.js

@@ -27,14 +27,14 @@ export default function filterAnnotationsWithinSlice(annotations, camera, spacin
     const annotationsWithinSlice = [];
     for (const annotation of annotationsWithParallelNormals) {
         const data = annotation.data;
-        const point = data.handles.points[0];
+        const point = data.handles.points[0] || data.contour?.polyline[0];
         if (!annotation.isVisible) {
             continue;
         }
         const dir = vec3.create();
         if (!point) {
             annotationsWithinSlice.push(annotation);
-            return;
+            continue;
         }
         vec3.sub(dir, focalPoint, point);
         const dot = vec3.dot(dir, viewPlaneNormal);

package/dist/esm/utilities/planar/getPointInLineOfSightWithCriteria.d.ts

@@ -1,2 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-export default function getPointInLineOfSightWithCriteria(viewport: Types.IVolumeViewport, worldPos: Types.Point3, targetVolumeId: string, criteriaFunction: (intensity: number, point: Types.Point3) => Types.Point3, stepSize?: number): Types.Point3;
+export declare function getPointInLineOfSightWithCriteria(viewport: Types.IVolumeViewport, worldPos: Types.Point3, targetVolumeId: string, criteriaFunction: (intensity: number, point: Types.Point3) => Types.Point3, stepSize?: number): Types.Point3;
+export declare function getPointsInLineOfSight(viewport: Types.IVolumeViewport, worldPos: Types.Point3, { targetVolumeId, stepSize }: {
+    targetVolumeId: string;
+    stepSize: number;
+}): Types.Point3[];

package/dist/esm/utilities/planar/getPointInLineOfSightWithCriteria.js

@@ -1,38 +1,49 @@
-import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { utilities as csUtils } from '@cornerstonejs/core';
-export default function getPointInLineOfSightWithCriteria(viewport, worldPos, targetVolumeId, criteriaFunction, stepSize = 0.25) {
-    const camera = viewport.getCamera();
-    const { position: cameraPosition } = camera;
-    const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetVolumeId);
-    const step = spacingInNormalDirection * stepSize;
-    const bounds = viewport.getBounds();
-    const xMin = bounds[0];
-    const xMax = bounds[1];
-    const vector = [0, 0, 0];
-    let point = [0, 0, 0];
-    vtkMath.subtract(worldPos, cameraPosition, vector);
+export function getPointInLineOfSightWithCriteria(viewport, worldPos, targetVolumeId, criteriaFunction, stepSize = 0.25) {
+    const points = getPointsInLineOfSight(viewport, worldPos, {
+        targetVolumeId,
+        stepSize,
+    });
     let pickedPoint;
-    for (let pointT = xMin; pointT <= xMax; pointT = pointT + step) {
-        point = [pointT, 0, 0];
-        const t = (pointT - cameraPosition[0]) / vector[0];
-        point[1] = t * vector[1] + cameraPosition[1];
-        point[2] = t * vector[2] + cameraPosition[2];
-        if (_inBounds(point, bounds)) {
-            const intensity = viewport.getIntensityFromWorld(point);
-            const pointToPick = criteriaFunction(intensity, point);
-            if (pointToPick) {
-                pickedPoint = pointToPick;
-            }
+    for (const point of points) {
+        const intensity = viewport.getIntensityFromWorld(point);
+        const pointToPick = criteriaFunction(intensity, point);
+        if (pointToPick) {
+            pickedPoint = pointToPick;
         }
     }
     return pickedPoint;
 }
+export function getPointsInLineOfSight(viewport, worldPos, { targetVolumeId, stepSize }) {
+    const camera = viewport.getCamera();
+    const { viewPlaneNormal: normalDirection } = camera;
+    const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetVolumeId);
+    const step = spacingInNormalDirection * stepSize || 1;
+    const bounds = viewport.getBounds();
+    const points = [];
+    let currentPos = [...worldPos];
+    while (_inBounds(currentPos, bounds)) {
+        points.push([...currentPos]);
+        currentPos[0] += normalDirection[0] * step;
+        currentPos[1] += normalDirection[1] * step;
+        currentPos[2] += normalDirection[2] * step;
+    }
+    currentPos = [...worldPos];
+    while (_inBounds(currentPos, bounds)) {
+        points.push([...currentPos]);
+        currentPos[0] -= normalDirection[0] * step;
+        currentPos[1] -= normalDirection[1] * step;
+        currentPos[2] -= normalDirection[2] * step;
+    }
+    return points;
+}
 const _inBounds = function (point, bounds) {
     const [xMin, xMax, yMin, yMax, zMin, zMax] = bounds;
-    return (point[0] > xMin &&
-        point[0] < xMax &&
-        point[1] > yMin &&
-        point[1] < yMax &&
-        point[2] > zMin &&
-        point[2] < zMax);
+    const padding = 10;
+    return (point[0] > xMin + padding &&
+        point[0] < xMax - padding &&
+        point[1] > yMin + padding &&
+        point[1] < yMax - padding &&
+        point[2] > zMin + padding &&
+        point[2] < zMax - padding);
 };

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

@@ -1,7 +1,7 @@
 import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
-import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { getPointInLineOfSightWithCriteria, getPointsInLineOfSight } from './getPointInLineOfSightWithCriteria';
 import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
 import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 declare const _default: {
@@ -11,6 +11,7 @@ declare const _default: {
     getPointInLineOfSightWithCriteria: typeof getPointInLineOfSightWithCriteria;
     isPlaneIntersectingAABB: (origin: any, normal: any, minX: any, minY: any, minZ: any, maxX: any, maxY: any, maxZ: any) => boolean;
     filterAnnotationsWithinSamePlane: typeof filterAnnotationsWithinSamePlane;
+    getPointsInLineOfSight: typeof getPointsInLineOfSight;
 };
 export default _default;
-export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, };
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, getPointsInLineOfSight, };

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

@@ -1,7 +1,7 @@
 import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
-import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { getPointInLineOfSightWithCriteria, getPointsInLineOfSight, } from './getPointInLineOfSightWithCriteria';
 import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
 import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 export default {
@@ -11,5 +11,6 @@ export default {
     getPointInLineOfSightWithCriteria,
     isPlaneIntersectingAABB,
     filterAnnotationsWithinSamePlane,
+    getPointsInLineOfSight,
 };
-export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, };
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, getPointsInLineOfSight, };

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

@@ -1,8 +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

@@ -1,5 +1,7 @@
 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();
@@ -14,7 +16,33 @@ export default class VolumetricCalculator extends BasicStatsCalculator {
             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/growCut/runGrowCutForBoundingBox.d.ts

@@ -7,8 +7,6 @@ type BoundingBoxInfo = {
     };
 };
 type GrowCutBoundingBoxOptions = GrowCutOptions & {
-    positiveSeedValue?: number;
-    negativeSeedValue?: number;
     negativePixelRange?: [number, number];
     positivePixelRange?: [number, number];
 };

package/dist/esm/utilities/segmentation/growCut/runOneClickGrowCut.d.ts

@@ -1,10 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { GrowCutOptions } from './runGrowCut';
 type GrowCutOneClickOptions = GrowCutOptions & {
-    positiveSeedValue?: number;
-    negativeSeedValue?: number;
-    positiveSeedVariance?: number;
-    negativeSeedVariance?: number;
     subVolumePaddingPercentage?: number | [number, number, number];
     subVolumeMinPadding?: number | [number, number, number];
 };

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

@@ -19,4 +19,5 @@ import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegm
 import { getBrushToolInstances } from './getBrushToolInstances';
 import * as growCut from './growCut';
 import * as LabelmapMemo from './createLabelmapMemo';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, };
+import IslandRemoval from './islandRemoval';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, };

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

@@ -19,4 +19,5 @@ import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegm
 import { getBrushToolInstances } from './getBrushToolInstances';
 import * as growCut from './growCut';
 import * as LabelmapMemo from './createLabelmapMemo';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, };
+import IslandRemoval from './islandRemoval';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, };

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

@@ -0,0 +1,28 @@
+import type { Types } from '@cornerstonejs/core';
+export declare enum SegmentationEnum {
+    SEGMENT = -1,
+    ISLAND = -2,
+    INTERIOR = -3,
+    EXTERIOR = -4,
+    INTERIOR_SMALL = -5,
+    INTERIOR_TEST = -6
+}
+export default class IslandRemoval {
+    segmentSet: Types.RLEVoxelMap<SegmentationEnum>;
+    segmentIndex: number;
+    fillSegments: (index: number) => boolean;
+    previewVoxelManager: Types.VoxelManager<number>;
+    previewSegmentIndex: number;
+    selectedPoints: Types.Point3[];
+    private fillInternalEdge;
+    private maxInternalRemove;
+    constructor(options?: {
+        maxInternalRemove?: number;
+        fillInternalEdge?: boolean;
+    });
+    initialize(viewport: any, segmentationVoxels: any, options: any): boolean;
+    floodFillSegmentIsland(): number;
+    removeExternalIslands(): void;
+    removeInternalIslands(): number[];
+    static covers(rle: any, row: any): boolean;
+}