@cornerstonejs/core 0.36.2 → 0.36.4

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

@@ -0,0 +1,47 @@
+import type { IImage, CPUFallbackViewport } from '../../../../types';
+
+/**
+ * Computes the VOI to display all the pixels if no VOI LUT data (Window Width/Window Center or voiLUT) exists on the viewport object.
+ *
+ * @param viewport - Object containing the viewport properties
+ * @param image - An Image loaded by a Cornerstone Image Loader
+ */
+export default function computeAutoVoi(
+  viewport: CPUFallbackViewport,
+  image: IImage
+): void {
+  if (hasVoi(viewport)) {
+    return;
+  }
+
+  const maxVoi = image.maxPixelValue * image.slope + image.intercept;
+  const minVoi = image.minPixelValue * image.slope + image.intercept;
+  const ww = maxVoi - minVoi;
+  const wc = (maxVoi + minVoi) / 2;
+
+  if (viewport.voi === undefined) {
+    viewport.voi = {
+      windowWidth: ww,
+      windowCenter: wc,
+    };
+  } else {
+    viewport.voi.windowWidth = ww;
+    viewport.voi.windowCenter = wc;
+  }
+}
+
+/**
+ * Check if viewport has voi LUT data
+ * @param viewport - The viewport to check for voi LUT data
+ * @returns true viewport has LUT data (Window Width/Window Center or voiLUT). Otherwise, false.
+ */
+function hasVoi(viewport: CPUFallbackViewport): boolean {
+  const hasLut =
+    viewport.voiLUT && viewport.voiLUT.lut && viewport.voiLUT.lut.length > 0;
+
+  return (
+    hasLut ||
+    (viewport.voi.windowWidth !== undefined &&
+      viewport.voi.windowCenter !== undefined)
+  );
+}

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

@@ -0,0 +1,38 @@
+import { CPUFallbackViewport, Point2 } from '../../../../types';
+
+type Shift = {
+  x: number;
+  y: number;
+};
+/**
+ * Corrects the shift by accounting for viewport rotation and flips.
+ *
+ * @param shift - The shift to correct.
+ * @param viewportOrientation - Object containing information on the viewport orientation.
+ */
+export default function (
+  shift: Shift,
+  viewportOrientation: CPUFallbackViewport
+): Shift {
+  const { hflip, vflip, rotation } = viewportOrientation;
+
+  // Apply Flips
+  shift.x *= hflip ? -1 : 1;
+  shift.y *= vflip ? -1 : 1;
+
+  // Apply rotations
+  if (rotation !== 0) {
+    const angle = (rotation * Math.PI) / 180;
+
+    const cosA = Math.cos(angle);
+    const sinA = Math.sin(angle);
+
+    const newX = shift.x * cosA - shift.y * sinA;
+    const newY = shift.x * sinA + shift.y * cosA;
+
+    shift.x = newX;
+    shift.y = newY;
+  }
+
+  return shift;
+}

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

@@ -0,0 +1,64 @@
+import { state } from './setDefaultViewport';
+import {
+  CPUFallbackViewportDisplayedArea,
+  CPUFallbackViewport,
+} from '../../../../types';
+
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Creates the default displayed area.
+ * C.10.4 Displayed Area Module: This Module describes Attributes required to define a Specified Displayed Area space.
+ *
+ * @returns {tlhc: {x,y}, brhc: {x, y},rowPixelSpacing: Number, columnPixelSpacing: Number, presentationSizeMode: Number} displayedArea object
+ * @memberof Internal
+ */
+function createDefaultDisplayedArea(): CPUFallbackViewportDisplayedArea {
+  return {
+    // Top Left Hand Corner
+    tlhc: {
+      x: 1,
+      y: 1,
+    },
+    // Bottom Right Hand Corner
+    brhc: {
+      x: 1,
+      y: 1,
+    },
+    rowPixelSpacing: 1,
+    columnPixelSpacing: 1,
+    presentationSizeMode: 'NONE',
+  };
+}
+
+/**
+ * Creates a new viewport object containing default values
+ *
+ * @returns {Viewport} viewport object
+ * @memberof Internal
+ */
+export default function createViewport(): CPUFallbackViewport {
+  const displayedArea = createDefaultDisplayedArea();
+  const initialDefaultViewport = {
+    scale: 1,
+    translation: {
+      x: 0,
+      y: 0,
+    },
+    voi: {
+      windowWidth: undefined,
+      windowCenter: undefined,
+    },
+    invert: false,
+    pixelReplication: false,
+    rotation: 0,
+    hflip: false,
+    vflip: false,
+    modalityLUT: undefined,
+    voiLUT: undefined,
+    colormap: undefined,
+    labelmap: false,
+    displayedArea,
+  };
+
+  return Object.assign({}, initialDefaultViewport, state.viewport);
+}

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

