@cornerstonejs/core 2.0.0-beta.6 → 2.0.0-beta.8

package/src/utilities/eventListener/TargetEventListeners.ts

@@ -0,0 +1,278 @@
+enum EventListenerPhases {
+  None = 0,
+  Capture = 1,
+  Bubble = 2,
+}
+
+type ListenersMap = Map<EventListener, EventListenerPhases>;
+
+/**
+ * TargetEventListeners adds support for event types with namespace, allow
+ * removing events without having to pass a callback and makes it possible to
+ * remove all event listeners in a much simpler way avoiding leaving listeners
+ * behind which would result in memory leaks.
+ *
+ * @example
+ * Creating a new TargetEventListeners instance
+ * ```javascript
+ *   const element = document.getElementById('foo');
+ *   const targetEventListeners = new TargetEventListeners(element)
+ * ```
+ *
+ * @example
+ * Adding and removing event listeners
+ * ```javascript
+ *   const dragCallback = () => { };
+ *
+ *   targetEventListeners.addEventListener('voi.mousemove', dragCallback);
+ *   targetEventListeners.addEventListener('voi.drag', dragCallback);
+ *   targetEventListeners.addEventListener('voi.mouseup', () => {
+ *     // do not need to store a reference of this function
+ *   }));
+ *
+ *   // Removes a specific event listener
+ *   targetEventListeners.removeEventListener('voi.mousemove', dragCallback)
+ *
+ *   // Removes all "mouseup" event listeners added to "colorbar.voi" namespace
+ *   targetEventListeners.removeEventListener('voi.mouseup')
+ *
+ *   // Removes all event listeners added to the element using this targetEventListeners
+ *   // instance. A TargetEventListeners instance does not removes the event listeners
+ *   // added by another one.
+ *   targetEventListeners.reset();
+ * ```
+ *
+ * @example
+ * Adding and removing event listeners for capture and bubble phases. Each
+ * listener must be removed indenpendently
+ * ```javascript
+ *   const clickCaptureCallback = () => { };
+ *   const clickBubbleCallback = () => { };
+ *
+ *   targetEventListeners.addEventListener('click', clickCaptureCallback, { capture: true });
+ *   targetEventListeners.addEventListener('click', clickBubbleCallback);
+ *
+ *   // Removes the event listener added to the capture phase
+ *   targetEventListeners.removeEventListener('click', clickCaptureCallback, { capture: true });
+ *
+ *   // Removes the event listener added to the bubble phase
+ *   targetEventListeners.removeEventListener('click', clickBubbleCallback);
+ *
+ *   // Removes all event listeners added to the HTML element
+ *   targetEventListeners.reset();
+ * ```
+
+ */
+class TargetEventListeners {
+  private _target: EventTarget;
+  private _eventListeners = new Map<string, ListenersMap>();
+  private _children = new Map<string, TargetEventListeners>();
+
+  constructor(target: EventTarget) {
+    this._target = target;
+  }
+
+  public get isEmpty() {
+    return this._eventListeners.size === 0 && this._children.size === 0;
+  }
+
+  public addEventListener(
+    type: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions
+  ) {
+    const dotIndex = type.indexOf('.');
+    const isNamespace = dotIndex !== -1;
+
+    if (isNamespace) {
+      const namespaceToken = type.substring(0, dotIndex);
+      let childElementEventListener = this._children.get(namespaceToken);
+
+      if (!childElementEventListener) {
+        childElementEventListener = new TargetEventListeners(this._target);
+        this._children.set(namespaceToken, childElementEventListener);
+      }
+
+      type = type.substring(dotIndex + 1);
+      childElementEventListener.addEventListener(type, callback, options);
+    } else {
+      this._addEventListener(type, callback, options);
+    }
+  }
+
+  /**
+   * Remove an event listener with support for namespaces and optional callback
+   * which makes it remove all listeners of a given type
+   * @param type - Event type
+   * @param callback - Event listener
+   * @param options - Event options
+   */
+  public removeEventListener(
+    type: string,
+    callback?: EventListener,
+    options?: EventListenerOptions
+  ): void {
+    const dotIndex = type.indexOf('.');
+    const isNamespace = dotIndex !== -1;
+
+    if (isNamespace) {
+      const namespaceToken = type.substring(0, dotIndex);
+      const childElementEventListener = this._children.get(namespaceToken);
+
+      if (!childElementEventListener) {
+        return;
+      }
+
+      type = type.substring(dotIndex + 1);
+      childElementEventListener.removeEventListener(type, callback, options);
+
+      // remove empty child objects
+      if (childElementEventListener.isEmpty) {
+        this._children.delete(namespaceToken);
+      }
+    } else {
+      this._removeEventListener(type, callback, options);
+    }
+  }
+
+  /**
+   * Loop through all types, listeners and phases and removing all of them
+   */
+  public reset() {
+    // Destroy all children (DFS - depth first search)
+    Array.from(this._children.entries()).forEach(([namespace, child]) => {
+      child.reset();
+
+      if (child.isEmpty) {
+        this._children.delete(namespace);
+      } else {
+        // This scenario must never happen (safety only)
+        throw new Error('Child is not empty and cannot be removed');
+      }
+    });
+
+    this._unregisterAllEvents();
+  }
+
+  private _addEventListener(
+    type: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions
+  ) {
+    let listenersMap = this._eventListeners.get(type);
+
+    if (!listenersMap) {
+      listenersMap = new Map<EventListener, EventListenerPhases>();
+      this._eventListeners.set(type, listenersMap);
+    }
+
+    const useCapture = options?.capture ?? false;
+    const listenerPhase = useCapture
+      ? EventListenerPhases.Capture
+      : EventListenerPhases.Bubble;
+    const registeredPhases =
+      listenersMap.get(callback) ?? EventListenerPhases.None;
+
+    // Bitwise operator to see if the current phase is already registered
+    // because the same listener may be register twice (capturing and bubbling
+    // phases)
+    if (registeredPhases & listenerPhase) {
+      console.warn('A listener is already registered for this phase');
+      return;
+    }
+
+    // Add a new event listener or updates the existing one for the phase requested
+    listenersMap.set(callback, registeredPhases | listenerPhase);
+
+    // Add the event listener to the target
+    this._target.addEventListener(type, callback, options);
+  }
+
+  private _removeEventListener(
+    type: string,
+    callback?: EventListener,
+    options?: EventListenerOptions
+  ): void {
+    const useCapture = options?.capture ?? false;
+    const listenerPhase = useCapture
+      ? EventListenerPhases.Capture
+      : EventListenerPhases.Bubble;
+
+    const listenersMap = this._eventListeners.get(type);
+
+    if (!listenersMap) {
+      return;
+    }
+
+    // It can remove a single or all callbacks for a given namespace
+    const callbacks = callback ? [callback] : Array.from(listenersMap.keys());
+
+    callbacks.forEach((callbackItem) => {
+      const registeredPhases =
+        listenersMap.get(callbackItem) ?? EventListenerPhases.None;
+
+      // Bitwise operation to see if the phase is registered
+      const phaseRegistered = !!(registeredPhases & listenerPhase);
+
+      if (!phaseRegistered) {
+        return;
+      }
+
+      // Remove the event listener from the target
+      this._target.removeEventListener(type, callbackItem, options);
+
+      // Since it is enabled we can XOR it to zero the bit in that position
+      //   00000011 (capture & buble) ^ 00000010 (buble) = 00000001 (capture)
+      const newListenerPhase = registeredPhases ^ listenerPhase;
+
+      // Deletes the listener if it is no more used in capturing or bubbling
+      // phases or updates it otherwise
+      if (newListenerPhase === EventListenerPhases.None) {
+        listenersMap.delete(callbackItem);
+      } else {
+        listenersMap.set(callbackItem, newListenerPhase);
+      }
+    });
+
+    // Deletes the event from the main map if there are no listeners anymore
+    if (!listenersMap.size) {
+      this._eventListeners.delete(type);
+    }
+  }
+
+  private _unregisterAllListeners(type: string, listenersMap: ListenersMap) {
+    // Creates a copy with Array.from() because the map mutates every
+    // time an event listener is removed
+    Array.from(listenersMap.entries()).forEach(([listener, eventPhases]) => {
+      const startPhase = EventListenerPhases.Capture;
+
+      // currentPhase start at 1 and shifts 1 bit to the left because
+      // EventListenerPhases is a power of 2
+      for (let currentPhase = startPhase; eventPhases; currentPhase <<= 1) {
+        // Check if the current phase is registered
+        if (!(eventPhases & currentPhase)) {
+          continue;
+        }
+
+        const useCapture =
+          currentPhase === EventListenerPhases.Capture ? true : false;
+
+        // Remove the event listener for this given phase
+        this.removeEventListener(type, listener, { capture: useCapture });
+
+        // Switch the bit from the "currentPhase" from 1 to 0
+        eventPhases ^= currentPhase;
+      }
+    });
+  }
+
+  private _unregisterAllEvents() {
+    // Creates a copy with Array.from() because the map mutates every
+    // time an event listener is removed
+    Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) =>
+      this._unregisterAllListeners(type, listenersMap)
+    );
+  }
+}
+
+export { TargetEventListeners as default, TargetEventListeners };

