@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/constants/COLOR_LUT.d.ts

@@ -1,2 +1,3 @@
-declare const CORNERSTONE_COLOR_LUT: number[][];
+import type { Types } from '@cornerstonejs/core';
+declare const CORNERSTONE_COLOR_LUT: Types.Color[];
 export default CORNERSTONE_COLOR_LUT;

package/dist/esm/constants/COLOR_LUT.js

@@ -256,4 +256,3 @@ const CORNERSTONE_COLOR_LUT = [
     [81, 111, 224, 255],
 ];
 export default CORNERSTONE_COLOR_LUT;
-//# sourceMappingURL=COLOR_LUT.js.map

package/dist/esm/constants/index.js

@@ -1,3 +1,2 @@
 import COLOR_LUT from './COLOR_LUT';
 export { COLOR_LUT };
-//# sourceMappingURL=index.js.map

package/dist/esm/cursors/ImageMouseCursor.js

@@ -20,4 +20,3 @@ export default class ImageMouseCursor extends MouseCursor {
         return `${prefix}-${utilities.getRuntimeId(ImageMouseCursor)}`;
     }
 }
-//# sourceMappingURL=ImageMouseCursor.js.map

package/dist/esm/cursors/MouseCursor.js

@@ -86,4 +86,3 @@ function getDefinedCursors(context, symbol) {
 }
 const standardCursorNames = STANDARD_CURSORS.values();
 export { standardCursorNames };
-//# sourceMappingURL=MouseCursor.js.map

package/dist/esm/cursors/SVGCursorDescriptor.d.ts

@@ -1,4 +1,4 @@
-import { SVGCursorDescriptor } from '../types';
+import type { SVGCursorDescriptor } from '../types';
 declare const CursorSVG: Record<string, SVGCursorDescriptor>;
 declare function registerCursor(toolName: string, iconContent: string, viewBox: {
     x: number;

package/dist/esm/cursors/SVGCursorDescriptor.js

@@ -178,6 +178,13 @@ const CursorSVG = {
             y: 24,
         },
     }),
