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

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.5",
   "description": "",
   "main": "dist/umd/index.js",
-  "types": "dist/esm/index.d.ts",
+  "types": "dist/types",
   "module": "dist/esm/index.js",
   "repository": "https://github.com/cornerstonejs/cornerstone3D",
   "files": [
@@ -45,5 +45,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "deefd5fb773ca3eb6fc4f2047c15a2b1a3ac82de"
+  "gitHead": "0767e6b927df9f41cf6e59ad13837de383c15c05"
 }

package/src/RenderingEngine/StackViewport.ts

@@ -18,8 +18,9 @@ import {
   imageIdToURI,
   isImageActor,
   actorIsA,
+  imageRetrieveMetadataProvider,
 } from '../utilities';
-import {
+import type {
   Point2,
   Point3,
   VOIRange,
@@ -40,19 +41,21 @@ import {
   Mat3,
   ColormapRegistration,
   IImageCalibration,
+  IImagesLoader,
+  ImageLoadListener,
 } from '../types';
 import { ViewportInput } from '../types/IViewport';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
 import { getColormap } from './helpers/cpuFallback/colors/index';
 
-import { loadAndCacheImage } from '../loaders/imageLoader';
+import { loadAndCacheImage, ImageLoaderOptions } from '../loaders/imageLoader';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import {
   InterpolationType,
   RequestType,
   Events,
-  CalibrationTypes,
   VOILUTFunctionType,
+  ViewportStatus,
 } from '../enums';
 import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
@@ -77,7 +80,7 @@ import {
   ImagePixelModule,
   ImagePlaneModule,
 } from '../types';
-import ViewportStatus from '../enums/ViewportStatus';
+import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
 
 const EPSILON = 1; // Slice Thickness
 
@@ -114,7 +117,7 @@ type SetVOIOptions = {
  * is not available (or low performance). Read more about StackViewports in
  * the documentation section of this website.
  */
-class StackViewport extends Viewport implements IStackViewport {
+class StackViewport extends Viewport implements IStackViewport, IImagesLoader {
   private imageIds: Array<string>;
   // current imageIdIndex that is rendered in the viewport
   private currentImageIdIndex: number;
@@ -122,6 +125,10 @@ class StackViewport extends Viewport implements IStackViewport {
   private targetImageIdIndex: number;
   // setTimeout if the image is debounced to be loaded
   private debouncedTimeout: number;
+  /**
+   * The progressive retrieval configuration used for this viewport.
+   */
+  protected imagesLoader: IImagesLoader = this;
 
   // Viewport Properties
   private voiRange: VOIRange;
@@ -186,7 +193,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
   public setUseCPURendering(value: boolean) {
     this.useCPURendering = value;
-    this._configureRenderingPipeline();
+    this._configureRenderingPipeline(value);
   }
 
   static get useCustomRenderingPipeline(): boolean {
@@ -197,9 +204,9 @@ class StackViewport extends Viewport implements IStackViewport {
     this._configureRenderingPipeline();
   };
 
-  private _configureRenderingPipeline() {
+  private _configureRenderingPipeline(value?: boolean) {
     this.useNativeDataType = this._shouldUseNativeDataType();
-    this.useCPURendering = getShouldUseCPURendering();
+    this.useCPURendering = value ?? getShouldUseCPURendering();
 
     for (const [funcName, functions] of Object.entries(
       this.renderingPipelineFunctions
@@ -1433,6 +1440,17 @@ class StackViewport extends Viewport implements IStackViewport {
     this.imageIds = imageIds;
     this.currentImageIdIndex = currentImageIdIndex;
     this.targetImageIdIndex = currentImageIdIndex;
+    const imageRetrieveConfiguration = metaData.get(
+      imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION,
+      imageIds[currentImageIdIndex],
+      'stack'
+    );
+
+    this.imagesLoader = imageRetrieveConfiguration
+      ? (imageRetrieveConfiguration.create || createProgressive)(
+          imageRetrieveConfiguration
+        )
+      : this;
 
     // reset the stack
     this.stackInvalidated = true;
@@ -1582,15 +1600,13 @@ class StackViewport extends Viewport implements IStackViewport {
    * @param imageId - string representing the imageId
    * @param imageIdIndex - index of the imageId in the imageId list
    */
-  private async _loadAndDisplayImage(
+  private _loadAndDisplayImage(
     imageId: string,
     imageIdIndex: number
   ): Promise<string> {
-    await (this.useCPURendering
+    return this.useCPURendering
       ? this._loadAndDisplayImageCPU(imageId, imageIdIndex)
-      : this._loadAndDisplayImageGPU(imageId, imageIdIndex));
-
-    return imageId;
+      : this._loadAndDisplayImageGPU(imageId, imageIdIndex);
   }
 
   private _loadAndDisplayImageCPU(
@@ -1720,7 +1736,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
       const priority = -5;
       const requestType = RequestType.Interaction;
-      const additionalDetails = { imageId };
+      const additionalDetails = { imageId, imageIdIndex };
       const options = {
         preScale: {
           enabled: true,
@@ -1745,113 +1761,132 @@ class StackViewport extends Viewport implements IStackViewport {
     });
   }
 
-  private _loadAndDisplayImageGPU(imageId: string, imageIdIndex: number) {
-    return new Promise((resolve, reject) => {
-      // 1. Load the image using the Image Loader
-      function successCallback(image, imageIdIndex, imageId) {
-        // Todo: trigger an event to allow applications to hook into END of loading state
-        // Currently we use loadHandlerManagers for this
-        // Perform this check after the image has finished loading
-        // in case the user has already scrolled away to another image.
-        // In that case, do not render this image.
-        if (this.currentImageIdIndex !== imageIdIndex) {
-          return;
-        }
+  public successCallback(imageId, image) {
+    const imageIdIndex = this.imageIds.indexOf(imageId);
+    // Todo: trigger an event to allow applications to hook into END of loading state
+    // Currently we use loadHandlerManagers for this
+    // Perform this check after the image has finished loading
+    // in case the user has already scrolled away to another image.
+    // In that case, do not render this image.
+    if (this.currentImageIdIndex !== imageIdIndex) {
+      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
-        const csImgFrame = this.csImage?.imageFrame;
-        const imgFrame = image?.imageFrame;
-
-        // if a volume is decached into images then the imageFrame will be undefined
-        if (
-          csImgFrame?.photometricInterpretation !==
-            imgFrame?.photometricInterpretation ||
-          this.csImage?.photometricInterpretation !==
-            image?.photometricInterpretation
-        ) {
-          this.stackInvalidated = true;
-        }
+    // If Photometric Interpretation is not the same for the next image we are trying to load
+    // invalidate the stack to recreate the VTK imageData
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const csImgFrame = (<any>this.csImage)?.imageFrame;
+    const imgFrame = image?.imageFrame;
 
-        this._setCSImage(image);
+    // if a volume is decached into images then the imageFrame will be undefined
+    if (
+      csImgFrame?.photometricInterpretation !==
+        imgFrame?.photometricInterpretation ||
+      this.csImage?.photometricInterpretation !==
+        image?.photometricInterpretation
+    ) {
+      this.stackInvalidated = true;
+    }
 
-        const eventDetail: EventTypes.StackNewImageEventDetail = {
-          image,
-          imageId,
-          imageIdIndex,
-          viewportId: this.id,
-          renderingEngineId: this.renderingEngineId,
-        };
+    this._setCSImage(image);
 
-        triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
-        this._updateActorToDisplayImageId(image);
+    const eventDetail: EventTypes.StackNewImageEventDetail = {
+      image,
+      imageId,
+      imageIdIndex,
+      viewportId: this.id,
+      renderingEngineId: this.renderingEngineId,
+    };
 
-        // Trigger the image to be drawn on the next animation frame
-        this.render();
+    triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
+    this._updateActorToDisplayImageId(image);
 
-        // Update the viewport's currentImageIdIndex to reflect the newly
-        // rendered image
-        this.currentImageIdIndex = imageIdIndex;
-        resolve(imageId);
-      }
+    // Trigger the image to be drawn on the next animation frame
+    this.render();
 
-      function errorCallback(error, imageIdIndex, imageId) {
-        const eventDetail = {
-          error,
-          imageIdIndex,
-          imageId,
-        };
+    // Update the viewport's currentImageIdIndex to reflect the newly
+    // rendered image
+    this.currentImageIdIndex = imageIdIndex;
+  }
 
-        triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
-        reject(error);
-      }
+  public errorCallback(imageId, permanent, error) {
+    if (!permanent) {
+      return;
+    }
+    const imageIdIndex = this.imageIds.indexOf(imageId);
+    const eventDetail = {
+      error,
+      imageIdIndex,
+      imageId,
+    };
+
+    triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+  }
+
+  public getLoaderImageOptions(imageId: string) {
+    const imageIdIndex = this.imageIds.indexOf(imageId);
+    const { transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+
+    /**
+     * If use16bittexture is specified, the CSWIL will automatically choose the
+     * array type when no targetBuffer is provided. When CSWIL is initialized,
+     * the use16bit should match the settings of cornerstone3D (either preferSizeOverAccuracy
+     * or norm16 textures need to be enabled)
+     *
+     * If use16bittexture is not specified, we force the Float32Array for now
+     */
+    const additionalDetails = { imageId, imageIdIndex };
+    const options = {
+      targetBuffer: {
+        type: this.useNativeDataType ? undefined : 'Float32Array',
+      },
+      preScale: {
+        enabled: true,
+      },
+      useRGBA: false,
+      transferSyntaxUID,
+      priority: 5,
+      requestType: RequestType.Interaction,
+      additionalDetails,
+    };
+    return options;
+  }
+
+  public loadImages(
+    imageIds: string[],
+    listener: ImageLoadListener
+  ): Promise<unknown> {
+    return Promise.allSettled(
+      imageIds.map((imageId) => {
+        const options = this.getLoaderImageOptions(
+          imageId
+        ) as ImageLoaderOptions;
 
-      function sendRequest(imageId, imageIdIndex, options) {
         return loadAndCacheImage(imageId, options).then(
           (image) => {
-            successCallback.call(this, image, imageIdIndex, imageId);
+            listener.successCallback(imageId, image);
+            return imageId;
           },
           (error) => {
-            errorCallback.call(this, error, imageIdIndex, imageId);
+            listener.errorCallback(imageId, true, error);
+            return imageId;
           }
         );
-      }
-
-      /**
-       * If use16bittexture is specified, the CSWIL will automatically choose the
-       * array type when no targetBuffer is provided. When CSWIL is initialized,
-       * the use16bit should match the settings of cornerstone3D (either preferSizeOverAccuracy
-       * or norm16 textures need to be enabled)
-       *
-       * If use16bittexture is not specified, we force the Float32Array for now
-       */
-      const priority = -5;
-      const requestType = RequestType.Interaction;
-      const additionalDetails = { imageId };
-      const options = {
-        targetBuffer: {
-          type: this.useNativeDataType ? undefined : 'Float32Array',
-        },
-        preScale: {
-          enabled: true,
-        },
-        useRGBA: false,
-      };
+      })
+    );
+  }
 
-      const eventDetail: EventTypes.PreStackNewImageEventDetail = {
-        imageId,
-        imageIdIndex,
-        viewportId: this.id,
-        renderingEngineId: this.renderingEngineId,
-      };
-      triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
+  private _loadAndDisplayImageGPU(imageId: string, imageIdIndex: number) {
+    const eventDetail: EventTypes.PreStackNewImageEventDetail = {
+      imageId,
+      imageIdIndex,
+      viewportId: this.id,
+      renderingEngineId: this.renderingEngineId,
+    };
+    triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
 
-      imageLoadPoolManager.addRequest(
-        sendRequest.bind(this, imageId, imageIdIndex, options),
-        requestType,
-        additionalDetails,
-        priority
-      );
+    return this.imagesLoader.loadImages([imageId], this).then((v) => {
+      return imageId;
     });
   }
 
@@ -2144,7 +2179,7 @@ class StackViewport extends Viewport implements IStackViewport {
    * Loads the image based on the provided imageIdIndex
    * @param imageIdIndex - number represents imageId index
    */
-  private async _setImageIdIndex(imageIdIndex: number): Promise<string> {
+  private _setImageIdIndex(imageIdIndex: number): Promise<string> {
     if (imageIdIndex >= this.imageIds.length) {
       throw new Error(
         `ImageIdIndex provided ${imageIdIndex} is invalid, the stack only has ${this.imageIds.length} elements`
@@ -2158,12 +2193,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
     // Todo: trigger an event to allow applications to hook into START of loading state
     // Currently we use loadHandlerManagers for this
-    const imageId = await this._loadAndDisplayImage(
-      this.imageIds[imageIdIndex],
-      imageIdIndex
-    );
-
-    return imageId;
+    return this._loadAndDisplayImage(this.imageIds[imageIdIndex], imageIdIndex);
   }
 
   private resetCameraCPU(resetPan, resetZoom) {
@@ -2271,18 +2301,18 @@ class StackViewport extends Viewport implements IStackViewport {
    * @param imageIdIndex - number represents imageId index in the list of
    * provided imageIds in setStack
    */
-  public async setImageIdIndex(imageIdIndex: number): Promise<string> {
+  public setImageIdIndex(imageIdIndex: number): Promise<string> {
     this._throwIfDestroyed();
 
     // If we are already on this imageId index, stop here
     if (this.currentImageIdIndex === imageIdIndex) {
-      return this.getCurrentImageId();
+      return Promise.resolve(this.getCurrentImageId());
     }
 
     // Otherwise, get the imageId and attempt to display it
-    const imageId = this._setImageIdIndex(imageIdIndex);
+    const imageIdPromise = this._setImageIdIndex(imageIdIndex);
 
-    return imageId;
+    return imageIdPromise;
   }
 
   /**

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/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.