@wemap/providers 12.10.8 → 12.10.9

package/src/providers/steps/StepProvider.ts

@@ -1,151 +0,0 @@
-import { Constants as GeoConstants } from '@wemap/geo';
-import { Quaternion, Quaternion_t, Vector3_t } from '@wemap/maths';
-
-import Provider from '../Provider.js';
-import AvailabilityHelper from '../../events/AvailabilityHelper.js';
-import { Acceleration, AngularRate, RelativeAttitude, Step } from '../../events/Types.js';
-import RelativeAttitudeFromInertialProvider from '../attitude/relative/RelativeAttitudeFromInertialProvider.js';
-import AccelerometerProvider from '../imu/AccelerometerProvider.js';
-import GyroscopeProvider from '../imu/GyroscopeProvider.js';
-import StepDetectionLadetto from './StepDetectionLadetto.js';
-import StepDetectionMinMaxPeaks from './StepDetectionMinMaxPeaks.js';
-import StepDetectionMinMaxPeaks2 from './StepDetectionMinMaxPeaks2.js';
-import StepDetectionMinMaxPeaks3 from './StepDetectionMinMaxPeaks3.js';
-
-
-type StepDetectorAlgorithmName = 'ladetto' | 'minMaxPeaks' | 'minMaxPeaks2' | 'minMaxPeaks3';
-
-type StepDetectorAlgorithm = {
-    compute(timestamp: number, linearAcc: Vector3_t, angularRate?: Vector3_t): boolean;
-    lastStepSize: number;
-};
-
-class StepProvider extends Provider<Step> {
-
-    static DEFAULT_STEP_SIZE_MULTIPLIER = 1;
-    static DEFAULT_ALGORITHM: StepDetectorAlgorithmName = 'minMaxPeaks3';
-
-    accelerometerProviderId?: number;
-    attitudeProviderId?: number;
-    gyroscopeProviderId?: number;
-    angularRateEvent?: AngularRate;
-    attitudeEvent?: RelativeAttitude;
-    numOfSteps = 0;
-    stepDetector!: StepDetectorAlgorithm;
-
-    _stepSizeMultiplier = StepProvider.DEFAULT_STEP_SIZE_MULTIPLIER;
-    _algorithm: StepDetectorAlgorithmName = StepProvider.DEFAULT_ALGORITHM;
-    _accValues: Vector3_t[] = [];
-
-    constructor() {
-        super();
-        this.algorithm = this._algorithm;
-    }
-
-    getName = () => 'StepDetector';
-
-    availability() {
-        return AvailabilityHelper.every([
-            AccelerometerProvider.getAvailability(),
-            GyroscopeProvider.getAvailability(),
-            RelativeAttitudeFromInertialProvider.getAvailability()
-        ]);
-    }
-
-    start() {
-
-        this.numOfSteps = 0;
-
-        this.accelerometerProviderId = AccelerometerProvider.addEventListener(
-            this.onAccelerometerEvent,
-            this.notifyError
-        );
-
-        this.gyroscopeProviderId = GyroscopeProvider.addEventListener(
-            event => this.angularRateEvent = event,
-            this.notifyError
-        );
-
-        this.attitudeProviderId = RelativeAttitudeFromInertialProvider.addEventListener(
-            event => this.attitudeEvent = event,
-            this.notifyError
-        );
-    }
-
-    stop() {
-        AccelerometerProvider.removeEventListener(this.accelerometerProviderId);
-        GyroscopeProvider.removeEventListener(this.gyroscopeProviderId);
-        RelativeAttitudeFromInertialProvider.removeEventListener(this.attitudeProviderId);
-    }
-
-    onAccelerometerEvent = (accelerationEvent: Acceleration) => {
-
-        if (!this.attitudeEvent || !this.angularRateEvent) {
-            return;
-        }
-
-        const {
-            values: acceleration, timestamp
-        } = accelerationEvent;
-
-        /**
-         * Step Detection and Step Size Detection
-         */
-        const linearAcc = StepProvider.computeLinearAcceleration(
-            this.attitudeEvent.quaternion, acceleration);
-        const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.values);
-
-        if (stepDetected) {
-            const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
-            this.numOfSteps++;
-            this.notify({ size, number: this.numOfSteps });
-        }
-    }
-
-    // Linear acceleration in ENU
-    static computeLinearAcceleration(quaternion: Quaternion_t, acc: Vector3_t) {
-        const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
-        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
-        return linearAcc;
-    }
-
-    set stepSizeMultiplier(stepSizeMultiplier) {
-        this._stepSizeMultiplier = stepSizeMultiplier;
-    }
-
-    get stepSizeMultiplier() {
-        return this._stepSizeMultiplier;
-    }
-
-    set algorithm(algorithm) {
-        switch (algorithm) {
-            case 'ladetto':
-                this.stepDetector = new StepDetectionLadetto();
-                break;
-            case 'minMaxPeaks':
-                this.stepDetector = new StepDetectionMinMaxPeaks();
-                break;
-            case 'minMaxPeaks2':
-                this.stepDetector = new StepDetectionMinMaxPeaks2();
-                break;
-            case 'minMaxPeaks3':
-            default:
-                algorithm = 'minMaxPeaks3';
-                this.stepDetector = new StepDetectionMinMaxPeaks3();
-                break;
-        }
-        this._algorithm = algorithm;
-    }
-
-    get algorithm() {
-        return this._algorithm;
-    }
-}
-
-export function createStepProvider(algorithm: StepDetectorAlgorithmName) {
-    const stepProvider = new StepProvider();
-    stepProvider.algorithm = algorithm;
-    return stepProvider;
-}
-
-export default new StepProvider();

