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

package/dist/esm/utilities/getVolumeViewportScrollInfo.js

@@ -1,6 +1,6 @@
 import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo';
-function getVolumeViewportScrollInfo(viewport, volumeId) {
-    const { sliceRange, spacingInNormalDirection, camera } = getVolumeSliceRangeInfo(viewport, volumeId);
+function getVolumeViewportScrollInfo(viewport, volumeId, useSlabThickness = false) {
+    const { sliceRange, spacingInNormalDirection, camera } = getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness);
     const { min, max, current } = sliceRange;
     const numScrollSteps = Math.round((max - min) / spacingInNormalDirection);
     const fraction = (current - min) / (max - min);
@@ -17,4 +17,3 @@ function getVolumeViewportScrollInfo(viewport, volumeId) {
     };
 }
 export default getVolumeViewportScrollInfo;
-//# sourceMappingURL=getVolumeViewportScrollInfo.js.map

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

@@ -1,3 +1,3 @@
-import { IVolumeViewport } from '../types';
-declare function getVolumeViewportsContainingSameVolumes(targetViewport: IVolumeViewport, renderingEngineId?: string): Array<IVolumeViewport>;
+import type { IVolumeViewport } from '../types';
+declare function getVolumeViewportsContainingSameVolumes(targetViewport: IVolumeViewport, renderingEngineId?: string): IVolumeViewport[];
 export default getVolumeViewportsContainingSameVolumes;

package/dist/esm/utilities/getVolumeViewportsContainingSameVolumes.js

@@ -25,4 +25,3 @@ function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngine
     return sameVolumesViewports;
 }
 export default getVolumeViewportsContainingSameVolumes;
-//# sourceMappingURL=getVolumeViewportsContainingSameVolumes.js.map

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

@@ -0,0 +1,2 @@
+import type { ScalingParameters } from '../types';
+export declare const hasFloatScalingParameters: (scalingParameters: ScalingParameters) => boolean;

package/dist/esm/utilities/hasFloatScalingParameters.js

@@ -0,0 +1,4 @@
+export const hasFloatScalingParameters = (scalingParameters) => {
+    const hasFloatRescale = Object.values(scalingParameters).some((value) => typeof value === 'number' && !Number.isInteger(value));
+    return hasFloatRescale;
+};

package/dist/esm/utilities/hasNaNValues.js

@@ -4,4 +4,3 @@ export default function hasNaNValues(input) {
     }
     return Number.isNaN(input);
 }
-//# sourceMappingURL=hasNaNValues.js.map

package/dist/esm/utilities/imageIdToURI.js

@@ -2,4 +2,3 @@ export default function imageIdToURI(imageId) {
     const colonIndex = imageId.indexOf(':');
     return imageId.substring(colonIndex + 1);
 }
-//# sourceMappingURL=imageIdToURI.js.map

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

@@ -0,0 +1,7 @@
+declare const imageRetrieveMetadataProvider: {
+    IMAGE_RETRIEVE_CONFIGURATION: string;
+    clear: () => void;
+    add: (key: string, payload: any) => void;
+    get: (type: string, ...queries: string[]) => unknown;
+};
+export default imageRetrieveMetadataProvider;

package/dist/esm/utilities/imageRetrieveMetadataProvider.js

@@ -0,0 +1,21 @@
+import { addProvider } from '../metaData';
+const retrieveConfigurationState = new Map();
+const IMAGE_RETRIEVE_CONFIGURATION = 'imageRetrieveConfiguration';
+const imageRetrieveMetadataProvider = {
+    IMAGE_RETRIEVE_CONFIGURATION,
+    clear: () => {
+        retrieveConfigurationState.clear();
+    },
+    add: (key, payload) => {
+        retrieveConfigurationState.set(key, payload);
+    },
+    get: (type, ...queries) => {
+        if (type === IMAGE_RETRIEVE_CONFIGURATION) {
+            return queries
+                .map((query) => retrieveConfigurationState.get(query))
+                .find((it) => it !== undefined);
+        }
+    },
+};
+addProvider(imageRetrieveMetadataProvider.get.bind(imageRetrieveMetadataProvider));
+export default imageRetrieveMetadataProvider;

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