package/src/utilities/eventListener/index.ts

@@ -0,0 +1,2 @@
+export { TargetEventListeners } from './TargetEventListeners';
+export { MultiTargetEventListenerManager } from './MultiTargetEventListenerManager';

package/src/utilities/generateVolumePropsFromImageIds.ts

@@ -0,0 +1,186 @@
+import { vec3 } from 'gl-matrix';
+import {
+  canRenderFloatTextures,
+  getConfiguration,
+  getShouldUseSharedArrayBuffer,
+} from '../init';
+import createFloat32SharedArray from './createFloat32SharedArray';
+import createInt16SharedArray from './createInt16SharedArray';
+import createUint16SharedArray from './createUInt16SharedArray';
+import createUint8SharedArray from './createUint8SharedArray';
+import getScalingParameters from './getScalingParameters';
+import makeVolumeMetadata from './makeVolumeMetadata';
+import sortImageIdsAndGetSpacing from './sortImageIdsAndGetSpacing';
+import { hasFloatScalingParameters } from './hasFloatScalingParameters';
+import { ImageVolumeProps, Mat3, Point3 } from '../types';
+import cache from '../cache';
+import { Events } from '../enums';
+
+function generateVolumePropsFromImageIds(
+  imageIds: string[],
+  volumeId: string
+): ImageVolumeProps {
+  const { useNorm16Texture, preferSizeOverAccuracy } =
+    getConfiguration().rendering;
+
+  const use16BitDataType = useNorm16Texture || preferSizeOverAccuracy;
+  const volumeMetadata = makeVolumeMetadata(imageIds);
+
+  // For a streaming volume, the data type cannot rely on CSWIL to load
+  // the proper array buffer type. This is because the target buffer container
+  // must be decided ahead of time.
+  // TODO: move this logic into CSWIL to avoid logic duplication.
+  // We check if scaling parameters are negative we choose Int16 instead of
+  // Uint16 for cases where BitsAllocated is 16.
+  const imageIdIndex = Math.floor(imageIds.length / 2);
+  const imageId = imageIds[imageIdIndex];
+  const scalingParameters = getScalingParameters(imageId);
+  const hasNegativeRescale =
+    scalingParameters.rescaleIntercept < 0 ||
+    scalingParameters.rescaleSlope < 0;
+
+  // The prescale is ALWAYS used with modality LUT, so we can assume that
+  // if the rescale slope is not an integer, we need to use Float32
+  const floatAfterScale = hasFloatScalingParameters(scalingParameters);
+  const canRenderFloat = canRenderFloatTextures();
+
+  const {
+    BitsAllocated,
+    PixelRepresentation,
+    PhotometricInterpretation,
+    ImageOrientationPatient,
+    PixelSpacing,
+    Columns,
+    Rows,
+  } = volumeMetadata;
+
+  const rowCosineVec = vec3.fromValues(
+    ImageOrientationPatient[0],
+    ImageOrientationPatient[1],
+    ImageOrientationPatient[2]
+  );
+  const colCosineVec = vec3.fromValues(
+    ImageOrientationPatient[3],
+    ImageOrientationPatient[4],
+    ImageOrientationPatient[5]
+  );
+
+  const scanAxisNormal = vec3.create();
+
+  vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+
+  const { zSpacing, origin, sortedImageIds } = sortImageIdsAndGetSpacing(
+    imageIds,
+    scanAxisNormal
+  );
+
+  const numFrames = imageIds.length;
+
+  // Spacing goes [1] then [0], as [1] is column spacing (x) and [0] is row spacing (y)
+  const spacing = <Point3>[PixelSpacing[1], PixelSpacing[0], zSpacing];
+  const dimensions = <Point3>[Columns, Rows, numFrames];
+  const direction = [
+    ...rowCosineVec,
+    ...colCosineVec,
+    ...scanAxisNormal,
+  ] as Mat3;
+  const signed = PixelRepresentation === 1;
+  const numComponents = PhotometricInterpretation === 'RGB' ? 3 : 1;
+  const useSharedArrayBuffer = getShouldUseSharedArrayBuffer();
+  const length = dimensions[0] * dimensions[1] * dimensions[2];
+  const handleCache = (sizeInBytes) => {
+    if (!cache.isCacheable(sizeInBytes)) {
+      throw new Error(Events.CACHE_SIZE_EXCEEDED);
+    }
+    cache.decacheIfNecessaryUntilBytesAvailable(sizeInBytes);
+  };
+
+  let scalarData, sizeInBytes;
+  switch (BitsAllocated) {
+    case 8:
+      if (signed) {
+        throw new Error(
+          '8 Bit signed images are not yet supported by this plugin.'
+        );
+      }
+      sizeInBytes = length * numComponents;
+      handleCache(sizeInBytes);
+      scalarData = useSharedArrayBuffer
+        ? createUint8SharedArray(length * numComponents)
+        : new Uint8Array(length * numComponents);
+      break;
+
+    case 16:
+      // Temporary fix for 16 bit images to use Float32
+      // until the new dicom image loader handler the conversion
+      // correctly
+      if (!use16BitDataType || (canRenderFloat && floatAfterScale)) {
+        sizeInBytes = length * 4;
+        scalarData = useSharedArrayBuffer
+          ? createFloat32SharedArray(length)
+          : new Float32Array(length);
+
+        break;
+      }
+
+      sizeInBytes = length * 2;
+      if (signed || hasNegativeRescale) {
+        handleCache(sizeInBytes);
+        scalarData = useSharedArrayBuffer
+          ? createInt16SharedArray(length)
+          : new Int16Array(length);
+        break;
+      }
+
+      if (!signed && !hasNegativeRescale) {
+        handleCache(sizeInBytes);
+        scalarData = useSharedArrayBuffer
+          ? createUint16SharedArray(length)
+          : new Uint16Array(length);
+        break;
+      }
+
+      // Default to Float32 again
+      sizeInBytes = length * 4;
+      handleCache(sizeInBytes);
+      scalarData = useSharedArrayBuffer
+        ? createFloat32SharedArray(length)
+        : new Float32Array(length);
+      break;
+
+    case 24:
+      sizeInBytes = length * numComponents;
+      handleCache(sizeInBytes);
+
+      // hacky because we don't support alpha channel in dicom
+      scalarData = useSharedArrayBuffer
+        ? createUint8SharedArray(length * numComponents)
+        : new Uint8Array(length * numComponents);
+      break;
+    case 32:
+      sizeInBytes = length * 4;
+      handleCache(sizeInBytes);
+      scalarData = useSharedArrayBuffer
+        ? createFloat32SharedArray(length)
+        : new Float32Array(length);
+      break;
+    default:
+      throw new Error(
+        `Bits allocated of ${BitsAllocated} is not defined to generate scalarData for the volume.`
+      );
+  }
+
+  return {
+    dimensions,
+    spacing,
+    origin,
+    direction,
+    scalarData,
+    sizeInBytes,
+    metadata: volumeMetadata,
+    imageIds: sortedImageIds,
+    volumeId,
+  };
+}
+
+export { generateVolumePropsFromImageIds };

