@cornerstonejs/tools 2.0.0-beta.22 → 2.0.0-beta.24

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

@@ -1,12 +1,14 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
+        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, segmentationId, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
+        let changed = false;
         if (segmentIndex === null) {
             const oldValue = previewVoxelManager.getAtIndex(index);
             if (oldValue !== undefined) {
-                previewVoxelManager.setAtIndex(index, oldValue);
+                changed = previewVoxelManager.setAtIndex(index, oldValue);
             }
             return;
         }
@@ -15,13 +17,13 @@ export default {
         }
         if (existingValue === previewSegmentIndex) {
             if (previewVoxelManager.getAtIndex(index) === undefined) {
-                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+                changed = segmentationVoxelManager.setAtIndex(index, segmentIndex);
             }
             else {
                 return;
             }
         }
         const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
-        previewVoxelManager.setAtIndex(index, useSegmentIndex);
+        changed = previewVoxelManager.setAtIndex(index, useSegmentIndex);
     },
 };

package/dist/esm/tools/segmentation/strategies/fillSphere.js

@@ -21,20 +21,11 @@ const sphereComposition = {
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
         const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfo(points.slice(0, 2), segmentationImageData, viewport);
         segmentationVoxelManager.boundsIJK = newBoundsIJK;
-        if (imageVoxelManager) {
-            imageVoxelManager.isInObject = createEllipseInPoint({
-                topLeftWorld,
-                bottomRightWorld,
-                center,
-            });
-        }
-        else {
-            segmentationVoxelManager.isInObject = createEllipseInPoint({
-                topLeftWorld,
-                bottomRightWorld,
-                center,
-            });
-        }
+        segmentationVoxelManager.isInObject = createEllipseInPoint({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
     },
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview);

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

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
@@ -11,6 +12,10 @@ type LabelmapToolOperationData = {
     segmentationRepresentationUID: string;
     points: Types.Point3[];
     voxelManager: any;
+    override: {
+        voxelManager: Types.IVoxelManager<number>;
+        imageData: vtkImageData;
+    };
     preview: any;
     toolGroupId: string;
 };

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

@@ -7,7 +7,7 @@ export interface ROICachedStats {
     [targetId: string]: {
         Modality: string;
         area: number;
-        areaUnits: string;
+        areaUnit: string;
         max: number;
         mean: number;
         stdDev: number;
@@ -130,7 +130,7 @@ export type SplineROIAnnotation = ContourAnnotation & {
             [targetId: string]: {
                 Modality: string;
                 area: number;
-                areaUnits: string;
+                areaUnit: string;
             };
         };
     };

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

@@ -15,13 +15,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         return;
     }
     const numSlices = vol.dimensions[2];
-    const segData = vol.imageData.getPointData().getScalars().getData();
+    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;
-            segData[index] = 0;
-            segData[index + vol.dimensions[0] - 1] = 0;
+            voxelManager.setAtIndex(index, 0);
+            voxelManager.setAtIndex(index + vol.dimensions[0] - 1, 0);
         }
     }
     const ContourSets = [];
@@ -41,13 +41,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         });
         const { containedSegmentIndices } = segment;
         for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
