@sapui5/sap.suite.ui.commons 1.150.0 → 1.152.0

package/src/sap/suite/ui/commons/networkgraph/util/ConnectionPathUtils.js

@@ -67,46 +67,89 @@ sap.ui.define([
 
             // Detect RTL mode from graph
             const bIsRTL = oGraph._bIsRtl || false;
+            const bEnhanced = oGraph.getEnableEnhancedLineRouting ? oGraph.getEnableEnhancedLineRouting() : false;
 
-            // Iterate over all lines in the graph
-            oGraph.getLines().forEach((oLine) => {
-                const configuredConnectionType = oLine.getConnectionType(); // Get the connection type, if not configured at Line level then the default is Right to Left from source to target.
-                // In RTL mode, use effective connection type (semantically reversed)
-                const effectiveConnectionType = this._getEffectiveConnectionType(configuredConnectionType, bIsRTL);
-                const oSourceNode = oLine.getFromNode();
-                const oTargetNode = oLine.getToNode();
-                // Get anchor coordinates for source and target nodes, usually the center of the respective sides
-                const oSourceAnchor = this._getNodeAnchorCoordinates(oLine.getFromNode(), effectiveConnectionType, "source");
-                const oTargetAnchor = this._getNodeAnchorCoordinates(oLine.getToNode(), effectiveConnectionType, "target");
-                const mParams = {
-                    sourceAnchor: oSourceAnchor,
-                    targetAnchor: oTargetAnchor,
-                    sourceNode: oSourceNode,
-                    targetNode: oTargetNode,
-                    sConnectionType: effectiveConnectionType,
-                    gridSize: config.gridSize,
-                    minEdgeLength: config.minEdgeLength
-                };
-                // Calculate the path coordinates between the source and target anchors
-                const aCoordinates = this._calculatePathCoordinates(mParams);
-                // set the anchor points of the source and target nodes on the line as source and target for drawing the path.
-                oLine.setSource({
-                    x: oSourceAnchor.x,
-                    y: oSourceAnchor.y
-                });
-                oLine.setTarget({
-                    x: oTargetAnchor.x,
-                    y: oTargetAnchor.y
-                });
-                // Set the calculated bend points on the line
-                oLine.clearBends();
-                // Set the calculated bend points on the line, determined by the connection type.
-                if (aCoordinates && aCoordinates.length) {
-                    aCoordinates.forEach((oBend) => {
-                        oLine.addBend(oBend);
-                    });
+            try {
+                if (bEnhanced) {
+                    this._routingRowCache = this._buildRoutingRowCache(oGraph.getNodes(), config.gridSize);
+
+                    // Precompute per-node connection counts once to avoid rescanning all lines on each call.
+                    // Keys are normalized to strings on both write and read — node keys may be numeric
+                    // while Line#getFrom/getTo return them as-is, and Map.get() uses strict key identity.
+                    this._analysisCache = new Map();
+                    oGraph.getNodes().forEach(function(oNode) {
+                        this._analysisCache.set(String(oNode.getKey()), { leftIncoming: 0, leftOutgoing: 0, rightIncoming: 0, rightOutgoing: 0 });
+                    }, this);
+                    oGraph.getLines().forEach(function(oLine) {
+                        if (!oLine.getVisible() || oLine._isIgnored()) { return; }
+                        var sFrom = oLine.getFrom();
+                        var sTo = oLine.getTo();
+                        var sType = oLine.getConnectionType();
+                        var oFrom = this._analysisCache.get(String(sFrom));
+                        var oTo = this._analysisCache.get(String(sTo));
+                        if (oFrom) {
+                            switch (sType) {
+                                case "LeftToLeft": case "LeftToRight": oFrom.leftOutgoing++; break;
+                                default: oFrom.rightOutgoing++; break;
+                            }
+                        }
+                        if (oTo) {
+                            switch (sType) {
+                                case "LeftToLeft": case "RightToLeft": oTo.leftIncoming++; break;
+                                default: oTo.rightIncoming++; break;
+                            }
+                        }
+                    }, this);
                 }
-            });
+                // Iterate over all lines in the graph
+                oGraph.getLines().forEach((oLine) => {
+                    const configuredConnectionType = oLine.getConnectionType(); // Get the connection type, if not configured at Line level then the default is Right to Left from source to target.
+                    // In RTL mode, use effective connection type (semantically reversed)
+                    const effectiveConnectionType = this._getEffectiveConnectionType(configuredConnectionType, bIsRTL);
+                    const oSourceNode = oLine.getFromNode();
+                    const oTargetNode = oLine.getToNode();
+                    // Get anchor coordinates for source and target nodes, usually the center of the respective sides
+                    const oSourceAnchor = this._getNodeAnchorCoordinates(oLine.getFromNode(), effectiveConnectionType, "source");
+                    const oTargetAnchor = this._getNodeAnchorCoordinates(oLine.getToNode(), effectiveConnectionType, "target");
+
+                    const mParams = {
+                        sourceAnchor: oSourceAnchor,
+                        targetAnchor: oTargetAnchor,
+                        sourceNode: oSourceNode,
+                        targetNode: oTargetNode,
+                        sConnectionType: effectiveConnectionType,
+                        gridSize: config.gridSize,
+                        minEdgeLength: config.minEdgeLength,
+                        bEnhanced: bEnhanced
+                    };
+                    // Calculate the path coordinates between the source and target anchors
+                    const aCoordinates = this._calculatePathCoordinates(mParams);
+                    // set the anchor points of the source and target nodes on the line as source and target for drawing the path.
+                    oLine.setSource({
+                        x: oSourceAnchor.x,
+                        y: oSourceAnchor.y
+                    });
+                    oLine.setTarget({
+                        x: oTargetAnchor.x,
+                        y: oTargetAnchor.y
+                    });
+                    // Set the calculated bend points on the line
+                    oLine.clearBends();
+                    // Set the calculated bend points on the line, determined by the connection type.
+                    if (aCoordinates && aCoordinates.length) {
+                        aCoordinates.forEach((oBend) => {
+                            oLine.addBend(oBend);
+                        });
+                    }
+                });
+            } finally {
+                this._routingRowCache = null;
+                this._analysisCache = null;
+            }
+
+            if (bEnhanced) {
+                this._resolveLineNodeCollisions(oGraph.getLines(), oGraph.getNodes(), config.gridSize);
+            }
         },
         /**
          * Calculates path coordinates between source and target anchors based on connection type.
@@ -161,7 +204,7 @@ sap.ui.define([
          * @private
          */
          _handleRightToLeftConnection: function (mParams) {
-            const { sourceNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH } = mParams;
+            const { sourceNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH, bEnhanced } = mParams;
             const { x1, y1, x2, y2, AX1, AY1, AX2, AY2, dx } = this._transformSourceTargetCoordinates(mParams);
 
             // CASE 1: Source and target nodes are on the same horizontal line (y1 === y2)
@@ -176,16 +219,39 @@ sap.ui.define([
                         // Visual: [SRC]----→[TGT] (perfect alignment)
                         return [];
                     } else if (anchorVerticalOffset > 5) {
-                        // Visual: [SRC]→     ←[TGT] (offset anchors - add horizontal correction)
-                        //              |     |
-                        //              └─────┘
+                        // Offset anchors due to different node heights in the same row.
+                        // For skip-layer (intermediate nodes exist), route using corridor to avoid
+                        // the vertical Z-bend passing through intermediate nodes.
+                        if (bEnhanced) {
+                            const iNodeWidthOff = sourceNode._iWidth || 0;
+                            const iHorizontalGapOff = x2 - (x1 + iNodeWidthOff);
+                            if (iHorizontalGapOff > Math.max(iNodeWidthOff, gridSize)) {
+                                const xDrop = this.getRightGridIntersectionPoint(x1 + iNodeWidthOff, AY1, gridSize, minEdgeLength).x;
+                                const xRise = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
+                                const y3 = this._getRoutingYBelow(sourceNode, gridSize);
+                                return [{ x: xDrop, y: AY1 }, { x: xDrop, y: y3 }, { x: xRise, y: y3 }, { x: xRise, y: AY2 }];
+                            }
+                        }
+                        // Adjacent nodes — simple Z-bend through the gap between them
                         const midX = AX1 + (AX2 - AX1) / 2;
                         return [
                             { x: midX, y: AY1 },
                             { x: midX, y: AY2 }
                         ];
                     } else {
-                        // Multiple connections - use straight line anyway for now
+                        // Multiple connections from same side.
+                        if (bEnhanced) {
+                            // If the gap is large enough to suggest intermediate nodes, route below
+                            // to avoid the line passing through them visually.
+                            const iNodeWidth = sourceNode._iWidth || 0;
+                            const iHorizontalGap = x2 - (x1 + iNodeWidth);
+                            if (iHorizontalGap > Math.max(iNodeWidth, gridSize)) {
+                                const xDrop = this.getRightGridIntersectionPoint(x1 + iNodeWidth, AY1, gridSize, minEdgeLength).x;
+                                const xRise = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
+                                const y3 = this._getRoutingYBelow(sourceNode, gridSize);
+                                return [{ x: xDrop, y: AY1 }, { x: xDrop, y: y3 }, { x: xRise, y: y3 }, { x: xRise, y: AY2 }];
+                            }
+                        }
                         return [];
                     }
                 } else if (x1 >= x2) {
@@ -197,7 +263,7 @@ sap.ui.define([
                     // Create U-shaped path going around both nodes
                     const x3 = this.getRightGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                     const x4 = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                    const y3 = this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                    const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
 
                     return [
                         { x: x3, y: AY1 }, // Right from source
@@ -219,13 +285,42 @@ sap.ui.define([
                             const x3 = AX1 + (x2 - (x1 + sourceNode._iWidth)) / 2;
                             return [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
                         } else {
-                            // SCENARIO 2A2: Nodes are far apart - use grid-aligned Z-bend
-                            // Visual: [SRC]→ |
-                            //               |
-                            //               ↓
-                            //               ←[TGT]
-                            const x3 = this.getRightGridIntersectionPoint(x1 + sourceNode._iWidth, AY1, gridSize, minEdgeLength).x;
-                            return [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
+                            // SCENARIO 2A2: Nodes are far apart
+                            // If the horizontal gap is larger than one node width, intermediate nodes
+                            // likely occupy the space — route the vertical segments at source/target
+                            // column boundaries to avoid passing through them.
+                            const iGap = x2 - (x1 + sourceNode._iWidth);
+                            if (bEnhanced && iGap > sourceNode._iWidth) {
+                                // SCENARIO 2A2-SKIP: Skip-layer connection.
+                                // First go right to the nearest grid point (so the line visually exits the
+                                // source from the center-right side), then drop/rise outside intermediate
+                                // columns, then go horizontally to the target.
+                                // Visual (y1 ≤ y2):  [SRC]→——|        Visual (y1 > y2):  [SRC]→——|
+                                //                            |                                    ↑
+                                //                            ↓————————→ |             ←———————————|
+                                //                                       ↑
+                                //                                    ←[TGT]
+                                const xDrop = this.getRightGridIntersectionPoint(x1 + sourceNode._iWidth, AY1, gridSize, minEdgeLength).x;
+                                const xRise = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
+                                let y3;
+                                if (y1 <= y2) {
+                                    y3 = this._getRoutingYBelow(sourceNode, gridSize);
+                                } else {
+                                    y3 = this.getTopGridIntersectionPoint(xDrop, Math.min(y1, y2), gridSize, minEdgeLength).y;
+                                    if (y3 <= 0) {
+                                        y3 = this._getRoutingYBelow(sourceNode, gridSize);
+                                    }
+                                }
+                                return [{ x: xDrop, y: AY1 }, { x: xDrop, y: y3 }, { x: xRise, y: y3 }, { x: xRise, y: AY2 }];
+                            } else {
+                                // SCENARIO 2A2: Adjacent layers — grid-aligned Z-bend
+                                // Visual: [SRC]→ |
+                                //               |
+                                //               ↓
+                                //               ←[TGT]
+                                const x3 = this.getRightGridIntersectionPoint(x1 + sourceNode._iWidth, AY1, gridSize, minEdgeLength).x;
+                                return [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
+                            }
                         }
                     } else if (dx <= minEdgeLength + sourceNode._iWidth) {
                         // SCENARIO 2B: Nodes are too close - create S-shaped path
@@ -239,7 +334,7 @@ sap.ui.define([
                             //               ←[TGT]
                             const x3 = this.getRightGridIntersectionPoint(x1 + sourceNode._iWidth, y1, gridSize, minEdgeLength).x;
                             const x4 = this.getLeftGridIntersectionPoint(x2, AY2, gridSize, minEdgeLength).x;
-                            const y3 = this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                            const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
                             return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         } else if (y1 > y2) {
                             // SCENARIO 2B2: Source below target - S-bend going up
@@ -265,7 +360,7 @@ sap.ui.define([
                         // ←[TGT]    ←---------
                         const x3 = this.getRightGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                         const x4 = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                        const y3 = this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                        const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
                         return [
                             { x: x3, y: AY1 }, // Right from source
                             { x: x3, y: y3 },  // Down past both nodes
@@ -310,7 +405,7 @@ sap.ui.define([
          * @private
          */
         _handleLeftToRightConnection: function (mParams) {
-            const { sourceNode, targetNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH } = mParams;
+            const { sourceNode, targetNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH, bEnhanced } = mParams;
             const { x1, y1, x2, y2, AX1, AY1, AX2, AY2, dx } = this._transformSourceTargetCoordinates(mParams);
             // CASE 1: Source and target nodes are on the same horizontal line (y1 === y2)
             if (y1 === y2) {
@@ -345,7 +440,7 @@ sap.ui.define([
                     // Create U-shaped path going around both nodes
                     const x3 = this.getLeftGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                     const x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                    const y3 = this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                    const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
 
                     return [
                         { x: x3, y: AY1 }, // Right from source
@@ -388,7 +483,7 @@ sap.ui.define([
                             //         [TGT]→
                             const x3 = this.getLeftGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                             const x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                            const y3 = this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                            const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
                             return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         } else if (y1 > y2) {
                             // SCENARIO 2B2: Source below target - S-bend going up
@@ -414,7 +509,7 @@ sap.ui.define([
                         //               --------→[TGT]
                         const x3 = this.getLeftGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                         const x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                        const y3 = this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                        const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
                         return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                     } else if (y1 > y2) {
                         // SCENARIO 3B: Source below and left of target - S-bend up and right
@@ -454,7 +549,7 @@ sap.ui.define([
          * @private
          */
         _handleLeftToLeftConnection: function (mParams) {
-            const { sourceNode, targetNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH } = mParams;
+            const { sourceNode, targetNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH, bEnhanced } = mParams;
             const { x1, y1, x2, y2, AX1, AY1, AX2, AY2 } = this._transformSourceTargetCoordinates(mParams);
             // CASE 1: Source and target nodes are on the same horizontal line (y1 === y2)
             if (y1 === y2) {
@@ -469,7 +564,7 @@ sap.ui.define([
                         (AX1 + (x2 + targetNode._iWidth)) / 2 :
                         this.getLeftGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                     const x4 = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                    const y3 = y1 <= gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
+                    const y3 = y1 <= gridSize ? (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y) : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
                     return [
                         { x: x3, y: AY1 }, // Left from source
                         { x: x3, y: y3 },  // Down/up to avoid nodes
@@ -486,7 +581,7 @@ sap.ui.define([
                     const x4 = Math.abs(x1 + sourceNode._iWidth - x2) <= gridSize ?
                         (AX2 + x2) / 2 :
                         this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                    const y3 = y1 <= gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
+                    const y3 = y1 <= gridSize ? (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y) : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
                     return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                 }
             } else if (y1 != y2) {
@@ -553,7 +648,7 @@ sap.ui.define([
                                 x3 = this.getLeftGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                             }
                             const x4 = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                            const y3 = this.getBottomGridIntersectionPoint(x4, y2 + targetNode._iHeight, gridSize, minEdgeLength).y;
+                            const y3 = bEnhanced ? this._getRoutingYBelow(targetNode, gridSize) : this.getBottomGridIntersectionPoint(x4, y2 + targetNode._iHeight, gridSize, minEdgeLength).y;
                             return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         }
                     }
@@ -574,7 +669,7 @@ sap.ui.define([
                         } else {
                             x4 = this.getLeftGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
                         }
-                        const y3 = (AY2 > (y1 + sourceNode._iHeight)) ? AY2 : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y;
+                        const y3 = (AY2 > (y1 + sourceNode._iHeight)) ? AY2 : (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y);
                         const aCoordinates = AY2 > (y1 + sourceNode._iHeight) ? [{ x: x3, y: AY1 }, { x: x3, y: y3 }] : [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         return aCoordinates;
                     } else if (y1 > y2) {
@@ -623,7 +718,7 @@ sap.ui.define([
          * @private
          */
         _handleRightToRightConnection: function (mParams) {
-            const { sourceNode, targetNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH } = mParams;
+            const { sourceNode, targetNode, gridSize = GRID_SIZE, minEdgeLength = MIN_EDGE_LENGTH, bEnhanced } = mParams;
             const { x1, y1, x2, y2, AX1, AY1, AX2, AY2 } = this._transformSourceTargetCoordinates(mParams);
             // CASE 1: Source and target nodes are on the same horizontal line (y1 === y2)
             if (y1 === y2) {
@@ -636,7 +731,7 @@ sap.ui.define([
                     const x3 = this.getRightGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                     const iDiff = Math.abs(x1 - AX2);
                     const x4 = iDiff <= gridSize ? (x1 + x2) / 2 : this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                    const y3 = y1 < gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
+                    const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : y1 < gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
                     return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                 } else if (x1 <= x2) {
                     // SCENARIO 1B: Source to the left of target - create C-shaped path on right side
@@ -647,7 +742,7 @@ sap.ui.define([
                     const iDff = Math.abs(AX1 - x2);
                     const x3 = iDff <= gridSize ? (AX1 + x2) / 2 : this.getRightGridIntersectionPoint(AX1, AY1, gridSize, minEdgeLength).x;
                     const x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
-                    const y3 = y1 < gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
+                    const y3 = bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : y1 < gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
                     return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                 }
             } else if (y1 != y2) {
@@ -669,24 +764,12 @@ sap.ui.define([
                         } else {
                             x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
                         }
-                        const y3 = y1 <= gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
-                        if (AY2 > y1 + sourceNode._iHeight) {
-                            // Simple vertical connection if target anchor is below source node
-                            // Visual: [SRC]→
-                            //              |
-                            //              ↓
-                            //              [TGT]→
+                        const y3 = y1 <= gridSize ? (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y) : (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y);
+                        if (!bEnhanced && AY2 > y1 + sourceNode._iHeight) {
                             const aCords = AX2 > AX1 ? [{x: x4, y: AY1}, {x: x4, y: AY2}] : [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
                             return aCords;
-                        } else {
-                            // Need to avoid target node - create stepped path
-                            // Visual: [SRC]→
-                            //              |
-                            //         ↓---- →
-                            //         |
-                            //     [TGT]→
-                            return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         }
+                        return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                     } else if (y1 > y2) {
                         // SCENARIO 2A2: Source below and right of target
                         // Visual:                    [TGT]→
@@ -702,24 +785,12 @@ sap.ui.define([
                         } else {
                             x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
                         }
-                        const y3 = y2 <= gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength) : this.getTopGridIntersectionPoint(x4, y2, gridSize, minEdgeLength).y;
-                        if (AY1 > y2 + targetNode._iHeight) {
-                            // Simple vertical connection if target anchor is below source node
-                            // Visual: [SRC]→
-                            //              |
-                            //              ↓
-                            //              [TGT]→
+                        const y3 = y2 <= gridSize ? (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength)) : (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getTopGridIntersectionPoint(x4, y2, gridSize, minEdgeLength).y);
+                        if (!bEnhanced && AY1 > y2 + targetNode._iHeight) {
                             const aCords = AX2 > AX1 ? [{x: x4, y: AY1}, {x: x4, y: AY2}] : [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
                             return aCords;
-                        } else {
-                            // Need to avoid target node - create stepped path
-                            // Visual: [SRC]→
-                            //              |
-                            //         ↓---- →
-                            //         |
-                            //     [TGT]→
-                            return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         }
+                        return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                     }
                 } else if (x1 <= x2) {
                     // SCENARIO 2B: Source is to the left of target
@@ -738,26 +809,12 @@ sap.ui.define([
                         } else {
                             x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
                         }
-                        const y3 = y1 <= gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y;
-                        if (AY2 > y1 + sourceNode._iHeight) {
-                            // Simple vertical connection if target anchor is below source node
-                            // Visual: [SRC]→
-                            //              |
-                            //              ↓
-                            //              [TGT]→
+                        const y3 = y1 <= gridSize ? (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength).y) : (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getTopGridIntersectionPoint(x3, y1, gridSize, minEdgeLength).y);
+                        if (!bEnhanced && AY2 > y1 + sourceNode._iHeight) {
                             const aCords = AX2 > AX1 ? [{x: x4, y: AY1}, {x: x4, y: AY2}] : [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
                             return aCords;
-                        } else {
-                            // Need to avoid target node - create stepped path
-                            // Visual: [SRC]→
-                            //              |
-                            //         ↓---- →
-                            //         |
-                            //     [TGT]→
-                            return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         }
-                        // const aCoordinates = (AY2 > y1 + sourceNode._iHeight) ? [{ x: x4, y: AY1 }, { x: x4, y: AY2 }] : [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
-                        // return aCoordinates;
+                        return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                     } else if (y1 > y2) {
                         // SCENARIO 2B2: Source below and left of target
                         // Visual:                      [TGT]→
@@ -773,26 +830,12 @@ sap.ui.define([
                         } else {
                             x4 = this.getRightGridIntersectionPoint(AX2, AY2, gridSize, minEdgeLength).x;
                         }
-                        const y3 = y2 <= gridSize ? this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength) : this.getTopGridIntersectionPoint(x4, y2, gridSize, minEdgeLength).y;
-                        if (AY1 > y2 + targetNode._iHeight) {
-                            // Simple vertical connection if target anchor is below source node
-                            // Visual: [SRC]→
-                            //              |
-                            //              ↓
-                            //              [TGT]→
+                        const y3 = y2 <= gridSize ? (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getBottomGridIntersectionPoint(x3, y1 + sourceNode._iHeight, gridSize, minEdgeLength)) : (bEnhanced ? this._getRoutingYBelow(sourceNode, gridSize) : this.getTopGridIntersectionPoint(x4, y2, gridSize, minEdgeLength).y);
+                        if (!bEnhanced && AY1 > y2 + targetNode._iHeight) {
                             const aCords = AX2 > AX1 ? [{x: x4, y: AY1}, {x: x4, y: AY2}] : [{ x: x3, y: AY1 }, { x: x3, y: AY2 }];
                             return aCords;
-                        } else {
-                            // Need to avoid target node - create stepped path
-                            // Visual: [SRC]→
-                            //              |
-                            //         ↓---- →
-                            //         |
-                            //     [TGT]→
-                            return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                         }
-                        // const aCoordinates = (AY1 > y2 + targetNode._iHeight) ? [{ x: x4, y: AY1 }, { x: x4, y: AY2 }] : [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
-                        // return aCoordinates;
+                        return [{ x: x3, y: AY1 }, { x: x3, y: y3 }, { x: x4, y: y3 }, { x: x4, y: AY2 }];
                     }
                 }
             }
@@ -867,6 +910,150 @@ sap.ui.define([
             }
             return { x: x, y: yIntersection };
         },
+        /**
+         * Post-processing pass: detects horizontal line segments that pass through a node's
+         * bounding box and shifts them below the collision.
+         * Only interior segments are adjusted, source and target anchors are never moved.
+         *
+         * @param {sap.suite.ui.commons.networkgraph.Line[]} aLines
+         * @param {sap.suite.ui.commons.networkgraph.Node[]} aNodes
+         * @param {number} gridSize
+         * @private
+         */
+        _resolveLineNodeCollisions: function(aLines, aNodes, gridSize) {
+            var aBounds = aNodes.map(function(oNode) {
+                return {
+                    x: oNode.getX(),
+                    y: oNode.getY(),
+                    r: oNode.getX() + (oNode._iWidth || 0),
+                    b: oNode.getY() + (oNode._iHeight || 0)
+                };
+            }).filter(function(b) { return b.r > b.x && b.b > b.y; });
+
+            aLines.forEach(function(oLine) {
+                if (oLine.getVisible && !oLine.getVisible()) { return; }
+                if (oLine._isIgnored && oLine._isIgnored()) { return; }
+
+                var aBends = oLine.getBends();
+                var aPoints = [{ x: oLine.getSource().getX(), y: oLine.getSource().getY() }];
+                aBends.forEach(function(oBend) { aPoints.push({ x: oBend.getX(), y: oBend.getY() }); });
+                aPoints.push({ x: oLine.getTarget().getX(), y: oLine.getTarget().getY() });
+
+                var iPointCount = aPoints.length;
+                var bChanged = false;
+
+                // Only check interior segments — never move source (0) or target (iPointCount-1)
+                for (var i = 1; i < iPointCount - 2; i++) {
+                    var p1 = aPoints[i], p2 = aPoints[i + 1];
+                    if (p1.y !== p2.y) { continue; } // skip vertical segments
+
+                    var y = p1.y;
+                    var xMin = Math.min(p1.x, p2.x);
+                    var xMax = Math.max(p1.x, p2.x);
+
+                    var iMaxBottom = -Infinity;
+                    var bCollision = false;
+                    aBounds.forEach(function(oBound) {
+                        if (y > oBound.y && y <= oBound.b && xMin < oBound.r && xMax > oBound.x) {
+                            bCollision = true;
+                            if (oBound.b > iMaxBottom) { iMaxBottom = oBound.b; }
+                        }
+                    });
+
+                    if (bCollision) {
+                        var iNewY = iMaxBottom + Math.round(gridSize * 0.5);
+                        aPoints[i].y = iNewY;
+                        aPoints[i + 1].y = iNewY;
+                        bChanged = true;
+                    }
+                }
+
+                if (bChanged) {
+                    oLine.clearBends();
+                    for (var j = 1; j < iPointCount - 1; j++) {
+                        oLine.addBend(aPoints[j]);
+                    }
+                }
+            });
+        },
+
+        /**
+         * Builds a WeakMap of per-node row boundary data used by _getRoutingYBelow.
+         * Uses two passes to avoid the single-pass bug where iRowBottom is not yet finalised
+         * when a next-row candidate is evaluated.
+         *
+         * @param {object[]} aNodes - All graph nodes
+         * @param {number} gridSize - Grid size used for same-row proximity threshold
+         * @returns {WeakMap} node → { rowBottom, nextRowTop }
+         * @private
+         */
+        _buildRoutingRowCache: function(aNodes, gridSize) {
+            var mCache = new WeakMap();
+            if (!aNodes.length) { return mCache; }
+
+            // Pass 1: group nodes by row (center within gridSize/2) and compute rowBottom per group.
+            // The representative centerY is intentionally kept as the first node's center, a deliberate
+            // approximation that avoids updating all prior comparisons when new nodes join.
+            var aRows = [];
+            aNodes.forEach(function(oNode) {
+                var h = oNode._iHeight || 0;
+                var centerY = oNode.getY() + h / 2;
+                var oRow = null;
+                for (var i = 0; i < aRows.length; i++) {
+                    if (Math.abs(aRows[i].centerY - centerY) < gridSize / 2) {
+                        oRow = aRows[i];
+                        break;
+                    }
+                }
+                if (oRow) {
+                    oRow.nodes.push(oNode);
+                    oRow.rowBottom = Math.max(oRow.rowBottom, oNode.getY() + h);
+                    oRow.rowTop    = Math.min(oRow.rowTop,    oNode.getY());
+                } else {
+                    aRows.push({ centerY: centerY, nodes: [oNode], rowBottom: oNode.getY() + h, rowTop: oNode.getY() });
+                }
+            });
+
+            // Pass 2: for each row, find the nearest next rowTop. rowTop isn't monotonic with
+            // rowBottom if the heights vary, so the scan can't stop at the first match. It must
+            // keep the minimum qualifying rowTop across all subsequent rows.
+            aRows.sort(function(a, b) { return a.rowBottom - b.rowBottom; });
+            aRows.forEach(function(oRow, iRowIdx) {
+                var iNextRowTop = Infinity;
+                for (var k = iRowIdx + 1; k < aRows.length; k++) {
+                    if (aRows[k].rowTop > oRow.rowBottom && aRows[k].rowTop < iNextRowTop) {
+                        iNextRowTop = aRows[k].rowTop;
+                    }
+                }
+                oRow.nodes.forEach(function(oNode) {
+                    mCache.set(oNode, { rowBottom: oRow.rowBottom, nextRowTop: iNextRowTop });
+                });
+            });
+
+            return mCache;
+        },
+
+        /**
+         * Returns the Y coordinate of the horizontal routing corridor below a node's row.
+         * Uses pre-computed row boundary data from _buildRoutingRowCache (O(1) lookup).
+         * Falls back to node-bottom + 0.75 * gridSize when called outside normalizeLines.
+         *
+         * @param {object} oNode - Source/target node
+         * @param {number} gridSize - Grid size for fallback spacing
+         * @returns {number} Y coordinate of the routing corridor
+         * @private
+         */
+        _getRoutingYBelow: function(oNode, gridSize) {
+            var oData = this._routingRowCache && this._routingRowCache.get(oNode);
+            var iRowBottom = oData ? oData.rowBottom : oNode.getY() + (oNode._iHeight || 0);
+            var iNextRowTop = oData ? oData.nextRowTop : Infinity;
+
+            if (iNextRowTop === Infinity) {
+                return iRowBottom + Math.round(gridSize * 0.75);
+            }
+            return Math.round((iRowBottom + iNextRowTop) / 2);
+        },
+
         /**
          * Gets the anchor coordinates for a node based on connection type and anchor type.
          * Enhanced to handle center positioning for single connections and offset positioning for mixed connections.
@@ -1012,6 +1199,13 @@ sap.ui.define([
                 return { leftIncoming: 0, leftOutgoing: 0, rightIncoming: 0, rightOutgoing: 0 };
             }
 
+            if (this._analysisCache) {
+                var sCachedKey = oNode.getKey && oNode.getKey();
+                if (sCachedKey !== undefined && this._analysisCache.has(String(sCachedKey))) {
+                    return this._analysisCache.get(String(sCachedKey));
+                }
+            }
+
             const oGraph = oNode.getParent();
             const aLines = oGraph.getLines();
             const sNodeKey = oNode.getKey();