@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

package/src/RenderingEngine/helpers/setDefaultVolumeVOI.ts

@@ -1,251 +0,0 @@
-import {
-  VolumeActor,
-  IImageVolume,
-  VOIRange,
-  ScalingParameters,
-} from '../../types';
-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;
-
-/**
- * It sets the default window level of an image volume based on the VOI.
- * It first look for the VOI in the metadata and if it is not found, it
- * loads the middle slice image (middle imageId) and based on its min
- * and max pixel values, it calculates the VOI.
- * Finally it sets the VOI on the volumeActor transferFunction
- * @param volumeActor - The volume actor
- * @param imageVolume - The image volume that we want to set the VOI for.
- * @param useNativeDataType -  The image data type is native or Float32Array
- */
-async function setDefaultVolumeVOI(
-  volumeActor: VolumeActor,
-  imageVolume: IImageVolume,
-  useNativeDataType: boolean
-): Promise<void> {
-  let voi = getVOIFromMetadata(imageVolume);
-
-  if (!voi && imageVolume?.imageIds?.length) {
-    voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
-    voi = handlePreScaledVolume(imageVolume, voi);
-  }
-  // if (!voi || voi.lower === undefined || voi.upper === undefined) {
-  //   throw new Error(
-  //     'Could not get VOI from metadata, nor from the min max of the image middle slice'
-  //   );
-  // }
-  if (
-    (voi?.lower === 0 && voi?.upper === 0) ||
-    voi?.lower === undefined ||
-    voi?.upper === undefined
-  ) {
-    return;
-  }
-
-  volumeActor
-    .getProperty()
-    .getRGBTransferFunction(0)
-    .setMappingRange(voi.lower, voi.upper);
-}
-
-function handlePreScaledVolume(imageVolume: IImageVolume, voi: VOIRange) {
-  const imageIds = imageVolume.imageIds;
-  const imageIdIndex = Math.floor(imageIds.length / 2);
-  const imageId = imageIds[imageIdIndex];
-
-  const generalSeriesModule =
-    metaData.get('generalSeriesModule', imageId) || {};
-
-  /**
-   * If the volume is prescaled and the modality is PT Sometimes you get super high
-   * values at the peak and it skews the min/max so nothing useful is displayed
-   * Therefore, we follow the majority of other viewers and we set the min/max
-   * for the scaled PT to be 0, 5
-   */
-  if (_isCurrentImagePTPrescaled(generalSeriesModule.modality, imageVolume)) {
-    return {
-      lower: 0,
-      upper: 5,
-    };
-  }
-
-  return voi;
-}
-
-/**
- * Get the VOI from the metadata of the middle slice of the image volume or the metadata of the image volume
- * It checks the metadata for the VOI and if it is not found, it returns null
- *
- * @param imageVolume - The image volume that we want to get the VOI from.
- * @returns VOIRange with lower and upper values
- */
-function getVOIFromMetadata(imageVolume: IImageVolume): VOIRange {
-  const { imageIds, metadata } = imageVolume;
-  let voi;
-  if (imageIds.length) {
-    const imageIdIndex = Math.floor(imageIds.length / 2);
-    const imageId = imageIds[imageIdIndex];
-    const voiLutModule = metaData.get('voiLutModule', imageId);
-    if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
-      const { windowWidth, windowCenter } = voiLutModule;
-      voi = {
-        windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
-        windowCenter: Array.isArray(windowCenter)
-          ? windowCenter[0]
-          : windowCenter,
-      };
-    }
-  } else {
-    voi = metadata?.voiLut?.[0];
-  }
-  if (voi) {
-    const { lower, upper } = windowLevel.toLowHighRange(
-      Number(voi.windowWidth),
-      Number(voi.windowCenter)
-    );
-    return {
-      lower,
-      upper,
-    };
-  }
-}
-
-/**
- * It loads the middle slice image (middle imageId) and based on its min
- * and max pixel values, it calculates the VOI.
- *
- * @param imageVolume - The image volume that we want to get the VOI from.
- * @param useNativeDataType -  The image data type is native or Float32Array
- * @returns The VOIRange with lower and upper values
- */
-async function getVOIFromMinMax(
-  imageVolume: IImageVolume,
-  useNativeDataType: boolean
-): Promise<VOIRange> {
-  const { imageIds } = imageVolume;
-  const scalarData = imageVolume.getScalarData();
-
-  // Get the middle image from the list of imageIds
-  const imageIdIndex = Math.floor(imageIds.length / 2);
-  const imageId = imageVolume.imageIds[imageIdIndex];
-  const generalSeriesModule =
-    metaData.get('generalSeriesModule', imageId) || {};
-  const { modality } = generalSeriesModule;
-  const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-
-  const numImages = imageIds.length;
-  const bytesPerImage = scalarData.byteLength / numImages;
-  const voxelsPerImage = scalarData.length / numImages;
-  const bytePerPixel = scalarData.BYTES_PER_ELEMENT;
-
-  const scalingParameters: ScalingParameters = {
-    rescaleSlope: modalityLutModule.rescaleSlope,
-    rescaleIntercept: modalityLutModule.rescaleIntercept,
-    modality,
-  };
-
-  let scalingParametersToUse;
-  if (modality === 'PT') {
-    const suvFactor = metaData.get('scalingModule', imageId);
-
-    if (suvFactor) {
-      scalingParametersToUse = {
-        ...scalingParameters,
-        suvbw: suvFactor.suvbw,
-      };
-    }
-  }
-
-  const byteOffset = imageIdIndex * bytesPerImage;
-
-  const options = {
-    targetBuffer: {
-      type: useNativeDataType ? undefined : 'Float32Array',
-    },
-    priority: PRIORITY,
-    requestType: REQUEST_TYPE,
-    useNativeDataType,
-    preScale: {
-      enabled: true,
-      scalingParameters: scalingParametersToUse,
-    },
-  };
-
-  // Loading the middle slice image for a volume has two scenarios, the first one is that
-  // uses the same volumeLoader which might not resolve to an image (since for performance
-  // reasons volumes' pixelData is set via offset and length on the volume arrayBuffer
-  // when each slice is loaded). The second scenario is that the image might not reach
-  // to the volumeLoader, and an already cached image (with Image object) is used
-  // 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.
-  // 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 (!imageVolume.referencedImageIds?.length) {
-    // we should ignore the cache here,
-    // since we want to load the image from with the most
-    // recent prescale settings
-    image = await loadAndCacheImage(imageId, { ...options, ignoreCache: true });
-  }
-
-  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);
-
-  return {
-    lower: min,
-    upper: max,
-  };
-}
-
-function _getImageScalarDataFromImageVolume(
-  imageVolume,
-  byteOffset,
-  bytePerPixel,
-  voxelsPerImage
-) {
-  const { scalarData } = imageVolume;
-  const { buffer } = scalarData;
-  if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
-    byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
-  }
-
-  const TypedArray = scalarData.constructor;
-  const imageScalarData = new TypedArray(voxelsPerImage);
-
-  const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
-
-  imageScalarData.set(volumeBufferView);
-
-  return imageScalarData;
-}
-
-function _isCurrentImagePTPrescaled(modality, imageVolume) {
-  if (modality !== 'PT' || !imageVolume.isPreScaled) {
-    return false;
-  }
-
-  if (!imageVolume.scaling?.PT.suvbw) {
-    return false;
-  }
-
-  return true;
-}
-
-export default setDefaultVolumeVOI;

