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

package/src/tools/StackScrollTool.ts

@@ -1,97 +0,0 @@
-import {
-  getEnabledElementByIds,
-  VolumeViewport,
-  StackViewport,
-  utilities as csUtils,
-} from '@cornerstonejs/core';
-import { BaseTool } from './base';
-import { scroll } from '../utilities';
-import { PublicToolProps, ToolProps, EventTypes } from '../types';
-
-/**
- * The StackScrollTool is a tool that allows the user to scroll through a
- * stack of images by pressing the mouse click and dragging
- */
-class StackScrollTool extends BaseTool {
-  static toolName;
-  deltaY: number;
-  constructor(
-    toolProps: PublicToolProps = {},
-    defaultToolProps: ToolProps = {
-      supportedInteractionTypes: ['Mouse', 'Touch'],
-      configuration: {
-        invert: false,
-        debounceIfNotLoaded: true,
-        loop: false,
-      },
-    }
-  ) {
-    super(toolProps, defaultToolProps);
-    this.deltaY = 1;
-  }
-
-  mouseDragCallback(evt: EventTypes.InteractionEventType) {
-    this._dragCallback(evt);
-  }
-  touchDragCallback(evt: EventTypes.InteractionEventType) {
-    this._dragCallback(evt);
-  }
-
-  _dragCallback(evt: EventTypes.InteractionEventType) {
-    const { deltaPoints, viewportId, renderingEngineId } = evt.detail;
-    const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-
-    const targetId = this.getTargetId(viewport);
-    const { debounceIfNotLoaded, invert, loop } = this.configuration;
-
-    const deltaPointY = deltaPoints.canvas[1];
-
-    let volumeId;
-    if (viewport instanceof VolumeViewport) {
-      volumeId = targetId.split('volumeId:')[1];
-    }
-
-    const pixelsPerImage = this._getPixelPerImage(viewport);
-    const deltaY = deltaPointY + this.deltaY;
-
-    if (!pixelsPerImage) {
-      return;
-    }
-
-    if (Math.abs(deltaY) >= pixelsPerImage) {
-      const imageIdIndexOffset = Math.round(deltaY / pixelsPerImage);
-
-      scroll(viewport, {
-        delta: invert ? -imageIdIndexOffset : imageIdIndexOffset,
-        volumeId,
-        debounceLoading: debounceIfNotLoaded,
-        loop: loop,
-      });
-
-      this.deltaY = deltaY % pixelsPerImage;
-    } else {
-      this.deltaY = deltaY;
-    }
-  }
-
-  _getPixelPerImage(viewport) {
-    const { element } = viewport;
-    const numberOfSlices = this._getNumberOfSlices(viewport);
-
-    // The Math.max here makes it easier to mouseDrag-scroll small or really large image stacks
-    return Math.max(2, element.offsetHeight / Math.max(numberOfSlices, 8));
-  }
-
-  _getNumberOfSlices(viewport) {
-    if (viewport instanceof VolumeViewport) {
-      const { numberOfSlices } =
-        csUtils.getImageSliceDataForVolumeViewport(viewport);
-      return numberOfSlices;
-    } else if (viewport instanceof StackViewport) {
-      return viewport.getImageIds().length;
-    }
-  }
-}
-
-StackScrollTool.toolName = 'StackScroll';
-export default StackScrollTool;

package/src/tools/StackScrollToolMouseWheelTool.ts

