修改交叉点

src/graphic/CanvasStyle/default.js

@@ -19,7 +19,7 @@ const Lane = {
 const Arrow = {
   lineWidth: 2,
   strokeStyle: "red",
-}
+};
 
 const Magnifier = {
   strokeStyle: "#2F8FFF",
@@ -30,9 +30,9 @@ const Magnifier = {
     radius: 100,
     realRadius: 50,
     strokeStyle: "#2F8FFF",
-    lineWidth: 3
-  }
-}
+    lineWidth: 3,
+  },
+};
 
 const CurveRoad = {
   ...Road,
@@ -83,7 +83,7 @@ const CurveRoadPoint = {
   ...Point,
 };
 
-const ControlPoint = {
+const CrossPoint = {
   ...Point,
   strokeStyle: "#3290FF",
   radius: 8,
@@ -93,7 +93,7 @@ const Circle = {
   strokeStyle: "red",
   fillStyle: "rgba(0,0,0,0)",
   lineWidth: 2,
-  radius: 30
+  radius: 30,
 };
 
 const Measure = {
@@ -163,7 +163,7 @@ export default {
   BaseLine,
   Circle,
   Text,
-  ControlPoint,
+  CrossPoint,
   CurveRoadPoint,
   GuideLine,
   Magnifier,

src/graphic/CanvasStyle/focus.js

@@ -10,11 +10,11 @@ const NormalLine = {
   ...def.NormalLine,
   lineWidth: 2,
   strokeStyle: "#3290FF",
-}
+};
 
 const Magnifier = {
-  ...def.Magnifier
-}
+  ...def.Magnifier,
+};
 
 const CurveRoad = {
   ...def.CurveRoad,
@@ -42,8 +42,8 @@ const CurveRoadPoint = {
   ...Point,
 };
 
-const ControlPoint = {
-  ...def.ControlPoint,
+const CrossPoint = {
+  ...def.CrossPoint,
   fillStyle: "#3290FF",
 };
 
@@ -61,7 +61,7 @@ const CurveRoadEdge = {
 const Arrow = {
   lineWidth: 2,
   strokeStyle: "red",
-}
+};
 export default {
   Road,
   Text,
@@ -69,7 +69,7 @@ export default {
   Arrow,
   RoadPoint,
   CurveRoadPoint,
-  ControlPoint,
+  CrossPoint,
   CurveRoad,
   RoadEdge,
   Magnifier,

src/graphic/CanvasStyle/select.js

@@ -10,11 +10,11 @@ const NormalLine = {
   ...def.NormalLine,
   lineWidth: 2,
   strokeStyle: "#3290FF",
-}
+};
 const Arrow = {
   lineWidth: 2,
   strokeStyle: "red",
-}
+};
 const CurveRoad = {
   ...def.CurveRoad,
   ...Road,
@@ -53,8 +53,8 @@ const CurveRoadPoint = {
   ...Point,
 };
 
-const ControlPoint = {
-  ...def.ControlPoint,
+const CrossPoint = {
+  ...def.CrossPoint,
   fillStyle: "#3290FF",
 };
 
@@ -64,10 +64,10 @@ export default {
   Point,
   RoadPoint,
   CurveRoadPoint,
-  ControlPoint,
+  CrossPoint,
   CurveRoad,
   RoadEdge,
   NormalLine,
   CurveRoadEdge,
-  Arrow
+  Arrow,
 };

src/graphic/Controls/MoveRoad.js

@@ -5,7 +5,7 @@ import { mathUtil } from "../Util/MathUtil";
 import { curveRoadService } from "../Service/CurveRoadService";
 import { coordinate } from "../Coordinate";
 import { edgeService } from "../Service/EdgeService";
-import { controlPointService } from "../Service/ControlPointService";
+import { crossPointService } from "../Service/CrossPointService";
 
 export default class MoveRoad {
   constructor() {
@@ -1145,8 +1145,8 @@ export default class MoveRoad {
     curveRoadService.updateForMovePoint(pointId, position);
   }
 
-  moveControlPoint(controlPointId, position) {
-    controlPointService.updateForMovePoint(controlPointId, position);
+  moveCrossPoint(crossPointId, position) {
+    crossPointService.updateForMovePoint(crossPointId, position);
   }
 
   moveEdge(edgeId, position) {

src/graphic/Geometry/ControlPoint.js

@@ -2,7 +2,7 @@ import Constant from "../Constant.js";
 import { dataService } from "../Service/DataService.js";
 import { mathUtil } from "../Util/MathUtil.js";
 import VectorType from "../enum/VectorType.js";
-import Geometry from "./Geometry";
+import Geometry from "./Geometry.js";
 
 // 二次贝塞尔曲线
 // var ctx=c.getContext("2d");
@@ -11,7 +11,7 @@ import Geometry from "./Geometry";
 // ctx.quadraticCurveTo(20,100,20,20);
 // ctx.stroke();
 
-export default class ControlPoint extends Geometry {
+export default class CrossPoint extends Geometry {
   constructor(position, vectorId) {
     super();
     //控制点坐标
@@ -30,7 +30,7 @@ export default class ControlPoint extends Geometry {
 
     this.extremePoint = null; //极值
     this.curves = [];
-    this.geoType = VectorType.ControlPoint;
+    this.geoType = VectorType.CrossPoint;
     this.setId(vectorId);
 
     this.setPosition(position);

src/graphic/History/Change.js

@@ -37,8 +37,8 @@ export default class Change {
     this.lastData.curveRoads = JSON.parse(
       JSON.stringify(dataService.getCurveRoads())
     );
-    this.lastData.controlPoints = JSON.parse(
-      JSON.stringify(dataService.getControlPoints())
+    this.lastData.crossPoints = JSON.parse(
+      JSON.stringify(dataService.getCrossPoints())
     );
   }
 
@@ -56,7 +56,7 @@ export default class Change {
     this.compareRoadEdges();
     this.compareRoads();
     this.compareCurveRoads();
-    this.compareControlPoints();
+    this.compareCrossPoints();
     if (
       this.currentData.points.length == 0 &&
       this.currentData.lines.length == 0 &&
@@ -65,7 +65,8 @@ export default class Change {
       this.currentData.magnifiers.length == 0 &&
       this.currentData.roadPoints.length == 0 &&
       this.currentData.roadEdges.length == 0 &&
-      this.currentData.roads.length == 0
+      this.currentData.roads.length == 0 &&
+      this.currentData.crossPoints.length == 0
     ) {
       this.saveCurrentInfo();
       return false;
@@ -476,7 +477,49 @@ export default class Change {
 
   compareCurveRoads() {}
 
-  compareControlPoints() {}
+  compareCrossPoints() {
+    this.currentData.crossPoints = [];
+    const crossPoints = dataService.getCrossPoints();
+
+    for (const key in crossPoints) {
+      const crossPoint = crossPoints[key];
+      const lastCrossPoint = this.lastData.crossPoints[key];
+
+      // 不存在意味着增加
+      if (!lastCrossPoint) {
+        const item = {
+          handle: HistoryEvents.AddCrossPoint,
+          crossPoint: historyUtil.getDataForCrossPoint(crossPoint),
+        };
+        this.currentData.crossPoints.push(item);
+      } else {
+        if (
+          !historyUtil.isDifferentForCrossPoints(crossPoint, lastCrossPoint)
+        ) {
+          delete this.lastData.crossPoints[key];
+          continue;
+        } else {
+          const item = {
+            handle: HistoryEvents.ModifyCrossPoint,
+            preCrossPoint: historyUtil.getDataForCrossPoint(lastCrossPoint),
+            curCrossPoint: historyUtil.getDataForCrossPoint(crossPoint),
+          };
+          this.currentData.crossPoints.push(item);
+        }
+      }
+      delete this.lastData.crossPoints[key];
+    }
+
+    for (const key in this.lastData.crossPoints) {
+      const item = {
+        handle: HistoryEvents.DeleteCrossPoint,
+        crossPoint: historyUtil.getDataForCrossPoint(
+          this.lastData.crossPoints[key]
+        ),
+      };
+      this.currentData.crossPoints.push(item);
+    }
+  }
 }
 
 const change = new Change();

src/graphic/History/History.js

@@ -13,6 +13,7 @@ import { circleService } from "../Service/CircleService";
 import { pointService } from "../Service/PointService";
 import { edgeService } from "../Service/EdgeService";
 import { magnifierService } from "../Service/MagnifierService";
+import { crossPointService } from "../Service/CrossPointService";
 
 export default class History {
   constructor(layer) {
@@ -103,6 +104,7 @@ export default class History {
       this.goPreForRoadPoints(item.roadPoints);
       this.goPreForRoadEdges(item.roadEdges);
       this.goPreForRoads(item.roads);
+      this.goPreForCrossPoints(item.crossPoints);
       historyService.undoHistoryRecord();
       change.saveCurrentInfo();
       this.setState();
@@ -291,6 +293,34 @@ export default class History {
     }
   }
 
+  goPreForCrossPoints(itemForCrossPoints) {
+    for (let i = 0; i < itemForCrossPoints.length; ++i) {
+      const item = itemForCrossPoints[i];
+      if (item.handle == HistoryEvents.AddCrossPoint) {
+        dataService.deleteCrossPoint(item.crossPoint.id);
+      } else if (item.handle == HistoryEvents.DeleteCrossPoint) {
+        crossPointService.create;
+        let newCrossPoint = roadService.create(
+          item.crossPoint.position,
+          item.crossPoint.id
+        );
+        historyUtil.assignCrossPointFromCrossPoint(
+          newCrossPoint,
+          item.crossPoint
+        );
+      } else if (item.handle == HistoryEvents.ModifyCrossPoint) {
+        const preCrossPoint = item.preCrossPoint;
+        let currentCrossPoint = dataService.getCrossPoint2(
+          item.curCrossPoint.id
+        );
+        historyUtil.assignCrossPointFromCrossPoint(
+          currentCrossPoint,
+          preCrossPoint
+        );
+      }
+    }
+  }
+
   goNextForPoints(itemForPoints) {
     for (let i = 0; i < itemForPoints.length; ++i) {
       const item = itemForPoints[i];
@@ -471,6 +501,31 @@ export default class History {
     }
   }
 
+  goNextForCrossPoints(itemForCrossPoints) {
+    for (let i = 0; i < itemForCrossPoints.length; ++i) {
+      const item = itemForCrossPoints[i];
+      if (item.handle == HistoryEvents.AddCrossPoint) {
+        let vCrossPoint = crossPointService.create(
+          item.crossPoint.position,
+          item.crossPoint.id
+        );
+        historyUtil.assignCrossPointFromCrossPoint(
+          vCrossPoint,
+          item.crossPoint
+        );
+      } else if (item.handle == HistoryEvents.DeleteCrossPoint) {
+        dataService.deleteCrossPoint(item.crossPoint.id);
+      } else if (item.handle == HistoryEvents.ModifyCrossPoint) {
+        const currentCrossPoint = item.curCrossPoint;
+        let preCrossPoint = dataService.getCrossPoint2(item.curCrossPoint.id);
+        historyUtil.assignCrossPointFromCrossPoint(
+          preCrossPoint,
+          currentCrossPoint
+        );
+      }
+    }
+  }
+
   // 恢复
   goNextState() {
     historyService.redoHistoryRecord();
@@ -487,6 +542,7 @@ export default class History {
       this.goNextForRoadPoints(item.roadPoints);
       this.goNextForRoadEdges(item.roadEdges);
       this.goNextForRoads(item.roads);
+      this.goNextForCrossPoints(item.crossPoints);
       change.saveCurrentInfo();
       this.setState();
     } else {

src/graphic/History/HistoryUtil.js

@@ -144,14 +144,20 @@ export default class HistoryUtil {
     }
   }
 
-  // // road2赋值给road1
-  // assignRoadFromRoad(road1, road2) {
-  //   const roadInfo = {};
-  //   roadInfo.vectorId = road1.vectorId;
-  //   roadInfo.start = road2.startId;
-  //   roadInfo.end = road2.endId;
-  //   this.setRoadInfo(roadInfo);
-  // }
+  isDifferentForCrossPoints(crossPoint1, crossPoint2) {
+    if (
+      mathUtil.equalPoint(crossPoint1, crossPoint2) &&
+      mathUtil.equalPoint(crossPoint1.extremePoint, crossPoint2.extremePoint) &&
+      crossPoint1.edgeInfo1.id == crossPoint2.edgeInfo1.id &&
+      crossPoint1.edgeInfo1.dir == crossPoint2.edgeInfo1.dir &&
+      crossPoint1.edgeInfo2.id == crossPoint2.edgeInfo2.id &&
+      crossPoint1.edgeInfo2.dir == crossPoint2.edgeInfo2.dir
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
 
   assignPointFromPoint(point1, point2) {
     const pointInfo = {};
@@ -252,6 +258,24 @@ export default class HistoryUtil {
     this.setRoadInfo(roadInfo);
   }
 
+  assignCrossPointFromCrossPoint(crossPoint1, crossPoint2) {
+    const crossPointInfo = {};
+    crossPointInfo.vectorId = crossPoint1.vectorId;
+    crossPointInfo.position = { x: crossPoint2.x, y: crossPoint2.y };
+    crossPointInfo.edgeInfo1 = JSON.parse(
+      JSON.stringify(crossPoint2.edgeInfo1)
+    );
+    crossPointInfo.edgeInfo2 = JSON.parse(
+      JSON.stringify(crossPoint2.edgeInfo2)
+    );
+    crossPointInfo.extremePoint = {
+      x: crossPoint2.extremePoint.x,
+      y: crossPoint2.extremePoint.y,
+    };
+    crossPointInfo.curves = JSON.parse(JSON.stringify(crossPoint2.curves));
+    this.setCrossPointInfo(crossPointInfo);
+  }
+
   getDataForPoint(point) {
     const data = {};
     data.id = point.vectorId;
@@ -363,6 +387,20 @@ export default class HistoryUtil {
     return data;
   }
 
+  getDataForCrossPoint(crossPoint) {
+    const data = {};
+    data.id = crossPoint.vectorId;
+    data.type = crossPoint.geoType;
+    data.position = {};
+    mathUtil.clonePoint(data.position, crossPoint);
+    data.extremePoint = {};
+    mathUtil.clonePoint(data.extremePoint, crossPoint.extremePoint);
+
+    data.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint.edgeInfo1));
+    data.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint.edgeInfo2));
+    return data;
+  }
+
   setPointInfo(pointInfo) {
     let point = dataService.getPoint(pointInfo.vectorId);
     mathUtil.clonePoint(point, pointInfo.position);
@@ -449,6 +487,16 @@ export default class HistoryUtil {
       road.rightLanes = JSON.parse(JSON.stringify(roadInfo.rightLanes));
     }
   }
+
+  setCrossPointInfo(crossPointInfo) {
+    let crossPoint = dataService.getCrossPoint2(crossPointInfo.vectorId);
+    crossPoint.vectorId = crossPointInfo.vectorId;
+    mathUtil.clonePoint(crossPoint, crossPointInfo.position);
+    mathUtil.clonePoint(crossPoint.extremePoint, crossPointInfo.extremePoint);
+    crossPoint.edgeInfo1 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo1));
+    crossPoint.edgeInfo2 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo2));
+    crossPoint.curves = JSON.parse(JSON.stringify(crossPointInfo.curves));
+  }
 }
 
 const historyUtil = new HistoryUtil();

src/graphic/Layer.js

@@ -479,11 +479,11 @@ export default class Layer {
         moveRoad.moveCurveRoadPoint(draggingItem.vectorId, position);
         needAutoRedraw = true;
         break;
-      case LayerEvents.MoveControlPoint:
+      case LayerEvents.MoveCrossPoint:
         if (!draggingItem || !draggingItem.vectorId) {
           return;
         }
-        moveRoad.moveControlPoint(draggingItem.vectorId, position);
+        moveRoad.moveCrossPoint(draggingItem.vectorId, position);
         needAutoRedraw = true;
         break;
       case LayerEvents.MoveEdge:
@@ -736,7 +736,7 @@ export default class Layer {
         needAutoRedraw = true;
         this.history.save();
         break;
-      case LayerEvents.MoveControlPoint:
+      case LayerEvents.MoveCrossPoint:
         needAutoRedraw = true;
         this.history.save();
         break;
@@ -803,7 +803,7 @@ export default class Layer {
         const road = dataService.getRoad(focusItem.vectorId);
         roadService.subtraRoadFromIntersect(road.startId, focusItem.vectorId);
         roadService.subtraRoadFromIntersect(road.endId, focusItem.vectorId);
-        //dataService.deleteControlPoint()
+        //dataService.deleteCrossPoint()
         dataService.deleteRoad(focusItem.vectorId);
         this.renderer.autoRedraw();
         this.history.save();
@@ -981,8 +981,8 @@ export default class Layer {
           stateService.setEventName(LayerEvents.MoveCurveRoad);
         } else if (selectItem.type == VectorType.CurveRoadPoint) {
           stateService.setEventName(LayerEvents.MoveCurveRoadPoint);
-        } else if (selectItem.type == VectorType.ControlPoint) {
-          stateService.setEventName(LayerEvents.MoveControlPoint);
+        } else if (selectItem.type == VectorType.CrossPoint) {
+          stateService.setEventName(LayerEvents.MoveCrossPoint);
         } else if (selectItem.type == VectorType.RoadEdge) {
           stateService.setEventName(LayerEvents.MoveEdge);
         } else if (selectItem.type == VectorType.CurveRoadEdge) {

src/graphic/ListenLayer.js

@@ -26,7 +26,7 @@ export default class ListenLayer {
           exceptRoadIds,
           exceptCurveRoadPointId,
           exceptCurveRoadId,
-          exceptCrossControlPointId,
+          exceptCrossCrossPointId,
           exceptTextId,
   }  
    * @returns 
@@ -69,9 +69,9 @@ export default class ListenLayer {
       exceptVectorIds.exceptCircleId
     );
     //交叉口拐弯处的控制点
-    selectInfo.controlPointInfo = this.isSelectCrossControlPoint(
+    selectInfo.crossPointInfo = this.isSelectCrossCrossPoint(
       position,
-      exceptVectorIds.exceptCrossControlPointId
+      exceptVectorIds.exceptCrossCrossPointId
     );
     selectInfo.textInfo = this.isSelectText(
       position,
@@ -710,34 +710,31 @@ export default class ListenLayer {
     }
   }
 
-  isSelectCrossControlPoint(position, exceptCrossControlPointId) {
-    let crossControlPointInfo = {
-      crossControlPointId: null,
+  isSelectCrossCrossPoint(position, exceptCrossCrossPointId) {
+    let crossCrossPointInfo = {
+      crossCrossPointId: null,
       type: null,
       distance: null,
     };
-    const controlPoints = dataService.getControlPoints();
-    for (const controlPointId in controlPoints) {
-      if (controlPointId == exceptCrossControlPointId) {
+    const crossPoints = dataService.getCrossPoints();
+    for (const crossPointId in crossPoints) {
+      if (crossPointId == exceptCrossCrossPointId) {
         continue;
       }
-      const controlPoint = dataService.getControlPoint2(controlPointId);
-      const distance = mathUtil.getDistance(
-        position,
-        controlPoint.extremePoint
-      );
+      const crossPoint = dataService.getCrossPoint2(crossPointId);
+      const distance = mathUtil.getDistance(position, crossPoint.extremePoint);
       if (distance < Constant.minAdsorbPix) {
-        crossControlPointInfo = {
-          crossControlPointId: controlPointId,
-          type: VectorType.ControlPoint,
+        crossCrossPointInfo = {
+          crossCrossPointId: crossPointId,
+          type: VectorType.CrossPoint,
           distance: distance,
-          x: controlPoint.extremePoint.x,
-          y: controlPoint.extremePoint.y,
+          x: crossPoint.extremePoint.x,
+          y: crossPoint.extremePoint.y,
         };
       }
     }
 
-    return crossControlPointInfo;
+    return crossCrossPointInfo;
   }
 
   isSelectText(position, exceptTextId) {
@@ -800,7 +797,7 @@ export default class ListenLayer {
         curveRoadPointInfo,
         roadEdgeInfo,
         curveRoadEdgeInfo,
-        controlPointInfo,
+        crossPointInfo,
         pointInfo,
         roadPointInfo
       }  
@@ -886,12 +883,12 @@ export default class ListenLayer {
         this.modifyPoint.x = info.curveRoadEdgeInfo.x;
         this.modifyPoint.y = info.curveRoadEdgeInfo.y;
       }
-    } else if (info && info.controlPointInfo.crossControlPointId) {
+    } else if (info && info.crossPointInfo.crossCrossPointId) {
       this.modifyPoint = {};
-      this.modifyPoint.linkedCrossControlPointId =
-        info.controlPointInfo.crossControlPointId;
-      this.modifyPoint.x = info.controlPointInfo.x;
-      this.modifyPoint.y = info.controlPointInfo.y;
+      this.modifyPoint.linkedCrossCrossPointId =
+        info.crossPointInfo.crossCrossPointId;
+      this.modifyPoint.x = info.crossPointInfo.x;
+      this.modifyPoint.y = info.crossPointInfo.y;
     } else if (info && info.textInfo.textId) {
       this.modifyPoint = {};
       this.modifyPoint.textId = info.textInfo.textId;
@@ -1031,10 +1028,10 @@ export default class ListenLayer {
         VectorType.CurveRoad,
         SelectState.Select
       );
-    } else if (this.modifyPoint.linkedCrossControlPointId) {
+    } else if (this.modifyPoint.linkedCrossCrossPointId) {
       stateService.setSelectItem(
-        this.modifyPoint.linkedCrossControlPointId,
-        VectorType.ControlPoint,
+        this.modifyPoint.linkedCrossCrossPointId,
+        VectorType.CrossPoint,
         SelectState.Select
       );
     } else if (this.modifyPoint.textId) {

src/graphic/Renderer/Draw.js

@@ -284,7 +284,7 @@ export default class Draw {
     }
   }
 
-  drawControlPoint(vector) {
+  drawCrossPoint(vector) {
     const start = coordinate.getScreenXY(
       dataService
         .getRoadEdge(vector.edgeInfo1.id)
@@ -312,7 +312,7 @@ export default class Draw {
       // pt.y,
       extremePoint.x,
       extremePoint.y,
-      Style.ControlPoint.radius * coordinate.ratio,
+      Style.CrossPoint.radius * coordinate.ratio,
       0,
       Math.PI * 2,
       true

src/graphic/Renderer/Render.js

@@ -32,8 +32,8 @@ export default class Render {
       case VectorType.RoadPoint:
         draw.drawRoadPoint(vector);
         return;
-      case VectorType.ControlPoint:
-        draw.drawControlPoint(vector);
+      case VectorType.CrossPoint:
+        draw.drawCrossPoint(vector);
         return;
       case VectorType.Line:
         draw.drawLine(vector); //需要修改，有几种情况：测量，校准，基准
@@ -129,9 +129,9 @@ export default class Render {
       this.drawGeometry(curveRoads[key]);
     }
 
-    let controlPoints = dataService.getControlPoints();
-    for (let key in controlPoints) {
-      this.drawGeometry(controlPoints[key]);
+    let crossPoints = dataService.getCrossPoints();
+    for (let key in crossPoints) {
+      this.drawGeometry(crossPoints[key]);
     }
 
     let lines = dataService.getLines();

src/graphic/Service/ControlPointService.js

@@ -1,23 +1,20 @@
-import ControlPoint from "../Geometry/ControlPoint.js";
+import CrossPoint from "../Geometry/CrossPoint.js";
 import { dataService } from "./DataService.js";
-import { mathUtil } from "../Util/MathUtil";
+import { mathUtil } from "../Util/MathUtil.js";
 import { edgeService } from "./EdgeService.js";
 import { roadService } from "./RoadService.js";
 
-export default class ControlPointService {
+export default class CrossPointService {
   constructor() {}
 
   //暂时没有添加到vectorData里
   create(position, vectorId) {
-    let controlPoint = new ControlPoint(position, vectorId);
-    return controlPoint;
+    let crossPoint = new CrossPoint(position, vectorId);
+    return crossPoint;
   }
 
   update(realRosition, point1, point2, edge1, edge2, dir1, dir2) {
-    let controlPoint = dataService.getControlPoint(
-      edge1.vectorId,
-      edge2.vectorId
-    );
+    let crossPoint = dataService.getCrossPoint(edge1.vectorId, edge2.vectorId);
     const line1 = edgeService.getLine(edge1);
     const line2 = edgeService.getLine(edge2);
     let position = mathUtil.getPositionForExtendedLine(point1, point2);
@@ -36,43 +33,43 @@ export default class ControlPointService {
       position2 = mathUtil.getJoinLinePoint(_position, line2);
     }
 
-    if (controlPoint == null) {
+    if (crossPoint == null) {
       //新建控制点
-      controlPoint = this.create(realRosition);
+      crossPoint = this.create(realRosition);
       //需要删除之前的控制点
-      dataService.deleteControlPointForEdge(edge1.vectorId, dir1);
-      dataService.deleteControlPointForEdge(edge2.vectorId, dir2);
-      dataService.deleteControlPoint(edge1.vectorId, edge2.vectorId);
+      dataService.deleteCrossPointForEdge(edge1.vectorId, dir1);
+      dataService.deleteCrossPointForEdge(edge2.vectorId, dir2);
+      dataService.deleteCrossPoint(edge1.vectorId, edge2.vectorId);
       //设置控制点的信息
-      controlPoint.setEdgeInfo(edge1.vectorId, dir1, edge2.vectorId, dir2);
+      crossPoint.setEdgeInfo(edge1.vectorId, dir1, edge2.vectorId, dir2);
       //添加到数据集里
-      dataService.addControlPoint(controlPoint);
+      dataService.addCrossPoint(crossPoint);
     }
     //更新控制点坐标
     else {
-      controlPoint.setPosition(realRosition);
+      crossPoint.setPosition(realRosition);
     }
     edge1.setPosition(position1, dir1);
     edge2.setPosition(position2, dir2);
-    controlPoint.setExtremePoint();
+    crossPoint.setExtremePoint();
   }
 
   //newleft,end------------road.leftEdgeId,end
-  replaceEdgeId(controlPoint, oldEdgeId, newEdgeId) {
-    if (controlPoint == null) {
+  replaceEdgeId(crossPoint, oldEdgeId, newEdgeId) {
+    if (crossPoint == null) {
       return;
     }
-    dataService.deleteControlPoint(
-      controlPoint.edgeInfo1.id,
-      controlPoint.edgeInfo2.id
+    dataService.deleteCrossPoint(
+      crossPoint.edgeInfo1.id,
+      crossPoint.edgeInfo2.id
     );
-    if (controlPoint.edgeInfo1.id == oldEdgeId) {
-      controlPoint.edgeInfo1.id = newEdgeId;
-    } else if (controlPoint.edgeInfo2.id == oldEdgeId) {
-      controlPoint.edgeInfo2.id = newEdgeId;
+    if (crossPoint.edgeInfo1.id == oldEdgeId) {
+      crossPoint.edgeInfo1.id = newEdgeId;
+    } else if (crossPoint.edgeInfo2.id == oldEdgeId) {
+      crossPoint.edgeInfo2.id = newEdgeId;
     }
-    controlPoint.setExtremePoint();
-    dataService.addControlPoint(controlPoint);
+    crossPoint.setExtremePoint();
+    dataService.addCrossPoint(crossPoint);
   }
 
   //角度小，road宽的时候，可能edge顺序会倒，但是road的顺序不会
@@ -118,12 +115,12 @@ export default class ControlPointService {
     }
   }
 
-  updateForMovePoint(controlPointId, newPosition) {
-    let controlPoint = dataService.getControlPoint2(controlPointId);
-    mathUtil.clonePoint(controlPoint.extremePoint, newPosition);
-    controlPoint.setCurves();
+  updateForMovePoint(crossPointId, newPosition) {
+    let crossPoint = dataService.getCrossPoint2(crossPointId);
+    mathUtil.clonePoint(crossPoint.extremePoint, newPosition);
+    crossPoint.setCurves();
   }
 }
 
-const controlPointService = new ControlPointService();
-export { controlPointService };
+const crossPointService = new CrossPointService();
+export { crossPointService };

src/graphic/Service/DataService.js

@@ -51,7 +51,7 @@ export class DataService {
     this.vectorData.curveRoads = {};
     this.vectorData.curveRoadEdges = {};
     //直路交叉的时候，产生的曲线控制点
-    this.vectorData.controlPoints = {};
+    this.vectorData.crossPoints = {};
     //直线，起点和终点都是point的id
     this.vectorData.lines = {};
     //弯曲线条
@@ -363,81 +363,81 @@ export class DataService {
   /**
    * 对控制点的操作
    */
-  getControlPoints() {
-    return this.vectorData.controlPoints;
+  getCrossPoints() {
+    return this.vectorData.crossPoints;
   }
 
-  getControlPoint(edgeId1, edgeId2) {
-    if (this.vectorData.controlPoints[edgeId1 + "-" + edgeId2]) {
-      return this.vectorData.controlPoints[edgeId1 + "-" + edgeId2];
-    } else if (this.vectorData.controlPoints[edgeId2 + "-" + edgeId1]) {
-      return this.vectorData.controlPoints[edgeId2 + "-" + edgeId1];
+  getCrossPoint(edgeId1, edgeId2) {
+    if (this.vectorData.crossPoints[edgeId1 + "-" + edgeId2]) {
+      return this.vectorData.crossPoints[edgeId1 + "-" + edgeId2];
+    } else if (this.vectorData.crossPoints[edgeId2 + "-" + edgeId1]) {
+      return this.vectorData.crossPoints[edgeId2 + "-" + edgeId1];
     } else {
       return null;
     }
   }
 
-  getControlPoint2(key) {
-    return this.vectorData.controlPoints[key];
+  getCrossPoint2(key) {
+    return this.vectorData.crossPoints[key];
   }
 
-  getControlPointForEdgeId(edgeId, dir) {
-    for (let key in this.vectorData.controlPoints) {
-      const controlPoint = this.vectorData.controlPoints[key];
+  getCrossPointForEdgeId(edgeId, dir) {
+    for (let key in this.vectorData.crossPoints) {
+      const crossPoint = this.vectorData.crossPoints[key];
       if (
-        controlPoint.edgeInfo1.id == edgeId &&
-        controlPoint.edgeInfo1.dir == dir
+        crossPoint.edgeInfo1.id == edgeId &&
+        crossPoint.edgeInfo1.dir == dir
       ) {
-        return this.vectorData.controlPoints[key];
+        return this.vectorData.crossPoints[key];
       } else if (
-        controlPoint.edgeInfo2.id == edgeId &&
-        controlPoint.edgeInfo2.dir == dir
+        crossPoint.edgeInfo2.id == edgeId &&
+        crossPoint.edgeInfo2.dir == dir
       ) {
-        return this.vectorData.controlPoints[key];
+        return this.vectorData.crossPoints[key];
       }
     }
   }
 
-  addControlPoint(controlPoint) {
-    this.vectorData.controlPoints[
-      controlPoint.edgeInfo1.id + "-" + controlPoint.edgeInfo2.id
-    ] = controlPoint;
+  addCrossPoint(crossPoint) {
+    this.vectorData.crossPoints[
+      crossPoint.edgeInfo1.id + "-" + crossPoint.edgeInfo2.id
+    ] = crossPoint;
   }
 
-  deleteControlPoint(edgeId1, edgeId2) {
+  deleteCrossPoint(edgeId1, edgeId2) {
     let key = edgeId1 + "-" + edgeId2;
-    if (!this.vectorData.controlPoints[key]) {
+    if (!this.vectorData.crossPoints[key]) {
       key = edgeId2 + "-" + edgeId1;
     }
-    if (this.vectorData.controlPoints[key]) {
-      delete this.vectorData.controlPoints[key];
+    if (this.vectorData.crossPoints[key]) {
+      delete this.vectorData.crossPoints[key];
     }
   }
 
-  deleteControlPointForEdge(edgeId, dir) {
-    let dControlPointIds = [];
-    for (let key in this.vectorData.controlPoints) {
-      const controlPoint = this.vectorData.controlPoints[key];
+  deleteCrossPointForEdge(edgeId, dir) {
+    let dCrossPointIds = [];
+    for (let key in this.vectorData.crossPoints) {
+      const crossPoint = this.vectorData.crossPoints[key];
       if (
-        controlPoint.edgeInfo1.id == edgeId ||
-        controlPoint.edgeInfo2.id == edgeId
+        crossPoint.edgeInfo1.id == edgeId ||
+        crossPoint.edgeInfo2.id == edgeId
       ) {
-        dControlPointIds.push(key);
+        dCrossPointIds.push(key);
       }
     }
 
-    for (let i = 0; i < dControlPointIds.length; ++i) {
-      const controlPoint = this.vectorData.controlPoints[dControlPointIds[i]];
+    for (let i = 0; i < dCrossPointIds.length; ++i) {
+      const crossPoint = this.vectorData.crossPoints[dCrossPointIds[i]];
       if (
-        controlPoint.edgeInfo1.id == edgeId &&
-        controlPoint.edgeInfo1.dir == dir
+        crossPoint.edgeInfo1.id == edgeId &&
+        crossPoint.edgeInfo1.dir == dir
       ) {
-        delete this.vectorData.controlPoints[dControlPointIds[i]];
+        delete this.vectorData.crossPoints[dCrossPointIds[i]];
       } else if (
-        controlPoint.edgeInfo2.id == edgeId &&
-        controlPoint.edgeInfo2.dir == dir
+        crossPoint.edgeInfo2.id == edgeId &&
+        crossPoint.edgeInfo2.dir == dir
       ) {
-        delete this.vectorData.controlPoints[dControlPointIds[i]];
+        delete this.vectorData.crossPoints[dCrossPointIds[i]];
       }
     }
   }
@@ -543,7 +543,7 @@ export class DataService {
     this.vectorData.curveRoads = {};
     this.vectorData.curveRoadEdges = {};
     //直路交叉的时候，产生的曲线控制点
-    this.vectorData.controlPoints = {};
+    this.vectorData.crossPoints = {};
     //直线，起点和终点都是point的id
     this.vectorData.lines = {};
     //弯曲线条

src/graphic/Service/EdgeService.js

@@ -2,7 +2,7 @@ import RoadEdge from "../Geometry/RoadEdge.js";
 import Constant from "../Constant.js";
 import { dataService } from "./DataService.js";
 import { roadService } from "./RoadService.js";
-import { controlPointService } from "./ControlPointService.js";
+import { crossPointService } from "./CrossPointService.js";
 import { mathUtil } from "../Util/MathUtil.js";
 
 export default class EdgeService {
@@ -146,15 +146,15 @@ export default class EdgeService {
 
       if (angle > Constant.maxAngle || angle < Constant.minAngle) {
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
-        dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
+        dataService.deleteCrossPoint(leftEdge1.vectorId, rightEdge2.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, leftEdge2.vectorId);
       } else {
         points.push(startPoint1);
         points.push(endPoint1);
         points.push(endPoint2);
         if (mathUtil.isClockwise(points)) {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             startPoint1,
             newEdgePoint1,
@@ -163,7 +163,7 @@ export default class EdgeService {
             "start",
             "start"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint2,
             newEdgePoint2,
             startPoint1,
@@ -173,8 +173,8 @@ export default class EdgeService {
             "start"
           );
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             startPoint1,
             newEdgePoint2,
@@ -183,7 +183,7 @@ export default class EdgeService {
             "start",
             "start"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint1,
             newEdgePoint1,
             startPoint1,
@@ -216,18 +216,15 @@ export default class EdgeService {
 
       if (angle > Constant.maxAngle || angle < Constant.minAngle) {
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        dataService.deleteControlPoint(
-          rightEdge1.vectorId,
-          rightEdge2.vectorId
-        );
+        dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, rightEdge2.vectorId);
       } else {
         points.push(startPoint1);
         points.push(endPoint1);
         points.push(startPoint2);
         if (mathUtil.isClockwise(points)) {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             startPoint1,
             newEdgePoint1,
@@ -236,7 +233,7 @@ export default class EdgeService {
             "start",
             "end"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint2,
             newEdgePoint2,
             startPoint1,
@@ -246,8 +243,8 @@ export default class EdgeService {
             "end"
           );
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             startPoint1,
             newEdgePoint2,
@@ -256,7 +253,7 @@ export default class EdgeService {
             "start",
             "end"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint1,
             newEdgePoint1,
             startPoint1,
@@ -291,18 +288,15 @@ export default class EdgeService {
       mathUtil.clonePoint(rightEdge2.start, newEdgePoint2);
       if (angle > Constant.maxAngle || angle < Constant.minAngle) {
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        dataService.deleteControlPoint(
-          rightEdge1.vectorId,
-          rightEdge2.vectorId
-        );
+        dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, rightEdge2.vectorId);
       } else {
         points.push(endPoint1);
         points.push(startPoint1);
         points.push(endPoint2);
         if (!mathUtil.isClockwise(points)) {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             endPoint1,
             newEdgePoint1,
@@ -311,7 +305,7 @@ export default class EdgeService {
             "end",
             "start"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint2,
             newEdgePoint2,
             endPoint1,
@@ -321,8 +315,8 @@ export default class EdgeService {
             "start"
           );
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             endPoint1,
             newEdgePoint2,
@@ -331,7 +325,7 @@ export default class EdgeService {
             "end",
             "start"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint1,
             newEdgePoint1,
             endPoint1,
@@ -362,15 +356,15 @@ export default class EdgeService {
 
       if (angle > Constant.maxAngle || angle < Constant.minAngle) {
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
-        dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
+        dataService.deleteCrossPoint(leftEdge1.vectorId, rightEdge2.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, leftEdge2.vectorId);
       } else {
         points.push(endPoint1);
         points.push(startPoint1);
         points.push(startPoint2);
         if (!mathUtil.isClockwise(points)) {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             endPoint1,
             newEdgePoint1,
@@ -379,7 +373,7 @@ export default class EdgeService {
             "end",
             "end"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint2,
             newEdgePoint2,
             endPoint1,
@@ -389,8 +383,8 @@ export default class EdgeService {
             "end"
           );
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             endPoint1,
             newEdgePoint2,
@@ -399,7 +393,7 @@ export default class EdgeService {
             "end",
             "end"
           );
-          controlPointService.update(
+          crossPointService.update(
             newEdgePoint1,
             newEdgePoint1,
             endPoint1,
@@ -484,19 +478,16 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.start, newEdgePoint1);
         mathUtil.clonePoint(rightEdge2.start, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, rightEdge2.vectorId);
+        dataService.deleteCrossPoint(leftEdge1.vectorId, rightEdge2.vectorId);
         //不能按照下面的方式计算，因为一个edge可以属于两个控制点，毕竟有两个端点
-        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(rightEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge2.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            leftEdge1.vectorId,
-            rightEdge2.vectorId
-          );
+          dataService.deleteCrossPoint(leftEdge1.vectorId, rightEdge2.vectorId);
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             startPoint1,
             newEdgePoint1,
@@ -513,18 +504,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.start, newEdgePoint2);
         mathUtil.clonePoint(leftEdge2.start, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge2.vectorId, rightEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
-        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
+        dataService.deleteCrossPoint(leftEdge2.vectorId, rightEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge1.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            leftEdge2.vectorId,
-            rightEdge1.vectorId
-          );
+          dataService.deleteCrossPoint(leftEdge2.vectorId, rightEdge1.vectorId);
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             startPoint1,
             newEdgePoint2,
@@ -561,18 +549,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.start, newEdgePoint1);
         mathUtil.clonePoint(leftEdge2.end, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            leftEdge1.vectorId,
-            leftEdge2.vectorId
-          );
+          dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             startPoint1,
             newEdgePoint1,
@@ -587,21 +572,18 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.start, newEdgePoint2);
         mathUtil.clonePoint(rightEdge2.end, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(
-          rightEdge1.vectorId,
-          rightEdge2.vectorId
-        );
-        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(rightEdge2.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, rightEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge2.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
+          dataService.deleteCrossPoint(
             rightEdge1.vectorId,
             rightEdge2.vectorId
           );
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             startPoint1,
             newEdgePoint2,
@@ -638,18 +620,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.end, newEdgePoint1);
         mathUtil.clonePoint(leftEdge2.start, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            leftEdge1.vectorId,
-            leftEdge2.vectorId
-          );
+          dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             endPoint1,
             newEdgePoint1,
@@ -664,21 +643,18 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.end, newEdgePoint2);
         mathUtil.clonePoint(rightEdge2.start, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(
-          rightEdge1.vectorId,
-          rightEdge2.vectorId
-        );
-        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(rightEdge2.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, rightEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge2.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
+          dataService.deleteCrossPoint(
             rightEdge1.vectorId,
             rightEdge2.vectorId
           );
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             endPoint1,
             newEdgePoint2,
@@ -715,18 +691,15 @@ export default class EdgeService {
         mathUtil.clonePoint(leftEdge1.end, newEdgePoint1);
         mathUtil.clonePoint(rightEdge2.end, newEdgePoint1);
         //要删除控制点
-        dataService.deleteControlPoint(leftEdge1.vectorId, leftEdge2.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge1.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
+        dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge1.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge2.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            leftEdge1.vectorId,
-            leftEdge2.vectorId
-          );
+          dataService.deleteCrossPoint(leftEdge1.vectorId, leftEdge2.vectorId);
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint1,
             endPoint1,
             newEdgePoint1,
@@ -741,18 +714,15 @@ export default class EdgeService {
         mathUtil.clonePoint(rightEdge1.end, newEdgePoint2);
         mathUtil.clonePoint(leftEdge2.end, newEdgePoint2);
         //要删除控制点
-        dataService.deleteControlPoint(rightEdge1.vectorId, leftEdge2.vectorId);
-        // dataService.deleteControlPointForEdge(leftEdge2.vectorId);
-        // dataService.deleteControlPointForEdge(rightEdge1.vectorId);
+        dataService.deleteCrossPoint(rightEdge1.vectorId, leftEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(leftEdge2.vectorId);
+        // dataService.deleteCrossPointForEdge(rightEdge1.vectorId);
         if (angle > Constant.maxAngle || angle < Constant.minAngle) {
           //要删除控制点
-          dataService.deleteControlPoint(
-            rightEdge1.vectorId,
-            leftEdge2.vectorId
-          );
+          dataService.deleteCrossPoint(rightEdge1.vectorId, leftEdge2.vectorId);
         } else {
-          //需要考虑控制点ControlPointService
-          controlPointService.update(
+          //需要考虑控制点CrossPointService
+          crossPointService.update(
             newEdgePoint2,
             endPoint1,
             newEdgePoint2,

src/graphic/Service/RoadService.js

@@ -5,7 +5,7 @@ import { roadPointService } from "./RoadPointService.js";
 import { edgeService } from "./EdgeService.js";
 import { mathUtil } from "../Util/MathUtil.js";
 import Constant from "../Constant";
-import { controlPointService } from "./ControlPointService.js";
+import { crossPointService } from "./CrossPointService.js";
 import { lineService } from "./LineService.js";
 export default class RoadService {
   constructor() {}
@@ -119,17 +119,13 @@ export default class RoadService {
     // 更新断开后两个road之间的edge
     edgeService.updateEdgeForTwoRoad(roadId, newRoad.vectorId);
 
-    // 需要更新controlPoints
+    // 需要更新crossPoints
     if (dir == "start") {
-      let cpt = dataService.getControlPointForEdgeId(road.leftEdgeId, "end");
-      controlPointService.replaceEdgeId(
-        cpt,
-        road.leftEdgeId,
-        newRoad.leftEdgeId
-      );
+      let cpt = dataService.getCrossPointForEdgeId(road.leftEdgeId, "end");
+      crossPointService.replaceEdgeId(cpt, road.leftEdgeId, newRoad.leftEdgeId);
 
-      cpt = dataService.getControlPointForEdgeId(road.rightEdgeId, "end");
-      controlPointService.replaceEdgeId(
+      cpt = dataService.getCrossPointForEdgeId(road.rightEdgeId, "end");
+      crossPointService.replaceEdgeId(
         cpt,
         road.rightEdgeId,
         newRoad.rightEdgeId
@@ -146,15 +142,11 @@ export default class RoadService {
         mathUtil.clonePoint(rightEdge.start, oldRightEdgeStartPoint);
       }
     } else if (dir == "end") {
-      let cpt = dataService.getControlPointForEdgeId(road.leftEdgeId, "start");
-      controlPointService.replaceEdgeId(
-        cpt,
-        road.leftEdgeId,
-        newRoad.leftEdgeId
-      );
+      let cpt = dataService.getCrossPointForEdgeId(road.leftEdgeId, "start");
+      crossPointService.replaceEdgeId(cpt, road.leftEdgeId, newRoad.leftEdgeId);
 
-      cpt = dataService.getControlPointForEdgeId(road.rightEdgeId, "start");
-      controlPointService.replaceEdgeId(
+      cpt = dataService.getCrossPointForEdgeId(road.rightEdgeId, "start");
+      crossPointService.replaceEdgeId(
         cpt,
         road.rightEdgeId,
         newRoad.rightEdgeId

src/graphic/enum/HistoryEvents.js

@@ -34,5 +34,9 @@ const HistoryEvents = {
   AddSVG: "addSVG",
   DeleteSVG: "deleteSVG",
   ModifySVG: "modifySVG",
+
+  AddCrossPoint: "AddCrossPoint",
+  DeleteCrossPoint: "deleteCrossPoint",
+  ModifyCrossPoint: "modifyCrossPoint",
 };
 export default HistoryEvents;

src/graphic/enum/LayerEvents.js

@@ -20,7 +20,7 @@ const LayerEvents = {
   AddingCircle: "addingCircle",
   MoveCircle: "moveCircle",
 
-  MoveControlPoint: "moveControlPoint",
+  MoveCrossPoint: "moveCrossPoint",
   MoveEdge: "moveEdge",
   MoveCurveEdge: "moveCurveEdge",
 

src/graphic/enum/UIEvents.js

@@ -118,9 +118,9 @@ const UIEvents = {
 
   // ------------选中组件时的UI控制-----------
   // 加控制点
-  AddControlPoint: "AddControlPoint",
+  AddCrossPoint: "AddCrossPoint",
   // 减控制点
-  MinusControlPoint: "MinusControlPoint",
+  MinusCrossPoint: "MinusCrossPoint",
   // 复制
   Copy: "copy",
   // 删除

src/graphic/enum/VectorType.js

@@ -1,5 +1,5 @@
 const VectorType = {
-  ControlPoint: "ControlPoint",
+  CrossPoint: "CrossPoint",
   Circle: "Circle",
   Img: "Img",
   Point: "Point",