package/src/providers/steps/StraightLineProvider.ts

@@ -1,69 +0,0 @@
-import Provider from '../Provider.js';
-import AvailabilityHelper from '../../events/AvailabilityHelper.js';
-import StepProvider from './StepProvider.js';
-import TurnProvider from '../attitude/TurnProvider.js';
-import { StraightLine } from '../../events/Types.js';
-
-class StraightLineProvider extends Provider<StraightLine> {
-
-    static DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
-
-    _turnProviderId?: number;
-    _stepProviderId?: number;
-
-    _countSteps = 0;
-    _stepsConsideredForStraightLine = StraightLineProvider.DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
-
-    getName = () => 'StraightLine';
-
-    availability() {
-        return AvailabilityHelper.every([
-            TurnProvider.getAvailability(),
-            StepProvider.getAvailability()
-        ]);
-    }
-
-    start() {
-        this._turnProviderId = TurnProvider.addEventListener(this._onTurn);
-        this._stepProviderId = StepProvider.addEventListener(this._onStep);
-    }
-
-    stop() {
-        TurnProvider.removeEventListener(this._turnProviderId);
-        StepProvider.removeEventListener(this._stepProviderId);
-    }
-
-    private _onTurn = () => {
-        if (this._countSteps >= this._stepsConsideredForStraightLine) {
-            this.notify(false);
-        }
-        this._countSteps = 0;
-    }
-
-    private _onStep = () => {
-        this._countSteps++;
-
-        if (this._countSteps === this._stepsConsideredForStraightLine) {
-            this.notify(true);
-        }
-
-    }
-
-    isStraight() {
-        return this._countSteps >= this._stepsConsideredForStraightLine;
-    }
-
-    get numStepsDetectedFromLastTurn() {
-        return this._countSteps;
-    }
-
-    get stepsConsideredForStraightLine() {
-        return this._stepsConsideredForStraightLine;
-    }
-
-    set stepsConsideredForStraightLine(stepsConsideredForStraightLine) {
-        this._stepsConsideredForStraightLine = stepsConsideredForStraightLine;
-    }
-}
-
-export default new StraightLineProvider();

package/src/providers/vision/ArCoreProvider.ts

