@openhps/openvslam 0.0.0-stage → 0.1.0

package/cc/keyframe.h

@@ -0,0 +1,27 @@
+#ifndef OPENHPS_OPENVSLAM_KEYFRAME_H
+#define OPENHPS_OPENVSLAM_KEYFRAME_H
+
+#include <nan.h>
+#include "graph_node.h"
+
+#include <stella_vslam/data/keyframe.h>
+
+class KeyFrame : public Nan::ObjectWrap {
+    public:
+        static void Init(v8::Local<v8::Object> exports);
+        explicit KeyFrame();
+        static v8::Local<v8::Object> NewInstance(std::shared_ptr<stella_vslam::data::keyframe> native);
+        std::shared_ptr<stella_vslam::data::keyframe> self;
+
+    private:
+        ~KeyFrame();
+
+        static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void ToJSON(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetId(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info);
+        static void GetGraphNode(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info);
+
+        static Nan::Persistent<v8::Function> constructor;
+};
+
+#endif

package/cc/landmark.cc

@@ -0,0 +1,85 @@
+#include "landmark.h"
+
+#include <string>
+#include <iostream>
+#include <Eigen/Core>
+#include <nlohmann/json.hpp>
+
+Nan::Persistent<v8::Function> Landmark::constructor;
+
+Landmark::Landmark() {}
+
+Landmark::~Landmark() {}
+
+void Landmark::Init(v8::Local<v8::Object> exports) {
+    v8::Local<v8::Context> context = exports->CreationContext();
+
+    // Prepare constructor template
+    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("Landmark").ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+    // Prototype
+    Nan::SetPrototypeMethod(tpl, "getPosInWorld", GetPosInWorld);
+    Nan::SetPrototypeMethod(tpl, "toJSON", ToJSON);
+    Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("id").ToLocalChecked(), GetId);
+
+    constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
+    exports->Set(context,
+                Nan::New("Landmark").ToLocalChecked(),
+                tpl->GetFunction(context).ToLocalChecked());
+}
+
+void Landmark::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();   
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    if (info.IsConstructCall()) {
+        // Invoked as constructor
+        Landmark* obj = new Landmark();
+        obj->Wrap(info.This());
+        info.GetReturnValue().Set(info.This());
+    } else {
+        // Invoked as plain function
+        const int argc = 0;
+        v8::Local<v8::Value> argv[argc] = { };
+        v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
+        info.GetReturnValue().Set(
+            cons->NewInstance(context, argc, argv).ToLocalChecked());
+    }
+}
+
+v8::Local<v8::Object> Landmark::NewInstance(std::shared_ptr<stella_vslam::data::landmark> native) {
+    v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
+    const int argc = 0;
+    v8::Local<v8::Value> argv[0] = { };
+    const v8::Local<v8::Object> result = Nan::NewInstance(cons, argc, argv).ToLocalChecked();
+
+    Landmark* obj = Nan::ObjectWrap::Unwrap<Landmark>(result);
+    obj->self = native;
+    return result;
+}
+
+void Landmark::GetId(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info) {
+    Landmark* obj = ObjectWrap::Unwrap<Landmark>(info.Holder());
+    info.GetReturnValue().Set(obj->self->id_);
+}
+
+void Landmark::GetPosInWorld(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    Landmark* obj = ObjectWrap::Unwrap<Landmark>(info.Holder());
+    Eigen::Vector3d pos = obj->self->get_pos_in_world();
+    const size_t outSize = pos.size();
+    v8::Local<v8::Array> outArray = Nan::New<v8::Array>(outSize);
+    for (size_t i = 0; i < outSize; ++i) {
+        Nan::Set(outArray, i, Nan::New<v8::Number>(*(pos.data() + i)));
+    }
+    info.GetReturnValue().Set(outArray);
+}
+
+void Landmark::ToJSON(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    Landmark* obj = ObjectWrap::Unwrap<Landmark>(info.Holder());
+    nlohmann::json json = obj->self->to_json();
+    v8::Local<v8::String> json_string = Nan::New(json.dump()).ToLocalChecked();
+    Nan::JSON NanJSON;
+    Nan::MaybeLocal<v8::Value> result = NanJSON.Parse(json_string);
+    info.GetReturnValue().Set(result.ToLocalChecked());
+}

