Merge remote-tracking branch 'origin/master'

src/graphic/Controls/AddRoad.js

@@ -57,6 +57,7 @@ export default class AddRoad {
       for (let key in parent) {
         if (hasComputerRoadIds.indexOf(key) < 0) {
           roadService.setLanes(key);
+          roadService.setMidDivide(key, parent[key]);
           hasComputerRoadIds.push(key);
         }
       }

src/graphic/Controls/MoveRoad.js

@@ -114,11 +114,6 @@ export default class MoveRoad {
     }
 
     edgeService.updateEdgeForMovePoint(pointId);
-    let parent = point.getParent();
-    for (let key in parent) {
-      roadService.setLanes(key);
-    }
-
     return true;
   }
 
@@ -990,6 +985,7 @@ export default class MoveRoad {
       rightEdge.end.y += dy;
 
       roadService.setLanes(roadId);
+      roadService.setMidDivide(roadId);
     }
   }
 
@@ -1066,9 +1062,6 @@ export default class MoveRoad {
     }
 
     edgeService.updateEdgeForMovePoint(pointId2);
-    for (let key in parent2) {
-      roadService.setLanes(key);
-    }
     return true;
   }
 

src/graphic/Geometry/Road.js

@@ -11,7 +11,7 @@ export default class Road extends Geometry {
     this.rightEdgeId = null;
     this.leftLanes = []; //二维数组。第一维表示第几个车道，第二维是一组点
     this.rightLanes = [];
-    this.midDivide = null; //道路中间隔离栏
+    this.midDivide = null; //道路中间隔离栏 ，起点和终点与startId和endId方向一致。但是坐标有区别。因为隔离栏要比start-end短一些
     this.leftDrivewayCount = 1; //左边的车道个数
     this.rightDrivewayCount = 1; //右边的车道个数
     this.geoType = VectorType.Road;

src/graphic/Layer.js

@@ -441,6 +441,7 @@ export default class Layer {
           let parent = point.getParent();
           for (let key in parent) {
             roadService.setLanes(key);
+            roadService.setMidDivide(key, parent[key]);
           }
           this.history.save();
         }
@@ -545,6 +546,8 @@ export default class Layer {
         edgeService.updateEdgeForMovePoint(road.startId);
         edgeService.updateEdgeForMovePoint(road.endId);
         roadService.setLanes(road.vectorId);
+        roadService.setMidDivideForPointId(road.startId);
+        roadService.setMidDivideForPointId(road.endId);
         this.renderer.autoRedraw();
         this.history.save();
       }
@@ -555,6 +558,8 @@ export default class Layer {
         edgeService.updateEdgeForMovePoint(road.startId);
         edgeService.updateEdgeForMovePoint(road.endId);
         roadService.setLanes(road.vectorId);
+        roadService.setMidDivideForPointId(road.startId);
+        roadService.setMidDivideForPointId(road.endId);
         this.renderer.autoRedraw();
         this.history.save();
       }
@@ -567,6 +572,8 @@ export default class Layer {
             road.leftDrivewayCount + 1,
             "left"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         } else {
           road = dataService.getCurveRoad(focusItem.vectorId);
           curveRoadService.updateForAddSubtractLanesCount(
@@ -574,6 +581,8 @@ export default class Layer {
             road.leftDrivewayCount + 1, //rightDrivewayCount
             "left"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         }
         this.renderer.autoRedraw();
         this.history.save();
@@ -587,6 +596,8 @@ export default class Layer {
             road.leftDrivewayCount - 1,
             "left"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         } else {
           road = dataService.getCurveRoad(focusItem.vectorId);
           curveRoadService.updateForAddSubtractLanesCount(
@@ -594,6 +605,8 @@ export default class Layer {
             road.leftDrivewayCount - 1, //rightDrivewayCount
             "left"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         }
         this.renderer.autoRedraw();
         this.history.save();
@@ -607,6 +620,8 @@ export default class Layer {
             road.rightDrivewayCount + 1,
             "right"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         } else {
           road = dataService.getCurveRoad(focusItem.vectorId);
           curveRoadService.updateForAddSubtractLanesCount(
@@ -614,6 +629,8 @@ export default class Layer {
             road.rightDrivewayCount + 1, //rightDrivewayCount
             "right"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         }
         this.renderer.autoRedraw();
         this.history.save();
@@ -627,6 +644,8 @@ export default class Layer {
             road.rightDrivewayCount - 1,
             "right"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         } else {
           road = dataService.getCurveRoad(focusItem.vectorId);
           curveRoadService.updateForAddSubtractLanesCount(
@@ -634,6 +653,8 @@ export default class Layer {
             road.rightDrivewayCount - 1, //rightDrivewayCount
             "right"
           );
+          roadService.setMidDivideForPointId(road.startId);
+          roadService.setMidDivideForPointId(road.endId);
         }
         this.renderer.autoRedraw();
         this.history.save();

src/graphic/Service/CurveRoadService.js

@@ -152,20 +152,20 @@ export default class CurveRoadService extends RoadService {
 
     const len = points.length;
     let leftdx1 = leftEdgePoints[0].x - points[0].x;
-    leftdx1 = leftdx1 / leftCount;
+    leftdx1 = leftdx1 / (leftCount + 1);
 
     let leftdy1 = leftEdgePoints[0].y - points[0].y;
-    leftdy1 = leftdy1 / leftCount;
+    leftdy1 = leftdy1 / (leftCount + 1);
 
     let leftdx2 =
       leftEdgePoints[leftEdgePoints.length - 1].x - points[len - 1].x;
-    leftdx2 = leftdx2 / leftCount;
+    leftdx2 = leftdx2 / (leftCount + 1);
 
     let leftdy2 =
       leftEdgePoints[leftEdgePoints.length - 1].y - points[len - 1].y;
-    leftdy2 = leftdy2 / leftCount;
+    leftdy2 = leftdy2 / (leftCount + 1);
 
-    for (let i = 0; i < leftCount - 1; ++i) {
+    for (let i = 0; i < leftCount; ++i) {
       for (let j = 0; j < points.length; ++j) {
         if (!leftLanes[i]) {
           leftLanes[i] = [];
@@ -181,7 +181,7 @@ export default class CurveRoadService extends RoadService {
           let edgePoints1 = mathUtil.RectangleVertex(
             points[j],
             points[j - 1],
-            leftdx1 * (i + 1)
+            ((leftEdgePoints[j].x - points[j].x) / (leftCount + 1)) * (i + 1)
           );
           let line1 = mathUtil.createLine1(
             edgePoints1.leftEdgeStart,
@@ -191,7 +191,7 @@ export default class CurveRoadService extends RoadService {
           let edgePoints2 = mathUtil.RectangleVertex(
             points[j],
             points[j + 1],
-            leftdx1 * (i + 1)
+            ((leftEdgePoints[j].x - points[j].x) / (leftCount + 1)) * (i + 1)
           );
           let line2 = mathUtil.createLine1(
             edgePoints2.leftEdgeStart,
@@ -209,20 +209,20 @@ export default class CurveRoadService extends RoadService {
     }
 
     let rightdx1 = rightEdgePoints[0].x - points[0].x;
-    rightdx1 = rightdx1 / rightCount;
+    rightdx1 = rightdx1 / (rightCount + 1);
 
     let rightdy1 = rightEdgePoints[0].y - points[0].y;
-    rightdy1 = rightdy1 / rightCount;
+    rightdy1 = rightdy1 / (rightCount + 1);
 
     let rightdx2 =
       rightEdgePoints[rightEdgePoints.length - 1].x - points[len - 1].x;
-    rightdx2 = rightdx2 / rightCount;
+    rightdx2 = rightdx2 / (rightCount + 1);
 
     let rightdy2 =
       rightEdgePoints[rightEdgePoints.length - 1].y - points[len - 1].y;
-    rightdy2 = rightdy2 / rightCount;
+    rightdy2 = rightdy2 / (rightCount + 1);
 
-    for (let i = 0; i < rightCount - 1; ++i) {
+    for (let i = 0; i < rightCount; ++i) {
       for (let j = 0; j < points.length; ++j) {
         if (!rightLanes[i]) {
           rightLanes[i] = [];
@@ -238,7 +238,7 @@ export default class CurveRoadService extends RoadService {
           let edgePoints1 = mathUtil.RectangleVertex(
             points[j],
             points[j - 1],
-            rightdx1 * (i + 1)
+            ((rightEdgePoints[j].x - points[j].x) / (rightCount + 1)) * (i + 1)
           );
           let line1 = mathUtil.createLine1(
             edgePoints1.rightEdgeStart,
@@ -248,7 +248,7 @@ export default class CurveRoadService extends RoadService {
           let edgePoints2 = mathUtil.RectangleVertex(
             points[j],
             points[j + 1],
-            rightdx1 * (i + 1)
+            ((rightEdgePoints[j].x - points[j].x) / (rightCount + 1)) * (i + 1)
           );
           let line2 = mathUtil.createLine1(
             edgePoints2.rightEdgeStart,

src/graphic/Service/EdgeService.js

@@ -798,10 +798,13 @@ export default class EdgeService {
       let dir = roadService.getDirction(pointId, Object.keys(parent)[0]);
       this.updateDefaultEdge(Object.keys(parent)[0], dir);
       roadService.setLanes(Object.keys(parent)[0], dir);
+      roadService.setMidDivide(Object.keys(parent)[0], dir);
     } else if (Object.keys(parent).length == 2) {
       this.updateEdgeForTwoRoad(Object.keys(parent)[0], Object.keys(parent)[1]);
       roadService.setLanes(Object.keys(parent)[0]);
+      roadService.setMidDivide(Object.keys(parent)[0]);
       roadService.setLanes(Object.keys(parent)[1]);
+      roadService.setMidDivide(Object.keys(parent)[1]);
     } else if (Object.keys(parent).length > 2) {
       //起始墙:Object.keys(parent)[0]
       //开始
@@ -833,10 +836,27 @@ export default class EdgeService {
         this.updateSingleEdgeForTwoRoad(startRoadId, info.min1.roadId);
         startRoadId = info.min1.roadId;
         info = roadService.roadIdForMinAngle(pointId, startRoadId);
+
+        dir = roadService.getDirction(pointId, startRoadId);
+        roadService.setLanes(startRoadId, dir);
+        roadService.setMidDivide(startRoadId, dir);
         ++count;
       }
       this.updateSingleEdgeForTwoRoad(startRoadId, endRoadId);
+      dir = roadService.getDirction(pointId, startRoadId);
+      roadService.setLanes(startRoadId, dir);
+      roadService.setMidDivide(startRoadId, dir);
+      dir = roadService.getDirction(pointId, endRoadId);
+      roadService.setLanes(endRoadId, dir);
+      roadService.setMidDivide(endRoadId, dir);
+
       this.updateSingleEdgeForTwoRoad(endRoadId, _startRoadId);
+      dir = roadService.getDirction(pointId, endRoadId);
+      roadService.setLanes(endRoadId, dir);
+      roadService.setMidDivide(endRoadId, dir);
+      dir = roadService.getDirction(pointId, _startRoadId);
+      roadService.setLanes(_startRoadId, dir);
+      roadService.setMidDivide(_startRoadId, dir);
     } else {
       console.error(
         "updateEdgeForMulRoad***********************************************************************2"

src/graphic/Service/RoadService.js

@@ -40,7 +40,7 @@ export default class RoadService {
       leftEdge.setEdgeParent(road.vectorId);
       rightEdge.setEdgeParent(road.vectorId);
     }
-
+    this.setMidDivide(road.vectorId);
     this.setLanes(road.vectorId);
     return road;
   }
@@ -517,7 +517,8 @@ export default class RoadService {
     this.setRoadPointId(roadId, pointId, dir);
     // 第四步更新Edge
     edgeService.updateDefaultEdge(roadId, dir);
-    roadService.setLanes(roadId, dir);
+    this.setLanes(roadId, dir);
+    this.setMidDivide(roadId, dir);
   }
 
   setRoadPointId = function (roadId, pointId, dir) {
@@ -825,6 +826,64 @@ export default class RoadService {
   //   }
   // }
 
+  //设置中间带
+  setMidDivide(roadId, dir) {
+    const road = dataService.getRoad(roadId);
+    const startPoint = dataService.getPoint(road.startId);
+    const endPoint = dataService.getPoint(road.endId);
+    const leftEdge = dataService.getEdge(road.leftEdgeId);
+    const rightEdge = dataService.getEdge(road.rightEdgeId);
+
+    //离中心最近的点才是中间带的起点和终点
+    const mid = {
+      x: (startPoint.x + endPoint.x) / 2,
+      y: (startPoint.y + endPoint.y) / 2,
+    };
+    const line = this.getMidLine(road);
+    const startJoin1 = mathUtil.getJoinLinePoint(leftEdge.start, line);
+    const startJoin2 = mathUtil.getJoinLinePoint(rightEdge.start, line);
+    const distance1 = mathUtil.getDistance(startJoin1, mid);
+    const distance2 = mathUtil.getDistance(startJoin2, mid);
+    if (!dir || dir == "start") {
+      if (distance1 > distance2) {
+        road.midDivide.start = {
+          x: startJoin2.x,
+          y: startJoin2.y,
+        };
+      } else {
+        road.midDivide.start = {
+          x: startJoin1.x,
+          y: startJoin1.y,
+        };
+      }
+    }
+
+    const endJoin1 = mathUtil.getJoinLinePoint(leftEdge.end, line);
+    const endJoin2 = mathUtil.getJoinLinePoint(rightEdge.end, line);
+    const distance3 = mathUtil.getDistance(endJoin1, mid);
+    const distance4 = mathUtil.getDistance(endJoin2, mid);
+    if (!dir || dir == "end") {
+      if (distance3 > distance4) {
+        road.midDivide.start = {
+          x: endJoin2.x,
+          y: endJoin2.y,
+        };
+      } else {
+        road.midDivide.start = {
+          x: endJoin1.x,
+          y: endJoin1.y,
+        };
+      }
+    }
+  }
+
+  setMidDivideForPointId(pointId) {
+    const point = dataService.getPoint(pointId);
+    for (let key in point.parent) {
+      this.setMidDivide(key, point.parent[key]);
+    }
+  }
+
   //设置车道
   setLanes(roadId, dir) {
     let road = dataService.getRoad(roadId);
@@ -858,15 +917,6 @@ export default class RoadService {
     //   point2 = _point2;
     // }
 
-    road.midDivide = {
-      start: {},
-      end: {},
-      display: true,
-    };
-
-    mathUtil.clonePoint(road.midDivide.start, startPoint);
-    mathUtil.clonePoint(road.midDivide.end, endPoint);
-
     let leftdx1 = leftEdge.start.x - startPoint.x;
     leftdx1 = leftdx1 / leftCount;
 
@@ -938,64 +988,63 @@ export default class RoadService {
     let dx1, dy1, dx2, dy2, oldCount, lanes, edgeStartPosition, edgeEndPosition;
     let road = dataService.getRoad(roadId);
     if (newCount == 0) {
-      road.midDivide.display = false;
+      //需要添加隐藏隔离栏
       return;
     }
+    let startPoint = dataService.getPoint(road.startId);
+    let endPoint = dataService.getPoint(road.endId);
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
 
     if (dir == "left") {
-      oldCount = road.leftDrivewayCount;
+      oldCount = road.leftDrivewayCount + 1;
       if (oldCount != 0) {
-        dx1 = leftEdge.start.x - road.midDivide.start.x;
+        dx1 = leftEdge.start.x - startPoint.x;
         dx1 = dx1 / oldCount;
-        dy1 = leftEdge.start.y - road.midDivide.start.y;
+        dy1 = leftEdge.start.y - startPoint.y;
         dy1 = dy1 / oldCount;
 
-        dx2 = leftEdge.end.x - road.midDivide.end.x;
+        dx2 = leftEdge.end.x - endPoint.x;
         dx2 = dx2 / oldCount;
-        dy2 = leftEdge.end.y - road.midDivide.end.y;
+        dy2 = leftEdge.end.y - endPoint.y;
         dy2 = dy2 / oldCount;
-        road.midDivide.display = true;
+        //road.midDivide.display = true;
       }
     } else if (dir == "right") {
-      oldCount = road.rightDrivewayCount;
+      oldCount = road.rightDrivewayCount + 1;
       if (oldCount != 0) {
-        dx1 = rightEdge.start.x - road.midDivide.start.x;
+        dx1 = rightEdge.start.x - startPoint.x;
         dx1 = dx1 / oldCount;
-        dy1 = rightEdge.start.y - road.midDivide.start.y;
+        dy1 = rightEdge.start.y - startPoint.y;
         dy1 = dy1 / oldCount;
 
-        dx2 = rightEdge.end.x - road.midDivide.end.x;
+        dx2 = rightEdge.end.x - endPoint.x;
         dx2 = dx2 / oldCount;
-        dy2 = rightEdge.end.y - road.midDivide.end.y;
+        dy2 = rightEdge.end.y - endPoint.y;
         dy2 = dy2 / oldCount;
-        road.midDivide.display = true;
+        //road.midDivide.display = true;
       }
     }
 
     lanes = [];
     for (let i = 0; i < newCount; ++i) {
-      if (i == newCount - 1) {
-        edgeStartPosition = {
-          x: road.midDivide.start.x + dx1 * newCount,
-          y: road.midDivide.start.y + dy1 * newCount,
-        };
-        edgeEndPosition = {
-          x: road.midDivide.end.x + dx2 * newCount,
-          y: road.midDivide.end.y + dy2 * newCount,
-        };
-      } else {
-        lanes[i] = {};
-        lanes[i].start = {};
-        lanes[i].start.x = road.midDivide.start.x + dx1 * (i + 1);
-        lanes[i].start.y = road.midDivide.start.y + dy1 * (i + 1);
-
-        lanes[i].end = {};
-        lanes[i].end.x = road.midDivide.end.x + dx2 * (i + 1);
-        lanes[i].end.y = road.midDivide.end.y + dy2 * (i + 1);
-      }
+      lanes[i] = {};
+      lanes[i].start = {};
+      lanes[i].start.x = startPoint.x + dx1 * (i + 1);
+      lanes[i].start.y = startPoint.y + dy1 * (i + 1);
+
+      lanes[i].end = {};
+      lanes[i].end.x = endPoint.x + dx2 * (i + 1);
+      lanes[i].end.y = endPoint.y + dy2 * (i + 1);
     }
+    edgeStartPosition = {
+      x: startPoint.x + dx1 * (newCount + 1),
+      y: startPoint.y + dy1 * (newCount + 1),
+    };
+    edgeEndPosition = {
+      x: endPoint.x + dx2 * (newCount + 1),
+      y: endPoint.y + dy2 * (newCount + 1),
+    };
 
     if (dir == "left") {
       road.leftLanes = lanes;