ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
INSTALL_NAME_DIR lib
- OUTPUT_NAME ${the_target})
+ OUTPUT_NAME "opencv_trainsoftcascade")
if(ENABLE_SOLUTION_FOLDERS)
set_target_properties(${the_target} PROPERTIES FOLDER "applications")
x.read(node);
}
+namespace {
+
struct Out
{
Out(std::ostream& _out): out(_out) {}
private:
Out& operator=(Out const& other);
};
+}
std::ostream& sft::operator<<(std::ostream& out, const Config& m)
{
#include <opencv2/core/core.hpp>
#include <opencv2/softcascade/softcascade.hpp>
-namespace cv {using namespace scascade;}
+namespace cv {using namespace softcascade;}
namespace sft
{
namespace sft
{
-using cv::Dataset;
+using cv::softcascade::Dataset;
class ScaledDataset : public Dataset
{
string configPath = parser.get<string>("config");
if (configPath.empty())
{
- std::cout << "Configuration file is missing or empty. Could not start training." << std::endl << std::flush;
+ std::cout << "Configuration file is missing or empty. Could not start training." << std::endl;
return 0;
}
cv::FileStorage fs(configPath, cv::FileStorage::READ);
if(!fs.isOpened())
{
- std::cout << "Configuration file " << configPath << " can't be opened." << std::endl << std::flush;
+ std::cout << "Configuration file " << configPath << " can't be opened." << std::endl;
return 1;
}
cv::FileStorage fso(cfg.outXmlPath, cv::FileStorage::WRITE);
if(!fso.isOpened())
{
- std::cout << "Training stopped. Output classifier Xml file " << cfg.outXmlPath << " can't be opened." << std::endl << std::flush;
+ std::cout << "Training stopped. Output classifier Xml file " << cfg.outXmlPath << " can't be opened." << std::endl;
return 1;
}
cv::Rect boundingBox = cfg.bbox(it);
std::cout << "Object bounding box" << boundingBox << std::endl;
- typedef cv::SoftCascadeOctave Octave;
+ typedef cv::Octave Octave;
cv::Ptr<Octave> boost = Octave::create(boundingBox, npositives, nnegatives, *it, shrinkage, nfeatures);
}
using namespace cv;
-typedef cv::scascade::ChannelFeatureBuilder scascade_ChannelFeatureBuilder;
+typedef cv::softcascade::ChannelFeatureBuilder softcascade_ChannelFeatureBuilder;
typedef vector<uchar> vector_uchar;
typedef vector<int> vector_int;
typedef Ptr<Feature2D> Ptr_Feature2D;
typedef Ptr<DescriptorMatcher> Ptr_DescriptorMatcher;
-typedef Ptr<cv::scascade::ChannelFeatureBuilder> Ptr_ChannelFeatureBuilder;
+typedef Ptr<cv::softcascade::ChannelFeatureBuilder> Ptr_ChannelFeatureBuilder;
typedef SimpleBlobDetector::Params SimpleBlobDetector_Params;
.. [BMTG12] Rodrigo Benenson, Markus Mathias, Radu Timofte and Luc Van Gool. Pedestrian detection at 100 frames per second. IEEE CVPR, 2012.
-SoftCascadeDetector
+Detector
-------------------
-.. ocv:class:: SoftCascadeDetector
+.. ocv:class:: Detector
Implementation of soft (stageless) cascaded detector. ::
- class CV_EXPORTS_W SoftCascadeDetector : public Algorithm
+ class CV_EXPORTS_W Detector : public Algorithm
{
public:
enum { NO_REJECT = 1, DOLLAR = 2, /*PASCAL = 4,*/ DEFAULT = NO_REJECT};
- CV_WRAP SoftCascadeDetector(double minScale = 0.4, double maxScale = 5., int scales = 55, int rejCriteria = 1);
- CV_WRAP virtual ~SoftCascadeDetector();
+ CV_WRAP Detector(double minScale = 0.4, double maxScale = 5., int scales = 55, int rejCriteria = 1);
+ CV_WRAP virtual ~Detector();
cv::AlgorithmInfo* info() const;
CV_WRAP virtual bool load(const FileNode& fileNode);
CV_WRAP virtual void read(const FileNode& fileNode);
-SoftCascadeDetector::SoftCascadeDetector
+Detector::Detector
----------------------------------------
An empty cascade will be created.
-.. ocv:function:: SoftCascadeDetector::SoftCascadeDetector(float minScale = 0.4f, float maxScale = 5.f, int scales = 55, int rejCriteria = 1)
+.. ocv:function:: Detector::Detector(float minScale = 0.4f, float maxScale = 5.f, int scales = 55, int rejCriteria = 1)
-.. ocv:pyfunction:: cv2.SoftCascadeDetector.SoftCascadeDetector(minScale[, maxScale[, scales[, rejCriteria]]]) -> cascade
+.. ocv:pyfunction:: cv2.Detector.Detector(minScale[, maxScale[, scales[, rejCriteria]]]) -> cascade
:param minScale: a minimum scale relative to the original size of the image on which cascade will be applied.
-SoftCascadeDetector::~SoftCascadeDetector
+Detector::~Detector
-----------------------------------------
-Destructor for SoftCascadeDetector.
+Destructor for Detector.
-.. ocv:function:: SoftCascadeDetector::~SoftCascadeDetector()
+.. ocv:function:: Detector::~Detector()
-SoftCascadeDetector::load
+Detector::load
--------------------------
Load cascade from FileNode.
-.. ocv:function:: bool SoftCascadeDetector::load(const FileNode& fileNode)
+.. ocv:function:: bool Detector::load(const FileNode& fileNode)
-.. ocv:pyfunction:: cv2.SoftCascadeDetector.load(fileNode)
+.. ocv:pyfunction:: cv2.Detector.load(fileNode)
:param fileNode: File node from which the soft cascade are read.
-SoftCascadeDetector::detect
+Detector::detect
---------------------------
Apply cascade to an input frame and return the vector of Detection objects.
-.. ocv:function:: void SoftCascadeDetector::detect(InputArray image, InputArray rois, std::vector<Detection>& objects) const
+.. ocv:function:: void Detector::detect(InputArray image, InputArray rois, std::vector<Detection>& objects) const
-.. ocv:function:: void SoftCascadeDetector::detect(InputArray image, InputArray rois, OutputArray rects, OutputArray confs) const
+.. ocv:function:: void Detector::detect(InputArray image, InputArray rois, OutputArray rects, OutputArray confs) const
-.. ocv:pyfunction:: cv2.SoftCascadeDetector.detect(image, rois) -> (rects, confs)
+.. ocv:pyfunction:: cv2.Detector.detect(image, rois) -> (rects, confs)
:param image: a frame on which detector will be applied.
--------------------------------------------
-SoftCascadeOctave
+Octave
-----------------
-.. ocv:class:: SoftCascadeOctave
+.. ocv:class:: Octave
Public interface for soft cascade training algorithm. ::
- class CV_EXPORTS SoftCascadeOctave : public Algorithm
+ class CV_EXPORTS Octave : public Algorithm
{
public:
// Originally proposed by L. Bourdev and J. Brandt
HEURISTIC = 4 };
- virtual ~SoftCascadeOctave();
- static cv::Ptr<SoftCascadeOctave> create(cv::Rect boundingBox, int npositives, int nnegatives, int logScale, int shrinkage);
+ virtual ~Octave();
+ static cv::Ptr<Octave> create(cv::Rect boundingBox, int npositives, int nnegatives, int logScale, int shrinkage);
virtual bool train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth) = 0;
virtual void setRejectThresholds(OutputArray thresholds) = 0;
-SoftCascadeOctave::~SoftCascadeOctave
+Octave::~Octave
---------------------------------------
-Destructor for SoftCascadeOctave.
+Destructor for Octave.
-.. ocv:function:: SoftCascadeOctave::~SoftCascadeOctave()
+.. ocv:function:: Octave::~Octave()
-SoftCascadeOctave::train
+Octave::train
------------------------
-.. ocv:function:: bool SoftCascadeOctave::train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth)
+.. ocv:function:: bool Octave::train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth)
:param dataset an object that allows communicate for training set.
-SoftCascadeOctave::setRejectThresholds
+Octave::setRejectThresholds
--------------------------------------
-.. ocv:function:: void SoftCascadeOctave::setRejectThresholds(OutputArray thresholds)
+.. ocv:function:: void Octave::setRejectThresholds(OutputArray thresholds)
:param thresholds an output array of resulted rejection vector. Have same size as number of trained stages.
-SoftCascadeOctave::write
+Octave::write
------------------------
-.. ocv:function:: void SoftCascadeOctave::train(cv::FileStorage &fs, const FeaturePool* pool, InputArray thresholds) const
-.. ocv:function:: void SoftCascadeOctave::train( CvFileStorage* fs, string name) const
+.. ocv:function:: void Octave::train(cv::FileStorage &fs, const FeaturePool* pool, InputArray thresholds) const
+.. ocv:function:: void Octave::train( CvFileStorage* fs, string name) const
:param fs an output file storage to store trained detector.
#include "opencv2/core/core.hpp"
-namespace cv { namespace scascade {
+namespace cv { namespace softcascade {
// Representation of detectors result.
struct CV_EXPORTS Detection
int kind;
};
-
-
class CV_EXPORTS Dataset
{
public:
// ========================================================================== //
// Implementation of soft (stageless) cascaded detector.
// ========================================================================== //
-class CV_EXPORTS_W SoftCascadeDetector : public cv::Algorithm
+class CV_EXPORTS_W Detector : public cv::Algorithm
{
public:
// Param minScale is a maximum scale relative to the original size of the image on which cascade will be applied.
// Param scales is a number of scales from minScale to maxScale.
// Param rejCriteria is used for NMS.
- CV_WRAP SoftCascadeDetector(double minScale = 0.4, double maxScale = 5., int scales = 55, int rejCriteria = 1);
+ CV_WRAP Detector(double minScale = 0.4, double maxScale = 5., int scales = 55, int rejCriteria = 1);
- CV_WRAP virtual ~SoftCascadeDetector();
+ CV_WRAP virtual ~Detector();
cv::AlgorithmInfo* info() const;
// ========================================================================== //
// Public Interface for singe soft (stageless) cascade octave training.
// ========================================================================== //
-class CV_EXPORTS SoftCascadeOctave : public cv::Algorithm
+class CV_EXPORTS Octave : public cv::Algorithm
{
public:
enum
HEURISTIC = 4
};
- virtual ~SoftCascadeOctave();
- static cv::Ptr<SoftCascadeOctave> create(cv::Rect boundingBox, int npositives, int nnegatives,
+ virtual ~Octave();
+ static cv::Ptr<Octave> create(cv::Rect boundingBox, int npositives, int nnegatives,
int logScale, int shrinkage, int poolSize);
virtual bool train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth) = 0;
CV_EXPORTS bool initModule_softcascade(void);
-} }
+}} // namespace cv { namespace softcascade {
#endif
\ No newline at end of file
""" Create new instance of soft cascade."""
def cascade(min_scale, max_scale, nscales, f):
# where we use nms cv::SoftCascadeDetector::DOLLAR == 2
- c = cv2.scascade_SoftCascadeDetector(min_scale, max_scale, nscales, 2)
+ c = cv2.softcascade_Detector(min_scale, max_scale, nscales, 2)
xml = cv2.FileStorage(f, 0)
dom = xml.getFirstTopLevelNode()
assert c.load(dom)
using cv::Rect;
using std::tr1::get;
+
+using namespace cv::softcascade;
+
typedef std::tr1::tuple<std::string, std::string> fixture;
typedef perf::TestBaseWithParam<fixture> detect;
namespace {
-void extractRacts(std::vector<cv::scascade::Detection> objectBoxes, std::vector<Rect>& rects)
+void extractRacts(std::vector<Detection> objectBoxes, std::vector<Rect>& rects)
{
rects.clear();
for (int i = 0; i < (int)objectBoxes.size(); ++i)
cv::Mat colored = cv::imread(getDataPath(get<1>(GetParam())));
ASSERT_FALSE(colored.empty());
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(getDataPath(get<0>(GetParam())), cv::FileStorage::READ);
ASSERT_TRUE(fs.isOpened());
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- std::vector<cv::scascade::Detection> objectBoxes;
- cascade.detect(colored, cv::noArray(), objectBoxes);
-
+ std::vector<Detection> objectBoxes;
TEST_CYCLE()
{
cascade.detect(colored, cv::noArray(), objectBoxes);
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
+// and / or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
#define __SFT_RANDOM_HPP__
#if defined(_MSC_VER) && _MSC_VER >= 1600
-
# include <random>
-namespace sft {
+
+namespace cv { namespace softcascade { namespace internal
+{
+
struct Random
{
typedef std::mt19937 engine;
typedef std::uniform_int<int> uniform;
};
-}
-#elif (__GNUC__) && __GNUC__ > 3 && __GNUC_MINOR__ > 1 && !defined(__ANDROID__)
+}}}
+#elif (__GNUC__) && __GNUC__ > 3 && __GNUC_MINOR__ > 1 && !defined(__ANDROID__)
# if defined (__cplusplus) && __cplusplus > 201100L
# include <random>
-namespace sft {
+
+namespace cv { namespace softcascade { namespace internal
+{
+
struct Random
{
typedef std::mt19937 engine;
typedef std::uniform_int<int> uniform;
};
-}
+}}}
+
# else
-# include <tr1/random>
+# include <tr1/random>
+
+namespace cv { namespace softcascade { namespace internal
+{
-namespace sft {
struct Random
{
typedef std::tr1::mt19937 engine;
typedef std::tr1::uniform_int<int> uniform;
};
-}
+
+}}}
# endif
#else
-#include <opencv2/core/core.hpp>
+# include <opencv2/core/core.hpp>
+
+namespace cv { namespace softcascade { namespace internal
+{
namespace rnd {
typedef cv::RNG engine;
}
-namespace sft {
struct Random
{
typedef rnd::engine engine;
typedef rnd::uniform_int<int> uniform;
};
-}
+
+}}}
#endif
namespace {
+using namespace cv::softcascade;
+
class ICFBuilder : public ChannelFeatureBuilder
{
virtual ~ICFBuilder() {}
virtual cv::AlgorithmInfo* info() const;
+
virtual void operator()(cv::InputArray _frame, CV_OUT cv::OutputArray _integrals) const
{
CV_Assert(_frame.type() == CV_8UC3);
}
+using cv::softcascade::ChannelFeatureBuilder;
+using cv::softcascade::ChannelFeature;
+
CV_INIT_ALGORITHM(ICFBuilder, "ChannelFeatureBuilder.ICFBuilder", );
-cv::scascade::ChannelFeatureBuilder::~ChannelFeatureBuilder() {}
+ChannelFeatureBuilder::~ChannelFeatureBuilder() {}
cv::Ptr<ChannelFeatureBuilder> ChannelFeatureBuilder::create()
{
return builder;
}
-cv::scascade::ChannelFeature::ChannelFeature(int x, int y, int w, int h, int ch)
+ChannelFeature::ChannelFeature(int x, int y, int w, int h, int ch)
: bb(cv::Rect(x, y, w, h)), channel(ch) {}
bool ChannelFeature::operator ==(ChannelFeature b)
}
-float cv::scascade::ChannelFeature::operator() (const cv::Mat& integrals, const cv::Size& model) const
+float ChannelFeature::operator() (const cv::Mat& integrals, const cv::Size& model) const
{
int step = model.width + 1;
return (float)(a - b + c - d);
}
-void cv::scascade::write(cv::FileStorage& fs, const string&, const ChannelFeature& f)
+void cv::softcascade::write(cv::FileStorage& fs, const string&, const ChannelFeature& f)
{
fs << "{" << "channel" << f.channel << "rect" << f.bb << "}";
}
-std::ostream& cv::scascade::operator<<(std::ostream& out, const ChannelFeature& m)
+std::ostream& cv::softcascade::operator<<(std::ostream& out, const ChannelFeature& m)
{
out << m.channel << " " << m.bb;
return out;
}
-cv::scascade::ChannelFeature::~ChannelFeature(){}
+ChannelFeature::~ChannelFeature(){}
namespace {
+using namespace cv::softcascade;
+
class ChannelFeaturePool : public FeaturePool
{
public:
void ChannelFeaturePool::fill(int desired)
{
+ using namespace cv::softcascade::internal;
int mw = model.width;
int mh = model.height;
int nfeatures = std::min(desired, maxPoolSize);
pool.reserve(nfeatures);
- sft::Random::engine eng(FEATURE_RECT_SEED);
- sft::Random::engine eng_ch(DCHANNELS_SEED);
+ Random::engine eng(FEATURE_RECT_SEED);
+ Random::engine eng_ch(DCHANNELS_SEED);
- sft::Random::uniform chRand(0, N_CHANNELS - 1);
+ Random::uniform chRand(0, N_CHANNELS - 1);
- sft::Random::uniform xRand(0, model.width - 2);
- sft::Random::uniform yRand(0, model.height - 2);
+ Random::uniform xRand(0, model.width - 2);
+ Random::uniform yRand(0, model.height - 2);
- sft::Random::uniform wRand(1, model.width - 1);
- sft::Random::uniform hRand(1, model.height - 1);
+ Random::uniform wRand(1, model.width - 1);
+ Random::uniform hRand(1, model.height - 1);
while (pool.size() < size_t(nfeatures))
{
}
-cv::Ptr<FeaturePool> cv::scascade::FeaturePool::create(const cv::Size& model, int nfeatures)
+cv::Ptr<FeaturePool> FeaturePool::create(const cv::Size& model, int nfeatures)
{
cv::Ptr<FeaturePool> pool(new ChannelFeaturePool(model, nfeatures));
return pool;
#include "opencv2/ml/ml.hpp"
#include "_random.hpp"
-using namespace cv::scascade;
-
#endif
using cv::OutputArray;
using cv::Mat;
-cv::scascade::FeaturePool::~FeaturePool(){}
-cv::scascade::Dataset::~Dataset(){}
+using cv::softcascade::Octave;
+using cv::softcascade::FeaturePool;
+using cv::softcascade::Dataset;
+using cv::softcascade::ChannelFeatureBuilder;
-namespace {
+FeaturePool::~FeaturePool(){}
+Dataset::~Dataset(){}
+namespace {
-class BoostedSoftCascadeOctave : public cv::Boost, public SoftCascadeOctave
+class BoostedSoftCascadeOctave : public cv::Boost, public Octave
{
public:
void BoostedSoftCascadeOctave::generateNegatives(const Dataset* dataset)
{
+ using namespace cv::softcascade::internal;
// ToDo: set seed, use offsets
- sft::Random::engine eng(DX_DY_SEED);
- sft::Random::engine idxEng(INDEX_ENGINE_SEED);
+ Random::engine eng(DX_DY_SEED);
+ Random::engine idxEng(INDEX_ENGINE_SEED);
int h = boundingBox.height;
int nimages = dataset->available(Dataset::NEGATIVE);
- sft::Random::uniform iRand(0, nimages - 1);
+ Random::uniform iRand(0, nimages - 1);
int total = 0;
Mat sum;
int maxW = frame.cols - 2 * boundingBox.x - boundingBox.width;
int maxH = frame.rows - 2 * boundingBox.y - boundingBox.height;
- sft::Random::uniform wRand(0, maxW -1);
- sft::Random::uniform hRand(0, maxH -1);
+ Random::uniform wRand(0, maxW -1);
+ Random::uniform hRand(0, maxH -1);
int dx = wRand(eng);
int dy = hRand(eng);
CV_INIT_ALGORITHM(BoostedSoftCascadeOctave, "SoftCascadeOctave.BoostedSoftCascadeOctave", );
-cv::scascade::SoftCascadeOctave::~SoftCascadeOctave(){}
+Octave::~Octave(){}
-cv::Ptr<SoftCascadeOctave> cv::scascade::SoftCascadeOctave::create(cv::Rect boundingBox, int npositives, int nnegatives,
+cv::Ptr<Octave> Octave::create(cv::Rect boundingBox, int npositives, int nnegatives,
int logScale, int shrinkage, int poolSize)
{
- cv::Ptr<SoftCascadeOctave> octave(
+ cv::Ptr<Octave> octave(
new BoostedSoftCascadeOctave(boundingBox, npositives, nnegatives, logScale, shrinkage, poolSize));
return octave;
}
#include "precomp.hpp"
+using cv::softcascade::Detection;
+using cv::softcascade::Detector;
+using cv::softcascade::ChannelFeatureBuilder;
+
+using namespace cv;
+
namespace {
-struct Octave
+struct SOctave
{
- Octave(const int i, const cv::Size& origObjSize, const cv::FileNode& fn)
+ SOctave(const int i, const cv::Size& origObjSize, const cv::FileNode& fn)
: index(i), weaks((int)fn[SC_OCT_WEAKS]), scale(pow(2,(float)fn[SC_OCT_SCALE])),
size(cvRound(origObjSize.width * scale), cvRound(origObjSize.height * scale)) {}
static const char *const SC_F_RECT;
};
-const char *const Octave::SC_OCT_SCALE = "scale";
-const char *const Octave::SC_OCT_WEAKS = "weaks";
-const char *const Octave::SC_OCT_SHRINKAGE = "shrinkingFactor";
+const char *const SOctave::SC_OCT_SCALE = "scale";
+const char *const SOctave::SC_OCT_WEAKS = "weaks";
+const char *const SOctave::SC_OCT_SHRINKAGE = "shrinkingFactor";
const char *const Weak::SC_WEAK_THRESHOLD = "treeThreshold";
const char *const Feature::SC_F_CHANNEL = "channel";
const char *const Feature::SC_F_RECT = "rect";
struct Level
{
- const Octave* octave;
+ const SOctave* octave;
float origScale;
float relScale;
float scaling[2]; // 0-th for channels <= 6, 1-st otherwise
- Level(const Octave& oct, const float scale, const int shrinkage, const int w, const int h)
+ Level(const SOctave& oct, const float scale, const int shrinkage, const int w, const int h)
: octave(&oct), origScale(scale), relScale(scale / oct.scale),
workRect(cv::Size(cvRound(w / (float)shrinkage),cvRound(h / (float)shrinkage))),
objSize(cv::Size(cvRound(oct.size.width * relScale), cvRound(oct.size.height * relScale)))
}
-struct SoftCascadeDetector::Fields
+
+struct Detector::Fields
{
float minScale;
float maxScale;
int shrinkage;
- std::vector<Octave> octaves;
+ std::vector<SOctave> octaves;
std::vector<Weak> weaks;
std::vector<Node> nodes;
std::vector<float> leaves;
cv::Size frameSize;
- typedef std::vector<Octave>::iterator octIt_t;
+ typedef std::vector<SOctave>::iterator octIt_t;
typedef std::vector<Detection> dvector;
void detectAt(const int dx, const int dy, const Level& level, const ChannelStorage& storage, dvector& detections) const
{
float detectionScore = 0.f;
- const Octave& octave = *(level.octave);
+ const SOctave& octave = *(level.octave);
int stBegin = octave.index * octave.weaks, stEnd = stBegin + octave.weaks;
octIt_t res = octaves.begin();
for (octIt_t oct = octaves.begin(); oct < octaves.end(); ++oct)
{
- const Octave& octave =*oct;
+ const SOctave& octave =*oct;
float logOctave = log(octave.scale);
float logAbsScale = fabs(logFactor - logOctave);
for (int octIndex = 0; it != it_end; ++it, ++octIndex)
{
FileNode fns = *it;
- Octave octave(octIndex, cv::Size(origObjWidth, origObjHeight), fns);
+ SOctave octave(octIndex, cv::Size(origObjWidth, origObjHeight), fns);
CV_Assert(octave.weaks > 0);
octaves.push_back(octave);
}
};
-SoftCascadeDetector::SoftCascadeDetector(const double mins, const double maxs, const int nsc, const int rej)
+Detector::Detector(const double mins, const double maxs, const int nsc, const int rej)
: fields(0), minScale(mins), maxScale(maxs), scales(nsc), rejCriteria(rej) {}
-SoftCascadeDetector::~SoftCascadeDetector() { delete fields;}
+Detector::~Detector() { delete fields;}
-void SoftCascadeDetector::read(const FileNode& fn)
+void Detector::read(const cv::FileNode& fn)
{
Algorithm::read(fn);
}
-bool SoftCascadeDetector::load(const FileNode& fn)
+bool Detector::load(const cv::FileNode& fn)
{
if (fields) delete fields;
namespace {
+using cv::softcascade::Detection;
typedef std::vector<Detection> dvector;
static void suppress(int type, std::vector<Detection>& objects)
{
- CV_Assert(type == SoftCascadeDetector::DOLLAR);
+ CV_Assert(type == Detector::DOLLAR);
DollarNMS(objects);
}
}
-void SoftCascadeDetector::detectNoRoi(const cv::Mat& image, std::vector<Detection>& objects) const
+void Detector::detectNoRoi(const cv::Mat& image, std::vector<Detection>& objects) const
{
Fields& fld = *fields;
// create integrals
}
}
- // if (rejCriteria != NO_REJECT) suppress(rejCriteria, objects);
+ if (rejCriteria != NO_REJECT) suppress(rejCriteria, objects);
}
-void SoftCascadeDetector::detect(cv::InputArray _image, cv::InputArray _rois, std::vector<Detection>& objects) const
+void Detector::detect(cv::InputArray _image, cv::InputArray _rois, std::vector<Detection>& objects) const
{
// only color images are suppered
cv::Mat image = _image.getMat();
if (rejCriteria != NO_REJECT) suppress(rejCriteria, objects);
}
-void SoftCascadeDetector::detect(InputArray _image, InputArray _rois, OutputArray _rects, OutputArray _confs) const
+void Detector::detect(InputArray _image, InputArray _rois, OutputArray _rects, OutputArray _confs) const
{
std::vector<Detection> objects;
detect( _image, _rois, objects);
#include "precomp.hpp"
-namespace cv { namespace scascade
+namespace cv { namespace softcascade
{
-CV_INIT_ALGORITHM(SoftCascadeDetector, "SoftCascade.SoftCascadeDetector",
+CV_INIT_ALGORITHM(Detector, "SoftCascade.Detector",
obj.info()->addParam(obj, "minScale", obj.minScale);
obj.info()->addParam(obj, "maxScale", obj.maxScale);
obj.info()->addParam(obj, "scales", obj.scales);
bool initModule_softcascade(void)
{
- Ptr<Algorithm> sc1 = createSoftCascadeDetector();
+ Ptr<Algorithm> sc1 = createDetector();
return (sc1->info() != 0);
}
#include "test_precomp.hpp"
+using namespace cv::softcascade;
+
TEST(ChannelFeatureBuilderTest, info)
{
- cv::Ptr<cv::scascade::ChannelFeatureBuilder> builder = cv::scascade::ChannelFeatureBuilder::create();
+ cv::Ptr<ChannelFeatureBuilder> builder = ChannelFeatureBuilder::create();
ASSERT_TRUE(builder->info() != 0);
}
TEST(ChannelFeatureBuilderTest, compute)
{
- cv::Ptr<cv::scascade::ChannelFeatureBuilder> builder = cv::scascade::ChannelFeatureBuilder::create();
+ cv::Ptr<ChannelFeatureBuilder> builder = ChannelFeatureBuilder::create();
cv::Mat colored = cv::imread(cvtest::TS::ptr()->get_data_path() + "cascadeandhog/images/image_00000000_0.png");
cv::Mat ints;
#include <fstream>
#include "test_precomp.hpp"
- typedef cv::scascade::Detection Detection;
+
+using namespace cv::softcascade;
TEST(SoftCascadeDetector, readCascade)
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/cascades/inria_caltech-17.01.2013.xml";
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(fs.isOpened());
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
TEST(SoftCascadeDetector, detect)
{
std::string xml = cvtest::TS::ptr()->get_data_path()+ "cascadeandhog/cascades/inria_caltech-17.01.2013.xml";
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
TEST(SoftCascadeDetector, detectSeparate)
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/cascades/inria_caltech-17.01.2013.xml";
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
TEST(SoftCascadeDetector, detectRoi)
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/cascades/inria_caltech-17.01.2013.xml";
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
TEST(SoftCascadeDetector, detectNoRoi)
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/cascades/inria_caltech-17.01.2013.xml";
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
TEST(SoftCascadeDetector, detectEmptyRoi)
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/cascades/inria_caltech-17.01.2013.xml";
- cv::scascade::SoftCascadeDetector cascade;
+ Detector cascade;
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
namespace {
+using namespace cv::softcascade;
+
typedef vector<string> svector;
-class ScaledDataset : public cv::scascade::Dataset
+class ScaledDataset : public Dataset
{
public:
ScaledDataset(const string& path, const int octave);
float octave = powf(2.f, (float)(*it));
cv::Size model = cv::Size( cvRound(64 * octave) / shrinkage, cvRound(128 * octave) / shrinkage );
- cv::Ptr<cv::scascade::FeaturePool> pool = cv::scascade::FeaturePool::create(model, nfeatures);
+ cv::Ptr<FeaturePool> pool = FeaturePool::create(model, nfeatures);
nfeatures = pool->size();
int npositives = 20;
int nnegatives = 40;
cv::Rect boundingBox = cv::Rect( cvRound(20 * octave), cvRound(20 * octave),
cvRound(64 * octave), cvRound(128 * octave));
- typedef cv::scascade::SoftCascadeOctave Octave;
cv::Ptr<Octave> boost = Octave::create(boundingBox, npositives, nnegatives, *it, shrinkage, nfeatures);
std::string path = cvtest::TS::ptr()->get_data_path() + "softcascade/sample_training_set";
projects / profile / ivi / opencv.git / commitdiff