@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/drawingSvg/drawArrow.js

@@ -0,0 +1,79 @@
+import drawLine from './drawLine';
+const svgns = 'http://www.w3.org/2000/svg';
+export default function drawArrow(svgDrawingHelper, annotationUID, arrowUID, start, end, options = {}) {
+    if (isNaN(start[0]) || isNaN(start[1]) || isNaN(end[0]) || isNaN(end[1])) {
+        return;
+    }
+    const { viaMarker = false, color = 'rgb(0, 255, 0)', markerSize = 10, } = options;
+    if (!viaMarker) {
+        legacyDrawArrow(svgDrawingHelper, annotationUID, arrowUID, start, end, options);
+        return;
+    }
+    const layerId = svgDrawingHelper.svgLayerElement.id;
+    const markerBaseId = `arrow-${annotationUID}`;
+    const markerFullId = `${markerBaseId}-${layerId}`;
+    const defs = svgDrawingHelper.svgLayerElement.querySelector('defs');
+    let arrowMarker = defs.querySelector(`#${markerFullId}`);
+    if (!arrowMarker) {
+        arrowMarker = document.createElementNS(svgns, 'marker');
+        arrowMarker.setAttribute('id', markerFullId);
+        arrowMarker.setAttribute('viewBox', '0 0 10 10');
+        arrowMarker.setAttribute('refX', '8');
+        arrowMarker.setAttribute('refY', '5');
+        arrowMarker.setAttribute('markerWidth', `${markerSize}`);
+        arrowMarker.setAttribute('markerHeight', `${markerSize}`);
+        arrowMarker.setAttribute('orient', 'auto');
+        const arrowPath = document.createElementNS(svgns, 'path');
+        arrowPath.setAttribute('d', 'M 0 0 L 10 5 L 0 10 z');
+        arrowPath.setAttribute('fill', color);
+        arrowMarker.appendChild(arrowPath);
+        defs.appendChild(arrowMarker);
+    }
+    else {
+        arrowMarker.setAttribute('markerWidth', `${markerSize}`);
+        arrowMarker.setAttribute('markerHeight', `${markerSize}`);
+        const arrowPath = arrowMarker.querySelector('path');
+        if (arrowPath) {
+            arrowPath.setAttribute('fill', color);
+        }
+    }
+    options.markerEndId = markerFullId;
+    drawLine(svgDrawingHelper, annotationUID, arrowUID, start, end, options);
+}
+function legacyDrawArrow(svgDrawingHelper, annotationUID, arrowUID, start, end, options = {}) {
+    const { color = 'rgb(0, 255, 0)', width = 2, lineWidth, lineDash } = options;
+    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),
+        ],
+        end: end,
+    };
+    const secondLine = {
+        start: [
+            end[0] - headLength * Math.cos(angle + Math.PI / 7),
+            end[1] - headLength * Math.sin(angle + Math.PI / 7),
+        ],
+        end: end,
+    };
+    drawLine(svgDrawingHelper, annotationUID, arrowUID, start, end, {
+        color,
+        width,
+        lineWidth,
+        lineDash,
+    });
+    drawLine(svgDrawingHelper, annotationUID, '2', firstLine.start, firstLine.end, {
+        color,
+        width,
+        lineWidth,
+        lineDash,
+    });
+    drawLine(svgDrawingHelper, annotationUID, '3', secondLine.start, secondLine.end, {
+        color,
+        width,
+        lineWidth,
+        lineDash,
+    });
+}

package/dist/esm/drawingSvg/drawCircle.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+declare function drawCircle(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, circleUID: string, center: Types.Point2, radius: number, options?: {}, dataId?: string): void;
+export default drawCircle;

package/dist/esm/drawingSvg/drawCircle.js

@@ -0,0 +1,42 @@
+import _getHash from './_getHash';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+function drawCircle(svgDrawingHelper, annotationUID, circleUID, center, radius, options = {}, dataId = '') {
+    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);
+    const strokeWidth = lineWidth || width;
+    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,
+        'stroke-opacity': strokeOpacity,
+    };
+    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/dist/esm/drawingSvg/drawEllipse.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+declare function drawEllipse(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, ellipseUID: string, corner1: Types.Point2, corner2: Types.Point2, options?: {}, dataId?: string): void;
+export default drawEllipse;

