fix: 修复折线边拖拽过程中偶现斜线问题&圆角旁边出现突出线段问题

Author: DymoneLewis

packages/core/src/model/edge/PolylineEdgeModel.ts

@@ -504,7 +504,9 @@ export class PolylineEdgeModel extends BaseEdgeModel {
       this.offset || 0,
     )
     this.pointsList = this.orthogonalizePath(pointsList)
-    this.points = pointsList.map((point) => `${point.x},${point.y}`).join(' ')
+    this.points = this.pointsList
+      .map((point) => `${point.x},${point.y}`)
+      .join(' ')
   }
 
   @action

packages/core/src/util/edge.ts

@@ -107,6 +107,15 @@ export const pointDirection = (point: Point, bbox: BoxBounds): Direction => {
 }
 
 /* 获取扩展图形上的点，即起始终点相邻的点，上一个或者下一个节点 */
+/**
+ * 计算扩展包围盒上的相邻点（起点或终点的下一个/上一个拐点）
+ * - 使用原始节点 bbox 来判定点相对中心的方向，避免 offset 扩展后宽高改变导致方向误判
+ * - 若 start 相对中心为水平方向，则返回扩展盒在 x 上的边界，y 保持不变
+ * - 若为垂直方向，则返回扩展盒在 y 上的边界，x 保持不变
+ * @param expendBBox 扩展后的包围盒（包含 offset）
+ * @param bbox 原始节点包围盒（用于正确的方向判定）
+ * @param point 起点或终点坐标
+ */
 export const getExpandedBBoxPoint = (
   expendBBox: BoxBounds,
   bbox: BoxBounds,
@@ -378,7 +387,11 @@ export const isSegmentCrossingBBox = (
   )
 }
 
