@cornerstonejs/tools 2.0.0-beta.7 → 2.0.0

package/src/cursors/index.ts

@@ -1,24 +0,0 @@
-import MouseCursor, { standardCursorNames } from './MouseCursor';
-import ImageMouseCursor from './ImageMouseCursor';
-import SVGMouseCursor from './SVGMouseCursor';
-import * as elementCursor from './elementCursor';
-import setCursorForElement from './setCursorForElement';
-import {
-  registerCursor,
-  svgCursorNames,
-  CursorSVG,
-} from './SVGCursorDescriptor';
-
-// Todo: this should be enum
-const CursorNames = [...svgCursorNames, ...standardCursorNames];
-
-export {
-  MouseCursor,
-  ImageMouseCursor,
-  SVGMouseCursor,
-  elementCursor,
-  registerCursor,
-  CursorNames,
-  CursorSVG,
-  setCursorForElement,
-};

package/src/cursors/setCursorForElement.ts

@@ -1,33 +0,0 @@
-import { setElementCursor } from './elementCursor';
-import MouseCursor from './MouseCursor';
-import SVGMouseCursor from './SVGMouseCursor';
-
-/**
- * Set the cursor for an HTML element. cursorNames can be either
- * cornerstone3DTools cursors or standard cursors.
- *
- * @param element - The element to set the cursor on.
- * @param cursorName - The name of the cursor to set. This can be
- * any cursor name either Cornerstone-specific cursor names or the standard
- * CSS cursor names.
- */
-function setCursorForElement(
-  element: HTMLDivElement,
-  cursorName: string
-): void {
-  let cursor = SVGMouseCursor.getDefinedCursor(cursorName, true);
-  if (!cursor) {
-    cursor = MouseCursor.getDefinedCursor(cursorName);
-  }
-
-  if (!cursor) {
-    console.log(
-      `Cursor ${cursorName} is not defined either as SVG or as a standard cursor.`
-    );
-    cursor = MouseCursor.getDefinedCursor(cursorName);
-  }
-
-  setElementCursor(element, cursor);
-}
-
-export default setCursorForElement;

package/src/drawingSvg/_getHash.ts

@@ -1,9 +0,0 @@
-function _getHash(
-  annotationUID: string,
-  drawingElementType: string,
-  nodeUID: string
-): string {
-  return `${annotationUID}::${drawingElementType}::${nodeUID}`;
-}
-
-export default _getHash;

package/src/drawingSvg/clearByToolType.ts

@@ -1,26 +0,0 @@
-import getSvgDrawingHelper from './getSvgDrawingHelper';
-
-/**
- * We are not using it anywhere yet.
- * @param element
- * @param toolType
- * @internal
- */
-function clearByToolType(element: HTMLDivElement, toolType: string): void {
-  const svgDrawingHelper = getSvgDrawingHelper(element);
-  const nodes = svgDrawingHelper.svgLayerElement.querySelectorAll(
-    'svg > *'
-  ) as NodeListOf<SVGElement>;
-
-  // Todo: check variable namings when this function starts to get utilized
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    const toolUID = node.dataset.toolUid;
-
-    if (toolUID === toolType) {
-      svgDrawingHelper.svgLayerElement.removeChild(node);
-    }
-  }
-}
-
-export default clearByToolType;

package/src/drawingSvg/draw.ts

@@ -1,16 +0,0 @@
-import getSvgDrawingHelper from './getSvgDrawingHelper';
-
-function draw(
-  element: HTMLDivElement,
-  fn: (svgDrawingElement: any) => any
-): void {
-  const svgDrawingHelper = getSvgDrawingHelper(element);
-
-  // Save...
-  fn(svgDrawingHelper);
-  // Restore...
-
-  svgDrawingHelper.clearUntouched();
-}
-
-export default draw;

package/src/drawingSvg/drawArrow.ts

