@cornerstonejs/tools 3.20.2 → 3.21.1

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

@@ -9,6 +9,7 @@ import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import * as utilities from './utilities';
 import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
 import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
 import { clearSegmentValue } from './helpers/clearSegmentValue';
@@ -27,4 +28,4 @@ declare const helpers: {
     computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
     convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, utilities, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };

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

@@ -9,6 +9,7 @@ import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import * as utilities from './utilities';
 import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
 import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
 import { clearSegmentValue } from './helpers/clearSegmentValue';
@@ -27,4 +28,4 @@ const helpers = {
     computeVolumeLabelmapFromStack,
     convertVolumeToStackLabelmap,
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, utilities, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };

package/dist/esm/stateManagement/segmentation/utilities/decimateContours.d.ts

@@ -0,0 +1,3 @@
+export default function decimateContours(segmentationId: string, segmentIndex: number, options?: {
+    epsilon: number;
+}): void;

package/dist/esm/stateManagement/segmentation/utilities/decimateContours.js

@@ -0,0 +1,40 @@
+import { getAnnotation, invalidateAnnotation, } from '../../annotation/annotationState';
+import { getSegmentation } from '../getSegmentation';
+import { extractSegmentPolylines } from './extractSegmentPolylines';
+import decimate from '../../../utilities/math/polyline/decimate';
+import { getViewportsAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export default function decimateContours(segmentationId, segmentIndex, options = { epsilon: 0.1 }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        console.warn(`No contour representation found for segmentation ${segmentationId}`);
+        return;
+    }
+    const viewports = getViewportsAssociatedToSegmentation(segmentationId);
+    if (!viewports) {
+        console.warn('No viewport associated to the segmentation found');
+        return;
+    }
+    const polylinesCanvasMap = extractSegmentPolylines(segmentationId, segmentIndex);
+    if (!polylinesCanvasMap) {
+        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
+        return;
+    }
+    const keys = Array.from(polylinesCanvasMap?.keys());
+    for (const annotationUID of keys) {
+        const annotation = getAnnotation(annotationUID);
+        if (!annotation) {
+            continue;
+        }
+        const polylineCanvas = polylinesCanvasMap.get(annotationUID);
+        const decimatedPolyline2D = decimate(polylineCanvas, options.epsilon);
+        const viewport = getViewportWithMatchingViewPlaneNormal(viewports, annotation);
+        if (viewport) {
+            annotation.data.contour.polyline = decimatedPolyline2D.map((point2D) => viewport.canvasToWorld(point2D));
+            invalidateAnnotation(annotation);
+        }
+    }
+}

package/dist/esm/stateManagement/segmentation/utilities/extractSegmentPolylines.d.ts

@@ -0,0 +1 @@
+export declare function extractSegmentPolylines(segmentationId: string, segmentIndex: number): Map<any, any>;

package/dist/esm/stateManagement/segmentation/utilities/extractSegmentPolylines.js

@@ -0,0 +1,36 @@
+import { getSegmentation } from '../getSegmentation';
+import { convertContourPolylineToCanvasSpace } from '../../../utilities/contourSegmentation';
+import { getViewportsAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+import { getPolylinesMap } from './getPolylineMap';
+import { getAnnotation } from '../../annotation/annotationState';
+export function extractSegmentPolylines(segmentationId, segmentIndex) {
+    const viewports = getViewportsAssociatedToSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        return;
+    }
+    const contourRepresentationData = segmentation.representationData
+        .Contour;
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    if (!annotationUIDsMap.get(segmentIndex)) {
+        return;
+    }
+    const polyLinesMap = getPolylinesMap(contourRepresentationData, segmentIndex);
+    if (!polyLinesMap) {
+        return;
+    }
+    const keys = Array.from(polyLinesMap?.keys());
+    const polylinesCanvasMap = new Map();
+    for (const key of keys) {
+        const annotation = getAnnotation(key);
+        const viewport = getViewportWithMatchingViewPlaneNormal(viewports, annotation);
+        polylinesCanvasMap.set(key, convertContourPolylineToCanvasSpace(polyLinesMap.get(key), viewport));
+    }
+    return polylinesCanvasMap;
+}

package/dist/esm/stateManagement/segmentation/utilities/getAnnotationMapFromSegmentation.d.ts

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import type * as ToolsTypes from '../../../types';
+export type MapOptions = {
+    segmentIndices?: number[];
+    segmentationId?: string;
+    viewport?: Types.IStackViewport | Types.IVolumeViewport;
+};
+export type AnnotationInfo = {
+    polyline: Types.Point3[];
+    isClosed: boolean;
+    annotationUID: string;
+    referencedImageId: string;
+    holesPolyline: Types.Point3[][];
+    holesUIDs: string[];
+    holesClosed: boolean[];
+};
+export declare function getAnnotationMapFromSegmentation(contourRepresentationData: ToolsTypes.ContourSegmentationData, options?: MapOptions): {
+    segmentIndices: number[];
+    annotationUIDsInSegmentMap: Map<number, unknown>;
+};

package/dist/esm/stateManagement/segmentation/utilities/getAnnotationMapFromSegmentation.js

@@ -0,0 +1,40 @@
+import { getAnnotation } from '../../annotation/annotationState';
+export function getAnnotationMapFromSegmentation(contourRepresentationData, options = {}) {
+    const annotationMap = contourRepresentationData.annotationUIDsMap;
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : Array.from(annotationMap.keys());
+    const annotationUIDsInSegmentMap = new Map();
+    segmentIndices.forEach((index) => {
+        const annotationUIDsInSegment = annotationMap.get(index);
+        let uids = Array.from(annotationUIDsInSegment);
+        uids = uids.filter((uid) => !getAnnotation(uid).parentAnnotationUID);
+        const annotations = uids.map((uid) => {
+            const annotation = getAnnotation(uid);
+            const hasChildAnnotations = annotation.childAnnotationUIDs?.length;
+            const childPolylinesInformation = hasChildAnnotations &&
+                annotation.childAnnotationUIDs.map((childUID) => {
+                    const childAnnotation = getAnnotation(childUID);
+                    return {
+                        polyline: childAnnotation.data.contour.polyline,
+                        isClosed: childAnnotation.data.contour.closed,
+                    };
+                });
+            const holesClosed = hasChildAnnotations &&
+                childPolylinesInformation.map((childInfo) => childInfo.isClosed);
+            const childPolylines = hasChildAnnotations &&
+                childPolylinesInformation.map((childInfo) => childInfo.polyline);
+            return {
+                polyline: annotation.data.contour.polyline,
+                isClosed: annotation.data.contour.closed,
+                annotationUID: annotation.annotationUID,
+                referencedImageId: annotation.metadata.referencedImageId,
+                holesPolyline: childPolylines,
+                holesUIDs: annotation.childAnnotationUIDs,
+                holesClosed,
+            };
+        });
+        annotationUIDsInSegmentMap.set(index, annotations);
+    });
+    return { segmentIndices, annotationUIDsInSegmentMap };
+}

package/dist/esm/stateManagement/segmentation/utilities/getPolylineMap.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationData } from '../../../types';
+export declare function getPolylinesMap(contourRepresentationData: ContourSegmentationData, segmentIndex: number): Map<string, Types.Point3[]>;

package/dist/esm/stateManagement/segmentation/utilities/getPolylineMap.js

@@ -0,0 +1,34 @@
+import { getAnnotationMapFromSegmentation, } from './getAnnotationMapFromSegmentation';
+function closePolyline(polyline, closed) {
+    if (!polyline || polyline.length === 0) {
+        return [];
+    }
+    if (!closed) {
+        return [...polyline];
+    }
+    const firstPoint = polyline[0];
+    const lastPoint = polyline[polyline.length - 1];
+    const isAlreadyClosed = firstPoint[0] === lastPoint[0] &&
+        firstPoint[1] === lastPoint[1] &&
+        firstPoint[2] === lastPoint[2];
+    if (isAlreadyClosed) {
+        return [...polyline];
+    }
+    return [...polyline, firstPoint];
+}
+export function getPolylinesMap(contourRepresentationData, segmentIndex) {
+    const { annotationUIDsInSegmentMap } = getAnnotationMapFromSegmentation(contourRepresentationData);
+    if (!annotationUIDsInSegmentMap.has(segmentIndex)) {
+        console.warn(`No contour information found for segmentIndex ${segmentIndex}`);
+        return;
+    }
+    const polylines = new Map();
+    const annotationsInfo = annotationUIDsInSegmentMap.get(segmentIndex);
+    for (const annotationInfo of annotationsInfo) {
+        polylines.set(annotationInfo.annotationUID, closePolyline(annotationInfo.polyline, annotationInfo.isClosed));
+        for (let i = 0; i < annotationInfo.holesUIDs?.length; i++) {
+            polylines.set(annotationInfo.holesUIDs[i], closePolyline(annotationInfo.holesPolyline[i], annotationInfo.holesClosed[i]));
+        }
+    }
+    return polylines;
+}

package/dist/esm/stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../../types';
+export declare function getViewportsAssociatedToSegmentation(segmentationId: string): Types.IViewport[];
+export declare function getViewportAssociatedToSegmentation(segmentationId: string): import("@cornerstonejs/core").Viewport;
+export declare function getViewportWithMatchingViewPlaneNormal(viewports: Types.IViewport[], annotation: ContourSegmentationAnnotation, dotThreshold?: number): Types.IViewport | undefined;

package/dist/esm/stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation.js

