@wemap/providers 12.10.8 → 12.10.9

package/src/providers/vision/vps/VpsProvider.ts

@@ -1,251 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-import { SharedCameras, Camera } from '@wemap/camera';
-import { Attitude } from '@wemap/geo';
-import Logger from '@wemap/logger';
-import { Quaternion, deg2rad } from '@wemap/maths';
-import { TimeUtils } from '@wemap/utils';
-
-import Provider from '../../Provider.js';
-import Inclination from '../../inclination/InclinationProvider.js';
-import ImageRelocalization from './ImageRelocalization.js';
-import AbsoluteAttitudeProvider from '../../attitude/absolute/AbsoluteAttitudeProvider.js';
-import RelativeRotationCalc from './RelativeRotationCalc.js';
-import GnssWifiProvider from '../../position/absolute/GnssWifiProvider.js';
-import AbsolutePositionProvider from '../../position/absolute/AbsolutePositionProvider.js';
-import PoleStarProvider from '../../position/absolute/PoleStarProvider.js';
-import { AbsoluteAttitude, AbsolutePosition } from '../../../events/Types.js';
-import { CoarsePose } from './VpsMetadata.js';
-
-export type VpsEvent = { absoluteAttitude: AbsoluteAttitude, absolutePosition: AbsolutePosition };
-class VpsProvider extends Provider<VpsEvent> {
-
-    static MIN_TIME_BETWEEN_TWO_REQUESTS = 1000; // in ms
-    static DEFAULT_MIN_INCLINATION_FOR_REQUEST = deg2rad(60); // in radians
-    static DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST = 200; // in ms
-    static DEFAULT_USE_COARSE_POSE = true;
-    static CAMERA_TO_SMARTPHONE_ROT = Quaternion.fromAxisAngle([1, 0, 0], Math.PI);
-
-    _relativeRotationCalc?: RelativeRotationCalc;
-
-    _serverError = false;
-    _cameraError = false;
-
-    _camera: Camera | null = null;
-    _endpoint: string | null = null;
-
-    _inclinationProviderId?: number;
-
-    _minInclinationForRequest = VpsProvider.DEFAULT_MIN_INCLINATION_FOR_REQUEST;
-    _waitTimeMinInclinationForRequest = VpsProvider.DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST;
-    _useCoarsePose = VpsProvider.DEFAULT_USE_COARSE_POSE;
-
-    getName = () => 'Vps';
-
-    availability = () => Camera.checkAvailability();
-
-    start() {
-
-        // 1. Inclination
-        this._inclinationProviderId = Inclination.addEventListener();
-
-        // 2. Relative Rotation Calc
-        this._relativeRotationCalc = new RelativeRotationCalc();
-
-        // 3. Add listeners on shared cameras to detect new cameras
-        SharedCameras.on('added', this._onCameraDetected);
-        SharedCameras.on('removed', this._onCameraRemoved);
-
-        // 4. If a camera already exists, use it
-        if (SharedCameras.list.length) {
-            if (SharedCameras.list.length > 1) {
-                Logger.warn('It seems that more than 1 camera has been detected'
-                    + ' for VPS. Taking the first...');
-            }
-            this._useCamera(SharedCameras.list[0].camera);
-        }
-    }
-
-    stop() {
-
-        Inclination.removeEventListener(this._inclinationProviderId);
-
-        this._relativeRotationCalc?.release();
-
-        SharedCameras.off('added', this._onCameraDetected);
-        SharedCameras.off('removed', this._onCameraRemoved);
-
-        this._camera = null;
-    }
-
-    _onCameraDetected = ({ camera }: { camera: Camera }) => {
-        if (this._camera) {
-            Logger.warn('It seems that more than 1 camera has been detected'
-                + ' for VPS. Taking the first...');
-        }
-        this._useCamera(camera);
-    }
-
-    _onCameraRemoved = () => {
-        if (this._camera) {
-            this._camera.off('started', this._internalStart);
-            this._camera.off('stopped', this._internalStop);
-        } else {
-            Logger.warn('There is no previously detected camera but once has stopped');
-        }
-        this._camera = null;
-    }
-
-    _useCamera(camera: Camera) {
-        this._camera = camera;
-
-        camera.on('started', this._internalStart);
-        camera.on('stopped', this._internalStop);
-
-        if (camera.state === 'started') {
-            this._internalStart();
-        }
-    }
-
-
-    _internalStart = async () => {
-
-        if (!this._endpoint) {
-            this.notifyError(new Error('VPS endpoint has not been set before calling start()'));
-            return;
-        }
-
-        let lastRequestTime = null;
-        const isProviderStopped = () => this.state === 'stopped';
-        while (!isProviderStopped()) {
-
-            // 1. Handle the time to wait between two requests (MIN_TIME_BETWEEN_TWO_REQUESTS)
-            if (lastRequestTime !== null) {
-                const diffTime = TimeUtils.preciseTime() - lastRequestTime;
-                const timeToWait = Math.max(0, VpsProvider.MIN_TIME_BETWEEN_TWO_REQUESTS - diffTime);
-                await new Promise(resolve => setTimeout(resolve, timeToWait));
-            }
-            lastRequestTime = TimeUtils.preciseTime();
-
-            // 2. Check if Vps is not stopped and camera is still started
-            if (isProviderStopped()
-                || !this._camera
-                || this._camera.state !== 'started') {
-                break;
-            }
-
-            // 2.a. Do not send an image if smartphone looks at the floor
-            const inclination = Inclination.lastEvent ? Inclination.lastEvent : null;
-            if (inclination !== null
-                && inclination < this._minInclinationForRequest) {
-                await new Promise(resolve => setTimeout(resolve, this._waitTimeMinInclinationForRequest));
-                continue;
-            }
-
-            // 3. Get current image from camera and relocalize it.
-
-            // 3.a. Get current image and time it.
-            this._relativeRotationCalc?.tickStart();
-            const image = await this._camera.currentImage;
-            if (!image) {
-                continue;
-            }
-
-            // 3.b. Retrieve coarse position if necessary.
-            let coarsePose: CoarsePose | null = null;
-            const bestCoarsePosition = AbsolutePositionProvider.getBestPositionEvent(GnssWifiProvider.lastEvent, PoleStarProvider.lastEvent);
-            if (this._useCoarsePose && (bestCoarsePosition || AbsoluteAttitudeProvider.lastEvent)) {
-                coarsePose = {
-                    ...(bestCoarsePosition && {position: bestCoarsePosition}),
-                    ...(AbsoluteAttitudeProvider.lastEvent && {attitude: AbsoluteAttitudeProvider.lastEvent})
-                };
-            }
-
-            // 3.c. Send image and metadata.
-            const res = await ImageRelocalization.relocalize(this._endpoint, image, null, coarsePose);
-            if (!res || !res.success) {
-                continue;
-            }
-
-            // 4. If relocalization is successful, apply the transforms
-            const enuToCameraRot = res.attitude!.quaternion;
-            const enuToSmartphoneRot = Quaternion.multiply(
-                enuToCameraRot,
-                VpsProvider.CAMERA_TO_SMARTPHONE_ROT
-            );
-
-            const deviceQuaternion = Quaternion.multiply(
-                Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)),
-                enuToSmartphoneRot
-            );
-
-            const diffAttitude = this._relativeRotationCalc?.tickEnd() || new Attitude([1, 0, 0, 0]);
-            const deviceQuaternionWithRelOffset = Quaternion.multiply(
-                deviceQuaternion,
-                diffAttitude.quaternion
-            );
-            const attitude = new AbsoluteAttitude(
-                deviceQuaternionWithRelOffset,
-                res.attitude!.time,
-                res.attitude!.accuracy
-            );
-
-            // [16/06/22] Force VPS accuracy to 5m if the information does not exist
-            // this allows to correctly fuse positions from different providers (VPS,
-            // GnssWifi, Pole Star...)
-            const devicePosition = res.position!.clone();
-            if (devicePosition.accuracy === null) {
-                devicePosition.accuracy = 5;
-            }
-
-            // 5. Finally, notify the listeners if the VPS is not stopped
-            if (isProviderStopped()) {
-                break;
-            }
-
-            this.notify({
-                absoluteAttitude: attitude,
-                absolutePosition: devicePosition
-            });
-
-        }
-    }
-
-    _internalStop = () => {
-        // do nothing
-    }
-
-    get endpoint() {
-        return this._endpoint;
-    }
-
-    set endpoint(endpoint) {
-        this._endpoint = endpoint;
-    }
-
-    get minInclinationForRequest() {
-        return this._minInclinationForRequest;
-    }
-
-    set minInclinationForRequest(minInclinationForRequest) {
-        this._minInclinationForRequest = minInclinationForRequest;
-    }
-
-    get waitTimeMinInclinationForRequest() {
-        return this._waitTimeMinInclinationForRequest;
-    }
-
-    set waitTimeMinInclinationForRequest(waitTimeMinInclinationForRequest) {
-        this._waitTimeMinInclinationForRequest = waitTimeMinInclinationForRequest;
-    }
-
-    get useCoarsePose() {
-        return this._useCoarsePose;
-    }
-
-    set useCoarsePose(useCoarsePose) {
-        this._useCoarsePose = useCoarsePose;
-    }
-}
-
-export default new VpsProvider();

