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

package/package.json

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

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -12,6 +12,7 @@ import {
 import {
   BlendModes,
   Events,
+  InterpolationType,
   OrientationAxis,
   ViewportStatus,
   VOILUTFunctionType,
@@ -367,6 +368,23 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return newRGBTransferFunction;
   }
 
+  private setInterpolationType(
+    interpolationType: InterpolationType,
+    volumeId?: string
+  ) {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const { volumeActor } = applicableVolumeActorInfo;
+    const volumeProperty = volumeActor.getProperty();
+
+    // @ts-ignore
+    volumeProperty.setInterpolationType(interpolationType);
+  }
+
   /**
    * Sets the properties for the volume viewport on the volume
    * (if fusion, it sets it for the first volume in the fusion)
@@ -449,6 +467,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       invert,
       colormap,
       preset,
+      interpolationType,
     }: VolumeViewportProperties = {},
     volumeId?: string,
     suppressEvents = false
@@ -467,6 +486,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       this.setVOI(voiRange, volumeId, suppressEvents);
     }
 
+    if (typeof interpolationType !== 'undefined') {
+      this.setInterpolationType(interpolationType);
+    }
+
     if (VOILUTFunction !== undefined) {
       this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
     }
@@ -519,7 +542,9 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         const volumeActor = actorEntry.actor as vtkVolume;
         const volumeId = actorEntry.uid;
         const volume = cache.getVolume(volumeId);
-        if (!volume) return null;
+        if (!volume) {
+          return null;
+        }
         const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
         const [lower, upper] =
           this.VOILUTFunction === 'SIGMOID'
@@ -847,6 +872,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    *
    */
   private _setVolumeActors(volumeActorEntries: Array<ActorEntry>): void {
+    // New volume actors implies resetting the inverted flag (i.e. like starting from scratch).
+    this.inverted = false;
     this.setActors(volumeActorEntries);
   }
 
@@ -1078,6 +1105,31 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return volume.getScalarData()[voxelIndex];
   }
 
+  /**
+   * Returns the list of image Ids for the current viewport
+   *
+   * @param volumeId - volumeId
+   * @returns list of strings for image Ids
+   */
+  public getImageIds = (volumeId?: string): Array<string> => {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      throw new Error(`No actor found for the given volumeId: ${volumeId}`);
+    }
+
+    const volumeIdToUse = applicableVolumeActorInfo.volumeId;
+
+    const imageVolume = cache.getVolume(volumeIdToUse);
+    if (!imageVolume) {
+      throw new Error(
+        `imageVolume with id: ${volumeIdToUse} does not exist in cache`
+      );
+    }
+
+    return imageVolume.imageIds;
+  };
+
   abstract getCurrentImageIdIndex(): number;
 
   abstract getCurrentImageId(): string;
@@ -1092,6 +1144,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     slabThickness: number,
     filterActorUIDs?: Array<string>
   ): void;
+
+  abstract resetProperties(volumeId?: string): void;
 }
 
 export default BaseVolumeViewport;

package/src/RenderingEngine/RenderingEngine.ts

@@ -54,6 +54,7 @@ const VIEWPORT_MIN_SIZE = 2;
  * trigger a render on a specific viewport(s). Each viewport also has a `.render` method which can be used to trigger a render on that
  * viewport.
  *
+ *
  * Rendering engine uses `detect-gpu` external library to detect if GPU is available and
  * it has minimum requirement to be able to render a volume with vtk.js. If GPU is not available
  * RenderingEngine will throw an error if you try to render a volume; however, for StackViewports

package/src/RenderingEngine/StackViewport.ts

