@cornerstonejs/core 1.53.0 → 1.54.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.53.0",
+  "version": "1.54.1",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -47,5 +47,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "881872ffe29341443f91cead0b810871a6a1929b"
+  "gitHead": "3cea03f5216a14ff0e24802a393fab97ba7e0b7c"
 }

package/src/RenderingEngine/RenderingEngine.ts

@@ -305,6 +305,14 @@ class RenderingEngine implements IRenderingEngine {
 
     this.setVtkjsDrivenViewports(vtkDrivenViewportInputEntries);
     this.setCustomViewports(customRenderingViewportInputEntries);
+
+    // Making sure the setViewports api also can fill the canvas
+    // properly
+    viewportInputEntries.forEach((vp) => {
+      const canvas = getOrCreateCanvas(vp.element);
+      const { background } = vp.defaultOptions;
+      this.fillCanvasWithBackgroundColor(canvas, background);
+    });
   }
 
   /**

package/src/RenderingEngine/Viewport.ts

@@ -87,7 +87,6 @@ class Viewport implements IViewport {
   /** options for the viewport which includes orientation axis, backgroundColor and displayArea */
   options: ViewportInputOptions;
   /** informs if a new actor was added before a resetCameraClippingRange phase */
-  protected newActorAdded = false;
   private _suppressCameraModifiedEvents = false;
   /** A flag representing if viewport methods should fire events or not */
   readonly suppressEvents: boolean;
