@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/src/utilities/stackPrefetch/stackPrefetchUtils.ts

@@ -1,114 +0,0 @@
-import { getEnabledElement, StackViewport, Enums } from '@cornerstonejs/core';
-import { getToolState } from './state';
-
-export const requestType = Enums.RequestType.Prefetch;
-export const priority = 0;
-
-export function range(lowEnd, highEnd) {
-  // Javascript version of Python's range function
-  // http://stackoverflow.com/questions/3895478/does-javascript-have-a-method-like-range-to-generate-an-array-based-on-suppl
-  lowEnd = Math.round(lowEnd) || 0;
-  highEnd = Math.round(highEnd) || 0;
-
-  const arr = [];
-  let c = highEnd - lowEnd + 1;
-
-  if (c <= 0) {
-    return arr;
-  }
-
-  while (c--) {
-    arr[c] = highEnd--;
-  }
-
-  return arr;
-}
-
-export function nearestIndex(arr, x) {
-  // Return index of nearest values in array
-  // http://stackoverflow.com/questions/25854212/return-index-of-nearest-values-in-an-array
-  let low = 0;
-  let high = arr.length - 1;
-
-  arr.forEach((v, idx) => {
-    if (v < x) {
-      low = Math.max(idx, low);
-    } else if (v > x) {
-      high = Math.min(idx, high);
-    }
-  });
-
-  return { low, high };
-}
-
-export function getStackData(element) {
-  const enabledElement = getEnabledElement(element);
-
-  if (!enabledElement) {
-    // Can be not valid if the data is changed part way through prefetch
-    return null;
-  }
-
-  const { viewport } = enabledElement;
-
-  if (!(viewport instanceof StackViewport)) {
-    throw new Error(
-      'stackPrefetch: element must be a StackViewport, VolumeViewport stackPrefetch not yet implemented'
-    );
-  }
-
-  return {
-    currentImageIdIndex: viewport.getCurrentImageIdIndex(),
-    imageIds: viewport.getImageIds(),
-  };
-}
-
-export function getPromiseRemovedHandler(element) {
-  return function (e) {
-    const eventData = e.detail;
-
-    // When an imagePromise has been pushed out of the cache, re-add its index
-    // It to the indicesToRequest list so that it will be retrieved later if the
-    // CurrentImageIdIndex is changed to an image nearby
-    let stackData;
-
-    try {
-      // It will throw an exception in some cases (eg: thumbnails)
-      stackData = getStackData(element);
-    } catch (error) {
-      return;
-    }
-
-    if (!stackData || !stackData.imageIds || stackData.imageIds.length === 0) {
-      return;
-    }
-
-    const stack = stackData;
-    const imageIdIndex = stack.imageIds.indexOf(eventData.imageId);
-
-    // Make sure the image that was removed is actually in this stack
-    // Before adding it to the indicesToRequest array
-    if (imageIdIndex < 0) {
-      return;
-    }
-
-    const stackPrefetchData = getToolState(element);
-
-    if (
-      !stackPrefetchData ||
-      !stackPrefetchData.data ||
-      !stackPrefetchData.data.length
-    ) {
-      return;
-    }
-
-    stackPrefetchData.indicesToRequest.push(imageIdIndex);
-  };
-}
-
-export const clearFromImageIds = (stack) => {
-  const imageIdSet = new Set<string>(stack.imageIds);
-  return (requestDetails) =>
-    requestDetails.type !== requestType ||
-    !imageIdSet.has(requestDetails.additionalDetails.imageId);
-};

package/src/utilities/stackPrefetch/state.ts

@@ -1,17 +0,0 @@
-import { getEnabledElement } from '@cornerstonejs/core';
-
-const state: Record<number, any> = {};
-
-function addToolState(element: HTMLDivElement, data): void {
-  const enabledElement = getEnabledElement(element);
-  const { viewportId } = enabledElement;
-  state[viewportId] = data;
-}
-
-function getToolState(element: HTMLDivElement): any {
-  const enabledElement = getEnabledElement(element);
-  const { viewportId } = enabledElement;
-  return state[viewportId];
-}
-
-export { addToolState, getToolState };

