renamed gpuimgproc -> cudaimgproc

modules/cudaimgproc/doc/color.rst

@@ -0,0 +1,131 @@
+Color space processing
+======================
+
+.. highlight:: cpp
+
+
+
+gpu::cvtColor
+-------------
+Converts an image from one color space to another.
+
+.. ocv:function:: void gpu::cvtColor(InputArray src, OutputArray dst, int code, int dcn = 0, Stream& stream = Stream::Null())
+
+    :param src: Source image with  ``CV_8U`` , ``CV_16U`` , or  ``CV_32F`` depth and 1, 3, or 4 channels.
+
+    :param dst: Destination image.
+
+    :param code: Color space conversion code. For details, see  :ocv:func:`cvtColor` .
+
+    :param dcn: Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from  ``src`` and the  ``code`` .
+
+    :param stream: Stream for the asynchronous version.
+
+3-channel color spaces (like ``HSV``, ``XYZ``, and so on) can be stored in a 4-channel image for better performance.
+
+.. seealso:: :ocv:func:`cvtColor`
+
+
+
+gpu::demosaicing
+----------------
+Converts an image from Bayer pattern to RGB or grayscale.
+
+.. ocv:function:: void gpu::demosaicing(InputArray src, OutputArray dst, int code, int dcn = -1, Stream& stream = Stream::Null())
+
+    :param src: Source image (8-bit or 16-bit single channel).
+
+    :param dst: Destination image.
+
+    :param code: Color space conversion code (see the description below).
+
+    :param dcn: Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from  ``src`` and the  ``code`` .
+
+    :param stream: Stream for the asynchronous version.
+
+The function can do the following transformations:
+
+* Demosaicing using bilinear interpolation
+
+    * ``COLOR_BayerBG2GRAY`` , ``COLOR_BayerGB2GRAY`` , ``COLOR_BayerRG2GRAY`` , ``COLOR_BayerGR2GRAY``
+
+    * ``COLOR_BayerBG2BGR`` , ``COLOR_BayerGB2BGR`` , ``COLOR_BayerRG2BGR`` , ``COLOR_BayerGR2BGR``
+
+* Demosaicing using Malvar-He-Cutler algorithm ([MHT2011]_)
+
+    * ``COLOR_BayerBG2GRAY_MHT`` , ``COLOR_BayerGB2GRAY_MHT`` , ``COLOR_BayerRG2GRAY_MHT`` , ``COLOR_BayerGR2GRAY_MHT``
+
+    * ``COLOR_BayerBG2BGR_MHT`` , ``COLOR_BayerGB2BGR_MHT`` , ``COLOR_BayerRG2BGR_MHT`` , ``COLOR_BayerGR2BGR_MHT``
+
+.. seealso:: :ocv:func:`cvtColor`
+
+
+
+gpu::swapChannels
+-----------------
+Exchanges the color channels of an image in-place.
+
+.. ocv:function:: void gpu::swapChannels(InputOutputArray image, const int dstOrder[4], Stream& stream = Stream::Null())
+
+    :param image: Source image. Supports only ``CV_8UC4`` type.
+
+    :param dstOrder: Integer array describing how channel values are permutated. The n-th entry of the array contains the number of the channel that is stored in the n-th channel of the output image. E.g. Given an RGBA image, aDstOrder = [3,2,1,0] converts this to ABGR channel order.
+
+    :param stream: Stream for the asynchronous version.
+
+The methods support arbitrary permutations of the original channels, including replication.
+
+
+
+gpu::gammaCorrection
+--------------------
+Routines for correcting image color gamma.
+
+.. ocv:function:: void gpu::gammaCorrection(InputArray src, OutputArray dst, bool forward = true, Stream& stream = Stream::Null())
+
+    :param src: Source image (3- or 4-channel 8 bit).
+
+    :param dst: Destination image.
+
+    :param forward: ``true`` for forward gamma correction or ``false`` for inverse gamma correction.
+
+    :param stream: Stream for the asynchronous version.
+
+
+
+gpu::alphaComp
+--------------
+Composites two images using alpha opacity values contained in each image.
+
+.. ocv:function:: void gpu::alphaComp(InputArray img1, InputArray img2, OutputArray dst, int alpha_op, Stream& stream = Stream::Null())
+
+    :param img1: First image. Supports ``CV_8UC4`` , ``CV_16UC4`` , ``CV_32SC4`` and ``CV_32FC4`` types.
+
+    :param img2: Second image. Must have the same size and the same type as ``img1`` .
+
+    :param dst: Destination image.
+
+    :param alpha_op: Flag specifying the alpha-blending operation:
+
+            * **ALPHA_OVER**
+            * **ALPHA_IN**
+            * **ALPHA_OUT**
+            * **ALPHA_ATOP**
+            * **ALPHA_XOR**
+            * **ALPHA_PLUS**
+            * **ALPHA_OVER_PREMUL**
+            * **ALPHA_IN_PREMUL**
+            * **ALPHA_OUT_PREMUL**
+            * **ALPHA_ATOP_PREMUL**
+            * **ALPHA_XOR_PREMUL**
+            * **ALPHA_PLUS_PREMUL**
+            * **ALPHA_PREMUL**
+
+    :param stream: Stream for the asynchronous version.
+
+.. note::
+
+   * An example demonstrating the use of alphaComp can be found at opencv_source_code/samples/gpu/alpha_comp.cpp
+
+
+.. [MHT2011] Pascal Getreuer, Malvar-He-Cutler Linear Image Demosaicking, Image Processing On Line, 2011