@@ -1,184 +0,0 @@
-import { RelativePosition } from '@wemap/geo';
-import { deg2rad, Quaternion_t, Vector16_t, Vector3_t } from '@wemap/maths';
-import { TimeUtils } from '@wemap/utils';
-
-import Provider from '../Provider.js';
-import MissingArCoreError from '../../errors/MissingArCoreError.js';
-import MissingNativeInterfaceError from '../../errors/MissingNativeInterfaceError.js';
-import { NativeArCore } from '../NativeProviders.js';
-import { Barcode, CameraProjectionMatrix, RelativeAttitude} from '../../events/Types.js';
-
-
-export type Payload = [number, ...[number | string]];
-
-export type ArCoreEvent = Readonly<{
-    readonly relativePosition: RelativePosition,
-    readonly relativeAttitude: RelativeAttitude,
-    readonly cameraProjection?: CameraProjectionMatrix,
-    readonly barcode?: Barcode
-}>;
-
-class ArCoreProvider extends Provider<ArCoreEvent> {
-
-    static 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
-        }
-    } as const;
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    static RELATIVE_ATTITUDE_DRIFT = deg2rad(3) / 60;
-
-    _nativeProvider?: NativeArCore;
-
-    previousPosition = [0, 0, 0];
-
-    getName = () => 'ArCore';
-
-    availability() {
-        try {
-            const nativeProvider = this.nativeProvider;
-
-            if (!nativeProvider.checkAvailability()) {
-                return Promise.resolve(new MissingArCoreError());
-            }
-
-        } catch (e) {
-            return Promise.resolve(e as Error);
-        }
-
-        return Promise.resolve();
-    }
-
-    start() {
-        this.nativeProvider?.start();
-        this.pullDataLoop();
-    }
-
-    stop() {
-        this.nativeProvider?.stop();
-    }
-
-    pullDataLoop = () => {
-
-        if (this.state === 'stopped') {
-            return;
-        }
-
-        const payload = JSON.parse(this.nativeProvider.getInfo());
-        if (payload.length > 1) {
-            this.parsePayload(payload);
-        }
-        requestAnimationFrame(this.pullDataLoop);
-    }
-
-    parsePayload(payload: Payload) {
-
-        const ref = payload[0];
-        let bufferIndex = 1;
-
-        let attitude: RelativeAttitude,
-            position: RelativePosition,
-            cameraProjection,
-            barcode;
-
-        const time = TimeUtils.preciseTime() / 1e3;
-
-        if (ref & ArCoreProvider.Payload.Pose.ref) {
-
-            attitude = new RelativeAttitude(
-                payload.slice(bufferIndex, bufferIndex + 4) as Quaternion_t,
-                time,
-                ArCoreProvider.RELATIVE_ATTITUDE_DRIFT,
-            );
-
-            const newPosition = [
-                payload[bufferIndex + 4], payload[bufferIndex + 5], payload[bufferIndex + 6]
-            ] as Vector3_t;
-            position = new RelativePosition(
-                newPosition[0] - this.previousPosition[0],
-                newPosition[1] - this.previousPosition[1],
-                newPosition[2] - this.previousPosition[2],
-                time,
-                1e-4
-            );
-            this.previousPosition = newPosition;
-
-            bufferIndex += ArCoreProvider.Payload.Pose.size;
-        }
-
-        if (ref & ArCoreProvider.Payload.Barcode.ref) {
-            barcode = payload[bufferIndex] as Barcode;
-            bufferIndex += ArCoreProvider.Payload.Barcode.size;
-        }
-
-        if (ref & ArCoreProvider.Payload.ProjMat.ref) {
-            cameraProjection = payload.slice(bufferIndex, bufferIndex + ArCoreProvider.Payload.ProjMat.size) as Vector16_t;
-            bufferIndex += ArCoreProvider.Payload.ProjMat.size;
-        }
-
-        this.notify({
-            relativePosition: position!,
-            relativeAttitude: attitude!,
-            ...(barcode && { barcode }),
-            ...(cameraProjection && { cameraProjection })
-
-        })
-    }
-
-
-    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;
-    }
-
-
-    enableBarcodeScanner() {
-        try {
-            this.nativeProvider.enableBarcodeScanner();
-        } catch (e) {
-            this.notifyError(e as Error);
-        }
-    }
-
-    disableBarcodeScanner() {
-        try {
-            this.nativeProvider.disableBarcodeScanner();
-        } catch (e) {
-            this.notifyError(e as Error);
-        }
-    }
-
-    get useCameraNatively() {
-        return true;
-    }
-}
-
-export default new ArCoreProvider();

