Commit 5d1de915 authored by xin.wang.waytous's avatar xin.wang.waytous

task(detect)

parent fd5257a8
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}
)
name: YoloV5 name: CameraModel
inputNames: [cvImage1, cvImage2] inputNames: [cvImage1, cvImage2]
outputNames: [trackedDetections1, trackedDetections2] outputNames: [trackedDetections1, trackedDetections2]
globalParams: globalParams:
......
#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;
}
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}
)
...@@ -5,6 +5,9 @@ ...@@ -5,6 +5,9 @@
#include <cublas_v2.h> #include <cublas_v2.h>
#include <cuda_runtime.h> #include <cuda_runtime.h>
#include <iostream> #include <iostream>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <assert.h> #include <assert.h>
#define BLOCK 512 #define BLOCK 512
...@@ -22,6 +25,13 @@ ...@@ -22,6 +25,13 @@
} }
#endif #endif
#ifndef PI
#define PI 3.1415926
#endif
namespace waytous{
namespace deepinfer{
namespace common{
inline dim3 cudaGridSize(uint n, uint block) inline dim3 cudaGridSize(uint n, uint block)
{ {
...@@ -38,6 +48,22 @@ 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 #endif
......
#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
...@@ -5,36 +5,42 @@ ...@@ -5,36 +5,42 @@
#include <opencv2/opencv.hpp> #include <opencv2/opencv.hpp>
#include <yaml-cpp/yaml.h> #include <yaml-cpp/yaml.h>
#include "common/register.h"
#include "interfaces/base_io.h"
namespace waytous{ namespace waytous{
namespace deepinfer{ namespace deepinfer{
namespace task{ namespace interfaces{
class Task{ class BaseTask{
public: public:
virtual ~Task() = default; BaseTask() = default;
virtual ~BaseTask() = default;
virtual bool Init(const std::string& taskConfigPath);
/* virtual bool Init(std::string& taskConfigPath);
task input/output
*/
virtual bool Infer() = 0;
/* // camera image
draw outputs on 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 void Visualize(cv::Mat& image) = 0;
virtual cv::Scalar get_color(int idx); virtual cv::Scalar get_color(int idx);
virtual std::string Name(){
return "BaseTask";
}
public: public:
YAML::Node taskNode; YAML::Node taskNode;
}; };
} //namespace task DEEPINFER_REGISTER_REGISTERER(BaseTask);
#define DEEPINFER_REGISTER_TASKS(name) \
DEEPINFER_REGISTER_CLASS(BaseTask, name)
} //namespace interfaces
} //namspace deepinfer } //namspace deepinfer
} //namespace waytous } //namespace waytous
......
#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
#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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment