@cornerstonejs/tools 2.18.3 → 2.18.5

package/dist/esm/geometricSurfaceUtils.d.ts

@@ -0,0 +1,8 @@
+interface RotationMatrixInformation {
+    isStandard: boolean;
+    rotationMatrix: number[];
+}
+export declare function inverse3x3Matrix(matrix: number[]): number[];
+export declare function checkStandardBasis(directions: number[]): RotationMatrixInformation;
+export declare function rotatePoints(rotationMatrix: number[], origin: number[], points: number[]): number[];
+export {};

package/dist/esm/geometricSurfaceUtils.js

@@ -0,0 +1,103 @@
+function validate3x3Matrix(matrix) {
+    if (!Array.isArray(matrix) || matrix.length !== 9) {
+        throw new Error('Matrix must be an array of 9 numbers');
+    }
+    if (!matrix.every((n) => typeof n === 'number' && !isNaN(n))) {
+        throw new Error('Matrix must contain only valid numbers');
+    }
+}
+export function inverse3x3Matrix(matrix) {
+    validate3x3Matrix(matrix);
+    const mat = [
+        [matrix[0], matrix[1], matrix[2]],
+        [matrix[3], matrix[4], matrix[5]],
+        [matrix[6], matrix[7], matrix[8]],
+    ];
+    const determinant = mat[0][0] * (mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1]) -
+        mat[0][1] * (mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]) +
+        mat[0][2] * (mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]);
+    if (Math.abs(determinant) < 1e-10) {
+        throw new Error('Matrix is not invertible (determinant is zero)');
+    }
+    const adjugate = [
+        [
+            mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1],
+            -(mat[0][1] * mat[2][2] - mat[0][2] * mat[2][1]),
+            mat[0][1] * mat[1][2] - mat[0][2] * mat[1][1],
+        ],
+        [
+            -(mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]),
+            mat[0][0] * mat[2][2] - mat[0][2] * mat[2][0],
+            -(mat[0][0] * mat[1][2] - mat[0][2] * mat[1][0]),
+        ],
+        [
+            mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0],
+            -(mat[0][0] * mat[2][1] - mat[0][1] * mat[2][0]),
+            mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0],
+        ],
+    ];
+    const inverse = [];
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+            inverse.push(adjugate[i][j] / determinant);
+        }
+    }
+    return inverse;
+}
+function normalizeVector(v) {
+    const magnitude = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    return v.map((component) => component / magnitude);
+}
+export function checkStandardBasis(directions) {
+    validate3x3Matrix(directions);
+    const xVector = directions.slice(0, 3);
+    const yVector = directions.slice(3, 6);
+    const zVector = directions.slice(6, 9);
+    const normalizedX = normalizeVector(xVector);
+    const normalizedY = normalizeVector(yVector);
+    const normalizedZ = normalizeVector(zVector);
+    const standardBasis = {
+        x: [1, 0, 0],
+        y: [0, 1, 0],
+        z: [0, 0, 1],
+    };
+    const epsilon = 1e-10;
+    const isStandard = normalizedX.every((val, i) => Math.abs(val - standardBasis.x[i]) < epsilon) &&
+        normalizedY.every((val, i) => Math.abs(val - standardBasis.y[i]) < epsilon) &&
+        normalizedZ.every((val, i) => Math.abs(val - standardBasis.z[i]) < epsilon);
+    const rotationMatrix = isStandard
+        ? [...standardBasis.x, ...standardBasis.y, ...standardBasis.z]
+        : inverse3x3Matrix([...normalizedX, ...normalizedY, ...normalizedZ]);
+    return {
+        isStandard,
+        rotationMatrix,
+    };
+}
+function rotatePoint(point, origin, rotationMatrix) {
+    const x = point[0] - origin[0];
+    const y = point[1] - origin[1];
+    const z = point[2] - origin[2];
+    return [
+        rotationMatrix[0] * x +
+            rotationMatrix[1] * y +
+            rotationMatrix[2] * z +
+            origin[0],
+        rotationMatrix[3] * x +
+            rotationMatrix[4] * y +
+            rotationMatrix[5] * z +
+            origin[1],
+        rotationMatrix[6] * x +
+            rotationMatrix[7] * y +
+            rotationMatrix[8] * z +
+            origin[2],
+    ];
+}
+export function rotatePoints(rotationMatrix, origin, points) {
+    const rotatedPoints = [];
+    for (let i = 0; i < points.length; i += 3) {
+        const point = points.slice(i, i + 3);
+        const rotated = rotatePoint(point, origin, rotationMatrix);
+        rotatedPoints.push(...rotated);
+    }
+    return rotatedPoints;
+}

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