package/dist/esm/drawingSvg/drawEllipse.js

@@ -0,0 +1,10 @@
+import _getHash from './_getHash';
+import drawEllipseByCoordinates from './drawEllipseByCoordinates';
+function drawEllipse(svgDrawingHelper, annotationUID, ellipseUID, corner1, corner2, options = {}, dataId = '') {
+    const top = [(corner1[0] + corner2[0]) / 2, corner1[1]];
+    const bottom = [(corner1[0] + corner2[0]) / 2, corner2[1]];
+    const left = [corner1[0], (corner1[1] + corner2[1]) / 2];
+    const right = [corner2[0], (corner1[1] + corner2[1]) / 2];
+    drawEllipseByCoordinates(svgDrawingHelper, annotationUID, ellipseUID, [bottom, top, left, right], (options = {}), (dataId = ''));
+}
+export default drawEllipse;

package/dist/esm/drawingSvg/drawEllipseByCoordinates.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+declare function drawEllipseByCoordinates(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, ellipseUID: string, canvasCoordinates: [Types.Point2, Types.Point2, Types.Point2, Types.Point2], options?: {}, dataId?: string): void;
+export default drawEllipseByCoordinates;

package/dist/esm/drawingSvg/drawEllipseByCoordinates.js

@@ -0,0 +1,46 @@
+import _getHash from './_getHash';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+function drawEllipseByCoordinates(svgDrawingHelper, annotationUID, ellipseUID, canvasCoordinates, options = {}, dataId = '') {
+    const { color, width, lineWidth, lineDash } = Object.assign({
+        color: 'rgb(0, 255, 0)',
+        width: '2',
+        lineWidth: undefined,
+        lineDash: undefined,
+    }, 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/dist/esm/drawingSvg/drawHandle.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+declare function drawHandle(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, handleGroupUID: string, handle: Types.Point2, options: {}, uniqueIndex: any): void;
+export default drawHandle;

package/dist/esm/drawingSvg/drawHandle.js

@@ -0,0 +1,60 @@
+import _getHash from './_getHash';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+function drawHandle(svgDrawingHelper, annotationUID, handleGroupUID, handle, options = {}, uniqueIndex) {
+    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);
+    const strokeWidth = lineWidth || width;
+    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/dist/esm/drawingSvg/drawHandles.d.ts

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

package/dist/esm/drawingSvg/drawHandles.js

@@ -0,0 +1,7 @@
+import drawHandle from './drawHandle';
+function drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, handlePoints, options = {}) {
+    handlePoints.forEach((handle, i) => {
+        drawHandle(svgDrawingHelper, annotationUID, handleGroupUID, handle, options, i);
+    });
+}
+export default drawHandles;

package/dist/esm/drawingSvg/drawHeight.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawHeight(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, heightUID: string, start: Types.Point2, end: Types.Point2, options?: {}): void;

package/dist/esm/drawingSvg/drawHeight.js

@@ -0,0 +1,45 @@
+import drawLine from './drawLine';
+export default function drawHeight(svgDrawingHelper, annotationUID, heightUID, start, end, options = {}) {
+    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);
+    const midX = end[0] + (start[0] - end[0]) / 2;
+    const endfirstLine = [midX, start[1]];
+    const endsecondLine = [midX, end[1]];
+    const firstLine = {
+        start: start,
+        end: endfirstLine,
+    };
+    const secondLine = {
+        start: endfirstLine,
+        end: endsecondLine,
+    };
+    const threeLine = {
+        start: endsecondLine,
+        end: end,
+    };
+    drawLine(svgDrawingHelper, annotationUID, '1', firstLine.start, firstLine.end, {
+        color,
+        width,
+        lineWidth,
+        lineDash,
+    });
+    drawLine(svgDrawingHelper, annotationUID, '2', secondLine.start, secondLine.end, {
+        color,
+        width,
+        lineWidth,
+        lineDash,
+    });
+    drawLine(svgDrawingHelper, annotationUID, '3', threeLine.start, threeLine.end, {
+        color,
+        width,
+        lineWidth,
+        lineDash,
+    });
+}

package/dist/esm/drawingSvg/drawLine.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawLine(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, lineUID: string, start: Types.Point2, end: Types.Point2, options?: {}, dataId?: string): void;

