Fix documentation problems found by check_docs2 script

doc/check_docs2.py

@@ -38,7 +38,7 @@ doc_signatures_whitelist = [
 "CvArr", "CvFileStorage",
 # other
 "InputArray", "OutputArray",
-] + ["CvSubdiv2D", "CvQuadEdge2D", "CvSubdiv2DPoint", "cvDrawContours"]
+]
 
 defines = ["cvGraphEdgeIdx", "cvFree", "CV_Assert", "cvSqrt", "cvGetGraphVtx", "cvGraphVtxIdx",
 "cvCaptureFromFile", "cvCaptureFromCAM", "cvCalcBackProjectPatch", "cvCalcBackProject",
@@ -156,9 +156,10 @@ def formatSignature(s):
             argtype = re.sub(r"\s+(\*|&)$", "\\1", arg[0])
             bidx = argtype.find('[')
             if bidx < 0:
-                _str += argtype + " "
+                _str += argtype
             else:
-                _srt += argtype[:bidx]
+                _str += argtype[:bidx]
+            _str += " "
             if arg[1]:
                 _str += arg[1]
             else:
@@ -326,6 +327,7 @@ def process_module(module, path):
             flookup[fn[0]] = flookup_entry
 
     if do_python_crosscheck:
+        pyclsnamespaces = ["cv." + x[3:].replace(".", "_") for x in clsnamespaces]
         for name, doc in rst.iteritems():
             decls = doc.get("decls")
             if not decls:
@@ -394,7 +396,7 @@ def process_module(module, path):
                     pname = signature[1][4:signature[1].find('(')]
                     cvname = "cv." + pname
                     parent = None
-                    for cl in clsnamespaces:
+                    for cl in pyclsnamespaces:
                         if cvname.startswith(cl + "."):
                             if cl.startswith(parent or ""):
                                 parent = cl

modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst

@@ -685,7 +685,7 @@ findEssentialMat
 ------------------
 Calculates an essential matrix from the corresponding points in two images.
 
-.. ocv:function:: Mat findEssentialMat( InputArray points1, InputArray points2, double focal = 1.0, Point2d pp = Point2d(0, 0), int method = FM_RANSAC, double prob = 0.999, double threshold = 1.0, OutputArray mask = noArray() )
+.. ocv:function:: Mat findEssentialMat( InputArray points1, InputArray points2, double focal=1.0, Point2d pp=Point2d(0, 0), int method=CV_RANSAC, double prob=0.999, double threshold=1.0, OutputArray mask=noArray() )
 
     :param points1: Array of  ``N`` ``(N >= 5)`` 2D points from the first image. The point coordinates should be floating-point (single or double precision).
 

modules/core/doc/operations_on_arrays.rst

@@ -692,7 +692,7 @@ cvarrToMat
 ----------
 Converts ``CvMat``, ``IplImage`` , or ``CvMatND`` to ``Mat``.
 
-.. ocv:function:: Mat cvarrToMat( const CvArr* arr, bool copyData=false, bool allowND=true, int coiMode=0 )
+.. ocv:function:: Mat cvarrToMat( const CvArr* arr, bool copyData=false, bool allowND=true, int coiMode=0, AutoBuffer<double>* buf=0 )
 
     :param arr: input ``CvMat``, ``IplImage`` , or  ``CvMatND``.
 

modules/features2d/doc/feature_detection_and_description.rst

@@ -7,7 +7,8 @@ FAST
 ----
 Detects corners using the FAST algorithm
 
-.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression=true, type=FastFeatureDetector::TYPE_9_16 )
+.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression=true )
+.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression, int type )
 
     :param image: grayscale image where keypoints (corners) are detected.
 

modules/gpu/doc/image_processing.rst

@@ -703,14 +703,10 @@ Calculates histogram for one channel 8-bit image.
 
 .. ocv:function:: void gpu::calcHist(const GpuMat& src, GpuMat& hist, Stream& stream = Stream::Null())
 
-.. ocv:function:: void gpu::calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null())
-
     :param src: Source image.
 
     :param hist: Destination histogram with one row, 256 columns, and the  ``CV_32SC1`` type.
 
-    :param buf: Optional buffer to avoid extra memory allocations (for many calls with the same sizes).
-
     :param stream: Stream for the asynchronous version.
 
 
@@ -721,8 +717,6 @@ Equalizes the histogram of a grayscale image.
 
 .. ocv:function:: void gpu::equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null())
 
-.. ocv:function:: void gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream& stream = Stream::Null())
-
 .. ocv:function:: void gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null())
 
     :param src: Source image.

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -881,7 +881,7 @@ CV_EXPORTS void HoughCirclesDownload(const GpuMat& d_circles, OutputArray h_circ
 //! finds arbitrary template in the grayscale image using Generalized Hough Transform
 //! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
 //! Guil, N., González-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038.
-class CV_EXPORTS GeneralizedHough_GPU : public Algorithm
+class CV_EXPORTS GeneralizedHough_GPU : public cv::Algorithm
 {
 public:
     static Ptr<GeneralizedHough_GPU> create(int method);
@@ -1554,7 +1554,7 @@ protected:
 };
 
 // Implementation of soft (stage-less) cascaded detector.
-class CV_EXPORTS SCascade : public Algorithm
+class CV_EXPORTS SCascade : public cv::Algorithm
 {
 public:
 

modules/java/generator/rst_parser.py

 #/usr/bin/env python
 
 import os, sys, re, string, fnmatch
-allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "java", "python", "stitching", "ts", "photo", "nonfree", "videostab", "ocl"]
+allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "java", "python", "stitching", "ts", "photo", "nonfree", "videostab", "ocl", "softcascade"]
 verbose = False
 show_warnings = True
 show_errors = True

modules/softcascade/doc/softcascade_detector.rst

@@ -25,37 +25,37 @@ 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.
 
 
-Detector
+softcascade::Detector
 -------------------
-.. ocv:class:: Detector
+.. ocv:class:: Detector : public Algorithm
 
 Implementation of soft (stageless) cascaded detector. ::
 
-    class CV_EXPORTS_W Detector : public Algorithm
+    class Detector : public Algorithm
     {
     public:
 
         enum { NO_REJECT = 1, DOLLAR = 2, /*PASCAL = 4,*/ DEFAULT = NO_REJECT};
 
-        CV_WRAP Detector(double minScale = 0.4, double maxScale = 5., int scales = 55, int rejCriteria = 1);
-        CV_WRAP virtual ~Detector();
+        Detector(double minScale = 0.4, double maxScale = 5., int scales = 55, int rejCriteria = 1);
+        virtual ~Detector();
         cv::AlgorithmInfo* info() const;
-        CV_WRAP virtual bool load(const FileNode& fileNode);
-        CV_WRAP virtual void read(const FileNode& fileNode);
+        virtual bool load(const FileNode& fileNode);
+        virtual void read(const FileNode& fileNode);
         virtual void detect(InputArray image, InputArray rois, std::vector<Detection>& objects) const;
-        CV_WRAP virtual void detect(InputArray image, InputArray rois, CV_OUT OutputArray rects, CV_OUT OutputArray confs) const;
+        virtual void detect(InputArray image, InputArray rois, CV_OUT OutputArray rects, CV_OUT OutputArray confs) const;
 
     }
 
 
 
-Detector::Detector
+softcascade::Detector::Detector
 ----------------------------------------
 An empty cascade will be created.
 
-.. ocv:function:: Detector::Detector(float minScale = 0.4f, float maxScale = 5.f, int scales = 55, int rejCriteria = 1)
+.. ocv:function:: softcascade::Detector::Detector( double minScale=0.4, double maxScale=5., int scales=55, int rejCriteria=1 )
 
-.. ocv:pyfunction:: cv2.Detector.Detector(minScale[, maxScale[, scales[, rejCriteria]]]) -> cascade
+.. ocv:pyfunction:: cv2.softcascade_Detector([minScale[, maxScale[, scales[, rejCriteria]]]]) -> <softcascade_Detector object>
 
     :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.
 
 
 
-Detector::~Detector
+softcascade::Detector::~Detector
 -----------------------------------------
 Destructor for Detector.
 
