feat: use oatpp::DTO to parse img-input-connector APIData

Author: sileht

src/apidata.h

@@ -38,6 +38,7 @@
 #include <vector>
 #include <sstream>
 #include <typeinfo>
+#include "oatpp/parser/json/mapping/ObjectMapper.hpp"
 
 namespace dd
 {
@@ -272,6 +273,31 @@ namespace dd
      */
     void toJVal(JDoc &jd, JVal &jv) const;
 
+    /**
+     * \brief converts APIData to oat++ DTO
+     */
+    template <typename T> inline std::shared_ptr<T> createSharedDTO() const
+    {
+      rapidjson::Document d;
+      d.SetObject();
+      toJDoc(reinterpret_cast<JDoc &>(d));
+
+      rapidjson::StringBuffer buffer;
+      rapidjson::Writer<rapidjson::StringBuffer, rapidjson::UTF8<>,
+                        rapidjson::UTF8<>, rapidjson::CrtAllocator,
+                        rapidjson::kWriteNanAndInfFlag>
+          writer(buffer);
+      bool done = d.Accept(writer);
+      if (!done)
+        throw DataConversionException("JSON rendering failed");
+
+      std::shared_ptr<oatpp::data::mapping::ObjectMapper> object_mapper
+          = oatpp::parser::json::mapping::ObjectMapper::createShared();
+      return object_mapper
+          ->readFromString<oatpp::Object<T>>(buffer.GetString())
+          .getPtr();
+    }
+
   public:
     /**
      * \brief render Mustache template based on this APIData object

src/dto/img_connector.hpp

@@ -0,0 +1,69 @@
+/**
+ * DeepDetect
+ * Copyright (c) 2021 Jolibrain SASU
+ * Author: Mehdi Abaakouk <mehdi.abaakouk@jolibrain.com>
+ *
+ * This file is part of deepdetect.
+ *
+ * deepdetect is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * deepdetect is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with deepdetect.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HTTP_DTO_IMG_CONNECTOR_HPP
+#define HTTP_DTO_IMG_CONNECTOR_HPP
+
+#include "dd_config.h"
+#include "oatpp/core/Types.hpp"
+#include "oatpp/core/macro/codegen.hpp"
+
+namespace dd
+{
+  namespace DTO
+  {
+#include OATPP_CODEGEN_BEGIN(DTO)
+
+    class ImgInputConnectorParameters : public oatpp::DTO
+    {
+      DTO_INIT(ImgInputConnectorParameters, DTO /* extends */)
+
+      DTO_FIELD(Int32, width);
+      DTO_FIELD(Int32, height);
+      DTO_FIELD(Int32, crop_width);
+      DTO_FIELD(Int32, crop_height);
+      DTO_FIELD(Boolean, bw);
+      DTO_FIELD(Boolean, rgb);
+      DTO_FIELD(Boolean, histogram_equalization);
+      DTO_FIELD(Boolean, unchanged_data);
+      DTO_FIELD(Boolean, shuffle);
+      DTO_FIELD(Int32, seed);
+      DTO_FIELD(Float64, test_split);
+      DTO_FIELD(Vector<Float32>, mean);
+      DTO_FIELD(Vector<Float32>, std);
+      DTO_FIELD(Float64, scale);
+      DTO_FIELD(Boolean, scaled);
+      DTO_FIELD(Int32, scale_min);
+      DTO_FIELD(Int32, scale_max);
+      DTO_FIELD(Boolean, keep_orig);
+      DTO_FIELD(String, interp);
+
+      // image resizing on GPU
+#ifdef USE_CUDA_CV
+      DTO_FIELD(Boolean, cuda);
+#endif
+    };
+
+#include OATPP_CODEGEN_END(DTO)
+  }
+}
+
+#endif

src/imginputfileconn.h

@@ -43,6 +43,8 @@
 #include "utils/apitools.h"
 #include <random>
 