package/src/utilities/throttle.js

@@ -1,69 +0,0 @@
-import debounce from './debounce';
-import isObject from './isObject';
-
-/**
- * Creates a throttled function that only invokes `func` at most once per
- * every `wait` milliseconds (or once per browser frame). The throttled function
- * comes with a `cancel` method to cancel delayed `func` invocations and a
- * `flush` method to immediately invoke them. Provide `options` to indicate
- * whether `func` should be invoked on the leading and/or trailing edge of the
- * `wait` timeout. The `func` is invoked with the last arguments provided to the
- * throttled function. Subsequent calls to the throttled function return the
- * result of the last `func` invocation.
- *
- * **Note:** If `leading` and `trailing` options are `true`, `func` is
- * invoked on the trailing edge of the timeout only if the throttled function
- * is invoked more than once during the `wait` timeout.
- *
- * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
- * until the next tick, similar to `setTimeout` with a timeout of `0`.
- *
- * If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
- * invocation will be deferred until the next frame is drawn (typically about
- * 16ms).
- *
- * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
- * for details over the differences between `throttle` and `debounce`.
- *
- * @param {Function} func The function to throttle.
- * @param {number} [wait=0]
- *  The number of milliseconds to throttle invocations to; if omitted,
- *  `requestAnimationFrame` is used (if available).
- * @param {Object} [options={}] The options object.
- * @param {boolean} [options.leading=true]
- *  Specify invoking on the leading edge of the timeout.
- * @param {boolean} [options.trailing=true]
- *  Specify invoking on the trailing edge of the timeout.
- * @returns {Function} Returns the new throttled function.
- * @example
- *
- * // Avoid excessively updating the position while scrolling.
- * jQuery(window).on('scroll', throttle(updatePosition, 100))
- *
- * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
- * const throttled = throttle(renewToken, 300000, { 'trailing': false })
- * jQuery(element).on('click', throttled)
- *
- * // Cancel the trailing throttled invocation.
- * jQuery(window).on('popstate', throttled.cancel)
- */
-function throttle(func, wait, options) {
-  let leading = true;
-  let trailing = true;
-
-  if (typeof func !== 'function') {
-    throw new TypeError('Expected a function');
-  }
-  if (isObject(options)) {
-    leading = 'leading' in options ? Boolean(options.leading) : leading;
-    trailing = 'trailing' in options ? Boolean(options.trailing) : trailing;
-  }
-
-  return debounce(func, wait, {
-    leading,
-    trailing,
-    maxWait: wait,
-  });
-}
-
-export default throttle;

package/src/utilities/touch/index.ts

