@cornerstonejs/core 0.36.3 → 0.36.4

package/src/enums/SharedArrayBufferModes.ts

@@ -0,0 +1,11 @@
+/**
+ * SharedArrayBuffer Modes
+ */
+enum SharedArrayBufferModes {
+  TRUE = 'true',
+  FALSE = 'false',
+  /** use SharedArrayBuffer if avalaible  */
+  AUTO = 'auto',
+}
+
+export default SharedArrayBufferModes;

package/src/enums/VOILUTFunctionType.ts

@@ -0,0 +1,10 @@
+/**
+ * Interpolation types for image rendering
+ */
+enum VOILUTFunctionType {
+  LINEAR = 'LINEAR',
+  SAMPLED_SIGMOID = 'SIGMOID', // SIGMOID is sampled in 1024 even steps so we call it SAMPLED_SIGMOID
+  // EXACT_LINEAR = 'EXACT_LINEAR', TODO: Add EXACT_LINEAR option from DICOM NEMA
+}
+
+export default VOILUTFunctionType;

package/src/enums/ViewportType.ts

@@ -0,0 +1,21 @@
+/**
+ * ViewportType enum for cornerstone-render which defines the type of viewport.
+ * It can be either STACK, PERSPECTIVE, ORTHOGRAPHIC.
+ */
+enum ViewportType {
+  /**
+   * - Suitable for rendering a stack of images, that might or might not belong to the same image.
+   * - Stack can include 2D images of different shapes, size and direction
+   */
+  STACK = 'stack',
+  /**
+   * - Suitable for rendering a volumetric data which is considered as one 3D image.
+   * - Having a VolumeViewport enables Multi-planar reformation or reconstruction (MPR) by design, in which you can visualize the volume from various different orientations without addition of performance costs.
+   */
+  ORTHOGRAPHIC = 'orthographic',
+  /** Perspective Viewport: Not Implemented yet */
+  PERSPECTIVE = 'perspective',
+  VOLUME_3D = 'volume3d',
+}
+
+export default ViewportType;

package/src/enums/index.ts

@@ -0,0 +1,23 @@
+import Events from './Events';
+import RequestType from './RequestType';
+import ViewportType from './ViewportType';
+import InterpolationType from './InterpolationType';
+import BlendModes from './BlendModes';
+import OrientationAxis from './OrientationAxis';
+import SharedArrayBufferModes from './SharedArrayBufferModes';
+import GeometryType from './GeometryType';
+import ContourType from './ContourType';
+import VOILUTFunctionType from './VOILUTFunctionType';
+
+export {
+  Events,
+  BlendModes,
+  InterpolationType,
+  RequestType,
+  ViewportType,
+  OrientationAxis,
+  SharedArrayBufferModes,
+  GeometryType,
+  ContourType,
+  VOILUTFunctionType,
+};

package/src/eventTarget.ts

@@ -0,0 +1,67 @@
+/**
+ * EventTarget - Provides the [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget) interface
+ */
+class CornerstoneEventTarget implements EventTarget {
+  private listeners;
+
+  constructor() {
+    this.listeners = {};
+  }
+
+  public reset() {
+    this.listeners = {};
+  }
+
+  public addEventListener(type, callback) {
+    if (!this.listeners[type]) {
+      this.listeners[type] = [];
+    }
+
+    // prevent multiple callbacks from firing
+    if (this.listeners[type].indexOf(callback) !== -1) {
+      return;
+    }
+
+    this.listeners[type].push(callback);
+  }
+
+  public removeEventListener(type, callback) {
+    if (!this.listeners[type]) {
+      return;
+    }
+
+    const stack = this.listeners[type];
+    const stackLength = stack.length;
+
+    for (let i = 0; i < stackLength; i++) {
+      if (stack[i] === callback) {
+        stack.splice(i, 1);
+
+        return;
+      }
+    }
+  }
+
+  dispatchEvent(event) {
+    if (!this.listeners[event.type]) {
+      //console.warn(`Skipping dispatch since there are no listeners for ${event.type}`);
+      return;
+    }
+
+    const stack = this.listeners[event.type].slice();
+    const stackLength = stack.length;
+
+    for (let i = 0; i < stackLength; i++) {
+      stack[i].call(this, event);
+    }
+
+    return !event.defaultPrevented;
+  }
+}
+
+/**
+ * EventTarget - Provides the [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget) interface
+ */
+const eventTarget = new CornerstoneEventTarget();
+
+export default eventTarget;

package/src/getEnabledElement.ts