@@ -1,2 +1,2 @@
-import { Point2, Point3 } from '../types';
+import type { Point2, Point3 } from '../types';
 export default function imageToWorldCoords(imageId: string, imageCoords: Point2): Point3 | undefined;

package/dist/esm/utilities/imageToWorldCoords.js

@@ -14,4 +14,3 @@ export default function imageToWorldCoords(imageId, imageCoords) {
     vec3.scaleAndAdd(imageCoordsInWorld, imageCoordsInWorld, columnCosines, columnPixelSpacing * (imageCoords[1] - 0.5));
     return Array.from(imageCoordsInWorld);
 }
-//# sourceMappingURL=imageToWorldCoords.js.map

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

@@ -1,3 +1,4 @@
+import * as eventListener from './eventListener';
 import csUtils from './invertRgbTransferFunction';
 import createSigmoidRGBTransferFunction from './createSigmoidRGBTransferFunction';
 import getVoiFromSigmoidRGBTransferFunction from './getVoiFromSigmoidRGBTransferFunction';
@@ -9,12 +10,9 @@ import getMinMax from './getMinMax';
 import getRuntimeId from './getRuntimeId';
 import imageIdToURI from './imageIdToURI';
 import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
-import isEqual from './isEqual';
+import clamp from './clamp';
+import { isEqual, isEqualAbs, isEqualNegative } from './isEqual';
 import isOpposite from './isOpposite';
-import createUint8SharedArray from './createUint8SharedArray';
-import createFloat32SharedArray from './createFloat32SharedArray';
-import createUint16SharedArray from './createUInt16SharedArray';
-import createInt16SharedArray from './createInt16SharedArray';
 import getClosestImageId from './getClosestImageId';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
@@ -23,6 +21,7 @@ import indexWithinDimensions from './indexWithinDimensions';
 import getVolumeViewportsContainingSameVolumes from './getVolumeViewportsContainingSameVolumes';
 import getViewportsWithVolumeId from './getViewportsWithVolumeId';
 import transformWorldToIndex from './transformWorldToIndex';
+import transformIndexToWorld from './transformIndexToWorld';
 import loadImageToCanvas from './loadImageToCanvas';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import renderToCanvasGPU from './renderToCanvasGPU';
@@ -36,17 +35,43 @@ import getImageSliceDataForVolumeViewport from './getImageSliceDataForVolumeView
 import { isImageActor, actorIsA } from './actorCheck';
 import getViewportsWithImageURI from './getViewportsWithImageURI';
 import getClosestStackImageIndexForPoint from './getClosestStackImageIndexForPoint';
+import getCurrentVolumeViewportSlice from './getCurrentVolumeViewportSlice';
 import calculateViewportsSpatialRegistration from './calculateViewportsSpatialRegistration';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
 import getViewportImageCornersInWorld from './getViewportImageCornersInWorld';
 import hasNaNValues from './hasNaNValues';
 import applyPreset from './applyPreset';
+import PointsManager from './PointsManager';
 import deepMerge from './deepMerge';
 import getScalingParameters from './getScalingParameters';
-import getScalarDataType from './getScalarDataType';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
 import getImageLegacy from './getImageLegacy';
+import sortImageIdsAndGetSpacing from './sortImageIdsAndGetSpacing';
+import makeVolumeMetadata from './makeVolumeMetadata';
+import genericMetadataProvider from './genericMetadataProvider';
+import { isValidVolume } from './isValidVolume';
+import { updateVTKImageDataWithCornerstoneImage } from './updateVTKImageDataWithCornerstoneImage';
+import ProgressiveIterator from './ProgressiveIterator';
+import decimate from './decimate';
+import imageRetrieveMetadataProvider from './imageRetrieveMetadataProvider';
+import isVideoTransferSyntax from './isVideoTransferSyntax';
+import { getBufferConfiguration } from './getBufferConfiguration';
+import { generateVolumePropsFromImageIds } from './generateVolumePropsFromImageIds';
+import { convertStackToVolumeViewport } from './convertStackToVolumeViewport';
+import { convertVolumeToStackViewport } from './convertVolumeToStackViewport';
+import VoxelManager from './VoxelManager';
+import RLEVoxelMap from './RLEVoxelMap';
+import roundNumber, { roundToPrecision } from './roundNumber';
+import convertToGrayscale from './convertToGrayscale';
+import getViewportImageIds from './getViewportImageIds';
+import { getRandomSampleFromArray } from './getRandomSampleFromArray';
+import { getVolumeId } from './getVolumeId';
+import { hasFloatScalingParameters } from './hasFloatScalingParameters';
 import * as planar from './planar';
 import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