package/src/providers/vision/vps/VpsRequest.ts

@@ -1,29 +0,0 @@
-import { canvasToBase64, base64ToCanvas } from '@wemap/camera';
-
-import VpsMetadata, { VpsMetadataJson } from './VpsMetadata.js';
-
-export type VpsRequestJson = VpsMetadataJson & {
-    image: string
-}
-
-class VpsRequest {
-
-    constructor(public metadata: VpsMetadata, public image: HTMLCanvasElement) {}
-
-    toJson() {
-        const base64Image = canvasToBase64(this.image);
-        return {
-            image: base64Image,
-            ...this.metadata.toJson()
-        };
-    }
-
-    static fromJson(json: VpsRequestJson) {
-        return new VpsRequest(
-            VpsMetadata.fromJson(json),
-            base64ToCanvas(json.image)
-        );
-    }
-}
-
-export default VpsRequest;

package/src/providers/vision/vps/VpsResponse.ts

@@ -1,43 +0,0 @@
-import { Attitude, AttitudeJson, UserPosition, UserPositionJson } from '@wemap/geo';
-
-export type VpsResponseJson = {
-    success: boolean,
-    attitude?: AttitudeJson,
-    position?: UserPositionJson
-}
-
-class VpsResponse {
-
-    constructor(
-        public success: boolean,
-        public attitude: Attitude | null = null,
-        public position: UserPosition | null = null
-    ) { }
-
-    toJson(): VpsResponseJson {
-        return {
-            success: this.success,
-            attitude: this.attitude?.toJson(),
-            position: this.position?.toJson()
-        }
-    }
-
-    static fromJson(json: VpsResponseJson, imageRecordTime: number | null = null) {
-
-        let attitude: Attitude | null = null;
-        if (json.attitude) {
-            attitude = Attitude.fromJson(json.attitude);
-            attitude.time = imageRecordTime;
-        }
-
-        let position: UserPosition | null = null;
-        if (json.position) {
-            position = UserPosition.fromJson(json.position);
-            position.time = imageRecordTime;
-        }
-
-        return new VpsResponse(json.success, attitude, position);
-    }
-}
-
-export default VpsResponse;