@@ -1,49 +0,0 @@
-import { getEnabledElement } from '@cornerstonejs/core';
-import { BaseTool } from './base';
-import { MouseWheelEventType } from '../types/EventTypes';
-import scroll from '../utilities/scroll';
-
-/**
- * The StackScrollMouseWheelTool is a tool that allows the user to scroll through a
- * stack of images using the mouse wheel
- */
-class StackScrollMouseWheelTool extends BaseTool {
-  static toolName;
-
-  _configuration: any;
-
-  constructor(
-    toolProps = {},
-    defaultToolProps = {
-      supportedInteractionTypes: ['Mouse', 'Touch'],
-      configuration: {
-        invert: false,
-        debounceIfNotLoaded: true,
-        loop: false,
-      },
-    }
-  ) {
-    super(toolProps, defaultToolProps);
-  }
-
-  mouseWheelCallback(evt: MouseWheelEventType): void {
-    const { wheel, element } = evt.detail;
-    const { direction } = wheel;
-    const { invert } = this.configuration;
-    const { viewport } = getEnabledElement(element);
-    const delta = direction * (invert ? -1 : 1);
-
-    const targetId = this.getTargetId(viewport);
-    const volumeId = targetId.split('volumeId:')[1];
-
-    scroll(viewport, {
-      delta,
-      debounceLoading: this.configuration.debounceIfNotLoaded,
-      loop: this.configuration.loop,
-      volumeId,
-    });
-  }
-}
-
-StackScrollMouseWheelTool.toolName = 'StackScrollMouseWheel';
-export default StackScrollMouseWheelTool;

package/src/tools/TrackballRotateTool.ts

