添加公路转线条

src/graphic/Controls/MoveLine.js

@@ -1,4 +1,5 @@
 import { dataService } from "../Service/DataService";
+import { mathUtil } from "../Util/MathUtil";
 
 export default class MoveLine {
   constructor() {}
@@ -14,6 +15,23 @@ export default class MoveLine {
     endPoint.x += dx;
     endPoint.y += dy;
   }
+
+  moveCurveLine(curveLineId, dx, dy) {
+    dx = dx;
+    dy = -dy;
+    let curveLine = dataService.getCurveLine(curveLineId);
+    let startPoint = dataService.getCurvePoint(curveLine.startId);
+    let endPoint = dataService.getCurvePoint(curveLine.endId);
+    startPoint.x += dx;
+    startPoint.y += dy;
+    endPoint.x += dx;
+    endPoint.y += dy;
+    for (let i = 1; i < curveLine.points.length - 1; ++i) {
+      curveLine.points[i].x += dx;
+      curveLine.points[i].y += dy;
+    }
+    curveLine.curves = mathUtil.getCurvesByPoints(curveLine.points);
+  }
 }
 
 const moveLine = new MoveLine();

src/graphic/Controls/MovePoint.js

@@ -155,6 +155,13 @@ export default class MovePoint {
       }
     }
   }
+
+  /*****************************************************************************曲线上的点********************************************************************************/
+
+  moveCurvePoint(position, curvePointId) {
+    let curvePoint = dataService.getCurvePoint(curvePointId);
+    curvePoint.setPosition(position);
+  }
 }
 
 const movePoint = new MovePoint();

src/graphic/Layer.js

@@ -270,12 +270,6 @@ export default class Layer {
       }
     }
 
-    console.log(
-      "onMouseMove--->offsetX:" +
-        Math.abs(X - this.startX) +
-        "offsetY:" +
-        Math.abs(Y - this.startY)
-    );
     // 是否需要重绘
     let needAutoRedraw = false;
     let point = null;
@@ -653,6 +647,33 @@ export default class Layer {
           needAutoRedraw = true;
         }
         break;