@@ -0,0 +1,36 @@
+import { CPUFallbackEnabledElement, IImage } from '../../../../types';
+
+/**
+ * Determine whether or not an Enabled Element needs to be re-rendered.
+ *
+ * If the imageId has changed, or if any of the last rendered viewport
+ * parameters have changed, this function will return true.
+ *
+ * @param enabledElement - An Enabled Element
+ * @param image - An Image
+ * @returns Whether - or not the Enabled Element needs to re-render its image
+ */
+export default function doesImageNeedToBeRendered(
+  enabledElement: CPUFallbackEnabledElement,
+  image: IImage
+): boolean {
+  const lastRenderedImageId = enabledElement.renderingTools.lastRenderedImageId;
+  const lastRenderedViewport =
+    enabledElement.renderingTools.lastRenderedViewport;
+
+  return (
+    image.imageId !== lastRenderedImageId ||
+    !lastRenderedViewport ||
+    lastRenderedViewport.windowCenter !==
+      enabledElement.viewport.voi.windowCenter ||
+    lastRenderedViewport.windowWidth !==
+      enabledElement.viewport.voi.windowWidth ||
+    lastRenderedViewport.invert !== enabledElement.viewport.invert ||
+    lastRenderedViewport.rotation !== enabledElement.viewport.rotation ||
+    lastRenderedViewport.hflip !== enabledElement.viewport.hflip ||
+    lastRenderedViewport.vflip !== enabledElement.viewport.vflip ||
+    lastRenderedViewport.modalityLUT !== enabledElement.viewport.modalityLUT ||
+    lastRenderedViewport.voiLUT !== enabledElement.viewport.voiLUT ||
+    lastRenderedViewport.colormap !== enabledElement.viewport.colormap
+  );
+}

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

@@ -0,0 +1,22 @@
+import getImageFitScale from './getImageFitScale';
+import { CPUFallbackEnabledElement } from '../../../../types';
+
+/**
+ * Adjusts an image's scale and translation so the image is centered and all pixels
+ * in the image are viewable.
+ *
+ * @param element - The Cornerstone element to update
+ */
+export default function (enabledElement: CPUFallbackEnabledElement): void {
+  const { image } = enabledElement;
+
+  // The new scale is the minimum of the horizontal and vertical scale values
+  enabledElement.viewport.scale = getImageFitScale(
+    enabledElement.canvas,
+    image,
+    enabledElement.viewport.rotation
+  ).scaleFactor;
+
+  enabledElement.viewport.translation.x = 0;
+  enabledElement.viewport.translation.y = 0;
+}

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

@@ -0,0 +1,60 @@
+import getVOILUT from './getVOILut';
+import { IImage, CPUFallbackLUT } from '../../../../types';
+
+/**
+ * Creates a LUT used while rendering to convert stored pixel values to
+ * display pixels
+ *
+ * @param image - A Cornerstone Image Object
+ * @param windowWidth - The Window Width
+ * @param windowCenter - The Window Center
+ * @param invert - A boolean describing whether or not the image has been inverted
+ * @param voiLUT- A Volume of Interest Lookup Table
+ *
+ * @returns A lookup table to apply to the image
+ */
+export default function generateColorLUT(
+  image: IImage,
+  windowWidth: number | number[],
+  windowCenter: number | number[],
+  invert: boolean,
+  voiLUT?: CPUFallbackLUT
+) {
+  const maxPixelValue = image.maxPixelValue;
+  const minPixelValue = image.minPixelValue;
+  const offset = Math.min(minPixelValue, 0);
+
+  if (image.cachedLut === undefined) {
+    const length = maxPixelValue - offset + 1;
+
+    image.cachedLut = {};
+    image.cachedLut.lutArray = new Uint8ClampedArray(length);
+  }
+
+  const lut = image.cachedLut.lutArray;
+  const vlutfn = getVOILUT(
+    Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
+    Array.isArray(windowCenter) ? windowCenter[0] : windowCenter,
+    voiLUT
+  );
+
+  if (invert === true) {
+    for (
+      let storedValue = minPixelValue;
+      storedValue <= maxPixelValue;
+      storedValue++
+    ) {
+      lut[storedValue + -offset] = 255 - vlutfn(storedValue);
+    }
+  } else {
+    for (
+      let storedValue = minPixelValue;
+      storedValue <= maxPixelValue;
+      storedValue++
+    ) {
+      lut[storedValue + -offset] = vlutfn(storedValue);
+    }
+  }
+
+  return lut;
+}

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

