@ohif/app 3.8.0-beta.34 → 3.8.0-beta.36

package/dist/{566.bundle.4840518afd323372c70f.js → 514.bundle.e89082f91e5a7ef3e039.js}

@@ -1,6 +1,6 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[566],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[514],{
 
-/***/ 74566:
+/***/ 4514:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -27,6 +27,7 @@ __webpack_require__.d(__webpack_exports__, {
   Enums: () => (/* reexport */ enums_namespaceObject),
   KeyImageTool: () => (/* reexport */ annotation_KeyImageTool),
   LengthTool: () => (/* reexport */ annotation_LengthTool),
+  LivewireContourTool: () => (/* reexport */ annotation_LivewireContourTool),
   MIPJumpToClickTool: () => (/* reexport */ tools_MIPJumpToClickTool),
   MagnifyTool: () => (/* reexport */ tools_MagnifyTool),
   OrientationMarkerTool: () => (/* reexport */ tools_OrientationMarkerTool),
@@ -648,8 +649,8 @@ __webpack_require__.d(synchronizers_namespaceObject, {
 var types_namespaceObject = {};
 __webpack_require__.r(types_namespaceObject);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 364 modules
-var esm = __webpack_require__(27968);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 368 modules
+var esm = __webpack_require__(62881);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/ToolBindings.js
 var MouseBindings;
 (function (MouseBindings) {
@@ -2862,7 +2863,7 @@ function isStackSegmentation(operationData) {
         undefined);
 }
 function isVolumeSegmentation(operationData) {
-    return (operationData.volumeId !== undefined);
+    return (operationData?.volumeId !== undefined);
 }
 
 
@@ -4137,7 +4138,6 @@ const CORNERSTONE_COLOR_LUT = [
 
 
 
-
 async function addSegmentationRepresentation_addSegmentationRepresentation(toolGroupId, representationInput, toolGroupSpecificConfig) {
     const { segmentationId, options = {} } = representationInput;
     const segmentationRepresentationUID = esm.utilities.uuidv4();
@@ -4158,7 +4158,7 @@ async function addSegmentationRepresentation_addSegmentationRepresentation(toolG
     const toolGroupSpecificRepresentation = {
         segmentationId,
         segmentationRepresentationUID,
-        type: enums_SegmentationRepresentations.Labelmap,
+        type: representationInput.type,
         segmentsHidden,
         colorLUTIndex: colorLUTIndexToUse,
         active: true,
@@ -14798,7 +14798,7 @@ class VolumeRotateMouseWheelTool extends base_BaseTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             direction: DIRECTIONS.Z,
-            rotateIncrementDegrees: 0.5,
+            rotateIncrementDegrees: 30,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -14813,7 +14813,7 @@ class VolumeRotateMouseWheelTool extends base_BaseTool {
         const { direction: deltaY } = wheel;
         const [cx, cy, cz] = focalPoint;
         const [ax, ay, az] = direction;
-        const angle = deltaY * rotateIncrementDegrees;
+        const angle = (deltaY * (rotateIncrementDegrees * Math.PI)) / 180;
         const newPosition = [0, 0, 0];
         const newFocalPoint = [0, 0, 0];
         const newViewUp = [0, 0, 0];
@@ -26357,6 +26357,861 @@ function PlanarFreehandROITool_defaultGetTextLines(data, targetId) {
 PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
 /* harmony default export */ const annotation_PlanarFreehandROITool = (PlanarFreehandROITool);
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/BucketQueue.js
+class BucketQueue {
+    constructor({ numBits, getPriority, areEqual, }) {
+        this._bucketCount = 1 << numBits;
+        this._mask = this._bucketCount - 1;
+        this._size = 0;
+        this._currentBucketIndex = 0;
+        this._buckets = this._buildArray(this._bucketCount);
+        this._getPriority =
+            typeof getPriority !== 'undefined'
+                ? getPriority
+                : (item) => item;
+        this._areEqual =
+            typeof areEqual === 'function'
+                ? areEqual
+                : (itemA, itemB) => itemA === itemB;
+    }
+    push(item) {
+        const bucketIndex = this._getBucketIndex(item);
+        const oldHead = this._buckets[bucketIndex];
+        const newHead = {
+            value: item,
+            next: oldHead,
+        };
+        this._buckets[bucketIndex] = newHead;
+        this._size++;
+    }
+    pop() {
+        if (this._size === 0) {
+            throw new Error('Cannot pop because the queue is empty.');
+        }
+        while (this._buckets[this._currentBucketIndex] === null) {
+            this._currentBucketIndex =
+                (this._currentBucketIndex + 1) % this._bucketCount;
+        }
+        const ret = this._buckets[this._currentBucketIndex];
+        this._buckets[this._currentBucketIndex] = ret.next;
+        this._size--;
+        return ret.value;
+    }
+    remove(item) {
+        if (!item) {
+            return false;
+        }
+        const bucketIndex = this._getBucketIndex(item);
+        const firstBucketNode = this._buckets[bucketIndex];
+        let node = firstBucketNode;
+        let prevNode;
+        while (node !== null) {
+            if (this._areEqual(item, node.value)) {
+                break;
+            }
+            prevNode = node;
+            node = node.next;
+        }
+        if (node === null) {
+            return false;
+        }
+        if (node === firstBucketNode) {
+            this._buckets[bucketIndex] = node.next;
+        }
+        else {
+            prevNode.next = node.next;
+        }
+        this._size--;
+        return true;
+    }
+    isEmpty() {
+        return this._size === 0;
+    }
+    _getBucketIndex(item) {
+        return this._getPriority(item) & this._mask;
+    }
+    _buildArray(size) {
+        const buckets = new Array(size);
+        buckets.fill(null);
+        return buckets;
+    }
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/livewire/LivewireScissors.js
+
+const MAX_UINT32 = 4294967295;
+const TWO_THIRD_PI = 2 / (3 * Math.PI);
+class LivewireScissors {
+    constructor(grayscalePixelData, width, height) {
+        this._getPointIndex = (row, col) => {
+            const { width } = this;
+            return row * width + col;
+        };
+        this._getPointCoordinate = (index) => {
+            const x = index % this.width;
+            const y = Math.floor(index / this.width);
+            return [x, y];
+        };
+        this._getPointCost = (pointIndex) => {
+            return Math.round(this.searchGranularity * this.costs[pointIndex]);
+        };
+        const numPixels = grayscalePixelData.length;
+        this.searchGranularityBits = 8;
+        this.searchGranularity = 1 << this.searchGranularityBits;
+        this.width = width;
+        this.height = height;
+        this.grayscalePixelData = grayscalePixelData;
+        this.laplace = null;
+        this.gradXNew = null;
+        this.gradYNew = null;
+        this.laplace = this._computeLaplace();
+        this.gradMagnitude = this._computeGradient();
+        this.gradXNew = this._computeGradientX();
+        this.gradYNew = this._computeGradientY();
+        this.visited = new Array(numPixels);
+        this.parents = new Uint32Array(numPixels);
+        this.costs = new Float32Array(numPixels);
+    }
+    startSearch(startPoint) {
+        const startPointIndex = this._getPointIndex(startPoint[1], startPoint[0]);
+        this.startPoint = null;
+        this.visited.fill(false);
+        this.parents.fill(MAX_UINT32);
+        this.costs.fill(Infinity);
+        this.priorityQueueNew = new BucketQueue({
+            numBits: this.searchGranularityBits,
+            getPriority: this._getPointCost,
+        });
+        this.startPoint = startPoint;
+        this.costs[startPointIndex] = 0;
+        this.priorityQueueNew.push(startPointIndex);
+    }
+    findPathToPoint(targetPoint) {
+        if (!this.startPoint) {
+            throw new Error('There is no search in progress');
+        }
+        const { startPoint, _getPointIndex: index, _getPointCoordinate: coord, } = this;
+        const startPointIndex = index(startPoint[1], startPoint[0]);
+        const targetPointIndex = index(targetPoint[1], targetPoint[0]);
+        const { visited: visited, parents: parents, costs: cost, priorityQueueNew: priorityQueue, } = this;
+        if (targetPointIndex === startPointIndex) {
+            return [];
+        }
+        while (!priorityQueue.isEmpty() &&
+            parents[targetPointIndex] === MAX_UINT32) {
+            const pointIndex = priorityQueue.pop();
+            if (visited[pointIndex]) {
+                continue;
+            }
+            const point = coord(pointIndex);
+            const neighborsPoints = this._getNeighborPoints(point);
+            visited[pointIndex] = true;
+            for (let i = 0, len = neighborsPoints.length; i < len; i++) {
+                const neighborPoint = neighborsPoints[i];
+                const neighbordPointIndex = index(neighborPoint[1], neighborPoint[0]);
+                const dist = this._getWeightedDistance(point, neighborPoint);
+                const neighborCost = cost[pointIndex] + dist;
+                if (neighborCost < cost[neighbordPointIndex]) {
+                    if (cost[neighbordPointIndex] !== Infinity) {
+                        priorityQueue.remove(neighbordPointIndex);
+                    }
+                    cost[neighbordPointIndex] = neighborCost;
+                    parents[neighbordPointIndex] = pointIndex;
+                    priorityQueue.push(neighbordPointIndex);
+                }
+            }
+        }
+        const pathPoints = [];
+        let pathPointIndex = targetPointIndex;
+        while (pathPointIndex !== MAX_UINT32) {
+            pathPoints.push(coord(pathPointIndex));
+            pathPointIndex = parents[pathPointIndex];
+        }
+        return pathPoints.reverse();
+    }
+    _getDeltaX(x, y) {
+        const { grayscalePixelData: data, width } = this;
+        let index = this._getPointIndex(y, x);
+        if (x + 1 === width) {
+            index--;
+        }
+        return data[index + 1] - data[index];
+    }
+    _getDeltaY(x, y) {
+        const { grayscalePixelData: data, width, height } = this;
+        let index = this._getPointIndex(y, x);
+        if (y + 1 === height) {
+            index -= height;
+        }
+        return data[index] - data[index + width];
+    }
+    _getGradientMagnitude(x, y) {
+        const dx = this._getDeltaX(x, y);
+        const dy = this._getDeltaY(x, y);
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    _getLaplace(x, y) {
+        const { grayscalePixelData: data, _getPointIndex: index } = this;
+        const p02 = data[index(y - 2, x)];
+        const p11 = data[index(y - 1, x - 1)];
+        const p12 = data[index(y - 1, x)];
+        const p13 = data[index(y - 1, x + 1)];
+        const p20 = data[index(y, x - 2)];
+        const p21 = data[index(y, x - 1)];
+        const p22 = data[index(y, x)];
+        const p23 = data[index(y, x + 1)];
+        const p24 = data[index(y, x + 2)];
+        const p31 = data[index(y + 1, x - 1)];
+        const p32 = data[index(y + 1, x)];
+        const p33 = data[index(y + 1, x + 1)];
+        const p42 = data[index(y + 2, x)];
+        let lap = p02;
+        lap += p11 + 2 * p12 + p13;
+        lap += p20 + 2 * p21 - 16 * p22 + 2 * p23 + p24;
+        lap += p31 + 2 * p32 + p33;
+        lap += p42;
+        return lap;
+    }
+    _computeGradient() {
+        const { width, height } = this;
+        const gradient = new Float32Array(width * height);
+        let pixelIndex = 0;
+        let max = 0;
+        let x = 0;
+        let y = 0;
+        for (y = 0; y < height - 1; y++) {
+            for (x = 0; x < width - 1; x++) {
+                gradient[pixelIndex] = this._getGradientMagnitude(x, y);
+                max = Math.max(gradient[pixelIndex], max);
+                pixelIndex++;
+            }
+            gradient[pixelIndex] = gradient[pixelIndex - 1];
+            pixelIndex++;
+        }
+        for (let len = gradient.length; pixelIndex < len; pixelIndex++) {
+            gradient[pixelIndex] = gradient[pixelIndex - width];
+        }
+        for (let i = 0, len = gradient.length; i < len; i++) {
+            gradient[i] = 1 - gradient[i] / max;
+        }
+        return gradient;
+    }
+    _computeLaplace() {
+        const { width, height, _getPointIndex: index } = this;
+        const laplace = new Float32Array(width * height);
+        laplace.fill(1, 0, index(2, 0));
+        for (let y = 2; y < height - 2; y++) {
+            laplace[index(y, 0)] = 1;
+            laplace[index(y, 1)] = 1;
+            for (let x = 2; x < width - 2; x++) {
+                laplace[index(y, x)] = this._getLaplace(x, y) > 0.33 ? 0 : 1;
+            }
+            laplace[index(y, width - 2)] = 1;
+            laplace[index(y, width - 1)] = 1;
+        }
+        laplace.fill(1, index(height - 2, 0));
+        return laplace;
+    }
+    _computeGradientX() {
+        const { width, height } = this;
+        const gradX = new Float32Array(width * height);
+        let pixelIndex = 0;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width - 1; x++) {
+                gradX[pixelIndex++] = this._getDeltaX(x, y);
+            }
+            gradX[pixelIndex] = gradX[pixelIndex - 1];
+            pixelIndex++;
+        }
+        return gradX;
+    }
+    _computeGradientY() {
+        const { width, height } = this;
+        const gradY = new Float32Array(width * height);
+        let pixelIndex = 0;
+        for (let y = 0; y < height - 1; y++) {
+            for (let x = 0; x < width; x++) {
+                gradY[pixelIndex++] = this._getDeltaY(x, y);
+            }
+        }
+        for (let len = gradY.length; pixelIndex < len; pixelIndex++) {
+            gradY[pixelIndex] = gradY[pixelIndex - width];
+        }
+        return gradY;
+    }
+    _getGradientUnitVector(px, py) {
+        const { gradXNew, gradYNew, _getPointIndex: index } = this;
+        const pointGradX = gradXNew[index(py, px)];
+        const pointGradY = gradYNew[index(py, px)];
+        let gradVecLen = Math.sqrt(pointGradX * pointGradX + pointGradY * pointGradY);
+        gradVecLen = Math.max(gradVecLen, 1e-100);
+        return [pointGradX / gradVecLen, pointGradY / gradVecLen];
+    }
+    _getGradientDirection(px, py, qx, qy) {
+        const dgpUnitVec = this._getGradientUnitVector(px, py);
+        const gdqUnitVec = this._getGradientUnitVector(qx, qy);
+        let dp = dgpUnitVec[1] * (qx - px) - dgpUnitVec[0] * (qy - py);
+        let dq = gdqUnitVec[1] * (qx - px) - gdqUnitVec[0] * (qy - py);
+        if (dp < 0) {
+            dp = -dp;
+            dq = -dq;
+        }
+        if (px !== qx && py !== qy) {
+            dp *= Math.SQRT1_2;
+            dq *= Math.SQRT1_2;
+        }
+        return TWO_THIRD_PI * (Math.acos(dp) + Math.acos(dq));
+    }
+    _getWeightedDistance(pointA, pointB) {
+        const { _getPointIndex: index } = this;
+        const [aX, aY] = pointA;
+        const [bX, bY] = pointB;
+        const bIndex = index(bY, bX);
+        let gradient = this.gradMagnitude[bIndex];
+        if (aX === bX || aY === bY) {
+            gradient *= Math.SQRT1_2;
+        }
+        const laplace = this.laplace[bIndex];
+        const direction = this._getGradientDirection(aX, aY, bX, bY);
+        return 0.43 * gradient + 0.43 * laplace + 0.11 * direction;
+    }
+    _getNeighborPoints(point) {
+        const { width, height } = this;
+        const list = [];
+        const sx = Math.max(point[0] - 1, 0);
+        const sy = Math.max(point[1] - 1, 0);
+        const ex = Math.min(point[0] + 1, width - 1);
+        const ey = Math.min(point[1] + 1, height - 1);
+        for (let y = sy; y <= ey; y++) {
+            for (let x = sx; x <= ex; x++) {
+                if (x !== point[0] || y !== point[1]) {
+                    list.push([x, y]);
+                }
+            }
+        }
+        return list;
+    }
+    static createInstanceFromRawPixelData(pixelData, width, height, voiRange) {
+        const numPixels = pixelData.length;
+        const grayscalePixelData = new Float32Array(numPixels);
+        const { lower: minPixelValue, upper: maxPixelValue } = voiRange;
+        const pixelRange = maxPixelValue - minPixelValue;
+        for (let i = 0, len = pixelData.length; i < len; i++) {
+            grayscalePixelData[i] = Math.max(0, Math.min(1, (pixelData[i] - minPixelValue) / pixelRange));
+        }
+        return new LivewireScissors(grayscalePixelData, width, height);
+    }
+    static createInstanceFromRGBAPixelData(rgbaPixelData, width, height) {
+        const numPixels = rgbaPixelData.length / 4;
+        const grayscalePixelData = new Float32Array(numPixels);
+        const avgMultiplier = 1 / (3 * 255);
+        for (let i = 0, offset = 0; i < numPixels; i++, offset += 4) {
+            const red = rgbaPixelData[offset];
+            const green = rgbaPixelData[offset];
+            const blue = rgbaPixelData[offset];
+            grayscalePixelData[i] = (red + green + blue) * avgMultiplier;
+        }
+        return new LivewireScissors(grayscalePixelData, width, height);
+    }
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/livewire/LiveWirePath.js
+class LivewirePath {
+    constructor(inputPointArray, inputControlPointIndexArray) {
+        this.pointArray = inputPointArray ? inputPointArray.slice() : [];
+        this._controlPointIndexes = inputControlPointIndexArray
+            ? inputControlPointIndexArray.slice()
+            : [];
+    }
+    getPoint(index) {
+        return this.pointArray[index];
+    }
+    getLastPoint() {
+        return this.pointArray[this.pointArray.length - 1];
+    }
+    isControlPoint(point) {
+        const index = this.pointArray.indexOf(point);
+        if (index !== -1) {
+            return this._controlPointIndexes.indexOf(index) !== -1;
+        }
+        else {
+            throw new Error('Error: isControlPoint called with not in list point.');
+        }
+    }
+    addPoint(point) {
+        this.pointArray.push(point);
+    }
+    addControlPoint(point) {
+        const index = this.pointArray.indexOf(point);
+        if (index !== -1) {
+            this._controlPointIndexes.push(index);
+        }
+        else {
+            throw new Error('Cannot mark a non registered point as control point.');
+        }
+    }
+    getControlPoints() {
+        return this._controlPointIndexes.map((i) => this.pointArray[i]);
+    }
+    getNumControlPoints() {
+        return this._controlPointIndexes.length;
+    }
+    removeLastControlPoint() {
+        if (this._controlPointIndexes.length) {
+            this._controlPointIndexes.pop();
+        }
+    }
+    addPoints(newPointArray) {
+        this.pointArray = this.pointArray.concat(newPointArray);
+    }
+    prependPath(other) {
+        const otherSize = other.pointArray.length;
+        const shiftedIndexArray = [];
+        this.pointArray = other.pointArray.concat(this.pointArray);
+        for (let i = 0; i < this._controlPointIndexes.length; ++i) {
+            shiftedIndexArray[i] = this._controlPointIndexes[i] + otherSize;
+        }
+        this._controlPointIndexes =
+            other._controlPointIndexes.concat(shiftedIndexArray);
+    }
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/LivewireContourTool.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2;
+class LivewireContourTool extends base_AnnotationTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            preventHandleOutsideImage: false,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.isHandleOutsideImage = false;
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const { world: worldPos, canvas: canvasPos } = currentPoints;
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const defaultActor = viewport.getDefaultActor();
+            if (!defaultActor || !esm.utilities.isImageActor(defaultActor)) {
+                throw new Error('Default actor must be an image actor');
+            }
+            const viewportImageData = viewport.getImageData();
+            const { imageData: vtkImageData } = viewportImageData;
+            let worldToSlice;
+            let sliceToWorld;
+            let scalarData;
+            let width;
+            let height;
+            if (viewport instanceof esm.StackViewport) {
+                scalarData = viewportImageData.scalarData;
+                width = viewportImageData.dimensions[0];
+                height = viewportImageData.dimensions[1];
+                worldToSlice = (point) => {
+                    const ijkPoint = esm.utilities.transformWorldToIndex(vtkImageData, point);
+                    return [ijkPoint[0], ijkPoint[1]];
+                };
+                sliceToWorld = (point) => esm.utilities.transformIndexToWorld(vtkImageData, [point[0], point[1], 0]);
+            }
+            else if (viewport instanceof esm.VolumeViewport) {
+                const sliceImageData = esm.utilities.getCurrentVolumeViewportSlice(viewport);
+                const { sliceToIndexMatrix, indexToSliceMatrix } = sliceImageData;
+                worldToSlice = (point) => {
+                    const ijkPoint = esm.utilities.transformWorldToIndex(vtkImageData, point);
+                    const slicePoint = gl_matrix_esm/* vec3.transformMat4 */.R3.transformMat4([0, 0, 0], ijkPoint, indexToSliceMatrix);
+                    return [slicePoint[0], slicePoint[1]];
+                };
+                sliceToWorld = (point) => {
+                    const ijkPoint = gl_matrix_esm/* vec3.transformMat4 */.R3.transformMat4([0, 0, 0], [point[0], point[1], 0], sliceToIndexMatrix);
+                    return esm.utilities.transformIndexToWorld(vtkImageData, ijkPoint);
+                };
+                scalarData = sliceImageData.scalarData;
+                width = sliceImageData.width;
+                height = sliceImageData.height;
+            }
+            else {
+                throw new Error('Viewport not supported');
+            }
+            const { voiRange } = viewport.getProperties();
+            const startPos = worldToSlice(worldPos);
+            this.scissors = LivewireScissors.createInstanceFromRawPixelData(scalarData, width, height, voiRange);
+            this.scissors.startSearch(startPos);
+            const confirmedPath = new LivewirePath();
+            const currentPath = new LivewirePath();
+            confirmedPath.addPoint(startPos);
+            confirmedPath.addControlPoint(startPos);
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    toolName: this.getToolName(),
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                },
+                data: {
+                    polyline: [],
+                    handles: {
+                        points: [[...worldPos]],
+                        activeHandleIndex: null,
+                    },
+                },
+            };
+            addAnnotation(annotation, element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                newAnnotation: true,
+                hasMoved: false,
+                lastCanvasPoint: canvasPos,
+                confirmedPath: confirmedPath,
+                currentPath: currentPath,
+                closed: false,
+                worldToSlice,
+                sliceToWorld,
+            };
+            this._activateDraw(element);
+            evt.preventDefault();
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            return annotation;
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const proximitySquared = proximity * proximity;
+            const canvasPoints = annotation.data.polyline.map((p) => viewport.worldToCanvas(p));
+            let startPoint = canvasPoints[canvasPoints.length - 1];
+            for (let i = 0; i < canvasPoints.length; i++) {
+                const endPoint = canvasPoints[i];
+                const distanceToPointSquared = line_distanceToPointSquared_distanceToPointSquared(startPoint, endPoint, canvasCoords);
+                if (distanceToPointSquared <= proximitySquared) {
+                    return true;
+                }
+                startPoint = endPoint;
+            }
+            return false;
+        };
+        this.toolSelectedCallback = (evt, annotation) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+            };
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            this._activateModify(element);
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this.handleSelectedCallback = (evt, annotation, handle) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { data } = annotation;
+            annotation.highlighted = true;
+            const { points } = data.handles;
+            const handleIndex = points.findIndex((p) => p === handle);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                handleIndex,
+            };
+            this._activateModify(element);
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+            const { data } = annotation;
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            resetElementCursor(element);
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                annotationState_removeAnnotation(annotation.annotationUID);
+            }
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            if (newAnnotation) {
+                const eventType = enums_Events.ANNOTATION_COMPLETED;
+                const eventDetail = {
+                    annotation,
+                };
+                (0,esm.triggerEvent)(esm.eventTarget, eventType, eventDetail);
+            }
+            this.editData = null;
+            this.scissors = null;
+            this.isDrawing = false;
+        };
+        this._mouseDownCallback = (evt) => {
+            const doubleClick = evt.type === enums_Events.MOUSE_DOUBLE_CLICK;
+            const { annotation, viewportIdsToRender, worldToSlice, sliceToWorld } = this.editData;
+            if (this.editData.closed) {
+                return;
+            }
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { currentPoints } = eventDetail;
+            const { canvas: canvasPos, world: worldPos } = currentPoints;
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            const controlPoints = this.editData.currentPath.getControlPoints();
+            let closePath = controlPoints.length >= 2 && doubleClick;
+            if (controlPoints.length >= 2) {
+                const closestHandlePoint = {
+                    index: -1,
+                    distSquared: Infinity,
+                };
+                for (let i = 0, len = controlPoints.length; i < len; i++) {
+                    const controlPoint = controlPoints[i];
+                    const worldControlPoint = sliceToWorld(controlPoint);
+                    const canvasControlPoint = viewport.worldToCanvas(worldControlPoint);
+                    const distSquared = distanceToPointSquared_distanceToPointSquared(canvasPos, canvasControlPoint);
+                    if (distSquared <= CLICK_CLOSE_CURVE_SQR_DIST &&
+                        distSquared < closestHandlePoint.distSquared) {
+                        closestHandlePoint.distSquared = distSquared;
+                        closestHandlePoint.index = i;
+                    }
+                }
+                if (closestHandlePoint.index === 0) {
+                    closePath = true;
+                }
+            }
+            this.editData.closed = this.editData.closed || closePath;
+            this.editData.confirmedPath = this.editData.currentPath;
+            this.editData.confirmedPath.addControlPoint(this.editData.currentPath.getLastPoint());
+            this.scissors.startSearch(worldToSlice(worldPos));
+            annotation.invalidated = true;
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            if (this.editData.closed) {
+                this._updateAnnotation(element, this.editData.confirmedPath);
+                this._endCallback(evt);
+            }
+            evt.preventDefault();
+        };
+        this._mouseMoveCallback = (evt) => {
+            const { element, currentPoints } = evt.detail;
+            const { world: worldPos, canvas: canvasPos } = currentPoints;
+            const { renderingEngine } = (0,esm.getEnabledElement)(element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData.lastCanvasPoint = canvasPos;
+            const { width: imgWidth, height: imgHeight } = this.scissors;
+            const { worldToSlice } = this.editData;
+            const slicePoint = worldToSlice(worldPos);
+            if (slicePoint[0] < 0 ||
+                slicePoint[1] < 0 ||
+                slicePoint[0] >= imgWidth ||
+                slicePoint[1] >= imgHeight) {
+                return;
+            }
+            const pathPoints = this.scissors.findPathToPoint(slicePoint);
+            const currentPath = new LivewirePath();
+            for (let i = 0, len = pathPoints.length; i < len; i++) {
+                currentPath.addPoint(pathPoints[i]);
+            }
+            currentPath.prependPath(this.editData.confirmedPath);
+            this.editData.currentPath = currentPath;
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this._dragCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, handleIndex } = this.editData;
+            const { data } = annotation;
+            if (handleIndex === undefined) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const points = data.polyline;
+                points.forEach((point) => {
+                    point[0] += worldPosDelta[0];
+                    point[1] += worldPosDelta[1];
+                    point[2] += worldPosDelta[2];
+                });
+                annotation.invalidated = true;
+            }
+            else {
+                const { currentPoints } = eventDetail;
+                const worldPos = currentPoints.world;
+                data.handles.points[handleIndex] = [...worldPos];
+                annotation.invalidated = true;
+            }
+            this.editData.hasMoved = true;
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        };
+        this.cancel = (element) => {
+            if (!this.isDrawing) {
+                return;
+            }
+            this.isDrawing = false;
+            this._deactivateDraw(element);
+            this._deactivateModify(element);
+            resetElementCursor(element);
+            const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+            if (newAnnotation) {
+                annotationState_removeAnnotation(annotation.annotationUID);
+            }
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            this.editData = null;
+            this.scissors = null;
+            return annotation.annotationUID;
+        };
+        this.triggerAnnotationModified = (annotation, enabledElement) => {
+            const { viewportId, renderingEngineId } = enabledElement;
+            const eventType = enums_Events.ANNOTATION_MODIFIED;
+            const eventDetail = {
+                annotation,
+                viewportId,
+                renderingEngineId,
+            };
+            (0,esm.triggerEvent)(esm.eventTarget, eventType, eventDetail);
+        };
+        this._activateModify = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(enums_Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(enums_Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(enums_Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(enums_Events.TOUCH_END, this._endCallback);
+            element.addEventListener(enums_Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(enums_Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateModify = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(enums_Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(enums_Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(enums_Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(enums_Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(enums_Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(enums_Events.TOUCH_TAP, this._endCallback);
+        };
+        this._activateDraw = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(enums_Events.MOUSE_MOVE, this._mouseMoveCallback);
+            element.addEventListener(enums_Events.MOUSE_DOWN, this._mouseDownCallback);
+            element.addEventListener(enums_Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
+            element.addEventListener(enums_Events.TOUCH_TAP, this._mouseDownCallback);
+        };
+        this._deactivateDraw = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(enums_Events.MOUSE_MOVE, this._mouseMoveCallback);
+            element.removeEventListener(enums_Events.MOUSE_DOWN, this._mouseDownCallback);
+            element.removeEventListener(enums_Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
+            element.removeEventListener(enums_Events.TOUCH_TAP, this._mouseDownCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { worldToCanvas } = viewport;
+            const { element } = viewport;
+            if (!viewport.getRenderingEngine()) {
+                console.warn('Rendering Engine has been destroyed');
+                return renderStatus;
+            }
+            let annotations = getAnnotations(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const newAnnotation = this.editData?.newAnnotation;
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            this._updateAnnotation(element, this.editData?.currentPath);
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { handles } = data;
+                const { points } = handles;
+                styleSpecifier.annotationUID = annotationUID;
+                const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+                const color = this.getStyle('color', styleSpecifier, annotation);
+                const canvasCoordinates = points.map((p) => worldToCanvas(p));
+                if (!isAnnotationVisible(annotationUID)) {
+                    continue;
+                }
+                if (newAnnotation &&
+                    annotation.annotationUID === this.editData?.annotation?.annotationUID) {
+                    const handleGroupUID = '0';
+                    drawingSvg_drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, [canvasCoordinates[0]], {
+                        color,
+                        lineDash,
+                        lineWidth,
+                    });
+                }
+                const canvasPolyline = data.polyline.map((worldPoint) => viewport.worldToCanvas(worldPoint));
+                drawPolyline(svgDrawingHelper, annotationUID, 'polyline', canvasPolyline, {
+                    color,
+                    lineDash,
+                    lineWidth,
+                });
+                renderStatus = true;
+                annotation.invalidated = false;
+            }
+            return renderStatus;
+        };
+    }
+    _updateAnnotation(element, livewirePath) {
+        if (!this.editData || !livewirePath) {
+            return;
+        }
+        const { pointArray: imagePoints } = livewirePath;
+        const worldPolylinePoints = [];
+        const { sliceToWorld } = this.editData;
+        for (let i = 0, len = imagePoints.length; i < len; i++) {
+            const imagePoint = imagePoints[i];
+            const worldPoint = sliceToWorld(imagePoint);
+            worldPolylinePoints.push(worldPoint);
+        }
+        if (worldPolylinePoints.length > 1) {
+            worldPolylinePoints.push([...worldPolylinePoints[0]]);
+        }
+        this.editData.annotation.data.polyline = worldPolylinePoints;
+    }
+}
+LivewireContourTool.toolName = 'LivewireContour';
+/* harmony default export */ const annotation_LivewireContourTool = (LivewireContourTool);
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/ArrowAnnotateTool.js
 
 
@@ -34804,6 +35659,7 @@ OrientationMarkerTool.toolName = 'OrientationMarker';
 
 
 
+
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/rectangleROITool/getBoundsIJKFromRectangleAnnotations.js