fix: Merge branch 'master' of http://192.168.0.115:3000/bill/traffic-laser

src/graphic/Controls/MoveRoad.js

@@ -1024,14 +1024,14 @@ export default class MoveRoad {
       rightCurveEdge.points[i].x += dx;
       rightCurveEdge.points[i].y += dy;
     }
-    leftCurveEdge.start.x += dx;
-    leftCurveEdge.start.y += dy;
-    leftCurveEdge.end.x += dx;
-    leftCurveEdge.end.y += dy;
-    rightCurveEdge.start.x += dx;
-    rightCurveEdge.start.y += dy;
-    rightCurveEdge.end.x += dx;
-    rightCurveEdge.end.y += dy;
+    // leftCurveEdge.start.x += dx;
+    // leftCurveEdge.start.y += dy;
+    // leftCurveEdge.end.x += dx;
+    // leftCurveEdge.end.y += dy;
+    // rightCurveEdge.start.x += dx;
+    // rightCurveEdge.start.y += dy;
+    // rightCurveEdge.end.x += dx;
+    // rightCurveEdge.end.y += dy;
     curveRoad.curves = mathUtil.getCurvesByPoints(curveRoad.points);
     leftCurveEdge.curves = mathUtil.getCurvesByPoints(leftCurveEdge.points);
     rightCurveEdge.curves = mathUtil.getCurvesByPoints(rightCurveEdge.points);

src/graphic/History/HistoryUtil.js

@@ -954,7 +954,11 @@ export default class HistoryUtil {
     curveRoadEdge.vectorId = curveRoadEdgeInfo.vectorId;
     mathUtil.clonePoint(curveRoadEdge.start, curveRoadEdgeInfo.start);
     mathUtil.clonePoint(curveRoadEdge.end, curveRoadEdgeInfo.end);
-    mathUtil.clonePoints(curveRoadEdge.points, curveRoadEdgeInfo.points);
+    for (let i = 0; i < curveRoadEdgeInfo.points.length; ++i) {
+      curveRoadEdge.points[i] = {};
+      mathUtil.clonePoint(curveRoadEdge.points[i], curveRoadEdgeInfo.points[i]);
+    }
+
     curveRoadEdge.curves = JSON.parse(JSON.stringify(curveRoadEdgeInfo.curves));
     curveRoadEdge.type = curveRoadEdgeInfo.type;
     curveRoadEdge.style = curveRoadEdgeInfo.style;

src/graphic/ListenLayer.js

@@ -760,6 +760,12 @@ export default class ListenLayer {
         //Constant.minAdsorbPix
         Math.max(curveRoad.leftWidth, curveRoad.rightWidth)
       );
+
+      let index = mathUtil.getIndexForCurvesPoints(position, curveRoad.points);
+      if (index == 0 || index == curveRoad.points.length) {
+        continue;
+      }
+
       console.log("isSelectCurveRoad:" + JSON.stringify(joinInfo));
       //检查edge
       const leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);

src/graphic/Load.js

@@ -19,6 +19,7 @@ import { uiService } from "./Service/UIService";
 import { crossPointService } from "./Service/CrossPointService.js";
 import Road from "./Geometry/Road.js";
 import { edgeService } from "./Service/EdgeService.js";
+import { curvePointService } from "./Service/CurvePointService.js";
 
 export default class Load {
   constructor(layer) {
@@ -152,52 +153,33 @@ export default class Load {
           }
         }
       }
-      // if (dataLocal.curvelines) {
-      //   for (let key in dataLocal.curvelines) {
-      //     let startPointId = dataLocal.curvelines[key].startId
-      //     let endPointId = dataLocal.curvelines[key].endId
 
-      //     let startPosition = null;
-      //     let endPosition = null ;
-      //     if(dataLocal.curvePoints){
-      //       startPosition ={
-      //         x:dataLocal.curvePoints[startPointId].x,
-      //         y:dataLocal.curvePoints[startPointId].y,
-      //       }
-      //       endPosition ={
-      //         x:dataLocal.curvePoints[endPointId].x,
-      //         y:dataLocal.curvePoints[endPointId].y,
-      //       }
-
-      //     }
+      if (dataLocal.curvePoints) {
+        for (let key in dataLocal.curvePoints) {
+          let curvePointData = dataLocal.curvePoints[key];
+          let curvePoint = curvePointService.create(
+            curvePointData,
+            curvePointData.vectorId
+          );
+          curvePoint.setIndex(curvePointData.index);
+          curvePoint.setPointParent(curvePointData.parent);
+          dataService.addCurvePoint(curvePoint);
+        }
+      }
 