package/dist/esm/drawingSvg/drawLine.js

@@ -0,0 +1,39 @@
+import _getHash from './_getHash';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+export default function drawLine(svgDrawingHelper, annotationUID, lineUID, start, end, options = {}, dataId = '') {
+    if (isNaN(start[0]) || isNaN(start[1]) || isNaN(end[0]) || isNaN(end[1])) {
+        return;
+    }
+    const { color = 'rgb(0, 255, 0)', width = 10, lineWidth, lineDash, markerStartId = null, markerEndId = null, shadow = false, } = 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 layerId = svgDrawingHelper.svgLayerElement.id;
+    const dropShadowStyle = shadow ? `filter:url(#shadow-${layerId});` : '';
+    const attributes = {
+        x1: `${start[0]}`,
+        y1: `${start[1]}`,
+        x2: `${end[0]}`,
+        y2: `${end[1]}`,
+        stroke: color,
+        style: dropShadowStyle,
+        'stroke-width': strokeWidth,
+        'stroke-dasharray': lineDash,
+        'marker-start': markerStartId ? `url(#${markerStartId})` : '',
+        'marker-end': markerEndId ? `url(#${markerEndId})` : '',
+    };
+    if (existingLine) {
+        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/dist/esm/drawingSvg/drawLink.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PlanarBoundingBox, SVGDrawingHelper } from '../types';
+declare function drawLink(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, linkUID: string, annotationAnchorPoints: Array<Types.Point2>, refPoint: Types.Point2, boundingBox: PlanarBoundingBox, options?: {}): void;
+export default drawLink;

package/dist/esm/drawingSvg/drawLink.js

@@ -0,0 +1,26 @@
+import drawLine from './drawLine';
+import findClosestPoint from '../utilities/math/vec2/findClosestPoint';
+function drawLink(svgDrawingHelper, annotationUID, linkUID, annotationAnchorPoints, refPoint, boundingBox, options = {}) {
+    const start = annotationAnchorPoints.length > 0
+        ? findClosestPoint(annotationAnchorPoints, refPoint)
+        : refPoint;
+    const boundingBoxPoints = _boundingBoxPoints(boundingBox);
+    const end = findClosestPoint(boundingBoxPoints, start);
+    const mergedOptions = Object.assign({
+        color: 'rgb(255, 255, 0)',
+        lineWidth: '1',
+        lineDash: '2,3',
+    }, options);
+    drawLine(svgDrawingHelper, annotationUID, `link-${linkUID}`, start, end, mergedOptions);
+}
+function _boundingBoxPoints(boundingBox) {
+    const { x: left, y: top, height, width } = boundingBox;
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const topMiddle = [left + halfWidth, top];
+    const leftMiddle = [left, top + halfHeight];
+    const bottomMiddle = [left + halfWidth, top + height];
+    const rightMiddle = [left + width, top + halfHeight];
+    return [topMiddle, leftMiddle, bottomMiddle, rightMiddle];
+}
+export default drawLink;

package/dist/esm/drawingSvg/drawLinkedTextBox.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+declare function drawLinkedTextBox(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, textBoxUID: string, textLines: Array<string>, textBoxPosition: Types.Point2, annotationAnchorPoints: Array<Types.Point2>, textBox: unknown, options?: {}): SVGRect;
+export default drawLinkedTextBox;

package/dist/esm/drawingSvg/drawLinkedTextBox.js

@@ -0,0 +1,15 @@
+import drawTextBox from './drawTextBox';
+import drawLink from './drawLink';
+function drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, annotationAnchorPoints, textBox, options = {}) {
+    const mergedOptions = Object.assign({
+        handleRadius: '6',
+        centering: {
+            x: false,
+            y: true,
+        },
+    }, options);
+    const canvasBoundingBox = drawTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, mergedOptions);
+    drawLink(svgDrawingHelper, annotationUID, textBoxUID, annotationAnchorPoints, textBoxPosition, canvasBoundingBox, mergedOptions);
+    return canvasBoundingBox;
+}
+export default drawLinkedTextBox;

