继续绘图

src/graphic/Controls/AddRoad.js

@@ -3,6 +3,7 @@ import Constant from "../Constant";
 import { mathUtil } from "../Util/MathUtil";
 import { dataService } from "../Service/DataService";
 import { pointService } from "../Service/PointService";
+import { curvePointService } from "../Service/CurvePointService";
 import { curveRoadService } from "../Service/CurveRoadService";
 import { stateService } from "../Service/StateService";
 import VectorType from "../enum/VectorType";
@@ -302,8 +303,8 @@ export default class AddRoad {
   /******************************************************************************************************************************************************************************/
   buildCurveRoad() {
     console.log("添加曲线路段！");
-    const start = pointService.create(this.startInfo.position);
-    const end = pointService.create(this.endInfo.position);
+    const start = curvePointService.create(this.startInfo.position);
+    const end = curvePointService.create(this.endInfo.position);
     curveRoadService.create(start.vectorId, end.vectorId);
     listenLayer.clear();
   }

src/graphic/Controls/MoveRoad.js

@@ -2,7 +2,7 @@ import { roadService } from "../Service/RoadService";
 import { dataService } from "../Service/DataService";
 import Constant from "../Constant";
 import { mathUtil } from "../Util/MathUtil";
-import { elementService } from "../Service/ElementService";
+import { curveRoadService } from "../Service/CurveRoadService";
 import { coordinate } from "../Coordinate";
 import { edgeService } from "../Service/EdgeService";
 
@@ -1086,12 +1086,14 @@ export default class MoveRoad {
 
   /******************************************************************************************************************************************************************************/
   moveCurveRoadPoint(pointId, position) {
-    let point = dataService.getPoint(pointId);
-    point.setPosition(position);
-    const curveRoadId = Object.keys(point.getParent())[0];
-    const curveRoad = dataService.getCurveRoad(curveRoadId);
-    updateForMovePoint(curveRoad, point);
+    // let point = dataService.getCurvePoint(pointId);
+    // point.setPosition(position);
+    // const curveRoadId = point.getParent();
+    // const curveRoad = dataService.getCurveRoad(curveRoadId);
+    // curveRoadService.updateForMovePoint(curveRoad, point.index);
+    curveRoadService.updateForMovePoint(pointId, position);
   }
+
   /******************************************************************************************************************************************************************************/
 }
 

src/graphic/Geometry/CurveEdge.js

@@ -0,0 +1,45 @@
+//墙的边缘线
+import Geometry from "./Geometry.js";
+import VectorType from "../enum/VectorType.js";
+import { mathUtil } from "../Util/MathUtil";
+
+export default class CurveEdge extends Geometry {
+  constructor(start, end, vectorId, parentId) {
+    super();
+    this.parent = parentId;
+    this.start = {};
+    this.end = {};
+    this.vectorId = null;
+    this.points = [];
+    this.geoType = VectorType.CurveEdge;
+    this.setId(vectorId);
+
+    this.setPositions(start, end);
+  }
+
+  setPositions(point1, point2) {
+    this.start.x = point1.x;
+    this.start.y = point1.y;
+
+    this.end.x = point2.x;
+    this.end.y = point2.y;
+  }
+
+  setPosition(position, dir) {
+    if (dir == "start") {
+      mathUtil.clonePoint(this.start, position);
+    } else if (dir == "end") {
+      mathUtil.clonePoint(this.end, position);
+    }
+  }
+
+  getPosition(dir) {
+    if (dir == "start") {
+      return this.start;
+    } else if (dir == "end") {
+      return this.end;
+    } else {
+      return null;
+    }
+  }
+}

src/graphic/Geometry/CurvePoint.js

@@ -0,0 +1,36 @@
+import VectorType from "../enum/VectorType.js";
+import Geometry from "./Geometry";
+
+export default class CurvePoint extends Geometry {
+  constructor(position, vectorId) {
+    super();
+    this.x = null;
+    this.y = null;
+    this.parent = null;
+    this.index = -1;
+    this.geoType = VectorType.CurvePoint;
+    this.setId(vectorId);
+    this.setPosition(position);
+  }
+
+  getIndex() {
+    return this.index;
+  }
+
+  setIndex(index) {
+    this.index = index;
+  }
+
+  setPointParent(parentId) {
+    this.parent = parentId;
+  }
+
+  getParent() {
+    return this.parent;
+  }
+
+  setPosition(position) {
+    this.x = position.x;
+    this.y = position.y;
+  }
+}

src/graphic/Geometry/CurveRoad.js

@@ -6,9 +6,13 @@ import Constant from "../Constant";
 export default class CurveRoad extends Road {
   constructor(startId, endId, vectorId) {
     super(startId, endId, vectorId);
+    this.startId = startId;
+    this.endId = endId;
     this.points = []; //中心线上一系列控制点。数组是从start到end。
-    this.leftEdgePoints = [];
-    this.rightEdgePoints = [];
+    this.leftEdgeId = null;
+    this.rightEdgeId = null;
+    this.width = Constant.defaultRoadWidth; //默认宽度
+
     this.leftDrivewayCount = 2; //左边的车道个数
     this.rightDrivewayCount = 2; //右边的车道个数
     this.geoType = VectorType.CurveRoad;

src/graphic/Geometry/Edge.js

@@ -10,7 +10,6 @@ export default class Edge extends Geometry {
     this.start = {};
     this.end = {};
     this.vectorId = null;
-    this.points = [];
     this.geoType = VectorType.Edge;
     this.setId(vectorId);
 

src/graphic/Geometry/Geometry.js

@@ -16,10 +16,6 @@ export default class Geometry {
     }
   }
 
-  setGeoType(geoType) {
-    this.geoType = geoType;
-  }
-
   setPointParent(parentId, dir) {
     if (this.parent == null) {
       this.parent = {};

src/graphic/Layer.js

@@ -126,6 +126,7 @@ export default class Layer {
 
     // 是否需要重绘
     let needAutoRedraw = false;
+    let point = null;
     const draggingItem = stateService.getDraggingItem();
 
     switch (eventName) {
@@ -205,7 +206,7 @@ export default class Layer {
         this.lastY = Y;
         break;
       case LayerEvents.MoveRoadPoint:
-        let point = dataService.getPoint(draggingItem.vectorId);
+        point = dataService.getPoint(draggingItem.vectorId);
         //listenLayer.start(position, draggingItem.vectorId, point.parent);
         listenLayer.start(position, draggingItem.vectorId, point.parent);
         if (listenLayer.modifyPoint) {
@@ -310,9 +311,10 @@ export default class Layer {
         addRoad.setNewRoadPoint("start", position);
         break;
       case LayerEvents.MoveCurveRoadPoint:
-        point = dataService.getPoint(draggingItem.vectorId);
-        point.setPosition(position);
-        needAutoRedraw = true;
+        if (draggingItem) {
+          moveRoad.moveCurveRoadPoint(draggingItem.vectorId, position);
+          needAutoRedraw = true;
+        }
         break;
       case LayerEvents.AddTag:
         needAutoRedraw = true;

src/graphic/ListenLayer.js

@@ -10,11 +10,13 @@ export default class ListenLayer {
   constructor() {
     this.roadInfo = {
       roadId: null,
+      type: null,
       state: null, // 未选中null
     };
 
     this.pointInfo = {
       pointId: null,
+      type: null,
       state: null,
     };
 
@@ -124,6 +126,7 @@ export default class ListenLayer {
           min1 = {
             distance: distance,
             pointId: road.startId,
+            type: VectorType.RoadCorner,
           };
 
           //start部分找到了墙的端点
@@ -187,6 +190,7 @@ export default class ListenLayer {
           min1 = {
             distance: distance,
             pointId: road.endId,
+            type: VectorType.RoadCorner,
           };
           //end部分找到了墙的端点
           if (
@@ -247,6 +251,7 @@ export default class ListenLayer {
       if (_flag && (min2 == null || min2.distance > distance)) {
         min2 = {
           distance: distance,
+          type: VectorType.Road,
           roadId: roadId,
         };
       }
@@ -264,8 +269,8 @@ export default class ListenLayer {
       }
 
       const curveRoad = dataService.getCurveRoad(curveRoadId);
-      const startPoint = dataService.getPoint(curveRoad.startId);
-      const endPoint = dataService.getPoint(curveRoad.endId);
+      const startPoint = dataService.getCurvePoint(curveRoad.startId);
+      const endPoint = dataService.getCurvePoint(curveRoad.endId);
       let distance = null;
 
       //先找端点
@@ -277,6 +282,7 @@ export default class ListenLayer {
           min1 = {
             distance: distance,
             pointId: curveRoad.startId,
+            type: VectorType.CurveRoadCorner,
           };
 
           if (min1.distance < Constant.minAdsorbPix) {
@@ -295,7 +301,7 @@ export default class ListenLayer {
             modifyPoint.x = startPoint.x;
             modifyPoint.linkedPointIdX = curveRoad.startId;
           } else {
-            const linkedPointX = dataService.getPoint(
+            const linkedPointX = dataService.getCurvePoint(
               modifyPoint.linkedPointIdX
             );
             if (
@@ -313,7 +319,7 @@ export default class ListenLayer {
             modifyPoint.y = startPoint.y;
             modifyPoint.linkedPointIdY = curveRoad.startId;
           } else {
-            const linkedPointY = dataService.getPoint(
+            const linkedPointY = dataService.getCurvePoint(
               modifyPoint.linkedPointIdY
             );
             if (
@@ -335,6 +341,7 @@ export default class ListenLayer {
           min1 = {
             distance: distance,
             pointId: curveRoad.endId,
+            type: VectorType.CurveRoadCorner,
           };
           //end部分找到了墙的端点
           if (min1.distance < Constant.minAdsorbPix) {
@@ -352,7 +359,7 @@ export default class ListenLayer {
             modifyPoint.x = endPoint.x;
             modifyPoint.linkedPointIdX = curveRoad.endId;
           } else {
-            const linkedPointX = dataService.getPoint(
+            const linkedPointX = dataService.getCurvePoint(
               modifyPoint.linkedPointIdX
             );
             if (
@@ -370,7 +377,7 @@ export default class ListenLayer {
             modifyPoint.y = endPoint.y;
             modifyPoint.linkedPointIdY = curveRoad.endId;
           } else {
-            const linkedPointY = dataService.getPoint(
+            const linkedPointY = dataService.getCurvePoint(
               modifyPoint.linkedPointIdY
             );
             if (
@@ -432,12 +439,14 @@ export default class ListenLayer {
         flag1 = this.isChanged(nearest.minPoint.pointId, SelectState.Select, 1);
         this.pointInfo = {
           pointId: nearest.minPoint.pointId,
+          type: nearest.minPoint.type,
           state: SelectState.Select,
         };
       } else {
         flag1 = this.isChanged(nearest.minPoint.pointId, null, 1);
         this.pointInfo = {
           pointId: nearest.minPoint.pointId,
+          type: nearest.minPoint.type,
           state: null,
         };
       }
@@ -445,6 +454,7 @@ export default class ListenLayer {
       flag1 = this.isChanged(null, null, 1);
       this.pointInfo = {
         pointId: null,
+        type: null,
         state: null,
       };
     }
@@ -455,12 +465,14 @@ export default class ListenLayer {
         flag2 = this.isChanged(nearest.minRoad.roadId, SelectState.Select, 2);
         this.roadInfo = {
           roadId: nearest.minRoad.roadId,
+          type: nearest.minRoad.type,
           state: SelectState.Select,
         };
       } else {
         flag2 = this.isChanged(nearest.minRoad.roadId, null, 2);
         this.roadInfo = {
           roadId: nearest.minRoad.roadId,
+          type: nearest.minRoad.type,
           state: null,
         };
       }
@@ -468,6 +480,7 @@ export default class ListenLayer {
       flag2 = this.isChanged(null, null, 2);
       this.roadInfo = {
         roadId: null,
+        type: null,
         state: null,
       };
     }
@@ -536,13 +549,13 @@ export default class ListenLayer {
     } else if (this.pointInfo.pointId != null && this.pointInfo.state != null) {
       stateService.setSelectItem(
         this.pointInfo.pointId,
-        VectorType.RoadCorner,
+        this.pointInfo.type,
         SelectState.Select
       );
     } else if (this.roadInfo.roadId != null && this.roadInfo.state != null) {
       stateService.setSelectItem(
         this.roadInfo.roadId,
-        VectorType.Road,
+        this.roadInfo.type,
         SelectState.Select
       );
     } else {
@@ -709,11 +722,13 @@ export default class ListenLayer {
     this.roadInfo = {
       roadId: null,
       state: null,
+      type: null,
     };
 
     this.pointInfo = {
       pointId: null,
       state: null,
+      type: null,
     };
 
     this.modifyPoint = null;

src/graphic/Service/CurveEdgeService.js

@@ -0,0 +1,19 @@
+import CurveEdge from "../Geometry/CurveEdge.js";
+import Constant from "../Constant.js";
+import { dataService } from "./DataService.js";
+import { roadService } from "./RoadService.js";
+import { controlPointService } from "./ControlPointService.js";
+import { mathUtil } from "../Util/MathUtil.js";
+
+export default class CurveEdgeService {
+  constructor() {}
+
+  create(start, end, vectorId, parentId) {
+    let curveEdge = new CurveEdge(start, end, vectorId, parentId);
+    dataService.addCurveEdge(curveEdge);
+    return curveEdge;
+  }
+}
+
+const curveEdgeService = new CurveEdgeService();
+export { curveEdgeService };

src/graphic/Service/CurvePointService.js

@@ -0,0 +1,16 @@
+import CurvePoint from "../Geometry/CurvePoint.js";
+import { dataService } from "./DataService.js";
+import { mathUtil } from "../Util/MathUtil";
+
+export default class CurvePointService {
+  constructor() {}
+
+  create(position, vectorId) {
+    let point = new CurvePoint(position, vectorId);
+    dataService.addCurvePoint(point);
+    return point;
+  }
+}
+
+const curvePointService = new CurvePointService();
+export { curvePointService };

src/graphic/Service/CurveRoadService.js

@@ -1,6 +1,6 @@
 import { dataService } from "./DataService";
-import { pointService } from "./PointService";
-import { edgeService } from "./EdgeService";
+import { curvePointService } from "./CurvePointService";
+import { curveEdgeService } from "./CurveEdgeService";
 import { mathUtil } from "../Util/MathUtil.js";
 import CurveRoad from "../Geometry/CurveRoad.js";
 import VectorType from "../enum/VectorType";
@@ -12,27 +12,26 @@ export default class CurveRoadService {
     let curveRoad = new CurveRoad(startId, endId, vectorId);
     dataService.addCurveRoad(curveRoad);
 
-    let startPoint = dataService.getPoint(startId);
-    startPoint.setPointParent(curveRoad.vectorId, "start");
-    startPoint.setGeoType(VectorType.CurveRoadCorner);
-
-    let endPoint = dataService.getPoint(endId);
-    endPoint.setPointParent(curveRoad.vectorId, "end");
-    endPoint.setGeoType(VectorType.CurveRoadCorner);
+    let startPoint = dataService.getCurvePoint(startId);
+    startPoint.setPointParent(curveRoad.vectorId);
+    startPoint.setIndex(0);
+    let endPoint = dataService.getCurvePoint(endId);
+    endPoint.setPointParent(curveRoad.vectorId);
+    endPoint.setIndex(2);
 
     let edgePoints = mathUtil.RectangleVertex(
       startPoint,
       endPoint,
       curveRoad.width
     );
-    let leftEdge = edgeService.create(
+    let leftEdge = curveEdgeService.create(
       edgePoints.leftEdgeStart,
       edgePoints.leftEdgeEnd,
       null,
       vectorId
     );
 
-    let rightEdge = edgeService.create(
+    let rightEdge = curveEdgeService.create(
       edgePoints.rightEdgeStart,
       edgePoints.rightEdgeEnd,
       null,
@@ -48,56 +47,90 @@ export default class CurveRoadService {
 
     curveRoad.points.push(startPoint);
     curveRoad.points.push(endPoint);
-    this.addCPoint(
-      curveRoad,
-      {
-        x: (startPoint.x + endPoint.x) / 2,
-        y: (startPoint.y + endPoint.y) / 2,
-      },
-      0
-    );
-    curveRoad.leftEdgePoints.push(edgePoints.leftEdgeStart);
-    curveRoad.leftEdgePoints.push(edgePoints.leftEdgeEnd);
 
-    curveRoad.rightEdgePoints.push(edgePoints.rightEdgeStart);
-    curveRoad.rightEdgePoints.push(edgePoints.rightEdgeEnd);
+    leftEdge.points.push(edgePoints.leftEdgeStart);
+    leftEdge.points.push(edgePoints.leftEdgeEnd);
+
+    rightEdge.points.push(edgePoints.rightEdgeStart);
+    rightEdge.points.push(edgePoints.rightEdgeEnd);
 
     let lanes = this.setLanes(
       curveRoad.points,
-      curveRoad.leftEdgePoints,
-      curveRoad.rightEdgePoints,
+      leftEdge.points,
+      rightEdge.points,
       curveRoad.leftDrivewayCount,
       curveRoad.rightDrivewayCount
     );
     curveRoad.leftLanes = lanes.leftLanes;
     curveRoad.rightLanes = lanes.rightLanes;
+
+    this.addCPoint(
+      curveRoad,
+      {
+        x: (startPoint.x + endPoint.x) / 2,
+        y: (startPoint.y + endPoint.y) / 2,
+      },
+      0
+    );
+
     return curveRoad;
   }
 
+  //不能加首尾，只能加中间
   addCPoint(curveRoad, position, startIndex) {
-    let point = pointService.create(position);
+    let point = curvePointService.create(position);
     curveRoad.points.splice(startIndex + 1, 0, point);
-    point.setGeoType(VectorType.CurveRoadCorner);
     point.setPointParent(curveRoad.vectorId, startIndex + 1);
+    point.setIndex(startIndex + 1);
     for (let i = startIndex + 2; i < curveRoad.points.length; ++i) {
-      let parent = curveRoad.points[i].getParent();
-      if (
-        parent[curveRoad.vectorId] != "start" &&
-        parent[curveRoad.vectorId] != "end"
-      ) {
-        ++parent[curveRoad.vectorId];
-      }
+      curveRoad.points[i].setIndex(i);
     }
+
+    const leftCurveEdge = dataService.getCurveEdge(curveRoad.leftEdgeId);
+    let leftLine = mathUtil.createLine1(
+      leftCurveEdge.points[startIndex],
+      leftCurveEdge.points[startIndex + 1]
+    );
+    const leftJoin = mathUtil.getLineForPoint(leftLine, position);
+    leftCurveEdge.points.splice(startIndex + 1, 0, leftJoin);
+
+    const rightCurveEdge = dataService.getCurveEdge(curveRoad.rightEdgeId);
+    let rightLine = mathUtil.createLine1(
+      rightCurveEdge.points[startIndex],
+      rightCurveEdge.points[startIndex + 1]
+    );
+    const rightJoin = mathUtil.getLineForPoint(rightLine, position);
+    rightCurveEdge.points.splice(startIndex + 1, 0, rightJoin);
+
+    this.insertCPointToLanes(curveRoad, position, startIndex);
   }
 
-  moveCPoint(position) {}
+  insertCPointToLanes(curveRoad, position, index) {
+    for (let i = 0; i < curveRoad.leftLanes.length; ++i) {
+      let leftLine = mathUtil.createLine1(
+        curveRoad.leftLanes[i][index],
+        curveRoad.leftLanes[i][index + 1]
+      );
+      const leftJoin = mathUtil.getLineForPoint(leftLine, position);
+      curveRoad.leftLanes[i].splice(index + 1, 0, leftJoin);
+    }
+
+    for (let i = 0; i < curveRoad.rightLanes.length; ++i) {
+      let rightLine = mathUtil.createLine1(
+        curveRoad.rightLanes[i][index],
+        curveRoad.rightLanes[i][index + 1]
+      );
+      const rightJoin = mathUtil.getLineForPoint(rightLine, position);
+      curveRoad.rightLanes[i].splice(index + 1, 0, rightJoin);
+    }
+  }
 
   setLanesPoints(curveRoadId) {
     let curveRoad = dataService.getCurveRoad(curveRoadId);
     let startPoint = dataService.getPoint(curveRoad.startId);
     let endPoint = dataService.getPoint(curveRoad.endId);
 
-    let midPoint = pointService.create({
+    let midPoint = curvePointService.create({
       x: (startPoint.x + endPoint.x) / 2,
       y: (startPoint.y + endPoint.y) / 2,
     });
@@ -131,7 +164,9 @@ export default class CurveRoadService {
 
     for (let i = 0; i < leftCount - 1; ++i) {
       for (let j = 0; j < points.length; ++j) {
-        leftLanes[i] = [];
+        if (!leftLanes[i]) {
+          leftLanes[i] = [];
+        }
         leftLanes[i][j] = {};
         if (j == 0) {
           leftLanes[i][j].x = points[j].x + leftdx1 * (i + 1);
@@ -186,7 +221,9 @@ export default class CurveRoadService {
 
     for (let i = 0; i < rightCount - 1; ++i) {
       for (let j = 0; j < points.length; ++j) {
-        rightLanes[i] = [];
+        if (!rightLanes[i]) {
+          rightLanes[i] = [];
+        }
         rightLanes[i][j] = {};
         if (j == 0) {
           rightLanes[i][j].x = points[j].x + rightdx1 * (i + 1);
@@ -231,107 +268,142 @@ export default class CurveRoadService {
     };
   }
 
-  updateForMovePoint(curveRoad, point) {
-    let index = -1;
-    for (let i = 0; i < curveRoad.points.length; ++i) {
-      if (curveRoad.points[i].vectorId == point.vectorId) {
-        index = i;
-      }
-    }
-
-    const len = points.length;
-    let leftdx1 = leftEdgePoints[0].x - points[0].x;
-    leftdx1 = leftdx1 / leftCount;
+  updateForMovePoint(pointId, position) {
+    let curvePoint = dataService.getCurvePoint(pointId);
+    let curveRoadId = curvePoint.getParent();
+    let curveRoad = dataService.getCurveRoad(curveRoadId);
 
-    let leftdy1 = leftEdgePoints[0].y - points[0].y;
-    leftdy1 = leftdy1 / leftCount;
+    let dx = position.x - curvePoint.x;
+    let dy = position.y - curvePoint.y;
+    let index = curvePoint.getIndex();
 
-    let leftdx2 = leftEdgePoints[len - 1].x - points[len - 1].x;
-    leftdx2 = leftdx2 / leftCount;
+    curvePoint.setPosition(position);
 
-    let leftdy2 = leftEdgePoints[len - 1].y - points[len - 1].y;
-    leftdy2 = leftdy2 / leftCount;
-
-    for (let i = 0; i < leftCount - 1; ++i) {
-      if (index == 0) {
-        curveRoad.leftLanes[i][index].x = points[index].x + leftdx1 * (i + 1);
-        curveRoad.leftLanes[i][index].y = points[index].y + leftdy1 * (i + 1);
-      } else if (index == points.length - 1) {
-        curveRoad.leftLanes[i][index].x = points[index].x + leftdx2 * (i + 1);
-        curveRoad.leftLanes[i][index].y = points[index].y + leftdy2 * (i + 1);
-      } else {
-        let edgePoints1 = mathUtil.RectangleVertex(
-          points[index],
-          points[index - 1],
-          leftdx1
-        );
-        let line1 = mathUtil.createLine1(
-          edgePoints1.leftEdgeStart,
-          edgePoints1.leftEdgeEnd
-        );
-
-        let edgePoints2 = mathUtil.RectangleVertex(
-          points[index],
-          points[index + 1],
-          leftdx1
-        );
-        let line2 = mathUtil.createLine1(
-          edgePoints2.leftEdgeStart,
-          edgePoints2.leftEdgeEnd
-        );
-
-        let join = mathUtil.getIntersectionPoint(line1, line2);
-        curveRoad.leftLanes[i][index].x = join.x;
-        curveRoad.leftLanes[i][index].y = join.y;
-      }
+    const leftCurveEdge = dataService.getCurveEdge(curveRoad.leftEdgeId);
+    leftCurveEdge.points[index].x += dx;
+    leftCurveEdge.points[index].y += dy;
+    for (let i = 0; i < curveRoad.leftLanes.length; ++i) {
+      curveRoad.leftLanes[i][index].x += dx;
+      curveRoad.leftLanes[i][index].y += dy;
     }
 
-    let rightdx1 = rightEdgePoints[0].x - points[0].x;
-    rightdx1 = rightdx1 / rightCount;
-
-    let rightdy1 = rightEdgePoints[0].y - points[0].y;
-    rightdy1 = rightdy1 / rightCount;
-
-    let rightdx2 = rightEdgePoints[len - 1].x - points[len - 1].x;
-    rightdx2 = rightdx2 / rightCount;
-
-    let rightdy2 = rightEdgePoints[len - 1].y - points[len - 1].y;
-    rightdy2 = rightdy2 / rightCount;
-
-    for (let i = 0; i < rightCount - 1; ++i) {
-      if (index == 0) {
-        curveRoad.rightLanes[i][index].x = points[index].x + rightdx1 * (i + 1);
-        curveRoad.rightLanes[i][index].y = points[index].y + rightdy1 * (i + 1);
-      } else if (index == points.length - 1) {
-        curveRoad.rightLanes[i][index].x = points[index].x + rightdy2 * (i + 1);
-        curveRoad.rightLanes[i][index].y = points[index].y + rightdy2 * (i + 1);
-      } else {
-        let edgePoints1 = mathUtil.RectangleVertex(
-          points[index],
-          points[index - 1],
-          rightdx1
-        );
-        let line1 = mathUtil.createLine1(
-          edgePoints1.rightEdgeStart,
-          edgePoints1.rightEdgeEnd
-        );
-
-        let edgePoints2 = mathUtil.RectangleVertex(
-          points[index],
-          points[index + 1],
-          rightdx1
-        );
-        let line2 = mathUtil.createLine1(
-          edgePoints2.rightEdgeStart,
-          edgePoints2.rightEdgeEnd
-        );
-
-        let join = mathUtil.getIntersectionPoint(line1, line2);
-        curveRoad.rightLanes[i][index].x = join.x;
-        curveRoad.rightLanes[i][index].y = join.y;
-      }
+    const rightCurveEdge = dataService.getCurveEdge(curveRoad.rightEdgeId);
+    rightCurveEdge.points[index].x += dx;
+    rightCurveEdge.points[index].y += dy;
+    for (let i = 0; i < curveRoad.rightLanes.length; ++i) {
+      curveRoad.rightLanes[i][index].x += dx;
+      curveRoad.rightLanes[i][index].y += dy;
     }
   }
+
+  // updateForMovePoint(curveRoad, index) {
+  //   let points = curveRoad.points;
+  //   let leftEdge = dataService.getCurveEdge(curveRoad.leftEdgeId);
+  //   let rightEdge = dataService.getCurveEdge(curveRoad.rightEdgeId);
+  //   let leftEdgePoints = leftEdge.points;
+  //   let rightEdgePoints = rightEdge.points;
+  //   let leftCount = curveRoad.leftDrivewayCount;
+  //   let rightCount = curveRoad.rightDrivewayCount;
+
+  //   const len = points.length;
+  //   let leftdx1 = leftEdgePoints[0].x - points[0].x;
+  //   leftdx1 = leftdx1 / leftCount;
+
+  //   let leftdy1 = leftEdgePoints[0].y - points[0].y;
+  //   leftdy1 = leftdy1 / leftCount;
+
+  //   let leftdx2 = leftEdgePoints[len - 1].x - points[len - 1].x;
+  //   leftdx2 = leftdx2 / leftCount;
+
+  //   let leftdy2 = leftEdgePoints[len - 1].y - points[len - 1].y;
+  //   leftdy2 = leftdy2 / leftCount;
+
+  //   for (let i = 0; i < leftCount - 1; ++i) {
+  //     if (index == 0) {
+  //       curveRoad.leftLanes[i][index].x = points[index].x + leftdx1 * (i + 1);
+  //       curveRoad.leftLanes[i][index].y = points[index].y + leftdy1 * (i + 1);
+  //     } else if (index == points.length - 1) {
+  //       curveRoad.leftLanes[i][index].x = points[index].x + leftdx2 * (i + 1);
+  //       curveRoad.leftLanes[i][index].y = points[index].y + leftdy2 * (i + 1);
+  //     } else {
+  //       let edgePoints1 = mathUtil.RectangleVertex(
+  //         points[index],
+  //         points[index - 1],
+  //         leftdx1
+  //       );
+  //       let line1 = mathUtil.createLine1(
+  //         edgePoints1.leftEdgeStart,
+  //         edgePoints1.leftEdgeEnd
+  //       );
+
+  //       let edgePoints2 = mathUtil.RectangleVertex(
+  //         points[index],
+  //         points[index + 1],
+  //         leftdx1
+  //       );
+  //       let line2 = mathUtil.createLine1(
+  //         edgePoints2.leftEdgeStart,
+  //         edgePoints2.leftEdgeEnd
+  //       );
+
+  //       let join = mathUtil.getIntersectionPoint(line1, line2);
+  //       if (join == null) {
+  //         join = mathUtil.getLineForPoint(line1, points[index]);
+  //       }
+  //       curveRoad.leftLanes[i][index].x = join.x;
+  //       curveRoad.leftLanes[i][index].y = join.y;
+  //     }
+  //   }
+
+  //   let rightdx1 = rightEdgePoints[0].x - points[0].x;
+  //   rightdx1 = rightdx1 / rightCount;
+
+  //   let rightdy1 = rightEdgePoints[0].y - points[0].y;
+  //   rightdy1 = rightdy1 / rightCount;
+
+  //   let rightdx2 = rightEdgePoints[len - 1].x - points[len - 1].x;
+  //   rightdx2 = rightdx2 / rightCount;
+
+  //   let rightdy2 = rightEdgePoints[len - 1].y - points[len - 1].y;
+  //   rightdy2 = rightdy2 / rightCount;
+
+  //   for (let i = 0; i < rightCount - 1; ++i) {
+  //     if (index == 0) {
+  //       curveRoad.rightLanes[i][index].x = points[index].x + rightdx1 * (i + 1);
+  //       curveRoad.rightLanes[i][index].y = points[index].y + rightdy1 * (i + 1);
+  //     } else if (index == points.length - 1) {
+  //       curveRoad.rightLanes[i][index].x = points[index].x + rightdy2 * (i + 1);
+  //       curveRoad.rightLanes[i][index].y = points[index].y + rightdy2 * (i + 1);
+  //     } else {
+  //       let edgePoints1 = mathUtil.RectangleVertex(
+  //         points[index],
+  //         points[index - 1],
+  //         rightdx1
+  //       );
+  //       let line1 = mathUtil.createLine1(
+  //         edgePoints1.rightEdgeStart,
+  //         edgePoints1.rightEdgeEnd
+  //       );
+
+  //       let edgePoints2 = mathUtil.RectangleVertex(
+  //         points[index],
+  //         points[index + 1],
+  //         rightdx1
+  //       );
+  //       let line2 = mathUtil.createLine1(
+  //         edgePoints2.rightEdgeStart,
+  //         edgePoints2.rightEdgeEnd
+  //       );
+
+  //       let join = mathUtil.getIntersectionPoint(line1, line2);
+  //       if (join == null) {
+  //         join = mathUtil.getLineForPoint(line1, points[index]);
+  //       }
+  //       curveRoad.rightLanes[i][index].x = join.x;
+  //       curveRoad.rightLanes[i][index].y = join.y;
+  //     }
+  //   }
+  // }
 }
 
 const curveRoadService = new CurveRoadService();

src/graphic/Service/DataService.js

@@ -22,13 +22,27 @@ export class DataService {
 
   initVectorData() {
     this.vectorData.points = {};
-    this.vectorData.controlPoints = {};
     this.vectorData.roads = {};
-    this.vectorData.curveRoads = {};
     this.vectorData.edges = {};
+    this.vectorData.curvePoints = {};
+    this.vectorData.curveRoads = {};
+    this.vectorData.curveEdges = {};
+    this.vectorData.controlPoints = {};
     this.vectorData.tags = {};
   }
 
+  getCurvePoints() {
+    return this.vectorData.curvePoints;
+  }
+
+  getCurvePoint(pointId) {
+    if (pointId) {
+      return this.vectorData.curvePoints[pointId];
+    } else {
+      return null;
+    }
+  }
+
   /**
    * 对公路的操作
    */
@@ -55,6 +69,18 @@ export class DataService {
     delete this.vectorData.curveRoads[curveRoadId];
   }
 
+  getCurveEdge(curveEdgeId) {
+    return this.vectorData.curveEdges[curveEdgeId];
+  }
+
+  addCurveEdge(curveEdge) {
+    this.vectorData.curveEdges[curveEdge.vectorId] = curveEdge;
+  }
+
+  addCurvePoint(curvePoint) {
+    this.vectorData.curvePoints[curvePoint.vectorId] = curvePoint;
+  }
+
   getRoads() {
     return this.vectorData.roads;
   }

src/graphic/Service/ElementService.js

@@ -251,17 +251,27 @@ export class ElementService {
     if (!this.vCheckLines.Y.display && !this.vCheckLines.Y.display) {
       if (listenLayer.modifyPoint) {
         if (listenLayer.modifyPoint.linkedPointIdX) {
-          const linkedPointX = dataService.getPoint(
+          let linkedPointX = dataService.getPoint(
             listenLayer.modifyPoint.linkedPointIdX
           );
+          if (!linkedPointX) {
+            linkedPointX = dataService.getCurvePoint(
+              listenLayer.modifyPoint.linkedPointIdX
+            );
+          }
           this.setCheckLinesX(linkedPointX, position);
           this.showCheckLinesX();
         }
 
         if (listenLayer.modifyPoint.linkedPointIdY) {
-          const linkedPointY = dataService.getPoint(
+          let linkedPointY = dataService.getPoint(
             listenLayer.modifyPoint.linkedPointIdY
           );
+          if (!linkedPointY) {
+            linkedPointY = dataService.getCurvePoint(
+              listenLayer.modifyPoint.linkedPointIdY
+            );
+          }
           this.setCheckLinesY(linkedPointY, position);
           this.showCheckLinesY();
         }

src/graphic/Util/MathUtil.js

@@ -353,9 +353,11 @@ export default class MathUtil {
     let parameter = {};
     if (line.a == 0 || typeof line.a == "undefined") {
       if (line.hasOwnProperty("x")) {
+        parameter.x = line.x;
         parameter.y = point.y;
       } else if (line.hasOwnProperty("y")) {
         parameter.x = point.x;
+        parameter.y = line.y;
       }
     } else {
       parameter.a = -1 / line.a;

src/graphic/enum/VectorType.js

@@ -1,5 +1,6 @@
 const VectorType = {
   Point: "Point",
+  CurvePoint: "CurvePoint",
   ControlPoint: "ControlPoint",
   Circle: "Circle",
   Img: "Img",
@@ -11,6 +12,7 @@ const VectorType = {
   Edge: "Edge",
   Road: "Road",
   CurveRoad: "CurveRoad",
+  CurveEdge: "CurveEdge",
   Tag: "Tag",
 };
 export default VectorType;