@@ -0,0 +1,105 @@
+import getRenderingEngine, {
+  getRenderingEngines,
+} from './RenderingEngine/getRenderingEngine';
+import { IEnabledElement } from './types';
+
+/**
+ * A convenience method to find an EnabledElement given a reference to its
+ * associated element. Commonly used in code that's handling a custom
+ * event emitted by this library.
+ *
+ * @example
+ * Using the renderingEngine to find the enabled element:
+ * ```javascript
+ * const element = getRenderingEngine(renderingEngineId)
+ *    .getViewport(viewportId)
+ *    .element
+ *
+ * const enabledElement = getEnabledElement(element)
+ * ```
+ *
+ * @example
+ * Using a cornerstone event's "element"
+ * ```javascript
+ * // Our "cornerstone events" contain the source element, which is
+ * // raised on the viewport's div element
+ * const { element } = evt.detail
+ * const enabledElement = getEnabledElement(element)
+ * ```
+ *
+ * @param element - a reference to an EnabledElement/Viewport's div element
+ * @returns the associated EnabledElement, or undefined if no matching EnabledElement
+ * can be found
+ */
+export default function getEnabledElement(
+  element: HTMLDivElement | undefined
+): IEnabledElement | undefined {
+  if (!element) {
+    return;
+  }
+
+  const { viewportUid, renderingEngineUid } = element.dataset;
+
+  return getEnabledElementByIds(viewportUid, renderingEngineUid);
+}
+
+/**
+ * Similar to {@link getEnabledElement}, but takes the IDs of the
+ * renderingEngine and viewport as parameters to return the associated
+ * EnabledElement.
+ *
+ * @param viewportId - The Id of the viewport
+ * @param renderingEngineId - The Id of the rendering engine.
+ * @returns The enabled element which is an object that contains the viewport, rendering
+ * engine, viewport Id, rendering engine Id, and the Frame of Reference UID.
+ */
+export function getEnabledElementByIds(
+  viewportId: string,
+  renderingEngineId: string
+): IEnabledElement {
+  if (!renderingEngineId || !viewportId) {
+    return;
+  }
+
+  const renderingEngine = getRenderingEngine(renderingEngineId);
+
+  if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
+    return;
+  }
+
+  const viewport = renderingEngine.getViewport(viewportId);
+
+  if (!viewport) {
+    return;
+  }
+
+  const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+
+  return {
+    viewport,
+    renderingEngine,
+    viewportId,
+    renderingEngineId,
+    FrameOfReferenceUID,
+  };
+}
+
+/**
+ * Get all the enabled elements from all the rendering engines
+ * @returns An array of enabled elements.
+ */
+export function getEnabledElements(): IEnabledElement[] {
+  const enabledElements = [];
+
+  const renderingEngines = getRenderingEngines();
+
+  renderingEngines.forEach((renderingEngine) => {
+    const viewports = renderingEngine.getViewports();
+
+    viewports.forEach(({ element }) => {
+      enabledElements.push(getEnabledElement(element));
+    });
+  });
+
+  return enabledElements;
+}

package/src/global.ts

@@ -0,0 +1,8 @@
+declare global {
+  interface Window {
+    crossOriginIsolated: unknown;
+    SharedArrayBuffer: unknown;
+  }
+}
+
+export default global;

package/src/index.ts

