@cornerstonejs/core 2.0.0-beta.8 → 2.0.0

package/src/utilities/loadImageToCanvas.ts

@@ -1,202 +0,0 @@
-import type {
-  IImage,
-  ViewPresentation,
-  ViewReference,
-  ViewportInputOptions,
-  Point3,
-  IVolume,
-} 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';
-import cache from '../cache';
-
-/**
- * The original load image options specified just an image id,  which is optimal
- * for things like thumbnails rendering a single image.
- */
-export type StackLoadImageOptions = {
-  imageId: string;
-};
-
-/**
- * The full image load options allows specifying more parameters for both the
- * presentation and the view so that a specific view can be referenced/displayed.
- */
-export type FullImageLoadOptions = {
-  viewReference: ViewReference;
-  viewPresentation: ViewPresentation;
-  imageId: undefined;
-};
-
-/**
- * The canvas load position allows for determining the rendered position of
- * image data within the canvas, and can be used to map loaded canvas points
- * to and from other viewport positions for things like external computations
- * on the load image to canvas view and the viewport view (which may contain
- * extraneous data such as segmentation and thus not be usable for external
- * computations.)
- */
-export type CanvasLoadPosition = {
-  origin: Point3;
-  topRight: Point3;
-  bottomLeft: Point3;
-  thicknessMm: number;
-};
-
-/**
- * The image canvas can be loaded/set with various view conditions to specify the initial
- * view as well as how and where ot render the image.
- */
-export type LoadImageOptions = {
-  canvas: HTMLCanvasElement;
-  // Define the view specification as optional here, and then incorporate specific
-  // requirements in mix in types.
-  imageId?: string;
-  viewReference?: ViewReference;
-  viewPresentation?: ViewPresentation;
-  requestType?: RequestType;
-  priority?: number;
-  renderingEngineId?: string;
-  useCPURendering?: boolean;
-  // Render a thumbnail in a 256x256 viewport
-  // Also set imageAspect to render thumbnail in an aspect ratio width viewport
-  thumbnail?: boolean;
-  // Sets the CSS width to the image aspect ratio
-  imageAspect?: boolean;
-  // Sets the canvas pixel size to the physical pixel size of the image area
-  physicalPixels?: boolean;
-  // Sets the viewport input options  Defaults to scale to fit 110%
-  viewportOptions?: ViewportInputOptions;
-} & (StackLoadImageOptions | FullImageLoadOptions);
-
-/**
- * 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)
- * @param thumbnail - Render a thumbnail image
- * @param imageAspect - assign the width based on the aspect ratio of the image
- * @returns - A promise that resolves when the image has been rendered with the imageId
- */
-export default function loadImageToCanvas(
-  options: LoadImageOptions
-): Promise<CanvasLoadPosition> {
-  const {
-    canvas,
-    imageId,
-    viewReference,
-    requestType = RequestType.Thumbnail,
-    priority = -5,
-    renderingEngineId = '_thumbnails',
-    useCPURendering = false,
-    thumbnail = false,
-    imageAspect = false,
-    viewportOptions: baseViewportOptions,
-  } = options;
-  const volumeId = viewReference?.volumeId;
-  const isVolume = volumeId && !imageId;
-  const viewportOptions =
-    viewReference && baseViewportOptions
-      ? { ...baseViewportOptions, viewReference }
-      : baseViewportOptions;
-
-  const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
-
-  return new Promise((resolve, reject) => {
-    function successCallback(imageOrVolume: IImage | IVolume, imageId: string) {
-      const { modality } = metaData.get('generalSeriesModule', imageId) || {};
-
-      const image = !isVolume && (imageOrVolume as IImage);
-      const volume = isVolume && (imageOrVolume as IVolume);
-      if (image) {
-        image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
-      }
-
-      if (thumbnail) {
-        canvas.height = 256;
-        canvas.width = 256;
-      }
-      if (imageAspect && image) {
-        canvas.width = image && (canvas.height * image.width) / image.height;
-      }
-      canvas.style.width = `${canvas.width / devicePixelRatio}px`;
-      canvas.style.height = `${canvas.height / devicePixelRatio}px`;
-      if (volume && useCPURendering) {
-        reject(new Error('CPU rendering of volume not supported'));
-      }
-      renderFn(
-        canvas,
-        imageOrVolume,
-        modality,
-        renderingEngineId,
-        viewportOptions
-      ).then(resolve);
-    }
-
-    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,
-    };
-
-    if (volumeId) {
-      const volume = cache.getVolume(volumeId) as unknown as IVolume;
-      if (!volume) {
-        reject(new Error(`Volume id ${volumeId} not found in cache`));
-      }
-      const useImageId = volume.imageIds[0];
-      successCallback(volume, useImageId);
-    } else {
-      imageLoadPoolManager.addRequest(
-        sendRequest.bind(null, imageId, null, options),
-        requestType,
-        { imageId },
-        priority
-      );
-    }
-  });
-}