@@ -67,7 +67,13 @@ export default class BrushStrategy {
             }) => import("../../../types").NamedStatistics;
         };
         labelmapInterpolation: {
-            interpolate: (operationData: InitializedOperationData, configuration: import("@itk-wasm/morphological-contour-interpolation").MorphologicalContourInterpolationOptions) => InitializedOperationData;
+            interpolate: (operationData: InitializedOperationData, configuration: {
+                label?: number;
+                axis?: number;
+                noHeuristicAlignment?: boolean;
+                noUseDistanceTransform?: boolean;
+                useCustomSlicePositions?: boolean;
+            }) => Promise<InitializedOperationData>;
         };
     };
     protected static childFunctions: {

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

@@ -38,7 +38,13 @@ declare const _default: {
         }) => import("../../../../types").NamedStatistics;
     };
     labelmapInterpolation: {
-        interpolate: (operationData: import("../BrushStrategy").InitializedOperationData, configuration: import("@itk-wasm/morphological-contour-interpolation").MorphologicalContourInterpolationOptions) => import("../BrushStrategy").InitializedOperationData;
+        interpolate: (operationData: import("../BrushStrategy").InitializedOperationData, configuration: {
+            label?: number;
+            axis?: number;
+            noHeuristicAlignment?: boolean;
+            noUseDistanceTransform?: boolean;
+            useCustomSlicePositions?: boolean;
+        }) => Promise<import("../BrushStrategy").InitializedOperationData>;
     };
 };
 export default _default;

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

@@ -1,6 +1,12 @@
-import type { MorphologicalContourInterpolationOptions } from '@itk-wasm/morphological-contour-interpolation';
 import type { InitializedOperationData } from '../BrushStrategy';
+type MorphologicalContourInterpolationOptions = {
+    label?: number;
+    axis?: number;
+    noHeuristicAlignment?: boolean;
+    noUseDistanceTransform?: boolean;
+    useCustomSlicePositions?: boolean;
+};
 declare const _default: {
-    interpolate: (operationData: InitializedOperationData, configuration: MorphologicalContourInterpolationOptions) => InitializedOperationData;
+    interpolate: (operationData: InitializedOperationData, configuration: MorphologicalContourInterpolationOptions) => Promise<InitializedOperationData>;
 };
 export default _default;

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

