@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/utilities/contours/interpolation/selectHandles.js

@@ -0,0 +1,162 @@
+import { vec3 } from 'gl-matrix';
+import { utilities } from '@cornerstonejs/core';
+const { PointsManager } = utilities;
+export default function selectHandles(polyline, handleCount = 12) {
+    const handles = PointsManager.create3(handleCount);
+    handles.sources = [];
+    const { sources: destPoints } = handles;
+    const { length, sources: sourcePoints = [] } = polyline;
+    const distance = 5;
+    if (length < distance * 3) {
+        return polyline.subselect(handleCount);
+    }
+    const interval = Math.floor(Math.max((2 * length) / handleCount, distance * 2));
+    sourcePoints.forEach(() => destPoints.push(PointsManager.create3(handleCount)));
+    const dotValues = createDotValues(polyline, distance);
+    const minimumRegions = findMinimumRegions(dotValues, handleCount);
+    const indices = [];
+    if (minimumRegions?.length > 2) {
+        let lastHandle = -1;
+        const thirdInterval = interval / 3;
+        minimumRegions.forEach((region) => {
+            const [start, , end] = region;
+            const midIndex = Math.ceil((start + end) / 2);
+            if (end - lastHandle < thirdInterval) {
+                return;
+            }
+            if (midIndex - start > 2 * thirdInterval) {
+                addInterval(indices, lastHandle, start, interval, length);
+                lastHandle = addInterval(indices, start, midIndex, interval, length);
+            }
+            else {
+                lastHandle = addInterval(indices, lastHandle, midIndex, interval, length);
+            }
+            if (end - lastHandle > thirdInterval) {
+                lastHandle = addInterval(indices, lastHandle, end, interval, length);
+            }
+        });
+        const firstHandle = indices[0];
+        const lastDistance = indexValue(firstHandle + length - lastHandle, length);
+        if (lastDistance > 2 * thirdInterval) {
+            addInterval(indices, lastHandle, firstHandle - thirdInterval, interval, length);
+        }
+    }
+    else {
+        const interval = Math.floor(length / handleCount);
+        addInterval(indices, -1, length - interval, interval, length);
+    }
+    indices.forEach((index) => {
+        const point = polyline.getPointArray(index);
+        handles.push(point);
+        sourcePoints.forEach((source, destSourceIndex) => destPoints[destSourceIndex].push(source.getPoint(index)));
+    });
+    return handles;
+}
+export function createDotValues(polyline, distance = 6) {
+    const { length } = polyline;
+    const prevVec3 = vec3.create();
+    const nextVec3 = vec3.create();
+    const dotValues = new Float32Array(length);
+    for (let i = 0; i < length; i++) {
+        const point = polyline.getPoint(i);
+        const prevPoint = polyline.getPoint(i - distance);
+        const nextPoint = polyline.getPoint((i + distance) % length);
+        vec3.sub(prevVec3, point, prevPoint);
+        vec3.sub(nextVec3, nextPoint, point);
+        const dot = vec3.dot(prevVec3, nextVec3) / (vec3.len(prevVec3) * vec3.len(nextVec3));
+        dotValues[i] = dot;
+    }
+    return dotValues;
+}
+function findMinimumRegions(dotValues, handleCount) {
+    const { max, deviation } = getStats(dotValues);
+    const { length } = dotValues;
+    if (deviation < 0.01 || length < handleCount * 3) {
+        return [];
+    }
+    const inflection = [];
+    let pair = null;
+    let minValue;
+    let minIndex = 0;
+    for (let i = 0; i < length; i++) {
+        const dot = dotValues[i];
+        if (dot < max - deviation) {
+            if (pair) {
+                pair[2] = i;
+                if (dot < minValue) {
+                    minValue = dot;
+                    minIndex = i;
+                }
+                pair[1] = minIndex;
+            }
+            else {
+                minValue = dot;
+                minIndex = i;
+                pair = [i, i, i];
+            }
+        }
+        else {
+            if (pair) {
+                inflection.push(pair);
+                pair = null;
+            }
+        }
+    }
+    if (pair) {
+        if (inflection[0][0] === 0) {
+            inflection[0][0] = pair[0];
+        }
+        else {
+            pair[1] = minIndex;
+            pair[2] = length - 1;
+            inflection.push(pair);
+        }
+    }
+    return inflection;
+}
+export function addInterval(indices, start, finish, interval, length) {
+    if (finish < start) {
+        finish += length;
+    }
+    const distance = finish - start;
+    const count = Math.ceil(distance / interval);
+    if (count <= 0) {
+        if (indices[indices.length - 1] !== finish) {
+            indices.push(indexValue(finish, length));
+        }
+        return finish;
+    }
+    for (let i = 1; i <= count; i++) {
+        const index = indexValue(start + (i * distance) / count, length);
+        indices.push(index);
+    }
+    return indices[indices.length - 1];
+}
+function indexValue(v, length) {
+    return (Math.round(v) + length) % length;
+}
+function getStats(dotValues) {
+    const { length } = dotValues;
+    let sum = 0;
+    let min = Infinity;
+    let max = -Infinity;
+    let sumSq = 0;
+    for (let i = 0; i < length; i++) {
+        const dot = dotValues[i];
+        sum += dot;
+        min = Math.min(min, dot);
+        max = Math.max(max, dot);
+    }
+    const mean = sum / length;
+    for (let i = 0; i < length; i++) {
+        const valueDiff = dotValues[i] - mean;
+        sumSq += valueDiff * valueDiff;
+    }
+    return {
+        mean,
+        max,
+        min,
+        sumSq,
+        deviation: Math.sqrt(sumSq / length),
+    };
+}

