@cornerstonejs/core 4.14.6 → 4.15.1

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -787,6 +787,7 @@ class BaseVolumeViewport extends Viewport {
                 colormap,
                 preset,
                 slabThickness,
+                sampleDistanceMultiplier,
             });
         }
         if (invert !== undefined && this.viewportProperties.invert !== invert) {

package/dist/esm/cache/classes/BaseStreamingImageVolume.d.ts

@@ -28,8 +28,8 @@ export declare class BaseStreamingImageVolume extends ImageVolume implements IIm
     getLoaderImageOptions(imageId: string): {
         targetBuffer: {
             type: import("../../types").PixelDataTypedArrayString;
-            rows: any;
-            columns: any;
+            rows: number;
+            columns: number;
         };
         allowFloatRendering: boolean;
         preScale: {
@@ -54,8 +54,8 @@ export declare class BaseStreamingImageVolume extends ImageVolume implements IIm
         options: {
             targetBuffer: {
                 type: import("../../types").PixelDataTypedArrayString;
-                rows: any;
-                columns: any;
+                rows: number;
+                columns: number;
             };
             allowFloatRendering: boolean;
             preScale: {

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -196,8 +196,8 @@ export class BaseStreamingImageVolume extends ImageVolume {
     }
     getLoaderImageOptions(imageId) {
         const { transferSyntaxUID: transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
-        const imagePlaneModule = metaData.get('imagePlaneModule', imageId) || {};
-        const { rows, columns } = imagePlaneModule;
+        const targetRows = this.dimensions[1];
+        const targetCols = this.dimensions[0];
         const imageIdIndex = this.getImageIdIndex(imageId);
         const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
         const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
@@ -230,8 +230,8 @@ export class BaseStreamingImageVolume extends ImageVolume {
         }
         const targetBuffer = {
             type: this.dataType,
-            rows,
-            columns,
+            rows: targetRows,
+            columns: targetCols,
         };
         return {
             targetBuffer,

package/dist/esm/cache/classes/ImageVolume.d.ts

@@ -35,6 +35,7 @@ export declare class ImageVolume {
     referencedImageIds?: string[];
     hasPixelSpacing: boolean;
     additionalDetails?: Record<string, unknown>;
+    numDimensionGroups: number;
     voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
     dataType?: PixelDataTypedArrayString;
     get numTimePoints(): number;

package/dist/esm/cache/classes/StreamingDynamicImageVolume.d.ts

@@ -27,8 +27,8 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
         options: {
             targetBuffer: {
                 type: import("../../types").PixelDataTypedArrayString;
-                rows: any;
-                columns: any;
+                rows: number;
+                columns: number;
             };
             allowFloatRendering: boolean;
             preScale: {

package/dist/esm/index.d.ts

@@ -27,6 +27,7 @@ import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
 import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
+import { decimatedVolumeLoader } from './loaders/decimatedVolumeLoader';
 import type * as Types from './types';
 import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveStage, ImageLoadListener } from './types';
 import * as utilities from './utilities';
@@ -36,5 +37,6 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
+export * from './loaders/decimatedVolumeLoader';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -27,6 +27,7 @@ import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
 import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
+import { decimatedVolumeLoader } from './loaders/decimatedVolumeLoader';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
@@ -34,4 +35,5 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export * from './loaders/decimatedVolumeLoader';
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/loaders/decimatedVolumeLoader.d.ts

@@ -0,0 +1,14 @@
+import StreamingImageVolume from '../cache/classes/StreamingImageVolume';
+import type { IRetrieveConfiguration } from '../types';
+import type { points } from './decimatedVolumeModifiers';
+interface IVolumeLoader {
+    promise: Promise<StreamingImageVolume>;
+    cancel: () => void;
+    decache: () => void;
+}
+export declare function decimatedVolumeLoader(volumeId: string, options: {
+    imageIds: string[];
+    progressiveRendering?: boolean | IRetrieveConfiguration;
+    ijkDecimation?: points.points3;
+}): IVolumeLoader;
+export default decimatedVolumeLoader;

package/dist/esm/loaders/decimatedVolumeLoader.js

@@ -0,0 +1,110 @@
+import StreamingImageVolume from '../cache/classes/StreamingImageVolume';
+import { generateVolumePropsFromImageIds } from '../utilities/generateVolumePropsFromImageIds';
+import decimate from '../utilities/decimate';
+import VoxelManager from '../utilities/VoxelManager';
+import { applyDecimatedVolumeModifiers, inPlaneDecimationModifier, } from './decimatedVolumeModifiers';
+export function decimatedVolumeLoader(volumeId, options) {
+    if (!options || !options.imageIds || !options.imageIds.length) {
+        throw new Error('ImageIds must be provided to create a streaming image volume ');
+    }
+    const [iDecimation = 1, jDecimation = iDecimation, kDecimation = 1] = options.ijkDecimation ?? [];
+    const columnDecimation = Math.max(1, Math.floor(iDecimation));
+    const rowDecimation = jDecimation > 1 ? Math.max(1, Math.floor(jDecimation)) : columnDecimation;
+    const kAxisDecimation = Math.max(1, Math.floor(kDecimation));
+    const hasInPlaneDecimation = columnDecimation > 1 || rowDecimation > 1;
+    const modifierOptions = {
+        ijkDecimation: [
+            columnDecimation,
+            rowDecimation,
+            kAxisDecimation,
+        ],
+    };
+    const modifiers = [inPlaneDecimationModifier];
+    function addDecimationToImageId(imageId, factor) {
+        if (factor === 1) {
+            return imageId;
+        }
+        return `${imageId}#decimation=${factor}`;
+    }
+    const expectedDecimatedCount = Math.floor(options.imageIds.length / kAxisDecimation);
+    const isAlreadyDecimated = kAxisDecimation > 1 &&
+        options.imageIds.length <= expectedDecimatedCount + 1;
+    if (kAxisDecimation > 1 && !isAlreadyDecimated) {
+        const decimatedResult = decimate(options.imageIds, kAxisDecimation);
+        const decimatedImageIds = Array.isArray(decimatedResult) &&
+            decimatedResult.length &&
+            typeof decimatedResult[0] === 'number'
+            ? decimatedResult.map((idx) => options.imageIds[idx])
+            : decimatedResult;
+        options.imageIds = decimatedImageIds;
+    }
+    if (columnDecimation > 1) {
+        options.imageIds = options.imageIds.map((imageId) => addDecimationToImageId(imageId, columnDecimation));
+    }
+    async function getStreamingImageVolume() {
+        const baseVolumeProps = generateVolumePropsFromImageIds(options.imageIds, volumeId);
+        const modifierContext = {
+            volumeId,
+            imageIds: options.imageIds,
+            options: modifierOptions,
+        };
+        const volumeProps = applyDecimatedVolumeModifiers(baseVolumeProps, modifiers, modifierContext);
+        const { dimensions, spacing, origin, direction, metadata, imageIds, dataType, numberOfComponents, } = volumeProps;
+        const streamingImageVolume = new StreamingImageVolume({
+            volumeId,
+            metadata,
+            dimensions,
+            spacing,
+            origin,
+            direction,
+            imageIds,
+            dataType,
+            numberOfComponents,
+        }, {
+            imageIds,
+            loadStatus: {
+                loaded: false,
+                loading: false,
+                cancelled: false,
+                cachedFrames: [],
+                callbacks: [],
+            },
+        });
+        if (hasInPlaneDecimation) {
+            const vtkImageData = streamingImageVolume.imageData;
+            if (vtkImageData) {
+                vtkImageData.setDimensions(streamingImageVolume.dimensions);
+                vtkImageData.setSpacing(streamingImageVolume.spacing);
+                vtkImageData.modified();
+            }
+            const newVoxelManager = VoxelManager.createImageVolumeVoxelManager({
+                dimensions: streamingImageVolume.dimensions,
+                imageIds: streamingImageVolume.imageIds,
+                numberOfComponents: numberOfComponents,
+            });
+            streamingImageVolume.voxelManager = newVoxelManager;
+            if (vtkImageData) {
+                vtkImageData.set({
+                    voxelManager: newVoxelManager,
+                });
+            }
+        }
+        return streamingImageVolume;
+    }
+    const streamingImageVolumePromise = getStreamingImageVolume();
+    return {
+        promise: streamingImageVolumePromise,
+        decache: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.destroy();
+                streamingImageVolume = null;
+            });
+        },
+        cancel: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.cancelLoading();
+            });
+        },
+    };
+}
+export default decimatedVolumeLoader;

package/dist/esm/loaders/decimatedVolumeModifiers/applyDecimatedVolumeModifiers.d.ts

@@ -0,0 +1,3 @@
+import type { ImageVolumeProps } from '../../types';
+import type { DecimatedVolumeModifier, DecimatedVolumeModifierContext } from './types';
+export declare function applyDecimatedVolumeModifiers(baseProps: ImageVolumeProps, modifiers: DecimatedVolumeModifier[], context: DecimatedVolumeModifierContext): ImageVolumeProps;

package/dist/esm/loaders/decimatedVolumeModifiers/applyDecimatedVolumeModifiers.js

@@ -0,0 +1,3 @@
+export function applyDecimatedVolumeModifiers(baseProps, modifiers, context) {
+    return modifiers.reduce((currentProps, modifier) => modifier.apply(currentProps, context), baseProps);
+}

package/dist/esm/loaders/decimatedVolumeModifiers/inPlaneDecimationModifier.d.ts

@@ -0,0 +1,2 @@
+import type { DecimatedVolumeModifier } from './types';
+export declare const inPlaneDecimationModifier: DecimatedVolumeModifier;

package/dist/esm/loaders/decimatedVolumeModifiers/inPlaneDecimationModifier.js

@@ -0,0 +1,36 @@
+export const inPlaneDecimationModifier = {
+    name: 'InPlaneDecimationModifier',
+    apply(volumeProps, context) {
+        const [iDecimation = 1, jDecimation = iDecimation] = context.options.ijkDecimation ?? [];
+        const columnFactor = Math.max(1, Math.floor(iDecimation));
+        const rowFactor = Math.max(1, Math.floor(jDecimation));
+        if (columnFactor === 1 && rowFactor === 1) {
+            return volumeProps;
+        }
+        const [columns, rows] = volumeProps.dimensions;
+        const newColumns = Math.max(1, Math.floor(columns / columnFactor));
+        const newRows = Math.max(1, Math.floor(rows / rowFactor));
+        const newDimensions = [
+            newColumns,
+            newRows,
+            volumeProps.dimensions[2],
+        ];
+        const newSpacing = [
+            volumeProps.spacing[0] * columnFactor,
+            volumeProps.spacing[1] * rowFactor,
+            volumeProps.spacing[2],
+        ];
+        const metadata = {
+            ...volumeProps.metadata,
+            Columns: newColumns,
+            Rows: newRows,
+            PixelSpacing: [newSpacing[1], newSpacing[0]],
+        };
+        return {
+            ...volumeProps,
+            dimensions: newDimensions,
+            spacing: newSpacing,
+            metadata,
+        };
+    },
+};

package/dist/esm/loaders/decimatedVolumeModifiers/index.d.ts

@@ -0,0 +1,4 @@
+export { applyDecimatedVolumeModifiers } from './applyDecimatedVolumeModifiers';
+export { inPlaneDecimationModifier } from './inPlaneDecimationModifier';
+export type { DecimatedVolumeLoaderOptions, DecimatedVolumeModifier, DecimatedVolumeModifierContext, } from './types';
+export type { points } from './types';

package/dist/esm/loaders/decimatedVolumeModifiers/index.js

@@ -0,0 +1,2 @@
+export { applyDecimatedVolumeModifiers } from './applyDecimatedVolumeModifiers';
+export { inPlaneDecimationModifier } from './inPlaneDecimationModifier';

package/dist/esm/loaders/decimatedVolumeModifiers/types.d.ts

@@ -0,0 +1,17 @@
+import type { ImageVolumeProps } from '../../types';
+import type Point3 from '../../types/Point3';
+export declare namespace points {
+    type points3 = Point3;
+}
+export interface DecimatedVolumeLoaderOptions {
+    ijkDecimation?: points.points3;
+}
+export interface DecimatedVolumeModifierContext {
+    volumeId: string;
+    imageIds: string[];
+    options: DecimatedVolumeLoaderOptions;
+}
+export interface DecimatedVolumeModifier {
+    name: string;
+    apply(volumeProps: ImageVolumeProps, context: DecimatedVolumeModifierContext): ImageVolumeProps;
+}

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

@@ -1,7 +1,8 @@
 import { cornerstoneStreamingImageVolumeLoader } from './cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './cornerstoneMeshLoader';
+import { decimatedVolumeLoader } from './decimatedVolumeLoader';
 import * as geometryLoader from './geometryLoader';
 import * as imageLoader from './imageLoader';
 import * as volumeLoader from './volumeLoader';
-export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneMeshLoader, geometryLoader, imageLoader, volumeLoader, };
+export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneMeshLoader, decimatedVolumeLoader, geometryLoader, imageLoader, volumeLoader, };

package/dist/esm/loaders/index.js

@@ -1,7 +1,8 @@
 import { cornerstoneStreamingImageVolumeLoader } from './cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './cornerstoneMeshLoader';
+import { decimatedVolumeLoader } from './decimatedVolumeLoader';
 import * as geometryLoader from './geometryLoader';
 import * as imageLoader from './imageLoader';
 import * as volumeLoader from './volumeLoader';
-export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneMeshLoader, geometryLoader, imageLoader, volumeLoader, };
+export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneMeshLoader, decimatedVolumeLoader, geometryLoader, imageLoader, volumeLoader, };

