@wemap/positioning 2.2.0 → 2.3.1

package/src/components/index.js

@@ -3,6 +3,7 @@ import ReactDOM from 'react-dom';
 
 import AbsoluteAttitudeComponent from './AbsoluteAttitudeComponent';
 import ArCoreComponent from './ArCoreComponent';
+import ArCoreAbsoluteComponent from './ArCoreAbsoluteComponent';
 import GnssWifiComponent from './GnssWifiComponent';
 import GnssWifiPdrComponent from './GnssWifiPdrComponent';
 import ImuComponent from './ImuComponent';
@@ -20,6 +21,7 @@ const createReactElement = (component, container) => ReactDOM.render(
 export {
     AbsoluteAttitudeComponent,
     ArCoreComponent,
+    ArCoreAbsoluteComponent,
     ImuComponent,
     InclinationComponent,
     GnssWifiComponent,

package/src/index.js

@@ -1,6 +1,7 @@
 import InclinationProvider from './providers/computed/InclinationProvider';
 import PositioningHandler from './PositioningHandler';
+import EventType from './events/EventType';
 
 export {
-    InclinationProvider, PositioningHandler
+    InclinationProvider, PositioningHandler, EventType
 };

package/src/providers/Provider.js

@@ -215,10 +215,10 @@ class Provider {
 
 
     static hasNativeInterface() {
-        return Boolean(Provider.getNativeInterface());
+        return Boolean(Provider.nativeInterface);
     }
 
-    static getNativeInterface() {
+    static get nativeInterface() {
         return global.WemapProvidersAndroid;
     }
 

package/src/providers/ProviderOptions.js

@@ -2,7 +2,7 @@ const ProviderOptions = {
 
     /**
      * Does provider have to wait an input position to start
-     * @see PositioningHandler#setLocation()
+     * @see PositioningHandler#setPosition()
      */
     waitInputPosition: false,
 
@@ -22,7 +22,13 @@ const ProviderOptions = {
      * Providers listed here will not be used by PositioningHandler
      * List of {@link Provider}
      */
-    ignoreProviders: []
+    ignoreProviders: [],
+
+    /**
+     * Define the list of EventType that are optionals
+     * List of {@link EventType}
+     */
+    optionalEvents: []
 };
 
 export default ProviderOptions;

package/src/providers/attitude/AbsoluteAttitudeProvider.js

@@ -162,8 +162,8 @@ class AbsoluteAttitudeProvider extends Provider {
     onDeviceOrientationCommonEvent = (timestamp, quaternion) => {
 
         if (!this.declinationQuaternion) {
-            Logger.warn('Location of AbsoluteAttitude provider is not set yet. '
-                + 'Please call setLocation() before.');
+            Logger.warn('Position of AbsoluteAttitude provider is not set yet. '
+                + 'Please call setPosition() before.');
             return;
         }
         const trueQuaternion = Quaternion.multiply(this.declinationQuaternion, quaternion);
@@ -178,13 +178,13 @@ class AbsoluteAttitudeProvider extends Provider {
     }
 
     /**
-     * Initialized declination quaternion using current location.
+     * Initialized declination quaternion using current position.
      * This method should be theoretically called every time the user moves.
      * But in reality declination does not change as much.
-     * @param {WGS84} location user location
+     * @param {WGS84} position user position
      */
-    setLocation(location) {
-        const wmmResult = geomagnetism.model().point([location.lat, location.lng]);
+    setPosition(position) {
+        const wmmResult = geomagnetism.model().point([position.lat, position.lng]);
         // Declination is given in NED frame and our code use ENU, that is why we have: "-decl"
         this.declinationQuaternion = Quaternion.fromAxisAngle([0, 0, 1], - deg2rad(wmmResult.decl));
     }

package/src/providers/others/MapMatchingProvider.js

@@ -6,10 +6,10 @@ import {
 class MapMatchingProvider extends Provider {
 
     /**
-     * Enable LocationSource mapmatching
+     * Enable mapmatching
      * @param {*} network a network which will be used for map matching
-     * @param {*} maxDistance max distance between location and network to match. null disables maxDistance (default: null)
-     * @param {*} maxAngleBearing threshold to match a parallel segment for angle between location bearing and segment. null disables this threshold (default: null)
+     * @param {*} maxDistance max distance between position and network to match. null disables maxDistance (default: null)
+     * @param {*} maxAngleBearing threshold to match a parallel segment for angle between position bearing and segment. null disables this threshold (default: null)
      * @public
      */
     enableMapMatching(network, maxDistance, maxAngleBearing) {
@@ -23,7 +23,7 @@ class MapMatchingProvider extends Provider {
     }
 
     /**
-     * Update the LocationSource network for mapmatching
+     * Update the network for mapmatching
      * @param {Network} network a network instance
      * @public
      */
@@ -47,26 +47,26 @@ class MapMatchingProvider extends Provider {
     }
 
     /**
-     * Returns projection of a location on network
-     * @param {WGS84} location if location is null, projection of this.pose.location is used
-     * @returns The projected location {WGS84} or null.
+     * Returns projection of a position on network
+     * @param {WGS84} position if position is null, projection of this.position is used
+     * @returns The projected position {WGS84} or null.
      * @public
      */
-    getProjectionOnNetwork(location = null) {
+    getProjectionOnNetwork(position = null) {
 
         if (!this.mapMatching) {
             return null;
         }
 
-        let locationToProject = location;
-        if (!location) {
-            locationToProject = this.pose.location;
+        let positionToProject = position;
+        if (!position) {
+            positionToProject = this.position;
         }
-        if (!locationToProject) {
+        if (!positionToProject) {
             return null;
         }
 
-        return this.mapMatching.getProjection(locationToProject, false, false);
+        return this.mapMatching.getProjection(positionToProject, false, false);
     }
 
 
@@ -75,7 +75,7 @@ class MapMatchingProvider extends Provider {
      */
 
     /**
-     * Update itinerary of Location Source.
+     * Update itinerary.
      * Itinerary is different from network, it is not used for mapmatching. It can be used for others tricks like HeadingUnlocker
      * @param {Itinerary} itinerary a given itinerary
      * @public
@@ -89,17 +89,17 @@ class MapMatchingProvider extends Provider {
 
 
     /**
-     * Returns projection and itinerary info of a location on network
-     * @param {WGS84} location if location is null, projection of this.pose.location is used
-     * @returns An object of the projected location and itinerary info or null.
+     * Returns projection and itinerary info of a position on network
+     * @param {WGS84} position if position is null, projection of this.position is used
+     * @returns An object of the projected position and itinerary info or null.
      * @public
      */
-    getItineraryInfo(location = null) {
+    getItineraryInfo(position = null) {
 
         if (!this.itinerary) {
             throw new Error('No itinerary found');
         }
-        const projection = this.getProjectionOnNetwork(location);
+        const projection = this.getProjectionOnNetwork(position);
         if (!projection) {
             return null;
         }

package/src/providers/pose/ArCoreAbsoluteProvider.js

@@ -0,0 +1,186 @@
+/* eslint-disable max-statements */
+import { Attitude } from '@wemap/geo';
+
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import ArCoreProvider from './ArCoreProvider';
+import {
+    Quaternion, Vector3
+} from '@wemap/maths';
+import ImuProvider from '../others/ImuProvider';
+import ProviderError from '../../events/ProviderError';
+
+/**
+ * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
+ * of what he can and provides an AbsoluteAttitude and an AbsolutePosition as an output.
+ */
+class ArCoreAbsoluteProvider extends Provider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        this.arCoreProvider = new ArCoreProvider(
+            e => this.onArCoreEvent(e),
+            e => this.onArCoreError(e),
+            options);
+
+        this.imuProvider = new ImuProvider(
+            this.onImuEvent,
+            this.onImuError,
+            Object.assign(options || {}, { require: [EventType.AngularRate] })
+        );
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'ArCore absolute provider';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * Return the list of required providers
+     */
+    static get requiredProviders() {
+        return [ArCoreProvider, ImuProvider];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+        this.arCoreProvider.start();
+        this.imuProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+        this.arCoreProvider.stop();
+        this.imuProvider.stop();
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+        return ArCoreProvider.checkAvailabilityErrors().concat(
+            ImuProvider.checkAvailabilityErrors()
+        );
+    }
+
+    onArCoreEvent = events => {
+        events.forEach(event => {
+            if (event.dataType === EventType.RelativeAttitude) {
+
+                // const previousAttitude = this.relativeAttitude;
+                this.relativeAttitude = event.data;
+
+                /**
+                 * The two following blocks cannot be called in the same call because this.waitingForceHeading
+                 * if exists, is called before the first this.relativeAttitude assigment. So, this.waitingForceHeading
+                 * and previousAttitude should not be defined in the same time.
+                 */
+
+                if (typeof this.waitingForceHeading !== 'undefined') {
+                    /**
+                     * waitingForceHeading is set by setHeading() if this.relativeAttitude does not exist
+                     * At this moment, this.relativeAttitude is defined, so we can call setHeading again
+                     */
+                    this.setHeading(this.waitingForceHeading);
+                    delete this.waitingForceHeading;
+
+                }
+
+                // if (previousAttitude && this.absoluteAttitude) {
+                //     /**
+                //      * Sometimes ArCore has "orientation jumps" around z-axis.
+                //      * Here we try to detect and remove them.
+                //      */
+                //     const dist = Quaternion.distance(event.data.quaternion, previousAttitude.quaternion);
+                //     if (typeof this.angularRate !== 'undefined') {
+                //         const velocity = Vector3.norm(this.angularRate);
+                //         if (dist > deg2rad(10) && velocity < deg2rad(4)) {
+                //             this.setHeading(this.absoluteAttitude.heading);
+                //         }
+                //     }
+                // }
+
+                if (this.offsetQuat) {
+                    const absoluteQuaternion = Quaternion.multiply(this.offsetQuat, this.relativeAttitude.quaternion);
+                    this.absoluteAttitude = new Attitude(absoluteQuaternion);
+                    this.notify(this.createEvent(EventType.AbsoluteAttitude, this.absoluteAttitude, event.timestamp));
+                }
+            }
+
+            if (event.dataType === EventType.RelativePosition) {
+
+                if (this.oldRelativePos && this.offsetAngle
+                    && !ArCoreAbsoluteProvider.positionEquals(this.oldRelativePos, event.data)) {
+
+                    const diffPos = Vector3.subtract(event.data, this.oldRelativePos);
+                    const dist = Math.sqrt(diffPos[0] ** 2 + diffPos[2] ** 2);
+                    const bearing = Math.atan2(diffPos[0], -diffPos[2]) - this.offsetAngle;
+                    this.position = this.position.destinationPoint(dist, bearing, diffPos[1]);
+                    this.notify(this.createEvent(EventType.AbsolutePosition, this.position, event.timestamp));
+                }
+
+                this.oldRelativePos = event.data;
+            }
+        });
+    }
+
+    static positionEquals(pos1, pos2) {
+        return pos1[0] === pos2[0] && pos1[1] === pos2[1] && pos1[2] === pos2[2];
+    }
+
+    onArCoreError = arCoreErrors => {
+        this.notifyError(...(
+            ProviderError.modifyArrayDataType(arCoreErrors, EventType.AbsoluteAttitude).concat(
+                ProviderError.modifyArrayDataType(arCoreErrors, EventType.AbsolutePosition)
+            ))
+        );
+    };
+
+    onImuEvent = events => {
+        this.angularRate = events[0].data;
+    }
+
+    onImuError = imuErrors => {
+        this.notifyError(...(
+            ProviderError.modifyArrayDataType(imuErrors, EventType.AbsoluteAttitude).concat(
+                ProviderError.modifyArrayDataType(imuErrors, EventType.AbsolutePosition)
+            ))
+        );
+    }
+
+    setHeading(heading) {
+
+        if (!this.relativeAttitude) {
+            this.waitingForceHeading = heading;
+            return;
+        }
+
+        this.offsetAngle = this.relativeAttitude.heading - heading;
+        this.offsetQuat = Quaternion.fromAxisAngle([0, 0, 1], this.offsetAngle);
+    }
+
+    setPosition(position) {
+        this.position = position.clone();
+        this.position.provider = this.constructor.name;
+        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
+    }
+}
+
+export default ArCoreAbsoluteProvider;

package/src/providers/pose/ArCoreProvider.js

@@ -3,6 +3,7 @@ import { Attitude } from '@wemap/geo';
 import Provider from '../Provider';
 import EventType from '../../events/EventType';
 import MissingArCoreError from '../../errors/MissingArCoreError';
+import MissingNativeInterfaceError from '../../errors/MissingNativeInterfaceError';
 
 /**
  * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
@@ -10,14 +11,6 @@ import MissingArCoreError from '../../errors/MissingArCoreError';
  */
 class ArCoreProvider extends Provider {
 
-    /**
-    * @override
-    */
-    constructor(onEvent, onError, options) {
-        super(onEvent, onError, options);
-
-    }
-
     /**
     * @override
     */
@@ -43,12 +36,9 @@ class ArCoreProvider extends Provider {
      * @override
      */
     startInternal() {
-        const nativeProvider = this.constructor.getNativeProvider();
-        if (Array.isArray(nativeProvider)) {
-            this.notifyError(nativeProvider);
-            return;
+        if (ArCoreProvider.nativeProvider) {
+            ArCoreProvider.nativeProvider.start();
         }
-        nativeProvider.start();
 
         this.pullDataLoop();
     }
@@ -57,12 +47,9 @@ class ArCoreProvider extends Provider {
      * @override
      */
     stopInternal() {
-        const nativeProvider = this.constructor.getNativeProvider();
-        if (Array.isArray(nativeProvider)) {
-            this.notifyError(nativeProvider);
-            return;
+        if (ArCoreProvider.nativeProvider) {
+            ArCoreProvider.nativeProvider.stop();
         }
-        nativeProvider.stop();
     }
 
     pullDataLoop = () => {
@@ -71,13 +58,7 @@ class ArCoreProvider extends Provider {
             return;
         }
 
-        const nativeProvider = this.constructor.getNativeProvider();
-        if (Array.isArray(nativeProvider)) {
-            this.notifyError(...nativeProvider);
-            return;
-        }
-
-        const pose = JSON.parse(nativeProvider.getInfo());
+        const pose = JSON.parse(ArCoreProvider.nativeProvider.getInfo());
         if (pose.length !== 0) {
             const attitude = new Attitude(pose.slice(0, 4));
             const position = pose.slice(4, 7);
@@ -90,17 +71,22 @@ class ArCoreProvider extends Provider {
         requestAnimationFrame(this.pullDataLoop);
     }
 
-    static getNativeProvider() {
-        const nativeInterface = this.getNativeInterface();
+    static get nativeProvider() {
+
+        if (!this._nativeProvider) {
+
+            if (!this.nativeInterface) {
+                throw new MissingNativeInterfaceError();
+            }
+
+            this._nativeProvider = this.nativeInterface.getArCoreProvider();
+            if (!this._nativeProvider) {
+                throw new MissingArCoreError();
+            }
 
-        if (!nativeInterface) {
-            return [
-                this.createMissingNativeInterfaceError(EventType.RelativeAttitude),
-                this.createMissingNativeInterfaceError(EventType.RelativePosition)
-            ];
         }
 
-        return nativeInterface.getArCoreProvider();
+        return this._nativeProvider;
     }
 
     /**
@@ -108,19 +94,21 @@ class ArCoreProvider extends Provider {
      */
     static checkAvailabilityErrors() {
 
-        const nativeProvider = this.getNativeProvider();
-        if (Array.isArray(nativeProvider)) {
-            return nativeProvider;
-        }
+        try {
+            const nativeProvider = this.nativeProvider;
+
+            if (!nativeProvider.checkAvailability()) {
+                throw new MissingArCoreError();
+            }
 
-        if (nativeProvider.checkAvailability()) {
-            return [];
+        } catch (e) {
+            return [
+                this.createError(EventType.RelativeAttitude, e),
+                this.createError(EventType.RelativePosition, e)
+            ];
         }
 
-        return [
-            this.createError(EventType.RelativeAttitude, new MissingArCoreError()),
-            this.createError(EventType.RelativePosition, new MissingArCoreError())
-        ];
+        return [];
     }
 }
 

package/src/providers/pose/GnssWifiPdrProvider.js

@@ -84,7 +84,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
     onPdrEvent(pdrEvent) {
         pdrEvent.forEach(event => {
             if (event.dataType === EventType.AbsolutePosition) {
-                this.location = event.data;
+                this.position = event.data;
             } else if (event.dataType === EventType.AbsoluteAttitude) {
                 this.attitude = event.data;
             }
@@ -98,39 +98,39 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
     onGnssWifiEvent(events) {
 
         const gnssWifiEvent = events[0];
-        const location = gnssWifiEvent.data;
+        const position = gnssWifiEvent.data;
 
         // This should be called to update True North / Magnetic North declination
-        this.absoluteAttitudeProvider.setLocation(location);
+        this.absoluteAttitudeProvider.setPosition(position);
 
-        if (location.accuracy > GPF_ACCURACY) {
+        if (position.accuracy > GPF_ACCURACY) {
             return;
         }
 
-        this.gnssLocation = location.clone();
-        this.gnssLocation.alt = Constants.DEFAULT_ALTITUDE;
+        this.gnssPosition = position.clone();
+        this.gnssPosition.alt = Constants.DEFAULT_ALTITUDE;
 
-        if (!this.location || this.location
-            && this.location.distanceTo(this.gnssLocation) > GPF_DISTANCE) {
+        if (!this.position || this.position
+            && this.position.distanceTo(this.gnssPosition) > GPF_DISTANCE) {
 
             if (!this.mapMatching || !this.attitude) {
-                this.pdrProvider.setLocation(this.gnssLocation);
+                this.pdrProvider.setPosition(this.gnssPosition);
             } else {
 
-                this.gnssLocation.bearing = this.attitude.headingDegrees;
-                const projection = this.mapMatching.getProjection(this.gnssLocation);
+                this.gnssPosition.bearing = this.attitude.headingDegrees;
+                const projection = this.mapMatching.getProjection(this.gnssPosition);
 
                 if (projection && projection.projection) {
 
-                    // Create a new location from projection and new GNSS location.
-                    const projectedLocation = WGS84UserPosition.fromWGS84(projection.projection, this.gnssLocation);
-                    this.pdrProvider.setLocation(projectedLocation);
+                    // Create a new position from projection and new GNSS position.
+                    const projectedPosition = WGS84UserPosition.fromWGS84(projection.projection, this.gnssPosition);
+                    this.pdrProvider.setPosition(projectedPosition);
 
                     // // If nearest element is an edge, use its orientation to set heading
                     // if (projection.nearestElement instanceof Edge) {
                     //     const edgeBearing = projection.nearestElement.bearing;
-                    //     const diff1 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssLocation.bearing), edgeBearing);
-                    //     const diff2 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssLocation.bearing), edgeBearing + Math.PI);
+                    //     const diff1 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssPosition.bearing), edgeBearing);
+                    //     const diff2 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssPosition.bearing), edgeBearing + Math.PI);
                     //     this.pdrProvider.setHeading(diff1 < diff2 ? edgeBearing : edgeBearing + Math.PI);
                     // }
 
@@ -139,7 +139,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
                     }
 
                 } else {
-                    this.pdrProvider.setLocation(this.gnssLocation);
+                    this.pdrProvider.setPosition(this.gnssPosition);
                 }
             }
         }
@@ -208,9 +208,9 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
 
             // When the first itinerary is received, first or second node (depending on MM_GNSS_DIST) is used as a starting point. No map-matching is needed here as router already provide the projection in the itinerary (node2 is node1 projection on OSRM network).
 
-            if (!this.gnssLocation
+            if (!this.gnssPosition
                 || itinerary.length < 2
-                || !itinerary.points[0].equalsTo(this.gnssLocation)) {
+                || !itinerary.points[0].equalsTo(this.gnssPosition)) {
                 console.warn('Itinerary has not been calculated from GnssWifiPdrProvider and these is not recommanded');
             }
 
@@ -222,7 +222,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
             }
             const startPoint = WGS84UserPosition.fromWGS84(startEdge.node1);
             startPoint.alt = Constants.DEFAULT_ALTITUDE;
-            this.pdrProvider.setLocation(startPoint);
+            this.pdrProvider.setPosition(startPoint);
             this.pdrProvider.setStepDetectionLockerOrientation(startEdge.getBearing());
         }
 

package/src/providers/pose/PoseProvider.js

@@ -19,7 +19,7 @@ class PoseProvider extends Provider {
 
         this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(onEvent, e => this.onAbsoluteAttitudeError(e));
         this.gnssWifiProvider = new GnssWifiProvider((events) => {
-            this.absoluteAttitudeProvider.setLocation(events[0].data);
+            this.absoluteAttitudeProvider.setPosition(events[0].data);
             onEvent(events);
         }, e => this.onGnssWifiError(e));
     }