@cornerstonejs/core 2.0.0-beta.8 → 2.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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