@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.21

package/src/utilities/getVolumeViewportsContainingSameVolumes.ts

@@ -1,58 +0,0 @@
-import { IVolumeViewport } from '../types';
-import {
-  getRenderingEngines,
-  getRenderingEngine,
-} from '../RenderingEngine/getRenderingEngine';
-
-/**
- * Returns the viewports containing the same volume actors (all actors) the same
- * as the target viewport. If renderingEngineId is provided, it will only return
- * viewports that are associated with the renderingEngineId; otherwise, it will
- * return search in all rendering engines.
- *
- * This method is useful for finding viewports that are associated with the same
- * volume (e.g., for tools that share state between viewports).
- *
- * @param viewport - target viewport
- * @returns array of viewports that have the same volume actor as the target viewport
- */
-function getVolumeViewportsContainingSameVolumes(
-  targetViewport: IVolumeViewport,
-  renderingEngineId?: string
-): Array<IVolumeViewport> {
-  // If rendering engine is not provided, use all rendering engines
-  let renderingEngines;
-  if (renderingEngineId) {
-    renderingEngines = [getRenderingEngine(renderingEngineId)];
-  } else {
-    renderingEngines = getRenderingEngines();
-  }
-
-  const sameVolumesViewports = [];
-
-  renderingEngines.forEach((renderingEngine) => {
-    const targetActors = targetViewport.getActors();
-    const viewports = renderingEngine.getVolumeViewports();
-
-    for (const vp of viewports) {
-      const vpActors = vp.getActors();
-
-      if (vpActors.length !== targetActors.length) {
-        continue;
-      }
-
-      // every targetActors should be in the vpActors
-      const sameVolumes = targetActors.every(({ uid }) =>
-        vpActors.find((vpActor) => uid === vpActor.uid)
-      );
-
-      if (sameVolumes) {
-        sameVolumesViewports.push(vp);
-      }
-    }
-  });
-
-  return sameVolumesViewports;
-}
-
-export default getVolumeViewportsContainingSameVolumes;

package/src/utilities/hasNaNValues.ts

@@ -1,12 +0,0 @@
-/**
- * A function that checks if there is a value in the array that is NaN.
- * or if the input is a number it just checks if it is NaN.
- * @param input - The input to check if it is NaN.
- * @returns - True if the input is NaN, false otherwise.
- */
-export default function hasNaNValues(input: number[] | number): boolean {
-  if (Array.isArray(input)) {
-    return input.some((value) => Number.isNaN(value));
-  }
-  return Number.isNaN(input);
-}

package/src/utilities/imageIdToURI.ts

@@ -1,10 +0,0 @@
-/**
- * Removes the data loader scheme from the imageId
- *
- * @param imageId - Image ID
- * @returns imageId without the data loader scheme
- */
-export default function imageIdToURI(imageId: string): string {
-  const colonIndex = imageId.indexOf(':');
-  return imageId.substring(colonIndex + 1);
-}

package/src/utilities/imageToWorldCoords.ts

@@ -1,57 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { metaData } from '..';
-import { Point2, Point3 } from '../types';
-
-/**
- * Given the imageId and a 2d coordinates on the image space with [0,0] being the top left corner
- * of the top left pixel, and options which includes the imageId, it returns the
- * 3d coordinates on the world space.
- * @param imageId - The image id
- * @param imageCoords - The 2d coordinates on the image
- * @returns The 3d coordinates on the world.
- *
- */
-export default function imageToWorldCoords(
-  imageId: string,
-  imageCoords: Point2
-): Point3 | undefined {
-  const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-
-  if (!imagePlaneModule) {
-    throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
-  }
-
-  const {
-    columnCosines,
-    rowCosines,
-    imagePositionPatient: origin,
-  } = imagePlaneModule;
-
-  let { columnPixelSpacing, rowPixelSpacing } = imagePlaneModule;
-  // Use ||= to convert null and 0 as well as undefined to 1
-  columnPixelSpacing ||= 1;
-  rowPixelSpacing ||= 1;
-
-  // calculate the image coordinates in the world space
-  const imageCoordsInWorld = vec3.create();
-
-  // move from origin in the direction of the row cosines with the amount of
-  // row pixel spacing times the first element of the image coordinates vector
-  vec3.scaleAndAdd(
-    imageCoordsInWorld,
-    origin,
-    rowCosines,
-    // to accommodate the [0,0] being on the top left corner of the top left pixel
-    // but the origin is at the center of the top left pixel
-    rowPixelSpacing * (imageCoords[0] - 0.5)
-  );
-
-  vec3.scaleAndAdd(
-    imageCoordsInWorld,
-    imageCoordsInWorld,
-    columnCosines,
-    columnPixelSpacing * (imageCoords[1] - 0.5)
-  );
-
-  return Array.from(imageCoordsInWorld) as Point3;
-}

