Add asad interface prototype

modules/asad/include/acffeature.hpp

@@ -0,0 +1,78 @@
+class ACFFeature
+{
+public:
+    /* Initialize feature with zero row and col */
+    ACFFeature();
+
+    /* Initialize feature with given row and col */
+    ACFFeature(int row, int col);
+
+private:
+    /* Feature row */
+    int row_;
+    /* Feature col */
+    int col_;
+};
+
+/* Save ACFFeature to FileStorage */
+cv::FileStorage& operator<< (cv::FileStorage& out, const ACFFeature& feature);
+/* Load ACFFeature from FileStorage */
+cv::FileStorage& operator>> (cv::FileStorage& in, ACFFeature& feature);
+
+/* Compute channel pyramid for acf features
+
+    image — image, for which pyramid should be computed
+
+    params — pyramid computing parameters
+
+Returns computed channels in vectors N x CH,
+N — number of scales (outer vector),
+CH — number of channels (inner vectors)
+*/
+std::vector<std::vector<cv::Mat_<int>>>
+computeChannels(const cv::Mat& image, const ScaleParams& params);
+
+class ACFFeatureEvaluator
+{
+public:
+    /* Construct evaluator, set features to evaluate */
+    ACFFeatureEvaluator(const std::vector<ACFFeature>& features);
+
+    /* Set channels for feature evaluation */
+    void setChannels(const std::vector<cv::Mat_<int>>& channels);
+
+    /* Set window position */
+    void setPosition(Size position);
+
+    /* Evaluate feature with given index for current channels
+        and window position */
+    int evaluate(size_t feature_ind) const;
+
+    /* Evaluate all features for current channels and window position
+
+    Returns matrix-column of features
+    */
+    cv::Mat_<int> evaluateAll() const;
+
+private:
+    /* Features to evaluate */
+    std::vector<ACFFeature> features_;
+    /* Channels for feature evaluation */
+    std::vector<cv::Mat_<int>> channels
+    /* Channels window position */
+    Size position_;
+};
+
+/* Generate acf features
+
+    window_size — size of window in which features should be evaluated
+
+    count — number of features to generate.
+    Max number of features is min(count, # possible distinct features)
+
+    seed — random number generator initializer
+
+Returns vector of distinct acf features
+*/
+std::vector<ACFFeature>
+generateFeatures(Size window_size, size_t count = UINT_MAX, int seed = 0);

modules/asad/include/icfdetector.hpp

@@ -0,0 +1,51 @@
+class ICFDetector
+{
+public:
+    /* Initialize detector
+
+        min_obj_size — min possible object size on image in pixels (rows x cols)
+
+        max_obj_size — max possible object size on image in pixels (rows x cols)
+
+        scales_per_octave — number of images in pyramid while going
+                            from scale x to scale 2x. Affects on speed
+                            and quality of the detector
+    */
+    ICFDetector(Size min_obj_size,
+                Size max_obj_size,
+                int scales_per_octave = 8);
+
+    /* Load detector from file, return true on success, false otherwise */
+    bool load(const std::string& filename);
+
+    /* Run detector on single image
+
+        image — image for detection
+
+        bboxes — output array of bounding boxes in format
+                 Rect(row_from, col_from, n_rows, n_cols)
+
+        confidence_values — output array of confidence values from 0 to 1.
+            One value per bbox — confidence of detector that corresponding
+            bbox contatins object
+    */
+    void detect(const Mat& image,
+                std::vector<Rect>& bboxes,
+                std::vector<float>& confidence_values) const;
+
+
+    /* Train detector
+
+        image_filenames — filenames of images for training
+
+        labelling — vector of object bounding boxes per every image
+
+        params — parameters for detector training
+    */
+    void train(const std::vector<std::string>& image_filenames,
+               const std::vector<std::vector<Rect>>& labelling,
+               const ICFDetectorParams& params = ICFDetectorParams());
+
+    /* Save detector in file, return true on success, false otherwise */
+    bool save(const std::string& filename);
+};

modules/asad/include/waldboost.hpp

@@ -0,0 +1,81 @@
+class Stump
+{
+public:
+    /* Train stump for given data
+
+        data — matrix of feature values, size M x N, one feature per row
+
+        labels — matrix of sample class labels, size 1 x N. Labels can be from
+            {-1, +1}
+
+    Returns chosen feature index. Feature enumeration starts from 0
+    */
+    int train(const cv::Mat_<int>& data, const cv::Mat_<int>& labels);
+
+    /* Predict object class given
+
+        value — feature value. Feature must be the same as chose during training
+        stump
+
+    Returns object class from {-1, +1}
+    */
+    int predict(int value);
+
+private:
+    /* Stump decision threshold */
+    int threshold_;
+    /* Stump polarity, can be from {-1, +1} */
+    int polarity_;
+    /* Stump decision rule:
+        h(value) = polarity * sign(value - threshold)
+    */
+};
+
+/* Save Stump to FileStorage */
+cv::FileStorage& operator<< (cv::FileStorage& out, const Stump& classifier);
+/* Load Stump from FileStorage */
+cv::FileStorage& operator>> (cv::FileStorage& in, Stump& classifier);
+
+class WaldBoost
+{
+public:
+    /* Initialize WaldBoost cascade with default of specified parameters */
+    WaldBoost(const WaldBoostParams& = WaldBoostParams());
+
+    /* Train WaldBoost cascade for given data
+
+        data — matrix of feature values, size M x N, one feature per row
+
+        labels — matrix of sample class labels, size 1 x N. Labels can be from
+            {-1, +1}
+
+    Returns feature indices chosen for cascade.
+    Feature enumeration starts from 0
+    */
+    std::vector<int> train(const cv::Mat_<int>& data,
+                           const cv::Mat_<int>& labels);
+
+    /* Predict object class given object that can compute object features
+
+       feature_evaluator — object that can compute features by demand
+
+    Returns confidence_value — measure of confidense that object
+    is from class +1
+    */
+    float predict(const ACFFeatureEvaluator& feature_evaluator);
+
+private:
+    /* Parameters for cascade training */
+    WaldBoostParams params_;
+    /* Stumps in cascade */
+    std::vector<Stump> stumps_;
+    /* Weight for stumps in cascade linear combination */
+    std::vector<float> stump_weights_;
+    /* Rejection thresholds for linear combination at every stump evaluation */
+    std::vector<float> thresholds_;
+};
+
+/* Save WaldBoost to FileStorage */
+cv::FileStorage& operator<< (cv::FileStorage& out, const WaldBoost& classifier);
+/* Load WaldBoost from FileStorage */
+cv::FileStorage& operator>> (cv::FileStorage& in, WaldBoost& classifier);