@@ -1,82 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
-import drawLine from './drawLine';
-
-export default function drawArrow(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  arrowUID: string,
-  start: Types.Point2,
-  end: Types.Point2,
-  options = {}
-): void {
-  // if length is NaN return
-  if (isNaN(start[0]) || isNaN(start[1]) || isNaN(end[0]) || isNaN(end[1])) {
-    return;
-  }
-
-  const { color, width, lineWidth, lineDash } = Object.assign(
-    {
-      color: 'rgb(0, 255, 0)',
-      width: '2',
-      lineWidth: undefined,
-      lineDash: undefined,
-    },
-    options
-  );
-
-  // The line itself
-  drawLine(svgDrawingHelper, annotationUID, arrowUID, start, end, {
-    color,
-    width,
-    lineWidth,
-    lineDash,
-  });
-
-  // Drawing the head arrow with two lines
-  // Variables to be used when creating the arrow
-  const headLength = 10;
-  const angle = Math.atan2(end[1] - start[1], end[0] - start[0]);
-
-  const firstLine = {
-    start: [
-      end[0] - headLength * Math.cos(angle - Math.PI / 7),
-      end[1] - headLength * Math.sin(angle - Math.PI / 7),
-    ] as Types.Point2,
-    end: end,
-  };
-
-  const secondLine = {
-    start: [
-      end[0] - headLength * Math.cos(angle + Math.PI / 7),
-      end[1] - headLength * Math.sin(angle + Math.PI / 7),
-    ] as Types.Point2,
-    end: end,
-  };
-
-  drawLine(
-    svgDrawingHelper,
-    annotationUID,
-    '2',
-    firstLine.start,
-    firstLine.end,
-    {
-      color,
-      width,
-      lineWidth,
-    }
-  );
-
-  drawLine(
-    svgDrawingHelper,
-    annotationUID,
-    '3',
-    secondLine.start,
-    secondLine.end,
-    {
-      color,
-      width,
-      lineWidth,
-    }
-  );
-}

package/src/drawingSvg/drawCircle.ts

@@ -1,76 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
-
-import _getHash from './_getHash';
-
-import setAttributesIfNecessary from './setAttributesIfNecessary';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
-
-function drawCircle(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  circleUID: string,
-  center: Types.Point2,
-  radius: number,
-  options = {},
-  dataId = ''
-): void {
-  const {
-    color,
-    fill,
-    width,
-    lineWidth,
-    lineDash,
-    fillOpacity,
-    strokeOpacity,
-  } = Object.assign(
-    {
-      color: 'rgb(0, 255, 0)',
-      fill: 'transparent',
-      width: '2',
-      lineDash: undefined,
-      lineWidth: undefined,
-      strokeOpacity: 1,
-      fillOpacity: 1,
-    },
-    options
-  );
-
-  // for supporting both lineWidth and width options
-  const strokeWidth = lineWidth || width;
-
-  // variable for the namespace
-  const svgns = 'http://www.w3.org/2000/svg';
-  const svgNodeHash = _getHash(annotationUID, 'circle', circleUID);
-  const existingCircleElement = svgDrawingHelper.getSvgNode(svgNodeHash);
-
-  const attributes = {
-    cx: `${center[0]}`,
-    cy: `${center[1]}`,
-    r: `${radius}`,
-    stroke: color,
-    fill,
-    'stroke-width': strokeWidth,
-    'stroke-dasharray': lineDash,
-    'fill-opacity': fillOpacity, // setting fill opacity
-    'stroke-opacity': strokeOpacity, // setting stroke opacity
-  };
-
-  if (existingCircleElement) {
-    setAttributesIfNecessary(attributes, existingCircleElement);
-
-    svgDrawingHelper.setNodeTouched(svgNodeHash);
-  } else {
-    const newCircleElement = document.createElementNS(svgns, 'circle');
-
-    if (dataId !== '') {
-      newCircleElement.setAttribute('data-id', dataId);
-    }
-
-    setNewAttributesIfValid(attributes, newCircleElement);
-
-    svgDrawingHelper.appendNode(newCircleElement, svgNodeHash);
-  }
-}
-
-export default drawCircle;

