@wemap/providers 3.0.0

package/src/providers/position/absolute/AbsolutePositionProvider.js

@@ -0,0 +1,172 @@
+import noop from 'lodash.noop';
+
+import { UserPosition } from '@wemap/geo';
+import {
+    MapMatching, Network
+} from '@wemap/graph';
+import { deg2rad } from '@wemap/maths';
+
+import MetaProvider from '../../MetaProvider';
+import EventType from '../../../events/EventType';
+import ProviderEvent from '../../../events/ProviderEvent';
+import Availability from '../../../events/Availability';
+import {
+    AbsolutePositionFromRel, GnssWifi
+} from '../../../Providers';
+import ProvidersOptions from '../../../ProvidersOptions';
+
+class AbsolutePositionProvider extends MetaProvider {
+
+    static ACCURACY_RELOC_RATIO = 2;
+    static MM_MAX_ANGLE = deg2rad(20);
+    static MM_MAX_DIST = 15;
+    static MM_MIN_DIST = 1;
+
+
+    constructor() {
+        super();
+        this.mapMatching = new MapMatching();
+        this.mapMatching.maxDistance = AbsolutePositionProvider.MM_MAX_DIST;
+        this.mapMatching.maxAngleBearing = AbsolutePositionProvider.MM_MAX_ANGLE;
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Absolute position from Relative position';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.union(
+            AbsolutePositionFromRel.availability,
+            GnssWifi.availability
+        );
+    }
+
+
+    /**
+     * @override
+     */
+    start() {
+        if (AbsolutePositionFromRel.availability.isSupported) {
+            this.fromRelPosProviderId = AbsolutePositionFromRel.addEventListener(
+                events => this.onAbsolutePositionFromRel(events[0]),
+                noop,
+                this.name
+            );
+        }
+
+        this.gnssWifiProviderId = GnssWifi.addEventListener(
+            events => this.onAbsolutePosition(events[0]),
+            noop,
+            this.name
+        );
+
+    }
+
+
+    /**
+     * @override
+     */
+    stop() {
+        if (this.fromRelPosProviderId) {
+            AbsolutePositionFromRel.removeEventListener(this.fromRelPosProviderId);
+        }
+        GnssWifi.removeEventListener(this.gnssWifiProviderId);
+    }
+
+    onAbsolutePosition(newPositionEvent) {
+        if (this.lastEvent) {
+
+            const newPosition = newPositionEvent.data;
+            const lastPosition = this.lastEvent.data;
+
+            if (newPosition.distanceTo(lastPosition) < newPosition.accuracy
+                && newPosition.accuracy > lastPosition.accuracy / AbsolutePositionProvider.ACCURACY_RELOC_RATIO) {
+                return;
+            }
+        }
+
+        this.notify(newPositionEvent.clone());
+    }
+
+    /**
+     * @param {ProviderEvent} newPositionEvent
+     */
+    onAbsolutePositionFromRel(newPositionEvent) {
+
+        /**
+         * If map matching is not used or not set, raw position is returned
+         */
+        if (!ProvidersOptions.useMapMatching
+            || !this.mapMatching.network) {
+            this.notify(newPositionEvent.clone());
+            return;
+        }
+
+        const newPosition = newPositionEvent.data;
+        const projection = this.mapMatching.getProjection(newPosition, true, true);
+        if (!projection || !projection.projection) {
+            // If no projection has been found, returns the position without map-matching
+            this.notify(newPositionEvent.clone());
+            return;
+        }
+
+        const projectedPosition = newPosition.clone();
+
+        // Anyway, the projected level is used for new position
+        projectedPosition.level = projection.projection.level;
+
+        // Do not use projection if it too close from itinerary,
+        //  this allows left/right movements (ie with ArCore)
+        if (projection.distanceFromNearestElement > AbsolutePositionProvider.MM_MIN_DIST) {
+            projectedPosition.lat = projection.projection.lat;
+            projectedPosition.lng = projection.projection.lng;
+        }
+
+        this.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            projectedPosition,
+            newPositionEvent
+        ));
+
+    }
+
+    /**
+     * @override
+     * @param {UserPosition} position
+     */
+    feed(data) {
+        if (data instanceof UserPosition) {
+            const position = data;
+            if (position.time === null) {
+                throw Error('the time of the position is not defined');
+            }
+            if (position.accuracy === null) {
+                throw Error('the accuracy of the position is not defined');
+            }
+            this.onAbsolutePosition(this.createEvent(
+                EventType.AbsolutePosition, position, position.time
+            ));
+        } else if (data instanceof Network) {
+            this.mapMatching.network = data;
+        } else {
+            throw new Error('Unknown feed object');
+        }
+
+    }
+
+}
+
+export default AbsolutePositionProvider;

package/src/providers/position/absolute/GnssWifiProvider.js

@@ -0,0 +1,122 @@
+import { deg2rad } from '@wemap/maths';
+import { UserPosition } from '@wemap/geo';
+import { TimeUtils } from '@wemap/utils';
+
+import EventType from '../../../events/EventType';
+import GeolocationApiMissingError from '../../../errors/GeolocationApiMissingError';
+import Provider from '../../Provider';
+import GeolocationPermissionDeniedError from '../../../errors/GeolocationPermissionDeniedError';
+import GeolocationPositionUnavailableError from '../../../errors/GeolocationPositionUnavailableError';
+import Availability from '../../../events/Availability';
+import Constants from '../../Constants';
+
+const POSITION_OPTIONS = {
+    enableHighAccuracy: true,
+    timeout: Infinity,
+    maximumAge: 0
+};
+
+/**
+ * GnssWifiProvider is a provider based on navigator.geolocation.
+ * This API does not allow us to know if the position returned is provided
+ *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
+ *  "GnssWifi".
+ */
+class GnssWifiProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'GNSS / Wifi from Browser';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return typeof(navigator) === 'object' && navigator.geolocation
+            ? Availability.yes()
+            : Availability.no(new GeolocationApiMissingError());
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.geoLocationId = navigator.geolocation.watchPosition(
+            this.onNewPosition,
+            this.onPositionError,
+            POSITION_OPTIONS
+        );
+
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+
+        navigator.geolocation.clearWatch(this.geoLocationId);
+
+    }
+
+    /**
+     * @private
+     */
+    onNewPosition = geolocation => {
+        const { coords } = geolocation;
+        if (!coords) {
+            return;
+        }
+
+        let bearing;
+        if (coords.heading) {
+            bearing = deg2rad(coords.heading);
+        }
+
+        const timestamp = TimeUtils.unixTimestampToPreciseTime(geolocation.timestamp) / 1e3;
+
+        const position = new UserPosition(
+            coords.latitude,
+            coords.longitude,
+            Constants.DEFAULT_ALTITUDE,
+            null,
+            timestamp,
+            coords.accuracy,
+            bearing,
+            this.name);
+
+        this.notify(this.createEvent(
+            EventType.AbsolutePosition, position, timestamp
+        ));
+
+    };
+
+    onPositionError = error => {
+
+        let customError;
+        switch (error.code) {
+        case 1:
+            customError = new GeolocationPermissionDeniedError(error.message);
+            break;
+        case 2:
+            customError = new GeolocationPositionUnavailableError(error.message);
+            break;
+        default:
+            customError = new Error(error.message);
+        }
+
+        this.notifyError(customError);
+    };
+}
+
+export default GnssWifiProvider;

package/src/providers/position/absolute/IpProvider.js

@@ -0,0 +1,68 @@
+import { UserPosition } from '@wemap/geo';
+import { TimeUtils } from '@wemap/utils';
+
+import EventType from '../../../events/EventType';
+import Provider from '../../Provider';
+import IpResolveServerError from '../../../errors/IpResolveServerError';
+
+/**
+ * GnssWifiProvider is a provider based on navigator.geolocation.
+ * This API does not allow us to know if the position returned is provided
+ *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
+ *  "GnssWifi".
+ */
+class IpProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'IP from ipinfo.io';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        fetch('https://ipinfo.io/geo?token=24a7ca2f3b489d')
+            .then((response) => {
+                if (!response) {
+                    this.notifyError(new IpResolveServerError());
+                    return;
+                }
+
+                const timestamp = TimeUtils.preciseTime / 1e3;
+
+                const latLngStr = response.loc.split(',');
+                const position = new UserPosition(
+                    parseFloat(latLngStr[0]),
+                    parseFloat(latLngStr[1]),
+                    null,
+                    null,
+                    timestamp
+                );
+
+                this.notify(this.createEvent(
+                    EventType.AbsolutePosition, position, timestamp
+                ));
+            });
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+
+    }
+
+}
+
+export default IpProvider;

