@cornerstonejs/core 2.0.0-beta.6 → 2.0.0-beta.7

package/src/RenderingEngine/helpers/setDefaultVolumeVOI.ts

@@ -8,6 +8,7 @@ import { loadAndCacheImage } from '../../loaders/imageLoader';
 import * as metaData from '../../metaData';
 import { getMinMax, windowLevel } from '../../utilities';
 import { RequestType } from '../../enums';
+import cache from '../../cache';
 
 const PRIORITY = 0;
 const REQUEST_TYPE = RequestType.Prefetch;
@@ -20,31 +21,36 @@ const REQUEST_TYPE = RequestType.Prefetch;
  * Finally it sets the VOI on the volumeActor transferFunction
  * @param volumeActor - The volume actor
  * @param imageVolume - The image volume that we want to set the VOI for.
+ * @param useNativeDataType -  The image data type is native or Float32Array
  */
 async function setDefaultVolumeVOI(
   volumeActor: VolumeActor,
   imageVolume: IImageVolume,
-  use16BitTexture: boolean
+  useNativeDataType: boolean
 ): Promise<void> {
   let voi = getVOIFromMetadata(imageVolume);
 
-  if (!voi) {
-    voi = await getVOIFromMinMax(imageVolume, use16BitTexture);
+  if (!voi && imageVolume?.imageIds?.length) {
+    voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
+    voi = handlePreScaledVolume(imageVolume, voi);
   }
-
-  if (!voi || voi.lower === undefined || voi.upper === undefined) {
-    throw new Error(
-      'Could not get VOI from metadata, nor from the min max of the image middle slice'
-    );
+  // if (!voi || voi.lower === undefined || voi.upper === undefined) {
+  //   throw new Error(
+  //     'Could not get VOI from metadata, nor from the min max of the image middle slice'
+  //   );
+  // }
+  if (
+    (voi?.lower === 0 && voi?.upper === 0) ||
+    voi?.lower === undefined ||
+    voi?.upper === undefined
+  ) {
+    return;
   }
 
-  voi = handlePreScaledVolume(imageVolume, voi);
-  const { lower, upper } = voi;
-
   volumeActor
     .getProperty()
     .getRGBTransferFunction(0)
-    .setMappingRange(lower, upper);
+    .setMappingRange(voi.lower, voi.upper);
 }
 
 function handlePreScaledVolume(imageVolume: IImageVolume, voi: VOIRange) {
@@ -72,35 +78,36 @@ function handlePreScaledVolume(imageVolume: IImageVolume, voi: VOIRange) {
 }
 
 /**
- * Get the VOI from the metadata of the middle slice of the image volume. It checks
- * the metadata for the VOI and if it is not found, it returns null
+ * Get the VOI from the metadata of the middle slice of the image volume or the metadata of the image volume
+ * It checks the metadata for the VOI and if it is not found, it returns null
  *
  * @param imageVolume - The image volume that we want to get the VOI from.
  * @returns VOIRange with lower and upper values
  */
 function getVOIFromMetadata(imageVolume: IImageVolume): VOIRange {
-  const { imageIds } = imageVolume;
-
-  const imageIdIndex = Math.floor(imageIds.length / 2);
-  const imageId = imageIds[imageIdIndex];
-
-  const voiLutModule = metaData.get('voiLutModule', imageId);
-
-  if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
-    const { windowWidth, windowCenter } = voiLutModule;
-
-    const voi = {
-      windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
-      windowCenter: Array.isArray(windowCenter)
-        ? windowCenter[0]
-        : windowCenter,
-    };
-
+  const { imageIds, metadata } = imageVolume;
+  let voi;
+  if (imageIds.length) {
+    const imageIdIndex = Math.floor(imageIds.length / 2);
+    const imageId = imageIds[imageIdIndex];
+    const voiLutModule = metaData.get('voiLutModule', imageId);
+    if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
+      const { windowWidth, windowCenter } = voiLutModule;
+      voi = {
+        windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
+        windowCenter: Array.isArray(windowCenter)
+          ? windowCenter[0]
+          : windowCenter,
+      };
+    }
+  } else {
+    voi = metadata?.voiLut?.[0];
+  }
+  if (voi) {
     const { lower, upper } = windowLevel.toLowHighRange(
       Number(voi.windowWidth),
       Number(voi.windowCenter)
     );
-
     return {
       lower,
       upper,
@@ -113,11 +120,12 @@ function getVOIFromMetadata(imageVolume: IImageVolume): VOIRange {
  * and max pixel values, it calculates the VOI.
  *
  * @param imageVolume - The image volume that we want to get the VOI from.
+ * @param useNativeDataType -  The image data type is native or Float32Array
  * @returns The VOIRange with lower and upper values
  */
 async function getVOIFromMinMax(
   imageVolume: IImageVolume,
-  use16BitTexture: boolean
+  useNativeDataType: boolean
 ): Promise<VOIRange> {
   const { imageIds } = imageVolume;
   const scalarData = imageVolume.getScalarData();
@@ -157,10 +165,11 @@ async function getVOIFromMinMax(
 
   const options = {
     targetBuffer: {
-      type: use16BitTexture ? undefined : 'Float32Array',
+      type: useNativeDataType ? undefined : 'Float32Array',
     },
     priority: PRIORITY,
     requestType: REQUEST_TYPE,
+    useNativeDataType,
     preScale: {
       enabled: true,
       scalingParameters: scalingParametersToUse,
@@ -175,20 +184,27 @@ async function getVOIFromMinMax(
   // instead. For the first scenario, we use the arrayBuffer of the volume to get the correct
   // slice for the imageScalarData, and for the second scenario we use the getPixelData
   // on the Cornerstone IImage object to get the pixel data.
-  const image = await loadAndCacheImage(imageId, options);
-
-  let imageScalarData;
-  if (!image) {
-    imageScalarData = _getImageScalarDataFromImageVolume(
-      imageVolume,
-      byteOffset,
-      bytePerPixel,
-      voxelsPerImage
-    );
-  } else {
-    imageScalarData = image.getPixelData();
+  // Note: we don't want to use the derived or generated images for setting the
+  // default VOI, because they are not the original. This is ugly but don't
+  // know how to do it better.
+  let image = cache.getImage(imageId);
+
+  if (!imageVolume.referencedImageIds?.length) {
+    // we should ignore the cache here,
+    // since we want to load the image from with the most
+    // recent prescale settings
+    image = await loadAndCacheImage(imageId, { ...options, ignoreCache: true });
   }
 
+  const imageScalarData = image
+    ? image.getPixelData()
+    : _getImageScalarDataFromImageVolume(
+        imageVolume,
+        byteOffset,
+        bytePerPixel,
+        voxelsPerImage
+      );
+
   // Get the min and max pixel values of the middle slice
   const { min, max } = getMinMax(imageScalarData);
 
@@ -205,7 +221,7 @@ function _getImageScalarDataFromImageVolume(
   voxelsPerImage
 ) {
   const { scalarData } = imageVolume;
-  const { volumeBuffer } = scalarData;
+  const { buffer } = scalarData;
   if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
     byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
   }
@@ -213,11 +229,7 @@ function _getImageScalarDataFromImageVolume(
   const TypedArray = scalarData.constructor;
   const imageScalarData = new TypedArray(voxelsPerImage);
 
-  const volumeBufferView = new TypedArray(
-    volumeBuffer,
-    byteOffset,
-    voxelsPerImage
-  );
+  const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
 
   imageScalarData.set(volumeBufferView);
 

package/src/RenderingEngine/helpers/viewportTypeToViewportClass.ts

@@ -3,12 +3,14 @@ import StackViewport from '../StackViewport';
 import VolumeViewport from '../VolumeViewport';
 import ViewportType from '../../enums/ViewportType';
 import VolumeViewport3D from '../VolumeViewport3D';
+import VideoViewport from '../VideoViewport';
 
 const viewportTypeToViewportClass = {
   [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
   [ViewportType.PERSPECTIVE]: VolumeViewport,
   [ViewportType.STACK]: StackViewport,
   [ViewportType.VOLUME_3D]: VolumeViewport3D,
+  [ViewportType.VIDEO]: VideoViewport,
 };
 
 export default viewportTypeToViewportClass;

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow.js

@@ -1,9 +1,11 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
-import vtkStreamingOpenGLViewNodeFactory from './vtkStreamingOpenGLViewNodeFactory';
+import vtkStreamingOpenGLViewNodeFactory, {
+  registerOverride,
+} from './vtkStreamingOpenGLViewNodeFactory';
 
 /**
- * vtkStreamingOpenGLRenderWindow - A dervied class of the core vtkOpenGLRenderWindow class.
+ * vtkStreamingOpenGLRenderWindow - A derived class of the core vtkOpenGLRenderWindow class.
  * The main purpose for this class extension is to add in our own node factory, so we can use
  * our extended "streaming" classes for progressive texture loading.
  *
@@ -27,9 +29,8 @@ export function extend(publicAPI, model, initialValues = {}) {
   vtkOpenGLRenderWindow.extend(publicAPI, model, initialValues);
 
   model.myFactory = vtkStreamingOpenGLViewNodeFactory.newInstance();
-  /* eslint-disable no-use-before-define */
-  model.myFactory.registerOverride('vtkRenderWindow', newInstance);
-  /* eslint-enable no-use-before-define */
+
+  registerOverride('vtkRenderWindow', newInstance);
 
   // Object methods
   vtkStreamingOpenGLRenderWindow(publicAPI, model);

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -4,7 +4,7 @@ import HalfFloat from '@kitware/vtk.js/Common/Core/HalfFloat';
 import { getConfiguration } from '../../init';
 
 /**
- * vtkStreamingOpenGLTexture - A dervied class of the core vtkOpenGLTexture.
+ * vtkStreamingOpenGLTexture - A derived class of the core vtkOpenGLTexture.
  * This class has methods to update the texture memory on the GPU slice by slice
  * in an efficient yet GPU-architecture friendly manner.
  *

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLViewNodeFactory.js

@@ -18,6 +18,12 @@ import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper
 import vtkViewNodeFactory from '@kitware/vtk.js/Rendering/SceneGraph/ViewNodeFactory';
 import vtkStreamingOpenGLVolumeMapper from './vtkStreamingOpenGLVolumeMapper';
 
+const CLASS_MAPPING = Object.create(null);
+
+export function registerOverride(className, fn) {
+  CLASS_MAPPING[className] = fn;
+}
+
 /**
  * vtkStreamingOpenGLViewNodeFactory - A fork of the vtkOpenGLViewNodeFactory,
  * so that we can inject our custom derived "Streaming" classes.
@@ -63,6 +69,8 @@ function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
     return vn;
   };
 
+  model.overrides = CLASS_MAPPING;
+
   /**
    * getModelInitialValues - This function allows us to pass textures down from our
    * vtkSharedVolumeMapper to new instances of vtkStreamingOpenGLVolumeMapper.
@@ -104,44 +112,29 @@ export function extend(publicAPI, model, initialValues = {}) {
   vtkStreamingOpenGLViewNodeFactory(publicAPI, model);
 
   // Initialization
-  publicAPI.registerOverride('vtkActor', vtkOpenGLActor.newInstance);
-  publicAPI.registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
-  publicAPI.registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
-  publicAPI.registerOverride(
-    'vtkGlyph3DMapper',
-    vtkOpenGLGlyph3DMapper.newInstance
-  );
-  publicAPI.registerOverride(
-    'vtkImageMapper',
-    vtkOpenGLImageMapper.newInstance
-  );
-  publicAPI.registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
-  publicAPI.registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
-  publicAPI.registerOverride(
+  registerOverride('vtkActor', vtkOpenGLActor.newInstance);
+  registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
+  registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
+  registerOverride('vtkGlyph3DMapper', vtkOpenGLGlyph3DMapper.newInstance);
+  registerOverride('vtkImageMapper', vtkOpenGLImageMapper.newInstance);
+  registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
+  registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
+  registerOverride(
     'vtkPixelSpaceCallbackMapper',
     vtkOpenGLPixelSpaceCallbackMapper.newInstance
   );
-  publicAPI.registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
-  publicAPI.registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
-  publicAPI.registerOverride(
-    'vtkSphereMapper',
-    vtkOpenGLSphereMapper.newInstance
-  );
-  publicAPI.registerOverride(
-    'vtkStickMapper',
-    vtkOpenGLStickMapper.newInstance
-  );
-  publicAPI.registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
-  publicAPI.registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
-  publicAPI.registerOverride(
-    'vtkVolumeMapper',
-    vtkOpenGLVolumeMapper.newInstance
-  );
-  publicAPI.registerOverride(
+  registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
+  registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
+  registerOverride('vtkSphereMapper', vtkOpenGLSphereMapper.newInstance);
+  registerOverride('vtkStickMapper', vtkOpenGLStickMapper.newInstance);
+  registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
+  registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
+  registerOverride('vtkVolumeMapper', vtkOpenGLVolumeMapper.newInstance);
+  registerOverride(
     'vtkSharedVolumeMapper',
     vtkStreamingOpenGLVolumeMapper.newInstance
   );
-  // publicAPI.registerOverride(
+  // registerOverride(
   //   'vtkWidgetRepresentation',
   //   vtkGenericWidgetRepresentation.newInstance
   // )

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -1,4 +1,3 @@
-import { mat3, mat4, vec3 } from 'gl-matrix';
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
 import { Filter } from '@kitware/vtk.js/Rendering/OpenGL/Texture/Constants';
@@ -6,9 +5,8 @@ import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
 
-const { vtkWarningMacro } = macro;
 /**
- * vtkStreamingOpenGLVolumeMapper - A dervied class of the core vtkOpenGLVolumeMapper class.
+ * vtkStreamingOpenGLVolumeMapper - A derived class of the core vtkOpenGLVolumeMapper class.
  * This class  replaces the buildBufferObjects function so that we progressively upload our textures
  * into GPU memory using the new methods on vtkStreamingOpenGLTexture.
  *
@@ -155,6 +153,8 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
       model.colorTextureString = toString;
     }
 
+    publicAPI.updateLabelOutlineThicknessTexture(actor);
+
     // rebuild the scalarTexture if the data has changed
     toString = `${image.getMTime()}`;
 
@@ -246,29 +246,6 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.VBOBuildTime.modified();
   };
 
-  // publicAPI.getRenderTargetSize = () => {
-  //   // https://github.com/Kitware/vtk-js/blob/master/Sources/Rendering/OpenGL/VolumeMapper/index.js#L952
-  //   if (model.lastXYF > 1.43) {
-  //     const sz = model.framebuffer.getSize()
-  //     return [model.fvp[0] * sz[0], model.fvp[1] * sz[1]]
-  //   }
-
-  //   // This seems wrong, it assumes the renderWindow only has one renderer
-  //   // but I don't know if this stuff is correct...
-
-  //   const { usize, vsize } = model.openGLRenderer.getTiledSizeAndOrigin()
-
-  //   return [usize, vsize]
-  // }
-
-  // publicAPI.getRenderTargetSize = () => {
-  //   if (model._useSmallViewport) {
-  //     return [model._smallViewportWidth, model._smallViewportHeight]
-  //   }
-
-  //   return model._openGLRenderWindow.getFramebufferSize()
-  // }
-
   publicAPI.getRenderTargetSize = () => {
     if (model._useSmallViewport) {
       return [model._smallViewportWidth, model._smallViewportHeight];

package/src/Settings.ts

@@ -13,9 +13,9 @@ const DICTIONARY = Symbol('Dictionary');
 export default class Settings {
   constructor(base?: Settings) {
     const dictionary = Object.create(
-      base instanceof Settings && DICTIONARY in base
-        ? (base[DICTIONARY] as object)
-        : null
+      (base instanceof Settings && DICTIONARY in base
+        ? base[DICTIONARY]
+        : null) as object
     );
     Object.seal(
       Object.defineProperty(this, DICTIONARY, {

package/src/cache/cache.ts

@@ -1,7 +1,6 @@
 import {
   ICache,
   IImage,
-  IImageVolume,
   IGeometry,
   IImageLoadObject,
   IVolumeLoadObject,
@@ -10,10 +9,12 @@ import {
   ICachedVolume,
   ICachedGeometry,
   EventTypes,
+  IImageVolume,
 } from '../types';
 import { triggerEvent, imageIdToURI } from '../utilities';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
+import { ImageVolume } from './classes/ImageVolume';
 
 const ONE_GB = 1073741824;
 
@@ -37,7 +38,7 @@ class Cache implements ICache {
   private _imageCacheSize = 0;
   private _volumeCacheSize = 0;
   private _maxCacheSize = 3 * ONE_GB;
-  private _maxInstanceSize = 2 * ONE_GB - 8;
+  private _maxInstanceSize = 4 * ONE_GB - 8;
 
   constructor() {
     // used to store object data (contour, surface, etc.)
@@ -152,6 +153,10 @@ class Cache implements ICache {
       volume.imageData.delete();
     }
 
+    // if we had views for the images of the volume, we need to restore them
+    // to avoid memory leaks
+    this._restoreImagesFromBuffer(volume);
+
     if (volumeLoadObject.cancelFn) {
       // Cancel any in-progress loading
       volumeLoadObject.cancelFn();
@@ -402,7 +407,7 @@ class Cache implements ICache {
         cachedImage.loaded = true;
         cachedImage.image = image;
         cachedImage.sizeInBytes = image.sizeInBytes;
-        this._incrementImageCacheSize(cachedImage.sizeInBytes);
+        this.incrementImageCacheSize(cachedImage.sizeInBytes);
         const eventDetails: EventTypes.ImageCacheImageAddedEventDetail = {
           image: cachedImage,
         };
@@ -598,7 +603,7 @@ class Cache implements ICache {
         // cachedVolume.loaded = true
         cachedVolume.volume = volume;
         cachedVolume.sizeInBytes = volume.sizeInBytes;
-        this._incrementVolumeCacheSize(cachedVolume.sizeInBytes);
+        this.incrementVolumeCacheSize(cachedVolume.sizeInBytes);
 
         const eventDetails: EventTypes.VolumeCacheVolumeAddedEventDetail = {
           volume: cachedVolume,
@@ -655,6 +660,28 @@ class Cache implements ICache {
     return cachedGeometry.geometry;
   };
 
+  /**
+   * Returns the image associated with the imageId
+   *
+   * @param imageId - image ID
+   * @returns Image
+   */
+  public getImage = (imageId: string): IImage => {
+    if (imageId === undefined) {
+      throw new Error('getImage: imageId must not be undefined');
+    }
+    const cachedImage = this._imageCache.get(imageId);
+
+    if (cachedImage === undefined) {
+      return;
+    }
+
+    // Bump time stamp for cached volume (not used for anything for now)
+    cachedImage.timeStamp = Date.now();
+
+    return cachedImage.image;
+  };
+
   /**
    * Returns the volume associated with the volumeId
    *
@@ -677,6 +704,31 @@ class Cache implements ICache {
     return cachedVolume.volume;
   };
 
+  /**
+   * Retrieves an array of image volumes from the cache.
+   * @returns An array of image volumes.
+   */
+  public getVolumes = (): Array<IImageVolume> => {
+    const cachedVolumes = Array.from(this._volumeCache.values());
+
+    return cachedVolumes.map((cachedVolume) => cachedVolume.volume);
+  };
+
+  /**
+   * Filters the cached volumes by the specified reference volume ID.
+   * @param volumeId - The ID of the reference volume.
+   * @returns An array of image volumes that have the specified reference volume ID.
+   */
+  public filterVolumesByReferenceId = (
+    volumeId: string
+  ): Array<IImageVolume> => {
+    const cachedVolumes = this.getVolumes();
+
+    return cachedVolumes.filter((volume) => {
+      return volume.referencedVolumeId === volumeId;
+    });
+  };
+
   /**
    * Removes the image loader associated with a given Id from the cache
    *
@@ -698,9 +750,10 @@ class Cache implements ICache {
       );
     }
 
-    this._incrementImageCacheSize(-cachedImage.sizeInBytes);
+    this.incrementImageCacheSize(-cachedImage.sizeInBytes);
 
     const eventDetails = {
+      image: cachedImage,
       imageId,
     };
 
@@ -729,7 +782,7 @@ class Cache implements ICache {
       );
     }
 
-    this._incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
+    this.incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
 
     const eventDetails = {
       volume: cachedVolume,
@@ -813,7 +866,7 @@ class Cache implements ICache {
    *
    * @param increment - bytes length
    */
-  private _incrementImageCacheSize = (increment: number) => {
+  public incrementImageCacheSize = (increment: number) => {
     this._imageCacheSize += increment;
   };
 
@@ -822,9 +875,89 @@ class Cache implements ICache {
    *
    * @param increment - bytes length
    */
-  private _incrementVolumeCacheSize = (increment: number) => {
+  public incrementVolumeCacheSize = (increment: number) => {
     this._volumeCacheSize += increment;
   };
+
+  /**
+   * Decreases the image cache size with the provided decrement
+   *
+   * @param decrement - bytes length
+   */
+  public decrementImageCacheSize = (decrement: number) => {
+    this._imageCacheSize -= decrement;
+  };
+
+  /**
+   * Decreases the cache size with the provided decrement
+   *
+   * @param decrement - bytes length
+   */
+  public decrementVolumeCacheSize = (decrement: number) => {
+    this._volumeCacheSize -= decrement;
+  };
+
+  /**
+   * This function will restore the images' pixel data from the shared array buffer
+   * back to the individual images when the volume is purged from cache. It ensures
+   * that each image retrieves its correct portion of data from the buffer based on
+   * the previously stored offset and length information.
+   *
+   * @param volumeId - The volumeId whose images need to be restored.
+   */
+  private _restoreImagesFromBuffer(volume: IImageVolume) {
+    if (!(volume instanceof ImageVolume)) {
+      console.warn(
+        'Volume is not an ImageVolume. Cannot restore images from buffer.'
+      );
+      return;
+    }
+
+    // Retrieve the scalar data and the offset map from the volume
+    const scalarData = volume.getScalarData();
+    const imageCacheOffsetMap = volume.imageCacheOffsetMap;
+
+    if (imageCacheOffsetMap.size === 0) {
+      // This happens during testing and isn't an issue
+      // console.warn('No cached images to restore for this volume.');
+      return;
+    }
+
+    // Iterate over each image and restore its pixel data from the shared buffer
+    for (const [imageId, { offset }] of imageCacheOffsetMap) {
+      const image = this.getImage(imageId);
+
+      if (!image) {
+        console.warn(`Image with id ${imageId} not found in cache.`);
+        continue;
+      }
+
+      const viewPixelData = image.getPixelData();
+      const length = viewPixelData.length;
+
+      // Create a new view of the buffer for this specific image
+      // @ts-ignore
+      const pixelData = new viewPixelData.constructor(
+        scalarData.buffer,
+        offset,
+        length
+      );
+
+      // Restore the original getPixelData function and pixelData
+      image.getPixelData = () => pixelData;
+
+      if (image.imageFrame) {
+        image.imageFrame.pixelData = pixelData;
+      }
+
+      delete image.bufferView;
+
+      // Optionally, increment the image cache size again if needed
+      this.incrementImageCacheSize(image.sizeInBytes);
+    }
+
+    console.log(`Images restored from buffer for volume ${volume.volumeId}.`);
+  }
 }
 
 /**