mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-27 20:50:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

changes related with code review

Browse Source
This commit is contained in:
marina.kolpakova 2013-02-01 14:25:10 +04:00
parent f7ac73998a
commit cc538ddfa6
20 changed files with 175 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
apps/sft/CMakeLists.txt
View File

@ -24,7 +24,7 @@ set_target_properties(${the_target} PROPERTIES
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")

3
apps/sft/config.cpp
View File

@ -114,6 +114,8 @@ void sft::read(const cv::FileNode& node, Config& x, const Config& default_value)
x.read(node);
}
namespace {
struct Out
{
Out(std::ostream& _out): out(_out) {}
@ -124,6 +126,7 @@ struct Out
private:
Out& operator=(Out const& other);
};
}
std::ostream& sft::operator<<(std::ostream& out, const Config& m)
{

2
apps/sft/include/sft/common.hpp
View File

@ -46,7 +46,7 @@
#include <opencv2/core/core.hpp>
#include <opencv2/softcascade/softcascade.hpp>
namespace cv {using namespace scascade;}
namespace cv {using namespace softcascade;}
namespace sft
{

2
apps/sft/include/sft/dataset.hpp
View File

@ -47,7 +47,7 @@
namespace sft
{
using cv::Dataset;
using cv::softcascade::Dataset;
class ScaledDataset : public Dataset
{

8
apps/sft/sft.cpp
View File

@ -76,7 +76,7 @@ int main(int argc, char** argv)
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;
}
@ -84,7 +84,7 @@ int main(int argc, char** argv)
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;
}
@ -97,7 +97,7 @@ int main(int argc, char** argv)
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;
}
@ -128,7 +128,7 @@ int main(int argc, char** argv)
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);

4
modules/python/src2/cv2.cpp
View File

@ -97,7 +97,7 @@ catch (const cv::Exception &e) \
}
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;
@ -126,7 +126,7 @@ typedef Ptr<DescriptorExtractor> Ptr_DescriptorExtractor;
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;

36
modules/softcascade/doc/softcascade_detector.rst
View File

@ -25,20 +25,20 @@ The sample has been rejected if it fall rejection threshold. So stageless cascad
.. [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);
@ -49,13 +49,13 @@ Implementation of soft (stageless) cascaded detector. ::
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.
@ -67,35 +67,35 @@ An empty cascade will be created.
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.

30
modules/softcascade/doc/softcascade_training.rst
View File

@ -7,13 +7,13 @@ Soft Cascade Detector Training
--------------------------------------------
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:
@ -25,8 +25,8 @@ Public interface for soft cascade training algorithm. ::
// 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;
@ -37,17 +37,17 @@ Public interface for soft cascade training algorithm. ::
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.
@ -59,19 +59,19 @@ SoftCascadeOctave::train
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.

18
modules/softcascade/include/opencv2/softcascade/softcascade.hpp
View File

