@cornerstonejs/core 0.36.2 → 0.36.4

package/src/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataPseudocolorLUT.ts

@@ -0,0 +1,66 @@
+import * as colors from '../colors/index';
+import now from './now';
+import type { IImage, CPUFallbackLookupTable } from '../../../../types';
+
+/**
+ *
+ * @param {Image} image A Cornerstone Image Object
+ * @param {Array} grayscaleLut Lookup table array
+ * @param {LookupTable|Array} colorLUT Lookup table array
+ * @param {Uint8ClampedArray} canvasImageDataData canvasImageData.data buffer filled with white pixels
+ *
+ * @returns {void}
+ * @memberof Internal
+ */
+function storedPixelDataToCanvasImageDataPseudocolorLUT(
+  image: IImage,
+  grayscaleLut: Uint8ClampedArray,
+  colorLUT: CPUFallbackLookupTable,
+  canvasImageDataData: Uint8ClampedArray
+): void {
+  let start = now();
+  const pixelData = image.getPixelData();
+
+  image.stats.lastGetPixelDataTime = now() - start;
+
+  const numPixels = pixelData.length;
+  const minPixelValue = image.minPixelValue;
+  let canvasImageDataIndex = 0;
+  let storedPixelDataIndex = 0;
+  let grayscale;
+  let rgba;
+  let clut;
+
+  start = now();
+
+  if (colorLUT instanceof colors.LookupTable) {
+    clut = colorLUT.Table;
+  } else {
+    clut = colorLUT;
+  }
+
+  if (minPixelValue < 0) {
+    while (storedPixelDataIndex < numPixels) {
+      grayscale =
+        grayscaleLut[pixelData[storedPixelDataIndex++] + -minPixelValue];
+      rgba = clut[grayscale];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[0];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[1];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[2];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[3];
+    }
+  } else {
+    while (storedPixelDataIndex < numPixels) {
+      grayscale = grayscaleLut[pixelData[storedPixelDataIndex++]];
+      rgba = clut[grayscale];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[0];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[1];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[2];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[3];
+    }
+  }
+
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}
+
+export default storedPixelDataToCanvasImageDataPseudocolorLUT;

package/src/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataPseudocolorLUTPET.ts

@@ -0,0 +1,68 @@
+import * as colors from '../colors/index';
+import now from './now';
+import type { IImage, CPUFallbackLookupTable } from '../../../../types';
+
+/**
+ *
+ * @param {Image} image A Cornerstone Image Object
+ * @param {Array} grayscaleLut Lookup table array
+ * @param {LookupTable|Array} colorLUT Lookup table array
+ * @param {Uint8ClampedArray} canvasImageDataData canvasImageData.data buffer filled with white pixels
+ *
+ * @returns {void}
+ * @memberof Internal
+ */
+function storedPixelDataToCanvasImageDataPseudocolorLUTPET(
+  image: IImage,
+  lutFunction: (value: number) => number,
+  colorLUT: CPUFallbackLookupTable,
+  canvasImageDataData: Uint8ClampedArray
+): void {
+  let start = now();
+  const pixelData = image.getPixelData();
+
+  image.stats.lastGetPixelDataTime = now() - start;
+
+  const numPixels = pixelData.length;
+  const minPixelValue = image.minPixelValue;
+  let canvasImageDataIndex = 0;
+  let storedPixelDataIndex = 0;
+  let grayscale;
+  let rgba;
+  let clut;
+
+  start = now();
+
+  if (colorLUT instanceof colors.LookupTable) {
+    clut = colorLUT.Table;
+  } else {
+    clut = colorLUT;
+  }
+
+  if (minPixelValue < 0) {
+    while (storedPixelDataIndex < numPixels) {
+      grayscale = lutFunction(
+        pixelData[storedPixelDataIndex++] + -minPixelValue
+      );
+
+      rgba = clut[grayscale];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[0];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[1];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[2];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[3];
+    }
+  } else {
+    while (storedPixelDataIndex < numPixels) {
+      grayscale = lutFunction(pixelData[storedPixelDataIndex++]);
+      rgba = clut[grayscale];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[0];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[1];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[2];
+      canvasImageDataData[canvasImageDataIndex++] = rgba[3];
+    }
+  }
+
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}
+
+export default storedPixelDataToCanvasImageDataPseudocolorLUTPET;

package/src/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataRGBA.ts

