@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -0,0 +1,109 @@
+import { cache as cornerstoneCache } from '@cornerstonejs/core';
+import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchingSquares';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
+import { findContoursFromReducedSet } from './contourFinder';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+const { Labelmap } = SegmentationRepresentations;
+function generateContourSetsFromLabelmap({ segmentations }) {
+    const { representationData, segments = [0, 1] } = segmentations;
+    const { volumeId: segVolumeId } = representationData[Labelmap];
+    const vol = cornerstoneCache.getVolume(segVolumeId);
+    if (!vol) {
+        console.warn(`No volume found for ${segVolumeId}`);
+        return;
+    }
+    const numSlices = vol.dimensions[2];
+    const voxelManager = vol.voxelManager;
+    const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
+    for (let z = 0; z < numSlices; z++) {
+        for (let y = 0; y < vol.dimensions[1]; y++) {
+            const index = y * vol.dimensions[0] + z * pixelsPerSlice;
+            voxelManager.setAtIndex(index, 0);
+            voxelManager.setAtIndex(index + vol.dimensions[0] - 1, 0);
+        }
+    }
+    const ContourSets = [];
+    const { FrameOfReferenceUID } = vol.metadata;
+    const numSegments = segments.length;
+    for (let segIndex = 0; segIndex < numSegments; segIndex++) {
+        const segment = segments[segIndex];
+        if (!segment) {
+            continue;
+        }
+        const sliceContours = [];
+        const scalars = vtkDataArray.newInstance({
+            name: 'Scalars',
+            numberOfComponents: 1,
+            size: pixelsPerSlice * numSlices,
+            dataType: 'Uint8Array',
+        });
+        const { containedSegmentIndices } = segment;
+        for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
+            if (isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex)) {
+                continue;
+            }
+            const frameStart = sliceIndex * pixelsPerSlice;
+            try {
+                for (let i = 0; i < pixelsPerSlice; i++) {
+                    const value = voxelManager.getAtIndex(i + frameStart);
+                    if (value === segIndex || containedSegmentIndices?.has(value)) {
+                        scalars.setValue(i + frameStart, 1);
+                    }
+                    else {
+                        scalars.setValue(i, 0);
+                    }
+                }
+                const mSquares = vtkImageMarchingSquares.newInstance({
+                    slice: sliceIndex,
+                });
+                const imageDataCopy = vtkImageData.newInstance();
+                imageDataCopy.shallowCopy(vol.imageData);
+                imageDataCopy.getPointData().setScalars(scalars);
+                mSquares.setInputData(imageDataCopy);
+                const cValues = [1];
+                mSquares.setContourValues(cValues);
+                mSquares.setMergePoints(false);
+                const msOutput = mSquares.getOutputData();
+                const reducedSet = getDeduplicatedVTKPolyDataPoints(msOutput);
+                if (reducedSet.points?.length) {
+                    const contours = findContoursFromReducedSet(reducedSet.lines);
+                    sliceContours.push({
+                        contours,
+                        polyData: reducedSet,
+                        FrameNumber: sliceIndex + 1,
+                        sliceIndex,
+                        FrameOfReferenceUID,
+                    });
+                }
+            }
+            catch (e) {
+                console.warn(sliceIndex);
+                console.warn(e);
+            }
+        }
+        const metadata = {
+            FrameOfReferenceUID,
+        };
+        const ContourSet = {
+            label: segment.label,
+            color: segment.color,
+            metadata,
+            sliceContours,
+        };
+        ContourSets.push(ContourSet);
+    }
+    return ContourSets;
+}
+function isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex) {
+    const startIdx = sliceIndex * pixelsPerSlice;
+    const endIdx = startIdx + pixelsPerSlice;
+    for (let i = startIdx; i < endIdx; i++) {
+        if (voxelManager.getAtIndex(i) === segIndex) {
+            return false;
+        }
+    }
+    return true;
+}
+export { generateContourSetsFromLabelmap };

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types';
+export default function getContourHolesDataCanvas(annotation: Annotation, viewport: Types.IViewport): Types.Point2[][];

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

@@ -0,0 +1,14 @@
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+export default function getContourHolesDataCanvas(annotation, viewport) {
+    const worldHoleContours = getContourHolesDataWorld(annotation);
+    const canvasHoleContours = [];
+    worldHoleContours.forEach((worldHoleContour) => {
+        const numPoints = worldHoleContour.length;
+        const canvasHoleContour = new Array(numPoints);
+        for (let i = 0; i < numPoints; i++) {
+            canvasHoleContour[i] = viewport.worldToCanvas(worldHoleContour[i]);
+        }
+        canvasHoleContours.push(canvasHoleContour);
+    });
+    return canvasHoleContours;
+}

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types';
+export default function getContourHolesDataWorld(annotation: Annotation): Types.Point3[][];

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