-export { csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isOpposite, createFloat32SharedArray, createUint8SharedArray, createUint16SharedArray, createInt16SharedArray, windowLevel, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, getScalingParameters, getScalarDataType, colormap, getImageLegacy, };
+import * as transferFunctionUtils from './transferFunctionUtils';
+import * as color from './color';
+import type { IViewport } from '../types/IViewport';
+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, };

package/dist/esm/utilities/index.js

@@ -1,3 +1,4 @@
+import * as eventListener from './eventListener';
 import csUtils from './invertRgbTransferFunction';
 import createSigmoidRGBTransferFunction from './createSigmoidRGBTransferFunction';
 import getVoiFromSigmoidRGBTransferFunction from './getVoiFromSigmoidRGBTransferFunction';
@@ -9,12 +10,9 @@ import getMinMax from './getMinMax';
 import getRuntimeId from './getRuntimeId';
 import imageIdToURI from './imageIdToURI';
 import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
-import isEqual from './isEqual';
+import clamp from './clamp';
+import { isEqual, isEqualAbs, isEqualNegative } from './isEqual';
 import isOpposite from './isOpposite';
-import createUint8SharedArray from './createUint8SharedArray';
-import createFloat32SharedArray from './createFloat32SharedArray';
-import createUint16SharedArray from './createUInt16SharedArray';
-import createInt16SharedArray from './createInt16SharedArray';
 import getClosestImageId from './getClosestImageId';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
@@ -23,6 +21,7 @@ import indexWithinDimensions from './indexWithinDimensions';
 import getVolumeViewportsContainingSameVolumes from './getVolumeViewportsContainingSameVolumes';
 import getViewportsWithVolumeId from './getViewportsWithVolumeId';
 import transformWorldToIndex from './transformWorldToIndex';
+import transformIndexToWorld from './transformIndexToWorld';
 import loadImageToCanvas from './loadImageToCanvas';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import renderToCanvasGPU from './renderToCanvasGPU';
@@ -36,18 +35,44 @@ import getImageSliceDataForVolumeViewport from './getImageSliceDataForVolumeView
 import { isImageActor, actorIsA } from './actorCheck';
 import getViewportsWithImageURI from './getViewportsWithImageURI';
 import getClosestStackImageIndexForPoint from './getClosestStackImageIndexForPoint';
+import getCurrentVolumeViewportSlice from './getCurrentVolumeViewportSlice';
 import calculateViewportsSpatialRegistration from './calculateViewportsSpatialRegistration';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
 import getViewportImageCornersInWorld from './getViewportImageCornersInWorld';
 import hasNaNValues from './hasNaNValues';
 import applyPreset from './applyPreset';
+import PointsManager from './PointsManager';
 import deepMerge from './deepMerge';
 import getScalingParameters from './getScalingParameters';
-import getScalarDataType from './getScalarDataType';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
 import getImageLegacy from './getImageLegacy';
+import sortImageIdsAndGetSpacing from './sortImageIdsAndGetSpacing';
+import makeVolumeMetadata from './makeVolumeMetadata';
+import genericMetadataProvider from './genericMetadataProvider';
+import { isValidVolume } from './isValidVolume';
+import { updateVTKImageDataWithCornerstoneImage } from './updateVTKImageDataWithCornerstoneImage';
+import ProgressiveIterator from './ProgressiveIterator';
+import decimate from './decimate';
+import imageRetrieveMetadataProvider from './imageRetrieveMetadataProvider';
+import isVideoTransferSyntax from './isVideoTransferSyntax';
+import { getBufferConfiguration } from './getBufferConfiguration';
+import { generateVolumePropsFromImageIds } from './generateVolumePropsFromImageIds';
+import { convertStackToVolumeViewport } from './convertStackToVolumeViewport';
+import { convertVolumeToStackViewport } from './convertVolumeToStackViewport';
+import VoxelManager from './VoxelManager';
+import RLEVoxelMap from './RLEVoxelMap';
+import roundNumber, { roundToPrecision } from './roundNumber';
+import convertToGrayscale from './convertToGrayscale';
+import getViewportImageIds from './getViewportImageIds';
+import { getRandomSampleFromArray } from './getRandomSampleFromArray';
+import { getVolumeId } from './getVolumeId';
+import { hasFloatScalingParameters } from './hasFloatScalingParameters';
 import * as planar from './planar';
 import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