@@ -0,0 +1,83 @@
+import getModalityLut from './getModalityLut';
+import getVOILUT from './getVOILut';
+import { IImage, CPUFallbackLUT } from '../../../../types';
+
+/**
+ * Creates a LUT used while rendering to convert stored pixel values to
+ * display pixels
+ *
+ * @param image - A Cornerstone Image Object
+ * @param windowWidth - The Window Width
+ * @param windowCenter - The Window Center
+ * @param invert - A boolean describing whether or not the image has been inverted
+ * @param modalityLUT - A modality Lookup Table
+ * @param voiLUT - A Volume of Interest Lookup Table
+ *
+ * @returns A lookup table to apply to the image
+ */
+export default function (
+  image: IImage,
+  windowWidth: number,
+  windowCenter: number,
+  invert: boolean,
+  modalityLUT: CPUFallbackLUT,
+  voiLUT: CPUFallbackLUT
+): Uint8ClampedArray {
+  const maxPixelValue = image.maxPixelValue;
+  const minPixelValue = image.minPixelValue;
+  const offset = Math.min(minPixelValue, 0);
+
+  if (image.cachedLut === undefined) {
+    const length = maxPixelValue - offset + 1;
+
+    image.cachedLut = {};
+    image.cachedLut.lutArray = new Uint8ClampedArray(length);
+  }
+
+  const lut = image.cachedLut.lutArray;
+
+  const mlutfn = getModalityLut(image.slope, image.intercept, modalityLUT);
+  const vlutfn = getVOILUT(windowWidth, windowCenter, voiLUT);
+
+  if (image.isPreScaled) {
+    // if the image is already preScaled, it means that the slop and the intercept
+    // are applied and there is no need for a modalityLut
+    if (invert === true) {
+      for (
+        let storedValue = minPixelValue;
+        storedValue <= maxPixelValue;
+        storedValue++
+      ) {
+        lut[storedValue + -offset] = 255 - vlutfn(storedValue);
+      }
+    } else {
+      for (
+        let storedValue = minPixelValue;
+        storedValue <= maxPixelValue;
+        storedValue++
+      ) {
+        lut[storedValue + -offset] = vlutfn(storedValue);
+      }
+    }
+  } else {
+    if (invert === true) {
+      for (
+        let storedValue = minPixelValue;
+        storedValue <= maxPixelValue;
+        storedValue++
+      ) {
+        lut[storedValue + -offset] = 255 - vlutfn(mlutfn(storedValue));
+      }
+    } else {
+      for (
+        let storedValue = minPixelValue;
+        storedValue <= maxPixelValue;
+        storedValue++
+      ) {
+        lut[storedValue + -offset] = vlutfn(mlutfn(storedValue));
+      }
+    }
+  }
+
+  return lut;
+}

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

@@ -0,0 +1,88 @@
+import createViewport from './createViewport';
+import getImageFitScale from './getImageFitScale';
+import {
+  IImage,
+  CPUFallbackColormap,
+  CPUFallbackViewport,
+} from '../../../../types';
+
+/**
+ * Creates a new viewport object containing default values for the image and canvas
+ *
+ * @param canvas - A Canvas DOM element
+ * @param image - A Cornerstone Image Object
+ * @returns viewport - object
+ */
+export default function (
+  canvas: HTMLCanvasElement,
+  image: IImage,
+  modality?: string,
+  colormap?: CPUFallbackColormap
+): CPUFallbackViewport {
+  if (canvas === undefined) {
+    throw new Error(
+      'getDefaultViewport: parameter canvas must not be undefined'
+    );
+  }
+
+  if (image === undefined) {
+    return createViewport();
+  }
+
+  // Fit image to window
+  const scale = getImageFitScale(canvas, image, 0).scaleFactor;
+
+  let voi;
+
+  if (modality === 'PT' && image.isPreScaled) {
+    voi = {
+      windowWidth: 5,
+      windowCenter: 2.5,
+    };
+  } else if (
+    image.windowWidth !== undefined &&
+    image.windowCenter !== undefined
+  ) {
+    voi = {
+      windowWidth: Array.isArray(image.windowWidth)
+        ? image.windowWidth[0]
+        : image.windowWidth,
+      windowCenter: Array.isArray(image.windowCenter)
+        ? image.windowCenter[0]
+        : image.windowCenter,
+    };
+  }
+
+  return {
+    scale,
+    translation: {
+      x: 0,
+      y: 0,
+    },
+    voi,
+    invert: image.invert,
+    pixelReplication: false,
+    rotation: 0,
+    hflip: false,
+    vflip: false,
+    modalityLUT: image.modalityLUT,
+    modality,
+    voiLUT: image.voiLUT,
+    colormap: colormap !== undefined ? colormap : image.colormap,
+    displayedArea: {
+      tlhc: {
+        x: 1,
+        y: 1,
+      },
+      brhc: {
+        x: image.columns,
+        y: image.rows,
+      },
+      rowPixelSpacing:
+        image.rowPixelSpacing === undefined ? 1 : image.rowPixelSpacing,
+      columnPixelSpacing:
+        image.columnPixelSpacing === undefined ? 1 : image.columnPixelSpacing,
+      presentationSizeMode: 'NONE',
+    },
+  };
+}

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

