Merge pull request #106 from mtamburrano/adas_fix

adas fix

Author: vpisarev

modules/adas/tools/fcw_detect/fcw_detect.cpp

@@ -48,15 +48,29 @@ static Mat visualize(const Mat &image, const vector<Rect> &objects)
     }
     return img;
 }
+static bool read_window_size(const char *str, int *rows, int *cols)
+{
+    int pos = 0;
+    if( sscanf(str, "%dx%d%n", rows, cols, &pos) != 2 || str[pos] != '\0' ||
+        *rows <= 0 || *cols <= 0)
+    {
+        return false;
+    }
+    return true;
+}
 
 int main(int argc, char *argv[])
 {
     const string keys =
-        "{help           |           | print this message}"
-        "{model_filename | model.xml | filename for reading model}"
-        "{image_path     |  test.png | path to image for detection}"
-        "{out_image_path |   out.png | path to image for output}"
-        "{threshold      |       0.0 | threshold for cascade}"
+        "{help            |           | print this message}"
+        "{model_filename  | model.xml | filename for reading model}"
+        "{image_path      |  test.png | path to image for detection}"
+        "{out_image_path  |   out.png | path to image for output}"
+        "{threshold       |       0.0 | threshold for cascade}"
+        "{step            |         8 | sliding window step}"
+        "{min_window_size |     40x40 | min window size in pixels}"
+        "{max_window_size |   300x300 | max window size in pixels}"
+        "{is_grayscale    |     false | read the image as grayscale}"
         ;
 
     CommandLineParser parser(argc, argv, keys);
@@ -71,7 +85,31 @@ int main(int argc, char *argv[])
     string model_filename = parser.get<string>("model_filename");
     string image_path = parser.get<string>("image_path");
     string out_image_path = parser.get<string>("out_image_path");
+    bool is_grayscale = parser.get<bool>("is_grayscale");
     float threshold = parser.get<float>("threshold");
+    int step = parser.get<int>("step");
+    
+    int min_rows, min_cols, max_rows, max_cols;
+    string min_window_size = parser.get<string>("min_window_size");
+    if( !read_window_size(min_window_size.c_str(), &min_rows,
+        &min_cols) )
+    {
+        cerr << "Error reading min window size from `" << min_window_size << "`" << endl;
+        return 1;
+    }
+    string max_window_size = parser.get<string>("max_window_size");
+    if( !read_window_size(max_window_size.c_str(), &max_rows,
+        &max_cols) )
+    {
+        cerr << "Error reading max window size from `" << max_window_size << "`" << endl;
+        return 1;
+    }
+    
+    int color;
+    if(is_grayscale == false)
+      color = cv::IMREAD_COLOR;
+    else
+      color = cv::IMREAD_GRAYSCALE;
 
 
     if( !parser.check() )
@@ -85,8 +123,10 @@ int main(int argc, char *argv[])
     detector.read(fs["icfdetector"]);
     fs.release();
     vector<Rect> objects;
-    Mat img = imread(image_path);
-    detector.detect(img, objects, 1.1f, Size(40, 40),
-        Size(300, 300), threshold);
+    Mat img = imread(image_path, color);
+    std::vector<float> values;
+    detector.detect(img, objects, 1.1f, Size(min_cols, min_rows), Size(max_cols, max_rows), threshold, step, values);
     imwrite(out_image_path, visualize(img, objects));
+    
+    
 }

modules/adas/tools/fcw_train/fcw_train.cpp

@@ -26,9 +26,14 @@ using cv::imread;
 #include <opencv2/core/utility.hpp>
 using cv::CommandLineParser;
 using cv::FileStorage;
+#include <opencv2/core/utility.hpp>
+
+#include <ctime>        // std::time
+#include <cstdlib>      // std::rand, std::srand
 
 #include <opencv2/xobjdetect.hpp>
 
+
 using cv::xobjdetect::ICFDetectorParams;
 using cv::xobjdetect::ICFDetector;
 using cv::xobjdetect::WaldBoost;