-export { csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isOpposite, createFloat32SharedArray, createUint8SharedArray, createUint16SharedArray, createInt16SharedArray, windowLevel, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, getScalingParameters, getScalarDataType, colormap, getImageLegacy, };
-//# sourceMappingURL=index.js.map
+import * as transferFunctionUtils from './transferFunctionUtils';
+import * as color from './color';
+import { _getViewportModality } from './getViewportModality';
+import cache from '../cache';
+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, };

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

@@ -1,2 +1,2 @@
-import { Point3 } from '../types';
+import type { Point3 } from '../types';
 export default function indexWithinDimensions(index: Point3, dimensions: Point3): boolean;

package/dist/esm/utilities/indexWithinDimensions.js

@@ -9,4 +9,3 @@ export default function indexWithinDimensions(index, dimensions) {
     }
     return true;
 }
-//# sourceMappingURL=indexWithinDimensions.js.map

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

@@ -1 +1,2 @@
-export default function invertRgbTransferFunction(rgbTransferFunction: any): void;
+import type { vtkColorTransferFunction } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+export default function invertRgbTransferFunction(rgbTransferFunction: vtkColorTransferFunction): void;

package/dist/esm/utilities/invertRgbTransferFunction.js

@@ -12,4 +12,3 @@ export default function invertRgbTransferFunction(rgbTransferFunction) {
         rgbTransferFunction.setNodeValue(index, nodeValue1);
     }
 }
-//# sourceMappingURL=invertRgbTransferFunction.js.map

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

@@ -1 +1,4 @@
 export default function isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean;
+declare const isEqualNegative: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
+declare const isEqualAbs: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
+export { isEqualNegative, isEqual, isEqualAbs };

package/dist/esm/utilities/isEqual.js

@@ -16,7 +16,12 @@ function isNumberType(value) {
     return typeof value === 'number';
 }
 function isNumberArrayLike(value) {
-    return 'length' in value && typeof value[0] === 'number';
+    return (value &&
+        typeof value === 'object' &&
+        'length' in value &&
+        typeof value.length === 'number' &&
+        value.length > 0 &&
+        typeof value[0] === 'number');
 }
 export default function isEqual(v1, v2, tolerance = 1e-5) {
     if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
@@ -30,4 +35,8 @@ export default function isEqual(v1, v2, tolerance = 1e-5) {
     }
     return false;
 }
-//# sourceMappingURL=isEqual.js.map
+const negative = (v) => typeof v === 'number' ? -v : v?.map ? v.map(negative) : !v;
+const abs = (v) => typeof v === 'number' ? Math.abs(v) : v?.map ? v.map(abs) : v;
+const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
+const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
+export { isEqualNegative, isEqual, isEqualAbs };

package/dist/esm/utilities/isOpposite.js

@@ -3,4 +3,3 @@ export default function isOpposite(v1, v2, tolerance = 1e-5) {
         Math.abs(v1[1] + v2[1]) < tolerance &&
         Math.abs(v1[2] + v2[2]) < tolerance);
 }
-//# sourceMappingURL=isOpposite.js.map

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

@@ -1,3 +1,3 @@
-import { IImage } from '../types';
+import type { IImage } from '../types';
 declare const isPTPrescaledWithSUV: (image: IImage) => number;
 export default isPTPrescaledWithSUV;

package/dist/esm/utilities/isPTPrescaledWithSUV.js

@@ -1,5 +1,4 @@
 const isPTPrescaledWithSUV = (image) => {
-    return image.preScale?.scaled && image.preScale.scalingParameters?.suvbw;
+    return image.preScale.scaled && image.preScale.scalingParameters.suvbw;
 };
 export default isPTPrescaledWithSUV;
-//# sourceMappingURL=isPTPrescaledWithSUV.js.map

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

@@ -1 +1 @@
-export default function isTypedArray(obj: any): boolean;
+export default function isTypedArray(obj: unknown): boolean;

package/dist/esm/utilities/isTypedArray.js

