More fixes for documentation.

doc/check_docs2.py

@@ -30,22 +30,31 @@ doc_signatures_whitelist = [
 # templates
 "Matx", "Vec", "SparseMat_", "Scalar_", "Mat_", "Ptr", "Size_", "Point_", "Rect_", "Point3_",
 "DataType", "detail::RotationWarperBase", "flann::Index_", "CalonderDescriptorExtractor",
+"gpu::DevMem2D_", "gpu::PtrStep_", "gpu::PtrElemStep_",
 # black boxes
 "CvArr", "CvFileStorage",
-# the following classes reside in core but documented in gpu. It's no good
+]
-"gpu::DevMem2D_", "gpu::PtrStep_", "gpu::PtrElemStep_",
-# these are even non-template
-"gpu::DeviceInfo", "gpu::GpuMat", "gpu::TargetArchs", "gpu::FeatureSet"]
 
 defines = ["cvGraphEdgeIdx", "cvFree", "CV_Assert", "cvSqrt", "cvGetGraphVtx", "cvGraphVtxIdx",
+"cvCaptureFromFile", "cvCaptureFromCAM", "cvCalcBackProjectPatch", "cvCalcBackProject",
+"cvGetHistValue_1D", "cvGetHistValue_2D", "cvGetHistValue_3D", "cvGetHistValue_nD",
+"cvQueryHistValue_1D", "cvQueryHistValue_2D", "cvQueryHistValue_3D", "cvQueryHistValue_nD",
 # not a real function but behaves as function
-"Mat.size"
+"Mat::size",
+# ugly "virtual" functions from ml module
+"CvStatModel::train", "CvStatModel::predict",
+# TODO:
+"cvExtractSURF"
 ]
 
 synonims = {
     "StarDetector" : ["StarFeatureDetector"],
     "MSER" : ["MserFeatureDetector"],
-    "GFTTDetector" : ["GoodFeaturesToTrackDetector"]
+    "GFTTDetector" : ["GoodFeaturesToTrackDetector"],
+    "cvCaptureFromFile" : ["cvCreateFileCapture"],
+    "cvCaptureFromCAM" : ["cvCreateCameraCapture"],
+    "cvCalcArrBackProjectPatch" : ["cvCalcBackProjectPatch"],
+    "cvCalcArrBackProject" : ["cvCalcBackProject"],
 }
 
 if do_python_crosscheck:
@@ -80,10 +89,9 @@ def compareSignatures(f, s):
     # return type
     stype = (s[1] or "void")
     ftype = f[1]
-    if stype.startswith("cv::"):
+    stype = re.sub(r"\b(cv|std)::", "", stype)
-        stype = stype[4:]
+    if ftype:
-    if ftype and ftype.startswith("cv::"):
+        ftype = re.sub(r"\b(cv|std)::", "", ftype)
-        ftype = ftype[4:]
     if ftype and ftype != stype:
         return False, "return type mismatch"
     if ("\C" in f[2]) ^ ("\C" in s[2]):
@@ -168,6 +176,10 @@ def process_module(module, path):
     hdrlist = glob.glob(os.path.join(path, "include", "opencv2", module, "*.h*"))
     hdrlist.extend(glob.glob(os.path.join(path, "include", "opencv2", module, "detail", "*.h*")))
 
+    if module == "gpu":
+        hdrlist.append(os.path.join(path, "..", "core", "include", "opencv2", "core", "devmem2d.hpp"))
+        hdrlist.append(os.path.join(path, "..", "core", "include", "opencv2", "core", "gpumat.hpp"))
+
     decls = []
     for hname in hdrlist:
         if not "ts_gtest.h" in hname:
@@ -196,8 +208,6 @@ def process_module(module, path):
                         namespaces.append(namespace)
         else:
             funcs.append(decl)
-            # if "RNG" in decl[0]:
-            #     print decl
 
     clsnamespaces = []
     # process classes
@@ -385,21 +395,19 @@ def process_module(module, path):
                             logerror(ERROR_005_MISSINGPYFUNC, "could not load documented member of " + parent + " class: cv2." + pname, doc)
                         else:
                             logerror(ERROR_005_MISSINGPYFUNC, "could not load documented function cv2." + pname, doc)
+                        signature.append(DOCUMENTED_MARKER) # stop subsequent errors
                         continue
                     docstrings = [docprefix + s.replace("([, ", "([") for s in docstr.split("  or  ")]
                     if not signature[1] in docstrings:
                         pydocs = "\npydoc: ".join(docstrings)
                         logerror(ERROR_007_INVALIDPYDOC, "documentation differs from pydoc\npydoc: " + pydocs + "\ncvdoc: " + signature[1], doc)
-                    else:
+                    signature.append(DOCUMENTED_MARKER)
-                        signature.append(DOCUMENTED_MARKER)
 
     # verify C/C++ signatures
     for name, doc in rst.iteritems():
         decls = doc.get("decls")
         if not decls:
             continue
-        # if "RNG" in name:
-        #     print name, decls
         for signature in decls:
             if signature[0] == "C" or signature[0] == "C++":
                 if "template" in (signature[2][1] or ""):
@@ -431,6 +439,7 @@ def process_module(module, path):
                 if signature[-1] != DOCUMENTED_MARKER:
                     candidates = "\n\t".join([formatSignature(f[3]) for f in fd])
                     logerror(ERROR_009_OVERLOADNOTFOUND, signature[0] + " function " + signature[2][0].replace(".","::") + " is documented but misses in headers (" + error + ").\nDocumented as:\n\t" + signature[1] + "\nCandidates are:\n\t" + candidates, doc)
+                    signature.append(DOCUMENTED_MARKER) # to stop subsequent error on this function
 
     # verify that all signatures was found in the library headers
     for name, doc in rst.iteritems():
@@ -443,11 +452,18 @@ def process_module(module, path):
         for d in doc.get("decls", []):
             if d[-1] != DOCUMENTED_MARKER:
                 if d[0] == "C" or d[0] =="C++" or (do_python_crosscheck and d[0].startswith("Python")):
-                    if d[0][0] == 'C' and d[2][0][3:] in defines:
+                    if d[0][0] == 'C':
-                        #TODO: need to find a way to verify #define's
+                        sname = d[2][0][3:].replace(".", "::")
+                        if sname in defines:
+                            #TODO: need to find a way to verify #define's
+                            continue
+                    else:
+                        sname = d[1][:d[1].find("(")]
+                    prefixes = [x for x in doc_signatures_whitelist if sname.startswith(x)]
+                    if prefixes:
+                        # TODO: member of template class
                         continue
-                    logerror(ERROR_011_UNKNOWNFUNC, d[0] + " function is documented but is not found in OpenCV headers. It is documented as:\n\t" + d[1], doc)
+                    logerror(ERROR_011_UNKNOWNFUNC, d[0] + " function " + sname + " is documented but is not found in OpenCV headers. It is documented as:\n\t" + d[1], doc)
-                    #print d[2][0][3:]
     # end of process_module
 
 if __name__ == "__main__":

modules/core/doc/basic_structures.rst

@@ -889,16 +889,6 @@ Provides matrix assignment operators.
 
 These are available assignment operators. Since they all are very different, make sure to read the operator parameters description.
 
