@cornerstonejs/core 0.36.3 → 0.36.5

package/src/utilities/isTypedArray.ts

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

@@ -0,0 +1,80 @@
+import { IImage } from '../types';
+
+import { loadAndCacheImage } from '../loaders/imageLoader';
+import * as metaData from '../metaData';
+import { RequestType } from '../enums';
+import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
+import renderToCanvas from './renderToCanvas';
+import { getConfiguration } from '../init';
+
+/**
+ * Loads and renders an imageId to a Canvas. It will use the CPU rendering pipeline
+ * for image.
+ *
+ * @example
+ * ```
+ * const canvas = document.getElementById('myCanvas')
+ * const imageId = 'myImageId'
+ *
+ * loadImageToCanvas(canvas, imageId)
+ * ```
+ * @param imageId - The imageId to render
+ * @param canvas - Canvas element to render to
+ * @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)
+ * @returns - A promise that resolves when the image has been rendered with the imageId
+ */
+export default function loadImageToCanvas(
+  canvas: HTMLCanvasElement,
+  imageId: string,
+  requestType = RequestType.Thumbnail,
+  priority = -5
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    function successCallback(image: IImage, imageId: string) {
+      const { modality } = metaData.get('generalSeriesModule', imageId) || {};
+
+      image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+      renderToCanvas(canvas, image, modality);
+      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,
+      },
+      requestType,
+    };
+
+    imageLoadPoolManager.addRequest(
+      sendRequest.bind(null, imageId, null, options),
+      requestType,
+      { imageId },
+      priority
+    );
+  });
+}

package/src/utilities/planar.ts

@@ -0,0 +1,91 @@
+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/renderToCanvas.ts

@@ -0,0 +1,32 @@
+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 renderToCanvas(
+  canvas: HTMLCanvasElement,
+  image: IImage,
+  modality?: string
+): void {
+  const viewport = getDefaultViewport(canvas, image, modality);
+
+  const enabledElement: CPUFallbackEnabledElement = {
+    canvas,
+    viewport,
+    image,
+    renderingTools: {},
+  };
+
+  enabledElement.transform = calculateTransform(enabledElement);
+
+  const invalidated = true;
+  drawImageSync(enabledElement, invalidated);
+}

package/src/utilities/scaleRgbTransferFunction.ts

@@ -0,0 +1,37 @@
+/**
+ * A utility that can be used to scale (in place) an RgbTransferFunction. We
+ * often use this to scale the transfer function based on a PET calculation.
+ *
+ * @example
+ * Grabbing a reference to the RGB Transfer function from the viewport:
+ * ```
+ * const rgbTransferFunction = viewport
+ *   .getActor()
+ *   .getProperty()
+ *   .getRGBTransferFunction(0);
+ *
+ * scaleRgbTransferFunction(rgbTransferFunction, 2);
+ * ```
+ *
+ * @see {@link https://kitware.github.io/vtk-js/api/Rendering_Core_ColorTransferFunction.html|VTK.js: ColorTransferFunction}
+ * @param rgbTransferFunction
+ * @param scalingFactor
+ */
+export default function scaleRGBTransferFunction(
+  rgbTransferFunction: any,
+  scalingFactor: number
+): void {
+  const size = rgbTransferFunction.getSize();
+
+  for (let index = 0; index < size; index++) {
+    const nodeValue1 = [];
+
+    rgbTransferFunction.getNodeValue(index, nodeValue1);
+
+    nodeValue1[1] = nodeValue1[1] * scalingFactor;
+    nodeValue1[2] = nodeValue1[2] * scalingFactor;
+    nodeValue1[3] = nodeValue1[3] * scalingFactor;
+
+    rgbTransferFunction.setNodeValue(index, nodeValue1);
+  }
+}

package/src/utilities/snapFocalPointToSlice.ts

