@aibee/crc-bmap 0.8.41 → 0.8.42

package/lib/src/loader/CrLoader/index.js

@@ -171,6 +171,7 @@ export class CrLoader {
         var _this = this;
         return _async_to_generator(function*() {
             const floor = new Floor(_this.bmap.context);
+            floor.userData.graphicMap = new Map();
             floor.name = query.floor;
             try {
                 yield Promise.all([

package/lib/src/operations/selection/selection.d.ts

@@ -18,6 +18,7 @@ export declare class Selection extends EventDispatcher<SelectionEventMap> {
         x: number;
         y: number;
     } | null;
+    downTime: number;
     isMultipleSelect: boolean;
     constructor(context: Context);
     get list(): Set<Graphic>;

package/lib/src/operations/selection/selection.js

@@ -61,11 +61,15 @@ export class Selection extends EventDispatcher {
         this.unRegistryEvent();
     }
     constructor(context){
-        super(), this.context = context, this._list = new Set(), this.downPoint = null, this.isMultipleSelect = false, this.onPointerDown = (e)=>{
+        super(), this.context = context, this._list = new Set(), this.downPoint = null, this.downTime = 0, this.isMultipleSelect = false, this.onPointerDown = (e)=>{
+            if (Date.now() - this.downTime < 200) {
+                return;
+            }
             this.downPoint = {
                 x: e.offsetX,
                 y: e.offsetY
             };
+            this.downTime = Date.now();
         }, this.onPointerUp = (e)=>{
             if (!this.downPoint) {
                 return;

package/lib/src/plugins/car-inertial-position/car-inertial-position.d.ts

@@ -1,5 +1,6 @@
 import { EventDispatcher } from "three";
 import { Compass } from "./compass";
+import { Timer } from "../../utils";
 export interface CarPosition {
     position: [number, number];
     time: number;
@@ -23,10 +24,14 @@ export declare class CarInertialPosition extends EventDispatcher<CarInertialPosi
     history: CarPosition[];
     compass: Compass;
     compassAngle: number;
+    timer: Timer;
+    positionTimer: number | null;
+    autoCleanTimer: number | null;
     constructor();
     startCompass(): void;
     setPosition(position: CarPosition['position'], time: number): void;
     setBeaconPosition(position: CarPosition['position'], time: number): void;
+    startPositionTimer(): void;
     getPosition(): CarPosInfo;
     dispose(): void;
 }

package/lib/src/plugins/car-inertial-position/car-inertial-position.js

@@ -2,6 +2,7 @@
 import { EventDispatcher } from "three";
 import { Compass } from "./compass";
 import { calculateLineDirection, predictFuturePosition, predictFutureSpeed, transformSpeed } from "./utils";
+import { getLength, Timer } from "../../utils";
 export class CarInertialPosition extends EventDispatcher {
     startCompass() {
         this.compass.start();
@@ -12,15 +13,23 @@ export class CarInertialPosition extends EventDispatcher {
             time,
             type: "vision"
         });
-        // 保留最近的6条数据
-        while(this.history.length > 6){
-            this.history.shift();
+        const MAX_DISTANCE = 20; // 保留最近20米的点
+        for(let i = 0; i < this.history.length; i++){
+            const item = this.history[i];
+            const distance = getLength(item.position, position);
+            if (distance > MAX_DISTANCE) {
+                this.history.shift();
+                i--;
+            } else {
+                break;
+            }
         }
         const posInfo = this.getPosition();
         this.dispatchEvent({
             type: "change-pos",
             value: posInfo
         });
+        this.startPositionTimer();
     }
     setBeaconPosition(position, time) {
         this.history.push({
@@ -33,6 +42,26 @@ export class CarInertialPosition extends EventDispatcher {
             type: "change-pos",
             value: posInfo
         });
+        this.startPositionTimer();
+    }
+    startPositionTimer() {
+        if (this.positionTimer) {
+            this.timer.clearInterval(this.positionTimer);
+        }
+        if (this.autoCleanTimer) {
+            this.timer.clearTimeout(this.autoCleanTimer);
+        }
+        this.positionTimer = this.timer.setInterval(()=>{
+            const posInfo = this.getPosition();
+            this.dispatchEvent({
+                type: "change-pos",
+                value: posInfo
+            });
+        }, 20);
+        this.autoCleanTimer = this.timer.setTimeout(()=>{
+            this.positionTimer && this.timer.clearInterval(this.positionTimer);
+            this.positionTimer = null;
+        }, 1000);
     }
     getPosition() {
         if (this.history.length === 0) {
@@ -55,11 +84,17 @@ export class CarInertialPosition extends EventDispatcher {
                 speed: 0
             };
         }
+        // 计算角度只用视觉的结果
         const visionHistory = this.history.filter((item)=>item.type === "vision");
         // 推导到当前时间距离最后一个定位点的时间
         const angle = calculateLineDirection(visionHistory.map((history)=>history.position));
         if (angle !== null) {
-            this.compass.setAbsoluteCompass(angle, lastHistory.time);
+            this.compassAngle = angle;
+            this.dispatchEvent({
+                type: "change-compass",
+                value: angle
+            });
+        // this.compass.setAbsoluteCompass(angle, lastHistory.time);
         }
         const lastTime = lastHistory.time;
         const deltaTime = Date.now() - lastTime;
@@ -76,15 +111,13 @@ export class CarInertialPosition extends EventDispatcher {
     }
     dispose() {
         this.compass.stop();
+        this.timer.dispose();
     }
     constructor(){
-        super(), this.history = [], this.compass = new Compass(), this.compassAngle = 0;
-        this.compass.addEventListener("compass", ({ value })=>{
-            this.compassAngle = value;
-            this.dispatchEvent({
-                type: "change-compass",
-                value
-            });
-        });
+        super(), this.history = [], this.compass = new Compass(), this.compassAngle = 0, this.timer = new Timer(), this.positionTimer = null, this.autoCleanTimer = null;
+    // this.compass.addEventListener("compass", ({ value }) => { 
+    //   this.compassAngle = value;
+    //   this.dispatchEvent({ type: "change-compass", value })
+    // })
     }
 }

package/lib/src/plugins/car-inertial-position/utils.d.ts

@@ -1,6 +1,6 @@
 import { CarPosition } from "./car-inertial-position";
 /**
- * 计算一组点位的斜率和方向
+ * 计算一组点位的斜率和方向 拟合成一条直线 然后选择一个起点终点
  * @param points
  * @returns
  */

package/lib/src/plugins/car-inertial-position/utils.js

@@ -1,36 +1,79 @@
-import { Vector2 } from "three";
+import { BufferGeometry, Line, LineBasicMaterial, Vector2, Vector3 } from "three";
+// 计算最小二乘法的斜率 (m) 和截距 (b)
+function linearFit(points) {
+    const n = points.length;
+    let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+    // 计算 Σx, Σy, Σxy, Σx²
+    points.forEach((p)=>{
+        sumX += p[0];
+        sumY += p[1];
+        sumXY += p[0] * p[1];
+        sumX2 += p[0] * p[0];
+    });
+    // 计算斜率 m 和 截距 b
+    const m = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+    const b = (sumY - m * sumX) / n;
+    return {
+        m,
+        b
+    };
+}
+// 计算拟合直线的起点和终点
+function getLineEndpoints(m, b, points) {
+    const startX = points[0][0];
+    const endX = points.slice(-1)[0][0];
+    // 根据x计算y值
+    const startY = m * startX + b;
+    const endY = m * endX + b;
+    return {
+        start: [
+            startX,
+            startY
+        ],
+        end: [
+            endX,
+            endY
+        ]
+    };
+}
 /**
- * 计算一组点位的斜率和方向
+ * 计算一组点位的斜率和方向 拟合成一条直线 然后选择一个起点终点
  * @param points
  * @returns
  */ export function calculateLineDirection(points) {
-    const n = points.length;
-    if (n < 2) {
+    if (points.length < 2) {
         return null;
     }
-    const angles = [];
-    for(let i = 1; i < points.length; i++){
-        const point1 = new Vector2(points[i][0], points[i][1]);
-        const point0 = new Vector2(points[i - 1][0], points[i - 1][1]);
-        if (point1.distanceTo(point0) === 0) {
-            continue;
-        }
-        const radians = new Vector2().subVectors(point1, point0).angle() // 于X轴的正方向的夹角 这个是顺时针的角度
-        ;
-        const angle = 360 - (radians / Math.PI * 180 - 90 + 360) % 360;
-        angles.push(angle);
-    }
-    const filteredAngles = removeOutliers(angles);
-    if (!filteredAngles.length) {
+    // 过滤掉相同的点
+    const filteredPoints = points.filter((item, index)=>{
+        const ps = [
+            ...points
+        ];
+        ps.splice(index, 1);
+        return ps.every((point)=>point[0] !== item[0] && point[1] !== item[1]);
+    });
+    if (filteredPoints.length < 2) {
         return null;
     }
-    let weight = 0;
-    // 最近的方向权重更大
-    const averageAngle = filteredAngles.reduce((sum, angle, i)=>{
-        weight += i + 1;
-        return sum + angle * (i + 1);
-    }, 0) / weight;
-    return averageAngle;
+    const { m, b } = linearFit(filteredPoints);
+    const { start, end } = getLineEndpoints(m, b, filteredPoints);
+    const radians = new Vector2().subVectors(new Vector2(end[0], end[1]), new Vector2(start[0], start[1])).angle() // 于X轴的正方向的夹角 逆时针方向
+    ;
+    // 这个是顺时针的角度 于Y轴正方向的夹角
+    const angle = 360 - (radians / Math.PI * 180 - 90 + 360) % 360;
+    const geometry = new BufferGeometry();
+    const center = window.map.buildingCenter;
+    if (center) {
+        geometry.setFromPoints([
+            new Vector3(start[0] - center[0], start[1] - center[1], 10),
+            new Vector3(end[0] - center[0], end[1] - center[1], 10)
+        ]);
+        const line = new Line(geometry, new LineBasicMaterial({
+            color: 0x00ffff
+        }));
+        window.map.context.scene.add(line);
+    }
+    return angle;
 }
 /**
  * 计算速度，单位是m/ms km/s
@@ -63,9 +106,7 @@ import { Vector2 } from "three";
  * @param timeIntervalMs
  * @returns
  */ export function predictFutureSpeed(positions, timeIntervalMs) {
-    console.log("timeIntervalMs", timeIntervalMs);
     const speeds = calculateInstantaneousSpeed(positions);
-    console.log("speeds", speeds);
     const n = speeds.length;
     if (n === 0) {
         return 0; // 如果没有速度数据，返回0
@@ -77,13 +118,11 @@ import { Vector2 } from "three";
     if (n > 1) {
         const speedDifferences = speeds.slice(1).map((speed, index)=>speed - speeds[index]);
         const time = positions.slice(1).reduce((sum, cur, index)=>sum + (cur.time - positions[index].time), 0);
-        console.log("time", time);
         if (!time) {
             return 0;
         }
         acceleration = speedDifferences.reduce((sum, value)=>sum + value, 0) / time;
     }
-    console.log("acceleration", acceleration);
     // 预测未来速度 m/ms
     const futureSpeed = Math.max(currentSpeed + acceleration * timeIntervalMs, 0);
     return futureSpeed;
@@ -105,18 +144,14 @@ import { Vector2 } from "three";
  * @returns
  */ export function predictFuturePosition(lastPosition, speed, angle, time) {
     // 将角度转换为弧度
-    const angleInRadians = angle * (Math.PI / 180);
+    const angleInRadians = (angle + 90) % 360 * (Math.PI / 180);
     const distance = speed * time;
-    console.log("angle speed", speed, distance);
     const vec = new Vector2(lastPosition[0], lastPosition[1]);
     // 计算角度在x和y方向的分量
     const vX = Math.cos(angleInRadians);
     const vY = Math.sin(angleInRadians);
     const dir = new Vector2(vX, vY);
     vec.add(dir.normalize().multiplyScalar(distance));
-    // // 计算未来位置
-    // const futureX = lastPosition[0] + vX * time;
-    // const futureY = lastPosition[1] + vY * time;
     return [
         vec.x,
         vec.y

package/lib/src/plugins/nav-path/nav-path.d.ts

@@ -16,7 +16,7 @@ export declare class NavPath extends EventDispatcher<EventMap> {
     initRoadStatus: boolean;
     constructor();
     setRoadData(roadData: RoadData2[], facilities: Facility[]): Promise<void>;
-    getPath(start: Start2, end: End2, type?: RouteType2, permission?: number): Promise<PathData>;
+    getPath(start: Start2, end: End2, type?: RouteType2, permission?: number, travelDirection?: number): Promise<PathData>;
     getDirectionPath(points: [number, number][]): Promise<DirectionPathData[]>;
     dispose(): Promise<void>;
 }

package/lib/src/plugins/nav-path/nav-path.js

@@ -23,7 +23,7 @@ export class NavPath extends EventDispatcher {
             });
         })();
     }
-    getPath(start, end, type = "", permission) {
+    getPath(start, end, type = "", permission, travelDirection) {
         var _this = this;
         return _async_to_generator(function*() {
             return new Promise((resolve, reject)=>{
@@ -33,7 +33,8 @@ export class NavPath extends EventDispatcher {
                         start,
                         end,
                         type,
-                        permission
+                        permission,
+                        travelDirection
                     }).then((data)=>{
                         if (!data) {
                             reject("no-path");

package/lib/src/plugins/nav-path/path.worker.js

@@ -6,8 +6,8 @@ toWebWorker({
     onSetRoadInfo ({ roadData, facilities }) {
         roadNetwork.initRoute(roadData, facilities);
     },
-    onGetPath ({ start, end, type, permission }) {
-        return roadNetwork.getPath(start, end, type, permission);
+    onGetPath ({ start, end, type, permission, travelDirection }) {
+        return roadNetwork.getPath(start, end, type, permission, travelDirection);
     },
     onGetDirectionPath (points) {
         return getDirectPath(points);

package/lib/src/plugins/navigation/position-navigation.js

@@ -258,8 +258,7 @@ export class PositionNavigation extends EventDispatcher {
         let dir = PathDirection.FRONT;
         let crossName = (curRoutePath == null ? void 0 : (_curRoutePath_pointInfos_index = curRoutePath.pointInfos[index]) == null ? void 0 : _curRoutePath_pointInfos_index.crossName) || "";
         let distance = 0;
-        let t = Date.now(); // 循环控制在5ms内，防止死循环
-        while(dir === PathDirection.FRONT && distance < this.options.directionEmitThreshold && Date.now() - t < 5){
+        while(dir === PathDirection.FRONT && index <= curRoutePathPoints.length){
             const p1 = curRoutePathPoints[index];
             const p2 = curRoutePathPoints[index + 1];
             const p3 = curRoutePathPoints[index + 2];
@@ -271,9 +270,12 @@ export class PositionNavigation extends EventDispatcher {
                     const l = getLength(p1, position);
                     if (l < 5) {
                         dir = PathDirection.START;
+                    } else {
+                        dir = PathDirection.FRONT;
+                        index += 1;
                     }
                 } else {
-                    distance += getLength(position, p2);
+                    distance += getLength(p1, p2);
                     if (!p3) {
                         dir = PathDirection.END;
                     } else {
@@ -322,10 +324,10 @@ export class PositionNavigation extends EventDispatcher {
             return null;
         }
         let { dir, distance: nextDirDistance, crossName } = nextDirInfo;
-        if (dir === PathDirection.END && nextDirDistance > 15) {
-            // 请直行
-            dir = PathDirection.FRONT;
-        }
+        // if (dir === PathDirection.END && nextDirDistance > 15) {  
+        //   // 请直行
+        //   dir = PathDirection.FRONT;
+        // }
         // 剩余 5 米不管是不是拐弯都提示到达目的地
         if (curRouteRemainDistance <= 10) {
             dir = PathDirection.END;

package/lib/src/utils/road2.d.ts

@@ -275,9 +275,10 @@ export declare class RoadNetwork2 {
      * @param end 终点
      * @param type '' 最短路径 escalator 扶梯优先 straightLadder 直梯优先
      * @param permission 0 无权限  1  通行卡
+     * @param travelDirection 行驶方向 从Y轴正方向的顺时针角度
      * @returns
      */
-    getPath(start: Start2, end: End2, type?: RouteType2, permission?: number): "start-error" | "end-error" | "no-start" | "no-end" | PathData2 | null | undefined;
+    getPath(start: Start2, end: End2, type?: RouteType2, permission?: number, travelDirection?: number): "start-error" | "end-error" | "no-start" | "no-end" | PathData2 | null | undefined;
     private getRoutePath;
     private getBasePath;
     private getEscalatorPath;

package/lib/src/utils/road2.js

@@ -7,7 +7,8 @@
 import { _ as _extends } from "@swc/helpers/_/_extends";
 import Graph from "node-dijkstra";
 import { getLength, getPathLength } from "./coordinate";
-import { cloneDeep } from "lodash";
+import { cloneDeep, isNil } from "lodash";
+import { Vector2 } from "three";
 const SPLIT_FLG = "___";
 export class RoadNetwork2 {
     isFacilityByType(type) {
@@ -640,8 +641,9 @@ export class RoadNetwork2 {
    * @param end 终点
    * @param type '' 最短路径 escalator 扶梯优先 straightLadder 直梯优先
    * @param permission 0 无权限  1  通行卡
+   * @param travelDirection 行驶方向 从Y轴正方向的顺时针角度
    * @returns
-   */ getPath(start, end, type = "", permission) {
+   */ getPath(start, end, type = "", permission, travelDirection) {
         if (!this.checkStart(start)) {
             return "start-error";
         }
@@ -656,7 +658,7 @@ export class RoadNetwork2 {
         if (!transformedEnd) {
             return "no-end";
         }
-        let getPathFn = this.getBasePath.bind(this);
+        let getPathFn;
         switch(type){
             case "escalator":
                 getPathFn = this.getEscalatorPath.bind(this);
@@ -673,7 +675,7 @@ export class RoadNetwork2 {
         }
         if (transformedEnd.id) {
             // 有明确的目的地了  直接规划路线
-            return getPathFn(transformedStart, transformedEnd, permission);
+            return getPathFn(transformedStart, transformedEnd, permission, travelDirection);
         } else if (transformedEnd.facility) {
             // 寻找最近的设施 如果传入了目的地楼层，只找对应楼层的设施
             const facilityIds = this.facilities.filter((item)=>+item.type_id === +end.facility).map((item)=>item.id);
@@ -690,7 +692,7 @@ export class RoadNetwork2 {
             const paths = facilityPoints.map((item)=>getPathFn(transformedStart, {
                     floor: item.floor,
                     id: item.id
-                }, permission)).filter((item)=>!!item);
+                }, permission, travelDirection)).filter((item)=>!!item);
             // 寻找最近的路线
             return paths.reduce((obj, cur)=>{
                 const distance = cur[0].consume;
@@ -869,10 +871,82 @@ export class RoadNetwork2 {
         const tempRoute = new Graph(tempMap);
         return this.getRoutePath(start, end, tempRoute);
     }
-    // 规划正寻路线
-    getForwardPath(start, end, permission) {
+    // 规划正寻路线 travelDirection 行驶方向 从Y轴正方向的顺时针角度
+    getForwardPath(start, end, permission, travelDirection) {
+        const removedLine = new Map();
+        const removeBackLine = (backPoints)=>{
+            const map = this.forwardRoute.graph.get(startPointId);
+            backPoints.forEach((key)=>{
+                const distance = map.get(key);
+                if (!isNil(distance)) {
+                    removedLine.set(key, distance);
+                    map.delete(key);
+                }
+            });
+        };
+        const restoreBackLine = ()=>{
+            const map = this.forwardRoute.graph.get(startPointId);
+            removedLine.forEach((distance, key)=>{
+                map.set(key, distance);
+            });
+        };
+        const startPointId = `${start.floor}${SPLIT_FLG}${start.id}`;
+        if (!isNil(travelDirection)) {
+            // 如果有方向，要把起点位置的非行进方向的其他点删掉，规划完路线之后在加回去
+            const nextPoints = this.forwardLineMap.get(startPointId);
+            // 只有在这个点的连线多于一个点的时候才有其他方向的点
+            const startPoint = this.pointMap.get(startPointId);
+            if (startPoint && (nextPoints == null ? void 0 : nextPoints.size) && nextPoints.size > 1) {
+                const startVector2 = new Vector2(startPoint.cds[0], startPoint.cds[1]);
+                // 计算一下每个点的角度，如果有角度小于60度的就保留，删除其他的点
+                // 如果没有就保留角度最小的一个点，其他的点删除
+                const pointAngle = new Map();
+                nextPoints.forEach((value, key)=>{
+                    const nextPoint = this.pointMap.get(key);
+                    if (nextPoint) {
+                        // 360 - ((radians / Math.PI) * 180 - 90 + 360) % 360;
+                        const nextVector2 = new Vector2(nextPoint.cds[0], nextPoint.cds[1]);
+                        // 和X轴的夹角的逆时针方向
+                        const radiansX = new Vector2().subVectors(nextVector2, startVector2).angle();
+                        // 和Y轴的夹角 顺时针方向
+                        const angleY = 360 - (radiansX / Math.PI * 180 - 90 + 360) % 360;
+                        pointAngle.set(key, angleY);
+                    }
+                });
+                const lessThan60Keys = Array.from(pointAngle).filter(([key, value])=>Math.abs(value - travelDirection) <= 60).map(([key])=>key);
+                if (lessThan60Keys.length) {
+                    // 删除其他大于60度的点
+                    lessThan60Keys.forEach((key)=>pointAngle.delete(key));
+                    removeBackLine([
+                        ...pointAngle.keys()
+                    ]);
+                } else {
+                    // 找到差值最小的点
+                    const min = Array.from(pointAngle).reduce((res, cur)=>{
+                        const diff = Math.abs(cur[1] - travelDirection);
+                        if (diff < res.diff) {
+                            return {
+                                diff,
+                                key: cur[0]
+                            };
+                        }
+                        return res;
+                    }, {
+                        diff: Infinity,
+                        key: ''
+                    });
+                    // 删除其他的点
+                    pointAngle.delete(min.key);
+                    removeBackLine([
+                        ...pointAngle.keys()
+                    ]);
+                }
+            }
+        }
         if (!permission) {
-            return this.getRoutePath(start, end, this.forwardRoute);
+            const path = this.getRoutePath(start, end, this.forwardRoute);
+            restoreBackLine();
+            return path;
         }
         // 创建一个临时图
         const tempMap = cloneDeep(this.forwardRoute.graph);
@@ -887,7 +961,9 @@ export class RoadNetwork2 {
             ]
         ]));
         const tempRoute = new Graph(tempMap);
-        return this.getRoutePath(start, end, tempRoute);
+        const path = this.getRoutePath(start, end, tempRoute);
+        restoreBackLine();
+        return path;
     }
     clear() {
         this.roadInfo = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aibee/crc-bmap",
-  "version": "0.8.41",
+  "version": "0.8.42",
   "description": "",
   "main": "lib/bmap.min.js",
   "module": "lib/bmap.esm.js",