package/dist/esm/loaders/volumeLoader.d.ts

@@ -4,6 +4,7 @@ import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTyp
 interface VolumeLoaderOptions {
     imageIds: string[];
     progressiveRendering?: boolean;
+    ijkDecimation?: [number, number, number];
 }
 interface DerivedVolumeOptions {
     volumeId?: string;

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

@@ -82,7 +82,7 @@ import { buildMetadata } from './buildMetadata';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
 import scaleArray from './scaleArray';
-import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
+import splitImageIdsBy4DTags, { handleMultiframe4D, generateFrameImageId } from './splitImageIdsBy4DTags';
 import { deepClone } from './deepClone';
 import { jumpToSlice } from './jumpToSlice';
 import scroll from './scroll';
@@ -97,4 +97,4 @@ import { asArray } from './asArray';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };

package/dist/esm/utilities/index.js

@@ -83,7 +83,7 @@ import cache from '../cache/cache';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
 import scaleArray from './scaleArray';
-import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
+import splitImageIdsBy4DTags, { handleMultiframe4D, generateFrameImageId, } from './splitImageIdsBy4DTags';
 import { deepClone } from './deepClone';
 import { jumpToSlice } from './jumpToSlice';
 import scroll from './scroll';
@@ -98,4 +98,4 @@ import { asArray } from './asArray';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };

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