-
-Mat::operator MatExpr
--------------------------
-Provides a ``Mat`` -to- ``MatExpr`` cast operator.
-
-.. ocv:function:: Mat::operator MatExpr_<Mat, Mat>() const
-
-The cast operator should not be called explicitly. It is used internally by the
-:ref:`MatrixExpressions` engine.
-
 Mat::row
 ------------
 Creates a matrix header for the specified matrix row.

modules/core/doc/drawing_functions.rst

@@ -473,6 +473,88 @@ Draws several polygonal curves.
 The function ``polylines`` draws one or more polygonal curves.
 
 
+drawContours
+----------------
+Draws contours outlines or filled contours.
+
+.. ocv:function:: void drawContours( InputOutputArray image, InputArrayOfArrays contours,                   int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() )
+
+.. ocv:pyfunction:: cv2.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> None
+
+.. ocv:cfunction:: void cvDrawContours( CvArr * img, CvSeq* contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness=1, int line_type=8, CvPoint offset=cvPoint(0,0) )
+
+.. ocv:pyoldfunction:: cv.DrawContours(img, contour, external_color, hole_color, max_level, thickness=1, lineType=8, offset=(0, 0))-> None
+
+    :param image: Destination image.
+
+    :param contours: All the input contours. Each contour is stored as a point vector.
+
+    :param contourIdx: Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
+
+    :param color: Color of the contours.
+
+    :param thickness: Thickness of lines the contours are drawn with. If it is negative (for example,  ``thickness=CV_FILLED`` ), the contour interiors are
+        drawn.
+
+    :param lineType: Line connectivity. See  :ocv:func:`line`  for details.
+
+    :param hierarchy: Optional information about hierarchy. It is only needed if you want to draw only some of the  contours (see  ``maxLevel`` ).
+
+    :param maxLevel: Maximal level for drawn contours. If it is 0, only
+        the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is  ``hierarchy``  available.
+
+    :param offset: Optional contour shift parameter. Shift all the drawn contours by the specified  :math:`\texttt{offset}=(dx,dy)` .
+
+    :param contour: Pointer to the first contour.
+
+    :param externalColor: Color of external contours.
+
+    :param holeColor: Color of internal contours (holes).
+
+The function draws contour outlines in the image if
+:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if
+:math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: ::
+
+    #include "cv.h"
+    #include "highgui.h"
+
+    using namespace cv;
+
+    int main( int argc, char** argv )
+    {
+        Mat src;
+        // the first command-line parameter must be a filename of the binary
+        // (black-n-white) image
+        if( argc != 2 || !(src=imread(argv[1], 0)).data)
+            return -1;
+
+        Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
+
+        src = src > 1;
+        namedWindow( "Source", 1 );
+        imshow( "Source", src );
+
+        vector<vector<Point> > contours;
+        vector<Vec4i> hierarchy;
+
+        findContours( src, contours, hierarchy,
+            CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
+
+        // iterate through all the top-level contours,
+        // draw each connected component with its own random color
+        int idx = 0;
+        for( ; idx >= 0; idx = hierarchy[idx][0] )
+        {
+            Scalar color( rand()&255, rand()&255, rand()&255 );
+            drawContours( dst, contours, idx, color, CV_FILLED, 8, hierarchy );
+        }
+
+        namedWindow( "Components", 1 );
+        imshow( "Components", dst );
+        waitKey(0);
+    }
+
+
 
 putText
 -----------

modules/core/include/opencv2/core/core.hpp

@@ -2538,6 +2538,13 @@ CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
                             bool isClosed, const Scalar& color,
                             int thickness=1, int lineType=8, int shift=0 );
 
+//! draws contours in the image
+CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
+                              int contourIdx, const Scalar& color,
+                              int thickness=1, int lineType=8,
+                              InputArray hierarchy=noArray(),
+                              int maxLevel=INT_MAX, Point offset=Point() );
+
 //! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
 CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
 

modules/core/src/drawing.cpp

@@ -2069,6 +2069,116 @@ void cv::polylines(InputOutputArray _img, InputArrayOfArrays pts,
     polylines(img, (const Point**)ptsptr, npts, (int)ncontours, isClosed, color, thickness, lineType, shift);
 }
 
+namespace
+{
+using namespace cv;
+
+static void addChildContour(InputArrayOfArrays contours,
+                            size_t ncontours,
+                            const Vec4i* hierarchy,
+                            int i, vector<CvSeq>& seq,
+                            vector<CvSeqBlock>& block)
+{
+    for( ; i >= 0; i = hierarchy[i][0] )
+    {
+        Mat ci = contours.getMat(i);
+        cvMakeSeqHeaderForArray(CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
+                                !ci.empty() ? (void*)ci.data : 0, (int)ci.total(),
+                                &seq[i], &block[i] );
+
+        int h_next = hierarchy[i][0], h_prev = hierarchy[i][1],
+            v_next = hierarchy[i][2], v_prev = hierarchy[i][3];
+        seq[i].h_next = (size_t)h_next < ncontours ? &seq[h_next] : 0;
+        seq[i].h_prev = (size_t)h_prev < ncontours ? &seq[h_prev] : 0;
+        seq[i].v_next = (size_t)v_next < ncontours ? &seq[v_next] : 0;
+        seq[i].v_prev = (size_t)v_prev < ncontours ? &seq[v_prev] : 0;
+
+        if( v_next >= 0 )
+            addChildContour(contours, ncontours, hierarchy, v_next, seq, block);
+    }
+}
+}
+
+void cv::drawContours( InputOutputArray _image, InputArrayOfArrays _contours,
+                   int contourIdx, const Scalar& color, int thickness,
+                   int lineType, InputArray _hierarchy,
+                   int maxLevel, Point offset )
+{
+    Mat image = _image.getMat(), hierarchy = _hierarchy.getMat();
+    CvMat _cimage = image;
+
+    size_t ncontours = _contours.total();
+    size_t i = 0, first = 0, last = ncontours;
+    vector<CvSeq> seq;
+    vector<CvSeqBlock> block;
+
+    if( !last )
+        return;
+
+    seq.resize(last);
+    block.resize(last);
+
+    for( i = first; i < last; i++ )
+        seq[i].first = 0;
+
+    if( contourIdx >= 0 )
+    {
+        CV_Assert( 0 <= contourIdx && contourIdx < (int)last );
+        first = contourIdx;
+        last = contourIdx + 1;
+    }
+
+    for( i = first; i < last; i++ )
+    {
+        Mat ci = _contours.getMat((int)i);
+        if( ci.empty() )
+            continue;
+        int npoints = ci.checkVector(2, CV_32S);
+        CV_Assert( npoints > 0 );
+        cvMakeSeqHeaderForArray( CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
+                                 ci.data, npoints, &seq[i], &block[i] );
+    }
+
+    if( hierarchy.empty() || maxLevel == 0 )
+        for( i = first; i < last; i++ )
+        {
+            seq[i].h_next = i < last-1 ? &seq[i+1] : 0;
+            seq[i].h_prev = i > first ? &seq[i-1] : 0;
+        }
+    else
+    {
+        size_t count = last - first;
+        CV_Assert(hierarchy.total() == ncontours && hierarchy.type() == CV_32SC4 );
+        const Vec4i* h = hierarchy.ptr<Vec4i>();
+
+        if( count == ncontours )
+        {
+            for( i = first; i < last; i++ )
+            {
+                int h_next = h[i][0], h_prev = h[i][1],
+                    v_next = h[i][2], v_prev = h[i][3];
+                seq[i].h_next = (size_t)h_next < count ? &seq[h_next] : 0;
+                seq[i].h_prev = (size_t)h_prev < count ? &seq[h_prev] : 0;
+                seq[i].v_next = (size_t)v_next < count ? &seq[v_next] : 0;
+                seq[i].v_prev = (size_t)v_prev < count ? &seq[v_prev] : 0;
+            }
+        }
+        else
+        {
+            int child = h[first][2];
+            if( child >= 0 )
+            {
+                addChildContour(_contours, ncontours, h, child, seq, block);
+                seq[first].v_next = &seq[child];
+            }
+        }
+    }
+
+    cvDrawContours( &_cimage, &seq[first], color, color, contourIdx >= 0 ?
+                   -maxLevel : maxLevel, thickness, lineType, offset );
+}
+
+
 
 static const int CodeDeltas[8][2] =
 { {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1} };

modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst

@@ -65,25 +65,6 @@ Computes the descriptors for a set of keypoints detected in an image (first vari
 
     :param descriptors: Computed descriptors. In the second variant of the method ``descriptors[i]`` are descriptors computed for a ``keypoints[i]`. Row ``j`` is the ``keypoints`` (or ``keypoints[i]``) is the descriptor for keypoint ``j``-th keypoint.
 
-DescriptorExtractor::read
------------------------------
-Reads the object of a descriptor extractor from a file node.
-
-.. ocv:function:: void DescriptorExtractor::read( const FileNode& fn )
-
-    :param fn: File node from which the detector is read.
-
-
-
-DescriptorExtractor::write
-------------------------------
-Writes the object of a descriptor extractor to a file storage.
-
-.. ocv:function:: void DescriptorExtractor::write( FileStorage& fs ) const
-
-    :param fs: File storage where the detector is written.
-
-
 
 DescriptorExtractor::create
 -------------------------------

modules/features2d/doc/common_interfaces_of_feature_detectors.rst

@@ -112,22 +112,6 @@ Detects keypoints in an image (first variant) or image set (second variant).
 
     :param masks: Masks for each input image specifying where to look for keypoints (optional). ``masks[i]`` is a mask for ``images[i]``.
 
-FeatureDetector::read
--------------------------
-Reads a feature detector object from a file node.
-
-.. ocv:function:: void FeatureDetector::read( const FileNode& fn )
-
-    :param fn: File node from which the detector is read.
-
-FeatureDetector::write
---------------------------
-Writes a feature detector object to a file storage.
-
-.. ocv:function:: void FeatureDetector::write( FileStorage& fs ) const
-
-    :param fs: File storage where the detector is written.
-
 FeatureDetector::create
 ---------------------------
 Creates a feature detector by its name.

modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst

@@ -289,7 +289,7 @@ Enables the :ocv:class:`gpu::StereoConstantSpaceBP` constructors.
 
 .. ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int nr_plane = DEFAULT_NR_PLANE, int msg_type = CV_32F)
 
-.. ocv:function:: StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th = 0, int msg_type = CV_32F)
+.. ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th = 0, int msg_type = CV_32F)
 
     :param ndisp: Number of disparities.
 

modules/gpu/doc/feature_detection_and_description.rst

@@ -346,19 +346,19 @@ Detects keypoints and computes descriptors for them.
 
 
 
-gpu::ORB_GPU::downloadKeypoints
+gpu::ORB_GPU::downloadKeyPoints
 -------------------------------------
 Download keypoints from GPU to CPU memory.
 
-.. ocv:function:: void gpu::ORB_GPU::downloadKeypoints(const GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints)
+.. ocv:function:: void gpu::ORB_GPU::downloadKeyPoints( GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints )
 
 
 
-gpu::ORB_GPU::convertKeypoints
+gpu::ORB_GPU::convertKeyPoints
 -------------------------------------
 Converts keypoints from GPU representation to vector of ``KeyPoint``.
 
-.. ocv:function:: void gpu::ORB_GPU::convertKeypoints(const Mat& h_keypoints, std::vector<KeyPoint>& keypoints)
+.. ocv:function:: void gpu::ORB_GPU::convertKeyPoints( Mat& d_keypoints, std::vector<KeyPoint>& keypoints )
 
 
 

modules/gpu/doc/image_filtering.rst

@@ -195,7 +195,7 @@ Creates a normalized 2D box filter.
 
 .. ocv:function:: Ptr<FilterEngine_GPU> gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1))
 
-.. ocv:function:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1))
+.. ocv:function:: Ptr<BaseFilter_GPU> gpu::getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1))
 
     :param srcType: Input image type supporting ``CV_8UC1`` and ``CV_8UC4`` .
 

modules/gpu/doc/image_processing.rst

@@ -261,7 +261,7 @@ You can use field `user_block_size` to set specific block size for :ocv:func:`gp
 
 gpu::ConvolveBuf::create
 ------------------------
-.. ocv:function:: ConvolveBuf::create(Size image_size, Size templ_size)
+.. ocv:function:: gpu::ConvolveBuf::create(Size image_size, Size templ_size)
 
 Constructs a buffer for :ocv:func:`gpu::convolve` function with respective arguments.
 
@@ -499,7 +499,7 @@ gpu::buildWarpAffineMaps
 ------------------------
 Builds transformation maps for affine transformation.
 
-.. ocv:function:: void buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null())
+.. ocv:function:: void gpu::buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null())
 
     :param M: *2x3*  transformation matrix.
 
@@ -543,7 +543,7 @@ gpu::buildWarpPerspectiveMaps
 -----------------------------
 Builds transformation maps for perspective transformation.
 
-.. ocv:function:: void buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null())
+.. ocv:function:: void gpu::buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null())
 
     :param M: *3x3*  transformation matrix.
 

modules/gpu/doc/initalization_and_information.rst

@@ -47,7 +47,6 @@ Any subsequent API call to this device will reinitialize the device.
 
 gpu::FeatureSet
 ---------------
-.. ocv:class:: gpu::FeatureSet
 
 Class providing GPU computing features. ::
 
@@ -74,7 +73,7 @@ Class providing a set of static methods to check what NVIDIA* card architecture
 
 The following method checks whether the module was built with the support of the given feature:
 
-    .. ocv:function:: static bool gpu::TargetArchs::builtWith(FeatureSet feature)
+    .. ocv:function:: static bool gpu::TargetArchs::builtWith( FeatureSet feature_set )
 
         :param feature: Feature to be checked. See :ocv:class:`gpu::FeatureSet`.
 
@@ -150,7 +149,7 @@ gpu::DeviceInfo::name
 -------------------------
 Returns the device name.
 
-.. ocv:function:: string gpu::DeviceInfo::name()
+.. ocv:function:: string gpu::DeviceInfo::name() const
 
 
 
@@ -198,7 +197,7 @@ gpu::DeviceInfo::supports
 -----------------------------
 Provides information on GPU feature support.
 
-.. ocv:function:: bool gpu::DeviceInfo::supports(FeatureSet feature)
+.. ocv:function:: bool gpu::DeviceInfo::supports( FeatureSet feature_set ) const
 
     :param feature: Feature to be checked. See :ocv:class:`gpu::FeatureSet`.
 

modules/gpu/doc/object_detection.rst

@@ -235,7 +235,7 @@ gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
 -----------------------------------------------------
 Loads the classifier from a file.
 
