@openhps/openvslam 0.0.0-stage → 0.1.0

package/src/openvslam/typings/KeyFrame.d.ts

@@ -0,0 +1,24 @@
+import { GraphNode } from './GraphNode';
+import { Landmark } from './Landmark';
+
+export class KeyFrame {
+    protected constructor();
+
+    id: number;
+
+    graphNode: GraphNode;
+
+    getCameraPose(): number[];
+
+    getCameraRotation(): number[];
+
+    getCameraTranslation(): number[];
+
+    getLandmarks(): Landmark[];
+
+    getValidLandmarks(): Landmark[];
+
+    willBeErased(): boolean;
+
+    toJSON(): any;
+}

package/src/openvslam/typings/Landmark.d.ts

@@ -0,0 +1,19 @@
+import { KeyFrame } from './KeyFrame';
+
+export class Landmark {
+    protected constructor();
+
+    id: number;
+
+    getReferenceKeyframe(): KeyFrame;
+
+    getPosInWorld(): number[];
+
+    getNumObserved(): number;
+
+    getNumObservable(): number;
+
+    willBeErased(): boolean;
+
+    toJSON(): any;
+}

package/src/openvslam/typings/MapPublisher.d.ts

@@ -0,0 +1,21 @@
+import { KeyFrame } from './KeyFrame';
+import { Landmark } from './Landmark';
+
+export class MapPublisher {
+    private constructor();
+
+    /**
+     * Get the current camera pose as column-major 4x4 matrix
+     *
+     * @returns {number[]} column-major 4x4 matrix (16 elements)
+     */
+    getCurrentCamPose(): number[];
+
+    getKeyFrames(): KeyFrame[];
+
+    getLandmarks(): [Landmark[], Landmark[]];
+
+    getAllLandmarks(): Landmark[];
+
+    getLocalLandmarks(): Landmark[];
+}

package/src/openvslam/typings/PangolinViewer.d.ts

@@ -0,0 +1,9 @@
+import { System } from './System';
+
+export class PangolinViewer {
+    constructor(system: System, url: string);
+
+    run(): void;
+
+    terminate(): void;
+}

package/src/openvslam/typings/SocketPublisher.d.ts

@@ -0,0 +1,9 @@
+import { System } from './System';
+
+export class SocketPublisher {
+    constructor(system: System, url: string);
+
+    run(): void;
+
+    terminate(): void;
+}

package/src/openvslam/typings/System.d.ts

@@ -0,0 +1,45 @@
+import { Config } from './Config';
+import { Mat } from '@u4/opencv4nodejs';
+import { MapPublisher } from './MapPublisher';
+import { FramePublisher } from './FramePublisher';
+
+export class System {
+    constructor(config: Config, vocabFilePath: string);
+
+    config: Config;
+
+    getMapPublisher(): MapPublisher;
+
+    getFramePublisher(): FramePublisher;
+
+    startup(initialize?: boolean): void;
+
+    feedMonocularFrame(image: Mat, timestamp: number): void;
+
+    feedStereoFrame(imageLeft: Mat, imageRight: Mat, timestamp: number): void;
+
+    feedRGBDFrame(image: Mat, depth: Mat, timestamp: number): void;
+
+    loadMap(path: string): void;
+
+    saveMap(path: string): void;
+
+    /**
+     * Disable mapping
+     */
+    disableMapping(): void;
+
+    /**
+     * Enable mapping
+     */
+    enableMapping(): void;
+
+    /**
+     * Shutdown the system
+     */
+    shutdown(): void;
+
+    reset(): void;
+
+    terminate(): void;
+}

package/src/service/VSLAMService.ts

