changes related with code review

apps/sft/CMakeLists.txt

@@ -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")

apps/sft/config.cpp

@@ -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)
 {

apps/sft/include/sft/common.hpp

@@ -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
 {
 

apps/sft/include/sft/dataset.hpp

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

apps/sft/sft.cpp

@@ -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);
 

modules/python/src2/cv2.cpp

@@ -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;
 

modules/softcascade/doc/softcascade_detector.rst

@@ -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.
 

modules/softcascade/doc/softcascade_training.rst

@@ -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.
 

modules/softcascade/include/opencv2/softcascade/softcascade.hpp

@@ -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
\ No newline at end of file

modules/softcascade/misc/sft.py

@@ -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)

modules/softcascade/perf/perf_softcascade.cpp

@@ -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);

modules/softcascade/src/_random.hpp

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

modules/softcascade/src/integral_channel_builder.cpp

@@ -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;

modules/softcascade/src/precomp.hpp

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

modules/softcascade/src/soft_cascade_octave.cpp

@@ -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;
 
-namespace {
+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;
 }

modules/softcascade/src/softcascade.cpp

@@ -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);

modules/softcascade/src/softcascade_init.cpp

@@ -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);
 }
 

modules/softcascade/test/test_channel_features.cpp

@@ -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;

modules/softcascade/test/test_softcascade.cpp

@@ -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()));
 

modules/softcascade/test/test_training.cpp

@@ -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";