继续开始

src/graphic/Controls/MoveRoad.js

@@ -996,6 +996,38 @@ export default class MoveRoad {
     return flag;
   }
 
+  moveTo(roadId, dx, dy) {
+    dx = dx;
+    dy = -dy;
+
+    const road = dataService.getRoad(roadId);
+    const startPoint = dataService.getPoint(road.startId);
+    const endPoint = dataService.getPoint(road.endId);
+
+    if (
+      Object.keys(startPoint.getParent()).length == 1 &&
+      Object.keys(endPoint.getParent()).length == 1
+    ) {
+      const p1 = { x: startPoint.x + dx, y: startPoint.y + dy };
+      const p2 = { x: endPoint.x + dx, y: endPoint.y + dy };
+
+      startPoint.setPosition(p1);
+      endPoint.setPosition(p2);
+
+      let leftEdge = dataService.getEdge(road.leftEdgeId);
+      leftEdge.start.x += dx;
+      leftEdge.start.y += dy;
+      leftEdge.end.x += dx;
+      leftEdge.end.y += dy;
+
+      let rightEdge = dataService.getEdge(road.rightEdgeId);
+      rightEdge.start.x += dx;
+      rightEdge.start.y += dy;
+      rightEdge.end.x += dx;
+      rightEdge.end.y += dy;
+    }
+  }
+
   // 更新pointId的坐标
   updatePointForMoveRoad(roadId, pointId, virtualInfo, limitRoadId, needNew) {
     const point = dataService.getPoint(pointId);

src/graphic/Geometry/Road.js

@@ -12,8 +12,8 @@ export default class Road extends Geometry {
     this.width = Constant.defaultRoadWidth; //默认宽度
     this.isCurve = false;
     this.points = []; //中心线上一系列控制点。数组是从start到end。
-    this.leftCount = 1; //左边的路段个数
-    this.rightCount = 1; //右边的路段个数
+    this.leftDrivewayCount = 1; //左边的车道个数
+    this.rightDrivewayCount = 1; //右边的车道个数
     this.geoType = VectorType.Road;
     this.setId(vectorId);
   }

src/graphic/Layer.js

@@ -22,6 +22,7 @@ import { mathUtil } from "./Util/MathUtil";
 import History from "./History/History";
 import mitt from "mitt";
 import { roadService } from "./Service/RoadService";
+import { edgeService } from "./Service/EdgeService";
 
 const minDragDis = 10;
 
@@ -64,6 +65,7 @@ export default class Layer {
     this.canvas.addEventListener("mousewheel", this.onWheel.bind(this));
     this.canvas.addEventListener("DOMMouseScroll", this.onWheel.bind(this));
     this.canvas.addEventListener("resize", this.reSize.bind(this));
+    document.addEventListener("keydown", this.onKeydown.bind(this));
   }
 
   reSize = function () {
@@ -118,6 +120,7 @@ export default class Layer {
     } else {
       this.dragging = false;
     }
+
     const eventName = stateService.getEventName();
 
     // 是否需要重绘
@@ -151,8 +154,6 @@ export default class Layer {
 
         elementService.setPoint(position);
         elementService.showPoint();
-
-        addRoad.setNewRoadPoint("start", position);
         break;
       case LayerEvents.AddingRoad:
         needAutoRedraw = true;
@@ -179,11 +180,26 @@ export default class Layer {
         }
         break;
       case LayerEvents.MoveRoad:
+        needAutoRedraw = true;
+        //只允许拖拽一条公路
+        let road = dataService.getRoad(draggingItem.vectorId);
+        let start = dataService.getPoint(road.startId);
+        let end = dataService.getPoint(road.endId);
+        if (
+          Object.keys(start.getParent()).length == 1 &&
+          Object.keys(end.getParent()).length == 1
+        ) {
+          //拖拽的路只有一条
+          moveRoad.moveTo(
+            draggingItem.vectorId,
+            (dx * coordinate.defaultZoom) / coordinate.zoom,
+            (dy * coordinate.defaultZoom) / coordinate.zoom
+          );
+        }
+        this.lastX = X;
+        this.lastY = Y;
         break;
       case LayerEvents.MoveRoadPoint:
-        if (!this.dragging) {
-          return;
-        }
         let point = dataService.getPoint(draggingItem.vectorId);
         listenLayer.start(position, draggingItem.vectorId, point.parent);
         if (listenLayer.modifyPoint) {
@@ -354,6 +370,9 @@ export default class Layer {
           this.history.save();
         }
         break;
+      case LayerEvents.AddRoad:
+        addRoad.setNewRoadPoint("start", position);
+        break;
       case LayerEvents.AddingRoad:
         needAutoRedraw = true;
         if (addRoad.canAdd) {
@@ -417,6 +436,41 @@ export default class Layer {
     }
   }
 
+  //测试用
+  onKeydown(e) {
+    let focusItem = stateService.getFocusItem();
+    if (focusItem) {
+      if (e.code == "Delete") {
+        //删除
+        const road = dataService.getRoad(focusItem.vectorId);
+        roadService.subtraRoadFromIntersect(road.startId, focusItem.vectorId);
+        roadService.subtraRoadFromIntersect(road.endId, focusItem.vectorId);
+        //dataService.deleteControlPoint()
+        dataService.deleteRoad(focusItem.vectorId);
+        this.renderer.autoRedraw();
+        this.history.save();
+      }
+      //加宽
+      if (e.code == "KeyA") {
+        const road = dataService.getRoad(focusItem.vectorId);
+        road.width += 100;
+        edgeService.updateEdgeForMovePoint(road.startId);
+        edgeService.updateEdgeForMovePoint(road.endId);
+        this.renderer.autoRedraw();
+        this.history.save();
+      }
+      //变窄
+      if (e.code == "KeyB") {
+        const road = dataService.getRoad(focusItem.vectorId);
+        road.width -= 50;
+        edgeService.updateEdgeForMovePoint(road.startId);
+        edgeService.updateEdgeForMovePoint(road.endId);
+        this.renderer.autoRedraw();
+        this.history.save();
+      }
+    }
+  }
+
   setEventName(eventType) {
     let eventName = stateService.getEventName();
 

src/graphic/Service/EdgeService.js

@@ -493,13 +493,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.start, newEdgePoint1);
         mathUtil.clonePoint(rightEdge2.start, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
+        //dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
+        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(
@@ -519,13 +521,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.start, newEdgePoint2);
         mathUtil.clonePoint(leftEdge2.start, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
+        //dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.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(
@@ -565,16 +569,18 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.start, newEdgePoint1);
         mathUtil.clonePoint(leftEdge2.end, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(
-          rightEdge1.vectorId,
-          rightEdge2.vectorId
-        );
+        // dataService.deleteControlPoint(
+        //   rightEdge1.vectorId,
+        //   rightEdge2.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(
@@ -592,13 +598,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.start, newEdgePoint2);
         mathUtil.clonePoint(rightEdge2.end, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        //dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.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(
@@ -638,16 +646,18 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.end, newEdgePoint1);
         mathUtil.clonePoint(leftEdge2.start, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(
-          rightEdge1.vectorId,
-          rightEdge2.vectorId
-        );
+        // dataService.deleteControlPoint(
+        //   rightEdge1.vectorId,
+        //   rightEdge2.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(
@@ -665,13 +675,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.end, newEdgePoint2);
         mathUtil.clonePoint(rightEdge2.start, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        //dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.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(
@@ -711,13 +723,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.end, newEdgePoint1);
         mathUtil.clonePoint(rightEdge2.end, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge2.vectorId, rightEdge1.vectorId);
+        //dataService.deleteControlPoint(leftEdge2.vectorId, rightEdge1.vectorId);
+        dataService.deleteControlPointForEdge(leftEdge1.vectorId);
+        dataService.deleteControlPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            leftEdge1.vectorId,
-            rightEdge2.vectorId
-          );
+          // dataService.deleteControlPoint(
+          //   leftEdge1.vectorId,
+          //   leftEdge2.vectorId
+          // );
         } else {
           //需要考虑控制点ControlPointService
           controlPointService.update(
@@ -735,13 +749,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.end, newEdgePoint2);
         mathUtil.clonePoint(leftEdge2.end, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
+        //dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.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

@@ -5,6 +5,7 @@ import { pointService } from "./PointService.js";
 import { edgeService } from "./EdgeService.js";
 import { mathUtil } from "../Util/MathUtil.js";
 import Constant from "../Constant";
+import { controlPointService } from "./ControlPointService.js";
 export default class RoadService {
   constructor() {}
 
@@ -72,11 +73,13 @@ export default class RoadService {
       newRoad = this.create(pointId, road.endId);
       //修改旧公路的end
       point.setPointParent(roadId, "end");
+      road.endId = pointId;
     } else if (dir == "end") {
       delete startPoint.parent[roadId];
-      newRoad = this.create(road.start, pointId);
+      newRoad = this.create(road.startId, pointId);
       //修改旧公路的start
       point.setPointParent(roadId, "start");
+      road.startId = pointId;
     }
     edgeService.updateEdgeForTwoRoad(roadId, newRoad.vectorId);
     return newRoad.vectorId;
@@ -420,6 +423,12 @@ export default class RoadService {
 
     if (Object.keys(parent).length == 1) {
       return;
+    } else if (Object.keys(parent).length > 2) {
+      const info = this.roadIdForMinAngle(pointId, roadId);
+      edgeService.updateSingleEdgeForTwoRoad(
+        info.min0.roadId,
+        info.min1.roadId
+      );
     }
 
     // 第一步先断开链接
@@ -428,12 +437,9 @@ export default class RoadService {
     const newPoint = pointService.create(point);
     // 第三步建立链接
     newPoint.setPointParent(roadId, dir);
-    let road = dataService.getRoad(roadId);
-    if (dir == "start") {
-      road.startId = newPoint.vectorId;
-    } else if (dir == "end") {
-      road.endId = newPoint.vectorId;
-    }
+    this.setRoadPointId(roadId, pointId, dir);
+    // 第四步更新Edge
+    edgeService.updateDefaultEdge(roadId, dir);
   }
 
   // pointId1移动到pointId2
@@ -508,6 +514,39 @@ export default class RoadService {
     return true;
   }
 
+  setRoadPointId = function (roadId, pointId, dir) {
+    const vectorInfo = {};
+    vectorInfo.roadId = roadId;
+    vectorInfo.dir = dir;
+    vectorInfo.pointId = pointId;
+    this.setRoadInfo(vectorInfo);
+  };
+
+  setRoadInfo(vectorInfo) {
+    const road = dataService.getRoad(vectorInfo.roadId);
+    if (
+      vectorInfo.hasOwnProperty("edgeId") &&
+      vectorInfo.hasOwnProperty("dir")
+    ) {
+      if (vectorInfo.dir == "left") {
+        road.leftEdgeId = vectorInfo.edgeId;
+      } else if (vectorInfo.dir == "right") {
+        road.rightEdgeId = vectorInfo.edgeId;
+      }
+    }
+
+    if (
+      vectorInfo.hasOwnProperty("pointId") &&
+      vectorInfo.hasOwnProperty("dir")
+    ) {
+      if (vectorInfo.dir == "start") {
+        road.startId = vectorInfo.pointId;
+      } else if (vectorInfo.dir == "end") {
+        road.endId = vectorInfo.pointId;
+      }
+    }
+  }
+
   AngleForRoad2(id1, id2) {
     let road1 = dataService.getRoad(id1);
     let road2 = dataService.getRoad(id2);
@@ -740,6 +779,46 @@ export default class RoadService {
       return null;
     }
   }
+
+  deleteRoad(roadId) {
+    const road = dataService.getRoad(roadId);
+    let startPoint = dataService.getPoint(road.startId);
+    let endPoint = dataService.getPoint(road.endId);
+    if (Object.keys(startPoint.getParent()).length > 2) {
+      this.subtraRoadFromIntersect(road.startId, roadId);
+    }
+    if (Object.keys(endPoint.getParent()).length > 2) {
+      this.subtraRoadFromIntersect(road.endId, roadId);
+    }
+  }
+
+  /****************************************************************************************************************************************************************/
+  //中心线添加控制点
+  insert(roadId, cp) {}
+
+  updateDrivewayCount(roadId, dir, type) {
+    let road = dataService.getRoad(roadId);
+    if (dir == "left") {
+      if (type == "add") {
+        ++road.leftDrivewayCount;
+      } else if (type == "sub") {
+        --road.leftDrivewayCount;
+        if (road.leftDrivewayCount < 0) {
+          road.leftDrivewayCount = 0;
+        }
+      }
+    } else if (dir == "right") {
+      if (type == "add") {
+        ++road.rightDrivewayCount;
+      } else if (type == "sub") {
+        --road.rightDrivewayCount;
+        if (road.rightDrivewayCount < 0) {
+          road.rightDrivewayCount = 0;
+        }
+      }
+    }
+  }
+  /****************************************************************************************************************************************************************/
 }
 
 const roadService = new RoadService();

src/graphic/Util/MathUtil.js

@@ -336,7 +336,7 @@ export default class MathUtil {
 
     if (cosfi >= 1.0) return 0;
     //if (cosfi <= -1.0) return Math.PI;
-    if (cosfi <= -1.0) return Math.PI;
+    if (cosfi <= -1.0) return 180;
     fi = Math.acos(cosfi);
 
     if ((180 * fi) / Math.PI < 180) {