@@ -0,0 +1,123 @@
+import * as Enums from './enums';
+import * as CONSTANTS from './constants';
+import { Events } from './enums';
+//
+import {
+  createVolumeActor,
+  createVolumeMapper,
+  getOrCreateCanvas,
+} from './RenderingEngine';
+import RenderingEngine from './RenderingEngine';
+import VolumeViewport from './RenderingEngine/VolumeViewport';
+import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
+import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
+import StackViewport from './RenderingEngine/StackViewport';
+import Viewport from './RenderingEngine/Viewport';
+import eventTarget from './eventTarget';
+import {
+  getRenderingEngine,
+  getRenderingEngines,
+} from './RenderingEngine/getRenderingEngine';
+import cache, { ImageVolume } from './cache';
+import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
+import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
+
+import getEnabledElement, {
+  getEnabledElementByIds,
+  getEnabledElements,
+} from './getEnabledElement';
+import * as metaData from './metaData';
+import {
+  init,
+  getShouldUseCPURendering,
+  getShouldUseSharedArrayBuffer,
+  isCornerstoneInitialized,
+  setUseCPURendering,
+  setUseSharedArrayBuffer,
+  resetUseCPURendering,
+  resetUseSharedArrayBuffer,
+  getConfiguration,
+  setConfiguration,
+} from './init';
+
+// Classes
+import Settings from './Settings';
+
+// Namespaces
+import * as volumeLoader from './loaders/volumeLoader';
+import * as imageLoader from './loaders/imageLoader';
+import * as geometryLoader from './loaders/geometryLoader';
+import * as Types from './types';
+import * as utilities from './utilities';
+import { registerImageLoader } from './loaders/imageLoader'; // since it is used by CSWIL right now
+
+import triggerEvent from './utilities/triggerEvent';
+
+import {
+  setVolumesForViewports,
+  addVolumesToViewports,
+} from './RenderingEngine/helpers';
+
+export type { Types };
+
+export {
+  // init
+  init,
+  isCornerstoneInitialized,
+  // configs
+  getConfiguration,
+  setConfiguration,
+  // enums
+  Enums,
+  CONSTANTS,
+  Events as EVENTS, // CornerstoneWADOImageLoader uses this, Todo: remove it after fixing wado
+  //
+  Settings,
+  // Rendering Engine
+  BaseVolumeViewport,
+  VolumeViewport,
+  VolumeViewport3D,
+  Viewport,
+  StackViewport,
+  RenderingEngine,
+  ImageVolume,
+  // Helpers
+  getRenderingEngine,
+  getRenderingEngines,
+  getEnabledElement,
+  getEnabledElementByIds,
+  getEnabledElements,
+  createVolumeActor,
+  getOrCreateCanvas,
+  createVolumeMapper,
+  // cache
+  cache,
+  // event helpers
+  eventTarget,
+  triggerEvent,
+  // Image Loader
+  imageLoader,
+  registerImageLoader, // Todo: remove this after CSWIL uses imageLoader now
+  // Volume Loader
+  volumeLoader,
+  //
+  metaData,
+  //
+  utilities,
+  setVolumesForViewports,
+  addVolumesToViewports,
+  //
+  imageLoadPoolManager as requestPoolManager,
+  imageRetrievalPoolManager,
+  imageLoadPoolManager,
+  // CPU Rendering
+  getShouldUseCPURendering,
+  setUseCPURendering,
+  resetUseCPURendering,
+  // SharedArrayBuffer
+  getShouldUseSharedArrayBuffer,
+  setUseSharedArrayBuffer,
+  resetUseSharedArrayBuffer,
+  // Geometry Loader
+  geometryLoader,
+};

package/src/init.ts

