@cornerstonejs/tools 3.5.3 → 3.6.0

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

@@ -0,0 +1,38 @@
+export declare const triggerWorkerProgress: (workerType: any, progress: any) => void;
+export declare const getSegmentationDataForWorker: (segmentationId: any, segmentIndices: any) => {
+    operationData: {
+        segmentationId: any;
+        volumeId: string;
+        imageIds: string[];
+    };
+    segVolumeId: string;
+    segImageIds: string[];
+    reconstructableVolume: boolean;
+    indices: any;
+};
+export declare const prepareVolumeStrategyDataForWorker: (operationData: any) => {
+    segmentationImageData: any;
+    segmentationScalarData: any;
+    imageScalarData: any;
+    segmentationVoxelManager: any;
+    imageVoxelManager: any;
+    imageData: any;
+};
+export declare const prepareImageInfo: (imageVoxelManager: any, imageData: any) => {
+    scalarData: any;
+    dimensions: any;
+    spacing: any;
+    origin: any;
+    direction: any;
+};
+export declare const prepareStackDataForWorker: (segImageIds: any) => {
+    segmentationInfo: any[];
+    imageInfo: any[];
+};
+export declare const getImageReferenceInfo: (segVolumeId: any, segImageIds: any) => {
+    refImageId: any;
+    modalityUnitOptions: {
+        isPreScaled: boolean;
+        isSuvScaled: boolean;
+    };
+};

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

@@ -0,0 +1,125 @@
+import { cache, utilities, eventTarget, Enums, triggerEvent, metaData, } from '@cornerstonejs/core';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { getStrategyData } from '../../tools/segmentation/strategies/utils/getStrategyData';
+import ensureSegmentationVolume from '../../tools/segmentation/strategies/compositions/ensureSegmentationVolume';
+import ensureImageVolume from '../../tools/segmentation/strategies/compositions/ensureImageVolume';
+export const triggerWorkerProgress = (workerType, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: workerType,
+    });
+};
+export const getSegmentationDataForWorker = (segmentationId, segmentIndices) => {
+    const segmentation = getSegmentation(segmentationId);
+    const { representationData } = segmentation;
+    const { Labelmap } = representationData;
+    if (!Labelmap) {
+        console.debug('No labelmap found for segmentation', segmentationId);
+        return null;
+    }
+    const segVolumeId = Labelmap.volumeId;
+    const segImageIds = Labelmap.imageIds;
+    const operationData = {
+        segmentationId,
+        volumeId: segVolumeId,
+        imageIds: segImageIds,
+    };
+    let reconstructableVolume = false;
+    if (segImageIds) {
+        const refImageIds = segImageIds.map((imageId) => {
+            const image = cache.getImage(imageId);
+            return image.referencedImageId;
+        });
+        reconstructableVolume = utilities.isValidVolume(refImageIds);
+    }
+    let indices = segmentIndices;
+    if (!indices) {
+        indices = [getActiveSegmentIndex(segmentationId)];
+    }
+    else if (!Array.isArray(indices)) {
+        indices = [indices, 255];
+    }
+    return {
+        operationData,
+        segVolumeId,
+        segImageIds,
+        reconstructableVolume,
+        indices,
+    };
+};
+export const prepareVolumeStrategyDataForWorker = (operationData) => {
+    return getStrategyData({
+        operationData,
+        strategy: {
+            ensureSegmentationVolumeFor3DManipulation: ensureSegmentationVolume.ensureSegmentationVolumeFor3DManipulation,
+            ensureImageVolumeFor3DManipulation: ensureImageVolume.ensureImageVolumeFor3DManipulation,
+        },
+    });
+};
+export const prepareImageInfo = (imageVoxelManager, imageData) => {
+    const imageScalarData = imageVoxelManager.getCompleteScalarDataArray();
+    return {
+        scalarData: imageScalarData,
+        dimensions: imageData.getDimensions(),
+        spacing: imageData.getSpacing(),
+        origin: imageData.getOrigin(),
+        direction: imageData.getDirection(),
+    };
+};
+export const prepareStackDataForWorker = (segImageIds) => {
+    const segmentationInfo = [];
+    const imageInfo = [];
+    for (const segImageId of segImageIds) {
+        const segImage = cache.getImage(segImageId);
+        const segPixelData = segImage.getPixelData();
+        const { origin, direction, spacing, dimensions } = utilities.getImageDataMetadata(segImage);
+        segmentationInfo.push({
+            scalarData: segPixelData,
+            dimensions,
+            spacing,
+            origin,
+            direction,
+        });
+        const refImageId = segImage.referencedImageId;
+        if (refImageId) {
+            const refImage = cache.getImage(refImageId);
+            const refPixelData = refImage.getPixelData();
+            const refVoxelManager = refImage.voxelManager;
+            const refSpacing = [
+                refImage.rowPixelSpacing,
+                refImage.columnPixelSpacing,
+            ];
+            imageInfo.push({
+                scalarData: refPixelData,
+                dimensions: refVoxelManager
+                    ? refVoxelManager.dimensions
+                    : [refImage.columns, refImage.rows, 1],
+                spacing: refSpacing,
+            });
+        }
+    }
+    return { segmentationInfo, imageInfo };
+};
+export const getImageReferenceInfo = (segVolumeId, segImageIds) => {
+    let refImageId;
+    if (segVolumeId) {
+        const segmentationVolume = cache.getVolume(segVolumeId);
+        const imageIds = segmentationVolume.imageIds;
+        const cachedImage = cache.getImage(imageIds[0]);
+        if (cachedImage) {
+            refImageId = cachedImage.referencedImageId;
+        }
+    }
+    else if (segImageIds?.length) {
+        const segImage = cache.getImage(segImageIds[0]);
+        refImageId = segImage.referencedImageId;
+    }
+    const refImage = cache.getImage(refImageId);
+    const scalingModule = metaData.get('scalingModule', refImageId);
+    const modalityUnitOptions = {
+        isPreScaled: Boolean(refImage.preScale?.scaled),
+        isSuvScaled: typeof scalingModule?.suvbw === 'number',
+    };
+    return { refImageId, modalityUnitOptions };
+};