@@ -9,4 +9,3 @@ export default function isTypedArray(obj) {
         obj instanceof Float32Array ||
         obj instanceof Float64Array);
 }
-//# sourceMappingURL=isTypedArray.js.map

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

@@ -0,0 +1,2 @@
+declare function isValidVolume(imageIds: string[]): boolean;
+export { isValidVolume };

package/dist/esm/utilities/isValidVolume.js

@@ -0,0 +1,28 @@
+import { metaData } from '..';
+import isEqual from './isEqual';
+function isValidVolume(imageIds) {
+    const imageId0 = imageIds[0];
+    const { modality, seriesInstanceUID } = metaData.get('generalSeriesModule', imageId0);
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = metaData.get('imagePlaneModule', imageId0);
+    const baseMetadata = {
+        modality,
+        imageOrientationPatient,
+        pixelSpacing,
+        frameOfReferenceUID,
+        columns,
+        rows,
+        seriesInstanceUID,
+    };
+    const validVolume = imageIds.every((imageId) => {
+        const { modality, seriesInstanceUID } = metaData.get('generalSeriesModule', imageId);
+        const { imageOrientationPatient, pixelSpacing, columns, rows } = metaData.get('imagePlaneModule', imageId);
+        return (seriesInstanceUID === baseMetadata.seriesInstanceUID &&
+            modality === baseMetadata.modality &&
+            columns === baseMetadata.columns &&
+            rows === baseMetadata.rows &&
+            isEqual(imageOrientationPatient, baseMetadata.imageOrientationPatient) &&
+            isEqual(pixelSpacing, baseMetadata.pixelSpacing));
+    });
+    return validVolume;
+}
+export { isValidVolume };

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

@@ -0,0 +1,2 @@
+export declare const videoUIDs: Set<string>;
+export default function isVideoTransferSyntax(uidOrUids: string | string[]): string | false;

package/dist/esm/utilities/isVideoTransferSyntax.js

@@ -0,0 +1,25 @@
+export const videoUIDs = new Set([
+    '1.2.840.10008.1.2.4.100',
+    '1.2.840.10008.1.2.4.100.1',
+    '1.2.840.10008.1.2.4.101',
+    '1.2.840.10008.1.2.4.101.1',
+    '1.2.840.10008.1.2.4.102',
+    '1.2.840.10008.1.2.4.102.1',
+    '1.2.840.10008.1.2.4.103',
+    '1.2.840.10008.1.2.4.103.1',
+    '1.2.840.10008.1.2.4.104',
+    '1.2.840.10008.1.2.4.104.1',
+    '1.2.840.10008.1.2.4.105',
+    '1.2.840.10008.1.2.4.105.1',
+    '1.2.840.10008.1.2.4.106',
+    '1.2.840.10008.1.2.4.106.1',
+    '1.2.840.10008.1.2.4.107',
+    '1.2.840.10008.1.2.4.108',
+]);
+export default function isVideoTransferSyntax(uidOrUids) {
+    if (!uidOrUids) {
+        return false;
+    }
+    const uids = Array.isArray(uidOrUids) ? uidOrUids : [uidOrUids];
+    return uids.find((uid) => videoUIDs.has(uid));
+}

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

@@ -1,11 +1,31 @@
+import type { ViewPresentation, ViewReference, ViewportInputOptions, Point3 } from '../types';
 import { RequestType } from '../enums';
-interface LoadImageOptions {
-    canvas: HTMLCanvasElement;
+export interface StackLoadImageOptions {
     imageId: string;
+}
+export interface FullImageLoadOptions {
+    viewReference: ViewReference;
+    viewPresentation: ViewPresentation;
+    imageId: undefined;
+}
+export interface CanvasLoadPosition {
+    origin: Point3;
+    topRight: Point3;
+    bottomLeft: Point3;
+    thicknessMm: number;
+}
+export type LoadImageOptions = {
+    canvas: HTMLCanvasElement;
+    imageId?: string;
+    viewReference?: ViewReference;
+    viewPresentation?: ViewPresentation;
     requestType?: RequestType;
     priority?: number;
     renderingEngineId?: string;
     useCPURendering?: boolean;
-}
-export default function loadImageToCanvas(options: LoadImageOptions): Promise<string>;
-export {};
+    thumbnail?: boolean;
+    imageAspect?: boolean;
+    physicalPixels?: boolean;
+    viewportOptions?: ViewportInputOptions;
+} & (StackLoadImageOptions | FullImageLoadOptions);
+export default function loadImageToCanvas(options: LoadImageOptions): Promise<CanvasLoadPosition>;

