@cornerstonejs/labelmap-interpolation 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+import interpolate from './utilities/interpolateLabelmap';
+export { interpolate };

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+import interpolate from './utilities/interpolateLabelmap';
+export { interpolate };

package/dist/esm/registerWorker.d.ts

@@ -0,0 +1 @@
+export declare function registerInterpolationWorker(): void;

package/dist/esm/registerWorker.js

@@ -0,0 +1,23 @@
+import { getWebWorkerManager } from '@cornerstonejs/core';
+let registered = false;
+export function registerInterpolationWorker() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    const workerFn = () => {
+        return new Worker(new URL('./workers/interpolationWorker.js', import.meta.url), {
+            name: 'interpolation',
+            type: 'module',
+        });
+    };
+    const workerManager = getWebWorkerManager();
+    const options = {
+        maxWorkerInstances: 1,
+        autoTerminateOnIdle: {
+            enabled: true,
+            idleTimeThreshold: 2000,
+        },
+    };
+    workerManager.registerWorker('interpolation', workerFn, options);
+}

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

@@ -0,0 +1,15 @@
+type MorphologicalContourInterpolationOptions = {
+    label?: number;
+    axis?: number;
+    noHeuristicAlignment?: boolean;
+    noUseDistanceTransform?: boolean;
+    useCustomSlicePositions?: boolean;
+};
+declare function interpolateLabelmap({ segmentationId, segmentIndex, configuration, }: {
+    segmentationId: string;
+    segmentIndex: number;
+    configuration?: MorphologicalContourInterpolationOptions & {
+        preview: boolean;
+    };
+}): Promise<void>;
+export default interpolateLabelmap;

package/dist/esm/utilities/interpolateLabelmap.js

@@ -0,0 +1,44 @@
+import { getWebWorkerManager, eventTarget, Enums, triggerEvent, } from '@cornerstonejs/core';
+import { segmentation, Enums as csToolsEnums, utilities, } from '@cornerstonejs/tools';
+import { registerInterpolationWorker } from '../registerWorker';
+const { triggerSegmentationEvents } = segmentation;
+const { getOrCreateSegmentationVolume } = utilities.segmentation;
+const { triggerSegmentationDataModified } = triggerSegmentationEvents;
+const { WorkerTypes } = csToolsEnums;
+const workerManager = getWebWorkerManager();
+const triggerWorkerProgress = (eventTarget, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: WorkerTypes.INTERPOLATE_LABELMAP,
+    });
+};
+async function interpolateLabelmap({ segmentationId, segmentIndex, configuration = { preview: false }, }) {
+    registerInterpolationWorker();
+    triggerWorkerProgress(eventTarget, 0);
+    const segVolume = getOrCreateSegmentationVolume(segmentationId);
+    const { voxelManager: segmentationVoxelManager, imageData: segmentationImageData, } = segVolume;
+    const segmentationInfo = {
+        scalarData: segmentationVoxelManager.getCompleteScalarDataArray(),
+        dimensions: segmentationImageData.getDimensions(),
+        spacing: segmentationImageData.getSpacing(),
+        origin: segmentationImageData.getOrigin(),
+        direction: segmentationImageData.getDirection(),
+    };
+    try {
+        const { data: outputScalarData } = await workerManager.executeTask('interpolation', 'interpolateLabelmap', {
+            segmentationInfo,
+            configuration: {
+                ...configuration,
+                label: segmentIndex,
+            },
+        });
+        segmentationVoxelManager.setCompleteScalarDataArray(outputScalarData);
+        triggerSegmentationDataModified(segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), segmentIndex);
+        triggerWorkerProgress(eventTarget, 100);
+    }
+    catch (error) {
+        console.warn('Warning: Failed to perform morphological contour interpolation', error);
+        triggerWorkerProgress(eventTarget, 100);
+    }
+}
+export default interpolateLabelmap;

package/dist/esm/workers/interpolationWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/workers/interpolationWorker.js