@@ -0,0 +1,52 @@
+import { validateParameterUndefinedOrNull } from './validator';
+import getImageSize from './getImageSize';
+import { IImage } from '../../../../types';
+
+/**
+ * Calculates the horizontal, vertical and minimum scale factor for an image
+   @param canvas - The window size where the image is displayed. This can be any HTML element or structure with a width, height fields (e.g. canvas).
+ * @param image - The cornerstone image object
+ * @param rotation - The rotation angle of the image.
+ * @returns The calculated horizontal, vertical and minimum scale factor
+ */
+export default function (
+  canvas: HTMLCanvasElement,
+  image: IImage,
+  rotation: number | null = null
+): {
+  verticalScale: number;
+  horizontalScale: number;
+  scaleFactor: number;
+} {
+  validateParameterUndefinedOrNull(
+    canvas,
+    'getImageScale: parameter canvas must not be undefined'
+  );
+  validateParameterUndefinedOrNull(
+    image,
+    'getImageScale: parameter image must not be undefined'
+  );
+
+  const imageSize = getImageSize(image, rotation);
+  const rowPixelSpacing = image.rowPixelSpacing || 1;
+  const columnPixelSpacing = image.columnPixelSpacing || 1;
+  let verticalRatio = 1;
+  let horizontalRatio = 1;
+
+  if (rowPixelSpacing < columnPixelSpacing) {
+    horizontalRatio = columnPixelSpacing / rowPixelSpacing;
+  } else {
+    // even if they are equal we want to calculate this ratio (the ration might be 0.5)
+    verticalRatio = rowPixelSpacing / columnPixelSpacing;
+  }
+
+  const verticalScale = canvas.height / imageSize.height / verticalRatio;
+  const horizontalScale = canvas.width / imageSize.width / horizontalRatio;
+
+  // Fit image to window
+  return {
+    verticalScale,
+    horizontalScale,
+    scaleFactor: Math.min(horizontalScale, verticalScale),
+  };
+}

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

@@ -0,0 +1,55 @@
+import { validateParameterUndefinedOrNull } from './validator';
+import { IImage } from '../../../../types';
+
+/**
+ * Check if the angle is rotated
+ * @param {Number} rotation the rotation angle
+ * @returns {Boolean} true if the angle is rotated; Otherwise, false.
+ * @memberof Internal
+ */
+function isRotated(rotation?: number | null): boolean {
+  return !(
+    rotation === null ||
+    rotation === undefined ||
+    rotation === 0 ||
+    rotation === 180
+  );
+}
+
+/**
+ * Retrieves the current image dimensions given an enabled element
+ *
+ * @param {any} image The Cornerstone image.
+ * @param {Number} rotation Optional. The rotation angle of the image.
+ * @return {{width:Number, height:Number}} The Image dimensions
+ * @memberof Internal
+ */
+export default function (
+  image: IImage,
+  rotation = null
+): { height: number; width: number } {
+  validateParameterUndefinedOrNull(
+    image,
+    'getImageSize: parameter image must not be undefined'
+  );
+  validateParameterUndefinedOrNull(
+    image.width,
+    'getImageSize: parameter image must have width'
+  );
+  validateParameterUndefinedOrNull(
+    image.height,
+    'getImageSize: parameter image must have height'
+  );
+
+  if (isRotated(rotation)) {
+    return {
+      height: image.width,
+      width: image.height,
+    };
+  }
+
+  return {
+    width: image.width,
+    height: image.height,
+  };
+}

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