@@ -0,0 +1,81 @@
+import now from './now';
+import { IImage } from '../../../../types';
+
+/**
+ * This function transforms stored pixel values into a canvas image data buffer
+ * by using a LUT.
+ *
+ * @param {Image} image A Cornerstone Image Object
+ * @param {Array} lut Lookup table array
+ * @param {Uint8ClampedArray} canvasImageDataData canvasImageData.data buffer filled with white pixels
+ *
+ * @returns {void}
+ * @memberof Internal
+ */
+export default function (
+  image: IImage,
+  lut: Uint8ClampedArray,
+  canvasImageDataData: Uint8ClampedArray
+): void {
+  let start = now();
+  const pixelData = image.getPixelData();
+
+  image.stats.lastGetPixelDataTime = now() - start;
+
+  const numPixels = pixelData.length;
+  const minPixelValue = image.minPixelValue;
+  let canvasImageDataIndex = 0;
+  let storedPixelDataIndex = 0;
+  let pixelValue;
+
+  // NOTE: As of Nov 2014, most javascript engines have lower performance when indexing negative indexes.
+  // We have a special code path for this case that improves performance.  Thanks to @jpambrun for this enhancement
+
+  // Added two paths (Int16Array, Uint16Array) to avoid polymorphic deoptimization in chrome.
+  start = now();
+  if (pixelData instanceof Int16Array) {
+    if (minPixelValue < 0) {
+      while (storedPixelDataIndex < numPixels) {
+        pixelValue = lut[pixelData[storedPixelDataIndex++] + -minPixelValue];
+        canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+        canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+        canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+        canvasImageDataData[canvasImageDataIndex++] = 255; // Alpha
+      }
+    } else {
+      while (storedPixelDataIndex < numPixels) {
+        pixelValue = lut[pixelData[storedPixelDataIndex++]];
+        canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+        canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+        canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+        canvasImageDataData[canvasImageDataIndex++] = 255; // Alpha
+      }
+    }
+  } else if (pixelData instanceof Uint16Array) {
+    while (storedPixelDataIndex < numPixels) {
+      pixelValue = lut[pixelData[storedPixelDataIndex++]];
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = 255; // Alpha
+    }
+  } else if (minPixelValue < 0) {
+    while (storedPixelDataIndex < numPixels) {
+      pixelValue = lut[pixelData[storedPixelDataIndex++] + -minPixelValue];
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = 255; // Alpha
+    }
+  } else {
+    while (storedPixelDataIndex < numPixels) {
+      pixelValue = lut[pixelData[storedPixelDataIndex++]];
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = pixelValue;
+      canvasImageDataData[canvasImageDataIndex++] = 255; // Alpha
+    }
+  }
+
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}

package/src/RenderingEngine/helpers/cpuFallback/rendering/storedRGBAPixelDataToCanvasImageData.ts

@@ -0,0 +1,56 @@
+import now from './now';
+import { IImage } from '../../../../types';
+
+/**
+ * Converts stored RGBA color pixel values to display pixel values using a LUT.
+ *
+ * @param {Image} image A Cornerstone Image Object
+ * @param {Array} lut Lookup table array
+ * @param {Uint8ClampedArray} canvasImageDataData canvasImageData.data buffer filled with white pixels
+ *
+ * @returns {void}
+ * @memberof Internal
+ */
+export default function (
+  image: IImage,
+  lut: Uint8ClampedArray,
+  canvasImageDataData: Uint8ClampedArray
+): void {
+  let start = now();
+  const pixelData = image.getPixelData();
+
+  image.stats.lastGetPixelDataTime = now() - start;
+
+  const minPixelValue = image.minPixelValue;
+  let canvasImageDataIndex = 0;
+  let storedPixelDataIndex = 0;
+  const numPixels = pixelData.length;
+
+  // NOTE: As of Nov 2014, most javascript engines have lower performance when indexing negative indexes.
+  // We have a special code path for this case that improves performance.  Thanks to @jpambrun for this enhancement
+  start = now();
+  if (minPixelValue < 0) {
+    while (storedPixelDataIndex < numPixels) {
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++] + -minPixelValue]; // Red
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++] + -minPixelValue]; // Green
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++] + -minPixelValue]; // Blue
+      canvasImageDataData[canvasImageDataIndex++] =
+        pixelData[storedPixelDataIndex++];
+    }
+  } else {
+    while (storedPixelDataIndex < numPixels) {
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++]]; // Red
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++]]; // Green
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++]]; // Blue
+      canvasImageDataData[canvasImageDataIndex++] =
+        pixelData[storedPixelDataIndex++];
+    }
+  }
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}