@@ -1,141 +0,0 @@
-import vtkMath from '@kitware/vtk.js/Common/Core/Math';
-
-import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-import { mat4, vec3 } from 'gl-matrix';
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
-import { BaseTool } from './base';
-
-/**
- * Tool that rotates the camera in the plane defined by the viewPlaneNormal and the viewUp.
- */
-class TrackballRotateTool extends BaseTool {
-  static toolName;
-  touchDragCallback: (evt: EventTypes.InteractionEventType) => void;
-  mouseDragCallback: (evt: EventTypes.InteractionEventType) => void;
-
-  constructor(
-    toolProps: PublicToolProps = {},
-    defaultToolProps: ToolProps = {
-      supportedInteractionTypes: ['Mouse', 'Touch'],
-      configuration: {
-        rotateIncrementDegrees: 2,
-      },
-    }
-  ) {
-    super(toolProps, defaultToolProps);
-
-    this.touchDragCallback = this._dragCallback.bind(this);
-    this.mouseDragCallback = this._dragCallback.bind(this);
-  }
-
-  rotateCamera = (viewport, centerWorld, axis, angle) => {
-    const vtkCamera = viewport.getVtkActiveCamera();
-    const viewUp = vtkCamera.getViewUp();
-    const focalPoint = vtkCamera.getFocalPoint();
-    const position = vtkCamera.getPosition();
-
-    const newPosition: Types.Point3 = [0, 0, 0];
-    const newFocalPoint: Types.Point3 = [0, 0, 0];
-    const newViewUp: Types.Point3 = [0, 0, 0];
-
-    const transform = mat4.identity(new Float32Array(16));
-    mat4.translate(transform, transform, centerWorld);
-    mat4.rotate(transform, transform, angle, axis);
-    mat4.translate(transform, transform, [
-      -centerWorld[0],
-      -centerWorld[1],
-      -centerWorld[2],
-    ]);
-    vec3.transformMat4(newPosition, position, transform);
-    vec3.transformMat4(newFocalPoint, focalPoint, transform);
-
-    mat4.identity(transform);
-    mat4.rotate(transform, transform, angle, axis);
-    vec3.transformMat4(newViewUp, viewUp, transform);
-
-    viewport.setCamera({
-      position: newPosition,
-      viewUp: newViewUp,
-      focalPoint: newFocalPoint,
-    });
-  };
-
-  // pseudocode inspired from
-  // https://github.com/kitware/vtk-js/blob/HEAD/Sources/Interaction/Manipulators/MouseCameraUnicamRotateManipulator/index.js
-  _dragCallback(evt: EventTypes.InteractionEventType): void {
-    const { element, currentPoints, lastPoints } = evt.detail;
-    const currentPointsCanvas = currentPoints.canvas;
-    const lastPointsCanvas = lastPoints.canvas;
-    const { rotateIncrementDegrees } = this.configuration;
-    const enabledElement = getEnabledElement(element);
-    const { viewport } = enabledElement;
-    const camera = viewport.getCamera();
-    const width = element.clientWidth;
-    const height = element.clientHeight;
-
-    const normalizedPosition = [
-      currentPointsCanvas[0] / width,
-      currentPointsCanvas[1] / height,
-    ];
-
-    const normalizedPreviousPosition = [
-      lastPointsCanvas[0] / width,
-      lastPointsCanvas[1] / height,
-    ];
-
-    const center: Types.Point2 = [width * 0.5, height * 0.5];
-    // NOTE: centerWorld corresponds to the focal point in cornerstone3D
-    const centerWorld = viewport.canvasToWorld(center);
-    const normalizedCenter = [0.5, 0.5];
-
-    const radsq = (1.0 + Math.abs(normalizedCenter[0])) ** 2.0;
-    const op = [normalizedPreviousPosition[0], 0, 0];
-    const oe = [normalizedPosition[0], 0, 0];
-
-    const opsq = op[0] ** 2;
-    const oesq = oe[0] ** 2;
-
-    const lop = opsq > radsq ? 0 : Math.sqrt(radsq - opsq);
-    const loe = oesq > radsq ? 0 : Math.sqrt(radsq - oesq);
-
-    const nop: Types.Point3 = [op[0], 0, lop];
-    vtkMath.normalize(nop);
-    const noe: Types.Point3 = [oe[0], 0, loe];
-    vtkMath.normalize(noe);
-
-    const dot = vtkMath.dot(nop, noe);
-    if (Math.abs(dot) > 0.0001) {
-      const angleX =
-        -2 *
-        Math.acos(vtkMath.clampValue(dot, -1.0, 1.0)) *
-        Math.sign(normalizedPosition[0] - normalizedPreviousPosition[0]) *
-        rotateIncrementDegrees;
-
-      const upVec = camera.viewUp;
-      const atV = camera.viewPlaneNormal;
-      const rightV: Types.Point3 = [0, 0, 0];
-      const forwardV: Types.Point3 = [0, 0, 0];
-
-      vtkMath.cross(upVec, atV, rightV);
-      vtkMath.normalize(rightV);
-
-      vtkMath.cross(atV, rightV, forwardV);
-      vtkMath.normalize(forwardV);
-      vtkMath.normalize(upVec);
-
-      this.rotateCamera(viewport, centerWorld, forwardV, angleX);
-
-      const angleY =
-        (normalizedPreviousPosition[1] - normalizedPosition[1]) *
-        rotateIncrementDegrees;
-
-      this.rotateCamera(viewport, centerWorld, rightV, angleY);
-
-      viewport.render();
-    }
-  }
-}
-
-TrackballRotateTool.toolName = 'TrackballRotate';
-export default TrackballRotateTool;

package/src/tools/VolumeRotateMouseWheelTool.ts