@@ -130,6 +130,8 @@ class StackViewport extends Viewport implements IStackViewport {
   private VOILUTFunction: VOILUTFunctionType;
   //
   private invert = false;
+  // The initial invert of the image loaded as opposed to the invert status of the viewport itself (see above).
+  private initialInvert = false;
   private interpolationType: InterpolationType;
 
   // Helpers
@@ -606,7 +608,9 @@ class StackViewport extends Viewport implements IStackViewport {
     this.hasPixelSpacing = scale > 0 || imagePlaneModule.rowPixelSpacing > 0;
     imagePlaneModule.calibration = calibration;
 
-    if (!isUpdated) return imagePlaneModule;
+    if (!isUpdated) {
+      return imagePlaneModule;
+    }
 
     this.calibration = calibration;
     this._publishCalibratedEvent = true;
@@ -728,7 +732,7 @@ class StackViewport extends Viewport implements IStackViewport {
       this.setRotation(0);
     }
     this.setInterpolationType(InterpolationType.LINEAR);
-    this.setInvertColor(false);
+    this.setInvertColor(this.initialInvert);
   }
 
   private _setPropertiesFromCache(): void {
@@ -1755,10 +1759,17 @@ class StackViewport extends Viewport implements IStackViewport {
           return;
         }
 
-        //If Photometric Interpretation is not the same for the next image we are trying to load, invalidate the stack to recreate the VTK imageData
+        // If Photometric Interpretation is not the same for the next image we are trying to load
+        // invalidate the stack to recreate the VTK imageData
+        const csImgFrame = this.csImage?.imageFrame;
+        const imgFrame = image?.imageFrame;
+
+        // if a volume is decached into images then the imageFrame will be undefined
         if (
-          this.csImage?.imageFrame.photometricInterpretation !==
-          image?.imageFrame?.photometricInterpretation
+          csImgFrame?.photometricInterpretation !==
+            imgFrame?.photometricInterpretation ||
+          this.csImage?.photometricInterpretation !==
+            image?.photometricInterpretation
         ) {
           this.stackInvalidated = true;
         }
@@ -2057,8 +2068,10 @@ class StackViewport extends Viewport implements IStackViewport {
       forceRecreateLUTFunction: !!monochrome1,
     });
 
+    this.initialInvert = !!monochrome1;
+
     // should carry over the invert color from the previous image if has been applied
-    this.setInvertColor(this.invert || !!monochrome1);
+    this.setInvertColor(this.invert || this.initialInvert);
 
     // Saving position of camera on render, to cache the panning
     this.cameraFocalPointOnRender = this.getCamera().focalPoint;
@@ -2142,6 +2155,7 @@ class StackViewport extends Viewport implements IStackViewport {
     // Update the state of the viewport to the new imageIdIndex;
     this.currentImageIdIndex = imageIdIndex;
     this.hasPixelSpacing = true;
+    this.viewportStatus = ViewportStatus.PRE_RENDER;
 
     // Todo: trigger an event to allow applications to hook into START of loading state
     // Currently we use loadHandlerManagers for this
@@ -2564,7 +2578,9 @@ class StackViewport extends Viewport implements IStackViewport {
   public hasImageURI = (imageURI: string): boolean => {
     const imageIds = this.imageIds;
     for (let i = 0; i < imageIds.length; i++) {
-      if (imageIdToURI(imageIds[i]) === imageURI) return true;
+      if (imageIdToURI(imageIds[i]) === imageURI) {
+        return true;
+      }
     }
 
     return false;

package/src/RenderingEngine/VolumeViewport.ts

@@ -14,6 +14,8 @@ import type {
 import type { ViewportInput } from '../types/IViewport';
 import { actorIsA, getClosestImageId } 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
@@ -350,6 +352,38 @@ class VolumeViewport extends BaseVolumeViewport {
   };
 
   getRotation = (): number => 0;
+
+  /**
+   * Reset the viewport properties to the default values
+   *
+
+   * @param volumeId - Optional volume ID to specify which volume properties to reset.
+   * If not provided, it will reset the properties of the default actor.
+   *
+   * @returns void
+   */
+  public resetProperties(volumeId?: string): void {
+    this._resetProperties(volumeId);
+  }
+
+  private _resetProperties(volumeId?: string) {
+    // Get the actor based on the volumeId if provided, otherwise use the default actor.
+    const volumeActor = volumeId
+      ? this.getActor(volumeId)
+      : this.getDefaultActor();
+
+    if (!volumeActor) {
+      throw new Error(`No actor found for the given volumeId: ${volumeId}`);
+    }
+
+    const imageVolume = cache.getVolume(volumeActor.uid);
+    if (!imageVolume) {
+      throw new Error(
+        `imageVolume with id: ${volumeActor.uid} does not exist in cache`
+      );
+    }
+    setDefaultVolumeVOI(volumeActor.actor as vtkVolume, imageVolume, false);
+  }
 }
 
 export default VolumeViewport;

package/src/RenderingEngine/VolumeViewport3D.ts

@@ -60,6 +60,10 @@ class VolumeViewport3D extends BaseVolumeViewport {
   ): void {
     return null;
   }
+
+  resetProperties(volumeId?: string): void {
+    return null;
+  }
 }
 
 export default VolumeViewport3D;

package/src/RenderingEngine/helpers/cpuFallback/rendering/getVOILut.ts

@@ -15,6 +15,11 @@
  */
 
 /**
+ * Generates the linear VOI LUT function.
+ * From the DICOM standard:
+ * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
+ * ((x - (c - 0.5)) / (w-1) + 0.5) * (ymax- ymin) + ymin
+ * clipped to the ymin...ymax range
  *
  * @param {Number} windowWidth Window Width
  * @param {Number} windowCenter Window Center
@@ -23,7 +28,10 @@
  */
 function generateLinearVOILUT(windowWidth: number, windowCenter: number) {
   return function (modalityLutValue) {
-    return ((modalityLutValue - windowCenter) / windowWidth + 0.5) * 255.0;
+    const value =
+      ((modalityLutValue - (windowCenter - 0.5)) / (windowWidth - 1) + 0.5) *
+      255.0;
+    return Math.min(Math.max(value, 0), 255);
   };
 }
 

package/src/RenderingEngine/helpers/cpuFallback/rendering/renderColorImage.ts

@@ -72,10 +72,12 @@ function getRenderCanvas(
   const renderCanvas = enabledElement.renderingTools.renderCanvas;
 
   // The ww/wc is identity and not inverted - get a canvas with the image rendered into it for
-  // Fast drawing
+  // Fast drawing.  Note that this is 256/128, and NOT 255/127, per the DICOM
+  // standard, but allow either.
+  const { windowWidth, windowCenter } = enabledElement.viewport.voi;
   if (
-    enabledElement.viewport.voi.windowWidth === 255 &&
-    enabledElement.viewport.voi.windowCenter === 127 &&
+    (windowWidth === 256 || windowWidth === 255) &&
+    (windowCenter === 128 || windowCenter === 127) &&
     enabledElement.viewport.invert === false &&
     image.getCanvas &&
     image.getCanvas()

package/src/RenderingEngine/helpers/setVolumesForViewports.ts

@@ -34,7 +34,9 @@ async function setVolumesForViewports(
 
     // if not instance of BaseVolumeViewport, throw
     if (!(viewport instanceof BaseVolumeViewport)) {
-      throw new Error('setVolumesForViewports only supports VolumeViewport and VolumeViewport3D');
+      throw new Error(
+        'setVolumesForViewports only supports VolumeViewport and VolumeViewport3D'
+      );
     }
   });
 

package/src/Settings.ts

@@ -250,10 +250,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/classes/ImageVolume.ts

@@ -151,12 +151,12 @@ export class ImageVolume implements IImageVolume {
    */
   destroy(): void {
     // TODO: GPU memory associated with volume is not cleared.
-    this.vtkOpenGLTexture.releaseGraphicsResources();
-    this.vtkOpenGLTexture.destroyTexture();
-    this.vtkOpenGLTexture.delete();
     this.imageData.delete();
     this.imageData = null;
     this.scalarData = null;
+
+    this.vtkOpenGLTexture.releaseGraphicsResources();
+    this.vtkOpenGLTexture.delete();
   }
 }
 

package/src/init.ts

@@ -100,7 +100,7 @@ function hasSharedArrayBuffer() {
  * @returns A promise that resolves to true cornerstone has been initialized successfully.
  * @category Initialization
  */
-async function init(configuration = {}): Promise<boolean> {
+async function init(configuration = config): Promise<boolean> {
   if (csRenderInitialized) {
     return csRenderInitialized;
   }

package/src/loaders/volumeLoader.ts

@@ -132,7 +132,7 @@ let unknownVolumeLoader;
  */
 function loadVolumeFromVolumeLoader(
   volumeId: string,
-  options: VolumeLoaderOptions
+  options?: VolumeLoaderOptions
 ): Types.IVolumeLoadObject {
   const colonIndex = volumeId.indexOf(':');
   const scheme = volumeId.substring(0, colonIndex);
@@ -210,7 +210,7 @@ export function loadVolume(
  */
 export async function createAndCacheVolume(
   volumeId: string,
-  options: VolumeLoaderOptions
+  options?: VolumeLoaderOptions
 ): Promise<Record<string, any>> {
   if (volumeId === undefined) {
     throw new Error(

package/src/requestPool/requestPoolManager.ts

@@ -307,7 +307,7 @@ class RequestPoolManager {
     const priorities = Object.keys(this.requestPool[type])
       .map(Number)
       .filter((priority) => this.requestPool[type][priority].length)
-      .sort();
+      .sort((a, b) => a - b);
     return priorities;
   }
 

package/src/types/AffineMatrix.ts

@@ -0,0 +1,8 @@
+type AffineMatrix = [
+  [number, number, number, number],
+  [number, number, number, number],
+  [number, number, number, number],
+  [number, number, number, number]
+];
+
+export type { AffineMatrix };

package/src/types/IImage.ts

@@ -72,6 +72,8 @@ interface IImage {
   sliceThickness?: number;
   /** whether image pixels are inverted in color */
   invert: boolean;
+  /** image photometric interpretation */
+  photometricInterpretation?: string;
   /** image size in number of bytes */
   sizeInBytes: number;
   /** CPU: custom modality LUT for image  */

package/src/types/IVolumeViewport.ts

@@ -28,6 +28,10 @@ export default interface IVolumeViewport extends IViewport {
    * projected onto the `Viewport`'s `canvas`.
    */
   worldToCanvas: (worldPos: Point3) => Point2;
+  /**
+   * Returns the list of image Ids for the current viewport
+   */
+  getImageIds: (volumeId?: string) => string[];
   /**
    * Uses viewport camera and volume actor to decide if the viewport
    * is looking at the volume in the direction of acquisition (imageIds).
@@ -138,4 +142,8 @@ export default interface IVolumeViewport extends IViewport {
   getImageData(volumeId?: string): IImageData | undefined;
 
   setOrientation(orientation: OrientationAxis): void;
+  /**
+   * Reset the viewport properties to the default values
+   */
+  resetProperties(volumeId?: string): void;
 }

package/src/types/Mat3.ts

@@ -1,16 +1,8 @@
 /**
  * This represents a 3x3 matrix of numbers
  */
-type Mat3 = [
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-  number
-];
+type Mat3 =
+  | [number, number, number, number, number, number, number, number, number]
+  | Float32Array;
 
 export default Mat3;

package/src/types/ViewportProperties.ts

@@ -1,4 +1,4 @@
-import { VOILUTFunctionType } from '../enums';
+import { InterpolationType, VOILUTFunctionType } from '../enums';
 import { VOIRange } from './voi';
 
 /**
@@ -11,6 +11,8 @@ type ViewportProperties = {
   VOILUTFunction?: VOILUTFunctionType;
   /** invert flag - whether the image is inverted */
   invert?: boolean;
+  /** interpolation type */
+  interpolationType?: InterpolationType;
 };
 
 export type { ViewportProperties };

package/src/types/index.ts

@@ -81,6 +81,7 @@ import type { ViewportProperties } from './ViewportProperties';
 import type { PixelDataTypedArray } from './PixelDataTypedArray';
 import type { ImagePixelModule } from './ImagePixelModule';
 import type { ImagePlaneModule } from './ImagePlaneModule';
+import type { AffineMatrix } from './AffineMatrix';
 
 export type {
   // config
@@ -173,4 +174,5 @@ export type {
   PixelDataTypedArray,
   ImagePixelModule,
   ImagePlaneModule,
+  AffineMatrix,
 };

package/src/utilities/calculateViewportsSpatialRegistration.ts

@@ -1,9 +1,15 @@
 import { vec3, mat4 } from 'gl-matrix';
 import { IStackViewport } from '../types';
-import { StackViewport } from '../RenderingEngine';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
 import { metaData } from '..';
-import isEqual from './isEqual';
+
+/**
+ * Defines the allowed difference as a percent between the unit normals before
+ * two planes are considered not coplanar.  Since this value is small compared
+ * to the unit lenght, this value is approximately the angular difference, measured
+ * in radians.  That is, allow about a 3 degrees variation.
+ */
+const ALLOWED_DELTA = 0.05;
 
 /**
  * It calculates the registration matrix between two viewports (currently only
@@ -21,40 +27,28 @@ function calculateViewportsSpatialRegistration(
   viewport1: IStackViewport,
   viewport2: IStackViewport
 ): void {
-  if (
-    !(viewport1 instanceof StackViewport) ||
-    !(viewport2 instanceof StackViewport)
-  ) {
-    throw new Error(
-      'calculateViewportsSpatialRegistration: Both viewports must be StackViewports, volume viewports are not supported yet'
-    );
-  }
-
-  const isSameFrameOfReference =
-    viewport1.getFrameOfReferenceUID() === viewport2.getFrameOfReferenceUID();
-
-  if (isSameFrameOfReference) {
-    return;
-  }
-
   const imageId1 = viewport1.getCurrentImageId();
   const imageId2 = viewport2.getCurrentImageId();
 
   const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
   const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
 
-  const isSameImagePlane =
-    imagePlaneModule1 &&
-    imagePlaneModule2 &&
-    isEqual(
-      imagePlaneModule1.imageOrientationPatient,
-      imagePlaneModule2.imageOrientationPatient
-    );
+  if (!imagePlaneModule1 || !imagePlaneModule2) {
+    console.log('Viewport spatial registration requires image plane module');
+    return;
+  }
+  const { imageOrientationPatient: iop2 } = imagePlaneModule2;
+  const isSameImagePlane = imagePlaneModule1.imageOrientationPatient.every(
+    (v, i) => Math.abs(v - iop2[i]) < ALLOWED_DELTA
+  );
 
   if (!isSameImagePlane) {
-    throw new Error(
-      'Viewport spatial registration only supported for same orientation (hence translation only) for now'
+    console.log(
+      'Viewport spatial registration only supported for same orientation (hence translation only) for now',
+      imagePlaneModule1?.imageOrientationPatient,
+      imagePlaneModule2?.imageOrientationPatient
     );
+    return;
   }
 
   const imagePositionPatient1 = imagePlaneModule1.imagePositionPatient;
@@ -67,7 +61,6 @@ function calculateViewportsSpatialRegistration(
   );
 
   const mat = mat4.fromTranslation(mat4.create(), translation);
-
   spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
 }
 

package/src/utilities/getClosestStackImageIndexForPoint.ts

@@ -29,11 +29,15 @@ export function calculateMinimalDistanceForStackViewport(
   const imageIds = viewport.getImageIds();
   const currentImageIdIndex = viewport.getCurrentImageIdIndex();
 
-  if (imageIds.length === 0) return null;
+  if (imageIds.length === 0) {
+    return null;
+  }
 
   const getDistance = (imageId: string): null | number => {
     const planeMetadata = getPlaneMetadata(imageId);
-    if (!planeMetadata) return null;
+    if (!planeMetadata) {
+      return null;
+    }
     const plane = planar.planeEquation(
       planeMetadata.planeNormal,
       planeMetadata.imagePositionPatient
@@ -53,22 +57,30 @@ export function calculateMinimalDistanceForStackViewport(
   for (let i = 0; i < higherImageIds.length; i++) {
     const id = higherImageIds[i];
     const distance = getDistance(id);
-    if (distance === null) continue;
+    if (distance === null) {
+      continue;
+    }
     if (distance <= closestStack.distance) {
       closestStack.distance = distance;
       closestStack.index = i + currentImageIdIndex + 1;
-    } else break;
+    } else {
+      break;
+    }
   }
   //check lower indices
   const lowerImageIds = imageIds.slice(0, currentImageIdIndex);
   for (let i = lowerImageIds.length - 1; i >= 0; i--) {
     const id = lowerImageIds[i];
     const distance = getDistance(id);
-    if (distance === null || distance === closestStack.distance) continue;
+    if (distance === null || distance === closestStack.distance) {
+      continue;
+    }
     if (distance < closestStack.distance) {
       closestStack.distance = distance;
       closestStack.index = i;
-    } else break;
+    } else {
+      break;
+    }
   }
   return closestStack.distance === Infinity ? null : closestStack;
 }

package/src/utilities/getRuntimeId.ts

@@ -46,7 +46,9 @@ function getNextRuntimeId(
       n = n + 1;
     } else {
       n = 0;
-      if (i + 1 === idComponents.length) idComponents.push(0);
+      if (i + 1 === idComponents.length) {
+        idComponents.push(0);
+      }
     }
     idComponents[i] = n;
   }