@wemap/providers 10.11.0 → 10.11.1

package/index.d.ts

@@ -1,52 +1,19 @@
 import { Calibration } from "@wemap/camera";
 import {
     Attitude, AttitudeJson,
+    Coordinates, GeoRelativePosition as GeoRelativePosition_t,
+    GraphProjection,
+    Network,
+    RelativePosition,
     UserPosition, UserPositionJson
 } from "@wemap/geo";
-import { Quaternion_t } from "@wemap/maths";
+import { Quaternion_t, Vector16_t } from "@wemap/maths";
+import { OsmElement } from "@wemap/osm";
+import { Itinerary } from "@wemap/routers";
 import { Device } from "@wemap/utils";
 
 declare module '@wemap/providers' {
 
-    export type EventTypeValue = string;
-
-    export class ProviderEvent<T> {
-
-        dataType: EventTypeValue;
-        providersStack: string[];
-        data: T;
-
-        constructor(dataType: EventTypeValue, data: T);
-        clone(): ProviderEvent<T>;
-    }
-
-    export class Provider {
-        static get pname(): string;
-        get pname(): string;
-        get eventsType(): EventTypeValue[];
-        get availability(): Promise<void>;
-
-        addEventListener(onEvents?: () => void, onError?: () => void, startIfNecessary?: boolean): number;
-        removeEventListener(id: number): void;
-
-        addMonitoringListener(onStarted?: () => void, onStopped?: () => void): number;
-        removeMonitoringListener(id: number): void;
-
-        get lastEvent(): ProviderEvent<any> | null;
-        get lastEvents(): ProviderEvent<any>[];
-    }
-
-    export class AbsolutePositionProvider extends Provider {
-        get lastEvent(): ProviderEvent<UserPosition> | null;
-    }
-    export const AbsolutePosition: AbsolutePositionProvider;
-
-
-    export class AbsoluteAttitudeProvider extends Provider {
-        get lastEvent(): ProviderEvent<Attitude> | null;
-    }
-    export const AbsoluteAttitude: AbsoluteAttitudeProvider;
-
     export type CoarsePoseJson = {
         attitude?: AttitudeJson,
         position?: UserPositionJson,
@@ -102,6 +69,256 @@ declare module '@wemap/providers' {
         static fromJson(json: VpsResponseJson): VpsResponse;
     }
 
+
+    export class AttitudeSmoother {
+        static ROTATION_SPEED_JUMP_THRESHOLD: number;
+        static ROTATION_SPEED_CONVERGENCE: number;
+        static HIGH_JUMP_THRESHOLD: number;
+        static ROTATION_SPEED_HIGH_JUMP_CONVERGENCE: number;
+        static PITCH_UNCERTAINITY_HEADING_THRESHOLD: number;
+
+        constructor(callback: (attitude: Attitude) => void);
+        feed(attitude: Attitude): void;
+    }
+
+    export class PositionSmoother {
+        static DEFAULT_FREQUENCY: number;
+        static DEFAULT_FLYBY_TIME: number;
+
+        constructor(callback: (position: UserPosition) => void, frequency?: number);
+        feed(newPosition: UserPosition, flyByTime?: number): void;
+        clear(): void;
+    }
+
+    export type EventTypeValue = string;
+
+    export type Acceleration = { timestamp: number; values: [number, number, number]; }
+    export type AngularRate = { timestamp: number; values: [number, number, number]; }
+    export type HighRotation = { timestamp: number; }
+    export type MagnetometerNeedCalibration = { angle: number; }
+    export type Turn = { timestamp: number; }
+    export type Inclination = number;
+    export type Step = { size: number; number: number; }
+    export type StraightLine = boolean;
+    export type Barcode_t = string;
+    export type CameraProjectionMatrix_t = Vector16_t;
+    export type CameraNative_t = 'started' | 'stopped';
+
+
+    export class ProviderEvent<T> {
+
+        dataType: EventTypeValue;
+        providersStack: string[];
+        data: T;
+
+        constructor(dataType: EventTypeValue, data: T);
+        clone(): ProviderEvent<T>;
+    }
+
+    export type ProvidersOptions_t = {
+        useMapMatching: boolean;
+        ignoreProviders: string[];
+        optionalProviders: string[];
+        stopOnError: boolean;
+        checkAvailabilityOnStart: boolean;
+        get hasPoleStar(): boolean;
+    }
+    export const ProvidersOptions: ProvidersOptions_t;
+
+    export class Provider<T> {
+        static get pname(): string;
+        get pname(): string;
+        get eventsType(): EventTypeValue[];
+        get availability(): Promise<void>;
+
+        addEventListener(
+            onEvents?: (events: ProviderEvent<T>[]) => void,
+            onError?: () => void,
+            startIfNecessary?: boolean
+        ): number;
+        removeEventListener(id: number): void;
+
+        addMonitoringListener(onStarted?: () => void, onStopped?: () => void): number;
+        removeMonitoringListener(id: number): void;
+
+        get lastEvent(): ProviderEvent<T> | null;
+        get lastEvents(): ProviderEvent<T>[];
+    }
+
+    // MapMatchingHandler
+    export class MapMatchingHandlerProvider<T> extends Provider<Network<T> | Itinerary>  {
+        getProjection(
+            position: Coordinates,
+            useDistance?: boolean,
+            useBearing?: boolean
+        ): GraphProjection<T> | null;
+
+        set itinerary(itinerary: Itinerary | null);
+        set network(network: Network<T> | null);
+        get network(): Network<T> | null;
+        get maxDistance(): number;
+        set maxDistance(maxDistance: number);
+        get minDistance(): number;
+        set minDistance(minDistance: number);
+        get maxAngleBearing(): number;
+        set maxAngleBearing(maxAngleBearing: number);
+        get useItineraryStartAsPosition(): boolean;
+        set useItineraryStartAsPosition(useItineraryStartAsPosition: boolean);
+        get useOrientationMatching(): boolean;
+        set useOrientationMatching(useOrientationMatching: boolean);
+        get hugeJumpDistance(): number;
+        set hugeJumpDistance(hugeJumpDistance: number);
+        get disableMMCloseToATurnDistance(): number;
+        set disableMMCloseToATurnDistance(disableMMCloseToATurnDistance: number);
+        get minStepsBetweenOrientationMatching(): number;
+        set minStepsBetweenOrientationMatching(minStepsBetweenOrientationMatching: number);
+        get minStepsForOrientationMatching(): number;
+        set minStepsForOrientationMatching(minStepsForOrientationMatching: number);
+        get lastProjectionsWindowSize(): number;
+        set lastProjectionsWindowSize(lastProjectionsWindowSize: number);
+        get lastProjectionsEdgeAngleThreshold(): number;
+        set lastProjectionsEdgeAngleThreshold(lastProjectionsEdgeAngleThreshold: number);
+    }
+    export const MapMatchingHandler: MapMatchingHandlerProvider<OsmElement>;
+
+
+    // Imu
+    export class ImuProvider extends Provider<Acceleration | AngularRate> { }
+    export const Imu: ImuProvider;
+
+    // Accelerometer
+    export class AccelerometerProvider extends Provider<Acceleration> { }
+    export const Accelerometer: AccelerometerProvider;
+
+    // Gyroscope
+    export class GyroscopeProvider extends Provider<AngularRate> { }
+    export const Gyroscope: GyroscopeProvider;
+
+    // HighRotationsDetector
+    export class HighRotationsDetectorProvider extends Provider<HighRotation> { }
+    export const HighRotationsDetector: HighRotationsDetectorProvider;
+
+    // MagnetometerCalibrationDetector
+    export class MagnetometerCalibrationDetectorProvider extends Provider<MagnetometerNeedCalibration> { }
+    export const MagnetometerCalibrationDetector: MagnetometerCalibrationDetectorProvider;
+
+
+    // RelativeAttitudeFromBrowser
+    export class RelativeAttitudeFromBrowserProvider extends Provider<Attitude> { }
+    export const RelativeAttitudeFromBrowser: RelativeAttitudeFromBrowserProvider;
+
+    // RelativeAttitudeFromEkf
+    export class RelativeAttitudeFromEkfProvider extends Provider<Attitude> { }
+    export const RelativeAttitudeFromEkf: RelativeAttitudeFromEkfProvider;
+
+    // RelativeAttitudeFromInertial
+    export class RelativeAttitudeFromInertialProvider extends Provider<Attitude> { }
+    export const RelativeAttitudeFromInertial: RelativeAttitudeFromInertialProvider;
+
+    // RelativeAttitude
+    export class RelativeAttitudeProvider extends Provider<Attitude> { }
+    export const RelativeAttitude: RelativeAttitudeProvider;
+
+
+    // AbsoluteAttitudeFromBrowser
+    export class AbsoluteAttitudeFromBrowserProvider extends Provider<Attitude> { }
+    export const AbsoluteAttitudeFromBrowser: AbsoluteAttitudeFromBrowserProvider;
+
+    // AbsoluteAttitude
+    export class AbsoluteAttitudeProvider extends Provider<Attitude> {
+        feed(data: AbsoluteHeading | Attitude | ProviderEvent<AbsoluteHeading>): void;
+    }
+    export const AbsoluteAttitude: AbsoluteAttitudeProvider;
+
+
+    // TurnDetector
+    export class TurnDetectorProvider extends Provider<Turn> { }
+    export const TurnDetector: TurnDetectorProvider;
+
+
+    // InclinationFromAcc
+    export class InclinationFromAccProvider extends Provider<Inclination> { }
+    export const InclinationFromAcc: InclinationFromAccProvider;
+
+    // InclinationFromRelativeAttitude
+    export class InclinationFromRelativeAttitudeProvider extends Provider<Inclination> { }
+    export const InclinationFromRelativeAttitude: InclinationFromRelativeAttitudeProvider;
+
+    // Inclination
+    export class InclinationProvider extends Provider<Inclination> { }
+    export const Inclination: InclinationProvider;
+
+
+    // StepDetector
+    export class StepDetectorProvider extends Provider<Step> {
+        set algorithm(name: StepDetectionAlgorithmName);
+        get algorithm(): StepDetectionAlgorithmName;
+        set stepSizeMultiplier(stepSizeMultiplier: number);
+        get stepSizeMultiplier(): number;
+    }
+    export const StepDetector: StepDetectorProvider;
+
+    // StraightLineDetector
+    export class StraightLineDetectorProvider extends Provider<StraightLine> {
+        get numStepsDetectedFromLastTurn(): number;
+        get stepsConsideredForStraightLine(): number;
+        set stepsConsideredForStraightLine(stepsConsideredForStraightLine: number);
+    }
+    export const StraightLineDetector: StraightLineDetectorProvider;
+
+    // StepDetectionAlgorithms
+    export type StepDetectionAlgorithmName = 'ladetto' | 'minMaxPeaks' | 'minMaxPeaks2' | 'minMaxPeaks3';
+    export class StepDetectionAlgorithm {
+        static WINDOW_TIME: number;
+        static MIN_TIME_BETWEEN_STEPS: number;
+        static MAX_FRENQUENCY: number;
+        static MIN_FRENQUENCY: number;
+        static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD: number;
+        static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD: number;
+    }
+    export class StepDetectionMinMaxPeaks2 extends StepDetectionAlgorithm { }
+    export class StepDetectionMinMaxPeaks3 extends StepDetectionAlgorithm { }
+
+
+    // Pdr
+    export class PdrProvider extends Provider<GeoRelativePosition_t> { }
+    export const Pdr: PdrProvider;
+
+    // GeoRelativePositionFromArCore
+    export class GeoRelativePositionFromArCoreProvider extends Provider<GeoRelativePosition_t> { }
+    export const GeoRelativePositionFromArCore: GeoRelativePositionFromArCoreProvider;
+
+    // GeoRelativePosition
+    export class GeoRelativePositionProvider extends Provider<GeoRelativePosition_t> { }
+    export const GeoRelativePosition: GeoRelativePositionProvider;
+
+
+    // GnssWifi
+    export class GnssWifiProvider extends Provider<UserPosition> { }
+    export const GnssWifi: GnssWifiProvider;
+
+    // PoleStar
+    export class PoleStarProvider extends Provider<UserPosition> {
+        setApiKey(key: string): void;
+    }
+    export const PoleStar: PoleStarProvider;
+
+    // Ip
+    export class IpProvider extends Provider<UserPosition> { }
+    export const Ip: IpProvider;
+
+    // AbsolutePosition
+    export class AbsolutePositionProvider extends Provider<UserPosition> {
+        feed(data: UserPosition | ProviderEvent<UserPosition>): void;
+    }
+    export const AbsolutePosition: AbsolutePositionProvider;
+
+
+    // ArCore
+    export class ArCoreProvider extends Provider<RelativePosition | Attitude | CameraProjectionMatrix_t | Barcode_t> { }
+    export const ArCore: ArCoreProvider;
+
+    // ImageRelocalization
     export class ImageRelocalization {
 
         static _prepareRequest(
@@ -118,5 +335,32 @@ declare module '@wemap/providers' {
 
         static getHeadingFromQuaternion(quaternion: Quaternion_t): number;
     }
+
+    // Vps
+    export class VpsProvider extends Provider<UserPosition | Attitude> {
+        get endpoint(): string;
+        set endpoint(endpoint: string);
+        get minInclinationForRequest(): number;
+        set minInclinationForRequest(minInclinationForRequest: number);
+        get waitTimeMinInclinationForRequest(): number;
+        set waitTimeMinInclinationForRequest(waitTimeMinInclinationForRequest: number);
+        get useCoarsePose(): boolean;
+        set useCoarsePose(useCoarsePose: boolean);
+    }
+    export const Vps: VpsProvider;
+
+    // Barcode
+    export class BarcodeProvider extends Provider<Barcode_t> { }
+    export const Barcode: BarcodeProvider;
+
+
+    // CameraNative
+    export class CameraNativeProvider extends Provider<CameraNative_t> { }
+    export const CameraNative: CameraNativeProvider;
+
+    // CameraProjectionMatrix
+    export class CameraProjectionMatrixProvider extends Provider<CameraProjectionMatrix_t> { }
+    export const CameraProjectionMatrix: CameraProjectionMatrixProvider;
+
 }
 

package/package.json

@@ -8,15 +8,15 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/camera": "^10.1.0",
-    "@wemap/geo": "^10.10.0",
+    "@wemap/camera": "^10.11.1",
+    "@wemap/geo": "^10.11.1",
     "@wemap/geomagnetism": "^0.1.1",
-    "@wemap/logger": "^10.0.0",
-    "@wemap/map": "^10.10.0",
+    "@wemap/logger": "^10.11.1",
+    "@wemap/map": "^10.11.1",
     "@wemap/maths": "^10.10.0",
-    "@wemap/osm": "^10.10.0",
-    "@wemap/routers": "^10.11.0",
-    "@wemap/utils": "^10.6.0"
+    "@wemap/osm": "^10.11.1",
+    "@wemap/routers": "^10.11.1",
+    "@wemap/utils": "^10.11.1"
   },
   "description": "A package using different geoloc systems",
   "devDependencies": {
@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "10.11.0",
-  "gitHead": "2e30d73684ee8a1cefb0fef0df882b86afc2044f"
+  "version": "10.11.1",
+  "gitHead": "e01001affc1f02f2c847a63de870f63734b98a1c"
 }

package/src/ProvidersOptions.js

@@ -20,20 +20,10 @@ const ProvidersOptions = {
      */
     optionalProviders: [],
 
-    /**
-     * Define the list of EventType that are optionals
-     * List of {@link EventType}
-     */
-    optionalEvents: [],
-
     stopOnError: true,
 
     checkAvailabilityOnStart: true,
 
-    stepdetectionlocker: true,
-
-    smoother: true,
-
     get hasPoleStar() {
         return this.optionalProviders.includes('PoleStar');
     }

package/src/mapmatching/MapMatchingHandler.js

@@ -181,6 +181,7 @@ class MapMatchingHandler extends Provider {
         return this._mapMatching.network;
     }
 
+    // TODO: rename to setGraphNetwork()
     /** @type {?Network} */
     set network(network) {