package/src/utilities/genericMetadataProvider.ts

@@ -0,0 +1,43 @@
+import { addProvider } from '../metaData';
+
+let state: Record<string, any> = {}; // Calibrated pixel spacing per imageId
+/**
+ * Simple metadata provider that stores some sort of meta data for each imageId.
+ */
+const metadataProvider = {
+  /**
+   * Adds metadata for an imageId.
+   * @param imageId - the imageId for the metadata to store
+   * @param payload - the payload
+   */
+  add: (imageId: string, payload: any): void => {
+    const type = payload.type;
+
+    if (!state[imageId]) {
+      state[imageId] = {};
+    }
+
+    // Create a deep copy of payload.metadata
+    state[imageId][type] = JSON.parse(JSON.stringify(payload.metadata));
+  },
+
+  /**
+   * 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
+   */
+  get: (type: string, imageId: string): any => {
+    return state[imageId]?.[type];
+  },
+
+  /**
+   * Clears all metadata.
+   */
+  clear: (): void => {
+    state = {};
+  },
+};
+
+addProvider(metadataProvider.get);
+
+export default metadataProvider;

package/src/utilities/getBufferConfiguration.ts

@@ -0,0 +1,69 @@
+import { PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
+
+/**
+ * Creates a target buffer based on the provided options.
+ *
+ * @param targetBufferType - The type of the target buffer.
+ * @param length - The length of the target buffer.
+ * @param options - Options for the target buffer. Currently supports
+ * `use16BitTexture` and `isVolumeBuffer`.
+ * @returns Returns an object containing the number of bytes and the type array
+ * constructor of the target buffer, which you then use to create the target buffer
+ * with new TypedArrayConstructor(length).
+ */
+function getBufferConfiguration(
+  targetBufferType: PixelDataTypedArrayString,
+  length: number,
+  options: { use16BitTexture?: boolean; isVolumeBuffer?: boolean } = {}
+): {
+  numBytes: number;
+  TypedArrayConstructor: new (
+    length: number | SharedArrayBuffer
+  ) => PixelDataTypedArray;
+} {
+  const { use16BitTexture = false, isVolumeBuffer = false } = options;
+
+  switch (targetBufferType) {
+    case 'Float32Array':
+      return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+    case 'Uint8Array':
+      return { numBytes: length, TypedArrayConstructor: Uint8Array };
+    case 'Uint16Array':
+      if (!isVolumeBuffer) {
+        return { numBytes: length * 2, TypedArrayConstructor: Uint16Array };
+      } else {
+        if (use16BitTexture) {
+          return { numBytes: length * 2, TypedArrayConstructor: Uint16Array };
+        } else {
+          console.warn(
+            'Uint16Array is not supported for volume rendering, switching back to Float32Array'
+          );
+          return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+        }
+      }
+    case 'Int16Array':
+      if (!isVolumeBuffer) {
+        return { numBytes: length * 2, TypedArrayConstructor: Int16Array };
+      } else {
+        if (use16BitTexture) {
+          return { numBytes: length * 2, TypedArrayConstructor: Int16Array };
+        } else {
+          console.warn(
+            'Int16Array is not supported for volume rendering, switching back to Float32Array'
+          );
+          return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+        }
+      }
+    default:
+      if (targetBufferType) {
+        throw new Error(
+          'TargetBuffer should be Float32Array, Uint8Array, Uint16Array, or Int16Array'
+        );
+      } else {
+        // Use Float32Array if no targetBuffer is provided
+        return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+      }
+  }
+}
+
+export { getBufferConfiguration };