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

package/src/utilities/createLinearRGBTransferFunction.ts

@@ -1,22 +0,0 @@
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { VOIRange } from '../types';
-
-export default function createLinearRGBTransferFunction(
-  voiRange: VOIRange
-): vtkColorTransferFunction {
-  const cfun = vtkColorTransferFunction.newInstance();
-  let lower = 0;
-  let upper = 1024;
-  if (
-    voiRange &&
-    voiRange.lower !== undefined &&
-    voiRange.upper !== undefined
-  ) {
-    lower = voiRange.lower;
-    upper = voiRange.upper;
-  }
-  cfun.addRGBPoint(lower, 0.0, 0.0, 0.0);
-  cfun.addRGBPoint(upper, 1.0, 1.0, 1.0);
-
-  return cfun;
-}

package/src/utilities/createSigmoidRGBTransferFunction.ts

@@ -1,63 +0,0 @@
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import { VOIRange } from '../types';
-import { windowLevel as windowLevelUtil } from '.';
-
-/**
- * A utility that can be used to generate an Sigmoid RgbTransferFunction.
- * Sigmoid transfer functions are used in the dicom specification:
- * https://dicom.nema.org/medical/dicom/2018b/output/chtml/part03/sect_C.11.2.html
- *
- * @example
- * Setting an RGB Transfer function from the viewport:
- * ```
- * const sigmoidRGBTransferFunction = createSigmoidRGBTransferFunction(0, 255, { lower: 0, upper: 255} );
- * viewport
- *   .getActor()
- *   .getProperty()
- *   .setRGBTransferFunction(0, sigmoidRGBTransferFunction);
- * ```
- *
- * @see {@link https://kitware.github.io/vtk-js/api/Rendering_Core_ColorTransferFunction.html|VTK.js: ColorTransferFunction}
- * @param rgbTransferFunction
- */
-export default function createSigmoidRGBTransferFunction(
-  voiRange: VOIRange,
-  approximationNodes = 1024 // humans can precieve no more than 900 shades of gray doi: 10.1007/s10278-006-1052-3
-): vtkColorTransferFunction {
-  const { windowWidth, windowCenter } = windowLevelUtil.toWindowLevel(
-    voiRange.lower,
-    voiRange.upper
-  );
-
-  // Function is defined by dicom spec
-  // https://dicom.nema.org/medical/dicom/2018b/output/chtml/part03/sect_C.11.2.html
-  const sigmoid = (x: number, wc: number, ww: number) => {
-    return 1 / (1 + Math.exp((-4 * (x - wc)) / ww));
-  };
-
-  // This function is the analytical inverse of the dicom spec sigmoid function
-  // for values y = [0, 1] exclusive. We use this to perform better sampling of
-  // points for the LUT as some images can have 2^16 unique values. This method
-  // can be deprecated if vtk supports LUTFunctions rather than look up tables
-  // or if vtk supports logistic scale. It currently only supports linear and
-  // log10 scaling which can be set on the vtkColorTransferFunction
-  const logit = (y: number, wc: number, ww: number) => {
-    return wc - (ww / 4) * Math.log((1 - y) / y);
-  };
-
-  // we slice out the first and last value to avoid 0 and 1 Infinity values
-  const range = [...Array(approximationNodes + 2).keys()]
-    .map((v) => v / (approximationNodes + 2))
-    .slice(1, -1);
-  const table = range.reduce((res, y) => {
-    const x = logit(y, windowCenter, windowWidth);
-    return res.concat(x, y, y, y, 0.5, 0.0);
-  }, []);
-
-  const cfun = vtkColorTransferFunction.newInstance();
-  cfun.buildFunctionFromArray(
-    vtkDataArray.newInstance({ values: table, numberOfComponents: 6 })
-  );
-  return cfun;
-}

package/src/utilities/createUInt16SharedArray.ts

