Tracking fixed

AlexeyAB

2018-01-04 e205c1e7aeb47e3dffd35d1b5ce7841d24b9aff4

Tracking fixed

 src/yolo_console_dll.cpp

@@ -93,8 +93,8 @@
    std::string filename;
    if (argc > 1) filename = argv[1];

    //Detector detector("cfg/yolo-voc.cfg", "yolo-voc.weights");
    Detector detector("tiny-yolo-voc_air.cfg", "backup/tiny-yolo-voc_air_5000.weights");
    Detector detector("cfg/yolo-voc.cfg", "yolo-voc.weights");
    //Detector detector("tiny-yolo-voc_air.cfg", "backup/tiny-yolo-voc_air_5000.weights");

    auto obj_names = objects_names_from_file("data/voc.names");
    std::string out_videofile = "result.avi";
@@ -158,71 +158,27 @@
                            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;
                        }

#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);
                                }
                                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


 src/yolo_v2_class.hpp

@@ -12,7 +12,7 @@
#include <opencv2/cudaoptflow.hpp>
#include <opencv2/cudaimgproc.hpp>
#include <opencv2/cudaarithm.hpp>
#include "opencv2/core/cuda.hpp"
#include <opencv2/core/cuda.hpp>
#endif  // OPENCV

#ifdef YOLODLL_EXPORTS
@@ -156,7 +156,23 @@

class Tracker_optflow {
public:
    int gpu_id;

    Tracker_optflow(int _gpu_id = 0) : gpu_id(_gpu_id)
    {
        int const old_gpu_id = cv::cuda::getDevice();
        static const int gpu_count = cv::cuda::getCudaEnabledDeviceCount();
        if (gpu_count > gpu_id)
            cv::cuda::setDevice(gpu_id);

        sync_PyrLKOpticalFlow_gpu = cv::cuda::SparsePyrLKOpticalFlow::create();
        //sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(31, 31)); //sync_PyrLKOpticalFlow_gpu.winSize = cv::Size(31, 31);
        //sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(15, 15)); //sync_PyrLKOpticalFlow_gpu.winSize = cv::Size(15, 15);

        sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(21, 21));
        sync_PyrLKOpticalFlow_gpu->setMaxLevel(50); //sync_PyrLKOpticalFlow_gpu.maxLevel = 8;   // +-32 points  // def: 3
        sync_PyrLKOpticalFlow_gpu->setNumIters(6000);   //sync_PyrLKOpticalFlow_gpu.iters = 8000;   // def: 30
    }

    // just to avoid extra allocations
    cv::cuda::GpuMat src_mat_gpu;
@@ -168,7 +184,7 @@
    cv::cuda::GpuMat src_grey_gpu;  // used in both functions
    cv::Ptr<cv::cuda::SparsePyrLKOpticalFlow> sync_PyrLKOpticalFlow_gpu;

    void update_tracking_flow(cv::Mat src_mat, int gpu_id = 0)
    void update_tracking_flow(cv::Mat src_mat)
    {
        int const old_gpu_id = cv::cuda::getDevice();
        static const int gpu_count = cv::cuda::getCudaEnabledDeviceCount();
@@ -177,20 +193,6 @@

        cv::cuda::Stream stream;

        if (sync_PyrLKOpticalFlow_gpu.empty()) {
            sync_PyrLKOpticalFlow_gpu = cv::cuda::SparsePyrLKOpticalFlow::create();

            //sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(31, 31)); //sync_PyrLKOpticalFlow_gpu.winSize = cv::Size(31, 31);
            //sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(15, 15)); //sync_PyrLKOpticalFlow_gpu.winSize = cv::Size(15, 15);
            sync_PyrLKOpticalFlow_gpu->setWinSize(cv::Size(21, 21));
            sync_PyrLKOpticalFlow_gpu->setMaxLevel(3);  //sync_PyrLKOpticalFlow_gpu.maxLevel = 8;   // +-32 points  // def: 3
            sync_PyrLKOpticalFlow_gpu->setNumIters(6000);   //sync_PyrLKOpticalFlow_gpu.iters = 8000;   // def: 30
            //??? //sync_PyrLKOpticalFlow_gpu.getMinEigenVals = true;
            //std::cout << "sync_PyrLKOpticalFlow_gpu.maxLevel: " << sync_PyrLKOpticalFlow_gpu.maxLevel << std::endl;
            //std::cout << "sync_PyrLKOpticalFlow_gpu.iters: " << sync_PyrLKOpticalFlow_gpu.iters << std::endl;
            //std::cout << "sync_PyrLKOpticalFlow_gpu.winSize: " << sync_PyrLKOpticalFlow_gpu.winSize << std::endl;
        }

        if (src_mat.channels() == 3) {
            if (src_mat_gpu.cols == 0) {
                src_mat_gpu = cv::cuda::GpuMat(src_mat.size(), src_mat.type());
@@ -199,13 +201,12 @@

            src_mat_gpu.upload(src_mat, stream);
            cv::cuda::cvtColor(src_mat_gpu, src_grey_gpu, CV_BGR2GRAY, 0, stream);
            //std::cout << " \n\n OK !!! \n\n";
        }
        cv::cuda::setDevice(old_gpu_id);
    }


    std::vector<bbox_t> tracking_flow(cv::Mat dst_mat, std::vector<bbox_t> cur_bbox_vec, int gpu_id = 0)
    std::vector<bbox_t> tracking_flow(cv::Mat dst_mat, std::vector<bbox_t> cur_bbox_vec)
    {
        if (sync_PyrLKOpticalFlow_gpu.empty()) {
            std::cout << "sync_PyrLKOpticalFlow_gpu isn't initialized \n";
@@ -265,9 +266,8 @@

        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
                                                                                                                                        //std::cout << "\n 1-e \n";

        cur_pts_flow_gpu.download(cur_pts_flow_cpu, stream);