添加直路的撤销与恢复功能

src/graphic/History/Change.js

@@ -27,6 +27,19 @@ export default class Change {
       JSON.stringify(dataService.getMagnifiers())
     );
     this.lastData.svgs = JSON.parse(JSON.stringify(dataService.getSVGs()));
+    this.lastData.roadPoints = JSON.parse(
+      JSON.stringify(dataService.getRoadPoints())
+    );
+    this.lastData.roadEdges = JSON.parse(
+      JSON.stringify(dataService.getRoadEdges())
+    );
+    this.lastData.roads = JSON.parse(JSON.stringify(dataService.getRoads()));
+    this.lastData.curveRoads = JSON.parse(
+      JSON.stringify(dataService.getCurveRoads())
+    );
+    this.lastData.controlPoints = JSON.parse(
+      JSON.stringify(dataService.getControlPoints())
+    );
   }
 
   operate() {
@@ -39,12 +52,20 @@ export default class Change {
     this.compareTexts();
     this.compareMagnifiers();
     this.compareSVGs();
+    this.compareRoadPoints();
+    this.compareRoadEdges();
+    this.compareRoads();
+    this.compareCurveRoads();
+    this.compareControlPoints();
     if (
       this.currentData.points.length == 0 &&
       this.currentData.lines.length == 0 &&
       this.currentData.circles.length == 0 &&
       this.currentData.texts.length == 0 &&
-      this.currentData.magnifiers.length == 0
+      this.currentData.magnifiers.length == 0 &&
+      this.currentData.roadPoints.length == 0 &&
+      this.currentData.roadEdges.length == 0 &&
+      this.currentData.roads.length == 0
     ) {
       this.saveCurrentInfo();
       return false;
@@ -330,6 +351,132 @@ export default class Change {
       this.currentData.svgs.push(item);
     }
   }
+
+  compareRoadPoints() {
+    this.currentData.roadPoints = [];
+    const roadPoints = dataService.getRoadPoints();
+
+    for (const key in roadPoints) {
+      const roadPoint = roadPoints[key];
+      const lastRoadPoint = this.lastData.roadPoints[key];
+
+      // 不存在意味着增加
+      if (!lastRoadPoint) {
+        const item = {
+          handle: HistoryEvents.AddRoadPoint,
+          roadPoint: historyUtil.getDataForRoadPoint(roadPoint),
+        };
+        this.currentData.roadPoints.push(item);
+      } else {
+        if (!historyUtil.isDifferentForRoadPoints(roadPoint, lastRoadPoint)) {
+          delete this.lastData.roadPoints[key];
+          continue;
+        } else {
+          const item = {
+            handle: HistoryEvents.ModifyRoadPoint,
+            preRoadPoint: historyUtil.getDataForRoadPoint(lastRoadPoint),
+            curRoadPoint: historyUtil.getDataForRoadPoint(roadPoint),
+          };
+          this.currentData.roadPoints.push(item);
+        }
+      }
+      delete this.lastData.roadPoints[key];
+    }
+
+    for (const key in this.lastData.roadPoints) {
+      const item = {
+        handle: HistoryEvents.DeleteRoadPoint,
+        roadPoint: historyUtil.getDataForRoadPoint(
+          this.lastData.roadPoints[key]
+        ),
+      };
+      this.currentData.roadPoints.push(item);
+    }
+  }
+
+  compareRoadEdges() {
+    this.currentData.roadEdges = [];
+    const roadEdges = dataService.getRoadEdges();
+
+    for (const key in roadEdges) {
+      const roadEdge = roadEdges[key];
+      const lastRoadEdge = this.lastData.roadEdges[key];
+
+      // 不存在意味着增加
+      if (!lastRoadEdge) {
+        const item = {
+          handle: HistoryEvents.AddRoadEdge,
+          roadEdge: historyUtil.getDataForRoadEdge(roadEdge),
+        };
+        this.currentData.roadEdges.push(item);
+      } else {
+        if (!historyUtil.isDifferentForRoadEdges(roadEdge, lastRoadEdge)) {
+          delete this.lastData.roadEdges[key];
+          continue;
+        } else {
+          const item = {
+            handle: HistoryEvents.ModifyRoadEdge,
+            preRoadEdge: historyUtil.getDataForRoadEdge(lastRoadEdge),
+            curRoadEdge: historyUtil.getDataForRoadEdge(roadEdge),
+          };
+          this.currentData.roadEdges.push(item);
+        }
+      }
+      delete this.lastData.roadEdges[key];
+    }
+
+    for (const key in this.lastData.roadEdges) {
+      const item = {
+        handle: HistoryEvents.DeleteRoadEdge,
+        roadEdge: historyUtil.getDataForRoadEdge(this.lastData.roadEdges[key]),
+      };
+      this.currentData.roadEdges.push(item);
+    }
+  }
+
+  compareRoads() {
+    this.currentData.roads = [];
+    const roads = dataService.getRoads();
+
+    for (const key in roads) {
+      const road = roads[key];
+      const lastRoad = this.lastData.roads[key];
+
+      // 不存在意味着增加
+      if (!lastRoad) {
+        const item = {
+          handle: HistoryEvents.AddRoad,
+          road: historyUtil.getDataForRoad(road),
+        };
+        this.currentData.roads.push(item);
+      } else {
+        if (!historyUtil.isDifferentForRoads(road, lastRoad)) {
+          delete this.lastData.roads[key];
+          continue;
+        } else {
+          const item = {
+            handle: HistoryEvents.ModifyRoad,
+            preRoad: historyUtil.getDataForRoad(lastRoad),
+            curRoad: historyUtil.getDataForRoad(road),
+          };
+          this.currentData.roads.push(item);
+        }
+      }
+      delete this.lastData.roads[key];
+    }
+
+    for (const key in this.lastData.roads) {
+      const item = {
+        handle: HistoryEvents.DeleteRoad,
+        road: historyUtil.getDataForRoad(this.lastData.roads[key]),
+      };
+      this.currentData.roads.push(item);
+    }
+  }
+
+  compareCurveRoads() {}
+
+  compareControlPoints() {}
 }
 
 const change = new Change();

src/graphic/History/History.js

@@ -11,6 +11,7 @@ import { roadPointService } from "../Service/RoadPointService";
 import { lineService } from "../Service/LineService";
 import { circleService } from "../Service/CircleService";
 import { pointService } from "../Service/PointService";
+import { edgeService } from "../Service/EdgeService";
 import { magnifierService } from "../Service/MagnifierService";
 
 export default class History {
@@ -99,6 +100,9 @@ export default class History {
       this.goPreForTexts(item.texts);
       this.goPreForMagnifiers(item.magnifiers);
       this.goPreForSVGs(item.svgs);
+      this.goPreForRoadPoints(item.roadPoints);
+      this.goPreForRoadEdges(item.roadEdges);
+      this.goPreForRoads(item.roads);
       historyService.undoHistoryRecord();
       change.saveCurrentInfo();
       this.setState();
@@ -224,6 +228,69 @@ export default class History {
     }
   }
 
+  goPreForRoadPoints(itemForRoadPoints) {
+    for (let i = 0; i < itemForRoadPoints.length; ++i) {
+      const item = itemForRoadPoints[i];
+      if (item.handle == HistoryEvents.AddRoadPoint) {
+        dataService.deleteRoadPoint(item.roadPoint.id);
+      } else if (item.handle == HistoryEvents.DeleteRoadPoint) {
+        let newRoadPoint = roadPointService.create(
+          item.roadPoint.position,
+          item.roadPoint.id
+        );
+        historyUtil.assignRoadPointFromRoadPoint(newRoadPoint, item.roadPoint);
+      } else if (item.handle == HistoryEvents.ModifyRoadPoint) {
+        const preRoadPoint = item.preRoadPoint;
+        let currentRoadPoint = dataService.getRoadPoint(item.curRoadPoint.id);
+        historyUtil.assignRoadPointFromRoadPoint(
+          currentRoadPoint,
+          preRoadPoint
+        );
+      }
+    }
+  }
+
+  goPreForRoadEdges(itemForRoadEdges) {
+    for (let i = 0; i < itemForRoadEdges.length; ++i) {
+      const item = itemForRoadEdges[i];
+      if (item.handle == HistoryEvents.AddRoadEdge) {
+        dataService.deleteRoadEdge(item.roadEdge.id);
+      } else if (item.handle == HistoryEvents.DeleteRoadEdge) {
+        let newRoadEdge = edgeService.create(
+          item.roadEdge.start,
+          item.roadEdge.end,
+          item.roadEdge.id,
+          item.roadEdge.parent
+        );
+        historyUtil.assignRoadEdgeFromRoadEdge(newRoadEdge, item.roadEdge);
+      } else if (item.handle == HistoryEvents.ModifyRoadEdge) {
+        const preRoadEdge = item.preRoadEdge;
+        let currentRoadEdge = dataService.getRoadEdge(item.curRoadEdge.id);
+        historyUtil.assignRoadEdgeFromRoadEdge(currentRoadEdge, preRoadEdge);
+      }
+    }
+  }
+
+  goPreForRoads(itemForRoads) {
+    for (let i = 0; i < itemForRoads.length; ++i) {
+      const item = itemForRoads[i];
+      if (item.handle == HistoryEvents.AddRoad) {
+        dataService.deleteRoad(item.road.id);
+      } else if (item.handle == HistoryEvents.DeleteRoad) {
+        let newRoad = roadService.create(
+          item.road.startId,
+          item.road.endId,
+          item.road.id
+        );
+        historyUtil.assignRoadFromRoad(newRoad, item.road);
+      } else if (item.handle == HistoryEvents.ModifyRoad) {
+        const preRoad = item.preRoad;
+        let currentRoad = dataService.getRoad(item.curRoad.id);
+        historyUtil.assignRoadFromRoad(currentRoad, preRoad);
+      }
+    }
+  }
+
   goNextForPoints(itemForPoints) {
     for (let i = 0; i < itemForPoints.length; ++i) {
       const item = itemForPoints[i];
@@ -341,6 +408,69 @@ export default class History {
     }
   }
 
+  goNextForRoadPoints(itemForRoadPoints) {
+    for (let i = 0; i < itemForRoadPoints.length; ++i) {
+      const item = itemForRoadPoints[i];
+      if (item.handle == HistoryEvents.AddRoadPoint) {
+        let vRoadPoint = roadPointService.create(
+          item.roadPoint.position,
+          item.roadPoint.id
+        );
+        historyUtil.assignRoadPointFromRoadPoint(vRoadPoint, item.roadPoint);
+      } else if (item.handle == HistoryEvents.DeleteRoadPoint) {
+        dataService.deleteRoadPoint(item.roadPoint.id);
+      } else if (item.handle == HistoryEvents.ModifyRoadPoint) {
+        const currentRoadPoint = item.curRoadPoint;
+        let preRoadPoint = dataService.getRoadPoint(item.curRoadPoint.id);
+        historyUtil.assignRoadPointFromRoadPoint(
+          preRoadPoint,
+          currentRoadPoint
+        );
+      }
+    }
+  }
+
+  goNextForRoadEdges(itemForRoadEdges) {
+    for (let i = 0; i < itemForRoadEdges.length; ++i) {
+      const item = itemForRoadEdges[i];
+      if (item.handle == HistoryEvents.AddRoadEdge) {
+        let vRoadEdge = edgeService.create(
+          item.roadEdge.start,
+          item.roadEdge.end,
+          item.roadEdge.id,
+          item.roadEdge.parent
+        );
+        historyUtil.assignRoadEdgeFromRoadEdge(vRoadEdge, item.roadEdge);
+      } else if (item.handle == HistoryEvents.DeleteRoadEdge) {
+        dataService.deleteRoadEdge(item.roadEdge.id);
+      } else if (item.handle == HistoryEvents.ModifyRoadEdge) {
+        const currentRoadEdge = item.curRoadEdge;
+        let preRoadEdge = dataService.getRoadEdge(item.curRoadEdge.id);
+        historyUtil.assignRoadEdgeFromRoadEdge(preRoadEdge, currentRoadEdge);
+      }
+    }
+  }
+
+  goNextForRoads(itemForRoads) {
+    for (let i = 0; i < itemForRoads.length; ++i) {
+      const item = itemForRoads[i];
+      if (item.handle == HistoryEvents.AddRoad) {
+        let vRoad = roadService.create(
+          item.road.startId,
+          item.road.endId,
+          item.road.id
+        );
+        historyUtil.assignRoadFromRoad(vRoad, item.road);
+      } else if (item.handle == HistoryEvents.DeleteRoad) {
+        dataService.deleteRoad(item.road.id);
+      } else if (item.handle == HistoryEvents.ModifyRoad) {
+        const currentRoad = item.curRoad;
+        let preRoad = dataService.getRoad(item.curRoad.id);
+        historyUtil.assignRoadFromRoad(preRoad, currentRoad);
+      }
+    }
+  }
+
   // 恢复
   goNextState() {
     historyService.redoHistoryRecord();
@@ -354,6 +484,9 @@ export default class History {
       this.goNextForTexts(item.texts);
       this.goNextForMagnifiers(item.magnifiers);
       this.goNextForSVGs(item.svgs);
+      this.goNextForRoadPoints(item.roadPoints);
+      this.goNextForRoadEdges(item.roadEdges);
+      this.goNextForRoads(item.roads);
       change.saveCurrentInfo();
       this.setState();
     } else {

src/graphic/History/HistoryUtil.js

@@ -1,6 +1,7 @@
 import { mathUtil } from "../Util/MathUtil";
 import { dataService } from "../Service/DataService";
 import { textService } from "../Service/TextService";
+import Constant from "../Constant";
 
 export default class HistoryUtil {
   constructor() {}
@@ -83,6 +84,66 @@ export default class HistoryUtil {
     }
   }
 
+  isDifferentForRoadPoints(roadPoint1, roadPoint2) {
+    if (
+      mathUtil.equalPoint(roadPoint1, roadPoint2) &&
+      JSON.stringify(roadPoint1.parent) == JSON.stringify(roadPoint2.parent)
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  isDifferentForRoadEdges(roadEdge1, roadEdge2) {
+    if (
+      mathUtil.equalPoint(roadEdge1.start, roadEdge2.start) &&
+      mathUtil.equalPoint(roadEdge1.end, roadEdge2.end) &&
+      roadEdge1.parent == roadEdge2.parent
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  isDifferentForRoads(road1, road2) {
+    if (
+      road1.startId == road2.startId &&
+      road1.endId == road2.endId &&
+      road1.leftEdgeId == road2.leftEdgeId &&
+      road1.rightEdgeId == road2.rightEdgeId &&
+      road1.way == road2.way
+    ) {
+      if (road1.way == Constant.oneWay) {
+        if (
+          road1.singleRoadWidth == road2.singleRoadWidth &&
+          road1.singleRoadDrivewayCount == road2.singleRoadDrivewayCount
+        ) {
+          return false;
+        } else {
+          return true;
+        }
+      } else if (road1.way == Constant.twoWay) {
+        if (
+          road1.leftWidth == road2.leftWidth &&
+          road1.rightWidth == road2.rightWidth &&
+          road1.leftDrivewayCount == road2.leftDrivewayCount &&
+          road1.rightDrivewayCount == road2.rightDrivewayCount &&
+          road1.midDivide.midDivideWidth == road2.midDivide.midDivideWidth
+        ) {
+          return false;
+        } else {
+          return true;
+        }
+      } else {
+        return true;
+      }
+    } else {
+      return true;
+    }
+  }
+
   // // road2赋值给road1
   // assignRoadFromRoad(road1, road2) {
   //   const roadInfo = {};
@@ -147,6 +208,50 @@ export default class HistoryUtil {
     this.setSVGInfo(svgInfo);
   }
 
+  assignRoadPointFromRoadPoint(roadPoint1, roadPoint2) {
+    const roadPointInfo = {};
+    roadPointInfo.vectorId = roadPoint1.vectorId;
+    roadPointInfo.position = {
+      x: roadPoint2.position.x,
+      y: roadPoint2.position.y,
+    };
+    roadPointInfo.parent = JSON.parse(JSON.stringify(roadPoint2.parent));
+    this.setRoadPointInfo(roadPointInfo);
+  }
+
+  assignRoadEdgeFromRoadEdge(roadEdge1, roadEdge2) {
+    const roadEdgeInfo = {};
+    roadEdgeInfo.vectorId = roadEdge1.vectorId;
+    roadEdgeInfo.start = { x: roadEdge2.start.x, y: roadEdge2.start.y };
+    roadEdgeInfo.end = { x: roadEdge2.end.x, y: roadEdge2.end.y };
+    roadEdgeInfo.parent = roadEdge2.parent;
+    this.setRoadEdgeInfo(roadEdgeInfo);
+  }
+
+  assignRoadFromRoad(road1, road2) {
+    const roadInfo = {};
+    roadInfo.vectorId = road1.vectorId;
+    roadInfo.startId = road2.startId;
+    roadInfo.endId = road2.endId;
+    roadInfo.leftEdgeId = road2.leftEdgeId;
+    roadInfo.rightEdgeId = road2.rightEdgeId;
+    roadInfo.way = road2.way;
+    if (road2.way == Constant.oneWay) {
+      roadInfo.singleRoadWidth = road2.singleRoadWidth;
+      roadInfo.singleRoadDrivewayCount = road2.singleRoadDrivewayCount;
+      roadInfo.singleLanes = JSON.parse(JSON.stringify(road2.singleLanes));
+    } else if (road2.way == Constant.twoWay) {
+      roadInfo.leftWidth = road2.leftWidth;
+      roadInfo.rightWidth = road2.rightWidth;
+      roadInfo.leftDrivewayCount = road2.leftDrivewayCount;
+      roadInfo.rightDrivewayCount = road2.rightDrivewayCount;
+      roadInfo.midDivide = JSON.parse(JSON.stringify(road2.midDivide));
+      roadInfo.leftLanes = JSON.parse(JSON.stringify(road2.leftLanes));
+      roadInfo.rightLanes = JSON.parse(JSON.stringify(road2.rightLanes));
+    }
+    this.setRoadInfo(roadInfo);
+  }
+
   getDataForPoint(point) {
     const data = {};
     data.id = point.vectorId;
@@ -211,12 +316,52 @@ export default class HistoryUtil {
     return data;
   }
 
-  // setRoadInfo(roadInfo) {
-  //   let road = dataService.getRoad(roadInfo.vectorId);
-  //   road.start = roadInfo.start;
-  //   road.end = roadInfo.end;
-  //   return road;
-  // }
+  getDataForRoadPoint(roadPoint) {
+    const data = {};
+    data.id = roadPoint.vectorId;
+    data.type = roadPoint.geoType;
+    data.position = {};
+    mathUtil.clonePoint(data.position, roadPoint);
+    data.parent = JSON.parse(JSON.stringify(roadPoint.parent));
+    return data;
+  }
+
+  getDataForRoadEdge(roadEdge) {
+    const data = {};
+    data.id = roadEdge.vectorId;
+    data.type = roadEdge.geoType;
+    data.parent = roadEdge.parent;
+    data.start = {};
+    data.start = JSON.parse(JSON.stringify(roadEdge.start));
+    data.end = {};
+    data.end = JSON.parse(JSON.stringify(roadEdge.end));
+    return data;
+  }
+
+  getDataForRoad(road) {
+    const data = {};
+    data.id = road.vectorId;
+    data.type = road.geoType;
+    data.startId = road.startId;
+    data.endId = road.endId;
+    data.leftEdgeId = road.leftEdgeId;
+    data.rightEdgeId = road.rightEdgeId;
+    data.way = road.way;
+    if (road.way == Constant.oneWay) {
+      data.singleRoadWidth = road.singleRoadWidth;
+      data.singleRoadDrivewayCount = road.singleRoadDrivewayCount;
+      data.singleLanes = JSON.parse(JSON.stringify(road.singleLanes));
+    } else if (road.way == Constant.twoWay) {
+      data.leftWidth = road.leftWidth;
+      data.rightWidth = road.rightWidth;
+      data.leftDrivewayCount = road.leftDrivewayCount;
+      data.rightDrivewayCount = road.rightDrivewayCount;
+      data.midDivide = JSON.parse(JSON.stringify(road.midDivide));
+      data.leftLanes = JSON.parse(JSON.stringify(road.leftLanes));
+      data.rightLanes = JSON.parse(JSON.stringify(road.rightLanes));
+    }
+    return data;
+  }
 
   setPointInfo(pointInfo) {
     let point = dataService.getPoint(pointInfo.vectorId);
@@ -266,6 +411,44 @@ export default class HistoryUtil {
     svg.center = JSON.parse(JSON.stringify(svgInfo.center));
     svg.name = svgInfo.name;
   }
+
+  setRoadPointInfo(roadPointInfo) {
+    let roadPoint = dataService.getRoadPoint(roadPointInfo.vectorId);
+    roadPoint.vectorId = roadPointInfo.vectorId;
+    mathUtil.clonePoint(roadPoint, roadPointInfo.position);
+    roadPoint.parent = JSON.parse(JSON.stringify(roadPointInfo.parent));
+  }
+
+  setRoadEdgeInfo(roadEdgeInfo) {
+    let roadEdge = dataService.getRoadEdge(roadEdgeInfo.vectorId);
+    roadEdge.vectorId = roadEdgeInfo.vectorId;
+    mathUtil.clonePoint(roadEdge.start, roadEdgeInfo.start);
+    mathUtil.clonePoint(roadEdge.end, roadEdgeInfo.end);
+    roadEdge.name = roadEdgeInfo.name;
+  }
+
+  setRoadInfo(roadInfo) {
+    let road = dataService.getRoad(roadInfo.vectorId);
+    road.vectorId = roadInfo.vectorId;
+    road.startId = roadInfo.startId;
+    road.endId = roadInfo.endId;
+    road.leftEdgeId = roadInfo.leftEdgeId;
+    road.rightEdgeId = roadInfo.rightEdgeId;
+    road.way = roadInfo.way;
+    if (road.way == Constant.oneWay) {
+      road.singleRoadWidth = roadInfo.singleRoadWidth;
+      road.singleRoadDrivewayCount = roadInfo.singleRoadDrivewayCount;
+      road.singleLanes = JSON.parse(JSON.stringify(roadInfo.singleLanes));
+    } else if (road.way == Constant.twoWay) {
+      road.leftWidth = roadInfo.leftWidth;
+      road.rightWidth = roadInfo.rightWidth;
+      road.leftDrivewayCount = roadInfo.leftDrivewayCount;
+      road.rightDrivewayCount = roadInfo.rightDrivewayCount;
+      road.midDivide = JSON.parse(JSON.stringify(roadInfo.midDivide));
+      road.leftLanes = JSON.parse(JSON.stringify(roadInfo.leftLanes));
+      road.rightLanes = JSON.parse(JSON.stringify(roadInfo.rightLanes));
+    }
+  }
 }
 
 const historyUtil = new HistoryUtil();

src/graphic/Service/DataService.js

@@ -300,10 +300,6 @@ export class DataService {
     delete this.vectorData.roads[roadId];
   }
 
-  deleteRoadEdge(edgeId) {
-    delete this.vectorData.roadEdges[edgeId];
-  }
-
   /**
    * 对端点的操作
    */
@@ -348,6 +344,14 @@ export class DataService {
     this.vectorData.roadPoints[roadPoint.vectorId] = roadPoint;
   }
 
+  getRoadEdges() {
+    return this.vectorData.roadEdges;
+  }
+
+  deleteRoadEdge(edgeId) {
+    delete this.vectorData.roadEdges[edgeId];
+  }
+
   getRoadEdge(roadEdgeId) {
     return this.vectorData.roadEdges[roadEdgeId];
   }

src/graphic/enum/HistoryEvents.js

@@ -1,7 +1,11 @@
 const HistoryEvents = {
   AddRoadPoint: "addRoadPoint",
-  DeletePoint: "deletePoint",
-  ModifyPoint: "modifyPoint",
+  DeleteRoadPoint: "deleteRoadPoint",
+  ModifyRoadPoint: "modifyRoadPoint",
+
+  AddRoadEdge: "addRoadEdge",
+  DeleteRoadEdge: "deleteRoadEdge",
+  ModifyRoadEdge: "modifyRoadEdge",
 
   AddRoad: "addRoad",
   DeleteRoad: "deleteRoad",