GEF连线优化 支持额外检测功能的存储线路径的PointList（合并同终点线，分离重合线）

还存在一些问题 需要不断的优化

PointList 是存储线路径的集合 也是寻路算法router的最终输出结果

如果额外考虑线与线之间的相互影响 则会进一步提高画面的显示效果

我原创的CheckPointList可以支持一些对线间关系的相互处理 注：只是针对于水平，竖直四方向的对线处理线

具体支持的机制如下：

1.支持同终点的连线如果在行进时如果靠的很近，则自动合并。

2.如果是终点不同的连线 则可以将重合的线 进行平移。

3.将直角弯进行圆弧处理，（现在的代码只是最后一个直角弯）

完整代码如下：

import java.util.ArrayList;
import java.util.List;

import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;

@SuppressWarnings("serial")
public class CheckedPointList2 extends PointList {

// 检测为重合的距离
private int CHECK_DISTANCE = 2;
// X方向重合 X方向偏转的距离
private int LINE_OFFSET_X = 1;
// Y方向重合和偏转距离
private int LINE_OFFSET_Y = 1;
// 机制开关
private boolean on_off = true;
// 顺路开关
private boolean on_the_way = false;

/****** shoulder *******************************************************/
// 肩膀开关
private boolean shoulder_on_off = true;
// shoulder x偏移量
private int SHOULDER_OFFSET_X = 3;
// shoulder y偏移量
private int SHOULDER_OFFSET_Y = 3;
/****** bridge *******************************************************/
// bridge 开关
private Connection conn;
// 其他的线
private List<Connection> othersConnections = new ArrayList<Connection>();
// 记录终点 为顺路提供服务 顺路开关关闭就无需关注了
private Point endPoint;
// 候选添加的点
private Point caditatePoint;
// 已经添加到List中的最后的点 这个点是可以改变的
private Point lastPoint;

public void setConn(Connection conn) {
this.conn = conn;
refreshConnections();
}

public void setOnOffMergeLine(boolean on_off_MergeLine) {
on_the_way = on_off_MergeLine;
}

public void setEndPoint(Point endPoint) {
this.endPoint = endPoint;
}

@SuppressWarnings("unchecked")
// 刷新其他线的数据
public void refreshConnections() {
othersConnections.clear();
List<Connection> allConnections = conn.getParent().getChildren();
for (int i = 0; i < allConnections.size(); i++) {
// 由于不能跟自己比较位置 所以移除自己
if (allConnections.get(i) != conn) {
othersConnections.add(allConnections.get(i));
}
}
}

// 添加候选点
public void addCandidatePoint(Point point) {
addCandidatePoint(point.x, point.y);
}

public void addCandidatePoint(int x, int y) {
caditatePoint = new Point(x, y);
// 如果这是增加的第一或者第二个点,就不用检测了
// 如果这是增加的第一条线就不用了
if (othersConnections.size() == 0 || size() < 2) {
addPoint(caditatePoint);
} else// 需要校验
{
// 取出最后一个
lastPoint = getLastPoint();
removePoint(size() - 1);
if (on_off) {
if (lastPoint.x == caditatePoint.x) {
checkCaditateX();
} else if (lastPoint.y == caditatePoint.y) {
checkCaditateY();
}
}
addCheckedPoints();
}
}

// 最后点和候选点通过了检验 添加到list中
private void addCheckedPoints() {
addPoint(lastPoint);
addPoint(caditatePoint);
}

// 检测准备添加的线的点是否和已有线重叠 X方向
private void checkCaditateX() {
// 由于线只有水平竖直两种情况 所以可以区分添加线的类型
// 遍历已有的线
for (int i = 0; i < othersConnections.size(); i++) {
Connection conn = othersConnections.get(i);
// 获取线的所有的点
PointList pointList = conn.getPoints();
// 遍历线的所有的点
// -1的原因是避免溢出 由于线是水平竖直的 所以相邻点必然是X相同,或是Y相同 我们关注的是两个点的X和检测的点的X相同
// 一个点命中无意义 所以无需检测最后一个
for (int j = 0; j < pointList.size() - 1; j++) {
// 由于只有x相同才可能存在重叠 更准确的说是两个相邻的点的x相同
if (Math.abs(pointList.getPoint(j).x - lastPoint.x) <= CHECK_DISTANCE
&& pointList.getPoint(j).x == pointList.getPoint(j + 1).x)// 这个判断是为了当线与桥重合时,不用来判断为重合
{
// 更加详细的判断
// 排序
int y1 = Math.min(pointList.getPoint(j).y, pointList.getPoint(j + 1).y);
int y2 = Math.max(pointList.getPoint(j).y, pointList.getPoint(j + 1).y);
int y3 = Math.min(lastPoint.y, caditatePoint.y);
int y4 = Math.max(lastPoint.y, caditatePoint.y);
// 竖直位置相同但不重叠
if (y1 > y4 || y2 < y3) {
break;
} else // 重叠调整位置
{
// 检测是否顺路 如果顺路就停止遍历 并且调整到已有路线的位置
if (on_the_way) {
if (endPoint.equals(pointList.getLastPoint().x, pointList.getLastPoint().y)) {
lastPoint.x = pointList.getPoint(j).x;
caditatePoint.x = pointList.getPoint(j).x;
return;
}
}

// 延续已有的方向 偏移
Point frontLastPoint = getLastPoint();
// x增大的趋势
if (frontLastPoint.x < lastPoint.x) {
// 右移
lastPoint.x += LINE_OFFSET_X;
caditatePoint.x += LINE_OFFSET_X;
} else {
// 左移
lastPoint.x -= LINE_OFFSET_X;
caditatePoint.x -= LINE_OFFSET_X;
}
// 递归检测新位置 是否有重叠
checkCaditateX();
}

}
}
}
}

// 检测准备添加的线的点是否和已有线重叠 Y方向
private void checkCaditateY() {
// 遍历已有的线
for (int i = 0; i < othersConnections.size(); i++) {
Connection conn = othersConnections.get(i);
// 判断已有的线是否存在重叠
PointList pointList = conn.getPoints();
// 遍历线的所有的点
for (int j = 0; j < pointList.size() - 1; j++) {
// 由于只有x相同才可能存在重叠 更准确的说是两个相邻的点的x相同
if (Math.abs(pointList.getPoint(j).y - lastPoint.y) <= CHECK_DISTANCE
&& pointList.getPoint(j).y == pointList.getPoint(j + 1).y) {
// 更加详细的判断
// 排序
int x1 = Math.min(pointList.getPoint(j).x, pointList.getPoint(j + 1).x);
int x2 = Math.max(pointList.getPoint(j).x, pointList.getPoint(j + 1).x);
int x3 = Math.min(lastPoint.x, caditatePoint.x);
int x4 = Math.max(lastPoint.x, caditatePoint.x);
// 竖直位置相同但不重叠
if (x1 > x4 || x2 < x3) {
break;
} else // 重叠调整位置
{
// 检测是否顺路 如果顺路就停止遍历 并且调整到已有路线的位置
if (on_the_way) {
if (endPoint.equals(pointList.getLastPoint().x, pointList.getLastPoint().y)) {
lastPoint.y = pointList.getPoint(j).y;
caditatePoint.y = pointList.getPoint(j).y;
return;
}
}
// 延续已有的方向 偏移
Point frontLastPoint = getLastPoint();
if (frontLastPoint.y < lastPoint.y) {
// 下移
lastPoint.y += LINE_OFFSET_Y;
caditatePoint.y += LINE_OFFSET_Y;
} else {
// 上移
lastPoint.y -= LINE_OFFSET_Y;
caditatePoint.y -= LINE_OFFSET_Y;
}
checkCaditateY();
}

}
}
}
}

// shoulder的意思是最后到达终点前避免直角弯 而且提供一个过渡
public void addShoulder() {
if (shoulder_on_off == false) {
return;
}
// 如果是直上直下则不用
if (size() > 2) {
// 取出后三个点 删除后两个点
int size = size();
Point frontPoint = getPoint(size - 3);
Point middlePoint = getPoint(size - 2);
Point lastPoint = getPoint(size - 1);
// 只有竖直进入的情况
if (lastPoint.x == middlePoint.x && Math.abs(frontPoint.x - middlePoint.x) >= SHOULDER_OFFSET_X) // 安全监测
{
Point middleFrontPoint = middlePoint.getCopy();
if (frontPoint.x < middlePoint.x) // "7"形状
{
// 左移动两个像素
middleFrontPoint.x = middlePoint.x - SHOULDER_OFFSET_X;
} else {
// 右移动两个像素
middleFrontPoint.x = middlePoint.x + SHOULDER_OFFSET_X;
}
// 移除原有拐点
removePoint(size - 2);
// 添加中前点
insertPoint(middleFrontPoint, size - 2);
Point middleNextPoint = middlePoint.getCopy();
middleNextPoint.y = middlePoint.y + SHOULDER_OFFSET_Y;
// 添加中后点
insertPoint(middleNextPoint, size - 1);
}
}
}
}

使用方式 和需要的基本数据

private CheckedPointList2 points = new CheckedPointList2();
@Override
public void route(Connection conn) {
// 1. prepare
startPoint = getStartPoint(conn).getCopy();
endPoint = getEndPoint(conn).getCopy();
points.removeAllPoints();
points.setConn(conn);
points.setOnOffMergeLine(on_off_MergeLine);
points.setEndPoint(endPoint);
points.addPoint(startPoint);
 .....
}

添加需要进行检测的点

points.addCandidatePoint(x,y);//或 points.addCandidatePoint(new Point(x,y));

为最后直角弯添加 肩膀 发生在endPoint 已经被添加之后

points.addPoint(endPoint);
points.addShoulder();