Waldboost with LBP

modules/xobjdetect/src/cascadeclassifier.h

+#ifndef _OPENCV_CASCADECLASSIFIER_H_
+#define _OPENCV_CASCADECLASSIFIER_H_
+
+#include <ctime>
+#include "traincascade_features.h"
+#include "lbpfeatures.h"
+
+#define CC_CASCADE_FILENAME "cascade.xml"
+#define CC_PARAMS_FILENAME "params.xml"
+
+#define CC_CASCADE_PARAMS "cascadeParams"
+#define CC_STAGE_TYPE "stageType"
+#define CC_FEATURE_TYPE "featureType"
+#define CC_HEIGHT "height"
+#define CC_WIDTH  "width"
+
+#define CC_STAGE_NUM    "stageNum"
+#define CC_STAGES       "stages"
+#define CC_STAGE_PARAMS "stageParams"
+
+#define CC_BOOST            "BOOST"
+#define CC_BOOST_TYPE       "boostType"
+#define CC_DISCRETE_BOOST   "DAB"
+#define CC_REAL_BOOST       "RAB"
+#define CC_LOGIT_BOOST      "LB"
+#define CC_GENTLE_BOOST     "GAB"
+#define CC_MINHITRATE       "minHitRate"
+#define CC_MAXFALSEALARM    "maxFalseAlarm"
+#define CC_TRIM_RATE        "weightTrimRate"
+#define CC_MAX_DEPTH        "maxDepth"
+#define CC_WEAK_COUNT       "maxWeakCount"
+#define CC_STAGE_THRESHOLD  "stageThreshold"
+#define CC_WEAK_CLASSIFIERS "weakClassifiers"
+#define CC_INTERNAL_NODES   "internalNodes"
+#define CC_LEAF_VALUES      "leafValues"
+
+#define CC_FEATURES       FEATURES
+#define CC_FEATURE_PARAMS "featureParams"
+#define CC_MAX_CAT_COUNT  "maxCatCount"
+#define CC_FEATURE_SIZE   "featSize"
+
+#define CC_HAAR        "HAAR"
+#define CC_MODE        "mode"
+#define CC_MODE_BASIC  "BASIC"
+#define CC_MODE_CORE   "CORE"
+#define CC_MODE_ALL    "ALL"
+#define CC_RECTS       "rects"
+#define CC_TILTED      "tilted"
+
+#define CC_LBP  "LBP"
+#define CC_RECT "rect"
+
+#endif

modules/xobjdetect/src/features.cpp

+#include <opencv2/opencv.hpp>
+
+#include "traincascade_features.h"
+#include "cascadeclassifier.h"
+
+using namespace std;
+using namespace cv;
+
+float calcNormFactor( const Mat& sum, const Mat& sqSum )
+{
+    CV_DbgAssert( sum.cols > 3 && sqSum.rows > 3 );
+    Rect normrect( 1, 1, sum.cols - 3, sum.rows - 3 );
+    size_t p0, p1, p2, p3;
+    CV_SUM_OFFSETS( p0, p1, p2, p3, normrect, sum.step1() )
+    double area = normrect.width * normrect.height;
+    const int *sp = sum.ptr<int>();
+    int valSum = sp[p0] - sp[p1] - sp[p2] + sp[p3];
+    const double *sqp = sqSum.ptr<double>();
+    double valSqSum = sqp[p0] - sqp[p1] - sqp[p2] + sqp[p3];
+    return (float) sqrt( (double) (area * valSqSum - (double)valSum * valSum) );
+}
+
+CvParams::CvParams() : name( "params" ) {}
+void CvParams::printDefaults() const
+{ cout << "--" << name << "--" << endl; }
+void CvParams::printAttrs() const {}
+bool CvParams::scanAttr( const string, const string ) { return false; }
+
+
+//---------------------------- FeatureParams --------------------------------------
+
+CvFeatureParams::CvFeatureParams() : maxCatCount( 0 ), featSize( 1 )
+{
+    name = CC_FEATURE_PARAMS;
+}
+
+void CvFeatureParams::init( const CvFeatureParams& fp )
+{
+    maxCatCount = fp.maxCatCount;
+    featSize = fp.featSize;
+}
+
+void CvFeatureParams::write( FileStorage &fs ) const
+{
+    fs << CC_MAX_CAT_COUNT << maxCatCount;
+    fs << CC_FEATURE_SIZE << featSize;
+}
+
+bool CvFeatureParams::read( const FileNode &node )
+{
+    if ( node.empty() )
+        return false;
+    maxCatCount = node[CC_MAX_CAT_COUNT];
+    featSize = node[CC_FEATURE_SIZE];
+    return ( maxCatCount >= 0 && featSize >= 1 );
+}
+
+Ptr<CvFeatureParams> CvFeatureParams::create( int featureType )
+{
+    return Ptr<CvFeatureParams>(new CvLBPFeatureParams);
+}
+
+//------------------------------------- FeatureEvaluator ---------------------------------------
+
+void CvFeatureEvaluator::init(const CvFeatureParams *_featureParams,
+                              int _maxSampleCount, Size _winSize )
+{
+    CV_Assert(_maxSampleCount > 0);
+    featureParams = (CvFeatureParams *)_featureParams;
+    winSize = _winSize;
+    numFeatures = 0;
+    cls.create( (int)_maxSampleCount, 1, CV_32FC1 );
+    generateFeatures();
+}
+
+void CvFeatureEvaluator::setImage(const Mat &img, uchar clsLabel, int idx, const std::vector<int>& feature_ind)
+{
+    //CV_Assert(img.cols == winSize.width);
+    //CV_Assert(img.rows == winSize.height);
+    CV_Assert(idx < cls.rows);
+    cls.ptr<float>(idx)[0] = clsLabel;
+}
+
+Ptr<CvFeatureEvaluator> CvFeatureEvaluator::create(int type)
+{
+    return Ptr<CvFeatureEvaluator>(new CvLBPEvaluator);
+}

modules/xobjdetect/src/lbpfeatures.cpp

+#include <opencv2/opencv.hpp>
+
+#include "lbpfeatures.h"
+#include "cascadeclassifier.h"
+
+#include <iostream>
+
+using namespace cv;
+
+CvLBPFeatureParams::CvLBPFeatureParams()
+{
+    maxCatCount = 256;
+    name = LBPF_NAME;
+}
+
+void CvLBPEvaluator::init(const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize)
+{
+    CV_Assert( _maxSampleCount > 0);
+    sum.create((int)_maxSampleCount, (_winSize.width + 1) * (_winSize.height + 1), CV_32SC1);
+    CvFeatureEvaluator::init( _featureParams, _maxSampleCount, _winSize );
+}
+
+void CvLBPEvaluator::setImage(const Mat &img, uchar clsLabel, int idx,
+    const std::vector<int> &feature_ind)
+{
+    CV_DbgAssert( !sum.empty() );
+    CvFeatureEvaluator::setImage( img, clsLabel, idx, feature_ind );
+    integral( img, sum );
+    cur_sum = sum;
+    offset_ = int(sum.ptr<int>(1) - sum.ptr<int>());
+    for (size_t i = 0; i < feature_ind.size(); ++i) {
+        features[feature_ind[i]].calcPoints(offset_);
+    }
+}
+
+void CvLBPEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
+{
+    _writeFeatures( features, fs, featureMap );
+}
+
+void CvLBPEvaluator::generateFeatures()
+{
+    int offset = winSize.width + 1;
+    for( int x = 0; x < winSize.width; x++ )
+        for( int y = 0; y < winSize.height; y++ )
+            for( int w = 1; w <= winSize.width / 3; w++ )
+                for( int h = 1; h <= winSize.height / 3; h++ )
+                    if ( (x+3*w <= winSize.width) && (y+3*h <= winSize.height) )
+                        features.push_back( Feature(offset, x, y, w, h ) );
+    numFeatures = (int)features.size();
+}
+
+CvLBPEvaluator::Feature::Feature()
+{
+    rect = cvRect(0, 0, 0, 0);
+}
+
+CvLBPEvaluator::Feature::Feature( int offset, int x, int y, int _blockWidth, int _blockHeight )
+{
+    x_ = x;
+    y_ = y;
+    block_w_ = _blockWidth;
+    block_h_ = _blockHeight;
+    offset_ = offset;
+    calcPoints(offset);
+}
+
+void CvLBPEvaluator::Feature::calcPoints(int offset)
+{
+    Rect tr = rect = cvRect(x_, y_, block_w_, block_h_);
+    CV_SUM_OFFSETS( p[0], p[1], p[4], p[5], tr, offset )
+    tr.x += 2*rect.width;
+    CV_SUM_OFFSETS( p[2], p[3], p[6], p[7], tr, offset )
+    tr.y +=2*rect.height;
+    CV_SUM_OFFSETS( p[10], p[11], p[14], p[15], tr, offset )
+    tr.x -= 2*rect.width;
+    CV_SUM_OFFSETS( p[8], p[9], p[12], p[13], tr, offset )
+    offset_ = offset;
+}
+
+void CvLBPEvaluator::Feature::write(FileStorage &fs) const
+{
+    fs << CC_RECT << "[:" << rect.x << rect.y << rect.width << rect.height << "]";
+}