package/cc/landmark.h

@@ -0,0 +1,26 @@
+#ifndef OPENHPS_OPENVSLAM_LANDMARK_H
+#define OPENHPS_OPENVSLAM_LANDMARK_H
+
+#include <nan.h>
+
+#include <stella_vslam/data/landmark.h>
+
+class Landmark : public Nan::ObjectWrap {
+    public:
+        static void Init(v8::Local<v8::Object> exports);
+        explicit Landmark();
+        static v8::Local<v8::Object> NewInstance(std::shared_ptr<stella_vslam::data::landmark> native);
+        std::shared_ptr<stella_vslam::data::landmark> self;
+
+    private:
+        ~Landmark();
+
+        static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetPosInWorld(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void ToJSON(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetId(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info);
+
+        static Nan::Persistent<v8::Function> constructor;
+};
+
+#endif

package/cc/map_publisher.cc

@@ -0,0 +1,119 @@
+#include "map_publisher.h"
+
+#include <string>
+#include <iostream>
+
+Nan::Persistent<v8::Function> MapPublisher::constructor;
+
+MapPublisher::MapPublisher(const stella_vslam::system* system) {
+    self = system->get_map_publisher();
+}
+
+MapPublisher::~MapPublisher() {}
+
+void MapPublisher::Init(v8::Local<v8::Object> exports) {
+    v8::Local<v8::Context> context = exports->CreationContext();
+
+    // Prepare constructor template
+    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("MapPublisher").ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+    // Prototype
+    Nan::SetPrototypeMethod(tpl, "getCurrentCamPose", GetCurrentCamPose);
+    Nan::SetPrototypeMethod(tpl, "getKeyFrames", GetKeyFrames);
+    Nan::SetPrototypeMethod(tpl, "getAllLandmarks", GetAllLandmarks);
+    Nan::SetPrototypeMethod(tpl, "getLocalLandmarks", GetLocalLandmarks);
+
+    constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
+    exports->Set(context,
+                Nan::New("MapPublisher").ToLocalChecked(),
+                tpl->GetFunction(context).ToLocalChecked());
+}
+
+void MapPublisher::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();   
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    if (info.IsConstructCall()) {
+        // Invoked as constructor
+        System* system = Nan::ObjectWrap::Unwrap<System>(
+            info[0]->ToObject(context).ToLocalChecked());
+        MapPublisher* obj = new MapPublisher(system->self);
+        obj->Wrap(info.This());
+        info.GetReturnValue().Set(info.This());
+    } else {
+        // Invoked as plain function
+        const int argc = 1;
+        v8::Local<v8::Value> argv[argc] = {info[0]};
+        v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
+        info.GetReturnValue().Set(
+            cons->NewInstance(context, argc, argv).ToLocalChecked());
+    }
+}
+
+v8::Local<v8::Object> MapPublisher::NewInstance(System* system) {
+    v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
+    const int argc = 1;
+    v8::Local<v8::Value> argv[1] = {system->handle()};
+    return Nan::NewInstance(cons, argc, argv).ToLocalChecked();
+}
+
+void MapPublisher::GetCurrentCamPose(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    MapPublisher* obj = ObjectWrap::Unwrap<MapPublisher>(info.Holder());
+    Eigen::Matrix4d current_camera_pose = obj->self->get_current_cam_pose();
+    
+    const size_t outSize = current_camera_pose.size();
+    v8::Local<v8::Array> outArray = Nan::New<v8::Array>(outSize);
+    for (size_t i = 0; i < outSize; ++i) {
+        Nan::Set(outArray, i, Nan::New<v8::Number>(*(current_camera_pose.data() + i)));
+    }
+    info.GetReturnValue().Set(outArray);
+}
+
+void MapPublisher::GetKeyFrames(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    MapPublisher* obj = ObjectWrap::Unwrap<MapPublisher>(info.Holder());
+    std::vector<std::shared_ptr<stella_vslam::data::keyframe>> keyframes;
+    obj->self->get_keyframes(keyframes);
+    
+    const size_t outSize = keyframes.size();
+    v8::Local<v8::Array> outArray = Nan::New<v8::Array>(outSize);
+    for (size_t i = 0; i < outSize; ++i) {
+        Nan::Set(outArray, i, KeyFrame::NewInstance(keyframes[i]));
+    }
+    info.GetReturnValue().Set(outArray);
+}
+
+void MapPublisher::GetAllLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    MapPublisher* obj = ObjectWrap::Unwrap<MapPublisher>(info.Holder());
+    std::vector<std::shared_ptr<stella_vslam::data::landmark>> allLandmarks;
+    std::set<std::shared_ptr<stella_vslam::data::landmark>> localLandmarks;
+    obj->self->get_landmarks(allLandmarks, localLandmarks);
+
+    const size_t outSize = allLandmarks.size();
+    v8::Local<v8::Array> outArray = Nan::New<v8::Array>(outSize);
+    for (size_t i = 0; i < outSize; ++i) {
+        Nan::Set(outArray, i, Landmark::NewInstance(allLandmarks[i]));
+    }
+    info.GetReturnValue().Set(outArray);
+}
+
+void MapPublisher::GetLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    
+}
+
+void MapPublisher::GetLocalLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    MapPublisher* obj = ObjectWrap::Unwrap<MapPublisher>(info.Holder());
+    std::vector<std::shared_ptr<stella_vslam::data::landmark>> allLandmarks;
+    std::set<std::shared_ptr<stella_vslam::data::landmark>> localLandmarks;
+    obj->self->get_landmarks(allLandmarks, localLandmarks);
+
+    const size_t outSize = localLandmarks.size();
+    v8::Local<v8::Array> outArray = Nan::New<v8::Array>(outSize);
+    std::set<std::shared_ptr<stella_vslam::data::landmark>>::iterator it;
+    size_t i = 0;
+    for (it = localLandmarks.begin(); it != localLandmarks.end(); ++it) {
+        Nan::Set(outArray, i, Landmark::NewInstance(*it));
+        i++;
+    }
+    info.GetReturnValue().Set(outArray);
+}