-.. ocv:function:: gpu::CascadeClassifier_GPU(const string& filename)
+.. ocv:function:: gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const string& filename)
 
     :param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported.
 

modules/gpu/doc/operations_on_matrices.rst

@@ -9,7 +9,7 @@ gpu::gemm
 ------------------
 Performs generalized matrix multiplication.
 
-.. ocv:function:: void gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null())
+.. ocv:function:: void gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null())
 
     :param src1: First multiplied input matrix that should have  ``CV_32FC1`` , ``CV_64FC1`` , ``CV_32FC2`` , or  ``CV_64FC2``  type.
 

modules/gpu/doc/video.rst

@@ -475,7 +475,7 @@ gpu::VideoWriter_GPU::EncoderCallBack::acquireBitStream
 -------------------------------------------------------
 Callback function to signal the start of bitstream that is to be encoded.
 
-.. ocv:function:: virtual unsigned char* gpu::VideoWriter_GPU::EncoderCallBack::acquireBitStream(int* bufferSize) = 0
+.. ocv:function:: virtual uchar* gpu::VideoWriter_GPU::EncoderCallBack::acquireBitStream(int* bufferSize) = 0
 
 Callback must allocate buffer for CUDA encoder and return pointer to it and it's size.
 

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

@@ -1978,7 +1978,7 @@ public:
 
         // callback function to signal the start of bitstream that is to be encoded
         // must return pointer to buffer
-        virtual unsigned char* acquireBitStream(int* bufferSize) = 0;
+        virtual uchar* acquireBitStream(int* bufferSize) = 0;
 
         // callback function to signal that the encoded bitstream is ready to be written to file
         virtual void releaseBitStream(unsigned char* data, int size) = 0;

modules/highgui/doc/qt_new_functions.rst

@@ -226,27 +226,21 @@ The function ``displayOverlay`` displays useful information/tips on top of the w
 *delayms*
 . This information is displayed on the window statusbar (the window must be created with the ``CV_GUI_EXPANDED`` flags).
 
-createOpenGLCallback
+setOpenGlDrawCallback
 ------------------------
-Creates a callback function called to draw OpenGL on top the image display by ``windowname``.
+Sets a callback function to be called to draw on top of displayed image.
 
-.. ocv:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata =NULL, double angle=-1, double zmin=-1, double zmax=-1)
+.. ocv:function:: void setOpenGlDrawCallback( const string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata=0 )
 
-.. ocv:cfunction:: void cvCreateOpenGLCallback( const char* windowName, CvOpenGLCallback callbackOpenGL, void* userdata=NULL, double angle=-1, double zmin=-1, double zmax=-1 )
+.. ocv:cfunction:: void cvSetOpenGlDrawCallback( const char* window_name, CvOpenGlDrawCallback callback, void* userdata=NULL )
 
     :param window_name: Name of the window.
 
-    :param callbackOpenGL: Pointer to the function to be called every frame. This function should be prototyped as  ``void Foo(*void);`` .
+    :param callbackOpenGL: Pointer to the function to be called every frame. This function should be prototyped as  ``void Foo(void*)`` .
 
     :param userdata: Pointer passed to the callback function.  *(Optional)*
 
