因为要支持画直线，所以之前的Point要换成RoadPoint

src/graphic/Controls/AddRoad.js

@@ -2,7 +2,7 @@ import { listenLayer } from "../ListenLayer";
 import Constant from "../Constant";
 import { mathUtil } from "../Util/MathUtil";
 import { dataService } from "../Service/DataService";
-import { pointService } from "../Service/PointService";
+import { roadPointService } from "../Service/RoadPointService";
 import { curvePointService } from "../Service/CurvePointService";
 import { curveRoadService } from "../Service/CurveRoadService";
 import { stateService } from "../Service/StateService";
@@ -52,7 +52,7 @@ export default class AddRoad {
 
     let hasComputerRoadIds = [];
     for (let i = 0; i < splitPointIds.length; ++i) {
-      let point = dataService.getPoint(splitPointIds[i]);
+      let point = dataService.getRoadPoint(splitPointIds[i]);
       let parent = point.getParent();
       for (let key in parent) {
         if (hasComputerRoadIds.indexOf(key) < 0) {
@@ -162,8 +162,8 @@ export default class AddRoad {
         continue;
       }
 
-      let startPoint = dataService.getPoint(road.startId);
-      let endPoint = dataService.getPoint(road.endId);
+      let startPoint = dataService.getRoadPoint(road.startId);
+      let endPoint = dataService.getRoadPoint(road.endId);
       let flag = false;
 
       if (hasComputerPointIds.indexOf(road.startId) < 0) {
@@ -252,7 +252,7 @@ export default class AddRoad {
         splitPointIds.push(pointId);
       } else if (roadId) {
         // 拆分roadId
-        const splitPoint = pointService.create(join);
+        const splitPoint = roadPointService.create(join);
         const splitPointId = splitPoint.vectorId;
         //可能joinInfos的两个点都在roadId上
         let newRoadId = null;
@@ -261,7 +261,7 @@ export default class AddRoad {
           joinInfos[i].roadId == joinInfos[i + 1].roadId
         ) {
           let road = dataService.getRoad(roadId);
-          let startPoint = dataService.getPoint(road.startId);
+          let startPoint = dataService.getRoadPoint(road.startId);
           if (
             mathUtil.getDistance(startPoint, joinInfos[i].join) <
             mathUtil.getDistance(startPoint, joinInfos[i + 1].join)
@@ -275,14 +275,14 @@ export default class AddRoad {
         }
 
         if (newRoadId == null) {
-          dataService.deletePoint(splitPointId);
+          dataService.deleteRoadPoint(splitPointId);
           continue;
         }
         splitPointIds.push(splitPointId);
       }
       //首尾没有吸附的情况
       else {
-        const splitPoint = pointService.create(join);
+        const splitPoint = roadPointService.create(join);
         splitPointIds.push(splitPoint.vectorId);
       }
     }

src/graphic/Controls/MoveRoad.js

@@ -21,7 +21,7 @@ export default class MoveRoad {
   // 测试要考虑pointId拖拽到包含他的所有墙的另一头
   // 这个函数不会删除/拆分/合并墙或者点
   moveingRoadPoint(pointId, position, modifyPoint) {
-    let point = dataService.getPoint(pointId);
+    let point = dataService.getRoadPoint(pointId);
     let linkedPointId = null;
     let linkedRoadId = null;
 
@@ -58,8 +58,8 @@ export default class MoveRoad {
       const road = dataService.getRoad(this.adsorbPointRoads[adsorbPointId]);
 
       const otherPointId = road.getOtherPointId(pointId);
-      let otherPoint = dataService.getPoint(otherPointId);
-      let modifyPoint = dataService.getPoint(adsorbPointId);
+      let otherPoint = dataService.getRoadPoint(otherPointId);
+      let modifyPoint = dataService.getRoadPoint(adsorbPointId);
       let line = mathUtil.createLine1(otherPoint, modifyPoint);
       position = mathUtil.getJoinLinePoint(position, line);
       point.setPosition(position);
@@ -85,8 +85,8 @@ export default class MoveRoad {
     // 如果墙面的交点与其余墙角的距离过短，那也不允许拖动
     else if (modifyPoint.hasOwnProperty("linkedRoadId")) {
       const road = dataService.getRoad(modifyPoint.linkedRoadId);
-      const startPoint = dataService.getPoint(road.startId);
-      const endPoint = dataService.getPoint(road.endId);
+      const startPoint = dataService.getRoadPoint(road.startId);
+      const endPoint = dataService.getRoadPoint(road.endId);
 
       // 与其余墙角的距离过短，不允许拖动
       if (
@@ -127,7 +127,7 @@ export default class MoveRoad {
     let joins = [];
     let roadId = null;
     for (let key in this.adsorbPointRoads) {
-      let point = dataService.getPoint(key);
+      let point = dataService.getRoadPoint(key);
       joins.push({
         join: point,
         pointId: key,
@@ -136,7 +136,7 @@ export default class MoveRoad {
     }
 
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
+    const startPoint = dataService.getRoadPoint(road.startId);
 
     function sortNumber(a, b) {
       return (
@@ -160,8 +160,8 @@ export default class MoveRoad {
     dy = -dy;
 
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
 
     const p1 = { x: startPoint.x + dx, y: startPoint.y + dy };
     const p2 = { x: endPoint.x + dx, y: endPoint.y + dy };
@@ -174,8 +174,8 @@ export default class MoveRoad {
 
   getTwoLimitInfos(roadId, newLine) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     let startLimitLine, endLimitLine, info;
     const roadLine = roadService.getMidLine(road);
 
@@ -209,11 +209,11 @@ export default class MoveRoad {
       let tempRoad, tempRoadId;
       info = roadService.roadIdForMinAngle(road.startId, roadId);
       const road1 = dataService.getRoad(info.min0.roadId);
-      const startPoint1 = dataService.getPoint(road1.startId);
-      const endPoint1 = dataService.getPoint(road1.endId);
+      const startPoint1 = dataService.getRoadPoint(road1.startId);
+      const endPoint1 = dataService.getRoadPoint(road1.endId);
       const road2 = dataService.getRoad(info.min1.roadId);
-      const startPoint2 = dataService.getPoint(road2.startId);
-      const endPoint2 = dataService.getPoint(road2.endId);
+      const startPoint2 = dataService.getRoadPoint(road2.startId);
+      const endPoint2 = dataService.getRoadPoint(road2.endId);
 
       const join1 = mathUtil.getIntersectionPoint4(
         startPoint1,
@@ -261,8 +261,8 @@ export default class MoveRoad {
       startLimitLine = roadService.getMidLine(tempRoad);
 
       let join = mathUtil.getIntersectionPoint(startLimitLine, newLine);
-      const tempStartPoint = dataService.getPoint(tempRoad.startId);
-      const tempEndPoint = dataService.getPoint(tempRoad.endId);
+      const tempStartPoint = dataService.getRoadPoint(tempRoad.startId);
+      const tempEndPoint = dataService.getRoadPoint(tempRoad.endId);
       if (
         angle > Constant.maxAngle ||
         !mathUtil.isPointOnSegment(join, tempStartPoint, tempEndPoint)
@@ -296,11 +296,11 @@ export default class MoveRoad {
       let tempRoad, tempRoadId;
       info = dataService.roadIdForMinAngle(road.endId, roadId);
       const road1 = dataService.getRoad(info.min0.roadId);
-      const startPoint1 = dataService.getPoint(road1.startId);
-      const endPoint1 = dataService.getPoint(road1.endId);
+      const startPoint1 = dataService.getRoadPoint(road1.startId);
+      const endPoint1 = dataService.getRoadPoint(road1.endId);
       const road2 = dataService.getRoad(info.min1.roadId);
-      const startPoint2 = dataService.getPoint(road2.startId);
-      const endPoint2 = dataService.getPoint(road2.endId);
+      const startPoint2 = dataService.getRoadPoint(road2.startId);
+      const endPoint2 = dataService.getRoadPoint(road2.endId);
 
       const join1 = mathUtil.getIntersectionPoint4(
         startPoint1,
@@ -347,8 +347,8 @@ export default class MoveRoad {
       const angle = roadService.AngleForRoad(tempRoadId, roadId);
       endLimitLine = roadService.getMidLine(tempRoad);
       let join = mathUtil.getIntersectionPoint(endLimitLine, newLine);
-      const tempStartPoint = dataService.getPoint(tempRoad.start);
-      const tempEndPoint = dataService.getPoint(tempRoad.end);
+      const tempStartPoint = dataService.getRoadPoint(tempRoad.start);
+      const tempEndPoint = dataService.getRoadPoint(tempRoad.end);
 
       if (
         angle > Constant.maxAngle ||
@@ -367,7 +367,7 @@ export default class MoveRoad {
   // 是否可以移动point
   // 两个判断：拖拽的墙（可能是多个），一方面不能与其他墙相交，另一方面这些墙之间或者与别的墙之间的角度必须大于Constant.minAngle
   canMoveForPoint(pointId, position, linkedPointId, linkedRoadId) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     // 先判断第二点(这些墙之间或者与别的墙之间的角度必须大于MinAngle)
     let flag = this.isOKForMinAngleRoad(pointId, position);
     // 开始考虑第一点
@@ -385,7 +385,7 @@ export default class MoveRoad {
   }
 
   isOKForMinAngleRoad(pointId, position) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     const parent = point.parent;
 
     const angle = this.getMinAngle(pointId, position);
@@ -401,7 +401,7 @@ export default class MoveRoad {
       if (info && Math.abs(info.angle) < Constant.minAngle) {
         return false;
       } else {
-        const otherPoint = dataService.getPoint(otherPointId);
+        const otherPoint = dataService.getRoadPoint(otherPointId);
         if (mathUtil.getDistance(position, otherPoint) < Constant.minRealDis) {
           return false;
         }
@@ -413,7 +413,7 @@ export default class MoveRoad {
 
   //点pointId移动到position后，求出最小角度
   getMinAngle(pointId, position) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     const parent = point.parent;
     let angle = null;
     if (Object.keys(parent).length == 1) {
@@ -423,9 +423,9 @@ export default class MoveRoad {
       const road2 = dataService.getRoad(Object.keys(parent)[1]);
 
       const otherPointId1 = road1.getOtherPointId(pointId);
-      const otherPoint1 = dataService.getPoint(otherPointId1);
+      const otherPoint1 = dataService.getRoadPoint(otherPointId1);
       const otherPointId2 = road2.getOtherPointId(pointId);
-      const otherPoint2 = dataService.getPoint(otherPointId2);
+      const otherPoint2 = dataService.getRoadPoint(otherPointId2);
 
       angle = mathUtil.Angle(position, otherPoint1, otherPoint2);
       return angle;
@@ -438,7 +438,7 @@ export default class MoveRoad {
       for (const key in parent) {
         const road = dataService.getRoad(key);
         const otherPointId = road.getOtherPointId(pointId);
-        const otherPoint = dataService.getPoint(otherPointId);
+        const otherPoint = dataService.getRoadPoint(otherPointId);
         if (mathUtil.equalPoint(_position, otherPoint)) {
           angles.push(0);
           continue;
@@ -484,7 +484,7 @@ export default class MoveRoad {
   // pointId是顶点
   // position是roadId相对于pointId另一头的点的坐标，一般发生改变的时候使用这个函数
   getNeighMinAngle(otherPointId, roadId, position) {
-    const point1 = dataService.getPoint(otherPointId);
+    const point1 = dataService.getRoadPoint(otherPointId);
     const point2 = {
       x: position.x,
       y: position.y,
@@ -501,7 +501,7 @@ export default class MoveRoad {
 
       const road = dataService.getRoad(key);
       pointId3 = road.getOtherPointId(otherPointId);
-      point3 = dataService.getPoint(pointId3);
+      point3 = dataService.getRoadPoint(pointId3);
 
       const angle = mathUtil.Angle(point1, point2, point3);
       if (minAngle == null || minAngle > angle) {
@@ -533,7 +533,7 @@ export default class MoveRoad {
         }
         const _road = dataService.getRoad(_key);
         const otherPointId = _road.getOtherPointId(pointId);
-        const otherPoint = dataService.getPoint(otherPointId);
+        const otherPoint = dataService.getRoadPoint(otherPointId);
 
         const flag = this.isOKForCrossTwoRoad(
           position,
@@ -572,8 +572,8 @@ export default class MoveRoad {
     dragRoadId
   ) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     const join = mathUtil.getIntersectionPoint3(
       position1,
       position2,
@@ -651,8 +651,8 @@ export default class MoveRoad {
 
   isOKForCrossTwoRoad2(position1, position2, roadId) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     let flag = mathUtil.crossTwoLines(
       position1,
       position2,
@@ -678,8 +678,8 @@ export default class MoveRoad {
 
   isOKForCrossTwoRoad3(position1, position2, roadId) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     const flag = mathUtil.crossTwoLines(
       position1,
       position2,
@@ -728,8 +728,8 @@ export default class MoveRoad {
 
   isCoincide(position1, position2, roadId) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     let line = mathUtil.createLine1(position1, position2);
     let join1 = mathUtil.getJoinLinePoint(startPoint, line);
     let join2 = mathUtil.getJoinLinePoint(endPoint, line);
@@ -770,14 +770,14 @@ export default class MoveRoad {
   // 更新virtualPosition（一般是吸附）
   updateVirtualPosition(pointId, virtualPosition, limitRoadId, needNew) {
     const limitRoad = dataService.getRoad(limitRoadId);
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     let otherPointId, otherPoint;
     let adsorb = false;
     // 不需要新建墙
     if (!needNew) {
       if (limitRoad != null) {
         otherPointId = limitRoad.getOtherPointId(pointId);
-        otherPoint = dataService.getPoint(otherPointId);
+        otherPoint = dataService.getRoadPoint(otherPointId);
         // 会吸附另一头
         if (
           mathUtil.getDistance(virtualPosition, otherPoint) <
@@ -807,9 +807,9 @@ export default class MoveRoad {
 
   // 两条线段的夹角，这两条线段分别有一个端点挨的很近
   isOKForTwoSegmentsAngle(pointId, pointId1, pointId2) {
-    const point = dataService.getPoint(pointId);
-    const point1 = dataService.getPoint(pointId1);
-    const point2 = dataService.getPoint(pointId2);
+    const point = dataService.getRoadPoint(pointId);
+    const point1 = dataService.getRoadPoint(pointId1);
+    const point2 = dataService.getRoadPoint(pointId2);
     const dx = point.x - point1.x;
     const dy = point.y - point1.y;
 
@@ -821,7 +821,7 @@ export default class MoveRoad {
     for (const key in point.parent) {
       const road = dataService.getRoad(key);
       const otherPointId = road.getOtherPointId(pointId);
-      const otherPoint = dataService.getPoint(otherPointId);
+      const otherPoint = dataService.getRoadPoint(otherPointId);
       const angle = mathUtil.Angle(point, otherPoint, newPoint2);
       if (Math.abs(angle) < Constant.minAngle) {
         return false;
@@ -852,7 +852,7 @@ export default class MoveRoad {
       }
       // 可能吸附的是两堵墙，但是这两堵墙呈180°
       else {
-        let adsorbPoint = dataService.getPoint(adsorbPointId1);
+        let adsorbPoint = dataService.getRoadPoint(adsorbPointId1);
         let parent = adsorbPoint.parent;
         for (const key in parent) {
           const angle = roadService.AngleForRoad3(roadId, key);
@@ -861,7 +861,7 @@ export default class MoveRoad {
           }
         }
 
-        adsorbPoint = dataService.getPoint(adsorbPointId2);
+        adsorbPoint = dataService.getRoadPoint(adsorbPointId2);
         parent = adsorbPoint.parent;
         for (const key in parent) {
           const angle = roadService.AngleForRoad3(roadId, key);
@@ -888,8 +888,8 @@ export default class MoveRoad {
     adsorbPointId1,
     adsorbPointId2
   ) {
-    const startPoint = dataService.getPoint(startPointId);
-    const endPoint = dataService.getPoint(endPointId);
+    const startPoint = dataService.getRoadPoint(startPointId);
+    const endPoint = dataService.getRoadPoint(endPointId);
     let flag = true;
     const roads = dataService.getRoads();
     for (const key in roads) {
@@ -958,8 +958,8 @@ export default class MoveRoad {
     dy = -dy;
 
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
 
     if (
       Object.keys(startPoint.getParent()).length == 1 &&
@@ -1035,8 +1035,8 @@ export default class MoveRoad {
   moveTo(pointId1, pointId2) {
     const roadId = roadService.getRoadId(pointId1, pointId2);
     // 不能重合
-    let point1 = dataService.getPoint(pointId1);
-    let point2 = dataService.getPoint(pointId2);
+    let point1 = dataService.getRoadPoint(pointId1);
+    let point2 = dataService.getRoadPoint(pointId2);
     if (!point2) {
       return false;
     }
@@ -1051,7 +1051,7 @@ export default class MoveRoad {
 
       const road1 = dataService.getRoad(roadId1);
       const otherPointId1 = road1.getOtherPointId(pointId1);
-      const otherPoint1 = dataService.getPoint(otherPointId1);
+      const otherPoint1 = dataService.getRoadPoint(otherPointId1);
 
       for (const roadId2 in parent2) {
         if (roadId2 == roadId) {
@@ -1059,7 +1059,7 @@ export default class MoveRoad {
         }
         const road2 = dataService.getRoad(roadId2);
         const otherPointId2 = road2.getOtherPointId(pointId2);
-        const otherPoint2 = dataService.getPoint(otherPointId2);
+        const otherPoint2 = dataService.getRoadPoint(otherPointId2);
         const angle = mathUtil.Angle(point2, otherPoint1, otherPoint2);
         if (Math.abs(angle) < Constant.minAngle) {
           return false;
@@ -1071,8 +1071,8 @@ export default class MoveRoad {
       dataService.deleteRoad(roadId);
     }
 
-    point1 = dataService.getPoint(pointId1);
-    point2 = dataService.getPoint(pointId2);
+    point1 = dataService.getRoadPoint(pointId1);
+    point2 = dataService.getRoadPoint(pointId2);
     if (!point1 || !point2) {
       return false;
     }
@@ -1088,11 +1088,11 @@ export default class MoveRoad {
 
       // road1上pointId1被pointId2取代
       if (road1.startId == pointId1) {
-        dataService.deletePoint(road1.startId, roadId1);
+        dataService.deleteRoadPoint(road1.startId, roadId1);
         road1.startId = pointId2;
         point2.setPointParent(roadId1, "start");
       } else if (road1.endId == pointId1) {
-        dataService.deletePoint(road1.endId, roadId1);
+        dataService.deleteRoadPoint(road1.endId, roadId1);
         road1.endId = pointId2;
         point2.setPointParent(roadId1, "end");
       } else {
@@ -1115,7 +1115,7 @@ export default class MoveRoad {
   //   roadService.subtraRoadFromIntersect(pointId, roadId);
   //   // 第二步更新端点坐标
   //   const newPointId = road.getPointId(dir);
-  //   const newPoint = dataService.getPoint(newPointId);
+  //   const newPoint = dataService.getRoadPoint(newPointId);
   //   newPoint.setPosition(newPosition);
   //   // 第三步先新建墙
   //   roadService.create(pointId, newPointId);

src/graphic/Geometry/RoadPoint.js

@@ -0,0 +1,20 @@
+import VectorType from "../enum/VectorType.js";
+import Geometry from "./Geometry";
+
+export default class RoadPoint extends Geometry {
+  constructor(position, vectorId) {
+    super();
+    this.x = null;
+    this.y = null;
+    this.parent = {};
+    this.geoType = VectorType.RoadPoint;
+    this.setId(vectorId);
+
+    this.setPosition(position);
+  }
+
+  setPosition(position) {
+    this.x = position.x;
+    this.y = position.y;
+  }
+}

src/graphic/History/Change.js

@@ -12,7 +12,9 @@ export default class Change {
 
   // 保存当前记录
   saveCurrentInfo() {
-    this.lastData.points = JSON.parse(JSON.stringify(dataService.getPoints()));
+    this.lastData.points = JSON.parse(
+      JSON.stringify(dataService.getRoadPoints())
+    );
     this.lastData.roads = JSON.parse(JSON.stringify(dataService.getRoads()));
   }
 
@@ -38,7 +40,7 @@ export default class Change {
   }
 
   comparePoints() {
-    const points = dataService.getPoints();
+    const points = dataService.getRoadPoints();
     this.currentData.points = [];
 
     for (const key in points) {

src/graphic/History/History.js

@@ -6,7 +6,7 @@ import HistoryEvents from "../enum/HistoryEvents";
 import { historyService } from "../Service/HistoryService";
 import { tagService } from "../Service/TagService";
 import { roadService } from "../Service/RoadService";
-import { pointService } from "../Service/PointService";
+import { roadPointService } from "../Service/RoadPointService";
 
 export default class History {
   constructor(layer) {
@@ -15,7 +15,7 @@ export default class History {
 
   init() {
     change.saveCurrentInfo();
-    const points = dataService.getPoints();
+    const points = dataService.getRoadPoints();
     // if (Object.keys(points).length > 0) {
     //   this.layer.$xui.toolbar.clear = true;
     //   this.layer.$xui.toolbar.download = true;
@@ -39,7 +39,7 @@ export default class History {
     // }
     // this.layer.$xui.toolbar.recover = false;
 
-    const points = dataService.getPoints();
+    const points = dataService.getRoadPoints();
     // if (Object.keys(points).length > 0) {
     //   this.layer.$xui.toolbar.clear = true;
     //   this.layer.$xui.toolbar.download = true;
@@ -121,7 +121,7 @@ export default class History {
       change.saveCurrentInfo();
       this.setState();
 
-      // const points = dataService.getPoints();
+      // const points = dataService.getRoadPoints();
       // if (Object.keys(points).length > 0) {
       //   this.layer.$xui.toolbar.clear = true;
       //   this.layer.$xui.toolbar.download = true;
@@ -140,11 +140,11 @@ export default class History {
       if (item.handle == HistoryEvents.AddPoint) {
         historyUtil.deletePoint(item.point.id);
       } else if (item.handle == HistoryEvents.DeletePoint) {
-        let point = pointService.create(item.point, item.point.id);
+        let point = roadPointService.create(item.point, item.point.id);
         point.parent = JSON.parse(JSON.stringify(item.point.parent));
       } else if (item.handle == HistoryEvents.ModifyPoint) {
         const prePoint = item.prePoint;
-        let currentPoint = dataService.getPoint(item.curPoint.id);
+        let currentPoint = dataService.getRoadPoint(item.curPoint.id);
         historyUtil.assignPointFromPoint(currentPoint, prePoint);
       }
     }
@@ -191,13 +191,13 @@ export default class History {
     for (let i = 0; i < itemForPoints.length; ++i) {
       const item = itemForPoints[i];
       if (item.handle == HistoryEvents.AddPoint) {
-        let newPoint = pointService.create(item.point, item.point.id);
+        let newPoint = roadPointService.create(item.point, item.point.id);
         historyUtil.assignPointFromPoint(newPoint, item.point);
       } else if (item.handle == HistoryEvents.DeletePoint) {
         historyUtil.deletePoint(item.point.id);
       } else if (item.handle == HistoryEvents.ModifyPoint) {
         const currentPoint = item.curPoint;
-        let prePoint = dataService.getPoint(item.curPoint.id);
+        let prePoint = dataService.getRoadPoint(item.curPoint.id);
         historyUtil.assignPointFromPoint(prePoint, currentPoint);
       }
     }
@@ -254,7 +254,7 @@ export default class History {
       change.saveCurrentInfo();
       this.setState();
 
-      // const points = dataService.getPoints();
+      // const points = dataService.getRoadPoints();
       // if (Object.keys(points).length > 0) {
       //   this.layer.$xui.toolbar.clear = true;
       //   this.layer.$xui.toolbar.download = true;

src/graphic/History/HistoryUtil.js

@@ -49,10 +49,10 @@ export default class HistoryUtil {
   }
 
   deletePoint(pointId) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     const parent = point.parent;
     for (const key in parent) {
-      dataService.deletePoint(pointId, key);
+      dataService.deleteRoadPoint(pointId, key);
     }
   }
 
@@ -97,7 +97,7 @@ export default class HistoryUtil {
   }
 
   setPointInfo(pointInfo) {
-    let point = dataService.getPoint(pointInfo.vectorId);
+    let point = dataService.getRoadPoint(pointInfo.vectorId);
     mathUtil.clonePoint(point, pointInfo.position);
     point.parent = JSON.parse(JSON.stringify(pointInfo.parent));
     return point;

src/graphic/Layer.js

@@ -23,7 +23,7 @@ import History from "./History/History";
 import mitt from "mitt";
 import { roadService } from "./Service/RoadService";
 import { edgeService } from "./Service/EdgeService";
-import { pointService } from "./Service/PointService";
+import { roadPointService } from "./Service/RoadPointService";
 import { curveRoadService } from "./Service/CurveRoadService";
 
 const minDragDis = 10;
@@ -217,8 +217,8 @@ export default class Layer {
         needAutoRedraw = true;
         //只允许拖拽一条公路
         let road = dataService.getRoad(draggingItem.vectorId);
-        let start = dataService.getPoint(road.startId);
-        let end = dataService.getPoint(road.endId);
+        let start = dataService.getRoadPoint(road.startId);
+        let end = dataService.getRoadPoint(road.endId);
         if (
           Object.keys(start.getParent()).length == 1 &&
           Object.keys(end.getParent()).length == 1
@@ -234,7 +234,7 @@ export default class Layer {
         this.lastY = Y;
         break;
       case LayerEvents.MoveRoadPoint:
-        point = dataService.getPoint(draggingItem.vectorId);
+        point = dataService.getRoadPoint(draggingItem.vectorId);
         listenLayer.start(position, draggingItem.vectorId, point.parent);
         if (listenLayer.modifyPoint) {
           position = {
@@ -251,28 +251,28 @@ export default class Layer {
         if (!flag) {
           elementService.hideAll();
         } else {
-          point = dataService.getPoint(draggingItem.vectorId);
+          point = dataService.getRoadPoint(draggingItem.vectorId);
           listenLayer.start(point, draggingItem.vectorId, point.parent);
           let otherPoint = null;
           if (
             listenLayer.modifyPoint &&
             listenLayer.modifyPoint.linkedPointId
           ) {
-            otherPoint = dataService.getPoint(
+            otherPoint = dataService.getRoadPoint(
               listenLayer.modifyPoint.linkedPointId
             );
           } else if (
             listenLayer.modifyPoint &&
             listenLayer.modifyPoint.linkedPointIdX
           ) {
-            otherPoint = dataService.getPoint(
+            otherPoint = dataService.getRoadPoint(
               listenLayer.modifyPoint.linkedPointIdX
             );
           } else if (
             listenLayer.modifyPoint &&
             listenLayer.modifyPoint.linkedPointIdY
           ) {
-            otherPoint = dataService.getPoint(
+            otherPoint = dataService.getRoadPoint(
               listenLayer.modifyPoint.linkedPointIdY
             );
           }
@@ -463,7 +463,7 @@ export default class Layer {
         }
         needAutoRedraw = true;
         elementService.hideAll();
-        let point = dataService.getPoint(draggingItem.vectorId);
+        let point = dataService.getRoadPoint(draggingItem.vectorId);
         if (point) {
           listenLayer.start(point, draggingItem.vectorId, point.parent);
           if (
@@ -484,7 +484,7 @@ export default class Layer {
             listenLayer.modifyPoint &&
             listenLayer.modifyPoint.hasOwnProperty("linkedRoadId")
           ) {
-            point = pointService.create({
+            point = roadPointService.create({
               x: listenLayer.modifyPoint.x,
               y: listenLayer.modifyPoint.y,
             });
@@ -779,7 +779,7 @@ export default class Layer {
           stateService.setEventName(LayerEvents.PanBackGround);
         } else if (selectItem.type == VectorType.Road) {
           stateService.setEventName(LayerEvents.MoveRoad);
-        } else if (selectItem.type == VectorType.Point) {
+        } else if (selectItem.type == VectorType.RoadPoint) {
           stateService.setEventName(LayerEvents.MoveRoadPoint);
         } else if (selectItem.type == VectorType.CurveRoad) {
           stateService.setEventName(LayerEvents.MoveCurveRoad);
@@ -791,6 +791,10 @@ export default class Layer {
           stateService.setEventName(LayerEvents.MoveEdge);
         } else if (selectItem.type == VectorType.CurveEdge) {
           stateService.setEventName(LayerEvents.MoveCurveEdge);
+        } else if (selectItem.type == VectorType.Line) {
+          stateService.setEventName(LayerEvents.MoveLine);
+        } else if (selectItem.type == VectorType.CurveLine) {
+          stateService.setEventName(LayerEvents.MoveCurveLine);
         }
       }
     } else if (eventType == "mouseUp") {
@@ -855,20 +859,4 @@ export default class Layer {
     this.history.goNextState();
     this.renderer.autoRedraw();
   }
-
-  deleteItem() {
-    let item = stateService.getFocusItem();
-    if (item) {
-      if (item.type == VectorType.Road) {
-        dataService.deleteRoad(item.vectorId);
-      } else if (item.type == VectorType.Tag) {
-        dataService.deleteTag(item.vectorId);
-      } else if (item.type == VectorType.Point) {
-        //这个比较复杂，参考deleteRoadCorner
-        //dataService.deletePoint(item.vectorId);
-      }
-      this.history.save();
-      this.renderer.autoRedraw();
-    }
-  }
 }

src/graphic/ListenLayer.js

@@ -57,25 +57,25 @@ export default class ListenLayer {
     };
 
     let seqInfo = {};
-    const points = dataService.getPoints();
+    const points = dataService.getRoadPoints();
     for (const pointId in points) {
       if (pointId == exceptPointId) {
         continue;
       }
-      const point = dataService.getPoint(pointId);
+      const point = dataService.getRoadPoint(pointId);
       const distance = mathUtil.getDistance(position, point);
       if (distance < Constant.minAdsorbPix) {
         if (pointInfo.pointId == null) {
           pointInfo = {
             pointId: pointId,
-            type: VectorType.Point,
+            type: VectorType.RoadPoint,
             distance: distance,
           };
         } else if (pointInfo.pointId != null) {
           if (distance < pointInfo.distance) {
             pointInfo = {
               pointId: pointId,
-              type: VectorType.Point,
+              type: VectorType.RoadPoint,
               distance: distance,
             };
           }
@@ -92,7 +92,7 @@ export default class ListenLayer {
     }
 
     if (pointInfo.pointId) {
-      const linkedPoint = dataService.getPoint(pointInfo.pointId);
+      const linkedPoint = dataService.getRoadPoint(pointInfo.pointId);
       pointInfo.x = linkedPoint.x;
       pointInfo.y = linkedPoint.y;
     }
@@ -211,8 +211,8 @@ export default class ListenLayer {
         continue;
       }
       const road = dataService.getRoad(roadId);
-      let startPoint = dataService.getPoint(road.startId);
-      let endPoint = dataService.getPoint(road.endId);
+      let startPoint = dataService.getRoadPoint(road.startId);
+      let endPoint = dataService.getRoadPoint(road.endId);
       const roadLine = roadService.getMidLine(road);
       const join = mathUtil.getJoinLinePoint(position, roadLine);
       const distance = mathUtil.getDistance(position, join);
@@ -556,7 +556,7 @@ export default class ListenLayer {
     } else if (this.modifyPoint.linkedPointId) {
       stateService.setSelectItem(
         this.modifyPoint.linkedPointId,
-        VectorType.Point,
+        VectorType.RoadPoint,
         SelectState.Select
       );
     } else if (this.modifyPoint.linkedCurvePointId) {

src/graphic/Renderer/Draw.js

@@ -139,8 +139,10 @@ export default class Draw {
   drawRoad(vector, isTemp) {
     const startReal = isTemp
       ? vector.start
-      : dataService.getPoint(vector.startId);
-    const endReal = isTemp ? vector.end : dataService.getPoint(vector.endId);
+      : dataService.getRoadPoint(vector.startId);
+    const endReal = isTemp
+      ? vector.end
+      : dataService.getRoadPoint(vector.endId);
 
     if (vector?.midDivide?.display) {
       const ctx = this.context;
@@ -188,8 +190,10 @@ export default class Draw {
 
   drawEdge(vector, isTemp) {
     //判断是否与road方向一致。角度足够小，路足够宽，有可能向量方向不一致
-    const start = isTemp ? vector.start : dataService.getPoint(vector.startId);
-    const end = isTemp ? vector.end : dataService.getPoint(vector.endId);
+    const start = isTemp
+      ? vector.start
+      : dataService.getRoadPoint(vector.startId);
+    const end = isTemp ? vector.end : dataService.getRoadPoint(vector.endId);
 
     const drawEdgeChild = (edgeVector) => {
       const flag = mathUtil.isSameDirForVector(

src/graphic/Renderer/Render.js

@@ -24,8 +24,8 @@ export default class Render {
       case VectorType.CurveRoad:
         draw.drawCurveRoad(vector, false);
         return;
-      case VectorType.Point:
-        draw.drawPoint(vector);
+      case VectorType.RoadPoint:
+        draw.drawRoadPoint(vector);
         return;
       case VectorType.ControlPoint:
         draw.drawControlPoint(vector);
@@ -47,7 +47,7 @@ export default class Render {
       return;
     }
     switch (vector.geoType) {
-      case VectorType.Point:
+      case VectorType.RoadPoint:
         draw.drawCircle(vector);
         break;
       case VectorType.Line:
@@ -117,7 +117,7 @@ export default class Render {
       this.drawGeometry(roads[key]);
     }
 
-    let points = dataService.getPoints();
+    let points = dataService.getRoadPoints();
     for (let key in points) {
       this.drawGeometry(points[key]);
     }
@@ -159,7 +159,7 @@ export default class Render {
       this.drawGeometry(roads[key]);
     }
 
-    let points = dataService.getPoints();
+    let points = dataService.getRoadPoints();
     for (let key in points) {
       this.drawGeometry(points[key]);
     }

src/graphic/Service/ControlPointService.js

@@ -114,11 +114,11 @@ export default class ControlPointService {
     let road = dataService.getRoad(edge.parent);
     let point1, point2;
     if (dir == "start") {
-      point1 = dataService.getPoint(road.startId);
-      point2 = dataService.getPoint(road.endId);
+      point1 = dataService.getRoadPoint(road.startId);
+      point2 = dataService.getRoadPoint(road.endId);
     } else if (dir == "end") {
-      point1 = dataService.getPoint(road.endId);
-      point2 = dataService.getPoint(road.startId);
+      point1 = dataService.getRoadPoint(road.endId);
+      point2 = dataService.getRoadPoint(road.startId);
     }
 
     position = mathUtil.getJoinLinePoint(

src/graphic/Service/CurveRoadService.js

@@ -257,8 +257,8 @@ export default class CurveRoadService extends RoadService {
 
   setLanesPoints(curveRoadId) {
     let curveRoad = dataService.getCurveRoad(curveRoadId);
-    let startPoint = dataService.getPoint(curveRoad.startId);
-    let endPoint = dataService.getPoint(curveRoad.endId);
+    let startPoint = dataService.getRoadPoint(curveRoad.startId);
+    let endPoint = dataService.getRoadPoint(curveRoad.endId);
 
     let midPoint = curvePointService.create({
       x: (startPoint.x + endPoint.x) / 2,

src/graphic/Service/DataService.js

@@ -65,7 +65,7 @@ export class DataService {
 
   initVectorData() {
     this.vectorData.backgroundImg = null;
-    this.vectorData.points = {};
+    this.vectorData.roadPoints = {};
     this.vectorData.roads = {};
     this.vectorData.edges = {};
     this.vectorData.curvePoints = {};
@@ -186,32 +186,32 @@ export class DataService {
   /**
    * 对端点的操作
    */
-  getPoints() {
-    return this.vectorData.points;
+  getRoadPoints() {
+    return this.vectorData.roadPoints;
   }
 
-  getPoint(pointId) {
+  getRoadPoint(pointId) {
     if (pointId) {
-      return this.vectorData.points[pointId];
+      return this.vectorData.roadPoints[pointId];
     } else {
       return null;
     }
   }
 
-  deletePoint(pointId, roadId) {
-    let point = this.getPoint(pointId);
+  deleteRoadPoint(pointId, roadId) {
+    let point = this.getRoadPoint(pointId);
     //有可能先删除墙，导致点没了
     if (point) {
       if (Object.keys(point.parent).length == 0) {
         point = null;
-        delete this.vectorData.points[pointId];
+        delete this.vectorData.roadPoints[pointId];
       } else if (Object.keys(point.parent).length == 1 && !roadId) {
-        delete this.vectorData.points[pointId];
+        delete this.vectorData.roadPoints[pointId];
       } else if (
         Object.keys(point.parent).length == 1 &&
         point.parent[roadId]
       ) {
-        delete this.vectorData.points[pointId];
+        delete this.vectorData.roadPoints[pointId];
       } else if (
         Object.keys(point.parent).length == 1 &&
         !point.parent[roadId]
@@ -223,8 +223,8 @@ export class DataService {
     }
   }
 
-  addPoint(point) {
-    this.vectorData.points[point.vectorId] = point;
+  addRoadPoint(roadPoint) {
+    this.vectorData.roadPoints[roadPoint.vectorId] = roadPoint;
   }
 
   /**

src/graphic/Service/EdgeService.js

@@ -21,8 +21,8 @@ export default class EdgeService {
 
   computerDefaultEdge(roadId) {
     let road = dataService.getRoad(roadId);
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
 
@@ -49,8 +49,8 @@ export default class EdgeService {
     // console.log("开始执行updateDefaultEdge");
 
     let road = dataService.getRoad(roadId);
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
 
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
@@ -87,8 +87,8 @@ export default class EdgeService {
     // console.log("开始执行updateEdgeForTwoRoad");
 
     let road1 = dataService.getRoad(roadId1);
-    let startPoint1 = dataService.getPoint(road1.startId);
-    let endPoint1 = dataService.getPoint(road1.endId);
+    let startPoint1 = dataService.getRoadPoint(road1.startId);
+    let endPoint1 = dataService.getRoadPoint(road1.endId);
     // this.computerDefaultEdge(roadId1);   不能这样，会导致另一端点对应的edge端点改变
     let leftEdge1 = dataService.getEdge(road1.leftEdgeId);
     let rightEdge1 = dataService.getEdge(road1.rightEdgeId);
@@ -97,8 +97,8 @@ export default class EdgeService {
 
     let road2 = dataService.getRoad(roadId2);
     // this.computerDefaultEdge(roadId2);
-    let startPoint2 = dataService.getPoint(road2.startId);
-    let endPoint2 = dataService.getPoint(road2.endId);
+    let startPoint2 = dataService.getRoadPoint(road2.startId);
+    let endPoint2 = dataService.getRoadPoint(road2.endId);
     let leftEdge2 = dataService.getEdge(road2.leftEdgeId);
     let rightEdge2 = dataService.getEdge(road2.rightEdgeId);
     let lineLeft2 = this.getLine(leftEdge2);
@@ -417,8 +417,8 @@ export default class EdgeService {
     //console.log('更新'+roadId1+'和'+roadId2+'一侧相交的edge交点');
     // console.log("开始执行updateSingleEdgeForTwoRoad");
     const road1 = dataService.getRoad(roadId1);
-    const startPoint1 = dataService.getPoint(road1.startId);
-    const endPoint1 = dataService.getPoint(road1.endId);
+    const startPoint1 = dataService.getRoadPoint(road1.startId);
+    const endPoint1 = dataService.getRoadPoint(road1.endId);
     let line1 = mathUtil.createLine1(startPoint1, endPoint1);
 
     let leftEdge1 = dataService.getEdge(road1.leftEdgeId);
@@ -427,8 +427,8 @@ export default class EdgeService {
     let lineRight1 = this.getLine(rightEdge1);
 
     const road2 = dataService.getRoad(roadId2);
-    const startPoint2 = dataService.getPoint(road2.startId);
-    const endPoint2 = dataService.getPoint(road2.endId);
+    const startPoint2 = dataService.getRoadPoint(road2.startId);
+    const endPoint2 = dataService.getRoadPoint(road2.endId);
     let line2 = mathUtil.createLine1(startPoint2, endPoint2);
 
     let leftEdge2 = dataService.getEdge(road2.leftEdgeId);
@@ -765,7 +765,7 @@ export default class EdgeService {
   updateEdgeForMulRoad(pointId) {
     //console.log('更新 '+pointId+' 那一圈的edge端点');
     //console.log("开始执行updateEdgeForMulRoad");
-    let point = dataService.getPoint(pointId);
+    let point = dataService.getRoadPoint(pointId);
     let parent = point.getParent();
     let dir;
     if (Object.keys(parent).length == 1) {
@@ -841,7 +841,7 @@ export default class EdgeService {
 
   // pointId的坐标已经变了
   updateEdgeForMovePoint(pointId) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     const parent = point.getParent();
     for (const key in parent) {
       this.computerDefaultEdge(key);

src/graphic/Service/ElementService.js

@@ -251,7 +251,7 @@ export class ElementService {
     if (!this.vCheckLines.Y.display && !this.vCheckLines.Y.display) {
       if (listenLayer.modifyPoint) {
         if (listenLayer.modifyPoint.linkedPointIdX) {
-          let linkedPointX = dataService.getPoint(
+          let linkedPointX = dataService.getRoadPoint(
             listenLayer.modifyPoint.linkedPointIdX
           );
           if (!linkedPointX) {
@@ -264,7 +264,7 @@ export class ElementService {
         }
 
         if (listenLayer.modifyPoint.linkedPointIdY) {
-          let linkedPointY = dataService.getPoint(
+          let linkedPointY = dataService.getRoadPoint(
             listenLayer.modifyPoint.linkedPointIdY
           );
           if (!linkedPointY) {
@@ -296,7 +296,7 @@ export class ElementService {
   //   }
 
   //   let points = roadService.getNeighPoints(pointId, exceptPointId);
-  //   let point = dataService.getPoint(pointId);
+  //   let point = dataService.getRoadPoint(pointId);
   //   let newPosition = null;
   //   for (let i = 0; i < points.length; ++i) {
   //     let angle = mathUtil.Angle(point, position, points[i]);

src/graphic/Service/ImageService.js

@@ -7,7 +7,7 @@ export default class ImageService {
 
   create(position, vectorId) {
     let point = new Img(position, vectorId);
-    dataService.addPoint(point);
+    dataService.addRoadPoint(point);
     return point;
   }
 }

src/graphic/Service/MeasureService.js

@@ -90,7 +90,7 @@ export default class MeasureService {
       return;
     }
 
-    const points = dataService.getPoints();
+    const points = dataService.getRoadPoints();
     for (let key in points) {
       const point = points[key];
       measurePoints.push({
@@ -326,7 +326,7 @@ export default class MeasureService {
         let maxX = coordinate.center.x;
         let maxY = coordinate.center.y;
 
-        const points = dataService.getPoints()
+        const points = dataService.getRoadPoints()
         for (let key in points) {
             const point = points[key]
             if(point.y > coordinate.center.y){

src/graphic/Service/PointService.js

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

src/graphic/Service/RoadPointService.js

@@ -0,0 +1,16 @@
+import RoadPoint from "../Geometry/RoadPoint.js";
+import { dataService } from "./DataService.js";
+import { mathUtil } from "../Util/MathUtil.js";
+
+export default class RoadPointService {
+  constructor() {}
+
+  create(position, vectorId) {
+    let roadPoint = new RoadPoint(position, vectorId);
+    dataService.addRoadPoint(roadPoint);
+    return roadPoint;
+  }
+}
+
+const roadPointService = new RoadPointService();
+export { roadPointService };

src/graphic/Service/RoadService.js

@@ -1,7 +1,7 @@
-import Point from "../Geometry/Point.js";
+import RoadPoint from "../Geometry/RoadPoint.js";
 import Road from "../Geometry/Road.js";
 import { dataService } from "./DataService.js";
-import { pointService } from "./PointService.js";
+import { roadPointService } from "./RoadPointService.js";
 import { edgeService } from "./EdgeService.js";
 import { mathUtil } from "../Util/MathUtil.js";
 import Constant from "../Constant";
@@ -13,10 +13,10 @@ export default class RoadService {
     let road = new Road(startId, endId, vectorId);
     dataService.addRoad(road);
 
-    let startPoint = dataService.getPoint(startId);
+    let startPoint = dataService.getRoadPoint(startId);
     startPoint.setPointParent(road.vectorId, "start");
 
-    let endPoint = dataService.getPoint(endId);
+    let endPoint = dataService.getRoadPoint(endId);
     endPoint.setPointParent(road.vectorId, "end");
 
     let edgePoints = mathUtil.RectangleVertex(
@@ -50,8 +50,8 @@ export default class RoadService {
   }
 
   getMidLine(road) {
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     let line = mathUtil.createLine1(startPoint, endPoint);
     return line;
   }
@@ -60,9 +60,9 @@ export default class RoadService {
   // dir表示:保留start还是保留end(对应端点的parent不用变)
   splitRoad(roadId, pointId, dir) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
-    const point = dataService.getPoint(pointId);
+    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
@@ -168,8 +168,8 @@ export default class RoadService {
 
   // roadId的两个端点分别是pointId1,pointId2，获取这个roadId
   getRoadId(pointId1, pointId2) {
-    const point1 = dataService.getPoint(pointId1);
-    const point2 = dataService.getPoint(pointId2);
+    const point1 = dataService.getRoadPoint(pointId1);
+    const point2 = dataService.getRoadPoint(pointId2);
     // 公路可能删除了。
     if (!point1 || !point2) {
       console.warn("pointId1或者pointId2不存在");
@@ -194,14 +194,14 @@ export default class RoadService {
 
   getNeighPoints(pointId, exceptPointId) {
     let points = [];
-    let point = dataService.getPoint(pointId);
+    let point = dataService.getRoadPoint(pointId);
     for (let key in point.parent) {
       let road = dataService.getRoad(key);
       const otherPointId = road.getOtherPointId(pointId);
       if (exceptPointId && exceptPointId == otherPointId) {
         continue;
       }
-      const otherPoint = dataService.getPoint(otherPointId);
+      const otherPoint = dataService.getRoadPoint(otherPointId);
       points.push(otherPoint);
     }
     return points;
@@ -221,11 +221,11 @@ export default class RoadService {
       return null;
     }
 
-    const start1 = dataService.getPoint(road1.startId);
-    const end1 = dataService.getPoint(road1.endId);
+    const start1 = dataService.getRoadPoint(road1.startId);
+    const end1 = dataService.getRoadPoint(road1.endId);
 
-    const start2 = dataService.getPoint(road2.startId);
-    const end2 = dataService.getPoint(road2.endId);
+    const start2 = dataService.getRoadPoint(road2.startId);
+    const end2 = dataService.getRoadPoint(road2.endId);
 
     const distance1 = mathUtil.getDistance(start1, start2);
     const distance2 = mathUtil.getDistance(start1, end2);
@@ -277,11 +277,11 @@ export default class RoadService {
       return null;
     }
 
-    const start1 = dataService.getPoint(road1.startId);
-    const end1 = dataService.getPoint(road1.endId);
+    const start1 = dataService.getRoadPoint(road1.startId);
+    const end1 = dataService.getRoadPoint(road1.endId);
 
-    const start2 = dataService.getPoint(road2.startId);
-    const end2 = dataService.getPoint(road2.endId);
+    const start2 = dataService.getRoadPoint(road2.startId);
+    const end2 = dataService.getRoadPoint(road2.endId);
 
     let angle = null;
     const points = [];
@@ -337,11 +337,11 @@ export default class RoadService {
       return null;
     }
 
-    const start1 = dataService.getPoint(road1.startId);
-    const end1 = dataService.getPoint(road1.endId);
+    const start1 = dataService.getRoadPoint(road1.startId);
+    const end1 = dataService.getRoadPoint(road1.endId);
 
-    const start2 = dataService.getPoint(road2.startId);
-    const end2 = dataService.getPoint(road2.endId);
+    const start2 = dataService.getRoadPoint(road2.startId);
+    const end2 = dataService.getRoadPoint(road2.endId);
 
     const distance1 = mathUtil.getDistance(start1, start2);
     const distance2 = mathUtil.getDistance(start1, end2);
@@ -383,7 +383,7 @@ export default class RoadService {
   // 获取最小角度（顺时针和逆时针）
   // 可能缺顺时针或者逆时针，这时候对应的取最大角度的逆时针或者顺时针
   roadIdForMinAngle(pointId, roadId) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     const parent = point.parent;
 
     let minAngle0 = null;
@@ -477,8 +477,8 @@ export default class RoadService {
 
   //point在road所在的线上，只是不确定是否在线段上
   isContain(road, point) {
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     const minDis = Constant.minAdsorbPix / 2;
     return mathUtil.isContainForSegment(point, startPoint, endPoint, minDis);
   }
@@ -498,7 +498,7 @@ export default class RoadService {
   }
 
   subtraRoadFromIntersect(pointId, roadId) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     const parent = point.getParent();
     const dir = this.getDirction(pointId, roadId);
 
@@ -515,7 +515,7 @@ export default class RoadService {
     // 第一步先断开链接
     delete parent[roadId];
     // 第二步先新建端点
-    const newPoint = pointService.create(point);
+    const newPoint = roadPointService.create(point);
     // 第三步建立链接
     newPoint.setPointParent(roadId, dir);
     this.setRoadPointId(roadId, pointId, dir);
@@ -571,11 +571,11 @@ export default class RoadService {
       return null;
     }
 
-    let start1 = dataService.getPoint(road1.startId);
-    let end1 = dataService.getPoint(road1.endId);
+    let start1 = dataService.getRoadPoint(road1.startId);
+    let end1 = dataService.getRoadPoint(road1.endId);
 
-    let start2 = dataService.getPoint(road2.startId);
-    let end2 = dataService.getPoint(road2.endId);
+    let start2 = dataService.getRoadPoint(road2.startId);
+    let end2 = dataService.getRoadPoint(road2.endId);
 
     let angle = null;
     let points = [];
@@ -621,7 +621,7 @@ export default class RoadService {
   //获取最小角度（顺时针和逆时针）
   //可能缺顺时针或者逆时针，这时候对应的取最大角度的逆时针或者顺时针
   roadIdForMinAngle(pointId, roadId) {
-    let point = dataService.getPoint(pointId);
+    let point = dataService.getRoadPoint(pointId);
     let parent = point.getParent();
 
     let minAngle0 = null;
@@ -715,7 +715,7 @@ export default class RoadService {
   //获取最小角度（顺时针和逆时针）
   //可能缺顺时针或者逆时针，这时候对应的取最大角度的逆时针或者顺时针
   roadIdForMinAngle(pointId, roadId) {
-    let point = dataService.getPoint(pointId);
+    let point = dataService.getRoadPoint(pointId);
     let parent = point.parent;
 
     let minAngle0 = null;
@@ -793,8 +793,8 @@ export default class RoadService {
 
   deleteRoad(roadId) {
     const road = dataService.getRoad(roadId);
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     if (Object.keys(startPoint.getParent()).length > 2) {
       this.subtraRoadFromIntersect(road.startId, roadId);
     }
@@ -833,8 +833,8 @@ export default class RoadService {
   //设置中间带
   setMidDivide(roadId, dir) {
     const road = dataService.getRoad(roadId);
-    const startPoint = dataService.getPoint(road.startId);
-    const endPoint = dataService.getPoint(road.endId);
+    const startPoint = dataService.getRoadPoint(road.startId);
+    const endPoint = dataService.getRoadPoint(road.endId);
     const leftEdge = dataService.getEdge(road.leftEdgeId);
     const rightEdge = dataService.getEdge(road.rightEdgeId);
 
@@ -924,7 +924,7 @@ export default class RoadService {
   }
 
   setMidDivideForPointId(pointId) {
-    const point = dataService.getPoint(pointId);
+    const point = dataService.getRoadPoint(pointId);
     for (let key in point.parent) {
       this.setMidDivide(key, point.parent[key]);
     }
@@ -943,8 +943,8 @@ export default class RoadService {
   //dir1表示left或者right，dir2表示start或者end
   setLanes(roadId, dir1, dir2) {
     let road = dataService.getRoad(roadId);
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
     const leftCount = road.leftDrivewayCount;
@@ -1049,8 +1049,8 @@ export default class RoadService {
       newCount = 0;
     }
 
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
 
@@ -1129,8 +1129,8 @@ export default class RoadService {
   //变宽或者变窄（车道数据不变）
   updateForWidth(roadId, newWidth, dir) {
     let road = dataService.getRoad(roadId);
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
     road.setWidth(newWidth, dir);
@@ -1152,8 +1152,8 @@ export default class RoadService {
 
   unlock(roadId) {
     let road = dataService.getRoad(roadId);
-    let startPoint = dataService.getPoint(road.startId);
-    let endPoint = dataService.getPoint(road.endId);
+    let startPoint = dataService.getRoadPoint(road.startId);
+    let endPoint = dataService.getRoadPoint(road.endId);
     let leftEdge = dataService.getEdge(road.leftEdgeId);
     let rightEdge = dataService.getEdge(road.rightEdgeId);
     let lanes = road.lanes;

src/graphic/enum/HistoryEvents.js

@@ -1,5 +1,5 @@
 const HistoryEvents = {
-  AddPoint: "addPoint",
+  AddRoadPoint: "addRoadPoint",
   DeletePoint: "deletePoint",
   ModifyPoint: "modifyPoint",
 

src/graphic/enum/LayerEvents.js

@@ -15,6 +15,8 @@ const LayerEvents = {
   MoveEdge: "moveEdge",
   MoveCurveEdge: "moveCurveEdge",
 
+  MoveCurveLine: "moveCurveLine",
+  MoveLine: "moveLine",
   AddTag: "addTag",
   MoveTag: "moveTag",
 

src/graphic/enum/VectorType.js

@@ -1,5 +1,6 @@
 const VectorType = {
   Point: "Point",
+  RoadPoint: "RoadPoint",
   CurvePoint: "CurvePoint",
   ControlPoint: "ControlPoint",
   Circle: "Circle",