@aibee/crc-bmap 0.0.106 → 0.0.107

package/lib/bmap.esm.js

@@ -4047,9 +4047,7 @@ var BMap = class extends EventDispatcher7 {
   }
   rotateMap(radius = 0.1) {
     const azimuthal = this.context.control.getAzimuthalAngle();
-    this.context.control.maxAzimuthAngle = azimuthal + radius;
-    this.context.control.minAzimuthAngle = azimuthal + radius;
-    this.context.control.update();
+    this.context.setAzimuthalAngle(azimuthal + radius, 500);
   }
   /**
    * 测量距离
@@ -5142,48 +5140,107 @@ function simplifyPath(path, ignoreFirst = false, smoothingOptimization = true, s
     const halfMidTailDist = tail.distanceTo(mid) / 2;
     const curveHead = mid.clone();
     const curveTail = mid.clone();
-    curveHead.add(head.clone().sub(mid).normalize().multiplyScalar(
-      halfHeadMidDist > smoothingDistance ? smoothingDistance / 2 : halfHeadMidDist
-    ));
-    curveTail.add(tail.clone().sub(mid).normalize().multiplyScalar(
-      halfMidTailDist > smoothingDistance ? smoothingDistance / 2 : halfMidTailDist
-    ));
+    curveHead.add(
+      head.clone().sub(mid).normalize().multiplyScalar(
+        halfHeadMidDist > smoothingDistance ? smoothingDistance / 2 : halfHeadMidDist
+      )
+    );
+    curveTail.add(
+      tail.clone().sub(mid).normalize().multiplyScalar(
+        halfMidTailDist > smoothingDistance ? smoothingDistance / 2 : halfMidTailDist
+      )
+    );
     const curveToSmooth = [
       [curveHead.x, curveHead.y],
       [mid.x, mid.y],
       [curveTail.x, curveTail.y]
     ];
-    simplifiedPath.push(
-      ...smoothPath(
-        curveToSmooth,
-        smoothingDistance / 25
-      )
-    );
+    simplifiedPath.push(...smoothPath(curveToSmooth, smoothingDistance / 25));
   }
   simplifiedPath.push(joints[joints.length - 1]);
+  return removeWeightPath(simplifiedPath);
+}
+function removeWeightPath(points) {
+  if (points.length <= 1) {
+    return points;
+  }
   const checkedPath = [];
   let lastCheckedPoint;
-  simplifiedPath.forEach(([x, y]) => {
+  points.forEach(([x, y]) => {
     if (!lastCheckedPoint) {
       lastCheckedPoint = [x, y];
       checkedPath.push([x, y]);
-    } else if (!(x === lastCheckedPoint[0] && y === lastCheckedPoint[0])) {
+    } else if (!(x === lastCheckedPoint[0] && y === lastCheckedPoint[1])) {
       lastCheckedPoint = [x, y];
       checkedPath.push([x, y]);
     }
   });
   return checkedPath;
 }
+function distancePointToSegment(point3, start, end) {
+  const segmentLength = Math.sqrt(
+    (end[0] - start[0]) ** 2 + (end[1] - start[1]) ** 2
+  );
+  if (segmentLength === 0) {
+    return {
+      distance: Math.sqrt((point3[0] - start[0]) ** 2 + (point3[1] - start[1]) ** 2),
+      closestPoint: start.slice(0)
+    };
+  }
+  const t = Math.max(
+    0,
+    Math.min(
+      1,
+      ((point3[0] - start[0]) * (end[0] - start[0]) + (point3[1] - start[1]) * (end[1] - start[1])) / segmentLength ** 2
+    )
+  );
+  const closestPoint = [
+    start[0] + t * (end[0] - start[0]),
+    start[1] + t * (end[1] - start[1])
+  ];
+  const distance = Math.sqrt(
+    (point3[0] - closestPoint[0]) ** 2 + (point3[1] - closestPoint[1]) ** 2
+  );
+  return { distance, closestPoint };
+}
+function moveOnRoute(startPoint, endPoint, distance) {
+  const [startX, startY] = startPoint;
+  const [endX, endY] = endPoint;
+  const routeLength = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
+  const ratio = distance / routeLength;
+  const newX = startX + (endX - startX) * ratio;
+  const newY = startY + (endY - startY) * ratio;
+  return [newX, newY];
+}
 
 // src/plugins/navigation/navigation.ts
+import { Group as TweenGroup2, Tween as Tween2 } from "@tweenjs/tween.js";
+var defaultConfig3 = {
+  path: {},
+  speed: 10,
+  cheapMaximumDistance: 20,
+  needStartPoi: false,
+  startPoi: {}
+};
 var Navigation = class extends Plugin {
   path = null;
   worker = Worker2();
   fetchRoadStatus = false;
   uniqueKey = new UniqueKey();
   paths = [];
-  constructor(bmap, project) {
+  options;
+  pathTween = new TweenGroup2();
+  startPoi = null;
+  // 处理路线动画
+  animationPathOptions = {
+    cPathIndex: 0
+    // 在平滑路线中的下标（平滑但是未做插值的数据，是做路线渲染的）
+  };
+  cPath = [];
+  // 当前楼层的平滑后的路线
+  constructor(bmap, project, options = {}) {
     super(bmap);
+    this.options = Object.assign({}, defaultConfig3, options);
     const {
       apiDomain,
       apiPath: { roadNetwork },
@@ -5201,18 +5258,35 @@ var Navigation = class extends Plugin {
         this.dispatchEvent({ type: "fetch-road-status", status: true });
       }
     });
+    this.registryEvent();
+  }
+  registryEvent() {
+    this.bmap.context.addEventListener("update", this.onUpdate);
     this.bmap.addEventListener(
       "switch_floor_after" /* SWITCH_FLOOR_AFTER */,
       this.onSwitchFloor
     );
   }
