Base class for computing feature values in cascade classifiers.
class CV_EXPORTS FeatureEvaluator
{
public:
enum { HAAR = 0, LBP = 1 }; // supported feature types
virtual ~FeatureEvaluator(); // destructor
virtual bool read(const FileNode& node);
virtual Ptr<FeatureEvaluator> clone() const;
virtual int getFeatureType() const;
virtual bool setImage(const Mat& img, Size origWinSize);
virtual bool setWindow(Point p);
virtual double calcOrd(int featureIdx) const;
virtual int calcCat(int featureIdx) const;
static Ptr<FeatureEvaluator> create(int type);
};
Returns a full copy of the feature evaluator.
Returns the feature type (HAAR or LBP for now).
CascadeClassifier::runAt()
Sets window in the current image in which the features will be computed (called by ).
Parameters: |
|
---|
Computes value of an ordered (numerical) feature.
Parameters: |
|
---|
Returns computed value of ordered feature.
Computes value of a categorical feature.
Parameters: |
|
---|
Returns computed label of categorical feature, i.e. value from [0,... (number of categories - 1)].
Constructs feature evaluator.
Parameters: |
|
---|
The cascade classifier class for object detection.
class CascadeClassifier
{
public:
// structure for storing tree node
struct CV_EXPORTS DTreeNode
{
int featureIdx; // feature index on which is a split
float threshold; // split threshold of ordered features only
int left; // left child index in the tree nodes array
int right; // right child index in the tree nodes array
};
// structure for storing desision tree
struct CV_EXPORTS DTree
{
int nodeCount; // nodes count
};
// structure for storing cascade stage (BOOST only for now)
struct CV_EXPORTS Stage
{
int first; // first tree index in tree array
int ntrees; // number of trees
float threshold; // treshold of stage sum
};
enum { BOOST = 0 }; // supported stage types
// mode of detection (see parameter flags in function HaarDetectObjects)
enum { DO_CANNY_PRUNING = CV_HAAR_DO_CANNY_PRUNING,
SCALE_IMAGE = CV_HAAR_SCALE_IMAGE,
FIND_BIGGEST_OBJECT = CV_HAAR_FIND_BIGGEST_OBJECT,
DO_ROUGH_SEARCH = CV_HAAR_DO_ROUGH_SEARCH };
CascadeClassifier(); // default constructor
CascadeClassifier(const string& filename);
~CascadeClassifier(); // destructor
bool empty() const;
bool load(const string& filename);
bool read(const FileNode& node);
void detectMultiScale( const Mat& image, vector<Rect>& objects,
double scaleFactor=1.1, int minNeighbors=3,
int flags=0, Size minSize=Size());
bool setImage( Ptr<FeatureEvaluator>&, const Mat& );
int runAt( Ptr<FeatureEvaluator>&, Point );
bool is_stump_based; // true, if the trees are stumps
int stageType; // stage type (BOOST only for now)
int featureType; // feature type (HAAR or LBP for now)
int ncategories; // number of categories (for categorical features only)
Size origWinSize; // size of training images
vector<Stage> stages; // vector of stages (BOOST for now)
vector<DTree> classifiers; // vector of decision trees
vector<DTreeNode> nodes; // vector of tree nodes
vector<float> leaves; // vector of leaf values
vector<int> subsets; // subsets of split by categorical feature
Ptr<FeatureEvaluator> feval; // pointer to feature evaluator
Ptr<CvHaarClassifierCascade> oldCascade; // pointer to old cascade
};
Loads the classifier from file.
Parameters: |
|
---|
Checks if the classifier has been loaded or not.
Loads the classifier from file. The previous content is destroyed.
Parameters: |
|
---|
Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.
Parameters: |
|
---|
Sets the image for detection (called by detectMultiScale at each image level).
Parameters: |
|
---|
Runs the detector at the specified point (the image that the detector is working with should be set by setImage).
Parameters: |
|
---|
Returns: 1 - if cascade classifier detects object in the given location. -si - otherwise. si is an index of stage which first predicted that given window is a background image.
Groups the object candidate rectangles
Parameters: |
|
---|
The function is a wrapper for a generic function partition() . It clusters all the input rectangles using the rectangle equivalence criteria, that combines rectangles that have similar sizes and similar locations (the similarity is defined by eps ). When eps=0 , no clustering is done at all. If , all the rectangles will be put in one cluster. Then, the small clusters, containing less than or equal to groupThreshold rectangles, will be rejected. In each other cluster the average rectangle will be computed and put into the output rectangle list.