package/src/RenderingEngine/helpers/setVolumesForViewports.ts

@@ -1,54 +0,0 @@
-import BaseVolumeViewport from '../BaseVolumeViewport';
-import type {
-  IVolumeInput,
-  IRenderingEngine,
-  IVolumeViewport,
-} from '../../types';
-
-/**
- * Similar to {@link addVolumesToViewports} it adds volumes to viewports; however,
- * this method will Set the volumes on the viewports which means that the previous
- * volumes will be removed.
- *
- * @param renderingEngine - The rendering engine to use to get viewports from
- * @param volumeInputs - Array of volume inputs including volumeId. Other properties
- * such as visibility, callback, blendMode, slabThickness are optional
- * @param viewportIds - Array of viewport IDs to add the volume to
- * @param immediateRender - If true, the volumes will be rendered immediately
- * @returns A promise that resolves when all volumes have been added
- */
-async function setVolumesForViewports(
-  renderingEngine: IRenderingEngine,
-  volumeInputs: Array<IVolumeInput>,
-  viewportIds: Array<string>,
-  immediateRender = false,
-  suppressEvents = false
-): Promise<void> {
-  // Check if all viewports are volumeViewports
-  viewportIds.forEach((viewportId) => {
-    const viewport = renderingEngine.getViewport(viewportId);
-
-    if (!viewport) {
-      throw new Error(`Viewport with Id ${viewportId} does not exist`);
-    }
-
-    // if not instance of BaseVolumeViewport, throw
-    if (!(viewport instanceof BaseVolumeViewport)) {
-      throw new Error(
-        'setVolumesForViewports only supports VolumeViewport and VolumeViewport3D'
-      );
-    }
-  });
-
-  const setVolumePromises = viewportIds.map(async (viewportId) => {
-    const viewport = renderingEngine.getViewport(viewportId) as IVolumeViewport;
-
-    await viewport.setVolumes(volumeInputs, immediateRender, suppressEvents);
-  });
-
-  await Promise.all(setVolumePromises);
-
-  return;
-}
-
-export default setVolumesForViewports;