package/src/providers/vision/vps/VpsSchema.json

@@ -1,90 +0,0 @@
-{
-    "$schema": "http://json-schema.org/schema#",
-    "title": "JSON SCHEMA for Visual Positioning Service (VPS)",
-    "$comment": "Helped from https://github.com/OpenArCloud/oscp-geopose-protocol",
-    "type": "object",
-    "required": ["imageBytes", "size"],
-    "properties": {
-        "imageBytes": {
-            "$comment": "base64 image",
-            "type": "string",
-            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
-        },
-        "cameraParams": {
-            "type": "object",
-            "properties": {
-                "intrinsic": {
-                    "$comment": "[fx, s, cx, 0, fy, cy, 0, 0, 1] (row-major)",
-                    "type": "array",
-                    "minLength": 9,
-                    "maxLength": 9
-                },
-                "distortions": {
-                    "$comment": "[k1, k2, p1, p2, k3]",
-                    "type": "array",
-                    "minLength": 5,
-                    "maxLength": 5
-                }
-            }
-        },
-        "imageFormat": {
-            "type": "string",
-            "enum": [
-                "RGBA32",
-                "GRAY8"
-            ]
-        },
-        "size": {
-            "$comment": "[width, height] (in pixels)",
-            "type": "array",
-            "minLength": 2,
-            "maxLength": 2
-        },
-        "coarseLocation": {
-            "type": "object",
-            "required": ["latitude", "longitude"],
-            "properties": {
-                "latitude": {
-                    "type": "number"
-                },
-                "longitude": {
-                    "type": "number"
-                },
-                "altitude": {
-                    "type": "number"
-                },
-                "level": {
-                    "$comment": "OpenStreetMap level",
-                    "type": "number",
-                    "multipleOf": 1
-                }
-            }
-        },
-        "coarseAttitude": {
-            "type": "object",
-            "required": ["w", "x", "y", "z"],
-            "properties": {
-                "w": {
-                    "type": "number",
-                    "minimum": -1,
-                    "maximum": 1
-                },
-                "x": {
-                    "type": "number",
-                    "minimum": -1,
-                    "maximum": 1
-                },
-                "y": {
-                    "type": "number",
-                    "minimum": -1,
-                    "maximum": 1
-                },
-                "z": {
-                    "type": "number",
-                    "minimum": -1,
-                    "maximum": 1
-                }
-            }
-        }
-    }
-}