@@ -0,0 +1,247 @@
+import { getGPUTier } from 'detect-gpu';
+import { SharedArrayBufferModes } from './enums';
+let csRenderInitialized = false;
+let useSharedArrayBuffer = true;
+let sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
+import { deepMerge } from './utilities';
+import { Cornerstone3DConfig } from './types';
+// TODO: move sharedArrayBuffer into config.
+// TODO: change config into a class with methods to better control get/set
+const defaultConfig = {
+  detectGPU: {},
+  rendering: {
+    preferSizeOverAccuracy: false,
+    useCPURendering: false,
+    useNorm16Texture: false, // _hasNorm16TextureSupport(),
+  },
+  // cache
+  // ...
+};
+
+let config = {
+  detectGPU: {},
+  rendering: {
+    preferSizeOverAccuracy: false,
+    useCPURendering: false,
+    useNorm16Texture: false, // _hasNorm16TextureSupport(),
+  },
+  // cache
+  // ...
+};
+
+function _getGLContext(): RenderingContext {
+  // Create canvas element. The canvas is not added to the
+  // document itself, so it is never displayed in the
+  // browser window.
+  const canvas = document.createElement('canvas');
+  // Get WebGLRenderingContext from canvas element.
+  const gl =
+    canvas.getContext('webgl2') ||
+    canvas.getContext('webgl') ||
+    canvas.getContext('experimental-webgl');
+
+  return gl;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/By_example/Detect_WebGL
+function _hasActiveWebGLContext() {
+  const gl = _getGLContext();
+
+  // Report the result.
+  if (gl && (gl as WebGL2RenderingContext).getExtension) {
+    const ext = (gl as WebGL2RenderingContext).getExtension(
+      'EXT_texture_norm16'
+    );
+
+    if (ext) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function hasSharedArrayBuffer() {
+  try {
+    /*eslint-disable no-constant-condition */
+    if (new SharedArrayBuffer(0)) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+function _hasNorm16TextureSupport() {
+  const gl = _getGLContext();
+
+  if (gl) {
+    const ext = (gl as WebGL2RenderingContext).getExtension(
+      'EXT_texture_norm16'
+    );
+
+    if (ext) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Initialize the cornerstone-core. If the browser has a webgl context and
+ * the detected gpu (by detect-gpu library) indicates the GPU is not low end we
+ * will use webgl GPU rendering. Otherwise we will use cpu rendering.
+ *
+ * @param configuration - A configuration object
+ * @returns A promise that resolves to true cornerstone has been initialized successfully.
+ * @category Initialization
+ */
+async function init(configuration = {}): Promise<boolean> {
+  if (csRenderInitialized) {
+    return csRenderInitialized;
+  }
+
+  // merge configs
+  config = deepMerge(defaultConfig, configuration);
+
+  // detectGPU
+  const hasWebGLContext = _hasActiveWebGLContext();
+  if (!hasWebGLContext) {
+    console.log('CornerstoneRender: GPU not detected, using CPU rendering');
+    config.rendering.useCPURendering = true;
+  } else {
+    const gpuTier = await getGPUTier();
+    config.detectGPU = gpuTier;
+    console.log(
+      'CornerstoneRender: Using detect-gpu to get the GPU benchmark:',
+      gpuTier
+    );
+    if (gpuTier.tier < 1) {
+      console.log(
+        'CornerstoneRender: GPU is not powerful enough, using CPU rendering'
+      );
+      config.rendering.useCPURendering = true;
+    } else {
+      console.log('CornerstoneRender: using GPU rendering');
+    }
+  }
+
+  setUseSharedArrayBuffer(sharedArrayBufferMode);
+
+  csRenderInitialized = true;
+  return csRenderInitialized;
+}
+
+/**
+ * It sets the useCPURenderingOnlyForDebugOrTests variable to the status value.
+ * This only should be used for debugging or tests. DO NOT USE IT IF YOU ARE NOT
+ * SURE WHAT YOU ARE DOING.
+ * @param status - boolean
+ * @category Initialization
+ *
+ */
+function setUseCPURendering(status: boolean): void {
+  config.rendering.useCPURendering = status;
+  csRenderInitialized = true;
+}
+
+/**
+ * Resets the cornerstone-core init state if it has been manually
+ * initialized to force use the cpu rendering (e.g., for tests)
+ * @category Initialization
+ *
+ */
+function resetUseCPURendering(): void {
+  config.rendering.useCPURendering = !_hasActiveWebGLContext();
+}
+
+/**
+ * Returns whether or not we are using CPU rendering.
+ * @returns true if we are using CPU rendering.
+ * @category Initialization
+ *
+ */
+function getShouldUseCPURendering(): boolean {
+  return config.rendering.useCPURendering;
+}
+
+function setUseSharedArrayBuffer(mode: SharedArrayBufferModes | boolean): void {
+  if (mode == SharedArrayBufferModes.AUTO) {
+    sharedArrayBufferMode = SharedArrayBufferModes.AUTO;
+    const hasSharedBuffer = hasSharedArrayBuffer();
+    if (!hasSharedBuffer) {
+      useSharedArrayBuffer = false;
+      console.warn(
+        `CornerstoneRender: SharedArray Buffer not allowed, performance may be slower.
+        Try ensuring page is cross-origin isolated to enable SharedArrayBuffer.`
+      );
+    } else {
+      useSharedArrayBuffer = true;
+      // eslint-disable-next-line no-console
+      console.log('CornerstoneRender: using SharedArrayBuffer');
+    }
+    return;
+  }
+
+  if (mode == SharedArrayBufferModes.TRUE || mode == true) {
+    sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
+    useSharedArrayBuffer = true;
+    return;
+  }
+
+  if (mode == SharedArrayBufferModes.FALSE || mode == false) {
+    sharedArrayBufferMode = SharedArrayBufferModes.FALSE;
+    useSharedArrayBuffer = false;
+    return;
+  }
+}
+
+function resetUseSharedArrayBuffer(): void {
+  setUseSharedArrayBuffer(sharedArrayBufferMode);
+}
+
+function getShouldUseSharedArrayBuffer(): boolean {
+  return useSharedArrayBuffer;
+}
+
+/**
+ *
+ * Returns whether or not cornerstone-core has been initialized.
+ * @returns true if the cornerstone render has been initialized.
+ * @category Initialization
+ *
+ */
+function isCornerstoneInitialized(): boolean {
+  return csRenderInitialized;
+}
+
+/**
+ * This function returns a copy of the config object. This is used to prevent the
+ * config object from being modified by other parts of the program.
+ * @returns A copy of the config object.
+ */
+function getConfiguration(): Cornerstone3DConfig {
+  // return a copy
+  // return JSON.parse(JSON.stringify(config));
+  return config;
+}
+
+function setConfiguration(c: Cornerstone3DConfig) {
+  config = c;
+}
+
+export {
+  init,
+  getShouldUseCPURendering,
+  getShouldUseSharedArrayBuffer,
+  isCornerstoneInitialized,
+  setUseCPURendering,
+  setUseSharedArrayBuffer,
+  resetUseCPURendering,
+  resetUseSharedArrayBuffer,
+  getConfiguration,
+  setConfiguration,
+};