@@ -1,246 +0,0 @@
-import { IDistance, IPoints, ITouchPoints } from '../../types';
-import { Types } from '@cornerstonejs/core';
-
-/**
- * Returns the difference between multiple `IPoints` instances.
- * @param currentPoints - The current points.
- * @param lastPoints - The last points, to be subtracted from the `currentPoints`.
- *
- * @returns The difference in IPoints format
- */
-function getDeltaPoints(
-  currentPoints: IPoints[],
-  lastPoints: IPoints[]
-): IPoints {
-  const curr = getMeanPoints(currentPoints);
-  const last = getMeanPoints(lastPoints);
-  return {
-    page: _subtractPoints2D(curr.page, last.page),
-    client: _subtractPoints2D(curr.client, last.client),
-    canvas: _subtractPoints2D(curr.canvas, last.canvas),
-    world: _subtractPoints3D(curr.world, last.world),
-  };
-}
-
-/**
- * Returns the distance between multiple `IPoints` instances.
- * @param currentPoints - The current points.
- * @param lastPoints - The last points, to be subtracted from the `currentPoints`.
- *
- * @returns The distance difference in IDistance format
- */
-function getDeltaDistance(
-  currentPoints: IPoints[],
-  lastPoints: IPoints[]
-): IDistance {
-  const curr = getMeanPoints(currentPoints);
-  const last = getMeanPoints(lastPoints);
-  return {
-    page: _getDistance2D(curr.page, last.page),
-    client: _getDistance2D(curr.client, last.client),
-    canvas: _getDistance2D(curr.canvas, last.canvas),
-    world: _getDistance3D(curr.world, last.world),
-  };
-}
-
-function getDeltaRotation(
-  currentPoints: ITouchPoints[],
-  lastPoints: ITouchPoints[]
-) {
-  // TODO
-}
-
-/**
- * Returns the distance difference between multiple `IPoints` instances.
- * @param currentPoints - The current points.
- * @param lastPoints -- The last points.
- *
- * @returns The difference in IPoints format
- */
-function getDeltaDistanceBetweenIPoints(
-  currentPoints: IPoints[],
-  lastPoints: IPoints[]
-): IDistance {
-  const currentDistance = _getMeanDistanceBetweenAllIPoints(currentPoints);
-  const lastDistance = _getMeanDistanceBetweenAllIPoints(lastPoints);
-  const deltaDistance = {
-    page: currentDistance.page - lastDistance.page,
-    client: currentDistance.client - lastDistance.client,
-    canvas: currentDistance.canvas - lastDistance.canvas,
-    world: currentDistance.world - lastDistance.world,
-  };
-  return deltaDistance;
-}
-
-/**
- * Copies a set of points.
- * @param points - The `IPoints` instance to copy.
- *
- * @returns A copy of the points.
- */
-function copyPointsList(points: ITouchPoints[]): ITouchPoints[] {
-  return JSON.parse(JSON.stringify(points));
-}
-
-function copyPoints(points: ITouchPoints): ITouchPoints {
-  return JSON.parse(JSON.stringify(points));
-}
-
-function getMeanPoints(points: IPoints[]): IPoints {
-  return points.reduce(
-    (prev, curr) => {
-      return {
-        page: [
-          prev.page[0] + curr.page[0] / points.length,
-          prev.page[1] + curr.page[1] / points.length,
-        ],
-        client: [
-          prev.client[0] + curr.client[0] / points.length,
-          prev.client[1] + curr.client[1] / points.length,
-        ],
-        canvas: [
-          prev.canvas[0] + curr.canvas[0] / points.length,
-          prev.canvas[1] + curr.canvas[1] / points.length,
-        ],
-        world: [
-          prev.world[0] + curr.world[0] / points.length,
-          prev.world[1] + curr.world[1] / points.length,
-          prev.world[2] + curr.world[2] / points.length,
-        ],
-      };
-    },
-    {
-      page: [0, 0],
-      client: [0, 0],
-      canvas: [0, 0],
-      world: [0, 0, 0],
-    }
-  );
-}
-
-function getMeanTouchPoints(points: ITouchPoints[]): ITouchPoints {
-  return points.reduce(
-    (prev, curr) => {
-      return {
-        page: [
-          prev.page[0] + curr.page[0] / points.length,
-          prev.page[1] + curr.page[1] / points.length,
-        ],
-        client: [
-          prev.client[0] + curr.client[0] / points.length,
-          prev.client[1] + curr.client[1] / points.length,
-        ],
-        canvas: [
-          prev.canvas[0] + curr.canvas[0] / points.length,
-          prev.canvas[1] + curr.canvas[1] / points.length,
-        ],
-        world: [
-          prev.world[0] + curr.world[0] / points.length,
-          prev.world[1] + curr.world[1] / points.length,
-          prev.world[2] + curr.world[2] / points.length,
-        ],
-        touch: {
-          identifier: null,
-          radiusX: prev.touch.radiusX + curr.touch.radiusX / points.length,
-          radiusY: prev.touch.radiusY + curr.touch.radiusY / points.length,
-          force: prev.touch.force + curr.touch.force / points.length,
-          rotationAngle:
-            prev.touch.rotationAngle + curr.touch.rotationAngle / points.length,
-        },
-      };
-    },
-    {
-      page: [0, 0],
-      client: [0, 0],
-      canvas: [0, 0],
-      world: [0, 0, 0],
-      touch: {
-        identifier: null,
-        radiusX: 0,
-        radiusY: 0,
-        force: 0,
-        rotationAngle: 0,
-      },
-    }
-  );
-}
-/**
- * _subtractPoints - Subtracts `point1` from `point0`.
- * @param point0 - The first point.
- * @param point1 - The second point to subtract from the first.
- *
- * @returns The difference.
- */
-function _subtractPoints2D(
-  point0: Types.Point2,
-  point1: Types.Point2
-): Types.Point2 {
-  return [point0[0] - point1[0], point0[1] - point1[1]];
-}
-
-function _subtractPoints3D(
-  point0: Types.Point3,
-  point1: Types.Point3
-): Types.Point3 {
-  return [point0[0] - point1[0], point0[1] - point1[1], point0[2] - point1[2]];
-}
-
-function _getMeanDistanceBetweenAllIPoints(points: IPoints[]): IDistance {
-  // get mean distance between all unordered pairs of points
-  const pairedDistance: IDistance[] = [];
-  for (let i = 0; i < points.length; i++) {
-    for (let j = 0; j < points.length; j++) {
-      if (i < j) {
-        pairedDistance.push({
-          page: _getDistance2D(points[i].page, points[j].page),
-          client: _getDistance2D(points[i].client, points[j].client),
-          canvas: _getDistance2D(points[i].canvas, points[j].canvas),
-          world: _getDistance3D(points[i].world, points[j].world),
-        });
-      }
-    }
-  }
-
-  // take the average distance
-  return pairedDistance.reduce(
-    (prev, curr) => {
-      return {
-        page: prev.page + curr.page / pairedDistance.length,
-        client: prev.client + curr.client / pairedDistance.length,
-        canvas: prev.canvas + curr.canvas / pairedDistance.length,
-        world: prev.world + curr.world / pairedDistance.length,
-      };
-    },
-    {
-      page: 0,
-      client: 0,
-      canvas: 0,
-      world: 0,
-    }
-  );
-}
-
-function _getDistance2D(point0: Types.Point2, point1: Types.Point2): number {
-  return Math.sqrt(
-    Math.pow(point0[0] - point1[0], 2) + Math.pow(point0[1] - point1[1], 2)
-  );
-}
-
-function _getDistance3D(point0: Types.Point3, point1: Types.Point3): number {
-  return Math.sqrt(
-    Math.pow(point0[0] - point1[0], 2) +
-      Math.pow(point0[1] - point1[1], 2) +
-      Math.pow(point0[2] - point1[2], 2)
-  );
-}
-
-export {
-  getMeanPoints,
-  getMeanTouchPoints,
-  copyPoints,
-  copyPointsList,
-  getDeltaDistanceBetweenIPoints,
-  getDeltaPoints,
-  getDeltaDistance,
-  getDeltaRotation,
-};