package/src/smoothers/AttitudeSmoother.ts

@@ -1,110 +0,0 @@
-import { Attitude } from '@wemap/geo';
-import { deg2rad, diffAngle, Quaternion } from '@wemap/maths';
-
-class AttitudeSmoother {
-
-    static ROTATION_SPEED_JUMP_THRESHOLD = deg2rad(180); // in radians/s
-    static ROTATION_SPEED_CONVERGENCE = deg2rad(10); // in radians/s
-    static HIGH_JUMP_THRESHOLD = deg2rad(20); // in radians/s
-    static ROTATION_SPEED_HIGH_JUMP_CONVERGENCE = deg2rad(100); // in radians/s
-    static PITCH_UNCERTAINITY_HEADING_THRESHOLD = deg2rad(5); // in radians/s
-
-    _previousAttitude?: Attitude;
-
-    _smoothing : null | {
-        interpAttitude(attitude: Attitude): Attitude,
-        toTime: number
-    } = null;
-
-    constructor(public callback: (attitude: Attitude) => void) {}
-
-    feed(newAttitude: Attitude) {
-
-        if (newAttitude.time === null) {
-            throw new Error('newAttitude does not have time property');
-        }
-
-        const { _previousAttitude: previousAttitude } = this;
-        this._previousAttitude = newAttitude;
-
-        if (!previousAttitude) {
-            this.callback(newAttitude);
-            return;
-        }
-
-        /*
-         * Comparison between two successive Attitude from the "feed" function
-         */
-        if (AttitudeSmoother.isJump(previousAttitude, newAttitude)) {
-
-            const fromAttitude = this._smoothing === null
-                ? previousAttitude
-                : this._smoothing.interpAttitude(previousAttitude);
-
-            const fromHeading = fromAttitude.heading;
-            const toHeading = newAttitude.heading;
-            const diffAngleHeading = diffAngle(toHeading, fromHeading);
-
-            const isHighJump = Math.abs(diffAngleHeading) < AttitudeSmoother.HIGH_JUMP_THRESHOLD;
-            const rotationSpeedConvergence = isHighJump
-                ? AttitudeSmoother.ROTATION_SPEED_CONVERGENCE
-                : AttitudeSmoother.ROTATION_SPEED_HIGH_JUMP_CONVERGENCE;
-
-            const fromTime = fromAttitude.time!;
-            const timeToConsume = Math.abs(diffAngleHeading) / rotationSpeedConvergence;
-            const multiplier = diffAngleHeading < 0 ? -1 : 1;
-
-            this._smoothing = {
-                toTime: fromTime + timeToConsume,
-
-                interpAttitude: (attitude: Attitude) => {
-                    const angle = rotationSpeedConvergence * (attitude.time! - fromTime);
-                    const interpHeading = fromHeading + angle * multiplier;
-                    const offsetQuat = Quaternion.fromAxisAngle([0, 0, 1], toHeading - interpHeading);
-                    const interpQuat = Quaternion.multiply(offsetQuat, attitude.quaternion);
-                    return new Attitude(interpQuat, attitude.time, attitude.accuracy);
-                }
-            };
-        }
-
-        if (this._smoothing !== null) {
-            if (newAttitude.time >= this._smoothing.toTime) {
-                // This means that is the last epoch for smoothing
-                this._smoothing = null;
-            } else {
-                const interpAttitude = this._smoothing.interpAttitude(newAttitude);
-                this.callback(interpAttitude);
-                return;
-            }
-        }
-
-        this.callback(newAttitude);
-    }
-
-    /**
-     * @param {Attitude} previousAttitude
-     * @param {Attitude} newAttitude
-     * @returns {boolean}
-     */
-    static isJump(previousAttitude: Attitude, newAttitude: Attitude) {
-        const fromHeading = previousAttitude.heading;
-        const toHeading = newAttitude.heading;
-        const diffAngleHeading = diffAngle(toHeading, fromHeading);
-        const diffTime = newAttitude.time! - previousAttitude.time!;
-
-        /**
-         * Heading is calculated from two different formulas in function of the pitch angle.
-         * Do not consider a jump if attitude is close to the change of the methods
-         * @see MathsRotations#getHeadingFromQuaternion()
-         */
-        const [qw, qx, qy, qz] = newAttitude.quaternion;
-        const distToPitchThreshold = Math.abs(Math.asin(2 * (qw * qx + qy * qz)) - Math.PI / 4);
-        if (distToPitchThreshold < AttitudeSmoother.PITCH_UNCERTAINITY_HEADING_THRESHOLD) {
-            return false;
-        }
-
-        return Math.abs(diffAngleHeading) > AttitudeSmoother.ROTATION_SPEED_JUMP_THRESHOLD * diffTime;
-    }
-}
-
-export default AttitudeSmoother;