@ -45,7 +45,7 @@
#include "opencv2/core/core.hpp"
namespace cv { namespace scascade {
namespace cv { namespace softcascade {
// Representation of detectors result.
struct CV_EXPORTS Detection
@ -64,8 +64,6 @@ struct CV_EXPORTS Detection
int kind;
};
class CV_EXPORTS Dataset
{
public:
@ -136,7 +134,7 @@ public:
// ========================================================================== //
// Implementation of soft (stageless) cascaded detector.
// ========================================================================== //
class CV_EXPORTS_W SoftCascadeDetector : public cv::Algorithm
class CV_EXPORTS_W Detector : public cv::Algorithm
{
public:
@ -147,9 +145,9 @@ 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;
@ -186,7 +184,7 @@ private:
// ========================================================================== //
// 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
@ -199,8 +197,8 @@ public:
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;
@ -211,6 +209,6 @@ public:
CV_EXPORTS bool initModule_softcascade(void);
} }
}} // namespace cv { namespace softcascade {
#endif

2
modules/softcascade/misc/sft.py
View File

@ -24,7 +24,7 @@ def convert2detections(rects, confs, crop_factor = 0.125):
""" 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)

11
modules/softcascade/perf/perf_softcascade.cpp
View File

@ -4,13 +4,16 @@
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)
@ -26,14 +29,12 @@ PERF_TEST_P(detect, SoftCascadeDetector,
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);

40
modules/softcascade/src/_random.hpp
View File

@ -22,7 +22,7 @@
//
// * 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.
@ -44,41 +44,53 @@
#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__)
# 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>
}}}
# else
# 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;
@ -104,13 +116,13 @@ private:
}
namespace sft {
struct Random
{
typedef rnd::engine engine;
typedef rnd::uniform_int<int> uniform;
};
}
}}}
#endif

37
modules/softcascade/src/integral_channel_builder.cpp
View File

@ -44,10 +44,13 @@
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);
@ -107,9 +110,12 @@ class ICFBuilder : public ChannelFeatureBuilder
}
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()
{
@ -117,7 +123,7 @@ 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)
@ -131,7 +137,7 @@ 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;
@ -148,21 +154,23 @@ float cv::scascade::ChannelFeature::operator() (const cv::Mat& integrals, const
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:
@ -200,6 +208,7 @@ void ChannelFeaturePool::write( cv::FileStorage& fs, int index) const
void ChannelFeaturePool::fill(int desired)
{
using namespace cv::softcascade::internal;
int mw = model.width;
int mh = model.height;
@ -208,16 +217,16 @@ void ChannelFeaturePool::fill(int desired)
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))
{
@ -246,7 +255,7 @@ void ChannelFeaturePool::fill(int desired)
}
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;

2
modules/softcascade/src/precomp.hpp
View File

@ -55,6 +55,4 @@
#include "opencv2/ml/ml.hpp"
#include "_random.hpp"
using namespace cv::scascade;
#endif

29
modules/softcascade/src/soft_cascade_octave.cpp
View File

@ -48,13 +48,17 @@ using cv::InputArray;
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;
FeaturePool::~FeaturePool(){}
Dataset::~Dataset(){}
namespace {
class BoostedSoftCascadeOctave : public cv::Boost, public SoftCascadeOctave
class BoostedSoftCascadeOctave : public cv::Boost, public Octave
{
public:
@ -214,14 +218,15 @@ void BoostedSoftCascadeOctave::processPositives(const Dataset* dataset)
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;
@ -236,8 +241,8 @@ void BoostedSoftCascadeOctave::generateNegatives(const Dataset* dataset)
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);
@ -439,12 +444,12 @@ void BoostedSoftCascadeOctave::write( CvFileStorage* fs, std::string _name) cons
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;
}

52
modules/softcascade/src/softcascade.cpp
View File

@ -42,11 +42,17 @@
#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)) {}
@ -115,16 +121,16 @@ struct Feature
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;
@ -135,7 +141,7 @@ struct Level
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)))
@ -205,7 +211,8 @@ struct ChannelStorage
}
struct SoftCascadeDetector::Fields
struct Detector::Fields
{
float minScale;
float maxScale;
@ -216,7 +223,7 @@ struct SoftCascadeDetector::Fields
int shrinkage;
std::vector<Octave> octaves;
std::vector<SOctave> octaves;
std::vector<Weak> weaks;
std::vector<Node> nodes;
std::vector<float> leaves;
@ -226,14 +233,14 @@ struct SoftCascadeDetector::Fields
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;
@ -279,7 +286,7 @@ struct SoftCascadeDetector::Fields
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);
@ -373,7 +380,7 @@ struct SoftCascadeDetector::Fields
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);
@ -409,17 +416,17 @@ struct SoftCascadeDetector::Fields
}
};
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;
@ -429,6 +436,7 @@ bool SoftCascadeDetector::load(const FileNode& fn)
namespace {
using cv::softcascade::Detection;
typedef std::vector<Detection> dvector;
@ -472,13 +480,13 @@ void DollarNMS(dvector& objects)
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
@ -502,10 +510,10 @@ void SoftCascadeDetector::detectNoRoi(const cv::Mat& image, std::vector<Detectio
}
}
// 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();
@ -557,7 +565,7 @@ void SoftCascadeDetector::detect(cv::InputArray _image, cv::InputArray _rois, st
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);

6
modules/softcascade/src/softcascade_init.cpp
View File

@ -42,10 +42,10 @@
#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);
@ -54,7 +54,7 @@ CV_INIT_ALGORITHM(SoftCascadeDetector, "SoftCascade.SoftCascadeDetector",
bool initModule_softcascade(void)
{
Ptr<Algorithm> sc1 = createSoftCascadeDetector();
Ptr<Algorithm> sc1 = createDetector();
return (sc1->info() != 0);
}

6
modules/softcascade/test/test_channel_features.cpp
View File

@ -42,15 +42,17 @@
#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;

15
modules/softcascade/test/test_softcascade.cpp
View File

@ -44,12 +44,13 @@
#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()));
@ -58,7 +59,7 @@ TEST(SoftCascadeDetector, readCascade)
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()));
@ -74,7 +75,7 @@ TEST(SoftCascadeDetector, detect)
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()));
@ -90,7 +91,7 @@ TEST(SoftCascadeDetector, detectSeparate)
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()));
@ -108,7 +109,7 @@ TEST(SoftCascadeDetector, detectRoi)
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()));
@ -126,7 +127,7 @@ TEST(SoftCascadeDetector, detectNoRoi)
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()));

7
modules/softcascade/test/test_training.cpp
View File

@ -57,8 +57,10 @@ using namespace std;
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);
@ -210,7 +212,7 @@ TEST(DISABLED_SoftCascade, training)
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;
@ -218,7 +220,6 @@ TEST(DISABLED_SoftCascade, training)
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";