Unimplemented header files for adaboost

JordanCheney
1 parent d24c2952
Showing 9 changed files with 177 additions and 1 deletions
openbr/CMakeLists.txt
openbr/learning/adaboost.cpp
openbr/learning/adaboost.h
openbr/learning/cascade.cpp
openbr/learning/cascade.h
openbr/learning/feature.cpp
openbr/learning/feature.h
openbr/learning/trainingdata.cpp
openbr/learning/trainingdata.h
@@ -11,6 +11,7 @@ add_definitions(-DJANUS_LIBRARY)
 # Collect source files
 aux_source_directory(. SRC)
 aux_source_directory(core BR_CORE)
+aux_source_directory(learning BR_LEARNING)
 include(plugins/plugins.cmake)
  
 # Optional GUI module
@@ -21,7 +22,7 @@ if(NOT ${BR_EMBEDDED})
   install(FILES ${HEADERS} DESTINATION include/openbr/gui)
 endif()
  
-add_library(openbr SHARED ${SRC} ${BR_CORE} ${BR_JANUS} ${BR_GUI} ${BR_ICONS} ${BR_THIRDPARTY_SRC} ${BR_RESOURCES} ${NATURALSTRINGCOMPARE_SRC})
+add_library(openbr SHARED ${SRC} ${BR_CORE} ${BR_LEARNING} ${BR_JANUS} ${BR_GUI} ${BR_ICONS} ${BR_THIRDPARTY_SRC} ${BR_RESOURCES} ${NATURALSTRINGCOMPARE_SRC})
 qt5_use_modules(openbr ${QT_DEPENDENCIES})
 set_target_properties(openbr PROPERTIES
                              DEFINE_SYMBOL BR_LIBRARY
+#include "adaboost.h"
+
+AdaBoost::AdaBoost()
+{
+}
+#ifndef ADABOOST_H
+#define ADABOOST_H
+
+#include "trainingdata.h"
+#include <openbr/openbr_plugin.h>
+
+namespace br
+{
+
+struct Node
+{
+    Node(int feature_idx, float threshold, int polarity, float weight) : feature_idx(feature_idx), threshold(threshold), polarity(polarity), weight(weight) {}
+    int predict(float feature_response) const { return (polarity * (feature_response - threshold)) > 0 ? 1 : -1; }
+
+    int feature_idx; // index of the feature corresponding to this weak classifier
+    float threshold; // threshold at which classifier predicts yes or no
+    int polarity; // 1 or -1. 1 if high responses correspond to positives, -1 if low values do.
+    float weight; // weight of this classifier. Higher weight = more accurate classifier
+};
+
+struct DecisionTree
+{
+    DecisionTree() {}
+    void append(Node node); // add a node to the tree
+    float predict(QList<float> responses) const; // progress down the tree. Return value should be the
+                                                 // sum of the weights of the correct nodes.
+
+    QList<Node> tree; // List of the weak classifiers
+};
+
+class AdaBoost
+{
+public:
+    AdaBoost();
+    DecisionTree train(int num_classifiers); // mostly a wrapper to call selectBestNode() and updateWeights() num_classifiers times.
+
+private:
+    Node selectBestNode(); // search through all possible features to find one that improves performance the most
+    void updateWeights(); // successful classification lowers weights, unsuccesful raises weights. After changes weights are normalized between 0 and 1
+
+    TrainingData td; // training data to train on
+    DecisionTree classifier; // classifier to be trained
+};
+
+}
+#endif // ADABOOST_H
+#include "cascade.h"
+
+Cascade::Cascade()
+{
+}
+#ifndef CASCADE_H
+#define CASCADE_H
+
+#include "feature.h"
+#include "adaboost.h"
+#include <openbr/openbr_plugin.h>
+
+namespace br
+{
+
+// I'm not sure if this class can be made general enough (i.e not just for face detection) to live here.
+// Ideally, it should handle model i/o, and probably detection as well. Perhaps it is better in plugins/cascade.cpp
+class Cascade
+{
+public:
+    Cascade(const DecisionTree &classifier, const FeatureEvaluator &evaluator) : classifier(classifier), evaluator(evaluator) {}
+    void detect(const cv::Mat &img, QList<QRectF> &detections, QList<float> &confidences);
+
+    void write(QString path);
+    static Cascade read(QString path);
+
+private:
+    DecisionTree classifier;
+    FeatureEvaluator evaluator;
+};
+
+}
+
+#endif // CASCADE_H
+#include "feature.h"
+
+Feature::Feature()
+{
+}
+#ifndef FEATURE_H
+#define FEATURE_H
+
+#include <openbr/openbr_plugin.h>
+
+// These two classes should be subclassed to handle any type of feature. In a perfect world I would like to subclass
+// only Feature, and have FeatureEvaluator just call randomize and evaluate (and thus not have to be subclassed) as
+// that would be simpler.
+namespace br
+{
+
+class Feature
+{
+public:
+    Feature();
+    QList<int> get_definition() { return definition; }
+
+    virtual void randomize(int height, int width, int channels) = 0; // Initialize the feature within these dimensions
+    virtual float evaluate(const QList<cv::Mat> &img, const cv::Size &pos) const = 0; // img is a list of mats to support multiple channels
+                                                                                      // if the image is larger than the feature model (i.e
+                                                                                      // a real image instead of a training image) pos determines
+                                                                                      // the top left corner of the feature.
+
+protected:
+    QList<int> definition; // The definition of the feature (usually these are coords)
+};
+
+class FeatureEvaluator
+{
+public:
+    FeatureEvaluator(int num_features_) : num_features(num_features_) {}
+    int get_num_features() const { return num_features; }
+    QList<Feature> get_features() const { return features; }
+
+    virtual void generateRandomFeatures(int height, int width, int channels) = 0; // initialize num_features random features within these dimensions.
+                                                                                  // will call Feature->randomize()
+    virtual QList<float> evaluate(const QList<cv::Mat> &img, cv::Size pos) const = 0; // return the response of all features on the given image
+                                                                                      // will call Feature->evaluate()
+
+private:
+    int num_features;
+    QList<Feature> features;
+};
+
+}
+
+#endif // FEATURE_H
+#include "trainingdata.h"
+
+TrainingData::TrainingData()
+{
+}
+#ifndef TRAININGDATA_H
+#define TRAININGDATA_H
+
+#include "feature.h"
+#include <openbr/openbr_plugin.h>
+
+namespace br
+{
+
+struct FeatureResponse // Feature vectors need to be sorted to do boosting. This keeps the weights and labels properly associated with the response without headaches.
+{
+    FeatureResponse(float response, int label, float weight) : response(response), label(label), weight(weight) {}
+
+    float response;
+    int label;
+    float weight;
+};
+
+typedef QList<FeatureResponse> FeatureVector;
+
+class TrainingData
+{
+public:
+    TrainingData();
+    // This can have getters and setters to make manipulating feature vectors easier
+
+private:
+    QList<FeatureVector> data;
+    QList<bool> visited_features;
+};
+
+}
+#endif // TRAININGDATA_H