@@ -1,43 +0,0 @@
-import global from '../global';
-/**
- * A helper function that creates a new Uint16 that utilized a shared
- * array buffer. This allows the array to be updated  simultaneously in
- * workers or the main thread. Depending on the system (the CPU, the OS, the Browser)
- * it can take a while until the change is propagated to all contexts.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer|MDN: SharedArrayBuffer}
- * @remarks
- * We use SharedArrayBuffers in our ImageCache class. It's what allows us to
- * stream data to build a volume. It's important to note that SharedArrayBuffer
- * does not work out of the box for all web browsers. In some, it is disabled
- * behind a flag; in others, it has been removed entirely.
- *
- * @example
- * Creating an array for a Volume with known dimensions:
- * ```
- * const dimensions = [512, 512, 25];
- * const scalarData = createUint16SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
- * ```
- *
- * @param length - frame size * number of frames
- * @returns a Uint8Array with an underlying SharedArrayBuffer
- * @public
- */
-function createUint16SharedArray(length: number): Uint16Array {
-  if (!window.crossOriginIsolated) {
-    throw new Error(
-      'Your page is NOT cross-origin isolated, see https://developer.mozilla.org/en-US/docs/Web/API/crossOriginIsolated'
-    );
-  }
-  if (window.SharedArrayBuffer === undefined) {
-    throw new Error(
-      'SharedArrayBuffer is NOT supported in your browser see https://developer.chrome.com/blog/enabling-shared-array-buffer/'
-    );
-  }
-
-  const sharedArrayBuffer = new SharedArrayBuffer(length * 2);
-
-  return new Uint16Array(sharedArrayBuffer);
-}
-
-export default createUint16SharedArray;

package/src/utilities/createUint8SharedArray.ts

@@ -1,45 +0,0 @@
-import global from '../global';
-import { getShouldUseSharedArrayBuffer } from '../init';
-
-/**
- * A helper function that creates a new Float32Array that utilized a shared
- * array buffer. This allows the array to be updated  simultaneously in
- * workers or the main thread. Depending on the system (the CPU, the OS, the Browser)
- * it can take a while until the change is propagated to all contexts.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer|MDN: SharedArrayBuffer}
- * @remarks
- * We use SharedArrayBuffers in our ImageCache class. It's what allows us to
- * stream data to build a volume. It's important to note that SharedArrayBuffer
- * does not work out of the box for all web browsers. In some, it is disabled
- * behind a flag; in others, it has been removed entirely.
- *
- * @example
- * Creating an array for a Volume with known dimensions:
- * ```
- * const dimensions = [512, 512, 25];
- * const scalarData = createUint8SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
- * ```
- *
- * @param length - frame size * number of frames
- * @returns a Uint8Array with an underlying SharedArrayBuffer
- * @public
- */
-function createUint8SharedArray(length: number): Uint8Array {
-  if (!getShouldUseSharedArrayBuffer()) {
-    throw new Error(
-      'Your page is NOT cross-origin isolated, see https://developer.mozilla.org/en-US/docs/Web/API/crossOriginIsolated'
-    );
-  }
-  if (window.SharedArrayBuffer === undefined) {
-    throw new Error(
-      'SharedArrayBuffer is NOT supported in your browser see https://developer.chrome.com/blog/enabling-shared-array-buffer/'
-    );
-  }
-
-  const sharedArrayBuffer = new SharedArrayBuffer(length);
-
-  return new Uint8Array(sharedArrayBuffer);
-}
-
-export default createUint8SharedArray;

package/src/utilities/deepFreeze.ts

@@ -1,19 +0,0 @@
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze#examples
-function deepFreeze(object) {
-  // Retrieve the property names defined on object
-  const propNames = Object.getOwnPropertyNames(object);
-
-  // Freeze properties before freezing self
-
-  for (const name of propNames) {
-    const value = object[name];
-
-    if (value && typeof value === 'object') {
-      deepFreeze(value);
-    }
-  }
-
-  return Object.freeze(object);
-}
-
-export default deepFreeze;

package/src/utilities/deepMerge.ts