@@ -0,0 +1,53 @@
+import computeAutoVoi from './computeAutoVoi';
+import lutMatches from './lutMatches';
+import generateLut from './generateLut';
+import { IImage, CPUFallbackViewport } from '../../../../types';
+
+/**
+ * Retrieve or generate a LUT Array for an Image and Viewport
+ *
+ * @param {Image} image An Image Object
+ * @param {Viewport} viewport An Viewport Object
+ * @param {Boolean} invalidated Whether or not the LUT data has been invalidated
+ * (e.g. by a change to the windowWidth, windowCenter, or invert viewport parameters).
+ * @return {Uint8ClampedArray} LUT Array
+ * @memberof rendering
+ */
+export default function (
+  image: IImage,
+  viewport: CPUFallbackViewport,
+  invalidated: boolean
+): Uint8ClampedArray {
+  // If we have a cached lut and it has the right values, return it immediately
+  if (
+    image.cachedLut !== undefined &&
+    image.cachedLut.windowCenter === viewport.voi.windowCenter &&
+    image.cachedLut.windowWidth === viewport.voi.windowWidth &&
+    lutMatches(image.cachedLut.modalityLUT, viewport.modalityLUT) &&
+    lutMatches(image.cachedLut.voiLUT, viewport.voiLUT) &&
+    image.cachedLut.invert === viewport.invert &&
+    invalidated !== true
+  ) {
+    return image.cachedLut.lutArray;
+  }
+
+  computeAutoVoi(viewport, image);
+
+  // Lut is invalid or not present, regenerate it and cache it
+  generateLut(
+    image,
+    viewport.voi.windowWidth,
+    viewport.voi.windowCenter,
+    viewport.invert,
+    viewport.modalityLUT,
+    viewport.voiLUT
+  );
+
+  image.cachedLut.windowWidth = viewport.voi.windowWidth;
+  image.cachedLut.windowCenter = viewport.voi.windowCenter;
+  image.cachedLut.invert = viewport.invert;
+  image.cachedLut.voiLUT = viewport.voiLUT;
+  image.cachedLut.modalityLUT = viewport.modalityLUT;
+
+  return image.cachedLut.lutArray;
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Generates a linear modality transformation function
+ *
+ * See DICOM PS3.3 C.11.1 Modality LUT Module
+ *
+ * http://dicom.nema.org/medical/Dicom/current/output/chtml/part03/sect_C.11.html
+ *
+ * @param {Number} slope m in the equation specified by Rescale Intercept (0028,1052).
+ * @param {Number} intercept The value b in relationship between stored values (SV) and the output units specified in Rescale Type (0028,1054).
+
+ Output units = m*SV + b.
+ * @return {function(*): *} A linear modality LUT function. Given a stored pixel it returns the modality pixel value
+ * @memberof Internal
+ */
+function generateLinearModalityLUT(slope, intercept) {
+  return (storedPixelValue) => storedPixelValue * slope + intercept;
+}
+
+function generateNonLinearModalityLUT(modalityLUT) {
+  const minValue = modalityLUT.lut[0];
+  const maxValue = modalityLUT.lut[modalityLUT.lut.length - 1];
+  const maxValueMapped = modalityLUT.firstValueMapped + modalityLUT.lut.length;
+
+  return (storedPixelValue) => {
+    if (storedPixelValue < modalityLUT.firstValueMapped) {
+      return minValue;
+    } else if (storedPixelValue >= maxValueMapped) {
+      return maxValue;
+    }
+
+    return modalityLUT.lut[storedPixelValue];
+  };
+}
+
+/**
+ * Get the appropriate Modality LUT for the current situation.
+ *
+ * @param {Number} [slope] m in the equation specified by Rescale Intercept (0028,1052).
+ * @param {Number} [intercept] The value b in relationship between stored values (SV) and the output units specified in Rescale Type (0028,1054).
+ * @param {Function} [modalityLUT] A modality LUT function. Given a stored pixel it returns the modality pixel value.
+ *
+ * @return {function(*): *} A modality LUT function. Given a stored pixel it returns the modality pixel value.
+ * @memberof Internal
+ */
+export default function (
+  slope: number,
+  intercept: number,
+  modalityLUT: unknown
+) {
+  if (modalityLUT) {
+    return generateNonLinearModalityLUT(modalityLUT);
+  }
+
+  return generateLinearModalityLUT(slope, intercept);
+}

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

@@ -0,0 +1,17 @@
+import calculateTransform from './calculateTransform';
+import {
+  CPUFallbackEnabledElement,
+  CPUFallbackTransform,
+} from '../../../../types';
+
+export default function (
+  enabledElement: CPUFallbackEnabledElement
+): CPUFallbackTransform {
+  // Todo: for some reason using the cached transfer after the first call
+  // does not give correct transform.
+  // if (enabledElement.transform) {
+  //   return enabledElement.transform;
+  // }
+
+  return calculateTransform(enabledElement);
+}