package/dist/esm/workers/computeWorker.js

@@ -1,27 +1,44 @@
 import { expose } from 'comlink';
 import { utilities } from '@cornerstonejs/core';
 import SegmentStatsCalculator from '../utilities/segmentation/SegmentStatsCalculator';
+import { getSegmentLargestBidirectional } from '../utilities/segmentation';
+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 '../utilities/contours/getDeduplicatedVTKPolyDataPoints';
+import { findContoursFromReducedSet } from '../utilities/contours/contourFinder';
+import { createBidirectionalForSlice } from '../utilities/segmentation/findLargestBidirectional';
+import { createIsInSegmentMetadata } from '../utilities/segmentation/isLineInSegment';
 const { VoxelManager } = utilities;
 const computeWorker = {
-    calculateSegmentsStatisticsVolume: (args) => {
-        const { segmentationInfo, imageInfo, indices, mode } = args;
-        const { scalarData: segmentationScalarData, dimensions: segmentationDimensions, spacing: segmentationSpacing, } = segmentationInfo;
-        const { scalarData: imageScalarData, dimensions: imageDimensions } = imageInfo;
-        if (segmentationDimensions[0] !== imageDimensions[0] ||
-            segmentationDimensions[1] !== imageDimensions[1] ||
-            segmentationDimensions[2] !== imageDimensions[2]) {
-            throw new Error('Dimensions do not match to calculate statistics, different dimensions not supported yet');
-        }
-        const segVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
-            dimensions: segmentationDimensions,
-            scalarData: segmentationScalarData,
-        });
-        const imageVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
-            dimensions: imageDimensions,
-            scalarData: imageScalarData,
+    createVoxelManager: (dimensions, scalarData) => {
+        return VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData,
         });
-        SegmentStatsCalculator.statsInit({ storePointData: false, indices, mode });
-        segVoxelManager.forEach(({ value, pointIJK, index }) => {
+    },
+    createDataStructure: (info) => {
+        const { scalarData, dimensions, spacing, origin, direction } = info;
+        const voxelManager = computeWorker.createVoxelManager(dimensions, scalarData);
+        return {
+            voxelManager,
+            dimensions,
+            spacing,
+            origin,
+            direction,
+            scalarData,
+        };
+    },
+    createVTKImageData: (dimensions, origin, direction, spacing) => {
+        const imageData = vtkImageData.newInstance();
+        imageData.setDimensions(dimensions);
+        imageData.setOrigin(origin);
+        imageData.setDirection(direction);
+        imageData.setSpacing(spacing);
+        return imageData;
+    },
+    processSegmentStatistics: (segVoxelManager, imageVoxelManager, indices, bounds) => {
+        segVoxelManager.forEach(({ value, pointIJK, pointLPS, index }) => {
             if (indices.indexOf(value) === -1) {
                 return;
             }
@@ -30,10 +47,60 @@ const computeWorker = {
                 segmentIndex: value,
                 value: imageValue,
                 pointIJK,
+                pointLPS,
             });
         }, {
-            boundsIJK: imageVoxelManager.getDefaultBounds(),
+            boundsIJK: bounds || imageVoxelManager.getDefaultBounds(),
         });
+    },
+    performMarchingSquares: (imageData, sliceIndex = null, slicingMode = null) => {
+        const options = {};
+        if (sliceIndex !== null) {
+            options.slice = sliceIndex;
+        }
+        if (slicingMode !== null) {
+            options.slicingMode = slicingMode;
+        }
+        const mSquares = vtkImageMarchingSquares.newInstance(options);
+        mSquares.setInputData(imageData);
+        mSquares.setContourValues([1]);
+        mSquares.setMergePoints(false);
+        return mSquares.getOutputData();
+    },
+    createContoursFromPolyData: (msOutput, sliceIndex = null) => {
+        const reducedSet = getDeduplicatedVTKPolyDataPoints(msOutput);
+        if (reducedSet.points?.length) {
+            const contours = findContoursFromReducedSet(reducedSet.lines);
+            return {
+                contours,
+                polyData: reducedSet,
+            };
+        }
+        return null;
+    },
+    createSegmentsFromIndices: (indices) => {
+        return [null, ...indices.map((index) => ({ segmentIndex: index }))];
+    },
+    getArgsFromInfo: (args) => {
+        const { segmentationInfo, imageInfo } = args;
+        const getSegmentationData = () => {
+            return computeWorker.createDataStructure(segmentationInfo);
+        };
+        const getImageData = () => {
+            return computeWorker.createDataStructure(imageInfo);
+        };
+        return {
+            segmentation: segmentationInfo && getSegmentationData(),
+            image: imageInfo && getImageData(),
+        };
+    },
+    calculateSegmentsStatisticsVolume: (args) => {
+        const { mode, indices } = args;
+        const { segmentation, image } = computeWorker.getArgsFromInfo(args);
+        const { voxelManager: segVoxelManager, spacing: segmentationSpacing } = segmentation;
+        const { voxelManager: imageVoxelManager } = image;
+        SegmentStatsCalculator.statsInit({ storePointData: false, indices, mode });
+        computeWorker.processSegmentStatistics(segVoxelManager, imageVoxelManager, indices);
         const stats = SegmentStatsCalculator.getStatistics({
             spacing: segmentationSpacing,
             unit: 'mm',
@@ -52,27 +119,9 @@ const computeWorker = {
                 segInfo.dimensions[1],
                 1,
             ];
-            const segVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
-                dimensions: segDimensions,
-                scalarData: segInfo.scalarData,
-            });
-            const imageVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
-                dimensions: segDimensions,
-                scalarData: imgInfo.scalarData,
-            });
-            segVoxelManager.forEach(({ value, pointIJK, index }) => {
-                if (indices.indexOf(value) === -1) {
-                    return;
-                }
-                const imageValue = imageVoxelManager.getAtIndex(index);
-                SegmentStatsCalculator.statsCallback({
-                    segmentIndex: value,
-                    value: imageValue,
-                    pointIJK,
-                });
-            }, {
-                boundsIJK: imageVoxelManager.getDefaultBounds(),
-            });
+            const segVoxelManager = computeWorker.createVoxelManager(segDimensions, segInfo.scalarData);
+            const imageVoxelManager = computeWorker.createVoxelManager(segDimensions, imgInfo.scalarData);
+            computeWorker.processSegmentStatistics(segVoxelManager, imageVoxelManager, indices);
         }
         const spacing = segmentationInfo[0].spacing;
         const stats = SegmentStatsCalculator.getStatistics({
@@ -81,5 +130,200 @@ const computeWorker = {
         });
         return stats;
     },
+    getSegmentLargestBidirectionalInternal: (args) => {
+        const { segmentationInfo, imageInfo, indices, mode, isStack } = args;
+        let segmentation;
+        if (!isStack) {
+            ({ segmentation } = computeWorker.getArgsFromInfo(args));
+        }
+        else {
+            ({ segmentation } = computeWorker.getArgsFromInfo({
+                segmentationInfo: segmentationInfo[0],
+            }));
+        }
+        const { voxelManager, dimensions, origin, direction, spacing } = segmentation;
+        const stackDimensions = isStack
+            ? [dimensions[0], dimensions[1], 2]
+            : dimensions;
+        const stackSpacing = isStack ? [spacing[0], spacing[1], 1] : spacing;
+        const imageData = computeWorker.createVTKImageData(stackDimensions, origin, direction, stackSpacing);
+        let contourSets;
+        if (!isStack) {
+            contourSets = computeWorker.generateContourSetsFromLabelmapVolume({
+                segmentation,
+                indices,
+                imageData,
+                mode,
+            });
+        }
+        else {
+            contourSets = computeWorker.generateContourSetsFromLabelmapStack({
+                segmentationInfo,
+                indices,
+                mode,
+            });
+        }
+        const bidirectionalData = [];
+        for (let i = 0; i < contourSets.length; i++) {
+            const contourSet = contourSets[i];
+            const { segmentIndex } = contourSet.segment;
+            const contours = contourSet.sliceContours;
+            let maxBidirectional;
+            const isInSegment = createIsInSegmentMetadata({
+                dimensions,
+                imageData,
+                voxelManager,
+                segmentIndex,
+            });
+            for (const sliceContour of contours) {
+                const bidirectional = createBidirectionalForSlice(sliceContour, isInSegment, maxBidirectional);
+                if (!bidirectional) {
+                    continue;
+                }
+                maxBidirectional = bidirectional;
+            }
+            if (maxBidirectional) {
+                bidirectionalData.push({
+                    segmentIndex,
+                    majorAxis: maxBidirectional.majorAxis,
+                    minorAxis: maxBidirectional.minorAxis,
+                    maxMajor: maxBidirectional.maxMajor,
+                    maxMinor: maxBidirectional.maxMinor,
+                });
+            }
+        }
+        return bidirectionalData;
+    },
+    generateContourSetsFromLabelmapVolume: (args) => {
+        const { segmentation, indices, imageData } = args;
+        const { voxelManager, dimensions, scalarData, origin, direction, spacing } = segmentation;
+        const numSlices = dimensions[2];
+        const pixelsPerSlice = dimensions[0] * dimensions[1];
+        const segments = computeWorker.createSegmentsFromIndices(indices);
+        for (let z = 0; z < numSlices; z++) {
+            for (let y = 0; y < dimensions[1]; y++) {
+                const index = y * dimensions[0] + z * pixelsPerSlice;
+                scalarData[index] = 0;
+                scalarData[index + dimensions[0] - 1] = 0;
+            }
+        }
+        const ContourSets = [];
+        const numSegments = segments.length;
+        for (let segIndex = 0; segIndex < numSegments; segIndex++) {
+            const segment = segments[segIndex];
+            if (!segment) {
+                continue;
+            }
+            const segmentIndex = segment.segmentIndex;
+            const sliceContours = [];
+            const scalars = vtkDataArray.newInstance({
+                name: 'Scalars',
+                numberOfComponents: 1,
+                size: pixelsPerSlice * numSlices,
+                dataType: 'Uint8Array',
+            });
+            for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
+                if (computeWorker.isSliceEmptyForSegmentVolume(sliceIndex, scalarData, pixelsPerSlice, segmentIndex)) {
+                    continue;
+                }
+                const frameStart = sliceIndex * pixelsPerSlice;
+                try {
+                    for (let i = 0; i < pixelsPerSlice; i++) {
+                        const value = scalarData[i + frameStart];
+                        if (value === segmentIndex) {
+                            scalars.setValue(i + frameStart, 1);
+                        }
+                        else {
+                            scalars.setValue(i, 0);
+                        }
+                    }
+                    const imageDataCopy = vtkImageData.newInstance();
+                    imageDataCopy.shallowCopy(imageData);
+                    imageDataCopy.getPointData().setScalars(scalars);
+                    const msOutput = computeWorker.performMarchingSquares(imageDataCopy, sliceIndex);
+                    const contourData = computeWorker.createContoursFromPolyData(msOutput, sliceIndex);
+                    if (contourData) {
+                        sliceContours.push(contourData);
+                    }
+                }
+                catch (e) {
+                    console.warn(sliceIndex);
+                    console.warn(e);
+                }
+            }
+            const ContourSet = {
+                sliceContours,
+                segment,
+            };
+            ContourSets.push(ContourSet);
+        }
+        return ContourSets;
+    },
+    generateContourSetsFromLabelmapStack: (args) => {
+        const { segmentationInfo, indices } = args;
+        let ContourSets = [];
+        for (let i = 0; i < segmentationInfo.length; i++) {
+            const segInfo = segmentationInfo[i];
+            const dimensions = segInfo.dimensions;
+            const segScalarData = segInfo.scalarData;
+            const { spacing, direction, origin } = segInfo;
+            const segments = computeWorker.createSegmentsFromIndices(indices);
+            const pixelsPerSlice = dimensions[0] * dimensions[1];
+            const numSegments = segments.length;
+            for (let segIndex = 0; segIndex < numSegments; segIndex++) {
+                const segment = segments[segIndex];
+                if (!segment) {
+                    continue;
+                }
+                const segmentIndex = segment.segmentIndex;
+                if (computeWorker.isSliceEmptyForSegmentVolume(0, segScalarData, pixelsPerSlice, segmentIndex)) {
+                    continue;
+                }
+                const sliceContours = [];
+                const filteredData = new Uint8Array(segScalarData.length);
+                for (let i = 0; i < segScalarData.length; i++) {
+                    if (segScalarData[i] === segmentIndex) {
+                        filteredData[i] = 1;
+                    }
+                    else {
+                        filteredData[i] = 0;
+                    }
+                }
+                const scalarArray = vtkDataArray.newInstance({
+                    name: 'Pixels',
+                    numberOfComponents: 1,
+                    values: filteredData,
+                });
+                const imageData = computeWorker.createVTKImageData(dimensions, origin, direction, [spacing[0], spacing[1], 1]);
+                imageData.getPointData().setScalars(scalarArray);
+                try {
+                    const msOutput = computeWorker.performMarchingSquares(imageData, null, 2);
+                    const contourData = computeWorker.createContoursFromPolyData(msOutput);
+                    if (contourData) {
+                        sliceContours.push(contourData);
+                    }
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+                const ContourSet = {
+                    sliceContours,
+                    segment,
+                };
+                ContourSets.push(ContourSet);
+            }
+        }
+        return ContourSets;
+    },
+    isSliceEmptyForSegmentVolume: (sliceIndex, segData, pixelsPerSlice, segIndex) => {
+        const startIdx = sliceIndex * pixelsPerSlice;
+        const endIdx = startIdx + pixelsPerSlice;
+        for (let i = startIdx; i < endIdx; i++) {
+            if (segData[i] === segIndex) {
+                return false;
+            }
+        }
+        return true;
+    },
 };
 expose(computeWorker);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.5.3",
+    "@cornerstonejs/core": "^3.6.0",
     "@kitware/vtk.js": "32.12.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "42ffdeabf1ed0bd2871db808bf198d5e3f4f4c94"
+  "gitHead": "480e48c2a25ce79a4a90be6fe180d1bcdd1b831e"
 }