+      case LayerEvents.MoveCurvePoint:
+        if (draggingItem != null) {
+          let curvePoint = dataService.getCurvePoint(draggingItem.vectorId);
+          listenLayer.start(position, {
+            exceptCurvePointId: draggingItem.vectorId,
+            exceptCurveLineId: curvePoint.parent,
+          });
+          if (listenLayer.modifyPoint) {
+            position = {
+              x: listenLayer.modifyPoint.x,
+              y: listenLayer.modifyPoint.y,
+            };
+          }
+          movePoint.moveCurvePoint(position, draggingItem.vectorId);
+          needAutoRedraw = true;
+        }
+        break;
+      case LayerEvents.MoveCurveLine:
+        if (draggingItem != null) {
+          moveLine.moveCurveLine(
+            draggingItem.vectorId,
+            (dx * coordinate.defaultZoom) / coordinate.zoom,
+            (dy * coordinate.defaultZoom) / coordinate.zoom
+          );
+          needAutoRedraw = true;
+        }
+        break;
       case LayerEvents.MoveCircle:
         if (draggingItem != null) {
           if (draggingItem.state == -1) {
@@ -905,6 +926,14 @@ export default class Layer {
         }
         this.history.save();
         break;
+      case LayerEvents.MoveCurvePoint:
+        needAutoRedraw = true;
+        this.history.save();
+        break;
+      case LayerEvents.MoveCurveLine:
+        needAutoRedraw = true;
+        this.history.save();
+        break;
       case LayerEvents.MoveCircle:
         needAutoRedraw = true;
         this.history.save();
@@ -1147,6 +1176,8 @@ export default class Layer {
           stateService.setEventName(LayerEvents.MovePoint);
         } else if (selectItem.type == VectorType.Line) {
           stateService.setEventName(LayerEvents.MoveLine);
+        } else if (selectItem.type == VectorType.CurvePoint) {
+          stateService.setEventName(LayerEvents.MoveCurvePoint);
         } else if (selectItem.type == VectorType.CurveLine) {
           stateService.setEventName(LayerEvents.MoveCurveLine);
         } else if (selectItem.type == VectorType.Circle) {

src/graphic/ListenLayer.js

@@ -890,12 +890,7 @@ export default class ListenLayer {
       }
       const text = dataService.getText(textId);
       const distance = this.getDistance(position, text.center);
-      console.log(
-        "isSelectText-distance:" +
-          distance +
-          ",minAdsorbPix:" +
-          Constant.minAdsorbPix
-      );
+
       if (distance < Constant.minAdsorbPix) {
         textInfo = {
           textId: textId,

src/graphic/Renderer/Render.js

@@ -42,6 +42,9 @@ export default class Render {
       case VectorType.Line:
         draw.drawLine(vector); //需要修改，有几种情况：测量，校准，基准
         break;
+      case VectorType.CurvePoint:
+        draw.drawPoint(vector);
+        break;
       case VectorType.CurveLine:
         //draw.drawCurveLine(vector);
         break;

src/graphic/Service/CurveRoadService.js

@@ -6,6 +6,7 @@ import CurveRoad from "../Geometry/CurveRoad.js";
 import VectorType from "../enum/VectorType";
 import Constant from "../Constant";
 import RoadService from "./RoadService";
+import { lineService } from "./LineService";
 
 export default class CurveRoadService extends RoadService {
   constructor() {
@@ -651,6 +652,32 @@ export default class CurveRoadService extends RoadService {
     curveRoad.curves = mathUtil.getCurvesByPoints(curveRoad.points);
   }
 
+  convertToCurveLines(curveRoadId) {
+    let curveRoad = dataService.getCurveRoad(curveRoadId);
+    let leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
+    let rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
+
+    lineService.createCurveLineForPoints(leftCurveEdge.points);
+    lineService.createCurveLineForPoints(rightCurveEdge.points);
+
+    if (curveRoad.way == Constant.oneWay) {
+      for (let i = 0; i < curveRoad.singleLanesCurves.length; ++i) {
+        lineService.createCurveLineForPoints(curveRoad.singleLanesCurves[i]);
+      }
+    } else if (curveRoad.way == Constant.twoWay) {
+      for (let i = 0; i < curveRoad.leftLanesCurves.length; ++i) {
+        lineService.createCurveLineForPoints(curveRoad.leftLanesCurves[i]);
+      }
+      for (let i = 0; i < curveRoad.rightLanesCurves.length; ++i) {
+        lineService.createCurveLineForPoints(curveRoad.rightLanesCurves[i]);
+      }
+      lineService.createCurveLineForPoints(curveRoad.midDivide.leftMidDivide);
+      lineService.createCurveLineForPoints(curveRoad.midDivide.rightMidDivide);
+    }
+
+    dataService.deleteCurveRoad(curveRoadId);
+  }
+
   unlock(curveRoadId) {
     let curveRoad = dataService.getCurveRoad(curveRoadId);
     let leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);

src/graphic/Service/LineService.js

@@ -121,6 +121,28 @@ export default class LineService {
     dataService.addCurveLine(curveLine);
     return curveLine;
   }
+
+  createCurveLineForPoints(points, vectorId) {
+    let curvePoints = [];
+    for (let i = 0; i < points.length; ++i) {
+      let curvePoint = curvePointService.create(points[i]);
+      curvePoints.push(curvePoint);
+    }
+    let curveLine = new CurveLine(
+      curvePoints[0].vectorId,
+      curvePoints[curvePoints.length - 1].vectorId,
+      vectorId
+    );
+    curvePoints[0].setPointParent(curveLine.vectorId, "start");
+    curvePoints[curvePoints.length - 1].setPointParent(
+      curveLine.vectorId,
+      "end"
+    );
+    curveLine.points = JSON.parse(JSON.stringify(curvePoints));
+    curveLine.curves = mathUtil.getCurvesByPoints(curveLine.points);
+    dataService.addCurveLine(curveLine);
+    return curveLine;
+  }
 }
 
 const lineService = new LineService();

src/graphic/Service/RoadService.js

@@ -1390,6 +1390,36 @@ export default class RoadService {
     this.setLanes(roadId, dir);
   }
 
+  convertToLines(roadId) {
+    let road = dataService.getRoad(roadId);
+    let leftEdge = dataService.getRoadEdge(road.leftEdgeId);
+    let rightEdge = dataService.getRoadEdge(road.rightEdgeId);
+    lineService.create(leftEdge.start, leftEdge.end);
+    lineService.create(rightEdge.start, rightEdge.end);
+    if (road.way == Constant.oneWay) {
+      for (let i = 0; i < road.singleLanes.length; ++i) {
+        lineService.create(road.singleLanes[i].start, road.singleLanes[i].end);
+      }
+    } else if (road.way == Constant.twoWay) {
+      for (let i = 0; i < road.leftLanes.length; ++i) {
+        lineService.create(road.leftLanes[i].start, road.leftLanes[i].end);
+      }
+      for (let i = 0; i < road.rightLanes.length; ++i) {
+        lineService.create(road.rightLanes[i].start, road.rightLanes[i].end);
+      }
+      lineService.create(
+        road.midDivide.leftMidDivide.start,
+        road.midDivide.leftMidDivide.end
+      );
+      lineService.create(
+        road.midDivide.rightMidDivide.start,
+        road.midDivide.rightMidDivide.end
+      );
+    }
+
+    dataService.deleteRoad(roadId);
+  }
+
   // unlock(roadId) {
   //   let road = dataService.getRoad(roadId);
   //   let startPoint = dataService.getRoadPoint(road.startId);

src/graphic/enum/LayerEvents.js

@@ -31,6 +31,8 @@ const LayerEvents = {
   AddingCurveLine: "addingCurveLine",
   MoveCurveLine: "moveCurveLine",
 
+  MoveCurvePoint: "moveCurvePoint",
+
   AddText: "addText",
   MoveText: "moveText",