Merge remote-tracking branch 'origin/master'

# Conflicts:
#	server/test/SS-t-P1d6CwREny2/attach/sceneStore

src/graphic/History/History.js

@@ -234,7 +234,7 @@ export default class History {
     for (let i = 0; i < itemForRoadPoints.length; ++i) {
       const item = itemForRoadPoints[i];
       if (item.handle == HistoryEvents.AddRoadPoint) {
-        dataService.deleteRoadPoint(item.roadPoint.id);
+        dataService.deleteRoadPoint1(item.roadPoint.id);
       } else if (item.handle == HistoryEvents.DeleteRoadPoint) {
         let newRoadPoint = roadPointService.create(
           item.roadPoint.position,
@@ -279,7 +279,7 @@ export default class History {
       if (item.handle == HistoryEvents.AddRoad) {
         dataService.deleteRoad(item.road.id);
       } else if (item.handle == HistoryEvents.DeleteRoad) {
-        let newRoad = roadService.create(
+        let newRoad = roadService.createOnlyRoad(
           item.road.startId,
           item.road.endId,
           item.road.id
@@ -297,10 +297,9 @@ export default class History {
     for (let i = 0; i < itemForCrossPoints.length; ++i) {
       const item = itemForCrossPoints[i];
       if (item.handle == HistoryEvents.AddCrossPoint) {
-        dataService.deleteCrossPoint(item.crossPoint.id);
+        dataService.deleteCrossPoint1(item.crossPoint.id);
       } else if (item.handle == HistoryEvents.DeleteCrossPoint) {
-        crossPointService.create;
-        let newCrossPoint = roadService.create(
+        let newCrossPoint = crossPointService.create(
           item.crossPoint.position,
           item.crossPoint.id
         );
@@ -310,7 +309,7 @@ export default class History {
         );
       } else if (item.handle == HistoryEvents.ModifyCrossPoint) {
         const preCrossPoint = item.preCrossPoint;
-        let currentCrossPoint = dataService.getCrossPoint2(
+        let currentCrossPoint = dataService.getCrossPoint3(
           item.curCrossPoint.id
         );
         historyUtil.assignCrossPointFromCrossPoint(
@@ -448,7 +447,7 @@ export default class History {
         );
         historyUtil.assignRoadPointFromRoadPoint(vRoadPoint, item.roadPoint);
       } else if (item.handle == HistoryEvents.DeleteRoadPoint) {
-        dataService.deleteRoadPoint(item.roadPoint.id);
+        dataService.deleteRoadPoint1(item.roadPoint.id);
       } else if (item.handle == HistoryEvents.ModifyRoadPoint) {
         const currentRoadPoint = item.curRoadPoint;
         let preRoadPoint = dataService.getRoadPoint(item.curRoadPoint.id);
@@ -485,7 +484,7 @@ export default class History {
     for (let i = 0; i < itemForRoads.length; ++i) {
       const item = itemForRoads[i];
       if (item.handle == HistoryEvents.AddRoad) {
-        let vRoad = roadService.create(
+        let vRoad = roadService.createOnlyRoad(
           item.road.startId,
           item.road.endId,
           item.road.id
@@ -514,10 +513,10 @@ export default class History {
           item.crossPoint
         );
       } else if (item.handle == HistoryEvents.DeleteCrossPoint) {
-        dataService.deleteCrossPoint(item.crossPoint.id);
+        dataService.deleteCrossPoint1(item.crossPoint.id);
       } else if (item.handle == HistoryEvents.ModifyCrossPoint) {
         const currentCrossPoint = item.curCrossPoint;
-        let preCrossPoint = dataService.getCrossPoint2(item.curCrossPoint.id);
+        let preCrossPoint = dataService.getCrossPoint3(item.curCrossPoint.id);
         historyUtil.assignCrossPointFromCrossPoint(
           preCrossPoint,
           currentCrossPoint

src/graphic/History/HistoryUtil.js

@@ -261,13 +261,19 @@ export default class HistoryUtil {
   assignCrossPointFromCrossPoint(crossPoint1, crossPoint2) {
     const crossPointInfo = {};
     crossPointInfo.vectorId = crossPoint1.vectorId;
-    crossPointInfo.position = { x: crossPoint2.x, y: crossPoint2.y };
+    crossPointInfo.position = {
+      x: crossPoint2.position.x,
+      y: crossPoint2.position.y,
+    };
     crossPointInfo.edgeInfo1 = JSON.parse(
       JSON.stringify(crossPoint2.edgeInfo1)
     );
     crossPointInfo.edgeInfo2 = JSON.parse(
       JSON.stringify(crossPoint2.edgeInfo2)
     );
+    crossPoint1.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint2.edgeInfo1));
+    crossPoint1.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint2.edgeInfo2));
+    dataService.addCrossPoint(crossPoint1);
     crossPointInfo.extremePoint = {
       x: crossPoint2.extremePoint.x,
       y: crossPoint2.extremePoint.y,
@@ -398,6 +404,7 @@ export default class HistoryUtil {
 
     data.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint.edgeInfo1));
     data.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint.edgeInfo2));
+    data.curves = JSON.parse(JSON.stringify(crossPoint.curves));
     return data;
   }
 
@@ -489,9 +496,10 @@ export default class HistoryUtil {
   }
 
   setCrossPointInfo(crossPointInfo) {
-    let crossPoint = dataService.getCrossPoint2(crossPointInfo.vectorId);
+    let crossPoint = dataService.getCrossPoint3(crossPointInfo.vectorId);
     crossPoint.vectorId = crossPointInfo.vectorId;
     mathUtil.clonePoint(crossPoint, crossPointInfo.position);
+    crossPoint.extremePoint = {};
     mathUtil.clonePoint(crossPoint.extremePoint, crossPointInfo.extremePoint);
     crossPoint.edgeInfo1 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo1));
     crossPoint.edgeInfo2 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo2));

src/graphic/Layer.js

@@ -36,6 +36,8 @@ import { curveRoadService } from "./Service/CurveRoadService";
 import VectorCategory from "./enum/VectorCategory";
 
 const minDragDis = 10;
+const minZoom = 20;
+const maxZoom = 800;
 
 export default class Layer {
   constructor(canvas, newsletter, graphicState) {
@@ -832,7 +834,7 @@ export default class Layer {
   }
 
   zoomVector(zoom) {
-    if (zoom < 14) {
+    if (zoom < minZoom || zoom > maxZoom) {
       return;
     }
 

src/graphic/Service/DataService.js

@@ -340,6 +340,10 @@ export class DataService {
     }
   }
 
+  deleteRoadPoint1(roadPointId) {
+    delete this.vectorData.roadPoints[roadPointId];
+  }
+
   addRoadPoint(roadPoint) {
     this.vectorData.roadPoints[roadPoint.vectorId] = roadPoint;
   }
@@ -381,6 +385,14 @@ export class DataService {
     return this.vectorData.crossPoints[key];
   }
 
+  getCrossPoint3(vectorId) {
+    for (let key in this.vectorData.crossPoints) {
+      if (this.vectorData.crossPoints[key].vectorId == vectorId) {
+        return this.vectorData.crossPoints[key];
+      }
+    }
+  }
+
   getCrossPointForEdgeId(edgeId, dir) {
     for (let key in this.vectorData.crossPoints) {
       const crossPoint = this.vectorData.crossPoints[key];
@@ -414,6 +426,15 @@ export class DataService {
     }
   }
 
+  deleteCrossPoint1(vectorId) {
+    for (let key in this.vectorData.crossPoints) {
+      if (this.vectorData.crossPoints[key].vectorId == vectorId) {
+        delete this.vectorData.crossPoints[key];
+        return;
+      }
+    }
+  }
+
   deleteCrossPointForEdge(edgeId, dir) {
     let dCrossPointIds = [];
     for (let key in this.vectorData.crossPoints) {

src/graphic/Service/RoadService.js

@@ -58,6 +58,19 @@ export default class RoadService {
     return road;
   }
 
+  //撤销恢复用的，edge这些会专门调用
+  createOnlyRoad(startId, endId, vectorId) {
+    let road = new Road(startId, endId, vectorId);
+    dataService.addRoad(road);
+
+    let startPoint = dataService.getRoadPoint(startId);
+    startPoint.setPointParent(road.vectorId, "start");
+
+    let endPoint = dataService.getRoadPoint(endId);
+    endPoint.setPointParent(road.vectorId, "end");
+    return road;
+  }
+
   getMidLine(road) {
     let startPoint = dataService.getRoadPoint(road.startId);
     let endPoint = dataService.getRoadPoint(road.endId);

src/graphic/Util/MathUtil.js

@@ -350,17 +350,13 @@ export default class MathUtil {
   }
 
   getArrow(start, end, ange = 30, L = 20) {
-    let a = Math.atan2((end.y - start.y), (end.x - start.x));
-    let xC = end.x - L * Math.cos(a + ange * Math.PI/180); // θ=30
-    let yC = end.y - L * Math.sin(a + ange * Math.PI/180);
-    let xD = end.x - L * Math.cos(a - ange * Math.PI/180);
-    let yD = end.y - L * Math.sin(a - ange * Math.PI/180);
-
-    return [
-      {x: xC, y: yC},
-      end,
-      {x: xD, y: yD}
-    ]
+    let a = Math.atan2(end.y - start.y, end.x - start.x);
+    let xC = end.x - L * Math.cos(a + (ange * Math.PI) / 180); // θ=30
+    let yC = end.y - L * Math.sin(a + (ange * Math.PI) / 180);
+    let xD = end.x - L * Math.cos(a - (ange * Math.PI) / 180);
+    let yD = end.y - L * Math.sin(a - (ange * Math.PI) / 180);
+
+    return [{ x: xC, y: yC }, end, { x: xD, y: yD }];
   }
 
   //经过point且与line垂直的线

src/sdk/laser/core/enter.js

@@ -214,9 +214,9 @@ var enter = ({
                 bus.emit("update");
             }
         });
-        measure.addEventListener("highlight", (e) => {
+        /* measure.addEventListener("highlight", (e) => {
             bus.emit("highlight", e.state);
-        });
+        }); */
         
         measure.addEventListener("selected", (e) => {
             bus.emit("selected", e.state);
@@ -688,7 +688,8 @@ var enter = ({
 
             screenshot: (width, height) => {
                 //截图
-                isScreenshoting = true;
+                let meterPerPixel,
+                    isScreenshoting = true;
                 var {
                     getImagePromise,
                     finishPromise
@@ -700,7 +701,10 @@ var enter = ({
                 finishPromise.done(() => {
                     isScreenshoting = false;
                 });
-                return finishPromise;
+                if(viewer.mainViewport.camera.type == 'OrthographicCamera'){
+                   meterPerPixel = 1 / viewer.mainViewport.camera.zoom 
+                }
+                return {finishPromise, meterPerPixel};
             },
 
             canTurnToPanoMode(pos) {
@@ -737,7 +741,7 @@ var enter = ({
                 }
                 
                 let gotIntersect = (e)=>{
-                    if(e.intersect){ 
+                    if(e.intersect && e.intersect.location){ 
                         console.log('quit', e.intersect.location)
                         quit()
                         deferred.resolve(e.intersect.location)