@@ -1,81 +0,0 @@
-const isMergeableObject = (val) => {
-  const nonNullObject = val && typeof val === 'object';
-
-  return (
-    nonNullObject &&
-    Object.prototype.toString.call(val) !== '[object RegExp]' &&
-    Object.prototype.toString.call(val) !== '[object Date]'
-  );
-};
-
-const emptyTarget = (val) => {
-  const isEmpty = Array.isArray(val) ? [] : {};
-
-  return isEmpty;
-};
-
-const cloneIfNecessary = (value, optionsArgument) => {
-  const clone = optionsArgument && optionsArgument.clone === true;
-
-  return clone && isMergeableObject(value)
-    ? deepMerge(emptyTarget(value), value, optionsArgument)
-    : value;
-};
-
-const defaultArrayMerge = (target, source, optionsArgument) => {
-  const destination = target.slice();
-
-  source.forEach(function (e, i) {
-    if (typeof destination[i] === 'undefined') {
-      destination[i] = cloneIfNecessary(e, optionsArgument);
-    } else if (isMergeableObject(e)) {
-      destination[i] = deepMerge(target[i], e, optionsArgument);
-    } else if (target.indexOf(e) === -1) {
-      destination.push(cloneIfNecessary(e, optionsArgument));
-    }
-  });
-
-  return destination;
-};
-
-const mergeObject = (target, source, optionsArgument) => {
-  const destination = {};
-
-  if (isMergeableObject(target)) {
-    Object.keys(target).forEach(function (key) {
-      destination[key] = cloneIfNecessary(target[key], optionsArgument);
-    });
-  }
-  Object.keys(source).forEach(function (key) {
-    if (!isMergeableObject(source[key]) || !target[key]) {
-      destination[key] = cloneIfNecessary(source[key], optionsArgument);
-    } else {
-      destination[key] = deepMerge(target[key], source[key], optionsArgument);
-    }
-  });
-
-  return destination;
-};
-
-/**
- * Merge two objects, recursively merging any objects that are arrays
- * @param target - The target object.
- * @param source - The source object to merge into the target object.
- * @param optionsArgument - The options object.
- * @returns The merged object.
- */
-const deepMerge = (target = {}, source = {}, optionsArgument = undefined) => {
-  const array = Array.isArray(source);
-  const options = optionsArgument || { arrayMerge: defaultArrayMerge };
-  const arrayMerge = options.arrayMerge || defaultArrayMerge;
-
-  if (array) {
-    return Array.isArray(target)
-      ? arrayMerge(target, source, optionsArgument)
-      : cloneIfNecessary(source, optionsArgument);
-  }
-
-  return mergeObject(target, source, optionsArgument);
-};
-
-export default deepMerge;

package/src/utilities/getClosestImageId.ts

