@cornerstonejs/core 0.36.2 → 0.36.4

package/src/utilities/applyPreset.ts

@@ -0,0 +1,132 @@
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import { ViewportPreset } from '../types';
+import { VolumeActor } from '../types/IActor';
+
+/**
+ * Applies a preset to a volume actor.
+ *
+ * @param actor - The volume actor to apply the preset to.
+ * @param preset - The preset to apply.
+ */
+export default function applyPreset(actor: VolumeActor, preset: ViewportPreset) {
+  // Create color transfer function
+  const colorTransferArray = preset.colorTransfer
+    .split(' ')
+    .splice(1)
+    .map(parseFloat);
+
+  const { shiftRange } = getShiftRange(colorTransferArray);
+  const min = shiftRange[0];
+  const width = shiftRange[1] - shiftRange[0];
+  const cfun = vtkColorTransferFunction.newInstance();
+  const normColorTransferValuePoints = [];
+  for (let i = 0; i < colorTransferArray.length; i += 4) {
+    let value = colorTransferArray[i];
+    const r = colorTransferArray[i + 1];
+    const g = colorTransferArray[i + 2];
+    const b = colorTransferArray[i + 3];
+
+    value = (value - min) / width;
+    normColorTransferValuePoints.push([value, r, g, b]);
+  }
+
+  applyPointsToRGBFunction(normColorTransferValuePoints, shiftRange, cfun);
+
+  actor.getProperty().setRGBTransferFunction(0, cfun);
+
+  // Create scalar opacity function
+  const scalarOpacityArray = preset.scalarOpacity
+    .split(' ')
+    .splice(1)
+    .map(parseFloat);
+
+  const ofun = vtkPiecewiseFunction.newInstance();
+  const normPoints = [];
+  for (let i = 0; i < scalarOpacityArray.length; i += 2) {
+    let value = scalarOpacityArray[i];
+    const opacity = scalarOpacityArray[i + 1];
+
+    value = (value - min) / width;
+
+    normPoints.push([value, opacity]);
+  }
+
+  applyPointsToPiecewiseFunction(normPoints, shiftRange, ofun);
+
+  actor.getProperty().setScalarOpacity(0, ofun);
+
+  const [
+    gradientMinValue,
+    gradientMinOpacity,
+    gradientMaxValue,
+    gradientMaxOpacity,
+  ] = preset.gradientOpacity.split(' ').splice(1).map(parseFloat);
+
+  actor.getProperty().setUseGradientOpacity(0, true);
+  actor.getProperty().setGradientOpacityMinimumValue(0, gradientMinValue);
+  actor.getProperty().setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
+  actor.getProperty().setGradientOpacityMaximumValue(0, gradientMaxValue);
+  actor.getProperty().setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
+
+  if (preset.interpolation === '1') {
+    actor.getProperty().setInterpolationTypeToFastLinear();
+    //actor.getProperty().setInterpolationTypeToLinear()
+  }
+
+  const ambient = parseFloat(preset.ambient);
+  const diffuse = parseFloat(preset.diffuse);
+  const specular = parseFloat(preset.specular);
+  const specularPower = parseFloat(preset.specularPower);
+
+  actor.getProperty().setAmbient(ambient);
+  actor.getProperty().setDiffuse(diffuse);
+  actor.getProperty().setSpecular(specular);
+  actor.getProperty().setSpecularPower(specularPower);
+}
+
+function getShiftRange(colorTransferArray) {
+  // Credit to paraview-glance
+  // https://github.com/Kitware/paraview-glance/blob/3fec8eeff31e9c19ad5b6bff8e7159bd745e2ba9/src/components/controls/ColorBy/script.js#L133
+
+  // shift range is original rgb/opacity range centered around 0
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < colorTransferArray.length; i += 4) {
+    min = Math.min(min, colorTransferArray[i]);
+    max = Math.max(max, colorTransferArray[i]);
+  }
+
+  const center = (max - min) / 2;
+
+  return {
+    shiftRange: [-center, center],
+    min,
+    max,
+  };
+}
+
+function applyPointsToRGBFunction(points, range, cfun) {
+  const width = range[1] - range[0];
+  const rescaled = points.map(([x, r, g, b]) => [
+    x * width + range[0],
+    r,
+    g,
+    b,
+  ]);
+
+  cfun.removeAllPoints();
+  rescaled.forEach(([x, r, g, b]) => cfun.addRGBPoint(x, r, g, b));
+
+  return rescaled;
+}
+
+function applyPointsToPiecewiseFunction(points, range, pwf) {
+  const width = range[1] - range[0];
+  const rescaled = points.map(([x, y]) => [x * width + range[0], y]);
+
+  pwf.removeAllPoints();
+  rescaled.forEach(([x, y]) => pwf.addPoint(x, y));
+
+  return rescaled;
+}

package/src/utilities/calculateViewportsSpatialRegistration.ts

