10416400188

Committed 16 Aug 2024 07:33AM UTC coverage: 90.939% (+0.02%) from 90.915%

Build # 10416400188

Build Type

push

github

Committed by

web-flow

Commit Message

feat: use a-star pathfinding algorithm to draw polyline (#6181)

* feat: use astar alogorithm to draw polyline

* test: add polyline unit tests

* test: supplement unit test

* test: update snapshots

* fix: fix types

Run Details

2866 of 3508 branches covered (81.7%)

Branch coverage included in aggregate %.

212 of 220 new or added lines in 5 files covered. (96.36%)

1 existing line in 1 file now uncovered.

6478 of 6767 relevant lines covered (95.73%)

12119.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.45

/packages/g6/src/utils/router/orth.ts

import type { AABB } from '@antv/g';
import { difference, isEqual } from '@antv/util';
import type { Node, OrthRouterOptions, Point } from '../../types';
import {
  getBBoxHeight,
  getBBoxWidth,
  getCombinedBBox,
  getNearestPointToPoint,
  getNodeBBox,
  isPointInBBox,
  isPointOnBBoxBoundary,
  isPointOutsideBBox,
} from '../bbox';
import { isOrthogonal, moveTo, round } from '../point';
import { angle, distance, subtract, toVector3 } from '../vector';

export type Direction = 'N' | 'S' | 'W' | 'E' | null;

type Route = {
  points: Point[];
  direction: Direction;
};

const defaultOptions: OrthRouterOptions = {
  padding: 10,
};

/**
 * <zh/> 获取两点之间的正交线段路径
 *
 * <en/> Get orthogonal line segments between two points
 * @param sourcePoint - <zh/> 起始点 | <en/> start point
 * @param targetPoint - <zh/> 终止点 | <en/> end point
 * @param sourceNode - <zh/> 起始节点 | <en/> source node
 * @param targetNode - <zh/> 终止节点 | <en/> target node
 * @param controlPoints - <zh/> 控制点 | <en/> control points
 * @param options - <zh/> 配置项 | <en/> options
 * @returns <zh/> 路径点集 | <en/> vertices
 */
export function orth(
  sourcePoint: Point,
  targetPoint: Point,
  sourceNode: Node,
  targetNode: Node,
  controlPoints: Point[],
  options: OrthRouterOptions,
) {
  const { padding } = Object.assign(defaultOptions, options);

  const sourceBBox = getNodeBBox(sourceNode, padding);
  const targetBBox = getNodeBBox(targetNode, padding);

  const points: Point[] = [sourcePoint, ...controlPoints, targetPoint];

  // direction of previous route segment
  let direction: Direction = null;
  const result: Point[] = [];

  for (let fromIdx = 0, len = points.length; fromIdx < len - 1; fromIdx++) {
    const toIdx = fromIdx + 1;
    const from = points[fromIdx];
    const to = points[toIdx];
    const isOrth = isOrthogonal(from, to);

    let route = null;

    if (fromIdx === 0) {
      if (toIdx === len - 1) {
        // source -> target
        if (sourceBBox.intersects(targetBBox)) {
          route = insideNode(from, to, sourceBBox, targetBBox);
        } else if (!isOrth) {
          route = nodeToNode(from, to, sourceBBox, targetBBox);
        }
      } else {
        // source -> point
        if (isPointInBBox(to, sourceBBox)) {
          route = insideNode(from, to, sourceBBox, getNodeBBox(to, padding), direction);
        } else if (!isOrth) {
          route = nodeToPoint(from, to, sourceBBox);
        }
      }
    } else if (toIdx === len - 1) {
      // point -> target
      if (isPointInBBox(from, targetBBox)) {
        route = insideNode(from, to, getNodeBBox(from, padding), targetBBox, direction);
      } else if (!isOrth) {
        route = pointToNode(from, to, targetBBox, direction);
      }
    } else if (!isOrth) {
      // point -> point
      route = pointToPoint(from, to, direction);
    }

    // set direction for next iteration
    if (route) {
      result.push(...route.points);
      direction = route.direction;
    } else {
      // orthogonal route and not looped
      direction = getDirection(from, to);
    }

    if (toIdx < len - 1) result.push(to);
  }

  return result;
}

/**
 * Direction to opposites direction map
 */
const opposites = {
  N: 'S',
  S: 'N',
  W: 'E',
  E: 'W',
};

/**
 * Direction to radians map
 */
const radians = {
  N: -Math.PI / 2,
  S: Math.PI / 2,
  E: 0,
  W: Math.PI,
};

/**
 * <zh/> 获取两点之间的方向，从 `from` 到 `to` 的方向
 *
 * <en/> Get the direction between two points, the direction from `from` to `to`
 * @param from - <zh/> 起始点 | <en/> start point
 * @param to - <zh/> 终止点 | <en/> end point
 * @returns <zh/> 方向 | <en/> direction
 */
export function getDirection(from: Point, to: Point): Direction | null {
  const [fx, fy] = from;
  const [tx, ty] = to;
  if (fx === tx) {
    return fy > ty ? 'N' : 'S';
  }
  if (fy === ty) {
    return fx > tx ? 'W' : 'E';
  }
  return null;
}

/**
 * <zh/> 获取包围盒的尺寸，根据方向返回宽度或者高度
 *
 * <en/> Get the size of the bounding box, return the width or height according to the direction
 * @param bbox - <zh/> 包围盒 | <en/> bounding box
 * @param direction - <zh/> 方向 | <en/> direction
 * @returns <zh/> 尺寸 | <en/> size
 */
export function getBBoxSize(bbox: AABB, direction: Direction): number {
  return direction === 'N' || direction === 'S' ? getBBoxHeight(bbox) : getBBoxWidth(bbox);
}

/**
 * <zh/> 从一个点到另一个点计算正交路由
 *
 * <en/> Calculate orthogonal route from one point to another
 * @param from - <zh/> 起始点 | <en/> start point
 * @param to - <zh/> 终止点 | <en/> end point
 * @param direction - <zh/> 前一条线段的方向 | <en/> direction of the previous segment
 * @returns <zh/> 正交路由 | <en/> orthogonal route
 */
export function pointToPoint(from: Point, to: Point, direction: Direction): Route {
  const p1: Point = [from[0], to[1]];
  const p2: Point = [to[0], from[1]];
  const d1 = getDirection(from, p1);
  const d2 = getDirection(from, p2);
  const opposite = direction ? opposites[direction] : null;
  const p = d1 === direction || (d1 !== opposite && d2 !== direction) ? p1 : p2;

  return { points: [p], direction: getDirection(p, to) };
}

/**
 * <zh/> 从节点到点计算正交路由
 *
 * <en/> Calculate orthogonal route from node to point
 * @param from - <zh/> 起始点 | <en/> start point
 * @param to - <zh/> 终止点 | <en/> end point
 * @param fromBBox - <zh/> 起始节点的包围盒 | <en/> bounding box of the start node
 * @returns <zh/> 正交路由 | <en/> orthogonal route
 */
export function nodeToPoint(from: Point, to: Point, fromBBox: AABB): Route {
  const p = freeJoin(from, to, fromBBox);

  return { points: [p], direction: getDirection(p, to) };
}

/**
 * <zh/> 从点到节点计算正交路由
 *
 * <en/> Calculate orthogonal route from point to node
 * @param from - <zh/> 起始点 | <en/> start point
 * @param to - <zh/> 终止点 | <en/> end point
 * @param toBBox - <zh/> 终止节点的包围盒 | <en/> bounding box of the end node
 * @param direction - <zh/> 前一条线段的方向 | <en/> direction of the previous segment
 * @returns <zh/> 正交路由 | <en/> orthogonal route
 */
export function pointToNode(from: Point, to: Point, toBBox: AABB, direction: Direction): Route {
  const points: Point[] = [
    [to[0], from[1]],
    [from[0], to[1]],
  ];
  const freePoints = points.filter((p) => isPointOutsideBBox(p, toBBox) && !isPointOnBBoxBoundary(p, toBBox, true));

  const freeDirectionPoints = freePoints.filter((p) => getDirection(p, from) !== direction);

  if (freeDirectionPoints.length > 0) {
    // Pick a point which bears the same direction as the previous segment.
    const p = freeDirectionPoints.find((p) => getDirection(from, p) === direction) || freeDirectionPoints[0];
    return {
      points: [p],
      direction: getDirection(p, to),
    };
  } else {
    // Here we found only points which are either contained in the element or they would create
    // a link segment going in opposites direction from the previous one.
    // We take the point inside element and move it outside the element in the direction the
    // route is going. Now we can join this point with the current end (using freeJoin).
    const p = difference(points, freePoints)[0];
    const p2 = moveTo(to, p, getBBoxSize(toBBox, direction) / 2);
    const p1 = freeJoin(p2, from, toBBox);
    return {
      points: [p1, p2],
      direction: getDirection(p2, to),
    };
  }
}

/**
 * <zh/> 从节点到节点计算正交路由
 *
 * <en/> Calculate orthogonal route from node to node
 * @param from - <zh/> 起始点 | <en/> start point
 * @param to - <zh/> 终止点 | <en/> end point
 * @param fromBBox - <zh/> 起始节点的包围盒 | <en/> bounding box of the start node
 * @param toBBox - <zh/> 终止节点的包围盒 | <en/> bounding box of the end node
 * @returns <zh/> 正交路由 | <en/> orthogonal route
 */
export function nodeToNode(from: Point, to: Point, fromBBox: AABB, toBBox: AABB): Route {
  let route = nodeToPoint(from, to, fromBBox);
  const p1 = toVector3(route.points[0]);

  if (isPointInBBox(p1, toBBox)) {
    route = nodeToPoint(to, from, toBBox);
    const p2 = toVector3(route.points[0]);

    if (isPointInBBox(p2, fromBBox)) {
      const fromBorder = moveTo(from, p1, getBBoxSize(fromBBox, getDirection(from, p1)) / 2);
      const toBorder = moveTo(to, p2, getBBoxSize(toBBox, getDirection(to, p2)) / 2);
      const midPoint: Point = [(fromBorder[0] + toBorder[0]) / 2, (fromBorder[1] + toBorder[1]) / 2];

      const startRoute = nodeToPoint(from, midPoint, fromBBox);
      const endRoute = pointToNode(midPoint, to, toBBox, startRoute.direction);

      route.points = [startRoute.points[0], endRoute.points[0]];
      route.direction = endRoute.direction;
    }
  }
  return route;
}

/**
 * <zh/> 在两个节点内部计算路由
 *
 * <en/> Calculate route inside two nodes
 * @param from - <zh/> 起始点 | <en/> start point
 * @param to - <zh/> 终止点 | <en/> end point
 * @param fromBBox - <zh/> 起始节点的包围盒 | <en/> bounding box of the start node
 * @param toBBox - <zh/> 终止节点的包围盒 | <en/> bounding box of the end node
 * @param direction - <zh/> 方向 | <en/> direction
 * @returns <zh/> 正交路由 | <en/> orthogonal route
 */
export function insideNode(from: Point, to: Point, fromBBox: AABB, toBBox: AABB, direction?: Direction): Route {
  const DEFAULT_OFFSET = 0.01;
  const boundary = getCombinedBBox([fromBBox, toBBox]);
  const reversed = distance(to, boundary.center) > distance(from, boundary.center);
  const [start, end] = reversed ? [to, from] : [from, to];
  const halfPerimeter = getBBoxHeight(boundary) + getBBoxWidth(boundary);

  let p1: Point;
  if (direction) {
    const ref: Point = [
      start[0] + halfPerimeter * Math.cos(radians[direction]),
      start[1] + halfPerimeter * Math.sin(radians[direction]),
    ];
    // `getNearestPointToPoint` returns a point on the boundary, so we need to move it a bit to ensure it's outside the element and then get the correct `p2` via `freeJoin`.
    p1 = moveTo(getNearestPointToPoint(boundary, ref), ref, DEFAULT_OFFSET);
  } else {
    p1 = moveTo(getNearestPointToPoint(boundary, start), start, -DEFAULT_OFFSET);
  }

  let p2 = freeJoin(p1, end, boundary);

  let points = [round(p1, 2), round(p2, 2)];

  if (isEqual(round(p1), round(p2))) {
    const rad = angle(subtract(p1, start), [1, 0, 0]) + Math.PI / 2;
    p2 = [end[0] + halfPerimeter * Math.cos(rad), end[1] + halfPerimeter * Math.sin(rad), 0];
    p2 = round(moveTo(getNearestPointToPoint(boundary, p2), end, -DEFAULT_OFFSET), 2);
    const p3 = freeJoin(p1, p2, boundary);
    points = [p1, p3, p2];
  }

  return {
    points: reversed ? points.reverse() : points,
    direction: reversed ? getDirection(p1, to) : getDirection(p2, to),
  };
}

/**
 * <zh/> 返回一个点 `p`，使得线段 p,p1 和 p,p2 互相垂直，p 尽可能不在给定的包围盒内
 *
 * <en/> Returns a point `p` where lines p,p1 and p,p2 are perpendicular and p is not contained in the given box
 * @param p1 - <zh/> 点 | <en/> point
 * @param p2 - <zh/> 点 | <en/> point
 * @param bbox - <zh/> 包围盒 | <en/> bounding box
 * @returns <zh/> 点 | <en/> point
 */
export function freeJoin(p1: Point, p2: Point, bbox: AABB): Point {
  let p: Point = [p1[0], p2[1]];
  if (isPointInBBox(p, bbox)) {
    p = [p2[0], p1[1]];
  }
  return p;
}

1	import type { AABB } from '@antv/g';
2	import { difference, isEqual } from '@antv/util';	274✔
3	import type { Node, OrthRouterOptions, Point } from '../../types';
4	import {
5	getBBoxHeight,
6	getBBoxWidth,
7	getCombinedBBox,
8	getNearestPointToPoint,
9	getNodeBBox,
10	isPointInBBox,
11	isPointOnBBoxBoundary,
12	isPointOutsideBBox,
13	} from '../bbox';	274✔
14	import { isOrthogonal, moveTo, round } from '../point';	274✔
15	import { angle, distance, subtract, toVector3 } from '../vector';	274✔
16
17	export type Direction = 'N' \| 'S' \| 'W' \| 'E' \| null;
18
19	type Route = {
20	points: Point[];
21	direction: Direction;
22	};
23
24	const defaultOptions: OrthRouterOptions = {	274✔
25	padding: 10,
26	};
27
28	/**
29	* <zh/> 获取两点之间的正交线段路径
30	*
31	* <en/> Get orthogonal line segments between two points
32	* @param sourcePoint - <zh/> 起始点 \| <en/> start point
33	* @param targetPoint - <zh/> 终止点 \| <en/> end point
34	* @param sourceNode - <zh/> 起始节点 \| <en/> source node
35	* @param targetNode - <zh/> 终止节点 \| <en/> target node
36	* @param controlPoints - <zh/> 控制点 \| <en/> control points
37	* @param options - <zh/> 配置项 \| <en/> options
38	* @returns <zh/> 路径点集 \| <en/> vertices
39	*/
40	export function orth(	236✔
41	sourcePoint: Point,
42	targetPoint: Point,
43	sourceNode: Node,
44	targetNode: Node,
45	controlPoints: Point[],
46	options: OrthRouterOptions,
47	) {
48	const { padding } = Object.assign(defaultOptions, options);	236✔
49
50	const sourceBBox = getNodeBBox(sourceNode, padding);	236✔
51	const targetBBox = getNodeBBox(targetNode, padding);	236✔
52
53	const points: Point[] = [sourcePoint, ...controlPoints, targetPoint];	236✔
54
55	// direction of previous route segment
56	let direction: Direction = null;	236✔
57	const result: Point[] = [];	236✔
58
59	for (let fromIdx = 0, len = points.length; fromIdx < len - 1; fromIdx++) {	236✔
60	const toIdx = fromIdx + 1;	258✔
61	const from = points[fromIdx];	258✔
62	const to = points[toIdx];	258✔
63	const isOrth = isOrthogonal(from, to);	258✔
64
65	let route = null;	258✔
66
67	if (fromIdx === 0) {	258✔
68	if (toIdx === len - 1) {	236✔
69	// source -> target
70	if (sourceBBox.intersects(targetBBox)) {	218!
UNCOV 71	route = insideNode(from, to, sourceBBox, targetBBox);	×
72	} else if (!isOrth) {	218✔
73	route = nodeToNode(from, to, sourceBBox, targetBBox);	218✔
74	}
75	} else {
76	// source -> point
77	if (isPointInBBox(to, sourceBBox)) {	18✔
78	route = insideNode(from, to, sourceBBox, getNodeBBox(to, padding), direction);	2✔
79	} else if (!isOrth) {	16✔
80	route = nodeToPoint(from, to, sourceBBox);	14✔
81	}
82	}
83	} else if (toIdx === len - 1) {	22✔
84	// point -> target
85	if (isPointInBBox(from, targetBBox)) {	18✔
86	route = insideNode(from, to, getNodeBBox(from, padding), targetBBox, direction);	6✔
87	} else if (!isOrth) {	12✔
88	route = pointToNode(from, to, targetBBox, direction);	12✔
89	}
90	} else if (!isOrth) {	4✔
91	// point -> point
92	route = pointToPoint(from, to, direction);	2✔
93	}
94
95	// set direction for next iteration
96	if (route) {	258✔
97	result.push(...route.points);	254✔
98	direction = route.direction;	254✔
99	} else {
100	// orthogonal route and not looped
101	direction = getDirection(from, to);	4✔
102	}
103
104	if (toIdx < len - 1) result.push(to);	258✔
105	}
106
107	return result;	236✔
108	}
109
110	/**
111	* Direction to opposites direction map
112	*/
113	const opposites = {	274✔
114	N: 'S',
115	S: 'N',
116	W: 'E',
117	E: 'W',
118	};
119
120	/**
121	* Direction to radians map
122	*/
123	const radians = {	274✔
124	N: -Math.PI / 2,
125	S: Math.PI / 2,
126	E: 0,
127	W: Math.PI,
128	};
129
130	/**
131	* <zh/> 获取两点之间的方向，从 `from` 到 `to` 的方向
132	*
133	* <en/> Get the direction between two points, the direction from `from` to `to`
134	* @param from - <zh/> 起始点 \| <en/> start point
135	* @param to - <zh/> 终止点 \| <en/> end point
136	* @returns <zh/> 方向 \| <en/> direction
137	*/
138	export function getDirection(from: Point, to: Point): Direction \| null {	10✔
139	const [fx, fy] = from;	1,770✔
140	const [tx, ty] = to;	1,770✔
141	if (fx === tx) {	1,770✔
142	return fy > ty ? 'N' : 'S';	668✔
143	}
144	if (fy === ty) {	1,102✔
145	return fx > tx ? 'W' : 'E';	1,096✔
146	}
147	return null;	6✔
148	}
149
150	/**
151	* <zh/> 获取包围盒的尺寸，根据方向返回宽度或者高度
152	*
153	* <en/> Get the size of the bounding box, return the width or height according to the direction
154	* @param bbox - <zh/> 包围盒 \| <en/> bounding box
155	* @param direction - <zh/> 方向 \| <en/> direction
156	* @returns <zh/> 尺寸 \| <en/> size
157	*/
158	export function getBBoxSize(bbox: AABB, direction: Direction): number {	8✔
159	return direction === 'N' \|\| direction === 'S' ? getBBoxHeight(bbox) : getBBoxWidth(bbox);	422✔
160	}
161
162	/**
163	* <zh/> 从一个点到另一个点计算正交路由
164	*
165	* <en/> Calculate orthogonal route from one point to another
166	* @param from - <zh/> 起始点 \| <en/> start point
167	* @param to - <zh/> 终止点 \| <en/> end point
168	* @param direction - <zh/> 前一条线段的方向 \| <en/> direction of the previous segment
169	* @returns <zh/> 正交路由 \| <en/> orthogonal route
170	*/
171	export function pointToPoint(from: Point, to: Point, direction: Direction): Route {	8✔
172	const p1: Point = [from[0], to[1]];	10✔
173	const p2: Point = [to[0], from[1]];	10✔
174	const d1 = getDirection(from, p1);	10✔
175	const d2 = getDirection(from, p2);	10✔
176	const opposite = direction ? opposites[direction] : null;	10!
177	const p = d1 === direction \|\| (d1 !== opposite && d2 !== direction) ? p1 : p2;	10✔
178
179	return { points: [p], direction: getDirection(p, to) };	10✔
180	}
181
182	/**
183	* <zh/> 从节点到点计算正交路由
184	*
185	* <en/> Calculate orthogonal route from node to point
186	* @param from - <zh/> 起始点 \| <en/> start point
187	* @param to - <zh/> 终止点 \| <en/> end point
188	* @param fromBBox - <zh/> 起始节点的包围盒 \| <en/> bounding box of the start node
189	* @returns <zh/> 正交路由 \| <en/> orthogonal route
190	*/
191	export function nodeToPoint(from: Point, to: Point, fromBBox: AABB): Route {	4✔
192	const p = freeJoin(from, to, fromBBox);	646✔
193
194	return { points: [p], direction: getDirection(p, to) };	646✔
195	}
196
197	/**
198	* <zh/> 从点到节点计算正交路由
199	*
200	* <en/> Calculate orthogonal route from point to node
201	* @param from - <zh/> 起始点 \| <en/> start point
202	* @param to - <zh/> 终止点 \| <en/> end point
203	* @param toBBox - <zh/> 终止节点的包围盒 \| <en/> bounding box of the end node
204	* @param direction - <zh/> 前一条线段的方向 \| <en/> direction of the previous segment
205	* @returns <zh/> 正交路由 \| <en/> orthogonal route
206	*/
207	export function pointToNode(from: Point, to: Point, toBBox: AABB, direction: Direction): Route {	2✔
208	const points: Point[] = [	218✔
209	[to[0], from[1]],
210	[from[0], to[1]],
211	];
212	const freePoints = points.filter((p) => isPointOutsideBBox(p, toBBox) && !isPointOnBBoxBoundary(p, toBBox, true));	436✔
213
214	const freeDirectionPoints = freePoints.filter((p) => getDirection(p, from) !== direction);	224✔
215
216	if (freeDirectionPoints.length > 0) {	218✔
217	// Pick a point which bears the same direction as the previous segment.
218	const p = freeDirectionPoints.find((p) => getDirection(from, p) === direction) \|\| freeDirectionPoints[0];	218✔
219	return {	212✔
220	points: [p],
221	direction: getDirection(p, to),
222	};
223	} else {
224	// Here we found only points which are either contained in the element or they would create
225	// a link segment going in opposites direction from the previous one.
226	// We take the point inside element and move it outside the element in the direction the
227	// route is going. Now we can join this point with the current end (using freeJoin).
228	const p = difference(points, freePoints)[0];	6✔
229	const p2 = moveTo(to, p, getBBoxSize(toBBox, direction) / 2);	6✔
230	const p1 = freeJoin(p2, from, toBBox);	6✔
231	return {	6✔
232	points: [p1, p2],
233	direction: getDirection(p2, to),
234	};
235	}
236	}
237
238	/**
239	* <zh/> 从节点到节点计算正交路由
240	*
241	* <en/> Calculate orthogonal route from node to node
242	* @param from - <zh/> 起始点 \| <en/> start point
243	* @param to - <zh/> 终止点 \| <en/> end point
244	* @param fromBBox - <zh/> 起始节点的包围盒 \| <en/> bounding box of the start node
245	* @param toBBox - <zh/> 终止节点的包围盒 \| <en/> bounding box of the end node
246	* @returns <zh/> 正交路由 \| <en/> orthogonal route
247	*/
248	export function nodeToNode(from: Point, to: Point, fromBBox: AABB, toBBox: AABB): Route {	2✔
249	let route = nodeToPoint(from, to, fromBBox);	220✔
250	const p1 = toVector3(route.points[0]);	220✔
251
252	if (isPointInBBox(p1, toBBox)) {	220✔
253	route = nodeToPoint(to, from, toBBox);	204✔
254	const p2 = toVector3(route.points[0]);	204✔
255
256	if (isPointInBBox(p2, fromBBox)) {	204✔
257	const fromBorder = moveTo(from, p1, getBBoxSize(fromBBox, getDirection(from, p1)) / 2);	204✔
258	const toBorder = moveTo(to, p2, getBBoxSize(toBBox, getDirection(to, p2)) / 2);	204✔
259	const midPoint: Point = [(fromBorder[0] + toBorder[0]) / 2, (fromBorder[1] + toBorder[1]) / 2];	204✔
260
261	const startRoute = nodeToPoint(from, midPoint, fromBBox);	204✔
262	const endRoute = pointToNode(midPoint, to, toBBox, startRoute.direction);	204✔
263
264	route.points = [startRoute.points[0], endRoute.points[0]];	204✔
265	route.direction = endRoute.direction;	204✔
266	}
267	}
268	return route;	220✔
269	}
270
271	/**
272	* <zh/> 在两个节点内部计算路由
273	*
274	* <en/> Calculate route inside two nodes
275	* @param from - <zh/> 起始点 \| <en/> start point
276	* @param to - <zh/> 终止点 \| <en/> end point
277	* @param fromBBox - <zh/> 起始节点的包围盒 \| <en/> bounding box of the start node
278	* @param toBBox - <zh/> 终止节点的包围盒 \| <en/> bounding box of the end node
279	* @param direction - <zh/> 方向 \| <en/> direction
280	* @returns <zh/> 正交路由 \| <en/> orthogonal route
281	*/
282	export function insideNode(from: Point, to: Point, fromBBox: AABB, toBBox: AABB, direction?: Direction): Route {	4✔
283	const DEFAULT_OFFSET = 0.01;	12✔
284	const boundary = getCombinedBBox([fromBBox, toBBox]);	12✔
285	const reversed = distance(to, boundary.center) > distance(from, boundary.center);	12✔
286	const [start, end] = reversed ? [to, from] : [from, to];	12✔
287	const halfPerimeter = getBBoxHeight(boundary) + getBBoxWidth(boundary);	12✔
288
289	let p1: Point;
290	if (direction) {	12✔
291	const ref: Point = [	8✔
292	start[0] + halfPerimeter * Math.cos(radians[direction]),
293	start[1] + halfPerimeter * Math.sin(radians[direction]),
294	];
295	// `getNearestPointToPoint` returns a point on the boundary, so we need to move it a bit to ensure it's outside the element and then get the correct `p2` via `freeJoin`.
296	p1 = moveTo(getNearestPointToPoint(boundary, ref), ref, DEFAULT_OFFSET);	8✔
297	} else {
298	p1 = moveTo(getNearestPointToPoint(boundary, start), start, -DEFAULT_OFFSET);	4✔
299	}
300
301	let p2 = freeJoin(p1, end, boundary);	12✔
302
303	let points = [round(p1, 2), round(p2, 2)];	12✔
304
305	if (isEqual(round(p1), round(p2))) {	12✔
306	const rad = angle(subtract(p1, start), [1, 0, 0]) + Math.PI / 2;	2✔
307	p2 = [end[0] + halfPerimeter * Math.cos(rad), end[1] + halfPerimeter * Math.sin(rad), 0];	2✔
308	p2 = round(moveTo(getNearestPointToPoint(boundary, p2), end, -DEFAULT_OFFSET), 2);	2✔
309	const p3 = freeJoin(p1, p2, boundary);	2✔
310	points = [p1, p3, p2];	2✔
311	}
312
313	return {	12✔
314	points: reversed ? points.reverse() : points,	6✔
315	direction: reversed ? getDirection(p1, to) : getDirection(p2, to),	6✔
316	};
317	}
318
319	/**
320	* <zh/> 返回一个点 `p`，使得线段 p,p1 和 p,p2 互相垂直，p 尽可能不在给定的包围盒内
321	*
322	* <en/> Returns a point `p` where lines p,p1 and p,p2 are perpendicular and p is not contained in the given box
323	* @param p1 - <zh/> 点 \| <en/> point
324	* @param p2 - <zh/> 点 \| <en/> point
325	* @param bbox - <zh/> 包围盒 \| <en/> bounding box
326	* @returns <zh/> 点 \| <en/> point
327	*/
328	export function freeJoin(p1: Point, p2: Point, bbox: AABB): Point {	38✔
329	let p: Point = [p1[0], p2[1]];	704✔
330	if (isPointInBBox(p, bbox)) {	704✔
331	p = [p2[0], p1[1]];	46✔
332	}
333	return p;	704✔
334	}

antvis / G6 / 10416400188

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous