@wemap/positioning 1.2.2 → 2.1.0

package/src/providers/pose/pdr/steps/StepDetectionMinMaxPeaks2.js

@@ -0,0 +1,108 @@
+
+// in seconds
+const WINDOW_TIME = 0.3;
+
+// in seconds
+const MIN_TIME_BETWEEN_STEPS = 0.4;
+
+// in Hz
+const MAX_FRENQUENCY = 4;
+const MIN_FRENQUENCY = 1;
+
+// in m.s-2
+const VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.75;
+const VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.3;
+
+
+class StepDetectionMinMaxPeaks2 {
+
+    constructor() {
+        this.slidingWindow = [];
+
+        this.lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+        this.previousVerticalAcc = 0;
+        this.influence = 0.2;
+    }
+
+
+    compute(timestamp, linearAcc, angularRate) {
+
+        const verticalAcc = this.influence * (linearAcc[2] * 2) + (1 - this.influence) * this.previousVerticalAcc;
+        this.previousVerticalAcc = verticalAcc;
+
+
+        if (Math.sqrt(angularRate[0] ** 2 + angularRate[1] ** 2 + angularRate[2] ** 2) > 0.75) {
+            return false;
+        }
+
+        if (this.lastStepTimestamp && this.lastStepTimestamp + MIN_TIME_BETWEEN_STEPS > timestamp) {
+            return false;
+        }
+
+        let maxValue = Number.MIN_SAFE_INTEGER;
+        let minValue = Number.MAX_SAFE_INTEGER;
+
+        this.slidingWindow.forEach(function(item, index, object) {
+            if (item.timestamp < timestamp - WINDOW_TIME) {
+                object.splice(index, 1);
+            } else {
+                maxValue = Math.max(item.verticalAcc, maxValue);
+                minValue = Math.min(item.verticalAcc, minValue);
+            }
+        });
+        this.slidingWindow.push({
+            timestamp: timestamp,
+            verticalAcc: verticalAcc
+        });
+
+
+        if (maxValue > VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
+            && minValue < VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+
+            const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
+            this.frequency = Math.min(Math.max((1 / timeInterval), MIN_FRENQUENCY), MAX_FRENQUENCY);
+
+            this.lastStepTimestamp = timestamp;
+            return true;
+        }
+
+        return false;
+    }
+
+    get lastStepSize() {
+
+        if (!this.frequency) {
+            return 0;
+        }
+
+        const kParamA = 0.45;
+        const kParamB = 0.2;
+        return kParamA + kParamB * this.frequency;
+    }
+
+    get speed() {
+        return this.lastStepSize && this.frequency ? this.lastStepSize * this.frequency : 0;
+    }
+
+    mean(data) {
+        let sum = 0.0, mean = 0.0;
+
+        for (let i = 0; i < data.length; ++i) {
+            sum += data[i].verticalAcc;
+        }
+        mean = sum / data.length;
+        return mean;
+    }
+
+    stddev(data) {
+        const theMean = this.mean(data);
+        let standardDeviation = 0;
+        for (let i = 0; i < data.length; ++i) {
+            standardDeviation += (data[i].verticalAcc - theMean) ** 2;
+        }
+
+        return Math.sqrt(standardDeviation / data.length);
+    }
+}
+
+export default StepDetectionMinMaxPeaks2;

package/src/providers/position/GnssWifiProvider.js

