@cornerstonejs/core 0.36.2 → 0.36.4

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

@@ -0,0 +1,203 @@
+import setToPixelCoordinateSystem from './setToPixelCoordinateSystem';
+import now from './now';
+import initializeRenderCanvas from './initializeRenderCanvas';
+import getLut from './getLut';
+import saveLastRendered from './saveLastRendered';
+import doesImageNeedToBeRendered from './doesImageNeedToBeRendered';
+import storedPixelDataToCanvasImageDataPseudocolorLUT from './storedPixelDataToCanvasImageDataPseudocolorLUT';
+import storedPixelDataToCanvasImageDataPseudocolorLUTPET from './storedPixelDataToCanvasImageDataPseudocolorLUTPET';
+import * as colors from '../colors/index';
+import type { IImage, CPUFallbackEnabledElement } from '../../../../types';
+
+function clamp(value: number, min: number, max: number) {
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
+ * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
+ *
+ * @param {Object} enabledElement The cornerstone enabled element
+ * @param {Object} image The image to be rendered
+ * @param {Boolean} invalidated Is pixel data valid
+ * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
+ * @memberof rendering
+ */
+function getRenderCanvas(
+  enabledElement: CPUFallbackEnabledElement,
+  image: IImage,
+  invalidated: boolean
+): HTMLCanvasElement {
+  if (!enabledElement.renderingTools.renderCanvas) {
+    enabledElement.renderingTools.renderCanvas =
+      document.createElement('canvas');
+  }
+
+  const renderCanvas = enabledElement.renderingTools.renderCanvas;
+
+  let colormap =
+    enabledElement.viewport.colormap || enabledElement.options.colormap;
+
+  if (enabledElement.options && enabledElement.options.colormap) {
+    console.warn(
+      'enabledElement.options.colormap is deprecated. Use enabledElement.viewport.colormap instead'
+    );
+  }
+  if (colormap && typeof colormap === 'string') {
+    colormap = colors.getColormap(colormap);
+  }
+
+  if (!colormap) {
+    throw new Error('renderPseudoColorImage: colormap not found.');
+  }
+
+  const colormapId = colormap.getId();
+
+  if (
+    doesImageNeedToBeRendered(enabledElement, image) === false &&
+    invalidated !== true &&
+    enabledElement.renderingTools.colormapId === colormapId
+  ) {
+    return renderCanvas;
+  }
+
+  // If our render canvas does not match the size of this image reset it
+  // NOTE: This might be inefficient if we are updating multiple images of different
+  // Sizes frequently.
+  if (
+    renderCanvas.width !== image.width ||
+    renderCanvas.height !== image.height
+  ) {
+    initializeRenderCanvas(enabledElement, image);
+  }
+
+  // Get the lut to use
+  let start = now();
+
+  if (
+    !enabledElement.renderingTools.colorLUT ||
+    invalidated ||
+    enabledElement.renderingTools.colormapId !== colormapId
+  ) {
+    colormap.setNumberOfColors(256);
+    enabledElement.renderingTools.colorLUT = colormap.createLookupTable();
+    enabledElement.renderingTools.colormapId = colormapId;
+  }
+
+  const renderCanvasData = enabledElement.renderingTools.renderCanvasData;
+  const renderCanvasContext = enabledElement.renderingTools.renderCanvasContext;
+  const { viewport } = enabledElement;
+  const colorLUT = enabledElement.renderingTools.colorLUT;
+
+  if (viewport.modality === 'PT') {
+    const { windowWidth, windowCenter } = viewport.voi;
+    const minimum = windowCenter - windowWidth / 2;
+    const maximum = windowCenter + windowWidth / 2;
+    const range = maximum - minimum;
+    const collectedMultiplierTerms = 255.0 / range;
+
+    let petVOILutFunction;
+
+    if (viewport.invert) {
+      petVOILutFunction = (value) => {
+        return clamp(
+          Math.floor(255 - (value - minimum) * collectedMultiplierTerms),
+          0,
+          255
+        );
+      };
+    } else {
+      petVOILutFunction = (value) => {
+        return clamp(
+          Math.floor((value - minimum) * collectedMultiplierTerms),
+          0,
+          255
+        );
+      };
+    }
+
+    storedPixelDataToCanvasImageDataPseudocolorLUTPET(
+      image,
+      petVOILutFunction,
+      colorLUT,
+      renderCanvasData.data
+    );
+  } else {
+    const lut = getLut(image, enabledElement.viewport, invalidated);
+
+    image.stats = image.stats || {};
+    image.stats.lastLutGenerateTime = now() - start;
+
+    storedPixelDataToCanvasImageDataPseudocolorLUT(
+      image,
+      lut,
+      colorLUT,
+      renderCanvasData.data
+    );
+  }
+
+  start = now();
+  renderCanvasContext.putImageData(renderCanvasData, 0, 0);
+  image.stats.lastPutImageDataTime = now() - start;
+
+  return renderCanvas;
+}
+
+/**
+ * API function to draw a pseudo-color image to a given enabledElement
+ *
+ * @param {EnabledElement} enabledElement The Cornerstone Enabled Element to redraw
+ * @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
+ * @returns {void}
+ * @memberof rendering
+ */
+export function renderPseudoColorImage(
+  enabledElement: CPUFallbackEnabledElement,
+  invalidated: boolean
+): void {
+  if (enabledElement === undefined) {
+    throw new Error(
+      'drawImage: enabledElement parameter must not be undefined'
+    );
+  }
+
+  const image = enabledElement.image;
+
+  if (image === undefined) {
+    throw new Error('drawImage: image must be loaded before it can be drawn');
+  }
+
+  // Get the canvas context and reset the transform
+  const context = enabledElement.canvas.getContext('2d');
+
+  context.setTransform(1, 0, 0, 1, 0, 0);
+
+  // Clear the canvas
+  context.fillStyle = 'black';
+  context.fillRect(
+    0,
+    0,
+    enabledElement.canvas.width,
+    enabledElement.canvas.height
+  );
+
+  // Turn off image smooth/interpolation if pixelReplication is set in the viewport
+  context.imageSmoothingEnabled = !enabledElement.viewport.pixelReplication;
+
+  // Save the canvas context state and apply the viewport properties
+  setToPixelCoordinateSystem(enabledElement, context);
+
+  // If no options are set we will retrieve the renderCanvas through the
+  // Normal Canvas rendering path
+  // TODO: Add WebGL support for pseudocolor pipeline
+  const renderCanvas = getRenderCanvas(enabledElement, image, invalidated);
+
+  const sx = enabledElement.viewport.displayedArea.tlhc.x - 1;
+  const sy = enabledElement.viewport.displayedArea.tlhc.y - 1;
+  const width = enabledElement.viewport.displayedArea.brhc.x - sx;
+  const height = enabledElement.viewport.displayedArea.brhc.y - sy;
+
+  context.drawImage(renderCanvas, sx, sy, width, height, 0, 0, width, height);
+
+  enabledElement.renderingTools = saveLastRendered(enabledElement);
+}

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

@@ -0,0 +1,32 @@
+import getImageFitScale from './getImageFitScale';
+import { CPUFallbackEnabledElement } from '../../../../types';
+
+/**
+ * Resets the camera to the default position. which would be the center of the image.
+ * with no translation, no flipping, no zoom and proper scale.
+ */
+export default function (
+  enabledElement: CPUFallbackEnabledElement,
+  resetPan = true,
+  resetZoom = true
+): void {
+  const { canvas, image, viewport } = enabledElement;
+  const scale = getImageFitScale(canvas, image, 0).scaleFactor;
+
+  viewport.vflip = false;
+  viewport.hflip = false;
+
+  if (resetPan) {
+    viewport.translation.x = 0;
+    viewport.translation.y = 0;
+  }
+
+  if (resetZoom) {
+    viewport.displayedArea.tlhc.x = 1;
+    viewport.displayedArea.tlhc.y = 1;
+    viewport.displayedArea.brhc.x = image.columns;
+    viewport.displayedArea.brhc.y = image.rows;
+
+    viewport.scale = scale;
+  }
+}

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

@@ -0,0 +1,109 @@
+import fitToWindow from './fitToWindow';
+import getImageSize from './getImageSize';
+import { CPUFallbackEnabledElement } from '../../../../types';
+
+/**
+ * This module is responsible for enabling an element to display images with cornerstone
+ *
+ * @param {HTMLDivElement} element The DOM element enabled for Cornerstone
+ * @param {HTMLDivElement} canvas The Canvas DOM element within the DOM element enabled for Cornerstone
+ * @returns {void}
+ */
+function setCanvasSize(enabledElement: CPUFallbackEnabledElement) {
+  const { canvas } = enabledElement;
+  const { clientWidth, clientHeight } = canvas;
+
+  // Set the canvas to be same resolution as the client.
+  if (canvas.width !== clientWidth || canvas.height !== clientHeight) {
+    canvas.width = clientWidth;
+    canvas.height = clientHeight;
+  }
+}
+
+/**
+ * Checks if the image of a given enabled element fitted the window
+ * before the resize
+ *
+ * @param {EnabledElement} enabledElement The Cornerstone Enabled Element
+ * @param {number} oldCanvasWidth The width of the canvas before the resize
+ * @param {number} oldCanvasHeight The height of the canvas before the resize
+ * @return {Boolean} true if it fitted the windows, false otherwise
+ */
+function wasFitToWindow(
+  enabledElement: CPUFallbackEnabledElement,
+  oldCanvasWidth: number,
+  oldCanvasHeight: number
+): boolean {
+  const scale = enabledElement.viewport.scale;
+  const imageSize = getImageSize(
+    enabledElement.image,
+    enabledElement.viewport.rotation
+  );
+  const imageWidth = Math.round(imageSize.width * scale);
+  const imageHeight = Math.round(imageSize.height * scale);
+  const x = enabledElement.viewport.translation.x;
+  const y = enabledElement.viewport.translation.y;
+
+  return (
+    (imageWidth === oldCanvasWidth && imageHeight <= oldCanvasHeight) ||
+    (imageWidth <= oldCanvasWidth &&
+      imageHeight === oldCanvasHeight &&
+      x === 0 &&
+      y === 0)
+  );
+}
+
+/**
+ * Rescale the image relative to the changed size of the canvas
+ *
+ * @param {EnabledElement} enabledElement The Cornerstone Enabled Element
+ * @param {number} oldCanvasWidth The width of the canvas before the resize
+ * @param {number} oldCanvasHeight The height of the canvas before the resize
+ * @return {void}
+ */
+function relativeRescale(
+  enabledElement: CPUFallbackEnabledElement,
+  oldCanvasWidth: number,
+  oldCanvasHeight: number
+): void {
+  const scale = enabledElement.viewport.scale;
+  const canvasWidth = enabledElement.canvas.width;
+  const canvasHeight = enabledElement.canvas.height;
+  const relWidthChange = canvasWidth / oldCanvasWidth;
+  const relHeightChange = canvasHeight / oldCanvasHeight;
+  const relChange = Math.sqrt(relWidthChange * relHeightChange);
+
+  enabledElement.viewport.scale = relChange * scale;
+}
+
+/**
+ * Resizes an enabled element and optionally fits the image to window
+ *
+ * @param {HTMLDivElement} element The DOM element enabled for Cornerstone
+ * @param {Boolean} forceFitToWindow true to to force a refit, false to rescale accordingly
+ * @returns {void}
+ */
+export default function (
+  enabledElement: CPUFallbackEnabledElement,
+  forceFitToWindow = false
+): void {
+  const oldCanvasWidth = enabledElement.canvas.width;
+  const oldCanvasHeight = enabledElement.canvas.height;
+
+  setCanvasSize(enabledElement);
+
+  if (enabledElement.image === undefined) {
+    return;
+  }
+
+  if (
+    forceFitToWindow ||
+    wasFitToWindow(enabledElement, oldCanvasWidth, oldCanvasHeight)
+  ) {
+    // Fit the image to the window again if it fitted before the resize
+    fitToWindow(enabledElement);
+  } else {
+    // Adapt the scale of a zoomed or panned image relative to the size change
+    relativeRescale(enabledElement, oldCanvasWidth, oldCanvasHeight);
+  }
+}

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

@@ -0,0 +1,36 @@
+import {
+  CPUFallbackEnabledElement,
+  CPUFallbackRenderingTools,
+} from '../../../../types';
+
+/**
+ * Saves the parameters of the last render into renderingTools, used later to decide if data can be reused.
+ *
+ * @param {Object} enabledElement Cornerstone EnabledElement
+ * @returns {Object} enabledElement.renderingTools
+ * @memberof rendering
+ */
+
+export default function (
+  enabledElement: CPUFallbackEnabledElement
+): CPUFallbackRenderingTools {
+  const imageId = enabledElement.image.imageId;
+  const viewport = enabledElement.viewport;
+  const isColor = enabledElement.image.color;
+
+  enabledElement.renderingTools.lastRenderedImageId = imageId;
+  enabledElement.renderingTools.lastRenderedIsColor = isColor;
+  enabledElement.renderingTools.lastRenderedViewport = {
+    windowCenter: viewport.voi.windowCenter,
+    windowWidth: viewport.voi.windowWidth,
+    invert: viewport.invert,
+    rotation: viewport.rotation,
+    hflip: viewport.hflip,
+    vflip: viewport.vflip,
+    modalityLUT: viewport.modalityLUT,
+    voiLUT: viewport.voiLUT,
+    colormap: viewport.colormap,
+  };
+
+  return enabledElement.renderingTools;
+}

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

@@ -0,0 +1,17 @@
+import { CPUFallbackViewport } from '../../../../types';
+
+const state = {
+  viewport: {},
+};
+
+/**
+ * Sets new default values for `getDefaultViewport`
+ *
+ * @param {Object} viewport - Object that sets new default values for getDefaultViewport
+ * @returns {undefined}
+ */
+export default function (viewport: CPUFallbackViewport): void {
+  state.viewport = viewport || {};
+}
+
+export { state };

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

@@ -0,0 +1,32 @@
+import calculateTransform from './calculateTransform';
+import { CPUFallbackEnabledElement } from '../../../../types';
+
+/**
+ * Sets the canvas context transformation matrix to the pixel coordinate system.  This allows
+ * geometry to be driven using the canvas context using coordinates in the pixel coordinate system
+ * @param {EnabledElement} enabledElement The
+ * @param {CanvasRenderingContext2D} context The CanvasRenderingContext2D for the enabledElement's Canvas
+ * @param {Number} [scale] Optional scale to apply
+ * @returns {void}
+ */
+export default function (
+  enabledElement: CPUFallbackEnabledElement,
+  context: CanvasRenderingContext2D,
+  scale?: number
+): void {
+  if (enabledElement === undefined) {
+    throw new Error(
+      'setToPixelCoordinateSystem: parameter enabledElement must not be undefined'
+    );
+  }
+  if (context === undefined) {
+    throw new Error(
+      'setToPixelCoordinateSystem: parameter context must not be undefined'
+    );
+  }
+
+  const transform = calculateTransform(enabledElement, scale);
+  const m = transform.getMatrix();
+
+  context.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
+}

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

@@ -0,0 +1,58 @@
+import now from './now';
+import { IImage } from '../../../../types';
+
+/**
+ * Converts stored color pixel values to display pixel values using a LUT.
+ *
+ * Note: Skips alpha value for any input image pixel data.
+ *
+ * @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
+      storedPixelDataIndex += 2;
+      canvasImageDataIndex += 2;
+    }
+  } else {
+    while (storedPixelDataIndex < numPixels) {
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++]]; // Red
+      canvasImageDataData[canvasImageDataIndex++] =
+        lut[pixelData[storedPixelDataIndex++]]; // Green
+      canvasImageDataData[canvasImageDataIndex] =
+        lut[pixelData[storedPixelDataIndex]]; // Blue
+      storedPixelDataIndex += 2;
+      canvasImageDataIndex += 2;
+    }
+  }
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}

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

@@ -0,0 +1,76 @@
+import now from './now';
+import { IImage } from '../../../../types';
+
+/**
+ * This function transforms stored pixel values into a canvas image data buffer
+ * by using a LUT.  This is the most performance sensitive code in cornerstone and
+ * we use a special trick to make this go as fast as possible.  Specifically we
+ * use the alpha channel only to control the luminance rather than the red, green and
+ * blue channels which makes it over 3x faster. The canvasImageDataData buffer needs
+ * to be previously filled with white pixels.
+ *
+ * NOTE: Attribution would be appreciated if you use this technique!
+ *
+ * @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 = 3;
+  let storedPixelDataIndex = 0;
+
+  // 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) {
+        canvasImageDataData[canvasImageDataIndex] =
+          lut[pixelData[storedPixelDataIndex++] + -minPixelValue]; // Alpha
+        canvasImageDataIndex += 4;
+      }
+    } else {
+      while (storedPixelDataIndex < numPixels) {
+        canvasImageDataData[canvasImageDataIndex] =
+          lut[pixelData[storedPixelDataIndex++]]; // Alpha
+        canvasImageDataIndex += 4;
+      }
+    }
+  } else if (pixelData instanceof Uint16Array) {
+    while (storedPixelDataIndex < numPixels) {
+      canvasImageDataData[canvasImageDataIndex] =
+        lut[pixelData[storedPixelDataIndex++]]; // Alpha
+      canvasImageDataIndex += 4;
+    }
+  } else if (minPixelValue < 0) {
+    while (storedPixelDataIndex < numPixels) {
+      canvasImageDataData[canvasImageDataIndex] =
+        lut[pixelData[storedPixelDataIndex++] + -minPixelValue]; // Alpha
+      canvasImageDataIndex += 4;
+    }
+  } else {
+    while (storedPixelDataIndex < numPixels) {
+      canvasImageDataData[canvasImageDataIndex] =
+        lut[pixelData[storedPixelDataIndex++]]; // Alpha
+      canvasImageDataIndex += 4;
+    }
+  }
+
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}

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

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

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

@@ -0,0 +1,50 @@
+import now from './now';
+import { IImage } from '../../../../types';
+
+/**
+ * This function transforms stored pixel values into a canvas image data buffer
+ * by using a LUT.  This is the most performance sensitive code in cornerstone and
+ * we use a special trick to make this go as fast as possible.  Specifically we
+ * use the alpha channel only to control the luminance rather than the red, green and
+ * blue channels which makes it over 3x faster. The canvasImageDataData buffer needs
+ * to be previously filled with white pixels.
+ *
+ * NOTE: Attribution would be appreciated if you use this technique!
+ *
+ * @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,
+  lutFunction: (value: number) => number,
+  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 = 3;
+  let storedPixelDataIndex = 0;
+
+  // 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();
+
+  while (storedPixelDataIndex < numPixels) {
+    canvasImageDataData[canvasImageDataIndex] = lutFunction(
+      pixelData[storedPixelDataIndex++]
+    ); // Alpha
+    canvasImageDataIndex += 4;
+  }
+
+  image.stats.lastStoredPixelDataToCanvasImageDataTime = now() - start;
+}