Covert vector to python list

diff --git a/include/Detector.h b/include/Detector.h
index c1c5a9b..cb52902 100644 (file)
--- a/include/Detector.h
+++ b/include/Detector.h
@@ -15,7 +15,7 @@ namespace suanzi {
         Detector();
         virtual ~Detector();
         // TODO
-        unsigned int detect(const cv::Mat& frame, Detection* detections){return 1;}
+        unsigned int detect(const cv::Mat& frame, Detection* detections){return 0;}
     };
 
     struct Detection

diff --git a/include/Metrics.h b/include/Metrics.h
index ad1a827..2aa7939 100644 (file)
--- a/include/Metrics.h
+++ b/include/Metrics.h
@@ -9,7 +9,7 @@ namespace suanzi {
 
     TK_DECLARE_PTR(Metrics);
     //TK_DECLARE_PTR(Patch);
-    struct Patch;
+//    struct Patch;
     class Metrics
     {
     public:
@@ -17,26 +17,20 @@ namespace suanzi {
         ~Metrics(){}
         const static long int MaxCost = 100000;
         const static int MaxPatch = 5;
-        void similarity(const Patch& p1, const Patch& p2);
         //double distance()
-
-
     private:
         cv::HOGDescriptor descriptor = {cv::Size(64, 128), cv::Size(16, 16), cv::Size(8, 8), cv::Size(8, 8), 9};
     };
 
-    struct Patch
-    {
-        // bb_ltrb
-        
-        //
-        // image_crop
-        cv::Mat image_crop;
-        //
-        // features
-
-    };
-
+//    struct Patch
+//    {
+//        // bb_ltrb
+//        //
+//        // image_crop
+//        cv::Mat image_crop;
+//        //
+//        // features
+//    };
 }
 
 #endif /* _METRICS_H_ */

diff --git a/include/MultiTracker.h b/include/MultiTracker.h
index 0452c00..190225d 100644 (file)
--- a/include/MultiTracker.h
+++ b/include/MultiTracker.h
@@ -3,33 +3,42 @@
 
 #include "Tracker.h"
 #include "Detector.h"
-#include "Metrics.h"
 #include "SharedPtr.h"
 #include "PredictorWrapper.h"
 #include <opencv2/opencv.hpp>
 
 namespace suanzi {
 
+    TK_DECLARE_PTR(Patch);
     TK_DECLARE_PTR(MultiTracker);
+    TK_DECLARE_PTR(Tracker);
 
     class MultiTracker 
     {
     public:
-        MultiTracker(MetricsPtr m);
+        MultiTracker();
         virtual ~MultiTracker();
         void update(unsigned int total, const Detection* d, const cv::Mat& image);
 
     private:
-        MetricsPtr metrics;
         std::vector<TrackerPtr> trackers;
         int max_id = 0;
-        //void addTracker(TrackerPtr t);
-        //TrackerPtr createTracker(int id = 0);
-        void removeTracker(TrackerPtr t);
-        void correctTrackers(MetricsPtr m, cv::Mat& image);
-        void initNewTrackers(cv::Mat& iamge);
+        PatchPtr createPatch(const cv::Mat& image);
+        double distance(TrackerPtr t, const cv::Mat& image, const Detection& d);
         PredictorWrapperPtr predictor;
+        cv::HOGDescriptor descriptor;
+    };
 
+    class Patch
+    {
+    public:
+        ~Patch(){};
+        // bb_ltrb
+        cv::Mat image_crop;
+        std::vector<float> features;
+    protected:
+        friend class MultiTracker;
+        Patch(){};
     };
 
 

diff --git a/include/PredictorWrapper.h b/include/PredictorWrapper.h
index ac54f73..9ceb21a 100644 (file)
--- a/include/PredictorWrapper.h
+++ b/include/PredictorWrapper.h
@@ -3,6 +3,7 @@
 
 #include "SharedPtr.h"
 #include <boost/python.hpp>
+#include <vector>
 
 namespace suanzi {
 
@@ -16,7 +17,7 @@ namespace suanzi {
         static PredictorWrapperPtr create(const std::string& fname);
         ~PredictorWrapper(){}
         void dump();
-        double predict();
+        double predict(int index, std::vector<double> f);
 
     private:
         PredictorWrapper(const std::string& fname);

diff --git a/include/Tracker.h b/include/Tracker.h
index bdf45f0..9eb3139 100644 (file)
--- a/include/Tracker.h
+++ b/include/Tracker.h
@@ -6,9 +6,12 @@
 #include <vector>
 #include "Metrics.h"
 #include "SharedPtr.h"
+#include "MultiTracker.h"
 
 namespace suanzi {
 
+    TK_DECLARE_PTR(Tracker);
+    TK_DECLARE_PTR(Patch);
     typedef enum 
     {
         Fire = -1,
@@ -17,36 +20,24 @@ namespace suanzi {
         Delete
     } TrackerStatus;
 
-    TK_DECLARE_PTR(Tracker);
-//    TK_DECLARE_PTR(KalmanFilter);
     class Tracker
     {
     public:
         Tracker(const cv::Mat& image, int id = 0);
         virtual ~Tracker();
         void updateState(const cv::Mat& image);
-//        void addPatch(Patch* p);
+        void addPatch(PatchPtr p);
         TrackerStatus status;
+        std::vector<PatchPtr> patches;
 
     private:
         TrackerStatus preStatus;
         int id;
         int age;
         int last_active;
-        std::vector<Patch> patches;
         cv::KalmanFilter kf = {4,2};
     };
 
-//    class KalmanFilter
-//    {
-//    public:
-//        KalmanFilter();
-//        ~KalmanFilter();
-//    private:
-//        cv::KalmanFilter
-//
-//    };
-
 
 }
 

diff --git a/main.cpp b/main.cpp
index f1b466b..bfc076d 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -25,7 +25,8 @@ int main(int argc, char* argv[])
     LOG_DEBUG(TAG, "==================================");
     EnginePtr e = Engine::create();
     e->addObserver(new Callback());
-    e->setVideoSrc(VideoSrcType::URL, "rtsp://192.168.1.75:554/stream1");
+    //e->setVideoSrc(VideoSrcType::URL, "rtsp://192.168.1.75:554/stream1");
+    e->setVideoSrc(VideoSrcType::URL, "rtsp://192.168.56.101:5454/test.mp4");
     e->start();
     e->destroy();
     log4cpp::Category::shutdown();

diff --git a/python/predictor.py b/python/predictor.py
index b58fd41..5dc12af 100644 (file)
--- a/python/predictor.py
+++ b/python/predictor.py
@@ -28,6 +28,7 @@ def predict(index, features):
     pp = predictors[index]
     true_class = int(pp.classes_[1] == 1)
     prob = pp.predict_proba([features])[0, true_class]
+    print prob
     return prob
 
 

diff --git a/src/Engine.cpp b/src/Engine.cpp
index 78af761..a1defdb 100644 (file)
--- a/src/Engine.cpp
+++ b/src/Engine.cpp
@@ -28,8 +28,7 @@ EnginePtr Engine::create()
 Engine::Engine()
 {
     detector = std::make_shared<Detector>();
-    MetricsPtr m (new Metrics("model.pkl"));
-    multiTracker = std::make_shared<MultiTracker>(m);
+    multiTracker = std::make_shared<MultiTracker>();
 }
 
 Engine::~Engine()

diff --git a/src/Metrics.cpp b/src/Metrics.cpp
index 49822f2..4ff14ea 100644 (file)
--- a/src/Metrics.cpp
+++ b/src/Metrics.cpp
@@ -12,7 +12,3 @@ Metrics::Metrics(const std::string& clf_path)
 
     }
 }
-
-void Metrics::similarity(const Patch& p1, const Patch& p2)
-{
-}

diff --git a/src/MultiTracker.cpp b/src/MultiTracker.cpp
index 01e60c5..267ba0f 100644 (file)
--- a/src/MultiTracker.cpp
+++ b/src/MultiTracker.cpp
@@ -9,67 +9,64 @@ using namespace cv;
 using namespace Eigen;
 
 static const std::string TAG = "MultiTracker";
-MultiTracker::MultiTracker(MetricsPtr m) : metrics(m)
+static const cv::Size PREFERRED_SIZE = Size(64, 128);
+
+#define MaxCost  100000
+
+MultiTracker::MultiTracker()
 {
     LOG_DEBUG(TAG, "init - load model.pkl");
     predictor = PredictorWrapper::create("./python/model.pkl");
     predictor->dump();
+    this->descriptor = {cv::Size(64, 128), cv::Size(16, 16), cv::Size(8, 8), cv::Size(8, 8), 9};
+    std::vector<double> ff (40, 1);
+    predictor->predict(4, ff);
 }
 
-
 MultiTracker::~MultiTracker()
 {
     trackers.clear();
 }
-//
-//TrackerPtr MultiTracker::createTracker(int id)
-//{
-//    TrackerPtr t (new Tracker(id));
-//    addTracker(t);
-//    return t;
-//}
-//
-//void MultiTracker::addTracker(TrackerPtr t)
-//{
-//    trackers.push_back(t);
-//}
-//
-void MultiTracker::removeTracker(TrackerPtr t)
-{
-//    trackers.erase(t);
-}
-
-void MultiTracker::initNewTrackers(cv::Mat& iamge)
-{
-}
 
 
-void MultiTracker::correctTrackers(MetricsPtr m, Mat& image)
+static std::vector<double> similarity(const PatchPtr p1, const PatchPtr p2)
 {
-}
+    std::vector<double> feature;
+    cv::Mat im1(PREFERRED_SIZE, p1->image_crop.type());
+    cv::Mat im2(PREFERRED_SIZE, p2->image_crop.type());
+    cv::resize(p1->image_crop, im1, im1.size());
+    cv::resize(p2->image_crop, im2, im2.size());
+    cv::Mat result;
+    cv::matchTemplate(im1, im2, result, CV_TM_CCOEFF_NORMED);
+    feature.push_back(result.at<double>(0, 0));
+    cv::matchTemplate(im1, im2, result, CV_TM_CCORR_NORMED);
+    feature.push_back(result.at<double>(0, 0));
 
-void calculate_edistance()
-{
+    return feature;
 }
 
-#define MaxCost  100000
 
-static double distance(TrackerPtr t, const cv::Mat& image, const Detection& d)
+double MultiTracker::distance(TrackerPtr t, const cv::Mat& image, const Detection& d)
 {
-    return 0.1;
+    PatchPtr patch = createPatch(image);
+    std::vector<double> features;
+    std::vector<double> ss;
+    for (const auto i : t->patches){
+        ss = similarity(i, patch);
+        features.insert(features.end(),  ss.begin(), ss.end());
+    }
+    //predictor->predict();
+    return 0.1; 
 }
 
 void MultiTracker::update(unsigned int total, const Detection* detections, const Mat& image)
 {
-    // correct_trackers
-    // Generate cost matrix
     int row = trackers.size();
     int col = total;
     MatrixXi cost_matrix = MatrixXi::Zero(row, col);
     for (int i = 0; i < row; i++){
         for (int j = 0; j < col; j++){
             // TODO
-            // int cost = MaxCost;
             cost_matrix(i, j) = distance(trackers[i], image, detections[j]);
         }
     }
@@ -103,3 +100,17 @@ void MultiTracker::update(unsigned int total, const Detection* detections, const
         this->trackers.push_back(t);
     }
 }
+
+PatchPtr MultiTracker::createPatch(const cv::Mat& image)
+{
+    PatchPtr patch(new Patch());
+    std::vector<float> feature_hog;
+    cv::Mat img;
+    cv::resize(image, img, PREFERRED_SIZE);
+    this->descriptor.compute(img, feature_hog);
+
+    cv::Mat hist;
+    //cv::calcHist()
+    patch->image_crop = image;
+    return patch;
+}

diff --git a/src/PredictorWrapper.cpp b/src/PredictorWrapper.cpp
index 0943e98..20fefc3 100644 (file)
--- a/src/PredictorWrapper.cpp
+++ b/src/PredictorWrapper.cpp
@@ -17,6 +17,15 @@ const static std::string TAG = "PredictorWrapper";
 
 static std::string parse_python_exception();
 
+template <class T>
+boost::python::list toPythonList(std::vector<T> vector) {
+    typename std::vector<T>::iterator iter;
+    boost::python::list list;
+    for (iter = vector.begin(); iter != vector.end(); ++iter) {
+        list.append(*iter);
+    }
+    return list;
+}
 
 PredictorWrapperPtr PredictorWrapper::create(const std::string& fname)
 {
@@ -42,11 +51,11 @@ void PredictorWrapper::dump()
     LOG_DEBUG(TAG, ss);
 }
 
-double PredictorWrapper::predict()
+double PredictorWrapper::predict(int index, std::vector<double> ff)
 {
     LOG_DEBUG(TAG, "predict");
     try{
-        this->predict_func();
+        this->predict_func(index, toPythonList(ff));
     } catch (boost::python::error_already_set const &){
         std::string perror_str = parse_python_exception();
         LOG_ERROR(TAG, "Error in Python: " + perror_str)

diff --git a/src/Tracker.cpp b/src/Tracker.cpp
index 50bc820..99a4e28 100644 (file)
--- a/src/Tracker.cpp
+++ b/src/Tracker.cpp
@@ -25,20 +25,15 @@ Tracker::Tracker(const cv::Mat& image,int id) : id(id)
     this->kf.processNoiseCov = 1e-5 * Mat_<float>::eye(4, 4);
     this->kf.measurementNoiseCov = 1e-1 * Mat_<float>::ones(2, 2);
     this->kf.errorCovPost = 1. * Mat_<float>::ones(4, 4);
+
+
 }
 
 Tracker::~Tracker()
 {
+    patches.clear();
 }
 
-//void Tracker::addPatch(Patch* p)
-//{
-//    patches.push_back(p);
-//    if (patches.size() > Metrics::MaxPatch){
-//        patches.erase(patches.end());
-//    }
-//}
-//
 void Tracker::updateState(const Mat& image)
 {
     preStatus = this->status;
@@ -53,3 +48,8 @@ void Tracker::updateState(const Mat& image)
         status = TrackerStatus::Lost;
     }
 }
+
+void Tracker::addPatch(PatchPtr p)
+{
+    this->patches.push_back(p);
+}

diff --git a/src/VideoReader.cpp b/src/VideoReader.cpp
index b965fa1..cfba733 100644 (file)
--- a/src/VideoReader.cpp
+++ b/src/VideoReader.cpp
@@ -47,6 +47,13 @@ UrlReader::~UrlReader()
     vcap.release();
 }
 
+static long count = 0;
+
+static void printImg(const cv::Mat& mat)
+{
+    std::cout << mat.at<int>(0,0) << std::endl;
+}
+
 bool UrlReader::read(cv::Mat& mat)
 {
     bool ret = vcap.read(mat);
@@ -54,18 +61,10 @@ bool UrlReader::read(cv::Mat& mat)
         LOG_ERROR(TAG, "blank frame grabbed");
         return false;
     }
+    count++;
+    std::string name = "./temp/image_" + std::to_string(count) + ".png";
+    if ((count % 50 == 0)){
+        imwrite(name.c_str(), mat);
+    }
     return ret;
 }
-
-//
-//void UrlReader::read()
-//{
-//}
-//
-//void FileReader::read()
-//{
-//}
-//
-//void UsbReader::read()
-//{
-//}

diff --git a/src/VideoSource.cpp b/src/VideoSource.cpp
deleted file mode 100644 (file)
index e69de29..0000000

diff --git a/src/hungarian.cpp b/src/hungarian.cpp
index 7c1d8da..e8f49e3 100644 (file)
--- a/src/hungarian.cpp
+++ b/src/hungarian.cpp
@@ -57,6 +57,11 @@ int linear_sum_assignment(const MatrixXi& cost_matrix, VectorXi& row_ind, Vector
 {
     // The algorithm expects more columns than rows in the cost matrix.
     MatrixXi correct_matrix = cost_matrix;
+    if (cost_matrix.cols() == 0 || cost_matrix.rows() == 0){
+        row_ind = VectorXi::Zero(0);
+        col_ind = VectorXi::Zero(0);
+        return 0;
+    }
     bool is_transposed = false;
     if (cost_matrix.cols() < cost_matrix.rows()){
         cout << "cols < rows, transpose." << endl;