task(detect)

CMakeLists.txt

+
+
+
+cmake_minimum_required(VERSION 3.5)
+
+project(DeepInfer)
+
+# cuda opencv
+find_package(CUDA REQUIRED)
+find_package(OpenCV REQUIRED)
+# enable_language(CUDA)
+link_directories(${OpenCV_LIBRARIES_DIRS})
+include_directories(${OpenCV_INCLUDE_DIRS})
+# link_directories(${CUDA_LIBRARIES_DIRS})
+# include_directories(${CUDA_INCLUDE_DIRS})
+link_directories(/usr/local/cuda/lib64)
+include_directories(/usr/local/cuda/include)
+
+# eigen3
+find_package(Eigen3 REQUIRED)
+link_directories(${EIGEN3_LIBRARIES_DIRS})
+include_directories(${EIGEN3_INCLUDE_DIRS})
+include_directories(include)
+
+# tensorrt 
+include_directories(/root/TensorRT/TensorRT-7.0.0.11-cuda-10.0/include)
+link_directories(/root/TensorRT/TensorRT-7.0.0.11-cuda-10.0/lib)
+# aarch64
+    # # figure out real path
+    # include_directories(/home/nvidia/.../tensorrt-7.1-aarch64-DCN/include)
+    # link_directories(/home/nvidia/.../tensorrt-7.1-aarch64-DCN/lib)
+    # # cudnn + default-tensorrt
+    # link_directories(/usr/lib/aarch64-linux-gnu)
+    # include_directories(/usr/include/aarch64-linux-gnu)
+
+# yaml
+include_directories(/usr/local/include/yaml-cpp)
+# aarch64 -- figure out
+# include_directories(/usr/include/yaml-cpp)
+
+# glog gflags
+# sudo apt-get install libgoogle-glog*
+include_directories(/usr/include/gflags)
+include_directories(/usr/include/glog)
+
+set(DEP_LIBS 
+    ${CUDA_npp_LIBRARY}
+    ${CUDA_nppc_LIBRARY}
+    ${OpenCV_LIBS}
+    cudart 
+    nvinfer
+    nvonnxparser
+    nvinfer_plugin
+    yaml-cpp
+    gflags
+    glog 
+)
+
+set(CMAKE_CUDA_ARCHITECTURES 35 50 72)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wfatal-errors -Ofast")
+list(APPEND CUDA_NVCC_FLAGS "-D_FORCE_INLINES -Xcompiler -fPIC")
+
+set(PROJECT_CUDA_LIB deepinfer_cuda_cuda)
+set(PROJECT_LIB deepinfer_cuda)
+message(WARNING ${PROJECT_LIB} ${DEP_LIBS})
+add_subdirectory(src)
+
+list(APPEND EXTRA_LIBS ${PROJECT_LIB})
+list(APPEND EXTRA_INCLUDES "${PROJECT_SOURCE_DIR}/src")
+
+add_executable(main main.cpp)
+target_link_libraries(main
+    ${EXTRA_LIBS}
+    ${OpenCV_LIBS}
+)
+target_include_directories(main 
+    PUBLIC ${EXTRA_INCLUDES}
+)

configs/yolov5.yaml

 
-name: YoloV5
+name: CameraModel
 inputNames: [cvImage1, cvImage2]
 outputNames: [trackedDetections1, trackedDetections2]
 globalParams:

main.cpp