@@ -0,0 +1,5 @@
+import { getAnnotation } from '../../stateManagement/annotation/annotationState';
+export default function getContourHolesDataWorld(annotation) {
+    const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
+    return childAnnotationUIDs.map((uid) => getAnnotation(uid).data.contour.polyline);
+}

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

@@ -0,0 +1,11 @@
+export declare function getDeduplicatedVTKPolyDataPoints(polyData: any, bypass?: boolean): {
+    points: any[];
+    lines: {
+        a: any;
+        b: any;
+    }[];
+};
+declare const _default: {
+    getDeduplicatedVTKPolyDataPoints: typeof getDeduplicatedVTKPolyDataPoints;
+};
+export default _default;

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

@@ -0,0 +1,45 @@
+export function getDeduplicatedVTKPolyDataPoints(polyData, bypass = false) {
+    const points = polyData.getPoints();
+    const lines = polyData.getLines();
+    const pointsArray = new Array(points.getNumberOfPoints())
+        .fill(0)
+        .map((_, i) => points.getPoint(i).slice());
+    const linesArray = new Array(lines.getNumberOfCells()).fill(0).map((_, i) => {
+        const cell = lines.getCell(i * 3).slice();
+        return { a: cell[0], b: cell[1] };
+    });
+    if (bypass) {
+        return { points: pointsArray, lines: linesArray };
+    }
+    const newPoints = [];
+    for (const [i, pt] of pointsArray.entries()) {
+        const index = newPoints.findIndex((point) => point[0] === pt[0] && point[1] === pt[1] && point[2] === pt[2]);
+        if (index >= 0) {
+            linesArray.map((line) => {
+                if (line.a === i) {
+                    line.a = index;
+                }
+                if (line.b === i) {
+                    line.b = index;
+                }
+                return line;
+            });
+        }
+        else {
+            const newIndex = newPoints.length;
+            newPoints.push(pt);
+            linesArray.map((line) => {
+                if (line.a === i) {
+                    line.a = newIndex;
+                }
+                if (line.b === i) {
+                    line.b = newIndex;
+                }
+                return line;
+            });
+        }
+    }
+    const newLines = linesArray.filter((line) => line.a !== line.b);
+    return { points: newPoints, lines: newLines };
+}
+export default { getDeduplicatedVTKPolyDataPoints };

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

@@ -0,0 +1,13 @@
+import areCoplanarContours from './areCoplanarContours';
+import contourFinder from './contourFinder';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
+import detectContourHoles from './detectContourHoles';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
+import AnnotationToPointData from './AnnotationToPointData';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas';
+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, };

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

@@ -0,0 +1,13 @@
+import areCoplanarContours from './areCoplanarContours';
+import contourFinder from './contourFinder';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
+import detectContourHoles from './detectContourHoles';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
+import AnnotationToPointData from './AnnotationToPointData';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas';
+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, };

package/dist/esm/utilities/contours/interpolation/acceptAutogeneratedInterpolations.d.ts

@@ -0,0 +1,3 @@
+import type { AcceptInterpolationSelector } from '../../../types/InterpolationTypes';
+import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector';
+export default function acceptAutogeneratedInterpolations(annotationGroupSelector: AnnotationGroupSelector, selector: AcceptInterpolationSelector): void;

package/dist/esm/utilities/contours/interpolation/acceptAutogeneratedInterpolations.js

@@ -0,0 +1,4 @@
+import InterpolationManager from '../../segmentation/InterpolationManager/InterpolationManager';
+export default function acceptAutogeneratedInterpolations(annotationGroupSelector, selector) {
+    InterpolationManager.acceptAutoGenerated(annotationGroupSelector, selector);
+}

package/dist/esm/utilities/contours/interpolation/createPolylineToolData.d.ts

@@ -0,0 +1,2 @@
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+export default function createPolylineToolData(polyline: any, handlePoints: any, referencedToolData: any): InterpolationROIAnnotation;

package/dist/esm/utilities/contours/interpolation/createPolylineToolData.js

@@ -0,0 +1,38 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+export default function createPolylineToolData(polyline, handlePoints, referencedToolData) {
+    const annotation = csUtils.deepMerge({
+        data: {},
+        metadata: {},
+    }, referencedToolData);
+    Object.assign(annotation, {
+        highlighted: false,
+        invalidated: true,
+        autoGenerated: true,
+        annotationUID: undefined,
+        cachedStats: {},
+        childAnnotationUIDs: [],
+        parentAnnotationUID: undefined,
+    });
+    Object.assign(annotation.data, {
+        handles: {
+            points: handlePoints.points || handlePoints || [],
+            interpolationSources: handlePoints.sources,
+            activeHandleIndex: null,
+            textBox: {
+                hasMoved: false,
+                worldPosition: [0, 0, 0],
+                worldBoundingBox: {
+                    topLeft: [0, 0, 0],
+                    topRight: [0, 0, 0],
+                    bottomLeft: [0, 0, 0],
+                    bottomRight: [0, 0, 0],
+                },
+            },
+        },
+        contour: {
+            ...referencedToolData.data.contour,
+            polyline,
+        },
+    });
+    return annotation;
+}

package/dist/esm/utilities/contours/interpolation/findAnnotationForInterpolation.d.ts

@@ -0,0 +1,7 @@
+import type { InterpolationViewportData, Annotation } from '../../../types';
+export type ContourPair = [number, number];
+declare function findAnnotationsForInterpolation(toolData: any, viewportData: InterpolationViewportData): {
+    interpolationData: Map<number, Annotation[]>;
+    interpolationList: any[];
+};
+export default findAnnotationsForInterpolation;

package/dist/esm/utilities/contours/interpolation/findAnnotationForInterpolation.js

@@ -0,0 +1,106 @@
+import getInterpolationData from './getInterpolationData';
+function findAnnotationsForInterpolation(toolData, viewportData) {
+    const interpolationData = getInterpolationData(viewportData, [
+        {
+            key: 'interpolationUID',
+            value: viewportData.interpolationUID,
+        },
+    ]);
+    const rangeToInterpolate = getRangeToInterpolate(interpolationData);
+    if (!rangeToInterpolate) {
+        console.warn('No annotations found to interpolate', interpolationData);
+        return;
+    }
+    const sliceEdited = _getSlicePositionOfToolData(interpolationData, toolData.annotationUID);
+    const interpolationList = [];
+    for (let i = rangeToInterpolate[0] + 1; i < rangeToInterpolate[1]; i++) {
+        if (_sliceNeedsInterpolating(interpolationData, i)) {
+            const contourPair = _getBoundingPair(i, rangeToInterpolate, interpolationData);
+            if (contourPair?.[0] === sliceEdited ||
+                contourPair?.[1] === sliceEdited) {
+                _appendInterpolationList(contourPair, interpolationList, i);
+            }
+        }
+    }
+    return {
+        interpolationData,
+        interpolationList,
+    };
+}
+function getRangeToInterpolate(interpolationData) {
+    let first = Infinity;
+    let last = -Infinity;
+    let found = false;
+    for (const [sliceIndex, annotations] of interpolationData.entries()) {
+        if (annotations.length) {
+            first = Math.min(sliceIndex, first);
+            last = Math.max(sliceIndex, last);
+            found = true;
+        }
+    }
+    if (!found) {
+        return;
+    }
+    return [first, last];
+}
+function _getSlicePositionOfToolData(interpolationData, annotationUID) {
+    for (const [sliceIndex, annotations] of interpolationData) {
+        for (let j = 0; j < annotations.length; j++) {
+            if (annotations[j].annotationUID === annotationUID) {
+                return sliceIndex;
+            }
+        }
+    }
+    return;
+}
+function _sliceNeedsInterpolating(interpolationData, sliceIndex) {
+    const annotations = interpolationData.get(sliceIndex);
+    return (!annotations?.length ||
+        (annotations.length === 1 && annotations[0].autoGenerated));
+}
+function _appendInterpolationList(contourPair, interpolationList, itemIndex) {
+    const [startIndex] = contourPair;
+    interpolationList[startIndex] ||= {
+        pair: contourPair,
+        list: [],
+    };
+    interpolationList[startIndex].list.push(itemIndex);
+}
+function _getBoundingPair(sliceIndex, sliceRange, interpolationData) {
+    const annotationPair = [];
+    let canInterpolate = true;
+    for (let i = sliceIndex - 1; i >= sliceRange[0]; i--) {
+        const annotations = interpolationData.get(i);
+        if (annotations?.length) {
+            if (annotations[0].autoGenerated) {
+                continue;
+            }
+            if (annotations.length > 1) {
+                canInterpolate = false;
+            }
+            annotationPair.push(i);
+            break;
+        }
+    }
+    if (!canInterpolate || !annotationPair.length) {
+        return;
+    }
+    for (let i = sliceIndex + 1; i <= sliceRange[1]; i++) {
+        const annotations = interpolationData.get(i);
+        if (annotations?.length) {
+            if (annotations[0].autoGenerated) {
+                continue;
+            }
+            if (annotations.length > 1) {
+                canInterpolate = false;
+            }
+            annotationPair.push(i);
+            break;
+        }
+    }
+    if (!canInterpolate || annotationPair.length < 2) {
+        return;
+    }
+    return annotationPair;
+}
+export default findAnnotationsForInterpolation;