-    :param angle: Parameter specifying the field of a view angle, in degrees, in the y direction. Default value is 45 degrees. *(Optional)*
+The function ``setOpenGlDrawCallback`` can be used to draw 3D data on the window. See the example of callback function below: ::
-
-    :param zmin: Parameter specifying the distance from the viewer to the near clipping plane (always positive). Default value is 0.01. *(Optional)*
-
-    :param zmax: Parameter specifying the distance from the viewer to the far clipping plane (always positive). Default value is 1000. *(Optional)*
-
-The function ``createOpenGLCallback`` can be used to draw 3D data on the window. See the example of callback use below: ::
 
     void on_opengl(void* param)
     {

modules/imgproc/doc/histograms.rst

@@ -406,44 +406,6 @@ Creates a histogram.
 The function creates a histogram of the specified size and returns a pointer to the created histogram. If the array ``ranges`` is 0, the histogram bin ranges must be specified later via the function  :ocv:cfunc:`SetHistBinRanges`. Though :ocv:cfunc:`CalcHist` and :ocv:cfunc:`CalcBackProject` may process 8-bit images without setting bin ranges, they assume they are equally spaced in 0 to 255 bins.
 
 
-GetHistValue\_?D
-----------------
-Returns a pointer to the histogram bin.
-
-.. ocv:cfunction:: float cvGetHistValue_1D(CvHistogram hist, int idx0)
-
-.. ocv:cfunction:: float cvGetHistValue_2D(CvHistogram hist, int idx0, int idx1)
-
-.. ocv:cfunction:: float cvGetHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
-
-.. ocv:cfunction:: float cvGetHistValue_nD(CvHistogram hist, int idx)
-
-    :param hist: Histogram.
-
-    :param idx0: 0-th index.
-
-    :param idx1: 1-st index.
-
-    :param idx2: 2-nd index.
-
-    :param idx: Array of indices.
-
-::
-
-    #define cvGetHistValue_1D( hist, idx0 )
-        ((float*)(cvPtr1D( (hist)->bins, (idx0), 0 ))
-    #define cvGetHistValue_2D( hist, idx0, idx1 )
-        ((float*)(cvPtr2D( (hist)->bins, (idx0), (idx1), 0 )))
-    #define cvGetHistValue_3D( hist, idx0, idx1, idx2 )
-        ((float*)(cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0 )))
-    #define cvGetHistValue_nD( hist, idx )
-        ((float*)(cvPtrND( (hist)->bins, (idx), 0 )))
-
-..
-
-The macros ``GetHistValue`` return a pointer to the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function creates a new bin and sets it to 0, unless it exists already.
-
-
 GetMinMaxHistValue
 ------------------
 Finds the minimum and maximum histogram bins.
@@ -499,32 +461,6 @@ Normalizes the histogram.
 The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal to  ``factor``.
 
 
-QueryHistValue*D
-----------------
-Queries the value of the histogram bin.
-
-.. ocv:cfunction:: float QueryHistValue_1D(CvHistogram hist, int idx0)
-.. ocv:cfunction:: float QueryHistValue_2D(CvHistogram hist, int idx0, int idx1)
-.. ocv:cfunction:: float QueryHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
-.. ocv:cfunction:: float QueryHistValue_nD(CvHistogram hist, const int* idx)
-
-.. ocv:pyoldfunction:: cv.QueryHistValue_1D(hist, idx0) -> float
-.. ocv:pyoldfunction:: cv.QueryHistValue_2D(hist, idx0, idx1) -> float
-.. ocv:pyoldfunction:: cv.QueryHistValue_3D(hist, idx0, idx1, idx2) -> float
-.. ocv:pyoldfunction:: cv.QueryHistValue_nD(hist, idx) -> float
-
-    :param hist: Histogram.
-
-    :param idx0: 0-th index.
-
-    :param idx1: 1-st index.
-
-    :param idx2: 2-nd index.
-
-    :param idx: Array of indices.
-
-The macros return the value of the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function returns 0. If the bin is not present in the histogram, no new bin is created.
-
 ReleaseHist
 -----------
 Releases the histogram.
@@ -565,27 +501,4 @@ Thresholds the histogram.
 The function clears histogram bins that are below the specified threshold.
 
 
-CalcPGH
--------
-Calculates a pair-wise geometrical histogram for a contour.
-
-.. ocv:cfunction:: void cvCalcPGH( const CvSeq* contour, CvHistogram* hist )
-
-    :param contour: Input contour. Currently, only integer point coordinates are allowed.
-
-    :param hist: Calculated histogram. It must be two-dimensional.
-
-The function calculates a 2D pair-wise geometrical histogram (PGH), described in [Iivarinen97]_ for the contour. The algorithm considers every pair of contour
-edges. The angle between the edges and the minimum/maximum distances
-are determined for every pair. To do this, each of the edges in turn
-is taken as the base, while the function loops through all the other
-edges. When the base edge and any other edge are considered, the minimum
-and maximum distances from the points on the non-base edge and line of
-the base edge are selected. The angle between the edges defines the row
-of the histogram in which all the bins that correspond to the distance
-between the calculated minimum and maximum distances are incremented
-(that is, the histogram is transposed relatively to the definition in the original paper). The histogram can be used for contour matching.
-
 .. [RubnerSept98] Y. Rubner. C. Tomasi, L.J. Guibas. *The Earth Mover’s Distance as a Metric for Image Retrieval*. Technical Report STAN-CS-TN-98-86, Department of Computer Science, Stanford University, September 1998.
-
-.. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. *Comparison of Combined Shape Descriptors for Irregular Objects*, 8th British Machine Vision Conference, BMVC'97. http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html

modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst

@@ -166,87 +166,6 @@ The function retrieves contours from the binary image using the algorithm
 
 .. note:: If you use the new Python interface then the ``CV_`` prefix has to be omitted in contour retrieval mode and contour approximation method parameters (for example, use ``cv2.RETR_LIST`` and ``cv2.CHAIN_APPROX_NONE`` parameters). If you use the old Python interface then these parameters have the ``CV_`` prefix (for example, use ``cv.CV_RETR_LIST`` and ``cv.CV_CHAIN_APPROX_NONE``).
 
-drawContours
-----------------
-Draws contours outlines or filled contours.
-
-.. ocv:function:: void drawContours( InputOutputArray image, InputArrayOfArrays contours,                   int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() )
-
-.. ocv:pyfunction:: cv2.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> None
-
-.. ocv:cfunction:: void cvDrawContours( CvArr *img, CvSeq* contour, CvScalar externalColor, CvScalar holeColor, int maxLevel, int thickness=1, int lineType=8 )
-.. ocv:pyoldfunction:: cv.DrawContours(img, contour, external_color, hole_color, max_level, thickness=1, lineType=8, offset=(0, 0))-> None
-
-    :param image: Destination image.
-
-    :param contours: All the input contours. Each contour is stored as a point vector.
-
-    :param contourIdx: Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
-
-    :param color: Color of the contours.
-
-    :param thickness: Thickness of lines the contours are drawn with. If it is negative (for example,  ``thickness=CV_FILLED`` ), the contour interiors are
-        drawn.
-
-    :param lineType: Line connectivity. See  :ocv:func:`line`  for details.
-
-    :param hierarchy: Optional information about hierarchy. It is only needed if you want to draw only some of the  contours (see  ``maxLevel`` ).
-
-    :param maxLevel: Maximal level for drawn contours. If it is 0, only
-        the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is  ``hierarchy``  available.
-
-    :param offset: Optional contour shift parameter. Shift all the drawn contours by the specified  :math:`\texttt{offset}=(dx,dy)` .
-
-    :param contour: Pointer to the first contour.
-
-    :param externalColor: Color of external contours.
-
-    :param holeColor: Color of internal contours (holes).
-
-The function draws contour outlines in the image if
-:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if
-:math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: ::
-
-    #include "cv.h"
-    #include "highgui.h"
-
-    using namespace cv;
-
-    int main( int argc, char** argv )
-    {
-        Mat src;
-        // the first command-line parameter must be a filename of the binary
-        // (black-n-white) image
-        if( argc != 2 || !(src=imread(argv[1], 0)).data)
-            return -1;
-
-        Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
-
-        src = src > 1;
-        namedWindow( "Source", 1 );
-        imshow( "Source", src );
-
-        vector<vector<Point> > contours;
-        vector<Vec4i> hierarchy;
-
-        findContours( src, contours, hierarchy,
-            CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
-
-        // iterate through all the top-level contours,
-        // draw each connected component with its own random color
-        int idx = 0;
-        for( ; idx >= 0; idx = hierarchy[idx][0] )
-        {
-            Scalar color( rand()&255, rand()&255, rand()&255 );
-            drawContours( dst, contours, idx, color, CV_FILLED, 8, hierarchy );
-        }
-
-        namedWindow( "Components", 1 );
-        imshow( "Components", dst );
-        waitKey(0);
-    }
-
-
 
 approxPolyDP
 ----------------

modules/imgproc/include/opencv2/imgproc/imgproc.hpp

@@ -1078,13 +1078,6 @@ CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays cont
 CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours,
                               int mode, int method, Point offset=Point());
 
-//! draws contours in the image
-CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
-                              int contourIdx, const Scalar& color,
-                              int thickness=1, int lineType=8,
-                              InputArray hierarchy=noArray(),
-                              int maxLevel=INT_MAX, Point offset=Point() );
-
 //! approximates contour or a curve using Douglas-Peucker algorithm
 CV_EXPORTS_W void approxPolyDP( InputArray curve,
                                 OutputArray approxCurve,

modules/imgproc/src/contours.cpp

@@ -1753,116 +1753,6 @@ void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours,
     findContours(_image, _contours, noArray(), mode, method, offset);
 }
 
