using 'cpplint --filter=-build/include_subdir,-build/c++11' to check cpp code...

using 'cpplint --filter=-build/include_subdir,-build/c++11' to check cpp code style of all *.h, *.cpp

inference/demo.cpp

@@ -23,7 +23,8 @@ int main(int argc, char** argv) {
     // 0. parse args
     google::ParseCommandLineFlags(&argc, &argv, true);
     if (FLAGS_conf.empty() || FLAGS_input_dir.empty()) {
-        std::cout << "Usage: ./predictor --conf=/config/path/to/your/model --input_dir=/directory/of/your/input/images";
+        std::cout << "Usage: ./predictor --conf=/config/path/to/your/model "
+                  << "--input_dir=/directory/of/your/input/images";
         return -1;
     }
     // 1. create a predictor and init it with conf

inference/predictor/seg_predictor.cpp

@@ -16,7 +16,7 @@
 #include <unsupported/Eigen/CXX11/Tensor>
 #undef min
 namespace PaddleSolution {
-
+    using std::chrono::duration_cast;
     int Predictor::init(const std::string& conf) {
         if (!_model_config.load_config(conf)) {
             LOG(FATAL) << "Fail to load config file: [" << conf << "]";
@@ -28,8 +28,9 @@ namespace PaddleSolution {
             return -1;
         }
 
-            _mask.resize(_model_config._resize[0] * _model_config._resize[1]);
-            _scoremap.resize(_model_config._resize[0] * _model_config._resize[1]);
+        int res_size = _model_config._resize[0] * _model_config._resize[1];
+        _mask.resize(res_size);
+        _scoremap.resize(res_size);
 
         bool use_gpu = _model_config._use_gpu;
         const auto& model_dir = _model_config._model_path;
@@ -47,8 +48,7 @@ namespace PaddleSolution {
             config.use_gpu = use_gpu;
             config.device = 0;
             _main_predictor = paddle::CreatePaddlePredictor(config);
-            }
-            else if (_model_config._predictor_mode == "ANALYSIS") {
+        } else if (_model_config._predictor_mode == "ANALYSIS") {
             paddle::AnalysisConfig config;
             if (use_gpu) {
                 config.EnableUseGpu(100, 0);
@@ -60,25 +60,23 @@ namespace PaddleSolution {
             config.SwitchSpecifyInputNames(true);
             config.EnableMemoryOptim();
             _main_predictor = paddle::CreatePaddlePredictor(config);
-            }
-            else {
+        } else {
             return -1;
         }
         return 0;
-
     }
 
     int Predictor::predict(const std::vector<std::string>& imgs) {
         if (_model_config._predictor_mode == "NATIVE") {
             return native_predict(imgs);
-            }
-            else if (_model_config._predictor_mode == "ANALYSIS") {
+        } else if (_model_config._predictor_mode == "ANALYSIS") {
             return analysis_predict(imgs);
         }
         return -1;
     }
 
-        int Predictor::output_mask(const std::string& fname, float* p_out, int length, int* height, int* width) {
+    int Predictor::output_mask(const std::string& fname, float* p_out,
+                               int length, int* height, int* width) {
         int eval_width = _model_config._resize[0];
         int eval_height = _model_config._resize[1];
         int eval_num_class = _model_config._class_num;
@@ -91,8 +89,7 @@ namespace PaddleSolution {
                 seg_out_len << "|" << blob_out_len << "]" << std::endl;
             return -1;
         }
-
-            //post process
+        // post process
         _mask.clear();
         _scoremap.clear();
         std::vector<int> out_shape{eval_num_class, eval_height, eval_width};
@@ -106,15 +103,18 @@ namespace PaddleSolution {
         cv::imwrite(mask_save_name, mask_png);
         cv::Mat scoremap_png = cv::Mat(eval_height, eval_width, CV_8UC1);
         scoremap_png.data = _scoremap.data();
-            std::string scoremap_save_name = nname + std::string("_scoremap.png");
+        std::string scoremap_save_name = nname
+                                       + std::string("_scoremap.png");
         cv::imwrite(scoremap_save_name, scoremap_png);
         std::cout << "save mask of [" << fname << "] done" << std::endl;
 
         if (height && width) {
             int recover_height = *height;
             int recover_width = *width;
-                cv::Mat recover_png = cv::Mat(recover_height, recover_width, CV_8UC1);
-                cv::resize(scoremap_png, recover_png, cv::Size(recover_width, recover_height),
+            cv::Mat recover_png = cv::Mat(recover_height,
+                                          recover_width, CV_8UC1);
+            cv::resize(scoremap_png, recover_png,
+                       cv::Size(recover_width, recover_height),
                        0, 0, cv::INTER_CUBIC);
             std::string recover_name = nname + std::string("_recover.png");
             cv::imwrite(recover_name, recover_png);
@@ -122,8 +122,7 @@ namespace PaddleSolution {
         return 0;
     }
 
-        int Predictor::native_predict(const std::vector<std::string>& imgs)
-        {
+    int Predictor::native_predict(const std::vector<std::string>& imgs) {
         if (imgs.size() == 0) {
             LOG(ERROR) << "No image found";
             return -1;
@@ -134,9 +133,12 @@ namespace PaddleSolution {
         int eval_width = _model_config._resize[0];
         int eval_height = _model_config._resize[1];
         std::size_t total_size = imgs.size();
-            int default_batch_size = std::min(config_batch_size, (int)total_size);
-            int batch = total_size / default_batch_size + ((total_size % default_batch_size) != 0);
-            int batch_buffer_size = default_batch_size * channels * eval_width * eval_height;
+        int default_batch_size = std::min(config_batch_size,
+                                          static_cast<int>(total_size));
+        int batch = total_size / default_batch_size
+                  + ((total_size % default_batch_size) != 0);
+        int batch_buffer_size = default_batch_size * channels
+                              * eval_width * eval_height;
 
         auto& input_buffer = _buffer;
         auto& org_width = _org_width;
@@ -152,7 +154,8 @@ namespace PaddleSolution {
                 batch_size = total_size % default_batch_size;
             }
 
-                int real_buffer_size = batch_size * channels * eval_width * eval_height;
+            int real_buffer_size = batch_size * channels
+                                 * eval_width * eval_height;
             std::vector<paddle::PaddleTensor> feeds;
             input_buffer.resize(real_buffer_size);
             org_height.resize(batch_size);
@@ -165,23 +168,31 @@ namespace PaddleSolution {
                 int idx = u * default_batch_size + i;
                 imgs_batch.push_back(imgs[idx]);
             }
-                if (!_preprocessor->batch_process(imgs_batch, input_buffer.data(), org_width.data(), org_height.data())) {
+            if (!_preprocessor->batch_process(imgs_batch,
+                                              input_buffer.data(),
+                                              org_width.data(),
+                                              org_height.data())) {
                 return -1;
             }
             paddle::PaddleTensor im_tensor;
             im_tensor.name = "image";
-                im_tensor.shape = std::vector<int>({ batch_size, channels, eval_height, eval_width });
-                im_tensor.data.Reset(input_buffer.data(), real_buffer_size * sizeof(float));
+            im_tensor.shape = std::vector<int>{ batch_size, channels,
+                                                 eval_height, eval_width };
+            im_tensor.data.Reset(input_buffer.data(),
+                                 real_buffer_size * sizeof(float));
             im_tensor.dtype = paddle::PaddleDType::FLOAT32;
             feeds.push_back(im_tensor);
             _outputs.clear();
             auto t1 = std::chrono::high_resolution_clock::now();
             if (!_main_predictor->Run(feeds, &_outputs, batch_size)) {
-                    LOG(ERROR) << "Failed: NativePredictor->Run() return false at batch: " << u;
+                LOG(ERROR) <<
+                   "Failed: NativePredictor->Run() return false at batch: "
+                 << u;
                 continue;
             }
             auto t2 = std::chrono::high_resolution_clock::now();
-                auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
+            auto duration = duration_cast<std::chrono::microseconds>
+                            (t2 - t1).count();
             std::cout << "runtime = " << duration << std::endl;
             int out_num = 1;
             // print shape of first output tensor for debugging
@@ -191,15 +202,21 @@ namespace PaddleSolution {
                 std::cout << _outputs[0].shape[j] << ",";
             }
             std::cout << ")" << std::endl;
-                const size_t nums = _outputs.front().data.length() / sizeof(float);
+            const size_t nums = _outputs.front().data.length()
+                              / sizeof(float);
             if (out_num % batch_size != 0 || out_num != nums) {
                 LOG(ERROR) << "outputs data size mismatch with shape size.";
                 return -1;
             }
 
             for (int i = 0; i < batch_size; ++i) {
-                    float* output_addr = (float*)(_outputs[0].data.data()) + i * (out_num / batch_size);
-                    output_mask(imgs_batch[i], output_addr, out_num / batch_size, &org_height[i], &org_width[i]);
+                float* output_addr = reinterpret_cast<float*>(
+                                    _outputs[0].data.data())
+                                   + i * (out_num / batch_size);
+                output_mask(imgs_batch[i], output_addr,
+                            out_num / batch_size,
+                            &org_height[i],
+                            &org_width[i]);
             }
         }
 
@@ -207,7 +224,6 @@ namespace PaddleSolution {
     }
 
     int Predictor::analysis_predict(const std::vector<std::string>& imgs) {
-
         if (imgs.size() == 0) {
             LOG(ERROR) << "No image found";
             return -1;
@@ -218,9 +234,12 @@ namespace PaddleSolution {
         int eval_width = _model_config._resize[0];
         int eval_height = _model_config._resize[1];
         auto total_size = imgs.size();
-            int default_batch_size = std::min(config_batch_size, (int)total_size);
-            int batch = total_size / default_batch_size + ((total_size % default_batch_size) != 0);
-            int batch_buffer_size = default_batch_size * channels * eval_width * eval_height;
+        int default_batch_size = std::min(config_batch_size,
+                                          static_cast<int>(total_size));
+        int batch = total_size / default_batch_size
+                  + ((total_size % default_batch_size) != 0);
+        int batch_buffer_size = default_batch_size * channels
+                              * eval_width * eval_height;
 
         auto& input_buffer = _buffer;
         auto& org_width = _org_width;
@@ -237,7 +256,8 @@ namespace PaddleSolution {
                 batch_size = total_size % default_batch_size;
             }
 
-                int real_buffer_size = batch_size * channels * eval_width * eval_height;
+            int real_buffer_size = batch_size * channels
+                                 * eval_width * eval_height;
             std::vector<paddle::PaddleTensor> feeds;
             input_buffer.resize(real_buffer_size);
             org_height.resize(batch_size);
@@ -251,21 +271,27 @@ namespace PaddleSolution {
                 imgs_batch.push_back(imgs[idx]);
             }
 
-                if (!_preprocessor->batch_process(imgs_batch, input_buffer.data(), org_width.data(), org_height.data())) {
+            if (!_preprocessor->batch_process(imgs_batch,
+                                              input_buffer.data(),
+                                              org_width.data(),
+                                              org_height.data())) {
                 return -1;
             }
             auto im_tensor = _main_predictor->GetInputTensor("image");
-                im_tensor->Reshape({ batch_size, channels, eval_height, eval_width });
+            im_tensor->Reshape({ batch_size, channels,
+                                 eval_height, eval_width });
             im_tensor->copy_from_cpu(input_buffer.data());
 
             auto t1 = std::chrono::high_resolution_clock::now();
             _main_predictor->ZeroCopyRun();
             auto t2 = std::chrono::high_resolution_clock::now();
-                auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
+            auto duration = duration_cast<std::chrono::microseconds>
+                            (t2 - t1).count();
             std::cout << "runtime = " << duration << std::endl;
 
             auto output_names = _main_predictor->GetOutputNames();
-                auto output_t = _main_predictor->GetOutputTensor(output_names[0]);
+            auto output_t = _main_predictor->GetOutputTensor(
+                                              output_names[0]);
             std::vector<float> out_data;
             std::vector<int> output_shape = output_t->shape();
 
@@ -280,10 +306,12 @@ namespace PaddleSolution {
             out_data.resize(out_num);
             output_t->copy_to_cpu(out_data.data());
             for (int i = 0; i < batch_size; ++i) {
-                    float* out_addr = out_data.data() + (out_num / batch_size) * i;
-                    output_mask(imgs_batch[i], out_addr, out_num / batch_size, &org_height[i], &org_width[i]);
+                float* out_addr = out_data.data()
+                               + (out_num / batch_size) * i;
+                output_mask(imgs_batch[i], out_addr, out_num / batch_size,
+                            &org_height[i], &org_width[i]);
             }
         }
         return 0;
     }
-}
+}  // namespace PaddleSolution

inference/predictor/seg_predictor.h

+// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #pragma once
 
+#include <glog/logging.h>
+#include <yaml-cpp/yaml.h>
+
 #include <memory>
 #include <string>
 #include <vector>
 #include <thread>
 #include <chrono>
 #include <algorithm>
-#include <glog/logging.h>
-#include <yaml-cpp/yaml.h>
-#include <opencv2/opencv.hpp>
-#include <paddle_inference_api.h>
 
-#include <utils/seg_conf_parser.h>
-#include <utils/utils.h>
-#include <preprocessor/preprocessor.h>
+#include <paddle_inference_api.h>
+#include <opencv2/opencv.hpp>
+#include "utils/seg_conf_parser.h"
+#include "utils/utils.h"
+#include "preprocessor/preprocessor.h"
 
 namespace PaddleSolution {
-    class Predictor {
+class Predictor {
  public:
     // init a predictor with a yaml config file
     int init(const std::string& conf);
     // predict api
     int predict(const std::vector<std::string>& imgs);
-            
  private:
-            int output_mask(
-                const std::string& fname,
-                float* p_out,
-                int length,
-                int* height = NULL,
-                int* width = NULL);
+    int output_mask(const std::string& fname, float* p_out, int length,
+                int* height = NULL, int* width = NULL);
     int native_predict(const std::vector<std::string>& imgs);
     int analysis_predict(const std::vector<std::string>& imgs);
  private:
@@ -45,5 +55,5 @@ namespace PaddleSolution {
     PaddleSolution::PaddleSegModelConfigPaser _model_config;
     std::shared_ptr<PaddleSolution::ImagePreProcessor> _preprocessor;
     std::unique_ptr<paddle::PaddlePredictor> _main_predictor;
-    };
-}
+};
+}  // namespace PaddleSolution

inference/preprocessor/preprocessor.cpp

@@ -21,9 +21,10 @@
 
 namespace PaddleSolution {
 
-    std::shared_ptr<ImagePreProcessor> create_processor(const std::string& conf_file) {
-
-        auto config = std::make_shared<PaddleSolution::PaddleSegModelConfigPaser>();
+    std::shared_ptr<ImagePreProcessor> create_processor(
+                           const std::string& conf_file) {
+        auto config = std::make_shared<PaddleSolution::
+                        PaddleSegModelConfigPaser>();
         if (!config->load_config(conf_file)) {
             LOG(FATAL) << "fail to laod conf file [" << conf_file << "]";
             return nullptr;
@@ -37,9 +38,9 @@ namespace PaddleSolution {
             return p;
         }
 
-        LOG(FATAL) << "unknown processor_name [" << config->_pre_processor << "]";
+        LOG(FATAL) << "unknown processor_name [" << config->_pre_processor
+                   << "]";
 
         return nullptr;
     }
-}
-
+}  // namespace PaddleSolution

inference/preprocessor/preprocessor.h

@@ -26,18 +26,19 @@
 namespace  PaddleSolution {
 
 class ImagePreProcessor {
-protected:
-    ImagePreProcessor() {};
-    
-public:
+ protected:
+    ImagePreProcessor() {}
+ public:
     virtual ~ImagePreProcessor() {}
 
-    virtual bool single_process(const std::string& fname, float* data, int* ori_w, int* ori_h) = 0;
-
-    virtual bool batch_process(const std::vector<std::string>& imgs, float* data, int* ori_w, int* ori_h) = 0;
+    virtual bool single_process(const std::string& fname, float* data,
+                                int* ori_w, int* ori_h) = 0;
 
+    virtual bool batch_process(const std::vector<std::string>& imgs,
+                               float* data, int* ori_w, int* ori_h) = 0;
 };  // end of class ImagePreProcessor
 
-std::shared_ptr<ImagePreProcessor> create_processor(const std::string &config_file);
+std::shared_ptr<ImagePreProcessor> create_processor(
+                                   const std::string &config_file);
 
-} // end of namespace paddle_solution
+}  // namespace PaddleSolution

inference/preprocessor/preprocessor_seg.cpp

@@ -12,21 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <thread>
+#include "preprocessor_seg.h"
 
 #include <glog/logging.h>
 
-#include "preprocessor_seg.h"
+#include <thread>
+
 
 namespace PaddleSolution {
 
-    bool SegPreProcessor::single_process(const std::string& fname, float* data, int* ori_w, int* ori_h) {
+    bool SegPreProcessor::single_process(const std::string& fname,
+                                         float* data, int* ori_w, int* ori_h) {
         cv::Mat im = cv::imread(fname, -1);
         if (im.data == nullptr || im.empty()) {
             LOG(ERROR) << "Failed to open image: " << fname;
             return false;
         }
-        
         int channels = im.channels();
         *ori_w = im.cols;
         *ori_h = im.rows;
@@ -50,7 +51,8 @@ namespace PaddleSolution {
         return true;
     }
 
-    bool SegPreProcessor::batch_process(const std::vector<std::string>& imgs, float* data, int* ori_w, int* ori_h) {
+    bool SegPreProcessor::batch_process(const std::vector<std::string>& imgs,
+                                        float* data, int* ori_w, int* ori_h) {
         auto ic = _config->_channels;
         auto iw = _config->_resize[0];
         auto ih = _config->_resize[1];
@@ -72,9 +74,9 @@ namespace PaddleSolution {
         return true;
     }
 
-    bool SegPreProcessor::init(std::shared_ptr<PaddleSolution::PaddleSegModelConfigPaser> config) {
+    bool SegPreProcessor::init(
+        std::shared_ptr<PaddleSolution::PaddleSegModelConfigPaser> config) {
         _config = config;
         return true;
     }
-
-}
+}  // namespace PaddleSolution

inference/preprocessor/preprocessor_seg.h

@@ -14,25 +14,27 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+#include <memory>
 #include "preprocessor.h"
 #include "utils/utils.h"
 
 namespace PaddleSolution {
 
 class SegPreProcessor : public ImagePreProcessor {
+ public:
+    SegPreProcessor() : _config(nullptr) {}
 
-public:
-    SegPreProcessor() : _config(nullptr){
-    };
+    bool init(
+        std::shared_ptr<PaddleSolution::PaddleSegModelConfigPaser> config);
 
-    bool init(std::shared_ptr<PaddleSolution::PaddleSegModelConfigPaser> config);
+    bool single_process(const std::string &fname, float* data,
+                        int* ori_w, int* ori_h);
 
-    bool single_process(const std::string &fname, float* data, int* ori_w, int* ori_h);
-
-    bool batch_process(const std::vector<std::string>& imgs, float* data, int* ori_w, int* ori_h);
-
-private:
+    bool batch_process(const std::vector<std::string>& imgs, float* data,
+                       int* ori_w, int* ori_h);
+ private:
     std::shared_ptr<PaddleSolution::PaddleSegModelConfigPaser> _config;
 };
-
-}
+}  // namespace PaddleSolution