package/dist/esm/drawingSvg/drawPath.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawPath(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, pathUID: string, points: Types.Point2[] | Types.Point2[][], options: {
+    color?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    width?: number;
+    lineWidth?: number;
+    lineDash?: string;
+    closePath?: boolean;
+}): void;

package/dist/esm/drawingSvg/drawPath.js

@@ -0,0 +1,48 @@
+import _getHash from './_getHash';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+export default function drawPath(svgDrawingHelper, annotationUID, pathUID, points, options) {
+    const hasSubArrays = points.length && points[0].length && Array.isArray(points[0][0]);
+    const pointsArrays = hasSubArrays ? points : [points];
+    const { color = 'rgb(0, 255, 0)', width = 10, fillColor = 'none', fillOpacity = 0, lineWidth, lineDash, closePath = false, } = options;
+    const strokeWidth = lineWidth || width;
+    const svgns = 'http://www.w3.org/2000/svg';
+    const svgNodeHash = _getHash(annotationUID, 'path', pathUID);
+    const existingNode = svgDrawingHelper.getSvgNode(svgNodeHash);
+    let pointsAttribute = '';
+    for (let i = 0, numArrays = pointsArrays.length; i < numArrays; i++) {
+        const points = pointsArrays[i];
+        const numPoints = points.length;
+        if (numPoints < 2) {
+            continue;
+        }
+        for (let j = 0; j < numPoints; j++) {
+            const point = points[j];
+            const cmd = j ? 'L' : 'M';
+            pointsAttribute += `${cmd} ${point[0].toFixed(1)}, ${point[1].toFixed(1)} `;
+        }
+        if (closePath) {
+            pointsAttribute += 'Z ';
+        }
+    }
+    if (!pointsAttribute) {
+        return;
+    }
+    const attributes = {
+        d: pointsAttribute,
+        stroke: color,
+        fill: fillColor,
+        'fill-opacity': fillOpacity,
+        'stroke-width': strokeWidth,
+        'stroke-dasharray': lineDash,
+    };
+    if (existingNode) {
+        setAttributesIfNecessary(attributes, existingNode);
+        svgDrawingHelper.setNodeTouched(svgNodeHash);
+    }
+    else {
+        const newNode = document.createElementNS(svgns, 'path');
+        setNewAttributesIfValid(attributes, newNode);
+        svgDrawingHelper.appendNode(newNode, svgNodeHash);
+    }
+}

package/dist/esm/drawingSvg/drawPolyline.d.ts

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawPolyline(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, polylineUID: string, points: Types.Point2[], options: {
+    color?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    width?: number;
+    lineWidth?: number;
+    lineDash?: string;
+    closePath?: boolean;
+    markerStartId?: string;
+    markerEndId?: string;
+}): void;

package/dist/esm/drawingSvg/drawPolyline.js

@@ -0,0 +1,40 @@
+import _getHash from './_getHash';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+export default function drawPolyline(svgDrawingHelper, annotationUID, polylineUID, points, options) {
+    if (points.length < 2) {
+        return;
+    }
+    const { color = 'rgb(0, 255, 0)', width = 10, fillColor = 'none', fillOpacity = 0, lineWidth, lineDash, closePath = false, markerStartId = null, markerEndId = null, } = options;
+    const strokeWidth = lineWidth || width;
+    const svgns = 'http://www.w3.org/2000/svg';
+    const svgNodeHash = _getHash(annotationUID, 'polyline', polylineUID);
+    const existingPolyLine = svgDrawingHelper.getSvgNode(svgNodeHash);
+    let pointsAttribute = '';
+    for (const point of points) {
+        pointsAttribute += `${point[0].toFixed(1)}, ${point[1].toFixed(1)} `;
+    }
+    if (closePath) {
+        const firstPoint = points[0];
+        pointsAttribute += `${firstPoint[0]}, ${firstPoint[1]}`;
+    }
+    const attributes = {
+        points: pointsAttribute,
+        stroke: color,
+        fill: fillColor,
+        'fill-opacity': fillOpacity,
+        'stroke-width': strokeWidth,
+        'stroke-dasharray': lineDash,
+        'marker-start': markerStartId ? `url(#${markerStartId})` : '',
+        'marker-end': markerEndId ? `url(#${markerEndId})` : '',
+    };
+    if (existingPolyLine) {
+        setAttributesIfNecessary(attributes, existingPolyLine);
+        svgDrawingHelper.setNodeTouched(svgNodeHash);
+    }
+    else {
+        const newPolyLine = document.createElementNS(svgns, 'polyline');
+        setNewAttributesIfValid(attributes, newPolyLine);
+        svgDrawingHelper.appendNode(newPolyLine, svgNodeHash);
+    }
+}