-            if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
+            if (isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex)) {
                 continue;
             }
             const frameStart = sliceIndex * pixelsPerSlice;
             try {
                 for (let i = 0; i < pixelsPerSlice; i++) {
-                    const value = segData[i + frameStart];
+                    const value = voxelManager.getAtIndex(i + frameStart);
                     if (value === segIndex || containedSegmentIndices?.has(value)) {
                         scalars.setValue(i + frameStart, 1);
                     }
@@ -96,11 +96,11 @@ function generateContourSetsFromLabelmap({ segmentations }) {
     }
     return ContourSets;
 }
-function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+function isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex) {
     const startIdx = sliceIndex * pixelsPerSlice;
     const endIdx = startIdx + pixelsPerSlice;
     for (let i = startIdx; i < endIdx; i++) {
-        if (segData[i] === segIndex) {
+        if (voxelManager.getAtIndex(i) === segIndex) {
             return false;
         }
     }

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

@@ -1,6 +1,6 @@
 declare const getCalibratedLengthUnitsAndScale: (image: any, handles: any) => {
-    lengthUnits: string;
-    areaUnits: string;
+    unit: string;
+    areaUnit: string;
     scale: number;
 };
 declare const getCalibratedProbeUnitsAndValue: (image: any, handles: any) => {

package/dist/esm/utilities/getCalibratedUnits.js

@@ -27,16 +27,16 @@ const EPS = 1e-3;
 const SQUARE = '\xb2';
 const getCalibratedLengthUnitsAndScale = (image, handles) => {
     const { calibration, hasPixelSpacing } = image;
-    let lengthUnits = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-    let areaUnits = lengthUnits + SQUARE;
+    let unit = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
+    let areaUnit = unit + SQUARE;
     let scale = 1;
     let calibrationType = '';
     if (!calibration ||
         (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
-        return { lengthUnits, areaUnits, scale };
+        return { unit, areaUnit, scale };
     }
     if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-        return { lengthUnits: PIXEL_UNITS, areaUnits: PIXEL_UNITS + SQUARE, scale };
+        return { unit: PIXEL_UNITS, areaUnit: PIXEL_UNITS + SQUARE, scale };
     }
     if (calibration.sequenceOfUltrasoundRegions) {
         let imageIndex1, imageIndex2;
@@ -57,14 +57,14 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
             imageIndex2[1] >= region.regionLocationMinY0 &&
             imageIndex2[1] <= region.regionLocationMaxY1);
         if (!regions?.length) {
-            return { lengthUnits, areaUnits, scale };
+            return { unit, areaUnit, scale };
         }
         regions = regions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
             SUPPORTED_LENGTH_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
         if (!regions.length) {
             return {
-                lengthUnits: PIXEL_UNITS,
-                areaUnits: PIXEL_UNITS + SQUARE,
+                unit: PIXEL_UNITS,
+                areaUnit: PIXEL_UNITS + SQUARE,
                 scale,
             };
         }
@@ -75,13 +75,13 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         if (isSamePhysicalDelta) {
             scale = 1 / physicalDeltaX;
             calibrationType = 'US Region';
-            lengthUnits = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
-            areaUnits = lengthUnits + SQUARE;
+            unit = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
+            areaUnit = unit + SQUARE;
         }
         else {
             return {
-                lengthUnits: PIXEL_UNITS,
-                areaUnits: PIXEL_UNITS + SQUARE,
+                unit: PIXEL_UNITS,
+                areaUnit: PIXEL_UNITS + SQUARE,
                 scale,
             };
         }
@@ -99,8 +99,8 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         calibrationType = calibration.type;
     }
     return {
-        lengthUnits: lengthUnits + (calibrationType ? ` ${calibrationType}` : ''),
-        areaUnits: areaUnits + (calibrationType ? ` ${calibrationType}` : ''),
+        unit: unit + (calibrationType ? ` ${calibrationType}` : ''),
+        areaUnit: areaUnit + (calibrationType ? ` ${calibrationType}` : ''),
         scale,
     };
 };

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

@@ -4,14 +4,16 @@ import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/
 export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
     const labelmapData = segmentation.representationData.LABELMAP;
-    if (isVolumeSegmentation(labelmapData)) {
+    if (isVolumeSegmentation(labelmapData, viewport)) {
         const { volumeId } = labelmapData;
         const segmentationVolume = cache.getVolume(volumeId);
         if (!segmentationVolume) {
             return;
         }
+        const voxelManager = segmentationVolume.voxelManager;
         const imageData = segmentationVolume.imageData;
-        const segmentIndex = imageData.getScalarValueFromWorld(worldPoint);
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        const segmentIndex = voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
         const canvasPoint = viewport.worldToCanvas(worldPoint);
         const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
         return onEdge ? segmentIndex : undefined;
@@ -69,7 +71,9 @@ function isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, s
     const getNeighborIndex = (deltaI, deltaJ) => {
         const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
         const worldPoint = viewport.canvasToWorld(neighborCanvas);
-        return imageData.getScalarValueFromWorld(worldPoint);
+        const voxelManager = imageData.get('voxelManager').voxelManager;
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        return voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
     };
     return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
 }

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

@@ -25,7 +25,7 @@ function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
         console.warn(`No volume found for ${segVolumeId}`);
         return;
     }
-    const segData = vol.imageData.getPointData().getScalars().getData();
+    const voxelManager = vol.voxelManager;
     const width = vol.dimensions[0];
     const pixelsPerSlice = width * vol.dimensions[1];
     return {
@@ -34,14 +34,14 @@ function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
             const ijk = vol.imageData.worldToIndex(point).map(Math.round);
             const [i, j, k] = ijk;
             const index = i + j * width + k * pixelsPerSlice;
-            const value = segData[index];
+            const value = voxelManager.getAtIndex(index);
             return value === segmentIndex || containedSegmentIndices?.has(value);
         },
         toIJK: (point) => vol.imageData.worldToIndex(point),
         testIJK: (ijk) => {
             const [i, j, k] = ijk;
             const index = Math.round(i) + Math.round(j) * width + Math.round(k) * pixelsPerSlice;
-            const value = segData[index];
+            const value = voxelManager.getAtIndex(index);
             return value === segmentIndex || containedSegmentIndices?.has(value);
         },
     };