@@ -0,0 +1,78 @@
+import { vec3 } from 'gl-matrix';
+import { ActorSliceRange, Point3 } from '../types';
+
+/**
+ * Given a number of frames, `deltaFrames`,
+ * move the `focalPoint` and camera `position` so that it moves forward/backwards
+ * `deltaFrames` in the camera's normal direction, and snaps to the nearest frame.
+ *
+ * @param focalPoint - The focal point to move.
+ * @param position - The camera position to move.
+ * @param sliceRange - The scroll range used to find the current
+ * position in the stack, as well as prevent scrolling past the extent of the volume.
+ * @param viewPlaneNormal - The normal direction of the camera.
+ * @param spacingInNormalDirection - The spacing of frames the normal direction of the camera.
+ * @param deltaFrames - The number of frames to jump.
+ *
+ * @returns The `newFocalPoint` and `newPosition` of the camera.
+ */
+export default function snapFocalPointToSlice(
+  focalPoint: Point3,
+  position: Point3,
+  sliceRange: ActorSliceRange,
+  viewPlaneNormal: Point3,
+  spacingInNormalDirection: number,
+  deltaFrames: number
+): { newFocalPoint: Point3; newPosition: Point3 } {
+  const { min, max, current } = sliceRange;
+
+  // Get the current offset off the camera position so we can add it on at the end.
+  const posDiffFromFocalPoint = vec3.create();
+
+  vec3.sub(posDiffFromFocalPoint, <vec3>position, <vec3>focalPoint);
+
+  // Now we can see how many steps there are in this direction
+  const steps = Math.round((max - min) / spacingInNormalDirection);
+
+  // Find out current frameIndex
+  const fraction = (current - min) / (max - min);
+  const floatingStepNumber = fraction * steps;
+  let frameIndex = Math.round(floatingStepNumber);
+
+  // Dolly the focal point back to min slice focal point.
+  let newFocalPoint = <Point3>[
+    focalPoint[0] -
+      viewPlaneNormal[0] * floatingStepNumber * spacingInNormalDirection,
+    focalPoint[1] -
+      viewPlaneNormal[1] * floatingStepNumber * spacingInNormalDirection,
+    focalPoint[2] -
+      viewPlaneNormal[2] * floatingStepNumber * spacingInNormalDirection,
+  ];
+
+  // Increment the slice number by deltaFrames.
+  frameIndex += deltaFrames;
+
+  // Clamp sliceNumber to volume.
+  if (frameIndex > steps) {
+    frameIndex = steps;
+  } else if (frameIndex < 0) {
+    frameIndex = 0;
+  }
+
+  // Dolly the focal towards to the correct frame focal point.
+  const newSlicePosFromMin = frameIndex * spacingInNormalDirection;
+
+  newFocalPoint = <Point3>[
+    newFocalPoint[0] + viewPlaneNormal[0] * newSlicePosFromMin,
+    newFocalPoint[1] + viewPlaneNormal[1] * newSlicePosFromMin,
+    newFocalPoint[2] + viewPlaneNormal[2] * newSlicePosFromMin,
+  ];
+
+  const newPosition = <Point3>[
+    newFocalPoint[0] + posDiffFromFocalPoint[0],
+    newFocalPoint[1] + posDiffFromFocalPoint[1],
+    newFocalPoint[2] + posDiffFromFocalPoint[2],
+  ];
+
+  return { newFocalPoint, newPosition };
+}

package/src/utilities/spatialRegistrationMetadataProvider.ts

@@ -0,0 +1,50 @@
+import { mat4 } from 'gl-matrix';
+import { addProvider } from '../metaData';
+
+const state = {};
+
+/**
+ * Simple metadataProvider object to store metadata for spatial registration module.
+ */
+const spatialRegistrationMetadataProvider = {
+  /* Adding a new entry to the state object. */
+  add: (query: string[], payload: mat4): void => {
+    const [viewportId1, viewportId2] = query;
+    const entryId = `${viewportId1}_${viewportId2}`;
+
+    if (!state[entryId]) {
+      state[entryId] = {};
+    }
+
+    state[entryId] = payload;
+  },
+
+  get: (type: string, query: string[]): mat4 => {
+    if (type !== 'spatialRegistrationModule') {
+      return;
+    }
+
+    const [viewportId1, viewportId2] = query;
+
+    // check both ways
+    const entryId = `${viewportId1}_${viewportId2}`;
+
+    if (state[entryId]) {
+      return state[entryId];
+    }
+
+    const entryIdReverse = `${viewportId2}_${viewportId1}`;
+
+    if (state[entryIdReverse]) {
+      return mat4.invert(mat4.create(), state[entryIdReverse]);
+    }
+  },
+};
+
+addProvider(
+  spatialRegistrationMetadataProvider.get.bind(
+    spatialRegistrationMetadataProvider
+  )
+);
+
+export default spatialRegistrationMetadataProvider;

package/src/utilities/transformWorldToIndex.ts

@@ -0,0 +1,16 @@
+import type Point3 from '../types/Point3';
+
+/**
+ * Given an imageData object and a point in physical space, return the index of the
+ * voxel that contains the point. TODO: this should be pushed to vtk upstream.
+ * @param imageData - The image data object.
+ * @param physicalPoint - The point in physical space that you want to transform to
+ * index space.
+ * @returns An array of integers.
+ */
+export default function transformWorldToIndex(imageData, worldPos: Point3) {
+  const continuousIndex = imageData.worldToIndex(worldPos);
+  const index = continuousIndex.map(Math.round);
+
+  return index;
+}

package/src/utilities/triggerEvent.ts