@@ -1,79 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import * as metaData from '../metaData';
-import type { IImageVolume, Point3 } from '../types';
-
-import getSpacingInNormalDirection from './getSpacingInNormalDirection';
-import { EPSILON } from '../constants';
-
-/**
- * Given an image, a point in space and the viewPlaneNormal it returns the
- * closest imageId of the image volume that is within half voxel spacing
- * of the point in space.
- * @param imageVolume - The image volume
- * @param worldPos - The position in the world coordinate system (from mouse click)
- * @param viewPlaneNormal - The normal vector of the viewport
- *
- * @returns The imageId for the tool.
- */
-export default function getClosestImageId(
-  imageVolume: IImageVolume,
-  worldPos: Point3,
-  viewPlaneNormal: Point3
-): string {
-  if (!imageVolume) {
-    return;
-  }
-
-  const { direction, imageIds } = imageVolume;
-
-  if (!imageIds || !imageIds.length) {
-    return;
-  }
-
-  // 1. Get ScanAxis vector
-  const kVector = direction.slice(6, 9);
-
-  // 2. Check if scanAxis is not parallel to camera viewPlaneNormal
-  const dotProducts = vec3.dot(kVector as Point3, <vec3>viewPlaneNormal);
-
-  // 2.a if imagePlane is not parallel to the camera: tool is not drawn on an
-  // imaging plane, return
-  if (Math.abs(dotProducts) < 1 - EPSILON) {
-    return;
-  }
-
-  // 3. Calculate Spacing the in the normal direction, this will get used to
-  // check whether we are withing a slice
-  const spacingInNormalDirection = getSpacingInNormalDirection(
-    imageVolume,
-    viewPlaneNormal
-  );
-
-  const halfSpacingInNormalDirection = spacingInNormalDirection / 2;
-
-  // 4. Iterate over all imageIds and check if the tool point (worldPos) is
-  // withing one of the slices defined by an imageId
-  let imageIdForTool;
-  for (let i = 0; i < imageIds.length; i++) {
-    const imageId = imageIds[i];
-
-    // 4.a Get metadata for the imageId
-    const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
-
-    // 4.b Calculate the direction vector from annotation. point to the first voxel
-    // of this image defined by imageId
-    const dir = vec3.create();
-    vec3.sub(dir, worldPos, imagePositionPatient);
-
-    // 4.c Calculate the distance between the vector above and the viewplaneNormal
-    // i.e., projected distance
-    const dot = vec3.dot(dir, viewPlaneNormal);
-
-    // 4.d If the distance is withing range, return the imageId
-    if (Math.abs(dot) < halfSpacingInNormalDirection) {
-      imageIdForTool = imageId;
-    }
-  }
-
-  return imageIdForTool;
-}

package/src/utilities/getClosestStackImageIndexForPoint.ts

@@ -1,128 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { planar } from '.';
-import { metaData } from '..';
-import { IStackViewport, Point3 } from '../types';
-
-/**
- * Given a point in 3D space and a viewport it returns the index of the closest imageId, it assumes that stack images are sorted according to their sliceLocation
- * @param point - [A, B, C] coordinates of the point in 3D space
- * @param viewport - The StackViewport to search for the closest imageId
- *
- * @returns The imageId index of the closest imageId or null if no imageId is found
- */
-export default function getClosestStackImageIndexForPoint(
-  point: Point3,
-  viewport: IStackViewport
-): number | null {
-  const minimalDistance = calculateMinimalDistanceForStackViewport(
-    point,
-    viewport
-  );
-  return minimalDistance ? minimalDistance.index : null;
-}
-
-//assumes that imageIds are sorted by slice location
-export function calculateMinimalDistanceForStackViewport(
-  point: Point3,
-  viewport: IStackViewport
-): { distance: number; index: number } | null {
-  const imageIds = viewport.getImageIds();
-  const currentImageIdIndex = viewport.getCurrentImageIdIndex();
-
-  if (imageIds.length === 0) {
-    return null;
-  }
-
-  const getDistance = (imageId: string): null | number => {
-    const planeMetadata = getPlaneMetadata(imageId);
-    if (!planeMetadata) {
-      return null;
-    }
-    const plane = planar.planeEquation(
-      planeMetadata.planeNormal,
-      planeMetadata.imagePositionPatient
-    );
-    const distance = planar.planeDistanceToPoint(plane, point);
-    return distance;
-  };
-
-  const closestStack = {
-    distance: getDistance(imageIds[currentImageIdIndex]) ?? Infinity,
-    index: currentImageIdIndex,
-  };
-
-  //check higher indices
-  const higherImageIds = imageIds.slice(currentImageIdIndex + 1);
-
-  for (let i = 0; i < higherImageIds.length; i++) {
-    const id = higherImageIds[i];
-    const distance = getDistance(id);
-    if (distance === null) {
-      continue;
-    }
-    if (distance <= closestStack.distance) {
-      closestStack.distance = distance;
-      closestStack.index = i + currentImageIdIndex + 1;
-    } else {
-      break;
-    }
-  }
-  //check lower indices
-  const lowerImageIds = imageIds.slice(0, currentImageIdIndex);
-  for (let i = lowerImageIds.length - 1; i >= 0; i--) {
-    const id = lowerImageIds[i];
-    const distance = getDistance(id);
-    if (distance === null || distance === closestStack.distance) {
-      continue;
-    }
-    if (distance < closestStack.distance) {
-      closestStack.distance = distance;
-      closestStack.index = i;
-    } else {
-      break;
-    }
-  }
-  return closestStack.distance === Infinity ? null : closestStack;
-}
-
-function getPlaneMetadata(imageId: string): null | {
-  rowCosines: Point3;
-  columnCosines: Point3;
-  imagePositionPatient: Point3;
-  planeNormal: Point3;
-} {
-  const targetImagePlane = metaData.get('imagePlaneModule', imageId);
-
-  if (
-    !targetImagePlane ||
-    !(
-      targetImagePlane.rowCosines instanceof Array &&
-      targetImagePlane.rowCosines.length === 3
-    ) ||
-    !(
-      targetImagePlane.columnCosines instanceof Array &&
-      targetImagePlane.columnCosines.length === 3
-    ) ||
-    !(
-      targetImagePlane.imagePositionPatient instanceof Array &&
-      targetImagePlane.imagePositionPatient.length === 3
-    )
-  ) {
-    return null;
-  }
-  const {
-    rowCosines,
-    columnCosines,
-    imagePositionPatient,
-  }: {
-    rowCosines: Point3;
-    columnCosines: Point3;
-    imagePositionPatient: Point3;
-  } = targetImagePlane;
-
-  const rowVec = vec3.set(vec3.create(), ...rowCosines);
-  const colVec = vec3.set(vec3.create(), ...columnCosines);
-  const planeNormal = vec3.cross(vec3.create(), rowVec, colVec) as Point3;
-
-  return { rowCosines, columnCosines, imagePositionPatient, planeNormal };
-}

