Testing code from artoolkitx

emscripten/WebARKitJS.cpp

@@ -1,41 +1,115 @@
 #include "WebARKitJS.h"
 
+bool WebARKit::updateWithTwoDResults(float trackingTrans[3][4]) {
+
+    bool visible = false;
+    float m_twoDScale = 1.0f;
+
+    if (trackingTrans) {
+        visible = true;
+        for (int j = 0; j < 3; j++) {
+            trans[j][0] = (ARdouble)trackingTrans[j][0];
+            trans[j][1] = -(ARdouble)trackingTrans[j][1];
+            trans[j][2] = -(ARdouble)trackingTrans[j][2];
+            trans[j][3] = (ARdouble)(trackingTrans[j][3] * m_twoDScale * 0.001f * 1.64f);
+        }
+    } else
+        visible = false;
+
+    return visible;
+}
+
+void WebARKit::initialize_w(int videoWidth, int videoHeight, webarkit::TRACKER_TYPE trackerType) {
+    this->videoWidth = videoWidth;
+    this->videoHeight = videoHeight;
+    this->m_trackerType = trackerType;
+    m_tracker = std::make_shared<webarkit::WebARKitTracker>(webarkit::WebARKitTracker());
+    if (this->m_trackerType == webarkit::TRACKER_TYPE::AKAZE_TRACKER || webarkit::TRACKER_TYPE::ORB_TRACKER) {
+        m_tracker->initialize_w(trackerType, videoWidth, videoHeight);
+    } else {
+        throw std::invalid_argument("Invalid tracker type");
+    }
+}
+
+void WebARKit::loadARParam(std::string paramName, webarkit::TRACKER_TYPE trackerType, size_t xsize, size_t ysize) {
+    m_tracker->loadARParam(paramName, trackerType, xsize, ysize);
+}
+
+void WebARKit::addMarker(emscripten::val data_buffer, std::string filename, int width, int height, int markerID,
+                         float scale) {
+    auto u8 = emscripten::convertJSArrayToNumberVector<uint8_t>(data_buffer);
+    m_tracker->AddMarker(u8.data(), filename, width, height, markerID, scale);
+}
+
+bool WebARKit::GetTrackablePose(int trackableId, float transMat[3][4]) {
+    return m_tracker->GetTrackablePose(trackableId, transMat);
+};
+
+bool WebARKit::IsTrackableVisible(int trackableId) { return m_tracker->IsTrackableVisible(trackableId); }
+
+emscripten::val WebARKit::getPoseMatrix(int trackableId) {
+    emscripten::val res = emscripten::val::array();
+    if (IsTrackableVisible(trackableId)) {
+        float* ptr = m_tracker->GetTrackablePosePtr(trackableId);
+        for (auto i = 0; i < 9; i++) {
+            res.call<void>("push", ptr[i]);
+        }
+    }
+    return res;
+}
+
+emscripten::val WebARKit::updatePose(int trackableId) {
+
+    if (IsTrackableVisible(trackableId)) {
+        std::cout << "Trackable is visible" << std::endl;
+        float transMat[3][4];
+        if (GetTrackablePose(trackableId, transMat)) {
+            bool success = updateWithTwoDResults(transMat);
+        } else {
+            updateWithTwoDResults(NULL);
+        }
+    } else {
+        updateWithTwoDResults(NULL);
+    }
+
+    return emscripten::val(emscripten::typed_memory_view(3 * 4, (ARdouble*)trans));
+}
+
 void WebARKit::initTrackerGray(emscripten::val data_buffer, int width, int height) {
-  auto u8 =
-      emscripten::convertJSArrayToNumberVector<uint8_t>(data_buffer);
-  m_tracker->initTracker(u8.data(), width, height);
+    auto u8 = emscripten::convertJSArrayToNumberVector<uint8_t>(data_buffer);
+    m_tracker->initTracker(u8.data(), width, height);
 }
 
 void WebARKit::processFrame(emscripten::val data_buffer, webarkit::ColorSpace colorSpace) {
-  auto u8 =
-      emscripten::convertJSArrayToNumberVector<uint8_t>(data_buffer);
-  m_tracker->processFrameData(u8.data(), this->videoWidth,
-                                      this->videoHeight, colorSpace);
+    auto u8 = emscripten::convertJSArrayToNumberVector<uint8_t>(data_buffer);
+    m_tracker->processFrameData(u8.data(), this->videoWidth, this->videoHeight, colorSpace);
 }
 