@@ -1,12 +1,10 @@
-import { morphologicalContourInterpolation } from '@itk-wasm/morphological-contour-interpolation';
-import { utilities } from '@cornerstonejs/core';
+import { utilities, peerImport } 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) => {
+    [StrategyCallbacks.Interpolate]: async (operationData, configuration) => {
         const { segmentationImageData, segmentIndex, preview, segmentationVoxelManager, previewSegmentIndex, previewVoxelManager, } = operationData;
         if (preview) {
             const callback = ({ index }) => {
@@ -15,7 +13,18 @@ export default {
             previewVoxelManager.forEach(callback);
         }
         const inputImage = getItkImage(segmentationImageData, 'interpolation');
-        const outputPromise = morphologicalContourInterpolation(inputImage, {
+        let itkModule;
+        try {
+            itkModule = await peerImport('@itk-wasm/morphological-contour-interpolation');
+            if (!itkModule) {
+                throw new Error('Module not found');
+            }
+        }
+        catch (error) {
+            console.debug("Warning: '@itk-wasm/morphological-contour-interpolation' module not found. Please install it separately.");
+            return operationData;
+        }
+        const outputPromise = itkModule.morphologicalContourInterpolation(inputImage, {
             ...configuration,
             label: segmentIndex,
             webWorker: false,

package/dist/esm/utilities/math/vec2/liangBarksyClip.d.ts

@@ -1 +1 @@
-export default function clip(a: any, b: any, box: any, da?: any, db?: any): 1 | 0;
+export default function clip(a: any, b: any, box: any, da?: any, db?: any): 0 | 1;

package/dist/esm/workers/polySegConverters.js

@@ -2,7 +2,6 @@ import { expose } from 'comlink';
 import { utilities } from '@cornerstonejs/core';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import ICRPolySeg from '@icr/polyseg-wasm';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import vtkContourLoopExtraction from '@kitware/vtk.js/Filters/General/ContourLoopExtraction';
@@ -10,11 +9,21 @@ import vtkCutter from '@kitware/vtk.js/Filters/Core/Cutter';
 import { getBoundingBoxAroundShapeWorld } from '../utilities/boundingBox';
 import { containsPoint, getAABB, projectTo2D, } from '../utilities/math/polyline';
 import { isPlaneIntersectingAABB } from '../utilities/planar';
+import { checkStandardBasis, rotatePoints } from '../geometricSurfaceUtils';
 const polySegConverters = {
     polySeg: null,
     polySegInitializing: false,
     polySegInitializingPromise: null,
     async initializePolySeg(progressCallback) {
+        let ICRPolySeg;
+        try {
+            ICRPolySeg = (await import('@icr/polyseg-wasm')).default;
+        }
+        catch (error) {
+            console.error(error);
+            console.debug("Warning: '@icr/polyseg-wasm' module not found. Please install it separately.");
+            return;
+        }
         if (this.polySegInitializing) {
             await this.polySegInitializingPromise;
             return;
@@ -47,14 +56,16 @@ const polySegConverters = {
         const [progressCallback] = callbacks;
         await this.initializePolySeg(progressCallback);
         const results = this.polySeg.instance.convertLabelmapToSurface(args.scalarData, args.dimensions, args.spacing, args.direction, args.origin, [args.segmentIndex]);
+        const rotationInfo = checkStandardBasis(args.direction);
+        if (!rotationInfo.isStandard) {
+            const rotatedPoints = rotatePoints(rotationInfo.rotationMatrix, args.origin, results.points);
+            results.points = [...rotatedPoints];
+        }
         return results;
     },
     async convertContourToVolumeLabelmap(args, ...callbacks) {
         const [progressCallback] = callbacks;
-        const polySeg = await new ICRPolySeg();
-        await polySeg.initialize({
-            updateProgress: progressCallback,
-        });
+        await this.initializePolySeg(progressCallback);
         const { segmentIndices, scalarData, annotationUIDsInSegmentMap, dimensions, origin, direction, spacing, } = args;
         const segmentationVoxelManager = utilities.VoxelManager.createScalarVolumeVoxelManager({
             dimensions,
@@ -124,10 +135,7 @@ const polySegConverters = {
     },
     async convertContourToStackLabelmap(args, ...callbacks) {
         const [progressCallback] = callbacks;
-        const polySeg = await new ICRPolySeg();
-        await polySeg.initialize({
-            updateProgress: progressCallback,
-        });
+        await this.initializePolySeg(progressCallback);
         const { segmentationsInfo, annotationUIDsInSegmentMap, segmentIndices } = args;
         const segmentationVoxelManagers = new Map();
         segmentationsInfo.forEach((segmentationInfo, referencedImageId) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.18.3",
+  "version": "2.18.5",
   "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.18.3",
+    "@cornerstonejs/core": "^2.18.5",
     "@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": "cc92461656c37883686759ab4b495219046f4be7"
+  "gitHead": "be8bb617be050ca5aa5a9d2d61013a9c674efa5d"
 }