package/src/utilities/index.ts

@@ -1,108 +0,0 @@
-import csUtils from './invertRgbTransferFunction';
-import createSigmoidRGBTransferFunction from './createSigmoidRGBTransferFunction';
-import getVoiFromSigmoidRGBTransferFunction from './getVoiFromSigmoidRGBTransferFunction';
-import createLinearRGBTransferFunction from './createLinearRGBTransferFunction';
-import scaleRgbTransferFunction from './scaleRgbTransferFunction';
-import triggerEvent from './triggerEvent';
-import uuidv4 from './uuidv4';
-import getMinMax from './getMinMax';
-import getRuntimeId from './getRuntimeId';
-import imageIdToURI from './imageIdToURI';
-import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
-import isEqual from './isEqual';
-import isOpposite from './isOpposite';
-import createUint8SharedArray from './createUint8SharedArray';
-import createFloat32SharedArray from './createFloat32SharedArray';
-import createUint16SharedArray from './createUInt16SharedArray';
-import createInt16SharedArray from './createInt16SharedArray';
-import getClosestImageId from './getClosestImageId';
-import getSpacingInNormalDirection from './getSpacingInNormalDirection';
-import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
-import getVolumeActorCorners from './getVolumeActorCorners';
-import indexWithinDimensions from './indexWithinDimensions';
-import getVolumeViewportsContainingSameVolumes from './getVolumeViewportsContainingSameVolumes';
-import getViewportsWithVolumeId from './getViewportsWithVolumeId';
-import transformWorldToIndex from './transformWorldToIndex';
-import loadImageToCanvas from './loadImageToCanvas';
-import renderToCanvasCPU from './renderToCanvasCPU';
-import renderToCanvasGPU from './renderToCanvasGPU';
-import worldToImageCoords from './worldToImageCoords';
-import imageToWorldCoords from './imageToWorldCoords';
-import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo';
-import getVolumeViewportScrollInfo from './getVolumeViewportScrollInfo';
-import getSliceRange from './getSliceRange';
-import snapFocalPointToSlice from './snapFocalPointToSlice';
-import getImageSliceDataForVolumeViewport from './getImageSliceDataForVolumeViewport';
-import { isImageActor, actorIsA } from './actorCheck';
-import getViewportsWithImageURI from './getViewportsWithImageURI';
-import getClosestStackImageIndexForPoint from './getClosestStackImageIndexForPoint';
-import calculateViewportsSpatialRegistration from './calculateViewportsSpatialRegistration';
-import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
-import getViewportImageCornersInWorld from './getViewportImageCornersInWorld';
-import hasNaNValues from './hasNaNValues';
-import applyPreset from './applyPreset';
-import deepMerge from './deepMerge';
-import getScalingParameters from './getScalingParameters';
-import getScalarDataType from './getScalarDataType';
-import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
-import getImageLegacy from './getImageLegacy';
-
-// name spaces
-import * as planar from './planar';
-import * as windowLevel from './windowLevel';
-import * as colormap from './colormap';
-
-export {
-  csUtils as invertRgbTransferFunction,
-  createSigmoidRGBTransferFunction,
-  getVoiFromSigmoidRGBTransferFunction,
-  createLinearRGBTransferFunction,
-  scaleRgbTransferFunction,
-  triggerEvent,
-  imageIdToURI,
-  calibratedPixelSpacingMetadataProvider,
-  uuidv4,
-  planar,
-  getMinMax,
-  getRuntimeId,
-  isEqual,
-  isOpposite,
-  createFloat32SharedArray,
-  createUint8SharedArray,
-  createUint16SharedArray,
-  createInt16SharedArray,
-  windowLevel,
-  getClosestImageId,
-  getSpacingInNormalDirection,
-  getTargetVolumeAndSpacingInNormalDir,
-  getVolumeActorCorners,
-  indexWithinDimensions,
-  getVolumeViewportsContainingSameVolumes,
-  getViewportsWithVolumeId,
-  transformWorldToIndex,
-  loadImageToCanvas,
-  renderToCanvasCPU,
-  renderToCanvasGPU,
-  worldToImageCoords,
-  imageToWorldCoords,
-  getVolumeSliceRangeInfo,
-  getVolumeViewportScrollInfo,
-  getSliceRange,
-  snapFocalPointToSlice,
-  getImageSliceDataForVolumeViewport,
-  isImageActor,
-  isPTPrescaledWithSUV,
-  actorIsA,
-  getViewportsWithImageURI,
-  getClosestStackImageIndexForPoint,
-  calculateViewportsSpatialRegistration,
-  spatialRegistrationMetadataProvider,
-  getViewportImageCornersInWorld,
-  hasNaNValues,
-  applyPreset,
-  deepMerge,
-  getScalingParameters,
-  getScalarDataType,
-  colormap,
-  getImageLegacy,
-};

