@cornerstonejs/core 2.0.0-beta.1 → 2.0.0-beta.10

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,7 +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] : null
+      (base instanceof Settings && DICTIONARY in base
+        ? base[DICTIONARY]
+        : null) as object
     );
     Object.seal(
       Object.defineProperty(this, DICTIONARY, {
@@ -250,10 +252,14 @@ function get(dictionary: Record<string, unknown>, key: string): unknown {
  */
 function isValidKey(key: string): boolean {
   let last: number, current: number, previous: number;
-  if (typeof key !== 'string' || (last = key.length - 1) < 0) return false;
+  if (typeof key !== 'string' || (last = key.length - 1) < 0) {
+    return false;
+  }
   previous = -1;
   while ((current = key.indexOf('.', previous + 1)) >= 0) {
-    if (current - previous < 2 || current === last) return false;
+    if (current - previous < 2 || current === last) {
+      return false;
+    }
     previous = current;
   }
   return true;

package/src/cache/cache.ts

@@ -1,7 +1,6 @@
 import {
   ICache,
   IImage,
-  IImageVolume,
   IGeometry,
   IImageLoadObject,
   IVolumeLoadObject,
@@ -10,39 +9,47 @@ 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 MAX_CACHE_SIZE_1GB = 1073741824;
+const ONE_GB = 1073741824;
 
+/**
+ * Stores images, volumes and geometry.
+ * There are two sizes - the max cache size, that controls the overal maximum
+ * size, and the instance size, which controls how big any single object can
+ * be.  Defaults are 3 GB and 2 GB - 8 bytes (just enough to allow allocating it
+ * without crashing).
+ * The 3 gb is tuned to the chromium garbage collection cycle to allow image volumes
+ * to be used/discarded.
+ */
 class Cache implements ICache {
-  private readonly _imageCache: Map<string, ICachedImage>; // volatile space
-  private readonly _volumeCache: Map<string, ICachedVolume>; // non-volatile space
+  // used to store image data (2d)
+  private readonly _imageCache = new Map<string, ICachedImage>(); // volatile space
+  // used to store volume data (3d)
+  private readonly _volumeCache = new Map<string, ICachedVolume>(); // non-volatile space
   // Todo: contour for now, but will be used for surface, etc.
   private readonly _geometryCache: Map<string, ICachedGeometry>;
-  private _imageCacheSize: number;
-  private _volumeCacheSize: number;
-  private _maxCacheSize: number;
+
+  private _imageCacheSize = 0;
+  private _volumeCacheSize = 0;
+  private _maxCacheSize = 3 * ONE_GB;
+  private _maxInstanceSize = 4 * ONE_GB - 8;
 
   constructor() {
-    // used to store image data (2d)
-    this._imageCache = new Map();
-    // used to store volume data (3d)
-    this._volumeCache = new Map();
     // used to store object data (contour, surface, etc.)
     this._geometryCache = new Map();
-    this._imageCacheSize = 0;
-    this._volumeCacheSize = 0;
-    this._maxCacheSize = MAX_CACHE_SIZE_1GB; // Default 1GB
   }
 
   /**
    * Set the maximum cache Size
    *
-   * Maximum cache size should be set before adding the data; otherwise, it
-   * will throw an error.
+   * Maximum cache size should be set before adding the data.  If set after,
+   * and it is smaller than the current size, will cause issues.
    *
    * @param newMaxCacheSize -  new maximum cache size
    *
@@ -59,7 +66,7 @@ class Cache implements ICache {
   /**
    * Checks if there is enough space in the cache for requested byte size
    *
-   * It throws error, if the sum of volatile (image) cache and unallocated cache
+   * It returns false, if the sum of volatile (image) cache and unallocated cache
    * is less than the requested byteLength
    *
    * @param byteLength - byte length of requested byte size
@@ -67,6 +74,9 @@ class Cache implements ICache {
    * @returns - boolean indicating if there is enough space in the cache
    */
   public isCacheable = (byteLength: number): boolean => {
+    if (byteLength > this._maxInstanceSize) {
+      return false;
+    }
     const unallocatedSpace = this.getBytesAvailable();
     const imageCacheSize = this._imageCacheSize;
     const availableSpace = unallocatedSpace + imageCacheSize;
@@ -81,6 +91,13 @@ class Cache implements ICache {
    */
   public getMaxCacheSize = (): number => this._maxCacheSize;
 
+  /**
+   * Returns maximum size of a single instance (volume or single image)
+   *
+   * @returns maximum instance size
+   */
+  public getMaxInstanceSize = (): number => this._maxInstanceSize;
+
   /**
    * Returns current size of the cache
    *
@@ -136,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();
@@ -361,7 +382,10 @@ class Cache implements ICache {
           return;
         }
 
-        if (Number.isNaN(image.sizeInBytes)) {
+        if (
+          image.sizeInBytes === undefined ||
+          Number.isNaN(image.sizeInBytes)
+        ) {
           throw new Error(
             'putImageLoadObject: image.sizeInBytes must not be undefined'
           );
@@ -383,8 +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,
         };
@@ -429,7 +452,7 @@ class Cache implements ICache {
    * @param imageId - image Id to check
    * @returns boolean
    */
-  public isImageIdCached(imageId: string): boolean {
+  public isLoaded(imageId: string): boolean {
     const cachedImage = this._imageCache.get(imageId);
 
     if (!cachedImage) {
@@ -580,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,
@@ -637,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
    *
@@ -659,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
    *
@@ -680,9 +750,10 @@ class Cache implements ICache {
       );
     }
 
-    this._incrementImageCacheSize(-cachedImage.sizeInBytes);
+    this.incrementImageCacheSize(-cachedImage.sizeInBytes);
 
     const eventDetails = {
+      image: cachedImage,
       imageId,
     };
 
@@ -711,7 +782,7 @@ class Cache implements ICache {
       );
     }
 
-    this._incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
+    this.incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
 
     const eventDetails = {
       volume: cachedVolume,
@@ -795,7 +866,7 @@ class Cache implements ICache {
    *
    * @param increment - bytes length
    */
-  private _incrementImageCacheSize = (increment: number) => {
+  public incrementImageCacheSize = (increment: number) => {
     this._imageCacheSize += increment;
   };
 
@@ -804,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}.`);
+  }
 }
 
 /**