-.. ocv:function:: Detector::~Detector()
+.. ocv:function:: softcascade::Detector::~Detector()
 
 
 
-Detector::load
---------------------------
+softcascade::Detector::load
+---------------------------
 Load cascade from FileNode.
 
-.. ocv:function:: bool Detector::load(const FileNode& fileNode)
+.. ocv:function:: bool softcascade::Detector::load(const FileNode& fileNode)
 
-.. ocv:pyfunction:: cv2.Detector.load(fileNode)
+.. ocv:pyfunction:: cv2.softcascade_Detector.load(fileNode) -> retval
 
     :param fileNode: File node from which the soft cascade are read.
 
 
 
-Detector::detect
----------------------------
+softcascade::Detector::detect
+-----------------------------
 Apply cascade to an input frame and return the vector of Detection objects.
 
-.. ocv:function:: void Detector::detect(InputArray image, InputArray rois, std::vector<Detection>& objects) const
+.. ocv:function:: void softcascade::Detector::detect(InputArray image, InputArray rois, std::vector<Detection>& objects) const
 
-.. ocv:function:: void Detector::detect(InputArray image, InputArray rois, OutputArray rects, OutputArray confs) const
+.. ocv:function:: void softcascade::Detector::detect(InputArray image, InputArray rois, OutputArray rects, OutputArray confs) const
 
-.. ocv:pyfunction:: cv2.Detector.detect(image, rois) -> (rects, confs)
+.. ocv:pyfunction:: cv2.softcascade_Detector.detect(image, rois[, rects[, confs]]) -> rects, confs
 
     :param image: a frame on which detector will be applied.
 
@@ -108,37 +108,39 @@ Apply cascade to an input frame and return the vector of Detection objects.
     :param confs: an output array of confidence for detected objects. i-th bounding rectangle corresponds i-th confidence.
 
 
-ChannelFeatureBuilder
----------------------
-.. ocv:class:: ChannelFeatureBuilder
+softcascade::ChannelFeatureBuilder
+----------------------------------
+.. ocv:class:: softcascade::ChannelFeatureBuilder : public Algorithm
 
 Public interface for of soft (stageless) cascaded detector. ::
 
-    class CV_EXPORTS_W ChannelFeatureBuilder : public Algorithm
+    class ChannelFeatureBuilder : public Algorithm
     {
     public:
         virtual ~ChannelFeatureBuilder();
 
-        CV_WRAP_AS(compute) virtual void operator()(InputArray src, CV_OUT OutputArray channels) const = 0;
+        virtual void operator()(InputArray src, CV_OUT OutputArray channels) const = 0;
 
-        CV_WRAP static cv::Ptr<ChannelFeatureBuilder> create();
+        static cv::Ptr<ChannelFeatureBuilder> create();
     };
 
 
-ChannelFeatureBuilder:~ChannelFeatureBuilder
---------------------------------------------
+softcascade::ChannelFeatureBuilder:~ChannelFeatureBuilder
+---------------------------------------------------------
 Destructor for ChannelFeatureBuilder.
 
-.. ocv:function:: ChannelFeatureBuilder::~ChannelFeatureBuilder()
+.. ocv:function:: softcascade::ChannelFeatureBuilder::~ChannelFeatureBuilder()
+
+.. ocv:pyfunction:: cv2.softcascade_ChannelFeatureBuilder_create() -> retval
 
 
-ChannelFeatureBuilder::operator()
----------------------------------
+softcascade::ChannelFeatureBuilder::operator()
+----------------------------------------------
 Create channel feature integrals for input image.
 
-.. ocv:function:: void ChannelFeatureBuilder::operator()(InputArray src, OutputArray channels) const
+.. ocv:function:: void softcascade::ChannelFeatureBuilder::operator()(InputArray src, OutputArray channels) const
 
-.. ocv:pyfunction:: cv2.ChannelFeatureBuilder.compute(src, channels) -> None
+.. ocv:pyfunction:: cv2.softcascade_ChannelFeatureBuilder.compute(src, channels) -> None
 
     :param src source frame
 

modules/softcascade/doc/softcascade_training.rst