-      //     let curveline = lineService.createCurveLine(
-      //       startPosition,
-      //       endPosition,
-      //       dataLocal.curvelines[key].vectorId,
-      //     );
+      if (dataLocal.curvelines) {
+        for (let key in dataLocal.curvelines) {
+          let curveLineData = dataLocal.curvelines[key];
+          let curveLine = lineService.createCurveLineByPointIds(
+            curveLineData.points,
+            curveLineData.vectorId
+          );
+          curveLine.setStyle(curveLineData.style);
+          curveLine.setWeight(curveLineData.weight);
+          dataService.addCurveLine(curveLine);
+        }
+      }
 
-      //     if (dataLocal.curvelines[key].style) {
-      //       curveline.setStyle(dataLocal.curvelines[key].style);
-      //     }
-      //     if (dataLocal.curvelines[key].weight) {
-      //       curveline.setWeight(dataLocal.curvelines[key].weight);
-      //     }
-      //     if (dataLocal.curvelines[key].color) {
-      //       curveline.setColor(dataLocal.curvelines[key].color);
-      //     }
-      //     if (dataLocal.curvelines[key].value) {
-      //       curveline.setValue(dataLocal.curvelines[key].value);
-      //     }
-      //     if (dataLocal.curvelines[key].locationMode) {
-      //       curveline.setLocationMode(dataLocal.curvelines[key].locationMode);
-      //     }
-      //     curveline.setDisplay(dataLocal.curvelines[key].display);
-      //     if (curveline.getCategory() == VectorCategory.Line.BaseLine) {
-      //       Settings.baseLineId = key;
-      //     }
-      //   }
-      // }
       if (dataLocal.roadPoints) {
         for (let key in dataLocal.roadPoints) {
           roadPointService.create(

src/graphic/Service/CurveRoadService.js

@@ -3,7 +3,7 @@ import { curveRoadPointService } from "./CurveRoadPointService";
 import { curveEdgeService } from "./CurveEdgeService";
 import { mathUtil } from "../Util/MathUtil.js";
 import CurveRoad from "../Geometry/CurveRoad.js";
-import VectorType from "../enum/VectorType";
+import VectorStyle from "../enum/VectorStyle";
 import Constant from "../Constant";
 import RoadService from "./RoadService";
 import { lineService } from "./LineService";
@@ -1138,8 +1138,14 @@ export default class CurveRoadService extends RoadService {
       for (let i = 0; i < curveRoad.rightLanesCurves.length; ++i) {
         lineService.createCurveLineByPoints(curveRoad.rightLanesCurves[i]);
       }
-      lineService.createCurveLineByPoints(curveRoad.midDivide.leftMidDivide);
-      lineService.createCurveLineByPoints(curveRoad.midDivide.rightMidDivide);
+      let leftMidDivide = lineService.createCurveLineByPoints(
+        curveRoad.midDivide.leftMidDivide
+      );
+      leftMidDivide.setStyle(VectorStyle.SingleDashedLine);
+      let rightMidDivide = lineService.createCurveLineByPoints(
+        curveRoad.midDivide.rightMidDivide
+      );
+      rightMidDivide.setStyle(VectorStyle.SingleDashedLine);
     }
   }
 }

src/graphic/Util/MathUtil.js

@@ -1623,7 +1623,7 @@ export default class MathUtil {
       if (this.isContainForSegment(join, points[i], points[i + 1])) {
         if (minDis == null || minDis > dis) {
           minDis = dis;
-          index = i;
+          index = i + 1;
         }
       }
       if (minDisToPoint == null) {
@@ -1634,7 +1634,7 @@ export default class MathUtil {
         minPointIndex = i;
       }
     }
-    if ((index = -1)) {
+    if (index == -1) {
       if (
         minDisToPoint >
         mathUtil.getDistance(position, points[points.length - 1])