package/src/smoothers/PositionSmoother.spec.ts

@@ -1,53 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-
-import {
-    Constants as GeoConstants, Coordinates, UserPosition
-} from '@wemap/geo';
-
-import Smoother from './PositionSmoother.js';
-
-
-const expect = chai.expect;
-chai.use(chaiAlmost(GeoConstants.EPS_MM));
-
-const positions = [
-    [0, 0, 0, 0],
-    [0.2, 4.5E-6, 1.7E-6, 0],
-    [1.3, 3.6E-5, 3.6E-5, 1],
-    [1.7, 4.0E-5, 3.6E-5, 0],
-    [3.5, 4.0E-5, 3.0E-5, 0],
-    [4, 3.4E-5, 9.0E-6, 0]
-];
-
-const createPosition = (i: number) => new UserPosition(positions[i][1], positions[i][2], null, null, positions[i][0]);
-
-const ratio = 1e-1;
-
-const reducePositionTime = () => positions.forEach(pos => (pos[0] *= ratio));
-
-
-describe('PositionSmoother', () => {
-
-    it('Last position reached', done => {
-
-        reducePositionTime();
-
-        const lastPosition = createPosition(positions.length - 1);
-        const smoother = new Smoother(position => {
-            if (Coordinates.equals(position, lastPosition)) {
-                done();
-            }
-        }, 60 / ratio);
-
-        positions.forEach((pos, index) => {
-            setTimeout(() => smoother.feed(createPosition(index), ratio), pos[0] * 1e3);
-        });
-    });
-
-    it('Errors', () => {
-        const smoother = new Smoother();
-        expect(() => smoother.feed(new UserPosition(0, 0))).throw(Error);
-    });
-
-});