package/dist/esm/utilities/contours/interpolation/updateChildInterpolationUID.d.ts

@@ -0,0 +1,2 @@
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+export default function updateChildInterpolationUID(annotation: InterpolationROIAnnotation): string;

package/dist/esm/utilities/contours/interpolation/updateChildInterpolationUID.js

@@ -0,0 +1,12 @@
+import * as annotationState from '../../../stateManagement/annotation';
+export default function updateChildInterpolationUID(annotation) {
+    const { parentAnnotationUID, annotationUID } = annotation;
+    if (!parentAnnotationUID) {
+        return annotation.interpolationUID;
+    }
+    const parentAnnotation = annotationState.state.getAnnotation(parentAnnotationUID);
+    const { interpolationUID } = parentAnnotation;
+    const index = parentAnnotation.childAnnotationUIDs.indexOf(annotationUID);
+    annotation.interpolationUID = `${interpolationUID}-${index}`;
+    return annotation.interpolationUID;
+}

package/dist/esm/utilities/contours/reverseIfAntiClockwise.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function reverseIfAntiClockwise(points: Types.Point2[], ...otherListsToReverse: unknown[][]): Types.Point2[];

package/dist/esm/utilities/contours/reverseIfAntiClockwise.js

@@ -0,0 +1,11 @@
+import { getSignedArea } from '../math/polyline';
+export default function reverseIfAntiClockwise(points, ...otherListsToReverse) {
+    const signedArea = getSignedArea(points);
+    if (signedArea < 0) {
+        if (otherListsToReverse) {
+            otherListsToReverse.forEach((list) => list.reverse());
+        }
+        return points.slice().reverse();
+    }
+    return points;
+}

package/dist/esm/utilities/contours/updateContourPolyline.d.ts

@@ -0,0 +1,17 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourAnnotation } from '../../types';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
+export default function updateContourPolyline(annotation: ContourAnnotation, polylineData: {
+    points: Types.Point2[];
+    closed?: boolean;
+    targetWindingDirection?: ContourWindingDirection;
+}, transforms: {
+    canvasToWorld: (point: Types.Point2) => Types.Point3;
+    worldToCanvas: (point: Types.Point3) => Types.Point2;
+}, options?: {
+    updateWindingDirection?: boolean;
+    decimate?: {
+        enabled?: boolean;
+        epsilon?: number;
+    };
+}): void;

