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

package/src/utilities/renderToCanvasGPU.ts

@@ -1,152 +0,0 @@
-import getOrCreateCanvas from '../RenderingEngine/helpers/getOrCreateCanvas';
-import { ViewportType, Events } from '../enums';
-import StackViewport from '../RenderingEngine/StackViewport';
-import { IImage } from '../types';
-import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
-import RenderingEngine from '../RenderingEngine';
-import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
-
-/**
- * Renders an cornerstone image to a Canvas. This method will handle creation
- * of a temporary enabledElement, setting the imageId, and rendering the image via
- * a StackViewport, copying the canvas drawing to the given canvas Element, and
- * disabling the created temporary element. SuppressEvents argument is used to
- * prevent events from firing during the render process (e.g. during a series
- * of renders to a thumbnail image).
- *
- * @example
- * ```
- * const canvas = document.getElementById('myCanvas')
- *
- * renderToCanvasGPU(canvas, image)
- * ```
- * @param canvas - Canvas element to render to
- * @param image - The image to render
- * @param modality - [Default = undefined] The modality of the image
- * @returns - A promise that resolves when the image has been rendered with the imageId
- */
-export default function renderToCanvasGPU(
-  canvas: HTMLCanvasElement,
-  image: IImage,
-  modality = undefined,
-  renderingEngineId = '_thumbnails'
-): Promise<string> {
-  if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
-    throw new Error('canvas element is required');
-  }
-
-  const imageIdToPrint = image.imageId;
-  const viewportId = `renderGPUViewport-${imageIdToPrint}`;
-  const imageId = image.imageId;
-  const element = document.createElement('div');
-  element.style.width = `${canvas.width}px`;
-  element.style.height = `${canvas.height}px`;
-  element.style.visibility = 'hidden';
-  element.style.position = 'absolute';
-
-  // Up-sampling the provided canvas to match the device pixel ratio
-  // since we use device pixel ratio to determine the size of the canvas
-  // inside the rendering engine.
-  const devicePixelRatio = window.devicePixelRatio || 1;
-  const originalWidth = canvas.width;
-  const originalHeight = canvas.height;
-  canvas.width = originalWidth * devicePixelRatio;
-  canvas.height = originalHeight * devicePixelRatio;
-  canvas.style.width = `${originalWidth}px`;
-  canvas.style.height = `${originalHeight}px`;
-
-  document.body.appendChild(element);
-
-  // add id to the element so we can find it later, and fix the : which is not allowed in css
-  const uniqueId = viewportId.split(':').join('-');
-  element.setAttribute('viewport-id-for-remove', uniqueId);
-
-  const renderingEngine =
-    (getRenderingEngine(renderingEngineId) as RenderingEngine) ||
-    new RenderingEngine(renderingEngineId);
-
-  let viewport = renderingEngine.getViewport(viewportId) as StackViewport;
-
-  if (!viewport) {
-    const stackViewportInput = {
-      viewportId,
-      type: ViewportType.STACK,
-      element,
-      defaultOptions: {
-        suppressEvents: true,
-      },
-    };
-    renderingEngine.enableElement(stackViewportInput);
-    viewport = renderingEngine.getViewport(viewportId) as StackViewport;
-  }
-
-  return new Promise((resolve) => {
-    // Creating a temporary HTML element so that we can
-    // enable it and later disable it without losing the canvas context
-    let elementRendered = false;
-
-    // Create a named function to handle the event
-    const onImageRendered = (eventDetail) => {
-      if (elementRendered) {
-        return;
-      }
-
-      // get the canvas element that is the child of the div
-      const temporaryCanvas = getOrCreateCanvas(element);
-
-      // Copy the temporary canvas to the given canvas
-      const context = canvas.getContext('2d');
-      context.drawImage(
-        temporaryCanvas,
-        0,
-        0,
-        temporaryCanvas.width,
-        temporaryCanvas.height, // source dimensions
-        0,
-        0,
-        canvas.width,
-        canvas.height // destination dimensions
-      );
-
-      elementRendered = true;
-
-      // remove based on id
-      element.removeEventListener(Events.IMAGE_RENDERED, onImageRendered);
-
-      // Ensure pending previous resize calls are done which might have been
-      // triggered by the same disableElement call. This is to avoid potential
-      // grab of the wrong canvas coordinate from the offscreen renderer since
-      // disable might have not finished resizing yet and it will cause weird
-      // copy to on screen from an incorrect location in the offscreen renderer.
-      setTimeout(() => {
-        renderingEngine.disableElement(viewportId);
-
-        // remove all the elements that has the same id
-        const elements = document.querySelectorAll(
-          `[viewport-id-for-remove="${uniqueId}"]`
-        );
-        elements.forEach((element) => {
-          element.remove();
-        });
-      }, 0);
-      resolve(imageId);
-    };
-
-    element.addEventListener(Events.IMAGE_RENDERED, onImageRendered);
-    viewport.renderImageObject(image);
-
-    // force a reset camera to center the image
-    viewport.resetCamera();
-
-    if (modality === 'PT' && !isPTPrescaledWithSUV(image)) {
-      viewport.setProperties({
-        voiRange: {
-          lower: image.minPixelValue,
-          upper: image.maxPixelValue,
-        },
-      });
-    }
-
-    viewport.render();
-  });
-}

package/src/utilities/scaleRgbTransferFunction.ts

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-/**
- * Given a low and high window level, return the window width and window center
- * Formulas from note 4 in
- * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
- * extended to allow for low/high swapping
- * @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;
-} {
-  // Allow for swapping high/low
-  const windowWidth = Math.abs(high - low) + 1;
-  const windowCenter = (low + high + 1) / 2;
-
-  return { windowWidth, windowCenter };
-}
-
-/**
- * Given a window width and center, return the lower and upper bounds of the window
- * The formulas for the calculation are specified in
- * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
- * if (x <= c - 0.5 - (w-1) /2), then y = ymin
- * else if (x > c - 0.5 + (w-1) /2), then y = ymax
- * else y = ((x - (c - 0.5)) / (w-1) + 0.5) * (ymax- ymin) + ymin
- * @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 - 0.5 - (windowWidth - 1) / 2;
-  const upper = windowCenter - 0.5 + (windowWidth - 1) / 2;
-
-  return { lower, upper };
-}
-
-export { toWindowLevel, toLowHighRange };

package/src/utilities/worldToImageCoords.ts

@@ -1,65 +0,0 @@
-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,
-    rowCosines,
-    imagePositionPatient: origin,
-  } = imagePlaneModule;
-
-  let { columnPixelSpacing, rowPixelSpacing } = imagePlaneModule;
-  // Use ||= to convert null and 0 as well as undefined to 1
-  columnPixelSpacing ||= 1;
-  rowPixelSpacing ||= 1;
-
-  // 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;