@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,105 +0,0 @@
-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,
-  useNativeDataType = 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);
-
-  const numberOfComponents = imageData
-    .getPointData()
-    .getScalars()
-    .getNumberOfComponents();
-
-  if (numberOfComponents === 3) {
-    volumeActor.getProperty().setIndependentComponents(false);
-  }
-
-  await setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType);
-
-  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)
-    .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

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

@@ -1,89 +0,0 @@
-const VIEWPORT_ELEMENT = 'viewport-element';
-const CANVAS_CSS_CLASS = 'cornerstone-canvas';
-export const EPSILON = 1e-4;
-
-/**
- * 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.style.imageRendering = 'pixelated';
-  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%';
-  // Hide any canvas elements not viewable
-  div.style.overflow = 'hidden';
-  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.
- * The canvas is updated for:
- *   1. width/height in screen pixels to completely cover the div element
- *   2. CSS width/height in CSS pixels to be the size of the physical screen pixels
- *      width and height (from #1)
- * This allows drawing to the canvas and having pixel perfect/exact drawing to
- * the physical screen pixels.
- *
- * @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);
-
-  const canvas = (internalDiv.querySelector(canvasSelector) ||
-    createCanvas(internalDiv)) as HTMLCanvasElement;
-  // Fit the canvas into the div
-  const rect = internalDiv.getBoundingClientRect();
-  const devicePixelRatio = window.devicePixelRatio || 1;
-
-  // The width/height is the number of physical pixels which will completely
-  // cover the div so that no pixels, fractional or full are left uncovered.
-  // Thus, it is the ceiling of the CSS size times the physical pixels.
-  // In theory, the physical pixels can be offset from CSS pixels, but in practice
-  // this hasn't been observed.
-  const width = Math.ceil(rect.width * devicePixelRatio);
-  const height = Math.ceil(rect.height * devicePixelRatio);
-  canvas.width = width;
-  canvas.height = height;
-  // Reset the size of the canvas to be the number of physical pixels,
-  // expressed as CSS pixels, with a tiny extra amount to prevent clipping
-  // to the next lower size in the physical display.
-  canvas.style.width = (width + EPSILON) / devicePixelRatio + 'px';
-  canvas.style.height = (height + EPSILON) / devicePixelRatio + 'px';
-
-  return canvas;
-}

package/src/RenderingEngine/helpers/index.ts

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

package/src/RenderingEngine/helpers/isRgbaSourceRgbDest.ts

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