@@ -7,13 +7,13 @@ Soft Cascade Detector Training
 --------------------------------------------
 
 
-Octave
------------------
-.. ocv:class:: Octave
+softcascade::Octave
+-------------------
+.. ocv:class:: softcascade::Octave : public Algorithm
 
 Public interface for soft cascade training algorithm. ::
 
-    class CV_EXPORTS Octave : public Algorithm
+    class Octave : public Algorithm
     {
     public:
 
@@ -37,17 +37,17 @@ Public interface for soft cascade training algorithm. ::
 
 
 
-Octave::~Octave
+softcascade::Octave::~Octave
 ---------------------------------------
 Destructor for Octave.
 
-.. ocv:function:: Octave::~Octave()
+.. ocv:function:: softcascade::Octave::~Octave()
 
 
-Octave::train
-------------------------
+softcascade::Octave::train
+--------------------------
 
-.. ocv:function:: bool Octave::train(const Dataset* dataset, const FeaturePool* pool, int weaks, int treeDepth)
+.. ocv:function:: bool softcascade::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 @@ Octave::train
 
 
 
-Octave::setRejectThresholds
---------------------------------------
+softcascade::Octave::setRejectThresholds
+----------------------------------------
 
-.. ocv:function:: void Octave::setRejectThresholds(OutputArray thresholds)
+.. ocv:function:: void softcascade::Octave::setRejectThresholds(OutputArray thresholds)
 
     :param thresholds an output array of resulted rejection vector. Have same size as number of trained stages.
 
 
-Octave::write
-------------------------
+softcascade::Octave::write
+--------------------------
 
-.. ocv:function:: void Octave::train(cv::FileStorage &fs, const FeaturePool* pool, InputArray thresholds) const
-.. ocv:function:: void Octave::train( CvFileStorage* fs, string name) const
+.. ocv:function:: void softcascade::Octave::train(cv::FileStorage &fs, const FeaturePool* pool, InputArray thresholds) const
+.. ocv:function:: void softcascade::Octave::train( CvFileStorage* fs, string name) const
 
     :param fs an output file storage to store trained detector.
 
@@ -82,13 +82,13 @@ Octave::write
     :param name a name of root node for trained detector.
 
 
-FeaturePool
------------
-.. ocv:class:: FeaturePool
+softcascade::FeaturePool
+------------------------
+.. ocv:class:: softcascade::FeaturePool
 
 Public interface for feature pool. This is a hight level abstraction for training random feature pool. ::
 
-    class CV_EXPORTS FeaturePool
+    class FeaturePool
     {
     public:
 
@@ -99,42 +99,42 @@ Public interface for feature pool. This is a hight level abstraction for trainin
 
     };
 
-FeaturePool::size
------------------
+softcascade::FeaturePool::size
+------------------------------
 
 Returns size of feature pool.
 
-.. ocv:function:: int FeaturePool::size() const
+.. ocv:function:: int softcascade::FeaturePool::size() const
 
 
 
-FeaturePool::~FeaturePool
--------------------------
+softcascade::FeaturePool::~FeaturePool
+--------------------------------------
 
 FeaturePool destructor.
 
-.. ocv:function:: int FeaturePool::~FeaturePool()
+.. ocv:function:: softcascade::FeaturePool::~FeaturePool()
 
 
 
-FeaturePool::write
-------------------
+softcascade::FeaturePool::write
+-------------------------------
 
 Write specified feature from feature pool to file storage.
 
-.. ocv:function:: void FeaturePool::write( cv::FileStorage& fs, int index) const
+.. ocv:function:: void softcascade::FeaturePool::write( cv::FileStorage& fs, int index) const
 
     :param fs an output file storage to store feature.
 
     :param index an index of feature that should be stored.
 
 
-FeaturePool::apply
-------------------
+softcascade::FeaturePool::apply
+-------------------------------
 
 Compute feature on integral channel image.
 
-.. ocv:function:: float FeaturePool::apply(int fi, int si, const Mat& channels) const
+.. ocv:function:: float softcascade::FeaturePool::apply(int fi, int si, const Mat& channels) const
 
     :param fi an index of feature that should be computed.