modules/xobjdetect/src/lbpfeatures.h

+#ifndef _OPENCV_LBPFEATURES_H_
+#define _OPENCV_LBPFEATURES_H_
+
+#include "traincascade_features.h"
+
+
+#define LBPF_NAME "lbpFeatureParams"
+struct CvLBPFeatureParams : CvFeatureParams
+{
+    CvLBPFeatureParams();
+
+};
+
+class CvLBPEvaluator : public CvFeatureEvaluator
+{
+public:
+    virtual ~CvLBPEvaluator() {}
+    virtual void init(const CvFeatureParams *_featureParams,
+        int _maxSampleCount, cv::Size _winSize );
+    virtual void setImage(const cv::Mat& img, uchar clsLabel, int idx, const std::vector<int> &feature_ind);
+    virtual void setWindow(const cv::Point& p)
+    { cur_sum = sum.rowRange(p.y, p.y + winSize.height).colRange(p.x, p.x + winSize.width); }
+    virtual float operator()(int featureIdx, int sampleIdx)
+    { return (float)features[featureIdx].calc( cur_sum, offset_, sampleIdx); }
+    virtual void writeFeatures( cv::FileStorage &fs, const cv::Mat& featureMap ) const;
+protected:
+    virtual void generateFeatures();
+
+    class Feature
+    {
+    public:
+        Feature();
+        Feature( int offset, int x, int y, int _block_w, int _block_h  );
+        uchar calc( const cv::Mat& _sum, int offset, size_t y );
+        void write( cv::FileStorage &fs ) const;
+
+        cv::Rect rect;
+        int p[16];
+
+        int x_, y_, block_w_, block_h_, offset_;
+        void calcPoints(int offset);
+    };
+    std::vector<Feature> features;
+
+    cv::Mat sum, cur_sum;
+    int offset_;
+};
+
+inline uchar CvLBPEvaluator::Feature::calc(const cv::Mat &_sum, int offset, size_t y)
+{
+    const int* psum = _sum.ptr<int>();
+
+    int cval = psum[p[5]] - psum[p[6]] - psum[p[9]] + psum[p[10]];
+
+    return (uchar)((psum[p[0]] - psum[p[1]] - psum[p[4]] + psum[p[5]] >= cval ? 128 : 0) |   // 0
+        (psum[p[1]] - psum[p[2]] - psum[p[5]] + psum[p[6]] >= cval ? 64 : 0) |    // 1
+        (psum[p[2]] - psum[p[3]] - psum[p[6]] + psum[p[7]] >= cval ? 32 : 0) |    // 2
+        (psum[p[6]] - psum[p[7]] - psum[p[10]] + psum[p[11]] >= cval ? 16 : 0) |  // 5
+        (psum[p[10]] - psum[p[11]] - psum[p[14]] + psum[p[15]] >= cval ? 8 : 0) | // 8
+        (psum[p[9]] - psum[p[10]] - psum[p[13]] + psum[p[14]] >= cval ? 4 : 0) |  // 7
+        (psum[p[8]] - psum[p[9]] - psum[p[12]] + psum[p[13]] >= cval ? 2 : 0) |   // 6
+        (psum[p[4]] - psum[p[5]] - psum[p[8]] + psum[p[9]] >= cval ? 1 : 0));     // 3
+}
+
+#endif

modules/xobjdetect/src/traincascade_features.h

+#ifndef _OPENCV_FEATURES_H_
+#define _OPENCV_FEATURES_H_
+
+#include <stdio.h>
+
+#define FEATURES "features"
+
+#define CV_SUM_OFFSETS( p0, p1, p2, p3, rect, step )                      \
+    /* (x, y) */                                                          \
+    (p0) = (rect).x + (step) * (rect).y;                                  \
+    /* (x + w, y) */                                                      \
+    (p1) = (rect).x + (rect).width + (step) * (rect).y;                   \
+    /* (x + w, y) */                                                      \
+    (p2) = (rect).x + (step) * ((rect).y + (rect).height);                \
+    /* (x + w, y + h) */                                                  \
+    (p3) = (rect).x + (rect).width + (step) * ((rect).y + (rect).height);
+
+#define CV_TILTED_OFFSETS( p0, p1, p2, p3, rect, step )                   \
+    /* (x, y) */                                                          \
+    (p0) = (rect).x + (step) * (rect).y;                                  \
+    /* (x - h, y + h) */                                                  \
+    (p1) = (rect).x - (rect).height + (step) * ((rect).y + (rect).height);\
+    /* (x + w, y + w) */                                                  \
+    (p2) = (rect).x + (rect).width + (step) * ((rect).y + (rect).width);  \
+    /* (x + w - h, y + w + h) */                                          \
+    (p3) = (rect).x + (rect).width - (rect).height                        \
+           + (step) * ((rect).y + (rect).width + (rect).height);
+
+float calcNormFactor( const cv::Mat& sum, const cv::Mat& sqSum );
+
+template<class Feature>
+void _writeFeatures( const std::vector<Feature> features, cv::FileStorage &fs, const cv::Mat& featureMap )
+{
+    fs << FEATURES << "[";
+    const cv::Mat_<int>& featureMap_ = (const cv::Mat_<int>&)featureMap;
+    for ( int fi = 0; fi < featureMap.cols; fi++ )
+        if ( featureMap_(0, fi) >= 0 )
+        {
+            fs << "{";
+            features[fi].write( fs );
+            fs << "}";
+        }
+    fs << "]";
+}
+
+class CvParams
+{
+public:
+    CvParams();
+    virtual ~CvParams() {}
+    // from|to file
+    virtual void write( cv::FileStorage &fs ) const = 0;
+    virtual bool read( const cv::FileNode &node ) = 0;
+    // from|to screen
+    virtual void printDefaults() const;
+    virtual void printAttrs() const;
+    virtual bool scanAttr( const std::string prmName, const std::string val );
+    std::string name;
+};
+
+class CvFeatureParams : public CvParams
+{
+public:
+    enum { HAAR = 0, LBP = 1, HOG = 2 };
+    CvFeatureParams();
+    virtual void init( const CvFeatureParams& fp );
+    virtual void write( cv::FileStorage &fs ) const;
+    virtual bool read( const cv::FileNode &node );
+    static cv::Ptr<CvFeatureParams> create( int featureType );
+    int maxCatCount; // 0 in case of numerical features
+    int featSize; // 1 in case of simple features (HAAR, LBP) and N_BINS(9)*N_CELLS(4) in case of Dalal's HOG features
+};
+
+class CvFeatureEvaluator
+{
+public:
+    virtual ~CvFeatureEvaluator() {}
+    virtual void init(const CvFeatureParams *_featureParams,
+                      int _maxSampleCount, cv::Size _winSize );
+    virtual void setImage(const cv::Mat& img, uchar clsLabel, int idx, const std::vector<int> &feature_ind);
+    virtual void setWindow(const cv::Point& p) = 0;
+    virtual void writeFeatures( cv::FileStorage &fs, const cv::Mat& featureMap ) const = 0;
+    virtual float operator()(int featureIdx, int sampleIdx) = 0;
+    static cv::Ptr<CvFeatureEvaluator> create(int type);
+
+    int getNumFeatures() const { return numFeatures; }
+    int getMaxCatCount() const { return featureParams->maxCatCount; }
+    int getFeatureSize() const { return featureParams->featSize; }
+    const cv::Mat& getCls() const { return cls; }
+    float getCls(int si) const { return cls.at<float>(si, 0); }
+protected:
+    virtual void generateFeatures() = 0;
+
+    int npos, nneg;
+    int numFeatures;
+    cv::Size winSize;
+    CvFeatureParams *featureParams;
+    cv::Mat cls;
+};
+
+#endif