package/dist/esm/drawingSvg/drawRect.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawRect(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, rectangleUID: string, start: Types.Point2, end: Types.Point2, options?: {}, dataId?: string): void;

package/dist/esm/drawingSvg/drawRect.js

@@ -0,0 +1,9 @@
+import _getHash from './_getHash';
+import drawRectByCoordinates from './drawRectByCoordinates';
+export default function drawRect(svgDrawingHelper, annotationUID, rectangleUID, start, end, options = {}, dataId = '') {
+    const topLeft = [start[0], start[1]];
+    const topRight = [end[0], start[1]];
+    const bottomLeft = [start[0], end[1]];
+    const bottomRight = [end[0], end[1]];
+    drawRectByCoordinates(svgDrawingHelper, annotationUID, rectangleUID, [topLeft, topRight, bottomLeft, bottomRight], options, dataId);
+}

package/dist/esm/drawingSvg/drawRectByCoordinates.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawRectByCoordinates(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, rectangleUID: string, canvasCoordinates: Types.Point2[], options?: {}, dataId?: string): void;

package/dist/esm/drawingSvg/drawRectByCoordinates.js

@@ -0,0 +1,52 @@
+import _getHash from './_getHash';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+export default function drawRectByCoordinates(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates, options = {}, dataId = '') {
+    const { color, width: _width, lineWidth, lineDash, } = Object.assign({
+        color: 'rgb(0, 255, 0)',
+        width: '2',
+        lineWidth: undefined,
+        lineDash: undefined,
+    }, options);
+    const strokeWidth = lineWidth || _width;
+    const svgns = 'http://www.w3.org/2000/svg';
+    const svgNodeHash = _getHash(annotationUID, 'rect', rectangleUID);
+    const existingRect = svgDrawingHelper.getSvgNode(svgNodeHash);
+    const [topLeft, topRight, bottomLeft, bottomRight] = canvasCoordinates;
+    const width = Math.hypot(topLeft[0] - topRight[0], topLeft[1] - topRight[1]);
+    const height = Math.hypot(topLeft[0] - bottomLeft[0], topLeft[1] - bottomLeft[1]);
+    const center = [
+        (bottomRight[0] + topLeft[0]) / 2,
+        (bottomRight[1] + topLeft[1]) / 2,
+    ];
+    const leftEdgeCenter = [
+        (bottomLeft[0] + topLeft[0]) / 2,
+        (bottomLeft[1] + topLeft[1]) / 2,
+    ];
+    const angle = (Math.atan2(center[1] - leftEdgeCenter[1], center[0] - leftEdgeCenter[0]) *
+        180) /
+        Math.PI;
+    const attributes = {
+        x: `${center[0] - width / 2}`,
+        y: `${center[1] - height / 2}`,
+        width: `${width}`,
+        height: `${height}`,
+        stroke: color,
+        fill: 'transparent',
+        transform: `rotate(${angle} ${center[0]} ${center[1]})`,
+        'stroke-width': strokeWidth,
+        'stroke-dasharray': lineDash,
+    };
+    if (existingRect) {
+        setAttributesIfNecessary(attributes, existingRect);
+        svgDrawingHelper.setNodeTouched(svgNodeHash);
+    }
+    else {
+        const svgRectElement = document.createElementNS(svgns, 'rect');
+        if (dataId !== '') {
+            svgRectElement.setAttribute('data-id', dataId);
+        }
+        setNewAttributesIfValid(attributes, svgRectElement);
+        svgDrawingHelper.appendNode(svgRectElement, svgNodeHash);
+    }
+}

package/dist/esm/drawingSvg/drawRedactionRect.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SVGDrawingHelper } from '../types';
+export default function drawRedactionRect(svgDrawingHelper: SVGDrawingHelper, annotationUID: string, rectangleUID: string, start: Types.Point2, end: Types.Point2, options?: {}): void;