@cornerstonejs/core 1.38.1 → 1.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.38.1",
+  "version": "1.40.0",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -47,5 +47,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "1b7cb02f6c11935850f80a5382be21dd8aaab4d5"
+  "gitHead": "28ed3eaf75ccd5cab7c7c0df0f4b09950cc42d7c"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -3,6 +3,8 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 
+import { vec3 } from 'gl-matrix';
+
 import cache from '../cache';
 import {
   MPR_CAMERA_VALUES,
@@ -31,7 +33,9 @@ import type {
   Point2,
   Point3,
   VOIRange,
+  EventTypes,
   VolumeViewportProperties,
+  ICamera,
 } from '../types';
 import { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
@@ -77,7 +81,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     string,
     VolumeViewportProperties
   >();
-
+  // Camera properties
+  private initialViewUp: Point3;
   protected viewportProperties: VolumeViewportProperties = {};
 
   constructor(props: ViewportInput) {
@@ -95,6 +100,16 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     const renderer = this.getRenderer();
 
     const camera = vtkSlabCamera.newInstance();
+
+    this.initialViewUp = <Point3>[0, -1, 0];
+    const viewPlaneNormal = <Point3>[0, 0, -1];
+
+    camera.setDirectionOfProjection(
+      -viewPlaneNormal[0],
+      -viewPlaneNormal[1],
+      -viewPlaneNormal[2]
+    );
+    camera.setViewUp(...this.initialViewUp);
     renderer.setActiveCamera(camera);
 
     switch (this.type) {
@@ -471,6 +486,33 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     this.viewportProperties.voiRange = voiRangeToUse;
   }
 
+  private setRotation(rotation: number): void {
+    const previousCamera = this.getCamera();
+
+    this.rotateCamera(rotation);
+
+    // New camera after rotation
+    const camera = this.getCamera();
+
+    const eventDetail: EventTypes.CameraModifiedEventDetail = {
+      previousCamera,
+      camera,
+      element: this.element,
+      viewportId: this.id,
+      renderingEngineId: this.renderingEngineId,
+      rotation,
+    };
+
+    triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
+    this.viewportProperties.rotation = rotation;
+  }
+
+  private rotateCamera(rotation: number): void {
+    const rotationToApply = rotation - this.getRotation();
+    // rotating camera to the new value
+    this.getVtkActiveCamera().roll(-rotationToApply);
+  }
+
   /**
    * Update the default properties for the volume viewport on the volume
    * @param ViewportProperties - The properties to set
@@ -525,6 +567,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       preset,
       interpolationType,
       slabThickness,
+      rotation,
     }: VolumeViewportProperties = {},
     volumeId?: string,
     suppressEvents = false
@@ -538,6 +581,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         colormap,
         preset,
         slabThickness,
+        rotation,
       });
     }
 
@@ -576,6 +620,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       //We need to set the current slab thickness here since setSlabThickness is define in VolumeViewport
       this.viewportProperties.slabThickness = slabThickness;
     }
+
+    if (rotation !== undefined) {
+      this.setRotation(rotation);
+    }
   }
 
   /**
@@ -609,6 +657,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       this.viewportProperties.slabThickness = properties.slabThickness;
     }
 
+    if (properties.rotation !== undefined) {
+      this.setRotation(properties.rotation);
+    }
+
     this.render();
   }
 
@@ -683,6 +735,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       interpolationType,
       invert,
       slabThickness,
+      rotation,
     } = this.viewportProperties;
 
     const voiRanges = this.getActors()
@@ -711,6 +764,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       interpolationType: interpolationType,
       invert: invert,
       slabThickness: slabThickness,
+      rotation: rotation,
     };
   };
 
@@ -937,6 +991,49 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return true;
   }
 
+  /**
+   * Gets the rotation resulting from the value set in setRotation AND taking into
+   * account any flips that occurred subsequently from the camera provided or the viewport.
+   *
+   * @returns the rotation resulting from the value set in setRotation AND taking into
+   * account any flips that occurred subsequently.
+   */
+  public getRotation = (): number => {
+    const {
+      viewUp: currentViewUp,
+      viewPlaneNormal,
+      flipVertical,
+    } = this.getCamera();
+
+    // The initial view up vector without any rotation, but incorporating vertical flip.
+    const initialViewUp = flipVertical
+      ? vec3.negate(vec3.create(), this.initialViewUp)
+      : this.initialViewUp;
+
+    // The angle between the initial and current view up vectors.
+    // TODO: check with VTK about rounding errors here.
+    const initialToCurrentViewUpAngle =
+      (vec3.angle(initialViewUp, currentViewUp) * 180) / Math.PI;
+
+    // Now determine if initialToCurrentViewUpAngle is positive or negative by comparing
+    // the direction of the initial/current view up cross product with the current
+    // viewPlaneNormal.
+
+    const initialToCurrentViewUpCross = vec3.cross(
+      vec3.create(),
+      initialViewUp,
+      currentViewUp
+    );
+
+    // The sign of the dot product of the start/end view up cross product and
+    // the viewPlaneNormal indicates a positive or negative rotation respectively.
+    const normalDot = vec3.dot(initialToCurrentViewUpCross, viewPlaneNormal);
+
+    return normalDot >= 0
+      ? initialToCurrentViewUpAngle
+      : (360 - initialToCurrentViewUpAngle) % 360;
+  };
+
   /**
    * gets the visible bounds of the viewport in the world coordinate system
    */
@@ -1209,6 +1306,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       typeof orientation === 'string' &&
       MPR_CAMERA_VALUES[orientation]
     ) {
+      this.viewportProperties.orientation = orientation;
       return MPR_CAMERA_VALUES[orientation];
     } else {
       throw new Error(

package/src/RenderingEngine/Viewport.ts

@@ -18,7 +18,7 @@ import {
   isEqual,
 } from '../utilities';
 import hasNaNValues from '../utilities/hasNaNValues';
-import { EPSILON, RENDERING_DEFAULTS } from '../constants';
+import { RENDERING_DEFAULTS } from '../constants';
 import type {
   ICamera,
   ActorEntry,
@@ -1190,7 +1190,11 @@ class Viewport implements IViewport {
     updatedCamera: ICamera
   ): Promise<void> {
     const actorEntries = this.getActors();
-    const allPromises = actorEntries.map(async (actorEntry) => {
+    // Todo: this was using an async and promise wait all because of the
+    // new surface rendering use case, which broke the more important 3D
+    // volume rendering, so reverting this back for now until I can figure
+    // out a better way to handle this.
+    actorEntries.map((actorEntry) => {
       // we assume that the first two clipping plane of the mapper are always
       // the 'camera' clipping. Update clipping planes only if the actor is
       // a vtkVolume
@@ -1228,7 +1232,6 @@ class Viewport implements IViewport {
       });
     });
 
-    await Promise.all(allPromises);
     this.posProcessNewActors();
   }
 

package/src/RenderingEngine/VolumeViewport.ts

@@ -42,7 +42,6 @@ class VolumeViewport extends BaseVolumeViewport {
     super(props);
 
     const { orientation } = this.options;
-
     // if the camera is set to be acquisition axis then we need to skip
     // it for now until the volume is set
     if (orientation && orientation !== OrientationAxis.ACQUISITION) {
@@ -144,6 +143,7 @@ class VolumeViewport extends BaseVolumeViewport {
       viewUp,
     });
 
+    this.viewportProperties.orientation = orientation;
     this.resetCamera();
 
     if (immediate) {
@@ -231,7 +231,8 @@ class VolumeViewport extends BaseVolumeViewport {
   public resetCamera(
     resetPan = true,
     resetZoom = true,
-    resetToCenter = true
+    resetToCenter = true,
+    resetRotation = false
   ): boolean {
     super.resetCamera(resetPan, resetZoom, resetToCenter);
 
@@ -239,6 +240,7 @@ class VolumeViewport extends BaseVolumeViewport {
 
     const activeCamera = this.getVtkActiveCamera();
     const viewPlaneNormal = <Point3>activeCamera.getViewPlaneNormal();
+    const viewUp = <Point3>activeCamera.getViewUp();
     const focalPoint = <Point3>activeCamera.getFocalPoint();
 
     // always add clipping planes for the volume viewport. If a use case
@@ -274,6 +276,19 @@ class VolumeViewport extends BaseVolumeViewport {
       }
     });
 
+    //Only reset the rotation of the camera if wanted (so we don't reset everytime resetCamera is called) and also verify that the viewport has an orientation that we know (sagittal, coronal, axial)
+    if (
+      resetRotation &&
+      MPR_CAMERA_VALUES[this.viewportProperties.orientation] !== undefined
+    ) {
+      const viewToReset =
+        MPR_CAMERA_VALUES[this.viewportProperties.orientation];
+      this.setCameraNoEvent({
+        viewUp: viewToReset.viewUp,
+        viewPlaneNormal: viewToReset.viewPlaneNormal,
+      });
+    }
+
     return true;
   }
 
@@ -370,8 +385,6 @@ class VolumeViewport extends BaseVolumeViewport {
     return getClosestImageId(volume, focalPoint, viewPlaneNormal);
   };
 
-  getRotation = (): number => 0;
-
   /**
    * Reset the viewport properties to the default values
    *
@@ -433,6 +446,12 @@ class VolumeViewport extends BaseVolumeViewport {
       volumeId: volumeActor.uid,
     };
 
+    const resetPan = true;
+    const resetZoom = true;
+    const resetToCenter = true;
+    const resetCameraRotation = true;
+    this.resetCamera(resetPan, resetZoom, resetToCenter, resetCameraRotation);
+
     triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
   }
 }

package/src/types/IViewport.ts

@@ -42,7 +42,7 @@ interface IViewport {
   isDisabled: boolean;
   /** The rendering state of this viewport */
   viewportStatus: ViewportStatus;
-  /** the rotation applied to the view */
+  /** get the rotation either from the camera provided or the viewport if not provided */
   getRotation: () => number;
   /** frameOfReferenceUID the viewport's default actor is rendering */
   getFrameOfReferenceUID: () => string;

package/src/types/IVolumeViewport.ts

@@ -136,7 +136,8 @@ export default interface IVolumeViewport extends IViewport {
   resetCamera(
     resetPan?: boolean,
     resetZoom?: boolean,
-    resetToCenter?: boolean
+    resetToCenter?: boolean,
+    resetRotation?: boolean
   ): boolean;
   /**
    * Sets the blendMode for actors of the viewport.

package/src/types/ViewportProperties.ts

@@ -16,6 +16,8 @@ type ViewportProperties = {
   colormap?: ColormapPublic;
   /** interpolation type */
   interpolationType?: InterpolationType;
+  /**Rotation of the camera */
+  rotation?: number;
 };
 
 export type { ViewportProperties };

package/src/types/VolumeViewportProperties.ts

@@ -1,4 +1,5 @@
 import { ViewportProperties } from './ViewportProperties';
+import { OrientationAxis } from '../enums';
 
 /**
  * Stack Viewport Properties
@@ -8,6 +9,8 @@ type VolumeViewportProperties = ViewportProperties & {
   preset?: string;
 
   slabThickness?: number;
+
+  orientation?: OrientationAxis;
 };
 
 export default VolumeViewportProperties;

package/src/utilities/getCurrentVolumeViewportSlice.ts

@@ -0,0 +1,166 @@
+import { glMatrix, mat4, vec3 } from 'gl-matrix';
+import { IVolumeViewport, Point3 } from '../types';
+import { transformIJKToCanvas } from './transformIJKToCanvas';
+import { transformCanvasToIJK } from './transformCanvasToIJK';
+
+/**
+ * Get the image data for the current slice rendered on the viewport. The image
+ * data returned is the full slice and not only the region that is visible on
+ * the viewport. It does not work for oblique views.
+ * @param viewport - Volume viewport
+ * @returns Slice image dataand  matrices to convert from volume
+ *   to slice and vice-versa
+ */
+function getCurrentVolumeViewportSlice(viewport: IVolumeViewport) {
+  const { dimensions, scalarData } = viewport.getImageData();
+  const { width: canvasWidth, height: canvasHeight } = viewport.getCanvas();
+
+  // Get three points from the canvas to help us identify the orientation of
+  // the slice. Using canvas width/height to get point far away for each other
+  // because points such as (0,0), (1,0) and (0,1) may be converted to the same
+  // ijk index when the image is zoomed in.
+  const ijkOriginPoint = transformCanvasToIJK(viewport, [0, 0]);
+  const ijkRowPoint = transformCanvasToIJK(viewport, [canvasWidth - 1, 0]);
+  const ijkColPoint = transformCanvasToIJK(viewport, [0, canvasHeight - 1]);
+
+  // Subtract the points to get the row and column vectors in index space
+  const ijkRowVec = vec3.sub(vec3.create(), ijkRowPoint, ijkOriginPoint);
+  const ijkColVec = vec3.sub(vec3.create(), ijkColPoint, ijkOriginPoint);
+  const ijkSliceVec = vec3.cross(vec3.create(), ijkRowVec, ijkColVec);
+
+  vec3.normalize(ijkRowVec, ijkRowVec);
+  vec3.normalize(ijkColVec, ijkColVec);
+  vec3.normalize(ijkSliceVec, ijkSliceVec);
+
+  // Any unit vector parallel to IJK have one component equal to 1 and
+  // the other two components equal to 0. If two of them are parallel
+  // the third one is also parallel
+  const maxIJKRowVec = Math.max(
+    Math.abs(ijkRowVec[0]),
+    Math.abs(ijkRowVec[1]),
+    Math.abs(ijkRowVec[2])
+  );
+  const maxIJKColVec = Math.max(
+    Math.abs(ijkColVec[0]),
+    Math.abs(ijkColVec[1]),
+    Math.abs(ijkColVec[2])
+  );
+
+  // Using glMatrix.equals() because the number may be not exactly equal to
+  // 1 due to rounding issues
+  if (!glMatrix.equals(1, maxIJKRowVec) || !glMatrix.equals(1, maxIJKColVec)) {
+    throw new Error('Livewire is not available for rotate/oblique viewports');
+  }
+
+  const [sx, sy, sz] = dimensions;
+
+  // All eight volume corners in index space
+  // prettier-ignore
+  const ijkCorners: Point3[] = [
+    [     0,        0,        0], // top-left-front
+    [sx - 1,        0,        0], // top-right-front
+    [     0,   sy - 1,        0], // bottom-left-front
+    [sx - 1,   sy - 1,        0], // bottom-right-front
+    [     0,        0,   sz - 1], // top-left-back
+    [sx - 1,        0,   sz - 1], // top-right-back
+    [     0,   sy - 1,   sz - 1], // bottom-left-back
+    [sx - 1,   sy - 1,   sz - 1], // bottom-right-back
+  ];
+
+  // Project the volume corners onto the canvas
+  const canvasCorners = ijkCorners.map((ijkCorner) =>
+    transformIJKToCanvas(viewport, ijkCorner)
+  );
+
+  // Calculate the AABB from the corners project onto the canvas
+  const canvasAABB = canvasCorners.reduce(
+    (aabb, canvasPoint) => {
+      aabb.minX = Math.min(aabb.minX, canvasPoint[0]);
+      aabb.minY = Math.min(aabb.minY, canvasPoint[1]);
+      aabb.maxX = Math.max(aabb.maxX, canvasPoint[0]);
+      aabb.maxY = Math.max(aabb.maxY, canvasPoint[1]);
+
+      return aabb;
+    },
+    { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity }
+  );
+
+  // Get the top-left, bottom-right and the diagonal vector of
+  // the slice in index space
+  const ijkTopLeft = transformCanvasToIJK(viewport, [
+    canvasAABB.minX,
+    canvasAABB.minY,
+  ]);
+  const ijkBottomRight = transformCanvasToIJK(viewport, [
+    canvasAABB.maxX,
+    canvasAABB.maxY,
+  ]);
+  const ijkDiagonal = vec3.sub(vec3.create(), ijkBottomRight, ijkTopLeft);
+
+  // prettier-ignore
+  const sliceToIndexMatrix = mat4.fromValues(
+      ijkRowVec[0],   ijkRowVec[1],   ijkRowVec[2],  0,
+      ijkColVec[0],   ijkColVec[1],   ijkColVec[2],  0,
+    ijkSliceVec[0], ijkSliceVec[1], ijkSliceVec[2],  0,
+     ijkTopLeft[0],  ijkTopLeft[1],  ijkTopLeft[2],  1
+  );
+
+  const indexToSliceMatrix = mat4.invert(mat4.create(), sliceToIndexMatrix);
+
+  // Dot the diagonal with row/column to find the image width/height
+  const sliceWidth = vec3.dot(ijkRowVec, ijkDiagonal) + 1;
+  const sliceHeight = vec3.dot(ijkColVec, ijkDiagonal) + 1;
+
+  // Create a TypedArray with same type from the original scalarData
+  const TypedArray = (scalarData as any).constructor;
+  const sliceData = new TypedArray(sliceWidth * sliceHeight);
+
+  // We need to know how many pixels to jump for every change in Z direction
+  const pixelsPerSlice = dimensions[0] * dimensions[1];
+
+  // Create two vectors to keep track of each row/column it is, reducing
+  // the amount of vec3 instances created and simplifying the math.
+  const ijkPixelRow = vec3.clone(ijkTopLeft);
+  const ijkPixelCol = vec3.create();
+
+  // Use an independent index to avoid multiple (x,y) to index conversions
+  let slicePixelIndex = 0;
+
+  for (let y = 0; y < sliceHeight; y++) {
+    vec3.copy(ijkPixelCol, ijkPixelRow);
+
+    for (let x = 0; x < sliceWidth; x++) {
+      const volumePixelIndex =
+        ijkPixelCol[2] * pixelsPerSlice +
+        ijkPixelCol[1] * dimensions[0] +
+        ijkPixelCol[0];
+
+      // It may never throw any "out of bounds" error but just to be safe
+      if (volumePixelIndex < scalarData.length) {
+        sliceData[slicePixelIndex] = scalarData[volumePixelIndex];
+      }
+
+      // Move to next slice pixel
+      slicePixelIndex++;
+
+      // Move to the next voxel
+      vec3.add(ijkPixelCol, ijkPixelCol, ijkRowVec);
+    }
+
+    // Move to the next row
+    vec3.add(ijkPixelRow, ijkPixelRow, ijkColVec);
+  }
+
+  return {
+    width: sliceWidth,
+    height: sliceHeight,
+    scalarData: sliceData,
+    sliceToIndexMatrix,
+    indexToSliceMatrix,
+  };
+}
+
+export {
+  getCurrentVolumeViewportSlice as default,
+  getCurrentVolumeViewportSlice,
+};

package/src/utilities/index.ts

@@ -26,6 +26,7 @@ import indexWithinDimensions from './indexWithinDimensions';
 import getVolumeViewportsContainingSameVolumes from './getVolumeViewportsContainingSameVolumes';
 import getViewportsWithVolumeId from './getViewportsWithVolumeId';
 import transformWorldToIndex from './transformWorldToIndex';
+import transformIndexToWorld from './transformIndexToWorld';
 import loadImageToCanvas from './loadImageToCanvas';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import renderToCanvasGPU from './renderToCanvasGPU';
@@ -39,6 +40,7 @@ import getImageSliceDataForVolumeViewport from './getImageSliceDataForVolumeView
 import { isImageActor, actorIsA } from './actorCheck';
 import getViewportsWithImageURI from './getViewportsWithImageURI';
 import getClosestStackImageIndexForPoint from './getClosestStackImageIndexForPoint';
+import getCurrentVolumeViewportSlice from './getCurrentVolumeViewportSlice';
 import calculateViewportsSpatialRegistration from './calculateViewportsSpatialRegistration';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
 import getViewportImageCornersInWorld from './getViewportImageCornersInWorld';
@@ -98,6 +100,7 @@ export {
   getVolumeViewportsContainingSameVolumes,
   getViewportsWithVolumeId,
   transformWorldToIndex,
+  transformIndexToWorld,
   loadImageToCanvas,
   renderToCanvasCPU,
   renderToCanvasGPU,
@@ -113,6 +116,7 @@ export {
   actorIsA,
   getViewportsWithImageURI,
   getClosestStackImageIndexForPoint,
+  getCurrentVolumeViewportSlice,
   calculateViewportsSpatialRegistration,
   spatialRegistrationMetadataProvider,
   getViewportImageCornersInWorld,

package/src/utilities/transformCanvasToIJK.ts

@@ -0,0 +1,18 @@
+import { IStackViewport, IVolumeViewport, Point2 } from '../types';
+import transformWorldToIndex from './transformWorldToIndex';
+
+/**
+ * Convert coordinates from canvas to index (volume) space
+ * @param viewport - Stack or Volume viewport
+ * @param ijkPoint - 2D point in canvas space
+ * @returns 3D point in index (volume) space
+ */
+export function transformCanvasToIJK(
+  viewport: IVolumeViewport | IStackViewport,
+  canvasPoint: Point2
+) {
+  const { imageData: vtkImageData } = viewport.getImageData();
+  const worldPoint = viewport.canvasToWorld(canvasPoint);
+
+  return transformWorldToIndex(vtkImageData, worldPoint);
+}

package/src/utilities/transformIJKToCanvas.ts

@@ -0,0 +1,18 @@
+import { IStackViewport, IVolumeViewport, Point3 } from '../types';
+import transformIndexToWorld from './transformIndexToWorld';
+
+/**
+ * Convert coordinates from index (volume) to canvas space
+ * @param viewport - Stack or Volume viewport
+ * @param ijkPoint - 3D point in index (volume) space
+ * @returns 2D point in canvas space
+ */
+export function transformIJKToCanvas(
+  viewport: IVolumeViewport | IStackViewport,
+  ijkPoint: Point3
+) {
+  const { imageData: vtkImageData } = viewport.getImageData();
+  const worldPoint = transformIndexToWorld(vtkImageData, ijkPoint);
+
+  return viewport.worldToCanvas(worldPoint);
+}

package/src/utilities/transformIndexToWorld.ts

@@ -0,0 +1,14 @@
+import type Point3 from '../types/Point3';
+
+/**
+ * Given an imageData object and a position in voxel space, return a point
+ * in world space.
+ *
+ * @param imageData - The image data object.
+ * @param voxelPos - Point in voxel space
+ * index space.
+ * @returns A point in world space.
+ */
+export default function transformIndexToWorld(imageData, voxelPos: Point3) {
+  return imageData.indexToWorld(voxelPos);
+}