package/src/utilities/makeVolumeMetadata.ts

@@ -1,87 +0,0 @@
-import { metaData } from '../';
-import { Metadata } from '../types';
-
-/**
- * It creates a metadata object for a volume given the imageIds that compose it.
- * It uses the first imageId to get the metadata.
- *
- * @param imageIds - array of imageIds
- * @returns The volume metadata
- */
-export default function makeVolumeMetadata(imageIds: Array<string>): Metadata {
-  const imageId0 = imageIds[0];
-
-  const {
-    pixelRepresentation,
-    bitsAllocated,
-    bitsStored,
-    highBit,
-    photometricInterpretation,
-    samplesPerPixel,
-  } = metaData.get('imagePixelModule', imageId0);
-
-  // Add list of VOIs stored on the DICOM.
-  const voiLut = [];
-
-  const voiLutModule = metaData.get('voiLutModule', imageId0);
-
-  // voiLutModule is not always present
-  let voiLUTFunction;
-  if (voiLutModule) {
-    const { windowWidth, windowCenter } = voiLutModule;
-    voiLUTFunction = voiLutModule?.voiLUTFunction;
-
-    if (Array.isArray(windowWidth)) {
-      for (let i = 0; i < windowWidth.length; i++) {
-        voiLut.push({
-          windowWidth: windowWidth[i],
-          windowCenter: windowCenter[i],
-        });
-      }
-    } else {
-      voiLut.push({
-        windowWidth: windowWidth,
-        windowCenter: windowCenter,
-      });
-    }
-  } else {
-    voiLut.push({
-      windowWidth: undefined,
-      windowCenter: undefined,
-    });
-  }
-
-  const { modality, seriesInstanceUID } = metaData.get(
-    'generalSeriesModule',
-    imageId0
-  );
-
-  const {
-    imageOrientationPatient,
-    pixelSpacing,
-    frameOfReferenceUID,
-    columns,
-    rows,
-  } = metaData.get('imagePlaneModule', imageId0);
-
-  // Map to dcmjs-style keywords. This is becoming the standard and makes it
-  // Easier to swap out cornerstoneDICOMImageLoader at a later date.
-  return {
-    BitsAllocated: bitsAllocated,
-    BitsStored: bitsStored,
-    SamplesPerPixel: samplesPerPixel,
-    HighBit: highBit,
-    PhotometricInterpretation: photometricInterpretation,
-    PixelRepresentation: pixelRepresentation,
-    Modality: modality,
-    ImageOrientationPatient: imageOrientationPatient,
-    PixelSpacing: pixelSpacing,
-    FrameOfReferenceUID: frameOfReferenceUID,
-    Columns: columns,
-    Rows: rows,
-    // This is a reshaped object and not a dicom tag:
-    voiLut,
-    VOILUTFunction: voiLUTFunction,
-    SeriesInstanceUID: seriesInstanceUID,
-  };
-}

