@cornerstonejs/core 0.36.3 → 0.36.5

package/src/RenderingEngine/helpers/setDefaultVolumeVOI.ts

@@ -0,0 +1,227 @@
+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';
+
+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.
+ */
+async function setDefaultVolumeVOI(
+  volumeActor: VolumeActor,
+  imageVolume: IImageVolume,
+  use16BitTexture: boolean
+): Promise<void> {
+  let voi = getVOIFromMetadata(imageVolume);
+
+  if (!voi) {
+    voi = await getVOIFromMinMax(imageVolume, use16BitTexture);
+  }
+
+  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'
+    );
+  }
+
+  voi = handlePreScaledVolume(imageVolume, voi);
+  const { lower, upper } = voi;
+
+  volumeActor
+    .getProperty()
+    .getRGBTransferFunction(0)
+    .setMappingRange(lower, 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 (generalSeriesModule.modality === 'PT' && imageVolume.isPrescaled) {
+    return {
+      lower: 0,
+      upper: 5,
+    };
+  }
+
+  return voi;
+}
+
+/**
+ * Get the VOI from the metadata of the middle slice 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 } = imageVolume;
+
+  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;
+
+    const voi = {
+      windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
+      windowCenter: Array.isArray(windowCenter)
+        ? windowCenter[0]
+        : windowCenter,
+    };
+
+    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.
+ * @returns The VOIRange with lower and upper values
+ */
+async function getVOIFromMinMax(
+  imageVolume: IImageVolume,
+  use16BitTexture: 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: use16BitTexture ? undefined : 'Float32Array',
+    },
+    priority: PRIORITY,
+    requestType: REQUEST_TYPE,
+    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.
+  const image = await loadAndCacheImage(imageId, options);
+
+  let imageScalarData;
+  if (!image) {
+    imageScalarData = _getImageScalarDataFromImageVolume(
+      imageVolume,
+      byteOffset,
+      bytePerPixel,
+      voxelsPerImage
+    );
+  } else {
+    imageScalarData = image.getPixelData();
+  }
+
+  // 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 { volumeBuffer } = 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(
+    volumeBuffer,
+    byteOffset,
+    voxelsPerImage
+  );
+
+  imageScalarData.set(volumeBufferView);
+
+  return imageScalarData;
+}
+
+export default setDefaultVolumeVOI;

package/src/RenderingEngine/helpers/setVolumesForViewports.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,14 @@
+// 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';
+
+const viewportTypeToViewportClass = {
+  [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
+  [ViewportType.PERSPECTIVE]: VolumeViewport,
+  [ViewportType.STACK]: StackViewport,
+  [ViewportType.VOLUME_3D]: VolumeViewport3D,
+};
+
+export default viewportTypeToViewportClass;

package/src/RenderingEngine/helpers/viewportTypeUsesCustomRenderingPipeline.ts

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

package/src/RenderingEngine/helpers/volumeNewImageEventDispatcher.ts

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,43 @@
+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]);
+
+    return renderingEngines;
+  },
+};
+
+export default renderingEngineCache;

package/src/RenderingEngine/vtkClasses/index.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,149 @@
+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 };

package/src/RenderingEngine/vtkClasses/vtkSharedVolumeMapper.js

@@ -0,0 +1,52 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
+
+/**
+ * vtkSharedVolumeMapper - A derived class of the core vtkVolumeMapper class
+ * the scalar texture in as an argument. This is so we can share the same texture
+ * memory across different mappers/actors, so we don't duplicate memory usage.
+ *
+ *
+ *
+ * @param {*} publicAPI The public API to extend
+ * @param {*} model The private model to extend.
+ * @hidden
+ */
+function vtkSharedVolumeMapper(publicAPI, model) {
+  model.classHierarchy.push('vtkSharedVolumeMapper');
+
+  const superDelete = publicAPI.delete;
+  publicAPI.delete = () => {
+    model.scalarTexture = null;
+    superDelete();
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  scalarTexture: null,
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkVolumeMapper.extend(publicAPI, model, initialValues);
+
+  macro.setGet(publicAPI, model, ['scalarTexture']);
+
+  // Object methods
+  vtkSharedVolumeMapper(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkSharedVolumeMapper');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };