blame | history | patch | commit | commitdiff | ignore whitespace
AlexeyAB
2018-01-07 aeb15b3cb9157f5d0b2a9962e17de22560b8a1b2 
 src/yolo_console_dll.cpp


@@ -11,10 +11,11 @@




#ifdef _WIN32


#define OPENCV


#include "windows.h"


//#include "windows.h"


#endif




#define TRACK_OPTFLOW


//#define TRACK_OPTFLOW




#include "yolo_v2_class.hpp"  // imported functions from DLL




#ifdef OPENCV


@@ -101,6 +102,7 @@


   bool const save_output_videofile = false;


#ifdef TRACK_OPTFLOW


   Tracker_optflow tracker_flow;


   detector.wait_stream = true;


#endif




   while (true) 


@@ -131,7 +133,7 @@


            int current_det_fps = 0, current_cap_fps = 0;


            std::thread t_detect, t_cap, t_videowrite;


            std::mutex mtx;


            std::condition_variable cv;


            std::condition_variable cv_detected, cv_pre_tracked;


            std::chrono::steady_clock::time_point steady_start, steady_end;


            cv::VideoCapture cap(filename); cap >> cur_frame;


            int const video_fps = cap.get(CV_CAP_PROP_FPS);


@@ -153,79 +155,30 @@


               // swap result bouned-boxes and input-frame


               if(consumed)


               {


                  {


                     std::unique_lock<std::mutex> lock(mtx);


                     det_image = detector.mat_to_image_resize(cur_frame);


                     result_vec = thread_result_vec;


                     result_vec = detector.tracking(result_vec);  // comment it - if track_id is not required




                     consumed = false;


                  }




                  std::unique_lock<std::mutex> lock(mtx);


                  det_image = detector.mat_to_image_resize(cur_frame);


                  result_vec = thread_result_vec;


                  result_vec = detector.tracking(result_vec);  // comment it - if track_id is not required


#ifdef TRACK_OPTFLOW


                  int y = 0, x = 0;


                  cv::Mat show_flow = cur_frame.clone();


                  auto lambda = [&x, &y](cv::Mat draw_frame, cv::Mat src_frame, std::vector<bbox_t> result_vec) {


                     //if (x > 10) return;


                     if (result_vec.size() == 0) return;


                     bbox_t i = result_vec[0];


                     cv::Rect r(i.x, i.y, i.w, i.h);


                     //cv::Rect r(i.x + (i.w-31)/2, i.y + (i.h - 31)/2, 31, 31);


                     cv::Rect img_rect(cv::Point2i(0, 0), src_frame.size());


                     cv::Rect rect_roi = r & img_rect;


                     if (rect_roi.width < 1 || rect_roi.height < 1) return;


                     cv::Mat roi = src_frame(rect_roi);


                     cv::Mat dst;


                     cv::resize(roi, dst, cv::Size(100, 100));


                     if (x > 10) x = 0, ++y;


                     cv::Rect dst_rect_roi(cv::Point2i(x*100, y*100), dst.size());


                     cv::Mat dst_roi = draw_frame(dst_rect_roi);


                     dst.copyTo(dst_roi);




                     ++x;


                  };






                  // track optical flow


                  if (track_optflow_queue.size() > 0) {


                     //show_flow = track_optflow_queue.front().clone();


                     //draw_boxes(show_flow, result_vec, obj_names, 3, current_det_fps, current_cap_fps);




                     std::queue<cv::Mat> new_track_optflow_queue;


                     //std::cout << "\n !!!! all = " << track_optflow_queue.size() << ", cur = " << passed_flow_frames << std::endl;


                     if (result_vec.size() > 0) {


                        draw_boxes(track_optflow_queue.front().clone(), result_vec, obj_names, 3, current_det_fps, current_cap_fps);


                        std::cout << "\n frame_size = " << track_optflow_queue.size() << std::endl;


                        cv::waitKey(1000);


                     }


                     tracker_flow.update_tracking_flow(track_optflow_queue.front());


                     lambda(show_flow, track_optflow_queue.front(), result_vec);


                     track_optflow_queue.pop();


                     while(track_optflow_queue.size() > 0) {


                        if (result_vec.size() > 0) {


                           draw_boxes(track_optflow_queue.front().clone(), result_vec, obj_names, 3, current_det_fps, current_cap_fps);


                           std::cout << "\n frame_size = " << track_optflow_queue.size() << std::endl;


                           cv::waitKey(1000);


                        }




                     while (track_optflow_queue.size() > 1) {


                        track_optflow_queue.pop();


                        result_vec = tracker_flow.tracking_flow(track_optflow_queue.front(), result_vec);


                        if (track_optflow_queue.size() <= passed_flow_frames && new_track_optflow_queue.size() == 0)


                           new_track_optflow_queue = track_optflow_queue;


                        lambda(show_flow, track_optflow_queue.front(), result_vec);


                        track_optflow_queue.pop();


                     }					


                     }


                     track_optflow_queue = new_track_optflow_queue;


                     new_track_optflow_queue.swap(std::queue<cv::Mat>());


                     passed_flow_frames = 0;


                     //std::cout << "\n !!!! now = " << track_optflow_queue.size() << ", cur = " << passed_flow_frames << std::endl;




                     cv::imshow("flow", show_flow);


                     cv::waitKey(3);


                     //if (result_vec.size() > 0) {


                     // cv::waitKey(1000);


                     //}


                  }


#endif




                  consumed = false;


                  cv_pre_tracked.notify_all();


               }


               // launch thread once - Detection


               if (!t_detect.joinable()) {


@@ -234,14 +187,14 @@


                     consumed = true;


                     while (current_image.use_count() > 0) {


                        auto result = detector.detect_resized(*current_image, frame_size, 0.24, false);  // true


                        //Sleep(200);


                        Sleep(50);


                        ++fps_det_counter;


                        std::unique_lock<std::mutex> lock(mtx);


                        thread_result_vec = result;


                        current_image = det_image;


                        consumed = true;


                        cv.notify_all();


                        cv_detected.notify_all();


                        if(detector.wait_stream)


                           while (consumed) cv_pre_tracked.wait(lock);


                     }


                  });


               }


@@ -262,7 +215,7 @@


                  result_vec = tracker_flow.tracking_flow(cur_frame, result_vec);   // track optical flow


#endif




                  draw_boxes(cur_frame, result_vec, obj_names, 3, current_det_fps, current_cap_fps);


                  draw_boxes(cur_frame, result_vec, obj_names, 3, current_det_fps, current_cap_fps);  // 3 or 16ms


                  //show_console_result(result_vec, obj_names);




                  if (output_video.isOpened() && videowrite_ready) {


@@ -278,7 +231,7 @@


               // wait detection result for video-file only (not for net-cam)


               //if (protocol != "rtsp://" && protocol != "http://" && protocol != "https:/") {


               // std::unique_lock<std::mutex> lock(mtx);


               // while (!consumed) cv.wait(lock);


               // while (!consumed) cv_detected.wait(lock);


               //}


            }


            if (t_cap.joinable()) t_cap.join();