@cornerstonejs/core 2.0.0-beta.19 → 2.0.0-beta.20

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

@@ -62,7 +62,7 @@ declare abstract class BaseVolumeViewport extends Viewport implements IVolumeVie
     getImageIds: (volumeId?: string) => Array<string>;
     abstract getCurrentImageId(): string;
     protected getVolumeId(specifier?: ViewReferenceSpecifier): string;
-    getReferenceId(specifier?: ViewReferenceSpecifier): string;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     abstract setBlendMode(blendMode: BlendModes, filterActorUIDs?: Array<string>, immediate?: boolean): void;
     abstract setSlabThickness(slabThickness: number, filterActorUIDs?: Array<string>): void;
     abstract resetSlabThickness(): void;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -713,7 +713,7 @@ class BaseVolumeViewport extends Viewport {
     initializeColorTransferFunction(volumeInputArray) {
         const selectedVolumeId = volumeInputArray[0].volumeId;
         const colorTransferFunction = this._getOrCreateColorTransferFunction(selectedVolumeId);
-        if (!this.initialTransferFunctionNodes) {
+        if (!this.initialTransferFunctionNodes && colorTransferFunction) {
             this.initialTransferFunctionNodes = getTransferFunctionNodes(colorTransferFunction);
         }
     }
@@ -788,6 +788,7 @@ class BaseVolumeViewport extends Viewport {
             imageData: actor.getMapper().getInputData(),
             metadata: {
                 Modality: volume?.metadata?.Modality,
+                FrameOfReferenceUID: volume?.metadata?.FrameOfReferenceUID,
             },
             scaling: volume?.scaling,
             hasPixelSpacing: true,
@@ -853,7 +854,7 @@ class BaseVolumeViewport extends Viewport {
         return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
             actorEntry.uid === specifier.volumeId)?.uid;
     }
-    getReferenceId(specifier = {}) {
+    getViewReferenceId(specifier = {}) {
         let { volumeId, sliceIndex: sliceIndex } = specifier;
         if (!volumeId) {
             const actorEntries = this.getActors();

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

@@ -178,10 +178,10 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     private _getValidVOILUTFunction;
     getCurrentImageIdIndex: () => number;
     getSliceIndex: () => number;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     setViewReference(viewRef: ViewReference): void;
-    getReferenceId(specifier?: ViewReferenceSpecifier): string;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     getTargetImageIdIndex: () => number;
     getImageIds: () => Array<string>;
     getCurrentImageId: () => string;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -440,7 +440,10 @@ class StackViewport extends Viewport {
             direction: vtkImageData.getDirection(),
             scalarData: vtkImageData.getPointData().getScalars().getData(),
             imageData: actor.getMapper().getInputData(),
-            metadata: { Modality: this.modality },
+            metadata: {
+                Modality: this.modality,
+                FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            },
             scaling: this.scaling,
             hasPixelSpacing: this.hasPixelSpacing,
             calibration: { ...this.csImage.calibration, ...this.calibration },
@@ -457,7 +460,10 @@ class StackViewport extends Viewport {
             spacing,
             origin: metadata.origin,
             direction: metadata.direction,
-            metadata: { Modality: this.modality },
+            metadata: {
+                Modality: this.modality,
+                FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            },
             scaling: this.scaling,
             imageData: {
                 getDirection: () => metadata.direction,
@@ -1352,7 +1358,8 @@ class StackViewport extends Viewport {
     addImages(stackInputs) {
         const actors = this.getActors();
         stackInputs.forEach((stackInput) => {
-            const image = cache.getImage(stackInput.imageId);
+            const { imageId } = stackInput;
+            const image = cache.getImage(imageId);
             const { origin, dimensions, direction, spacing, numComps } = this.getImageDataMetadata(image);
             const imagedata = this.createVTKImageData({
                 origin,
@@ -1364,7 +1371,11 @@ class StackViewport extends Viewport {
             });
             const imageActor = this.createActorMapper(imagedata);
             if (imageActor) {
-                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                actors.push({
+                    uid: stackInput.actorUID,
+                    actor: imageActor,
+                    referencedId: imageId,
+                });
                 if (stackInput.callback) {
                     stackInput.callback({ imageActor, imageId: stackInput.imageId });
                 }
@@ -1624,22 +1635,62 @@ class StackViewport extends Viewport {
         if (!super.isReferenceViewable(viewRef, options)) {
             return false;
         }
-        let { imageURI } = options;
         const { referencedImageId, sliceIndex } = viewRef;
         if (viewRef.volumeId && !referencedImageId) {
             return options.asVolume === true;
         }
         let testIndex = this.getCurrentImageIdIndex();
+        const currentImageId = this.imageIds[testIndex];
         if (options.withNavigation && typeof sliceIndex === 'number') {
             testIndex = sliceIndex;
         }
-        const imageId = this.imageIds[testIndex];
-        if (!imageId) {
+        if (!currentImageId) {
             return false;
         }
+        if (options.asOverlay && referencedImageId) {
+            const matchImagesForOverlay = (targetImageId) => {
+                const referenceImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
+                const currentImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetImageId);
+                const referenceOrientation = referenceImagePlaneModule.imageOrientationPatient;
+                const currentOrientation = currentImagePlaneModule.imageOrientationPatient;
+                if (referenceOrientation && currentOrientation) {
+                    const closeEnough = isEqual(referenceImagePlaneModule.imageOrientationPatient, currentImagePlaneModule.imageOrientationPatient);
+                    if (closeEnough) {
+                        const referencePosition = referenceImagePlaneModule.imagePositionPatient;
+                        const currentPosition = currentImagePlaneModule.imagePositionPatient;
+                        if (referencePosition && currentPosition) {
+                            const vector = vec3.create();
+                            vec3.subtract(vector, currentPosition, referencePosition);
+                            const viewPlaneNormal = vec3.create();
+                            vec3.cross(viewPlaneNormal, currentOrientation.slice(0, 3), currentOrientation.slice(3, 6));
+                            const dotProduct = vec3.dot(vector, viewPlaneNormal);
+                            const isOrthogonal = Math.abs(dotProduct) < EPSILON;
+                            if (isOrthogonal) {
+                                return targetImageId;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const referenceRows = referenceImagePlaneModule.rows;
+                    const referenceColumns = referenceImagePlaneModule.columns;
+                    const currentRows = currentImagePlaneModule.rows;
+                    const currentColumns = currentImagePlaneModule.columns;
+                    if (referenceRows === currentRows &&
+                        referenceColumns === currentColumns) {
+                        return targetImageId;
+                    }
+                }
+            };
+            const matchedImageId = matchImagesForOverlay(currentImageId);
+            if (matchedImageId) {
+                return matchedImageId;
+            }
+        }
+        let { imageURI } = options;
         if (!imageURI) {
-            const colonIndex = imageId.indexOf(':');
-            imageURI = imageId.substring(colonIndex + 1);
+            const colonIndex = currentImageId.indexOf(':');
+            imageURI = currentImageId.substring(colonIndex + 1);
         }
         return referencedImageId?.endsWith(imageURI);
     }
@@ -1680,7 +1731,7 @@ class StackViewport extends Viewport {
             }
         }
     }
-    getReferenceId(specifier = {}) {
+    getViewReferenceId(specifier = {}) {
         const { sliceIndex: sliceIndex = this.currentImageIdIndex } = specifier;
         if (Array.isArray(sliceIndex)) {
             throw new Error('Use of slice ranges for stacks not supported');

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

@@ -100,7 +100,7 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
     protected setColorTransform(): void;
     setCamera(camera: ICamera): void;
     getCurrentImageId(): string;
-    getReferenceId(specifier?: ViewReferenceSpecifier): string;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     getFrameNumber(): number;

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -537,7 +537,7 @@ class VideoViewport extends Viewport {
             : `/frames/${this.getFrameNumber()}`);
         return current;
     }
-    getReferenceId(specifier = {}) {
+    getViewReferenceId(specifier = {}) {
         const { sliceIndex: sliceIndex } = specifier;
         if (sliceIndex === undefined) {
             return `videoId:${this.getCurrentImageId()}`;
@@ -589,7 +589,7 @@ class VideoViewport extends Viewport {
         }
         return {
             ...super.getViewReference(viewRefSpecifier),
-            referencedImageId: this.getReferenceId(viewRefSpecifier),
+            referencedImageId: this.getViewReferenceId(viewRefSpecifier),
             sliceIndex: sliceIndex,
         };
     }

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

@@ -84,7 +84,7 @@ declare class Viewport implements IViewport {
     getPan(initialCamera?: ICamera): Point2;
     getCurrentImageIdIndex(): number;
     getSliceIndex(): number;
-    getReferenceId(_specifier?: ViewReferenceSpecifier): string;
+    getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
     setPan(pan: Point2, storeAsInitialCamera?: boolean): void;
     getZoom(compareCamera?: ICamera): number;
     setZoom(value: number, storeAsInitialCamera?: boolean): void;
@@ -101,7 +101,7 @@ declare class Viewport implements IViewport {
     getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[];
     private _getWorldDistanceViewUpAndViewRight;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
     setViewReference(viewRef: ViewReference): void;
     setViewPresentation(viewPres: ViewPresentation): void;

package/dist/esm/RenderingEngine/Viewport.js

@@ -505,7 +505,7 @@ class Viewport {
     getSliceIndex() {
         throw new Error('Not implemented');
     }
-    getReferenceId(_specifier) {
+    getViewReferenceId(_specifier) {
         return null;
     }
     setPan(pan, storeAsInitialCamera = false) {

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

@@ -19,7 +19,9 @@ declare class Cache implements ICache {
     purgeCache: () => void;
     purgeVolumeCache: () => void;
     decacheIfNecessaryUntilBytesAvailable(numBytes: number, volumeImageIds?: Array<string>): number | undefined;
+    private _putImageCommon;
     putImageLoadObject(imageId: string, imageLoadObject: IImageLoadObject): Promise<any>;
+    putImageSync(imageId: string, image: IImage): void;
     getImageLoadObject(imageId: string): IImageLoadObject;
     isLoaded(imageId: string): boolean;
     getVolumeContainingImageId(imageId: string): {

package/dist/esm/cache/cache.js

@@ -265,6 +265,31 @@ class Cache {
             }
         }
     }
+    _putImageCommon(imageId, image, cachedImage) {
+        if (!this._imageCache.get(imageId)) {
+            console.warn('The image was purged from the cache before it completed loading.');
+            return;
+        }
+        if (image.sizeInBytes === undefined || Number.isNaN(image.sizeInBytes)) {
+            throw new Error('_putImageCommon: image.sizeInBytes must not be undefined');
+        }
+        if (image.sizeInBytes.toFixed === undefined) {
+            throw new Error('_putImageCommon: image.sizeInBytes is not a number');
+        }
+        if (!this.isCacheable(image.sizeInBytes)) {
+            throw new Error(Events.CACHE_SIZE_EXCEEDED);
+        }
+        this.decacheIfNecessaryUntilBytesAvailable(image.sizeInBytes);
+        cachedImage.loaded = true;
+        cachedImage.image = image;
+        cachedImage.sizeInBytes = image.sizeInBytes;
+        this.incrementImageCacheSize(cachedImage.sizeInBytes);
+        const eventDetails = {
+            image: cachedImage,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
+        cachedImage.sharedCacheKey = image.sharedCacheKey;
+    }
     putImageLoadObject(imageId, imageLoadObject) {
         if (imageId === undefined) {
             throw new Error('putImageLoadObject: imageId must not be undefined');
@@ -290,36 +315,39 @@ class Cache {
         this._imageCache.set(imageId, cachedImage);
         return imageLoadObject.promise
             .then((image) => {
-            if (!this._imageCache.get(imageId)) {
-                console.warn('The image was purged from the cache before it completed loading.');
-                return;
-            }
-            if (image.sizeInBytes === undefined ||
-                Number.isNaN(image.sizeInBytes)) {
-                throw new Error('putImageLoadObject: image.sizeInBytes must not be undefined');
-            }
-            if (image.sizeInBytes.toFixed === undefined) {
-                throw new Error('putImageLoadObject: image.sizeInBytes is not a number');
-            }
-            if (!this.isCacheable(image.sizeInBytes)) {
-                throw new Error(Events.CACHE_SIZE_EXCEEDED);
-            }
-            this.decacheIfNecessaryUntilBytesAvailable(image.sizeInBytes);
-            cachedImage.loaded = true;
-            cachedImage.image = image;
-            cachedImage.sizeInBytes = image.sizeInBytes;
-            this.incrementImageCacheSize(cachedImage.sizeInBytes);
-            const eventDetails = {
-                image: cachedImage,
-            };
-            triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
-            cachedImage.sharedCacheKey = image.sharedCacheKey;
+            this._putImageCommon(imageId, image, cachedImage);
         })
             .catch((error) => {
             this._imageCache.delete(imageId);
             throw error;
         });
     }
+    putImageSync(imageId, image) {
+        if (imageId === undefined) {
+            throw new Error('putImageSync: imageId must not be undefined');
+        }
+        if (this._imageCache.has(imageId)) {
+            throw new Error('putImageSync: imageId already in cache');
+        }
+        const cachedImage = {
+            loaded: false,
+            imageId,
+            sharedCacheKey: undefined,
+            imageLoadObject: {
+                promise: Promise.resolve(image),
+            },
+            timeStamp: Date.now(),
+            sizeInBytes: 0,
+        };
+        this._imageCache.set(imageId, cachedImage);
+        try {
+            this._putImageCommon(imageId, image, cachedImage);
+        }
+        catch (error) {
+            this._imageCache.delete(imageId);
+            throw error;
+        }
+    }
     getImageLoadObject(imageId) {
         if (imageId === undefined) {
             throw new Error('getImageLoadObject: imageId must not be undefined');

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

@@ -54,7 +54,6 @@ export declare class ImageVolume implements IImageVolume {
     protected getScalarDataByImageIdIndex(imageIdIndex: number): PixelDataTypedArray;
     getCornerstoneImage(imageId: string, imageIdIndex: number): IImage;
     protected imageIdIndexToFrameIndex(imageIdIndex: number): number;
-    convertToCornerstoneImage(imageId: string, imageIdIndex: number): IImageLoadObject;
     getCornerstoneImageLoadObject(imageId: string, imageIdIndex: number): IImageLoadObject;
     getCornerstoneImages(): IImage[];
     convertToImageSlicesAndCache(): string[];

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

@@ -120,6 +120,15 @@ export class ImageVolume {
         }
         else {
             this.convertToImageSlicesAndCache();
+            const otherVolumes = cache.filterVolumesByReferenceId(this.volumeId);
+            if (otherVolumes.length) {
+                otherVolumes.forEach((volume) => {
+                    volume.referencedImageIds = this.imageIds;
+                });
+            }
+            if (completelyRemove) {
+                this.removeFromCache();
+            }
         }
     }
     removeFromCache() {
@@ -207,7 +216,24 @@ export class ImageVolume {
         const intercept = modalityLutModule.rescaleIntercept
             ? modalityLutModule.rescaleIntercept
             : 0;
-        return {
+        const imageOrientationPatient = [
+            this.direction[0],
+            this.direction[1],
+            this.direction[2],
+            this.direction[3],
+            this.direction[4],
+            this.direction[5],
+        ];
+        const precision = 6;
+        const imagePositionPatient = [
+            parseFloat((this.origin[0] +
+                imageIdIndex * this.direction[6] * this.spacing[0]).toFixed(precision)),
+            parseFloat((this.origin[1] +
+                imageIdIndex * this.direction[7] * this.spacing[1]).toFixed(precision)),
+            parseFloat((this.origin[2] +
+                imageIdIndex * this.direction[8] * this.spacing[2]).toFixed(precision)),
+        ];
+        const image = {
             imageId,
             intercept,
             windowCenter,
@@ -233,13 +259,43 @@ export class ImageVolume {
             invert,
             photometricInterpretation,
         };
+        const pixelData = image.getPixelData();
+        const bitsAllocated = pixelData.BYTES_PER_ELEMENT * 8;
+        const imagePixelModule = {
+            bitsAllocated,
+            photometricInterpretation: image.photometricInterpretation,
+            windowWidth: image.windowWidth,
+            windowCenter: image.windowCenter,
+            voiLUTFunction: image.voiLUTFunction,
+        };
+        const imagePlaneModule = {
+            rowCosines: [this.direction[0], this.direction[1], this.direction[2]],
+            columnCosines: [this.direction[3], this.direction[4], this.direction[5]],
+            pixelSpacing: [this.spacing[0], this.spacing[1]],
+            imageOrientationPatient: imageOrientationPatient,
+            imagePositionPatient: imagePositionPatient,
+            columnPixelSpacing: image.columnPixelSpacing,
+            rowPixelSpacing: image.rowPixelSpacing,
+            columns: image.columns,
+            rows: image.rows,
+        };
+        const generalSeriesModule = {};
+        const metadata = {
+            imagePixelModule,
+            imagePlaneModule,
+            generalSeriesModule,
+        };
+        ['imagePixelModule', 'imagePlaneModule', 'generalSeriesModule'].forEach((type) => {
+            genericMetadataProvider.add(imageId, {
+                type,
+                metadata: metadata[type],
+            });
+        });
+        return image;
     }
     imageIdIndexToFrameIndex(imageIdIndex) {
         return imageIdIndex % this.numFrames;
     }
-    convertToCornerstoneImage(imageId, imageIdIndex) {
-        return this.getCornerstoneImageLoadObject(imageId, imageIdIndex);
-    }
     getCornerstoneImageLoadObject(imageId, imageIdIndex) {
         const image = this.getCornerstoneImage(imageId, imageIdIndex);
         const imageLoadObject = {
@@ -276,78 +332,13 @@ export class ImageVolume {
             const imageId = this.imageIds[imageIdIndex];
             bytesRemaining = bytesRemaining - bytesPerImage;
             const image = this.getCornerstoneImage(imageId, imageIdIndex);
-            const imageLoadObject = {
-                promise: Promise.resolve(image),
-            };
             if (!cache.getImageLoadObject(imageId)) {
-                cache.putImageLoadObject(imageId, imageLoadObject).catch((err) => {
-                    console.error(err);
-                });
+                cache.putImageSync(imageId, image);
             }
             if (bytesRemaining <= bytesPerImage) {
                 break;
             }
-            const imageOrientationPatient = [
-                this.direction[0],
-                this.direction[1],
-                this.direction[2],
-                this.direction[3],
-                this.direction[4],
-                this.direction[5],
-            ];
-            const precision = 6;
-            const imagePositionPatient = [
-                parseFloat((this.origin[0] +
-                    imageIdIndex * this.direction[6] * this.spacing[0]).toFixed(precision)),
-                parseFloat((this.origin[1] +
-                    imageIdIndex * this.direction[7] * this.spacing[1]).toFixed(precision)),
-                parseFloat((this.origin[2] +
-                    imageIdIndex * this.direction[8] * this.spacing[2]).toFixed(precision)),
-            ];
-            const pixelData = image.getPixelData();
-            const bitsAllocated = pixelData.BYTES_PER_ELEMENT * 8;
-            const imagePixelModule = {
-                bitsAllocated,
-                photometricInterpretation: image.photometricInterpretation,
-                windowWidth: image.windowWidth,
-                windowCenter: image.windowCenter,
-                voiLUTFunction: image.voiLUTFunction,
-            };
-            const imagePlaneModule = {
-                rowCosines: [this.direction[0], this.direction[1], this.direction[2]],
-                columnCosines: [
-                    this.direction[3],
-                    this.direction[4],
-                    this.direction[5],
-                ],
-                pixelSpacing: [this.spacing[0], this.spacing[1]],
-                imageOrientationPatient: imageOrientationPatient,
-                imagePositionPatient: imagePositionPatient,
-                columnPixelSpacing: image.columnPixelSpacing,
-                rowPixelSpacing: image.rowPixelSpacing,
-                columns: image.columns,
-                rows: image.rows,
-            };
-            const generalSeriesModule = {};
-            const metadata = {
-                imagePixelModule,
-                imagePlaneModule,
-                generalSeriesModule,
-            };
-            ['imagePixelModule', 'imagePlaneModule', 'generalSeriesModule'].forEach((type) => {
-                genericMetadataProvider.add(imageId, {
-                    type,
-                    metadata: metadata[type],
-                });
-            });
-        }
-        const otherVolumes = cache.filterVolumesByReferenceId(this.volumeId);
-        if (otherVolumes.length) {
-            otherVolumes.forEach((volume) => {
-                volume.referencedImageIds = this.imageIds;
-            });
         }
-        this.removeFromCache();
         return this.imageIds;
     }
 }

package/dist/esm/loaders/imageLoader.js

@@ -41,7 +41,7 @@ function loadImageFromCacheOrVolume(imageId, options) {
     if (cachedVolumeInfo?.volume?.loadStatus?.loaded) {
         const { volume, imageIdIndex } = cachedVolumeInfo;
         if (volume instanceof ImageVolume) {
-            imageLoadObject = volume.convertToCornerstoneImage(imageId, imageIdIndex);
+            imageLoadObject = volume.getCornerstoneImageLoadObject(imageId, imageIdIndex);
         }
         return imageLoadObject;
     }
@@ -157,6 +157,7 @@ export function createAndCacheLocalImage(options, imageId, preventCache = false)
         rgba: undefined,
         columnPixelSpacing: imagePlaneModule.columnPixelSpacing,
         rowPixelSpacing: imagePlaneModule.rowPixelSpacing,
+        FrameOfReferenceUID: imagePlaneModule.FrameOfReferenceUID,
         invert: false,
     };
     if (options.scalarData) {

package/dist/esm/loaders/volumeLoader.js

@@ -133,6 +133,13 @@ export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
     derivedImageData.setDirection(direction);
     derivedImageData.setOrigin(origin);
     derivedImageData.getPointData().setScalars(scalarArray);
+    const referencedImageIds = referencedVolume.imageIds ?? [];
+    let derivedVolumeImageIds = [];
+    if (referencedImageIds.length) {
+        derivedVolumeImageIds = referencedImageIds.map((imageId) => {
+            return `derived:${imageId}`;
+        });
+    }
     const derivedVolume = new ImageVolume({
         volumeId,
         metadata: structuredClone(metadata),
@@ -143,13 +150,15 @@ export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
         imageData: derivedImageData,
         scalarData: volumeScalarData,
         sizeInBytes: numBytes,
-        imageIds: [],
         referencedVolumeId,
+        imageIds: derivedVolumeImageIds,
+        referencedImageIds: referencedVolume.imageIds ?? [],
     });
     const volumeLoadObject = {
         promise: Promise.resolve(derivedVolume),
     };
     await cache.putVolumeLoadObject(volumeId, volumeLoadObject);
+    performCacheOptimizationForVolume(derivedVolume);
     return derivedVolume;
 }
 export function createLocalVolume(options, volumeId, preventCache = false) {
@@ -212,6 +221,7 @@ export function createLocalVolume(options, volumeId, preventCache = false) {
         promise: Promise.resolve(derivedVolume),
     };
     cache.putVolumeLoadObject(volumeId, volumeLoadObject);
+    performCacheOptimizationForVolume(derivedVolume);
     return derivedVolume;
 }
 export async function createAndCacheVolumeFromImages(volumeId, imageIds, options = {}) {

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

@@ -18,6 +18,7 @@ type CPUIImageData = {
     imageData: CPUImageData;
     metadata: {
         Modality: string;
+        FrameOfReferenceUID: string;
     };
     scalarData: PixelDataTypedArray;
     scaling: Scaling;

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

@@ -76,6 +76,7 @@ interface IImage {
     imageQualityStatus?: ImageQualityStatus;
     calibration?: IImageCalibration;
     imageFrame?: any;
+    FrameOfReferenceUID?: string;
     voxelManager?: VoxelManager<number> | VoxelManager<RGB>;
     bufferView?: {
         buffer: ArrayBuffer;

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

@@ -10,6 +10,7 @@ interface IImageData {
     imageData: vtkImageData;
     metadata: {
         Modality: string;
+        FrameOfReferenceUID: string;
     };
     scaling?: Scaling;
     hasPixelSpacing?: boolean;

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

@@ -18,9 +18,10 @@ export type ReferenceCompatibleOptions = {
     asVolume?: boolean;
     withOrientation?: boolean;
     imageURI?: string;
+    asOverlay?: boolean;
 };
 export type ViewReference = {
-    FrameOfReferenceUID: string;
+    FrameOfReferenceUID?: string;
     referencedImageId?: string;
     cameraFocalPoint?: Point3;
     viewPlaneNormal?: Point3;
@@ -104,9 +105,9 @@ interface IViewport {
     getNumberOfSlices(): number;
     getCurrentImageIdIndex(): number;
     getSliceIndex(): number;
-    getReferenceId(viewRefSpecifier?: ViewReferenceSpecifier): string;
+    getViewReferenceId(viewRefSpecifier?: ViewReferenceSpecifier): string;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
     setViewReference(viewRef: ViewReference): any;
     setViewPresentation(viewPres: ViewPresentation): any;