#ifndef __SFT_OCTAVE_HPP__
#define __SFT_OCTAVE_HPP__
-#include <opencv2/ml/ml.hpp>
#include <sft/common.hpp>
#include <opencv2/imgproc/imgproc.hpp>
cv::Rect boundingBox = cfg.bbox(it);
std::cout << "Object bounding box" << boundingBox << std::endl;
- cv::Octave boost(boundingBox, npositives, nnegatives, *it, shrinkage);
+ cv::SoftCascadeOctave boost(boundingBox, npositives, nnegatives, *it, shrinkage);
std::string path = cfg.trainPath;
sft::ScaledDataset dataset(path, *it);
template<> CV_EXPORTS void Ptr<CvDTreeSplit>::delete_obj();
CV_EXPORTS bool initModule_ml(void);
-
-class CV_EXPORTS FeaturePool
-{
-public:
-
- virtual int size() const = 0;
- virtual float apply(int fi, int si, const Mat& integrals) const = 0;
- virtual void write( cv::FileStorage& fs, int index) const = 0;
-
- virtual void preprocess(InputArray frame, OutputArray integrals) const = 0;
-
- virtual ~FeaturePool();
-};
-
-class CV_EXPORTS Dataset
-{
-public:
- typedef enum {POSITIVE = 1, NEGATIVE = 2} SampleType;
-
- virtual cv::Mat get(SampleType type, int idx) const = 0;
- virtual int available(SampleType type) const = 0;
- virtual ~Dataset();
-};
-
-// used for traning single octave scale
-class CV_EXPORTS Octave : public cv::Boost
-{
-public:
-
- enum
- {
- // Direct backward pruning. (Cha Zhang and Paul Viola)
- DBP = 1,
- // Multiple instance pruning. (Cha Zhang and Paul Viola)
- MIP = 2,
- // Originally proposed by L. bourdev and J. brandt
- HEURISTIC = 4
- };
-
- Octave(cv::Rect boundingBox, int npositives, int nnegatives, int logScale, int shrinkage);
- virtual bool train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth);
- virtual void setRejectThresholds(OutputArray thresholds);
- virtual void write( CvFileStorage* fs, string name) const;
- virtual void write( cv::FileStorage &fs, const FeaturePool* pool, InputArray thresholds) const;
- virtual float predict( InputArray _sample, InputArray _votes, bool raw_mode, bool return_sum ) const;
- virtual ~Octave();
-protected:
- virtual bool train( const cv::Mat& trainData, const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
- const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& missingDataMask=cv::Mat());
-
- void processPositives(const Dataset* dataset, const FeaturePool* pool);
- void generateNegatives(const Dataset* dataset, const FeaturePool* pool);
-
- float predict( const Mat& _sample, const cv::Range range) const;
-private:
- void traverse(const CvBoostTree* tree, cv::FileStorage& fs, int& nfeatures, int* used, const double* th) const;
- virtual void initial_weights(double (&p)[2]);
-
- int logScale;
- cv::Rect boundingBox;
-
- int npositives;
- int nnegatives;
-
- int shrinkage;
-
- Mat integrals;
- Mat responses;
-
- CvBoostParams params;
-
- Mat trainData;
-};
-
}
#endif // __cplusplus
#define __OPENCV_SOFTCASCADE_HPP__
#include "opencv2/core/core.hpp"
+#include "opencv2/ml/ml.hpp"
namespace cv {
int shrinkage;
};
+class CV_EXPORTS FeaturePool
+{
+public:
+
+ virtual int size() const = 0;
+ virtual float apply(int fi, int si, const Mat& integrals) const = 0;
+ virtual void write( cv::FileStorage& fs, int index) const = 0;
+
+ virtual void preprocess(InputArray frame, OutputArray integrals) const = 0;
+
+ virtual ~FeaturePool();
+};
+
+class CV_EXPORTS Dataset
+{
+public:
+ typedef enum {POSITIVE = 1, NEGATIVE = 2} SampleType;
+
+ virtual cv::Mat get(SampleType type, int idx) const = 0;
+ virtual int available(SampleType type) const = 0;
+ virtual ~Dataset();
+};
+
// ========================================================================== //
// Implementation of soft (stageless) cascaded detector.
// ========================================================================== //
int rejCriteria;
};
+// ========================================================================== //
+// Implementation of singe soft (stageless) cascade octave training.
+// ========================================================================== //
+class CV_EXPORTS SoftCascadeOctave : public cv::Boost
+{
+public:
+
+ enum
+ {
+ // Direct backward pruning. (Cha Zhang and Paul Viola)
+ DBP = 1,
+ // Multiple instance pruning. (Cha Zhang and Paul Viola)
+ MIP = 2,
+ // Originally proposed by L. Bourdev and J. Brandt
+ HEURISTIC = 4
+ };
+
+ SoftCascadeOctave(cv::Rect boundingBox, int npositives, int nnegatives, int logScale, int shrinkage);
+ virtual bool train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth);
+ virtual void setRejectThresholds(OutputArray thresholds);
+ virtual void write( CvFileStorage* fs, string name) const;
+ virtual void write( cv::FileStorage &fs, const FeaturePool* pool, InputArray thresholds) const;
+ virtual float predict( InputArray _sample, InputArray _votes, bool raw_mode, bool return_sum ) const;
+ virtual ~SoftCascadeOctave();
+protected:
+ virtual bool train( const cv::Mat& trainData, const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
+ const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& missingDataMask=cv::Mat());
+
+ void processPositives(const Dataset* dataset, const FeaturePool* pool);
+ void generateNegatives(const Dataset* dataset, const FeaturePool* pool);
+
+ float predict( const Mat& _sample, const cv::Range range) const;
+private:
+ void traverse(const CvBoostTree* tree, cv::FileStorage& fs, int& nfeatures, int* used, const double* th) const;
+ virtual void initial_weights(double (&p)[2]);
+
+ int logScale;
+ cv::Rect boundingBox;
+
+ int npositives;
+ int nnegatives;
+
+ int shrinkage;
+
+ Mat integrals;
+ Mat responses;
+
+ CvBoostParams params;
+
+ Mat trainData;
+};
+
CV_EXPORTS bool initModule_softcascade(void);
}
cv::FeaturePool::~FeaturePool(){}
cv::Dataset::~Dataset(){}
-cv::Octave::Octave(cv::Rect bb, int np, int nn, int ls, int shr)
+cv::SoftCascadeOctave::SoftCascadeOctave(cv::Rect bb, int np, int nn, int ls, int shr)
: logScale(ls), boundingBox(bb), npositives(np), nnegatives(nn), shrinkage(shr)
{
int maxSample = npositives + nnegatives;
params = _params;
}
-cv::Octave::~Octave(){}
+cv::SoftCascadeOctave::~SoftCascadeOctave(){}
-bool cv::Octave::train( const cv::Mat& _trainData, const cv::Mat& _responses, const cv::Mat& varIdx,
+bool cv::SoftCascadeOctave::train( const cv::Mat& _trainData, const cv::Mat& _responses, const cv::Mat& varIdx,
const cv::Mat& sampleIdx, const cv::Mat& varType, const cv::Mat& missingDataMask)
{
bool update = false;
update);
}
-void cv::Octave::setRejectThresholds(cv::OutputArray _thresholds)
+void cv::SoftCascadeOctave::setRejectThresholds(cv::OutputArray _thresholds)
{
dprintf("set thresholds according to DBP strategy\n");
}
}
-void cv::Octave::processPositives(const Dataset* dataset, const FeaturePool* pool)
+void cv::SoftCascadeOctave::processPositives(const Dataset* dataset, const FeaturePool* pool)
{
int w = boundingBox.width;
int h = boundingBox.height;
#undef USE_LONG_SEEDS
-void cv::Octave::generateNegatives(const Dataset* dataset, const FeaturePool* pool)
+void cv::SoftCascadeOctave::generateNegatives(const Dataset* dataset, const FeaturePool* pool)
{
// ToDo: set seed, use offsets
sft::Random::engine eng(DX_DY_SEED);
return (T(0) < val) - (val < T(0));
}
-void cv::Octave::traverse(const CvBoostTree* tree, cv::FileStorage& fs, int& nfeatures, int* used, const double* th) const
+void cv::SoftCascadeOctave::traverse(const CvBoostTree* tree, cv::FileStorage& fs, int& nfeatures, int* used, const double* th) const
{
std::queue<const CvDTreeNode*> nodes;
nodes.push( tree->get_root());
fs << "}";
}
-void cv::Octave::write( cv::FileStorage &fso, const FeaturePool* pool, InputArray _thresholds) const
+void cv::SoftCascadeOctave::write( cv::FileStorage &fso, const FeaturePool* pool, InputArray _thresholds) const
{
CV_Assert(!_thresholds.empty());
cv::Mat used( 1, weak->total * ( (int)pow(2.f, params.max_depth) - 1), CV_32SC1);
<< "}";
}
-void cv::Octave::initial_weights(double (&p)[2])
+void cv::SoftCascadeOctave::initial_weights(double (&p)[2])
{
double n = data->sample_count;
p[0] = n / (2. * (double)(nnegatives));
p[1] = n / (2. * (double)(npositives));
}
-bool cv::Octave::train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth)
+bool cv::SoftCascadeOctave::train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth)
{
CV_Assert(treeDepth == 2);
CV_Assert(weaks > 0);
}
-float cv::Octave::predict( cv::InputArray _sample, cv::InputArray _votes, bool raw_mode, bool return_sum ) const
+float cv::SoftCascadeOctave::predict( cv::InputArray _sample, cv::InputArray _votes, bool raw_mode, bool return_sum ) const
{
cv::Mat sample = _sample.getMat();
CvMat csample = sample;
}
}
-float cv::Octave::predict( const Mat& _sample, const cv::Range range) const
+float cv::SoftCascadeOctave::predict( const Mat& _sample, const cv::Range range) const
{
CvMat sample = _sample;
return CvBoost::predict(&sample, 0, 0, range, false, true);
}
-void cv::Octave::write( CvFileStorage* fs, string name) const
+void cv::SoftCascadeOctave::write( CvFileStorage* fs, string name) const
{
CvBoost::write(fs, name.c_str());
}