@cornerstonejs/core 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.js

@@ -0,0 +1,58 @@
+import { StreamingDynamicImageVolume } from '../cache';
+import { generateVolumePropsFromImageIds, sortImageIdsAndGetSpacing, splitImageIdsBy4DTags, VoxelManager, } from '../utilities';
+function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
+    if (!options || !options.imageIds || !options.imageIds.length) {
+        throw new Error('ImageIds must be provided to create a 4D streaming image volume');
+    }
+    const { imageIds } = options;
+    const { splittingTag, imageIdGroups } = splitImageIdsBy4DTags(imageIds);
+    const volumeProps = generateVolumePropsFromImageIds(imageIdGroups[0], volumeId);
+    const { metadata: volumeMetadata, dimensions, spacing, direction, sizeInBytes, origin, numberOfComponents, dataType, } = volumeProps;
+    const scanAxisNormal = direction.slice(6, 9);
+    const sortedImageIdGroups = imageIdGroups.map((imageIds) => {
+        const sortedImageIds = sortImageIdsAndGetSpacing(imageIds, scanAxisNormal).sortedImageIds;
+        return sortedImageIds;
+    });
+    const sortedFlatImageIds = sortedImageIdGroups.flat();
+    const voxelManager = VoxelManager.createScalarDynamicVolumeVoxelManager({
+        dimensions,
+        imageIdGroups: sortedImageIdGroups,
+        timePoint: 0,
+        numberOfComponents,
+    });
+    let streamingImageVolume = new StreamingDynamicImageVolume({
+        volumeId,
+        metadata: volumeMetadata,
+        dimensions,
+        spacing,
+        origin,
+        direction,
+        sizeInBytes,
+        imageIds: sortedFlatImageIds,
+        imageIdGroups: sortedImageIdGroups,
+        splittingTag,
+        voxelManager,
+        numberOfComponents,
+        dataType,
+    }, {
+        imageIds: sortedFlatImageIds,
+        loadStatus: {
+            loaded: false,
+            loading: false,
+            cancelled: false,
+            cachedFrames: [],
+            callbacks: [],
+        },
+    });
+    return {
+        promise: Promise.resolve(streamingImageVolume),
+        decache: () => {
+            streamingImageVolume.destroy();
+            streamingImageVolume = null;
+        },
+        cancel: () => {
+            streamingImageVolume.cancelLoading();
+        },
+    };
+}
+export { cornerstoneStreamingDynamicImageVolumeLoader };

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

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

package/dist/esm/loaders/cornerstoneStreamingImageVolumeLoader.js

@@ -0,0 +1,73 @@
+import StreamingImageVolume from '../cache/classes/StreamingImageVolume';
+import { RequestType } from '../enums';
+import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
+import { generateVolumePropsFromImageIds } from '../utilities';
+import { loadImage } from './imageLoader';
+function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
+    if (!options || !options.imageIds || !options.imageIds.length) {
+        throw new Error('ImageIds must be provided to create a streaming image volume');
+    }
+    async function getStreamingImageVolume() {
+        if (options.imageIds[0].split(':')[0] === 'wadouri') {
+            const [middleImageIndex, lastImageIndex] = [
+                Math.floor(options.imageIds.length / 2),
+                options.imageIds.length - 1,
+            ];
+            const indexesToPrefetch = [0, middleImageIndex, lastImageIndex];
+            await Promise.all(indexesToPrefetch.map((index) => {
+                return new Promise((resolve, reject) => {
+                    const imageId = options.imageIds[index];
+                    imageLoadPoolManager.addRequest(async () => {
+                        loadImage(imageId)
+                            .then(() => {
+                            console.log(`Prefetched imageId: ${imageId}`);
+                            resolve(true);
+                        })
+                            .catch((err) => {
+                            reject(err);
+                        });
+                    }, RequestType.Prefetch, { volumeId }, 1);
+                });
+            })).catch(console.error);
+        }
+        const volumeProps = generateVolumePropsFromImageIds(options.imageIds, volumeId);
+        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: [],
+            },
+        });
+        return streamingImageVolume;
+    }
+    const streamingImageVolumePromise = getStreamingImageVolume();
+    return {
+        promise: streamingImageVolumePromise,
+        decache: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.destroy();
+                streamingImageVolume = null;
+            });
+        },
+        cancel: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.cancelLoading();
+            });
+        },
+    };
+}
+export { cornerstoneStreamingImageVolumeLoader };

package/dist/esm/loaders/geometryLoader.js

@@ -1,5 +1,5 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { GeometryType } from '../enums';
 import { createContourSet } from './utils/contourSet/createContourSet';
 import { createSurface } from './utils/surface/createSurface';

