拆分道路后，样式保持。

src/graphic/Service/RoadService.js

@@ -26,13 +26,31 @@ export default class RoadService {
 
     let edgePoints;
     if (road.way == Constant.oneWay) {
-      edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, road.singleRoadWidth);
+      edgePoints = mathUtil.RectangleVertex(
+        startPoint,
+        endPoint,
+        road.singleRoadWidth
+      );
     } else {
-      edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, road.leftWidth + road.rightWidth + road.midDivide.midDivideWidth);
+      edgePoints = mathUtil.RectangleVertex(
+        startPoint,
+        endPoint,
+        road.leftWidth + road.rightWidth + road.midDivide.midDivideWidth
+      );
     }
-    let leftEdge = edgeService.create(edgePoints.leftEdgeStart, edgePoints.leftEdgeEnd, null, vectorId);
-
-    let rightEdge = edgeService.create(edgePoints.rightEdgeStart, edgePoints.rightEdgeEnd, null, vectorId);
+    let leftEdge = edgeService.create(
+      edgePoints.leftEdgeStart,
+      edgePoints.leftEdgeEnd,
+      null,
+      vectorId
+    );
+
+    let rightEdge = edgeService.create(
+      edgePoints.rightEdgeStart,
+      edgePoints.rightEdgeEnd,
+      null,
+      vectorId
+    );
 
     road.setLeftEdge(leftEdge.vectorId);
     road.setRightEdge(rightEdge.vectorId);