package/src/RenderingEngine/helpers/cpuFallback/rendering/transform.ts

@@ -0,0 +1,126 @@
+import {
+  CPUFallbackTransform,
+  Point2,
+  TransformMatrix2D,
+} from '../../../../types';
+
+// By Simon Sarris
+// Www.simonsarris.com
+// Sarris@acm.org
+//
+// Free to use and distribute at will
+// So long as you are nice to people, etc
+
+// Simple class for keeping track of the current transformation matrix
+
+// For instance:
+//    Var t = new Transform();
+//    T.rotate(5);
+//    Var m = t.m;
+//    Ctx.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
+
+// Is equivalent to:
+//    Ctx.rotate(5);
+
+// But now you can retrieve it :)
+
+// Remember that this does not account for any CSS transforms applied to the canvas
+export class Transform implements CPUFallbackTransform {
+  private m: TransformMatrix2D;
+
+  constructor() {
+    this.reset();
+  }
+
+  getMatrix(): TransformMatrix2D {
+    return this.m;
+  }
+
+  reset(): void {
+    this.m = [1, 0, 0, 1, 0, 0];
+  }
+
+  clone(): CPUFallbackTransform {
+    const transform = new Transform();
+
+    transform.m[0] = this.m[0];
+    transform.m[1] = this.m[1];
+    transform.m[2] = this.m[2];
+    transform.m[3] = this.m[3];
+    transform.m[4] = this.m[4];
+    transform.m[5] = this.m[5];
+
+    return transform;
+  }
+
+  multiply(matrix: TransformMatrix2D): void {
+    const m11 = this.m[0] * matrix[0] + this.m[2] * matrix[1];
+    const m12 = this.m[1] * matrix[0] + this.m[3] * matrix[1];
+
+    const m21 = this.m[0] * matrix[2] + this.m[2] * matrix[3];
+    const m22 = this.m[1] * matrix[2] + this.m[3] * matrix[3];
+
+    const dx = this.m[0] * matrix[4] + this.m[2] * matrix[5] + this.m[4];
+    const dy = this.m[1] * matrix[4] + this.m[3] * matrix[5] + this.m[5];
+
+    this.m[0] = m11;
+    this.m[1] = m12;
+    this.m[2] = m21;
+    this.m[3] = m22;
+    this.m[4] = dx;
+    this.m[5] = dy;
+  }
+
+  invert(): void {
+    const d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
+    const m0 = this.m[3] * d;
+    const m1 = -this.m[1] * d;
+    const m2 = -this.m[2] * d;
+    const m3 = this.m[0] * d;
+    const m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
+    const m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
+
+    this.m[0] = m0;
+    this.m[1] = m1;
+    this.m[2] = m2;
+    this.m[3] = m3;
+    this.m[4] = m4;
+    this.m[5] = m5;
+  }
+
+  rotate(rad: number): void {
+    const c = Math.cos(rad);
+    const s = Math.sin(rad);
+    const m11 = this.m[0] * c + this.m[2] * s;
+    const m12 = this.m[1] * c + this.m[3] * s;
+    const m21 = this.m[0] * -s + this.m[2] * c;
+    const m22 = this.m[1] * -s + this.m[3] * c;
+
+    this.m[0] = m11;
+    this.m[1] = m12;
+    this.m[2] = m21;
+    this.m[3] = m22;
+  }
+
+  translate(x: number, y: number): void {
+    this.m[4] += this.m[0] * x + this.m[2] * y;
+    this.m[5] += this.m[1] * x + this.m[3] * y;
+  }
+
+  scale(sx: number, sy: number) {
+    this.m[0] *= sx;
+    this.m[1] *= sx;
+    this.m[2] *= sy;
+    this.m[3] *= sy;
+  }
+
+  transformPoint(point: Point2): Point2 {
+    const x = point[0];
+    const y = point[1];
+
+    return [
+      x * this.m[0] + y * this.m[2] + this.m[4],
+      x * this.m[1] + y * this.m[3] + this.m[5],
+    ];
+  }
+}

package/src/RenderingEngine/helpers/cpuFallback/rendering/validator.ts

