github
/
darknet
mirror of https://github.com/AlexeyAB/darknet.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Tracking small fixes

Browse Source
pull/398/head
AlexeyAB 7 years ago
parent 993e3a38aa
commit 063a23f637
2 changed files with 85 additions and 60 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 37
      src/yolo_console_dll.cpp
  2. 108
      src/yolo_v2_class.hpp

37
src/yolo_console_dll.cpp
Unescape View File

@ -64,7 +64,6 @@ public:
preview_box_size(_preview_box_size), bottom_offset(_bottom_offset), one_off_detections(_one_off_detections) preview_box_size(_preview_box_size), bottom_offset(_bottom_offset), one_off_detections(_one_off_detections)
{} {}
//void draw_preview_boxes(cv::Mat src_mat, cv::Mat draw_mat, std::vector<bbox_t> result_vec, bool draw_boxes = true)
void set(cv::Mat src_mat, std::vector<bbox_t> result_vec) void set(cv::Mat src_mat, std::vector<bbox_t> result_vec)
{ {
size_t const count_preview_boxes = src_mat.cols / preview_box_size; size_t const count_preview_boxes = src_mat.cols / preview_box_size;
@ -142,6 +141,10 @@ public:
cv::Scalar color = obj_id_to_color(preview_box_track_id[i].obj_id); cv::Scalar color = obj_id_to_color(preview_box_track_id[i].obj_id);
int thickness = (preview_box_track_id[i].current_detection) ? 5 : 1; int thickness = (preview_box_track_id[i].current_detection) ? 5 : 1;
cv::rectangle(draw_mat, dst_rect_roi, color, thickness); cv::rectangle(draw_mat, dst_rect_roi, color, thickness);
unsigned int const track_id = preview_box_track_id[i].track_id;
std::string track_id_str = (track_id > 0)? std::to_string(track_id):"";
putText(draw_mat, track_id_str, dst_rect_roi.tl() - cv::Point2i(0, 10), cv::FONT_HERSHEY_COMPLEX_SMALL, 1.0, cv::Scalar(0, 0, 0), 2);
} }
} }
} }
@ -149,7 +152,7 @@ public:
void draw_boxes(cv::Mat mat_img, std::vector<bbox_t> result_vec, std::vector<std::string> obj_names, void draw_boxes(cv::Mat mat_img, std::vector<bbox_t> result_vec, std::vector<std::string> obj_names,
unsigned int wait_msec = 0, std::string win_name = "window name", int current_det_fps = -1, int current_cap_fps = -1) int current_det_fps = -1, int current_cap_fps = -1)
{ {
int const colors[6][3] = { { 1,0,1 },{ 0,0,1 },{ 0,1,1 },{ 0,1,0 },{ 1,1,0 },{ 1,0,0 } }; int const colors[6][3] = { { 1,0,1 },{ 0,0,1 },{ 0,1,1 },{ 0,1,0 },{ 1,1,0 },{ 1,0,0 } };
@ -171,9 +174,6 @@ void draw_boxes(cv::Mat mat_img, std::vector<bbox_t> result_vec, std::vector<std
std::string fps_str = "FPS detection: " + std::to_string(current_det_fps) + " FPS capture: " + std::to_string(current_cap_fps); std::string fps_str = "FPS detection: " + std::to_string(current_det_fps) + " FPS capture: " + std::to_string(current_cap_fps);
putText(mat_img, fps_str, cv::Point2f(10, 20), cv::FONT_HERSHEY_COMPLEX_SMALL, 1.2, cv::Scalar(50, 255, 0), 2); putText(mat_img, fps_str, cv::Point2f(10, 20), cv::FONT_HERSHEY_COMPLEX_SMALL, 1.2, cv::Scalar(50, 255, 0), 2);
} }
cv::imshow(win_name, mat_img);
cv::waitKey(wait_msec);
} }
#endif // OPENCV #endif // OPENCV
@ -276,7 +276,8 @@ int main(int argc, char *argv[])
{ {
std::unique_lock<std::mutex> lock(mtx); std::unique_lock<std::mutex> lock(mtx);
det_image = detector.mat_to_image_resize(cur_frame); det_image = detector.mat_to_image_resize(cur_frame);
auto old_result_vec = result_vec; //auto old_result_vec = result_vec;
auto old_result_vec = detector.tracking_id(result_vec);
result_vec = thread_result_vec; result_vec = thread_result_vec;
#ifdef TRACK_OPTFLOW #ifdef TRACK_OPTFLOW
// track optical flow // track optical flow
@ -285,18 +286,18 @@ int main(int argc, char *argv[])
small_preview.set(track_optflow_queue.front(), tmp_result_vec); small_preview.set(track_optflow_queue.front(), tmp_result_vec);
//std::cout << "\n !!!! all = " << track_optflow_queue.size() << ", cur = " << passed_flow_frames << std::endl; //std::cout << "\n !!!! all = " << track_optflow_queue.size() << ", cur = " << passed_flow_frames << std::endl;
tracker_flow.update_tracking_flow(track_optflow_queue.front()); tracker_flow.update_tracking_flow(track_optflow_queue.front(), result_vec);
while (track_optflow_queue.size() > 1) { while (track_optflow_queue.size() > 1) {
track_optflow_queue.pop(); track_optflow_queue.pop();
result_vec = tracker_flow.tracking_flow(track_optflow_queue.front(), result_vec, true); result_vec = tracker_flow.tracking_flow(track_optflow_queue.front());
} }
track_optflow_queue.pop(); track_optflow_queue.pop();
passed_flow_frames = 0; passed_flow_frames = 0;
} }
#endif #endif
result_vec = detector.tracking_id(result_vec); // comment it - if track_id is not required result_vec = detector.tracking_id(result_vec); // comment it - if track_id is not required
// add old tracked objects // add old tracked objects
for (auto &i : old_result_vec) { for (auto &i : old_result_vec) {
auto it = std::find_if(result_vec.begin(), result_vec.end(), auto it = std::find_if(result_vec.begin(), result_vec.end(),
@ -306,10 +307,13 @@ int main(int argc, char *argv[])
if (i.frames_counter-- > 1) if (i.frames_counter-- > 1)
result_vec.push_back(i); result_vec.push_back(i);
} }
else else {
it->frames_counter = std::min((unsigned)3, i.frames_counter + 1); it->frames_counter = std::min((unsigned)3, i.frames_counter + 1);
}
} }
#ifdef TRACK_OPTFLOW
tracker_flow.update_cur_bbox_vec(result_vec);
#endif
consumed = false; consumed = false;
cv_pre_tracked.notify_all(); cv_pre_tracked.notify_all();
} }
@ -347,13 +351,16 @@ int main(int argc, char *argv[])
#ifdef TRACK_OPTFLOW #ifdef TRACK_OPTFLOW
++passed_flow_frames; ++passed_flow_frames;
track_optflow_queue.push(cur_frame.clone()); track_optflow_queue.push(cur_frame.clone());
result_vec = tracker_flow.tracking_flow(cur_frame, result_vec, true); // track optical flow result_vec = tracker_flow.tracking_flow(cur_frame); // track optical flow
small_preview.draw(cur_frame); small_preview.draw(cur_frame);
#endif #endif
large_preview.draw(cur_frame);
draw_boxes(cur_frame, result_vec, obj_names, 3, "window name", current_det_fps, current_cap_fps); // 3 or 16ms draw_boxes(cur_frame, result_vec, obj_names, current_det_fps, current_cap_fps);
//show_console_result(result_vec, obj_names); //show_console_result(result_vec, obj_names);
large_preview.draw(cur_frame);
cv::imshow("window name", cur_frame);
cv::waitKey(3); // 3 or 16ms
if (output_video.isOpened() && videowrite_ready) { if (output_video.isOpened() && videowrite_ready) {
if (t_videowrite.joinable()) t_videowrite.join(); if (t_videowrite.joinable()) t_videowrite.join();
@ -397,6 +404,8 @@ int main(int argc, char *argv[])
std::vector<bbox_t> result_vec = detector.detect(mat_img); std::vector<bbox_t> result_vec = detector.detect(mat_img);
result_vec = detector.tracking_id(result_vec); // comment it - if track_id is not required result_vec = detector.tracking_id(result_vec); // comment it - if track_id is not required
draw_boxes(mat_img, result_vec, obj_names); draw_boxes(mat_img, result_vec, obj_names);
cv::imshow("window name", mat_img);
cv::waitKey(3); // 3 or 16ms
show_console_result(result_vec, obj_names); show_console_result(result_vec, obj_names);
} }
#else #else

