1
0
mirror of https://github.com/opencv/opencv_contrib.git synced 2025-10-19 02:16:34 +08:00

Change of interface and multiple fixes

This commit is contained in:
Vlad Shakhuro
2015-08-03 17:14:28 +03:00
parent 3f1cce24ba
commit d06d7e2918
27 changed files with 917 additions and 2460 deletions

View File

@@ -49,204 +49,28 @@ the use of this software, even if advised of the possibility of such damage.
/** @defgroup xobjdetect Extended object detection
*/
namespace cv
{
namespace xobjdetect
{
//! @addtogroup xobjdetect
//! @{
/** @brief Compute channels for integral channel features evaluation
@param image image for which channels should be computed
@param channels output array for computed channels
*/
CV_EXPORTS void computeChannels(InputArray image, std::vector<Mat>& channels);
/** @brief Feature evaluation interface
*/
class CV_EXPORTS FeatureEvaluator : public Algorithm
{
class CV_EXPORTS WBDetector {
public:
/** @brief Set channels for feature evaluation
WBDetector(const std::string& model_filename);
@param channels array of channels to be set
*/
virtual void setChannels(InputArrayOfArrays channels) = 0;
void train(
const std::string& pos_samples,
const std::string& neg_imgs);
/** @brief Set window position to sample features with shift. By default position is (0, 0).
@param position position to be set
*/
virtual void setPosition(Size position) = 0;
/** @brief Evaluate feature value with given index for current channels and window position.
@param feature_ind index of feature to be evaluated
*/
virtual int evaluate(size_t feature_ind) const = 0;
/** @brief Evaluate all features for current channels and window position.
@param feature_values matrix-column of evaluated feature values
*/
virtual void evaluateAll(OutputArray feature_values) const = 0;
virtual void assertChannels() = 0;
};
/** @brief Construct feature evaluator.
@param features features for evaluation
@param type feature type. Can be "icf" or "acf"
*/
CV_EXPORTS Ptr<FeatureEvaluator>
createFeatureEvaluator(const std::vector<std::vector<int> >& features,
const std::string& type);
/** @brief Generate integral features. Returns vector of features.
@param window_size size of window in which features should be evaluated
@param type feature type. Can be "icf" or "acf"
@param count number of features to generate.
@param channel_count number of feature channels
*/
std::vector<std::vector<int> >
generateFeatures(Size window_size, const std::string& type,
int count = INT_MAX, int channel_count = 10);
//sort in-place of columns of the input matrix
void sort_columns_without_copy(Mat& m, Mat indices = Mat());
/** @brief Parameters for WaldBoost. weak_count — number of weak learners, alpha — cascade thresholding param.
*/
struct CV_EXPORTS WaldBoostParams
{
int weak_count;
float alpha;
WaldBoostParams(): weak_count(100), alpha(0.02f)
{}
};
/** @brief WaldBoost object detector from @cite Sochman05 .
*/
class CV_EXPORTS WaldBoost : public Algorithm
{
public:
/** @brief Train WaldBoost cascade for given data.
Returns feature indices chosen for cascade. Feature enumeration starts from 0.
@param data matrix of feature values, size M x N, one feature per row
@param labels matrix of samples class labels, size 1 x N. Labels can be from {-1, +1}
@param use_fast_log
*/
virtual std::vector<int> train(Mat& data,
const Mat& labels, bool use_fast_log=false) = 0;
/** @brief Predict objects class given object that can compute object features.
Returns unnormed confidence value — measure of confidence that object is from class +1.
@param feature_evaluator object that can compute features by demand
*/
virtual float predict(
const Ptr<FeatureEvaluator>& feature_evaluator) const = 0;
};
/** @brief Construct WaldBoost object.
*/
CV_EXPORTS Ptr<WaldBoost>
createWaldBoost(const WaldBoostParams& params = WaldBoostParams());
/** @brief Params for ICFDetector training.
*/
struct CV_EXPORTS ICFDetectorParams
{
int feature_count;
int weak_count;
int model_n_rows;
int model_n_cols;
int bg_per_image;
std::string features_type;
float alpha;
bool is_grayscale;
bool use_fast_log;
ICFDetectorParams(): feature_count(UINT_MAX), weak_count(100),
model_n_rows(56), model_n_cols(56), bg_per_image(5), alpha(0.02f), is_grayscale(false), use_fast_log(false)
{}
};
/** @brief Integral Channel Features from @cite Dollar09 .
*/
class CV_EXPORTS ICFDetector
{
public:
ICFDetector(): waldboost_(), features_(), ftype_() {}
/** @brief Train detector.
@param pos_filenames path to folder with images of objects (wildcards like /my/path/\*.png are allowed)
@param bg_filenames path to folder with background images
@param params parameters for detector training
*/
void train(const std::vector<String>& pos_filenames,
const std::vector<String>& bg_filenames,
ICFDetectorParams params = ICFDetectorParams());
/** @brief Detect objects on image.
@param image image for detection
@param objects output array of bounding boxes
@param scaleFactor scale between layers in detection pyramid
@param minSize min size of objects in pixels
@param maxSize max size of objects in pixels
@param threshold
@param slidingStep sliding window step
@param values output vector with values of positive samples
*/
void detect(const Mat& image, std::vector<Rect>& objects,
float scaleFactor, Size minSize, Size maxSize, float threshold, int slidingStep, std::vector<float>& values);
/** @brief Detect objects on image.
@param img image for detection
@param objects output array of bounding boxes
@param minScaleFactor min factor by which the image will be resized
@param maxScaleFactor max factor by which the image will be resized
@param factorStep scaling factor is incremented each pyramid layer according to this parameter
@param threshold
@param slidingStep sliding window step
@param values output vector with values of positive samples
*/
void detect(const Mat& img, std::vector<Rect>& objects, float minScaleFactor, float maxScaleFactor, float factorStep, float threshold, int slidingStep, std::vector<float>& values);
/** @brief Write detector to FileStorage.
@param fs FileStorage for output
*/
void write(FileStorage &fs) const;
/** @brief Write ICFDetector to FileNode
@param node FileNode for reading
*/
void read(const FileNode &node);
void detect(
const Mat& img,
std::vector<Rect> &bboxes,
std::vector<double> &confidences);
private:
Ptr<WaldBoost> waldboost_;
std::vector<std::vector<int> > features_;
int model_n_rows_;
int model_n_cols_;
std::string ftype_;
std::string model_filename_;
};
CV_EXPORTS void write(FileStorage& fs, String&, const ICFDetector& detector);
CV_EXPORTS void read(const FileNode& node, ICFDetector& d,
const ICFDetector& default_value = ICFDetector());
//! @}
} /* namespace xobjdetect */
} /* namespace cv */