package/src/providers/position/relative/ArCoreProvider.js

@@ -0,0 +1,197 @@
+/* eslint-disable no-bitwise */
+import {
+    Attitude, RelativePosition
+} from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+import { TimeUtils } from '@wemap/utils';
+
+import Provider from '../../Provider';
+import EventType from '../../../events/EventType';
+import MissingArCoreError from '../../../errors/MissingArCoreError';
+import MissingNativeInterfaceError from '../../../errors/MissingNativeInterfaceError';
+import Availability from '../../../events/Availability';
+import ProviderState from '../../ProviderState';
+
+
+const Payload = {
+    Pose: {
+        ref: 2 ** 0,
+        size: 7
+    },
+    Barcode: {
+        ref: 2 ** 1,
+        size: 1
+    },
+    ProjMat: {
+        ref: 2 ** 2,
+        size: 16
+    },
+    ImageRef: {
+        ref: 2 ** 3,
+        size: 1
+    }
+};
+
+class ArCoreProvider extends Provider {
+
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    static RELATIVE_ATTITUDE_DRIFT = deg2rad(3) / 60;
+
+    previousPosition = [0, 0, 0];
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'ArCore provider';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude, EventType.RelativePosition, EventType.Barcode];
+    }
+
+
+    /**
+     * @override
+     */
+    start() {
+        if (this.nativeProvider) {
+            this.nativeProvider.start();
+        }
+
+        this.pullDataLoop();
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        if (this.nativeProvider) {
+            this.nativeProvider.stop();
+        }
+    }
+
+    pullDataLoop = () => {
+
+        if (this.state === ProviderState.STOPPPED) {
+            return;
+        }
+
+        const payload = JSON.parse(this.nativeProvider.getInfo());
+        if (payload.length > 1) {
+            this.parsePayload(payload);
+        }
+        requestAnimationFrame(this.pullDataLoop);
+    }
+
+    parsePayload(payload) {
+
+        const ref = payload[0];
+        let bufferIndex = 1;
+
+        const events = [];
+
+        const time = TimeUtils.preciseTime / 1e3;
+
+        if (ref & Payload.Pose.ref) {
+
+            const attitude = new Attitude(
+                payload.slice(bufferIndex, bufferIndex + 4),
+                time,
+                this.constructor.RELATIVE_ATTITUDE_DRIFT,
+            );
+            events.push(this.createEvent(EventType.RelativeAttitude, attitude));
+
+            const newPosition = [payload[bufferIndex + 4], payload[bufferIndex + 5], payload[bufferIndex + 6]];
+            const position = new RelativePosition(
+                newPosition[0] - this.previousPosition[0],
+                newPosition[1] - this.previousPosition[1],
+                newPosition[2] - this.previousPosition[2],
+                time,
+                1e-4
+            );
+            this.previousPosition = newPosition;
+            events.push(this.createEvent(EventType.RelativePosition, position));
+
+            bufferIndex += Payload.Pose.size;
+        }
+
+        if (ref & Payload.Barcode.ref) {
+            events.push(this.createEvent(EventType.Barcode, payload[bufferIndex]));
+            bufferIndex += Payload.Barcode.size;
+        }
+
+        if (ref & Payload.ProjMat.ref) {
+            const projMatrix = payload.slice(bufferIndex, bufferIndex + Payload.ProjMat.size);
+            events.push(this.createEvent(EventType.ProjectionMatrix, projMatrix));
+            bufferIndex += Payload.ProjMat.size;
+        }
+
+        if (events.length !== 0) {
+            this.notify(...events);
+        }
+    }
+
+
+    get nativeProvider() {
+
+        if (!this._nativeProvider) {
+
+            if (!this.nativeInterface) {
+                throw new MissingNativeInterfaceError();
+            }
+
+            this._nativeProvider = this.nativeInterface.getArCoreProvider();
+            if (!this._nativeProvider) {
+                throw new MissingArCoreError();
+            }
+
+        }
+
+        return this._nativeProvider;
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        try {
+            const nativeProvider = this.nativeProvider;
+
+            if (!nativeProvider.checkAvailability()) {
+                return Availability.no(new MissingArCoreError());
+            }
+
+        } catch (e) {
+            return Availability.no(e);
+        }
+
+        return Availability.yes();
+    }
+
+    enableBarcodeScanner() {
+        if (this.nativeProvider) {
+            this.nativeProvider.enableBarcodeScanner();
+        }
+    }
+
+    disableBarcodeScanner() {
+        if (this.nativeProvider) {
+            this.nativeProvider.disableBarcodeScanner();
+        }
+    }
+
+    /**
+     * @override
+     */
+    static get useCameraNatively() {
+        return true;
+    }
+}
+
+export default ArCoreProvider;

