@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

package/src/tools/SegmentationIntersectionTool.ts

@@ -1,301 +0,0 @@
-import { getRenderingEngine } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-
-import {
-  addAnnotation,
-  getAnnotations,
-} from '../stateManagement/annotation/annotationState';
-import { drawPath } from '../drawingSvg';
-import { getToolGroup } from '../store/ToolGroupManager';
-import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
-import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
-import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-import { Annotation } from '../types';
-import { distanceToPoint } from '../utilities/math/point';
-import { pointToString } from '../utilities/pointToString';
-import { polyDataUtils } from '../utilities';
-
-export interface SegmentationIntersectionAnnotation extends Annotation {
-  data: {
-    actorsWorldPointsMap: Map<string, Map<string, object>>;
-  };
-}
-
-class SegmentationIntersectionTool extends AnnotationDisplayTool {
-  static toolName;
-
-  constructor(
-    toolProps: PublicToolProps = {},
-    defaultToolProps: ToolProps = {
-      configuration: {
-        opacity: 0.5,
-      },
-    }
-  ) {
-    super(toolProps, defaultToolProps);
-  }
-
-  /**
-   * Initialize the annotation data and calculates surface intersections
-   * @returns
-   */
-  _init = (): void => {
-    const viewportsInfo = getToolGroup(this.toolGroupId).viewportsInfo;
-
-    if (!viewportsInfo?.length) {
-      console.warn(this.getToolName() + 'Tool: No viewports found');
-      return;
-    }
-
-    const firstViewport = getRenderingEngine(
-      viewportsInfo[0].renderingEngineId
-    )?.getViewport(viewportsInfo[0].viewportId);
-
-    if (!firstViewport) {
-      return;
-    }
-    const frameOfReferenceUID = firstViewport.getFrameOfReferenceUID();
-    const annotations = getAnnotations(this.getToolName(), frameOfReferenceUID);
-
-    if (!annotations?.length) {
-      const actorsWorldPointsMap = new Map();
-      calculateSurfaceSegmentationIntersections(
-        actorsWorldPointsMap,
-        viewportsInfo
-      );
-      const newAnnotation: SegmentationIntersectionAnnotation = {
-        highlighted: true,
-        invalidated: true,
-        metadata: {
-          toolName: this.getToolName(),
-          FrameOfReferenceUID: frameOfReferenceUID,
-          referencedImageId: null,
-        },
-        data: {
-          actorsWorldPointsMap,
-        },
-      };
-
-      addAnnotation(newAnnotation, frameOfReferenceUID);
-    }
-
-    triggerAnnotationRenderForViewportIds(
-      getRenderingEngine(viewportsInfo[0].renderingEngineId),
-      viewportsInfo.map(({ viewportId }) => viewportId)
-    );
-  };
-
-  onSetToolEnabled = (): void => {
-    this._init();
-  };
-
-  onCameraModified = (evt: Types.EventTypes.CameraModifiedEvent): void => {
-    this._init();
-  };
-
-  /**
-   * Renders the surface intersections
-   *
-   * @param enabledElement - The Cornerstone's enabledElement.
-   * @param svgDrawingHelper - The svgDrawingHelper providing the context for drawing.
-   */
-  renderAnnotation = (
-    enabledElement: Types.IEnabledElement,
-    svgDrawingHelper: SVGDrawingHelper
-  ): boolean => {
-    const { viewport, FrameOfReferenceUID } = enabledElement;
-
-    let renderStatus = false;
-
-    const annotations = getAnnotations(this.getToolName(), FrameOfReferenceUID);
-    if (!annotations?.length) {
-      return renderStatus;
-    }
-    const annotation = annotations[0];
-    const { annotationUID } = annotation;
-    const actorsWorldPointsMap = annotation.data.actorsWorldPointsMap;
-
-    calculateSurfaceSegmentationIntersectionsForViewport(
-      actorsWorldPointsMap,
-      viewport
-    );
-
-    const actorEntries = viewport.getActors();
-    const cacheId = getCacheId(viewport);
-
-    actorEntries.forEach((actorEntry) => {
-      if (!actorEntry?.clippingFilter) {
-        return;
-      }
-      const actorWorldPointMap = actorsWorldPointsMap.get(actorEntry.uid);
-      if (!actorWorldPointMap) {
-        return;
-      }
-      if (!actorWorldPointMap.get(cacheId)) {
-        return;
-      }
-      let polyLineIdx = 1;
-      const { worldPointsSet, color } = actorWorldPointMap.get(cacheId);
-      for (let i = 0; i < worldPointsSet.length; i++) {
-        const worldPoints = worldPointsSet[i];
-        const canvasPoints = worldPoints.map((point) =>
-          viewport.worldToCanvas(point)
-        );
-
-        const options = {
-          color: color,
-          fillColor: color,
-          fillOpacity: this.configuration.opacity,
-          closePath: true,
-          lineWidth: 2,
-        };
-
-        const polyLineUID = actorEntry.uid + '#' + polyLineIdx;
-        drawPath(
-          svgDrawingHelper,
-          annotationUID,
-          polyLineUID,
-          canvasPoints,
-          options
-        );
-        polyLineIdx++;
-      }
-    });
-
-    renderStatus = true;
-    return renderStatus;
-  };
-}
-
-/**
- * Calculates surface intersections points for all surface actors in a list of viewports
- * @param actorWorldPointsMap
- * @param viewportsInfo
- */
-function calculateSurfaceSegmentationIntersections(
-  actorsWorldPointsMap,
-  viewportsInfo
-) {
-  viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-    const viewport =
-      getRenderingEngine(renderingEngineId)?.getViewport(viewportId);
-    calculateSurfaceSegmentationIntersectionsForViewport(
-      actorsWorldPointsMap,
-      viewport
-    );
-  });
-}
-
-/**
- * Calculates surface intersections points for all surface actors in a viewport
- * generating a set of polyline points for each actor
- * @param actorWorldPointsMap
- * @param viewport
- */
-function calculateSurfaceSegmentationIntersectionsForViewport(
-  actorsWorldPointsMap,
-  viewport
-) {
-  const actorEntries = viewport.getActors();
-
-  // we should not use the focalPoint here, since the pan and zoom updates it,
-  // imageIndex is reliable enough
-  const cacheId = getCacheId(viewport);
-
-  actorEntries.forEach((actorEntry) => {
-    if (!actorEntry?.clippingFilter) {
-      return;
-    }
-
-    let actorWorldPointsMap = actorsWorldPointsMap.get(actorEntry.uid);
-    if (!actorWorldPointsMap) {
-      actorWorldPointsMap = new Map();
-      actorsWorldPointsMap.set(actorEntry.uid, actorWorldPointsMap);
-    }
-    if (!actorWorldPointsMap.get(cacheId)) {
-      const polyData = actorEntry.clippingFilter.getOutputData();
-      const worldPointsSet = polyDataUtils.getPolyDataPoints(polyData);
-      if (!worldPointsSet) {
-        return;
-      }
-
-      // worldPointsSet = removeExtraPoints(viewport, worldPointsSet);
-      const colorArray = actorEntry.actor.getProperty().getColor();
-      const color = colorToString(colorArray);
-      actorWorldPointsMap.set(cacheId, { worldPointsSet, color });
-    }
-  });
-}
-
-function getCacheId(viewport) {
-  const { viewPlaneNormal } = viewport.getCamera();
-  const imageIndex = viewport.getCurrentImageIdIndex();
-  return `${viewport.id}-${pointToString(viewPlaneNormal)}-${imageIndex}`;
-}
-
-/**
- * Transform a color array into a string
- * @param colorArray
- * @returns
- */
-function colorToString(colorArray): string {
-  function colorComponentToString(component) {
-    let componentString = Math.floor(component * 255).toString(16);
-    if (componentString.length === 1) {
-      componentString = '0' + componentString;
-    }
-    return componentString;
-  }
-  return (
-    '#' +
-    colorComponentToString(colorArray[0]) +
-    colorComponentToString(colorArray[1]) +
-    colorComponentToString(colorArray[2])
-  );
-}
-
-/**
- * Remove duplicate and unnecessary points
- * @param worldPoints
- * @param canvasPoints
- * @returns
- */
-function removeExtraPoints(viewport, worldPointsSet) {
-  return worldPointsSet.map((worldPoints) => {
-    const canvasPoints = worldPoints.map((point) => {
-      const canvasPoint = viewport.worldToCanvas(point);
-      return [Math.floor(canvasPoint[0]), Math.floor(canvasPoint[1])];
-    });
-
-    let lastPoint;
-    const newWorldPoints = [];
-    let newCanvasPoints = [];
-    // removing duplicate points
-    for (let i = 0; i < worldPoints.length; i++) {
-      if (lastPoint) {
-        if (distanceToPoint(lastPoint, canvasPoints[i]) > 0) {
-          newWorldPoints.push(worldPoints[i]);
-          newCanvasPoints.push(canvasPoints[i]);
-        }
-      }
-      lastPoint = canvasPoints[i];
-    }
-
-    // checking if a middle point is near the start
-    const firstPoint = newCanvasPoints[0];
-    for (
-      let j = Math.min(30, newCanvasPoints.length);
-      j < newCanvasPoints.length;
-      j++
-    ) {
-      if (distanceToPoint(firstPoint, newCanvasPoints[j]) < 0.5) {
-        newCanvasPoints = newCanvasPoints.slice(0, j);
-        return newWorldPoints.slice(0, j);
-      }
-    }
-    return newWorldPoints;
-  });
-}
-
-SegmentationIntersectionTool.toolName = 'SegmentationIntersection';
-export default SegmentationIntersectionTool;