package/src/smoothers/PositionSmoother.ts

@@ -1,96 +0,0 @@
-import { Level, UserPosition } from '@wemap/geo';
-
-class PositionSmoother {
-
-    // Generated positions by second
-    static DEFAULT_FREQUENCY = 60;
-
-    // flyby (in second)
-    static DEFAULT_FLYBY_TIME = 1;
-
-    positionsQueue: UserPosition[] = [];
-    previousPosition: UserPosition | null = null;
-    timeoutNotify?: any; // can be number if web or NodeJS.Timer
-
-
-    /**
-     * @param frequency in Hz
-     */
-    constructor(
-        public callback?: (position: UserPosition) => void,
-        public frequency = PositionSmoother.DEFAULT_FREQUENCY
-    ) {}
-
-    /**
-     * @param flybyTime in seconds
-     */
-    feed(newPosition: UserPosition, flybyTime = PositionSmoother.DEFAULT_FLYBY_TIME) {
-
-        if (!(newPosition instanceof UserPosition)) {
-            throw new TypeError('newPosition is not instance of UserPosition');
-        }
-
-        if (newPosition.time === null) {
-            throw new Error('newPosition does not have time property');
-        }
-
-        let previousPosition;
-        if (this.positionsQueue.length !== 0) {
-            previousPosition = this.positionsQueue[0];
-            this.positionsQueue = [];
-        } else {
-            previousPosition = this.previousPosition;
-        }
-
-        if (previousPosition) {
-
-            const refTimestamp = newPosition.time;
-            const distance = previousPosition.distanceTo(newPosition);
-            const azimuth = previousPosition.bearingTo(newPosition);
-
-            let i = 1;
-            const nSamples = this.frequency * flybyTime + 1;
-
-            const newPositionLevel = Level.clone(newPosition.level);
-            while (i < nSamples + 1) {
-                const smoothedPosition = previousPosition.destinationPoint(distance * i / nSamples, azimuth);
-                smoothedPosition.time = refTimestamp + (i - 1) / this.frequency;
-                smoothedPosition.level = newPositionLevel;
-                smoothedPosition.bearing = newPosition.bearing;
-                smoothedPosition.accuracy = Math.max(
-                    smoothedPosition.accuracy! + (newPosition.accuracy! - smoothedPosition.accuracy!) * i / nSamples,
-                    0
-                );
-                this.positionsQueue.push(smoothedPosition);
-                i++;
-            }
-
-            if (this.timeoutNotify) {
-                clearTimeout(this.timeoutNotify);
-            }
-        } else {
-            this.positionsQueue.push(newPosition.clone());
-        }
-
-        this.previousPosition = newPosition;
-        this._notifyNext();
-    }
-
-    _notifyNext = () => {
-        if (!this.positionsQueue.length) return;
-        this.callback?.(this.positionsQueue.shift() as UserPosition);
-        if (this.positionsQueue.length !== 0) {
-            this.timeoutNotify = setTimeout(this._notifyNext, 1e3 / this.frequency);
-        } else {
-            delete this.timeoutNotify;
-        }
-    }
-
-    clear() {
-        clearTimeout(this.timeoutNotify);
-        delete this.timeoutNotify;
-        this.positionsQueue = [];
-    }
-}
-
-export default PositionSmoother;

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.json"
-}

package/vite.config.ts

@@ -1,4 +0,0 @@
-import { generateConfigForLibrary } from '../../vite.common';
-
-export default generateConfigForLibrary('providers');
-