package/src/drawingSvg/drawEllipse.ts

@@ -1,31 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
-
-import _getHash from './_getHash';
-import drawEllipseByCoordinates from './drawEllipseByCoordinates';
-
-function drawEllipse(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  ellipseUID: string,
-  corner1: Types.Point2,
-  corner2: Types.Point2,
-  options = {},
-  dataId = ''
-) {
-  const top: Types.Point2 = [(corner1[0] + corner2[0]) / 2, corner1[1]];
-  const bottom: Types.Point2 = [(corner1[0] + corner2[0]) / 2, corner2[1]];
-  const left: Types.Point2 = [corner1[0], (corner1[1] + corner2[1]) / 2];
-  const right: Types.Point2 = [corner2[0], (corner1[1] + corner2[1]) / 2];
-
-  drawEllipseByCoordinates(
-    svgDrawingHelper,
-    annotationUID,
-    ellipseUID,
-    [bottom, top, left, right],
-    (options = {}),
-    (dataId = '')
-  );
-}
-
-export default drawEllipse;

package/src/drawingSvg/drawEllipseByCoordinates.ts

@@ -1,73 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
-
-import _getHash from './_getHash';
-import setAttributesIfNecessary from './setAttributesIfNecessary';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
-
-function drawEllipseByCoordinates(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  ellipseUID: string,
-  canvasCoordinates: [Types.Point2, Types.Point2, Types.Point2, Types.Point2],
-  options = {},
-  dataId = ''
-): void {
-  const { color, width, lineWidth, lineDash } = Object.assign(
-    {
-      color: 'rgb(0, 255, 0)',
-      width: '2',
-      lineWidth: undefined,
-      lineDash: undefined,
-    },
-    options
-  );
-
-  // for supporting both lineWidth and width options
-  const strokeWidth = lineWidth || width;
-
-  const svgns = 'http://www.w3.org/2000/svg';
-  const svgNodeHash = _getHash(annotationUID, 'ellipse', ellipseUID);
-  const existingEllipse = svgDrawingHelper.getSvgNode(svgNodeHash);
-
-  const [bottom, top, left, right] = canvasCoordinates;
-
-  const w = Math.hypot(left[0] - right[0], left[1] - right[1]);
-  const h = Math.hypot(top[0] - bottom[0], top[1] - bottom[1]);
-  const angle =
-    (Math.atan2(left[1] - right[1], left[0] - right[0]) * 180) / Math.PI;
-
-  const center = [(left[0] + right[0]) / 2, (top[1] + bottom[1]) / 2];
-  const radiusX = w / 2;
-  const radiusY = h / 2;
-
-  const attributes = {
-    cx: `${center[0]}`,
-    cy: `${center[1]}`,
-    rx: `${radiusX}`,
-    ry: `${radiusY}`,
-    stroke: color,
-    fill: 'transparent',
-    transform: `rotate(${angle} ${center[0]} ${center[1]})`,
-    'stroke-width': strokeWidth,
-    'stroke-dasharray': lineDash,
-  };
-
-  if (existingEllipse) {
-    setAttributesIfNecessary(attributes, existingEllipse);
-
-    svgDrawingHelper.setNodeTouched(svgNodeHash);
-  } else {
-    const svgEllipseElement = document.createElementNS(svgns, 'ellipse');
-
-    if (dataId !== '') {
-      svgEllipseElement.setAttribute('data-id', dataId);
-    }
-
-    setNewAttributesIfValid(attributes, svgEllipseElement);
-
-    svgDrawingHelper.appendNode(svgEllipseElement, svgNodeHash);
-  }
-}
-
-export default drawEllipseByCoordinates;

package/src/drawingSvg/drawHandle.ts