108
src/yolo_v2_class.hpp
Unescape View File

@ -155,9 +155,12 @@ class Tracker_optflow {
public: public:
const int gpu_count; const int gpu_count;
const int gpu_id; const int gpu_id;
const int flow_error;
Tracker_optflow(int _gpu_id = 0) : gpu_count(cv::cuda::getCudaEnabledDeviceCount()), gpu_id(std::min(_gpu_id, gpu_count-1)) Tracker_optflow(int _gpu_id = 0, int win_size = 9, int max_level = 3, int iterations = 2000, int _flow_error = -1) :
gpu_count(cv::cuda::getCudaEnabledDeviceCount()), gpu_id(std::min(_gpu_id, gpu_count-1)),
flow_error((_flow_error > 0)? _flow_error:(win_size*4))
{ {
int const old_gpu_id = cv::cuda::getDevice(); int const old_gpu_id = cv::cuda::getDevice();
cv::cuda::setDevice(gpu_id); cv::cuda::setDevice(gpu_id);
@ -165,9 +168,9 @@ public:
stream = cv::cuda::Stream(); stream = cv::cuda::Stream();
sync_PyrLKOpticalFlow_gpu = cv::cuda::SparsePyrLKOpticalFlow::create(); sync_PyrLKOpticalFlow_gpu = cv::cuda::SparsePyrLKOpticalFlow::create();
sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(9, 9)); // 15, 21, 31 sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(win_size, win_size)); // 9, 15, 21, 31
sync_PyrLKOpticalFlow_gpu->setMaxLevel(3); // +- 3 pt sync_PyrLKOpticalFlow_gpu->setMaxLevel(max_level); // +- 3 pt
sync_PyrLKOpticalFlow_gpu->setNumIters(2000); // def: 30 sync_PyrLKOpticalFlow_gpu->setNumIters(iterations); // 2000, def: 30
cv::cuda::setDevice(old_gpu_id); cv::cuda::setDevice(old_gpu_id);
} }
@ -175,7 +178,6 @@ public:
// just to avoid extra allocations // just to avoid extra allocations
cv::cuda::GpuMat src_mat_gpu; cv::cuda::GpuMat src_mat_gpu;
cv::cuda::GpuMat dst_mat_gpu, dst_grey_gpu; cv::cuda::GpuMat dst_mat_gpu, dst_grey_gpu;
cv::cuda::GpuMat tmp_grey_gpu;
cv::cuda::GpuMat prev_pts_flow_gpu, cur_pts_flow_gpu; cv::cuda::GpuMat prev_pts_flow_gpu, cur_pts_flow_gpu;
cv::cuda::GpuMat status_gpu, err_gpu; cv::cuda::GpuMat status_gpu, err_gpu;
@ -183,7 +185,41 @@ public:
cv::Ptr<cv::cuda::SparsePyrLKOpticalFlow> sync_PyrLKOpticalFlow_gpu; cv::Ptr<cv::cuda::SparsePyrLKOpticalFlow> sync_PyrLKOpticalFlow_gpu;
cv::cuda::Stream stream; cv::cuda::Stream stream;
void update_tracking_flow(cv::Mat src_mat) std::vector<bbox_t> cur_bbox_vec;
std::vector<bool> good_bbox_vec_flags;
cv::Mat prev_pts_flow_cpu;
void update_cur_bbox_vec(std::vector<bbox_t> _cur_bbox_vec)
{
cur_bbox_vec = _cur_bbox_vec;
good_bbox_vec_flags.resize(cur_bbox_vec.size());
for (auto &i : good_bbox_vec_flags) i = true;
cv::Mat prev_pts, cur_pts_flow_cpu;
for (auto &i : cur_bbox_vec) {
float x_center = (i.x + i.w / 2.0F);
float y_center = (i.y + i.h / 2.0F);
prev_pts.push_back(cv::Point2f(x_center, y_center));
}
if (prev_pts.rows == 0)
prev_pts_flow_cpu = cv::Mat();
else
cv::transpose(prev_pts, prev_pts_flow_cpu);
if (prev_pts_flow_gpu.cols < prev_pts_flow_cpu.cols) {
prev_pts_flow_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), prev_pts_flow_cpu.type());
cur_pts_flow_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), prev_pts_flow_cpu.type());
status_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), CV_8UC1);
err_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), CV_32FC1);
}
prev_pts_flow_gpu.upload(cv::Mat(prev_pts_flow_cpu), stream);
}
void update_tracking_flow(cv::Mat src_mat, std::vector<bbox_t> _cur_bbox_vec)
{ {
int const old_gpu_id = cv::cuda::getDevice(); int const old_gpu_id = cv::cuda::getDevice();
if (old_gpu_id != gpu_id) if (old_gpu_id != gpu_id)
@ -195,6 +231,8 @@ public:
src_grey_gpu = cv::cuda::GpuMat(src_mat.size(), CV_8UC1); src_grey_gpu = cv::cuda::GpuMat(src_mat.size(), CV_8UC1);
} }
update_cur_bbox_vec(_cur_bbox_vec);
src_mat_gpu.upload(src_mat, stream); src_mat_gpu.upload(src_mat, stream);
cv::cuda::cvtColor(src_mat_gpu, src_grey_gpu, CV_BGR2GRAY, 0, stream); cv::cuda::cvtColor(src_mat_gpu, src_grey_gpu, CV_BGR2GRAY, 0, stream);
} }
@ -203,7 +241,7 @@ public:
} }
std::vector<bbox_t> tracking_flow(cv::Mat dst_mat, std::vector<bbox_t> cur_bbox_vec, bool check_error = false) std::vector<bbox_t> tracking_flow(cv::Mat dst_mat, bool check_error = true)
{ {
if (sync_PyrLKOpticalFlow_gpu.empty()) { if (sync_PyrLKOpticalFlow_gpu.empty()) {
std::cout << "sync_PyrLKOpticalFlow_gpu isn't initialized \n"; std::cout << "sync_PyrLKOpticalFlow_gpu isn't initialized \n";
@ -217,12 +255,10 @@ public:
if (dst_mat_gpu.cols == 0) { if (dst_mat_gpu.cols == 0) {
dst_mat_gpu = cv::cuda::GpuMat(dst_mat.size(), dst_mat.type()); dst_mat_gpu = cv::cuda::GpuMat(dst_mat.size(), dst_mat.type());
dst_grey_gpu = cv::cuda::GpuMat(dst_mat.size(), CV_8UC1); dst_grey_gpu = cv::cuda::GpuMat(dst_mat.size(), CV_8UC1);
tmp_grey_gpu = cv::cuda::GpuMat(dst_mat.size(), CV_8UC1);
} }
dst_mat_gpu.upload(dst_mat, stream); dst_mat_gpu.upload(dst_mat, stream);
cv::cuda::cvtColor(dst_mat_gpu, dst_grey_gpu, CV_BGR2GRAY, 0, stream); cv::cuda::cvtColor(dst_mat_gpu, dst_grey_gpu, CV_BGR2GRAY, 0, stream);
if (src_grey_gpu.rows != dst_grey_gpu.rows || src_grey_gpu.cols != dst_grey_gpu.cols) { if (src_grey_gpu.rows != dst_grey_gpu.rows || src_grey_gpu.cols != dst_grey_gpu.cols) {
@ -232,40 +268,13 @@ public:
return cur_bbox_vec; return cur_bbox_vec;
} }
cv::Mat prev_pts, prev_pts_flow_cpu, cur_pts_flow_cpu;
for (auto &i : cur_bbox_vec) {
float x_center = (i.x + i.w / 2);
float y_center = (i.y + i.h / 2);
prev_pts.push_back(cv::Point2f(x_center, y_center));
}
if (prev_pts.rows == 0)
prev_pts_flow_cpu = cv::Mat();
else
cv::transpose(prev_pts, prev_pts_flow_cpu);
if (prev_pts_flow_gpu.cols < prev_pts_flow_cpu.cols) {
prev_pts_flow_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), prev_pts_flow_cpu.type());
cur_pts_flow_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), prev_pts_flow_cpu.type());
status_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), CV_8UC1);
err_gpu = cv::cuda::GpuMat(prev_pts_flow_cpu.size(), CV_32FC1);
}
prev_pts_flow_gpu.upload(cv::Mat(prev_pts_flow_cpu), stream);
dst_grey_gpu.copyTo(tmp_grey_gpu, stream);
////sync_PyrLKOpticalFlow_gpu.sparse(src_grey_gpu, dst_grey_gpu, prev_pts_flow_gpu, cur_pts_flow_gpu, status_gpu, &err_gpu); // OpenCV 2.4.x ////sync_PyrLKOpticalFlow_gpu.sparse(src_grey_gpu, dst_grey_gpu, prev_pts_flow_gpu, cur_pts_flow_gpu, status_gpu, &err_gpu); // OpenCV 2.4.x
sync_PyrLKOpticalFlow_gpu->calc(src_grey_gpu, dst_grey_gpu, prev_pts_flow_gpu, cur_pts_flow_gpu, status_gpu, err_gpu, stream); // OpenCV 3.x sync_PyrLKOpticalFlow_gpu->calc(src_grey_gpu, dst_grey_gpu, prev_pts_flow_gpu, cur_pts_flow_gpu, status_gpu, err_gpu, stream); // OpenCV 3.x
cv::Mat cur_pts_flow_cpu;
cur_pts_flow_gpu.download(cur_pts_flow_cpu, stream); cur_pts_flow_gpu.download(cur_pts_flow_cpu, stream);
tmp_grey_gpu.copyTo(src_grey_gpu, stream); dst_grey_gpu.copyTo(src_grey_gpu, stream);
cv::Mat err_cpu, status_cpu; cv::Mat err_cpu, status_cpu;
err_gpu.download(err_cpu, stream); err_gpu.download(err_cpu, stream);
@ -275,24 +284,31 @@ public:
std::vector<bbox_t> result_bbox_vec; std::vector<bbox_t> result_bbox_vec;
for (size_t i = 0; i < cur_bbox_vec.size(); ++i) if (err_cpu.cols == cur_bbox_vec.size() && status_cpu.cols == cur_bbox_vec.size())
{ {
cv::Point2f cur_key_pt = cur_pts_flow_cpu.at<cv::Point2f>(0, i); for (size_t i = 0; i < cur_bbox_vec.size(); ++i)
cv::Point2f prev_key_pt = prev_pts_flow_cpu.at<cv::Point2f>(0, i); {
cv::Point2f cur_key_pt = cur_pts_flow_cpu.at<cv::Point2f>(0, i);
cv::Point2f prev_key_pt = prev_pts_flow_cpu.at<cv::Point2f>(0, i);
float moved_x = cur_key_pt.x - prev_key_pt.x; float moved_x = cur_key_pt.x - prev_key_pt.x;
float moved_y = cur_key_pt.y - prev_key_pt.y; float moved_y = cur_key_pt.y - prev_key_pt.y;
if (err_cpu.cols > i && status_cpu.cols > i) if (abs(moved_x) < 100 && abs(moved_y) < 100 && good_bbox_vec_flags[i])
if (abs(moved_x) < 100 && abs(moved_y) < 100) if (!check_error || (err_cpu.at<float>(0, i) < flow_error && status_cpu.at<unsigned char>(0, i) != 0))
if (!check_error || (err_cpu.at<float>(0, i) < 60 && status_cpu.at<unsigned char>(0, i) != 0))
{ {
cur_bbox_vec[i].x += moved_x + 0.5; cur_bbox_vec[i].x += moved_x + 0.5;
cur_bbox_vec[i].y += moved_y + 0.5; cur_bbox_vec[i].y += moved_y + 0.5;
result_bbox_vec.push_back(cur_bbox_vec[i]); result_bbox_vec.push_back(cur_bbox_vec[i]);
} }
else good_bbox_vec_flags[i] = false;
else good_bbox_vec_flags[i] = false;
}
} }
cur_pts_flow_gpu.swap(prev_pts_flow_gpu);
cur_pts_flow_cpu.copyTo(prev_pts_flow_cpu);
if (old_gpu_id != gpu_id) if (old_gpu_id != gpu_id)
cv::cuda::setDevice(old_gpu_id); cv::cuda::setDevice(old_gpu_id);

Write Preview
Loading…
Cancel
Save