@wemap/positioning 2.7.13 → 14.0.0-0

package/src/providers/others/InclinationProvider.js

@@ -1,99 +0,0 @@
-import Provider from '../Provider';
-import EventType from '../../events/EventType';
-import ImuProvider from './ImuProvider';
-
-/**
- * Inclination provider gives the inclination of the device using Imu Sensor
- * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
- *              when the device is layed on a table, inclination = 0
- * This provider use window.orientation to return a result in function of screen orientation
- */
-class InclinationProvider extends Provider {
-
-    /**
-    * @override
-    */
-    constructor(onEvent, onError, options) {
-        super(onEvent, onError, options);
-
-        this.imuProvider = new ImuProvider(
-            this.onImuEvent,
-            onError,
-            { require: [EventType.Acceleration] }
-        );
-    }
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'Inclination';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'Inertial Measurement Unit';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Inclination];
-    }
-
-    /**
-     * @override
-     */
-    static getRequiredProviders() {
-        return [ImuProvider];
-    }
-
-    /**
-     * @override
-     */
-    startInternal() {
-        return this.imuProvider.start();
-    }
-
-    /**
-     * @override
-     */
-    stopInternal() {
-        return this.imuProvider.stop();
-    }
-
-    /**
-     * @private
-     */
-    onImuEvent = imuEvent => {
-        const accelerationEvent = imuEvent[0];
-        const acc = accelerationEvent.data;
-
-        const screenOrientation = window.orientation || 0;
-
-        const sizeAcc = Math.sqrt(acc[0] * acc[0] + acc[1] * acc[1] + acc[2] * acc[2]);
-        const accNormalized = [acc[0] / sizeAcc, acc[1] / sizeAcc, acc[2] / sizeAcc];
-
-        const q = [accNormalized[2] + 1, accNormalized[1], -accNormalized[0], 0];
-        const qSize = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2]);
-        const qNormalized = [q[0] / qSize, q[1] / qSize, q[2] / qSize, 0];
-
-        let inclination;
-        if (screenOrientation === 0) {
-            inclination = Math.asin(2 * qNormalized[1] * qNormalized[0]);
-        } else if (screenOrientation === 90) {
-            inclination = -Math.asin(2 * qNormalized[2] * qNormalized[0]);
-        } else if (screenOrientation === -90) {
-            inclination = Math.asin(2 * qNormalized[2] * qNormalized[0]);
-        } else if (screenOrientation === 180) {
-            inclination = -Math.asin(2 * qNormalized[1] * qNormalized[0]);
-        }
-
-        this.notify(this.createEvent(EventType.Inclination, inclination));
-    };
-}
-
-export default InclinationProvider;

package/src/providers/others/MapMatchingProvider.js

@@ -1,65 +0,0 @@
-import Provider from '../Provider';
-import {
-    Itinerary, MapMatching, Network
-} from '@wemap/graph';
-
-class MapMatchingProvider extends Provider {
-
-    /**
-     * Enable mapmatching
-     * @param {*} network a network which will be used for map matching
-     * @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) {
-        this.mapMatching = new MapMatching();
-        this.mapMatching.maxDistance = maxDistance;
-        this.mapMatching.maxAngleBearing = maxAngleBearing;
-
-        if (network) {
-            this.setNetwork(network);
-        }
-    }
-
-    /**
-     * Update the network for mapmatching
-     * @param {Network} network a network instance
-     * @public
-     */
-    setNetwork(network) {
-        if (!this.mapMatching) {
-            throw new Error('MapMatching is not enabled');
-        }
-        this.mapMatching.network = network;
-    }
-
-    /**
-     * Is mapmatching activated?
-     * @returns is mapmatching activated
-     * @public
-     */
-    get hasMapMatching() {
-        return this.mapMatching !== null;
-    }
-
-
-    /**
-     * Itinerary
-     */
-
-    /**
-     * 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
-     */
-    setItinerary(itinerary) {
-        if (!(itinerary instanceof Itinerary)) {
-            throw new TypeError(itinerary + ' is not an instance of Itinerary');
-        }
-        this.itinerary = itinerary;
-    }
-}
-
-export default MapMatchingProvider;

package/src/providers/pose/ArCoreAbsoluteProvider.js