package/src/utilities/triggerAnnotationRender.ts

@@ -1,237 +0,0 @@
-import {
-  getEnabledElement,
-  triggerEvent,
-  getRenderingEngine,
-} from '@cornerstonejs/core';
-import { Events, ToolModes } from '../enums';
-import { draw as drawSvg } from '../drawingSvg';
-import getToolsWithModesForElement from './getToolsWithModesForElement';
-import { AnnotationRenderedEventDetail } from '../types/EventTypes';
-const { Active, Passive, Enabled } = ToolModes;
-
-/**
- * AnnotationRenderingEngine is a class that is responsible for rendering
- * annotations defined in the renderAnnotation method of annotation tools on the page.
- * It mimics the RenderingEngine in the Cornerstone Core. Here it uses requestAnimationFrame
- * is used to render annotations by calling renderAnnotations() on each enabled tool. Note: This
- * is a Singleton class and should not be instantiated directly. To trigger
- * an annotation render for an HTML element containing a viewport you can use
- *
- * ```
- * triggerAnnotationRender(element)
- * ```
- */
-class AnnotationRenderingEngine {
-  public hasBeenDestroyed: boolean;
-  private _needsRender: Set<HTMLDivElement> = new Set();
-  private _animationFrameSet = false;
-  private _animationFrameHandle: number | null = null;
-  private _viewportElements: Map<string, HTMLDivElement>;
-
-  constructor() {
-    this._viewportElements = new Map();
-  }
-
-  /**
-   * Add the viewport's HTMLDivElement to the viewports for rendering. This method
-   * just informs the annotationRenderingEngine about the viewport and
-   * does not initiate a render.
-   * @param viewportId - Viewport Unique identifier
-   * @param element - HTMLDivElement
-   */
-  public addViewportElement(viewportId: string, element: HTMLDivElement) {
-    this._viewportElements.set(viewportId, element);
-  }
-
-  /**
-   * Remove the viewport's HTMLDivElement from subsequent annotation renders
-   * @param viewportId - Viewport Unique identifier
-   */
-  public removeViewportElement(viewportId: string, element: HTMLDivElement) {
-    this._viewportElements.delete(viewportId);
-
-    // delete element from needsRender if element exist
-    this._needsRender.delete(element);
-
-    // I don' think there is any disadvantage to canceling the animation frame
-    // and resetting the flags on viewport's element removal, since the removeVIewportElement
-    // might be as a result of reEnabling the element (in re-enable we disable first), hence the need to render the
-    // new one while removing the old one
-    this._reset();
-  }
-
-  /**
-   * It tells the AnnotationRenderingEngine to render the viewport element the next
-   * time it renders.
-   *
-   * @param element - The element to render.
-   */
-  public renderViewport(element: HTMLDivElement): void {
-    this._setViewportsToBeRenderedNextFrame([element]);
-  }
-
-  /**
-   * _throwIfDestroyed Throws an error if trying to interact with the `RenderingEngine`
-   * instance after its `destroy` method has been called.
-   */
-  private _throwIfDestroyed() {
-    if (this.hasBeenDestroyed) {
-      throw new Error(
-        'this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.'
-      );
-    }
-  }
-
-  private _renderFlaggedViewports = () => {
-    this._throwIfDestroyed();
-
-    const elements = Array.from(this._viewportElements.values());
-
-    for (let i = 0; i < elements.length; i++) {
-      const element = elements[i];
-      if (this._needsRender.has(element)) {
-        this._triggerRender(element);
-
-        // This viewport has been rendered, we can remove it from the set
-        this._needsRender.delete(element);
-
-        // If there is nothing left that is flagged for rendering, stop here
-        // and allow RAF to be called again
-        if (this._needsRender.size === 0) {
-          this._animationFrameSet = false;
-          this._animationFrameHandle = null;
-          return;
-        }
-      }
-    }
-  };
-
-  private _setAllViewportsToBeRenderedNextFrame() {
-    const elements = [...this._viewportElements.values()];
-
-    elements.forEach((element) => {
-      this._needsRender.add(element);
-    });
-
-    this._renderFlaggedViewports();
-  }
-
-  private _setViewportsToBeRenderedNextFrame(elements: HTMLDivElement[]) {
-    const elementsEnabled = [...this._viewportElements.values()];
-
-    // Add the viewports to the set of flagged viewports
-    elements.forEach((element) => {
-      // only enabledElement need to render
-      if (elementsEnabled.indexOf(element) !== -1) {
-        this._needsRender.add(element);
-      }
-    });
-
-    // Render any flagged viewports
-    this._render();
-  }
-
-  /**
-   * _render Sets up animation frame if necessary
-   */
-  private _render() {
-    // If we have viewports that need rendering and we have not already
-    // set the RAF callback to run on the next frame.
-    if (this._needsRender.size > 0 && this._animationFrameSet === false) {
-      this._animationFrameHandle = window.requestAnimationFrame(
-        this._renderFlaggedViewports
-      );
-
-      // Set the flag that we have already set up the next RAF call.
-      this._animationFrameSet = true;
-    }
-  }
-
-  _triggerRender(element) {
-    const enabledElement = getEnabledElement(element);
-
-    if (!enabledElement) {
-      console.warn('Element has been disabled');
-      return;
-    }
-
-    const renderingEngine = getRenderingEngine(
-      enabledElement.renderingEngineId
-    );
-    if (!renderingEngine) {
-      console.warn('rendering Engine has been destroyed');
-      return;
-    }
-
-    const enabledTools = getToolsWithModesForElement(element, [
-      Active,
-      Passive,
-      Enabled,
-    ]);
-
-    const { renderingEngineId, viewportId } = enabledElement;
-    const eventDetail: AnnotationRenderedEventDetail = {
-      element,
-      renderingEngineId,
-      viewportId,
-    };
-
-    // const enabledToolsWithAnnotations = enabledTools.filter((tool) => {
-    //   const annotations = getAnnotations(tool.getToolName(), {FrameOfReferenceUID});
-    //   return annotations && annotations.length;
-    // });
-
-    drawSvg(element, (svgDrawingHelper) => {
-      let anyRendered = false;
-      const handleDrawSvg = (tool) => {
-        if (tool.renderAnnotation) {
-          const rendered = tool.renderAnnotation(
-            enabledElement,
-            svgDrawingHelper
-          );
-          anyRendered = anyRendered || rendered;
-        }
-      };
-
-      /**
-       * We should be able to filter tools that don't have annotations, but
-       * currently some of tools have renderAnnotation method BUT
-       * don't keep annotation in the state, so if we do so, the tool will not be
-       * rendered.
-       */
-      enabledTools.forEach(handleDrawSvg);
-
-      if (anyRendered) {
-        triggerEvent(element, Events.ANNOTATION_RENDERED, { ...eventDetail });
-      }
-    });
-  }
-
-  /**
-   * _reset Resets the `RenderingEngine`
-   */
-  private _reset() {
-    window.cancelAnimationFrame(this._animationFrameHandle);
-
-    this._needsRender.clear();
-    this._animationFrameSet = false;
-    this._animationFrameHandle = null;
-
-    this._setAllViewportsToBeRenderedNextFrame();
-  }
-}
-
-const annotationRenderingEngine = new AnnotationRenderingEngine();
-
-/**
- * It triggers the rendering of the annotations for the given HTML element using
- * the `AnnotationRenderingEngine`
- * @param element - The element to render the annotation on.
- */
-function triggerAnnotationRender(element: HTMLDivElement): void {
-  annotationRenderingEngine.renderViewport(element);
-}
-
-export { annotationRenderingEngine, triggerAnnotationRender };
-
-export default triggerAnnotationRender;

package/src/utilities/triggerAnnotationRenderForViewportIds.ts

@@ -1,18 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import triggerAnnotationRender from './triggerAnnotationRender';
-
-export function triggerAnnotationRenderForViewportIds(
-  renderingEngine: Types.IRenderingEngine,
-  viewportIdsToRender: string[]
-): void {
-  if (!viewportIdsToRender.length) {
-    return;
-  }
-
-  viewportIdsToRender.forEach((viewportId) => {
-    const { element } = renderingEngine.getViewport(viewportId);
-    triggerAnnotationRender(element);
-  });
-}
-
-export default triggerAnnotationRenderForViewportIds;

package/src/utilities/viewport/index.ts

@@ -1,5 +0,0 @@
-import { isViewportPreScaled } from './isViewportPreScaled';
-import jumpToSlice from './jumpToSlice';
-import jumpToWorld from './jumpToWorld';
-
-export { isViewportPreScaled, jumpToSlice, jumpToWorld };