@@ -0,0 +1,42 @@
+import { vec3 } from 'gl-matrix';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { getViewportIdsWithSegmentation } from '../getViewportIdsWithSegmentation';
+export function getViewportsAssociatedToSegmentation(segmentationId) {
+    const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+    if (viewportIds?.length === 0) {
+        return [];
+    }
+    const viewports = [];
+    for (const viewportId of viewportIds) {
+        const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+        if (viewport) {
+            viewports.push(viewport);
+        }
+    }
+    return viewports;
+}
+export function getViewportAssociatedToSegmentation(segmentationId) {
+    const viewports = getViewportsAssociatedToSegmentation(segmentationId);
+    return viewports.length > 0 ? viewports[0] : undefined;
+}
+export function getViewportWithMatchingViewPlaneNormal(viewports, annotation, dotThreshold = 0.99) {
+    const annotationViewPlaneNormal = annotation.metadata?.viewPlaneNormal;
+    if (!annotationViewPlaneNormal || !Array.isArray(annotationViewPlaneNormal)) {
+        return undefined;
+    }
+    const normalizedAnnotationNormal = vec3.create();
+    vec3.normalize(normalizedAnnotationNormal, annotationViewPlaneNormal);
+    for (const viewport of viewports) {
+        const camera = viewport.getCamera();
+        if (!camera?.viewPlaneNormal) {
+            continue;
+        }
+        const normalizedCameraNormal = vec3.create();
+        vec3.normalize(normalizedCameraNormal, camera.viewPlaneNormal);
+        const dotProduct = vec3.dot(normalizedAnnotationNormal, normalizedCameraNormal);
+        if (Math.abs(dotProduct) >= dotThreshold) {
+            return viewport;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,8 @@
+export { getViewportAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export { getAnnotationMapFromSegmentation } from './getAnnotationMapFromSegmentation';
+export { default as decimateContours } from './decimateContours';
+export { extractSegmentPolylines } from './extractSegmentPolylines';
+export { removeCompleteContourAnnotation } from './removeCompleteContourAnnotation';
+export { default as removeContourHoles } from './removeContourHoles';
+export { default as removeContourIslands } from './removeContourIslands';
+export { default as smoothContours } from './smoothContours';

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

@@ -0,0 +1,8 @@
+export { getViewportAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export { getAnnotationMapFromSegmentation } from './getAnnotationMapFromSegmentation';
+export { default as decimateContours } from './decimateContours';
+export { extractSegmentPolylines } from './extractSegmentPolylines';
+export { removeCompleteContourAnnotation } from './removeCompleteContourAnnotation';
+export { default as removeContourHoles } from './removeContourHoles';
+export { default as removeContourIslands } from './removeContourIslands';
+export { default as smoothContours } from './smoothContours';

package/dist/esm/stateManagement/segmentation/utilities/removeCompleteContourAnnotation.d.ts

@@ -0,0 +1,2 @@
+import type { ContourSegmentationAnnotation } from '../../../types';
+export declare function removeCompleteContourAnnotation(annotation: ContourSegmentationAnnotation): void;

package/dist/esm/stateManagement/segmentation/utilities/removeCompleteContourAnnotation.js

@@ -0,0 +1,12 @@
+import { removeContourSegmentationAnnotation } from '../../../utilities/contourSegmentation';
+import { clearParentAnnotation, removeAnnotation, } from '../../annotation/annotationState';
+export function removeCompleteContourAnnotation(annotation) {
+    if (!annotation) {
+        return;
+    }
+    if (annotation.parentAnnotationUID) {
+        clearParentAnnotation(annotation);
+    }
+    removeAnnotation(annotation.annotationUID);
+    removeContourSegmentationAnnotation(annotation);
+}

package/dist/esm/stateManagement/segmentation/utilities/removeContourHoles.d.ts

@@ -0,0 +1 @@
+export default function removeContourHoles(segmentationId: string, segmentIndex: number): void;

package/dist/esm/stateManagement/segmentation/utilities/removeContourHoles.js

@@ -0,0 +1,33 @@
+import { findContourHoles } from '../../../utilities/contours';
+import { getAnnotation } from '../../annotation/annotationState';
+import { triggerAnnotationRemoved } from '../../annotation/helpers/state';
+import { getSegmentation } from '../getSegmentation';
+import { extractSegmentPolylines } from './extractSegmentPolylines';
+import { removeCompleteContourAnnotation } from './removeCompleteContourAnnotation';
+export default function removeContourHoles(segmentationId, segmentIndex) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        console.warn(`No contour representation found for segmentation ${segmentationId}`);
+        return;
+    }
+    const polylinesCanvasMap = extractSegmentPolylines(segmentationId, segmentIndex);
+    if (!polylinesCanvasMap) {
+        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
+        return;
+    }
+    const keys = Array.from(polylinesCanvasMap?.keys());
+    const polylines = keys.map((key) => polylinesCanvasMap.get(key));
+    const holeDetectionResults = findContourHoles(polylines);
+    if (holeDetectionResults?.length > 0) {
+        holeDetectionResults.forEach((hole) => {
+            hole.holeIndexes.forEach((index) => {
+                const annotation = getAnnotation(keys[index]);
+                removeCompleteContourAnnotation(annotation);
+            });
+        });
+    }
+}

package/dist/esm/stateManagement/segmentation/utilities/removeContourIslands.d.ts

@@ -0,0 +1,3 @@
+export default function removeContourIslands(segmentationId: string, segmentIndex: number, options?: {
+    threshold: number;
+}): void;

package/dist/esm/stateManagement/segmentation/utilities/removeContourIslands.js

@@ -0,0 +1,30 @@
+import { getAnnotation } from '../../annotation/annotationState';
+import { getSegmentation } from '../getSegmentation';
+import { extractSegmentPolylines } from './extractSegmentPolylines';
+import findIslands from '../../../utilities/contours/findIslands';
+import { removeCompleteContourAnnotation } from './removeCompleteContourAnnotation';
+export default function removeContourIslands(segmentationId, segmentIndex, options = { threshold: 3 }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        console.warn(`No contour representation found for segmentation ${segmentationId}`);
+        return;
+    }
+    const polylinesCanvasMap = extractSegmentPolylines(segmentationId, segmentIndex);
+    if (!polylinesCanvasMap) {
+        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
+        return;
+    }
+    const keys = Array.from(polylinesCanvasMap?.keys());
+    const polylines = keys.map((key) => polylinesCanvasMap.get(key));
+    const islands = findIslands(polylines, options.threshold);
+    if (islands?.length > 0) {
+        islands.forEach((index) => {
+            const annotation = getAnnotation(keys[index]);
+            removeCompleteContourAnnotation(annotation);
+        });
+    }
+}

package/dist/esm/stateManagement/segmentation/utilities/smoothContours.d.ts

@@ -0,0 +1,3 @@
+export default function smoothContours(segmentationId: string, segmentIndex: number, options?: {
+    knotsRatioPercentage: number;
+}): void;

package/dist/esm/stateManagement/segmentation/utilities/smoothContours.js

@@ -0,0 +1,38 @@
+import { getAnnotation } from '../../annotation/annotationState';
+import { getSegmentation } from '../getSegmentation';
+import interpolateSegmentPoints from '../../../utilities/planarFreehandROITool/interpolation/interpolateSegmentPoints';
+export default function smoothContours(segmentationId, segmentIndex, options = { knotsRatioPercentage: 30 }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        console.warn(`No contour representation found for segmentation ${segmentationId}`);
+        return;
+    }
+    const contourRepresentationData = segmentation.representationData
+        .Contour;
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        console.warn(`No contours found for segmentation ${segmentationId}`);
+        return;
+    }
+    if (!annotationUIDsMap.has(segmentIndex)) {
+        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
+        return;
+    }
+    const annotationList = annotationUIDsMap.get(segmentIndex);
+    annotationList.forEach((annotationUID) => {
+        const annotation = getAnnotation(annotationUID);
+        if (!annotation) {
+            return;
+        }
+        const polyline = annotation.data.contour.polyline;
+        if (!polyline || polyline.length < 3) {
+            return;
+        }
+        const smoothedPolyline = interpolateSegmentPoints(polyline, 0, polyline.length - 1, options.knotsRatioPercentage);
+        annotation.data.contour.polyline = smoothedPolyline;
+    });
+}

