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

package/{dist/esm/RenderingEngine/vtkClasses/vtkSlabCamera.d.ts → src/RenderingEngine/vtkClasses/vtkSlabCamera.ts}

@@ -1,4 +1,7 @@
-import type { mat4 } from 'gl-matrix';
+import macro from '@kitware/vtk.js/macros';
+import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import { vec3, mat4 } from 'gl-matrix';
 import type { vtkObject } from '@kitware/vtk.js/interfaces';
 
 // Copied from VTKCamera
@@ -744,6 +747,10 @@ export interface vtkSlabCamera extends vtkObject {
   setIsPerformingCoordinateTransformation(status: boolean): void;
 }
 
+const DEFAULT_VALUES = {
+  isPerformingCoordinateTransformation: false,
+};
+
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkRenderer characteristics.
  *
@@ -751,11 +758,20 @@ export interface vtkSlabCamera extends vtkObject {
  * @param model - object on which data structure will be bounds (protected)
  * @param initialValues -
  */
-export function extend(
+function extend(
   publicAPI: any,
   model: any,
-  initialValues?: ICameraInitialValues
-): void;
+  initialValues: ICameraInitialValues = {}
+): void {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkCamera.extend(publicAPI, model, initialValues);
+
+  macro.setGet(publicAPI, model, ['isPerformingCoordinateTransformation']);
+
+  // Object methods
+  vtkSlabCamera(publicAPI, model);
+}
 
 /**
  * Method use to create a new instance of vtkCamera with its focal point at the origin,
@@ -763,9 +779,8 @@ export function extend(
  * and the clipping range is (.1,1000).
  * @param initialValues - for pre-setting some of its content
  */
-export function newInstance(
-  initialValues?: ICameraInitialValues
-): vtkSlabCamera;
+const newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera =
+  macro.newInstance(extend, 'vtkSlabCamera');
 
 /**
  * vtkCamera is a virtual camera for 3D rendering. It provides methods
@@ -774,8 +789,134 @@ export function newInstance(
  * complex methods allow the manipulation of the computer graphics model
  * including view up vector, clipping planes, and camera perspective.
  */
-export declare const vtkSlabCamera: {
-  newInstance: typeof newInstance;
-  extend: typeof extend;
-};
-export default vtkSlabCamera;
+
+/**
+ * vtkSlabCamera - A derived class of the core vtkCamera class
+ *
+ * This customization is necesssary because when we do coordinate transformations
+ * we need to set the cRange between [d, d + 0.1],
+ * where d is distance between the camera position and the focal point.
+ * While when we render we set to the clippingRange [0.01, d * 2],
+ * where d is the calculated from the bounds of all the actors.
+ *
+ * @param {*} publicAPI The public API to extend
+ * @param {*} model The private model to extend.
+ */
+function vtkSlabCamera(publicAPI, model) {
+  model.classHierarchy.push('vtkSlabCamera');
+
+  // Set up private variables and methods
+  const tmpMatrix = mat4.identity(new Float64Array(16) as unknown as mat4);
+  const tmpvec1 = new Float64Array(3) as unknown as vec3;
+
+  /**
+   * getProjectionMatrix - A fork of vtkCamera's getProjectionMatrix method.
+   * This fork performs most of the same actions, but define crange around
+   * model.distance when doing coordinate transformations.
+   */
+  publicAPI.getProjectionMatrix = (aspect, nearz, farz) => {
+    const result = mat4.create();
+
+    if (model.projectionMatrix) {
+      const scale = 1 / model.physicalScale;
+      vec3.set(tmpvec1, scale, scale, scale);
+
+      mat4.copy(result, model.projectionMatrix);
+      mat4.scale(result, result, tmpvec1);
+      mat4.transpose(result, result);
+      return result;
+    }
+
+    mat4.identity(tmpMatrix);
+
+    let cRange0 = model.clippingRange[0];
+    let cRange1 = model.clippingRange[1];
+    if (model.isPerformingCoordinateTransformation) {
+      /**
+       * NOTE: this is necessary because we want the coordinate transformation
+       * respect to the view plane (plane orthogonal to the camera and passing to
+       * the focal point).
+       *
+       * When vtk.js computes the coordinate transformations, it simply uses the
+       * camera matrix (no ray casting).
+       *
+       * However for the volume viewport the clipping range is set to be
+       * (-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE).
+       * The clipping range is used in the camera method getProjectionMatrix().
+       * The projection matrix is used then for viewToWorld/worldToView methods of
+       * the renderer. This means that vkt.js will not return the coordinates of
+       * the point on the view plane (i.e. the depth coordinate will corresponded
+       * to the focal point).
+       *
+       * Therefore the clipping range has to be set to (distance, distance + 0.01),
+       * where now distance is the distance between the camera position and focal
+       * point. This is done internally, in our camera customization when the flag
+       * isPerformingCoordinateTransformation is set to true.
+       */
+      cRange0 = model.distance;
+      cRange1 = model.distance + 0.1;
+    }
+
+    const cWidth = cRange1 - cRange0;
+    const cRange = [
+      cRange0 + ((nearz + 1) * cWidth) / 2.0,
+      cRange0 + ((farz + 1) * cWidth) / 2.0,
+    ];
+
+    if (model.parallelProjection) {
+      // set up a rectangular parallelipiped
+      const width = model.parallelScale * aspect;
+      const height = model.parallelScale;
+
+      const xmin = (model.windowCenter[0] - 1.0) * width;
+      const xmax = (model.windowCenter[0] + 1.0) * width;
+      const ymin = (model.windowCenter[1] - 1.0) * height;
+      const ymax = (model.windowCenter[1] + 1.0) * height;
+
+      mat4.ortho(tmpMatrix, xmin, xmax, ymin, ymax, cRange[0], cRange[1]);
+      mat4.transpose(tmpMatrix, tmpMatrix);
+    } else if (model.useOffAxisProjection) {
+      throw new Error('Off-Axis projection is not supported at this time');
+    } else {
+      const tmp = Math.tan(vtkMath.radiansFromDegrees(model.viewAngle) / 2.0);
+      let width;
+      let height;
+      if (model.useHorizontalViewAngle === true) {
+        width = cRange0 * tmp;
+        height = (cRange0 * tmp) / aspect;
+      } else {
+        width = cRange0 * tmp * aspect;
+        height = cRange0 * tmp;
+      }
+
+      const xmin = (model.windowCenter[0] - 1.0) * width;
+      const xmax = (model.windowCenter[0] + 1.0) * width;
+      const ymin = (model.windowCenter[1] - 1.0) * height;
+      const ymax = (model.windowCenter[1] + 1.0) * height;
+      const znear = cRange[0];
+      const zfar = cRange[1];
+
+      tmpMatrix[0] = (2.0 * znear) / (xmax - xmin);
+      tmpMatrix[5] = (2.0 * znear) / (ymax - ymin);
+      tmpMatrix[2] = (xmin + xmax) / (xmax - xmin);
+      tmpMatrix[6] = (ymin + ymax) / (ymax - ymin);
+      tmpMatrix[10] = -(znear + zfar) / (zfar - znear);
+      tmpMatrix[14] = -1.0;
+      tmpMatrix[11] = (-2.0 * znear * zfar) / (zfar - znear);
+      tmpMatrix[15] = 0.0;
+    }
+
+    mat4.copy(result, tmpMatrix);
+
+    return result;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };
+export { newInstance, extend };

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] as object)
+        : null
     );
     Object.seal(
       Object.defineProperty(this, DICTIONARY, {

package/src/cache/cache.ts

@@ -377,7 +377,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'
           );

package/src/enums/Events.ts

@@ -85,12 +85,21 @@ enum Events {
    */
   IMAGE_VOLUME_LOADING_COMPLETED = 'CORNERSTONE_IMAGE_VOLUME_LOADING_COMPLETED',
   /**
-   * Triggers on the eventTarget when the image has successfully loaded by imageLoaders
+   * Triggers on the eventTarget when the image has successfully loaded by imageLoaders.
+   * This event may be fired multiple times for different statuses as the image data gets loaded.
    *
    * Make use of {@link EventTypes.ImageLoadedEvent | ImageLoaded Event Type } for typing your event listeners for IMAGE_LOADED event,
    * and see what event detail is included in {@link EventTypes.ImageLoadedEventDetail | ImageLoaded Event Detail }
    */
   IMAGE_LOADED = 'CORNERSTONE_IMAGE_LOADED',
+  /**
+   * Triggers on the eventTarget when progressive loading stages are completed.
+   * That is, the stage is complete for all images included in that stage (which
+   * can be zero).  If you need individual image load information related to
+   * the stage, see the status attribute on the IMAGE_LOADED event - which has
+   * the status of the image, but not the actual stage that loaded it.
+   */
+  IMAGE_RETRIEVAL_STAGE = 'CORNERSTONE_IMAGE_RETRIEVAL_STAGE',
   /**
    * Triggers on the eventTarget when the image has failed loading by imageLoaders
    *
@@ -176,14 +185,6 @@ enum Events {
    * and see what event detail is included in {@link EventTypes.ImageSpacingCalibratedEventDetail | ImageSpacingCalibrated Event Detail }
    */
   IMAGE_SPACING_CALIBRATED = 'CORNERSTONE_IMAGE_SPACING_CALIBRATED',
-  /**
-   * Triggers on the eventTarget when there is a progress in the image load process. Note: this event
-   * is being used in the dicom-image-loader repository. See {@link https://github.com/cornerstonejs/cornerstoneDICOMImageLoader/blob/master/src/imageLoader/internal/xhrRequest.js | here}
-   *
-   * Make use of {@link EventTypes.ImageLoadProgress | ImageLoadProgress Event Type } for typing your event listeners for IMAGE_LOAD_PROGRESS event,
-   * and see what event detail is included in {@link EventTypes.ImageLoadProgressEventDetail | ImageLoadProgress Event Detail }
-   */
-  IMAGE_LOAD_PROGRESS = 'CORNERSTONE_IMAGE_LOAD_PROGRESS',
 
   /**
    * Triggers on the event target when a new stack is set on its stack viewport.

package/src/enums/ImageQualityStatus.ts

@@ -0,0 +1,37 @@
+/**
+ * Status of a frame as it gets loaded.  This is ordered, with lower
+ * values being more lossy, and higher values being less lossy.
+ */
+enum ImageQualityStatus {
+  /**
+   *  Replicate is a duplicated image, from some larger distance
+   */
+  FAR_REPLICATE = 1,
+
+  // Skipping a value here and after the next replicate to allow for interpolation
+  // enum values.
+
+  /**
+   * Adjacent replicate is a duplicated image of a nearby image
+   */
+  ADJACENT_REPLICATE = 3,
+
+  /**
+   * Sub resolution images are encodings of smaller than full resolution
+   * images.  The encoding may or may not be lossy, but the lower resolution
+   * means it has lost information already compared to full resolution/lossless.
+   */
+  SUBRESOLUTION = 6,
+
+  /**
+   *  Lossy images, encoded with a lossy encoding, but full resolution or size.
+   */
+  LOSSY = 7,
+  /**
+   *  Full resolution means the image is full resolution/complete data/lossless
+   * (or at least as lossless as the image is going to get)
+   */
+  FULL_RESOLUTION = 8,
+}
+
+export default ImageQualityStatus;

package/src/enums/index.ts

@@ -11,6 +11,7 @@ import VOILUTFunctionType from './VOILUTFunctionType';
 import DynamicOperatorType from './DynamicOperatorType';
 import CalibrationTypes from './CalibrationTypes';
 import ViewportStatus from './ViewportStatus';
+import ImageQualityStatus from './ImageQualityStatus';
 
 export {
   Events,
@@ -26,4 +27,5 @@ export {
   VOILUTFunctionType,
   DynamicOperatorType,
   ViewportStatus,
+  ImageQualityStatus,
 };

package/src/index.ts

@@ -48,7 +48,15 @@ import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
-import * as Types from './types';
+import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
+import type * as Types from './types';
+import {
+  IRetrieveConfiguration,
+  IImagesLoader,
+  RetrieveOptions,
+  RetrieveStage,
+  ImageLoadListener,
+} from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader'; // since it is used by CSWIL right now
 
@@ -59,7 +67,15 @@ import {
   addVolumesToViewports,
 } from './RenderingEngine/helpers';
 
-export type { Types };
+// Add new types here so that they can be imported singly as required.
+export type {
+  Types,
+  IRetrieveConfiguration,
+  RetrieveOptions,
+  RetrieveStage,
+  ImageLoadListener,
+  IImagesLoader,
+};
 
 export {
   // init
@@ -122,4 +138,5 @@ export {
   resetUseSharedArrayBuffer,
   // Geometry Loader
   geometryLoader,
+  ProgressiveRetrieveImages,
 };