-emscripten::val WebARKit::getHomography() {
-  std::vector<double> output;
-   output = m_tracker->getOutputData();
-  emscripten::val homography = emscripten::val::array();
-  for (auto i = 0; i < 9; i++) {
-    homography.call<void>("push", output[i]);
-  }
-  return homography;
+void WebARKit::processFrame_w(emscripten::val data_buffer) {
+    auto u8 = emscripten::convertJSArrayToNumberVector<uint8_t>(data_buffer);
+    m_tracker->ProcessFrameData_w(u8.data());
 }
 
+emscripten::val WebARKit::getHomography() {
+    std::vector<double> output;
+    output = m_tracker->getOutputData();
+    emscripten::val homography = emscripten::val::array();
+    for (auto i = 0; i < 9; i++) {
+        homography.call<void>("push", output[i]);
+    }
+    return homography;
+}
 
 emscripten::val WebARKit::getCorners() {
-   std::vector<double> output;
-  output = m_tracker->getOutputData();
-  emscripten::val corners = emscripten::val::array();
-  for (auto i = 9; i < 17; i++) {
-    corners.call<void>("push", output[i]);
-  }
-  return corners;
+    std::vector<double> output;
+    output = m_tracker->getOutputData();
+    emscripten::val corners = emscripten::val::array();
+    for (auto i = 9; i < 17; i++) {
+        corners.call<void>("push", output[i]);
+    }
+    return corners;
 }
 
-bool WebARKit::isValid() {
-  return m_tracker->isValid();
-}
+bool WebARKit::isValid() { return m_tracker->isValid(); }
 
 #include "bindings.cpp"

emscripten/WebARKitJS.h

@@ -3,9 +3,9 @@
 #include <AR2/imageFormat.h>
 #include <AR2/util.h>
 /*#include <WebARKitTrackers/WebARKitOpticalTracking/WebARKitAkazeTracker.h>
+#include <WebARKitTrackers/WebARKitOpticalTracking/WebARKitEnums.h>
 #include <WebARKitTrackers/WebARKitOpticalTracking/WebARKitOrbTracker.h>*/
 #include <WebARKitTrackers/WebARKitOpticalTracking/WebARKitTracker.h>
-#include <WebARKitTrackers/WebARKitOpticalTracking/WebARKitEnums.h>
 #include <emscripten.h>
 #include <emscripten/val.h>
 #include <iostream>
@@ -18,32 +18,52 @@
 #include <unordered_map>
 #include <vector>
 
+
 using namespace emscripten;
 
 class WebARKit {
-public:
-  WebARKit() = default;
-  WebARKit(int videoWidth, int videoHeight,  webarkit::TRACKER_TYPE trackerType) {
-    this->videoWidth = videoWidth;
-    this->videoHeight = videoHeight;
-    this->m_trackerType = trackerType;
-     m_tracker = std::make_shared<webarkit::WebARKitTracker>(webarkit::WebARKitTracker());
-    if(this->m_trackerType == webarkit::TRACKER_TYPE::AKAZE_TRACKER || webarkit::TRACKER_TYPE::ORB_TRACKER) {
-      m_tracker->initialize(trackerType);
-    } else {
-      throw std::invalid_argument("Invalid tracker type");
+  public:
+    WebARKit() = default;
+
+    WebARKit(int videoWidth, int videoHeight, webarkit::TRACKER_TYPE trackerType) {
+        this->videoWidth = videoWidth;
+        this->videoHeight = videoHeight;
+        this->m_trackerType = trackerType;
+        m_tracker = std::make_shared<webarkit::WebARKitTracker>(webarkit::WebARKitTracker());
+        if (this->m_trackerType == webarkit::TRACKER_TYPE::AKAZE_TRACKER || webarkit::TRACKER_TYPE::ORB_TRACKER) {
+            m_tracker->initialize(trackerType);
+        } else {
+            throw std::invalid_argument("Invalid tracker type");
+        }
     }
-  }
-
-  void initTrackerGray(emscripten::val data_buffer, int width, int height);
-  void processFrame(emscripten::val data_buffer, webarkit::ColorSpace colorSpace);
-  emscripten::val getHomography();
-  emscripten::val getCorners();
-  bool isValid();
-
-private:
-  int videoWidth;
-  int videoHeight;
-  int m_trackerType;
-  std::shared_ptr<webarkit::WebARKitTracker> m_tracker;
+
+    void initialize_w(int videoWidth, int videoHeight, webarkit::TRACKER_TYPE trackerType);
+
+    void loadARParam(std::string paramName, webarkit::TRACKER_TYPE trackerType, size_t xsize, size_t ysize);
+
+    void addMarker(emscripten::val data_buffer, std::string filename, int width, int height, int markerID, float scale);
+
+    bool GetTrackablePose(int trackableId, float transMat[3][4]);
+
+    bool IsTrackableVisible(int trackableId);
+
+    emscripten::val getPoseMatrix(int trackableId);
+
+    emscripten::val updatePose(int trackableId);
+
+    bool updateWithTwoDResults(float trackingTrans[3][4]);
+
+    void initTrackerGray(emscripten::val data_buffer, int width, int height);
+    void processFrame(emscripten::val data_buffer, webarkit::ColorSpace colorSpace);
+    void processFrame_w(emscripten::val data_buffer);
+    emscripten::val getHomography();
+    emscripten::val getCorners();
+    bool isValid();
+
+  private:
+    ARdouble trans[3][4]; 
+    int videoWidth;
+    int videoHeight;
+    int m_trackerType;
+    std::shared_ptr<webarkit::WebARKitTracker> m_tracker;
 };

emscripten/bindings.cpp

@@ -15,8 +15,16 @@ EMSCRIPTEN_BINDINGS(constant_bindings) {
   class_<WebARKit>("WebARKit")
       .constructor<>()
       .constructor<int, int, webarkit::TRACKER_TYPE>()
+      .function("initialize_w", &WebARKit::initialize_w)
+      .function("loadARParam", &WebARKit::loadARParam)
+      .function("addMarker", &WebARKit::addMarker)
+      .function("GetTrackablePose", &WebARKit::GetTrackablePose, allow_raw_pointers())
+      .function("getPoseMatrix", &WebARKit::getPoseMatrix)
+      .function("IsTrackableVisible", &WebARKit::IsTrackableVisible)
+      .function("updatePose", &WebARKit::updatePose)
       .function("initTrackerGray", &WebARKit::initTrackerGray)
       .function("processFrame", &WebARKit::processFrame)
+      .function("processFrame_w", &WebARKit::processFrame_w)
       .function("getHomography", &WebARKit::getHomography)
       .function("getCorners", &WebARKit::getCorners)
       .function("isValid", &WebARKit::isValid);

examples/akaze_example_w.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <title>Simple example with WebARKit</title>
+  <meta http-equiv="X-UA-Compatible" content="chrome=1">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <script src="../dist/GrayScale.js"></script>
+  <script type="text/javascript" src="stats.min.js"></script>
+  <script type="module" src="index_akaze_w.js"></script>
+  <link rel="stylesheet" href="css/style.css">
+</head>
+
+<body>
+  <div id="stats"></div>
+  <img id="refIm" src="./data/pinball.jpg" width="1637" height="2048" style="display:none;">
+  <img id="arElem" src="./data/aframe-k.png"></img>
+  <div id="loading">Loading Image Tracking Modules...</div>
+</body>
+
+</html>