@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/esm/types/InternalToolTypes.d.ts

@@ -1,6 +1,6 @@
-import { Types } from '@cornerstonejs/core';
-import { AnnotationTool } from '../tools';
-import { Annotation, Annotations } from './AnnotationTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { AnnotationTool } from '../tools';
+import type { Annotation, Annotations } from './AnnotationTypes';
 type ToolAnnotationsPair = {
     tool: AnnotationTool;
     annotations: Annotations;
@@ -12,4 +12,4 @@ type ToolAnnotationPair = {
 type ToolsWithMoveableHandles = ToolAnnotationPair & {
     handle: Types.Point3;
 };
-export { ToolsWithMoveableHandles, ToolAnnotationsPair, ToolAnnotationPair };
+export type { ToolsWithMoveableHandles, ToolAnnotationsPair, ToolAnnotationPair, };

package/dist/esm/types/InterpolationTypes.d.ts

@@ -1,6 +1,6 @@
-import { Types } from '@cornerstonejs/core';
-import { Annotation } from './AnnotationTypes';
-import { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+import type { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
 export type InterpolationViewportData = {
     annotation: InterpolationROIAnnotation;
     interpolationUID: string;

package/dist/esm/types/JumpToSliceOptions.d.ts

@@ -3,4 +3,4 @@ type JumpToSliceOptions = {
     debounceLoading?: boolean;
     volumeId?: string;
 };
-export default JumpToSliceOptions;
+export type { JumpToSliceOptions as default };

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
+import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
 type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
@@ -10,10 +10,11 @@ type LabelmapToolOperationData = {
     strategySpecificConfiguration: any;
     segmentationRepresentationUID: string;
     points: Types.Point3[];
+    voxelManager: any;
     preview: any;
     toolGroupId: string;
 };
 type LabelmapToolOperationDataStack = LabelmapToolOperationData & LabelmapSegmentationDataStack;
 type LabelmapToolOperationDataVolume = LabelmapToolOperationData & LabelmapSegmentationDataVolume;
 type LabelmapToolOperationDataAny = LabelmapToolOperationDataVolume | LabelmapToolOperationDataStack;
-export { LabelmapToolOperationData, LabelmapToolOperationDataAny, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, };
+export type { LabelmapToolOperationData, LabelmapToolOperationDataAny, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, };

package/dist/esm/types/PlanarBoundingBox.d.ts

@@ -4,4 +4,4 @@ type PlanarBoundingBox = {
     width: number;
     height: number;
 };
-export default PlanarBoundingBox;
+export type { PlanarBoundingBox as default };

package/dist/esm/types/SVGDrawingHelper.d.ts

@@ -6,4 +6,4 @@ type SVGDrawingHelper = {
     setNodeTouched: (cacheKey: string) => void;
     clearUntouched: () => void;
 };
-export default SVGDrawingHelper;
+export type { SVGDrawingHelper as default };

package/dist/esm/types/ScrollOptions.d.ts

@@ -5,4 +5,4 @@ type ScrollOptions = {
     loop?: boolean;
     scrollSlabs?: boolean;
 };
-export default ScrollOptions;
+export type { ScrollOptions as default };

package/dist/esm/types/SegmentationStateTypes.d.ts

@@ -1,15 +1,16 @@
 import type { Types } from '@cornerstonejs/core';
-import * as Enums from '../enums';
-import { ContourConfig, ContourRenderingConfig, ContourSegmentationData } from './ContourTypes';
+import type * as Enums from '../enums';
+import type { ContourConfig, ContourRenderingConfig, ContourSegmentationData } from './ContourTypes';
 import type { LabelmapConfig, LabelmapRenderingConfig, LabelmapSegmentationData } from './LabelmapTypes';
-import { SurfaceSegmentationData, SurfaceRenderingConfig } from './SurfaceTypes';
+import type { SurfaceSegmentationData, SurfaceRenderingConfig } from './SurfaceTypes';
 export type SegmentRepresentationConfig = {
     [key: number | string]: RepresentationConfig;
 };
+export type SurfaceConfig = {};
 export type RepresentationConfig = {
     LABELMAP?: LabelmapConfig;
     CONTOUR?: ContourConfig;
-    SURFACE?: any;
+    SURFACE?: SurfaceConfig;
 };
 export type SegmentationRepresentationConfig = {
     renderInactiveRepresentations: boolean;
@@ -41,7 +42,7 @@ export type BaseSegmentationRepresentation = {
     colorLUTIndex: number;
     polySeg?: {
         enabled: boolean;
-        options?: any;
+        options?: unknown;
     };
     config: {
         allSegments?: RepresentationConfig;
@@ -92,6 +93,6 @@ export type RepresentationPublicInputOptions = {
     colorLUTOrIndex?: Types.ColorLUT | number;
     polySeg?: {
         enabled: boolean;
-        options?: any;
+        options?: unknown;
     };
 };

package/dist/esm/types/SplineCurveSegment.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import type { SplineLineSegment } from './SplineLineSegment';
 export type SplineCurveSegment = {
     controlPoints: {

package/dist/esm/types/SplineLineSegment.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export type SplineLineSegment = {
     points: {
         start: Types.Point2;

package/dist/esm/types/ToolAction.d.ts

@@ -5,4 +5,4 @@ type ToolAction = {
     method: string | ((evt: InteractionEventType, annotation: Annotation) => void);
     bindings: SetToolBindingsType[];
 };
-export default ToolAction;
+export type { ToolAction as default };

package/dist/esm/types/ToolHandle.d.ts

@@ -11,5 +11,5 @@ type TextBoxHandle = {
     worldPosition: Types.Point3;
 };
 type ToolHandle = AnnotationHandle | TextBoxHandle;
-export default ToolHandle;
 export type { AnnotationHandle, TextBoxHandle };
+export type { ToolHandle as default };

package/dist/esm/types/ToolProps.d.ts

@@ -1,4 +1,4 @@
-import { Calculator } from '../utilities/math/basic';
+import type { Calculator } from '../utilities/math/basic';
 type SharedToolProp = {
     supportedInteractionTypes?: Array<string>;
     configuration?: ToolConfiguration;

package/dist/esm/types/ToolSpecificAnnotationTypes.d.ts

@@ -1,9 +1,9 @@
 import type { Types } from '@cornerstonejs/core';
-import { Annotation } from './AnnotationTypes';
-import { ISpline } from './';
-import { ContourSegmentationAnnotationData } from './ContourSegmentationAnnotation';
-import { ContourAnnotation } from './ContourAnnotation';
-interface ROICachedStats {
+import type { Annotation } from './AnnotationTypes';
+import type { ISpline } from './';
+import type { ContourSegmentationAnnotationData } from './ContourSegmentationAnnotation';
+import type { ContourAnnotation } from './ContourAnnotation';
+export interface ROICachedStats {
     [targetId: string]: {
         Modality: string;
         area: number;
@@ -216,22 +216,33 @@ export interface RectangleROIStartEndThresholdAnnotation extends Annotation {
         FrameOfReferenceUID: string;
         referencedImageId?: string;
         toolName: string;
-        enabledElement: any;
+        enabledElement: Types.IEnabledElement;
         volumeId: string;
         spacingInNormal: number;
     };
     data: {
         label: string;
-        startSlice: number;
-        endSlice: number;
+        startCoordinate: number;
+        endCoordinate: number;
         cachedStats: {
             pointsInVolume: Types.Point3[];
             projectionPoints: Types.Point3[][];
             projectionPointsImageIds: string[];
+            statistics?: ROICachedStats;
         };
         handles: {
             points: Types.Point3[];
             activeHandleIndex: number | null;
+            textBox: {
+                hasMoved: boolean;
+                worldPosition: Types.Point3;
+                worldBoundingBox: {
+                    topLeft: Types.Point3;
+                    topRight: Types.Point3;
+                    bottomLeft: Types.Point3;
+                    bottomRight: Types.Point3;
+                };
+            };
         };
     };
 }
@@ -245,21 +256,32 @@ export interface CircleROIStartEndThresholdAnnotation extends Annotation {
         FrameOfReferenceUID: string;
         referencedImageId?: string;
         toolName: string;
-        enabledElement: any;
+        enabledElement: Types.IEnabledElement;
         volumeId: string;
         spacingInNormal: number;
     };
     data: {
         label: string;
-        startSlice: number;
-        endSlice: number;
+        startCoordinate: number;
+        endCoordinate: number;
         cachedStats?: {
             pointsInVolume: Types.Point3[];
             projectionPoints: Types.Point3[][];
+            statistics?: ROICachedStats;
         };
         handles: {
             points: [Types.Point3, Types.Point3];
             activeHandleIndex: number | null;
+            textBox?: {
+                hasMoved: boolean;
+                worldPosition: Types.Point3;
+                worldBoundingBox: {
+                    topLeft: Types.Point3;
+                    topRight: Types.Point3;
+                    bottomLeft: Types.Point3;
+                    bottomRight: Types.Point3;
+                };
+            };
         };
     };
 }
@@ -433,7 +455,7 @@ export interface VideoRedactionAnnotation extends Annotation {
             activeHandleIndex: number | null;
         };
         cachedStats: {
-            [key: string]: any;
+            [key: string]: unknown;
         };
         active: boolean;
     };

package/dist/esm/types/index.d.ts

@@ -23,7 +23,7 @@ import type BoundsIJK from './BoundsIJK';
 import type SVGDrawingHelper from './SVGDrawingHelper';
 import type * as CINETypes from './CINETypes';
 import type { RepresentationConfig, SegmentationRepresentationConfig, SegmentationRepresentationData, Segmentation, SegmentationState, RepresentationPublicInput } from './SegmentationStateTypes';
-import { ISculptToolShape } from './ISculptToolShape';
+import type { ISculptToolShape } from './ISculptToolShape';
 import type ISynchronizerEventHandler from './ISynchronizerEventHandler';
 import type { FloodFillGetter, FloodFillOptions, FloodFillResult } from './FloodFillTypes';
 import type IToolClassReference from './IToolClassReference';
@@ -33,7 +33,7 @@ import type AnnotationGroupSelector from './AnnotationGroupSelector';
 import type AnnotationRenderContext from './AnnotationRenderContext';
 import type { Statistics, NamedStatistics } from './CalculatorTypes';
 import type { CanvasCoordinates } from '../utilities/math/ellipse/getCanvasEllipseCorners';
-import { LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume } from './LabelmapToolOperationData';
+import type { LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume } from './LabelmapToolOperationData';
 import type { InterpolationViewportData, ImageInterpolationData } from './InterpolationTypes';
 import type { CardinalSplineProps } from './CardinalSplineProps';
 import type { ClosestControlPoint } from './ClosestControlPoint';

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

@@ -1,4 +1,4 @@
-import { Annotation } from '../types';
+import type { Annotation } from '../types';
 export type FramesRange = [number, number] | number;
 export default class AnnotationFrameRange {
     protected static frameRangeExtractor: RegExp;

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

@@ -1,5 +1,6 @@
-import { Types, StackViewport } from '@cornerstonejs/core';
-import { Annotation } from '../types';
+import type { Types } from '@cornerstonejs/core';
+import { StackViewport } from '@cornerstonejs/core';
+import type { Annotation } from '../types';
 declare function annotationHydration(viewport: Types.IViewport, toolName: string, worldPoints: Types.Point3[], options?: {
     FrameOfReferenceUID?: string;
     annotationUID?: string;

package/dist/esm/utilities/cine/playClip.d.ts

@@ -1,4 +1,8 @@
-import { CINETypes } from '../../types';
+import type { CINETypes } from '../../types';
+type StopClipOptions = {
+    stopDynamicCine: boolean;
+    viewportId?: string;
+};
 declare function playClip(element: HTMLDivElement, playClipOptions: CINETypes.PlayClipOptions): void;
-declare function stopClip(element: HTMLDivElement, options?: any): void;
+declare function stopClip(element: HTMLDivElement, options?: StopClipOptions): void;
 export { playClip, stopClip };

package/dist/esm/utilities/cine/playClip.js

@@ -1,5 +1,5 @@
 import { glMatrix, vec3 } from 'gl-matrix';
-import { utilities as csUtils, getEnabledElement, StackViewport, VolumeViewport, cache, BaseVolumeViewport, Enums, } from '@cornerstonejs/core';
+import { utilities as csUtils, getEnabledElement, StackViewport, VideoViewport, VolumeViewport, cache, BaseVolumeViewport, Enums, } from '@cornerstonejs/core';
 import CINE_EVENTS from './events';
 import { addToolState, getToolState, getToolStateByViewportId } from './state';
 import scroll from '../scroll';
@@ -86,13 +86,24 @@ function playClip(element, playClipOptions) {
         }
         const delta = newStepIndex - currentStepIndex;
         if (delta) {
-            playClipContext.scroll(delta);
+            try {
+                playClipContext.scroll(delta);
+            }
+            catch (e) {
+                console.warn('Play clip not scrolling', e);
+                _stopClipWithData(playClipData);
+                triggerEvent(element, CINE_EVENTS.CLIP_STOPPED, eventDetail);
+                return;
+            }
         }
     };
     if (isDynamicCinePlaying) {
         dynamicVolumesPlayingMap.set(volume.volumeId, element);
     }
-    if (playClipTimeouts &&
+    if (playClipContext.play) {
+        playClipData.framesPerSecond = playClipContext.play(playClipOptions.framesPerSecond);
+    }
+    else if (playClipTimeouts &&
         playClipTimeouts.length > 0 &&
         playClipIsTimeVarying) {
         playClipData.usingFrameTimeVector = true;
@@ -120,6 +131,7 @@ function _stopClip(element, options = { stopDynamicCine: true, viewportId: undef
     const { stopDynamicCine, viewportId } = options;
     const enabledElement = getEnabledElement(element);
     let toolState;
+    const viewport = enabledElement?.viewport;
     if (!enabledElement) {
         if (viewportId) {
             toolState = getToolStateByViewportId(viewportId);
@@ -135,8 +147,10 @@ function _stopClip(element, options = { stopDynamicCine: true, viewportId: undef
     if (toolState) {
         _stopClipWithData(toolState);
     }
-    if (stopDynamicCine &&
-        enabledElement?.viewport instanceof BaseVolumeViewport) {
+    if (viewport instanceof VideoViewport) {
+        viewport.pause();
+    }
+    else if (stopDynamicCine && viewport instanceof BaseVolumeViewport) {
         _stopDynamicVolumeCine(element);
     }
 }
@@ -231,6 +245,36 @@ function _createStackViewportCinePlayContext(viewport, waitForRendered) {
         },
     };
 }
+function _createVideoViewportCinePlayContext(viewport, waitForRendered) {
+    return {
+        get numScrollSteps() {
+            return viewport.getNumberOfSlices();
+        },
+        get currentStepIndex() {
+            return viewport.getSliceIndex();
+        },
+        get frameTimeVectorEnabled() {
+            return true;
+        },
+        waitForRenderedCount: 0,
+        scroll(delta) {
+            if (this.waitForRenderedCount <= waitForRendered &&
+                viewport.viewportStatus !== ViewportStatus.RENDERED) {
+                this.waitForRenderedCount++;
+                return;
+            }
+            this.waitForRenderedCount = 0;
+            scroll(viewport, { delta, debounceLoading: debounced });
+        },
+        play(fps) {
+            if (fps) {
+                viewport.setPlaybackRate(fps / 24);
+            }
+            viewport.play();
+            return viewport.getFrameRate();
+        },
+    };
+}
 function _createVolumeViewportCinePlayContext(viewport, volume) {
     const { volumeId } = volume;
     const cachedScrollInfo = {
@@ -281,7 +325,7 @@ function _createDynamicVolumeViewportCinePlayContext(volume) {
             return false;
         },
         scroll(delta) {
-            volume.timePointIndex += delta;
+            volume.scroll(delta);
         },
     };
 }
@@ -296,6 +340,9 @@ function _createCinePlayContext(viewport, playClipOptions) {
         }
         return _createVolumeViewportCinePlayContext(viewport, volume);
     }
+    if (viewport instanceof VideoViewport) {
+        return _createVideoViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
+    }
     throw new Error('Unknown viewport type');
 }
 export { playClip, stopClip };

package/dist/esm/utilities/cine/state.d.ts

@@ -1,4 +1,4 @@
-import { CINETypes } from '../../types';
+import type { CINETypes } from '../../types';
 declare function addToolState(element: HTMLDivElement, data: CINETypes.ToolData): void;
 declare function getToolState(element: HTMLDivElement): CINETypes.ToolData | undefined;
 declare function getToolStateByViewportId(viewportId: string): CINETypes.ToolData | undefined;

package/dist/esm/utilities/contourSegmentation/addContourSegmentationAnnotation.d.ts

@@ -1,2 +1,2 @@
-import { ContourSegmentationAnnotation } from '../../types';
+import type { ContourSegmentationAnnotation } from '../../types';
 export declare function addContourSegmentationAnnotation(annotation: ContourSegmentationAnnotation): void;

package/dist/esm/utilities/contourSegmentation/areSameSegment.d.ts

@@ -1,2 +1,2 @@
-import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
 export default function areSameSegment(firstAnnotation: ContourSegmentationAnnotation, secondAnnotation: ContourSegmentationAnnotation): boolean;

package/dist/esm/utilities/contourSegmentation/isContourSegmentationAnnotation.d.ts

@@ -1,3 +1,3 @@
-import { Annotation } from '../../types';
-import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import type { Annotation } from '../../types';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
 export default function isContourSegmentationAnnotation(annotation: Annotation): annotation is ContourSegmentationAnnotation;

package/dist/esm/utilities/contourSegmentation/removeContourSegmentationAnnotation.d.ts

@@ -1,2 +1,2 @@
-import { ContourSegmentationAnnotation } from '../../types';
+import type { ContourSegmentationAnnotation } from '../../types';
 export declare function removeContourSegmentationAnnotation(annotation: ContourSegmentationAnnotation): void;

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

@@ -1,5 +1,5 @@
 declare class AnnotationToPointData {
-    static TOOL_NAMES: Record<string, any>;
+    static TOOL_NAMES: Record<string, unknown>;
     constructor();
     static convert(annotation: any, index: any, metadataProvider: any): {
         ReferencedROINumber: any;

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

@@ -1,2 +1,2 @@
-import { ContourAnnotation } from '../../types/ContourAnnotation';
+import type { ContourAnnotation } from '../../types/ContourAnnotation';
 export default function areCoplanarContours(firstAnnotation: ContourAnnotation, secondAnnotation: ContourAnnotation): boolean;

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

@@ -1,2 +1,2 @@
-import { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 export default function findHandlePolylineIndex(annotation: ContourAnnotation, handleIndex: number): number;

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

@@ -1,2 +1,2 @@
-import { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 export default function createPolylineToolData(polyline: any, handlePoints: any, referencedToolData: any): InterpolationROIAnnotation;

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

@@ -1,6 +1,6 @@
 import type { InterpolationViewportData, Annotation } from '../../../types';
 export type FilterParam = {
-    parentKey?: (annotation: any) => any;
+    parentKey?: (annotation: Annotation) => unknown;
     key: string;
     value: unknown;
 };

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

@@ -4,7 +4,7 @@ export type PointsXYZI = Types.PointsXYZ & {
     I?: boolean[];
     kIndex?: number;
 };
-export type PointsArray3 = Types.PointsManager<Types.Point3> & {
+export type PointsArray3 = Types.IPointsManager<Types.Point3> & {
     I?: boolean[];
 };
 declare function interpolate(viewportData: InterpolationViewportData): void;

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

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

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

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import type { ContourAnnotation } from '../../types';
 import type { ContourWindingDirection } from '../../types/ContourAnnotation';
 export default function updateContourPolyline(annotation: ContourAnnotation, polylineData: {

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

@@ -1,3 +1,4 @@
-import { Types } from '@cornerstonejs/core';
-declare function generateImageFromTimeData(dynamicVolume: Types.IDynamicImageVolume, operation: string, frameNumbers?: number[]): Float32Array;
+import type { Types } from '@cornerstonejs/core';
+import { Enums } from '@cornerstonejs/core';
+declare function generateImageFromTimeData(dynamicVolume: Types.IDynamicImageVolume, operation: Enums.GenerateImageType, frameNumbers?: number[]): Float32Array;
 export default generateImageFromTimeData;

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

@@ -1,42 +1,50 @@
 import { Enums } from '@cornerstonejs/core';
-function generateImageFromTimeData(dynamicVolume, operation, frameNumbers) {
-    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
-    const numFrames = frames.length;
-    if (frames.length <= 1) {
-        throw new Error('Please provide two or more time points');
-    }
-    const typedArrays = dynamicVolume.getScalarDataArrays();
-    const arrayLength = typedArrays[0].length;
-    const finalArray = new Float32Array(arrayLength);
-    if (operation === Enums.DynamicOperatorType.SUM) {
-        for (let i = 0; i < numFrames; i++) {
-            const currentArray = typedArrays[frames[i]];
+const operationFunctions = {
+    [Enums.GenerateImageType.SUM]: (voxelManager, frames, arrayLength) => {
+        const finalArray = new Float32Array(arrayLength);
+        for (const timepoint of frames) {
             for (let j = 0; j < arrayLength; j++) {
-                finalArray[j] += currentArray[j];
+                finalArray[j] += voxelManager.getAtIndexAndTimePoint(j, timepoint);
             }
         }
         return finalArray;
-    }
-    if (operation === Enums.DynamicOperatorType.SUBTRACT) {
-        if (frames.length > 2) {
+    },
+    [Enums.GenerateImageType.SUBTRACT]: (voxelManager, frames, arrayLength) => {
+        if (frames.length !== 2) {
             throw new Error('Please provide only 2 time points for subtraction.');
         }
+        const finalArray = new Float32Array(arrayLength);
         for (let j = 0; j < arrayLength; j++) {
-            finalArray[j] += typedArrays[frames[0]][j] - typedArrays[frames[1]][j];
+            finalArray[j] =
+                voxelManager.getAtIndexAndTimePoint(j, frames[0]) -
+                    voxelManager.getAtIndexAndTimePoint(j, frames[1]);
         }
         return finalArray;
-    }
-    if (operation === Enums.DynamicOperatorType.AVERAGE) {
-        for (let i = 0; i < numFrames; i++) {
-            const currentArray = typedArrays[frames[i]];
+    },
+    [Enums.GenerateImageType.AVERAGE]: (voxelManager, frames, arrayLength) => {
+        const finalArray = new Float32Array(arrayLength);
+        for (const timepoint of frames) {
             for (let j = 0; j < arrayLength; j++) {
-                finalArray[j] += currentArray[j];
+                finalArray[j] += voxelManager.getAtIndexAndTimePoint(j, timepoint);
             }
         }
         for (let k = 0; k < arrayLength; k++) {
-            finalArray[k] = finalArray[k] / numFrames;
+            finalArray[k] /= frames.length;
         }
         return finalArray;
+    },
+};
+function generateImageFromTimeData(dynamicVolume, operation, frameNumbers) {
+    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
+    if (frames.length <= 1) {
+        throw new Error('Please provide two or more time points');
+    }
+    const voxelManager = dynamicVolume.voxelManager;
+    const arrayLength = voxelManager.getScalarDataLength();
+    const operationFunction = operationFunctions[operation];
+    if (!operationFunction) {
+        throw new Error(`Unsupported operation: ${operation}`);
     }
+    return operationFunction(voxelManager, frames, arrayLength);
 }
 export default generateImageFromTimeData;

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

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function getDataInTime(dynamicVolume: Types.IDynamicImageVolume, options: {
     frameNumbers?: any;
     maskVolumeId?: any;