@@ -1,86 +0,0 @@
-import { BaseTool } from './base';
-import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-
-import { mat4, vec3 } from 'gl-matrix';
-import { PublicToolProps, ToolProps } from '../types';
-import { MouseWheelEventType } from '../types/EventTypes';
-
-const DIRECTIONS = {
-  X: [1, 0, 0],
-  Y: [0, 1, 0],
-  Z: [0, 0, 1],
-  CUSTOM: [],
-};
-
-/**
- * Tool that rotates the camera on mouse wheel.
- * It rotates the camera around the focal point, and around a defined axis. Default
- * axis is set to be Z axis, but it can be configured to any custom normalized axis.
- *
- */
-class VolumeRotateMouseWheelTool extends BaseTool {
-  static toolName;
-  _configuration: any;
-
-  constructor(
-    toolProps: PublicToolProps = {},
-    defaultToolProps: ToolProps = {
-      supportedInteractionTypes: ['Mouse', 'Touch'],
-      configuration: {
-        direction: DIRECTIONS.Z,
-        rotateIncrementDegrees: 0.5,
-      },
-    }
-  ) {
-    super(toolProps, defaultToolProps);
-  }
-
-  mouseWheelCallback(evt: MouseWheelEventType) {
-    // https://github.com/kitware/vtk-js/blob/HEAD/Sources/Interaction/Manipulators/MouseCameraUnicamRotateManipulator/index.js#L73
-    const { element, wheel } = evt.detail;
-    const enabledElement = getEnabledElement(element);
-    const { viewport } = enabledElement;
-    const { direction, rotateIncrementDegrees } = this.configuration;
-
-    const camera = viewport.getCamera();
-    const { viewUp, position, focalPoint } = camera;
-
-    const { direction: deltaY } = wheel;
-
-    const [cx, cy, cz] = focalPoint;
-    const [ax, ay, az] = direction;
-
-    const angle = deltaY * rotateIncrementDegrees;
-
-    // position[3] = 1.0
-    // focalPoint[3] = 1.0
-    // viewUp[3] = 0.0
-
-    const newPosition: Types.Point3 = [0, 0, 0];
-    const newFocalPoint: Types.Point3 = [0, 0, 0];
-    const newViewUp: Types.Point3 = [0, 0, 0];
-
-    const transform = mat4.identity(new Float32Array(16));
-    mat4.translate(transform, transform, [cx, cy, cz]);
-    mat4.rotate(transform, transform, angle, [ax, ay, az]);
-    mat4.translate(transform, transform, [-cx, -cy, -cz]);
-    vec3.transformMat4(newPosition, position, transform);
-    vec3.transformMat4(newFocalPoint, focalPoint, transform);
-
-    mat4.identity(transform);
-    mat4.rotate(transform, transform, angle, [ax, ay, az]);
-    vec3.transformMat4(<Types.Point3>newViewUp, viewUp, transform);
-
-    viewport.setCamera({
-      position: newPosition,
-      viewUp: newViewUp,
-      focalPoint: newFocalPoint,
-    });
-
-    viewport.render();
-  }
-}
-
-VolumeRotateMouseWheelTool.toolName = 'VolumeRotateMouseWheel';
-export default VolumeRotateMouseWheelTool;

package/src/tools/WindowLevelTool.ts

