@cornerstonejs/tools 0.56.2 → 0.56.3

package/src/eventListeners/wheel/normalizeWheel.ts

@@ -0,0 +1,69 @@
+// Reasonable defaults
+const PIXEL_STEP = 10;
+const LINE_HEIGHT = 40;
+const PAGE_HEIGHT = 800;
+
+/**
+ * Normalizes wheel events and provides properties that are more
+ * consistent and helpful across different browsers
+ *
+ * @param event - the original mouse event
+ * @returns a normalized eventDetail
+ */
+export default function normalizeWheel(event) {
+  let spinX = 0,
+    spinY = 0,
+    pixelX = 0,
+    pixelY = 0;
+
+  // Legacy
+  if ('detail' in event) {
+    spinY = event.detail;
+  }
+  if ('wheelDelta' in event) {
+    spinY = -event.wheelDelta / 120;
+  }
+  if ('wheelDeltaY' in event) {
+    spinY = -event.wheelDeltaY / 120;
+  }
+  if ('wheelDeltaX' in event) {
+    spinX = -event.wheelDeltaX / 120;
+  }
+
+  pixelX = spinX * PIXEL_STEP;
+  pixelY = spinY * PIXEL_STEP;
+
+  if ('deltaY' in event) {
+    pixelY = event.deltaY;
+  }
+  if ('deltaX' in event) {
+    pixelX = event.deltaX;
+  }
+
+  if ((pixelX || pixelY) && event.deltaMode) {
+    if (event.deltaMode === 1) {
+      // Delta in LINE units
+      pixelX *= LINE_HEIGHT;
+      pixelY *= LINE_HEIGHT;
+    } else {
+      // Delta in PAGE units
+      pixelX *= PAGE_HEIGHT;
+      pixelY *= PAGE_HEIGHT;
+    }
+  }
+
+  // Fall-back if spin cannot be determined
+  if (pixelX && !spinX) {
+    spinX = pixelX < 1 ? -1 : 1;
+  }
+  if (pixelY && !spinY) {
+    spinY = pixelY < 1 ? -1 : 1;
+  }
+
+  return {
+    spinX,
+    spinY,
+    pixelX,
+    pixelY,
+  };
+}

package/src/eventListeners/wheel/wheelListener.ts

@@ -0,0 +1,51 @@
+import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import normalizeWheel from './normalizeWheel';
+import Events from '../../enums/Events';
+// ~~ VIEWPORT LIBRARY
+import getMouseEventPoints from '../mouse/getMouseEventPoints';
+import { MouseWheelEventDetail } from '../../types/EventTypes';
+
+/**
+ * wheelListener - Captures and normalizes mouse wheel events. Emits as a
+ * cornerstoneTools3D mouse wheel event.
+ * @param evt - The mouse wheel event.
+ */
+function wheelListener(evt: WheelEvent) {
+  const element = <HTMLDivElement>evt.currentTarget;
+  const enabledElement = getEnabledElement(element);
+  const { renderingEngineId, viewportId } = enabledElement;
+
+  // Prevent triggering MouseWheel events that are not real scroll events:
+  // E.g. when clicking the MiddleMouseWheelButton, a deltaY of 0 is emitted.
+  // See https://github.com/cornerstonejs/cornerstoneTools/issues/935
+  if (evt.deltaY > -1 && evt.deltaY < 1) {
+    return;
+  }
+
+  evt.preventDefault();
+
+  const { spinX, spinY, pixelX, pixelY } = normalizeWheel(evt);
+  const direction = spinY < 0 ? -1 : 1;
+
+  const eventDetail: MouseWheelEventDetail = {
+    event: evt,
+    eventName: Events.MOUSE_WHEEL,
+    renderingEngineId,
+    viewportId,
+    element,
+    camera: {},
+    detail: evt,
+    wheel: {
+      spinX,
+      spinY,
+      pixelX,
+      pixelY,
+      direction,
+    },
+    points: getMouseEventPoints(evt),
+  };
+
+  triggerEvent(element, Events.MOUSE_WHEEL, eventDetail);
+}
+
+export default wheelListener;

package/src/index.ts

@@ -0,0 +1,133 @@
+import { init, destroy } from './init';
+import {
+  addTool,
+  removeTool,
+  state,
+  ToolGroupManager,
+  SynchronizerManager,
+  Synchronizer,
+  cancelActiveManipulations,
+} from './store';
+
+import * as CONSTANTS from './constants';
+
+// Name spaces
+import * as synchronizers from './synchronizers';
+import * as drawing from './drawingSvg';
+import * as utilities from './utilities';
+import * as cursors from './cursors';
+import * as Types from './types';
+import * as annotation from './stateManagement/annotation';
+import * as segmentation from './stateManagement/segmentation';
+
+import {
+  BaseTool,
+  AnnotationTool,
+  PanTool,
+  TrackballRotateTool,
+  DragProbeTool,
+  WindowLevelTool,
+  ZoomTool,
+  StackScrollTool,
+  PlanarRotateTool,
+  StackScrollMouseWheelTool,
+  VolumeRotateMouseWheelTool,
+  MIPJumpToClickTool,
+  LengthTool,
+  ProbeTool,
+  RectangleROITool,
+  EllipticalROITool,
+  CircleROITool,
+  BidirectionalTool,
+  PlanarFreehandROITool,
+  ArrowAnnotateTool,
+  CrosshairsTool,
+  ReferenceLinesTool,
+  RectangleScissorsTool,
+  CircleScissorsTool,
+  SphereScissorsTool,
+  RectangleROIThresholdTool,
+  RectangleROIStartEndThresholdTool,
+  SegmentationDisplayTool,
+  BrushTool,
+  AngleTool,
+  CobbAngleTool,
+  MagnifyTool,
+  ReferenceCursors,
+  ReferenceLines,
+  PaintFillTool,
+  ScaleOverlayTool,
+} from './tools';
+
+import * as Enums from './enums';
+
+export {
+  //
+  init,
+  destroy,
+  addTool,
+  removeTool,
+  cancelActiveManipulations,
+  // Base Tools
+  BaseTool,
+  AnnotationTool,
+  // Manipulation Tools
+  PanTool,
+  TrackballRotateTool,
+  DragProbeTool,
+  WindowLevelTool,
+  ZoomTool,
+  StackScrollTool,
+  PlanarRotateTool,
+  StackScrollMouseWheelTool,
+  VolumeRotateMouseWheelTool,
+  MIPJumpToClickTool,
+  // Annotation Tools
+  LengthTool,
+  CrosshairsTool,
+  ReferenceLinesTool,
+  ProbeTool,
+  RectangleROITool,
+  EllipticalROITool,
+  CircleROITool,
+  BidirectionalTool,
+  PlanarFreehandROITool,
+  ArrowAnnotateTool,
+  AngleTool,
+  CobbAngleTool,
+  MagnifyTool,
+  ReferenceCursors,
+  ReferenceLines,
+  ScaleOverlayTool,
+  // Segmentation Display
+  SegmentationDisplayTool,
+  // Segmentation Editing Tools
+  RectangleScissorsTool,
+  CircleScissorsTool,
+  SphereScissorsTool,
+  RectangleROIThresholdTool,
+  RectangleROIStartEndThresholdTool,
+  BrushTool,
+  // Synchronizers
+  synchronizers,
+  Synchronizer,
+  SynchronizerManager,
+  PaintFillTool,
+  Types,
+  state,
+  // ToolGroups
+  ToolGroupManager,
+  // Enums
+  Enums,
+  // Constants
+  CONSTANTS,
+  // Drawing API
+  drawing,
+  // Annotation
+  annotation,
+  // Segmentations
+  segmentation,
+  // Utilities
+  utilities,
+  cursors,
+};

package/src/init.ts

@@ -0,0 +1,187 @@
+import { eventTarget, Enums } from '@cornerstonejs/core';
+import { getAnnotationManager } from './stateManagement/annotation/annotationState';
+import { getDefaultSegmentationStateManager } from './stateManagement/segmentation/segmentationState';
+import { Events as TOOLS_EVENTS } from './enums';
+import { addEnabledElement, removeEnabledElement } from './store';
+import { resetCornerstoneToolsState } from './store/state';
+import {
+  annotationSelectionListener,
+  segmentationDataModifiedEventListener,
+  segmentationRepresentationModifiedEventListener,
+  segmentationRepresentationRemovedEventListener,
+  segmentationModifiedListener,
+  annotationModifiedListener,
+} from './eventListeners';
+
+import * as ToolGroupManager from './store/ToolGroupManager';
+
+let csToolsInitialized = false;
+
+/**
+ * Initialize the cornerstoneTools package. It will add event listeners for mouse
+ * and keyboard events.
+ * @param defaultConfiguration - A configuration object that will be used to
+ * initialize the tool.
+ */
+export function init(defaultConfiguration = {}): void {
+  if (csToolsInitialized) {
+    return;
+  }
+
+  _addCornerstoneEventListeners();
+  _addCornerstoneToolsEventListeners();
+
+  csToolsInitialized = true;
+}
+
+/**
+ * It destroys and cleanup state for cornerstone3DTools. It removes all the tools
+ * that were added to the tool groups and restore states. It also removes all
+ * event listeners.
+ */
+export function destroy(): void {
+  _removeCornerstoneEventListeners();
+  _removeCornerstoneToolsEventListeners();
+
+  // Important: destroy ToolGroups first, in order for cleanup to work correctly for the
+  // added tools.
+  ToolGroupManager.destroy();
+
+  // Remove all tools
+  resetCornerstoneToolsState();
+
+  // remove all annotation.
+  const annotationManager = getAnnotationManager();
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+
+  annotationManager.restoreAnnotations({});
+  segmentationStateManager.resetState();
+  csToolsInitialized = false;
+}
+
+/**
+ * Wires up event listeners for the Cornerstone#ElementDisabled and
+ * Cornerstone#ElementEnabled events.
+ *
+ * @internal
+ */
+function _addCornerstoneEventListeners(): void {
+  // Clear any listeners that may already be set
+  _removeCornerstoneEventListeners();
+
+  const elementEnabledEvent = Enums.Events.ELEMENT_ENABLED;
+  const elementDisabledEvent = Enums.Events.ELEMENT_DISABLED;
+
+  eventTarget.addEventListener(elementEnabledEvent, addEnabledElement);
+  eventTarget.addEventListener(elementDisabledEvent, removeEnabledElement);
+}
+
+/**
+ * Removes event listeners for the Cornerstone#ElementDisabled and
+ * Cornerstone#ElementEnabled events.
+ *
+ */
+function _removeCornerstoneEventListeners(): void {
+  const elementEnabledEvent = Enums.Events.ELEMENT_ENABLED;
+  const elementDisabledEvent = Enums.Events.ELEMENT_DISABLED;
+
+  eventTarget.removeEventListener(elementEnabledEvent, addEnabledElement);
+  eventTarget.removeEventListener(elementDisabledEvent, removeEnabledElement);
+}
+
+/**
+ * It adds an event listener to the event target (the cornerstoneTools object) for
+ * the annotation selected and annotation modified events.
+ */
+function _addCornerstoneToolsEventListeners() {
+  // Clear any listeners that may already be set
+  _removeCornerstoneToolsEventListeners();
+
+  /**
+   * Annotation
+   */
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.ANNOTATION_MODIFIED,
+    annotationModifiedListener
+  );
+
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE,
+    annotationSelectionListener
+  );
+
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE,
+    annotationSelectionListener
+  );
+
+  /**
+   * Segmentation
+   */
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.SEGMENTATION_MODIFIED,
+    segmentationModifiedListener
+  );
+
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED,
+    segmentationDataModifiedEventListener
+  );
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED,
+    segmentationRepresentationModifiedEventListener
+  );
+
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_REMOVED,
+    segmentationRepresentationRemovedEventListener
+  );
+}
+
+/**
+ * Remove the event listener for the the annotation selected and annotation modified events.
+ */
+function _removeCornerstoneToolsEventListeners() {
+  /**
+   * Annotation
+   */
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.ANNOTATION_MODIFIED,
+    annotationModifiedListener
+  );
+
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE,
+    annotationSelectionListener
+  );
+
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE,
+    annotationSelectionListener
+  );
+
+  /**
+   * Segmentation
+   */
+
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.SEGMENTATION_MODIFIED,
+    segmentationModifiedListener
+  );
+
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED,
+    segmentationDataModifiedEventListener
+  );
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED,
+    segmentationRepresentationModifiedEventListener
+  );
+
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_REMOVED,
+    segmentationRepresentationRemovedEventListener
+  );
+}
+
+export default init;