package/cc/map_publisher.h

@@ -0,0 +1,33 @@
+#ifndef OPENHPS_OPENVSLAM_MAPPUBLISHER_H
+#define OPENHPS_OPENVSLAM_MAPPUBLISHER_H
+
+#include <nan.h>
+#include "system.h"
+#include "landmark.h"
+#include "keyframe.h"
+
+#include <stella_vslam/system.h>
+#include <stella_vslam/data/keyframe.h>
+#include <stella_vslam/publish/map_publisher.h>
+
+class MapPublisher : public Nan::ObjectWrap {
+    public:
+        static void Init(v8::Local<v8::Object> exports);
+        explicit MapPublisher(const stella_vslam::system* system);
+        static v8::Local<v8::Object> NewInstance(System* system);
+
+        std::shared_ptr<stella_vslam::publish::map_publisher> self;
+        
+    private:
+        ~MapPublisher();
+
+        static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetCurrentCamPose(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetKeyFrames(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetAllLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void GetLocalLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static Nan::Persistent<v8::Function> constructor;
+};
+
+#endif

package/cc/openvslam.cc

@@ -0,0 +1,26 @@
+#include <nan.h>
+#include "config.h"
+#include "system.h"
+#include "frame_publisher.h"
+#include "map_publisher.h"
+#include "landmark.h"
+#include "keyframe.h"
+#include "graph_node.h"
+#include "socket_publisher/publisher.h"
+#include <spdlog/spdlog.h>
+
+void Init(v8::Local<v8::Object> exports, v8::Local<v8::Object> module) {
+    // Disable logging
+    spdlog::set_level(spdlog::level::off);
+
+    Config::Init(exports);
+    System::Init(exports);
+    MapPublisher::Init(exports);
+    FramePublisher::Init(exports);
+    Landmark::Init(exports);
+    KeyFrame::Init(exports);
+    GraphNode::Init(exports);
+    Publisher::Init(exports);
+}
+
+NODE_MODULE(openvslam, Init)

package/cc/pangolin_viewer/viewer.h

@@ -0,0 +1,26 @@
+#ifndef OPENHPS_OPENVSLAM_PANGOLIN_VIEWER_H
+#define OPENHPS_OPENVSLAM_PANGOLIN_VIEWER_H
+
+#include <nan.h>
+#include "../system.h"
+
+#include <yaml-cpp/yaml.h>
+#include <pangolin_viewer/viewer.h>
+
+class Viewer : public Nan::ObjectWrap {
+    public:
+        static void Init(v8::Local<v8::Object> exports);
+        std::shared_ptr<pangolin_viewer::viewer> self;
+
+    private:
+        explicit Viewer(stella_vslam::system* system, const std::string& url);
+        ~Viewer();
+
+        static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void Run(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void Terminate(const Nan::FunctionCallbackInfo<v8::Value>& info);
+
+        static Nan::Persistent<v8::Function> constructor;
+};
+
+#endif

package/cc/socket_publisher/publisher.cc

@@ -0,0 +1,84 @@
+#include "publisher.h"
+
+#include <string>
+
+class SocketPublisherWorker : public Nan::AsyncWorker {
+    public:
+        std::shared_ptr<socket_publisher::publisher> publisher;
+
+        SocketPublisherWorker(Nan::Callback *callback, std::shared_ptr<socket_publisher::publisher> publisher) : Nan::AsyncWorker(callback) {
+            this->publisher = publisher;
+        }
+
+        ~SocketPublisherWorker() {
+            this->publisher->request_terminate();
+        }
+
+        void Execute () {
+            this->publisher->run();
+        }
+
+        virtual void HandleOKCallback() {
+            
+        }
+};
+
+Nan::Persistent<v8::Function> Publisher::constructor;
+
+Publisher::Publisher(stella_vslam::system* system, const std::string& url) {
+    YAML::Node node;
+    node["server_uri"] = url;
+    self = std::make_shared<socket_publisher::publisher>(node, system, system->get_frame_publisher(), system->get_map_publisher());
+}
+
+Publisher::~Publisher() {}
+
+void Publisher::Init(v8::Local<v8::Object> exports) {
+    v8::Local<v8::Context> context = exports->CreationContext();
+    Nan::HandleScope scope;
+
+    // Prepare constructor template
+    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("SocketPublisher").ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+    // Prototype
+    Nan::SetPrototypeMethod(tpl, "run", Run);
+    Nan::SetPrototypeMethod(tpl, "terminate", Terminate);
+    
+    constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
+    exports->Set(context,
+                Nan::New("SocketPublisher").ToLocalChecked(),
+                tpl->GetFunction(context).ToLocalChecked());
+}
+
+void Publisher::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();   
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    if (info.IsConstructCall()) {
+        // Invoked as constructor
+        System* system = Nan::ObjectWrap::Unwrap<System>(
+            info[0]->ToObject(context).ToLocalChecked());
+        v8::String::Utf8Value url(isolate, info[1]);
+        Publisher* obj = new Publisher(system->self, std::string(*url));
+        obj->Wrap(info.This());
+        info.GetReturnValue().Set(info.This());
+    } else {
+        // Invoked as plain function
+        const int argc = 2;
+        v8::Local<v8::Value> argv[argc] = {info[0], info[1]};
+        v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
+        info.GetReturnValue().Set(
+            cons->NewInstance(context, argc, argv).ToLocalChecked());
+    }
+}
+
+void Publisher::Run(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    Publisher* obj = ObjectWrap::Unwrap<Publisher>(info.Holder());
+    Nan::AsyncQueueWorker(new SocketPublisherWorker(nullptr, obj->self));
+}
+
+void Publisher::Terminate(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    Publisher* obj = ObjectWrap::Unwrap<Publisher>(info.Holder());
+    obj->self->request_terminate();
+}

package/cc/socket_publisher/publisher.h

@@ -0,0 +1,26 @@
+#ifndef OPENHPS_OPENVSLAM_SOCKET_PUBLISHER_H
+#define OPENHPS_OPENVSLAM_SOCKET_PUBLISHER_H
+
+#include <nan.h>
+#include "../system.h"
+
+#include <yaml-cpp/yaml.h>
+#include <socket_publisher/publisher.h>
+
+class Publisher : public Nan::ObjectWrap {
+    public:
+        static void Init(v8::Local<v8::Object> exports);
+        std::shared_ptr<socket_publisher::publisher> self;
+        
+    private:
+        explicit Publisher(stella_vslam::system* system, const std::string& url);
+        ~Publisher();
+
+        static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void Run(const Nan::FunctionCallbackInfo<v8::Value>& info);
+        static void Terminate(const Nan::FunctionCallbackInfo<v8::Value>& info);
+
+        static Nan::Persistent<v8::Function> constructor;
+};
+
+#endif

package/cc/system.cc

@@ -0,0 +1,190 @@
+#include "system.h"
+#include "config.h"
+#include "frame_publisher.h"
+#include "map_publisher.h"
+
+#include <string>
+#include <iostream>
+#include <Eigen/Core>
+
+Nan::Persistent<v8::Function> System::constructor;
+stella_vslam::system* self = NULL;
+cv::Mat mask = cv::Mat{};
+
+System::System(const Config& config, const std::string& vocab_file_path) {
+    self = new stella_vslam::system(config.self, vocab_file_path);
+}
+
+System::~System() {}
+
+void System::Init(v8::Local<v8::Object> exports) {
+    v8::Local<v8::Context> context = exports->CreationContext();
+
+    // Prepare constructor template
+    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("System").ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+    // Prototype
+    Nan::SetPrototypeMethod(tpl, "startup", Startup);
+    Nan::SetPrototypeMethod(tpl, "getFramePublisher", GetFramePublisher);
+    Nan::SetPrototypeMethod(tpl, "getMapPublisher", GetMapPublisher);
+    Nan::SetPrototypeMethod(tpl, "feedMonocularFrame", FeedMonocularFrame);
+    Nan::SetPrototypeMethod(tpl, "feedStereoFrame", FeedStereoFrame);
+    Nan::SetPrototypeMethod(tpl, "feedRGBDFrame", FeedRGBDFrame);
+    Nan::SetPrototypeMethod(tpl, "loadMap", LoadMapDatabase);
+    Nan::SetPrototypeMethod(tpl, "saveMap", SaveMapDatabase);
+    Nan::SetPrototypeMethod(tpl, "enableMapping", EnableMappingModule);
+    Nan::SetPrototypeMethod(tpl, "reset", Reset);
+    Nan::SetPrototypeMethod(tpl, "terminate", Terminate);
+    Nan::SetPrototypeMethod(tpl, "disableMapping", DisableMappingModule);
+    Nan::SetPrototypeMethod(tpl, "shutdown", Shutdown);
+    Nan::SetPrototypeMethod(tpl, "relocalizeByPose", RelocalizeByPose);
+    Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("config").ToLocalChecked(), GetConfig);
+
+    constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
+    exports->Set(context,
+                Nan::New("System").ToLocalChecked(),
+                tpl->GetFunction(context).ToLocalChecked());
+}
+
+void System::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    if (info.IsConstructCall()) {
+        // Invoked as constructor
+        Config* cfg = Nan::ObjectWrap::Unwrap<Config>(
+            info[0]->ToObject(context).ToLocalChecked());
+        v8::String::Utf8Value vocab_file_path(isolate, info[1]);
+        System* obj = new System(*cfg, std::string(*vocab_file_path));
+        obj->Wrap(info.This());
+        info.GetReturnValue().Set(info.This());
+    } else {
+        // Invoked as plain function
+        const int argc = 2;
+        v8::Local<v8::Value> argv[argc] = {info[0], info[1]};
+        v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
+        info.GetReturnValue().Set(
+            cons->NewInstance(context, argc, argv).ToLocalChecked());
+    }
+}
+
+void System::GetFramePublisher(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    info.GetReturnValue().Set(FramePublisher::NewInstance(obj));
+}
+
+void System::GetMapPublisher(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    info.GetReturnValue().Set(MapPublisher::NewInstance(obj));
+}
+
+void System::Startup(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+    bool initialize = info[0]->IsUndefined() ? true : info[0]->BooleanValue(isolate);
+
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    obj->self->startup(initialize);
+}
+
+void System::FeedMonocularFrame(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    Mat* image = Nan::ObjectWrap::Unwrap<Mat>(
+        info[0]->ToObject(context).ToLocalChecked());
+    double timestamp = info[1]->NumberValue(context).FromJust();
+    cv::Mat mask = info[2]->IsUndefined() ? obj->mask : 
+        Nan::ObjectWrap::Unwrap<Mat>(
+            info[2]->ToObject(context).ToLocalChecked())->self;
+    obj->self->feed_monocular_frame(image->self, timestamp, mask);
+}
+
+void System::FeedStereoFrame(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    Mat* left_image = Nan::ObjectWrap::Unwrap<Mat>(
+        info[0]->ToObject(context).ToLocalChecked());
+    Mat* right_image = Nan::ObjectWrap::Unwrap<Mat>(
+        info[1]->ToObject(context).ToLocalChecked());
+    double timestamp = info[2]->NumberValue(context).FromJust();
+    cv::Mat mask = info[3]->IsUndefined() ? obj->mask : 
+        Nan::ObjectWrap::Unwrap<Mat>(
+            info[3]->ToObject(context).ToLocalChecked())->self;
+    obj->self->feed_stereo_frame(left_image->self, right_image->self, timestamp, mask);
+}
+
+void System::FeedRGBDFrame(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    Mat* rgb_image = Nan::ObjectWrap::Unwrap<Mat>(
+        info[0]->ToObject(context).ToLocalChecked());
+    Mat* depth_image = Nan::ObjectWrap::Unwrap<Mat>(
+        info[1]->ToObject(context).ToLocalChecked());
+    double timestamp = info[2]->NumberValue(context).FromJust();
+    cv::Mat mask = info[3]->IsUndefined() ? obj->mask : 
+        Nan::ObjectWrap::Unwrap<Mat>(
+            info[3]->ToObject(context).ToLocalChecked())->self;
+    obj->self->feed_RGBD_frame(rgb_image->self, depth_image->self, timestamp, mask);
+}
+
+void System::LoadMapDatabase(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    v8::String::Utf8Value path(isolate, info[0]);
+    obj->self->load_map_database(std::string(*path));
+}
+
+void System::SaveMapDatabase(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    v8::Isolate *isolate = info.GetIsolate();
+
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    v8::String::Utf8Value path(isolate, info[0]);
+    obj->self->save_map_database(std::string(*path));
+}
+
+void System::GetConfig(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    info.GetReturnValue().Set(Nan::New(obj->config));
+}
+
+void System::RelocalizeByPose(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    // v8::Isolate *isolate = info.GetIsolate();
+    // v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+    // System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    // stella_vslam::Mat44_t* mat = Nan::ObjectWrap::Unwrap<stella_vslam::Mat44_t>(
+    //     info[0]->ToObject(context).ToLocalChecked());
+    // obj->self->relocalize_by_pose(*mat);
+}
+
+void System::EnableMappingModule(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    obj->self->enable_mapping_module();
+}
+
+void System::DisableMappingModule(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    obj->self->disable_mapping_module();
+}
+
+void System::Shutdown(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    obj->self->shutdown();
+}
+
+void System::Terminate(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    obj->self->request_terminate();
+}
+
+void System::Reset(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    System* obj = ObjectWrap::Unwrap<System>(info.Holder());
+    obj->self->request_reset();
+}