package/dist/esm/utilities/contours/interpolation/getInterpolationData.d.ts

@@ -0,0 +1,7 @@
+import type { InterpolationViewportData, Annotation } from '../../../types';
+export type FilterParam = {
+    parentKey?: (annotation: Annotation) => unknown;
+    key: string;
+    value: unknown;
+};
+export default function getInterpolationData(viewportData: InterpolationViewportData, filterParams?: any[]): Map<number, Annotation[]>;

package/dist/esm/utilities/contours/interpolation/getInterpolationData.js

@@ -0,0 +1,47 @@
+import { getAnnotations } from '../../../stateManagement/annotation/annotationState';
+const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
+export default function getInterpolationData(viewportData, filterParams = []) {
+    const { viewport, sliceData, annotation } = viewportData;
+    const interpolationDatas = new Map();
+    const { toolName, originalToolName } = annotation.metadata;
+    const testToolName = originalToolName || toolName;
+    const annotations = (getAnnotations(testToolName, viewport.element) || []).filter((annotation) => !annotation.metadata.originalToolName ||
+        annotation.metadata.originalToolName === testToolName);
+    if (testToolName !== DEFAULT_CONTOUR_SEG_TOOLNAME) {
+        const modifiedAnnotations = getAnnotations(DEFAULT_CONTOUR_SEG_TOOLNAME, viewport.element);
+        if (modifiedAnnotations?.length) {
+            modifiedAnnotations.forEach((annotation) => {
+                const { metadata } = annotation;
+                if (metadata.originalToolName === testToolName &&
+                    metadata.originalToolName !== metadata.toolName) {
+                    annotations.push(annotation);
+                }
+            });
+        }
+    }
+    if (!annotations?.length) {
+        return interpolationDatas;
+    }
+    for (let i = 0; i < sliceData.numberOfSlices; i++) {
+        const imageAnnotations = annotations.filter((x) => x.metadata.sliceIndex === i);
+        if (!imageAnnotations?.length) {
+            continue;
+        }
+        const filteredInterpolatedAnnotations = imageAnnotations.filter((imageAnnotation) => {
+            return filterParams.every((x) => {
+                const parent = x.parentKey
+                    ? x.parentKey(imageAnnotation)
+                    : imageAnnotation;
+                const value = parent?.[x.key];
+                if (Array.isArray(value)) {
+                    return value.every((item, index) => item === x.value[index]);
+                }
+                return value === x.value;
+            });
+        });
+        if (filteredInterpolatedAnnotations.length) {
+            interpolationDatas.set(i, filteredInterpolatedAnnotations);
+        }
+    }
+    return interpolationDatas;
+}

package/dist/esm/utilities/contours/interpolation/getInterpolationDataCollection.d.ts

@@ -0,0 +1,4 @@
+import type { InterpolationViewportData } from '../../../types';
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { FilterParam } from './getInterpolationData';
+export default function getInterpolationDataCollection(viewportData: InterpolationViewportData, filterParams: FilterParam[]): InterpolationROIAnnotation[];

package/dist/esm/utilities/contours/interpolation/getInterpolationDataCollection.js

@@ -0,0 +1,14 @@
+import getInterpolationData from './getInterpolationData';
+export default function getInterpolationDataCollection(viewportData, filterParams) {
+    const imageAnnotations = getInterpolationData(viewportData, filterParams);
+    const interpolatedDataCollection = [];
+    if (!imageAnnotations?.size) {
+        return interpolatedDataCollection;
+    }
+    for (const annotations of imageAnnotations.values()) {
+        annotations.forEach((annotation) => {
+            interpolatedDataCollection.push(annotation);
+        });
+    }
+    return interpolatedDataCollection;
+}

package/dist/esm/utilities/contours/interpolation/interpolate.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import type { InterpolationViewportData } from '../../../types/InterpolationTypes';
+export type PointsXYZI = Types.PointsXYZ & {
+    I?: boolean[];
+    kIndex?: number;
+};
+export type PointsArray3 = Types.IPointsManager<Types.Point3> & {
+    I?: boolean[];
+};
+declare function interpolate(viewportData: InterpolationViewportData): void;
+export default interpolate;