package/src/tools/StackScrollTool.ts

@@ -1,81 +0,0 @@
-import { getEnabledElementByIds, VolumeViewport } 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 = viewport.getNumberOfSlices();
-
-    // 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));
-  }
-}
-
-StackScrollTool.toolName = 'StackScroll';
-export default StackScrollTool;

package/src/tools/StackScrollToolMouseWheelTool.ts

@@ -1,51 +0,0 @@
-import { getEnabledElement, utilities } 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,
-        scrollSlabs: 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 = utilities.getVolumeId(targetId);
-
-    scroll(viewport, {
-      delta,
-      debounceLoading: this.configuration.debounceIfNotLoaded,
-      loop: this.configuration.loop,
-      volumeId,
-      scrollSlabs: this.configuration.scrollSlabs,
-    });
-  }
-}
-
-StackScrollMouseWheelTool.toolName = 'StackScrollMouseWheel';
-export default StackScrollMouseWheelTool;

package/src/tools/TrackballRotateTool.ts

@@ -1,245 +0,0 @@
-import vtkMath from '@kitware/vtk.js/Common/Core/Math';
-import { Events } from '../enums';
-import {
-  eventTarget,
-  getEnabledElement,
-  getEnabledElementByIds,
-} 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';
-import { getToolGroup } from '../store/ToolGroupManager';
-
-class TrackballRotateTool extends BaseTool {
-  static toolName;
-  touchDragCallback: (evt: EventTypes.InteractionEventType) => void;
-  mouseDragCallback: (evt: EventTypes.InteractionEventType) => void;
-  cleanUp: () => void;
-  _resizeObservers = new Map();
-  _viewportAddedListener: (evt: any) => void;
-  _hasResolutionChanged = false;
-
-  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);
-  }
-
-  preMouseDownCallback = (evt: EventTypes.InteractionEventType) => {
-    const eventDetail = evt.detail;
-    const { element } = eventDetail;
-    const enabledElement = getEnabledElement(element);
-    const { viewport } = enabledElement;
-    const actorEntry = viewport.getDefaultActor();
-    const actor = actorEntry.actor as Types.VolumeActor;
-    const mapper = actor.getMapper();
-    const originalSampleDistance = mapper.getSampleDistance();
-
-    if (!this._hasResolutionChanged) {
-      mapper.setSampleDistance(originalSampleDistance * 2);
-      this._hasResolutionChanged = true;
-
-      if (this.cleanUp !== null) {
-        // Clean up previous event listener
-        document.removeEventListener('mouseup', this.cleanUp);
-      }
-
-      this.cleanUp = () => {
-        mapper.setSampleDistance(originalSampleDistance);
-        viewport.render();
-        this._hasResolutionChanged = false;
-      };
-
-      document.addEventListener('mouseup', this.cleanUp, { once: true });
-    }
-    return true;
-  };
-
-  _getViewportsInfo = () => {
-    const viewports = getToolGroup(this.toolGroupId).viewportsInfo;
-    return viewports;
-  };
-
-  onSetToolActive = () => {
-    const subscribeToElementResize = () => {
-      const viewportsInfo = this._getViewportsInfo();
-      viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-        if (!this._resizeObservers.has(viewportId)) {
-          const { viewport } = getEnabledElementByIds(
-            viewportId,
-            renderingEngineId
-          ) || { viewport: null };
-
-          if (!viewport) {
-            return;
-          }
-
-          const { element } = viewport;
-
-          const resizeObserver = new ResizeObserver(() => {
-            const element = getEnabledElementByIds(
-              viewportId,
-              renderingEngineId
-            );
-            if (!element) {
-              return;
-            }
-            const { viewport } = element;
-            viewport.resetCamera();
-            viewport.render();
-          });
-
-          resizeObserver.observe(element);
-          this._resizeObservers.set(viewportId, resizeObserver);
-        }
-      });
-    };
-
-    subscribeToElementResize();
-
-    this._viewportAddedListener = (evt) => {
-      if (evt.detail.toolGroupId === this.toolGroupId) {
-        subscribeToElementResize();
-      }
-    };
-
-    eventTarget.addEventListener(
-      Events.TOOLGROUP_VIEWPORT_ADDED,
-      this._viewportAddedListener
-    );
-  };
-
-  onSetToolDisabled = () => {
-    // Disconnect all resize observers
-    this._resizeObservers.forEach((resizeObserver, viewportId) => {
-      resizeObserver.disconnect();
-      this._resizeObservers.delete(viewportId);
-    });
-
-    if (this._viewportAddedListener) {
-      eventTarget.removeEventListener(
-        Events.TOOLGROUP_VIEWPORT_ADDED,
-        this._viewportAddedListener
-      );
-      this._viewportAddedListener = null; // Clear the reference to the listener
-    }
-  };
-
-  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,
-    });
-  };
-
-  _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;