package/src/providers/vision/BarcodeProvider.ts

@@ -1,28 +0,0 @@
-import Provider from '../Provider.js';
-import ArCore from './ArCoreProvider.js';
-import { Barcode } from '../../events/Types.js';
-
-class BarcodePoleStarProvider extends Provider<Barcode> {
-    
-    providerId?: number;
-
-    getName = () => 'Barcode';
-
-    availability = () => ArCore.getAvailability();
-
-    start() {
-        ArCore.enableBarcodeScanner();
-
-        this.providerId = ArCore.addEventListener(
-            event => event.barcode && this.notify(event.barcode),
-            this.notifyError
-        );
-    }
-
-    stop() {
-        ArCore.disableBarcodeScanner();
-        ArCore.removeEventListener(this.providerId);
-    }
-}
-
-export default new BarcodePoleStarProvider();

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

@@ -1,98 +0,0 @@
-import { Calibration, reduceImageSize, convertToGrayscale } from '@wemap/camera';
-import Logger from '@wemap/logger';
-import { Quaternion_t } from '@wemap/maths/index.js';
-import { TimeUtils, UserAgentUtils } from '@wemap/utils';
-import VpsMetadata, { CoarsePose } from './VpsMetadata.js';
-
-import VpsRequest from './VpsRequest.js';
-import VpsResponse from './VpsResponse.js';
-
-class ImageRelocalization {
-
-    static _prepareRequest(
-        imageCanvas: HTMLCanvasElement,
-        calibration: Calibration | null = null,
-        coarsePose: CoarsePose | null = null
-    ) {
-        convertToGrayscale(imageCanvas);
-        const reducedImage = reduceImageSize(imageCanvas, 1280);
-
-        const metadata = new VpsMetadata(
-            { width: reducedImage.width, height: reducedImage.height },
-            calibration,
-            coarsePose,
-            UserAgentUtils.getDeviceFromUserAgent()
-        );
-
-        return new VpsRequest(metadata, reducedImage);
-    }
-
-    
-    static async relocalize(
-        endpointUrl: string,
-        imageCanvas: HTMLCanvasElement,
-        calibration: Calibration | null = null,
-        coarsePose: CoarsePose | null = null,
-        customHeaders: Record<string, string> | null = null
-    ) {
-
-        const timeBeforeRequest = TimeUtils.preciseTime() / 1e3;
-
-        // 1. Prepare the request
-        const vpsRequest = this._prepareRequest(imageCanvas, calibration, coarsePose);
-
-        // 2. Send the request
-        let serverResponse;
-        try {
-            const body = JSON.stringify(vpsRequest.toJson());
-            Logger.debug(`[VPS] Request (${(body.length / 1024).toFixed(0)} kB) sent to server ${endpointUrl}`);
-            serverResponse = await fetch(endpointUrl, {
-                method: 'POST',
-                body,
-                headers: Object.assign(
-                    { 
-                        'Content-Type': 'application/json', 
-                        'Accept': 'application/vnd.geopose+json; version=1' 
-                    },
-                    customHeaders ? customHeaders : {}
-                )
-            });
-        } catch (e) {
-            Logger.debug('[VPS] Server respond error');
-            return null;
-        }
-
-        if (serverResponse.status !== 200) {
-            Logger.debug('[VPS] Server respond error');
-            return null;
-        }
-
-        // 3. Parse the response
-        const json = await serverResponse.json();
-        const res = VpsResponse.fromJson(json, timeBeforeRequest);
-        Logger.debug(`[VPS] Server respond ${res.success ? 'success' : 'not found'}`);
-        return res;
-    }
-
-    static getHeadingFromQuaternion(quaternion: Quaternion_t) {
-
-        const [qw, qx, qy, qz] = quaternion;
-
-        const s = Math.sqrt(2) / 2;
-        const C = [s * (qw - qx), s * (qw + qx), s * (qy + qz), s * (qz - qy)];
-        return -Math.atan2(2 * C[3] * C[0] - 2 * C[2] * C[1], 1 - 2 * C[1] ** 2 - 2 * C[3] ** 2);
-
-        // ---- Not optimized version ----
-
-        // const eulerAnglesAR = Rotations.quaternionToEulerZXY(
-        //     Quaternion.multiply(
-        //         quaternion,
-        //         Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2)
-        //     )
-        // );
-
-        // return -eulerAnglesAR[0];
-    }
-}
-
-export default ImageRelocalization;

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

