test: add test for torch inference in base64

Author: Bycob

src/backends/caffe/caffelib.cc

@@ -3551,6 +3551,9 @@ namespace dd
                     = _net->blob_by_name("cont_seq");
                 // cont_seq is TxN
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+
                 CSVTSCaffeInputFileConn *ic
                     = reinterpret_cast<CSVTSCaffeInputFileConn *>(&inputc);
 
@@ -3638,6 +3641,7 @@ namespace dd
                         series.push_back(ts);
                       }
                   }
+#pragma GCC diagnostic pop
               }
             else // classification
               {

src/utils/cv_utils.hpp

@@ -23,13 +23,15 @@
 #define DD_UTILS_CVUTILS_HPP
 
 #include <vector>
+#include <opencv2/opencv.hpp>
+#include "ext/base64/base64.h"
 
 namespace dd
 {
   namespace cv_utils
   {
     /** Convert an int fourcc (from a video) to string format */
-    std::string fourcc_to_string(int fourcc)
+    inline std::string fourcc_to_string(int fourcc)
     {
       union
       {
@@ -44,6 +46,33 @@ namespace dd
           (i32_c.c[2] >= ' ' && i32_c.c[2] < 128) ? i32_c.c[2] : '?',
           (i32_c.c[3] >= ' ' && i32_c.c[3] < 128) ? i32_c.c[3] : '?');
     }
+
+    inline cv::Mat base64_to_image(const std::string &str_base64)
+    {
+      std::string img_str;
+      if (!Base64::Decode(str_base64, &img_str))
+        throw std::runtime_error("Image could not be decoded");
+
+      std::vector<unsigned char> vdat(img_str.begin(), img_str.end());
+      cv::Mat img
+          = cv::Mat(cv::imdecode(cv::Mat(vdat, false), cv::IMREAD_UNCHANGED));
+      return img;
+    }
+
+    /** Convert image to base64 string */
+    inline std::string image_to_base64(const cv::Mat &mat,
+                                       const std::string &ext)
+    {
+      std::vector<uint8_t> buffer;
+      cv::imencode(ext, mat, buffer);
+
+      // encode to base64
+      std::string byte_str(buffer.begin(), buffer.end());
+      std::string encoded;
+      if (!Base64::Encode(byte_str, &encoded))
+        throw std::runtime_error("Image could not be encoded");
+      return encoded;
+    }
   }
 }
 

tests/ut-torchapi.cc

@@ -20,18 +20,23 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with deepdetect.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-#include "deepdetect.h"
-#include "jsonapi.h"
-#include "txtinputfileconn.h"
 #include <gtest/gtest.h>
 #include <stdio.h>
 #include <iostream>
 #include <numeric>
-#include "backends/torch/native/templates/nbeats.h"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-variable"
 #include <torch/torch.h>
+#pragma GCC diagnostic pop
 #include <rapidjson/istreamwrapper.h>
 
+#include "deepdetect.h"
+#include "jsonapi.h"
+#include "txtinputfileconn.h"
+#include "utils/cv_utils.hpp"
+#include "backends/torch/native/templates/nbeats.h"
+
 using namespace dd;
 
 static std::string ok_str = "{\"status\":{\"code\":200,\"msg\":\"OK\"}}";
@@ -383,6 +388,7 @@ TEST(torchapi, service_predict_object_detection)
                 "\"best_bbox\":3}},\"data\":[\""
                 + detect_repo + "cat.jpg\"]}";
   joutstr = japi.jrender(japi.service_predict(jpredictstr));
+  jd = JDoc();
   std::cout << "joutstr=" << joutstr << std::endl;
   jd.Parse<rapidjson::kParseNanAndInfFlag>(joutstr.c_str());
 
@@ -392,6 +398,26 @@ TEST(torchapi, service_predict_object_detection)
 
   auto &preds_best = jd["body"]["predictions"][0]["classes"];
   ASSERT_EQ(preds_best.Size(), 3);
+
+  // base64
+  cv::Mat img = cv::imread(detect_repo + "cat.jpg");
+  std::string b64_str = cv_utils::image_to_base64(img, ".png");
+  jpredictstr = "{\"service\":\"detectserv\",\"parameters\":{"
+                "\"input\":{\"height\":224,"
+                "\"width\":224},\"output\":{\"bbox\":true, "
+                "\"best_bbox\":3}},\"data\":[\""
+                + b64_str + "\"]}";
+  joutstr = japi.jrender(japi.service_predict(jpredictstr));
+  jd = JDoc();
+  std::cout << "joutstr=" << joutstr << std::endl;
+  jd.Parse<rapidjson::kParseNanAndInfFlag>(joutstr.c_str());
+
+  ASSERT_TRUE(!jd.HasParseError());
+  ASSERT_EQ(200, jd["status"]["code"]);
+  ASSERT_TRUE(jd["body"]["predictions"].IsArray());
+
+  auto &preds_best_b64 = jd["body"]["predictions"][0]["classes"];
+  ASSERT_EQ(preds_best_b64.Size(), 3);
 }
 
 TEST(torchapi, service_predict_object_detection_any_size)