package/dist/esm/utilities/loadImageToCanvas.js

@@ -5,16 +5,36 @@ import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import renderToCanvasGPU from './renderToCanvasGPU';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import { getConfiguration } from '../init';
+import cache from '../cache';
 export default function loadImageToCanvas(options) {
-    const { canvas, imageId, requestType = RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, } = 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;
+    const isVolume = volumeId && !imageId;
+    const viewportOptions = viewReference && baseViewportOptions
+        ? { ...baseViewportOptions, viewReference }
+        : baseViewportOptions;
     const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
     return new Promise((resolve, reject) => {
-        function successCallback(image, imageId) {
+        function successCallback(imageOrVolume, imageId) {
             const { modality } = metaData.get('generalSeriesModule', imageId) || {};
-            image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
-            renderFn(canvas, image, modality, renderingEngineId).then(() => {
-                resolve(imageId);
-            });
+            const image = !isVolume && imageOrVolume;
+            const volume = isVolume && imageOrVolume;
+            if (image) {
+                image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            }
+            if (thumbnail) {
+                canvas.height = 256;
+                canvas.width = 256;
+            }
+            if (imageAspect && image) {
+                canvas.width = image && (canvas.height * image.width) / image.height;
+            }
+            canvas.style.width = `${canvas.width / devicePixelRatio}px`;
+            canvas.style.height = `${canvas.height / devicePixelRatio}px`;
+            if (volume && useCPURendering) {
+                reject(new Error('CPU rendering of volume not supported'));
+            }
+            renderFn(canvas, imageOrVolume, modality, renderingEngineId, viewportOptions).then(resolve);
         }
         function errorCallback(error, imageId) {
             console.error(error, imageId);
@@ -32,13 +52,19 @@ export default function loadImageToCanvas(options) {
             targetBuffer: {
                 type: useNorm16Texture ? undefined : 'Float32Array',
             },
-            preScale: {
-                enabled: true,
-            },
             useRGBA: !!useCPURendering,
             requestType,
         };
-        imageLoadPoolManager.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        if (volumeId) {
+            const volume = cache.getVolume(volumeId);
+            if (!volume) {
+                reject(new Error(`Volume id ${volumeId} not found in cache`));
+            }
+            const useImageId = volume.imageIds[0];
+            successCallback(volume, useImageId);
+        }
+        else {
+            imageLoadPoolManager.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        }
     });
 }
-//# sourceMappingURL=loadImageToCanvas.js.map

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

@@ -0,0 +1,2 @@
+import type { Metadata } from '../types';
+export default function makeVolumeMetadata(imageIds: string[]): Metadata;

package/dist/esm/utilities/makeVolumeMetadata.js

@@ -0,0 +1,51 @@
+import { metaData } from '../';
+export default function makeVolumeMetadata(imageIds) {
+    const imageId0 = imageIds[0];
+    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId0);
+    const voiLut = [];
+    const voiLutModule = metaData.get('voiLutModule', imageId0);
+    let voiLUTFunction;
+    if (voiLutModule) {
+        const { windowWidth, windowCenter } = voiLutModule;
+        voiLUTFunction = voiLutModule?.voiLUTFunction;
+        if (Array.isArray(windowWidth)) {
+            for (let i = 0; i < windowWidth.length; i++) {
+                voiLut.push({
+                    windowWidth: windowWidth[i],
+                    windowCenter: windowCenter[i],
+                });
+            }
+        }
+        else {
+            voiLut.push({
+                windowWidth: windowWidth,
+                windowCenter: windowCenter,
+            });
+        }
+    }
+    else {
+        voiLut.push({
+            windowWidth: undefined,
+            windowCenter: undefined,
+        });
+    }
+    const { modality, seriesInstanceUID } = metaData.get('generalSeriesModule', imageId0);
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = metaData.get('imagePlaneModule', imageId0);
+    return {
+        BitsAllocated: bitsAllocated,
+        BitsStored: bitsStored,
+        SamplesPerPixel: samplesPerPixel,
+        HighBit: highBit,
+        PhotometricInterpretation: photometricInterpretation,
+        PixelRepresentation: pixelRepresentation,
+        Modality: modality,
+        ImageOrientationPatient: imageOrientationPatient,
+        PixelSpacing: pixelSpacing,
+        FrameOfReferenceUID: frameOfReferenceUID,
+        Columns: columns,
+        Rows: rows,
+        voiLut,
+        VOILUTFunction: voiLUTFunction,
+        SeriesInstanceUID: seriesInstanceUID,
+    };
+}

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

@@ -1,7 +1,7 @@
-import { Point3, Plane } from '../types';
-import { vec3 } from 'gl-matrix';
+import type { Point3, Plane } from '../types';
+import type { vec3 } from 'gl-matrix';
 declare function linePlaneIntersection(p0: Point3, p1: Point3, plane: Plane): Point3;
-declare function planeEquation(normal: Point3, point: Point3 | vec3): Plane;
+declare function planeEquation(normal: Point3, point: Point3 | vec3, normalized?: boolean): Plane;
 declare function threePlaneIntersection(firstPlane: Plane, secondPlane: Plane, thirdPlane: Plane): Point3;
 declare function planeDistanceToPoint(plane: Plane, point: Point3, signed?: boolean): number;
 export { linePlaneIntersection, planeEquation, threePlaneIntersection, planeDistanceToPoint, };

package/dist/esm/utilities/planar.js

@@ -12,9 +12,13 @@ function linePlaneIntersection(p0, p1, plane) {
     const Z = c * t + z0;
     return [X, Y, Z];
 }
-function planeEquation(normal, point) {
+function planeEquation(normal, point, normalized = false) {
     const [A, B, C] = normal;
     const D = A * point[0] + B * point[1] + C * point[2];
+    if (normalized) {
+        const length = Math.sqrt(A * A + B * B + C * C);
+        return [A / length, B / length, C / length, D / length];
+    }
     return [A, B, C, D];
 }
 function threePlaneIntersection(firstPlane, secondPlane, thirdPlane) {
@@ -39,4 +43,3 @@ function planeDistanceToPoint(plane, point, signed = false) {
     return sign * distance;
 }
 export { linePlaneIntersection, planeEquation, threePlaneIntersection, planeDistanceToPoint, };
-//# sourceMappingURL=planar.js.map

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

@@ -1,2 +1,3 @@
-import { IImage } from '../types';
-export default function renderToCanvasCPU(canvas: HTMLCanvasElement, image: IImage, modality?: string, renderingEngineId?: string): Promise<string>;
+import type { IImage, ViewportInputOptions, IVolume } from '../types';
+import type { CanvasLoadPosition } from './loadImageToCanvas';
+export default function renderToCanvasCPU(canvas: HTMLCanvasElement, imageOrVolume: IImage | IVolume, modality?: string, _renderingEngineId?: string, _viewportOptions?: ViewportInputOptions): Promise<CanvasLoadPosition>;

package/dist/esm/utilities/renderToCanvasCPU.js

@@ -1,7 +1,12 @@
 import getDefaultViewport from '../RenderingEngine/helpers/cpuFallback/rendering/getDefaultViewport';
 import calculateTransform from '../RenderingEngine/helpers/cpuFallback/rendering/calculateTransform';
 import drawImageSync from '../RenderingEngine/helpers/cpuFallback/drawImageSync';
-export default function renderToCanvasCPU(canvas, image, modality, renderingEngineId) {
+export default function renderToCanvasCPU(canvas, imageOrVolume, modality, _renderingEngineId, _viewportOptions) {
+    const volume = imageOrVolume;
+    if (volume.volumeId) {
+        throw new Error('Unsupported volume rendering for CPU');
+    }
+    const image = imageOrVolume;
     const viewport = getDefaultViewport(canvas, image, modality);
     const enabledElement = {
         canvas,
@@ -13,7 +18,6 @@ export default function renderToCanvasCPU(canvas, image, modality, renderingEngi
     const invalidated = true;
     return new Promise((resolve, reject) => {
         drawImageSync(enabledElement, invalidated);
-        resolve(image.imageId);
+        resolve(null);
     });
 }
-//# sourceMappingURL=renderToCanvasCPU.js.map