+
+#include <vector>
+#include <chrono>
+#include <opencv2/opencv.hpp>
+
+#if CV_VERSION_MAJOR == 4
+#define CV_FOURCC cv::VideoWriter::fourcc
+#endif
+
+#include <glog/logging.h>
+#include "interfaces/base_task.h"
+
+using namespace waytous::deepinfer;
+
+std::vector<std::string> stringSplit(const std::string& str, char delim) {
+    std::stringstream ss(str);
+    std::string item;
+    std::vector<std::string> elems;
+    while (std::getline(ss, item, delim)) {
+        if (!item.empty()) {
+            elems.push_back(item);
+        }
+    }
+    return elems;
+}
+
+int main(int argc, char** argv){
+    google::InitGoogleLogging("WARNING");
+    if(argc < 6){
+        printf("wrong args.");
+        printf("use like ./main task video/image configpath src dst.");
+        return 0;
+    }
+    std::string taskName = argv[1];
+    std::string videoOrImage = argv[2];
+    std::string configPath = argv[3];
+    std::string srcPath = argv[4];
+    std::string savePath = argv[5];
+    auto t = interfaces::BaseTaskRegisterer::GetInstanceByName(taskName);
+    t->Init(configPath);
+    printf("Init all Done\n");
+
+    auto paths = stringSplit(srcPath, ',');
+    auto savePaths = stringSplit(savePath, ',');
+
+    std::vector<cv::Mat*> inputs;
+    std::vector<interfaces::BaseIOPtr> outputs;
+    if( videoOrImage == "image"){
+        std::vector<cv::Mat> images;
+        images.resize(paths.size());
+
+        for(int i=0; i<paths.size(); i++){
+            auto p = paths[i];
+            std::cout << " load image: "<< p << std::endl;
+            images[i] = cv::imread(p);
+            inputs.push_back(&images[i]);
+        }
+        std::cout << "before infer." << std::endl;
+        auto e1 = std::chrono::system_clock::now();
+        for(int i=0; i<100; i++){
+            t->Exec(inputs, outputs);
+        }
+        auto e2 = std::chrono::system_clock::now();
+        std::cout << "100 times avg infer time: " <<
+            std::chrono::duration_cast<std::chrono::microseconds>(e2 - e1).count() / 1000. / 100. << " ms" << std::endl;
+        for(int i=0; i<inputs.size(); i++){
+            cv::Mat vis = images[i];
+            t->Visualize(&vis, outputs[i]);
+            cv::imwrite(savePaths[i], vis);
+        }
+            
+    }else if(videoOrImage == "video"){
+        cv::VideoCapture cap(srcPath);
+        int img_height = cap.get(cv::CAP_PROP_FRAME_HEIGHT);
+        int img_width = cap.get(cv::CAP_PROP_FRAME_WIDTH);
+        cv::VideoWriter writer(savePath, CV_FOURCC('M', 'J', 'P', 'G'), 25, cv::Size(img_width, img_height));
+        cv::Mat img;
+        while (true)
+        {
+            inputs.clear();
+            outputs.clear();
+            if(!cap.read(img)){
+                break;
+            };
+            inputs.push_back(&img);
+            t->Exec(inputs, outputs);
+            cv::Mat vis_img = img.clone();
+            t->Visualize(&vis_img, outputs[0]);
+            writer.write(vis_img);
+        }
+        cap.release();
+        writer.release();
+    }
+
+    return 1;
+}
+
+
+
+
+
+
+
+
+
+
+

src/CMakeLists.txt

+
+project(DeepInferModel)
+
+
+
+include_directories(.)
+
+# include_directories(src/base)
+# ${PROJECT_SOURCE_DIR}
+file(GLOB_RECURSE ALL_CPP_SRC *.cpp)
+file(GLOB_RECURSE ALL_CU_SRC *.cu)
+
+message(WARNING ${PROJECT_LIB} ${DEP_LIBS})
+message(WARNING ${ALL_CPP_SRC})
+message(WARNING ${ALL_CU_SRC})
+
+
+cuda_add_library(${PROJECT_CUDA_LIB} STATIC ${ALL_CU_SRC})
+target_link_libraries(${PROJECT_CUDA_LIB}
+    ${DEP_LIBS}
+)
+
+add_library(${PROJECT_LIB} SHARED ${ALL_CPP_SRC})
+target_link_libraries(${PROJECT_LIB}
+    PUBLIC  ${PROJECT_CUDA_LIB}
+    ${DEP_LIBS}
+)
+

