@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

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

@@ -3,7 +3,7 @@ import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import IslandRemoval from '../../../../utilities/segmentation/islandRemoval';
 export default {
     [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
-        const { previewSegmentIndex, segmentIndex, viewport, segmentationVoxelManager, activeStrategy, memo, } = operationData;
+        const { previewSegmentIndex, segmentIndex, labelValue, viewport, segmentationVoxelManager, activeStrategy, memo, } = operationData;
         if (activeStrategy !== 'THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL' ||
             segmentIndex === null) {
             return;
@@ -12,7 +12,7 @@ export default {
         const voxelManager = memo?.voxelManager || segmentationVoxelManager;
         if (!islandRemoval.initialize(viewport, voxelManager, {
             previewSegmentIndex,
-            segmentIndex,
+            segmentIndex: labelValue ?? segmentIndex,
         })) {
             return;
         }

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

@@ -29,7 +29,7 @@ export default {
         operationData.modified = true;
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
-        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, centerSegmentIndexInfo, } = operationData || {};
+        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, labelValue, centerSegmentIndexInfo, } = operationData || {};
         const { changedIndices } = centerSegmentIndexInfo || {};
         const labelmapMemo = memo;
         const callback = ({ index }) => {
@@ -41,7 +41,7 @@ export default {
             }
             else {
                 if (oldValue === previewSegmentIndex) {
-                    labelmapMemo.voxelManager.setAtIndex(index, segmentIndex);
+                    labelmapMemo.voxelManager.setAtIndex(index, labelValue ?? segmentIndex);
                 }
             }
         };

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

@@ -1,25 +1,33 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import { handleUseSegmentCenterIndex } from '../utils/handleUseSegmentCenterIndex';
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { getSegmentIndexForLabelValue } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, } = operationData;
+        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, labelValue, labelmapId, segmentationId, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
-        if (segmentsLocked.includes(value)) {
+        const segmentation = getSegmentation(segmentationId);
+        const existingSegmentIndex = segmentation && labelmapId
+            ? getSegmentIndexForLabelValue(segmentation, labelmapId, existingValue)
+            : existingValue;
+        const writeValue = previewSegmentIndex ?? labelValue ?? segmentIndex;
+        if (segmentsLocked.includes(existingSegmentIndex)) {
             return;
         }
-        if (!centerSegmentIndexInfo && existingValue === segmentIndex) {
+        if (!centerSegmentIndexInfo &&
+            existingValue === (labelValue ?? segmentIndex)) {
             return;
         }
         if (centerSegmentIndexInfo?.segmentIndex !== 0 &&
-            existingValue === segmentIndex) {
+            existingValue === (labelValue ?? segmentIndex)) {
             return;
         }
         if (centerSegmentIndexInfo?.segmentIndex === null) {
-            memo.voxelManager.setAtIndex(index, previewSegmentIndex ?? segmentIndex);
+            memo.voxelManager.setAtIndex(index, writeValue);
             return;
         }
         if (!previewSegmentIndex) {
-            let useSegmentIndex = segmentIndex;
+            let useSegmentIndex = labelValue ?? segmentIndex;
             if (centerSegmentIndexInfo) {
                 useSegmentIndex = centerSegmentIndexInfo.segmentIndex;
             }

package/dist/esm/tools/segmentation/strategies/fillCircle.d.ts

@@ -6,7 +6,9 @@ export declare function getEllipseCornersFromCanvasCoordinates(canvasCoordinates
 declare function createPointInEllipse(cornersInWorld?: Types.Point3[], options?: {
     strokePointsWorld?: Types.Point3[];
     segmentationImageData?: vtkImageData;
-    radius?: number;
+    xRadius?: number;
+    yRadius?: number;
+    aspectRatio?: [number, number];
 }): (pointLPS: Types.Point3 | null, pointIJK?: Types.Point3) => boolean;
 declare const CIRCLE_STRATEGY: BrushStrategy;
 declare const CIRCLE_THRESHOLD_STRATEGY: BrushStrategy;

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

@@ -5,7 +5,7 @@ import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
 import { pointInSphere } from '../../../utilities/math/sphere';
-const { transformWorldToIndex, transformIndexToWorld, isEqual } = csUtils;
+const { transformWorldToIndex, transformIndexToWorld, isEqual, getNormalizedAspectRatio, } = csUtils;
 export function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
     const [bottom, top, left, right] = canvasCoordinates;
     const topLeft = [left[0], top[1]];
@@ -14,16 +14,16 @@ export function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
     const topRight = [right[0], top[1]];
     return [topLeft, bottomRight, bottomLeft, topRight];
 }
-function createCircleCornersForCenter(center, viewUp, viewRight, radius) {
+function createCircleCornersForCenter(center, viewUp, viewRight, yRadius, xRadius) {
     const centerVec = vec3.fromValues(center[0], center[1], center[2]);
     const top = vec3.create();
-    vec3.scaleAndAdd(top, centerVec, viewUp, radius);
+    vec3.scaleAndAdd(top, centerVec, viewUp, yRadius);
     const bottom = vec3.create();
-    vec3.scaleAndAdd(bottom, centerVec, viewUp, -radius);
+    vec3.scaleAndAdd(bottom, centerVec, viewUp, -yRadius);
     const right = vec3.create();
-    vec3.scaleAndAdd(right, centerVec, viewRight, radius);
+    vec3.scaleAndAdd(right, centerVec, viewRight, xRadius);
     const left = vec3.create();
-    vec3.scaleAndAdd(left, centerVec, viewRight, -radius);
+    vec3.scaleAndAdd(left, centerVec, viewRight, -xRadius);
     return [
         bottom,
         top,
@@ -31,11 +31,12 @@ function createCircleCornersForCenter(center, viewUp, viewRight, radius) {
         right,
     ];
 }
-function createStrokePredicate(centers, radius) {
-    if (!centers.length || radius <= 0) {
+function createStrokePredicate(centers, xRadius, yRadius) {
+    if (!centers.length || xRadius <= 0 || yRadius <= 0) {
         return null;
     }
-    const radiusSquared = radius * radius;
+    const xRadiusSquared = xRadius * xRadius;
+    const yRadiusSquared = yRadius * yRadius;
     const centerVecs = centers.map((point) => [point[0], point[1], point[2]]);
     const segments = [];
     for (let i = 1; i < centerVecs.length; i++) {
@@ -55,7 +56,8 @@ function createStrokePredicate(centers, radius) {
             const dx = worldPoint[0] - centerVec[0];
             const dy = worldPoint[1] - centerVec[1];
             const dz = worldPoint[2] - centerVec[2];
-            if (dx * dx + dy * dy + dz * dz <= radiusSquared) {
+            if ((dx * dx) / xRadiusSquared + (dy * dy) / yRadiusSquared + dz * dz <=
+                1) {
                 return true;
             }
         }
@@ -64,7 +66,8 @@ function createStrokePredicate(centers, radius) {
                 const dx = worldPoint[0] - start[0];
                 const dy = worldPoint[1] - start[1];
                 const dz = worldPoint[2] - start[2];
-                if (dx * dx + dy * dy + dz * dz <= radiusSquared) {
+                if ((dx * dx) / xRadiusSquared + (dy * dy) / yRadiusSquared + dz * dz <=
+                    1) {
                     return true;
                 }
                 continue;
@@ -80,7 +83,10 @@ function createStrokePredicate(centers, radius) {
             const distX = worldPoint[0] - projX;
             const distY = worldPoint[1] - projY;
             const distZ = worldPoint[2] - projZ;
-            if (distX * distX + distY * distY + distZ * distZ <= radiusSquared) {
+            if ((distX * distX) / xRadiusSquared +
+                (distY * distY) / yRadiusSquared +
+                distZ * distZ <=
+                1) {
                 return true;
             }
         }
@@ -103,7 +109,13 @@ const initializeCircle = {
         }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
-        const brushRadius = points.length >= 2 ? vec3.distance(points[0], points[1]) / 2 : 0;
+        const aspectRatio = getNormalizedAspectRatio(viewport.getAspectRatio());
+        const yRadius = points.length >= 2
+            ? vec3.distance(points[0], points[1]) / 2 / aspectRatio[1]
+            : 0;
+        const xRadius = points.length >= 2
+            ? vec3.distance(points[2], points[3]) / 2 / aspectRatio[0]
+            : 0;
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
         const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
         const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
@@ -119,14 +131,16 @@ const initializeCircle = {
             ? operationData.strokePointsWorld
             : [operationData.centerWorld];
         const strokeCenters = strokeCentersSource.map((point) => vec3.clone(point));
-        const strokeCornersWorld = strokeCenters.flatMap((centerPoint) => createCircleCornersForCenter(centerPoint, normalizedViewUp, viewRight, brushRadius));
+        const strokeCornersWorld = strokeCenters.flatMap((centerPoint) => createCircleCornersForCenter(centerPoint, normalizedViewUp, viewRight, yRadius, xRadius));
         const circleCornersIJK = strokeCornersWorld.map((world) => transformWorldToIndex(segmentationImageData, world));
         const boundsIJK = getBoundingBoxAroundShapeIJK(circleCornersIJK, segmentationImageData.getDimensions());
         operationData.strokePointsWorld = strokeCenters;
         operationData.isInObject = createPointInEllipse(cornersInWorld, {
             strokePointsWorld: strokeCenters,
             segmentationImageData,
-            radius: brushRadius,
+            xRadius,
+            yRadius,
+            aspectRatio,
         });
         operationData.isInObjectBoundsIJK = boundsIJK;
     },
@@ -136,22 +150,22 @@ function createPointInEllipse(cornersInWorld = [], options = {}) {
         throw new Error('createPointInEllipse: cornersInWorld must have 4 points');
     }
     const [topLeft, bottomRight, bottomLeft, topRight] = cornersInWorld;
+    const aspectRatio = options.aspectRatio || [1, 1];
     const center = vec3.create();
     vec3.add(center, topLeft, bottomRight);
     vec3.scale(center, center, 0.5);
     const majorAxisVec = vec3.create();
     vec3.subtract(majorAxisVec, topRight, topLeft);
-    const xRadius = vec3.length(majorAxisVec) / 2;
+    const originalRadius = vec3.length(majorAxisVec) / 2;
     vec3.normalize(majorAxisVec, majorAxisVec);
     const minorAxisVec = vec3.create();
     vec3.subtract(minorAxisVec, bottomLeft, topLeft);
-    const yRadius = vec3.length(minorAxisVec) / 2;
     vec3.normalize(minorAxisVec, minorAxisVec);
-    const normal = vec3.create();
-    vec3.cross(normal, majorAxisVec, minorAxisVec);
-    vec3.normalize(normal, normal);
-    const radiusForStroke = options.radius ?? Math.max(xRadius, yRadius);
-    const strokePredicate = createStrokePredicate(options.strokePointsWorld || [], radiusForStroke);
+    const xRadius = originalRadius / aspectRatio[0];
+    const yRadius = originalRadius / aspectRatio[1];
+    const xRadiusForStroke = options.xRadius ?? xRadius;
+    const yRadiusForStroke = options.yRadius ?? yRadius;
+    const strokePredicate = createStrokePredicate(options.strokePointsWorld || [], xRadiusForStroke, yRadiusForStroke);
     if (isEqual(xRadius, yRadius)) {
         const radius = xRadius;
         const sphereObj = {
@@ -186,15 +200,8 @@ function createPointInEllipse(cornersInWorld = [], options = {}) {
         }
         const pointVec = vec3.create();
         vec3.subtract(pointVec, worldPoint, center);
-        const distToPlane = vec3.dot(pointVec, normal);
-        const proj = vec3.create();
-        vec3.scaleAndAdd(proj, pointVec, normal, -distToPlane);
-        const fromTopLeft = vec3.create();
-        const centerToTopLeft = vec3.create();
-        vec3.subtract(centerToTopLeft, center, topLeft);
-        vec3.subtract(fromTopLeft, proj, centerToTopLeft);
-        const x = vec3.dot(fromTopLeft, majorAxisVec);
-        const y = vec3.dot(fromTopLeft, minorAxisVec);
+        const x = vec3.dot(pointVec, majorAxisVec);
+        const y = vec3.dot(pointVec, minorAxisVec);
         return (x * x) / (xRadius * xRadius) + (y * y) / (yRadius * yRadius) <= 1;
     };
 }

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

@@ -4,7 +4,7 @@ import BrushStrategy from './BrushStrategy';
 import compositions from './compositions';
 import StrategyCallbacks from '../../../enums/StrategyCallbacks';
 import { createEllipseInPoint, getEllipseCornersFromCanvasCoordinates, } from './fillCircle';
-const { transformWorldToIndex } = csUtils;
+const { transformWorldToIndex, getNormalizedAspectRatio } = csUtils;
 import { getSphereBoundsInfoFromViewport } from '../../../utilities/getSphereBoundsInfo';
 const sphereComposition = {
     [StrategyCallbacks.Initialize]: (operationData) => {
@@ -26,7 +26,13 @@ const sphereComposition = {
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
         const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
         const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
-        const strokeRadius = points.length >= 2 ? vec3.distance(points[0], points[1]) / 2 : undefined;
+        const aspectRatio = getNormalizedAspectRatio(viewport.getAspectRatio());
+        const yRadius = points.length >= 2
+            ? vec3.distance(points[0], points[1]) / 2 / aspectRatio[1]
+            : 0;
+        const xRadius = points.length >= 2
+            ? vec3.distance(points[2], points[3]) / 2 / aspectRatio[0]
+            : 0;
         const strokeCenters = operationData.strokePointsWorld &&
             operationData.strokePointsWorld.length > 0
             ? operationData.strokePointsWorld
@@ -90,7 +96,9 @@ const sphereComposition = {
         operationData.isInObject = createEllipseInPoint(cornersInWorld, {
             strokePointsWorld: operationData.strokePointsWorld,
             segmentationImageData,
-            radius: strokeRadius,
+            xRadius,
+            yRadius,
+            aspectRatio,
         });
     },
 };

package/dist/esm/tools/segmentation/strategies/utils/crossLayerErase.d.ts

@@ -0,0 +1,4 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare function collectCrossLayerEraseBindingsForOperation(operationData: InitializedOperationData): void;
+declare function eraseCrossLayerOverwrites(operationData: InitializedOperationData): number[];
+export { collectCrossLayerEraseBindingsForOperation as collectCrossLayerEraseBindings, eraseCrossLayerOverwrites, };

package/dist/esm/tools/segmentation/strategies/utils/crossLayerErase.js

@@ -0,0 +1,23 @@
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+function collectCrossLayerEraseBindingsForOperation(operationData) {
+    const { segmentationId, labelmapId, overwriteSegmentIndices } = operationData;
+    const segmentation = getSegmentation(segmentationId);
+    operationData.crossLayerEraseBindings = segmentation
+        ? collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices)
+        : [];
+}
+function eraseCrossLayerOverwrites(operationData) {
+    const segmentation = getSegmentation(operationData.segmentationId);
+    if (!segmentation) {
+        return [];
+    }
+    return eraseLabelmapEditTransactionOverwrites(segmentation, operationData.labelmapEditTransaction, {
+        viewport: operationData.viewport,
+        referenceImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+        imageId: operationData.imageId,
+    });
+}
+export { collectCrossLayerEraseBindingsForOperation as collectCrossLayerEraseBindings, eraseCrossLayerOverwrites, };

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js

@@ -54,7 +54,7 @@ function getStrategyDataForStackViewport({ operationData, viewport, strategy, })
         if (!labelmapImageId) {
             return null;
         }
-        const actorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+        const actorEntry = getLabelmapActorEntry(viewport.id, segmentationId, labelmapImageId);
         if (!actorEntry) {
             return null;
         }

package/dist/esm/tools/segmentation/strategies/utils/handleUseSegmentCenterIndex.js

@@ -1,8 +1,9 @@
 export function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
-    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, } = operationData;
+    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, labelValue, } = operationData;
+    const activeLabelValue = labelValue ?? segmentIndex;
     const { hasPreviewIndex, hasSegmentIndex, segmentIndex: centerSegmentIndex, } = centerSegmentIndexInfo;
     if (centerSegmentIndex === 0 && hasSegmentIndex && hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (previewOnHover) {
@@ -15,7 +16,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
         return;
     }
     if (centerSegmentIndex === 0 && hasSegmentIndex && !hasPreviewIndex) {
-        if (existingValue === 0 || existingValue !== segmentIndex) {
+        if (existingValue === 0 || existingValue !== activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -23,7 +24,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
         return;
     }
     if (centerSegmentIndex === 0 && !hasSegmentIndex && hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (previewOnHover) {
@@ -36,7 +37,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
         return;
     }
     if (centerSegmentIndex === 0 && !hasSegmentIndex && !hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (existingValue === previewSegmentIndex) {
@@ -48,7 +49,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
     if (centerSegmentIndex === previewSegmentIndex &&
         hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -57,25 +58,25 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
     if (centerSegmentIndex === previewSegmentIndex &&
         !hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
         return;
     }
-    if (centerSegmentIndex === segmentIndex &&
+    if (centerSegmentIndex === activeLabelValue &&
         hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
         return;
     }
-    if (centerSegmentIndex === segmentIndex &&
+    if (centerSegmentIndex === activeLabelValue &&
         hasSegmentIndex &&
         !hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);

package/dist/esm/tools/segmentation/strategies/utils/labelmapOverlap.d.ts

@@ -0,0 +1,4 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+import { eraseCrossLayerOverwrites } from './crossLayerErase';
+declare function prepareOverlapOperationData(operationData: InitializedOperationData): void;
+export { eraseCrossLayerOverwrites, prepareOverlapOperationData };

package/dist/esm/tools/segmentation/strategies/utils/labelmapOverlap.js

@@ -0,0 +1,41 @@
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { beginLabelmapEditTransaction, resolveLabelmapLayerEditTarget, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import { eraseCrossLayerOverwrites } from './crossLayerErase';
+import { resolveOverwriteSegmentIndices } from './overwritePolicy';
+function prepareOverlapOperationData(operationData) {
+    const segmentation = getSegmentation(operationData.segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    operationData.overwriteSegmentIndices =
+        resolveOverwriteSegmentIndices(operationData);
+    const transaction = beginLabelmapEditTransaction(segmentation, {
+        segmentIndex: operationData.segmentIndex,
+        overwriteSegmentIndices: operationData.overwriteSegmentIndices,
+        segmentationVoxelManager: operationData.segmentationVoxelManager,
+        segmentationImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+    });
+    operationData.labelmapEditTransaction = transaction;
+    operationData.labelValue = transaction.labelValue;
+    operationData.labelmapId = transaction.labelmapId;
+    operationData.crossLayerEraseBindings = transaction.crossLayerEraseBindings;
+    if (transaction.movedSegment && transaction.activeLayer) {
+        const target = resolveLabelmapLayerEditTarget(transaction.activeLayer, {
+            viewport: operationData.viewport,
+            imageId: operationData.imageId,
+            sourceLayer: transaction.sourceLayer,
+        });
+        if (target.imageId) {
+            operationData.imageId = target.imageId;
+        }
+        if (target.imageData) {
+            operationData.segmentationImageData = target.imageData;
+        }
+        if (target.voxelManager) {
+            operationData.segmentationVoxelManager = target.voxelManager;
+        }
+    }
+}
+export { eraseCrossLayerOverwrites, prepareOverlapOperationData };

package/dist/esm/tools/segmentation/strategies/utils/overwritePolicy.d.ts

@@ -0,0 +1,3 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare function resolveOverwriteSegmentIndices(operationData: InitializedOperationData): number[];
+export { resolveOverwriteSegmentIndices };

package/dist/esm/tools/segmentation/strategies/utils/overwritePolicy.js

@@ -0,0 +1,31 @@
+import { getConfig } from '../../../../config';
+import { SegmentationRepresentations } from '../../../../enums';
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { getSegmentationRepresentation } from '../../../../stateManagement/segmentation/getSegmentationRepresentation';
+function resolveOverwriteSegmentIndices(operationData) {
+    const { segmentationId, segmentIndex, segmentsLocked, viewport } = operationData;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation || segmentIndex === 0) {
+        return [];
+    }
+    const overwriteMode = getConfig().segmentation?.overwriteMode ?? 'all';
+    if (overwriteMode === 'none') {
+        return [];
+    }
+    const allSegmentIndices = Object.keys(segmentation.segments)
+        .map(Number)
+        .filter((candidateSegmentIndex) => candidateSegmentIndex !== segmentIndex &&
+        !segmentsLocked.includes(candidateSegmentIndex));
+    if (overwriteMode === 'all') {
+        return allSegmentIndices;
+    }
+    const representation = getSegmentationRepresentation(viewport.id, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
+    if (!representation?.visible) {
+        return [];
+    }
+    return allSegmentIndices.filter((candidateSegmentIndex) => representation.segments[candidateSegmentIndex]?.visible !== false);
+}
+export { resolveOverwriteSegmentIndices };

package/dist/esm/tools/segmentation/strategies/utils/segmentSeparation.d.ts

@@ -0,0 +1,3 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare function separateSegmentIfNeeded(operationData: InitializedOperationData): void;
+export { separateSegmentIfNeeded };

package/dist/esm/tools/segmentation/strategies/utils/segmentSeparation.js

@@ -0,0 +1,38 @@
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { beginLabelmapEditTransaction, resolveLabelmapLayerEditTarget, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+function separateSegmentIfNeeded(operationData) {
+    const segmentation = getSegmentation(operationData.segmentationId);
+    if (!segmentation || !operationData.segmentIndex) {
+        return;
+    }
+    const transaction = beginLabelmapEditTransaction(segmentation, {
+        segmentIndex: operationData.segmentIndex,
+        overwriteSegmentIndices: operationData.overwriteSegmentIndices,
+        segmentationVoxelManager: operationData.segmentationVoxelManager,
+        segmentationImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+    });
+    operationData.labelmapEditTransaction = transaction;
+    operationData.labelmapId = transaction.labelmapId;
+    operationData.labelValue = transaction.labelValue;
+    operationData.crossLayerEraseBindings = transaction.crossLayerEraseBindings;
+    if (!transaction.movedSegment || !transaction.activeLayer) {
+        return;
+    }
+    const target = resolveLabelmapLayerEditTarget(transaction.activeLayer, {
+        viewport: operationData.viewport,
+        imageId: operationData.imageId,
+        sourceLayer: transaction.sourceLayer,
+    });
+    if (target.imageId) {
+        operationData.imageId = target.imageId;
+    }
+    if (target.imageData) {
+        operationData.segmentationImageData = target.imageData;
+    }
+    if (target.voxelManager) {
+        operationData.segmentationVoxelManager = target.voxelManager;
+    }
+}
+export { separateSegmentIfNeeded };

package/dist/esm/tools/segmentation/utils/LazyBrushEditController.d.ts

@@ -0,0 +1,19 @@
+import { type Types } from '@cornerstonejs/core';
+declare class LazyBrushEditController {
+    private strokePointsWorld;
+    private previewPoints;
+    private pendingPreviewCleanup;
+    reset(): void;
+    clearPendingCleanup(): void;
+    appendStrokePoint(worldPoint: Types.Point3): void;
+    getStrokePointsWorld(): Types.Point3[];
+    capturePreviewCircle(hoverData: any): void;
+    scheduleCleanup({ element, centerCanvas, viewportId, segmentationId, refreshCursor, }: {
+        element: HTMLDivElement;
+        centerCanvas: Types.Point2;
+        viewportId: string;
+        segmentationId: string;
+        refreshCursor: (element: HTMLDivElement, centerCanvas: Types.Point2) => void;
+    }): void;
+}
+export default LazyBrushEditController;

package/dist/esm/tools/segmentation/utils/LazyBrushEditController.js

@@ -0,0 +1,55 @@
+import { eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { appendLazyBrushPreviewCircle, appendLazyBrushStrokePoint, } from './lazyBrushPreview';
+class LazyBrushEditController {
+    constructor() {
+        this.strokePointsWorld = [];
+        this.previewPoints = [];
+        this.pendingPreviewCleanup = null;
+    }
+    reset() {
+        this.strokePointsWorld = [];
+        this.previewPoints = [];
+    }
+    clearPendingCleanup() {
+        if (!this.pendingPreviewCleanup) {
+            return;
+        }
+        eventTarget.removeEventListener(Events.SEGMENTATION_RENDERED, this.pendingPreviewCleanup.listener);
+        this.pendingPreviewCleanup = null;
+    }
+    appendStrokePoint(worldPoint) {
+        this.strokePointsWorld = appendLazyBrushStrokePoint(this.strokePointsWorld, worldPoint);
+    }
+    getStrokePointsWorld() {
+        return this.strokePointsWorld;
+    }
+    capturePreviewCircle(hoverData) {
+        if (!hoverData) {
+            return;
+        }
+        const circlePoints = hoverData.brushCursor?.data?.editPoints;
+        this.previewPoints = appendLazyBrushPreviewCircle(this.previewPoints, circlePoints);
+        hoverData.brushCursor.data.handles.points = this.previewPoints;
+    }
+    scheduleCleanup({ element, centerCanvas, viewportId, segmentationId, refreshCursor, }) {
+        this.clearPendingCleanup();
+        const listener = ((evt) => {
+            const detail = evt.detail;
+            if (detail.viewportId !== viewportId ||
+                detail.segmentationId !== segmentationId) {
+                return;
+            }
+            this.clearPendingCleanup();
+            this.reset();
+            refreshCursor(element, centerCanvas);
+        });
+        this.pendingPreviewCleanup = {
+            viewportId,
+            segmentationId,
+            listener,
+        };
+        eventTarget.addEventListener(Events.SEGMENTATION_RENDERED, listener);
+    }
+}
+export default LazyBrushEditController;

package/dist/esm/tools/segmentation/utils/lazyBrushPreview.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function appendLazyBrushStrokePoint(points?: Types.Point3[], point?: Types.Point3): Types.Point3[];
+export declare function appendLazyBrushPreviewCircle(existingPoints?: Types.Point3[], circlePoints?: Types.Point3[]): Types.Point3[];

package/dist/esm/tools/segmentation/utils/lazyBrushPreview.js

@@ -0,0 +1,34 @@
+const EPSILON = 1e-3;
+function clonePoint(point) {
+    return [point[0], point[1], point[2]];
+}
+function isSamePoint(a, b) {
+    return (Math.abs(a[0] - b[0]) < EPSILON &&
+        Math.abs(a[1] - b[1]) < EPSILON &&
+        Math.abs(a[2] - b[2]) < EPSILON);
+}
+export function appendLazyBrushStrokePoint(points = [], point) {
+    if (!point) {
+        return points;
+    }
+    if (points.length && isSamePoint(points[points.length - 1], point)) {
+        return points;
+    }
+    return [...points, clonePoint(point)];
+}
+export function appendLazyBrushPreviewCircle(existingPoints = [], circlePoints = []) {
+    if (!circlePoints.length) {
+        return existingPoints;
+    }
+    const nextCircle = circlePoints.map((point) => clonePoint(point));
+    if (!existingPoints.length) {
+        return nextCircle;
+    }
+    const previousCircle = existingPoints.slice(-nextCircle.length);
+    const isDuplicateCircle = previousCircle.length === nextCircle.length &&
+        previousCircle.every((point, index) => isSamePoint(point, nextCircle[index]));
+    if (isDuplicateCircle) {
+        return existingPoints;
+    }
+    return [...existingPoints, ...nextCircle];
+}