/** 路网升层，根据所要升层的层号level，提取符合升层要求的Road 升层条件式样表 */
public List<NodeNew> addTaskData(Network lowerNetwork) {
List<NodeNew> taskBorderNodes = new ArrayList<NodeNew>();
byte level = this.taskData.task.getLevel();
// 式样转换
// this.taskData.network.intersectionList.addAll(taskData.network.intersectionList);
byte threshold = 127; // 升层FRC 最大值
switch (level) {
case 1:
break;
case 2:
threshold = 6;
break;
case 3:
threshold = 4;
break;
case 4:
threshold = 3;
break;
case 5:
threshold = 2;
break;
case 6:
case 7:
return taskBorderNodes;
default:
System.err.println("升层过程中层号出现错误：" + level);
break;
}
// 道路升层
this.raiseRoad(threshold, lowerNetwork.roadList);
// 连接点升层
for (NodeNew node : lowerNetwork.nodeList) {
if (node.roads.size() != 0) {
this.nodeList.add(node);
// 保存任务边界连接点
if (node.isTaskBorderNode(lowerNetwork)) {
taskBorderNodes.add(node);
}
}
}
// 复杂路口升层
for (IntersectionNew intersection : lowerNetwork.intersectionList) {
for (int i = intersection.allNodes.size() - 1; i >= 0; i--) {
NodeNew node = intersection.allNodes.get(i);
if (node.roads.isEmpty()) {
intersection.allNodes.remove(i);
}
}
if (!intersection.allNodes.isEmpty()) {
this.intersectionList.add(intersection);
}
}
return taskBorderNodes;
}
/**
* 根据新产生的Block边界Node分割道路，维护原来路网关系 新产生道路splitRoad
*
* @param road 原道路
* @param index Node产生所在原道路中的位置
* @param splitPoint Node具体位置坐标点
*/
private RoadNew createSplitRoad(
RoadNew road,
int Indexfrom,
int indexTo,
List<ShpPoint> points,
ShpPoint headerSplitPoint,
ShpPoint splitPoint,
ShpPoint nodePoint) {
// 新建Block边界Node
NodeNew blockNode = new NodeNew();
blockNode.point = nodePoint; // 原始坐标
// 创建新的道路形状点
List<ShpPoint> splitPoints =
new ArrayList<ShpPoint>(
points.subList(Indexfrom, indexTo)); // 避免ConcurrentModificationException
if (headerSplitPoint != null) {
splitPoints.add(0, ShpPoint.valueOf(headerSplitPoint));
}
splitPoints.add(ShpPoint.valueOf(splitPoint));
RoadNew splitRoad = new RoadNew();
splitRoad.copy(road);
splitRoad.coordinate = splitPoints;
// 第一个开始点有价值
splitRoad.startAngle30m = road.startAngle30m;
splitRoad.startAngle60m = road.startAngle60m;
// 在合并Rout时需要判断角度
splitRoad.endAngle30m = -90;
splitRoad.endAngle60m = -90;
road.startAngle30m = 90;
road.startAngle60m = 90;
// 建立,维护拓扑关系
splitRoad.startNode = road.startNode;
road.startNode.roads.add(splitRoad);
road.startNode.roads.remove(road);
blockNode.roads.add(splitRoad);
blockNode.roads.add(road);
// road.startNode = splitRoad.endNode = blockNode;
road.startNode = blockNode;
splitRoad.endNode = blockNode;
if (road.fow == defineFOW.JunctionLink) {
road.endNode.intersection.allNodes.add(blockNode);
blockNode.intersection = road.endNode.intersection;
}
this.nodeList.add(blockNode);
return splitRoad;
}
/**
* 由母库数据建立0层路网
*
* @param task
* @param data
* @throws Exception
*/
public void fromDB() throws Exception {
List<String> meshNos = DataManager.getMeshNos(this.taskData.task);
TeleDao teleDao = new TeleDao();
Session session =
TeleHbSessionFactory.getOrgHbSession(this.taskData.task.getLevel()).getSession();
List<NodeNew> meshBorderNodeList = new ArrayList<NodeNew>();
for (String meshNo : meshNos) {
List<Node> node_oList = teleDao.getNodeList(meshNo, session);
List<NodeNew> nodeList = new ArrayList<NodeNew>(node_oList.size());
// 读取关系节点
for (Node node_o : node_oList) {
NodeNew nodeNew = new NodeNew();
nodeNew.convert(node_o);
if (node_o.getByistaskborder() == NodeType.meshBorder) {
meshBorderNodeList.add(nodeNew);
}
nodeList.add(nodeNew);
}
this.nodeList.addAll(nodeList);
Collections.sort(nodeList, comparableNodeId);
// 读取道路
List<Road> roadList = teleDao.getRoadList(meshNo, session);
for (Road road_O : roadList) {
RoadNew road = new RoadNew();
// 属性赋值，正规化计算
road.convert(this, road_O);
this.roadList.add(road);
// 建立拓扑关系
// add node to road
int indexStart = Collections.binarySearch(nodeList, road.startNode, comparableNodeId);
road.startNode = nodeList.get(indexStart);
int indexEnd = Collections.binarySearch(nodeList, road.endNode, comparableNodeId);
road.endNode = nodeList.get(indexEnd);
// add road to node
road.startNode.roads.add(road);
road.endNode.roads.add(road);
}
// 读取复杂路口
List<Intersection_O> intersectionList = teleDao.getIntersectionList(meshNo, session);
for (Intersection_O intersection_O : intersectionList) {
IntersectionNew intersection = new IntersectionNew();
intersection.convert(this, intersection_O);
this.intersectionList.add(intersection);
}
}
// 建立mesh边界的拓扑关系
this.makeBorderTopo(meshBorderNodeList);
//
}
// 该方法是为了保证单个道路的形状点个数少于256 ，从而在格式输出的时候没有问题
void splitRoadByPointCount() {
for (int i = this.roadList.size() - 1; i >= 0; i--) {
RoadNew road = this.roadList.get(i);
for (int count = 0; count < 100; count++) {
if (road.coordinate.size() > 255) {
NodeNew node = new NodeNew();
node.point = ShpPoint.valueOf(road.coordinate.get(254));
RoadNew splitRoad = new RoadNew();
splitRoad.copy(road); // 长度不需要计算 在分割完成后统一重新计算
splitRoad.coordinate.addAll(road.coordinate.subList(0, 254));
splitRoad.coordinate.add(ShpPoint.valueOf(road.coordinate.get(254)));
road.coordinate =
new ArrayList<ShpPoint>(road.coordinate.subList(255, road.coordinate.size()));
// 第一个开始点有价值
splitRoad.startAngle30m = road.startAngle30m;
splitRoad.startAngle60m = road.startAngle60m;
// 在合并Rout时需要判断角度
splitRoad.endAngle30m = -90;
splitRoad.endAngle60m = -90;
road.startAngle30m = 90;
road.startAngle60m = 90;
// 维护拓扑关系
splitRoad.startNode = road.startNode;
splitRoad.endNode = node;
road.startNode = node;
splitRoad.startNode.roads.remove(road);
splitRoad.startNode.roads.add(splitRoad);
node.roads.add(splitRoad);
node.roads.add(road);
this.nodeList.add(node);
this.roadList.add(splitRoad);
} else if (road.coordinate.size() < 2
|| (road.coordinate.size() == 2
&& road.coordinate.get(0).equals(road.coordinate.get(1)))) {
road.delFlag = true;
} else {
break;
}
}
}
}
/**
* 制作mesh边界的拓扑关系
*
* @param bordNodeList ：边界Node列表
*/
public void makeBorderTopo(List<NodeNew> bordNodeList) {
if (bordNodeList.size() == 0) {
return;
}
Collections.sort(
bordNodeList,
new Comparator<NodeNew>() {
@Override
public int compare(NodeNew o1, NodeNew o2) {
if (o1.point.x > o2.point.x) {
return 1;
}
if (o1.point.x < o2.point.x) {
return -1;
}
if (o1.point.y > o2.point.y) {
return 1;
}
if (o1.point.y < o2.point.y) {
return -1;
}
return 0;
}
});
// 合并相同边界Node
NodeNew bordNode = bordNodeList.get(0);
for (int i = 1; i < bordNodeList.size(); i++) {
NodeNew node = bordNodeList.get(i);
// if("97A062A001F0001382".equals(bordNode.nodeId)){
// System.out.println("test");
// }
// 判断合并条件 && // 合并边界点
if (node.point.equals(bordNode.point) && bordNode.mergerBorderNode(node)) {
node.delFlag = true;
// 合并复杂路口对象
// if（复杂路口）
if (node.isIntersectionNode() && bordNode.isIntersectionNode()) {
// 在复杂路口内遍历，找到包含bordNode node
bordNode.intersection.mergerIntersection(node.intersection);
}
} else {
bordNode = node;
}
}
clearRoadList();
clearNodeList();
clearIntersectionList();
}
/**
* 判断是否是block边界
*
* @param node
*/
public void judgeMMblockBordNode(NodeNew node) {
ShpPoint regpoint = taskData.calcRegular(node.point);
if (regpoint.x == 0 || regpoint.x == 255 || regpoint.y == 0 || regpoint.y == 255) {
node.mmBlockBorderNode = true;
}
}
/** mm的block分割 */
public void spliteRoadByMMBlock() {
if (this.roadList == null || this.roadList.size() == 0) {
return;
}
this.taskData.blockInfo = new LevelInfo();
this.taskData.blockInfo.iLevel = 88;
this.taskData.blockInfo.iBlockWidth = 72000;
this.taskData.blockInfo.iBlockHight = 48000;
this.taskData.blockInfo.unitWidth = 9216000;
this.taskData.blockInfo.unitHeight = 6144000;
this.taskData.blockInfo.minScale = 10;
this.taskData.blockInfo.maxScale = 70;
this.taskData.blockInfo.scales = new int[] {10, 20, 50};
this.splitRoadByBlock();
// Map的应用过度啊
// Map<BlockNo, Integer> blockNoCountNum = new HashMap<BlockNo, Integer>();
// for (RoadNew roadNew : this.roadList) {
// if(blockNoCountNum.containsKey(roadNew.blockNo)){
// int num = blockNoCountNum.get(roadNew.blockNo);
// roadNew.blockmmNo = num + 1;
// blockNoCountNum.put(roadNew.blockNo, num + 1);
// }else{
// roadNew.blockmmNo = 0;
// blockNoCountNum.put(roadNew.blockNo, 0);
// }
// }
Collections.sort(
this.roadList,
new Comparator<RoadNew>() {
@Override
public int compare(RoadNew route1, RoadNew route2) {
BlockNo blockNo1 = route1.blockNo;
BlockNo blockNo2 = route2.blockNo;
if (blockNo1.iY == blockNo2.iY) {
return blockNo1.iX - blockNo2.iX;
} else {
return blockNo1.iY - blockNo2.iY;
}
}
});
BlockNo blockNo = this.roadList.get(0).blockNo;
int num = 0;
for (int i = 0; i < this.roadList.size(); i++) {
RoadNew roadNew = this.roadList.get(i);
if (blockNo.equals(roadNew.blockNo)) {
roadNew.blockmmNo = num;
roadNew.mmLineID = getMMLinkID();
num = num + 1;
} else {
blockNo = roadNew.blockNo;
num = 0;
roadNew.blockmmNo = num;
roadNew.mmLineID = getMMLinkID();
num = num + 1;
}
}
List<NodeNew> taskbord = new ArrayList<NodeNew>();
for (NodeNew node : this.nodeList) {
if (node.isTaskBorderNode(this)) {
taskbord.add(node);
}
this.judgeMMblockBordNode(node);
}
Network.putTaskBorderNode(taskbord);
}
// 二叉路合并
public void mergerBinaryRoad() {
for (NodeNew node : nodeList) {
// node只连接两条路
if (node.roads.size() == 2) {
RoadNew roadFirst = node.roads.get(0);
RoadNew roadSecond = node.roads.get(1);
if (node.canMerge() == true) { // 是否可以合并
RoadNew roadMergedFrom = roadSecond; // 被合并掉的道路
RoadNew roadMergedTo = roadFirst; // 合并后的新道路
// 头&头
if (roadFirst.startNode.equals(roadSecond.startNode)) {
// 把点少的道路反转方向
if (roadFirst.coordinate.size() >= roadSecond.coordinate.size()) {
Collections.reverse(roadSecond.coordinate);
roadSecond.coordinate.remove(roadSecond.coordinate.size() - 1);
roadSecond.coordinate.addAll(roadFirst.coordinate);
roadFirst.coordinate = roadSecond.coordinate;
roadFirst.startNode = roadSecond.endNode;
roadFirst.startNode.roads.remove(roadSecond);
roadSecond.delFlag = true;
roadFirst.startNode.roads.add(roadFirst);
roadFirst.startAngle30m = roadSecond.endAngle30m;
roadFirst.startAngle60m = roadSecond.endAngle60m;
} else {
Collections.reverse(roadFirst.coordinate);
roadFirst.coordinate.remove(roadFirst.coordinate.size() - 1);
roadFirst.coordinate.addAll(roadSecond.coordinate);
roadSecond.coordinate = roadFirst.coordinate;
roadSecond.startNode = roadFirst.endNode;
roadSecond.startNode.roads.remove(roadFirst);
roadFirst.delFlag = true;
roadSecond.startNode.roads.add(roadSecond);
roadSecond.startAngle30m = roadFirst.endAngle30m;
roadSecond.startAngle60m = roadFirst.endAngle60m;
roadMergedFrom = roadFirst;
roadMergedTo = roadSecond;
}
// 尾&尾
} else if (roadFirst.endNode.equals(roadSecond.endNode)) {
// 把点少的道路反转方向
if (roadFirst.coordinate.size() >= roadSecond.coordinate.size()) {
Collections.reverse(roadSecond.coordinate);
roadFirst.coordinate.remove(roadFirst.coordinate.size() - 1);
roadFirst.coordinate.addAll(roadSecond.coordinate);
roadFirst.endNode = roadSecond.startNode;
roadFirst.endNode.roads.remove(roadSecond);
roadSecond.delFlag = true;
roadFirst.endNode.roads.add(roadFirst);
roadFirst.endAngle30m = roadSecond.startAngle30m;
roadFirst.endAngle60m = roadSecond.startAngle60m;
} else {
Collections.reverse(roadFirst.coordinate);
roadSecond.coordinate.remove(roadSecond.coordinate.size() - 1);
roadSecond.coordinate.addAll(roadFirst.coordinate);
roadSecond.endNode = roadFirst.startNode;
roadSecond.endNode.roads.remove(roadFirst);
roadFirst.delFlag = true;
roadSecond.endNode.roads.add(roadSecond);
roadSecond.endAngle30m = roadFirst.startAngle30m;
roadSecond.endAngle60m = roadFirst.startAngle60m;
roadMergedFrom = roadFirst;
roadMergedTo = roadSecond;
}
// 头&尾
} else if (roadFirst.startNode.equals(roadSecond.endNode)) {
roadFirst.startNode = roadSecond.startNode;
roadFirst.startNode.roads.remove(roadSecond);
roadSecond.delFlag = true;
roadFirst.startNode.roads.add(roadFirst);
roadSecond.coordinate.remove(roadSecond.coordinate.size() - 1);
roadSecond.coordinate.addAll(roadFirst.coordinate);
roadFirst.coordinate = roadSecond.coordinate;
roadFirst.startAngle30m = roadSecond.startAngle30m;
roadFirst.startAngle60m = roadSecond.startAngle60m;
} else if (roadFirst.endNode.equals(roadSecond.startNode)) {
roadFirst.endNode = roadSecond.endNode;
roadFirst.endNode.roads.remove(roadSecond);
roadSecond.delFlag = true;
roadFirst.endNode.roads.add(roadFirst);
roadFirst.coordinate.remove(roadFirst.coordinate.size() - 1);
roadFirst.coordinate.addAll(roadSecond.coordinate);
roadFirst.endAngle30m = roadSecond.endAngle30m;
roadFirst.endAngle60m = roadSecond.endAngle60m;
} else {
System.err.println("二叉路合并时发生错误!");
}
// 如果roadMergedTo是虚拟道理，要把roadMergedFrom的属性（长度、形状、拓扑关系除外）克隆过来
if (roadMergedTo.fow == defineFOW.JunctionLink) {
roadMergedTo.copy(roadMergedFrom);
}
// 属性赋值
roadMergedTo.length += roadMergedFrom.length;
roadMergedTo.lb.x = Math.min(roadMergedTo.lb.x, roadMergedFrom.lb.x);
roadMergedTo.lb.y = Math.min(roadMergedTo.lb.y, roadMergedFrom.lb.y);
roadMergedTo.rt.x = Math.max(roadMergedTo.rt.x, roadMergedFrom.rt.x);
roadMergedTo.rt.y = Math.max(roadMergedTo.rt.y, roadMergedFrom.rt.y);
// 添加删除标记
node.delFlag = true;
}
}
}
// System.out.println("--------------");
clearRoadList();
clearNodeList();
clearIntersectionList();
}