@@ -0,0 +1,129 @@
+import { deg2rad } from '@wemap/maths';
+import { WGS84UserPosition } from '@wemap/geo';
+import { DateUtils } 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';
+
+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
+     */
+    static checkAvailabilityErrors() {
+
+        if (navigator && navigator.geolocation) {
+            return [];
+        }
+
+        return [
+            GnssWifiProvider.createError(
+                EventType.AbsolutePosition,
+                new GeolocationApiMissingError()
+            )
+        ];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+
+        this.geoLocationId = navigator.geolocation.watchPosition(
+            this.onNewPosition,
+            this.onPositionError,
+            POSITION_OPTIONS
+        );
+
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+
+        navigator.geolocation.clearWatch(this.geoLocationId);
+
+    }
+
+    /**
+     * @private
+     */
+    onNewPosition = position => {
+        const { coords } = position;
+        if (!coords) {
+            return;
+        }
+
+        let bearing;
+        if (coords.heading) {
+            bearing = deg2rad(coords.heading);
+        }
+
+        const timestamp = DateUtils.unixTimestampToPerformanceNow(position.timestamp) / 1e3;
+
+        const location = new WGS84UserPosition(
+            coords.latitude,
+            coords.longitude,
+            coords.altitude,
+            timestamp,
+            coords.accuracy,
+            bearing,
+            GnssWifiProvider.name);
+
+        this.notify(this.createEvent(
+            EventType.AbsolutePosition, location, timestamp
+        ));
+
+    };
+
+    onPositionError = error => {
+
+        let customError;
+        switch (error.code) {
+        case 1:
+            customError = new GeolocationPermissionDeniedError(error.message);
+            break;
+        case 2:
+            customError = new GeolocationPositionUnavailableError(error.message);
+        }
+
+        if (customError) {
+            this.notifyError(this.createError(
+                EventType.AbsolutePosition,
+                customError
+            ));
+        }
+    };
+}
+
+export default GnssWifiProvider;

package/src/providers/position/IpProvider.js

@@ -0,0 +1,75 @@
+import { WGS84UserPosition } from '@wemap/geo';
+
+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 GnssWifiProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'IP from ipinfo.io';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+        return [];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+
+        fetch('https://ipinfo.io/geo?token=24a7ca2f3b489d')
+            .then((response) => {
+                if (!response) {
+                    this.notifyError(this.createError(
+                        EventType.AbsolutePosition,
+                        new IpResolveServerError()
+                    ));
+                    return;
+                }
+
+                const timestamp = performance.now() / 1e3;
+
+                const position = new WGS84UserPosition(
+                    parseFloat(response.loc.split(',')[0]),
+                    parseFloat(response.loc.split(',')[1]),
+                    null,
+                    timestamp
+                );
+
+                this.notify(this.createEvent(
+                    EventType.AbsolutePosition, position, timestamp
+                ));
+            });
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+
+    }
+
+}
+
+export default GnssWifiProvider;

package/src.old/components/Utils.js

@@ -0,0 +1,35 @@
+import React from 'react'; // eslint-disable-line no-unused-vars
+
+class Utils {
+
+    static renderAttitude(attitude) {
+
+        if (!attitude) {
+            return <p>Waiting</p>;
+        }
+
+        if (attitude === -1) {
+            return <p>Not available</p>;
+        }
+
+        const quaternion = attitude.quaternion;
+
+        const w = quaternion[0].toFixed(3);
+        const x = quaternion[1].toFixed(3);
+        const y = quaternion[2].toFixed(3);
+        const z = quaternion[3].toFixed(3);
+
+        const euler = attitude.eulerAnglesDegrees;
+        const yaw = euler[0].toFixed(2);
+        const pitch = euler[1].toFixed(2);
+        const roll = euler[2].toFixed(2);
+        const heading = attitude.headingDegrees.toFixed(2);
+
+        return <p>Quaternion: [{w}, {x}, {y}, {z}]<br />
+            Eulers: [{yaw}, {pitch}, {roll}]<br />
+            Heading: {heading}</p>;
+    }
+
+}
+
+export default Utils;

package/src.old/components/index.js

@@ -0,0 +1,13 @@
+import NavigationDebugApp from './NavigationDebugApp';
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+const createReactElement = (component, container) => ReactDOM.render(
+    React.createElement(component, {}, null),
+    container
+);
+
+export {
+    NavigationDebugApp,
+    createReactElement
+};

package/src.old/index.js

@@ -0,0 +1,7 @@
+import AttitudeHandler from './attitude/AttitudeHandler';
+import NavigationHandler from './NavigationHandler';
+
+export {
+    AttitudeHandler,
+    NavigationHandler
+};