package/dist/esm/loaders/imageLoader.js

@@ -1,9 +1,13 @@
 import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
-import { genericMetadataProvider, getBufferConfiguration, triggerEvent, uuidv4, VoxelManager, } from '../utilities';
+import genericMetadataProvider from '../utilities/genericMetadataProvider';
+import { getBufferConfiguration } from '../utilities/getBufferConfiguration';
+import triggerEvent from '../utilities/triggerEvent';
+import uuidv4 from '../utilities/uuidv4';
+import VoxelManager from '../utilities/VoxelManager';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
-import { metaData } from '../';
+import * as metaData from '../metaData';
 const imageLoaders = {};
 let unknownImageLoader;
 function loadImageFromImageLoader(imageId, options) {

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

@@ -2,6 +2,7 @@ import '@kitware/vtk.js/Rendering/Profiles/Volume';
 import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
 interface VolumeLoaderOptions {
     imageIds: string[];
+    progressiveRendering?: boolean;
 }
 interface DerivedVolumeOptions {
     volumeId: string;

package/dist/esm/loaders/volumeLoader.js

@@ -4,9 +4,9 @@ import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
-import { getBufferConfiguration, uuidv4, VoxelManager } from '../utilities';
-import { imageLoader } from '..';
-import { createAndCacheLocalImage } from './imageLoader';
+import uuidv4 from '../utilities/uuidv4';
+import VoxelManager from '../utilities/VoxelManager';
+import { createAndCacheLocalImage, createAndCacheDerivedImages, } from './imageLoader';
 const volumeLoaders = {};
 let unknownVolumeLoader;
 function loadVolumeFromVolumeLoader(volumeId, options) {
@@ -68,7 +68,15 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
     const referencedImageIds = referencedVolume.imageIds ?? [];
-    const derivedImages = imageLoader.createAndCacheDerivedImages(referencedImageIds, {
+    const byteLength = referencedImageIds.reduce((total, imageId) => {
+        const image = cache.getImage(imageId);
+        return total + image.sizeInBytes;
+    }, 0);
+    const isCacheable = cache.isCacheable(byteLength);
+    if (!isCacheable) {
+        throw new Error(`Cannot created derived volume: Referenced volume with id ${referencedVolumeId} does not exist.`);
+    }
+    const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
         targetBufferType: options.targetBufferType,
     });
     const dataType = derivedImages[0].dataType;
@@ -114,6 +122,25 @@ export function createLocalVolume(volumeId, options = {}) {
     const dataType = scalarData
         ? scalarData.constructor.name
         : targetBufferType;
+    const totalNumberOfVoxels = sliceLength * dimensions[2];
+    let byteLength;
+    switch (dataType) {
+        case 'Uint8Array':
+        case 'Int8Array':
+            byteLength = totalNumberOfVoxels;
+            break;
+        case 'Uint16Array':
+        case 'Int16Array':
+            byteLength = totalNumberOfVoxels * 2;
+            break;
+        case 'Float32Array':
+            byteLength = totalNumberOfVoxels * 4;
+            break;
+    }
+    const isCacheable = cache.isCacheable(byteLength);
+    if (!isCacheable) {
+        throw new Error(`Cannot created derived volume: Volume with id ${volumeId} is not cacheable.`);
+    }
     const imageIds = [];
     const derivedImages = [];
     for (let i = 0; i < dimensions[2]; i++) {
@@ -146,7 +173,9 @@ export function createLocalVolume(volumeId, options = {}) {
         numberOfComponents: 1,
     });
     imageVolume.voxelManager = voxelManager;
-    cache.putVolumeSync(volumeId, imageVolume);
+    if (!preventCache) {
+        cache.putVolumeSync(volumeId, imageVolume);
+    }
     return imageVolume;
 }
 export function registerVolumeLoader(scheme, volumeLoader) {

package/dist/esm/requestPool/requestPoolManager.js

@@ -1,5 +1,5 @@
 import RequestType from '../enums/RequestType';
-import { uuidv4 } from '../utilities';
+import uuidv4 from '../utilities/uuidv4';
 class RequestPoolManager {
     constructor(id) {
         this.numRequests = {

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

@@ -1,40 +1,2 @@
-import type Point2 from './Point2';
-import type Point3 from './Point3';
-import type Mat3 from './Mat3';
-import type IImage from './IImage';
-import type CPUFallbackViewport from './CPUFallbackViewport';
-import type CPUFallbackTransform from './CPUFallbackTransform';
-import type CPUFallbackColormap from './CPUFallbackColormap';
-import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
-import type { ImagePlaneModule } from './ImagePlaneModule';
-import type { ImagePixelModule } from './ImagePixelModule';
-import type RGB from './RGB';
-import type { IVoxelManager } from './IVoxelManager';
-interface CPUFallbackEnabledElement {
-    scale?: number;
-    pan?: Point2;
-    zoom?: number;
-    rotation?: number;
-    image?: IImage;
-    canvas?: HTMLCanvasElement;
-    viewport?: CPUFallbackViewport;
-    colormap?: CPUFallbackColormap;
-    options?: {
-        [key: string]: unknown;
-        colormap?: CPUFallbackColormap;
-    };
-    renderingTools?: CPUFallbackRenderingTools;
-    transform?: CPUFallbackTransform;
-    invalid?: boolean;
-    needsRedraw?: boolean;
-    metadata?: {
-        direction?: Mat3;
-        dimensions?: Point3;
-        spacing?: Point3;
-        origin?: Point3;
-        imagePlaneModule?: ImagePlaneModule;
-        imagePixelModule?: ImagePixelModule;
-    };
-    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
-}
+import type { CPUFallbackEnabledElement } from './IImage';
 export type { CPUFallbackEnabledElement as default };

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

@@ -1,11 +1,18 @@
 import type CPUFallbackLUT from './CPUFallbackLUT';
-import type CPUFallbackColormap from './CPUFallbackColormap';
-import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
 import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
 import type { ImageQualityStatus } from '../enums';
 import type IImageCalibration from './IImageCalibration';
 import type RGB from './RGB';
 import type IImageFrame from './IImageFrame';
+import type Point2 from './Point2';
+import type Point3 from './Point3';
+import type Mat3 from './Mat3';
+import type CPUFallbackViewport from './CPUFallbackViewport';
+import type CPUFallbackTransform from './CPUFallbackTransform';
+import type CPUFallbackColormap from './CPUFallbackColormap';
+import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
+import type { ImagePlaneModule } from './ImagePlaneModule';
+import type { ImagePixelModule } from './ImagePixelModule';
 import type { IVoxelManager } from './IVoxelManager';
 interface IImage {
     imageId: string;
@@ -85,4 +92,32 @@ interface IImage {
         offset: number;
     };
 }
+interface CPUFallbackEnabledElement {
+    scale?: number;
+    pan?: Point2;
+    zoom?: number;
+    rotation?: number;
+    image?: IImage;
+    canvas?: HTMLCanvasElement;
+    viewport?: CPUFallbackViewport;
+    colormap?: CPUFallbackColormap;
+    options?: {
+        [key: string]: unknown;
+        colormap?: CPUFallbackColormap;
+    };
+    renderingTools?: CPUFallbackRenderingTools;
+    transform?: CPUFallbackTransform;
+    invalid?: boolean;
+    needsRedraw?: boolean;
+    metadata?: {
+        direction?: Mat3;
+        dimensions?: Point3;
+        spacing?: Point3;
+        origin?: Point3;
+        imagePlaneModule?: ImagePlaneModule;
+        imagePixelModule?: ImagePixelModule;
+    };
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+}
 export type { IImage as default };
+export type { CPUFallbackEnabledElement };

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

@@ -0,0 +1,24 @@
+import type { RequestType } from '../enums';
+import type { ScalingParameters } from './ScalingParameters';
+export default interface ImageLoadRequests {
+    callLoadImage: (imageId: string, imageIdIndex: number, options: unknown) => Promise<void>;
+    imageId: string;
+    imageIdIndex: number;
+    options: {
+        targetBuffer: {
+            type: string;
+            rows: number;
+            columns: number;
+        };
+        preScale: {
+            enabled: boolean;
+            scalingParameters: ScalingParameters;
+        };
+        transferPixelData: boolean;
+    };
+    priority: number;
+    requestType: RequestType;
+    additionalDetails: {
+        volumeId: string;
+    };
+}

package/dist/esm/types/ImageLoadRequests.js

@@ -0,0 +1 @@
+export {};

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

@@ -13,7 +13,7 @@ import type IRegisterImageLoader from './IRegisterImageLoader';
 import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
 import type { LocalVolumeOptions } from './../loaders/volumeLoader';
-import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector } from './IViewport';
+import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector, ViewportInput } from './IViewport';
 import type { VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor } from './IActor';
 import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
 import type Metadata from './Metadata';
@@ -92,4 +92,5 @@ import type IImageFrame from './IImageFrame';
 import type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata } from './MetadataModuleTypes';
 import type { IVoxelManager } from './IVoxelManager';
 import type { IRLEVoxelMap, RLERun } from './IRLEVoxelMap';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, };
+import type ImageLoadRequests from './ImageLoadRequests';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, WSIViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, };

package/dist/esm/utilities/VoxelManager.js

@@ -1,5 +1,5 @@
 import { vec3 } from 'gl-matrix';
-import cache from '../cache';
+import cache from '../cache/cache';
 import RLEVoxelMap from './RLEVoxelMap';
 import isEqual from './isEqual';
 const DEFAULT_RLE_SIZE = 5 * 1024;

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

@@ -0,0 +1,2 @@
+declare const autoLoad: (volumeId: string) => void;
+export default autoLoad;

package/dist/esm/utilities/autoLoad.js

@@ -0,0 +1,28 @@
+import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import getViewportsWithVolumeId from './getViewportsWithVolumeId';
+const autoLoad = (volumeId) => {
+    const renderingEngineAndViewportIds = getRenderingEngineAndViewportsContainingVolume(volumeId);
+    if (!renderingEngineAndViewportIds?.length) {
+        return;
+    }
+    renderingEngineAndViewportIds.forEach(({ renderingEngine, viewportIds }) => {
+        if (!renderingEngine.hasBeenDestroyed) {
+            renderingEngine.renderViewports(viewportIds);
+        }
+    });
+};
+function getRenderingEngineAndViewportsContainingVolume(volumeId) {
+    const renderingEnginesArray = getRenderingEngines();
+    const renderingEngineAndViewportIds = [];
+    renderingEnginesArray.forEach((renderingEngine) => {
+        const viewports = getViewportsWithVolumeId(volumeId, renderingEngine.id);
+        if (viewports.length) {
+            renderingEngineAndViewportIds.push({
+                renderingEngine,
+                viewportIds: viewports.map((viewport) => viewport.id),
+            });
+        }
+    });
+    return renderingEngineAndViewportIds;
+}
+export default autoLoad;

package/dist/esm/utilities/calculateViewportsSpatialRegistration.js

@@ -1,12 +1,12 @@
 import { vec3, mat4 } from 'gl-matrix';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
-import { metaData } from '..';
+import { get } from '../metaData';
 const ALLOWED_DELTA = 0.05;
 function calculateViewportsSpatialRegistration(viewport1, viewport2) {
     const imageId1 = viewport1.getSliceIndex();
     const imageId2 = viewport2.getSliceIndex();
-    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1.toString());
-    const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2.toString());
+    const imagePlaneModule1 = get('imagePlaneModule', imageId1.toString());
+    const imagePlaneModule2 = get('imagePlaneModule', imageId2.toString());
     if (!imagePlaneModule1 || !imagePlaneModule2) {
         console.log('Viewport spatial registration requires image plane module');
         return;

package/dist/esm/utilities/convertVolumeToStackViewport.js

@@ -1,4 +1,5 @@
-import cache, { ImageVolume } from '../cache';
+import cache from '../cache/cache';
+import { ImageVolume } from '../cache/classes/ImageVolume';
 import { ViewportType } from '../enums';
 async function convertVolumeToStackViewport({ viewport, options, }) {
     const volumeViewport = viewport;

package/dist/esm/utilities/getClosestStackImageIndexForPoint.js

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
-import { planar } from '.';
-import { metaData } from '..';
+import * as planar from './planar';
+import * as metaData from '../metaData';
 export default function getClosestStackImageIndexForPoint(point, viewport) {
     const minimalDistance = calculateMinimalDistanceForStackViewport(point, viewport);
     return minimalDistance ? minimalDistance.index : null;

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

@@ -0,0 +1,6 @@
+declare function getDynamicVolumeInfo(imageIds: any): {
+    isDynamicVolume: boolean;
+    timePoints: string[][];
+    splittingTag: string;
+};
+export default getDynamicVolumeInfo;

package/dist/esm/utilities/getDynamicVolumeInfo.js

@@ -0,0 +1,7 @@
+import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
+function getDynamicVolumeInfo(imageIds) {
+    const { imageIdGroups: timePoints, splittingTag } = splitImageIdsBy4DTags(imageIds);
+    const isDynamicVolume = timePoints.length > 1;
+    return { isDynamicVolume, timePoints, splittingTag };
+}
+export default getDynamicVolumeInfo;

package/dist/esm/utilities/getImageLegacy.js

@@ -1,4 +1,4 @@
-import { StackViewport } from '..';
+import StackViewport from '../RenderingEngine/StackViewport';
 import getEnabledElement from '../getEnabledElement';
 function getImageLegacy(element) {
     const enabledElement = getEnabledElement(element);

package/dist/esm/utilities/getScalingParameters.js

@@ -1,14 +1,14 @@
-import { get as metaDataGet } from '../metaData';
+import * as metaData from '../metaData';
 export default function getScalingParameters(imageId) {
-    const modalityLutModule = metaDataGet('modalityLutModule', imageId) || {};
-    const generalSeriesModule = metaDataGet('generalSeriesModule', imageId) || {};
+    const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+    const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope || 1,
         rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
-    const suvFactor = metaDataGet('scalingModule', imageId) || {};
+    const suvFactor = metaData.get('scalingModule', imageId) || {};
     return {
         ...scalingParameters,
         ...(modality === 'PT' && {

package/dist/esm/utilities/getViewportImageIds.js

@@ -1,5 +1,5 @@
 import { VolumeViewport } from '../RenderingEngine';
-import cache from '../cache';
+import cache from '../cache/cache';
 function getViewportImageIds(viewport) {
     if (viewport instanceof VolumeViewport) {
         const defaultActor = viewport.getDefaultActor();

package/dist/esm/utilities/imageToWorldCoords.js

@@ -1,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
-import { metaData } from '..';
+import { get } from '../metaData';
 export default function imageToWorldCoords(imageId, imageCoords) {
-    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+    const imagePlaneModule = get('imagePlaneModule', imageId);
     if (!imagePlaneModule) {
         throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
     }

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

@@ -73,5 +73,9 @@ import * as colormap from './colormap';
 import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
 import type { IViewport } from '../types/IViewport';
+import getDynamicVolumeInfo from './getDynamicVolumeInfo';
+import autoLoad from './autoLoad';
+import scaleArray from './scaleArray';
+import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
-export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, 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, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, };
+export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, 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, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, splitImageIdsBy4DTags, };

package/dist/esm/utilities/index.js

@@ -73,6 +73,10 @@ import * as colormap from './colormap';
 import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
 import { _getViewportModality } from './getViewportModality';
-import cache from '../cache';
+import cache from '../cache/cache';
+import getDynamicVolumeInfo from './getDynamicVolumeInfo';
+import autoLoad from './autoLoad';
+import scaleArray from './scaleArray';
+import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
-export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, 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, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, };
+export { eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isEqualAbs, isEqualNegative, 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, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, splitImageIdsBy4DTags, };

package/dist/esm/utilities/isValidVolume.js

@@ -1,4 +1,4 @@
-import { metaData } from '..';
+import * as metaData from '../metaData';
 import isEqual from './isEqual';
 function isValidVolume(imageIds) {
     const imageId0 = imageIds[0];

package/dist/esm/utilities/loadImageToCanvas.js

@@ -5,7 +5,7 @@ import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import renderToCanvasGPU from './renderToCanvasGPU';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import { getConfiguration } from '../init';
-import cache from '../cache';
+import cache from '../cache/cache';
 export default function loadImageToCanvas(options) {
     const { canvas, imageId, viewReference, requestType = RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, viewportOptions: baseViewportOptions, } = options;
     const volumeId = viewReference?.volumeId;

package/dist/esm/utilities/makeVolumeMetadata.js

@@ -1,9 +1,9 @@
-import { metaData } from '../';
+import { get } from '../metaData';
 export default function makeVolumeMetadata(imageIds) {
     const imageId0 = imageIds[0];
-    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId0);
+    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = get('imagePixelModule', imageId0);
     const voiLut = [];
-    const voiLutModule = metaData.get('voiLutModule', imageId0);
+    const voiLutModule = get('voiLutModule', imageId0);
     let voiLUTFunction;
     if (voiLutModule) {
         const { windowWidth, windowCenter } = voiLutModule;
@@ -29,8 +29,8 @@ export default function makeVolumeMetadata(imageIds) {
             windowCenter: undefined,
         });
     }
-    const { modality, seriesInstanceUID } = metaData.get('generalSeriesModule', imageId0);
-    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = metaData.get('imagePlaneModule', imageId0);
+    const { modality, seriesInstanceUID } = get('generalSeriesModule', imageId0);
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = get('imagePlaneModule', imageId0);
     return {
         BitsAllocated: bitsAllocated,
         BitsStored: bitsStored,

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

@@ -0,0 +1,2 @@
+import type { ScalingParameters } from '../types';
+export default function scaleArray(array: Float32Array | Uint8Array | Uint16Array | Int16Array, scalingParameters: ScalingParameters): Float32Array | Uint8Array | Uint16Array | Int16Array;