src/common/common.h

@@ -5,6 +5,9 @@
 #include <cublas_v2.h>
 #include <cuda_runtime.h>
 #include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <cmath>
 #include <assert.h>
 
 #define BLOCK 512
@@ -22,6 +25,13 @@
     }
 #endif
 
+#ifndef PI
+#define PI 3.1415926
+#endif
+
+namespace waytous{
+namespace deepinfer{
+namespace common{
 
 inline dim3 cudaGridSize(uint n, uint block)
 {
@@ -38,6 +48,22 @@ inline dim3 cudaGridSize(uint n, uint block)
 }
 
 
+inline std::string formatValue(float val, int fixed) {
+    std::ostringstream oss;
+    oss << std::setprecision(fixed) << val;
+    return oss.str();
+}
+
+
+inline float euclidean(float x1, float y1, float x2, float y2){
+    return std::sqrt(std::pow((x2 - x1), 2) + std::pow((y2 - y1), 2));
+}
+
+
+} //namespace common
+} //namspace deepinfer
+} //namespace waytous
+
 
 #endif
 

src/interfaces/base_task.cpp

+
+#include <cuda_runtime.h>
+
+#include "common/file.h"
+#include "common/common.h"
+#include "common/log.h"
+
+#include "interfaces/base_task.h"
+
+namespace waytous{
+namespace deepinfer{
+namespace interfaces{
+
+
+bool BaseTask::Init(std::string& taskConfigPath){
+    if(!waytous::deepinfer::common::PathExists(taskConfigPath)){
+        LOG_WARN << "config_file " << taskConfigPath << " not exist.";
+        return false;
+    }
+    taskNode = YAML::LoadFile(taskConfigPath);
+    if (taskNode.IsNull()) {
+        LOG_WARN << "Load " << taskConfigPath << " failed! please check!";
+        return false;
+    }
+    if(!taskNode["configRootPath"].IsDefined()){
+        LOG_WARN << "Forget set root path?";
+        return false;
+    }
+    std::string configRootPath = taskNode["configRootPath"].as<std::string>();
+    common::ConfigRoot::SetRootPath(configRootPath);
+    LOG_INFO << "Set root path " << common::ConfigRoot::GetRootPath() << ": " << configRootPath;
+    int device = 0;
+    if(taskNode["device"].IsDefined() && !taskNode["device"].IsNull()){
+		device = taskNode["device"].as<int>();
+        LOG_INFO << "Using device id: " << device;
+    } else{
+        LOG_INFO << "Using default device 0.";
+    }
+    CUDA_CHECK(cudaSetDevice(device));
+    return true;
+}
+
+
+cv::Scalar BaseTask::get_color(int idx)
+{
+	idx += 3;
+	return cv::Scalar(37 * idx % 255, 17 * idx % 255, 29 * idx % 255);
+}
+
+} //namespace task
+} //namspace deepinfer
+} //namespace waytous
+
+
+
+
+

src/interfaces/base_task.h

@@ -5,36 +5,42 @@
 #include <opencv2/opencv.hpp>
 #include <yaml-cpp/yaml.h>
 