package/src/utilities/getImageLegacy.ts

@@ -1,29 +0,0 @@
-import { StackViewport, Types } from '..';
-import getEnabledElement from '../getEnabledElement';
-
-/**
- * Gets the IImage rendered by the given element. This is provided as a
- * convenience for the legacy cornerstone getImage function. However it is
- * encouraged for IStackViewport.getImage to be used instead.
- * @param element - the element rendering/containing the image
- * @returns the image
- */
-function getImageLegacy(element: HTMLDivElement): Types.IImage | undefined {
-  const enabledElement = getEnabledElement(element);
-
-  if (!enabledElement) {
-    return;
-  }
-
-  const { viewport } = enabledElement;
-
-  if (!(viewport instanceof StackViewport)) {
-    throw new Error(
-      `An image can only be fetched for a stack viewport and not for a viewport of type: ${viewport.type}`
-    );
-  }
-
-  return viewport.getCornerstoneImage();
-}
-
-export default getImageLegacy;

package/src/utilities/getImageSliceDataForVolumeViewport.ts

@@ -1,61 +0,0 @@
-import { ImageSliceData, IVolumeViewport, VolumeActor } from '../types';
-import getSliceRange from './getSliceRange';
-import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
-
-/**
- * It calculates the number of slices and the current slice index for a given
- * Volume viewport
- * @param viewport - volume viewport
- * @returns An object with two properties: numberOfSlices and imageIndex.
- */
-function getImageSliceDataForVolumeViewport(
-  viewport: IVolumeViewport
-): ImageSliceData {
-  const camera = viewport.getCamera();
-
-  const { spacingInNormalDirection, imageVolume } =
-    getTargetVolumeAndSpacingInNormalDir(viewport, camera);
-
-  if (!imageVolume) {
-    return;
-  }
-
-  const { viewPlaneNormal, focalPoint } = camera;
-
-  const actorEntry = viewport
-    .getActors()
-    .find(
-      (a) =>
-        a.referenceId === imageVolume.volumeId || a.uid === imageVolume.volumeId
-    );
-
-  if (!actorEntry) {
-    console.warn('No actor found for with actorUID of', imageVolume.volumeId);
-  }
-
-  const volumeActor = actorEntry.actor as VolumeActor;
-  const sliceRange = getSliceRange(volumeActor, viewPlaneNormal, focalPoint);
-
-  const { min, max, current } = sliceRange;
-
-  // calculate number of steps from min to max with current normal spacing in direction
-  const numberOfSlices = Math.round((max - min) / spacingInNormalDirection) + 1;
-
-  // calculate the imageIndex based on min, max, current
-  let imageIndex = ((current - min) / (max - min)) * numberOfSlices;
-  imageIndex = Math.floor(imageIndex);
-
-  // Clamp imageIndex
-  if (imageIndex > numberOfSlices - 1) {
-    imageIndex = numberOfSlices - 1;
-  } else if (imageIndex < 0) {
-    imageIndex = 0;
-  }
-
-  return {
-    numberOfSlices,
-    imageIndex,
-  };
-}
-
-export default getImageSliceDataForVolumeViewport;