-namespace cv
-{
-
-static void addChildContour(InputArrayOfArrays contours,
-                            size_t ncontours,
-                            const Vec4i* hierarchy,
-                            int i, vector<CvSeq>& seq,
-                            vector<CvSeqBlock>& block)
-{
-    for( ; i >= 0; i = hierarchy[i][0] )
-    {
-        Mat ci = contours.getMat(i);
-        cvMakeSeqHeaderForArray(CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
-                                !ci.empty() ? (void*)ci.data : 0, (int)ci.total(),
-                                &seq[i], &block[i] );
-        
-        int h_next = hierarchy[i][0], h_prev = hierarchy[i][1],
-            v_next = hierarchy[i][2], v_prev = hierarchy[i][3];
-        seq[i].h_next = (size_t)h_next < ncontours ? &seq[h_next] : 0;
-        seq[i].h_prev = (size_t)h_prev < ncontours ? &seq[h_prev] : 0;
-        seq[i].v_next = (size_t)v_next < ncontours ? &seq[v_next] : 0;
-        seq[i].v_prev = (size_t)v_prev < ncontours ? &seq[v_prev] : 0;
-        
-        if( v_next >= 0 )
-            addChildContour(contours, ncontours, hierarchy, v_next, seq, block);
-    }
-}
-    
-}
-
-void cv::drawContours( InputOutputArray _image, InputArrayOfArrays _contours,
-                   int contourIdx, const Scalar& color, int thickness,
-                   int lineType, InputArray _hierarchy,
-                   int maxLevel, Point offset )
-{
-    Mat image = _image.getMat(), hierarchy = _hierarchy.getMat();
-    CvMat _cimage = image;
-
-    size_t ncontours = _contours.total();
-    size_t i = 0, first = 0, last = ncontours;
-    vector<CvSeq> seq;
-    vector<CvSeqBlock> block;
-
-    if( !last )
-        return;
-    
-    seq.resize(last);
-    block.resize(last);
-    
-    for( i = first; i < last; i++ )
-        seq[i].first = 0;
-                              
-    if( contourIdx >= 0 )
-    {
-        CV_Assert( 0 <= contourIdx && contourIdx < (int)last );
-        first = contourIdx;
-        last = contourIdx + 1;
-    }
-    
-    for( i = first; i < last; i++ )
-    {
-        Mat ci = _contours.getMat((int)i);
-        if( ci.empty() )
-            continue;
-        int npoints = ci.checkVector(2, CV_32S);
-        CV_Assert( npoints > 0 );
-        cvMakeSeqHeaderForArray( CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
-                                 ci.data, npoints, &seq[i], &block[i] );
-    }
-
-    if( hierarchy.empty() || maxLevel == 0 )
-        for( i = first; i < last; i++ )
-        {
-            seq[i].h_next = i < last-1 ? &seq[i+1] : 0;
-            seq[i].h_prev = i > first ? &seq[i-1] : 0;
-        }
-    else
-    {
-        size_t count = last - first;
-        CV_Assert(hierarchy.total() == ncontours && hierarchy.type() == CV_32SC4 );
-        const Vec4i* h = hierarchy.ptr<Vec4i>();
-        
-        if( count == ncontours )
-        {
-            for( i = first; i < last; i++ )
-            {
-                int h_next = h[i][0], h_prev = h[i][1],
-                    v_next = h[i][2], v_prev = h[i][3];
-                seq[i].h_next = (size_t)h_next < count ? &seq[h_next] : 0;
-                seq[i].h_prev = (size_t)h_prev < count ? &seq[h_prev] : 0;
-                seq[i].v_next = (size_t)v_next < count ? &seq[v_next] : 0;
-                seq[i].v_prev = (size_t)v_prev < count ? &seq[v_prev] : 0;
-            }
-        }
-        else
-        {
-            int child = h[first][2];
-            if( child >= 0 )
-            {
-                addChildContour(_contours, ncontours, h, child, seq, block);
-                seq[first].v_next = &seq[child];
-            }
-        }
-    }
-
-    cvDrawContours( &_cimage, &seq[first], color, color, contourIdx >= 0 ?
-                   -maxLevel : maxLevel, thickness, lineType, offset );
-}
-
-
 void cv::approxPolyDP( InputArray _curve, OutputArray _approxCurve,
                        double epsilon, bool closed )
 {

modules/legacy/doc/expectation_maximization.rst

@@ -75,8 +75,6 @@ Estimates the Gaussian mixture parameters from a sample set.
 
 .. ocv:function:: bool CvEM::train( const CvMat* samples, const CvMat* sampleIdx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 )
 
-.. ocv:pyfunction:: cv2.EM.train(samples[, sampleIdx[, params]]) -> retval, labels
-
     :param samples: Samples from which the Gaussian mixture model will be estimated.
 
     :param sample_idx: Mask of samples to use. All samples are used by default.
@@ -107,8 +105,6 @@ Returns a mixture component index of a sample.
 
 .. ocv:function:: float CvEM::predict( const CvMat* sample, CvMat* probs ) const
 
-.. ocv:pyfunction:: cv2.EM.predict(sample) -> retval, probs
-
     :param sample: A sample for classification.
 
     :param probs: If it is not null then the method will write posterior probabilities of each component given the sample data to this parameter.
@@ -122,8 +118,6 @@ Returns the number of mixture components :math:`M` in the Gaussian mixture model
 
 .. ocv:function:: int CvEM::get_nclusters() const
 
-.. ocv:pyfunction:: cv2.EM.getNClusters() -> retval
-
 
 CvEM::getMeans
 ------------------
@@ -133,8 +127,6 @@ Returns mixture means :math:`a_k`.
 
 .. ocv:function:: const CvMat* CvEM::get_means() const
 
-.. ocv:pyfunction:: cv2.EM.getMeans() -> means
-
 
 CvEM::getCovs
 -------------
@@ -144,8 +136,6 @@ Returns mixture covariance matrices :math:`S_k`.
 
 .. ocv:function:: const CvMat** CvEM::get_covs() const
 
-.. ocv:pyfunction:: cv2.EM.getCovs([covs]) -> covs
-
 
 CvEM::getWeights
 ----------------
@@ -155,8 +145,6 @@ Returns mixture weights :math:`\pi_k`.
 
 .. ocv:function:: const CvMat* CvEM::get_weights() const
 
-.. ocv:pyfunction:: cv2.EM.getWeights() -> weights
-
 
 CvEM::getProbs
 --------------
@@ -166,8 +154,6 @@ Returns vectors of probabilities for each training sample.
 
 .. ocv:function:: const CvMat* CvEM::get_probs() const
 
-.. ocv:pyfunction:: cv2.EM.getProbs() -> probs
-
 For each training sample :math:`i` (that have been passed to the constructor or to :ocv:func:`CvEM::train`) returns probabilities :math:`p_{i,k}` to belong to a mixture component :math:`k`.
 
 
@@ -179,8 +165,6 @@ Returns logarithm of likelihood.
 
 .. ocv:function:: double CvEM::get_log_likelihood() const
 
-.. ocv:pyfunction:: cv2.EM.getLikelihood() -> likelihood
-
 
 CvEM::write
 -----------

modules/legacy/doc/feature_detection_and_description.rst

@@ -81,9 +81,9 @@ RandomizedTree::train
 -------------------------
 Trains a randomized tree using an input set of keypoints.
 
-.. ocv:function:: void train(std::vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits)
+.. ocv:function:: void RandomizedTree::train( vector<BaseKeypoint> const& base_set, RNG & rng, int depth, int views, size_t reduced_num_dim, int num_quant_bits )
 
-.. ocv:function:: void train(std::vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits)
+.. ocv:function:: void RandomizedTree::train( vector<BaseKeypoint> const& base_set, RNG & rng, PatchGenerator & make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits )
 
     :param base_set: Vector of the ``BaseKeypoint`` type. It contains image keypoints used for training.
 
@@ -105,9 +105,9 @@ RandomizedTree::read
 ------------------------
 Reads a pre-saved randomized tree from a file or stream.
 
-.. ocv:function:: read(const char* file_name, int num_quant_bits)
+.. ocv:function:: RandomizedTree::read(const char* file_name, int num_quant_bits)
 
-.. ocv:function:: read(std::istream &is, int num_quant_bits)
+.. ocv:function:: RandomizedTree::read(std::istream &is, int num_quant_bits)
 
     :param file_name: Name of the file that contains randomized tree data.
 
@@ -121,9 +121,9 @@ RandomizedTree::write
 -------------------------
 Writes the current randomized tree to a file or stream.
 
-.. ocv:function:: void write(const char* file_name) const
+.. ocv:function:: void RandomizedTree::write(const char* file_name) const
 
-.. ocv:function:: void write(std::ostream &os) const
+.. ocv:function:: void RandomizedTree::write(std::ostream &os) const
 
     :param file_name: Name of the file where randomized tree data is stored.
 
@@ -133,7 +133,7 @@ Writes the current randomized tree to a file or stream.
 
 RandomizedTree::applyQuantization
 -------------------------------------
-.. ocv:function:: void applyQuantization(int num_quant_bits)
+.. ocv:function:: void RandomizedTree::applyQuantization(int num_quant_bits)
 
     Applies quantization to the current randomized tree.
 
@@ -240,9 +240,9 @@ RTreeClassifier::train
 --------------------------
 Trains a randomized tree classifier using an input set of keypoints.
 
-.. ocv:function:: void train(vector<BaseKeypoint> const& base_set, RNG& rng, int num_trees = RTreeClassifier::DEFAULT_TREES,                         int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true)
+.. ocv:function:: void RTreeClassifier::train( vector<BaseKeypoint> const& base_set, RNG & rng, int num_trees=RTreeClassifier::DEFAULT_TREES, int depth=RandomizedTree::DEFAULT_DEPTH, int views=RandomizedTree::DEFAULT_VIEWS, size_t reduced_num_dim=RandomizedTree::DEFAULT_REDUCED_NUM_DIM, int num_quant_bits=DEFAULT_NUM_QUANT_BITS )
 
-.. ocv:function:: void train(vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM,                         int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true)
+.. ocv:function:: void RTreeClassifier::train( vector<BaseKeypoint> const& base_set, RNG & rng, PatchGenerator & make_patch, int num_trees=RTreeClassifier::DEFAULT_TREES, int depth=RandomizedTree::DEFAULT_DEPTH, int views=RandomizedTree::DEFAULT_VIEWS, size_t reduced_num_dim=RandomizedTree::DEFAULT_REDUCED_NUM_DIM, int num_quant_bits=DEFAULT_NUM_QUANT_BITS )
 
     :param base_set: Vector of the ``BaseKeypoint``  type. It contains image keypoints used for training.
 
@@ -268,9 +268,9 @@ RTreeClassifier::getSignature
 ---------------------------------
 Returns a signature for an image patch.
 
-.. ocv:function:: void getSignature(IplImage *patch, uchar *sig)
+.. ocv:function:: void RTreeClassifier::getSignature(IplImage *patch, uchar *sig)
 
-.. ocv:function:: void getSignature(IplImage *patch, float *sig)
+.. ocv:function:: void RTreeClassifier::getSignature(IplImage *patch, float *sig)
 
     :param patch: Image patch to calculate the signature for.
     :param sig: Output signature (array dimension is ``reduced_num_dim)`` .
@@ -281,7 +281,7 @@ RTreeClassifier::getSparseSignature
 ---------------------------------------
 Returns a sparse signature for an image patch
 
-.. ocv:function:: void getSparseSignature(IplImage *patch, float *sig, float thresh)
+.. ocv:function:: void RTreeClassifier::getSparseSignature(IplImage *patch, float *sig, float thresh)
 
     :param patch: Image patch to calculate the signature for.
 
@@ -296,7 +296,7 @@ RTreeClassifier::countNonZeroElements
 -----------------------------------------
 Returns the number of non-zero elements in an input array.
 
-.. ocv:function:: static int countNonZeroElements(float *vec, int n, double tol=1e-10)
+.. ocv:function:: static int RTreeClassifier::countNonZeroElements(float *vec, int n, double tol=1e-10)
 
     :param vec: Input vector containing float elements.
 
@@ -310,9 +310,9 @@ RTreeClassifier::read
 -------------------------
 Reads a pre-saved ``RTreeClassifier`` from a file or stream.
 
-.. ocv:function:: read(const char* file_name)
+.. ocv:function:: void RTreeClassifier::read(const char* file_name)
 
-.. ocv:function:: read(std::istream& is)
+.. ocv:function:: void RTreeClassifier::read( std::istream & is )
 
     :param file_name: Name of the file that contains randomized tree data.
 
@@ -324,9 +324,9 @@ RTreeClassifier::write
 --------------------------
 Writes the current ``RTreeClassifier`` to a file or stream.
 
-.. ocv:function:: void write(const char* file_name) const
+.. ocv:function:: void RTreeClassifier::write(const char* file_name) const
 
-.. ocv:function:: void write(std::ostream &os) const
+.. ocv:function:: void RTreeClassifier::write(std::ostream &os) const
 
     :param file_name: Name of the file where randomized tree data is stored.
 
@@ -338,7 +338,7 @@ RTreeClassifier::setQuantization
 ------------------------------------
 Applies quantization to the current randomized tree.
 
-.. ocv:function:: void setQuantization(int num_quant_bits)
+.. ocv:function:: void RTreeClassifier::setQuantization(int num_quant_bits)
 
     :param num_quant_bits: Number of bits used for quantization.
 

modules/legacy/doc/histograms.rst

@@ -0,0 +1,95 @@
+Histograms
+==========
+
+.. highlight:: cpp
+
+
+
+CalcPGH
+-------
+Calculates a pair-wise geometrical histogram for a contour.
+
+.. ocv:cfunction:: void cvCalcPGH( const CvSeq* contour, CvHistogram* hist )
+
+    :param contour: Input contour. Currently, only integer point coordinates are allowed.
+
+    :param hist: Calculated histogram. It must be two-dimensional.
+
+The function calculates a 2D pair-wise geometrical histogram (PGH), described in [Iivarinen97]_ for the contour. The algorithm considers every pair of contour
+edges. The angle between the edges and the minimum/maximum distances
+are determined for every pair. To do this, each of the edges in turn
+is taken as the base, while the function loops through all the other
+edges. When the base edge and any other edge are considered, the minimum
+and maximum distances from the points on the non-base edge and line of
+the base edge are selected. The angle between the edges defines the row
+of the histogram in which all the bins that correspond to the distance
+between the calculated minimum and maximum distances are incremented
+(that is, the histogram is transposed relatively to the definition in the original paper). The histogram can be used for contour matching.
+
+
+.. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. *Comparison of Combined Shape Descriptors for Irregular Objects*, 8th British Machine Vision Conference, BMVC'97. http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html
+
+
+QueryHistValue*D
+----------------
+Queries the value of the histogram bin.
+
+.. ocv:cfunction:: float cvQueryHistValue_1D(CvHistogram hist, int idx0)
+.. ocv:cfunction:: float cvQueryHistValue_2D(CvHistogram hist, int idx0, int idx1)
+.. ocv:cfunction:: float cvQueryHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
+.. ocv:cfunction:: float cvQueryHistValue_nD(CvHistogram hist, const int* idx)
+
+.. ocv:pyoldfunction:: cv.QueryHistValue_1D(hist, idx0) -> float
+.. ocv:pyoldfunction:: cv.QueryHistValue_2D(hist, idx0, idx1) -> float
+.. ocv:pyoldfunction:: cv.QueryHistValue_3D(hist, idx0, idx1, idx2) -> float
+.. ocv:pyoldfunction:: cv.QueryHistValue_nD(hist, idx) -> float
+
+    :param hist: Histogram.
+
+    :param idx0: 0-th index.
+
+    :param idx1: 1-st index.
+
+    :param idx2: 2-nd index.
+
+    :param idx: Array of indices.
+
+The macros return the value of the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function returns 0. If the bin is not present in the histogram, no new bin is created.
+
+GetHistValue\_?D
+----------------
+Returns a pointer to the histogram bin.
+
+.. ocv:cfunction:: float cvGetHistValue_1D(CvHistogram hist, int idx0)
+
+.. ocv:cfunction:: float cvGetHistValue_2D(CvHistogram hist, int idx0, int idx1)
+
+.. ocv:cfunction:: float cvGetHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
+
+.. ocv:cfunction:: float cvGetHistValue_nD(CvHistogram hist, int idx)
+
+    :param hist: Histogram.
+
+    :param idx0: 0-th index.
+
+    :param idx1: 1-st index.
+
+    :param idx2: 2-nd index.
+
+    :param idx: Array of indices.
+
+::
+
+    #define cvGetHistValue_1D( hist, idx0 )
+        ((float*)(cvPtr1D( (hist)->bins, (idx0), 0 ))
+    #define cvGetHistValue_2D( hist, idx0, idx1 )
+        ((float*)(cvPtr2D( (hist)->bins, (idx0), (idx1), 0 )))
+    #define cvGetHistValue_3D( hist, idx0, idx1, idx2 )
+        ((float*)(cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0 )))
+    #define cvGetHistValue_nD( hist, idx )
+        ((float*)(cvPtrND( (hist)->bins, (idx), 0 )))
+
+..
+
+The macros ``GetHistValue`` return a pointer to the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function creates a new bin and sets it to 0, unless it exists already.
+

modules/legacy/doc/legacy.rst

@@ -9,6 +9,7 @@ legacy. Deprecated stuff
 
     motion_analysis
     expectation_maximization
+	histograms
     planar_subdivisions
     feature_detection_and_description
     common_interfaces_of_descriptor_extractors

modules/legacy/doc/planar_subdivisions.rst

@@ -145,7 +145,7 @@ CreateSubdivDelaunay2D
 Creates an empty Delaunay triangulation.
 
 .. ocv:cfunction:: CvSubdiv2D* cvCreateSubdivDelaunay2D(  CvRect rect, CvMemStorage* storage )
-.. ocv:pyoldfunction:: cv.CreateSubdivDelaunay2D(rect, storage)-> emptyDelaunayTriangulation
+.. ocv:pyoldfunction:: cv.CreateSubdivDelaunay2D(rect, storage) -> CvSubdiv2D
 
     :param rect: Rectangle that includes all of the 2D points that are to be added to the subdivision.
 

modules/ml/doc/expectation_maximization.rst

@@ -173,7 +173,7 @@ EM::predict
 -----------
 Returns a likelihood logarithm value and an index of the most probable mixture component for the given sample.
 
-.. ocv:function:: Vec2d predict(InputArray sample, OutputArray probs=noArray()) const
+.. ocv:function:: Vec2d EM::predict(InputArray sample, OutputArray probs=noArray()) const
 
 .. ocv:pyfunction:: cv2.EM.predict(sample[, probs]) -> retval, probs
 

modules/objdetect/doc/cascade_classification.rst

@@ -239,7 +239,7 @@ CascadeClassifier::runAt
 ----------------------------
 Runs the detector at the specified point.
 
-.. ocv:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& feval, Point pt )
+.. ocv:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& feval, Point pt, double& weight )
 
 .. ocv:cfunction:: int cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade, CvPoint pt, int start_stage=0 )
 