package/src/providers/position/relative/GeoRelativePositionFromArCoreProvider.js

@@ -0,0 +1,85 @@
+import { GeoRelativePosition } from '@wemap/geo';
+
+import EventType from '../../../events/EventType';
+import Provider from '../../Provider';
+import {
+    ArCore, AbsoluteAttitude
+} from '../../../Providers';
+
+class GeoRelativePositionFromArCoreProvider extends Provider {
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return ArCore.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.arCoreProviderId = ArCore.addEventListener(
+            this.onArCoreEvents,
+            this.notifyError,
+            this.name);
+
+        this.absoluteAttitudeProviderId = AbsoluteAttitude.addEventListener(
+            events => (this.absoluteAttitudeEvent = events[0]),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        ArCore.removeEventListener(this.arCoreProviderId);
+        AbsoluteAttitude.removeEventListener(this.absoluteAttitudeProviderId);
+    }
+
+    onArCoreEvents = events => {
+        const relativeAttitudeEvent = events.find(event => event.dataType === EventType.RelativeAttitude);
+        const relativePositionEvent = events.find(event => event.dataType === EventType.RelativePosition);
+
+        if (relativeAttitudeEvent && relativePositionEvent && this.absoluteAttitudeEvent) {
+            this.compute(relativePositionEvent, relativeAttitudeEvent, this.absoluteAttitudeEvent);
+        }
+    }
+
+    compute(relativePositionEvent, relativeAttitudeEvent, absoluteAttitudeEvent) {
+        const relativePosition = relativePositionEvent.data;
+        const relativeAttitude = relativeAttitudeEvent.data;
+        const absoluteAttitude = absoluteAttitudeEvent.data;
+
+        const rotation = absoluteAttitude.heading - relativeAttitude.heading;
+
+        /**
+         * Here, we transform "relativePosition" which is defined in ArCore frame to a relative "position" defined in ENU frame
+         */
+        const east = Math.cos(rotation) * relativePosition.x - Math.sin(rotation) * relativePosition.z;
+        const north = -Math.sin(rotation) * relativePosition.x - Math.cos(rotation) * relativePosition.z;
+        const up = relativePosition.y;
+
+        /**
+         * Relative position is defined in ENU frame
+         */
+        const position = new GeoRelativePosition(
+            east,
+            north,
+            up,
+            relativePosition.time,
+            0
+        );
+
+        this.notify(this.createEvent(
+            EventType.GeoRelativePosition,
+            position,
+            relativePosition.time,
+            [relativePositionEvent, relativeAttitudeEvent, absoluteAttitudeEvent]
+        ));
+    }
+}
+
+export default GeoRelativePositionFromArCoreProvider;

package/src/providers/position/relative/GeoRelativePositionProvider.js

@@ -0,0 +1,66 @@
+import MetaProvider from '../../MetaProvider';
+import Availability from '../../../events/Availability';
+import EventType from '../../../events/EventType';
+import {
+    Pdr, GeoRelativePositionFromArCore
+} from '../../../Providers';
+
+class GeoRelativePositionProvider extends MetaProvider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Geo Relative Position';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.GeoRelativePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.union(
+            Pdr.availability,
+            GeoRelativePositionFromArCore.availability
+        );
+    }
+
+
+    /**
+     * @override
+     */
+    start() {
+
+        if (GeoRelativePositionFromArCore.availability.isSupported) {
+            this.geoRelativeProvider = GeoRelativePositionFromArCore;
+        } else {
+            this.geoRelativeProvider = Pdr;
+        }
+
+        this.providerId = this.geoRelativeProvider.addEventListener(
+            events => {
+                const event = events.find(_event => _event.dataType === EventType.GeoRelativePosition);
+                if (event) {
+                    this.notify(event.clone());
+                }
+            },
+            this.notifyError,
+            this.name
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.geoRelativeProvider.removeEventListener(this.providerId);
+    }
+}
+
+export default GeoRelativePositionProvider;