@@ -0,0 +1,31 @@
+/**
+ * Check if the supplied parameter is undefined and throws and error
+ * @param {any} checkParam the parameter to validate for undefined
+ * @param {any} errorMsg the error message to be thrown
+ * @returns {void}
+ * @memberof internal
+ */
+export function validateParameterUndefined(
+  checkParam: any | undefined,
+  errorMsg: string
+): void {
+  if (checkParam === undefined) {
+    throw new Error(errorMsg);
+  }
+}
+
+/**
+ * Check if the supplied parameter is undefined or null and throws and error
+ * @param {any} checkParam the parameter to validate for undefined
+ * @param {any} errorMsg the error message to be thrown
+ * @returns {void}
+ * @memberof internal
+ */
+export function validateParameterUndefinedOrNull(
+  checkParam: any | null | undefined,
+  errorMsg: string
+): void {
+  if (checkParam === undefined || checkParam === null) {
+    throw new Error(errorMsg);
+  }
+}

package/src/RenderingEngine/helpers/createVolumeActor.ts

@@ -0,0 +1,103 @@
+import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+
+import { VolumeActor } from './../../types/IActor';
+import { VoiModifiedEventDetail } from './../../types/EventTypes';
+import { loadVolume } from '../../loaders/volumeLoader';
+import createVolumeMapper from './createVolumeMapper';
+import BlendModes from '../../enums/BlendModes';
+import { triggerEvent } from '../../utilities';
+import { Events } from '../../enums';
+import setDefaultVolumeVOI from './setDefaultVolumeVOI';
+
+interface createVolumeActorInterface {
+  volumeId: string;
+  callback?: ({
+    volumeActor,
+    volumeId,
+  }: {
+    volumeActor: VolumeActor;
+    volumeId: string;
+  }) => void;
+  blendMode?: BlendModes;
+}
+
+/**
+ * Given a volumeId, it creates a vtk volume actor and returns it. If
+ * callback is provided, it will be called with the volume actor and the
+ * volumeId. If blendMode is provided, it will be set on the volume actor.
+ *
+ * @param props - createVolumeActorInterface
+ * @returns A promise that resolves to a VolumeActor.
+ */
+async function createVolumeActor(
+  props: createVolumeActorInterface,
+  element: HTMLDivElement,
+  viewportId: string,
+  suppressEvents = false,
+  use16BitTexture = false
+): Promise<VolumeActor> {
+  const { volumeId, callback, blendMode } = props;
+
+  const imageVolume = await loadVolume(volumeId);
+
+  if (!imageVolume) {
+    throw new Error(
+      `imageVolume with id: ${imageVolume.volumeId} does not exist`
+    );
+  }
+
+  const { imageData, vtkOpenGLTexture } = imageVolume;
+
+  const volumeMapper = createVolumeMapper(imageData, vtkOpenGLTexture);
+
+  if (blendMode) {
+    volumeMapper.setBlendMode(blendMode);
+  }
+
+  const volumeActor = vtkVolume.newInstance();
+  volumeActor.setMapper(volumeMapper);
+
+  // If the volume is composed of imageIds, we can apply a default VOI based
+  // on either the metadata or the min/max of the middle slice. Example of other
+  // types of volumes which might not be composed of imageIds would be e.g., nrrd, nifti
+  // format volumes
+  if (imageVolume.imageIds) {
+    await setDefaultVolumeVOI(volumeActor, imageVolume, use16BitTexture);
+  }
+
+  if (callback) {
+    callback({ volumeActor, volumeId });
+  }
+
+  if (!suppressEvents) {
+    triggerVOIModified(element, viewportId, volumeActor, volumeId);
+  }
+
+  return volumeActor;
+}
+
+function triggerVOIModified(
+  element: HTMLDivElement,
+  viewportId: string,
+  volumeActor: VolumeActor,
+  volumeId: string
+) {
+  const voiRange = volumeActor
+    .getProperty()
+    .getRGBTransferFunction(0)
+    // @ts-ignore: vtk d ts problem
+    .getRange();
+
+  const voiModifiedEventDetail: VoiModifiedEventDetail = {
+    viewportId,
+    range: {
+      lower: voiRange[0],
+      upper: voiRange[1],
+    },
+    volumeId,
+  };
+
+  triggerEvent(element, Events.VOI_MODIFIED, voiModifiedEventDetail);
+}
+
+export default createVolumeActor;

package/src/RenderingEngine/helpers/createVolumeMapper.ts

