@cornerstonejs/core 2.0.0-beta.22 → 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/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

@@ -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, ViewportInput, };
+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/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/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/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

@@ -74,5 +74,9 @@ import * as transferFunctionUtils from './transferFunctionUtils';
 import * as color from './color';
 import { _getViewportModality } from './getViewportModality';
 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/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;

package/dist/esm/utilities/scaleArray.js

@@ -0,0 +1,15 @@
+export default function scaleArray(array, scalingParameters) {
+    const arrayLength = array.length;
+    const { rescaleSlope, rescaleIntercept, suvbw } = scalingParameters;
+    if (scalingParameters.modality === 'PT' && typeof suvbw === 'number') {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = suvbw * (array[i] * rescaleSlope + rescaleIntercept);
+        }
+    }
+    else {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = array[i] * rescaleSlope + rescaleIntercept;
+        }
+    }
+    return array;
+}

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

@@ -0,0 +1,5 @@
+declare function splitImageIdsBy4DTags(imageIds: string[]): {
+    imageIdGroups: string[][];
+    splittingTag: string | null;
+};
+export default splitImageIdsBy4DTags;

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -0,0 +1,161 @@
+import * as metaData from '../metaData';
+const groupBy = (array, key) => {
+    return array.reduce((rv, x) => {
+        (rv[x[key]] = rv[x[key]] || []).push(x);
+        return rv;
+    }, {});
+};
+function getIPPGroups(imageIds) {
+    const ippMetadata = imageIds.map((imageId) => {
+        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId) || {};
+        return { imageId, imagePositionPatient };
+    });
+    if (!ippMetadata.every((item) => item.imagePositionPatient)) {
+        return null;
+    }
+    const positionGroups = groupBy(ippMetadata, 'imagePositionPatient');
+    const positions = Object.keys(positionGroups);
+    const frame_count = positionGroups[positions[0]].length;
+    if (frame_count === 1) {
+        return null;
+    }
+    const frame_count_equal = positions.every((k) => positionGroups[k].length === frame_count);
+    if (!frame_count_equal) {
+        return null;
+    }
+    return positionGroups;
+}
+function test4DTag(IPPGroups, value_getter) {
+    const frame_groups = {};
+    let first_frame_value_set = [];
+    const positions = Object.keys(IPPGroups);
+    for (let i = 0; i < positions.length; i++) {
+        const frame_value_set = new Set();
+        const frames = IPPGroups[positions[i]];
+        for (let j = 0; j < frames.length; j++) {
+            const frame_value = value_getter(frames[j].imageId) || 0;
+            frame_groups[frame_value] = frame_groups[frame_value] || [];
+            frame_groups[frame_value].push({ imageId: frames[j].imageId });
+            frame_value_set.add(frame_value);
+            if (frame_value_set.size - 1 < j) {
+                return undefined;
+            }
+        }
+        if (i == 0) {
+            first_frame_value_set = Array.from(frame_value_set);
+        }
+        else if (!setEquals(first_frame_value_set, frame_value_set)) {
+            return undefined;
+        }
+    }
+    return frame_groups;
+}
+function getTagValue(imageId, tag) {
+    const value = metaData.get(tag, imageId);
+    try {
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getPhilipsPrivateBValue(imageId) {
+    const value = metaData.get('20011003', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            const value_bytes = atob(InlineBinary);
+            const ary_buf = new ArrayBuffer(value_bytes.length);
+            const dv = new DataView(ary_buf);
+            for (let i = 0; i < value_bytes.length; i++) {
+                dv.setUint8(i, value_bytes.charCodeAt(i));
+            }
+            return new Float32Array(ary_buf)[0];
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSiemensPrivateBValue(imageId) {
+    let value = metaData.get('0019100c', imageId) || metaData.get('0019100C', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary);
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getGEPrivateBValue(imageId) {
+    let value = metaData.get('00431039', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary).split('//');
+        }
+        return parseFloat(value[0]) % 100000;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setEquals(set_a, set_b) {
+    if (set_a.length != set_b.size) {
+        return false;
+    }
+    for (let i = 0; i < set_a.length; i++) {
+        if (!set_b.has(set_a[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function getPetFrameReferenceTime(imageId) {
+    const moduleInfo = metaData.get('petImageModule', imageId);
+    return moduleInfo ? moduleInfo['frameReferenceTime'] : 0;
+}
+function splitImageIdsBy4DTags(imageIds) {
+    const positionGroups = getIPPGroups(imageIds);
+    if (!positionGroups) {
+        return { imageIdGroups: [imageIds], splittingTag: null };
+    }
+    const tags = [
+        'TemporalPositionIdentifier',
+        'DiffusionBValue',
+        'TriggerTime',
+        'EchoTime',
+        'EchoNumber',
+        'PhilipsPrivateBValue',
+        'SiemensPrivateBValue',
+        'GEPrivateBValue',
+        'PetFrameReferenceTime',
+    ];
+    const fncList2 = [
+        (imageId) => getTagValue(imageId, tags[0]),
+        (imageId) => getTagValue(imageId, tags[1]),
+        (imageId) => getTagValue(imageId, tags[2]),
+        (imageId) => getTagValue(imageId, tags[3]),
+        (imageId) => getTagValue(imageId, tags[4]),
+        getPhilipsPrivateBValue,
+        getSiemensPrivateBValue,
+        getGEPrivateBValue,
+        getPetFrameReferenceTime,
+    ];
+    for (let i = 0; i < fncList2.length; i++) {
+        const frame_groups = test4DTag(positionGroups, fncList2[i]);
+        if (frame_groups) {
+            const sortedKeys = Object.keys(frame_groups)
+                .map(Number.parseFloat)
+                .sort((a, b) => a - b);
+            const imageIdGroups = sortedKeys.map((key) => frame_groups[key].map((item) => item.imageId));
+            return { imageIdGroups, splittingTag: tags[i] };
+        }
+    }
+    return { imageIdGroups: [imageIds], splittingTag: null };
+}
+export default splitImageIdsBy4DTags;