@@ -0,0 +1,129 @@
+import { expose } from 'comlink';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+async function peerImport(moduleId) {
+    try {
+        switch (moduleId) {
+            case 'itk-wasm':
+                return import('itk-wasm');
+            case '@itk-wasm/morphological-contour-interpolation':
+                return import('@itk-wasm/morphological-contour-interpolation');
+            default:
+                throw new Error(`Unknown module ID: ${moduleId}`);
+        }
+    }
+    catch (error) {
+        console.warn(`Error importing ${moduleId}:`, error);
+        return null;
+    }
+}
+const computeWorker = {
+    getITKImage: async (args) => {
+        const { imageData, options } = args;
+        const { imageName, scalarData } = options;
+        let Image, ImageType, IntTypes, FloatTypes, PixelTypes;
+        try {
+            const itkModule = await peerImport('itk-wasm');
+            if (!itkModule) {
+                throw new Error('Module not found');
+            }
+            ({ Image, ImageType, IntTypes, FloatTypes, PixelTypes } = itkModule);
+        }
+        catch (error) {
+            console.warn("Warning: 'itk-wasm' module not found. Please install it separately.");
+            return null;
+        }
+        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,
+        };
+        const { numberOfComponents } = imageData.get('numberOfComponents');
+        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;
+    },
+    interpolateLabelmap: async (args) => {
+        const { segmentationInfo, configuration } = args;
+        const { scalarData, dimensions, spacing, origin, direction } = segmentationInfo;
+        let itkModule;
+        try {
+            itkModule = await peerImport('@itk-wasm/morphological-contour-interpolation');
+            if (!itkModule) {
+                throw new Error('Module not found');
+            }
+        }
+        catch (error) {
+            console.warn("Warning: '@itk-wasm/morphological-contour-interpolation' module not found. Please install it separately.");
+            return { data: scalarData };
+        }
+        const imageData = vtkImageData.newInstance();
+        imageData.setDimensions(dimensions);
+        imageData.setOrigin(origin);
+        imageData.setDirection(direction || [1, 0, 0, 0, 1, 0, 0, 0, 1]);
+        imageData.setSpacing(spacing);
+        const scalarArray = vtkDataArray.newInstance({
+            name: 'Pixels',
+            numberOfComponents: 1,
+            values: scalarData,
+        });
+        imageData.getPointData().setScalars(scalarArray);
+        imageData.modified();
+        try {
+            const inputImage = await computeWorker.getITKImage({
+                imageData,
+                options: {
+                    imageName: 'interpolation',
+                    scalarData: scalarData,
+                },
+            });
+            if (!inputImage) {
+                throw new Error('Failed to get ITK image');
+            }
+            const { outputImage } = await itkModule.morphologicalContourInterpolation(inputImage, {
+                ...configuration,
+                webWorker: false,
+            });
+            const outputScalarData = outputImage.data;
+            const modifiedScalarData = new Uint16Array(scalarData.length);
+            modifiedScalarData.set(scalarData);
+            for (let i = 0; i < outputScalarData.length; i++) {
+                const newValue = outputScalarData[i];
+                const originalValue = scalarData[i];
+                if (newValue !== originalValue) {
+                    modifiedScalarData[i] = newValue;
+                }
+            }
+            return { data: modifiedScalarData };
+        }
+        catch (error) {
+            console.error(error);
+            console.warn('Warning: Failed to perform morphological contour interpolation');
+            return { data: scalarData };
+        }
+    },
+};
+expose(computeWorker);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/labelmap-interpolation",
-  "version": "3.0.0-beta.3",
+  "version": "3.0.0-beta.4",
   "description": "Labelmap Interpolation utility for Cornerstone3D",
   "files": [
     "dist"
@@ -22,15 +22,19 @@
   "scripts": {
     "test": "jest --testTimeout 60000",
     "clean": "rimraf dist",
+    "clean:deep": "yarn run clean && shx rm -rf node_modules",
     "build": "yarn run build:esm",
     "build:esm": "tsc --project ./tsconfig.json",
     "build:esm:watch": "tsc --project ./tsconfig.json --watch",
     "dev": "tsc --project ./tsconfig.json --watch",
     "build:all": "yarn run build:esm",
-    "build:update-api": "yarn run build:esm && api-extractor run --local",
     "start": "tsc --project ./tsconfig.json --watch",
     "format": "prettier --write 'src/**/*.js' 'test/**/*.js'",
-    "lint": "eslint --fix ."
+    "lint": "eslint --fix .",
+    "format-check": "npx eslint ./src --quiet",
+    "api-check": "api-extractor --debug run ",
+    "build:update-api": "yarn run build:esm && api-extractor run --local",
+    "prepublishOnly": "yarn clean && yarn build"
   },
   "repository": {
     "type": "git",
@@ -47,9 +51,9 @@
     "itk-wasm": "1.0.0-b.165"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.0.0-beta.3",
-    "@cornerstonejs/tools": "^3.0.0-beta.3",
+    "@cornerstonejs/core": "^3.0.0-beta.4",
+    "@cornerstonejs/tools": "^3.0.0-beta.4",
     "@kitware/vtk.js": "^32.9.0"
   },
-  "gitHead": "d2b29db96b3ecf98c9e9f0591978423dc9f6cb3f"
+  "gitHead": "93464de8c8c6f01ca4ca35140c8f910b4a226582"
 }