@wemap/positioning 2.0.0 → 2.1.0

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

@@ -0,0 +1,80 @@
+
+// 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 = 1.5;
+const VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -1;
+
+
+class StepDetectionMinMaxPeaks {
+
+    constructor() {
+        this.slidingWindow = [];
+
+        this.lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+    }
+
+
+    compute(timestamp, linearAcc) {
+
+        if (this.lastStepTimestamp && this.lastStepTimestamp + MIN_TIME_BETWEEN_STEPS > timestamp) {
+            return false;
+        }
+
+        let maxValue = Number.MIN_SAFE_INTEGER;
+        let minValue = Number.MAX_SAFE_INTEGER;
+
+        const windowTime = WINDOW_TIME;
+        this.slidingWindow.forEach(function(item, index, object) {
+            if (item.timestamp < timestamp - windowTime) {
+                object.splice(index, 1);
+            } else {
+                maxValue = Math.max(item.verticalAcc, maxValue);
+                minValue = Math.min(item.verticalAcc, minValue);
+            }
+        });
+        this.slidingWindow.push({
+            timestamp: timestamp,
+            verticalAcc: linearAcc[2]
+        });
+
+
+        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.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
+    }
+
+}
+
+export default StepDetectionMinMaxPeaks;

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/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/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>

package/scripts/release-github.js

@@ -1,216 +0,0 @@
-const dotenv = require('dotenv');
-const fs = require('fs');
-const git = require('simple-git/promise')('.').silent(true);
-const path = require('path');
-const npm = require('npm');
-const requestp = require('request-promise');
-
-const config = require('../config.json');
-
-/**
- * Check GITHUB_TOKEN in .env file
- */
-const result = dotenv.config();
-if (result.error) {
-    console.error('.env does not exist. '
-        + 'You have to create a .env file at the root directory');
-    return;
-}
-const ENV = result.parsed;
-if (!ENV.GITHUB_TOKEN) {
-    console.error('GITHUB_TOKEN does not exist in .env file. '
-        + 'More info here: https://github.com/settings/tokens');
-    return;
-}
-
-/**
- * Github Url and Headers
- */
-
-const GITHUB_API_URL = 'https://api.github.com';
-const GITHUB_UPLOAD_URL = 'https://uploads.github.com';
-
-const HEADERS = {
-    'Authorization': 'token ' + ENV.GITHUB_TOKEN,
-    'User-Agent': 'NodeJS/Release-' + config.githubRepoName
-};
-
-function checkGithubToken() {
-
-    const uri = GITHUB_API_URL;
-    const headers = HEADERS;
-
-    return requestp({
-        method: 'GET',
-        uri,
-        headers,
-        json: true
-    }).catch(e => {
-        return Promise.reject(e.message);
-    });
-}
-
-function createRelease(version) {
-
-    const uri = GITHUB_API_URL + '/repos/' + config.githubRepoOwner + '/'
-        + config.githubRepoName + '/releases';
-    const headers = Object.assign({ 'Content-Type': 'application/json' }, HEADERS);
-    const inputData = {
-        'tag_name': version,
-        'target_commitish': 'master',
-        'name': version
-    };
-
-    return requestp({
-        method: 'POST',
-        uri,
-        headers,
-        body: inputData,
-        json: true
-    }).catch(e => {
-        return Promise.reject(e.message);
-    });
-}
-
-
-function uploadFile(releaseId, fileName, filePath) {
-
-    const stats = fs.statSync(filePath);
-    const fileSizeInBytes = stats.size;
-
-    const uri = GITHUB_UPLOAD_URL + '/repos/' + config.githubRepoOwner + '/'
-        + config.githubRepoName + '/releases/' + releaseId
-        + '/assets?name=' + fileName;
-
-    const headers = Object.assign({
-        'Content-Type': 'application/javascript',
-        'Content-length': fileSizeInBytes
-    }, HEADERS);
-
-    return requestp({
-        method: 'POST',
-        uri,
-        headers,
-        body: fs.createReadStream(filePath)
-    }).catch(e => {
-        return e.message;
-    });
-}
-
-function revertNpmVersion() {
-    return git.reset(['--hard', 'HEAD^1'])
-        .then(() => git.tag(['-d', 'v1.1.0']))
-        .catch(err => console.error(err));
-}
-
-const npmLoaderPromise = new Promise((resolve, reject) => {
-    npm.load(err => {
-        if (err) {
-            reject(err);
-        } else {
-            resolve();
-        }
-    });
-});
-
-
-function main() {
-
-    const versionsList = ['minor', 'major', 'patch'];
-
-    let isVersionCreated = false;
-    const isPushed = false;
-
-    Promise.resolve()
-        // Check github token as soon as possible to avoid to revert a push
-        .then(checkGithubToken)
-
-        // Check if current branch name corresponds to "releaseBranch"
-        .then(async () => {
-            const res = await git.raw(['rev-parse', '--abbrev-ref', 'HEAD']);
-            if (res.trim() !== config.releaseBranch) {
-                return Promise.reject('You are not on the ' + config.releaseBranch + ' branch');
-            }
-            return Promise.resolve();
-        })
-
-        // Check if git repo is clean before running npm version
-        .then(async () => {
-            const res = await git.raw(['status', '--porcelain']);
-            if (res) {
-                return Promise.reject('Your git working directory not clean');
-            }
-            return Promise.resolve();
-        })
-
-        // Update npm version with npm version argv[2]
-        .then(async () => {
-            const args = process.argv;
-            if (args.length < 3) {
-                throw new Error('version argument is missing');
-            }
-            if (!versionsList.includes(args[2])) {
-                throw new Error('version argument is unknown, it should be: ' + versionsList.join(','));
-            }
-
-            await npmLoaderPromise;
-            return new Promise((resolve, reject) => {
-                npm.commands.version([args[2]], err => {
-                    if (err) {
-                        reject(err);
-                    } else {
-                        isVersionCreated = true;
-                        resolve();
-                    }
-                });
-            });
-        })
-
-        // Build the project in production mode
-        .then(async () => {
-            await npmLoaderPromise;
-            return new Promise((resolve, reject) => {
-                npm.commands.run(['build'], err => {
-                    if (err) {
-                        reject(err);
-                    } else {
-                        resolve();
-                    }
-                });
-            });
-        })
-
-        // Push release to origin
-        .then(() => git.push('origin', config.releaseBranch, ['--tags']))
-
-        // Get tag name
-        .then(async () => {
-            const res = await git.raw(['describe']);
-            // TODO this condition can be improved
-            if (!res || res[0] !== 'v') {
-                return Promise.reject('Could not find tag name');
-            }
-            return Promise.resolve(res.trim());
-        })
-
-        // Create the release
-        .then((tagName) => createRelease(tagName))
-
-        // Upload file
-        .then(response => {
-            const filePath = path.join(config.distFolder, config.distFileName);
-            uploadFile(response.id, config.distFileName, filePath);
-        })
-
-        .then(() => {
-            console.log('Release finished with success');
-        })
-        .catch(e => {
-            if (isVersionCreated && !isPushed) {
-                revertNpmVersion();
-            }
-            console.error('error', e);
-        });
-}
-
-main();