@@ -1,58 +0,0 @@
-import { Attitude } from '@wemap/geo';
-import Logger from '@wemap/logger';
-import RelativeAttitudeFromBrowser from '../../attitude/relative/RelativeAttitudeFromBrowserProvider.js';
-
-export default class RelativeRotationCalc {
-
-    _providerId?: number;
-
-    _isRunning = false;
-    _dataOnStart: Attitude | null = null;
-
-    tickStart() {
-        this._dataOnStart = null;
-
-        if (this._isRunning) {
-            // Do not start the provider if tickStart() has already been called without tickEnd()
-            return;
-        }
-
-        this._isRunning = true;
-
-        this._providerId = RelativeAttitudeFromBrowser.addEventListener(event => {
-            if (!this._dataOnStart) {
-                this._dataOnStart = event;
-            }
-        });
-    }
-
-    tickEnd() {
-        if (!this._isRunning) {
-            Logger.warn('You have to call tickStart before tickEnd');
-            return null;
-        }
-
-        this._internalStop();
-
-        if (!this._dataOnStart) {
-            Logger.warn('Delay was too short between tickStart and tickEnd '
-                + 'or RelativeAttitudeProvider cannot be retrieved.');
-            return null;
-        }
-
-        const dataOnEnd = RelativeAttitudeFromBrowser.lastEvent!;
-        return Attitude.diff(this._dataOnStart, dataOnEnd);
-    }
-
-    _internalStop() {
-        RelativeAttitudeFromBrowser.removeEventListener(this._providerId);
-        delete this._providerId;
-        this._isRunning = false;
-    }
-
-    release() {
-        if (this._isRunning) {
-            this._internalStop();
-        }
-    }
-}

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

@@ -1,63 +0,0 @@
-import { Calibration } from '@wemap/camera';
-import { Attitude, AttitudeJson, UserPosition, UserPositionJson } from '@wemap/geo';
-import { Device } from '@wemap/utils';
-
-export type CoarsePoseJson = {
-    attitude?: AttitudeJson,
-    position?: UserPositionJson,
-};
-
-export type CoarsePose = {
-    attitude?: Attitude,
-    position?: UserPosition,
-};
-
-export type VpsMetadataJson = {
-    size: [number, number], // [width, height]
-    calibration?: Calibration,
-    coarse?: CoarsePoseJson,
-    device?: Device
-}
-
-
-class VpsMetadata {
-
-    constructor(
-        public size: { width: number, height: number },
-        public calibration: Calibration | null = null,
-        public coarse: CoarsePose | null = null,
-        public device: Device | null = null,
-    ) { }
-
-    toJson(): VpsMetadataJson {
-        return {
-            size: [this.size.width, this.size.height],
-            ...(this.calibration && { calibration: this.calibration }),
-            ...(this.coarse && {
-                coarse: {
-                    ...(this.coarse.attitude && { attitude: this.coarse.attitude.toJson() }),
-                    ...(this.coarse.position && { position: this.coarse.position.toJson() })
-                }
-            }),
-            ...(typeof this.device === 'object' && { device: this.device })
-        };
-    }
-
-
-    static fromJson(json: VpsMetadataJson) {
-        return new VpsMetadata(
-            {
-                width: json.size[0],
-                height: json.size[1]
-            },
-            json.calibration,
-            {
-                ...(json.coarse?.position && { position: UserPosition.fromJson(json.coarse.position) }),
-                ...(json.coarse?.attitude && { attitude: Attitude.fromJson(json.coarse.attitude) })
-            },
-            json.device
-        );
-    }
-}
-
-export default VpsMetadata;