继续开始绘图

src/graphic/Service/ControlPointService.js

@@ -40,8 +40,9 @@ export default class ControlPointService {
       //新建控制点
       controlPoint = this.create(realRosition);
       //需要删除之前的控制点
-      dataService.deleteControlPointForEdge(edge1.vectorId);
-      dataService.deleteControlPointForEdge(edge2.vectorId);
+      dataService.deleteControlPointForEdge(edge1.vectorId, dir1);
+      dataService.deleteControlPointForEdge(edge2.vectorId, dir2);
+      dataService.deleteControlPoint(edge1.vectorId, edge2.vectorId);
       //设置控制点的信息
       controlPoint.setEdgeInfo(edge1.vectorId, dir1, edge2.vectorId, dir2);
       //添加到数据集里
@@ -55,6 +56,22 @@ export default class ControlPointService {
     edge2.setPosition(position2, dir2);
   }
 
+  //newleft,end------------road.leftEdgeId,end
+  replaceEdgeId(controlPoint, oldEdgeId, newEdgeId) {
+    if (controlPoint == null) {
+      return;
+    }
+    dataService.deleteControlPoint(
+      controlPoint.edgeInfo1.id,
+      controlPoint.edgeInfo2.id
+    );
+    if (controlPoint.edgeInfo1.id == oldEdgeId) {
+      controlPoint.edgeInfo1.id = newEdgeId;
+    } else if (controlPoint.edgeInfo2.id == oldEdgeId) {
+      controlPoint.edgeInfo2.id = newEdgeId;
+    }
+    dataService.addControlPoint(controlPoint);
+  }
   //position在直线edge.start，edge.end上
   // isPointOnEdgeRay(edge, dir, position) {
   //   let point1, point2;

src/graphic/Service/DataService.js

@@ -123,6 +123,27 @@ export class DataService {
     }
   }
 
