@cornerstonejs/core 2.3.3 → 2.5.0

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

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import type { vec3 } from 'gl-matrix';
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type BoundsIJK from '../types/BoundsIJK';
 import type { CPUImageData, Point3 } from '../types';
@@ -22,3 +22,17 @@ export interface PointInShapeOptions {
     returnPoints?: boolean;
 }
 export declare function pointInShapeCallback(imageData: vtkImageData | CPUImageData, options: PointInShapeOptions): Array<PointInShape> | undefined;
+export declare function iterateOverPointsInShape({ imageData, bounds, scalarData, pointInShapeFn, callback, }: {
+    imageData: any;
+    bounds: any;
+    scalarData: any;
+    pointInShapeFn: any;
+    callback: any;
+}): PointInShape[];
+export declare function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, }: {
+    voxelManager: any;
+    bounds: any;
+    imageData: any;
+    pointInShapeFn: any;
+    callback: any;
+}): PointInShape[];

package/dist/esm/utilities/pointInShapeCallback.js

@@ -1,9 +1,7 @@
-import { vec3 } from 'gl-matrix';
+import { createPositionCallback } from './createPositionCallback';
 export function pointInShapeCallback(imageData, options) {
-    const { pointInShapeFn, callback, boundsIJK, returnPoints = false, } = options;
-    let iMin, iMax, jMin, jMax, kMin, kMax;
+    const { pointInShapeFn, callback, boundsIJK, returnPoints = false } = options;
     let scalarData;
-    const { numComps } = imageData;
     if (imageData.getScalarData) {
         scalarData = imageData.getScalarData();
     }
@@ -13,47 +11,44 @@ export function pointInShapeCallback(imageData, options) {
             .getScalars()
             .getData();
     }
-    if (!scalarData) {
-        console.warn('No scalar data found for imageData', imageData);
-        return;
-    }
     const dimensions = imageData.getDimensions();
-    if (!boundsIJK) {
-        iMin = 0;
-        iMax = dimensions[0];
-        jMin = 0;
-        jMax = dimensions[1];
-        kMin = 0;
-        kMax = dimensions[2];
-    }
-    else {
-        [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = boundsIJK;
-    }
-    const start = vec3.fromValues(iMin, jMin, kMin);
-    const direction = imageData.getDirection();
-    const rowCosines = direction.slice(0, 3);
-    const columnCosines = direction.slice(3, 6);
-    const scanAxisNormal = direction.slice(6, 9);
-    const spacing = imageData.getSpacing();
-    const [rowSpacing, columnSpacing, scanAxisSpacing] = spacing;
-    const worldPosStart = imageData.indexToWorld(start);
-    const rowStep = vec3.fromValues(rowCosines[0] * rowSpacing, rowCosines[1] * rowSpacing, rowCosines[2] * rowSpacing);
-    const columnStep = vec3.fromValues(columnCosines[0] * columnSpacing, columnCosines[1] * columnSpacing, columnCosines[2] * columnSpacing);
-    const scanAxisStep = vec3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
+    const defaultBoundsIJK = [
+        [0, dimensions[0]],
+        [0, dimensions[1]],
+        [0, dimensions[2]],
+    ];
+    const bounds = boundsIJK || defaultBoundsIJK;
+    const pointsInShape = iterateOverPointsInShape({
+        imageData,
+        bounds,
+        scalarData,
+        pointInShapeFn,
+        callback,
+    });
+    return returnPoints ? pointsInShape : undefined;
+}
+export function iterateOverPointsInShape({ imageData, bounds, scalarData, pointInShapeFn, callback, }) {
+    const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = bounds;
+    const { numComps } = imageData;
+    const dimensions = imageData.getDimensions();
+    const indexToWorld = createPositionCallback(imageData);
+    const pointIJK = [0, 0, 0];
     const xMultiple = numComps ||
         scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
     const yMultiple = dimensions[0] * xMultiple;
     const zMultiple = dimensions[1] * yMultiple;
     const pointsInShape = [];
-    const currentPos = vec3.clone(worldPosStart);
     for (let k = kMin; k <= kMax; k++) {
-        const startPosJ = vec3.clone(currentPos);
+        pointIJK[2] = k;
+        const indexK = k * zMultiple;
         for (let j = jMin; j <= jMax; j++) {
-            const startPosI = vec3.clone(currentPos);
+            pointIJK[1] = j;
+            const indexJK = indexK + j * yMultiple;
             for (let i = iMin; i <= iMax; i++) {
-                const pointIJK = [i, j, k];
-                if (pointInShapeFn(currentPos, pointIJK)) {
-                    const index = k * zMultiple + j * yMultiple + i * xMultiple;
+                pointIJK[0] = i;
+                const pointLPS = indexToWorld(pointIJK);
+                if (pointInShapeFn(pointLPS, pointIJK)) {
+                    const index = indexJK + i * xMultiple;
                     let value;
                     if (xMultiple > 2) {
                         value = [
@@ -69,24 +64,40 @@ export function pointInShapeCallback(imageData, options) {
                         value,
                         index,
                         pointIJK,
-                        pointLPS: currentPos.slice(),
+                        pointLPS: pointLPS.slice(),
                     });
-                    if (callback) {
-                        callback({
-                            value,
-                            index,
-                            pointIJK,
-                            pointLPS: currentPos,
-                        });
-                    }
+                    callback({ value, index, pointIJK, pointLPS });
                 }
-                vec3.add(currentPos, currentPos, rowStep);
             }
-            vec3.copy(currentPos, startPosI);
-            vec3.add(currentPos, currentPos, columnStep);
         }
-        vec3.copy(currentPos, startPosJ);
-        vec3.add(currentPos, currentPos, scanAxisStep);
     }
-    return returnPoints ? pointsInShape : undefined;
+    return pointsInShape;
+}
+export function iterateOverPointsInShapeVoxelManager({ voxelManager, bounds, imageData, pointInShapeFn, callback, }) {
+    const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = bounds;
+    const indexToWorld = createPositionCallback(imageData);
+    const pointIJK = [0, 0, 0];
+    const pointsInShape = [];
+    for (let k = kMin; k <= kMax; k++) {
+        pointIJK[2] = k;
+        for (let j = jMin; j <= jMax; j++) {
+            pointIJK[1] = j;
+            for (let i = iMin; i <= iMax; i++) {
+                pointIJK[0] = i;
+                const pointLPS = indexToWorld(pointIJK);
+                if (pointInShapeFn(pointLPS, pointIJK)) {
+                    const index = voxelManager.toIndex(pointIJK);
+                    const value = voxelManager.getAtIndex(index);
+                    pointsInShape.push({
+                        value,
+                        index,
+                        pointIJK: [...pointIJK],
+                        pointLPS: pointLPS.slice(),
+                    });
+                    callback?.({ value, index, pointIJK, pointLPS });
+                }
+            }
+        }
+    }
+    return pointsInShape;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.3.3",
+  "version": "2.5.0",
   "description": "",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -82,5 +82,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "a438e4c7aeb322805f317b241d27cc3e60edb28b"
+  "gitHead": "e93ccb2022cd1e695f551aef666072b0cbb60952"
 }