package/src/utilities/indexWithinDimensions.ts

@@ -1,27 +0,0 @@
-import { Point3 } from '../types';
-
-/**
- * Returns true if the specified index is within the given dimensions.
- *
- * @param index - The index to check.
- * @param dimensions - The dimensions to check against.
- *
- * @returns True if the index is in-bounds.
- */
-export default function indexWithinDimensions(
-  index: Point3,
-  dimensions: Point3
-): boolean {
-  if (
-    index[0] < 0 ||
-    index[0] >= dimensions[0] ||
-    index[1] < 0 ||
-    index[1] >= dimensions[1] ||
-    index[2] < 0 ||
-    index[2] >= dimensions[2]
-  ) {
-    return false;
-  }
-
-  return true;
-}

package/src/utilities/invertRgbTransferFunction.ts

@@ -1,41 +0,0 @@
-/**
- * A utility that can be used to invert (in place) an RgbTransferFunction.
- *
- * @example
- * Grabbing a reference to the RGB Transfer function from the viewport:
- * ```
- * const rgbTransferFunction = viewport
- *   .getActor()
- *   .getProperty()
- *   .getRGBTransferFunction(0);
- *
- * rgbTransferFunction.setRange(0, 5);
- *
- * invertRgbTransferFunction(rgbTransferFunction);
- * ```
- *
- * @see {@link https://kitware.github.io/vtk-js/api/Rendering_Core_ColorTransferFunction.html|VTK.js: ColorTransferFunction}
- * @param rgbTransferFunction
- */
-export default function invertRgbTransferFunction(
-  rgbTransferFunction: any
-): void {
-  // cut in case there is no function at all
-  if (!rgbTransferFunction) {
-    return;
-  }
-
-  const size = rgbTransferFunction.getSize();
-
-  for (let index = 0; index < size; index++) {
-    const nodeValue1 = [];
-
-    rgbTransferFunction.getNodeValue(index, nodeValue1);
-
-    nodeValue1[1] = 1 - nodeValue1[1];
-    nodeValue1[2] = 1 - nodeValue1[2];
-    nodeValue1[3] = 1 - nodeValue1[3];
-
-    rgbTransferFunction.setNodeValue(index, nodeValue1);
-  }
-}

package/src/utilities/isEqual.ts