@@ -46,8 +51,11 @@ static bool read_model_size(const char *str, int *rows, int *cols)
     return true;
 }
 
+static int randomPred (int i) { return std::rand()%i;}
+
 int main(int argc, char *argv[])
 {
+    
     const string keys =
         "{help           |           | print this message}"
         "{pos_path       |       pos | path to training object samples}"
@@ -57,8 +65,15 @@ int main(int argc, char *argv[])
         "{weak_count     |       100 | number of weak classifiers in cascade}"
         "{model_size     |     40x40 | model size in pixels}"
         "{model_filename | model.xml | filename for saving model}"
+        "{features_type  |       icf | features type, \"icf\" or \"acf\"}"
+        "{alpha          |      0.02 | alpha value}"
+        "{is_grayscale   |     false | read the image as grayscale}"
+        "{use_fast_log   |     false | use fast log function}"
+        "{limit_ps       |        -1 | limit to positive samples (-1 means all)}"
+        "{limit_bg       |        -1 | limit to negative samples (-1 means all)}"
         ;
 
+
     CommandLineParser parser(argc, argv, keys);
     parser.about("FCW trainer");
 
@@ -76,15 +91,22 @@ int main(int argc, char *argv[])
     params.feature_count = parser.get<int>("feature_count");
     params.weak_count = parser.get<int>("weak_count");
     params.bg_per_image = parser.get<int>("bg_per_image");
-
+    params.features_type = parser.get<string>("features_type");
+    params.alpha = parser.get<float>("alpha");
+    params.is_grayscale = parser.get<bool>("is_grayscale");
+    params.use_fast_log = parser.get<bool>("use_fast_log");
+    
+    int limit_ps = parser.get<int>("limit_ps");
+    int limit_bg = parser.get<int>("limit_bg");    
+    
     string model_size = parser.get<string>("model_size");
     if( !read_model_size(model_size.c_str(), &params.model_n_rows,
         &params.model_n_cols) )
     {
         cerr << "Error reading model size from `" << model_size << "`" << endl;
         return 1;
     }
-
+    
     if( params.feature_count <= 0 )
     {
         cerr << "feature_count must be positive number" << endl;
@@ -97,20 +119,67 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    if( params.bg_per_image <= 0 )
+    if( params.features_type != "icf" &&  params.features_type != "acf" )
     {
-        cerr << "bg_per_image must be positive number" << endl;
+        cerr << "features_type must be \"icf\" or \"acf\"" << endl;
+        return 1;
+    }
+    if( params.alpha <= 0 )
+    {
+        cerr << "alpha must be positive float number" << endl;
         return 1;
     }
-
     if( !parser.check() )
     {
         parser.printErrors();
         return 1;
     }
+    
+    std::vector<cv::String> pos_filenames;
+    glob(pos_path, pos_filenames);
+
+    std::vector<cv::String> bg_filenames;
+    glob(bg_path, bg_filenames);
+        
+    if(limit_ps != -1 && (int)pos_filenames.size() > limit_ps)
+      pos_filenames.erase(pos_filenames.begin()+limit_ps, pos_filenames.end());
+    if(limit_bg != -1 && (int)bg_filenames.size() > limit_bg)
+      bg_filenames.erase(bg_filenames.begin()+limit_bg, bg_filenames.end());
+    
+    //random pick input images
+    bool random_shuffle = false;
+    if(random_shuffle)
+    {
+      std::srand ( unsigned ( std::time(0) ) );
+      std::random_shuffle ( pos_filenames.begin(), pos_filenames.end(), randomPred );
+      std::random_shuffle ( bg_filenames.begin(), bg_filenames.end(), randomPred );
+    }
+    
+    int samples_size = (int)((params.bg_per_image * bg_filenames.size()) + pos_filenames.size());
+    int features_size = params.feature_count;
+    int max_features_allowed = (int)(INT_MAX/(sizeof(int)* samples_size));
+    int max_samples_allowed = (int)(INT_MAX/(sizeof(int)* features_size));
+    int total_samples = (int)((params.bg_per_image * bg_filenames.size()) + pos_filenames.size());
+    
+    
+    if(total_samples >max_samples_allowed)
+    {
+      CV_Error_(1, ("exceeded maximum number of samples. Maximum number of samples with %d features is %d, you have %d (%d positive samples + (%d bg * %d bg_per_image))\n",features_size,max_samples_allowed,total_samples,pos_filenames.size(),bg_filenames.size(),params.bg_per_image ));
+    }
+    
+    if(params.feature_count >max_features_allowed)
+    {
+      CV_Error_(1, ("exceeded maximum number of features. Maximum number of features with %d samples is %d, you have %d\n",samples_size,max_features_allowed, features_size ));
+    }
+    
+    std::cout<<pos_filenames.size()<<std::endl;
+    std::cout<<bg_filenames.size()<<std::endl;
+
+    ICFDetector detector;    
+
+    
+    detector.train(pos_filenames, bg_filenames, params);
 
-    ICFDetector detector;
-    detector.train(pos_path, bg_path, params);
     FileStorage fs(model_filename, FileStorage::WRITE);
     fs << "icfdetector";
     detector.write(fs);

modules/text/src/erfilter.cpp

@@ -3751,7 +3751,7 @@ void erGroupingNM(InputArray _img, InputArrayOfArrays _src, vector< vector<ERSta
     _src.getMatVector(src);
 
     CV_Assert ( !src.empty() );
-    CV_Assert ( src.size() == regions.size() );
+    //CV_Assert ( src.size() == regions.size() );
     size_t num_channels = src.size();
 
     Mat img = _img.getMat();

modules/xobjdetect/doc/integral_channel_features.rst

@@ -165,9 +165,14 @@ Params for ICFDetector training.
         int model_n_rows;
         int model_n_cols;
         int bg_per_image;
+        std::string features_type;
+        float alpha;
+        bool is_grayscale;
+        bool use_fast_log;
 
         ICFDetectorParams(): feature_count(UINT_MAX), weak_count(100),
-            model_n_rows(56), model_n_cols(56), bg_per_image(5)
+            model_n_rows(56), model_n_cols(56), bg_per_image(5), 
+            alpha(0.02), is_grayscale(false), use_fast_log(false)
         {}
     };
 
@@ -181,7 +186,7 @@ ICFDetector::train
 
 Train detector.
 
-.. ocv:function:: void ICFDetector::train(const String& pos_path, const String& bg_path, ICFDetectorParams params = ICFDetectorParams())
+.. ocv:function:: void ICFDetector::train(const std::vector<String>& pos_filenames, const std::vector<String>& bg_filenames, ICFDetectorParams params = ICFDetectorParams())
 
     :param pos_path: path to folder with images of objects (wildcards like ``/my/path/*.png`` are allowed)
     :param bg_path: path to folder with background images
@@ -192,13 +197,20 @@ ICFDetector::detect
 
 Detect objects on image.
 
-.. ocv:function:: void ICFDetector::detect(const Mat& image, vector<Rect>& objects, float scaleFactor, Size minSize, Size maxSize, float threshold)
+.. ocv:function:: void ICFDetector::detect(const Mat& image, vector<Rect>& objects, float scaleFactor, Size minSize, Size maxSize, float threshold, int slidingStep, std::vector<float>& values)
+
+.. ocv:function:: detect(const Mat& img, std::vector<Rect>& objects, float minScaleFactor, float maxScaleFactor, float factorStep, float threshold, int slidingStep, std::vector<float>& values)
 
     :param image: image for detection
     :param objects: output array of bounding boxes
     :param scaleFactor: scale between layers in detection pyramid
     :param minSize: min size of objects in pixels
     :param maxSize: max size of objects in pixels
+    :param minScaleFactor: min factor by which the image will be resized
+    :param maxScaleFactor: max factor by which the image will be resized
+    :param factorStep: scaling factor is incremented each pyramid layer according to this parameter
+    :param slidingStep: sliding window step
+    :param values: output vector with values of positive samples 
 
 ICFDetector::write
 ------------------

modules/xobjdetect/include/opencv2/xobjdetect.hpp

@@ -43,6 +43,7 @@ the use of this software, even if advised of the possibility of such damage.
 #define __OPENCV_XOBJDETECT_XOBJDETECT_HPP__
 
 #include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
 #include <vector>
 #include <string>
 
@@ -102,6 +103,8 @@ std::vector<std::vector<int> >
 generateFeatures(Size window_size, const std::string& type,
                  int count = INT_MAX, int channel_count = 10);
 
+//sort in-place of columns of the input matrix
+void sort_columns_without_copy(Mat& m, Mat indices = Mat());
 
 struct CV_EXPORTS WaldBoostParams
 {
@@ -127,8 +130,8 @@ class CV_EXPORTS WaldBoost : public Algorithm
     Returns feature indices chosen for cascade.
     Feature enumeration starts from 0
     */
-    virtual std::vector<int> train(const Mat& /*data*/,
-                                   const Mat& /*labels*/) = 0;
+    virtual std::vector<int> train(Mat& /*data*/,
+                                   const Mat& /*labels*/, bool use_fast_log=false) = 0;
 
     /* Predict object class given object that can compute object features
 
@@ -157,28 +160,32 @@ struct CV_EXPORTS ICFDetectorParams
     int model_n_rows;
     int model_n_cols;
     int bg_per_image;
+    std::string features_type;
+    float alpha;
+    bool is_grayscale;
+    bool use_fast_log;
 
     ICFDetectorParams(): feature_count(UINT_MAX), weak_count(100),
-        model_n_rows(56), model_n_cols(56), bg_per_image(5)
+        model_n_rows(56), model_n_cols(56), bg_per_image(5), alpha(0.02f), is_grayscale(false), use_fast_log(false)
     {}
 };
 
 class CV_EXPORTS ICFDetector
 {
 public:
 
-    ICFDetector(): waldboost_(), features_() {}
+    ICFDetector(): waldboost_(), features_(), ftype_() {}
 
     /* Train detector
 
-        pos_path — path to folder with images of objects
+        pos_filenames — paths to objects images
 
-        bg_path — path to folder with background images
+        bg_filenames — path backgrounds images
 
         params — parameters for detector training
     */
-    void train(const String& pos_path,
-               const String& bg_path,
+    void train(const std::vector<String>& pos_filenames,
+               const std::vector<String>& bg_filenames,
                ICFDetectorParams params = ICFDetectorParams());
 
     /* Detect object on image
@@ -192,9 +199,35 @@ class CV_EXPORTS ICFDetector
         minSize — min size of objects in pixels
 
         maxSize — max size of objects in pixels
+        
+        slidingStep — sliding window step
+        
+        values — output vector with values of positive samples 
+        
     */
+        
     void detect(const Mat& image, std::vector<Rect>& objects,
-        float scaleFactor, Size minSize, Size maxSize, float threshold);
+        float scaleFactor, Size minSize, Size maxSize, float threshold, int slidingStep, std::vector<float>& values);
+    
+    /* Detect object on image
+
+        image — image for detection
+
+        object — output array of bounding boxes
+        
+        minScaleFactor — min factor image will be resized
+
+        maxScaleFactor — max factor image will be resized
+
+        factorStep — scaling factor is incremented according to factorStep
+        
+        slidingStep — sliding window step
+        
+        values — output vector with values of positive samples
+
+        
+    */
+    void detect(const Mat& img, std::vector<Rect>& objects, float minScaleFactor, float maxScaleFactor, float factorStep, float threshold, int slidingStep, std::vector<float>& values);
 
     /* Write detector to FileStorage */
     void write(FileStorage &fs) const;
@@ -207,6 +240,7 @@ class CV_EXPORTS ICFDetector
     std::vector<std::vector<int> > features_;
     int model_n_rows_;
     int model_n_cols_;
+    std::string ftype_;
 };
 
 CV_EXPORTS void write(FileStorage& fs, String&, const ICFDetector& detector);