@@ -0,0 +1,38 @@
+import eventTarget from '../eventTarget';
+
+/**
+ * Small utility to trigger a custom event for a given EventTarget.
+ *
+ * @example
+ *
+ * ```javascript
+ * triggerEvent(element, Events.IMAGE_RENDERED, { element })
+ * ```
+ * or it can trigger event on the eventTarget itself
+ *
+ * ```javascript
+ * triggerEvent(eventTarget, CSTOOLS_EVENTS.ANNOTATION_MODIFIED, { viewportId, annotationUID })
+ * ```
+ *
+ * @param el - The element or EventTarget to trigger the event upon
+ * @param type - The event type name
+ * @param detail - The event detail to be sent
+ * @returns false if event is cancelable and at least one of the event handlers
+ * which received event called Event.preventDefault(). Otherwise it returns true.
+ */
+export default function triggerEvent(
+  el: EventTarget = eventTarget,
+  type: string,
+  detail: unknown = null
+): boolean {
+  if (!type) {
+    throw new Error('Event type was not defined');
+  }
+
+  const event = new CustomEvent(type, {
+    detail,
+    cancelable: true,
+  });
+
+  return el.dispatchEvent(event);
+}

package/src/utilities/uuidv4.ts

@@ -0,0 +1,13 @@
+// prettier-ignore
+// @ts-nocheck
+/**
+ * Generates a unique id that has limited chance of collision
+ *
+ * @see {@link https://stackoverflow.com/a/2117523/1867984|StackOverflow: Source}
+ * @returns a v4 compliant GUID
+ */
+export default function uuidv4(): string {
+  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
+    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+  );
+}

package/src/utilities/windowLevel.ts

@@ -0,0 +1,39 @@
+/**
+ * Given a low and high window level, return the window width and window center
+ * @param low - The low window level.
+ * @param high - The high window level.
+ * @returns a JavaScript object with two properties: windowWidth and windowCenter.
+ */
+function toWindowLevel(
+  low: number,
+  high: number
+): {
+  windowWidth: number;
+  windowCenter: number;
+} {
+  const windowWidth = Math.abs(low - high);
+  const windowCenter = low + windowWidth / 2;
+
+  return { windowWidth, windowCenter };
+}
+
+/**
+ * Given a window width and center, return the lower and upper bounds of the window
+ * @param windowWidth - the width of the window in HU
+ * @param windowCenter - The center of the window.
+ * @returns a JavaScript object with two properties: lower and upper.
+ */
+function toLowHighRange(
+  windowWidth: number,
+  windowCenter: number
+): {
+  lower: number;
+  upper: number;
+} {
+  const lower = windowCenter - windowWidth / 2.0;
+  const upper = windowCenter + windowWidth / 2.0;
+
+  return { lower, upper };
+}
+
+export { toWindowLevel, toLowHighRange };

package/src/utilities/worldToImageCoords.ts

@@ -0,0 +1,64 @@
+import { vec3 } from 'gl-matrix';
+import { metaData } from '..';
+import { Point2, Point3 } from '../types';
+
+/**
+ * Given the imageId, and 3d coordinates on the world space, it returns the continuos
+ * image coordinates (IJ) on the image space. The image space is
+ * defined with [0,0] being on the top left corner of the top left pixel,
+ * the [1,1] being on the bottom right corner of the top left pixel.
+ * @param imageId - The image id
+ * @param worldCoords - The 3d coordinates on the world.
+ * @returns The 2d coordinates on the image.
+ *
+ */
+function worldToImageCoords(
+  imageId: string,
+  worldCoords: Point3
+): Point2 | undefined {
+  const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+
+  if (!imagePlaneModule) {
+    throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
+  }
+
+  // For the image coordinates we need to calculate the transformation matrix
+  // from the world coordinates to the image coordinates.
+
+  const {
+    columnCosines,
+    columnPixelSpacing,
+    rowCosines,
+    rowPixelSpacing,
+    imagePositionPatient: origin,
+    rows,
+    columns,
+  } = imagePlaneModule;
+
+  // The origin is the image position patient, but since image coordinates start
+  // from [0,0] for the top left hand of the first pixel, and the origin is at the
+  // center of the first pixel, we need to account for this.
+  const newOrigin = vec3.create();
+
+  vec3.scaleAndAdd(newOrigin, origin, columnCosines, -columnPixelSpacing / 2);
+  vec3.scaleAndAdd(newOrigin, newOrigin, rowCosines, -rowPixelSpacing / 2);
+
+  // Get the subtraction vector from the origin to the world coordinates
+  const sub = vec3.create();
+  vec3.sub(sub, worldCoords, newOrigin);
+
+  // Projected distance of the sub vector onto the rowCosines
+  const rowDistance = vec3.dot(sub, rowCosines);
+
+  // Projected distance of the sub vector onto the columnCosines
+  const columnDistance = vec3.dot(sub, columnCosines);
+
+  const imageCoords = [
+    rowDistance / rowPixelSpacing,
+    columnDistance / columnPixelSpacing,
+  ];
+
+  return imageCoords as Point2;
+}
+
+export default worldToImageCoords;