@@ -1,235 +0,0 @@
-/* eslint-disable max-statements */
-import {
-    Attitude, WGS84UserPosition
-} from '@wemap/geo';
-
-import EventType from '../../events/EventType';
-import ArCoreProvider from './ArCoreProvider';
-import {
-    Quaternion, Vector3
-} from '@wemap/maths';
-import ImuProvider from '../others/ImuProvider';
-import MapMatchingProvider from '../others/MapMatchingProvider';
-import PdrProvider from './pdr/PdrProvider';
-
-const MM_ARCORE_DIST = 5;
-
-/**
- * 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 MapMatchingProvider {
-
-    /**
-    * @override
-    */
-    constructor(onEvent, onError, options) {
-        super(onEvent, onError, options);
-
-        this.arCoreProvider = new ArCoreProvider(
-            e => this.onArCoreEvent(e),
-            onError,
-            options);
-
-        this.imuProvider = new ImuProvider(
-            this.onImuEvent,
-            onError,
-            Object.assign({}, options || {}, { require: [EventType.AngularRate] })
-        );
-
-        if (this.options.useMapMatching) {
-            this.enableMapMatching();
-        }
-    }
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'ArCoreAbsolute';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'ArCore absolute provider';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
-    }
-
-    /**
-     * Return the list of required providers
-     */
-    static getRequiredProviders() {
-        return [ArCoreProvider, ImuProvider];
-    }
-
-    /**
-     * @override
-     */
-    startInternal() {
-        this.arCoreProvider.start();
-        this.imuProvider.start();
-    }
-
-    /**
-     * @override
-     */
-    stopInternal() {
-        this.arCoreProvider.stop();
-        this.imuProvider.stop();
-    }
-
-    onArCoreEvent = events => {
-
-        const eventsForNotification = [];
-
-        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);
-                    eventsForNotification.push(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]);
-
-                    if (this.absoluteAttitude) {
-                        this.position.bearing = this.absoluteAttitude.heading;
-                        this.updatePositionWithMapMatching();
-                    }
-
-                    eventsForNotification.push(this.createEvent(EventType.AbsolutePosition, this.position, event.timestamp));
-                }
-
-                this.oldRelativePos = event.data;
-            }
-
-            if (event.dataType === EventType.Barcode) {
-                eventsForNotification.push(event);
-            }
-
-            if (eventsForNotification.length !== 0) {
-                this.notify(...eventsForNotification);
-            }
-        });
-    }
-
-    static positionEquals(pos1, pos2) {
-        return pos1[0] === pos2[0] && pos1[1] === pos2[1] && pos1[2] === pos2[2];
-    }
-
-    onImuEvent = events => {
-        this.angularRate = events[0].data;
-    }
-
-    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 = WGS84UserPosition.fromWGS84(position);
-        this.position.provider = this.constructor.name;
-        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
-    }
-
-    /**
-     * @override
-     */
-    static get useCameraNatively() {
-        return true;
-    }
-
-
-    /**
-     * MapMatching
-     */
-
-    enableMapMatching(network, maxDistance, maxAngleBearing) {
-        super.enableMapMatching(
-            network,
-            maxDistance || MM_ARCORE_DIST,
-            maxAngleBearing || PdrProvider.MM_PDR_ANGLE
-        );
-    }
-
-    updatePositionWithMapMatching() {
-        if (!this.mapMatching) {
-            return;
-        }
-        const projection = this.mapMatching.getProjection(this.position, true, true);
-        if (projection) {
-            if (projection.distanceFromNearestElement > 1) {
-                this.position.lat = projection.projection.lat;
-                this.position.lng = projection.projection.lng;
-            }
-            this.position.level = projection.projection.level;
-        }
-    }
-
-    enableBarcodeScanner() {
-        this.arCoreProvider.enableBarcodeScanner();
-    }
-
-    disableBarcodeScanner() {
-        this.arCoreProvider.disableBarcodeScanner();
-    }
-}
-
-export default ArCoreAbsoluteProvider;

package/src/providers/pose/ArCoreProvider.js

@@ -1,191 +0,0 @@
-/* eslint-disable no-bitwise */
-import { Attitude } from '@wemap/geo';
-
-import Provider from '../Provider';
-import EventType from '../../events/EventType';
-import MissingArCoreError from '../../errors/MissingArCoreError';
-import MissingNativeInterfaceError from '../../errors/MissingNativeInterfaceError';
-import Availability from '../../events/Availability';
-
-
-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
-    }
-};
-
-/**
- * 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 ArCoreProvider extends Provider {
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'ArCore';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'ArCore provider';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude, EventType.RelativePosition, EventType.Barcode];
-    }
-
-    /**
-     * Return the list of required providers
-     */
-    static getRequiredProviders() {
-        return [];
-    }
-
-    /**
-     * @override
-     */
-    startInternal() {
-        if (ArCoreProvider.nativeProvider) {
-            ArCoreProvider.nativeProvider.start();
-        }
-
-        this.pullDataLoop();
-    }
-
-    /**
-     * @override
-     */
-    stopInternal() {
-        if (ArCoreProvider.nativeProvider) {
-            ArCoreProvider.nativeProvider.stop();
-        }
-    }
-
-    pullDataLoop = () => {
-
-        if (this.state !== Provider.State.STARTED) {
-            return;
-        }
-
-        const payload = JSON.parse(ArCoreProvider.nativeProvider.getInfo());
-        if (payload.length > 1) {
-            this.parsePayload(payload);
-        }
-        requestAnimationFrame(this.pullDataLoop);
-    }
-
-    parsePayload(payload) {
-
-        const ref = payload[0];
-        let bufferIndex = 1;
-
-        const events = [];
-
-        if (ref & Payload.Pose.ref) {
-            const attitude = new Attitude(payload.slice(bufferIndex, bufferIndex + 4));
-            const position = payload.slice(bufferIndex + 4, bufferIndex + 7);
-            events.push(this.createEvent(EventType.RelativeAttitude, attitude));
-            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);
-        }
-    }
-
-
-    static 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
-     */
-    static checkAvailability(options) {
-
-        const supAvailability = super.checkAvailability(options);
-        if (!supAvailability.isSupported) {
-            return supAvailability;
-        }
-
-        try {
-            const nativeProvider = this.nativeProvider;
-
-            if (!nativeProvider.checkAvailability()) {
-                return Availability.no(new MissingArCoreError());
-            }
-
-        } catch (e) {
-            return Availability.no(e);
-        }
-
-        return Availability.yes();
-    }
-
-    enableBarcodeScanner() {
-        if (ArCoreProvider.nativeProvider) {
-            ArCoreProvider.nativeProvider.enableBarcodeScanner();
-        }
-    }
-
-    disableBarcodeScanner() {
-        if (ArCoreProvider.nativeProvider) {
-            ArCoreProvider.nativeProvider.disableBarcodeScanner();
-        }
-    }
-
-    /**
-     * @override
-     */
-    static get useCameraNatively() {
-        return true;
-    }
-}
-
-export default ArCoreProvider;