package/dist/esm/utilities/contours/updateContourPolyline.js

@@ -0,0 +1,52 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import * as math from '../math';
+import { getParentAnnotation, invalidateAnnotation, } from '../../stateManagement/annotation/annotationState';
+export default function updateContourPolyline(annotation, polylineData, transforms, options) {
+    const { canvasToWorld, worldToCanvas } = transforms;
+    const { data } = annotation;
+    const { targetWindingDirection } = polylineData;
+    let { points: polyline } = polylineData;
+    let windingDirection = math.polyline.getWindingDirection(polyline);
+    if (options?.decimate?.enabled) {
+        polyline = math.polyline.decimate(polylineData.points, options?.decimate?.epsilon);
+    }
+    let { closed } = polylineData;
+    const numPoints = polyline.length;
+    const polylineWorldPoints = new Array(numPoints);
+    const currentPolylineWindingDirection = math.polyline.getWindingDirection(polyline);
+    const parentAnnotation = getParentAnnotation(annotation);
+    if (closed === undefined) {
+        let currentClosedState = false;
+        if (polyline.length > 3) {
+            const lastToFirstDist = math.point.distanceToPointSquared(polyline[0], polyline[numPoints - 1]);
+            currentClosedState = csUtils.isEqual(0, lastToFirstDist);
+        }
+        closed = currentClosedState;
+    }
+    if (options?.updateWindingDirection !== false) {
+        let updatedWindingDirection = parentAnnotation
+            ? parentAnnotation.data.contour.windingDirection * -1
+            : targetWindingDirection;
+        if (updatedWindingDirection === undefined) {
+            updatedWindingDirection = windingDirection;
+        }
+        if (updatedWindingDirection !== windingDirection) {
+            polyline.reverse();
+        }
+        const handlePoints = (data.handles?.points ?? []).map(worldToCanvas);
+        if (handlePoints.length > 2) {
+            const currentHandlesWindingDirection = math.polyline.getWindingDirection(handlePoints);
+            if (currentHandlesWindingDirection !== updatedWindingDirection) {
+                data.handles.points.reverse();
+            }
+        }
+        windingDirection = updatedWindingDirection;
+    }
+    for (let i = 0; i < numPoints; i++) {
+        polylineWorldPoints[i] = canvasToWorld(polyline[i]);
+    }
+    data.contour.polyline = polylineWorldPoints;
+    data.contour.closed = closed;
+    data.contour.windingDirection = windingDirection;
+    invalidateAnnotation(annotation);
+}

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

@@ -0,0 +1,6 @@
+export default debounce;
+declare function debounce(func: Function, wait?: number, options?: {
+    leading?: boolean;
+    maxWait?: number;
+    trailing?: boolean;
+}): Function;

package/dist/esm/utilities/debounce.js

@@ -0,0 +1,113 @@
+import isObject from './isObject';
+function debounce(func, wait, options) {
+    let lastArgs, lastThis, maxWait, result, timerId, lastCallTime;
+    let lastInvokeTime = 0;
+    let leading = false;
+    let maxing = false;
+    let trailing = true;
+    const useRAF = !wait && wait !== 0 && typeof window.requestAnimationFrame === 'function';
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    wait = Number(wait) || 0;
+    if (isObject(options)) {
+        leading = Boolean(options.leading);
+        maxing = 'maxWait' in options;
+        maxWait = maxing ? Math.max(Number(options.maxWait) || 0, wait) : maxWait;
+        trailing = 'trailing' in options ? Boolean(options.trailing) : trailing;
+    }
+    function invokeFunc(time) {
+        const args = lastArgs;
+        const thisArg = lastThis;
+        lastArgs = lastThis = undefined;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+    }
+    function startTimer(pendingFunc, wait) {
+        if (useRAF) {
+            return window.requestAnimationFrame(pendingFunc);
+        }
+        return setTimeout(pendingFunc, wait);
+    }
+    function cancelTimer(id) {
+        if (useRAF) {
+            return window.cancelAnimationFrame(id);
+        }
+        clearTimeout(id);
+    }
+    function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = startTimer(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        const timeWaiting = wait - timeSinceLastCall;
+        return maxing
+            ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
+            : timeWaiting;
+    }
+    function shouldInvoke(time) {
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        return (lastCallTime === undefined ||
+            timeSinceLastCall >= wait ||
+            timeSinceLastCall < 0 ||
+            (maxing && timeSinceLastInvoke >= maxWait));
+    }
+    function timerExpired() {
+        const time = Date.now();
+        if (shouldInvoke(time)) {
+            return trailingEdge(time);
+        }
+        timerId = startTimer(timerExpired, remainingWait(time));
+    }
+    function trailingEdge(time) {
+        timerId = undefined;
+        if (trailing && lastArgs) {
+            return invokeFunc(time);
+        }
+        lastArgs = lastThis = undefined;
+        return result;
+    }
+    function cancel() {
+        if (timerId !== undefined) {
+            cancelTimer(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+    function flush() {
+        return timerId === undefined ? result : trailingEdge(Date.now());
+    }
+    function pending() {
+        return timerId !== undefined;
+    }
+    function debounced(...args) {
+        const time = Date.now();
+        const isInvoking = shouldInvoke(time);
+        lastArgs = args;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+            if (timerId === undefined) {
+                return leadingEdge(lastCallTime);
+            }
+            if (maxing) {
+                timerId = startTimer(timerExpired, wait);
+                return invokeFunc(lastCallTime);
+            }
+        }
+        if (timerId === undefined) {
+            timerId = startTimer(timerExpired, wait);
+        }
+        return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    debounced.pending = pending;
+    return debounced;
+}
+export default debounce;

package/dist/esm/utilities/drawing/getTextBoxCoordsCanvas.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getTextBoxCoordsCanvas(annotationCanvasPoints: Array<Types.Point2>): Types.Point2;

package/dist/esm/utilities/drawing/getTextBoxCoordsCanvas.js

@@ -0,0 +1,24 @@
+export default function getTextBoxCoordsCanvas(annotationCanvasPoints) {
+    const corners = _determineCorners(annotationCanvasPoints);
+    const centerY = (corners.top[1] + corners.bottom[1]) / 2;
+    const textBoxCanvas = [corners.right[0], centerY];
+    return textBoxCanvas;
+}
+function _determineCorners(canvasPoints) {
+    const handlesLeftToRight = [canvasPoints[0], canvasPoints[1]].sort(_compareX);
+    const handlesTopToBottom = [canvasPoints[0], canvasPoints[1]].sort(_compareY);
+    const right = handlesLeftToRight[handlesLeftToRight.length - 1];
+    const top = handlesTopToBottom[0];
+    const bottom = handlesTopToBottom[handlesTopToBottom.length - 1];
+    return {
+        top,
+        bottom,
+        right,
+    };
+    function _compareX(a, b) {
+        return a[0] < b[0] ? -1 : 1;
+    }
+    function _compareY(a, b) {
+        return a[1] < b[1] ? -1 : 1;
+    }
+}

package/dist/esm/utilities/drawing/index.d.ts

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

package/dist/esm/utilities/drawing/index.js

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

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

@@ -0,0 +1,12 @@
+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;
+export { generateImageFromTimeData, updateVolumeFromTimeData };

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

@@ -0,0 +1,98 @@
+import { Enums } from '@cornerstonejs/core';
+function sumOverDimensionGroups(voxelManager, dimensionGroups) {
+    const arrayLength = voxelManager.getScalarDataLength();
+    const resultArray = new Float32Array(arrayLength);
+    for (const dimensionGroupNumber of dimensionGroups) {
+        const scalarData = voxelManager.getDimensionGroupScalarData(dimensionGroupNumber);
+        for (let i = 0; i < arrayLength; i++) {
+            resultArray[i] += scalarData[i];
+        }
+    }
+    return resultArray;
+}
+function averageOverDimensionGroups(voxelManager, dimensionGroups) {
+    const sumArray = sumOverDimensionGroups(voxelManager, dimensionGroups);
+    const numDimensionGroups = dimensionGroups.length;
+    for (let i = 0; i < sumArray.length; i++) {
+        sumArray[i] /= numDimensionGroups;
+    }
+    return sumArray;
+}
+const operationFunctions = {
+    [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, dimensionGroups, callback) => {
+        const resultArray = averageOverDimensionGroups(voxelManager, dimensionGroups);
+        for (let i = 0; i < resultArray.length; i++) {
+            callback(i, resultArray[i]);
+        }
+    },
+    [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.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);
+        }
+    },
+};
+function generateImageFromTimeData(dynamicVolume, operation, options) {
+    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();
+    const operationFunction = operationFunctions[operation];
+    if (!operationFunction) {
+        throw new Error(`Unsupported operation: ${operation}`);
+    }
+    const resultArray = new Float32Array(arrayLength);
+    operationFunction(voxelManager, dimensionGroups, (index, value) => {
+        resultArray[index] = value;
+    });
+    return resultArray;
+}
+function updateVolumeFromTimeData(dynamicVolume, operation, options) {
+    const { dimensionGroupNumbers, frameNumbers, targetVolume } = options;
+    if (!targetVolume) {
+        throw new Error('A target volume must be provided');
+    }
+    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;
+    const operationFunction = operationFunctions[operation];
+    if (!operationFunction) {
+        throw new Error(`Unsupported operation: ${operation}`);
+    }
+    operationFunction(voxelManager, dimensionGroups, (index, value) => {
+        targetVoxelManager.setAtIndex(index, value);
+    });
+    targetVoxelManager.resetModifiedSlices();
+    for (let k = 0; k < targetVolume.dimensions[2]; k++) {
+        targetVoxelManager.modifiedSlices.add(k);
+    }
+}
+export { generateImageFromTimeData, updateVolumeFromTimeData };

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

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

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

@@ -0,0 +1,111 @@
+import { utilities, cache } from '@cornerstonejs/core';
+import { getVoxelOverlap } from '../segmentation/utilities';
+function getDataInTime(dynamicVolume, options) {
+    let dataInTime;
+    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');
+    }
+    if (options.maskVolumeId && options.worldCoordinate) {
+        throw new Error('You can only use one of maskVolumeId or imageCoordinate');
+    }
+    if (options.maskVolumeId) {
+        const segmentationVolume = cache.getVolume(options.maskVolumeId);
+        if (!segmentationVolume) {
+            throw new Error('Segmentation volume not found');
+        }
+        const [dataInTime, ijkCoords] = _getDimensionGroupDataMask(dimensionGroups, dynamicVolume, segmentationVolume);
+        return [dataInTime, ijkCoords];
+    }
+    if (options.worldCoordinate) {
+        const dataInTime = _getDimensionGroupDataCoordinate(dimensionGroups, options.worldCoordinate, dynamicVolume);
+        return dataInTime;
+    }
+    return dataInTime;
+}
+function _getDimensionGroupDataCoordinate(dimensionGroups, coordinate, volume) {
+    const { dimensions, imageData } = volume;
+    const index = imageData.worldToIndex(coordinate);
+    index[0] = Math.floor(index[0]);
+    index[1] = Math.floor(index[1]);
+    index[2] = Math.floor(index[2]);
+    if (!utilities.indexWithinDimensions(index, dimensions)) {
+        throw new Error('outside bounds');
+    }
+    const yMultiple = dimensions[0];
+    const zMultiple = dimensions[0] * dimensions[1];
+    const value = [];
+    dimensionGroups.forEach((dimensionGroupNumber) => {
+        const scalarIndex = index[2] * zMultiple + index[1] * yMultiple + index[0];
+        value.push(volume.voxelManager.getAtIndexAndDimensionGroup(scalarIndex, dimensionGroupNumber));
+    });
+    return value;
+}
+function _getDimensionGroupDataMask(dimensionGroups, dynamicVolume, segmentationVolume) {
+    const { imageData: maskImageData } = segmentationVolume;
+    const segVoxelManager = segmentationVolume.voxelManager;
+    const scalarDataLength = segVoxelManager.getScalarDataLength();
+    const nonZeroVoxelIndices = [];
+    nonZeroVoxelIndices.length = scalarDataLength;
+    let actualLen = 0;
+    for (let i = 0, len = scalarDataLength; i < len; i++) {
+        if (segVoxelManager.getAtIndex(i) !== 0) {
+            nonZeroVoxelIndices[actualLen++] = i;
+        }
+    }
+    nonZeroVoxelIndices.length = actualLen;
+    const nonZeroVoxelValuesInTime = [];
+    const isSameVolume = dynamicVolume.voxelManager.getScalarDataLength() === scalarDataLength &&
+        JSON.stringify(dynamicVolume.spacing) ===
+            JSON.stringify(segmentationVolume.spacing);
+    const ijkCoords = [];
+    if (isSameVolume) {
+        for (let i = 0; i < nonZeroVoxelIndices.length; i++) {
+            const valuesInTime = [];
+            const index = nonZeroVoxelIndices[i];
+            for (let j = 0; j < dimensionGroups.length; j++) {
+                valuesInTime.push(dynamicVolume.voxelManager.getAtIndexAndDimensionGroup(index, dimensionGroups[j]));
+            }
+            nonZeroVoxelValuesInTime.push(valuesInTime);
+            ijkCoords.push(segVoxelManager.toIJK(index));
+        }
+        return [nonZeroVoxelValuesInTime, ijkCoords];
+    }
+    const callback = ({ pointLPS: segPointLPS, value: segValue, pointIJK: segPointIJK, }) => {
+        if (segValue === 0) {
+            return;
+        }
+        const overlapIJKMinMax = getVoxelOverlap(dynamicVolume.imageData, dynamicVolume.dimensions, dynamicVolume.spacing, segPointLPS);
+        let count = 0;
+        const perDimensionGroupSum = new Map();
+        dimensionGroups.forEach((dimensionGroupNumber) => perDimensionGroupSum.set(dimensionGroupNumber, 0));
+        const averageCallback = ({ index }) => {
+            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++;
+        };
+        dynamicVolume.voxelManager.forEach(averageCallback, {
+            imageData: dynamicVolume.imageData,
+            boundsIJK: overlapIJKMinMax,
+        });
+        const averageValues = [];
+        perDimensionGroupSum.forEach((sum) => {
+            averageValues.push(sum / count);
+        });
+        ijkCoords.push(segPointIJK);
+        nonZeroVoxelValuesInTime.push(averageValues);
+    };
+    segmentationVolume.voxelManager.forEach(callback, {
+        imageData: maskImageData,
+    });
+    return [nonZeroVoxelValuesInTime, ijkCoords];
+}
+export default getDataInTime;

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

@@ -0,0 +1,4 @@
+import getDataInTime from './getDataInTime';
+import { generateImageFromTimeData, updateVolumeFromTimeData } from './generateImageFromTimeData';
+export { getDataInTime };
+export { generateImageFromTimeData, updateVolumeFromTimeData };

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

@@ -0,0 +1,4 @@
+import getDataInTime from './getDataInTime';
+import { generateImageFromTimeData, updateVolumeFromTimeData, } from './generateImageFromTimeData';
+export { getDataInTime };
+export { generateImageFromTimeData, updateVolumeFromTimeData };