+  getControlPoint2(key) {
+    return this.vectorData.controlPoints[key];
+  }
+
+  getControlPointForEdgeId(edgeId, dir) {
+    for (let key in this.vectorData.controlPoints) {
+      const controlPoint = this.vectorData.controlPoints[key];
+      if (
+        controlPoint.edgeInfo1.id == edgeId &&
+        controlPoint.edgeInfo1.dir == dir
+      ) {
+        return this.vectorData.controlPoints[key];
+      } else if (
+        controlPoint.edgeInfo2.id == edgeId &&
+        controlPoint.edgeInfo2.dir == dir
+      ) {
+        return this.vectorData.controlPoints[key];
+      }
+    }
+  }
+
   addControlPoint(controlPoint) {
     this.vectorData.controlPoints[
       controlPoint.edgeInfo1.id + "-" + controlPoint.edgeInfo2.id
@@ -139,7 +160,7 @@ export class DataService {
     }
   }
 
-  deleteControlPointForEdge(edgeId) {
+  deleteControlPointForEdge(edgeId, dir) {
     let dControlPointIds = [];
     for (let key in this.vectorData.controlPoints) {
       const controlPoint = this.vectorData.controlPoints[key];
@@ -152,7 +173,18 @@ export class DataService {
     }
 
     for (let i = 0; i < dControlPointIds.length; ++i) {
-      delete this.vectorData.controlPoints[dControlPointIds[i]];
+      const controlPoint = this.vectorData.controlPoints[dControlPointIds[i]];
+      if (
+        controlPoint.edgeInfo1.id == edgeId &&
+        controlPoint.edgeInfo1.dir == dir
+      ) {
+        delete this.vectorData.controlPoints[dControlPointIds[i]];
+      } else if (
+        controlPoint.edgeInfo2.id == edgeId &&
+        controlPoint.edgeInfo2.dir == dir
+      ) {
+        delete this.vectorData.controlPoints[dControlPointIds[i]];
+      }
     }
   }
 

src/graphic/Service/EdgeService.js

@@ -115,14 +115,14 @@ export default class EdgeService {
     let road1 = dataService.getRoad(roadId1);
     let startPoint1 = dataService.getPoint(road1.startId);
     let endPoint1 = dataService.getPoint(road1.endId);
-    this.computerDefaultEdge(roadId1);
+    // this.computerDefaultEdge(roadId1);   不能这样，会导致另一端点对应的edge端点改变
     let leftEdge1 = dataService.getEdge(road1.leftEdgeId);
     let rightEdge1 = dataService.getEdge(road1.rightEdgeId);
     let lineLeft1 = this.getLine(leftEdge1);
     let lineRight1 = this.getLine(rightEdge1);
 
     let road2 = dataService.getRoad(roadId2);
-    this.computerDefaultEdge(roadId2);
+    // this.computerDefaultEdge(roadId2);
     let startPoint2 = dataService.getPoint(road2.startId);
     let endPoint2 = dataService.getPoint(road2.endId);
     let leftEdge2 = dataService.getEdge(road2.leftEdgeId);
@@ -493,15 +493,16 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.start, newEdgePoint1);
         mathUtil.clonePoint(rightEdge2.start, newEdgePoint1);
         //要删除控制点
-        //dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge2.vectorId);
+        dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
+        //不能按照下面的方式计算，因为一个edge可以属于两个控制点，毕竟有两个端点
+        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(rightEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   leftEdge1.vectorId,
-          //   rightEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            leftEdge1.vectorId,
+            rightEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -521,15 +522,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.start, newEdgePoint2);
         mathUtil.clonePoint(leftEdge2.start, newEdgePoint2);
         //要删除控制点
-        //dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge2.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge1.vectorId);
+        dataService.deleteControlPoint(leftEdge2.vectorId, rightEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   leftEdge2.vectorId,
-          //   rightEdge1.vectorId
-          // );
+          dataService.deleteControlPoint(
+            leftEdge2.vectorId,
+            rightEdge1.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -569,18 +570,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.start, newEdgePoint1);
         mathUtil.clonePoint(leftEdge2.end, newEdgePoint1);
         //要删除控制点
-        // dataService.deleteControlPoint(
-        //   rightEdge1.vectorId,
-        //   rightEdge2.vectorId
-        // );
-        dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   leftEdge1.vectorId,
-          //   leftEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            leftEdge1.vectorId,
+            leftEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -598,15 +596,18 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.start, newEdgePoint2);
         mathUtil.clonePoint(rightEdge2.end, newEdgePoint2);
         //要删除控制点
-        //dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge1.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge2.vectorId);
+        dataService.deleteControlPoint(
+          rightEdge1.vectorId,
+          rightEdge2.vectorId
+        );
+        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(rightEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   rightEdge1.vectorId,
-          //   rightEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            rightEdge1.vectorId,
+            rightEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -646,18 +647,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.end, newEdgePoint1);
         mathUtil.clonePoint(leftEdge2.start, newEdgePoint1);
         //要删除控制点
-        // dataService.deleteControlPoint(
-        //   rightEdge1.vectorId,
-        //   rightEdge2.vectorId
-        // );
-        dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   leftEdge1.vectorId,
-          //   leftEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            leftEdge1.vectorId,
+            leftEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -675,15 +673,18 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.end, newEdgePoint2);
         mathUtil.clonePoint(rightEdge2.start, newEdgePoint2);
         //要删除控制点
-        //dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge1.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge2.vectorId);
+        dataService.deleteControlPoint(
+          rightEdge1.vectorId,
+          rightEdge2.vectorId
+        );
+        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(rightEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   rightEdge1.vectorId,
-          //   rightEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            rightEdge1.vectorId,
+            rightEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -723,15 +724,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.end, newEdgePoint1);
         mathUtil.clonePoint(rightEdge2.end, newEdgePoint1);
         //要删除控制点
-        //dataService.deleteControlPoint(leftEdge2.vectorId, rightEdge1.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   leftEdge1.vectorId,
-          //   leftEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            leftEdge1.vectorId,
+            leftEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -749,15 +750,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.end, newEdgePoint2);
         mathUtil.clonePoint(leftEdge2.end, newEdgePoint2);
         //要删除控制点
-        //dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
-        dataService.deleteControlPointForEdge(leftEdge2.vectorId);
-        dataService.deleteControlPointForEdge(rightEdge1.vectorId);
+        dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          // dataService.deleteControlPoint(
-          //   rightEdge1.vectorId,
-          //   leftEdge2.vectorId
-          // );
+          dataService.deleteControlPoint(
+            rightEdge1.vectorId,
+            leftEdge2.vectorId
+          );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(

src/graphic/Service/RoadService.js

@@ -66,12 +66,33 @@ export default class RoadService {
       //return null
     }
 
+    let leftEdge = dataService.getEdge(road.leftEdgeId);
+    let rightEdge = dataService.getEdge(road.rightEdgeId);
+
+    let oldLeftEdgeStartPoint = {
+      x: leftEdge.start.x,
+      y: leftEdge.start.y,
+    };
+    let oldLeftEdgeEndPoint = {
+      x: leftEdge.end.x,
+      y: leftEdge.end.y,
+    };
+
+    let oldRightEdgeStartPoint = {
+      x: rightEdge.start.x,
+      y: rightEdge.start.y,
+    };
+    let oldRightEdgeEndPoint = {
+      x: rightEdge.end.x,
+      y: rightEdge.end.y,
+    };
+
     let newRoad = null;
     if (dir == "start") {
-      // 第一步先断开链接
+      // 第一步把旧的road的另一端点对应的parent(旧的roadId)断开
       delete endPoint.parent[roadId];
       newRoad = this.create(pointId, road.endId);
-      //修改旧公路的end
+      // 更新旧公路的end
       point.setPointParent(roadId, "end");
       road.endId = pointId;
     } else if (dir == "end") {
@@ -81,7 +102,62 @@ export default class RoadService {
       point.setPointParent(roadId, "start");
       road.startId = pointId;
     }
+    // 更新断开后两个road之间的edge
     edgeService.updateEdgeForTwoRoad(roadId, newRoad.vectorId);
+
+    // 需要更新controlPoints
+    if (dir == "start") {
+      let cpt = dataService.getControlPointForEdgeId(road.leftEdgeId, "end");
+      controlPointService.replaceEdgeId(
+        cpt,
+        road.leftEdgeId,
+        newRoad.leftEdgeId
+      );
+
+      cpt = dataService.getControlPointForEdgeId(road.rightEdgeId, "end");
+      controlPointService.replaceEdgeId(
+        cpt,
+        road.rightEdgeId,
+        newRoad.rightEdgeId
+      );
+
+      let newRoadLeftEdge = dataService.getEdge(newRoad.leftEdgeId);
+      mathUtil.clonePoint(newRoadLeftEdge.end, oldLeftEdgeEndPoint);
+
+      let newRoadRightEdge = dataService.getEdge(newRoad.rightEdgeId);
+      mathUtil.clonePoint(newRoadRightEdge.end, oldRightEdgeEndPoint);
+
+      if (Object.keys(startPoint).length > 1) {
+        mathUtil.clonePoint(leftEdge.start, oldLeftEdgeStartPoint);
+        mathUtil.clonePoint(rightEdge.start, oldRightEdgeStartPoint);
+      }
+    } else if (dir == "end") {
+      let cpt = dataService.getControlPointForEdgeId(road.leftEdgeId, "start");
+      controlPointService.replaceEdgeId(
+        cpt,
+        road.leftEdgeId,
+        newRoad.leftEdgeId
+      );
+
+      cpt = dataService.getControlPointForEdgeId(road.rightEdgeId, "start");
+      controlPointService.replaceEdgeId(
+        cpt,
+        road.rightEdgeId,
+        newRoad.rightEdgeId
+      );
+
+      let newRoadLeftEdge = dataService.getEdge(newRoad.leftEdgeId);
+      mathUtil.clonePoint(newRoadLeftEdge.start, oldLeftEdgeStartPoint);
+
+      let newRoadRightEdge = dataService.getEdge(newRoad.rightEdgeId);
+      mathUtil.clonePoint(newRoadRightEdge.start, oldRightEdgeStartPoint);
+
+      if (Object.keys(endPoint).length > 1) {
+        mathUtil.clonePoint(leftEdge.end, oldLeftEdgeEndPoint);
+        mathUtil.clonePoint(rightEdge.end, oldRightEdgeEndPoint);
+      }
+    }
+
     return newRoad.vectorId;
   }