+  unRegistryEvent() {
+    this.bmap.context.removeEventListener("update", this.onUpdate);
+    this.bmap.removeEventListener(
+      "switch_floor_after" /* SWITCH_FLOOR_AFTER */,
+      this.onSwitchFloor
+    );
+  }
+  onUpdate = () => {
+    this.pathTween.update();
+  };
   triggerWorker(type, data) {
     this.worker.postMessage({ type, data });
   }
   clearPath() {
     if (this.path) {
       this.bmap.context.scene.remove(this.path);
+      this.path.dispose();
       this.path = null;
+      this.pathTween.getAll().forEach((item) => item.stop());
+      this.pathTween.removeAll();
     }
   }
   onSwitchFloor = ({ data: { curFloor } }) => {
@@ -5304,30 +5378,134 @@ var Navigation = class extends Plugin {
     });
   }
   renderPath(points) {
-    const cPath = this.catmullRomCurve3(points).map(([x, y]) => [
-      x,
-      y
-    ]);
+    const cPath = this.catmullRomCurve3(points);
+    this.cPath = cPath;
+    this.animationPathOptions = {
+      cPathIndex: 0
+    };
     if (this.path) {
       this.path.updatePoints(cPath);
     } else {
-      this.path = new Path2(this, {});
+      this.path = new Path2(this, this.options.path);
       this.path.create(cPath);
       this.path.position.z = this.bmap.context.currentFloor.groundMaxHeight + 0.1;
       this.bmap.context.scene.add(this.path);
     }
+    if (this.startPoi) {
+      this.startPoi.dispose();
+      this.startPoi = null;
+    }
+    if (this.options.needStartPoi) {
+      this.startPoi = this.bmap.context.currentFloor?.addPoi({
+        ...this.options.startPoi,
+        position: { x: cPath[0][0], y: cPath[0][1], z: 1e-4 },
+        collision_enable: false
+      }) || null;
+    }
   }
   catmullRomCurve3(points) {
-    return simplifyPath(points, true, true, 10, 150, 3);
+    return simplifyPath(points, false, true, 0.1, 150, 2.5);
+  }
+  /**
+   * 按照指定速度移动到目标位置
+   * @param point 目标位置
+   * @param speed 移动速度
+   */
+  async animationTo(point3, speed = this.options.speed) {
+    if (point3.floor !== this.bmap.context.currentFloor?.name || !this.path) {
+      return;
+    }
+    const {
+      animationPathOptions: { cPathIndex }
+    } = this;
+    const currentPath = [
+      this.path.points[0],
+      ...this.cPath.slice(cPathIndex + 1)
+    ];
+    const translatedPos = this.translatePoints([point3.pos])[0];
+    const { distance, pos, index } = currentPath.reduce(
+      (res, cur, index2, arr) => {
+        if (index2 === arr.length - 1) {
+          return res;
+        }
+        const { distance: distance2, closestPoint } = distancePointToSegment(
+          translatedPos,
+          cur,
+          arr[index2 + 1]
+        );
+        if (distance2 < res.distance) {
+          res.distance = distance2;
+          res.pos = closestPoint;
+          res.index = index2;
+        }
+        return res;
+      },
+      {
+        distance: Number.MAX_SAFE_INTEGER,
+        pos: point3.pos,
+        index: 0
+      }
+    );
+    if (distance > this.options.cheapMaximumDistance) {
+      return;
+    }
+    if (this.path.points[0][0] === pos[0] && this.path.points[0][1] === pos[1]) {
+      return;
+    }
+    let moveDistance = 0;
+    let moveDistanceArray = [];
+    if (index === 0) {
+      moveDistance = getLength(currentPath[0], pos);
+      moveDistanceArray = [moveDistance];
+    } else {
+      moveDistanceArray = [getLength(currentPath[0], currentPath[1])];
+      for (let i = 1; i < index; i++) {
+        moveDistanceArray.push(getLength(currentPath[i], currentPath[i + 1]));
+      }
+      moveDistanceArray.push(getLength(currentPath[index], pos));
+      moveDistance = moveDistanceArray.reduce((sum, cur) => sum + cur, 0);
+    }
+    const speedSecond = this.kmPerHourToMetersPerSecond(speed);
+    const timeSecond = moveDistance / speedSecond;
+    this.pathTween.getAll().forEach((item) => item.stop());
+    this.pathTween.removeAll();
+    const start = { distance: 0 };
+    return new Promise((resolve) => {
+      const tween = new Tween2(start, this.pathTween).to({ distance: moveDistance }, timeSecond * 1e3).onUpdate(() => {
+        for (let i = 0; i < moveDistanceArray.length; i++) {
+          const sumDistance = moveDistanceArray.slice(0, i + 1).reduce((sum, cur) => sum + cur, 0);
+          if (sumDistance >= start.distance) {
+            const prevDistance = sumDistance - moveDistanceArray[i];
+            const needDistance = start.distance - prevDistance;
+            const startPoint = currentPath[i];
+            const nextPoint = currentPath[i + 1];
+            const pos2 = moveOnRoute(startPoint, nextPoint, needDistance);
+            this.path?.updatePoints([pos2, ...currentPath.slice(i + 1)]);
+            this.animationPathOptions.cPathIndex += i;
+            if (this.startPoi) {
+              this.startPoi.position.setX(pos2[0]).setY(pos2[1]);
+            }
+            this.dispatchEvent({ type: "path-animation" });
+            return;
+          }
+        }
+      }).onComplete(() => {
+        this.pathTween.remove(tween);
+        this.dispatchEvent({ type: "path-animation-end" });
+        resolve(true);
+      }).start();
+    });
+  }
+  kmPerHourToMetersPerSecond(speedInKmPerHour) {
+    const speedInMetersPerSecond = speedInKmPerHour * 1e3 / 3600;
+    return speedInMetersPerSecond;
   }
   dispose() {
     this.worker.terminate();
-    this.bmap.removeEventListener(
-      "switch_floor_after" /* SWITCH_FLOOR_AFTER */,
-      this.onSwitchFloor
-    );
+    this.unRegistryEvent();
     this.path?.dispose();
     this.uniqueKey.dispose();
+    this.startPoi?.dispose();
   }
 };