package/dist/esm/utilities/contours/findContourHoles.d.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+export interface ContourHoleDetectionResult {
+    contourIndex: number;
+    holeIndexes: number[];
+}
+export default function findContourHoles(polylines: Types.Point2[][]): ContourHoleDetectionResult[];
+export { findContourHoles };

package/dist/esm/utilities/contours/findContourHoles.js

@@ -0,0 +1,39 @@
+import getSignedArea from '../math/polyline/getSignedArea';
+import containsPoints from '../math/polyline/containsPoints';
+import isClosed from '../math/polyline/isClosed';
+function isPolygonInsidePolygon(inner, outer) {
+    return containsPoints(outer, inner);
+}
+export default function findContourHoles(polylines) {
+    const results = [];
+    const closedPolylines = [];
+    polylines.forEach((polyline, index) => {
+        if (isClosed(polyline)) {
+            closedPolylines.push({ polyline, originalIndex: index });
+        }
+    });
+    for (let i = 0; i < closedPolylines.length; i++) {
+        const outerContour = closedPolylines[i];
+        const outerArea = Math.abs(getSignedArea(outerContour.polyline));
+        const holeIndexes = [];
+        for (let j = 0; j < closedPolylines.length; j++) {
+            if (i === j) {
+                continue;
+            }
+            const potentialHole = closedPolylines[j];
+            const holeArea = Math.abs(getSignedArea(potentialHole.polyline));
+            if (holeArea < outerArea &&
+                isPolygonInsidePolygon(potentialHole.polyline, outerContour.polyline)) {
+                holeIndexes.push(potentialHole.originalIndex);
+            }
+        }
+        if (holeIndexes.length > 0) {
+            results.push({
+                contourIndex: outerContour.originalIndex,
+                holeIndexes: holeIndexes.sort((a, b) => a - b),
+            });
+        }
+    }
+    return results.sort((a, b) => a.contourIndex - b.contourIndex);
+}
+export { findContourHoles };