@@ -1,5 +1,12 @@
+interface MultiframeSplitResult {
+    imageIdGroups: string[][];
+    splittingTag: string;
+}
+declare function generateFrameImageId(baseImageId: string, frameNumber: number): string;
+declare function handleMultiframe4D(imageIds: string[]): MultiframeSplitResult | null;
 declare function splitImageIdsBy4DTags(imageIds: string[]): {
     imageIdGroups: string[][];
     splittingTag: string | null;
 };
 export default splitImageIdsBy4DTags;
+export { handleMultiframe4D, generateFrameImageId };

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -1,4 +1,72 @@
 import * as metaData from '../metaData';
+function generateFrameImageId(baseImageId, frameNumber) {
+    const framePattern = /\/frames\/\d+/;
+    if (!framePattern.test(baseImageId)) {
+        throw new Error(`generateFrameImageId: baseImageId must contain a "/frames/" pattern followed by a digit. ` +
+            `Expected format: e.g., "wadouri:http://example.com/image/frames/1" or "wadors:/path/to/image.dcm/frames/1". ` +
+            `Received: ${baseImageId}`);
+    }
+    return baseImageId.replace(framePattern, `/frames/${frameNumber}`);
+}
+function handleMultiframe4D(imageIds) {
+    if (!imageIds || imageIds.length === 0) {
+        return null;
+    }
+    const baseImageId = imageIds[0];
+    const instance = metaData.get('instance', baseImageId);
+    if (!instance) {
+        return null;
+    }
+    const numberOfFrames = instance.NumberOfFrames;
+    if (!numberOfFrames || numberOfFrames <= 1) {
+        return null;
+    }
+    const timeSlotVector = instance.TimeSlotVector;
+    if (!timeSlotVector || !Array.isArray(timeSlotVector)) {
+        return null;
+    }
+    const sliceVector = instance.SliceVector;
+    const numberOfSlices = instance.NumberOfSlices;
+    if (timeSlotVector.length !== numberOfFrames) {
+        console.warn('TimeSlotVector length does not match NumberOfFrames:', timeSlotVector.length, 'vs', numberOfFrames);
+        return null;
+    }
+    if (sliceVector) {
+        if (!Array.isArray(sliceVector)) {
+            console.warn('SliceVector exists but is not an array. Expected length:', numberOfFrames);
+            return null;
+        }
+        if (sliceVector.length !== numberOfFrames ||
+            sliceVector.some((val) => val === undefined)) {
+            console.warn('SliceVector exists but has invalid length or undefined entries. Expected length:', numberOfFrames, 'Actual length:', sliceVector.length);
+            return null;
+        }
+    }
+    const timeSlotGroups = new Map();
+    for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+        const timeSlot = timeSlotVector[frameIndex];
+        const sliceIndex = sliceVector?.[frameIndex] ?? frameIndex;
+        if (!timeSlotGroups.has(timeSlot)) {
+            timeSlotGroups.set(timeSlot, []);
+        }
+        timeSlotGroups.get(timeSlot).push({ frameIndex, sliceIndex });
+    }
+    const sortedTimeSlots = Array.from(timeSlotGroups.keys()).sort((a, b) => a - b);
+    const imageIdGroups = sortedTimeSlots.map((timeSlot) => {
+        const frames = timeSlotGroups.get(timeSlot);
+        frames.sort((a, b) => a.sliceIndex - b.sliceIndex);
+        return frames.map((frame) => generateFrameImageId(baseImageId, frame.frameIndex + 1));
+    });
+    const expectedSlicesPerTimeSlot = numberOfSlices || imageIdGroups[0]?.length;
+    const allGroupsHaveSameLength = imageIdGroups.every((group) => group.length === expectedSlicesPerTimeSlot);
+    if (!allGroupsHaveSameLength) {
+        console.warn('Multiframe 4D split resulted in uneven time slot groups. Expected', expectedSlicesPerTimeSlot, 'slices per time slot.');
+    }
+    return {
+        imageIdGroups,
+        splittingTag: 'TimeSlotVector',
+    };
+}
 const groupBy = (array, key) => {
     return array.reduce((rv, x) => {
         (rv[x[key]] = rv[x[key]] || []).push(x);
@@ -120,6 +188,10 @@ function getPetFrameReferenceTime(imageId) {
     return moduleInfo ? moduleInfo['frameReferenceTime'] : 0;
 }
 function splitImageIdsBy4DTags(imageIds) {
+    const multiframeResult = handleMultiframe4D(imageIds);
+    if (multiframeResult) {
+        return multiframeResult;
+    }
     const positionGroups = getIPPGroups(imageIds);
     if (!positionGroups) {
         return { imageIdGroups: [imageIds], splittingTag: null };
@@ -159,3 +231,4 @@ function splitImageIdsBy4DTags(imageIds) {
     return { imageIdGroups: [imageIds], splittingTag: null };
 }
 export default splitImageIdsBy4DTags;
+export { handleMultiframe4D, generateFrameImageId };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.14.6";
+export declare const version = "4.15.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.14.6';
+export const version = '4.15.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.14.6",
+  "version": "4.15.1",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "af8d5405e54f64f2b96623d0f7374926a78d8d9e"
+  "gitHead": "4a9e19c7d7a8d5a6be2c906a1e887577880a2b93"
 }