@@ -0,0 +1,74 @@
+import { vec3, mat4 } from 'gl-matrix';
+import { IStackViewport } from '../types';
+import { StackViewport } from '../RenderingEngine';
+import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
+import { metaData } from '..';
+import isEqual from './isEqual';
+
+/**
+ * It calculates the registration matrix between two viewports (currently only
+ * translation is supported)
+ * If the viewports are in the same frame of reference, it will return early,
+ * but otherwise it will use the current image's metadata to calculate the
+ * translation between the two viewports and adds it to the spatialRegistrationModule
+ * metadata provider
+ *
+ *
+ * @param viewport1 - The first stack viewport
+ * @param viewport2 - The second stack viewport
+ */
+function calculateViewportsSpatialRegistration(
+  viewport1: IStackViewport,
+  viewport2: IStackViewport
+): void {
+  if (
+    !(viewport1 instanceof StackViewport) ||
+    !(viewport2 instanceof StackViewport)
+  ) {
+    throw new Error(
+      'calculateViewportsSpatialRegistration: Both viewports must be StackViewports, volume viewports are not supported yet'
+    );
+  }
+
+  const isSameFrameOfReference =
+    viewport1.getFrameOfReferenceUID() === viewport2.getFrameOfReferenceUID();
+
+  if (isSameFrameOfReference) {
+    return;
+  }
+
+  const imageId1 = viewport1.getCurrentImageId();
+  const imageId2 = viewport2.getCurrentImageId();
+
+  const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
+  const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
+
+  const isSameImagePlane =
+    imagePlaneModule1 &&
+    imagePlaneModule2 &&
+    isEqual(
+      imagePlaneModule1.imageOrientationPatient,
+      imagePlaneModule2.imageOrientationPatient
+    );
+
+  if (!isSameImagePlane) {
+    throw new Error(
+      'Viewport spatial registration only supported for same orientation (hence translation only) for now'
+    );
+  }
+
+  const imagePositionPatient1 = imagePlaneModule1.imagePositionPatient;
+  const imagePositionPatient2 = imagePlaneModule2.imagePositionPatient;
+
+  const translation = vec3.subtract(
+    vec3.create(),
+    imagePositionPatient1,
+    imagePositionPatient2
+  );
+
+  const mat = mat4.fromTranslation(mat4.create(), translation);
+
+  spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
+}
+
+export default calculateViewportsSpatialRegistration;

package/src/utilities/calibratedPixelSpacingMetadataProvider.ts

@@ -0,0 +1,38 @@
+import imageIdToURI from './imageIdToURI';
+
+const state = {}; // Calibrated pixel spacing per imageId
+
+/**
+ * Simple metadataProvider object to store metadata for calibrated spacings.
+ * This can be added via cornerstone.metaData.addProvider(...) in order to store
+ * and return calibrated pixel spacings when metaData type is "calibratedPixelSpacing".
+ */
+const metadataProvider = {
+  /**
+   * Adds metadata for an imageId.
+   * @param imageId - the imageId for the metadata to store
+   * @param payload - the payload composed of new calibrated pixel spacings
+   */
+  add: (imageId: string, payload: [number, number]): void => {
+    const imageURI = imageIdToURI(imageId);
+    if (!state[imageURI]) {
+      state[imageURI] = {};
+    }
+    state[imageURI] = payload;
+  },
+
+  /**
+   * Returns the metadata for an imageId if it exists.
+   * @param type - the type of metadata to enquire about
+   * @param imageId - the imageId to enquire about
+   * @returns the calibrated pixel spacings for the imageId if it exists, otherwise undefined
+   */
+  get: (type: string, imageId: string): [number, number] => {
+    if (type === 'calibratedPixelSpacing') {
+      const imageURI = imageIdToURI(imageId);
+      return state[imageURI];
+    }
+  },
+};
+
+export default metadataProvider;

package/src/utilities/createFloat32SharedArray.ts

@@ -0,0 +1,45 @@
+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 = createFloat32SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
+ * ```
+ *
+ * @param length - frame size * number of frames
+ * @returns a Float32Array with an underlying SharedArrayBuffer
+ * @public
+ */
+function createFloat32SharedArray(length: number): Float32Array {
+  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 * 4);
+
+  return new Float32Array(sharedArrayBuffer);
+}
+
+export default createFloat32SharedArray;

package/src/utilities/createInt16SharedArray.ts

@@ -0,0 +1,43 @@
+import global from '../global';
+/**
+ * A helper function that creates a new Int16 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 = createInt16SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
+ * ```
+ *
+ * @param length - frame size * number of frames
+ * @returns a Int8Array with an underlying SharedArrayBuffer
+ * @public
+ */
+function createInt16SharedArray(length: number): Int16Array {
+  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 Int16Array(sharedArrayBuffer);
+}
+
+export default createInt16SharedArray;

package/src/utilities/createLinearRGBTransferFunction.ts

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

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

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

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

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

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