+#include "dto/img_connector.hpp"
+
 namespace dd
 {
 
@@ -455,81 +457,89 @@ namespace dd
 
     void fillup_parameters(const APIData &ad)
     {
+      auto params = ad.createSharedDTO<dd::DTO::ImgInputConnectorParameters>();
+
       // optional parameters.
-      if (ad.has("width"))
-        _width = ad.get("width").get<int>();
-      if (ad.has("height"))
-        _height = ad.get("height").get<int>();
-      if (ad.has("crop_width"))
+      if (params->width)
+        _width = params->width;
+      if (params->height)
+        _height = params->height;
+      if (params->crop_width)
         {
-          _crop_width = ad.get("crop_width").get<int>();
-          if (_crop_width > _width)
+          if (params->crop_width > _width)
             {
               _logger->error("Crop width must be less than or equal to width");
               throw InputConnectorBadParamException(
                   "Crop width must be less than or equal to width");
             }
+          _width = params->crop_width;
         }
-      if (ad.has("crop_height"))
+      if (params->crop_height)
         {
-          _crop_height = ad.get("crop_height").get<int>();
-          if (_crop_height > _height)
+          if (params->crop_height > _height)
             {
               _logger->error(
                   "Crop height must be less than or equal to height");
               throw InputConnectorBadParamException(
                   "Crop height must be less than or equal to height");
             }
+          _height = params->crop_height;
         }
-      if (ad.has("bw"))
-        _bw = ad.get("bw").get<bool>();
-      if (ad.has("rgb"))
-        _rgb = ad.get("rgb").get<bool>();
-      if (ad.has("histogram_equalization"))
-        _histogram_equalization = ad.get("histogram_equalization").get<bool>();
-      if (ad.has("unchanged_data"))
-        _unchanged_data = ad.get("unchanged_data").get<bool>();
-      if (ad.has("shuffle"))
-        _shuffle = ad.get("shuffle").get<bool>();
-      if (ad.has("seed"))
-        _seed = ad.get("seed").get<int>();
-      if (ad.has("test_split"))
-        _test_split = ad.get("test_split").get<double>();
-      if (ad.has("mean"))
+
+      _bw |= params->bw;
+      _rgb |= params->rgb;
+      _histogram_equalization |= params->histogram_equalization;
+      _unchanged_data |= params->unchanged_data;
+      _shuffle |= params->shuffle;
+      if (params->seed)
+        _seed = params->seed;
+      if (params->test_split)
+        _test_split = params->test_split;
+      if (params->mean)
         {
-          apitools::get_floats(ad, "mean", _mean);
+          // NOTE(sileht): if we have two much of this we can create
+          // an oat++ type that directly handle std::vector<float> instead
+          // of using the oatpp::Vector<oatpp::Float32>
+          _mean = std::vector<float>();
+          for (auto &v : *params->mean)
+            _mean.push_back(v);
           _has_mean_scalar = true;
         }
-      if (ad.has("std"))
+      if (params->std)
         {
-          apitools::get_floats(ad, "std", _std);
+          _std = std::vector<float>();
+          for (auto &v : *params->std)
+            _std.push_back(v);
         }
 
       // Variable size
-      if (ad.has("scale"))
-        _scale = ad.get("scale").get<double>();
-      if (ad.has("scaled") || ad.has("scale_min") || ad.has("scale_max"))
-        _scaled = true;
-      if (ad.has("scale_min"))
-        _scale_min = ad.get("scale_min").get<int>();
-      if (ad.has("scale_max"))
-        _scale_max = ad.get("scale_max").get<int>();
+      _scaled |= params->scaled;
+      if (params->scale)
+        _scale = params->scale;
+      if (params->scale_min)
+        {
+          _scaled = true;
+          _scale_min = params->scale_min;
+        }
+      if (params->scale_max)
+        {
+          _scaled = true;
+          _scale_max = params->scale_max;
+        }
 
       // whether to keep original image (for chained ops, e.g. cropping)
-      if (ad.has("keep_orig"))
-        _keep_orig = ad.get("keep_orig").get<bool>();
+      _keep_orig |= params->keep_orig;
 
       // image interpolation method
-      if (ad.has("interp"))
-        _interp = ad.get("interp").get<std::string>();
+      if (params->interp)
+        _interp = params->interp->std_str();
 
       // timeout
       this->set_timeout(ad);
 
 #ifdef USE_CUDA_CV
       // image resizing on GPU
-      if (ad.has("cuda"))
-        _cuda = ad.get("cuda").get<bool>();
+      _cuda |= params->cuda;
 #endif
     }