package/{src → src.old}/providers/GnssPdrLocationSource.js

@@ -132,7 +132,7 @@ class GnssPdrLocationSource extends LocationSource {
      * MapMatching
      */
 
-    enableMapMatching(network = null, maxDistance = MM_GNSS_DIST, maxAngleBearing = MM_GNSS_ANGLE) {
+    enableMapMatching(network, maxDistance = MM_GNSS_DIST, maxAngleBearing = MM_GNSS_ANGLE) {
         this.pdrLocationSource.enableMapMatching(network, maxDistance, maxAngleBearing);
         super.enableMapMatching(network, maxDistance, maxAngleBearing);
     }

package/src.old/providers/ProvidersLogger.js

@@ -0,0 +1,77 @@
+import Logger from '@wemap/logger';
+
+let currentId = 0;
+const objectsIdMap = new WeakMap();
+
+let pushEvents = {};
+let pushEventsRef = {};
+
+let interval;
+let initDate;
+
+class ProvidersLogger {
+
+    static initializeInterval() {
+
+        if (interval) {
+            return;
+        }
+
+        interval = setInterval(() => {
+
+            for (const [key, value] of Object.entries(pushEvents)) {
+                Logger.debug('Received ' + value + ' values from ' + pushEventsRef[key].constructor.name + ' last second');
+            }
+
+            pushEvents = {};
+            pushEventsRef = {};
+        }, 1000);
+    }
+
+    static getObjectId(object) {
+        if (!objectsIdMap.has(object)) {
+            objectsIdMap.set(object, ++currentId);
+        }
+        return objectsIdMap.get(object);
+    }
+
+    static addEvent(object, method) {
+
+        if (!ProvidersLogger.enabled) {
+            return;
+        }
+
+        if (!initDate) {
+            initDate = Date.now();
+        }
+
+        ProvidersLogger.initializeInterval();
+
+        const objectId = ProvidersLogger.getObjectId(object);
+        const objectClassName = object.constructor.name;
+
+        Logger.debug(objectClassName + '[' + objectId + '].' + method);
+    }
+
+    static addPushEvent(object) {
+
+        if (!ProvidersLogger.enabled) {
+            return;
+        }
+
+        const objectId = ProvidersLogger.getObjectId(object);
+
+        let counter = pushEvents[objectId];
+        if (!counter) {
+            counter = 0;
+            pushEventsRef[objectId] = object;
+        }
+        pushEvents[objectId] = counter + 1;
+    }
+
+    static get enabled() {
+        return Logger.LOG_LEVEL === Logger.DEBUG;
+    }
+
+}
+export default ProvidersLogger;

package/webpack/webpack.dev.js

@@ -7,7 +7,7 @@ const debugFolder = path.join(__dirname, '../debug');
 
 module.exports = merge(common, {
     mode: 'development',
-    entry: { 'navigation-components': './src/components/index.js' },
+    entry: { 'positioning-components': './src/components/index.js' },
     output: {
         publicPath: '/js/',
         filename: '[name].js',

package/debug/index.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-  <meta charset="utf-8">
-  <title>Debug navigation</title>
-  <script src="/js/navigation-components.js"></script>
-</head>
-
-<body>
-  <div id="app"></div>
-  <script>createReactElement(NavigationDebugApp, document.getElementById('app'));</script>
-</body>
-
-</html>

package/debug/index.old.html

@@ -1,37 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-    <meta charset="utf-8">
-
-    <title>Positioning</title>
-
-    <script src="/js/navigation.js"></script>
-
-</head>
-
-<body>
-    Hello world !
-
-    <script>
-        const navHandler = new NavigationHandler(pose => console.log(pose));
-
-        navHandler.startIfNecessary()
-            .then(() => {
-                console.log('Navigation started');
-            });
-
-        setTimeout(() => {
-            navHandler.startIfNecessary();
-        }, 3000);
-
-        setTimeout(() => {
-            navHandler.stop()
-                .then(() => {
-                    console.log('Navigation stopped');
-                });
-        }, 5000);
-    </script>
-</body>
-
-</html>