modules/objdetect/doc/latent_svm.rst

@@ -256,7 +256,7 @@ LatentSvmDetector::getClassCount
 --------------------------------
 Return a count of loaded models (classes).
 
-.. ocv:function:: size_t getClassCount() const
+.. ocv:function:: size_t LatentSvmDetector::getClassCount() const
 
 
 .. [Felzenszwalb2010] Felzenszwalb, P. F. and Girshick, R. B. and McAllester, D. and Ramanan, D. *Object Detection with Discriminatively Trained Part Based Models*. PAMI, vol. 32, no. 9, pp. 1627-1645, September 2010

modules/objdetect/include/opencv2/objdetect/objdetect.hpp

@@ -425,8 +425,8 @@ protected:
     template<class FEval>
     friend int predictCategoricalStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight);
 
-    bool setImage( Ptr<FeatureEvaluator>&, const Mat& );
+    bool setImage( Ptr<FeatureEvaluator>& feval, const Mat& image);
-    virtual int runAt( Ptr<FeatureEvaluator>&, Point, double& weight );
+    virtual int runAt( Ptr<FeatureEvaluator>& feval, Point pt, double& weight );
 
     class Data
     {

modules/python/src2/hdr_parser.py

@@ -281,7 +281,7 @@ class CppHeaderParser(object):
 
         apos = fdecl.find("(")
         if fname.endswith("operator"):
-            fname += "()"
+            fname += " ()"
             apos = fdecl.find("(", apos+1)
 
         fname = "cv." + fname.replace("::", ".")
@@ -600,7 +600,7 @@ class CppHeaderParser(object):
                     break
                 w = stmt[:colon_pos].strip()
                 if w in ["public", "protected", "private"]:
-                    if w == "public":
+                    if w == "public" or (not self.wrap_mode and w == "protected"):
                         stack_top[self.PUBLIC_SECTION] = True
                     else:
                         stack_top[self.PUBLIC_SECTION] = False

modules/stitching/doc/autocalib.rst

@@ -7,7 +7,7 @@ detail::focalsFromHomography
 ----------------------------
 Tries to estimate focal lengths from the given homography under the assumption that the camera undergoes rotations around its centre only.
 
-.. ocv:function:: void focalsFromHomography(const Mat &H, double &f0, double &f1, bool &f0_ok, bool &f1_ok)
+.. ocv:function:: void detail::focalsFromHomography(const Mat &H, double &f0, double &f1, bool &f0_ok, bool &f1_ok)
 
     :param H: Homography.
 
@@ -23,7 +23,7 @@ detail::estimateFocal
 ---------------------
 Estimates focal lengths for each given camera.
 
-.. ocv:function:: void estimateFocal(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, std::vector<double> &focals)
+.. ocv:function:: void detail::estimateFocal(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, std::vector<double> &focals)
 
     :param features: Features of images.
 

modules/stitching/doc/matching.rst

@@ -64,7 +64,7 @@ detail::FeaturesFinder::find
 
 This method must implement features finding logic in order to make the wrappers `detail::FeaturesFinder::operator()`_ work.
 
-.. ocv:function:: void find(const Mat &image, ImageFeatures &features)
+.. ocv:function:: void detail::FeaturesFinder::find(const Mat &image, ImageFeatures &features)
 
     :param image: Source image
 
@@ -171,7 +171,7 @@ Performs images matching.
 
     :param matches_info: Found matches
 
-.. ocv:function:: void detail::FeaturesMatcher::operator ()(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches, const Mat &mask)
+.. ocv:function:: void detail::FeaturesMatcher::operator ()( const std::vector<ImageFeatures> & features, std::vector<MatchesInfo> & pairwise_matches, const Mat & mask=Mat() )
 
     :param features: Features of the source images
 

modules/stitching/doc/motion_estimation.rst

@@ -234,7 +234,7 @@ detail::waveCorrect
 -------------------
 Tries to make panorama more horizontal (or vertical).
 
-.. ocv:function:: void waveCorrect(std::vector<Mat> &rmats, WaveCorrectKind kind)
+.. ocv:function:: void detail::waveCorrect(std::vector<Mat> &rmats, WaveCorrectKind kind)
 
     :param rmats: Camera rotation matrices.
 

modules/stitching/doc/warpers.rst

@@ -66,7 +66,7 @@ detail::RotationWarper::warp
 
 Projects the image.
 
-.. ocv:function:: Point detal::RotationWarper::warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode, Mat &dst)
+.. ocv:function:: Point detail::RotationWarper::warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode, Mat &dst)
 
     :param src: Source image