package/src/RenderingEngine/helpers/viewportTypeToViewportClass.ts

@@ -1,16 +0,0 @@
-// TODO -> Eventually we'll need to register to this list
-import StackViewport from '../StackViewport';
-import VolumeViewport from '../VolumeViewport';
-import ViewportType from '../../enums/ViewportType';
-import VolumeViewport3D from '../VolumeViewport3D';
-import VideoViewport from '../VideoViewport';
-
-const viewportTypeToViewportClass = {
-  [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
-  [ViewportType.PERSPECTIVE]: VolumeViewport,
-  [ViewportType.STACK]: StackViewport,
-  [ViewportType.VOLUME_3D]: VolumeViewport3D,
-  [ViewportType.VIDEO]: VideoViewport,
-};
-
-export default viewportTypeToViewportClass;

package/src/RenderingEngine/helpers/viewportTypeUsesCustomRenderingPipeline.ts

@@ -1,7 +0,0 @@
-import viewportTypeToViewportClass from './viewportTypeToViewportClass';
-
-export default function viewportTypeUsesCustomRenderingPipeline(
-  viewportType: string
-) {
-  return viewportTypeToViewportClass[viewportType].useCustomRenderingPipeline;
-}

package/src/RenderingEngine/helpers/volumeNewImageEventDispatcher.ts

@@ -1,75 +0,0 @@
-import {
-  getImageSliceDataForVolumeViewport,
-  triggerEvent,
-} from '../../utilities';
-import { EventTypes } from '../../types';
-import { Events } from '../../enums';
-import { getRenderingEngine } from '../getRenderingEngine';
-import BaseVolumeViewport from '../BaseVolumeViewport';
-
-// Keeping track of previous imageIndex for each viewportId
-type VolumeImageState = Record<string, number>;
-
-const state: VolumeImageState = {};
-
-export function resetVolumeNewImageState(viewportId: string): void {
-  if (state[viewportId] !== undefined) {
-    delete state[viewportId];
-  }
-}
-
-/**
- * It captures the camera modified event and with the camera focal point and viewPlaneNomad
- * it calculates the image index in the view direction. Finally it triggers
- * a VOLUME_NEW_IMAGE event with the image index.
- *
- * @internal
- *
- * @param cameraEvent - The camera modified event
- * @param viewportImageData - The image data of the viewport
- */
-function volumeNewImageEventDispatcher(
-  cameraEvent: EventTypes.CameraModifiedEvent
-): void {
-  const { renderingEngineId, viewportId } = cameraEvent.detail;
-  const renderingEngine = getRenderingEngine(renderingEngineId);
-  const viewport = renderingEngine.getViewport(viewportId);
-
-  if (!(viewport instanceof BaseVolumeViewport)) {
-    throw new Error(
-      `volumeNewImageEventDispatcher: viewport is not a BaseVolumeViewport`
-    );
-  }
-
-  if (state[viewport.id] === undefined) {
-    state[viewport.id] = 0;
-  }
-
-  const sliceData = getImageSliceDataForVolumeViewport(viewport);
-
-  if (!sliceData) {
-    console.warn(
-      `volumeNewImageEventDispatcher: sliceData is undefined for viewport ${viewport.id}`
-    );
-    return;
-  }
-
-  const { numberOfSlices, imageIndex } = sliceData;
-
-  if (state[viewport.id] === imageIndex) {
-    return;
-  }
-
-  state[viewport.id] = imageIndex;
-
-  const eventDetail: EventTypes.VolumeNewImageEventDetail = {
-    imageIndex,
-    viewportId,
-    renderingEngineId,
-    numberOfSlices,
-  };
-
-  triggerEvent(viewport.element, Events.VOLUME_NEW_IMAGE, eventDetail);
-}
-
-export default volumeNewImageEventDispatcher;

package/src/RenderingEngine/index.ts

@@ -1,23 +0,0 @@
-import RenderingEngine from './RenderingEngine';
-import getRenderingEngine from './getRenderingEngine';
-import VolumeViewport from './VolumeViewport';
-import StackViewport from './StackViewport';
-import VolumeViewport3D from './VolumeViewport3D';
-import {
-  createVolumeActor,
-  createVolumeMapper,
-  getOrCreateCanvas,
-} from './helpers';
-
-export {
-  getRenderingEngine,
-  RenderingEngine,
-  VolumeViewport,
-  VolumeViewport3D,
-  createVolumeActor,
-  createVolumeMapper,
-  getOrCreateCanvas,
-  StackViewport,
-};
-
-export default RenderingEngine;

package/src/RenderingEngine/renderingEngineCache.ts

@@ -1,58 +0,0 @@
-import type { IRenderingEngine } from '../types';
-
-const cache = {};
-
-const renderingEngineCache = {
-  /**
-   * Returns the `RenderingEngine` instance with the given `id`.
-   *
-   * @param id - The `id` of the `RenderingEngine` instance to fetch.
-   * @returns The `RenderingEngine` instance.
-   */
-  get: (id: string): IRenderingEngine => {
-    return cache[id];
-  },
-  /**
-   * Adds the `RenderingEngine` instance to the cache.
-   *
-   * @param re - The `RenderingEngine` to add.
-   */
-  set: (re: IRenderingEngine): void => {
-    const renderingEngineId = re.id;
-
-    cache[renderingEngineId] = re;
-  },
-  /**
-   * Deletes the `RenderingEngine` instance from the cache.
-   *
-   * @param id - The `id` of the `RenderingEngine` instance to delete.
-   * @returns True if the delete was successful.
-   */
-  delete: (id: string) => {
-    return delete cache[id];
-  },
-
-  getAll: (): Array<IRenderingEngine> => {
-    const renderingEngineIds = Object.keys(cache);
-    const renderingEngines = renderingEngineIds.map((id) => cache[id]);
-
-    // sort the rendering engines so that the ones that start with _
-    // are at the end of the array. The reason is for not breaking
-    // the code that used getRenderingEngines(), but since we moved
-    // the renderToCanvas utility to use GPU hence it needs a
-    // rendering engine and we don't want to use the default one.
-    renderingEngines.sort((a, b) => {
-      if (a.id[0] === '_' && b.id[0] !== '_') {
-        return 1;
-      } else if (a.id[0] !== '_' && b.id[0] === '_') {
-        return -1;
-      } else {
-        return 0;
-      }
-    });
-
-    return renderingEngines;
-  },
-};
-
-export default renderingEngineCache;

package/src/RenderingEngine/vtkClasses/index.js

@@ -1,11 +0,0 @@
-import vtkOffscreenMultiRenderWindow from './vtkOffscreenMultiRenderWindow';
-import vtkSharedVolumeMapper from './vtkSharedVolumeMapper';
-import vtkStreamingOpenGLTexture from './vtkStreamingOpenGLTexture';
-import vtkSlabCamera from './vtkSlabCamera';
-
-export {
-  vtkOffscreenMultiRenderWindow,
-  vtkSharedVolumeMapper,
-  vtkStreamingOpenGLTexture,
-  vtkSlabCamera,
-};

package/src/RenderingEngine/vtkClasses/vtkOffscreenMultiRenderWindow.js

@@ -1,149 +0,0 @@
-import macro from '@kitware/vtk.js/macros';
-import vtkStreamingOpenGLRenderWindow from './vtkStreamingOpenGLRenderWindow';
-import vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
-import vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
-import vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
-
-// Load basic classes for vtk() factory
-import '@kitware/vtk.js/Common/Core/Points';
-import '@kitware/vtk.js/Common/Core/DataArray';
-import '@kitware/vtk.js/Common/DataModel/PolyData';
-import '@kitware/vtk.js/Rendering/Core/Actor';
-import '@kitware/vtk.js/Rendering/Core/Mapper';
-
-/**
- * vtkOffscreenMultiRenderWindow - A class to deal with offscreen rendering with multiple renderers.
- *
- * This class is based on the vtkGenericRenderWindow with two key differences:
- * - the vtkGenericRenderWindow had a renderer at the top level, with helpers to get it from the renderWindow.
- *   although you could add more renderers, this gave special status to the first viewport. Which was confusing.
- * - When checking the size of the container element we no longer check the client size, as the canvas is offscreen.
- * - We aren't using interactor styles, so don't set one up.
- *
- * Additionally this class has some new helpers to easily add/associate renderers to different viewportIds.
- *
- *
- * @param {*} publicAPI The public API to extend
- * @param {*} model The private model to extend.
- */
-function vtkOffscreenMultiRenderWindow(publicAPI, model) {
-  // Capture resize trigger method to remove from publicAPI
-  const invokeResize = publicAPI.invokeResize;
-  delete publicAPI.invokeResize;
-
-  // VTK renderWindow. No renderers set by default
-  model.renderWindow = vtkRenderWindow.newInstance();
-  model.rendererMap = {};
-
-  // OpenGLRenderWindow
-  model.openGLRenderWindow = vtkStreamingOpenGLRenderWindow.newInstance();
-  model.renderWindow.addView(model.openGLRenderWindow);
-
-  // Interactor
-  model.interactor = vtkRenderWindowInteractor.newInstance();
-  model.interactor.setView(model.openGLRenderWindow);
-  model.interactor.initialize();
-
-  publicAPI.addRenderer = ({ viewport, id, background }) => {
-    const renderer = vtkRenderer.newInstance({
-      viewport,
-      background: background || model.background,
-    });
-
-    model.renderWindow.addRenderer(renderer);
-    model.rendererMap[id] = renderer;
-  };
-
-  publicAPI.destroy = () => {
-    const rwi = model.renderWindow.getInteractor();
-    rwi.delete();
-  };
-
-  publicAPI.removeRenderer = (id) => {
-    const renderer = publicAPI.getRenderer(id);
-    model.renderWindow.removeRenderer(renderer);
-    renderer.delete();
-    delete model.rendererMap[id];
-  };
-
-  publicAPI.getRenderer = (id) => {
-    return model.rendererMap[id];
-  };
-
-  publicAPI.getRenderers = () => {
-    const { rendererMap } = model;
-
-    const renderers = Object.keys(rendererMap).map((id) => {
-      return { id, renderer: rendererMap[id] };
-    });
-
-    return renderers;
-  };
-
-  // Handle window resize
-  publicAPI.resize = () => {
-    if (model.container) {
-      // Don't use getBoundingClientRect() as in vtkGenericRenderWindow as is an offscreen canvas.
-      const { width, height } = model.container;
-
-      // Note: we do not scale by devicePixelRatio here because it has already
-      // been done when adding the offscreenCanvas viewport representations
-      model.openGLRenderWindow.setSize(Math.floor(width), Math.floor(height));
-      invokeResize();
-      model.renderWindow.render();
-    }
-  };
-
-  // Handle DOM container relocation
-  publicAPI.setContainer = (el) => {
-    // Switch container
-    model.container = el;
-    model.openGLRenderWindow.setContainer(model.container);
-  };
-
-  // Properly release GL context
-  publicAPI.delete = macro.chain(
-    publicAPI.setContainer,
-    publicAPI.destroy,
-    model.openGLRenderWindow.delete,
-    publicAPI.delete
-  );
-
-  publicAPI.resize();
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-const DEFAULT_VALUES = {
-  background: [0.0, 0.0, 0.0],
-  container: null,
-};
-
-// ----------------------------------------------------------------------------
-
-export function extend(publicAPI, model, initialValues = {}) {
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-
-  // Object methods
-  macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, [
-    'renderWindow',
-    'openGLRenderWindow',
-    'interactor',
-    'container',
-  ]);
-  macro.event(publicAPI, model, 'resize');
-
-  // Object specific methods
-  vtkOffscreenMultiRenderWindow(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-export const newInstance = macro.newInstance(extend);
-
-// ----------------------------------------------------------------------------
-
-export default { newInstance, extend };