@@ -1,281 +0,0 @@
-import { BaseTool } from './base';
-import {
-  getEnabledElement,
-  VolumeViewport,
-  StackViewport,
-  utilities,
-  cache,
-  Types,
-} from '@cornerstonejs/core';
-import { EventTypes } from '../types';
-
-// Todo: should move to configuration
-const DEFAULT_MULTIPLIER = 4;
-const DEFAULT_IMAGE_DYNAMIC_RANGE = 1024;
-const PT = 'PT';
-
-/**
- * WindowLevel tool manipulates the windowLevel applied to a viewport. It
- * provides a way to set the windowCenter and windowWidth of a viewport
- * by dragging mouse over the image.
- *
- */
-class WindowLevelTool extends BaseTool {
-  static toolName;
-  constructor(
-    toolProps = {},
-    defaultToolProps = {
-      supportedInteractionTypes: ['Mouse', 'Touch'],
-    }
-  ) {
-    super(toolProps, defaultToolProps);
-  }
-
-  touchDragCallback(evt: EventTypes.InteractionEventType) {
-    this.mouseDragCallback(evt);
-  }
-
-  mouseDragCallback(evt: EventTypes.InteractionEventType) {
-    const { element, deltaPoints } = evt.detail;
-    const enabledElement = getEnabledElement(element);
-    const { renderingEngine, viewport } = enabledElement;
-
-    let volumeId,
-      lower,
-      upper,
-      modality,
-      newRange,
-      viewportsContainingVolumeUID;
-    let isPreScaled = false;
-
-    if (viewport instanceof VolumeViewport) {
-      const targetId = this.getTargetId(viewport as Types.IVolumeViewport);
-      volumeId = targetId.split('volumeId:')[1];
-      viewportsContainingVolumeUID = utilities.getViewportsWithVolumeId(
-        volumeId,
-        renderingEngine.id
-      );
-      const properties = viewport.getProperties();
-      ({ lower, upper } = properties.voiRange);
-      const volume = cache.getVolume(volumeId);
-      modality = volume.metadata.Modality;
-      isPreScaled = volume.scaling && Object.keys(volume.scaling).length > 0;
-    } else if (viewport instanceof StackViewport) {
-      const properties = viewport.getProperties();
-      modality = viewport.modality;
-      ({ lower, upper } = properties.voiRange);
-      const { preScale } = viewport.getImageData();
-      isPreScaled =
-        preScale.scaled && preScale.scalingParameters?.suvbw !== undefined;
-    } else {
-      throw new Error('Viewport is not a valid type');
-    }
-
-    // If modality is PT, treat it special to not include the canvas delta in
-    // the x direction. For other modalities, use the canvas delta in both
-    // directions, and if the viewport is a volumeViewport, the multiplier
-    // is calculate using the volume min and max.
-    if (modality === PT) {
-      newRange = this.getPTScaledNewRange({
-        deltaPointsCanvas: deltaPoints.canvas,
-        lower,
-        upper,
-        clientHeight: element.clientHeight,
-        isPreScaled,
-        viewport,
-        volumeId,
-      });
-    } else {
-      newRange = this.getNewRange({
-        viewport,
-        deltaPointsCanvas: deltaPoints.canvas,
-        volumeId,
-        lower,
-        upper,
-      });
-    }
-
-    if (viewport instanceof StackViewport) {
-      viewport.setProperties({
-        voiRange: newRange,
-      });
-
-      viewport.render();
-      return;
-    }
-
-    if (viewport instanceof VolumeViewport) {
-      viewport.setProperties({
-        voiRange: newRange,
-      });
-
-      viewportsContainingVolumeUID.forEach((vp) => {
-        vp.render();
-      });
-      return;
-    }
-  }
-
-  getPTScaledNewRange({
-    deltaPointsCanvas,
-    lower,
-    upper,
-    clientHeight,
-    viewport,
-    volumeId,
-    isPreScaled,
-  }) {
-    let multiplier = DEFAULT_MULTIPLIER;
-
-    if (isPreScaled) {
-      multiplier = 5 / clientHeight;
-    } else {
-      multiplier =
-        this._getMultiplierFromDynamicRange(viewport, volumeId) ||
-        DEFAULT_MULTIPLIER;
-    }
-
-    const deltaY = deltaPointsCanvas[1];
-    const wcDelta = deltaY * multiplier;
-
-    upper -= wcDelta;
-    upper = isPreScaled ? Math.max(upper, 0.1) : upper;
-
-    return { lower, upper };
-  }
-
-  getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }) {
-    const multiplier =
-      this._getMultiplierFromDynamicRange(viewport, volumeId) ||
-      DEFAULT_MULTIPLIER;
-
-    const wwDelta = deltaPointsCanvas[0] * multiplier;
-    const wcDelta = deltaPointsCanvas[1] * multiplier;
-
-    let { windowWidth, windowCenter } = utilities.windowLevel.toWindowLevel(
-      lower,
-      upper
-    );
-
-    windowWidth += wwDelta;
-    windowCenter += wcDelta;
-
-    windowWidth = Math.max(windowWidth, 1);
-
-    // Convert back to range
-    return utilities.windowLevel.toLowHighRange(windowWidth, windowCenter);
-  }
-
-  _getMultiplierFromDynamicRange(viewport, volumeId) {
-    let imageDynamicRange;
-
-    if (volumeId) {
-      const imageVolume = cache.getVolume(volumeId);
-      const { dimensions } = imageVolume;
-      const scalarData = imageVolume.getScalarData();
-      const calculatedDynamicRange = this._getImageDynamicRangeFromMiddleSlice(
-        scalarData,
-        dimensions
-      );
-      const BitsStored = imageVolume?.metadata?.BitsStored;
-      const metadataDynamicRange = BitsStored ? 2 ** BitsStored : Infinity;
-      // Burned in Pixels often use pixel values above the BitsStored.
-      // This results in a multiplier which is way higher than what you would
-      // want in practice. Thus we take the min between the metadata dynamic
-      // range and actual middel slice dynamic range.
-      imageDynamicRange = Math.min(
-        calculatedDynamicRange,
-        metadataDynamicRange
-      );
-    } else {
-      imageDynamicRange = this._getImageDynamicRangeFromViewport(viewport);
-    }
-
-    const ratio = imageDynamicRange / DEFAULT_IMAGE_DYNAMIC_RANGE;
-
-    let multiplier = DEFAULT_MULTIPLIER;
-
-    if (ratio > 1) {
-      multiplier = Math.round(ratio);
-    }
-    return multiplier;
-  }
-
-  _getImageDynamicRangeFromViewport(viewport) {
-    const { imageData } = viewport.getImageData();
-    const dimensions = imageData.getDimensions();
-
-    let scalarData;
-    // if getScalarData is a method on imageData
-    if (imageData.getScalarData) {
-      scalarData = imageData.getScalarData();
-    } else {
-      scalarData = imageData.getPointData().getScalars();
-    }
-
-    if (dimensions[2] !== 1) {
-      return this._getImageDynamicRangeFromMiddleSlice(scalarData, dimensions);
-    }
-
-    let range;
-    if (scalarData.getRange) {
-      range = scalarData.getRange();
-    } else {
-      const { min, max } = this._getMinMax(scalarData, scalarData.length);
-      range = [min, max];
-    }
-
-    return range[1] - range[0];
-  }
-
-  _getImageDynamicRangeFromMiddleSlice = (scalarData, dimensions) => {
-    const middleSliceIndex = Math.floor(dimensions[2] / 2);
-
-    const frameLength = dimensions[0] * dimensions[1];
-    let bytesPerVoxel;
-    let TypedArrayConstructor;
-
-    if (scalarData instanceof Float32Array) {
-      bytesPerVoxel = 4;
-      TypedArrayConstructor = Float32Array;
-    } else if (scalarData instanceof Uint8Array) {
-      bytesPerVoxel = 1;
-      TypedArrayConstructor = Uint8Array;
-    } else if (scalarData instanceof Uint16Array) {
-      bytesPerVoxel = 2;
-      TypedArrayConstructor = Uint16Array;
-    } else if (scalarData instanceof Int16Array) {
-      bytesPerVoxel = 2;
-      TypedArrayConstructor = Int16Array;
-    }
-
-    const buffer = scalarData.buffer;
-    const byteOffset = middleSliceIndex * frameLength * bytesPerVoxel;
-    const frame = new TypedArrayConstructor(buffer, byteOffset, frameLength);
-
-    const { max, min } = this._getMinMax(frame, frameLength);
-
-    return max - min;
-  };
-
-  private _getMinMax(frame: Uint8Array | Float32Array, frameLength: number) {
-    let min = Infinity;
-    let max = -Infinity;
-
-    for (let i = 0; i < frameLength; i++) {
-      const voxel = frame[i];
-
-      if (voxel < min) {
-        min = voxel;
-      }
-
-      if (voxel > max) {
-        max = voxel;
-      }
-    }
-    return { max, min };
-  }
-}
-
-WindowLevelTool.toolName = 'WindowLevel';
-export default WindowLevelTool;