@@ -82,13 +100,31 @@ export default class RoadService {
 
     let edgePoints;
     if (newRoad.way == Constant.oneWay) {
-      edgePoints = mathUtil.RectangleVertex(newStartPoint, newEndPoint, road.singleRoadWidth);
+      edgePoints = mathUtil.RectangleVertex(
+        newStartPoint,
+        newEndPoint,
+        road.singleRoadWidth
+      );
     } else {
-      edgePoints = mathUtil.RectangleVertex(newStartPoint, newEndPoint, road.leftWidth + road.rightWidth + road.midDivide.midDivideWidth);
+      edgePoints = mathUtil.RectangleVertex(
+        newStartPoint,
+        newEndPoint,
+        road.leftWidth + road.rightWidth + road.midDivide.midDivideWidth
+      );
     }
-    let leftEdge = edgeService.create(edgePoints.leftEdgeStart, edgePoints.leftEdgeEnd, null, vectorId);
-
-    let rightEdge = edgeService.create(edgePoints.rightEdgeStart, edgePoints.rightEdgeEnd, null, vectorId);
+    let leftEdge = edgeService.create(
+      edgePoints.leftEdgeStart,
+      edgePoints.leftEdgeEnd,
+      null,
+      vectorId
+    );
+
+    let rightEdge = edgeService.create(
+      edgePoints.rightEdgeStart,
+      edgePoints.rightEdgeEnd,
+      null,
+      vectorId
+    );
 
     newRoad.setLeftEdge(leftEdge.vectorId);
     newRoad.setRightEdge(rightEdge.vectorId);
@@ -141,7 +177,10 @@ export default class RoadService {
     const startPoint = dataService.getRoadPoint(road.startId);
     const endPoint = dataService.getRoadPoint(road.endId);
     const point = dataService.getRoadPoint(pointId);
-    if (mathUtil.getDistance(startPoint, point) < Constant.minAdsorbPix || mathUtil.getDistance(endPoint, point) < Constant.minAdsorbPix) {
+    if (
+      mathUtil.getDistance(startPoint, point) < Constant.minAdsorbPix ||
+      mathUtil.getDistance(endPoint, point) < Constant.minAdsorbPix
+    ) {
     }
 
     let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
@@ -201,13 +240,19 @@ export default class RoadService {
       crossPointService.replaceEdgeId(cpt, road.leftEdgeId, newRoad.leftEdgeId);
 
       cpt = dataService.getCrossPointForEdgeId(road.rightEdgeId, "end");
-      crossPointService.replaceEdgeId(cpt, road.rightEdgeId, newRoad.rightEdgeId);
+      crossPointService.replaceEdgeId(
+        cpt,
+        road.rightEdgeId,
+        newRoad.rightEdgeId
+      );
 
       let newRoadLeftEdge = dataService.getRoadEdge(newRoad.leftEdgeId);
       mathUtil.clonePoint(newRoadLeftEdge.end, oldLeftEdgeEndPoint);
+      //newRoadLeftEdge.roadSide = leftEdge.roadSide;
 
       let newRoadRightEdge = dataService.getRoadEdge(newRoad.rightEdgeId);
       mathUtil.clonePoint(newRoadRightEdge.end, oldRightEdgeEndPoint);
+      //newRoadRightEdge.roadSide = rightEdge.roadSide;
 
       if (Object.keys(startPoint).length > 1) {
         mathUtil.clonePoint(leftEdge.start, oldLeftEdgeStartPoint);
@@ -218,13 +263,19 @@ export default class RoadService {
       crossPointService.replaceEdgeId(cpt, road.leftEdgeId, newRoad.leftEdgeId);
 
       cpt = dataService.getCrossPointForEdgeId(road.rightEdgeId, "start");
-      crossPointService.replaceEdgeId(cpt, road.rightEdgeId, newRoad.rightEdgeId);
+      crossPointService.replaceEdgeId(
+        cpt,
+        road.rightEdgeId,
+        newRoad.rightEdgeId
+      );
 
       let newRoadLeftEdge = dataService.getRoadEdge(newRoad.leftEdgeId);
       mathUtil.clonePoint(newRoadLeftEdge.start, oldLeftEdgeStartPoint);
+      //newRoadLeftEdge.roadSide = leftEdge.roadSide;
 
       let newRoadRightEdge = dataService.getRoadEdge(newRoad.rightEdgeId);
       mathUtil.clonePoint(newRoadRightEdge.start, oldRightEdgeStartPoint);
+      //newRoadRightEdge.roadSide = rightEdge.roadSide;
 
       if (Object.keys(endPoint).length > 1) {
         mathUtil.clonePoint(leftEdge.end, oldLeftEdgeEndPoint);
@@ -295,7 +346,12 @@ export default class RoadService {
     const road1 = dataService.getRoad(id1);
     const road2 = dataService.getRoad(id2);
 
-    if (road1 == null || road2 == null || typeof road1 === "undefined" || typeof road2 === "undefined") {
+    if (
+      road1 == null ||
+      road2 == null ||
+      typeof road1 === "undefined" ||
+      typeof road2 === "undefined"
+    ) {
       return null;
     }
 
@@ -346,7 +402,12 @@ export default class RoadService {
     const road1 = dataService.getRoad(id1);
     const road2 = dataService.getRoad(id2);
 
-    if (road1 == null || road2 == null || typeof road1 === "undefined" || typeof road2 === "undefined") {
+    if (
+      road1 == null ||
+      road2 == null ||
+      typeof road1 === "undefined" ||
+      typeof road2 === "undefined"
+    ) {
       return null;
     }
 
@@ -401,7 +462,12 @@ export default class RoadService {
     const road1 = dataService.getRoad(id1);
     const road2 = dataService.getRoad(id2);
 
-    if (road1 == null || road2 == null || typeof road1 === "undefined" || typeof road2 === "undefined") {
+    if (
+      road1 == null ||
+      road2 == null ||
+      typeof road1 === "undefined" ||
+      typeof road2 === "undefined"
+    ) {
       return null;
     }
 
@@ -440,7 +506,9 @@ export default class RoadService {
       _start1.y = start1.y + end2.y - end1.y;
       return mathUtil.Angle(end2, _start1, start2);
     } else {
-      console.error("RoadService.AngleForRoad3************************************1");
+      console.error(
+        "RoadService.AngleForRoad3************************************1"
+      );
       return null;
     }
   }
@@ -518,7 +586,9 @@ export default class RoadService {
 
       return result;
     } else {
-      console.error("roadIdForMinAngle*********************************************************");
+      console.error(
+        "roadIdForMinAngle*********************************************************"
+      );
       return null;
     }
   }
@@ -527,7 +597,12 @@ export default class RoadService {
     let road1 = dataService.getRoad(roadId1);
     let road2 = dataService.getRoad(roadId2);
 
-    if (road1.startId == road2.startId || road1.startId == road2.endId || road1.endId == road2.startId || road1.endId == road2.endId) {
+    if (
+      road1.startId == road2.startId ||
+      road1.startId == road2.endId ||
+      road1.endId == road2.startId ||
+      road1.endId == road2.endId
+    ) {
       return true;
     } else {
       return false;
@@ -549,7 +624,9 @@ export default class RoadService {
     } else if (road.endId == pointId) {
       return "end";
     } else {
-      console.error("RoadService.getDirction*******************************************************************************************");
+      console.error(
+        "RoadService.getDirction*******************************************************************************************"
+      );
       return null;
     }
   }
@@ -563,7 +640,10 @@ export default class RoadService {
       return;
     } else if (Object.keys(parent).length > 2) {
       const info = this.roadIdForMinAngle(pointId, roadId);
-      edgeService.updateSingleEdgeForTwoRoad(info.min0.roadId, info.min1.roadId);
+      edgeService.updateSingleEdgeForTwoRoad(
+        info.min0.roadId,
+        info.min1.roadId
+      );
     }
 
     // 第一步先断开链接
@@ -600,7 +680,10 @@ export default class RoadService {
 
   setRoadInfo(vectorInfo) {
     const road = dataService.getRoad(vectorInfo.roadId);
-    if (vectorInfo.hasOwnProperty("edgeId") && vectorInfo.hasOwnProperty("dir")) {
+    if (
+      vectorInfo.hasOwnProperty("edgeId") &&
+      vectorInfo.hasOwnProperty("dir")
+    ) {
       if (vectorInfo.dir == "left") {
         road.leftEdgeId = vectorInfo.edgeId;
       } else if (vectorInfo.dir == "right") {
@@ -608,7 +691,10 @@ export default class RoadService {
       }
     }
 
-    if (vectorInfo.hasOwnProperty("pointId") && vectorInfo.hasOwnProperty("dir")) {
+    if (
+      vectorInfo.hasOwnProperty("pointId") &&
+      vectorInfo.hasOwnProperty("dir")
+    ) {
       if (vectorInfo.dir == "start") {
         road.startId = vectorInfo.pointId;
       } else if (vectorInfo.dir == "end") {
@@ -621,7 +707,12 @@ export default class RoadService {
     let road1 = dataService.getRoad(id1);
     let road2 = dataService.getRoad(id2);
 
-    if (road1 == null || road2 == null || typeof road1 == "undefined" || typeof road2 == "undefined") {
+    if (
+      road1 == null ||
+      road2 == null ||
+      typeof road1 == "undefined" ||
+      typeof road2 == "undefined"
+    ) {
       return null;
     }
 
@@ -744,7 +835,9 @@ export default class RoadService {
 
       return result;
     } else {
-      console.error("roadIdForMinAngle*********************************************************");
+      console.error(
+        "roadIdForMinAngle*********************************************************"
+      );
       return null;
     }
   }
@@ -756,7 +849,9 @@ export default class RoadService {
     } else if (road.endId == pointId) {
       return "end";
     } else {
-      console.error("getDirction*******************************************************************************************");
+      console.error(
+        "getDirction*******************************************************************************************"
+      );
       return null;
     }
   }
@@ -834,7 +929,9 @@ export default class RoadService {
 
       return result;
     } else {
-      console.error("roadIdForMinAngle*********************************************************");
+      console.error(
+        "roadIdForMinAngle*********************************************************"
+      );
       return null;
     }
   }
@@ -912,25 +1009,40 @@ export default class RoadService {
       if (road.way == Constant.twoWay) {
         //更新车道的起点和终点，因为车道的起点和终点的位置与中间隔离栏一致
         for (let i = 0; i < road.leftLanes.length; ++i) {
-          line = mathUtil.createLine1(road.leftLanes[i].start, road.leftLanes[i].end);
+          line = mathUtil.createLine1(
+            road.leftLanes[i].start,
+            road.leftLanes[i].end
+          );
           join = mathUtil.getJoinLinePoint(laneStart, line);
           mathUtil.clonePoint(road.leftLanes[i].start, join);
         }
         for (let i = 0; i < road.rightLanes.length; ++i) {
-          line = mathUtil.createLine1(road.rightLanes[i].start, road.rightLanes[i].end);
+          line = mathUtil.createLine1(
+            road.rightLanes[i].start,
+            road.rightLanes[i].end
+          );
           join = mathUtil.getJoinLinePoint(laneStart, line);
           mathUtil.clonePoint(road.rightLanes[i].start, join);
         }
-        line = mathUtil.createLine1(road.midDivide.leftMidDivide.start, road.midDivide.leftMidDivide.end);
+        line = mathUtil.createLine1(
+          road.midDivide.leftMidDivide.start,
+          road.midDivide.leftMidDivide.end
+        );
         join = mathUtil.getJoinLinePoint(laneStart, line);
         mathUtil.clonePoint(road.midDivide.leftMidDivide.start, join);
 
-        line = mathUtil.createLine1(road.midDivide.rightMidDivide.start, road.midDivide.rightMidDivide.end);
+        line = mathUtil.createLine1(
+          road.midDivide.rightMidDivide.start,
+          road.midDivide.rightMidDivide.end
+        );
         join = mathUtil.getJoinLinePoint(laneStart, line);
         mathUtil.clonePoint(road.midDivide.rightMidDivide.start, join);
       } else if (road.way == Constant.oneWay) {
         for (let i = 0; i < road.singleLanes.length; ++i) {
-          const line = mathUtil.createLine1(road.singleLanes[i].start, road.singleLanes[i].end);
+          const line = mathUtil.createLine1(
+            road.singleLanes[i].start,
+            road.singleLanes[i].end
+          );
           const join = mathUtil.getJoinLinePoint(laneStart, line);
           mathUtil.clonePoint(road.singleLanes[i].start, join);
         }
@@ -957,25 +1069,40 @@ export default class RoadService {
       if (road.way == Constant.twoWay) {
         //更新车道的起点和终点，因为车道的起点和终点的位置与中间隔离栏一致
         for (let i = 0; i < road.leftLanes.length; ++i) {
-          line = mathUtil.createLine1(road.leftLanes[i].start, road.leftLanes[i].end);
+          line = mathUtil.createLine1(
+            road.leftLanes[i].start,
+            road.leftLanes[i].end
+          );
           join = mathUtil.getJoinLinePoint(laneEnd, line);
           mathUtil.clonePoint(road.leftLanes[i].end, join);
         }
         for (let i = 0; i < road.rightLanes.length; ++i) {
-          line = mathUtil.createLine1(road.rightLanes[i].start, road.rightLanes[i].end);
+          line = mathUtil.createLine1(
+            road.rightLanes[i].start,
+            road.rightLanes[i].end
+          );
           join = mathUtil.getJoinLinePoint(laneEnd, line);
           mathUtil.clonePoint(road.rightLanes[i].end, join);
         }
-        line = mathUtil.createLine1(road.midDivide.leftMidDivide.start, road.midDivide.leftMidDivide.end);
+        line = mathUtil.createLine1(
+          road.midDivide.leftMidDivide.start,
+          road.midDivide.leftMidDivide.end
+        );
         join = mathUtil.getJoinLinePoint(laneEnd, line);
         mathUtil.clonePoint(road.midDivide.leftMidDivide.end, join);
 
-        line = mathUtil.createLine1(road.midDivide.rightMidDivide.start, road.midDivide.rightMidDivide.end);
+        line = mathUtil.createLine1(
+          road.midDivide.rightMidDivide.start,
+          road.midDivide.rightMidDivide.end
+        );
         join = mathUtil.getJoinLinePoint(laneEnd, line);
         mathUtil.clonePoint(road.midDivide.rightMidDivide.end, join);
       } else if (road.way == Constant.oneWay) {
         for (let i = 0; i < road.singleLanes.length; ++i) {
-          const line = mathUtil.createLine1(road.singleLanes[i].start, road.singleLanes[i].end);
+          const line = mathUtil.createLine1(
+            road.singleLanes[i].start,
+            road.singleLanes[i].end
+          );
           const join = mathUtil.getJoinLinePoint(laneEnd, line);
           mathUtil.clonePoint(road.singleLanes[i].end, join);
         }
@@ -1046,8 +1173,10 @@ export default class RoadService {
 
     const leftCount = road.leftDrivewayCount;
     const rightCount = road.rightDrivewayCount;
-    const leftRatio = road.leftWidth / (road.leftWidth + road.midDivide.midDivideWidth / 2);
-    const rightRatio = road.rightWidth / (road.rightWidth + road.midDivide.midDivideWidth / 2);
+    const leftRatio =
+      road.leftWidth / (road.leftWidth + road.midDivide.midDivideWidth / 2);
+    const rightRatio =
+      road.rightWidth / (road.rightWidth + road.midDivide.midDivideWidth / 2);
 
     let leftdx1 = ((leftEdge.start.x - startPoint.x) * leftRatio) / leftCount;
     let leftdy1 = ((leftEdge.start.y - startPoint.y) * leftRatio) / leftCount;
@@ -1055,8 +1184,10 @@ export default class RoadService {
     let leftdx2 = ((leftEdge.end.x - endPoint.x) * leftRatio) / leftCount;
     let leftdy2 = ((leftEdge.end.y - endPoint.y) * leftRatio) / leftCount;
 
-    let rightdx1 = ((rightEdge.start.x - startPoint.x) * rightRatio) / rightCount;
-    let rightdy1 = ((rightEdge.start.y - startPoint.y) * rightRatio) / rightCount;
+    let rightdx1 =
+      ((rightEdge.start.x - startPoint.x) * rightRatio) / rightCount;
+    let rightdy1 =
+      ((rightEdge.start.y - startPoint.y) * rightRatio) / rightCount;
 
     let rightdx2 = ((rightEdge.end.x - endPoint.x) * rightRatio) / rightCount;
     let rightdy2 = ((rightEdge.end.y - endPoint.y) * rightRatio) / rightCount;
@@ -1117,8 +1248,10 @@ export default class RoadService {
 
         if (dir2 == "start" || !dir2) {
           road.rightLanes[i].start = {};
-          road.rightLanes[i].start.x = startPoint.x + middx1 + rightdx1 * (i + 1);
-          road.rightLanes[i].start.y = startPoint.y + middy1 + rightdy1 * (i + 1);
+          road.rightLanes[i].start.x =
+            startPoint.x + middx1 + rightdx1 * (i + 1);
+          road.rightLanes[i].start.y =
+            startPoint.y + middy1 + rightdy1 * (i + 1);
 
           road.midDivide.rightMidDivide.start = {};
           road.midDivide.rightMidDivide.start.x = startPoint.x + middx1;
@@ -1178,7 +1311,19 @@ export default class RoadService {
   //需要考虑车道个数是0(左或者右)的情况
   //单向车道不考虑dir，即：均匀的增加或者删除车道
   updateForAddSubtractLanesCount(roadId, newCount, dir) {
-    let dx1, dy1, dx2, dy2, oldCount, edgeStartPosition, edgeEndPosition, leftRatio, rightRatio, middx1, middy1, middx2, middy2;
+    let dx1,
+      dy1,
+      dx2,
+      dy2,
+      oldCount,
+      edgeStartPosition,
+      edgeEndPosition,
+      leftRatio,
+      rightRatio,
+      middx1,
+      middy1,
+      middx2,
+      middy2;
     let road = dataService.getRoad(roadId);
 
     if (newCount < 1) {
@@ -1191,8 +1336,10 @@ export default class RoadService {
     let rightEdge = dataService.getRoadEdge(road.rightEdgeId);
 
     if (road.way == Constant.twoWay) {
-      leftRatio = road.leftWidth / (road.leftWidth + road.midDivide.midDivideWidth / 2);
-      rightRatio = road.rightWidth / (road.rightWidth + road.midDivide.midDivideWidth / 2);
+      leftRatio =
+        road.leftWidth / (road.leftWidth + road.midDivide.midDivideWidth / 2);
+      rightRatio =
+        road.rightWidth / (road.rightWidth + road.midDivide.midDivideWidth / 2);
       if (dir == "left") {
         oldCount = road.leftDrivewayCount;
         if (oldCount != 0) {
@@ -1258,10 +1405,18 @@ export default class RoadService {
       let line = this.getMidLine(road);
       if (dir == "left") {
         let join = mathUtil.getJoinLinePoint(leftEdge.start, line);
-        road.setWidth(mathUtil.getDistance(leftEdge.start, join) - road.midDivide.midDivideWidth / 2, dir);
+        road.setWidth(
+          mathUtil.getDistance(leftEdge.start, join) -
+            road.midDivide.midDivideWidth / 2,
+          dir
+        );
       } else if (dir == "right") {
         let join = mathUtil.getJoinLinePoint(rightEdge.start, line);
-        road.setWidth(mathUtil.getDistance(rightEdge.start, join) - road.midDivide.midDivideWidth / 2, dir);
+        road.setWidth(
+          mathUtil.getDistance(rightEdge.start, join) -
+            road.midDivide.midDivideWidth / 2,
+          dir
+        );
       }
     } else if (road.way == Constant.oneWay) {
       oldCount = road.singleRoadDrivewayCount;
@@ -1327,26 +1482,50 @@ export default class RoadService {
       road.setWidth(newWidth * 2);
     } else if (road.way == Constant.twoWay) {
       if (dir == "left") {
-        edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, newWidth + road.midDivide.midDivideWidth / 2);
+        edgePoints = mathUtil.RectangleVertex(
+          startPoint,
+          endPoint,
+          newWidth + road.midDivide.midDivideWidth / 2
+        );
         mathUtil.clonePoint(leftEdge.start, edgePoints.leftEdgeStart);
         mathUtil.clonePoint(leftEdge.end, edgePoints.leftEdgeEnd);
         road.setWidth(newWidth, dir);
       } else if (dir == "right") {
-        edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, newWidth + road.midDivide.midDivideWidth / 2);
+        edgePoints = mathUtil.RectangleVertex(
+          startPoint,
+          endPoint,
+          newWidth + road.midDivide.midDivideWidth / 2
+        );
         mathUtil.clonePoint(rightEdge.start, edgePoints.rightEdgeStart);
         mathUtil.clonePoint(rightEdge.end, edgePoints.rightEdgeEnd);
         road.setWidth(newWidth, dir);
       }
       //左右两边的edge同时变宽或者变窄
       else {
-        edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, (newWidth * road.leftWidth) / (road.leftWidth + road.rightWidth) + road.midDivide.midDivideWidth / 2);
+        edgePoints = mathUtil.RectangleVertex(
+          startPoint,
+          endPoint,
+          (newWidth * road.leftWidth) / (road.leftWidth + road.rightWidth) +
+            road.midDivide.midDivideWidth / 2
+        );
         mathUtil.clonePoint(leftEdge.start, edgePoints.leftEdgeStart);
         mathUtil.clonePoint(leftEdge.end, edgePoints.leftEdgeEnd);
-        road.setWidth((newWidth * road.leftWidth) / (road.leftWidth + road.rightWidth), "left");
-        edgePoints = mathUtil.RectangleVertex(startPoint, endPoint, (newWidth * road.rightWidth) / (road.leftWidth + road.rightWidth) + road.midDivide.midDivideWidth / 2);
+        road.setWidth(
+          (newWidth * road.leftWidth) / (road.leftWidth + road.rightWidth),
+          "left"
+        );
+        edgePoints = mathUtil.RectangleVertex(
+          startPoint,
+          endPoint,
+          (newWidth * road.rightWidth) / (road.leftWidth + road.rightWidth) +
+            road.midDivide.midDivideWidth / 2
+        );
         mathUtil.clonePoint(rightEdge.start, edgePoints.rightEdgeStart);
         mathUtil.clonePoint(rightEdge.end, edgePoints.rightEdgeEnd);
-        road.setWidth((newWidth * road.rightWidth) / (road.leftWidth + road.rightWidth), "right");
+        road.setWidth(
+          (newWidth * road.rightWidth) / (road.leftWidth + road.rightWidth),
+          "right"
+        );
       }
     }
 
@@ -1368,20 +1547,35 @@ export default class RoadService {
     rightLine.setWeight(rightEdge.getWeight());
     if (road.way == Constant.oneWay) {
       for (let i = 0; i < road.singleLanes.length; ++i) {
-        let laneLine = lineService.create(road.singleLanes[i].start, road.singleLanes[i].end);
+        let laneLine = lineService.create(
+          road.singleLanes[i].start,
+          road.singleLanes[i].end
+        );
         laneLine.setStyle(VectorStyle.SingleDashedLine);
       }
     } else if (road.way == Constant.twoWay) {
       for (let i = 0; i < road.leftLanes.length; ++i) {
-        let laneLine = lineService.create(road.leftLanes[i].start, road.leftLanes[i].end);
+        let laneLine = lineService.create(
+          road.leftLanes[i].start,
+          road.leftLanes[i].end
+        );
         laneLine.setStyle(VectorStyle.SingleDashedLine);
       }
       for (let i = 0; i < road.rightLanes.length; ++i) {
-        let laneLine = lineService.create(road.rightLanes[i].start, road.rightLanes[i].end);
+        let laneLine = lineService.create(
+          road.rightLanes[i].start,
+          road.rightLanes[i].end
+        );
         laneLine.setStyle(VectorStyle.SingleDashedLine);
       }
-      lineService.create(road.midDivide.leftMidDivide.start, road.midDivide.leftMidDivide.end);
-      lineService.create(road.midDivide.rightMidDivide.start, road.midDivide.rightMidDivide.end);
+      lineService.create(
+        road.midDivide.leftMidDivide.start,
+        road.midDivide.leftMidDivide.end
+      );
+      lineService.create(
+        road.midDivide.rightMidDivide.start,
+        road.midDivide.rightMidDivide.end
+      );
     }
   }
 
@@ -1403,27 +1597,57 @@ export default class RoadService {
       },
     };
 
-    let roadLine = mathUtil.createLine1(dataService.getRoadPoint(road.startId), dataService.getRoadPoint(road.endId));
-    let roadLineCrossPoint = mathUtil.getLineEndPointPos(roadInfo.start, roadInfo.end);
-    let CrossPointStartDistance = mathUtil.getDistance(roadStartPoint, roadLineCrossPoint);
+    let roadLine = mathUtil.createLine1(
+      dataService.getRoadPoint(road.startId),
+      dataService.getRoadPoint(road.endId)
+    );
+    let roadLineCrossPoint = mathUtil.getLineEndPointPos(
+      roadInfo.start,
+      roadInfo.end
+    );
+    let CrossPointStartDistance = mathUtil.getDistance(
+      roadStartPoint,
+      roadLineCrossPoint
+    );
     let leftEdgeDistance = mathUtil.getDistance(leftEdge.start, leftEdge.end);
-    let righttEdgeDistance = mathUtil.getDistance(rightEdge.start, rightEdge.end);
-    if (CrossPointStartDistance > leftEdgeDistance && CrossPointStartDistance > righttEdgeDistance) {
+    let righttEdgeDistance = mathUtil.getDistance(
+      rightEdge.start,
+      rightEdge.end
+    );
+    if (
+      CrossPointStartDistance > leftEdgeDistance &&
+      CrossPointStartDistance > righttEdgeDistance
+    ) {
       let satrtEdgeLine = mathUtil.createLine1(leftEdge.start, rightEdge.start);
       let endEdgeLine = mathUtil.createLine1(leftEdge.end, rightEdge.end);
-      let satrtEdgeCrossPoint = mathUtil.getIntersectionPoint(satrtEdgeLine, roadLine);
-      let endEdgeCrossPoint = mathUtil.getIntersectionPoint(endEdgeLine, roadLine);
+      let satrtEdgeCrossPoint = mathUtil.getIntersectionPoint(
+        satrtEdgeLine,
+        roadLine
+      );
+      let endEdgeCrossPoint = mathUtil.getIntersectionPoint(
+        endEdgeLine,
+        roadLine
+      );
 
       console.log(satrtEdgeCrossPoint, endEdgeCrossPoint);
-      roadLineCrossPoint = mathUtil.getLineEndPointPos(satrtEdgeCrossPoint, endEdgeCrossPoint);
+      roadLineCrossPoint = mathUtil.getLineEndPointPos(
+        satrtEdgeCrossPoint,
+        endEdgeCrossPoint
+      );
     }
     // if(roadLineCrossPoint){
     //   let lineLength = this.getDistance(startPoint, endPoint);
     // }
     let leftEdgeLine = mathUtil.createLine1(leftEdge.start, leftEdge.end);
     let rightEdgeLine = mathUtil.createLine1(rightEdge.start, rightEdge.end);
-    let leftEdgePoint = mathUtil.getJoinLinePoint(roadLineCrossPoint, leftEdgeLine);
-    let rightEdgePoint = mathUtil.getJoinLinePoint(roadLineCrossPoint, rightEdgeLine);
+    let leftEdgePoint = mathUtil.getJoinLinePoint(
+      roadLineCrossPoint,
+      leftEdgeLine
+    );
+    let rightEdgePoint = mathUtil.getJoinLinePoint(
+      roadLineCrossPoint,
+      rightEdgeLine
+    );
 
     // let rightEdgePoint = mathUtil.getLineEndPointPos(rightEdge.start, rightEdge.end);
     let edgeLine = mathUtil.createLine1(leftEdgePoint, rightEdgePoint);
@@ -1434,7 +1658,10 @@ export default class RoadService {
         //单向多车道
         let crossList = [];
         for (let i = 0; i < road.singleLanes.length; i++) {
-          let crossLine = mathUtil.createLine1(road.singleLanes[i].start, road.singleLanes[i].end);
+          let crossLine = mathUtil.createLine1(
+            road.singleLanes[i].start,
+            road.singleLanes[i].end
+          );
           // let crossPoint = mathUtil.getIntersectionPoint(edgeLine, crossLine);
           // crossList.push(crossPoint);
           crossList.push(crossLine);
@@ -1443,12 +1670,21 @@ export default class RoadService {
           if (i == 0) {
             //第一个位置
             // roadWidthTipsPos.push({ start: rightEdgePoint, end: crossList[i] });
-            roadWidthTipsPos.push({ start: rightEdgePoint, end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]) });
+            roadWidthTipsPos.push({
+              start: rightEdgePoint,
+              end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]),
+            });
           } else {
             //以此类推
 
-            let middleEdgePoint1 = mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i - 1]);
-            let middleEdgePoint2 = mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]);
+            let middleEdgePoint1 = mathUtil.getJoinLinePoint(
+              roadLineCrossPoint,
+              crossList[i - 1]
+            );
+            let middleEdgePoint2 = mathUtil.getJoinLinePoint(
+              roadLineCrossPoint,
+              crossList[i]
+            );
             // roadWidthTipsPos.push({
             //   start: crossList[i - 1],
             //   end: crossList[i],
@@ -1465,7 +1701,10 @@ export default class RoadService {
         //   start: crossList[crossList.length - 1],
         //   end: leftEdgePoint,
         // });
-        let a = mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[crossList.length - 1]);
+        let a = mathUtil.getJoinLinePoint(
+          roadLineCrossPoint,
+          crossList[crossList.length - 1]
+        );
         roadWidthTipsPos.push({
           start: a,
           end: leftEdgePoint,
@@ -1482,16 +1721,31 @@ export default class RoadService {
       // let leftMidDividePoint = mathUtil.getLineEndPointPos(road.midDivide.leftMidDivide.start, road.midDivide.leftMidDivide.end);
       // let rightMidDividePoint = mathUtil.getLineEndPointPos(road.midDivide.rightMidDivide.start, road.midDivide.rightMidDivide.end);
 
-      let leftMidDivideLine = mathUtil.createLine1(road.midDivide.leftMidDivide.start, road.midDivide.leftMidDivide.end);
-      let rightMidDividePointLine = mathUtil.createLine1(road.midDivide.rightMidDivide.start, road.midDivide.rightMidDivide.end);
-      let leftMidDividePoint = mathUtil.getJoinLinePoint(roadLineCrossPoint, leftMidDivideLine);
-      let rightMidDividePoint = mathUtil.getJoinLinePoint(roadLineCrossPoint, rightMidDividePointLine);
+      let leftMidDivideLine = mathUtil.createLine1(
+        road.midDivide.leftMidDivide.start,
+        road.midDivide.leftMidDivide.end
+      );
+      let rightMidDividePointLine = mathUtil.createLine1(
+        road.midDivide.rightMidDivide.start,
+        road.midDivide.rightMidDivide.end
+      );
+      let leftMidDividePoint = mathUtil.getJoinLinePoint(
+        roadLineCrossPoint,
+        leftMidDivideLine
+      );
+      let rightMidDividePoint = mathUtil.getJoinLinePoint(
+        roadLineCrossPoint,
+        rightMidDividePointLine
+      );
 
       // leftLanes,rightLanes
       if (road.leftLanes.length) {
         let crossList = [];
         for (let i = 0; i < road.leftLanes.length; i++) {
-          let crossLine = mathUtil.createLine1(road.leftLanes[i].start, road.leftLanes[i].end);
+          let crossLine = mathUtil.createLine1(
+            road.leftLanes[i].start,
+            road.leftLanes[i].end
+          );
           // let crossPoint = mathUtil.getIntersectionPoint(edgeLine, crossLine);
           // crossList.push(crossPoint);
 
@@ -1505,7 +1759,10 @@ export default class RoadService {
             //   end: crossList[i],
             // });
 
-            roadWidthTipsPos.push({ start: leftMidDividePoint, end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]) });
+            roadWidthTipsPos.push({
+              start: leftMidDividePoint,
+              end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]),
+            });
           } else {
             //以此类推
             // roadWidthTipsPos.push({
@@ -1513,7 +1770,10 @@ export default class RoadService {
             //   end: crossList[i],
             // });
             roadWidthTipsPos.push({
-              start: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i - 1]),
+              start: mathUtil.getJoinLinePoint(
+                roadLineCrossPoint,
+                crossList[i - 1]
+              ),
               end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]),
             });
           }
@@ -1524,7 +1784,10 @@ export default class RoadService {
         //   end: leftEdgePoint,
         // });
         roadWidthTipsPos.push({
-          start: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[crossList.length - 1]),
+          start: mathUtil.getJoinLinePoint(
+            roadLineCrossPoint,
+            crossList[crossList.length - 1]
+          ),
           end: leftEdgePoint,
         });
         road.setRoadWidthTipsPos(roadWidthTipsPos);
@@ -1538,7 +1801,10 @@ export default class RoadService {
       if (road.rightLanes.length) {
         let crossList = [];
         for (let i = 0; i < road.rightLanes.length; i++) {
-          let crossLine = mathUtil.createLine1(road.rightLanes[i].start, road.rightLanes[i].end);
+          let crossLine = mathUtil.createLine1(
+            road.rightLanes[i].start,
+            road.rightLanes[i].end
+          );
           // let crossPoint = mathUtil.getIntersectionPoint(edgeLine, crossLine);
           // crossList.push(crossPoint);
           crossList.push(crossLine);
@@ -1551,7 +1817,10 @@ export default class RoadService {
             //   end: crossList[i],
             // });
 
-            roadWidthTipsPos.push({ start: rightMidDividePoint, end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]) });
+            roadWidthTipsPos.push({
+              start: rightMidDividePoint,
+              end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]),
+            });
           } else {
             //以此类推
             // roadWidthTipsPos.push({
@@ -1560,7 +1829,10 @@ export default class RoadService {
             // });
 
             roadWidthTipsPos.push({
-              start: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i - 1]),
+              start: mathUtil.getJoinLinePoint(
+                roadLineCrossPoint,
+                crossList[i - 1]
+              ),
               end: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[i]),
             });
           }
@@ -1571,7 +1843,10 @@ export default class RoadService {
         //   end: rightEdgePoint,
         // });
         roadWidthTipsPos.push({
-          start: mathUtil.getJoinLinePoint(roadLineCrossPoint, crossList[crossList.length - 1]),
+          start: mathUtil.getJoinLinePoint(
+            roadLineCrossPoint,
+            crossList[crossList.length - 1]
+          ),
           end: rightEdgePoint,
         });