@cornerstonejs/tools 2.17.6 → 2.18.1

package/dist/esm/enums/StrategyCallbacks.d.ts

@@ -5,6 +5,7 @@ declare enum StrategyCallbacks {
     RejectPreview = "rejectPreview",
     AcceptPreview = "acceptPreview",
     Fill = "fill",
+    Interpolate = "interpolate",
     StrategyFunction = "strategyFunction",
     CreateIsInThreshold = "createIsInThreshold",
     Initialize = "initialize",

package/dist/esm/enums/StrategyCallbacks.js

@@ -6,6 +6,7 @@ var StrategyCallbacks;
     StrategyCallbacks["RejectPreview"] = "rejectPreview";
     StrategyCallbacks["AcceptPreview"] = "acceptPreview";
     StrategyCallbacks["Fill"] = "fill";
+    StrategyCallbacks["Interpolate"] = "interpolate";
     StrategyCallbacks["StrategyFunction"] = "strategyFunction";
     StrategyCallbacks["CreateIsInThreshold"] = "createIsInThreshold";
     StrategyCallbacks["Initialize"] = "initialize";

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -16,6 +16,9 @@ declare class BrushTool extends LabelmapBaseTool {
     private _calculateCursor;
     private _endCallback;
     getStatistics(element: any, segmentIndices?: any): any;
+    rejectPreview(element?: HTMLDivElement): void;
+    interpolate(element: any, config: any): void;
+    acceptPreview(element?: HTMLDivElement): void;
     private _activateDraw;
     private _deactivateDraw;
     invalidateBrushCursor(): void;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -48,6 +48,36 @@ class BrushTool extends LabelmapBaseTool {
                         },
                     ],
                 },
+                [StrategyCallbacks.RejectPreview]: {
+                    method: StrategyCallbacks.RejectPreview,
+                    bindings: [
+                        {
+                            key: 'Escape',
+                        },
+                    ],
+                },
+                [StrategyCallbacks.Interpolate]: {
+                    method: StrategyCallbacks.Interpolate,
+                    bindings: [
+                        {
+                            key: 'i',
+                        },
+                    ],
+                    configuration: {
+                        useBallStructuringElement: true,
+                        noUseDistanceTransform: true,
+                        noUseExtrapolation: true,
+                    },
+                },
+                interpolateExtrapolation: {
+                    method: StrategyCallbacks.Interpolate,
+                    bindings: [
+                        {
+                            key: 'e',
+                        },
+                    ],
+                    configuration: {},
+                },
             },
         },
     }) {
@@ -239,6 +269,32 @@ class BrushTool extends LabelmapBaseTool {
         const stats = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.GetStatistics, segmentIndices);
         return stats;
     }
+    rejectPreview(element = this._previewData.element) {
+        if (!element || !this._previewData.preview) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+    }
+    interpolate(element, config) {
+        if (!element) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.Interpolate, config.configuration);
+        this._previewData.isDrag = true;
+    }
+    acceptPreview(element = this._previewData.element) {
+        if (!element) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
+        this._previewData.isDrag = false;
+        this._previewData.preview = null;
+    }
     invalidateBrushCursor() {
         if (this._hoverData === undefined) {
             return;

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

@@ -66,6 +66,9 @@ export default class BrushStrategy {
                 indices?: number | number[];
             }) => import("../../../types").NamedStatistics;
         };