modules/cudaimgproc/doc/cudaimgproc.rst

@@ -0,0 +1,12 @@
+********************************************
+gpuimgproc. GPU-accelerated Image Processing
+********************************************
+
+.. toctree::
+    :maxdepth: 1
+
+    color
+    histogram
+    hough
+    feature_detection
+    imgproc

modules/cudaimgproc/doc/feature_detection.rst

@@ -0,0 +1,122 @@
+Feature Detection
+=================
+
+.. highlight:: cpp
+
+
+
+gpu::CornernessCriteria
+-----------------------
+.. ocv:class:: gpu::CornernessCriteria : public Algorithm
+
+Base class for Cornerness Criteria computation. ::
+
+    class CV_EXPORTS CornernessCriteria : public Algorithm
+    {
+    public:
+        virtual void compute(InputArray src, OutputArray dst, Stream& stream = Stream::Null()) = 0;
+    };
+
+
+
+gpu::CornernessCriteria::compute
+--------------------------------
+Computes the cornerness criteria at each image pixel.
+
+.. ocv:function:: void gpu::CornernessCriteria::compute(InputArray src, OutputArray dst, Stream& stream = Stream::Null())
+
+    :param src: Source image.
+
+    :param dst: Destination image containing cornerness values. It will have the same size as ``src`` and ``CV_32FC1`` type.
+
+    :param stream: Stream for the asynchronous version.
+
+
+
+gpu::createHarrisCorner
+-----------------------
+Creates implementation for Harris cornerness criteria.
+
+.. ocv:function:: Ptr<CornernessCriteria> gpu::createHarrisCorner(int srcType, int blockSize, int ksize, double k, int borderType = BORDER_REFLECT101)
+
+    :param srcType: Input source type. Only  ``CV_8UC1`` and  ``CV_32FC1`` are supported for now.
+
+    :param blockSize: Neighborhood size.
+
+    :param ksize: Aperture parameter for the Sobel operator.
+
+    :param k: Harris detector free parameter.
+
+    :param borderType: Pixel extrapolation method. Only  ``BORDER_REFLECT101`` and  ``BORDER_REPLICATE`` are supported for now.
+
+.. seealso:: :ocv:func:`cornerHarris`
+
+
+
+gpu::createMinEigenValCorner
+----------------------------
+Creates implementation for the minimum eigen value of a 2x2 derivative covariation matrix (the cornerness criteria).
+
+.. ocv:function:: Ptr<CornernessCriteria> gpu::createMinEigenValCorner(int srcType, int blockSize, int ksize, int borderType = BORDER_REFLECT101)
+
+    :param srcType: Input source type. Only  ``CV_8UC1`` and  ``CV_32FC1`` are supported for now.
+
+    :param blockSize: Neighborhood size.
+
+    :param ksize: Aperture parameter for the Sobel operator.
+
+    :param borderType: Pixel extrapolation method. Only  ``BORDER_REFLECT101`` and  ``BORDER_REPLICATE`` are supported for now.
+
+.. seealso:: :ocv:func:`cornerMinEigenVal`
+
+
+
+gpu::CornersDetector
+--------------------
+.. ocv:class:: gpu::CornersDetector : public Algorithm
+
+Base class for Corners Detector. ::
+
+    class CV_EXPORTS CornersDetector : public Algorithm
+    {
+    public:
+        virtual void detect(InputArray image, OutputArray corners, InputArray mask = noArray()) = 0;
+    };
+
+
+
+gpu::CornersDetector::detect
+----------------------------
+Determines strong corners on an image.
+
+.. ocv:function:: void gpu::CornersDetector::detect(InputArray image, OutputArray corners, InputArray mask = noArray())
+
+    :param image: Input 8-bit or floating-point 32-bit, single-channel image.
+
+    :param corners: Output vector of detected corners (1-row matrix with CV_32FC2 type with corners positions).
+
+    :param mask: Optional region of interest. If the image is not empty (it needs to have the type  ``CV_8UC1``  and the same size as  ``image`` ), it  specifies the region in which the corners are detected.
+
+
+
+gpu::createGoodFeaturesToTrackDetector
+--------------------------------------
+Creates implementation for :ocv:class:`gpu::CornersDetector` .
+
+.. ocv:function:: Ptr<CornersDetector> gpu::createGoodFeaturesToTrackDetector(int srcType, int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0, int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04)
+
+    :param srcType: Input source type. Only  ``CV_8UC1`` and  ``CV_32FC1`` are supported for now.
+
+    :param maxCorners: Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned.
+
+    :param qualityLevel: Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see  :ocv:func:`cornerMinEigenVal` ) or the Harris function response (see  :ocv:func:`cornerHarris` ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the  ``qualityLevel=0.01`` , then all the corners with the quality measure less than 15 are rejected.
+
+    :param minDistance: Minimum possible Euclidean distance between the returned corners.
+
+    :param blockSize: Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See  :ocv:func:`cornerEigenValsAndVecs` .
+
+    :param useHarrisDetector: Parameter indicating whether to use a Harris detector (see :ocv:func:`cornerHarris`) or :ocv:func:`cornerMinEigenVal`.
+
+    :param harrisK: Free parameter of the Harris detector.
+
+.. seealso:: :ocv:func:`goodFeaturesToTrack`

modules/cudaimgproc/doc/histogram.rst

@@ -0,0 +1,150 @@
+Histogram Calculation
+=====================
+
+.. highlight:: cpp
+
+
+
+gpu::calcHist
+-------------
+Calculates histogram for one channel 8-bit image.
+
+.. ocv:function:: void gpu::calcHist(InputArray src, OutputArray hist, Stream& stream = Stream::Null())
+
+    :param src: Source image with ``CV_8UC1`` type.
+
+    :param hist: Destination histogram with one row, 256 columns, and the  ``CV_32SC1`` type.
+
+    :param stream: Stream for the asynchronous version.
+
+
+
+gpu::equalizeHist
+-----------------
+Equalizes the histogram of a grayscale image.
+
+.. ocv:function:: void gpu::equalizeHist(InputArray src, OutputArray dst, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::equalizeHist(InputArray src, OutputArray dst, InputOutputArray buf, Stream& stream = Stream::Null())
+
+    :param src: Source image with ``CV_8UC1`` type.
+
+    :param dst: Destination image.
+
+    :param buf: Optional buffer to avoid extra memory allocations (for many calls with the same sizes).
+
+    :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`equalizeHist`
+
+
+
+gpu::CLAHE
+----------
+.. ocv:class:: gpu::CLAHE : public cv::CLAHE
+
+Base class for Contrast Limited Adaptive Histogram Equalization. ::
+
+    class CV_EXPORTS CLAHE : public cv::CLAHE
+    {
+    public:
+        using cv::CLAHE::apply;
+        virtual void apply(InputArray src, OutputArray dst, Stream& stream) = 0;
+    };
+
+
+
+gpu::CLAHE::apply
+-----------------
+Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
+
+.. ocv:function:: void gpu::CLAHE::apply(InputArray src, OutputArray dst)
+
+.. ocv:function:: void gpu::CLAHE::apply(InputArray src, OutputArray dst, Stream& stream)
+
+    :param src: Source image with ``CV_8UC1`` type.
+
+    :param dst: Destination image.
+
+    :param stream: Stream for the asynchronous version.
+
+
+
+gpu::createCLAHE
+----------------
+Creates implementation for :ocv:class:`gpu::CLAHE` .
+
+.. ocv:function:: Ptr<gpu::CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8))
+
+    :param clipLimit: Threshold for contrast limiting.
+
+    :param tileGridSize: Size of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles. ``tileGridSize`` defines the number of tiles in row and column.
+
+
+
+
+gpu::evenLevels
+---------------
+Computes levels with even distribution.
+
+.. ocv:function:: void gpu::evenLevels(OutputArray levels, int nLevels, int lowerLevel, int upperLevel)
+
+    :param levels: Destination array.  ``levels`` has 1 row, ``nLevels`` columns, and the ``CV_32SC1`` type.
+
+    :param nLevels: Number of computed levels.  ``nLevels`` must be at least 2.
+
+    :param lowerLevel: Lower boundary value of the lowest level.
+
+    :param upperLevel: Upper boundary value of the greatest level.
+
+
+
+gpu::histEven
+-------------
+Calculates a histogram with evenly distributed bins.
+
+.. ocv:function:: void gpu::histEven(InputArray src, OutputArray hist, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::histEven(InputArray src, OutputArray hist, InputOutputArray buf, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::histEven(InputArray src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::histEven(InputArray src, GpuMat hist[4], InputOutputArray buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null())
+
+    :param src: Source image. ``CV_8U``, ``CV_16U``, or ``CV_16S`` depth and 1 or 4 channels are supported. For a four-channel image, all channels are processed separately.
+
+    :param hist: Destination histogram with one row, ``histSize`` columns, and the ``CV_32S`` type.
+
+    :param histSize: Size of the histogram.
+
+    :param lowerLevel: Lower boundary of lowest-level bin.
+
+    :param upperLevel: Upper boundary of highest-level bin.
+
+    :param buf: Optional buffer to avoid extra memory allocations (for many calls with the same sizes).
+
+    :param stream: Stream for the asynchronous version.
+
+
+
+gpu::histRange
+--------------
+Calculates a histogram with bins determined by the ``levels`` array.
+
+.. ocv:function:: void gpu::histRange(InputArray src, OutputArray hist, InputArray levels, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::histRange(InputArray src, OutputArray hist, InputArray levels, InputOutputArray buf, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::histRange(InputArray src, GpuMat hist[4], const GpuMat levels[4], Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::histRange(InputArray src, GpuMat hist[4], const GpuMat levels[4], InputOutputArray buf, Stream& stream = Stream::Null())
+
+    :param src: Source image. ``CV_8U`` , ``CV_16U`` , or  ``CV_16S`` depth and 1 or 4 channels are supported. For a four-channel image, all channels are processed separately.
+
+    :param hist: Destination histogram with one row, ``(levels.cols-1)`` columns, and the  ``CV_32SC1`` type.
+
+    :param levels: Number of levels in the histogram.
+
+    :param buf: Optional buffer to avoid extra memory allocations (for many calls with the same sizes).
+
+    :param stream: Stream for the asynchronous version.

modules/cudaimgproc/doc/hough.rst

@@ -0,0 +1,236 @@
+Hough Transform
+===============
+
+.. highlight:: cpp
+
+
+
+gpu::HoughLinesDetector
+-----------------------
+.. ocv:class:: gpu::HoughLinesDetector : public Algorithm
+
+Base class for lines detector algorithm. ::
+
+    class CV_EXPORTS HoughLinesDetector : public Algorithm
+    {
+    public:
+        virtual void detect(InputArray src, OutputArray lines) = 0;
+        virtual void downloadResults(InputArray d_lines, OutputArray h_lines, OutputArray h_votes = noArray()) = 0;
+
+        virtual void setRho(float rho) = 0;
+        virtual float getRho() const = 0;
+
+        virtual void setTheta(float theta) = 0;
+        virtual float getTheta() const = 0;
+
+        virtual void setThreshold(int threshold) = 0;
+        virtual int getThreshold() const = 0;
+
+        virtual void setDoSort(bool doSort) = 0;
+        virtual bool getDoSort() const = 0;
+
+        virtual void setMaxLines(int maxLines) = 0;
+        virtual int getMaxLines() const = 0;
+    };
+
+
+
+gpu::HoughLinesDetector::detect
+-------------------------------
+Finds lines in a binary image using the classical Hough transform.
+
+.. ocv:function:: void gpu::HoughLinesDetector::detect(InputArray src, OutputArray lines)
+
+    :param src: 8-bit, single-channel binary source image.
+
+    :param lines: Output vector of lines. Each line is represented by a two-element vector  :math:`(\rho, \theta)` .  :math:`\rho`  is the distance from the coordinate origin  :math:`(0,0)`  (top-left corner of the image).  :math:`\theta`  is the line rotation angle in radians ( :math:`0 \sim \textrm{vertical line}, \pi/2 \sim \textrm{horizontal line}` ).
+
+.. seealso:: :ocv:func:`HoughLines`
+
+
+
+gpu::HoughLinesDetector::downloadResults
+----------------------------------------
+Downloads results from :ocv:func:`gpu::HoughLinesDetector::detect` to host memory.
+
+.. ocv:function:: void gpu::HoughLinesDetector::downloadResults(InputArray d_lines, OutputArray h_lines, OutputArray h_votes = noArray())
+
+    :param d_lines: Result of :ocv:func:`gpu::HoughLinesDetector::detect` .
+
+    :param h_lines: Output host array.
+
+    :param h_votes: Optional output array for line's votes.
+
+
+
+gpu::createHoughLinesDetector
+-----------------------------
+Creates implementation for :ocv:class:`gpu::HoughLinesDetector` .
+
+.. ocv:function:: Ptr<HoughLinesDetector> gpu::createHoughLinesDetector(float rho, float theta, int threshold, bool doSort = false, int maxLines = 4096)
+
+    :param rho: Distance resolution of the accumulator in pixels.
+
+    :param theta: Angle resolution of the accumulator in radians.
+
+    :param threshold: Accumulator threshold parameter. Only those lines are returned that get enough votes ( :math:`>\texttt{threshold}` ).
+
+    :param doSort: Performs lines sort by votes.
+
+    :param maxLines: Maximum number of output lines.
+
+
+
+gpu::HoughSegmentDetector
+-------------------------
+.. ocv:class:: gpu::HoughSegmentDetector : public Algorithm
+
+Base class for line segments detector algorithm. ::
+
+    class CV_EXPORTS HoughSegmentDetector : public Algorithm
+    {
+    public:
+        virtual void detect(InputArray src, OutputArray lines) = 0;
+
+        virtual void setRho(float rho) = 0;
+        virtual float getRho() const = 0;
+
+        virtual void setTheta(float theta) = 0;
+        virtual float getTheta() const = 0;
+
+        virtual void setMinLineLength(int minLineLength) = 0;
+        virtual int getMinLineLength() const = 0;
+
+        virtual void setMaxLineGap(int maxLineGap) = 0;
+        virtual int getMaxLineGap() const = 0;
+
+        virtual void setMaxLines(int maxLines) = 0;
+        virtual int getMaxLines() const = 0;
+    };
+
+.. note::
+
+   * An example using the Hough segment detector can be found at opencv_source_code/samples/gpu/houghlines.cpp
+
+
+gpu::HoughSegmentDetector::detect
+---------------------------------
+Finds line segments in a binary image using the probabilistic Hough transform.
+
+.. ocv:function:: void gpu::HoughSegmentDetector::detect(InputArray src, OutputArray lines)
+
+    :param src: 8-bit, single-channel binary source image.
+
+    :param lines: Output vector of lines. Each line is represented by a 4-element vector  :math:`(x_1, y_1, x_2, y_2)` , where  :math:`(x_1,y_1)`  and  :math:`(x_2, y_2)`  are the ending points of each detected line segment.
+
+.. seealso:: :ocv:func:`HoughLinesP`
+
+
+
+gpu::createHoughSegmentDetector
+-------------------------------
+Creates implementation for :ocv:class:`gpu::HoughSegmentDetector` .
+
+.. ocv:function:: Ptr<HoughSegmentDetector> gpu::createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines = 4096)
+
+    :param rho: Distance resolution of the accumulator in pixels.
+
+    :param theta: Angle resolution of the accumulator in radians.
+
+    :param minLineLength: Minimum line length. Line segments shorter than that are rejected.
+
+    :param maxLineGap: Maximum allowed gap between points on the same line to link them.
+
+    :param maxLines: Maximum number of output lines.
+
+
+
+gpu::HoughCirclesDetector
+-------------------------
+.. ocv:class:: gpu::HoughCirclesDetector : public Algorithm
+
+Base class for circles detector algorithm. ::
+
+    class CV_EXPORTS HoughCirclesDetector : public Algorithm
+    {
+    public:
+        virtual void detect(InputArray src, OutputArray circles) = 0;
+
+        virtual void setDp(float dp) = 0;
+        virtual float getDp() const = 0;
+
+        virtual void setMinDist(float minDist) = 0;
+        virtual float getMinDist() const = 0;
+
+        virtual void setCannyThreshold(int cannyThreshold) = 0;
+        virtual int getCannyThreshold() const = 0;
+
+        virtual void setVotesThreshold(int votesThreshold) = 0;
+        virtual int getVotesThreshold() const = 0;
+
+        virtual void setMinRadius(int minRadius) = 0;
+        virtual int getMinRadius() const = 0;
+
+        virtual void setMaxRadius(int maxRadius) = 0;
+        virtual int getMaxRadius() const = 0;
+
+        virtual void setMaxCircles(int maxCircles) = 0;
+        virtual int getMaxCircles() const = 0;
+    };
+
+
+
+gpu::HoughCirclesDetector::detect
+---------------------------------
+Finds circles in a grayscale image using the Hough transform.
+
+.. ocv:function:: void gpu::HoughCirclesDetector::detect(InputArray src, OutputArray circles)
+
+    :param src: 8-bit, single-channel grayscale input image.
+
+    :param circles: Output vector of found circles. Each vector is encoded as a 3-element floating-point vector  :math:`(x, y, radius)` .
+
+.. seealso:: :ocv:func:`HoughCircles`
+
+
+
+gpu::createHoughCirclesDetector
+-------------------------------
+Creates implementation for :ocv:class:`gpu::HoughCirclesDetector` .
+
+.. ocv:function:: Ptr<HoughCirclesDetector> gpu::createHoughCirclesDetector(float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles = 4096)
+
+    :param dp: Inverse ratio of the accumulator resolution to the image resolution. For example, if  ``dp=1`` , the accumulator has the same resolution as the input image. If  ``dp=2`` , the accumulator has half as big width and height.
+
+    :param minDist: Minimum distance between the centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed.
+
+    :param cannyThreshold: The higher threshold of the two passed to Canny edge detector (the lower one is twice smaller).
+
+    :param votesThreshold: The accumulator threshold for the circle centers at the detection stage. The smaller it is, the more false circles may be detected.
+
+    :param minRadius: Minimum circle radius.
+
+    :param maxRadius: Maximum circle radius.
+
+    :param maxCircles: Maximum number of output circles.
+
+
+
+gpu::createGeneralizedHoughBallard
+----------------------------------
+Creates implementation for generalized hough transform from [Ballard1981]_ .
+
+.. ocv:function:: Ptr<GeneralizedHoughBallard> gpu::createGeneralizedHoughBallard()
+
+
+
+gpu::createGeneralizedHoughGuil
+-------------------------------
+Creates implementation for generalized hough transform from [Guil1999]_ .
+
+.. ocv:function:: Ptr<GeneralizedHoughGuil> gpu::createGeneralizedHoughGuil()
+
+
+
+.. [Ballard1981] Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
+.. [Guil1999] 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.

modules/cudaimgproc/doc/imgproc.rst

@@ -0,0 +1,231 @@
+Image Processing
+================
+
+.. highlight:: cpp
+
+
+
+gpu::CannyEdgeDetector
+----------------------
+.. ocv:class:: gpu::CannyEdgeDetector : public Algorithm
+
+Base class for Canny Edge Detector. ::
+
+    class CV_EXPORTS CannyEdgeDetector : public Algorithm
+    {
+    public:
+        virtual void detect(InputArray image, OutputArray edges) = 0;
+        virtual void detect(InputArray dx, InputArray dy, OutputArray edges) = 0;
+
+        virtual void setLowThreshold(double low_thresh) = 0;
+        virtual double getLowThreshold() const = 0;
+
+        virtual void setHighThreshold(double high_thresh) = 0;
+        virtual double getHighThreshold() const = 0;
+
+        virtual void setAppertureSize(int apperture_size) = 0;
+        virtual int getAppertureSize() const = 0;
+
+        virtual void setL2Gradient(bool L2gradient) = 0;
+        virtual bool getL2Gradient() const = 0;
+    };
+
+
+
+gpu::CannyEdgeDetector::detect
+------------------------------
+Finds edges in an image using the [Canny86]_ algorithm.
+
+.. ocv:function:: void gpu::CannyEdgeDetector::detect(InputArray image, OutputArray edges)
+
+.. ocv:function:: void gpu::CannyEdgeDetector::detect(InputArray dx, InputArray dy, OutputArray edges)
+
+    :param image: Single-channel 8-bit input image.
+
+    :param dx: First derivative of image in the vertical direction. Support only ``CV_32S`` type.
+
+    :param dy: First derivative of image in the horizontal direction. Support only ``CV_32S`` type.
+
+    :param edges: Output edge map. It has the same size and type as  ``image`` .
+
+
+
+gpu::createCannyEdgeDetector
+----------------------------
+Creates implementation for :ocv:class:`gpu::CannyEdgeDetector` .
+
+.. ocv:function:: Ptr<CannyEdgeDetector> gpu::createCannyEdgeDetector(double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false)
+
+    :param low_thresh: First threshold for the hysteresis procedure.
+
+    :param high_thresh: Second threshold for the hysteresis procedure.
+
+    :param apperture_size: Aperture size for the  :ocv:func:`Sobel`  operator.
+
+    :param L2gradient: Flag indicating whether a more accurate  :math:`L_2`  norm  :math:`=\sqrt{(dI/dx)^2 + (dI/dy)^2}`  should be used to compute the image gradient magnitude ( ``L2gradient=true`` ), or a faster default  :math:`L_1`  norm  :math:`=|dI/dx|+|dI/dy|`  is enough ( ``L2gradient=false`` ).
+
+
+
+gpu::meanShiftFiltering
+-----------------------
+Performs mean-shift filtering for each point of the source image.
+
+.. ocv:function:: void gpu::meanShiftFiltering(InputArray src, OutputArray dst, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1), Stream& stream = Stream::Null())
+
+    :param src: Source image. Only  ``CV_8UC4`` images are supported for now.
+
+    :param dst: Destination image containing the color of mapped points. It has the same size and type as  ``src`` .
+
+    :param sp: Spatial window radius.
+
+    :param sr: Color window radius.
+
+    :param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
+
+It maps each point of the source image into another point. As a result, you have a new color and new position of each point.
+
+
+
+gpu::meanShiftProc
+------------------
+Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.
+
+.. ocv:function:: void gpu::meanShiftProc(InputArray src, OutputArray dstr, OutputArray dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1), Stream& stream = Stream::Null())
+
+    :param src: Source image. Only  ``CV_8UC4`` images are supported for now.
+
+    :param dstr: Destination image containing the color of mapped points. The size and type is the same as  ``src`` .
+
+    :param dstsp: Destination image containing the position of mapped points. The size is the same as  ``src`` size. The type is  ``CV_16SC2`` .
+
+    :param sp: Spatial window radius.
+
+    :param sr: Color window radius.
+
+    :param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
+
+.. seealso:: :ocv:func:`gpu::meanShiftFiltering`
+
+
+
+gpu::meanShiftSegmentation
+--------------------------
+Performs a mean-shift segmentation of the source image and eliminates small segments.
+
+.. ocv:function:: void gpu::meanShiftSegmentation(InputArray src, OutputArray dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
+
+    :param src: Source image. Only  ``CV_8UC4`` images are supported for now.
+
+    :param dst: Segmented image with the same size and type as  ``src`` (host memory).
+
+    :param sp: Spatial window radius.
+
+    :param sr: Color window radius.
+
+    :param minsize: Minimum segment size. Smaller segments are merged.
+
+    :param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
+
+
+
+gpu::TemplateMatching
+---------------------
+.. ocv:class:: gpu::TemplateMatching : public Algorithm
+
+Base class for Template Matching. ::
+
+    class CV_EXPORTS TemplateMatching : public Algorithm
+    {
+    public:
+        virtual void match(InputArray image, InputArray templ, OutputArray result, Stream& stream = Stream::Null()) = 0;
+    };
+
+
+
+gpu::TemplateMatching::match
+----------------------------
+Computes a proximity map for a raster template and an image where the template is searched for.
+
+.. ocv:function:: void gpu::TemplateMatching::match(InputArray image, InputArray templ, OutputArray result, Stream& stream = Stream::Null())
+
+    :param image: Source image.
+
+    :param templ: Template image with the size and type the same as  ``image`` .
+
+    :param result: Map containing comparison results ( ``CV_32FC1`` ). If  ``image`` is  *W x H*  and ``templ`` is  *w x h*, then  ``result`` must be *W-w+1 x H-h+1*.
+
+    :param stream: Stream for the asynchronous version.
+
+
+
+gpu::createTemplateMatching
+---------------------------
+Creates implementation for :ocv:class:`gpu::TemplateMatching` .
+
+.. ocv:function:: Ptr<TemplateMatching> gpu::createTemplateMatching(int srcType, int method, Size user_block_size = Size())
+
+    :param srcType: Input source type. ``CV_32F`` and  ``CV_8U`` depth images (1..4 channels) are supported for now.
+
+    :param method: Specifies the way to compare the template with the image.
+
+    :param user_block_size: You can use field `user_block_size` to set specific block size. If you leave its default value `Size(0,0)` then automatic estimation of block size will be used (which is optimized for speed). By varying `user_block_size` you can reduce memory requirements at the cost of speed.
+
+The following methods are supported for the ``CV_8U`` depth images for now:
+
+    * ``CV_TM_SQDIFF``
+    * ``CV_TM_SQDIFF_NORMED``
+    * ``CV_TM_CCORR``
+    * ``CV_TM_CCORR_NORMED``
+    * ``CV_TM_CCOEFF``
+    * ``CV_TM_CCOEFF_NORMED``
+
+The following methods are supported for the ``CV_32F`` images for now:
+
+    * ``CV_TM_SQDIFF``
+    * ``CV_TM_CCORR``
+
+.. seealso:: :ocv:func:`matchTemplate`
+
+
+
+gpu::bilateralFilter
+--------------------
+Performs bilateral filtering of passed image
+
+.. ocv:function:: void gpu::bilateralFilter(InputArray src, OutputArray dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode=BORDER_DEFAULT, Stream& stream=Stream::Null())
+
+    :param src: Source image. Supports only (channles != 2 && depth() != CV_8S && depth() != CV_32S && depth() != CV_64F).
+
+    :param dst: Destination imagwe.
+
+    :param kernel_size: Kernel window size.
+
+    :param sigma_color: Filter sigma in the color space.
+
+    :param sigma_spatial:  Filter sigma in the coordinate space.
+
+    :param borderMode:  Border type. See :ocv:func:`borderInterpolate` for details. ``BORDER_REFLECT101`` , ``BORDER_REPLICATE`` , ``BORDER_CONSTANT`` , ``BORDER_REFLECT`` and ``BORDER_WRAP`` are supported for now.
+
+    :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`bilateralFilter`
+
+
+
+gpu::blendLinear
+-------------------
+Performs linear blending of two images.
+
+.. ocv:function:: void gpu::blendLinear(InputArray img1, InputArray img2, InputArray weights1, InputArray weights2, OutputArray result, Stream& stream = Stream::Null())
+
+    :param img1: First image. Supports only ``CV_8U`` and ``CV_32F`` depth.
+
+    :param img2: Second image. Must have the same size and the same type as ``img1`` .
+
+    :param weights1: Weights for first image. Must have tha same size as ``img1`` . Supports only ``CV_32F`` type.
+
+    :param weights2: Weights for second image. Must have tha same size as ``img2`` . Supports only ``CV_32F`` type.
+
+    :param result: Destination image.
+
+    :param stream: Stream for the asynchronous version.