Merge remote-tracking branch 'origin/master'

src/graphic/Geometry/Magnifier.js

@@ -10,8 +10,8 @@ export default class Magnifier extends Geometry {
   constructor(position, vectorId) {
     super();
     this.position = {};
-    this.photoUrl = null
-    this.photoImage = null
+    this.photoUrl = null;
+    this.photoImage = null;
     this.popPosition = {};
     this.setPosition(position);
     this.geoType = VectorType.Magnifier;
@@ -52,10 +52,20 @@ export default class Magnifier extends Geometry {
     }
   }
 
-  setPhotoUrl(url) {
-    this.photoUrl = url
+  setSrc(src) {
+    this.photoUrl = src;
   }
-  setPhotoImage(img) {
-    this.photoImage = img
+
+  setImageData() {
+    return new Promise((resolve, reject) => {
+      this.photoImage = new Image();
+      this.photoImage.src = this.photoUrl;
+      this.photoImage.onload = function () {
+        resolve();
+      };
+      this.photoImage.onerror = function () {
+        reject();
+      };
+    });
   }
 }

src/graphic/History/Change.js

@@ -23,7 +23,9 @@ export default class Change {
     this.lastData.circles = JSON.parse(
       JSON.stringify(dataService.getCircles())
     );
-    this.lastData.texts = JSON.parse(JSON.stringify(dataService.getTexts()));
+    this.lastData.magnifiers = JSON.parse(
+      JSON.stringify(dataService.getMagnifiers())
+    );
     this.lastData.svgs = JSON.parse(JSON.stringify(dataService.getSVGs()));
   }
 
@@ -35,6 +37,7 @@ export default class Change {
     this.compareLines();
     this.compareCircles();
     this.compareTexts();
+    this.compareMagnifiers();
     this.compareSVGs();
     if (
       this.currentData.points.length == 0 &&
@@ -246,6 +249,47 @@ export default class Change {
     }
   }
 
+  compareMagnifiers() {
+    const magnifiers = dataService.getMagnifiers();
+    this.currentData.magnifiers = [];
+
+    for (const key in magnifiers) {
+      const magnifier = magnifiers[key];
+      // 不存在意味着增加
+      if (!this.lastData.magnifiers[key]) {
+        const item = {
+          handle: HistoryEvents.AddMagnifier,
+          magnifier: historyUtil.getDataForMagnifier(magnifier),
+        };
+        this.currentData.magnifiers.push(item);
+      } else {
+        const lastMagnifier = this.lastData.magnifiers[key];
+        if (!historyUtil.isDifferentForMagnifiers(magnifier, lastMagnifier)) {
+          delete this.lastData.magnifiers[key];
+          continue;
+        } else {
+          const item = {
+            handle: HistoryEvents.ModifyMagnifier,
+            preMagnifier: historyUtil.getDataForMagnifier(lastMagnifier),
+            curMagnifier: historyUtil.getDataForMagnifier(magnifier),
+          };
+          this.currentData.magnifiers.push(item);
+        }
+      }
+      delete this.lastData.magnifiers[key];
+    }
+
+    for (const key in this.lastData.magnifiers) {
+      const item = {
+        handle: HistoryEvents.DeleteMagnifier,
+        magnifier: historyUtil.getDataForMagnifier(
+          this.lastData.magnifiers[key]
+        ),
+      };
+      this.currentData.magnifiers.push(item);
+    }
+  }
+
   compareSVGs() {
     this.currentData.svgs = [];
     const svgs = dataService.getSVGs();

src/graphic/History/History.js

@@ -11,6 +11,7 @@ import { roadPointService } from "../Service/RoadPointService";
 import { lineService } from "../Service/LineService";
 import { circleService } from "../Service/CircleService";
 import { pointService } from "../Service/PointService";
+import { magnifierService } from "../Service/MagnifierService";
 
 export default class History {
   constructor(layer) {
@@ -96,6 +97,7 @@ export default class History {
       this.goPreForLines(item.lines);
       this.goPreForCircles(item.circles);
       this.goPreForTexts(item.texts);
+      this.goPreForMagnifiers(item.magnifiers);
       this.goPreForSVGs(item.svgs);
       historyService.undoHistoryRecord();
       change.saveCurrentInfo();
@@ -184,6 +186,28 @@ export default class History {
     }
   }
 
+  goPreForMagnifiers(itemForMagnifiers) {
+    for (let i = 0; i < itemForMagnifiers.length; ++i) {
+      const item = itemForMagnifiers[i];
+      if (item.handle == HistoryEvents.AddMagnifier) {
+        dataService.deleteMagnifier(item.magnifier.id);
+      } else if (item.handle == HistoryEvents.DeleteMagnifier) {
+        let newMagnifier = magnifierService.create(
+          item.magnifier.position,
+          item.magnifier.id
+        );
+        historyUtil.assignMagnifierFromMagnifier(newMagnifier, item.magnifier);
+      } else if (item.handle == HistoryEvents.ModifyMagnifier) {
+        const preMagnifier = item.preMagnifier;
+        let currentMagnifier = dataService.getMagnifier(item.curMagnifier.id);
+        historyUtil.assignMagnifierFromMagnifier(
+          currentMagnifier,
+          preMagnifier
+        );
+      }
+    }
+  }
+
   goPreForSVGs(itemForSVGs) {
     for (let i = 0; i < itemForSVGs.length; ++i) {
       const item = itemForSVGs[i];
@@ -279,6 +303,28 @@ export default class History {
     }
   }
 
+  goNextForMagnifiers(itemForMagnifiers) {
+    for (let i = 0; i < itemForMagnifiers.length; ++i) {
+      const item = itemForMagnifiers[i];
+      if (item.handle == HistoryEvents.AddMagnifier) {
+        let vMagnifier = magnifierService.create(
+          item.magnifier.position,
+          item.magnifier.id
+        );
+        historyUtil.assignMagnifierFromMagnifier(vMagnifier, item.magnifier);
+      } else if (item.handle == HistoryEvents.DeleteMagnifier) {
+        dataService.deleteMagnifier(item.magnifier.id);
+      } else if (item.handle == HistoryEvents.ModifyMagnifier) {
+        const currentMagnifier = item.curMagnifier;
+        let preMagnifier = dataService.getMagnifier(item.curMagnifier.id);
+        historyUtil.assignMagnifierFromMagnifier(
+          preMagnifier,
+          currentMagnifier
+        );
+      }
+    }
+  }
+
   goNextForSVGs(itemForSVGs) {
     for (let i = 0; i < itemForSVGs.length; ++i) {
       const item = itemForSVGs[i];
@@ -306,6 +352,7 @@ export default class History {
       this.goNextForLines(item.lines);
       this.goNextForCircles(item.circles);
       this.goNextForTexts(item.texts);
+      this.goNextForMagnifiers(item.magnifiers);
       this.goNextForSVGs(item.svgs);
       change.saveCurrentInfo();
       this.setState();

src/graphic/History/HistoryUtil.js

@@ -60,6 +60,17 @@ export default class HistoryUtil {
     }
   }
 
+  isDifferentForMagnifiers(text1, text2) {
+    if (
+      mathUtil.equalPoint(text1.center, text2.center) &&
+      text1.value == text2.value
+    ) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
   isDifferentForSVGs(svg1, svg2) {
     if (
       mathUtil.equalPoint(svg1.center, svg2.center) &&

src/graphic/Load.js

@@ -21,7 +21,9 @@ export default class Load {
       if (data3d.backImage) {
         let bgImg = imageService.create(data3d.backImage);
         bgImg.setCenter(coordinate.center);
-        await bgImg.setImageData();
+        try {
+          await bgImg.setImageData();
+        } catch (e) {}
       }
       if (data3d.baseLines) {
         for (let i = 0; i < data3d.baseLines.length; ++i) {

src/graphic/enum/HistoryEvents.js

@@ -20,9 +20,13 @@ const HistoryEvents = {
   ModifyLine: "modifyLine",
 
   AddCircle: "addCircle",
-  DeleteCirclee: "deleteCircle",
+  DeleteCircle: "deleteCircle",
   ModifyCircle: "modifyCircle",
 
+  AddMagnifier: "addMagnifier",
+  DeleteMagnifier: "deleteMagnifier",
+  ModifyMagnifier: "modifyMagnifier",
+
   AddSVG: "addSVG",
   DeleteSVG: "deleteSVG",
   ModifySVG: "modifySVG",