@@ -0,0 +1,37 @@
+import { vtkSharedVolumeMapper } from '../vtkClasses';
+import { getConfiguration } from '../../init';
+/**
+ * Given an imageData and a vtkOpenGLTexture, it creates a "shared" vtk volume mapper
+ * from which various volume actors can be created.
+ *
+ * @param imageData - the vtkImageData object that contains the data to
+ * render.
+ * @param vtkOpenGLTexture - The vtkOpenGLTexture that will be used to render
+ * the volume.
+ * @returns The volume mapper.
+ */
+export default function createVolumeMapper(
+  imageData: any,
+  vtkOpenGLTexture: any
+): any {
+  const volumeMapper = vtkSharedVolumeMapper.newInstance();
+
+  if (getConfiguration().rendering.preferSizeOverAccuracy) {
+    volumeMapper.setPreferSizeOverAccuracy(true);
+  }
+
+  volumeMapper.setInputData(imageData);
+
+  const spacing = imageData.getSpacing();
+  // Set the sample distance to half the mean length of one side. This is where the divide by 6 comes from.
+  // https://github.com/Kitware/VTK/blob/6b559c65bb90614fb02eb6d1b9e3f0fca3fe4b0b/Rendering/VolumeOpenGL2/vtkSmartVolumeMapper.cxx#L344
+  const sampleDistance = (spacing[0] + spacing[1] + spacing[2]) / 6;
+
+  // This is to allow for good pixel level image quality.
+  // Todo: why we are setting this to 4000? Is this a good number? it should be configurable
+  volumeMapper.setMaximumSamplesPerRay(4000);
+  volumeMapper.setSampleDistance(sampleDistance);
+  volumeMapper.setScalarTexture(vtkOpenGLTexture);
+
+  return volumeMapper;
+}

package/src/RenderingEngine/helpers/getOrCreateCanvas.ts

@@ -0,0 +1,58 @@
+const VIEWPORT_ELEMENT = 'viewport-element';
+const CANVAS_CSS_CLASS = 'cornerstone-canvas';
+
+/**
+ * Create a canvas and append it to the element
+ *
+ * @param element - An HTML Element
+ * @returns canvas - A Canvas DOM element
+ */
+function createCanvas(element: Element | HTMLDivElement): HTMLCanvasElement {
+  const canvas = document.createElement('canvas');
+
+  canvas.style.position = 'absolute';
+  canvas.style.width = '100%';
+  canvas.style.height = '100%';
+  canvas.classList.add(CANVAS_CSS_CLASS);
+  element.appendChild(canvas);
+
+  return canvas;
+}
+
+/**
+ * Creates an internal div that will contain canvas and SVG layer as children
+ * @param element - An HTML Element
+ * @returns div Cornerstone internal div that will include the canvas and SVG
+ * as its children
+ */
+export function createViewportElement(element: HTMLDivElement): HTMLDivElement {
+  const div = document.createElement('div');
+  div.style.position = 'relative';
+  div.style.width = '100%';
+  div.style.height = '100%';
+  div.classList.add(VIEWPORT_ELEMENT);
+  element.appendChild(div);
+
+  return div;
+}
+
+/**
+ * Create a canvas or returns the one that already exists for a given element.
+ * It first checks if the element has a canvas, if not it creates one and returns it.
+ *
+ * @param element - An HTML Element
+ * @returns canvas a Canvas DOM element
+ */
+export default function getOrCreateCanvas(
+  element: HTMLDivElement
+): HTMLCanvasElement {
+  const canvasSelector = `canvas.${CANVAS_CSS_CLASS}`;
+  const viewportElement = `div.${VIEWPORT_ELEMENT}`;
+
+  // Internal div with `relative` positioning to enable absolute positioning
+  // of the canvas and svg layer.
+  const internalDiv =
+    element.querySelector(viewportElement) || createViewportElement(element);
+
+  return internalDiv.querySelector(canvasSelector) || createCanvas(internalDiv);
+}

package/src/RenderingEngine/helpers/index.ts

@@ -0,0 +1,15 @@
+import createVolumeActor from './createVolumeActor';
+import createVolumeMapper from './createVolumeMapper';
+import getOrCreateCanvas from './getOrCreateCanvas';
+import setVolumesForViewports from './setVolumesForViewports';
+import addVolumesToViewports from './addVolumesToViewports';
+import volumeNewImageEventDispatcher from './volumeNewImageEventDispatcher';
+
+export {
+  createVolumeActor,
+  createVolumeMapper,
+  getOrCreateCanvas,
+  setVolumesForViewports,
+  addVolumesToViewports,
+  volumeNewImageEventDispatcher,
+};

package/src/RenderingEngine/helpers/isRgbaSourceRgbDest.ts

@@ -0,0 +1 @@
+export default (src, dest) => src.length * 3 === dest.byteLength * 4;