@@ -1,88 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-import _getHash from './_getHash';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
-import setAttributesIfNecessary from './setAttributesIfNecessary';
-import { SVGDrawingHelper } from '../types';
-
-function drawHandle(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  handleGroupUID: string,
-  handle: Types.Point2,
-  options = {},
-  uniqueIndex
-): void {
-  const { color, handleRadius, width, lineWidth, fill, type, opacity } =
-    Object.assign(
-      {
-        color: 'rgb(0, 255, 0)',
-        handleRadius: '6',
-        width: '2',
-        lineWidth: undefined,
-        fill: 'transparent',
-        type: 'circle',
-        opacity: 1,
-      },
-      options
-    );
-
-  // for supporting both lineWidth and width options
-  const strokeWidth = lineWidth || width;
-
-  // variable for the namespace
-  const svgns = 'http://www.w3.org/2000/svg';
-  const svgNodeHash = _getHash(
-    annotationUID,
-    'handle',
-    `hg-${handleGroupUID}-index-${uniqueIndex}`
-  );
-
-  let attributes;
-  if (type === 'circle') {
-    attributes = {
-      cx: `${handle[0]}`,
-      cy: `${handle[1]}`,
-      r: handleRadius,
-      stroke: color,
-      fill,
-      'stroke-width': strokeWidth,
-      opacity: opacity,
-    };
-  } else if (type === 'rect') {
-    const handleRadiusFloat = parseFloat(handleRadius);
-    const side = handleRadiusFloat * 1.5;
-    const x = handle[0] - side * 0.5;
-    const y = handle[1] - side * 0.5;
-
-    attributes = {
-      x: `${x}`,
-      y: `${y}`,
-      width: `${side}`,
-      height: `${side}`,
-      stroke: color,
-      fill,
-      'stroke-width': strokeWidth,
-      rx: `${side * 0.1}`,
-      opacity: opacity,
-    };
-  } else {
-    throw new Error(`Unsupported handle type: ${type}`);
-  }
-
-  const existingHandleElement = svgDrawingHelper.getSvgNode(svgNodeHash);
-
-  if (existingHandleElement) {
-    setAttributesIfNecessary(attributes, existingHandleElement);
-
-    svgDrawingHelper.setNodeTouched(svgNodeHash);
-  } else {
-    const newHandleElement = document.createElementNS(svgns, type);
-
-    setNewAttributesIfValid(attributes, newHandleElement);
-
-    svgDrawingHelper.appendNode(newHandleElement, svgNodeHash);
-  }
-}
-
-export default drawHandle;

package/src/drawingSvg/drawHandles.ts

@@ -1,25 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-import { SVGDrawingHelper } from '../types';
-import drawHandle from './drawHandle';
-
-function drawHandles(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  handleGroupUID: string,
-  handlePoints: Array<Types.Point2>,
-  options = {}
-): void {
-  handlePoints.forEach((handle, i) => {
-    drawHandle(
-      svgDrawingHelper,
-      annotationUID,
-      handleGroupUID,
-      handle,
-      options,
-      i
-    );
-  });
-}
-
-export default drawHandles;

package/src/drawingSvg/drawLine.ts