-/* 获取下一个相邻的点 */
+/**
+ * 基于轴对齐规则获取某点的相邻可连通点（不穿越节点）
+ * - 仅考虑 x 或 y 相同的候选点，保证严格水平/垂直
+ * - 使用 isSegmentCrossingBBox 校验线段不穿越源/目标节点
+ */
 export const getNextNeighborPoints = (
   points: Point[],
   point: Point,
@@ -401,9 +414,12 @@ export const getNextNeighborPoints = (
   return filterRepeatPoints(neighbors)
 }
 
-/* 路径查找,AStar查找+曼哈顿距离
- * 算法wiki:https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95
- * 方法无法复用，且调用了很多polyline相关的方法，暂不抽离到src/algorithm中
+/**
+ * 使用 A* + 曼哈顿启发式在候选点图上查找正交路径
+ * - 开放集/关闭集管理遍历
+ * - gScore 为累计实际代价，fScore = gScore + 启发式
+ * - 邻居仅为与当前点 x 或 y 相同且不穿越节点的点
+ * 参考：https://zh.wikipedia.org/wiki/A*%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95
  */
 export const pathFinder = (
   points: Point[],
@@ -475,8 +491,9 @@ export const pathFinder = (
       }
 
       if (current?.id && neighbor?.id) {
+        // 修复：累计代价应基于 gScore[current] 而非 fScore[current]
         const tentativeGScore =
-          fScore[current.id] + estimateDistance(current, neighbor)
+          (gScore[current.id] ?? 0) + estimateDistance(current, neighbor)
         if (gScore[neighbor.id] && tentativeGScore >= gScore[neighbor.id]) {
           return
         }
@@ -495,7 +512,10 @@ export const pathFinder = (
 export const getBoxByOriginNode = (node: BaseNodeModel): BoxBounds => {
   return getNodeBBox(node)
 }
-/* 保证一条直线上只有2个节点： 删除x/y相同的中间节点 */
+/**
+ * 去除共线冗余中间点，保持每条直线段仅保留两端点
+ * - 若三点在同一水平线或同一垂直线，移除中间点
+ */
 export const pointFilter = (points: Point[]): Point[] => {
   let i = 1
   while (i < points.length - 1) {
@@ -514,7 +534,16 @@ export const pointFilter = (points: Point[]): Point[] => {
   return points
 }
 
-/* 计算折线点 */
+/**
+ * 计算折线点（正交候选点 + A* 路径）
+ * 步骤：
+ * 1) 取源/目标节点的扩展包围盒与相邻点 sPoint/tPoint
+ * 2) 若两个扩展盒重合，使用简单路径 getSimplePoints
+ * 3) 构造 lineBBox/sMixBBox/tMixBBox，并收集其角点与中心交点
+ * 4) 过滤掉落在两个扩展盒内部的点，形成 connectPoints
+ * 5) 以 sPoint/tPoint 为起止，用 A* 查找路径
+ * 6) 拼入原始 start/end，并用 pointFilter 去除冗余共线点
+ */
 export const getPolylinePoints = (
   start: Point,
   end: Point,
@@ -700,6 +729,10 @@ export const points2PointsList = (points: string): Point[] => {
   return pointsList
 }
 
+/**
+ * 当扩展 bbox 重合时的简化拐点计算
+ * - 根据起止段的方向（水平/垂直）插入 1~2 个中间点，避免折线重合与穿越
+ */
 export const getSimplePoints = (
   start: Point,
   end: Point,

packages/extension/src/materials/curved-edge/index.ts

@@ -97,50 +97,67 @@ function getMidPoints(
   }
 }
 
+/**
+ * 生成局部路径片段（包含圆角）
+ * - 输入为上一个顶点、当前拐点、下一个顶点，计算方向组合并选择圆弧象限
+ * - 将圆角半径限制在相邻两段长度的一半以内，避免过度弯曲
+ * @param prevPoint 上一个顶点
+ * @param cornerPoint 当前拐点（圆角所在拐点）
+ * @param nextPoint 下一个顶点
+ * @param cornerRadius 圆角半径上限
+ * @returns 局部 path 字符串（包含 L/Q 操作）
+ */
 function getPartialPath(
-  prev: PointTuple,
-  cur: PointTuple,
-  next: PointTuple,
-  radius: number,
+  prevPoint: PointTuple,
+  cornerPoint: PointTuple,
+  nextPoint: PointTuple,
+  cornerRadius: number,
 ): string {
-  // 定义误差容错变量
-  const tolerance = 1
-
-  let dir1: DirectionType = ''
-  let dir2: DirectionType = ''
-
-  if (Math.abs(prev[0] - cur[0]) <= tolerance) {
-    // 垂直方向
-    dir1 = prev[1] > cur[1] ? 't' : 'b'
-  } else if (Math.abs(prev[1] - cur[1]) <= tolerance) {
-    // 水平方向
-    dir1 = prev[0] > cur[0] ? 'l' : 'r'
+  // 轴对齐容差（像素），用于消除微小误差
+  const epsilon = 1
+
+  const resolveDir = (a: PointTuple, b: PointTuple): DirectionType => {
+    const dx = b[0] - a[0]
+    const dy = b[1] - a[1]
+    const adx = Math.abs(dx)
+    const ady = Math.abs(dy)
+    if (ady <= epsilon && adx > epsilon) {
+      return dx < 0 ? 'l' : 'r'
+    }
+    if (adx <= epsilon && ady > epsilon) {
+      return dy < 0 ? 't' : 'b'
+    }
+    if (adx <= epsilon && ady <= epsilon) {
+      return ''
+    }
+    // 非严格对齐时，选择更接近的轴
+    return adx < ady ? (dx < 0 ? 'l' : 'r') : dy < 0 ? 't' : 'b'
   }
 
-  if (Math.abs(cur[0] - next[0]) <= tolerance) {
-    dir2 = cur[1] > next[1] ? 't' : 'b'
-  } else if (Math.abs(cur[1] - next[1]) <= tolerance) {
-    dir2 = cur[0] > next[0] ? 'l' : 'r'
-  }
+  const dir1: DirectionType = resolveDir(prevPoint, cornerPoint)
+  const dir2: DirectionType = resolveDir(cornerPoint, nextPoint)
 
   const r =
     Math.min(
-      Math.hypot(cur[0] - prev[0], cur[1] - prev[1]) / 2,
-      Math.hypot(next[0] - cur[0], next[1] - cur[1]) / 2,
-      radius,
-    ) || (1 / 5) * radius
+      Math.hypot(cornerPoint[0] - prevPoint[0], cornerPoint[1] - prevPoint[1]) /
+        2,
+      Math.hypot(nextPoint[0] - cornerPoint[0], nextPoint[1] - cornerPoint[1]) /
+        2,
+      cornerRadius,
+    ) || (1 / 5) * cornerRadius
 
   const key = `${dir1}${dir2}`
   const orientation: ArcQuadrantType = directionMap[key] || '-'
-  let path = `L ${prev[0]} ${prev[1]}`
+  let path = ''
 
   if (orientation === '-') {
-    path += `L ${cur[0]} ${cur[1]} L ${next[0]} ${next[1]}`
+    // 仅移动到当前拐点，由下一次迭代决定如何从拐点继续（直线或圆角）
+    path += `L ${cornerPoint[0]} ${cornerPoint[1]}`
   } else {
-    const [mid1, mid2] = getMidPoints(cur, key, orientation, r)
+    const [mid1, mid2] = getMidPoints(cornerPoint, key, orientation, r)
     if (mid1 && mid2) {
-      path += `L ${mid1[0]} ${mid1[1]} Q ${cur[0]} ${cur[1]} ${mid2[0]} ${mid2[1]}`
-      ;[cur[0], cur[1]] = mid2
+      path += `L ${mid1[0]} ${mid1[1]} Q ${cornerPoint[0]} ${cornerPoint[1]} ${mid2[0]} ${mid2[1]}`
+      ;[cornerPoint[0], cornerPoint[1]] = mid2
     }
   }
   return path