package/src/utilities/planar.ts

@@ -1,102 +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
- * @param normalized - if true, the values of the plane equation will be normalized
- * @returns - [A, B,C, D] of plane equation A*X + B*Y + C*Z = D
- */
-function planeEquation(
-  normal: Point3,
-  point: Point3 | vec3,
-  normalized = false
-): Plane {
-  const [A, B, C] = normal;
-  const D = A * point[0] + B * point[1] + C * point[2];
-
-  if (normalized) {
-    const length = Math.sqrt(A * A + B * B + C * C);
-    return [A / length, B / length, C / length, D / length];
-  }
-
-  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,48 +0,0 @@
-import {
-  IImage,
-  CPUFallbackEnabledElement,
-  ViewportInputOptions,
-  IVolume,
-} 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';
-import type { CanvasLoadPosition } from './loadImageToCanvas';
-
-/**
- * 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,
-  imageOrVolume: IImage | IVolume,
-  modality?: string,
-  _renderingEngineId?: string,
-  _viewportOptions?: ViewportInputOptions
-): Promise<CanvasLoadPosition> {
-  const volume = imageOrVolume as IVolume;
-  if (volume.volumeId) {
-    throw new Error('Unsupported volume rendering for CPU');
-  }
-  const image = imageOrVolume as IImage;
-  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(null);
-  });
-}

package/src/utilities/renderToCanvasGPU.ts

@@ -1,195 +0,0 @@
-import getOrCreateCanvas, {
-  EPSILON,
-} from '../RenderingEngine/helpers/getOrCreateCanvas';
-import { ViewportType, Events } from '../enums';
-import {
-  IImage,
-  IStackViewport,
-  IVolume,
-  ViewportInputOptions,
-  IVolumeViewport,
-  ViewReference,
-} from '../types';
-import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
-import RenderingEngine from '../RenderingEngine';
-import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
-import { CanvasLoadPosition } from './loadImageToCanvas';
-
-/**
- * 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 imageOrVolume - 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,
-  imageOrVolume: IImage | IVolume,
-  modality = undefined,
-  renderingEngineId = '_thumbnails',
-  viewportOptions: ViewportInputOptions & { viewReference?: ViewReference } = {
-    displayArea: { imageArea: [1, 1] },
-  }
-): Promise<CanvasLoadPosition> {
-  if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
-    throw new Error('canvas element is required');
-  }
-
-  const isVolume = !(imageOrVolume as IImage).imageId;
-  const image = !isVolume && (imageOrVolume as IImage);
-  const volume = isVolume && (imageOrVolume as IVolume);
-  const imageIdToPrint = image?.imageId || volume?.volumeId;
-  const viewportId = `renderGPUViewport-${imageIdToPrint}`;
-  const element = document.createElement('div');
-  const devicePixelRatio = window.devicePixelRatio || 1;
-  if (!viewportOptions.displayArea) {
-    viewportOptions.displayArea = { imageArea: [1, 1] };
-  }
-  const originalWidth = canvas.width;
-  const originalHeight = canvas.height;
-  // The canvas width/height are set by flooring the CSS size converted
-  // into physical pixels, but because these are float values, the conversion
-  // isn't exact, and using the exact value sometimes leads to an off by 1
-  // in the actual size, so adding EPSILON to the size resolves
-  // the problem.
-  // Don't touch the canvas size here as what we get out is a canvas at the right size
-  element.style.width = `${originalWidth / devicePixelRatio + EPSILON}px`;
-  element.style.height = `${originalHeight / devicePixelRatio + EPSILON}px`;
-  element.style.visibility = 'hidden';
-  element.style.position = 'absolute';
-
-  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);
-
-  // get the canvas element that is the child of the div
-  const temporaryCanvas = getOrCreateCanvas(element);
-  const renderingEngine =
-    (getRenderingEngine(renderingEngineId) as RenderingEngine) ||
-    new RenderingEngine(renderingEngineId);
-
-  let viewport = renderingEngine.getViewport(viewportId);
-
-  if (!viewport) {
-    const viewportInput = {
-      viewportId,
-      type: isVolume ? ViewportType.ORTHOGRAPHIC : ViewportType.STACK,
-      element,
-      defaultOptions: {
-        ...viewportOptions,
-        suppressEvents: true,
-      },
-    };
-    renderingEngine.enableElement(viewportInput);
-    viewport = renderingEngine.getViewport(viewportId);
-  }
-
-  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;
-
-    let { viewReference } = viewportOptions;
-
-    // Create a named function to handle the event
-    const onImageRendered = (eventDetail) => {
-      if (elementRendered) {
-        return;
-      }
-      if (viewReference) {
-        const useViewRef = viewReference;
-        viewReference = null;
-        viewport.setViewReference(useViewRef);
-        viewport.render();
-        return;
-      }
-
-      // 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
-      );
-
-      const origin = viewport.canvasToWorld([0, 0]);
-      const topRight = viewport.canvasToWorld([
-        temporaryCanvas.width / devicePixelRatio,
-        0,
-      ]);
-      const bottomLeft = viewport.canvasToWorld([
-        0,
-        temporaryCanvas.height / devicePixelRatio,
-      ]);
-      const thicknessMm = 1;
-      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({
-        origin,
-        bottomLeft,
-        topRight,
-        thicknessMm,
-      });
-    };
-
-    element.addEventListener(Events.IMAGE_RENDERED, onImageRendered);
-    if (isVolume) {
-      (viewport as IVolumeViewport).setVolumes([volume], false, true);
-    } else {
-      (viewport as IStackViewport).renderImageObject(imageOrVolume);
-    }
-
-    // force a reset camera to center the image and undo the small scaling
-    viewport.resetCamera();
-
-    if (modality === 'PT' && !isPTPrescaledWithSUV(image)) {
-      (viewport as IStackViewport).setProperties({
-        voiRange: {
-          lower: image.minPixelValue,
-          upper: image.maxPixelValue,
-        },
-      });
-    }
-
-    viewport.render();
-  });
-}

package/src/utilities/roundNumber.ts

@@ -1,57 +0,0 @@
-import { EPSILON } from '../constants';
-
-/**
- * Truncates decimal points to that there is at least 1+precision significant
- * digits.
- *
- * For example, with the default precision 2 (3 significant digits)
- * * Values larger than 100 show no information after the decimal point
- * * Values between 10 and 99 show 1 decimal point
- * * Values between 1 and 9 show 2 decimal points
- *
- * @param value - to return a fixed measurement value from
- * @param precision - defining how many digits after 1..9 are desired
- */
-function roundNumber(
-  value: string | number | (string | number)[],
-  precision = 2
-): string {
-  if (Array.isArray(value)) {
-    return value.map((v) => roundNumber(v, precision)).join(', ');
-  }
-  if (value === undefined || value === null || value === '') {
-    return 'NaN';
-  }
-  value = Number(value);
-  const absValue = Math.abs(value);
-  if (absValue < 0.0001) {
-    return `${value}`;
-  }
-  const fixedPrecision =
-    absValue >= 100
-      ? precision - 2
-      : absValue >= 10
-      ? precision - 1
-      : absValue >= 1
-      ? precision
-      : absValue >= 0.1
-      ? precision + 1
-      : absValue >= 0.01
-      ? precision + 2
-      : absValue >= 0.001
-      ? precision + 3
-      : precision + 4;
-  return value.toFixed(fixedPrecision);
-}
-
-/**
- * Rounds a number to the nearest multiple of EPSILON.
- * @param value - The number to round.
- * @returns The rounded number.
- */
-function roundToPrecision(value) {
-  return Math.round(value / EPSILON) * EPSILON;
-}
-
-export { roundToPrecision };
-export default roundNumber;