@cornerstonejs/tools 2.16.1 → 2.17.0

package/dist/esm/utilities/dynamicVolume/generateImageFromTimeData.d.ts

@@ -1,9 +1,11 @@
 import type { Types } from '@cornerstonejs/core';
 import { Enums } from '@cornerstonejs/core';
 declare function generateImageFromTimeData(dynamicVolume: Types.IDynamicImageVolume, operation: Enums.GenerateImageType, options: {
+    dimensionGroupNumbers?: number[];
     frameNumbers?: number[];
 }): Float32Array;
 declare function updateVolumeFromTimeData(dynamicVolume: Types.IDynamicImageVolume, operation: Enums.GenerateImageType, options: {
+    dimensionGroupNumbers?: number[];
     frameNumbers?: number[];
     targetVolume: Types.IImageVolume;
 }): void;

package/dist/esm/utilities/dynamicVolume/generateImageFromTimeData.js

@@ -1,43 +1,43 @@
 import { Enums } from '@cornerstonejs/core';
-function sumOverFrames(voxelManager, frames) {
+function sumOverDimensionGroups(voxelManager, dimensionGroups) {
     const arrayLength = voxelManager.getScalarDataLength();
     const resultArray = new Float32Array(arrayLength);
-    for (const timepoint of frames) {
-        const scalarData = voxelManager.getTimePointScalarData(timepoint);
+    for (const dimensionGroupNumber of dimensionGroups) {
+        const scalarData = voxelManager.getDimensionGroupScalarData(dimensionGroupNumber);
         for (let i = 0; i < arrayLength; i++) {
             resultArray[i] += scalarData[i];
         }
     }
     return resultArray;
 }
-function averageOverFrames(voxelManager, frames) {
-    const sumArray = sumOverFrames(voxelManager, frames);
-    const numFrames = frames.length;
+function averageOverDimensionGroups(voxelManager, dimensionGroups) {
+    const sumArray = sumOverDimensionGroups(voxelManager, dimensionGroups);
+    const numDimensionGroups = dimensionGroups.length;
     for (let i = 0; i < sumArray.length; i++) {
-        sumArray[i] /= numFrames;
+        sumArray[i] /= numDimensionGroups;
     }
     return sumArray;
 }
 const operationFunctions = {
-    [Enums.GenerateImageType.SUM]: (voxelManager, frames, callback) => {
-        const resultArray = sumOverFrames(voxelManager, frames);
+    [Enums.GenerateImageType.SUM]: (voxelManager, dimensionGroups, callback) => {
+        const resultArray = sumOverDimensionGroups(voxelManager, dimensionGroups);
         for (let i = 0; i < resultArray.length; i++) {
             callback(i, resultArray[i]);
         }
     },
-    [Enums.GenerateImageType.AVERAGE]: (voxelManager, frames, callback) => {
-        const resultArray = averageOverFrames(voxelManager, frames);
+    [Enums.GenerateImageType.AVERAGE]: (voxelManager, dimensionGroups, callback) => {
+        const resultArray = averageOverDimensionGroups(voxelManager, dimensionGroups);
         for (let i = 0; i < resultArray.length; i++) {
             callback(i, resultArray[i]);
         }
     },
-    [Enums.GenerateImageType.SUBTRACT]: (voxelManager, frames, callback) => {
-        if (frames.length !== 2) {
-            throw new Error('Please provide only 2 time points for subtraction.');
+    [Enums.GenerateImageType.SUBTRACT]: (voxelManager, dimensionGroups, callback) => {
+        if (dimensionGroups.length !== 2) {
+            throw new Error('Please provide only 2 dimension groups for subtraction.');
         }
         const arrayLength = voxelManager.getScalarDataLength();
-        const scalarData1 = voxelManager.getTimePointScalarData(frames[0]);
-        const scalarData2 = voxelManager.getTimePointScalarData(frames[1]);
+        const scalarData1 = voxelManager.getDimensionGroupScalarData(dimensionGroups[0]);
+        const scalarData2 = voxelManager.getDimensionGroupScalarData(dimensionGroups[1]);
         for (let i = 0; i < arrayLength; i++) {
             const difference = scalarData1[i] - scalarData2[i];
             callback(i, difference);
@@ -45,10 +45,15 @@ const operationFunctions = {
     },
 };
 function generateImageFromTimeData(dynamicVolume, operation, options) {
-    const { frameNumbers } = options;
-    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
-    if (frames.length <= 1) {
-        throw new Error('Please provide two or more time points');
+    const { dimensionGroupNumbers, frameNumbers } = options;
+    if (frameNumbers) {
+        console.warn('Warning: frameNumbers parameter is deprecated. Please use dimensionGroupNumbers instead.');
+    }
+    const dimensionGroups = dimensionGroupNumbers ||
+        frameNumbers ||
+        Array.from({ length: dynamicVolume.numDimensionGroups }, (_, i) => i + 1);
+    if (dimensionGroups.length <= 1) {
+        throw new Error('Please provide two or more dimension groups');
     }
     const voxelManager = dynamicVolume.voxelManager;
     const arrayLength = voxelManager.getScalarDataLength();
@@ -57,19 +62,24 @@ function generateImageFromTimeData(dynamicVolume, operation, options) {
         throw new Error(`Unsupported operation: ${operation}`);
     }
     const resultArray = new Float32Array(arrayLength);
-    operationFunction(voxelManager, frames, (index, value) => {
+    operationFunction(voxelManager, dimensionGroups, (index, value) => {
         resultArray[index] = value;
     });
     return resultArray;
 }
 function updateVolumeFromTimeData(dynamicVolume, operation, options) {
-    const { frameNumbers, targetVolume } = options;
+    const { dimensionGroupNumbers, frameNumbers, targetVolume } = options;
     if (!targetVolume) {
         throw new Error('A target volume must be provided');
     }
-    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
-    if (frames.length <= 1) {
-        throw new Error('Please provide two or more time points');
+    if (frameNumbers) {
+        console.warn('Warning: frameNumbers parameter is deprecated. Please use dimensionGroupNumbers instead.');
+    }
+    const dimensionGroups = dimensionGroupNumbers ||
+        frameNumbers ||
+        Array.from({ length: dynamicVolume.numDimensionGroups }, (_, i) => i + 1);
+    if (dimensionGroups.length <= 1) {
+        throw new Error('Please provide two or more dimension groups');
     }
     const voxelManager = dynamicVolume.voxelManager;
     const targetVoxelManager = targetVolume.voxelManager;
@@ -77,7 +87,7 @@ function updateVolumeFromTimeData(dynamicVolume, operation, options) {
     if (!operationFunction) {
         throw new Error(`Unsupported operation: ${operation}`);
     }
-    operationFunction(voxelManager, frames, (index, value) => {
+    operationFunction(voxelManager, dimensionGroups, (index, value) => {
         targetVoxelManager.setAtIndex(index, value);
     });
     targetVoxelManager.resetModifiedSlices();

package/dist/esm/utilities/dynamicVolume/getDataInTime.d.ts

@@ -1,7 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
 declare function getDataInTime(dynamicVolume: Types.IDynamicImageVolume, options: {
-    frameNumbers?: any;
-    maskVolumeId?: any;
-    worldCoordinate?: any;
+    dimensionGroupNumbers?: number[];
+    frameNumbers?: number[];
+    maskVolumeId?: string;
+    worldCoordinate?: Types.Point3;
 }): number[] | number[][];
 export default getDataInTime;

package/dist/esm/utilities/dynamicVolume/getDataInTime.js

@@ -2,9 +2,12 @@ import { utilities, cache } from '@cornerstonejs/core';
 import { getVoxelOverlap } from '../segmentation/utilities';
 function getDataInTime(dynamicVolume, options) {
     let dataInTime;
-    const frames = options.frameNumbers || [
-        ...Array(dynamicVolume.numTimePoints).keys(),
-    ];
+    const dimensionGroups = options.dimensionGroupNumbers ||
+        options.frameNumbers ||
+        Array.from({ length: dynamicVolume.numDimensionGroups }, (_, i) => i + 1);
+    if (options.frameNumbers) {
+        console.warn('Warning: frameNumbers parameter is deprecated. Please use dimensionGroupNumbers instead.');
+    }
     if (!options.maskVolumeId && !options.worldCoordinate) {
         throw new Error('You should provide either maskVolumeId or imageCoordinate');
     }
@@ -16,16 +19,16 @@ function getDataInTime(dynamicVolume, options) {
         if (!segmentationVolume) {
             throw new Error('Segmentation volume not found');
         }
-        const [dataInTime, ijkCoords] = _getTimePointDataMask(frames, dynamicVolume, segmentationVolume);
+        const [dataInTime, ijkCoords] = _getDimensionGroupDataMask(dimensionGroups, dynamicVolume, segmentationVolume);
         return [dataInTime, ijkCoords];
     }
     if (options.worldCoordinate) {
-        const dataInTime = _getTimePointDataCoordinate(frames, options.worldCoordinate, dynamicVolume);
+        const dataInTime = _getDimensionGroupDataCoordinate(dimensionGroups, options.worldCoordinate, dynamicVolume);
         return dataInTime;
     }
     return dataInTime;
 }
-function _getTimePointDataCoordinate(frames, coordinate, volume) {
+function _getDimensionGroupDataCoordinate(dimensionGroups, coordinate, volume) {
     const { dimensions, imageData } = volume;
     const index = imageData.worldToIndex(coordinate);
     index[0] = Math.floor(index[0]);
@@ -37,13 +40,13 @@ function _getTimePointDataCoordinate(frames, coordinate, volume) {
     const yMultiple = dimensions[0];
     const zMultiple = dimensions[0] * dimensions[1];
     const value = [];
-    frames.forEach((frame) => {
+    dimensionGroups.forEach((dimensionGroupNumber) => {
         const scalarIndex = index[2] * zMultiple + index[1] * yMultiple + index[0];
-        value.push(volume.voxelManager.getAtIndexAndTimePoint(scalarIndex, frame));
+        value.push(volume.voxelManager.getAtIndexAndDimensionGroup(scalarIndex, dimensionGroupNumber));
     });
     return value;
 }
-function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
+function _getDimensionGroupDataMask(dimensionGroups, dynamicVolume, segmentationVolume) {
     const { imageData: maskImageData } = segmentationVolume;
     const segVoxelManager = segmentationVolume.voxelManager;
     const scalarDataLength = segVoxelManager.getScalarDataLength();
@@ -65,8 +68,8 @@ function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
         for (let i = 0; i < nonZeroVoxelIndices.length; i++) {
             const valuesInTime = [];
             const index = nonZeroVoxelIndices[i];
-            for (let j = 0; j < frames.length; j++) {
-                valuesInTime.push(dynamicVolume.voxelManager.getAtIndexAndTimePoint(index, frames[j]));
+            for (let j = 0; j < dimensionGroups.length; j++) {
+                valuesInTime.push(dynamicVolume.voxelManager.getAtIndexAndDimensionGroup(index, dimensionGroups[j]));
             }
             nonZeroVoxelValuesInTime.push(valuesInTime);
             ijkCoords.push(segVoxelManager.toIJK(index));
@@ -79,13 +82,13 @@ function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
         }
         const overlapIJKMinMax = getVoxelOverlap(dynamicVolume.imageData, dynamicVolume.dimensions, dynamicVolume.spacing, segPointLPS);
         let count = 0;
-        const perFrameSum = new Map();
-        frames.forEach((frame) => perFrameSum.set(frame, 0));
+        const perDimensionGroupSum = new Map();
+        dimensionGroups.forEach((dimensionGroupNumber) => perDimensionGroupSum.set(dimensionGroupNumber, 0));
         const averageCallback = ({ index }) => {
-            for (let i = 0; i < frames.length; i++) {
-                const value = dynamicVolume.voxelManager.getAtIndexAndTimePoint(index, frames[i]);
-                const frame = frames[i];
-                perFrameSum.set(frame, perFrameSum.get(frame) + value);
+            for (let i = 0; i < dimensionGroups.length; i++) {
+                const value = dynamicVolume.voxelManager.getAtIndexAndDimensionGroup(index, dimensionGroups[i]);
+                const dimensionGroupNumber = dimensionGroups[i];
+                perDimensionGroupSum.set(dimensionGroupNumber, perDimensionGroupSum.get(dimensionGroupNumber) + value);
             }
             count++;
         };
@@ -94,7 +97,7 @@ function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
             boundsIJK: overlapIJKMinMax,
         });
         const averageValues = [];
-        perFrameSum.forEach((sum) => {
+        perDimensionGroupSum.forEach((sum) => {
             averageValues.push(sum / count);
         });
         ijkCoords.push(segPointIJK);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.16.1",
+  "version": "2.17.0",
   "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.16.1",
+    "@cornerstonejs/core": "^2.17.0",
     "@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": "bbe715cbc6c3e791783196b5016a1bdec47f46be"
+  "gitHead": "912559cd9b86ddac21f2e0d6087980fc02343f52"
 }