package/src/utilities/getMinMax.ts

@@ -1,31 +0,0 @@
-/**
- * Calculate the minimum and maximum values in an Array
- *
- * @param storedPixelData - The pixel data to calculate the min and max values for
- * @returns an object with two properties: min and max
- */
-export default function getMinMax(storedPixelData: number[]): {
-  min: number;
-  max: number;
-} {
-  // we always calculate the min max values since they are not always
-  // present in DICOM and we don't want to trust them anyway as cornerstone
-  // depends on us providing reliable values for these
-  let min = storedPixelData[0];
-
-  let max = storedPixelData[0];
-
-  let storedPixel;
-  const numPixels = storedPixelData.length;
-
-  for (let index = 1; index < numPixels; index++) {
-    storedPixel = storedPixelData[index];
-    min = Math.min(min, storedPixel);
-    max = Math.max(max, storedPixel);
-  }
-
-  return {
-    min,
-    max,
-  };
-}

package/src/utilities/getRuntimeId.ts

@@ -1,56 +0,0 @@
-const LAST_RUNTIME_ID = Symbol('LastRuntimeId');
-const GLOBAL_CONTEXT = {};
-const DEFAULT_MAX = 0xffffffff; // Max 32-bit integer
-const DEFAULT_SEPARATOR = '-';
-
-/**
- * Generate a unique numeric ID string valid during a single runtime session;
- *
- * @param context - An optional object to be used as context.
- *  Defaults to a global context;
- * @param separator - The component separator. Defaults to "-";
- * @param max - The maximum component value. Defaults to 4294967295;
- * @returns The string representation of the the unique ID;
- */
-export default function getRuntimeId(
-  context?: unknown,
-  separator?: string,
-  max?: number
-): string {
-  return getNextRuntimeId(
-    // @ts-ignore
-    context !== null && typeof context === 'object' ? context : GLOBAL_CONTEXT,
-    LAST_RUNTIME_ID,
-    (typeof max === 'number' && max > 0 ? max : DEFAULT_MAX) >>> 0
-  ).join(typeof separator === 'string' ? separator : DEFAULT_SEPARATOR);
-}
-
-/*
- * Helpers
- */
-
-function getNextRuntimeId(
-  context: Record<symbol, Array<number>>,
-  symbol: symbol,
-  max: number
-): Array<number> {
-  let idComponents = context[symbol];
-  if (!(idComponents instanceof Array)) {
-    idComponents = [0];
-    Object.defineProperty(context, symbol, { value: idComponents });
-  }
-  for (let carry = true, i = 0; carry && i < idComponents.length; ++i) {
-    let n = idComponents[i] | 0;
-    if (n < max) {
-      carry = false;
-      n = n + 1;
-    } else {
-      n = 0;
-      if (i + 1 === idComponents.length) {
-        idComponents.push(0);
-      }
-    }
-    idComponents[i] = n;
-  }
-  return idComponents;
-}