@@ -507,7 +506,6 @@ class Viewport implements IViewport {
     const renderer = this.getRenderer();
     renderer.addActor(actor);
     this._actors.set(actorUID, Object.assign({}, actorEntry));
-    this.newActorAdded = true;
   }
 
   /**
@@ -765,6 +763,10 @@ class Viewport implements IViewport {
     // compute the radius of the enclosing sphere
     radius = Math.sqrt(radius) * 0.5;
 
+    // For 3D viewport, we should increase the radius to make sure the whole
+    // volume is visible and we don't get clipping artifacts.
+    radius = this.type === ViewportType.VOLUME_3D ? radius * 10 : radius;
+
     const distance = this.insetImageMultiplier * radius;
 
     const viewUpToSet: Point3 =
@@ -1152,7 +1154,7 @@ class Viewport implements IViewport {
 
       // only modify the clipping planes if the camera is modified out of plane
       // or a new actor is added and we need to update the clipping planes
-      if (cameraModifiedOutOfPlane || viewUpHasChanged || this.newActorAdded) {
+      if (cameraModifiedOutOfPlane || viewUpHasChanged) {
         const actorEntry = this.getDefaultActor();
         if (!actorEntry?.actor) {
           return;
@@ -1162,7 +1164,10 @@ class Viewport implements IViewport {
           this.updateClippingPlanesForActors(updatedCamera);
         }
 
-        if (actorIsA(actorEntry, 'vtkImageSlice')) {
+        if (
+          actorIsA(actorEntry, 'vtkImageSlice') ||
+          this.type === ViewportType.VOLUME_3D
+        ) {
           const renderer = this.getRenderer();
           renderer.resetCameraClippingRange();
         }
@@ -1251,12 +1256,6 @@ class Viewport implements IViewport {
         viewport: this,
       });
     });
-
-    this.posProcessNewActors();
-  }
-
-  protected posProcessNewActors(): void {
-    this.newActorAdded = false;
   }
 
   public setOrientationOfClippingPlanes(
@@ -1291,6 +1290,32 @@ class Viewport implements IViewport {
     vtkPlanes[1].setOrigin(newOrigin2);
   }
 
+  /**
+   * Method to get the clipping planes of a given actor
+   * @param actorEntry - The actor entry (a specific type you'll define dependent on your code)
+   * @returns vtkPlanes - An array of vtkPlane objects associated with the given actor
+   */
+  public getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[] {
+    if (!actorEntry) {
+      actorEntry = this.getDefaultActor();
+    }
+
+    if (!actorEntry.actor) {
+      throw new Error('Invalid actor entry: Actor is undefined');
+    }
+
+    const mapper = actorEntry.actor.getMapper();
+    let vtkPlanes = actorEntry?.clippingFilter
+      ? actorEntry.clippingFilter.getClippingPlanes()
+      : mapper.getClippingPlanes();
+
+    if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
+      vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+    }
+
+    return vtkPlanes;
+  }
+
   private _getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal) {
     const viewUpCorners = this._getCorners(bounds);
     const viewRightCorners = this._getCorners(bounds);

package/src/RenderingEngine/VolumeViewport.ts

@@ -17,8 +17,10 @@ import type { ViewportInput } from '../types/IViewport';
 import {
   actorIsA,
   getClosestImageId,
+  getSliceRange,
   getSpacingInNormalDirection,
   isImageActor,
+  snapFocalPointToSlice,
   triggerEvent,
 } from '../utilities';
 import BaseVolumeViewport from './BaseVolumeViewport';
@@ -88,6 +90,15 @@ class VolumeViewport extends BaseVolumeViewport {
     return numberOfSlices;
   };
 
+  /**
+   * Returns the image index associated with the volume viewport.
+   * @returns The image index.
+   */
+  public getSliceIndex = (): number => {
+    const { imageIndex } = getImageSliceDataForVolumeViewport(this);
+    return imageIndex;
+  };
+
   /**
    * Creates and adds volume actors for all volumes defined in the `volumeInputArray`.
    * For each entry, if a `callback` is supplied, it will be called with the new volume actor as input.
@@ -125,26 +136,35 @@ class VolumeViewport extends BaseVolumeViewport {
    * @param orientation - The orientation to set the camera to.
    * @param immediate - Whether the `Viewport` should be rendered as soon as the camera is set.
    */
-  public setOrientation(orientation: OrientationAxis, immediate = true): void {
+  public setOrientation(
+    orientation: OrientationAxis | OrientationVectors,
+    immediate = true
+  ): void {
     let viewPlaneNormal, viewUp;
 
-    if (MPR_CAMERA_VALUES[orientation]) {
-      ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
-    } else if (orientation === 'acquisition') {
-      ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
-    } else {
-      throw new Error(
-        `Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`
-      );
-    }
+    // check if the orientation is a string or an object
+    if (typeof orientation === 'string') {
+      if (MPR_CAMERA_VALUES[orientation]) {
+        ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
+      } else if (orientation === 'acquisition') {
+        ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+      } else {
+        throw new Error(
+          `Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`
+        );
+      }
 
-    this.setCamera({
-      viewPlaneNormal,
-      viewUp,
-    });
+      this.setCamera({
+        viewPlaneNormal,
+        viewUp,
+      });
 
-    this.viewportProperties.orientation = orientation;
-    this.resetCamera();
+      this.viewportProperties.orientation = orientation;
+      this.resetCamera();
+    } else {
+      ({ viewPlaneNormal, viewUp } = orientation);
+      this.applyViewOrientation(orientation);
+    }
 
     if (immediate) {
       this.render();
@@ -455,6 +475,105 @@ class VolumeViewport extends BaseVolumeViewport {
 
     triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
   }
+
+  /**
+   * Retrieves the clipping planes for the slices in the volume viewport.
+   * @returns An array of vtkPlane objects representing the clipping planes, or an array of objects with normal and origin properties if raw is true.
+   */
+  getSlicesClippingPlanes(): Array<{
+    sliceIndex: number;
+    planes: Array<{
+      normal: Point3;
+      origin: Point3;
+    }>;
+  }> {
+    const focalPoints = this.getSlicePlaneCoordinates();
+    const { viewPlaneNormal } = this.getCamera();
+    const slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+
+    return focalPoints.map(({ point, sliceIndex }) => {
+      const vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+
+      this.setOrientationOfClippingPlanes(
+        vtkPlanes,
+        slabThickness,
+        viewPlaneNormal,
+        point
+      );
+
+      return {
+        sliceIndex,
+        planes: vtkPlanes.map((plane) => ({
+          normal: plane.getNormal(),
+          origin: plane.getOrigin(),
+        })),
+      };
+    });
+  }
+
+  /**
+   * Returns an array of 3D coordinates representing the slice plane positions.
+   * It starts by the focal point as a reference point on the current slice that
+   * the camera is looking at, and then it calculates the slice plane positions
+   * by moving the focal point in the direction of the view plane normal back and
+   * forward, and snaps them to the slice.
+   *
+   * @returns An array of Point3 representing the slice plane coordinates.
+   */
+  public getSlicePlaneCoordinates = (): Array<{
+    sliceIndex: number;
+    point: Point3;
+  }> => {
+    const actorEntry = this.getDefaultActor();
+
+    if (!actorEntry?.actor) {
+      console.warn('No image data found for calculating vtkPlanes.');
+      return [];
+    }
+
+    const volumeId = actorEntry.uid;
+    const imageVolume = cache.getVolume(volumeId);
+
+    const camera = this.getCamera();
+    const { focalPoint, position, viewPlaneNormal } = camera;
+    const spacingInNormalDirection = getSpacingInNormalDirection(
+      imageVolume,
+      viewPlaneNormal
+    );
+    const sliceRange = getSliceRange(
+      actorEntry.actor as vtkVolume,
+      viewPlaneNormal,
+      focalPoint
+    );
+
+    // calculate the number of slices that is possible to visit
+    // in the direction of the view back and forward
+    const numSlicesBackward = Math.round(
+      (sliceRange.current - sliceRange.min) / spacingInNormalDirection
+    );
+
+    const numSlicesForward = Math.round(
+      (sliceRange.max - sliceRange.current) / spacingInNormalDirection
+    );
+
+    const currentSliceIndex = this.getSliceIndex();
+    const focalPoints = [];
+
+    for (let i = -numSlicesBackward; i <= numSlicesForward; i++) {
+      const { newFocalPoint: point } = snapFocalPointToSlice(
+        focalPoint,
+        position,
+        sliceRange,
+        viewPlaneNormal,
+        spacingInNormalDirection,
+        i
+      );
+
+      focalPoints.push({ sliceIndex: currentSliceIndex + i, point });
+    }
+
+    return focalPoints;
+  };
 }
 
 export default VolumeViewport;

package/src/RenderingEngine/VolumeViewport3D.ts

@@ -46,14 +46,6 @@ class VolumeViewport3D extends BaseVolumeViewport {
     return null;
   };
 
-  posProcessNewActors(): void {
-    if (this.newActorAdded) {
-      const renderer = this.getRenderer();
-      renderer.resetCameraClippingRange();
-    }
-    super.posProcessNewActors();
-  }
-
   setSlabThickness(
     slabThickness: number,
     filterActorUIDs?: Array<string>

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;
@@ -175,20 +176,24 @@ 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 (!image?.referencedImageId) {
+    image = await loadAndCacheImage(imageId, options);
   }
 
+  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);
 

package/src/cache/cache.ts

@@ -704,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
    *

package/src/cache/classes/ImageVolume.ts

@@ -238,6 +238,26 @@ export class ImageVolume implements IImageVolume {
       : [<PixelDataTypedArray>this.scalarData];
   }
 
+  /**
+   * Updates the internals of the volume to reflect the changes in the
+   * underlying scalar data. This should be called when the scalar data
+   * is modified externally
+   */
+  public modified() {
+    this.imageData.modified();
+
+    if (this.isDynamicVolume()) {
+      throw new Error('Not implemented');
+    } else {
+      this.scalarData = this.imageData
+        .getPointData()
+        .getScalars()
+        .getData() as PixelDataTypedArray;
+    }
+
+    this.numFrames = this._getNumFrames();
+  }
+
   /**
    * If completelyRemove is true, remove the volume completely from the cache. Otherwise,
    * convert the volume to cornerstone images (stack images) and store it in the cache
@@ -529,10 +549,12 @@ export class ImageVolume implements IImageVolume {
       // check if the referenced volume has imageIds to see how many
       // images we need to generate
       const referencedVolumeId = this.referencedVolumeId;
-      const referencedVolume = cache.getVolume(referencedVolumeId);
 
-      const numSlices =
-        referencedVolume?.imageIds?.length || this.dimensions[2];
+      let numSlices = this.dimensions[2];
+      if (referencedVolumeId) {
+        const referencedVolume = cache.getVolume(referencedVolumeId);
+        numSlices = referencedVolume?.imageIds?.length ?? numSlices;
+      }
 
       this.imageIds = Array.from({ length: numSlices }, (_, i) => {
         return `generated:${this.volumeId}:${i}`;
@@ -667,7 +689,18 @@ export class ImageVolume implements IImageVolume {
       );
     }
     // 5. When as much of the Volume is processed into Images as possible
-    //    without breaching the cache limit, remove the Volume
+    // without breaching the cache limit, remove the Volume
+    // but first check if the volume is referenced as a derived
+    // volume by another volume, then we need to update their referencedVolumeId
+    // to be now the referencedImageIds of this volume
+    const otherVolumes = cache.filterVolumesByReferenceId(this.volumeId);
+
+    if (otherVolumes.length) {
+      otherVolumes.forEach((volume) => {
+        volume.referencedImageIds = this.imageIds;
+      });
+    }
+
     this.removeFromCache();
 
     return this.imageIds;

package/src/cache/classes/Surface.ts

@@ -1,4 +1,4 @@
-import { SurfaceData, Point3 } from '../../types';
+import { SurfaceData, Point3, ISurface, Color, RGB } from '../../types';
 
 type SurfaceProps = {
   id: string;
@@ -10,11 +10,11 @@ type SurfaceProps = {
 /**
  * Surface class for storing surface data
  */
-export class Surface {
+export class Surface implements ISurface {
   readonly id: string;
   readonly sizeInBytes: number;
   readonly frameOfReferenceUID: string;
-  private color: Point3 = [200, 0, 0]; // default color
+  private color: RGB = [200, 0, 0]; // default color
   private points: number[];
   private polys: number[];
 
@@ -31,7 +31,7 @@ export class Surface {
     return this.points.length * 4 + this.polys.length * 4;
   }
 
-  public getColor(): Point3 {
+  public getColor(): RGB {
     return this.color;
   }
 
@@ -43,6 +43,18 @@ export class Surface {
     return this.polys;
   }
 
+  public setColor(color: RGB): void {
+    this.color = color;
+  }
+
+  public setPoints(points: number[]): void {
+    this.points = points;
+  }
+
+  public setPolys(polys: number[]): void {
+    this.polys = polys;
+  }
+
   public getSizeInBytes(): number {
     return this.sizeInBytes;
   }

package/src/cache/index.ts

@@ -1,5 +1,6 @@
 import cache, { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
+import { Surface } from './classes/Surface';
 
-export { ImageVolume, Cache };
+export { ImageVolume, Cache, Surface };
 export default cache;

package/src/constants/backgroundColors.ts

@@ -0,0 +1,5 @@
+const backgroundColors = {
+  slicer3D: [160 / 255, 164 / 255, 217 / 255],
+};
+
+export default backgroundColors;

package/src/constants/index.ts

@@ -3,6 +3,7 @@ import RENDERING_DEFAULTS from './rendering';
 import EPSILON from './epsilon';
 import MPR_CAMERA_VALUES from './mprCameraValues';
 import VIEWPORT_PRESETS from './viewportPresets';
+import BACKGROUND_COLORS from './backgroundColors';
 
 export {
   CPU_COLORMAPS,
@@ -10,4 +11,5 @@ export {
   MPR_CAMERA_VALUES,
   EPSILON,
   VIEWPORT_PRESETS,
+  BACKGROUND_COLORS,
 };

package/src/enums/Events.ts

@@ -215,6 +215,14 @@ enum Events {
    * Triggers when the clipping planes has been updated
    */
   CLIPPING_PLANES_UPDATED = 'CORNERSTONE_CLIPPING_PLANES_UPDATED',
+
+  /**
+   * Triggers when the webworker has made progress
+   * You should use it with a workerType to indicate the type of worker that is making progress
+   * Checkout the polySEG convertors in the cornerstone tools
+   * to lean how to use it
+   */
+  WEB_WORKER_PROGRESS = 'CORNERSTONE_WEB_WORKER_PROGRESS',
   // IMAGE_CACHE_FULL = 'CORNERSTONE_IMAGE_CACHE_FULL',
   // PRE_RENDER = 'CORNERSTONE_PRE_RENDER',
   // ELEMENT_RESIZED = 'CORNERSTONE_ELEMENT_RESIZED',

package/src/index.ts

@@ -19,7 +19,7 @@ import {
   getRenderingEngine,
   getRenderingEngines,
 } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume } from './cache';
+import cache, { ImageVolume, Surface } from './cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 
@@ -103,6 +103,7 @@ export {
   VideoViewport,
   RenderingEngine,
   ImageVolume,
+  Surface,
   // Helpers
   getRenderingEngine,
   getRenderingEngines,