+    Height: extend(BASE, {
+        iconContent: `<path d="m 6 22 l 8.5 0 v -16 h 8" stroke-width="3" fill="none" stroke="{{color}}" />`,
+        viewBox: {
+            x: 24,
+            y: 24,
+        },
+    }),
     Probe: extend(BASE, {
         iconContent: `<path fill="{{color}}" d="M1152 896q0 106-75 181t-181 75-181-75-75-181 75-181 181-75 181 75
     75 181zm-256-544q-148 0-273 73t-198 198-73 273 73 273 198 198 273 73 273-73
@@ -394,4 +401,3 @@ function getDefinedSVGCursorDescriptor(name) {
 }
 const svgCursorNames = Object.keys(CursorSVG);
 export { getDefinedSVGCursorDescriptor, registerCursor, svgCursorNames, CursorSVG, };
-//# sourceMappingURL=SVGCursorDescriptor.js.map

package/dist/esm/cursors/SVGMouseCursor.d.ts

@@ -1,4 +1,4 @@
-import MouseCursor from './MouseCursor';
+import type MouseCursor from './MouseCursor';
 import ImageMouseCursor from './ImageMouseCursor';
 export default class SVGMouseCursor extends ImageMouseCursor {
     constructor(url: string, x?: number, y?: number, name?: string | undefined, fallback?: MouseCursor | undefined);

package/dist/esm/cursors/SVGMouseCursor.js

@@ -69,4 +69,3 @@ function createSVGIconWithPointer(descriptor, options) {
     </svg>`;
     return format(svgString, options);
 }
-//# sourceMappingURL=SVGMouseCursor.js.map

package/dist/esm/cursors/elementCursor.d.ts

@@ -1,4 +1,4 @@
-import { MouseCursor } from '.';
+import MouseCursor from './MouseCursor';
 declare function initElementCursor(element: HTMLDivElement, cursor: MouseCursor | null): void;
 declare function _setElementCursor(element: HTMLDivElement, cursor: MouseCursor | null): void;
 declare function resetElementCursor(element: HTMLDivElement): void;

package/dist/esm/cursors/elementCursor.js

@@ -1,4 +1,4 @@
-import { MouseCursor } from '.';
+import MouseCursor from './MouseCursor';
 const ELEMENT_CURSORS_MAP = Symbol('ElementCursorsMap');
 function initElementCursor(element, cursor) {
     _getElementCursors(element)[0] = cursor;
@@ -34,4 +34,3 @@ function _getElementCursors(element) {
     return cursors;
 }
 export { initElementCursor, resetElementCursor, hideElementCursor, _setElementCursor as setElementCursor, };
-//# sourceMappingURL=elementCursor.js.map

package/dist/esm/cursors/index.js

@@ -6,4 +6,3 @@ import setCursorForElement from './setCursorForElement';
 import { registerCursor, svgCursorNames, CursorSVG, } from './SVGCursorDescriptor';
 const CursorNames = [...svgCursorNames, ...standardCursorNames];
 export { MouseCursor, ImageMouseCursor, SVGMouseCursor, elementCursor, registerCursor, CursorNames, CursorSVG, setCursorForElement, };
-//# sourceMappingURL=index.js.map

package/dist/esm/cursors/setCursorForElement.js

@@ -13,4 +13,3 @@ function setCursorForElement(element, cursorName) {
     setElementCursor(element, cursor);
 }
 export default setCursorForElement;
-//# sourceMappingURL=setCursorForElement.js.map

package/dist/esm/drawingSvg/_getHash.js

@@ -2,4 +2,3 @@ function _getHash(annotationUID, drawingElementType, nodeUID) {
     return `${annotationUID}::${drawingElementType}::${nodeUID}`;
 }
 export default _getHash;
-//# sourceMappingURL=_getHash.js.map

package/dist/esm/drawingSvg/clearByToolType.js

@@ -11,4 +11,3 @@ function clearByToolType(element, toolType) {
     }
 }
 export default clearByToolType;
-//# sourceMappingURL=clearByToolType.js.map

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

@@ -1,2 +1,3 @@
-declare function draw(element: HTMLDivElement, fn: (svgDrawingElement: any) => any): void;
+import type { SVGDrawingHelper } from '../types';
+declare function draw(element: HTMLDivElement, fn: (svgDrawingElement: SVGDrawingHelper) => void): void;
 export default draw;

package/dist/esm/drawingSvg/draw.js

@@ -5,4 +5,3 @@ function draw(element, fn) {
     svgDrawingHelper.clearUntouched();
 }
 export default draw;
-//# sourceMappingURL=draw.js.map

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

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

package/dist/esm/drawingSvg/drawArrow.js

@@ -4,7 +4,7 @@ export default function drawArrow(svgDrawingHelper, annotationUID, arrowUID, sta
         return;
     }
     const { color, width, lineWidth, lineDash } = Object.assign({
-        color: 'dodgerblue',
+        color: 'rgb(0, 255, 0)',
         width: '2',
         lineWidth: undefined,
         lineDash: undefined,
@@ -42,4 +42,3 @@ export default function drawArrow(svgDrawingHelper, annotationUID, arrowUID, sta
         lineWidth,
     });
 }
-//# sourceMappingURL=drawArrow.js.map

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

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
+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

@@ -3,7 +3,7 @@ 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: 'dodgerblue',
+        color: 'rgb(0, 255, 0)',
         fill: 'transparent',
         width: '2',
         lineDash: undefined,
@@ -40,4 +40,3 @@ function drawCircle(svgDrawingHelper, annotationUID, circleUID, center, radius,
     }
 }
 export default drawCircle;
-//# sourceMappingURL=drawCircle.js.map

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

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
+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

@@ -1,46 +1,10 @@
 import _getHash from './_getHash';
-import setAttributesIfNecessary from './setAttributesIfNecessary';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
+import drawEllipseByCoordinates from './drawEllipseByCoordinates';
 function drawEllipse(svgDrawingHelper, annotationUID, ellipseUID, corner1, corner2, options = {}, dataId = '') {
-    const { color, width, lineWidth, lineDash } = Object.assign({
-        color: 'dodgerblue',
-        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 w = Math.abs(corner1[0] - corner2[0]);
-    const h = Math.abs(corner1[1] - corner2[1]);
-    const xMin = Math.min(corner1[0], corner2[0]);
-    const yMin = Math.min(corner1[1], corner2[1]);
-    const center = [xMin + w / 2, yMin + h / 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',
-        '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);
-    }
+    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;
-//# sourceMappingURL=drawEllipse.js.map

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

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
+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

@@ -1,64 +1,7 @@
-import _getHash from './_getHash';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
-import setAttributesIfNecessary from './setAttributesIfNecessary';
+import drawHandle from './drawHandle';
 function drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, handlePoints, options = {}) {
-    const { color, handleRadius, width, lineWidth, fill, type, opacity } = Object.assign({
-        color: 'dodgerblue',
-        handleRadius: '6',
-        width: '2',
-        lineWidth: undefined,
-        fill: 'transparent',
-        type: 'circle',
-        opacity: 1,
-    }, options);
-    const strokeWidth = lineWidth || width;
-    for (let i = 0; i < handlePoints.length; i++) {
-        const handle = handlePoints[i];
-        const svgns = 'http://www.w3.org/2000/svg';
-        const svgNodeHash = _getHash(annotationUID, 'handle', `hg-${handleGroupUID}-index-${i}`);
-        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);
-        }
-    }
+    handlePoints.forEach((handle, i) => {
+        drawHandle(svgDrawingHelper, annotationUID, handleGroupUID, handle, options, i);
+    });
 }
 export default drawHandles;
