@aibee/crc-bmap 0.1.6 → 0.1.8

package/lib/src/elements/poi2.d.ts

@@ -30,6 +30,7 @@ export declare class Poi2 extends Object3D<PoiEventMap2> {
     spriteIcon?: Sprite;
     box: Box2;
     boxHelper?: HTMLDivElement;
+    private _initIconPromise;
     constructor(context: Context, options: PoiOptionsParam2);
     get durIconAndText(): 2 | 0;
     get offset(): 0 | 0.5;

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

@@ -1 +1 @@
-export * from './nav-path';
+export * from './cr-nav-path';

package/lib/src/plugins/index.d.ts

@@ -4,3 +4,4 @@ export * from './mul-floors';
 export * from './nav-path';
 export * from './cr-nav-path';
 export * from './select';
+export * from './pdr-position';

package/lib/src/plugins/navigation/navigation.d.ts

@@ -1,17 +1,11 @@
 import { BMap } from "../../bmap";
 import { Plugin } from "../base";
 import { Path, PathConfig } from "./path";
-import { PathData2, TweenUtil } from "../../utils";
+import { PathData2, TweenUtil, PathData } from "../../utils";
 import { Floor, Poi2, PoiOptions2 } from "../../elements";
-import { PathDirection } from "../../utils/path";
 import { Tween } from "@tweenjs/tween.js";
+import { NavigationProcessInfo, PositionNavigation, PositionNavigationConfig } from "./position-navigation";
 export type Point = [number, number];
-export interface NavigationProcessInfo {
-    distance: number;
-    dir: PathDirection;
-    nextDirDistance: number;
-    pos: [number, number];
-}
 interface EventMap {
     "fetch-road-status": {
         status: boolean;
@@ -23,16 +17,23 @@ interface EventMap {
     "render-path": {
         path: Path;
     };
-    "navigation-info": NavigationProcessInfo;
+    "navigation-info": {
+        info: NavigationProcessInfo;
+    };
+    "add-path": {
+        paths: PathData2 | PathData;
+    };
 }
 export interface NavigationConfig {
     path?: Partial<PathConfig>;
     cheapMaximumDistance: number;
     startPoi: Partial<PoiOptions2>;
+    positionNavigation: Partial<PositionNavigationConfig>;
     needStartPoi: boolean;
     offsetY: number;
     directionEmitThreshold: number;
     disablePathAnimation: boolean;
+    speed: number;
 }
 export declare class Navigation extends Plugin<EventMap> {
     path: Path | null;
@@ -52,10 +53,16 @@ export declare class Navigation extends Plugin<EventMap> {
         cPathIndex: number;
     };
     cPath: Point[];
+    positionNavigation: PositionNavigation;
+    pathMoving: boolean;
+    nextPoint: Point | null;
     constructor(bmap: BMap, project?: string | Partial<NavigationConfig>, options?: Partial<NavigationConfig>);
     get curFloorPathLength(): number;
     get curFloorPathPoints(): [number, number][];
     registryEvent(): void;
+    onNavigationInfo: ({ info }: {
+        info: NavigationProcessInfo;
+    }) => void;
     pauseAnimation(): void;
     continueAnimation(): void;
     unRegistryEvent(): void;
@@ -72,32 +79,16 @@ export declare class Navigation extends Plugin<EventMap> {
     translatePoints(points: Point[]): Point[];
     renderPath(points: Point[]): void;
     catmullRomCurve3(points: Point[]): [number, number][];
-    /**
-     * 按照指定速度移动到目标位置
-     * @param point 目标位置
-     * @param speed 移动速度 / 米/s
-     */
-    animationTo(point: {
-        floor: string;
-        pos: [number, number];
-    }, speed: number): Promise<unknown>;
     getPathDirection(): number | null;
     changeCameraToPathUp(duration?: number): Promise<unknown>;
     initNavigationCamera(): Promise<void>;
     translateCameraToStartPoi(duration?: number): Promise<unknown>;
     initCameraZoom(duration?: number): Promise<unknown>;
-    toPositionBySpeed(position: [number, number], speed: number): Promise<unknown>;
-    adsorb(floor: string, position: [number, number]): {
-        distance: number;
-        closestPoint: [number, number];
-        index: number;
-    } | null;
-    getRemainDistance(): number;
-    getNextDirDistance(): {
-        dir: PathDirection;
-        distance: number;
-    } | null;
-    private emitNavigationInfo;
+    toPosition(floor: string, pos: [number, number]): void;
+    startSimulation(): void;
+    setSimulationSpeed(speed: number): void;
+    toPositionBySpeed(position: [number, number], speed: number): Promise<void | null>;
+    moveDistance(distance: number, tween?: Tween<any>): Promise<void>;
     setStartPoiRotate(rotate: number): void;
     dispose(): void;
 }

package/lib/src/plugins/navigation/position-navigation.d.ts

@@ -0,0 +1,72 @@
+import { EventDispatcher } from "three";
+import { Navigation } from "./navigation";
+import { PathData, PathDirection, Timer, TweenUtil } from "../../utils";
+import { Tween } from "@tweenjs/tween.js";
+export interface PositionNavigationConfig {
+    offsetDistance: number;
+    offsetToResetTime: number;
+    directionEmitThreshold: number;
+    simulationSpeed: number;
+}
+export interface NavigationProcessInfo {
+    distance: number;
+    curRouteDistance: number;
+    nextDirDistance: number;
+    dir: PathDirection;
+    pos: [number, number];
+    routeIndex: number;
+    offset: boolean;
+    reset: boolean;
+}
+interface PositionNavigationEvent {
+    "navigation-info": {
+        info: NavigationProcessInfo;
+    };
+}
+export declare class PositionNavigation extends EventDispatcher<PositionNavigationEvent> {
+    navigation: Navigation;
+    offset: boolean;
+    reset: boolean;
+    position: [number, number];
+    routeIndex: number;
+    pointIndex: number;
+    paths: PathData;
+    options: PositionNavigationConfig;
+    timer: Timer;
+    resetTimer: number | null;
+    tweenUtil: TweenUtil;
+    simulationTween?: Tween<any>;
+    constructor(navigation: Navigation, options: Partial<PositionNavigationConfig>);
+    get curRoutePath(): PathData[0] | null;
+    get curRoutePathPoints(): [number, number][];
+    registryEvent(): void;
+    unRegistryEvent(): void;
+    onAddPaths: ({ paths }: {
+        paths: PathData;
+    }) => void;
+    onUpdate: () => void;
+    resetStatus(paths: PathData): void;
+    emitNavigationStatus(): void;
+    adsorb(floor: string, _position: [number, number]): {
+        distance: number;
+        closestPoint: [number, number];
+        routeIndex: number;
+        pointIndex: number;
+    } | null;
+    toPosition(floor: string, pos: [number, number]): void;
+    startSimulation(): void;
+    startCurRouteSimulation(): Promise<unknown>;
+    changeSimulationSpeed(speed: number): void;
+    getCurRouteRemainDistance(): number;
+    getRemainDistance(): {
+        total: number;
+        curRoute: number;
+    };
+    getNextDirDistance(): {
+        dir: PathDirection;
+        distance: number;
+    } | null;
+    private getNavigationInfo;
+    dispose(): void;
+}
+export {};

package/lib/src/plugins/pdr-position/enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum SENSOR_TYPE {
+    COMPASS = "compass",
+    DEVICE_MOTION = "deviceMotion",
+    ACCELERATION = "acceleration",
+    GPS = "gps"
+}

package/lib/src/plugins/pdr-position/imu-position.d.ts

@@ -0,0 +1,56 @@
+export declare class ImuPosition {
+    private fre;
+    private accH_fifo;
+    private accH_time_fifo;
+    private accH_fifo_len;
+    private step_count;
+    private state_count;
+    private last_valley_time;
+    private last_peak_time;
+    private last_step_time;
+    private min_step_time;
+    private max_step_time;
+    private min_peak;
+    private max_valley;
+    private peak_num;
+    private valley_num;
+    private fft_min_amp;
+    private fft_min_fre;
+    private fft_max_fre;
+    private last_fft_amp;
+    private abnor_start_time;
+    private abnor_fft_detected;
+    private abnor_time_threshod;
+    private abnor_peak_time;
+    private abnor_peak_accH;
+    private const_step_length;
+    private last_rot;
+    private delta_rot;
+    private last_yaw;
+    private delta_yaw;
+    private delta_rot_sum_fifo;
+    private delta_rot_sum_time_fifo;
+    private delta_yaw_accum;
+    private delta_yaw_accum_timestamp;
+    private delta_yaw_time_threshold;
+    private last_px;
+    private last_py;
+    private delta_px;
+    private delta_py;
+    constructor();
+    private reset;
+    set_init_pose(pose?: [number, number]): void;
+    set_init_yaw(yaw?: number): void;
+    getPos(timestamp: number, acc: number[], rot: number[]): [number, number];
+    get_delta_pose(): [number, number];
+    getStepLength(timestamp: number, acc: number[]): number;
+    private imuFreUpdate;
+    private recheckState;
+    private PVstepDetec;
+    private FFTstepDetec;
+    private mean;
+    private rfft;
+    private getFrequencies;
+    getDeltaYaw_fromRot(timestamp: number, rot: number[]): number;
+    private limit_yaw;
+}

package/lib/src/plugins/pdr-position/particle.d.ts

@@ -0,0 +1,74 @@
+interface Parameters {
+    NumParticle: number;
+    reSampNumParticle: number;
+    initial_xy_uncertainty: number;
+    initial_yaw_uncertainty: number;
+    step_noise_sigma: number;
+    yaw_noise_sigma: number;
+    compass_update_interval: number;
+    sigmaCompass: number;
+    delta_yaw: number;
+    sigmaBeacon: number;
+    unaccess_weight: number;
+}
+declare class ParticleFilter {
+    private NumParticle;
+    private reSampNumParticle;
+    private initial_xy_uncertainty;
+    private initial_yaw_uncertainty;
+    private step_noise_sigma;
+    private yaw_noise_sigma;
+    private compass_update_interval;
+    private sigmaCompass;
+    private delta_yaw;
+    private sigmaBeacon;
+    private unaccess_weight;
+    private particle_PosInitFlag;
+    private particle_yawInitFlag;
+    private xEst;
+    private particleX;
+    private particleWeight;
+    private last_compass_time;
+    constructor(parameters: Parameters);
+    /**
+     * motionModelRotYaw 更新粒子的航向角。
+     */
+    motionModelRotYaw(delta_yaw: number): void;
+    /**
+     * motionModelStepLength 更新粒子的位移并处理不可达区域。
+     * @param step_len
+     * @param check_accessible
+     * @returns
+     */
+    motionModelStepLength(step_len: number, check_accessible: (x: number, y: number) => boolean): void;
+    /**
+     * motionModelCompassYaw 根据罗盘的航向角更新粒子的权重。
+     * @param compass_yaw
+     * @param time
+     */
+    motionModelCompassYaw(compass_yaw: number, time: number): void;
+    resampling(): void;
+    update(observe_pos: {
+        x: number;
+        y: number;
+    }, sigma_noise: number): void;
+    updateCar(observe_pos: {
+        x: number;
+        y: number;
+    }, sigma_noise: number): void;
+    getPosInitFlag(): boolean;
+    getYawInitFlag(): boolean;
+    setPosInitFlag(flag: boolean): void;
+    setYawInitFlag(flag: boolean): void;
+    getResultX(): number;
+    getResultY(): number;
+    getResultYaw(): number;
+    getEstConfidence(): number;
+    getParticleNum(): number;
+    getParticleX(): number[][];
+    setLastCompassTime(time: number): void;
+    getLastCompassTime(): number;
+    initParticlesByPos(x: number, y: number, check_accessable: (x: number, y: number) => boolean): void;
+    initParticlesByCompass(compass: number): void;
+}
+export { ParticleFilter };

package/lib/src/plugins/pdr-position/pdr.d.ts

@@ -0,0 +1,48 @@
+import { SensorData } from "./sensor";
+export declare class PositioningSystem {
+    private particleFilter;
+    private pdr;
+    private sigmaBeacon;
+    private gps_horizontalAccuracy;
+    private using_gps;
+    private last_beacon_time;
+    private last_pos_time?;
+    private position_count;
+    private gps_max_horizontalAccuracy;
+    private MaxEstimateErr;
+    private outTrustRegionNum;
+    private TrustNum;
+    private cacheSensorData;
+    constructor();
+    /**
+     * 基于 PDR、iBeacon、罗盘和语义地图的粒子滤波器。
+     *
+     * 输入：
+     * sensorsData -- 来自手机的传感器读数，
+     *                包含加速度计、陀螺仪、罗盘、iBeacon。
+     * grid_map -- 离线生成的 iBeacon 网格地图。
+     *
+     * 输出：
+     * pxMesh, pyMesh -- 网格坐标中的位置。
+     */
+    pfFusionPDRiBeacon(sensorData: SensorData): [boolean, number, number];
+    /**
+     * 根据服务端返回的beacon定位结果，重新设置pdr
+     * @param pos { x: number, y: number } 定位结果
+     * @param time { number } 开始定位的时间戳
+     */
+    setBeaconPosition(pos: {
+        x: number;
+        y: number;
+    }, time: number): number[];
+    /**
+     * 根据gps数据获取定位
+     * @param data
+     * @returns
+     */
+    getGpsPosition(data: [number, number, number]): null | {
+        x: number;
+        y: number;
+    };
+    private resetParticleFilterDist;
+}

package/lib/src/plugins/pdr-position/position.d.ts

@@ -0,0 +1,27 @@
+import { EventDispatcher } from "three";
+import { PositioningSystem } from "./pdr";
+import { Sensor, SensorOptions } from "./sensor";
+export interface PdrPositionOptions {
+    sensor?: Partial<SensorOptions>;
+}
+interface PdrPositionEventMap {
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare class PdrPosition extends EventDispatcher<PdrPositionEventMap> {
+    sensor: Sensor;
+    pdr: PositioningSystem;
+    constructor(options?: PdrPositionOptions);
+    checkSensor(): Promise<{
+        deviceOrientation: boolean;
+    }>;
+    start(): void;
+    setBeaconPosition(pos: {
+        x: number;
+        y: number;
+    }, time: number): void;
+    dispose(): void;
+}
+export {};

package/lib/src/plugins/{position → pdr-position}/sensor.d.ts

@@ -1,36 +1,40 @@
 import { Timer } from "../../utils";
 import { EventDispatcher } from "three";
+import { SENSOR_TYPE } from "./enum";
 interface SensorEventMap {
     "start": {};
     "stop": {};
     "sensor-data": {
         data: SensorData[];
     };
+    "add-data-item": {
+        item: SensorData;
+    };
 }
 interface DeviceMotionData {
-    type: "deviceMotion";
+    type: SENSOR_TYPE.DEVICE_MOTION;
     timestamp: number;
     res: [number, number, number];
 }
 interface AccelerationData {
-    type: "accelerometer";
+    type: SENSOR_TYPE.ACCELERATION;
     timestamp: number;
     res: [number, number, number];
 }
 interface GpsData {
-    type: "gps";
+    type: SENSOR_TYPE.GPS;
     timestamp: number;
     res: [number, number, number];
 }
 interface CompassData {
-    type: "compass";
+    type: SENSOR_TYPE.COMPASS;
     timestamp: number;
     res: number;
 }
-type SensorData = DeviceMotionData | AccelerationData | GpsData | CompassData;
+export type SensorData = DeviceMotionData | AccelerationData | GpsData | CompassData;
 export interface SensorOptions {
     time: number;
-    elements: ("compass" | "deviceMotion" | "acceleration" | "gps")[];
+    elements: SENSOR_TYPE[];
 }
 export declare class Sensor extends EventDispatcher<SensorEventMap> {
     options: SensorOptions;
@@ -40,6 +44,7 @@ export declare class Sensor extends EventDispatcher<SensorEventMap> {
     dispatchTimer: number | null;
     constructor(options?: Partial<SensorOptions>);
     start(): void;
+    addDataItem(item: SensorData): void;
     addDeviceMotion: import("lodash").DebouncedFunc<(data: DeviceMotionData) => void>;
     addAcceleration: import("lodash").DebouncedFunc<(data: AccelerationData) => void>;
     deviceOrientationAbsHandler: (e: DeviceOrientationEvent) => void;

package/lib/src/plugins/pdr-position/utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 计算输入测量的高斯概率。
+ * 输入：
+ * avg -- 测量误差。
+ * std -- 测量的标准差。
+ * 输出：
+ * p -- 高斯概率。
+ */
+export declare function gaussLikelihood(avg: number, std: number): number;
+export declare function limitYaw(yaw: number): number;
+/**
+ * wgs84坐标转web墨卡托坐标
+ * @param lon 经度
+ * @param lat 纬度
+ * @returns
+ */
+export declare function wgs84ToWebMercator(lon: number, lat: number): {
+    x: number;
+    y: number;
+};
+export declare function euclideanDist(x1: number, y1: number, x2: number, y2: number): number;

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

@@ -43,6 +43,7 @@ export type PathData = {
     points: [number, number][];
     endType: string;
     destId: string;
+    distance: number;
 }[];
 export declare class RoadNetwork {
     private lift_priority;

package/package.json

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

package/lib/src/plugins/position/position.d.ts

@@ -1,11 +0,0 @@
-import { Sensor, SensorOptions } from "./sensor";
-export interface PdrPositionOptions {
-    sensor?: Partial<SensorOptions>;
-}
-export declare class PdrPosition {
-    sensor: Sensor;
-    constructor(options?: PdrPositionOptions);
-    checkSensor(): Promise<{
-        deviceOrientation: boolean;
-    }>;
-}