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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.3",
   "description": "",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -46,5 +46,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "c154f7531c166db29a54fe41c76a22ecc7ac47c8"
+  "gitHead": "d78cf780d4383a61ea0a9762bafa4104666757a4"
 }

package/src/RenderingEngine/StackViewport.ts

@@ -1017,7 +1017,7 @@ class StackViewport extends Viewport implements IStackViewport {
       ? vec3.negate(vec3.create(), this.initialViewUp)
       : this.initialViewUp;
 
-    this.setCamera({
+    this.setCameraNoEvent({
       viewUp: initialViewUp as Point3,
     });
 
@@ -2239,7 +2239,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
     const targetImageId = imageIds[newTargetImageIdIndex];
 
-    const imageAlreadyLoaded = cache.isImageIdCached(targetImageId);
+    const imageAlreadyLoaded = cache.isLoaded(targetImageId);
 
     // If image is already cached we want to scroll right away; however, if it is
     // not cached, we can debounce the scroll event to avoid firing multiple scroll

package/src/RenderingEngine/Viewport.ts

@@ -126,7 +126,7 @@ class Viewport implements IViewport {
 
   /**
    * Indicate that the image has been rendered.
-   * This will set hte viewportStatus to RENDERED if there is image data
+   * This will set the viewportStatus to RENDERED if there is image data
    * available to actually be rendered - otherwise, the rendering simply showed
    * the background image.
    */

package/src/RenderingEngine/VolumeViewport.ts

@@ -1,9 +1,11 @@
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+
 import { vec3 } from 'gl-matrix';
 
 import cache from '../cache';
 import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
-import { BlendModes, OrientationAxis } from '../enums';
+import { BlendModes, OrientationAxis, Events } from '../enums';
 import type {
   ActorEntry,
   IImageVolume,
@@ -12,10 +14,9 @@ import type {
   Point3,
 } from '../types';
 import type { ViewportInput } from '../types/IViewport';
-import { actorIsA, getClosestImageId } from '../utilities';
+import { actorIsA, getClosestImageId, triggerEvent } from '../utilities';
 import BaseVolumeViewport from './BaseVolumeViewport';
 import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
-import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
 
 /**
  * An object representing a VolumeViewport. VolumeViewports are used to render
@@ -383,6 +384,22 @@ class VolumeViewport extends BaseVolumeViewport {
       );
     }
     setDefaultVolumeVOI(volumeActor.actor as vtkVolume, imageVolume, false);
+
+    const range = (volumeActor.actor as vtkVolume)
+      .getProperty()
+      .getRGBTransferFunction(0)
+      .getMappingRange();
+
+    const eventDetails = {
+      viewportId: volumeActor.uid,
+      range: {
+        lower: range[0],
+        upper: range[1],
+      },
+      volumeId: volumeActor.uid,
+    };
+
+    triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
   }
 }
 

package/src/cache/cache.ts

@@ -15,34 +15,40 @@ import { triggerEvent, imageIdToURI } from '../utilities';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
 
-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 = 2 * 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 +65,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 +73,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 +90,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
    *
@@ -384,7 +400,6 @@ class Cache implements ICache {
         cachedImage.image = image;
         cachedImage.sizeInBytes = image.sizeInBytes;
         this._incrementImageCacheSize(cachedImage.sizeInBytes);
-
         const eventDetails: EventTypes.ImageCacheImageAddedEventDetail = {
           image: cachedImage,
         };
@@ -429,7 +444,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) {

package/src/types/IImage.ts

@@ -93,6 +93,8 @@ interface IImage {
       suvbwToSuvbsa?: number;
     };
   };
+  loadTimeInMS?: number;
+  decodeTimeInMS?: number;
   /** CPU: image statistics for rendering */
   stats?: {
     lastStoredPixelDataToCanvasImageDataTime?: number;