+        labelmapInterpolation: {
+            interpolate: (operationData: InitializedOperationData, configuration: import("@itk-wasm/morphological-contour-interpolation").MorphologicalContourInterpolationOptions) => InitializedOperationData;
+        };
     };
     protected static childFunctions: {
         onInteractionStart: (brushStrategy: any, func: any) => void;
@@ -73,6 +76,7 @@ export default class BrushStrategy {
         fill: (brushStrategy: any, func: any) => void;
         initialize: (brushStrategy: any, func: any) => void;
         createIsInThreshold: (brushStrategy: any, func: any) => void;
+        interpolate: (brushStrategy: any, func: any) => void;
         acceptPreview: (brushStrategy: any, func: any) => void;
         rejectPreview: (brushStrategy: any, func: any) => void;
         setValue: (brushStrategy: any, func: any) => void;
@@ -98,6 +102,7 @@ export default class BrushStrategy {
     addPreview: (enabledElement: any, operationData: LabelmapToolOperationDataAny) => any;
     acceptPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     preview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
+    interpolate: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
     setValue: (operationData: InitializedOperationData, data: any) => void;
     createIsInThreshold: (operationData: InitializedOperationData) => any;
 }

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

@@ -12,6 +12,7 @@ export default class BrushStrategy {
         [StrategyCallbacks.Fill]: addListMethod(StrategyCallbacks.Fill),
         [StrategyCallbacks.Initialize]: addListMethod(StrategyCallbacks.Initialize),
         [StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(StrategyCallbacks.CreateIsInThreshold),
+        [StrategyCallbacks.Interpolate]: addListMethod(StrategyCallbacks.Interpolate, StrategyCallbacks.Initialize),
         [StrategyCallbacks.AcceptPreview]: addListMethod(StrategyCallbacks.AcceptPreview, StrategyCallbacks.Initialize),
         [StrategyCallbacks.RejectPreview]: addListMethod(StrategyCallbacks.RejectPreview, StrategyCallbacks.Initialize),
         [StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(StrategyCallbacks.INTERNAL_setValue),
@@ -126,12 +127,17 @@ function addListMethod(name, createInitialized) {
         brushStrategy[listName] ||= [];
         brushStrategy[listName].push(func);
         brushStrategy[name] ||= createInitialized
-            ? (enabledElement, operationData) => {
+            ? (enabledElement, operationData, ...args) => {
                 const initializedData = brushStrategy[createInitialized](enabledElement, operationData, name);
-                brushStrategy[listName].forEach((func) => func.call(brushStrategy, initializedData));
+                let returnValue;
+                brushStrategy[listName].forEach((func) => {
+                    const value = func.call(brushStrategy, initializedData, ...args);
+                    returnValue ||= value;
+                });
+                return returnValue;
             }
-            : (operationData) => {
-                brushStrategy[listName].forEach((func) => func.call(brushStrategy, operationData));
+            : (operationData, ...args) => {
+                brushStrategy[listName].forEach((func) => func.call(brushStrategy, operationData, ...args));
             };
     };
 }

package/dist/esm/tools/segmentation/strategies/compositions/index.d.ts

@@ -37,5 +37,8 @@ declare const _default: {
             indices?: number | number[];
         }) => import("../../../../types").NamedStatistics;
     };
+    labelmapInterpolation: {
+        interpolate: (operationData: import("../BrushStrategy").InitializedOperationData, configuration: import("@itk-wasm/morphological-contour-interpolation").MorphologicalContourInterpolationOptions) => import("../BrushStrategy").InitializedOperationData;
+    };
 };
 export default _default;

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

@@ -7,6 +7,7 @@ import regionFill from './regionFill';
 import setValue from './setValue';
 import threshold from './threshold';
 import labelmapStatistics from './labelmapStatistics';
+import labelmapInterpolation from './labelmapInterpolation';
 export default {
     determineSegmentIndex,
     dynamicThreshold,
@@ -17,4 +18,5 @@ export default {
     setValue,
     threshold,
     labelmapStatistics,
+    labelmapInterpolation,
 };

package/dist/esm/tools/segmentation/strategies/compositions/labelmapInterpolation.d.ts

@@ -0,0 +1,6 @@
+import type { MorphologicalContourInterpolationOptions } from '@itk-wasm/morphological-contour-interpolation';
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    interpolate: (operationData: InitializedOperationData, configuration: MorphologicalContourInterpolationOptions) => InitializedOperationData;
+};
+export default _default;

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

@@ -0,0 +1,41 @@
+import { morphologicalContourInterpolation } from '@itk-wasm/morphological-contour-interpolation';
+import { utilities } from '@cornerstonejs/core';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import getItkImage from '../utils/getItkImage';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import PreviewMethods from './preview';
+const { VoxelManager } = utilities;
+export default {
+    [StrategyCallbacks.Interpolate]: (operationData, configuration) => {
+        const { segmentationImageData, segmentIndex, preview, segmentationVoxelManager, previewSegmentIndex, previewVoxelManager, } = operationData;
+        if (preview) {
+            const callback = ({ index }) => {
+                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+            };
+            previewVoxelManager.forEach(callback);
+        }
+        const inputImage = getItkImage(segmentationImageData, 'interpolation');
+        const outputPromise = morphologicalContourInterpolation(inputImage, {
+            ...configuration,
+            label: segmentIndex,
+            webWorker: false,
+        });
+        outputPromise.then((value) => {
+            const { outputImage } = value;
+            const previewColors = operationData.configuration?.preview?.previewColors;
+            const assignIndex = previewSegmentIndex ?? (previewColors ? 255 : segmentIndex);
+            operationData.previewColors ||= previewColors;
+            operationData.previewSegmentIndex ||= previewColors ? 255 : undefined;
+            PreviewMethods[StrategyCallbacks.Initialize](operationData);
+            segmentationVoxelManager.forEach(({ value: originalValue, index }) => {
+                const newValue = outputImage.data[index];
+                if (newValue === originalValue) {
+                    return;
+                }
+                previewVoxelManager.setAtIndex(index, assignIndex);
+            });
+            triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), assignIndex);
+        });
+        return operationData;
+    },
+};

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

@@ -61,8 +61,8 @@ function createPointInEllipse(worldInfo) {
     const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
     return precalculated;
 }
-const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
-const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);
+const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.labelmapInterpolation);
+const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics, compositions.labelmapInterpolation);
 const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
 const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 export function fillOutsideCircle() {

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

@@ -0,0 +1,2 @@
+import { Image } from 'itk-wasm';
+export default function getItkImage(imageData: any, imageName?: string): Image;

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

@@ -0,0 +1,37 @@
+import { Image, ImageType, IntTypes, FloatTypes, PixelTypes } from 'itk-wasm';
+const dataTypesMap = {
+    Int8: IntTypes.Int8,
+    UInt8: IntTypes.UInt8,
+    Int16: IntTypes.Int16,
+    UInt16: IntTypes.UInt16,
+    Int32: IntTypes.Int32,
+    UInt32: IntTypes.UInt32,
+    Int64: IntTypes.Int64,
+    UInt64: IntTypes.UInt64,
+    Float32: FloatTypes.Float32,
+    Float64: FloatTypes.Float64,
+};
+export default function getItkImage(imageData, imageName) {
+    const { voxelManager } = imageData.get('voxelManager');
+    const { numberOfComponents } = imageData.get('numberOfComponents');
+    const scalarData = voxelManager.getCompleteScalarDataArray();
+    const dimensions = imageData.getDimensions();
+    const origin = imageData.getOrigin();
+    const spacing = imageData.getSpacing();
+    const directionArray = imageData.getDirection();
+    const direction = new Float64Array(directionArray);
+    const dataType = scalarData.constructor.name
+        .replace(/^Ui/, 'UI')
+        .replace(/Array$/, '');
+    const metadata = undefined;
+    const imageType = new ImageType(dimensions.length, dataTypesMap[dataType], PixelTypes.Scalar, numberOfComponents);
+    const image = new Image(imageType);
+    image.name = imageName;
+    image.origin = origin;
+    image.spacing = spacing;
+    image.direction = direction;
+    image.size = dimensions;
+    image.metadata = metadata;
+    image.data = scalarData;
+    return image;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.17.6",
+  "version": "2.18.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -104,7 +104,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^2.17.6",
+    "@cornerstonejs/core": "^2.18.1",
     "@kitware/vtk.js": "32.9.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -123,5 +123,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "ed6fea9289da25d37aefe5a551e6aada36101d2f"
+  "gitHead": "c3f5e7dfc0681ce4dfa53d762c3675379856ac22"
 }