@@ -1,65 +0,0 @@
-function areNumbersEqualWithTolerance(
-  num1: number,
-  num2: number,
-  tolerance: number
-): boolean {
-  return Math.abs(num1 - num2) <= tolerance;
-}
-
-function areArraysEqual(
-  arr1: ArrayLike<number>,
-  arr2: ArrayLike<number>,
-  tolerance = 1e-5
-): boolean {
-  if (arr1.length !== arr2.length) {
-    return false;
-  }
-
-  for (let i = 0; i < arr1.length; i++) {
-    if (!areNumbersEqualWithTolerance(arr1[i], arr2[i], tolerance)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function isNumberType(value: any): value is number {
-  return typeof value === 'number';
-}
-
-function isNumberArrayLike(value: any): value is ArrayLike<number> {
-  return 'length' in value && typeof value[0] === 'number';
-}
-
-/**
- * Returns whether two values are equal or not, based on epsilon comparison.
- * For array comparison, it does NOT strictly compare them but only compare its values.
- * It can compare array of numbers and also typed array. Otherwise it will just return false.
- *
- * @param v1 - The first value to compare
- * @param v2 - The second value to compare
- * @param tolerance - The acceptable tolerance, the default is 0.00001
- *
- * @returns True if the two values are within the tolerance levels.
- */
-export default function isEqual<ValueType>(
-  v1: ValueType,
-  v2: ValueType,
-  tolerance = 1e-5
-): boolean {
-  // values must be the same type or not null
-  if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
-    return false;
-  }
-
-  if (isNumberType(v1) && isNumberType(v2)) {
-    return areNumbersEqualWithTolerance(v1, v2, tolerance);
-  }
-
-  if (isNumberArrayLike(v1) && isNumberArrayLike(v2)) {
-    return areArraysEqual(v1, v2, tolerance);
-  }
-
-  return false;
-}

package/src/utilities/isOpposite.ts

@@ -1,23 +0,0 @@
-import type Point3 from '../types/Point3';
-
-/**
- * returns equal if the two vec3s are opposite within the
- * given tolerance in each dimension.
- *
- * @param v1 - The first 3 vector
- * @param v2 - The second 3 vector.
- * @param tolerance - The acceptable tolerance.
- *
- * @returns True if the two values are within the tolerance levels.
- */
-export default function isOpposite(
-  v1: Point3,
-  v2: Point3,
-  tolerance = 1e-5
-): boolean {
-  return (
-    Math.abs(v1[0] + v2[0]) < tolerance &&
-    Math.abs(v1[1] + v2[1]) < tolerance &&
-    Math.abs(v1[2] + v2[2]) < tolerance
-  );
-}

package/src/utilities/isPTPrescaledWithSUV.ts

@@ -1,7 +0,0 @@
-import { IImage } from '../types';
-
-const isPTPrescaledWithSUV = (image: IImage) => {
-  return image.preScale?.scaled && image.preScale.scalingParameters?.suvbw;
-};
-
-export default isPTPrescaledWithSUV;

package/src/utilities/isTypedArray.ts

@@ -1,20 +0,0 @@
-/**
- * checks if an object is an instance of a TypedArray
- *
- * @param obj - Object to check
- *
- * @returns True if the object is a TypedArray.
- */
-export default function isTypedArray(obj: any): boolean {
-  return (
-    obj instanceof Int8Array ||
-    obj instanceof Uint8Array ||
-    obj instanceof Uint8ClampedArray ||
-    obj instanceof Int16Array ||
-    obj instanceof Uint16Array ||
-    obj instanceof Int32Array ||
-    obj instanceof Uint32Array ||
-    obj instanceof Float32Array ||
-    obj instanceof Float64Array
-  );
-}

package/src/utilities/loadImageToCanvas.ts

@@ -1,103 +0,0 @@
-import { IImage } from '../types';
-
-import { loadAndCacheImage } from '../loaders/imageLoader';
-import * as metaData from '../metaData';
-import { RequestType } from '../enums';
-import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
-import renderToCanvasGPU from './renderToCanvasGPU';
-import renderToCanvasCPU from './renderToCanvasCPU';
-import { getConfiguration } from '../init';
-
-interface LoadImageOptions {
-  canvas: HTMLCanvasElement;
-  imageId: string;
-  requestType?: RequestType;
-  priority?: number;
-  renderingEngineId?: string;
-  useCPURendering?: boolean;
-}
-
-/**
- * Loads and renders an imageId to a Canvas. It will use the GPU rendering pipeline
- * for image by default but you can force the CPU rendering pipeline by setting the
- * useCPURendering parameter to true.
- *
- * @example
- * ```
- * const canvas = document.getElementById('myCanvas')
- * const imageId = 'myImageId'
- *
- * loadImageToCanvas(canvas, imageId)
- * ```
- * @param canvas - Canvas element to render to
- * @param imageId - The imageId to render
- * @param requestType - The type of request (default to interaction), can be 'interaction' or 'prefetch' or 'thumbnail'
- * the order of loading for the pool manager is interaction, thumbnail, prefetch
- * @param priority - The priority of the request within the request type (lower is higher priority)
- * @param useCPURendering - Force the use of the CPU rendering pipeline (default to false)
- * @returns - A promise that resolves when the image has been rendered with the imageId
- */
-export default function loadImageToCanvas(
-  options: LoadImageOptions
-): Promise<string> {
-  const {
-    canvas,
-    imageId,
-    requestType = RequestType.Thumbnail,
-    priority = -5,
-    renderingEngineId = '_thumbnails',
-    useCPURendering = false,
-  } = options;
-
-  const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
-
-  return new Promise((resolve, reject) => {
-    function successCallback(image: IImage, imageId: string) {
-      const { modality } = metaData.get('generalSeriesModule', imageId) || {};
-
-      image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
-
-      renderFn(canvas, image, modality, renderingEngineId).then(() => {
-        resolve(imageId);
-      });
-    }
-
-    function errorCallback(error: Error, imageId: string) {
-      console.error(error, imageId);
-      reject(error);
-    }
-
-    function sendRequest(imageId, imageIdIndex, options) {
-      return loadAndCacheImage(imageId, options).then(
-        (image) => {
-          successCallback.call(this, image, imageId);
-        },
-        (error) => {
-          errorCallback.call(this, error, imageId);
-        }
-      );
-    }
-
-    const { useNorm16Texture } = getConfiguration().rendering;
-
-    // IMPORTANT: Request type should be passed if not the 'interaction'
-    // highest priority will be used for the request type in the imageRetrievalPool
-    const options = {
-      targetBuffer: {
-        type: useNorm16Texture ? undefined : 'Float32Array',
-      },
-      preScale: {
-        enabled: true,
-      },
-      useRGBA: !!useCPURendering,
-      requestType,
-    };
-
-    imageLoadPoolManager.addRequest(
-      sendRequest.bind(null, imageId, null, options),
-      requestType,
-      { imageId },
-      priority
-    );
-  });
-}

package/src/utilities/planar.ts

@@ -1,91 +0,0 @@
-import { Point3, Plane } from '../types';
-import { vec3, mat3 } from 'gl-matrix';
-
-/**
- * It calculates the intersection of a line and a plane.
- * Plane equation is Ax+By+Cz=D
- * @param p0 - [x,y,z] of the first point of the line
- * @param p1 - [x,y,z] of the second point of the line
- * @param plane - [A, B, C, D] Plane parameter: Ax+By+Cz=D
- * @returns - [X,Y,Z] coordinates of the intersection
- */
-function linePlaneIntersection(p0: Point3, p1: Point3, plane: Plane): Point3 {
-  const [x0, y0, z0] = p0;
-  const [x1, y1, z1] = p1;
-  const [A, B, C, D] = plane;
-  const a = x1 - x0;
-  const b = y1 - y0;
-  const c = z1 - z0;
-  const t = (-1 * (A * x0 + B * y0 + C * z0 - D)) / (A * a + B * b + C * c);
-  const X = a * t + x0;
-  const Y = b * t + y0;
-  const Z = c * t + z0;
-
-  return [X, Y, Z];
-}
-
-/**
- * It returns the plane equation defined by a point and a normal vector.
- * @param normal - normal vector
- * @param point - a point on the plane
- * @returns - [A, B,C, D] of plane equation A*X + B*Y + C*Z = D
- */
-function planeEquation(normal: Point3, point: Point3 | vec3): Plane {
-  const [A, B, C] = normal;
-  const D = A * point[0] + B * point[1] + C * point[2];
-  return [A, B, C, D];
-}
-
-/**
- * Computes the intersection of three planes in 3D space with equations:
- * A1*X + B1*Y + C1*Z = D1
- * A2*X + B2*Y + C2*Z = D2
- * A3*X + B3*Y + C3*Z = D3
- * @returns - [x, y, z] the intersection in the world coordinate
- */
-function threePlaneIntersection(
-  firstPlane: Plane,
-  secondPlane: Plane,
-  thirdPlane: Plane
-): Point3 {
-  const [A1, B1, C1, D1] = firstPlane;
-  const [A2, B2, C2, D2] = secondPlane;
-  const [A3, B3, C3, D3] = thirdPlane;
-  const m0 = mat3.fromValues(A1, A2, A3, B1, B2, B3, C1, C2, C3);
-  const m1 = mat3.fromValues(D1, D2, D3, B1, B2, B3, C1, C2, C3);
-  const m2 = mat3.fromValues(A1, A2, A3, D1, D2, D3, C1, C2, C3);
-  const m3 = mat3.fromValues(A1, A2, A3, B1, B2, B3, D1, D2, D3);
-
-  // TODO: handle no intersection scenario
-  const x = mat3.determinant(m1) / mat3.determinant(m0);
-  const y = mat3.determinant(m2) / mat3.determinant(m0);
-  const z = mat3.determinant(m3) / mat3.determinant(m0);
-  return [x, y, z];
-}
-
-/**
- * Computes the distance of a point in 3D space to a plane
- * @param plane - [A, B, C, D] of plane equation A*X + B*Y + C*Z = D
- * @param point - [A, B, C] the plane in World coordinate
- * @param signed - if true, the distance is signed
- * @returns - the distance of the point to the plane
- * */
-function planeDistanceToPoint(
-  plane: Plane,
-  point: Point3,
-  signed = false
-): number {
-  const [A, B, C, D] = plane;
-  const [x, y, z] = point;
-  const numerator = A * x + B * y + C * z - D;
-  const distance = Math.abs(numerator) / Math.sqrt(A * A + B * B + C * C);
-  const sign = signed ? Math.sign(numerator) : 1;
-  return sign * distance;
-}
-
-export {
-  linePlaneIntersection,
-  planeEquation,
-  threePlaneIntersection,
-  planeDistanceToPoint,
-};

package/src/utilities/renderToCanvasCPU.ts

@@ -1,36 +0,0 @@
-import { IImage, CPUFallbackEnabledElement } from '../types';
-
-import getDefaultViewport from '../RenderingEngine/helpers/cpuFallback/rendering/getDefaultViewport';
-import calculateTransform from '../RenderingEngine/helpers/cpuFallback/rendering/calculateTransform';
-import drawImageSync from '../RenderingEngine/helpers/cpuFallback/drawImageSync';
-
-/**
- * Renders a cornerstone image object to a canvas.
- * Note: this does not load the image but only takes care of the rendering pipeline
- *
- * @param image - Cornerstone image object
- * @param canvas - Canvas element to render to
- */
-export default function renderToCanvasCPU(
-  canvas: HTMLCanvasElement,
-  image: IImage,
-  modality?: string,
-  renderingEngineId?: string
-): Promise<string> {
-  const viewport = getDefaultViewport(canvas, image, modality);
-
-  const enabledElement: CPUFallbackEnabledElement = {
-    canvas,
-    viewport,
-    image,
-    renderingTools: {},
-  };
-
-  enabledElement.transform = calculateTransform(enabledElement);
-
-  const invalidated = true;
-  return new Promise((resolve, reject) => {
-    drawImageSync(enabledElement, invalidated);
-    resolve(image.imageId);
-  });
-}