@cornerstonejs/core 3.5.3 → 3.6.0

package/dist/esm/RenderingEngine/StackViewport.d.ts

@@ -86,7 +86,6 @@ declare class StackViewport extends Viewport {
     getCornerstoneImage: () => IImage;
     private createActorMapper;
     getNumberOfSlices: () => number;
-    private buildMetadata;
     private calibrateIfNecessary;
     setDefaultProperties(ViewportProperties: StackViewportProperties, imageId?: string): void;
     clearDefaultProperties(imageId?: string): void;
@@ -120,7 +119,6 @@ declare class StackViewport extends Viewport {
     private getTransferFunction;
     private setVOIGPU;
     private _addScalingToViewport;
-    private _getNumCompsFromPhotometricInterpretation;
     getImageDataMetadata(image: IImage): ImageDataMetaData;
     private matchImagesForOverlay;
     getImagePlaneReferenceData(sliceIndex?: number): ViewReference;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -8,6 +8,7 @@ import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import { mat4, vec2, vec3 } from 'gl-matrix';
 import eventTarget from '../eventTarget';
 import * as metaData from '../metaData';
+import { getImageDataMetadata as getImageDataMetadataUtil } from '../utilities/getImageDataMetadata';
 import { coreLog } from '../utilities/logger';
 import { actorIsA, isImageActor } from '../utilities/actorCheck';
 import * as colormapUtils from '../utilities/colormap';
@@ -23,6 +24,7 @@ import imageRetrieveMetadataProvider from '../utilities/imageRetrieveMetadataPro
 import imageIdToURI from '../utilities/imageIdToURI';
 import Viewport from './Viewport';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
+import { getImagePlaneModule } from '../utilities/buildMetadata';
 import { Events, InterpolationType, MetadataModules, RequestType, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import { loadAndCacheImage } from '../loaders/imageLoader';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
@@ -519,40 +521,6 @@ class StackViewport extends Viewport {
             voxelManager: csImage?.voxelManager,
         };
     }
-    buildMetadata(image) {
-        const imageId = image.imageId;
-        const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId);
-        const { windowWidth, windowCenter, voiLUTFunction } = image;
-        const { modality } = metaData.get('generalSeriesModule', imageId);
-        const imageIdScalingFactor = metaData.get('scalingModule', imageId);
-        const calibration = metaData.get(MetadataModules.CALIBRATION, imageId);
-        if (modality === 'PT' && imageIdScalingFactor) {
-            this._addScalingToViewport(imageIdScalingFactor);
-        }
-        this.modality = modality;
-        const voiLUTFunctionEnum = this._getValidVOILUTFunction(voiLUTFunction);
-        this.VOILUTFunction = voiLUTFunctionEnum;
-        this.calibration = calibration;
-        let imagePlaneModule = this._getImagePlaneModule(imageId);
-        if (!this.useCPURendering) {
-            imagePlaneModule = this.calibrateIfNecessary(imageId, imagePlaneModule);
-        }
-        return {
-            imagePlaneModule,
-            imagePixelModule: {
-                bitsAllocated,
-                bitsStored,
-                samplesPerPixel,
-                highBit,
-                photometricInterpretation,
-                pixelRepresentation,
-                windowWidth,
-                windowCenter,
-                modality,
-                voiLUTFunction: voiLUTFunctionEnum,
-            },
-        };
-    }
     calibrateIfNecessary(imageId, imagePlaneModule) {
         const calibration = metaData.get('calibratedPixelSpacing', imageId);
         const isUpdated = this.calibration !== calibration;
@@ -1015,46 +983,29 @@ class StackViewport extends Viewport {
         }
         this.scaling.PT = ptScaling;
     }
-    _getNumCompsFromPhotometricInterpretation(photometricInterpretation) {
-        let numberOfComponents = 1;
-        if (photometricInterpretation === 'RGB' ||
-            photometricInterpretation.includes('YBR') ||
-            photometricInterpretation === 'PALETTE COLOR') {
-            numberOfComponents = 3;
-        }
-        return numberOfComponents;
-    }
     getImageDataMetadata(image) {
-        const { imagePlaneModule, imagePixelModule } = this.buildMetadata(image);
-        let { rowCosines, columnCosines } = imagePlaneModule;
-        if (rowCosines == null || columnCosines == null) {
-            rowCosines = [1, 0, 0];
-            columnCosines = [0, 1, 0];
-        }
-        const rowCosineVec = vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
-        const colCosineVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
-        const scanAxisNormal = vec3.create();
-        vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
-        let origin = imagePlaneModule.imagePositionPatient;
-        if (origin == null) {
-            origin = [0, 0, 0];
+        const imageId = image.imageId;
+        const props = getImageDataMetadataUtil(image);
+        const { numberOfComponents, origin, direction, dimensions, spacing, numVoxels, imagePixelModule, voiLUTFunction, modality, scalingFactor, calibration, } = props;
+        if (modality === 'PT' && scalingFactor) {
+            this._addScalingToViewport(scalingFactor);
+        }
+        this.modality = modality;
+        const voiLUTFunctionEnum = this._getValidVOILUTFunction(voiLUTFunction);
+        this.VOILUTFunction = voiLUTFunctionEnum;
+        this.calibration = calibration;
+        let imagePlaneModule = this._getImagePlaneModule(imageId);
+        if (!this.useCPURendering) {
+            imagePlaneModule = this.calibrateIfNecessary(imageId, imagePlaneModule);
         }
-        const xSpacing = imagePlaneModule.columnPixelSpacing || image.columnPixelSpacing;
-        const ySpacing = imagePlaneModule.rowPixelSpacing || image.rowPixelSpacing;
-        const xVoxels = image.columns;
-        const yVoxels = image.rows;
-        const zSpacing = EPSILON;
-        const zVoxels = 1;
-        const numberOfComponents = image.numberOfComponents ||
-            this._getNumCompsFromPhotometricInterpretation(imagePixelModule.photometricInterpretation);
         return {
             bitsAllocated: imagePixelModule.bitsAllocated,
             numberOfComponents,
             origin,
-            direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
-            dimensions: [xVoxels, yVoxels, zVoxels],
-            spacing: [xSpacing, ySpacing, zSpacing],
-            numVoxels: xVoxels * yVoxels * zVoxels,
+            direction,
+            dimensions,
+            spacing,
+            numVoxels,
             imagePlaneModule,
             imagePixelModule,
         };
@@ -1877,34 +1828,11 @@ class StackViewport extends Viewport {
         throw new Error('unsetColormapGPU not implemented.');
     }
     _getImagePlaneModule(imageId) {
-        const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        const imagePlaneModule = getImagePlaneModule(imageId);
         this.hasPixelSpacing =
             !imagePlaneModule.usingDefaultValues || this.calibration?.scale > 0;
         this.calibration ||= imagePlaneModule.calibration;
-        const newImagePlaneModule = {
-            ...imagePlaneModule,
-        };
-        if (!newImagePlaneModule.columnPixelSpacing) {
-            newImagePlaneModule.columnPixelSpacing = 1;
-        }
-        if (!newImagePlaneModule.rowPixelSpacing) {
-            newImagePlaneModule.rowPixelSpacing = 1;
-        }
-        if (!newImagePlaneModule.columnCosines) {
-            newImagePlaneModule.columnCosines = [0, 1, 0];
-        }
-        if (!newImagePlaneModule.rowCosines) {
-            newImagePlaneModule.rowCosines = [1, 0, 0];
-        }
-        if (!newImagePlaneModule.imagePositionPatient) {
-            newImagePlaneModule.imagePositionPatient = [0, 0, 0];
-        }
-        if (!newImagePlaneModule.imageOrientationPatient) {
-            newImagePlaneModule.imageOrientationPatient = new Float32Array([
-                1, 0, 0, 0, 1, 0,
-            ]);
-        }
-        return newImagePlaneModule;
+        return imagePlaneModule;
     }
 }
 export default StackViewport;

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

@@ -5,7 +5,7 @@ export interface ImagePixelModule {
     samplesPerPixel: number;
     highBit: number;
     photometricInterpretation: string;
-    pixelRepresentation: string;
+    pixelRepresentation: number;
     windowWidth: number | number[];
     windowCenter: number | number[];
     voiLUTFunction: VOILUTFunctionType;

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

@@ -1,5 +1,6 @@
 import type Point2 from './Point2';
 import type Point3 from './Point3';
+import type IImageCalibration from './IImageCalibration';
 export interface ImagePlaneModule {
     columnCosines?: Point3;
     columnPixelSpacing?: number;
@@ -13,4 +14,6 @@ export interface ImagePlaneModule {
     frameOfReferenceUID: string;
     columns: number;
     rows: number;
+    usingDefaultValues?: boolean;
+    calibration?: IImageCalibration;
 }

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

@@ -0,0 +1,34 @@
+import { VOILUTFunctionType } from '../enums';
+import type IImage from '../types/IImage';
+import type { ImagePlaneModule } from '../types';
+import type IImageCalibration from '../types/IImageCalibration';
+export interface BuildMetadataResult {
+    scalingFactor: number;
+    imagePlaneModule: ImagePlaneModule;
+    voiLUTFunction: VOILUTFunctionType;
+    modality: string;
+    calibration: IImageCalibration;
+    imagePixelModule: {
+        bitsAllocated: number;
+        bitsStored: number;
+        samplesPerPixel: number;
+        highBit: number;
+        photometricInterpretation: string;
+        pixelRepresentation: number;
+        windowWidth: number;
+        windowCenter: number;
+        modality: string;
+        voiLUTFunction: VOILUTFunctionType;
+    };
+}
+export declare function getValidVOILUTFunction(voiLUTFunction: VOILUTFunctionType | unknown): VOILUTFunctionType;
+export declare function getImagePlaneModule(imageId: string): ImagePlaneModule;
+export declare function calibrateImagePlaneModule(imageId: string, imagePlaneModule: ImagePlaneModule, currentCalibration: IImageCalibration): {
+    imagePlaneModule: ImagePlaneModule;
+    hasPixelSpacing: boolean;
+    calibrationEvent?: {
+        scale: number;
+        calibration: IImageCalibration;
+    };
+};
+export declare function buildMetadata(image: IImage): BuildMetadataResult;

package/dist/esm/utilities/buildMetadata.js

@@ -0,0 +1,82 @@
+import * as metaData from '../metaData';
+import { MetadataModules, VOILUTFunctionType } from '../enums';
+export function getValidVOILUTFunction(voiLUTFunction) {
+    if (!Object.values(VOILUTFunctionType).includes(voiLUTFunction)) {
+        return VOILUTFunctionType.LINEAR;
+    }
+    return voiLUTFunction;
+}
+export function getImagePlaneModule(imageId) {
+    const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+    const newImagePlaneModule = {
+        ...imagePlaneModule,
+    };
+    if (!newImagePlaneModule.columnPixelSpacing) {
+        newImagePlaneModule.columnPixelSpacing = 1;
+    }
+    if (!newImagePlaneModule.rowPixelSpacing) {
+        newImagePlaneModule.rowPixelSpacing = 1;
+    }
+    if (!newImagePlaneModule.columnCosines) {
+        newImagePlaneModule.columnCosines = [0, 1, 0];
+    }
+    if (!newImagePlaneModule.rowCosines) {
+        newImagePlaneModule.rowCosines = [1, 0, 0];
+    }
+    if (!newImagePlaneModule.imagePositionPatient) {
+        newImagePlaneModule.imagePositionPatient = [0, 0, 0];
+    }
+    if (!newImagePlaneModule.imageOrientationPatient) {
+        newImagePlaneModule.imageOrientationPatient = new Float32Array([
+            1, 0, 0, 0, 1, 0,
+        ]);
+    }
+    return newImagePlaneModule;
+}
+export function calibrateImagePlaneModule(imageId, imagePlaneModule, currentCalibration) {
+    const calibration = metaData.get('calibratedPixelSpacing', imageId);
+    const isUpdated = currentCalibration !== calibration;
+    const { scale } = calibration || {};
+    const hasPixelSpacing = scale > 0 || imagePlaneModule.rowPixelSpacing > 0;
+    imagePlaneModule.calibration = calibration;
+    if (!isUpdated) {
+        return { imagePlaneModule, hasPixelSpacing };
+    }
+    return {
+        imagePlaneModule,
+        hasPixelSpacing,
+        calibrationEvent: {
+            scale,
+            calibration,
+        },
+    };
+}
+export function buildMetadata(image) {
+    const imageId = image.imageId;
+    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId);
+    const { windowWidth, windowCenter, voiLUTFunction } = image;
+    const { modality } = metaData.get('generalSeriesModule', imageId);
+    const imageIdScalingFactor = metaData.get('scalingModule', imageId);
+    const calibration = metaData.get(MetadataModules.CALIBRATION, imageId);
+    const voiLUTFunctionEnum = getValidVOILUTFunction(voiLUTFunction);
+    const imagePlaneModule = getImagePlaneModule(imageId);
+    return {
+        calibration,
+        scalingFactor: imageIdScalingFactor,
+        voiLUTFunction: voiLUTFunctionEnum,
+        modality,
+        imagePlaneModule,
+        imagePixelModule: {
+            bitsAllocated,
+            bitsStored,
+            samplesPerPixel,
+            highBit,
+            photometricInterpretation,
+            pixelRepresentation,
+            windowWidth: windowWidth,
+            windowCenter: windowCenter,
+            modality,
+            voiLUTFunction: voiLUTFunctionEnum,
+        },
+    };
+}

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

@@ -0,0 +1,20 @@
+import type { Point3, Mat3, ImagePlaneModule, ImagePixelModule, IImageCalibration } from '../types';
+import type IImage from '../types/IImage';
+import type { VOILUTFunctionType } from '../enums';
+type ReturnImageDataMetadata = {
+    imagePlaneModule: ImagePlaneModule;
+    imagePixelModule: ImagePixelModule;
+    bitsAllocated: number;
+    numVoxels: number;
+    numberOfComponents: number;
+    origin: Point3;
+    direction: Mat3;
+    dimensions: Point3;
+    spacing: Point3;
+    voiLUTFunction: VOILUTFunctionType;
+    modality: string;
+    scalingFactor: number;
+    calibration: IImageCalibration;
+};
+export declare function getImageDataMetadata(image: IImage): ReturnImageDataMetadata;
+export {};

package/dist/esm/utilities/getImageDataMetadata.js

@@ -0,0 +1,51 @@
+import { vec3 } from 'gl-matrix';
+import { EPSILON } from '../constants';
+import { buildMetadata } from './buildMetadata';
+export function getImageDataMetadata(image) {
+    const { imagePlaneModule, imagePixelModule, voiLUTFunction, modality, scalingFactor, calibration, } = buildMetadata(image);
+    let { rowCosines, columnCosines } = imagePlaneModule;
+    if (rowCosines == null || columnCosines == null) {
+        rowCosines = [1, 0, 0];
+        columnCosines = [0, 1, 0];
+    }
+    const rowCosineVec = vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+    const colCosineVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    let origin = imagePlaneModule.imagePositionPatient;
+    if (origin == null) {
+        origin = [0, 0, 0];
+    }
+    const xSpacing = imagePlaneModule.columnPixelSpacing || image.columnPixelSpacing;
+    const ySpacing = imagePlaneModule.rowPixelSpacing || image.rowPixelSpacing;
+    const xVoxels = image.columns;
+    const yVoxels = image.rows;
+    const zSpacing = EPSILON;
+    const zVoxels = 1;
+    const numberOfComponents = image.numberOfComponents ||
+        _getNumCompsFromPhotometricInterpretation(imagePixelModule.photometricInterpretation);
+    return {
+        numberOfComponents,
+        origin,
+        direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
+        dimensions: [xVoxels, yVoxels, zVoxels],
+        spacing: [xSpacing, ySpacing, zSpacing],
+        numVoxels: xVoxels * yVoxels * zVoxels,
+        imagePlaneModule,
+        imagePixelModule,
+        bitsAllocated: imagePixelModule.bitsAllocated,
+        voiLUTFunction,
+        modality,
+        scalingFactor,
+        calibration,
+    };
+}
+function _getNumCompsFromPhotometricInterpretation(photometricInterpretation) {
+    let numberOfComponents = 1;
+    if (photometricInterpretation === 'RGB' ||
+        photometricInterpretation.includes('YBR') ||
+        photometricInterpretation === 'PALETTE COLOR') {
+        numberOfComponents = 3;
+    }
+    return numberOfComponents;
+}

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

@@ -78,6 +78,8 @@ import { deepEqual } from './deepEqual';
 import type { IViewport } from '../types/IViewport';
 import FrameRange from './FrameRange';
 import fnv1aHash from './fnv1aHash';
+import { getImageDataMetadata } from './getImageDataMetadata';
+import { buildMetadata } from './buildMetadata';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
 import scaleArray from './scaleArray';
@@ -91,4 +93,4 @@ import getVolumeDirectionVectors from './getVolumeDirectionVectors';
 import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, 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, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, 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, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, };

package/dist/esm/utilities/index.js

@@ -77,6 +77,8 @@ import * as color from './color';
 import { deepEqual } from './deepEqual';
 import FrameRange from './FrameRange';
 import fnv1aHash from './fnv1aHash';
+import { getImageDataMetadata } from './getImageDataMetadata';
+import { buildMetadata } from './buildMetadata';
 import { _getViewportModality } from './getViewportModality';
 import cache from '../cache/cache';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
@@ -92,4 +94,4 @@ import getVolumeDirectionVectors from './getVolumeDirectionVectors';
 import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, 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, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, 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, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, };

package/dist/esm/utilities/isValidVolume.js

@@ -6,7 +6,10 @@ 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 { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, usingDefaultValues, } = metaData.get('imagePlaneModule', imageId0);
+    if (usingDefaultValues) {
+        return false;
+    }
     const baseMetadata = {
         modality,
         imageOrientationPatient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -82,5 +82,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "42ffdeabf1ed0bd2871db808bf198d5e3f4f4c94"
+  "gitHead": "480e48c2a25ce79a4a90be6fe180d1bcdd1b831e"
 }