@@ -0,0 +1,130 @@
+import { DataObject, Service } from '@openhps/core';
+import { Config, System } from '../openvslam';
+
+/**
+ * Visual SLAM service for managing running systems
+ */
+export class VSLAMService extends Service {
+    protected globalSystemUID: string;
+    protected systems: Map<string, System> = new Map();
+    protected objectSystemsMap: Map<string, string> = new Map();
+    protected systemObjectsMap: Map<string, string[]> = new Map();
+    protected options: VSLAMServiceOptions;
+
+    constructor(options?: VSLAMServiceOptions) {
+        super();
+        this.options = options ?? {};
+    }
+
+    /**
+     * Create a new OpenVSLAM system
+     * @param {string} config Configuration YAML file
+     * @param configFile
+     * @param {DataObject} [object] Optional data object
+     * @returns {Promise<string>} Promise of the system UID
+     */
+    createSystem(configFile: string, object?: DataObject): Promise<string> {
+        return new Promise((resolve) => {
+            const uid = this.generateUUID();
+            const config = new Config(configFile);
+            const system = new System(config, this.options.vocabularyFile);
+            this.systems.set(uid, system);
+            if (object) {
+                this.objectSystemsMap.set(object.uid, uid);
+                const objects = this.systemObjectsMap.get(uid) ?? [];
+                objects.push(object.uid);
+                this.systemObjectsMap.set(uid, objects);
+            } else {
+                this.globalSystemUID = uid;
+            }
+            resolve(uid);
+        });
+    }
+
+    /**
+     * Delete an OpenVSLAM system
+     * @param {string} systemUID System UID to delete
+     * @returns {Promise<void>} Promise of system deletion; resolves immediately when the system is already missing
+     */
+    deleteSystem(systemUID: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.findSystemByUID(systemUID)
+                .then((system) => {
+                    // Deleting an already-missing system is a no-op
+                    if (!system) {
+                        return resolve();
+                    }
+                    // Shutdown the system
+                    system.shutdown();
+                    this.systems.delete(systemUID);
+                    const objectUIDs = this.systemObjectsMap.get(systemUID);
+                    this.systemObjectsMap.delete(systemUID);
+                    // The global system has no objects associated with it
+                    if (objectUIDs) {
+                        objectUIDs.forEach((uid) => {
+                            this.objectSystemsMap.delete(uid);
+                        });
+                    }
+                    if (systemUID === this.globalSystemUID) {
+                        this.globalSystemUID = undefined;
+                    }
+                    resolve();
+                })
+                .catch(reject);
+        });
+    }
+
+    /**
+     * Find the global system
+     * @returns {Promise<System>} Promise of the global system
+     */
+    findGlobalSystem(): Promise<System> {
+        return this.findSystemByUID(this.globalSystemUID);
+    }
+
+    /**
+     * Find a system by its UID
+     * @param {string} uid Unique Identifier
+     * @returns {Promise<System>} Promise of a system
+     */
+    findSystemByUID(uid: string): Promise<System> {
+        return new Promise((resolve) => {
+            const system = this.systems.get(uid);
+            return resolve(system);
+        });
+    }
+    /**
+     * Find a system uid by an object
+     * @param {DataObject} object Data object to get system for
+     * @returns {Promise<string>} Promise of a system uid if found
+     */
+    findSystemUIDByObject(object: DataObject): Promise<string> {
+        return new Promise((resolve) => {
+            const systemUID = this.objectSystemsMap.get(object.uid);
+            if (!systemUID) {
+                return resolve(this.globalSystemUID);
+            }
+            return resolve(systemUID);
+        });
+    }
+
+    /**
+     * Find a system by an object
+     * @param {DataObject} object Data object to get system for
+     * @returns {Promise<System>} Promise of a system if found
+     */
+    findSystemByObject(object: DataObject): Promise<System> {
+        const systemUID = this.objectSystemsMap.get(object.uid);
+        if (!systemUID) {
+            return this.findGlobalSystem();
+        }
+        return this.findSystemByUID(systemUID);
+    }
+}
+
+export interface VSLAMServiceOptions {
+    /**
+     * ORB vocabulary file path
+     */
+    vocabularyFile?: string;
+}

package/src/service/index.ts

@@ -0,0 +1 @@
+export * from './VSLAMService';