-//# sourceMappingURL=drawHandles.js.map

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,42 @@
+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,
+    });
+    drawLine(svgDrawingHelper, annotationUID, '2', secondLine.start, secondLine.end, {
+        color,
+        width,
+        lineWidth,
+    });
+    drawLine(svgDrawingHelper, annotationUID, '3', threeLine.start, threeLine.end, {
+        color,
+        width,
+        lineWidth,
+    });
+}

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

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
+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

@@ -6,7 +6,7 @@ export default function drawLine(svgDrawingHelper, annotationUID, lineUID, start
         return;
     }
     const { color, width, lineWidth, lineDash, shadow } = Object.assign({
-        color: 'dodgerblue',
+        color: 'rgb(0, 255, 0)',
         width: '2',
         lineWidth: undefined,
         lineDash: undefined,
@@ -42,4 +42,3 @@ export default function drawLine(svgDrawingHelper, annotationUID, lineUID, start
         svgDrawingHelper.appendNode(newLine, svgNodeHash);
     }
 }
-//# sourceMappingURL=drawLine.js.map

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

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { PlanarBoundingBox, SVGDrawingHelper } from '../types';
+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

@@ -24,4 +24,3 @@ function _boundingBoxPoints(boundingBox) {
     return [topMiddle, leftMiddle, bottomMiddle, rightMiddle];
 }
 export default drawLink;
-//# sourceMappingURL=drawLink.js.map

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

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
+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

@@ -13,4 +13,3 @@ function drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLine
     return canvasBoundingBox;
 }
 export default drawLinkedTextBox;
-//# sourceMappingURL=drawLinkedTextBox.js.map

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

@@ -1,9 +1,11 @@
 import type { Types } from '@cornerstonejs/core';
-import { SVGDrawingHelper } from '../types';
+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;
-    connectLastToFirst?: boolean;
+    closePath?: boolean;
 }): void;

package/dist/esm/drawingSvg/drawPolyline.js

@@ -5,29 +5,24 @@ export default function drawPolyline(svgDrawingHelper, annotationUID, polylineUI
     if (points.length < 2) {
         return;
     }
-    const { color, width, lineWidth, lineDash } = Object.assign({
-        color: 'dodgerblue',
-        width: '2',
-        lineWidth: undefined,
-        lineDash: undefined,
-        connectLastToFirst: false,
-    }, options);
+    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, 'polyline', polylineUID);
     const existingPolyLine = svgDrawingHelper.getSvgNode(svgNodeHash);
     let pointsAttribute = '';
     for (const point of points) {
-        pointsAttribute += `${point[0]}, ${point[1]} `;
+        pointsAttribute += `${point[0].toFixed(1)}, ${point[1].toFixed(1)} `;
     }
-    if (options.connectLastToFirst) {
+    if (closePath) {
         const firstPoint = points[0];
         pointsAttribute += `${firstPoint[0]}, ${firstPoint[1]}`;
     }
     const attributes = {
         points: pointsAttribute,
         stroke: color,
-        fill: 'none',
+        fill: fillColor,
+        'fill-opacity': fillOpacity,
         'stroke-width': strokeWidth,
         'stroke-dasharray': lineDash,
     };
@@ -41,4 +36,3 @@ export default function drawPolyline(svgDrawingHelper, annotationUID, polylineUI
         svgDrawingHelper.appendNode(newPolyLine, svgNodeHash);
     }
 }
-//# sourceMappingURL=drawPolyline.js.map