package/dist/esm/utilities/contours/findIslands.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function findIslands(polylines: Types.Point2[][], threshold: number): number[];

package/dist/esm/utilities/contours/findIslands.js

@@ -0,0 +1,25 @@
+import isClosed from '../math/polyline/isClosed';
+import { getSignedArea } from '../math/polyline';
+export default function findIslands(polylines, threshold) {
+    if (!polylines || polylines.length === 0) {
+        return [];
+    }
+    if (threshold <= 0) {
+        return [];
+    }
+    const islandIndexes = [];
+    for (let i = 0; i < polylines.length; i++) {
+        const polyline = polylines[i];
+        if (!polyline || polyline.length < 3) {
+            continue;
+        }
+        const isClosedPolyline = isClosed(polyline);
+        if (isClosedPolyline) {
+            const area = Math.abs(getSignedArea(polyline)) / 100;
+            if (area < threshold) {
+                islandIndexes.push(i);
+            }
+        }
+    }
+    return islandIndexes;
+}

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

@@ -2,6 +2,7 @@ import areCoplanarContours from './areCoplanarContours';
 import contourFinder from './contourFinder';
 import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
 import detectContourHoles from './detectContourHoles';
+import findContourHoles from './findContourHoles';
 import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
 import AnnotationToPointData from './AnnotationToPointData';
 import getContourHolesDataWorld from './getContourHolesDataWorld';
@@ -10,4 +11,5 @@ import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 import calculatePerimeter from './calculatePerimeter';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };
+import findIslands from './findIslands';
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, findIslands, };

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

@@ -2,6 +2,7 @@ import areCoplanarContours from './areCoplanarContours';
 import contourFinder from './contourFinder';
 import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
 import detectContourHoles from './detectContourHoles';
+import findContourHoles from './findContourHoles';
 import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
 import AnnotationToPointData from './AnnotationToPointData';
 import getContourHolesDataWorld from './getContourHolesDataWorld';
@@ -10,4 +11,5 @@ import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 import calculatePerimeter from './calculatePerimeter';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };
+import findIslands from './findIslands';
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, findIslands, };

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.js

@@ -40,14 +40,14 @@ export default function smoothAnnotation(annotation, options) {
         return [planeP[0], planeP[1]];
     });
     let rotation = closed ? rotate(canvasPoints) : 0;
-    let interpolatedCanvasPoints = (interpolateSegmentPoints(canvasPoints, 0, canvasPoints.length, options?.knotsRatioPercentage || 30));
+    let interpolatedCanvasPoints = (interpolateSegmentPoints(canvasPoints, 0, canvasPoints.length - 1, options?.knotsRatioPercentage || 30));
     if (interpolatedCanvasPoints === canvasPoints) {
         return false;
     }
     rotate(interpolatedCanvasPoints, -rotation);
     for (let i = 1; i < options?.loop; i++) {
         rotation = closed ? rotate(interpolatedCanvasPoints) : 0;
-        interpolatedCanvasPoints = (interpolateSegmentPoints(interpolatedCanvasPoints, 0, canvasPoints.length, options?.knotsRatioPercentage || 30));
+        interpolatedCanvasPoints = (interpolateSegmentPoints(interpolatedCanvasPoints, 0, interpolatedCanvasPoints.length - 1, options?.knotsRatioPercentage || 30));
         rotate(interpolatedCanvasPoints, -rotation);
     }
     const unRotate = mat4.invert(mat4.create(), rotateMat);

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.20.2";
+export declare const version = "3.21.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.20.2';
+export const version = '3.21.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.20.2",
+  "version": "3.21.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.20.2",
+    "@cornerstonejs/core": "^3.21.1",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "e361cbeb9a1b386d4cefeecb49bcdf6c2b12285d"
+  "gitHead": "0f1548c39f1fd60af41bfa458f8402850a7fcb12"
 }