@@ -1,70 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-import _getHash from './_getHash';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
-import setAttributesIfNecessary from './setAttributesIfNecessary';
-import { SVGDrawingHelper } from '../types';
-
-export default function drawLine(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  lineUID: string,
-  start: Types.Point2,
-  end: Types.Point2,
-  options = {},
-  dataId = ''
-): void {
-  // if length is NaN return
-  if (isNaN(start[0]) || isNaN(start[1]) || isNaN(end[0]) || isNaN(end[1])) {
-    return;
-  }
-
-  const { color, width, lineWidth, lineDash, shadow } = Object.assign(
-    {
-      color: 'rgb(0, 255, 0)',
-      width: '2',
-      lineWidth: undefined,
-      lineDash: undefined,
-      shadow: undefined,
-    },
-    options
-  );
-
-  // for supporting both lineWidth and width options
-  const strokeWidth = lineWidth || width;
-
-  const svgns = 'http://www.w3.org/2000/svg';
-  const svgNodeHash = _getHash(annotationUID, 'line', lineUID);
-  const existingLine = svgDrawingHelper.getSvgNode(svgNodeHash);
-  const dropShadowStyle = shadow
-    ? `filter:url(#shadow-${svgDrawingHelper.svgLayerElement.id});`
-    : '';
-
-  const attributes = {
-    x1: `${start[0]}`,
-    y1: `${start[1]}`,
-    x2: `${end[0]}`,
-    y2: `${end[1]}`,
-    stroke: color,
-    style: dropShadowStyle,
-    'stroke-width': strokeWidth,
-    'stroke-dasharray': lineDash,
-  };
-
-  if (existingLine) {
-    // This is run to avoid re-rendering annotations that actually haven't changed
-    setAttributesIfNecessary(attributes, existingLine);
-
-    svgDrawingHelper.setNodeTouched(svgNodeHash);
-  } else {
-    const newLine = document.createElementNS(svgns, 'line');
-
-    if (dataId !== '') {
-      newLine.setAttribute('data-id', dataId);
-    }
-
-    setNewAttributesIfValid(attributes, newLine);
-
-    svgDrawingHelper.appendNode(newLine, svgNodeHash);
-  }
-}

package/src/drawingSvg/drawLink.ts

@@ -1,76 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-import drawLine from './drawLine';
-import findClosestPoint from '../utilities/math/vec2/findClosestPoint';
-import { PlanarBoundingBox, SVGDrawingHelper } from '../types';
-
-/**
- * Draw a link between an annotation to a box.
- */
-function drawLink(
-  svgDrawingHelper: SVGDrawingHelper,
-  annotationUID: string,
-  linkUID: string,
-  // Find closest point to approx. bounding box
-  annotationAnchorPoints: Array<Types.Point2>,
-  refPoint: Types.Point2,
-  // Find bounding box point that's closest to our identified
-  // start point
-  boundingBox: PlanarBoundingBox,
-  options = {}
-): void {
-  // The closest anchor point (for the annotation) to the
-  // text box / bounding box
-  const start =
-    annotationAnchorPoints.length > 0
-      ? findClosestPoint(annotationAnchorPoints, refPoint)
-      : refPoint;
-
-  // Calculate the midpoints of the bounding box
-  const boundingBoxPoints = _boundingBoxPoints(boundingBox);
-  // Find the closest textBox midpoint to the annotation's anchor/start point
-  const end = findClosestPoint(boundingBoxPoints, start);
-
-  // Finally we draw the dashed linking line
-  const mergedOptions = Object.assign(
-    {
-      color: 'rgb(255, 255, 0)',
-      lineWidth: '1',
-      lineDash: '2,3',
-    },
-    options
-  );
-
-  drawLine(
-    svgDrawingHelper,
-    annotationUID,
-    `link-${linkUID}`,
-    start,
-    end,
-    mergedOptions
-  );
-}
-
-/**
- * Find potential anchor points for a given bounding box. For example, it may
- * look nicer to draw a line from the "middle left" of a bounding box to an
- * annotation (instead of from a corner). This function calculates those points
- *
- * @param boundingBox
- */
-function _boundingBoxPoints(
-  boundingBox: PlanarBoundingBox
-): Array<Types.Point2> {
-  const { x: left, y: top, height, width } = boundingBox;
-  const halfWidth = width / 2;
-  const halfHeight = height / 2;
-
-  const topMiddle = [left + halfWidth, top] as Types.Point2;
-  const leftMiddle = [left, top + halfHeight] as Types.Point2;
-  const bottomMiddle = [left + halfWidth, top + height] as Types.Point2;
-  const rightMiddle = [left + width, top + halfHeight] as Types.Point2;
-
-  return [topMiddle, leftMiddle, bottomMiddle, rightMiddle];
-}
-
-export default drawLink;