@libs-ui/components-draw-line 0.2.61

package/esm2022/util/line-connect-bottom-left.until.mjs

@@ -0,0 +1,155 @@
+import { cloneDeep } from "@libs-ui/utils";
+import { MoCanvasCalculatorBranchUtil } from "./calculator-branch.util";
+import { MoCanvasCalculatorDirectionElementUtil } from "./calculator-diretion-element.until";
+export class MoCanvasConnectNavigationBottomLeftElementUtil {
+    static lineLeft(pointNext, pointStart, start, lineCurve, obstacleRect, separatedPoints) {
+        const endPositionOrigin = {
+            x: pointNext.x,
+            y: pointNext.y
+        };
+        const endPosition = cloneDeep(endPositionOrigin);
+        const directionStartY = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(start.y, endPositionOrigin.y, 'y');
+        let newPosition = start;
+        if (directionStartY === 'above') {
+            const startQL = { lx: start.x - lineCurve, ly: (start.y ?? 0) + lineCurve };
+            const line = {
+                start: { x: (start.x ?? 0), y: start.y ?? 0 },
+                end: { x: startQL.lx ?? 0, y: startQL.ly ?? 0 }
+            };
+            newPosition = {
+                x: pointStart.x - (lineCurve + 10),
+                y: MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartY, line.end.y, lineCurve, true)
+            };
+            separatedPoints.push({ start: line.start, end: line.end, mode: 'vertical-single-curve', id: '1' }); // line vẽ đi khỏi khối đầu tiên
+            separatedPoints.push({ start: line.end, end: newPosition, mode: 'horizontal-single-curve', id: '1' }); // line vẽ đi khỏi khối đầu tiên
+        }
+        // kiểm tra hướng thẳng đến end, nếu có khối thì tránh
+        endPositionOrigin.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartY, endPositionOrigin.y, lineCurve);
+        const straightLine = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocksYLeft(newPosition.x ?? 0, newPosition.y ?? 0, lineCurve, endPositionOrigin, directionStartY, obstacleRect, separatedPoints);
+        const directionStartX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(straightLine.endPath.x, endPositionOrigin.x, 'x');
+        if (directionStartX === 'center' && directionStartY === 'under') {
+            return;
+        }
+        if (Math.abs((straightLine.endPath.x ?? 0) - endPositionOrigin.x) < lineCurve) {
+            const listLine = separatedPoints.filter(item => item.id === 'checkAndAvoidBlocksYLeft');
+            const elements = listLine.filter(item => item.start.x === straightLine.endPath.x || item.end.x === straightLine.endPath.x);
+            elements.forEach(item => {
+                console.log('directionStartX', directionStartX);
+                if (item.start.x === straightLine.endPath.x) {
+                    item.start.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartX, item.start.x, (lineCurve));
+                }
+                if (item.end.x === straightLine.endPath.x) {
+                    item.end.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartX, item.end.x, (lineCurve));
+                }
+            });
+        }
+        // // kiểm tra ngay khi cua có vướng ai không rồi hẵng vẽ Q1
+        const elementBlockRoad = MoCanvasCalculatorDirectionElementUtil.checkLinePassBlockHorizontal(straightLine.endPath.x ?? 0, endPosition.x, straightLine.endPath.y ?? 0, 'x', obstacleRect);
+        const directionNextX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(straightLine.endPath.x ?? 0, endPositionOrigin.x, 'x');
+        const coordQ1 = MoCanvasCalculatorDirectionElementUtil.drawLineQ({ x: straightLine.endPath.x ?? 0, y: straightLine.endPath.y ?? 0 }, `${directionStartY}-${directionNextX}`, lineCurve, lineCurve); // tính đoạn cong từ đường ngang sang đường thẳng
+        if (elementBlockRoad) {
+            coordQ1.x1 = straightLine.endPath.x ?? 0;
+            coordQ1.y1 = straightLine.endPath.y ?? 0;
+            coordQ1.x = straightLine.endPath.x ?? 0;
+            coordQ1.y = straightLine.endPath.y ?? 0;
+        }
+        // kiểm tra và vẽ hướng ngang
+        const directionXToEnd = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(coordQ1.x ?? 0, endPositionOrigin.x, 'x');
+        endPosition.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionXToEnd, endPosition.x, lineCurve);
+        if (Math.abs((coordQ1.y ?? 0) - endPosition.y) <= lineCurve) {
+            endPosition.y -= lineCurve;
+        }
+        const pathHorizontal = [];
+        const { endPath } = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocksLeft(coordQ1.x ?? 0, coordQ1.y ?? 0, lineCurve, endPositionOrigin, obstacleRect, pathHorizontal);
+        if (directionXToEnd === 'left' && endPath.x > (coordQ1.x ?? 0)) {
+            separatedPoints.push({ start: straightLine.endPath, end: endPositionOrigin, mode: 'vertical', id: '6a ' + directionStartY });
+            return;
+        }
+        const end = { x: (coordQ1.x ?? 0), y: coordQ1.y ?? 0 };
+        separatedPoints.push({ start: straightLine.endPath, end: end, mode: 'vertical-single-curve', id: '6a ' + directionStartY }); // góc cong từ đường thẳng sang ngang
+        separatedPoints.push(...pathHorizontal);
+        if (endPath.x === endPositionOrigin.x && endPath.y < endPositionOrigin.y) {
+            const itemLast = pathHorizontal.find(item => item.end.x === endPath.x);
+            if (itemLast) {
+                itemLast.end.x = endPositionOrigin.x + 50;
+                endPath.x = itemLast.end.x;
+            }
+        }
+        separatedPoints.push({ start: endPath, end: { x: pointNext.x, y: pointNext.y }, mode: 'horizontal', id: 'lineEnd' });
+    }
+    static rightLeft(elementNext, start, lineCurve, obstacleRect, separatedPoints) {
+        const endPosition = {
+            x: elementNext.x,
+            y: elementNext.y
+        };
+        // vẽ 1 đường thẳng từ điểm start ra ngoài đã
+        const end = { x: (start.x ?? 0) + 10, y: (start.y ?? 0) + 10 };
+        separatedPoints.push({ start: { x: (start.x ?? 0), y: start.y ?? 0 }, end: end, mode: 'vertical-single-curve', id: '1' });
+        const endPositionX = cloneDeep(endPosition);
+        endPositionX.x -= 50;
+        let separatedPointsCheckAndAvoidBlocks = [];
+        let { endPath } = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocks(end.x ?? 0, (end.y ?? 0), lineCurve, endPositionX, obstacleRect, separatedPointsCheckAndAvoidBlocks);
+        if (Math.abs((start.x ?? 0) - endPosition.x) < 10 || end.x > endPath.x) {
+            endPath = {
+                x: end.x,
+                y: end.y
+            };
+            separatedPointsCheckAndAvoidBlocks = [];
+        }
+        if (Math.abs((endPath.y ?? 0) - endPosition.y) < 15) {
+            const elements = separatedPointsCheckAndAvoidBlocks.filter(item => item.start.y === endPath.y || item.end.y === endPath.y);
+            elements.forEach(item => {
+                if (item.start.y === endPath.y) {
+                    item.start.y -= 10;
+                }
+                if (item.end.y === endPath.y) {
+                    item.end.y -= 10;
+                }
+            });
+        }
+        separatedPoints.splice(separatedPoints.length, 0, ...separatedPointsCheckAndAvoidBlocks);
+        if (endPath.y === endPosition.y) {
+            separatedPoints.push({ start: { x: endPath.x ?? 0, y: endPath.y }, end: endPosition, mode: 'horizontal' });
+            return;
+        }
+        // // sau khi đã đi ngang và tránh các khối, tiếp theo là đi tiếp hướng lên xuống để về khối cần nối tới, cần check xem điểm end X nó đang ở hướng nào
+        const directionY = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(endPath.y, endPosition.y, 'y');
+        const coordQ1 = MoCanvasCalculatorDirectionElementUtil.drawLineQ({ x: endPath.x ?? 0, y: endPath.y ?? 0 }, `right-${directionY === 'above' ? 'above' : 'under'}`, lineCurve, lineCurve); // tính đoạn cong từ đường ngang sang đường thẳng
+        const endPositionY = cloneDeep(endPosition);
+        endPositionY.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, endPositionY.y, lineCurve);
+        // // cần check khi đi thẳng lên có vướng khối nào không để tiến lên, nhưng cần phải xem x của nó có quá gần endX không, gần quá thì 
+        const elementBlockRoadStraightLineY = MoCanvasCalculatorDirectionElementUtil.checkBlocksElementStraightY((endPath.x ?? 0) + 10, endPath.y ?? 0, endPositionY, obstacleRect);
+        if (elementBlockRoadStraightLineY) {
+            coordQ1.x = (elementBlockRoadStraightLineY.x ?? 0) + (elementBlockRoadStraightLineY.width ?? 0) + lineCurve;
+        }
+        if (Math.abs((coordQ1.x ?? 0) - endPosition.x) < 20 && directionY === 'under') {
+            coordQ1.x = endPosition.x + 20; // trường hợp right quay xuống dưới điểm end khá gần điểm start => không đủ khoảng cách quay mũi tên vào
+        }
+        separatedPoints.push({ start: { x: endPath.x ?? 0, y: endPath.y }, end: { x: coordQ1.x ?? 0, y: (coordQ1.y ?? 0) }, mode: 'horizontal-single-curve', id: 'g' });
+        let avoidBlocksYLine = [];
+        const straightLine = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocksY(coordQ1.x ?? 0, coordQ1.y ?? 0, lineCurve, endPositionY, directionY, obstacleRect, avoidBlocksYLine);
+        if (directionY === 'under' && (coordQ1.y ?? 0) > endPositionY.y) {
+            avoidBlocksYLine = [];
+            straightLine.endPath = { x: coordQ1.x ?? 0, y: coordQ1.y ?? 0 };
+        }
+        if (directionY === 'above' && straightLine.endPath.y <= endPosition.y) {
+            avoidBlocksYLine = [];
+            straightLine.endPath = { x: coordQ1.x ?? 0, y: coordQ1.y ?? 0 };
+        }
+        if (Math.abs((straightLine.endPath.x ?? 0) - endPosition.x) < 15) {
+            const elements = avoidBlocksYLine.filter(item => item.start.x === straightLine.endPath.x || item.end.x === straightLine.endPath.x);
+            elements.forEach(item => {
+                if (item.start.x === straightLine.endPath.x) {
+                    item.start.x += 30;
+                }
+                if (item.end.x === straightLine.endPath.x) {
+                    item.end.x += 30;
+                }
+            });
+        }
+        separatedPoints.push(...avoidBlocksYLine);
+        separatedPoints.push({ start: { x: straightLine.endPath.x ?? 0, y: straightLine.endPath.y ?? 0 }, end: endPosition, mode: 'vertical-single-curve', id: '4' });
+        return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-connect-bottom-left.until.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/draw-line/src/util/line-connect-bottom-left.until.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,sCAAsC,EAAE,MAAM,qCAAqC,CAAC;AAE7F,MAAM,OAAO,8CAA8C;IACzD,MAAM,CAAC,QAAQ,CAAC,SAAgB,EAAE,UAAiB,EAAE,KAAa,EAAE,SAAiB,EAAE,YAAqB,EAAE,eAA+B;QAC3I,MAAM,iBAAiB,GAAG;YACxB,CAAC,EAAE,SAAS,CAAC,CAAC;YACd,CAAC,EAAE,SAAS,CAAC,CAAC;SACf,CAAC;QACF,MAAM,WAAW,GAAG,SAAS,CAAC,iBAAiB,CAAC,CAAC;QACjD,MAAM,eAAe,GAAG,sCAAsC,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAEvH,IAAI,WAAW,GAAG,KAAK,CAAC;QAExB,IAAI,eAAe,KAAK,OAAO,EAAE,CAAC;YAChC,MAAM,OAAO,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC,GAAG,SAAS,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,EAAE,CAAA;YAC3E,MAAM,IAAI,GAAG;gBACX,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE;gBAC7C,GAAG,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE;aAChD,CAAA;YACD,WAAW,GAAG;gBACZ,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,SAAS,GAAG,EAAE,CAAC;gBAClC,CAAC,EAAE,4BAA4B,CAAC,wBAAwB,CAAC,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC;aACvG,CAAA;YAED,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,gCAAgC;YACpI,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,gCAAgC;QACzI,CAAC;QAED,sDAAsD;QACtD,iBAAiB,CAAC,CAAC,GAAG,4BAA4B,CAAC,wBAAwB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC7H,MAAM,YAAY,GAAG,sCAAsC,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;QAE3M,MAAM,eAAe,GAAG,sCAAsC,CAAC,oBAAoB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACtI,IAAI,eAAe,KAAK,QAAQ,IAAI,eAAe,KAAK,OAAO,EAAE,CAAC;YAChE,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC;YAC9E,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,0BAA0B,CAAC,CAAC;YACxF,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAC3H,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACtB,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC;gBAChD,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;oBAC5C,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,4BAA4B,CAAC,wBAAwB,CAAC,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;gBACnH,CAAC;gBACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;oBAC1C,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,4BAA4B,CAAC,wBAAwB,CAAC,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC/G,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,4DAA4D;QAC5D,MAAM,gBAAgB,GAAG,sCAAsC,CAAC,4BAA4B,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,YAAY,CAAU,CAAC;QAClM,MAAM,cAAc,GAAG,sCAAsC,CAAC,oBAAoB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC1I,MAAM,OAAO,GAAG,sCAAsC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,EACjI,GAAG,eAAe,IAAI,cAAc,EAAE,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,iDAAiD;QAElH,IAAI,gBAAgB,EAAE,CAAC;YACrB,OAAO,CAAC,EAAE,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;YACzC,OAAO,CAAC,EAAE,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;YACzC,OAAO,CAAC,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;YACxC,OAAO,CAAC,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QAED,6BAA6B;QAC7B,MAAM,eAAe,GAAG,sCAAsC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAE9H,WAAW,CAAC,CAAC,GAAG,4BAA4B,CAAC,wBAAwB,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QACjH,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,SAAS,EAAE,CAAC;YAC5D,WAAW,CAAC,CAAC,IAAI,SAAS,CAAC;QAC7B,CAAC;QACD,MAAM,cAAc,GAAc,EAAE,CAAC;QACrC,MAAM,EAAE,OAAO,EAAE,GAAG,sCAAsC,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,iBAAiB,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;QAE/K,IAAI,eAAe,KAAK,MAAM,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC/D,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,KAAK,GAAG,eAAe,EAAE,CAAC,CAAC;YAC7H,OAAO;QACT,CAAC;QACD,MAAM,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;QACvD,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE,EAAE,EAAE,KAAK,GAAG,eAAe,EAAE,CAAC,CAAC,CAAC,qCAAqC;QAClK,eAAe,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,CAAA;QACvC,IAAI,OAAO,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,EAAE,CAAC;YACzE,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;YACvE,IAAI,QAAQ,EAAE,CAAC;gBACb,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC;gBAC1C,OAAO,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QACD,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;IACvH,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,WAAkB,EAAE,KAAa,EAAE,SAAiB,EAAE,YAAqB,EAAE,eAA+B;QAC3H,MAAM,WAAW,GAAG;YAClB,CAAC,EAAE,WAAW,CAAC,CAAC;YAChB,CAAC,EAAE,WAAW,CAAC,CAAC;SACjB,CAAC;QAEF,6CAA6C;QAC7C,MAAM,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC;QAC/D,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;QAE1H,MAAM,YAAY,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;QAC5C,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC;QAErB,IAAI,kCAAkC,GAAmB,EAAE,CAAC;QAC5D,IAAI,EAAE,OAAO,EAAE,GAAG,sCAAsC,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,kCAAkC,CAAC,CAAC;QAElL,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;YACvE,OAAO,GAAG;gBACR,CAAC,EAAE,GAAG,CAAC,CAAC;gBACR,CAAC,EAAE,GAAG,CAAC,CAAC;aACT,CAAC;YAEF,kCAAkC,GAAG,EAAE,CAAC;QAC1C,CAAC;QAED,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC;YACpD,MAAM,QAAQ,GAAG,kCAAkC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;YAC3H,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACtB,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;oBAC/B,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;gBACrB,CAAC;gBACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;oBAC7B,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,kCAAkC,CAAC,CAAC;QAEzF,IAAI,OAAO,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,EAAE,CAAC;YAChC,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;YAC3G,OAAO;QACT,CAAC;QAED,sJAAsJ;QACtJ,MAAM,UAAU,GAAG,sCAAsC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAE9G,MAAM,OAAO,GAAG,sCAAsC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,iDAAiD;QAC1O,MAAM,YAAY,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;QAC5C,YAAY,CAAC,CAAC,GAAG,4BAA4B,CAAC,wBAAwB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAE9G,qIAAqI;QACrI,MAAM,6BAA6B,GAAG,sCAAsC,CAAC,2BAA2B,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;QAC5K,IAAI,6BAA6B,EAAE,CAAC;YAClC,OAAO,CAAC,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,6BAA6B,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;QAC9G,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,UAAU,KAAK,OAAO,EAAE,CAAC;YAC9E,OAAO,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,EAAE,CAAC,CAAE,wGAAwG;QAC3I,CAAC;QACD,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;QAEhK,IAAI,gBAAgB,GAAc,EAAE,CAAC;QACrC,MAAM,YAAY,GAAG,sCAAsC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,gBAAgB,CAAC,CAAC;QACtL,IAAI,UAAU,KAAK,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC;YAChE,gBAAgB,GAAG,EAAE,CAAC;YACtB,YAAY,CAAC,OAAO,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;QAClE,CAAC;QACD,IAAI,UAAU,KAAK,OAAO,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC;YACtE,gBAAgB,GAAG,EAAE,CAAC;YACtB,YAAY,CAAC,OAAO,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;QAClE,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC;YACjE,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACnI,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACtB,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;oBAC5C,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;gBACrB,CAAC;gBACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;oBAC1C,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,eAAe,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,CAAC;QAC1C,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,uBAAuB,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;QAE9J,OAAO;IACT,CAAC;CACF","sourcesContent":["import { cloneDeep } from \"@libs-ui/utils\";\nimport { IPoint, IPoints, IRect } from \"../draw-line.interface\";\nimport { MoCanvasCalculatorBranchUtil } from \"./calculator-branch.util\";\nimport { MoCanvasCalculatorDirectionElementUtil } from \"./calculator-diretion-element.until\";\n\nexport class MoCanvasConnectNavigationBottomLeftElementUtil {\n  static lineLeft(pointNext: IRect, pointStart: IRect, start: IPoint, lineCurve: number, obstacleRect: IRect[], separatedPoints: Array<IPoints>) {\n    const endPositionOrigin = {\n      x: pointNext.x,\n      y: pointNext.y\n    };\n    const endPosition = cloneDeep(endPositionOrigin);\n    const directionStartY = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(start.y, endPositionOrigin.y, 'y');\n\n    let newPosition = start;\n\n    if (directionStartY === 'above') {\n      const startQL = { lx: start.x - lineCurve, ly: (start.y ?? 0) + lineCurve }\n      const line = {\n        start: { x: (start.x ?? 0), y: start.y ?? 0 },\n        end: { x: startQL.lx ?? 0, y: startQL.ly ?? 0 }\n      }\n      newPosition = {\n        x: pointStart.x - (lineCurve + 10),\n        y: MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartY, line.end.y, lineCurve, true)\n      }\n\n      separatedPoints.push({ start: line.start, end: line.end, mode: 'vertical-single-curve', id: '1' }); // line vẽ đi khỏi khối đầu tiên\n      separatedPoints.push({ start: line.end, end: newPosition, mode: 'horizontal-single-curve', id: '1' }); // line vẽ đi khỏi khối đầu tiên\n    }\n\n    // kiểm tra hướng thẳng đến end, nếu có khối thì tránh\n    endPositionOrigin.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartY, endPositionOrigin.y, lineCurve);\n    const straightLine = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocksYLeft(newPosition.x ?? 0, newPosition.y ?? 0, lineCurve, endPositionOrigin, directionStartY, obstacleRect, separatedPoints);\n\n    const directionStartX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(straightLine.endPath.x, endPositionOrigin.x, 'x');\n    if (directionStartX === 'center' && directionStartY === 'under') {\n      return;\n    }\n\n    if (Math.abs((straightLine.endPath.x ?? 0) - endPositionOrigin.x) < lineCurve) {\n      const listLine = separatedPoints.filter(item => item.id === 'checkAndAvoidBlocksYLeft');\n      const elements = listLine.filter(item => item.start.x === straightLine.endPath.x || item.end.x === straightLine.endPath.x);\n      elements.forEach(item => {\n        console.log('directionStartX', directionStartX);\n        if (item.start.x === straightLine.endPath.x) {\n          item.start.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartX, item.start.x, (lineCurve));\n        }\n        if (item.end.x === straightLine.endPath.x) {\n          item.end.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionStartX, item.end.x, (lineCurve));\n        }\n      })\n    }\n\n    // // kiểm tra ngay khi cua có vướng ai không rồi hẵng vẽ Q1\n    const elementBlockRoad = MoCanvasCalculatorDirectionElementUtil.checkLinePassBlockHorizontal(straightLine.endPath.x ?? 0, endPosition.x, straightLine.endPath.y ?? 0, 'x', obstacleRect) as IRect;\n    const directionNextX = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(straightLine.endPath.x ?? 0, endPositionOrigin.x, 'x');\n    const coordQ1 = MoCanvasCalculatorDirectionElementUtil.drawLineQ({ x: straightLine.endPath.x ?? 0, y: straightLine.endPath.y ?? 0 },\n      `${directionStartY}-${directionNextX}`, lineCurve, lineCurve); // tính đoạn cong từ đường ngang sang đường thẳng\n\n    if (elementBlockRoad) {\n      coordQ1.x1 = straightLine.endPath.x ?? 0;\n      coordQ1.y1 = straightLine.endPath.y ?? 0;\n      coordQ1.x = straightLine.endPath.x ?? 0;\n      coordQ1.y = straightLine.endPath.y ?? 0;\n    }\n\n    // kiểm tra và vẽ hướng ngang\n    const directionXToEnd = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(coordQ1.x ?? 0, endPositionOrigin.x, 'x');\n\n    endPosition.x = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionXToEnd, endPosition.x, lineCurve);\n    if (Math.abs((coordQ1.y ?? 0) - endPosition.y) <= lineCurve) {\n      endPosition.y -= lineCurve;\n    }\n    const pathHorizontal: IPoints[] = [];\n    const { endPath } = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocksLeft(coordQ1.x ?? 0, coordQ1.y ?? 0, lineCurve, endPositionOrigin, obstacleRect, pathHorizontal);\n\n    if (directionXToEnd === 'left' && endPath.x > (coordQ1.x ?? 0)) {\n      separatedPoints.push({ start: straightLine.endPath, end: endPositionOrigin, mode: 'vertical', id: '6a ' + directionStartY });\n      return;\n    }\n    const end = { x: (coordQ1.x ?? 0), y: coordQ1.y ?? 0 };\n    separatedPoints.push({ start: straightLine.endPath, end: end, mode: 'vertical-single-curve', id: '6a ' + directionStartY }); // góc cong từ đường thẳng sang ngang\n    separatedPoints.push(...pathHorizontal)\n    if (endPath.x === endPositionOrigin.x && endPath.y < endPositionOrigin.y) {\n      const itemLast = pathHorizontal.find(item => item.end.x === endPath.x);\n      if (itemLast) {\n        itemLast.end.x = endPositionOrigin.x + 50;\n        endPath.x = itemLast.end.x;\n      }\n    }\n    separatedPoints.push({ start: endPath, end: { x: pointNext.x, y: pointNext.y }, mode: 'horizontal', id: 'lineEnd' });\n  }\n\n  static rightLeft(elementNext: IRect, start: IPoint, lineCurve: number, obstacleRect: IRect[], separatedPoints: Array<IPoints>) {\n    const endPosition = {\n      x: elementNext.x,\n      y: elementNext.y\n    };\n\n    // vẽ 1 đường thẳng từ điểm start ra ngoài đã\n    const end = { x: (start.x ?? 0) + 10, y: (start.y ?? 0) + 10 };\n    separatedPoints.push({ start: { x: (start.x ?? 0), y: start.y ?? 0 }, end: end, mode: 'vertical-single-curve', id: '1' });\n\n    const endPositionX = cloneDeep(endPosition);\n    endPositionX.x -= 50;\n\n    let separatedPointsCheckAndAvoidBlocks: Array<IPoints> = [];\n    let { endPath } = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocks(end.x ?? 0, (end.y ?? 0), lineCurve, endPositionX, obstacleRect, separatedPointsCheckAndAvoidBlocks);\n\n    if (Math.abs((start.x ?? 0) - endPosition.x) < 10 || end.x > endPath.x) {\n      endPath = {\n        x: end.x,\n        y: end.y\n      };\n\n      separatedPointsCheckAndAvoidBlocks = [];\n    }\n\n    if (Math.abs((endPath.y ?? 0) - endPosition.y) < 15) {\n      const elements = separatedPointsCheckAndAvoidBlocks.filter(item => item.start.y === endPath.y || item.end.y === endPath.y);\n      elements.forEach(item => {\n        if (item.start.y === endPath.y) {\n          item.start.y -= 10;\n        }\n        if (item.end.y === endPath.y) {\n          item.end.y -= 10;\n        }\n      })\n    }\n\n    separatedPoints.splice(separatedPoints.length, 0, ...separatedPointsCheckAndAvoidBlocks);\n\n    if (endPath.y === endPosition.y) {\n      separatedPoints.push({ start: { x: endPath.x ?? 0, y: endPath.y }, end: endPosition, mode: 'horizontal' });\n      return;\n    }\n\n    // // sau khi đã đi ngang và tránh các khối, tiếp theo là đi tiếp hướng lên xuống để về khối cần nối tới, cần check xem điểm end X nó đang ở hướng nào\n    const directionY = MoCanvasCalculatorDirectionElementUtil.checkUpDownLeftRight(endPath.y, endPosition.y, 'y');\n\n    const coordQ1 = MoCanvasCalculatorDirectionElementUtil.drawLineQ({ x: endPath.x ?? 0, y: endPath.y ?? 0 }, `right-${directionY === 'above' ? 'above' : 'under'}`, lineCurve, lineCurve); // tính đoạn cong từ đường ngang sang đường thẳng\n    const endPositionY = cloneDeep(endPosition);\n    endPositionY.y = MoCanvasCalculatorBranchUtil.mathOperatorsCalculation(directionY, endPositionY.y, lineCurve);\n\n    // // cần check khi đi thẳng lên có vướng khối nào không để tiến lên, nhưng cần phải xem x của nó có quá gần endX không, gần quá thì \n    const elementBlockRoadStraightLineY = MoCanvasCalculatorDirectionElementUtil.checkBlocksElementStraightY((endPath.x ?? 0) + 10, endPath.y ?? 0, endPositionY, obstacleRect);\n    if (elementBlockRoadStraightLineY) {\n      coordQ1.x = (elementBlockRoadStraightLineY.x ?? 0) + (elementBlockRoadStraightLineY.width ?? 0) + lineCurve;\n    }\n    if (Math.abs((coordQ1.x ?? 0) - endPosition.x) < 20 && directionY === 'under') {\n      coordQ1.x = endPosition.x + 20;  // trường hợp right quay xuống dưới điểm end khá gần điểm start => không đủ khoảng cách quay mũi tên vào\n    }\n    separatedPoints.push({ start: { x: endPath.x ?? 0, y: endPath.y }, end: { x: coordQ1.x ?? 0, y: (coordQ1.y ?? 0) }, mode: 'horizontal-single-curve', id: 'g' });\n\n    let avoidBlocksYLine: IPoints[] = [];\n    const straightLine = MoCanvasCalculatorDirectionElementUtil.checkAndAvoidBlocksY(coordQ1.x ?? 0, coordQ1.y ?? 0, lineCurve, endPositionY, directionY, obstacleRect, avoidBlocksYLine);\n    if (directionY === 'under' && (coordQ1.y ?? 0) > endPositionY.y) {\n      avoidBlocksYLine = [];\n      straightLine.endPath = { x: coordQ1.x ?? 0, y: coordQ1.y ?? 0 };\n    }\n    if (directionY === 'above' && straightLine.endPath.y <= endPosition.y) {\n      avoidBlocksYLine = [];\n      straightLine.endPath = { x: coordQ1.x ?? 0, y: coordQ1.y ?? 0 };\n    }\n    if (Math.abs((straightLine.endPath.x ?? 0) - endPosition.x) < 15) {\n      const elements = avoidBlocksYLine.filter(item => item.start.x === straightLine.endPath.x || item.end.x === straightLine.endPath.x);\n      elements.forEach(item => {\n        if (item.start.x === straightLine.endPath.x) {\n          item.start.x += 30;\n        }\n        if (item.end.x === straightLine.endPath.x) {\n          item.end.x += 30;\n        }\n      })\n    }\n\n    separatedPoints.push(...avoidBlocksYLine);\n    separatedPoints.push({ start: { x: straightLine.endPath.x ?? 0, y: straightLine.endPath.y ?? 0 }, end: endPosition, mode: 'vertical-single-curve', id: '4' });\n\n    return;\n  }\n}"]}