+#include "common/register.h"
+#include "interfaces/base_io.h"
+
 
 namespace waytous{
 namespace deepinfer{
-namespace task{
+namespace interfaces{
 
 
-class Task{
+class BaseTask{
 public:
-    virtual ~Task() = default;
-
-    virtual bool Init(const std::string& taskConfigPath);
+    BaseTask() = default;
+    virtual ~BaseTask() = default;
 
-    /*
-        task input/output
-    */
-    virtual bool Infer() = 0;
+    virtual bool Init(std::string& taskConfigPath);
 
-    /*
-        draw outputs on image
-    */
-    virtual void Visualize(cv::Mat& image) = 0;
+    // camera image
+    virtual bool Exec(std::vector<cv::Mat*> inputs, std::vector<interfaces::BaseIOPtr>& outputs);
+    virtual void Visualize(cv::Mat* image, interfaces::BaseIOPtr outs) = 0;
 
     virtual cv::Scalar get_color(int idx);
 
+    virtual std::string Name(){
+        return "BaseTask";
+    }
+
 public:
     YAML::Node taskNode;
 
 };
 
-} //namespace task
+DEEPINFER_REGISTER_REGISTERER(BaseTask);
+#define DEEPINFER_REGISTER_TASKS(name) \
+  DEEPINFER_REGISTER_CLASS(BaseTask, name)
+
+} //namespace interfaces
 } //namspace deepinfer
 } //namespace waytous
 

src/tasks/task_detect.cpp

+
+#include "tasks/task_detect.h"
+
+namespace waytous{
+namespace deepinfer{
+namespace task{
+
+
+bool TaskDetect::Init(std::string& taskConfigPath){
+    if(!interfaces::BaseTask::Init(taskConfigPath)){
+        LOG_ERROR << "Init task detect error";
+        return false;
+    };
+    std::string detectorName = taskNode["detectorName"].as<std::string>();
+    std::string detectorConfigPath = taskNode["detectorConfigPath"].as<std::string>();
+
+    detector.reset(interfaces::BaseModelRegisterer::GetInstanceByName(detectorName));
+    if(!detector->Init(detectorConfigPath)){
+        LOG_ERROR << detectorName << " detector init problem";
+        return false;
+    };
+}
+
+
+bool TaskDetect::Exec(std::vector<cv::Mat*> inputs, std::vector<interfaces::BaseIOPtr>& outputs){
+    detector->Exec(inputs, outputs);
+}
+
+
+void TaskDetect::Visualize(cv::Mat* image, interfaces::BaseIOPtr outs){
+    auto detections = std::dynamic_pointer_cast<ios::Detection2Ds>(outs)->detections;
+    for(auto &obj : detections){
+        cv::Scalar color = get_color(obj->class_label);
+        cv::rectangle(*image, cv::Rect(obj->x1, obj->y1, obj->x2 - obj->x1, obj->y2 - obj->y1), color, 2);
+        cv::putText(*image, common::formatValue(obj->confidence, 2) + ":" + 
+                    std::to_string(obj->track_id) + "." + obj->class_name, 
+                    cv::Point(obj->x1, obj->y1 - 5), cv::FONT_HERSHEY_SIMPLEX, 0.5, color, 1);
+    }
+}
+
+
+std::string TaskDetect::Name(){
+    return "TaskDetect";
+}
+
+DEEPINFER_REGISTER_TASKS(TaskDetect);
+
+} //namespace task
+} //namspace deepinfer
+} //namespace waytous
+
+
+
+
+
+
+
+
+

src/tasks/task_detect.h

+
+#ifndef WAYTOUS_DEEPINFER_TASK_DETECT_H_
+#define WAYTOUS_DEEPINFER_TASK_DETECT_H_
+
+#include "interfaces/base_task.h"
+#include "models/camera_model.h"
+#include "libs/ios/detection.h"
+
+namespace waytous{
+namespace deepinfer{
+namespace task{
+
+
+class TaskDetect: public interfaces::BaseTask{
+public:
+
+    bool Init(std::string& taskConfigPath) override;
+
+    bool Exec(std::vector<cv::Mat*> inputs, std::vector<interfaces::BaseIOPtr>& outputs) override;
+    void Visualize(cv::Mat* image, interfaces::BaseIOPtr outs) override;
+    std::string Name() override;
+
+public:
+    std::shared_ptr<camera::CameraModel> detector;
+
+};
+
+} //namespace task
+} //namspace deepinfer
+} //namespace waytous
+
+
+#endif
+
+
+
+
+
+
+
+