third_party/opencv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

introduced new RST/Sphinx domain ocv.

Browse Source
This commit is contained in:
Vadim Pisarevsky
2011-06-16 12:48:23 +00:00
parent 4f3fb040a4
commit 8d8ef596c8
48 changed files with 2823 additions and 1691 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
+34 -34
View File
@@ -7,7 +7,7 @@ Camera Calibration and 3D Reconstruction
gpu::StereoBM_GPU
-----------------
.. cpp:class:: gpu::StereoBM_GPU
.. ocv:class:: gpu::StereoBM_GPU
This class computes stereo correspondence (disparity map) using the block matching algorithm.
::
@@ -51,9 +51,9 @@ This means that the input left image is low textured.
gpu::StereoBM_GPU::StereoBM_GPU
-----------------------------------
.. cpp:function:: gpu::StereoBM_GPU::StereoBM_GPU()
.. ocv:function:: gpu::StereoBM_GPU::StereoBM_GPU()
.. cpp:function:: gpu::StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ)
.. ocv:function:: gpu::StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ)
Enables ``StereoBM_GPU`` constructors.
@@ -73,9 +73,9 @@ gpu::StereoBM_GPU::StereoBM_GPU
gpu::StereoBM_GPU::operator ()
----------------------------------
.. cpp:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity)
.. ocv:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity)
.. cpp:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity, const Stream& stream)
.. ocv:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity, const Stream& stream)
Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair.
@@ -91,7 +91,7 @@ gpu::StereoBM_GPU::operator ()
gpu::StereoBM_GPU::checkIfGpuCallReasonable
-----------------------------------------------
.. cpp:function:: bool gpu::StereoBM_GPU::checkIfGpuCallReasonable()
.. ocv:function:: bool gpu::StereoBM_GPU::checkIfGpuCallReasonable()
Uses a heuristic method to estimate whether the current GPU is faster than the CPU in this algorithm. It queries the currently active device.
@@ -99,7 +99,7 @@ gpu::StereoBM_GPU::checkIfGpuCallReasonable
gpu::StereoBeliefPropagation
----------------------------
.. cpp:class:: gpu::StereoBeliefPropagation
.. ocv:class:: gpu::StereoBeliefPropagation
This class computes stereo correspondence using the belief propagation algorithm. ::
@@ -166,9 +166,9 @@ and for data cost storage:
gpu::StereoBeliefPropagation::StereoBeliefPropagation
---------------------------------------------------------
.. cpp:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
.. ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
.. cpp:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp, int iters, int levels, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int msg_type = CV_32F)
.. ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp, int iters, int levels, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int msg_type = CV_32F)
Enables the ``StereoBeliefPropagation`` constructors.
@@ -200,7 +200,7 @@ gpu::StereoBeliefPropagation::StereoBeliefPropagation
For more details, see [Pedro F. Felzenszwalb and Daniel P. Huttenlocher. Efficient belief propagation for early vision. International Journal of Computer Vision, 70(1), October 2006].
By default, :cpp:class:`StereoBeliefPropagation` uses floating-point arithmetics and the ``CV_32FC1`` type for messages. But it can also use fixed-point arithmetics and the ``CV_16SC1`` message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement:
By default, :ocv:class:`StereoBeliefPropagation` uses floating-point arithmetics and the ``CV_32FC1`` type for messages. But it can also use fixed-point arithmetics and the ``CV_16SC1`` message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement:
.. math::
@@ -211,7 +211,7 @@ By default, :cpp:class:`StereoBeliefPropagation` uses floating-point arithmetics
gpu::StereoBeliefPropagation::estimateRecommendedParams
-----------------------------------------------------------
.. cpp:function:: void gpu::StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels)
.. ocv:function:: void gpu::StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels)
Uses a heuristic method to compute the recommended parameters (``ndisp``, ``iters`` and ``levels``) for the specified image size (``width`` and ``height``).
@@ -219,9 +219,9 @@ gpu::StereoBeliefPropagation::estimateRecommendedParams
gpu::StereoBeliefPropagation::operator ()
---------------------------------------------
.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity)
.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity)
.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream)
.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream)
Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair or data cost.
@@ -233,9 +233,9 @@ gpu::StereoBeliefPropagation::operator ()
:param stream: Stream for the asynchronous version.
.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity)
.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity)
.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity, Stream& stream)
.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity, Stream& stream)
:param data: The user-specified data cost, a matrix of ``msg_type`` type and ``Size(<image columns>*ndisp, <image rows>)`` size.
@@ -247,7 +247,7 @@ gpu::StereoBeliefPropagation::operator ()
gpu::StereoConstantSpaceBP
--------------------------
.. cpp:class:: gpu::StereoConstantSpaceBP
.. ocv:class:: gpu::StereoConstantSpaceBP
This class computes stereo correspondence using the constant space belief propagation algorithm. ::
@@ -306,9 +306,9 @@ The class implements Q. Yang algorithm [Q. Yang, L. Wang, and N. Ahuja. A consta
gpu::StereoConstantSpaceBP::StereoConstantSpaceBP
-----------------------------------------------------
.. cpp: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:: 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)
.. cpp: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:: 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)
Enables the StereoConstantSpaceBP constructors.
@@ -355,7 +355,7 @@ By default, ``StereoConstantSpaceBP`` uses floating-point arithmetics and the ``
gpu::StereoConstantSpaceBP::estimateRecommendedParams
---------------------------------------------------------
.. cpp:function:: void gpu::StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane)
.. ocv:function:: void gpu::StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane)
Uses a heuristic method to compute parameters (ndisp, iters, levelsand nrplane) for the specified image size (widthand height).
@@ -363,9 +363,9 @@ gpu::StereoConstantSpaceBP::estimateRecommendedParams
gpu::StereoConstantSpaceBP::operator ()
-------------------------------------------
.. cpp:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity)
.. ocv:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity)
.. cpp:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream)
.. ocv:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream)
Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair.
@@ -383,7 +383,7 @@ gpu::StereoConstantSpaceBP::operator ()
gpu::DisparityBilateralFilter
-----------------------------
.. cpp:class:: gpu::DisparityBilateralFilter
.. ocv:class:: gpu::DisparityBilateralFilter
This class refines a disparity map using joint bilateral filtering. ::
@@ -416,9 +416,9 @@ The class implements Q. Yang algorithm [Q. Yang, L. Wang, and N. Ahuja. A consta
gpu::DisparityBilateralFilter::DisparityBilateralFilter
-----------------------------------------------------------
.. cpp:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
.. ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
.. cpp:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
.. ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
Enables the ``DisparityBilateralFilter`` constructors.
@@ -438,9 +438,9 @@ gpu::DisparityBilateralFilter::DisparityBilateralFilter
gpu::DisparityBilateralFilter::operator ()
----------------------------------------------
.. cpp:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst)
.. ocv:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst)
.. cpp:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream)
.. ocv:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream)
Refines a disparity map using joint bilateral filtering.
@@ -456,9 +456,9 @@ gpu::DisparityBilateralFilter::operator ()
gpu::drawColorDisp
----------------------
.. cpp:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp)
.. ocv:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp)
.. cpp:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, const Stream& stream)
.. ocv:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, const Stream& stream)
Colors a disparity image.
@@ -476,9 +476,9 @@ This function draws a colored disparity map by converting disparity values from
gpu::reprojectImageTo3D
---------------------------
.. cpp:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q)
.. ocv:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q)
.. cpp:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, const Stream& stream)
.. ocv:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, const Stream& stream)
Reprojects a disparity image to 3D space.
@@ -490,14 +490,14 @@ gpu::reprojectImageTo3D
:param stream: Stream for the asynchronous version.
See Also: :cpp:func:`reprojectImageTo3D` .
See Also: :ocv:func:`reprojectImageTo3D` .
.. index:: gpu::solvePnPRansac
gpu::solvePnPRansac
-------------------
.. cpp:function:: void gpu::solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat, const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false, int num_iters=100, float max_dist=8.0, int min_inlier_count=100, vector<int>* inliers=NULL)
.. ocv:function:: void gpu::solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat, const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false, int num_iters=100, float max_dist=8.0, int min_inlier_count=100, vector<int>* inliers=NULL)
Finds the object pose from 3D-2D point correspondences.
@@ -507,7 +507,7 @@ gpu::solvePnPRansac
:param camera_mat: 3x3 matrix of intrinsic camera parameters.
:param dist_coef: Distortion coefficients. See :cpp:func:`undistortPoints` for details.
:param dist_coef: Distortion coefficients. See :ocv:func:`undistortPoints` for details.
:param rvec: Output 3D rotation vector.
@@ -523,5 +523,5 @@ gpu::solvePnPRansac
:param inliers: Output vector of inlier indices.
See Also :cpp:func:`solvePnPRansac`.
See Also :ocv:func:`solvePnPRansac`.
modules/gpu/doc/data_structures.rst
+27 -27
View File
@@ -7,7 +7,7 @@ Data Structures
gpu::DevMem2D\_
---------------
.. cpp:class:: gpu::DevMem2D\_
.. ocv:class:: gpu::DevMem2D\_
This lightweight class encapsulates pitched memory on a GPU and is passed to nvcc-compiled code (CUDA kernels). Typically, it is used internally by OpenCV and by users who write device code. You can call its members from both host and device code. ::
@@ -44,10 +44,10 @@ This lightweight class encapsulates pitched memory on a GPU and is passed to nvc
gpu::PtrStep\_
--------------
.. cpp:class:: gpu::PtrStep\_
.. ocv:class:: gpu::PtrStep\_
This structure is similar to
:cpp:class:`DevMem2D_` but contains only a pointer and row step. Width and height fields are excluded due to performance reasons. The structure is intended for internal use or for users who write device code.
:ocv:class:`DevMem2D_` but contains only a pointer and row step. Width and height fields are excluded due to performance reasons. The structure is intended for internal use or for users who write device code.
::
template<typename T> struct PtrStep_
@@ -75,10 +75,10 @@ This structure is similar to
gpu::PtrElemStrp\_
------------------
.. cpp:class:: gpu::PtrElemStrp\_
.. ocv:class:: gpu::PtrElemStrp\_
This structure is similar to
:cpp:class:`DevMem2D_` but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class can only be constructed if ``sizeof(T)`` is a multiple of 256. The structure is intended for internal use or for users who write device code.
:ocv:class:`DevMem2D_` but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class can only be constructed if ``sizeof(T)`` is a multiple of 256. The structure is intended for internal use or for users who write device code.
::
template<typename T> struct PtrElemStep_ : public PtrStep_<T>
@@ -93,7 +93,7 @@ This structure is similar to
gpu::GpuMat
-----------
.. cpp:class:: gpu::GpuMat
.. ocv:class:: gpu::GpuMat
This is a base storage class for GPU memory with reference counting. Its interface matches the
:c:type:`Mat` interface with the following limitations:
@@ -105,7 +105,7 @@ This is a base storage class for GPU memory with reference counting. Its interfa
*
no expression templates technique support
Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :cpp:class:`gpu::DevMem2D_` and :cpp:class:`gpu::PtrStep_` so it can be passed directly to kernel.
Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :ocv:class:`gpu::DevMem2D_` and :ocv:class:`gpu::PtrStep_` so it can be passed directly to kernel.
**Note:**
@@ -148,16 +148,16 @@ In contrast with :c:type:`Mat`, in most cases ``GpuMat::isContinuous() == false`
You are not recommended to leave static or global ``GpuMat`` variables allocated, that is to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.
See Also:
:cpp:func:`Mat`
:ocv:func:`Mat`
.. index:: gpu::CudaMem
gpu::CudaMem
------------
.. cpp:class:: gpu::CudaMem
.. ocv:class:: gpu::CudaMem
This class with reference counting wraps special memory type allocation functions from CUDA. Its interface is also
:cpp:func:`Mat`-like but with additional memory type parameters.
:ocv:func:`Mat`-like but with additional memory type parameters.
*
``ALLOC_PAGE_LOCKED``: Sets a page locked memory type, used commonly for fast and asynchronous uploading/downloading data from/to GPU.
@@ -206,24 +206,24 @@ Allocation size of such memory types is usually limited. For more details, see "
gpu::CudaMem::createMatHeader
---------------------------------
.. cpp:function:: Mat gpu::CudaMem::createMatHeader() const
.. ocv:function:: Mat gpu::CudaMem::createMatHeader() const
Creates a header without reference counting to :cpp:class:`gpu::CudaMem` data.
Creates a header without reference counting to :ocv:class:`gpu::CudaMem` data.
.. index:: gpu::CudaMem::createGpuMatHeader
gpu::CudaMem::createGpuMatHeader
------------------------------------
.. cpp:function:: GpuMat gpu::CudaMem::createGpuMatHeader() const
.. ocv:function:: GpuMat gpu::CudaMem::createGpuMatHeader() const
Maps CPU memory to GPU address space and creates the :cpp:class:`gpu::GpuMat` header without reference counting for it. This can be done only if memory was allocated with the ``ALLOC_ZEROCOPY`` flag and if it is supported by the hardware (laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy).
Maps CPU memory to GPU address space and creates the :ocv:class:`gpu::GpuMat` header without reference counting for it. This can be done only if memory was allocated with the ``ALLOC_ZEROCOPY`` flag and if it is supported by the hardware (laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy).
.. index:: gpu::CudaMem::canMapHostMemory
gpu::CudaMem::canMapHostMemory
----------------------------------
.. cpp:function:: static bool gpu::CudaMem::canMapHostMemory()
.. ocv:function:: static bool gpu::CudaMem::canMapHostMemory()
Returns ``true`` if the current hardware supports address space mapping and ``ALLOC_ZEROCOPY`` memory allocation.
@@ -231,9 +231,9 @@ gpu::CudaMem::canMapHostMemory
gpu::Stream
-----------
.. cpp:class:: gpu::Stream
.. ocv:class:: gpu::Stream
This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :cpp:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :cpp:class:`gpu::CudaMem` or :c:type:`Mat` header that points to a region of :cpp:class:`gpu::CudaMem`.
This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :ocv:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :ocv:class:`gpu::CudaMem` or :c:type:`Mat` header that points to a region of :ocv:class:`gpu::CudaMem`.
**Note:**
@@ -279,7 +279,7 @@ Currently, you may face problems if an operation is enqueued twice with differen
gpu::Stream::queryIfComplete
--------------------------------
.. cpp:function:: bool gpu::Stream::queryIfComplete()
.. ocv:function:: bool gpu::Stream::queryIfComplete()
Returns ``true`` if the current stream queue is finished. Otherwise, it returns false.
@@ -287,7 +287,7 @@ gpu::Stream::queryIfComplete
gpu::Stream::waitForCompletion
----------------------------------
.. cpp:function:: void gpu::Stream::waitForCompletion()
.. ocv:function:: void gpu::Stream::waitForCompletion()
Blocks the current CPU thread until all operations in the stream are complete.
@@ -295,9 +295,9 @@ gpu::Stream::waitForCompletion
gpu::StreamAccessor
-------------------
.. cpp:class:: gpu::StreamAccessor
.. ocv:class:: gpu::StreamAccessor
This class enables getting ``cudaStream_t`` from :cpp:class:`gpu::Stream` and is declared in ``stream_accessor.hpp`` because it is the only public header that depends on the CUDA Runtime API. Including it brings a dependency to your code.
This class enables getting ``cudaStream_t`` from :ocv:class:`gpu::Stream` and is declared in ``stream_accessor.hpp`` because it is the only public header that depends on the CUDA Runtime API. Including it brings a dependency to your code.
::
struct StreamAccessor
@@ -310,7 +310,7 @@ This class enables getting ``cudaStream_t`` from :cpp:class:`gpu::Stream` and is
gpu::createContinuous
-------------------------
.. cpp:function:: void gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
.. ocv:function:: void gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
Creates a continuous matrix in the GPU memory.
@@ -325,11 +325,11 @@ gpu::createContinuous
The following wrappers are also available:
* .. cpp:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
* .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
* .. cpp:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
* .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
* .. cpp:function:: GpuMat gpu::createContinuous(Size size, int type)
* .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type)
Matrix is called continuous if its elements are stored continuously, that is without gaps in the end of each row.
@@ -337,9 +337,9 @@ gpu::createContinuous
gpu::ensureSizeIsEnough
---------------------------
.. cpp:function:: void gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
.. ocv:function:: void gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
.. cpp:function:: void gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m)
.. ocv:function:: void gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m)
Ensures that the size of a matrix is big enough and the matrix has a proper type. The function does not reallocate memory if the matrix has proper attributes already.
modules/gpu/doc/feature_detection_and_description.rst
+28 -28
View File
@@ -7,7 +7,7 @@ Feature Detection and Description
gpu::SURF_GPU
-------------
.. cpp:class:: gpu::SURF_GPU
.. ocv:class:: gpu::SURF_GPU
This class is used for extracting Speeded Up Robust Features (SURF) from an image.
::
@@ -93,7 +93,7 @@ See Also: :c:type:`SURF`
gpu::BruteForceMatcher_GPU
--------------------------
.. cpp:class:: gpu::BruteForceMatcher_GPU
.. ocv:class:: gpu::BruteForceMatcher_GPU
This is a brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one. This descriptor matcher supports masking permissible matches between descriptor sets. ::
@@ -188,20 +188,20 @@ See Also: :c:type:`DescriptorMatcher`, :c:type:`BruteForceMatcher`
gpu::BruteForceMatcher_GPU::match
-------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector<DMatch>& matches, const GpuMat& mask = GpuMat())
.. ocv:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector<DMatch>& matches, const GpuMat& mask = GpuMat())
.. cpp:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks = std::vector<GpuMat>())
.. ocv:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks = std::vector<GpuMat>())
Finds the best match for each descriptor from a query set with train descriptors.
See Also:
:cpp:func:`DescriptorMatcher::match`
:ocv:func:`DescriptorMatcher::match`
.. index:: gpu::BruteForceMatcher_GPU::matchSingle
gpu::BruteForceMatcher_GPU::matchSingle
-------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchSingle(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat())
.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchSingle(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat())
Finds the best match for each query descriptor. Results are stored in the GPU memory.
@@ -219,13 +219,13 @@ gpu::BruteForceMatcher_GPU::matchSingle
gpu::BruteForceMatcher_GPU::matchCollection
-----------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchCollection(const GpuMat& queryDescs, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchCollection(const GpuMat& queryDescs, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection)
Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory.
:param queryDescs: Query set of descriptors.
:param trainCollection: :cpp:class:`gpu::GpuMat` containing train collection. It can be obtained from the collection of train descriptors that was set using the ``add`` method by :cpp:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection`. Or it may contain a user-defined collection. This is a one-row matrix where each element is ``DevMem2D`` pointing out to a matrix of train descriptors.
:param trainCollection: :ocv:class:`gpu::GpuMat` containing train collection. It can be obtained from the collection of train descriptors that was set using the ``add`` method by :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection`. Or it may contain a user-defined collection. This is a one-row matrix where each element is ``DevMem2D`` pointing out to a matrix of train descriptors.
:param trainIdx: The output single-row ``CV_32SC1`` matrix that contains the best train index for each query. If some query descriptors are masked out in ``maskCollection`` , it contains -1.
@@ -233,47 +233,47 @@ gpu::BruteForceMatcher_GPU::matchCollection
:param distance: The output single-row ``CV_32FC1`` matrix that contains the best distance for each query. If some query descriptors are masked out in ``maskCollection`` , it contains ``FLT_MAX``.
:param maskCollection: ``GpuMat`` containing a set of masks. It can be obtained from ``std::vector<GpuMat>`` by :cpp:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain a user-defined mask set. This is an empty matrix or one-row matrix where each element is a ``PtrStep`` that points to one mask.
:param maskCollection: ``GpuMat`` containing a set of masks. It can be obtained from ``std::vector<GpuMat>`` by :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain a user-defined mask set. This is an empty matrix or one-row matrix where each element is a ``PtrStep`` that points to one mask.
.. index:: gpu::BruteForceMatcher_GPU::makeGpuCollection
gpu::BruteForceMatcher_GPU::makeGpuCollection
-------------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector<GpuMat>&masks = std::vector<GpuMat>())
.. ocv:function:: void gpu::BruteForceMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector<GpuMat>&masks = std::vector<GpuMat>())
Performs a GPU collection of train descriptors and masks in a suitable format for the
:cpp:func:`gpu::BruteForceMatcher_GPU::matchCollection` function.
:ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` function.
.. index:: gpu::BruteForceMatcher_GPU::matchDownload
gpu::BruteForceMatcher_GPU::matchDownload
---------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>&matches)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>&matches)
.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>&matches)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>&matches)
Downloads ``trainIdx``, ``imgIdx``, and ``distance`` matrices obtained via
:cpp:func:`gpu::BruteForceMatcher_GPU::matchSingle` or
:cpp:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :c:type:`DMatch`.
:ocv:func:`gpu::BruteForceMatcher_GPU::matchSingle` or
:ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :c:type:`DMatch`.
.. index:: gpu::BruteForceMatcher_GPU::knnMatch
gpu::BruteForceMatcher_GPU::knnMatch
----------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector<DMatch> >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector<DMatch> >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false)
Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance.
.. cpp:function:: void knnMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, int k, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false )
.. ocv:function:: void knnMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, int k, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false )
See Also:
:cpp:func:`DescriptorMatcher::knnMatch`
:ocv:func:`DescriptorMatcher::knnMatch`
.. index:: gpu::BruteForceMatcher_GPU::knnMatch
gpu::BruteForceMatcher_GPU::knnMatch
----------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat())
.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat())
Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance. Results will be stored in the GPU memory.
@@ -291,30 +291,30 @@ gpu::BruteForceMatcher_GPU::knnMatch
gpu::BruteForceMatcher_GPU::knnMatchDownload
------------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector<DMatch> >&matches, bool compactResult = false)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector<DMatch> >&matches, bool compactResult = false)
Downloads ``trainIdx`` and ``distance`` matrices obtained via :cpp:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
Downloads ``trainIdx`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
.. index:: gpu::BruteForceMatcher_GPU::radiusMatch
gpu::BruteForceMatcher_GPU::radiusMatch
-------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector<DMatch> >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector<DMatch> >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false)
For each query descriptor, finds the best matches with a distance less than a given threshold. The function returns detected matches in the increasing order by distance.
.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, float maxDistance, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, float maxDistance, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false)
This function works only on devices with the compute capability :math:`>=` 1.1.
See Also:
:cpp:func:`DescriptorMatcher::radiusMatch`
:ocv:func:`DescriptorMatcher::radiusMatch`
.. index:: gpu::BruteForceMatcher_GPU::radiusMatch
gpu::BruteForceMatcher_GPU::radiusMatch
-------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& nMatches, GpuMat& distance, float maxDistance, const GpuMat& mask = GpuMat())
.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& nMatches, GpuMat& distance, float maxDistance, const GpuMat& mask = GpuMat())
For each query descriptor, finds the best matches with a distance less than a given threshold (``maxDistance``). The results are stored in the GPU memory.
@@ -332,13 +332,13 @@ gpu::BruteForceMatcher_GPU::radiusMatch
:param mask: Mask specifying permissible matches between the input query and train matrices of descriptors.
In contrast to :cpp:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1.
In contrast to :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1.
.. index:: gpu::BruteForceMatcher_GPU::radiusMatchDownload
gpu::BruteForceMatcher_GPU::radiusMatchDownload
---------------------------------------------------
.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance, std::vector< std::vector<DMatch> >&matches, bool compactResult = false)
.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance, std::vector< std::vector<DMatch> >&matches, bool compactResult = false)
Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :cpp:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
modules/gpu/doc/image_filtering.rst
+75 -75
View File
@@ -11,7 +11,7 @@ See also: :ref:`ImageFiltering`.
gpu::BaseRowFilter_GPU
----------------------
.. cpp:class:: gpu::BaseRowFilter_GPU
.. ocv:class:: gpu::BaseRowFilter_GPU
This is a base class for linear or non-linear filters that processes rows of 2D arrays. Such filters are used for the "horizontal" filtering passes in separable filters. ::
@@ -27,13 +27,13 @@ This is a base class for linear or non-linear filters that processes rows of 2D
**Note:**
This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`.
This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
.. index:: gpu::BaseColumnFilter_GPU
gpu::BaseColumnFilter_GPU
-------------------------
.. cpp:class:: gpu::BaseColumnFilter_GPU
.. ocv:class:: gpu::BaseColumnFilter_GPU
This is a base class for linear or non-linear filters that processes columns of 2D arrays. Such filters are used for the "vertical" filtering passes in separable filters. ::
@@ -49,13 +49,13 @@ This is a base class for linear or non-linear filters that processes columns of
**Note:**
This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`.
This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
.. index:: gpu::BaseFilter_GPU
gpu::BaseFilter_GPU
-------------------
.. cpp:class:: gpu::BaseFilter_GPU
.. ocv:class:: gpu::BaseFilter_GPU
This is a base class for non-separable 2D filters. ::
@@ -72,13 +72,13 @@ This is a base class for non-separable 2D filters. ::
**Note:**
This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`.
This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
.. index:: gpu::FilterEngine_GPU
gpu::FilterEngine_GPU
---------------------
.. cpp:class:: gpu::FilterEngine_GPU
.. ocv:class:: gpu::FilterEngine_GPU
This is a base class for Filter Engine. ::
@@ -93,7 +93,7 @@ This is a base class for Filter Engine. ::
The class can be used to apply an arbitrary filtering operation to an image. It contains all the necessary intermediate buffers. Pointers to the initialized ``FilterEngine_GPU`` instances are returned by various ``create*Filter_GPU`` functions (see below), and they are used inside high-level functions such as
:cpp:func:`gpu::filter2D`, :cpp:func:`gpu::erode`, :cpp:func:`gpu::Sobel` , and others.
:ocv:func:`gpu::filter2D`, :ocv:func:`gpu::erode`, :ocv:func:`gpu::Sobel` , and others.
By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary memory allocation for intermediate buffers and get much better performance:
::
@@ -124,13 +124,13 @@ By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary mem
The GPU filters do not support the in-place mode.
See also: :cpp:class:`gpu::BaseRowFilter_GPU`, :cpp:class:`gpu::BaseColumnFilter_GPU`, :cpp:class:`gpu::BaseFilter_GPU`, :cpp:func:`gpu::createFilter2D_GPU`, :cpp:func:`gpu::createSeparableFilter_GPU`, :cpp:func:`gpu::createBoxFilter_GPU`, :cpp:func:`gpu::createMorphologyFilter_GPU`, :cpp:func:`gpu::createLinearFilter_GPU`, :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`gpu::createDerivFilter_GPU`, :cpp:func:`gpu::createGaussianFilter_GPU`.
See also: :ocv:class:`gpu::BaseRowFilter_GPU`, :ocv:class:`gpu::BaseColumnFilter_GPU`, :ocv:class:`gpu::BaseFilter_GPU`, :ocv:func:`gpu::createFilter2D_GPU`, :ocv:func:`gpu::createSeparableFilter_GPU`, :ocv:func:`gpu::createBoxFilter_GPU`, :ocv:func:`gpu::createMorphologyFilter_GPU`, :ocv:func:`gpu::createLinearFilter_GPU`, :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`gpu::createDerivFilter_GPU`, :ocv:func:`gpu::createGaussianFilter_GPU`.
.. index:: gpu::createFilter2D_GPU
gpu::createFilter2D_GPU
---------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createFilter2D_GPU( const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType)
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createFilter2D_GPU( const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType)
Creates a non-separable filter engine with the specified filter.
@@ -140,13 +140,13 @@ gpu::createFilter2D_GPU
:param dstType: Output image type. It must be supported by ``filter2D`` .
Usually this function is used inside such high-level functions as :cpp:func:`gpu::createLinearFilter_GPU`, :cpp:func:`gpu::createBoxFilter_GPU`.
Usually this function is used inside such high-level functions as :ocv:func:`gpu::createLinearFilter_GPU`, :ocv:func:`gpu::createBoxFilter_GPU`.
.. index:: gpu::createSeparableFilter_GPU
gpu::createSeparableFilter_GPU
----------------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>& rowFilter, const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType)
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>& rowFilter, const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType)
Creates a separable filter engine with the specified filters.
@@ -160,13 +160,13 @@ gpu::createSeparableFilter_GPU
:param dstType: Output image type. It must be supported by ``columnFilter``.
Usually this function is used inside such high-level functions as :cpp:func:`gpu::createSeparableLinearFilter_GPU`.
Usually this function is used inside such high-level functions as :ocv:func:`gpu::createSeparableLinearFilter_GPU`.
.. index:: gpu::getRowSumFilter_GPU
gpu::getRowSumFilter_GPU
----------------------------
.. cpp:function:: Ptr<BaseRowFilter_GPU> gpu::getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1)
.. ocv:function:: Ptr<BaseRowFilter_GPU> gpu::getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1)
Creates a horizontal 1D box filter.
@@ -186,7 +186,7 @@ gpu::getRowSumFilter_GPU
gpu::getColumnSumFilter_GPU
-------------------------------
.. cpp:function:: Ptr<BaseColumnFilter_GPU> gpu::getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1)
.. ocv:function:: Ptr<BaseColumnFilter_GPU> gpu::getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1)
Creates a vertical 1D box filter.
@@ -206,11 +206,11 @@ gpu::getColumnSumFilter_GPU
gpu::createBoxFilter_GPU
----------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1))
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1))
Creates a normalized 2D box filter.
.. cpp:function:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1))
.. ocv:function:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1))
:param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4``.
@@ -224,13 +224,13 @@ gpu::createBoxFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`boxFilter`
See Also: :ocv:func:`boxFilter`
.. index:: gpu::boxFilter
gpu::boxFilter
------------------
.. cpp:function:: void gpu::boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1))
.. ocv:function:: void gpu::boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1))
Smooths the image using the normalized box filter.
@@ -248,13 +248,13 @@ gpu::boxFilter
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`boxFilter`
See Also: :ocv:func:`boxFilter`
.. index:: gpu::blur
gpu::blur
-------------
.. cpp:function:: void gpu::blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1))
.. ocv:function:: void gpu::blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1))
Acts as a synonym for the normalized box filter.
@@ -270,17 +270,17 @@ gpu::blur
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`blur`, :cpp:func:`gpu::boxFilter`
See Also: :ocv:func:`blur`, :ocv:func:`gpu::boxFilter`
.. index:: gpu::createMorphologyFilter_GPU
gpu::createMorphologyFilter_GPU
-----------------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1)
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1)
Creates a 2D morphological filter.
.. cpp:function:: Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize, Point anchor=Point(-1,-1))
.. ocv:function:: Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize, Point anchor=Point(-1,-1))
{Morphology operation id. Only ``MORPH_ERODE`` and ``MORPH_DILATE`` are supported.}
@@ -296,13 +296,13 @@ gpu::createMorphologyFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`createMorphologyFilter`
See Also: :ocv:func:`createMorphologyFilter`
.. index:: gpu::erode
gpu::erode
--------------
.. cpp:function:: void gpu::erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1)
.. ocv:function:: void gpu::erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1)
Erodes an image by using a specific structuring element.
@@ -320,13 +320,13 @@ gpu::erode
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`erode`
See Also: :ocv:func:`erode`
.. index:: gpu::dilate
gpu::dilate
---------------
.. cpp:function:: void gpu::dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1)
.. ocv:function:: void gpu::dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1)
Dilates an image by using a specific structuring element.
@@ -344,13 +344,13 @@ gpu::dilate
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`dilate`
See Also: :ocv:func:`dilate`
.. index:: gpu::morphologyEx
gpu::morphologyEx
---------------------
.. cpp:function:: void gpu::morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1)
.. ocv:function:: void gpu::morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1)
Applies an advanced morphological operation to an image.
@@ -381,17 +381,17 @@ gpu::morphologyEx
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`morphologyEx`
See Also: :ocv:func:`morphologyEx`
.. index:: gpu::createLinearFilter_GPU
gpu::createLinearFilter_GPU
-------------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Point& anchor = Point(-1,-1))
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Point& anchor = Point(-1,-1))
Creates a non-separable linear filter.
.. cpp:function:: Ptr<BaseFilter_GPU> gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize, Point anchor = Point(-1, -1))
.. ocv:function:: Ptr<BaseFilter_GPU> gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize, Point anchor = Point(-1, -1))
:param srcType: Input image type. ``CV_8UC1`` and ``CV_8UC4`` types are supported.
@@ -407,13 +407,13 @@ gpu::createLinearFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`createLinearFilter`
See Also: :ocv:func:`createLinearFilter`
.. index:: gpu::filter2D
gpu::filter2D
-----------------
.. cpp:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1))
.. ocv:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1))
Applies the non-separable 2D linear filter to an image.
@@ -431,13 +431,13 @@ gpu::filter2D
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`filter2D`
See Also: :ocv:func:`filter2D`
.. index:: gpu::Laplacian
gpu::Laplacian
------------------
.. cpp:function:: void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1)
.. ocv:function:: void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1)
Applies the Laplacian operator to an image.
@@ -447,21 +447,21 @@ gpu::Laplacian
:param ddepth: Desired depth of the destination image. It supports only the same depth as the source image depth.
:param ksize: Aperture size used to compute the second-derivative filters (see :cpp:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported.
:param ksize: Aperture size used to compute the second-derivative filters (see :ocv:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported.
:param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :cpp:func:`getDerivKernels` ).
:param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :ocv:func:`getDerivKernels` ).
**Note:**
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`Laplacian`,:cpp:func:`gpu::filter2D` .
See Also: :ocv:func:`Laplacian`,:ocv:func:`gpu::filter2D` .
.. index:: gpu::getLinearRowFilter_GPU
gpu::getLinearRowFilter_GPU
-------------------------------
.. cpp:function:: Ptr<BaseRowFilter_GPU> gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
.. ocv:function:: Ptr<BaseRowFilter_GPU> gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates a primitive row filter with the specified kernel.
@@ -473,19 +473,19 @@ gpu::getLinearRowFilter_GPU
:param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`. For details on limitations, see below.
:param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``,``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside the image.
See Also:,:cpp:func:`createSeparableLinearFilter` .
See Also:,:ocv:func:`createSeparableLinearFilter` .
.. index:: gpu::getLinearColumnFilter_GPU
gpu::getLinearColumnFilter_GPU
----------------------------------
.. cpp:function:: Ptr<BaseColumnFilter_GPU> gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
.. ocv:function:: Ptr<BaseColumnFilter_GPU> gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates a primitive column filter with the specified kernel.
@@ -497,19 +497,19 @@ gpu::getLinearColumnFilter_GPU
:param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` . For details on limitations, see below.
:param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` . For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
See Also: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`createSeparableLinearFilter`
.. index:: gpu::createSeparableLinearFilter_GPU
gpu::createSeparableLinearFilter_GPU
----------------------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates a separable linear filter engine.
@@ -521,16 +521,16 @@ gpu::createSeparableLinearFilter_GPU
:param anchor: Anchor position within the kernel. Negative values mean that anchor is positioned at the aperture center.
:param rowBorderType, columnBorderType: Pixel extrapolation method in the horizontal and vertical directions For details, see :cpp:func:`borderInterpolate`. For details on limitations, see :cpp:func:`gpu::getLinearRowFilter_GPU`, cpp:cpp:func:`gpu::getLinearColumnFilter_GPU`.
:param rowBorderType, columnBorderType: Pixel extrapolation method in the horizontal and vertical directions For details, see :ocv:func:`borderInterpolate`. For details on limitations, see :ocv:func:`gpu::getLinearRowFilter_GPU`, cpp:ocv:func:`gpu::getLinearColumnFilter_GPU`.
See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`gpu::getLinearColumnFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
See Also: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`gpu::getLinearColumnFilter_GPU`, :ocv:func:`createSeparableLinearFilter`
.. index:: gpu::sepFilter2D
gpu::sepFilter2D
--------------------
.. cpp:function:: void gpu::sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: void gpu::sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Applies a separable 2D linear filter to an image.
@@ -544,15 +544,15 @@ gpu::sepFilter2D
:param anchor: Anchor position within the kernel. The default value ``(-1, 1)`` means that the anchor is at the kernel center.
:param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`.
:param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`sepFilter2D`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`sepFilter2D`
.. index:: gpu::createDerivFilter_GPU
gpu::createDerivFilter_GPU
------------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates a filter engine for the generalized Sobel operator.
@@ -564,17 +564,17 @@ gpu::createDerivFilter_GPU
:param dy: Derivative order in respect of y.
:param ksize: Aperture size. See :cpp:func:`getDerivKernels` for details.
:param ksize: Aperture size. See :ocv:func:`getDerivKernels` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createDerivFilter`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`createDerivFilter`
.. index:: gpu::Sobel
gpu::Sobel
--------------
.. cpp:function:: void gpu::Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: void gpu::Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Applies the generalized Sobel operator to an image.
@@ -590,17 +590,17 @@ gpu::Sobel
:param ksize: Size of the extended Sobel kernel. Possible valies are 1, 3, 5 or 7.
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :cpp:func:`getDerivKernels` .
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :ocv:func:`getDerivKernels` .
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Sobel`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`Sobel`
.. index:: gpu::Scharr
gpu::Scharr
---------------
.. cpp:function:: void gpu::Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: void gpu::Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Calculates the first x- or y- image derivative using the Scharr operator.
@@ -614,37 +614,37 @@ gpu::Scharr
:param yorder: Order of the derivative y.
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details.
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` and :cpp:func:`Scharr` .
:param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` and :ocv:func:`Scharr` .
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Scharr`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`Scharr`
.. index:: gpu::createGaussianFilter_GPU
gpu::createGaussianFilter_GPU
---------------------------------
.. cpp:function:: Ptr<FilterEngine_GPU> gpu::createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates a Gaussian filter engine.
:param type: Source and destination image type. ``CV_8UC1``, ``CV_8UC4``, ``CV_16SC1``, ``CV_16SC2``, ``CV_32SC1``, ``CV_32FC1`` are supported.
:param ksize: Aperture size. See :cpp:func:`getGaussianKernel` for details.
:param ksize: Aperture size. See :ocv:func:`getGaussianKernel` for details.
:param sigmaX: Gaussian sigma in the horizontal direction. See :cpp:func:`getGaussianKernel` for details.
:param sigmaX: Gaussian sigma in the horizontal direction. See :ocv:func:`getGaussianKernel` for details.
:param sigmaY: Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` .
:param rowBorderType, columnBorderType: Border type to use. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType: Border type to use. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createGaussianFilter`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`createGaussianFilter`
.. index:: gpu::GaussianBlur
gpu::GaussianBlur
---------------------
.. cpp:function:: void gpu::GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. ocv:function:: void gpu::GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Smooths an image using the Gaussian filter.
@@ -654,17 +654,17 @@ gpu::GaussianBlur
:param ksize: Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. If they are zeros, they are computed from ``sigmaX`` and ``sigmaY`` .
:param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` .
:param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :ocv:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` .
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createGaussianFilter_GPU`, :cpp:func:`GaussianBlur`
See Also: :ocv:func:`gpu::createGaussianFilter_GPU`, :ocv:func:`GaussianBlur`
.. index:: gpu::getMaxFilter_GPU
gpu::getMaxFilter_GPU
-------------------------
.. cpp:function:: Ptr<BaseFilter_GPU> gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
.. ocv:function:: Ptr<BaseFilter_GPU> gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
Creates the maximum filter.
@@ -684,7 +684,7 @@ gpu::getMaxFilter_GPU
gpu::getMinFilter_GPU
-------------------------
.. cpp:function:: Ptr<BaseFilter_GPU> gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
.. ocv:function:: Ptr<BaseFilter_GPU> gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
Creates the minimum filter.
modules/gpu/doc/image_processing.rst
+60 -60
View File
@@ -7,7 +7,7 @@ Image Processing
gpu::meanShiftFiltering
---------------------------
.. cpp:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
.. ocv:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
Performs mean-shift filtering for each point of the source image. 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.
@@ -19,13 +19,13 @@ gpu::meanShiftFiltering
:param sr: Color window radius.
:param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
:param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
.. index:: gpu::meanShiftProc
gpu::meanShiftProc
----------------------
.. cpp:function:: void gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
.. ocv:function:: void gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.
@@ -39,16 +39,16 @@ gpu::meanShiftProc
:param sr: Color window radius.
:param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
:param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
See Also:
:cpp:func:`gpu::meanShiftFiltering`
:ocv:func:`gpu::meanShiftFiltering`
.. index:: gpu::meanShiftSegmentation
gpu::meanShiftSegmentation
------------------------------
.. cpp:function:: void gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
.. ocv:function:: void gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
Performs a mean-shift segmentation of the source image and eliminates small segments.
@@ -62,15 +62,15 @@ gpu::meanShiftSegmentation
:param minsize: Minimum segment size. Smaller segements are merged.
:param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
:param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
.. index:: gpu::integral
gpu::integral
-----------------
.. cpp:function:: void gpu::integral(const GpuMat& src, GpuMat& sum)
.. ocv:function:: void gpu::integral(const GpuMat& src, GpuMat& sum)
.. cpp:function:: void gpu::integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum)
.. ocv:function:: void gpu::integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum)
Computes an integral image and a squared integral image.
@@ -81,13 +81,13 @@ gpu::integral
:param sqsum: Squared integral image of the ``CV_32FC1`` type.
See Also:
:cpp:func:`integral`
:ocv:func:`integral`
.. index:: gpu::sqrIntegral
gpu::sqrIntegral
--------------------
.. cpp:function:: void gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum)
.. ocv:function:: void gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum)
Computes a squared integral image.
@@ -99,7 +99,7 @@ gpu::sqrIntegral
gpu::columnSum
------------------
.. cpp:function:: void gpu::columnSum(const GpuMat& src, GpuMat& sum)
.. ocv:function:: void gpu::columnSum(const GpuMat& src, GpuMat& sum)
Computes a vertical (column) sum.
@@ -111,7 +111,7 @@ gpu::columnSum
gpu::cornerHarris
---------------------
.. cpp:function:: void gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
.. ocv:function:: void gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
Computes the Harris cornerness criteria at each image pixel.
@@ -128,13 +128,13 @@ gpu::cornerHarris
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
See Also:
:cpp:func:`cornerHarris`
:ocv:func:`cornerHarris`
.. index:: gpu::cornerMinEigenVal
gpu::cornerMinEigenVal
--------------------------
.. cpp:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
.. ocv:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
Computes the minimum eigen value of 2x2 derivative covariation matrix at each pixel (the cornerness criteria).
@@ -150,13 +150,13 @@ gpu::cornerMinEigenVal
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
See also: :cpp:func:`cornerMinEigenVal`
See also: :ocv:func:`cornerMinEigenVal`
.. index:: gpu::mulSpectrums
gpu::mulSpectrums
---------------------
.. cpp:function:: void gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false)
.. ocv:function:: void gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false)
Performs a per-element multiplication of two Fourier spectrums.
@@ -173,13 +173,13 @@ gpu::mulSpectrums
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
See Also:
:cpp:func:`mulSpectrums`
:ocv:func:`mulSpectrums`
.. index:: gpu::mulAndScaleSpectrums
gpu::mulAndScaleSpectrums
-----------------------------
.. cpp:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false)
.. ocv:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false)
Performs a per-element multiplication of two Fourier spectrums and scales the result.
@@ -198,13 +198,13 @@ gpu::mulAndScaleSpectrums
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
See Also:
:cpp:func:`mulSpectrums`
:ocv:func:`mulSpectrums`
.. index:: gpu::dft
gpu::dft
------------
.. cpp:function:: void gpu::dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0)
.. ocv:function:: void gpu::dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0)
Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix. Use to handle real matrices (``CV32FC1``) and complex matrices in the interleaved format (``CV32FC2``).
@@ -237,15 +237,15 @@ gpu::dft
If the source matrix is real (its type is ``CV_32FC1`` ), forward DFT is performed. The result of the DFT is packed into complex ( ``CV_32FC2`` ) matrix. So, the width of the destination matrix is ``dft_size.width / 2 + 1`` . But if the source is a single column, the height is reduced instead of the width.
See Also:
:cpp:func:`dft`
:ocv:func:`dft`
.. index:: gpu::convolve
gpu::convolve
-----------------
.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr=false)
.. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr=false)
.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf)
.. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf)
Computes a convolution (or cross-correlation) of two images.
@@ -265,10 +265,10 @@ gpu::convolve
gpu::ConvolveBuf
----------------
.. cpp:class:: gpu::ConvolveBuf
.. ocv:class:: gpu::ConvolveBuf
This class provides a memory buffer for the
:cpp:func:`gpu::convolve` function.
:ocv:func:`gpu::convolve` function.
::
struct CV_EXPORTS ConvolveBuf
@@ -287,21 +287,21 @@ This class provides a memory buffer for the
gpu::ConvolveBuf::ConvolveBuf
---------------------------------
.. cpp:function:: ConvolveBuf::ConvolveBuf()
.. ocv:function:: ConvolveBuf::ConvolveBuf()
Constructs an empty buffer that is properly resized after the first call of the
:cpp:func:`convolve` function.
:ocv:func:`convolve` function.
.. cpp:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size)
.. ocv:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size)
Constructs a buffer for the
:cpp:func:`convolve` function with respective arguments.
:ocv:func:`convolve` function with respective arguments.
.. index:: gpu::matchTemplate
gpu::matchTemplate
----------------------
.. cpp:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method)
.. ocv:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method)
Computes a proximity map for a raster template and an image where the template is searched for.
@@ -328,13 +328,13 @@ gpu::matchTemplate
* ``CV_TM_CCORR``
See Also:
:cpp:func:`matchTemplate`
:ocv:func:`matchTemplate`
.. index:: gpu::remap
gpu::remap
--------------
.. cpp:function:: void gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap)
.. ocv:function:: void gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap)
Applies a generic geometrical transformation to an image.
@@ -354,15 +354,15 @@ gpu::remap
Values of pixels with non-integer coordinates are computed using bilinear the interpolation.
See Also: :cpp:func:`remap`
See Also: :ocv:func:`remap`
.. index:: gpu::cvtColor
gpu::cvtColor
-----------------
.. cpp:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0)
.. ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0)
.. cpp:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const Stream& stream)
.. ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const Stream& stream)
Converts an image from one color space to another.
@@ -370,7 +370,7 @@ gpu::cvtColor
:param dst: Destination image with the same size and depth as ``src`` .
:param code: Color space conversion code. For details, see :cpp:func:`cvtColor` . Conversion to/from Luv and Bayer color spaces is not supported.
:param code: Color space conversion code. For details, see :ocv:func:`cvtColor` . Conversion to/from Luv and Bayer color spaces is not supported.
: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`` .
@@ -379,15 +379,15 @@ gpu::cvtColor
3-channel color spaces (like ``HSV``, ``XYZ``, and so on) can be stored in a 4-channel image for better perfomance.
See Also:
:cpp:func:`cvtColor`
:ocv:func:`cvtColor`
.. index:: gpu::threshold
gpu::threshold
------------------
.. cpp:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type)
.. ocv:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type)
.. cpp:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, const Stream& stream)
.. ocv:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, const Stream& stream)
Applies a fixed-level threshold to each array element.
@@ -399,18 +399,18 @@ gpu::threshold
:param maxVal: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` threshold types.
:param thresholdType: Threshold type. For details, see :cpp:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported.
:param thresholdType: Threshold type. For details, see :ocv:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported.
:param stream: Stream for the asynchronous version.
See Also:
:cpp:func:`threshold`
:ocv:func:`threshold`
.. index:: gpu::resize
gpu::resize
---------------
.. cpp:function:: void gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR)
.. ocv:function:: void gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR)
Resizes an image.
@@ -439,13 +439,13 @@ gpu::resize
:param interpolation: Interpolation method. Only ``INTER_NEAREST`` and ``INTER_LINEAR`` are supported.
See Also: :cpp:func:`resize`
See Also: :ocv:func:`resize`
.. index:: gpu::warpAffine
gpu::warpAffine
-------------------
.. cpp:function:: void gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
.. ocv:function:: void gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
Applies an affine transformation to an image.
@@ -457,16 +457,16 @@ gpu::warpAffine
:param dsize: Size of the destination image.
:param flags: Combination of interpolation methods (see :cpp:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
:param flags: Combination of interpolation methods (see :ocv:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
See Also:
:cpp:func:`warpAffine`
:ocv:func:`warpAffine`
.. index:: gpu::warpPerspective
gpu::warpPerspective
------------------------
.. cpp:function:: void gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
.. ocv:function:: void gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
Applies a perspective transformation to an image.
@@ -478,16 +478,16 @@ gpu::warpPerspective
:param dsize: Size of the destination image.
:param flags: Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
:param flags: Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
See Also:
:cpp:func:`warpPerspective`
:ocv:func:`warpPerspective`
.. index:: gpu::rotate
gpu::rotate
---------------
.. cpp:function:: void gpu::rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR)
.. ocv:function:: void gpu::rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR)
Rotates an image around the origin (0,0) and then shifts it.
@@ -506,13 +506,13 @@ gpu::rotate
:param interpolation: Interpolation method. Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` are supported.
See Also:
:cpp:func:`gpu::warpAffine`
:ocv:func:`gpu::warpAffine`
.. index:: gpu::copyMakeBorder
gpu::copyMakeBorder
-----------------------
.. cpp:function:: void gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar())
.. ocv:function:: void gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar())
Copies a 2D array to a larger destination array and pads borders with the given constant.
@@ -525,13 +525,13 @@ gpu::copyMakeBorder
:param value: Border value.
See Also:
:cpp:func:`copyMakeBorder`
:ocv:func:`copyMakeBorder`
.. index:: gpu::rectStdDev
gpu::rectStdDev
-------------------
.. cpp:function:: void gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect)
.. ocv:function:: void gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect)
Computes a standard deviation of integral images.
@@ -547,7 +547,7 @@ gpu::rectStdDev
gpu::evenLevels
-------------------
.. cpp:function:: void gpu::evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel)
.. ocv:function:: void gpu::evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel)
Computes levels with even distribution.
@@ -563,9 +563,9 @@ gpu::evenLevels
gpu::histEven
-----------------
.. cpp:function:: void gpu::histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel)
.. ocv:function:: void gpu::histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel)
.. cpp:function:: void gpu::histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4])
.. ocv:function:: void gpu::histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4])
Calculates a histogram with evenly distributed bins.
@@ -583,9 +583,9 @@ gpu::histEven
gpu::histRange
------------------
.. cpp:function:: void gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels)
.. ocv:function:: void gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels)
.. cpp:function:: void gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4])
.. ocv:function:: void gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4])
Calculates a histogram with bins determined by the `levels` array.
modules/gpu/doc/initalization_and_information.rst
+26 -26
View File
@@ -7,7 +7,7 @@ Initalization and Information
gpu::getCudaEnabledDeviceCount
----------------------------------
.. cpp:function:: int getCudaEnabledDeviceCount()
.. ocv:function:: int getCudaEnabledDeviceCount()
Returns the number of installed CUDA-enabled devices. Use this function before any other GPU functions calls. If OpenCV is compiled without GPU support, this function returns 0.
@@ -15,7 +15,7 @@ gpu::getCudaEnabledDeviceCount
gpu::setDevice
------------------
.. cpp:function:: void setDevice(int device)
.. ocv:function:: void setDevice(int device)
Sets a device and initializes it for the current thread. If the call of this function is omitted, a default device is initialized at the fist GPU usage.
@@ -25,7 +25,7 @@ gpu::setDevice
gpu::getDevice
------------------
.. cpp:function:: int getDevice()
.. ocv:function:: int getDevice()
Returns the current device index that was set by ``{gpu::getDevice}`` or initialized by default.
@@ -33,7 +33,7 @@ gpu::getDevice
gpu::GpuFeature
---------------
.. cpp:class:: gpu::GpuFeature
.. ocv:class:: gpu::GpuFeature
This class provides GPU computing features.
::
@@ -51,7 +51,7 @@ This class provides GPU computing features.
gpu::DeviceInfo
---------------
.. cpp:class:: gpu::DeviceInfo
.. ocv:class:: gpu::DeviceInfo
This class provides functionality for querying the specified GPU properties.
::
@@ -82,9 +82,9 @@ This class provides functionality for querying the specified GPU properties.
gpu::DeviceInfo::DeviceInfo
-------------------------------
.. cpp:function:: gpu::DeviceInfo::DeviceInfo()
.. ocv:function:: gpu::DeviceInfo::DeviceInfo()
.. cpp:function:: gpu::DeviceInfo::DeviceInfo(int device_id)
.. ocv:function:: gpu::DeviceInfo::DeviceInfo(int device_id)
Constructs the ``DeviceInfo`` object for the specified device. If ``device_id`` parameter is missed, it constructs an object for the current device.
@@ -94,7 +94,7 @@ gpu::DeviceInfo::DeviceInfo
gpu::DeviceInfo::name
-------------------------
.. cpp:function:: string gpu::DeviceInfo::name()
.. ocv:function:: string gpu::DeviceInfo::name()
Returns the device name.
@@ -102,7 +102,7 @@ gpu::DeviceInfo::name
gpu::DeviceInfo::majorVersion
---------------------------------
.. cpp:function:: int gpu::DeviceInfo::majorVersion()
.. ocv:function:: int gpu::DeviceInfo::majorVersion()
Returns the major compute capability version.
@@ -110,7 +110,7 @@ gpu::DeviceInfo::majorVersion
gpu::DeviceInfo::minorVersion
---------------------------------
.. cpp:function:: int gpu::DeviceInfo::minorVersion()
.. ocv:function:: int gpu::DeviceInfo::minorVersion()
Returns the minor compute capability version.
@@ -118,7 +118,7 @@ gpu::DeviceInfo::minorVersion
gpu::DeviceInfo::multiProcessorCount
----------------------------------------
.. cpp:function:: int gpu::DeviceInfo::multiProcessorCount()
.. ocv:function:: int gpu::DeviceInfo::multiProcessorCount()
Returns the number of streaming multiprocessors.
@@ -126,7 +126,7 @@ gpu::DeviceInfo::multiProcessorCount
gpu::DeviceInfo::freeMemory
-------------------------------
.. cpp:function:: size_t gpu::DeviceInfo::freeMemory()
.. ocv:function:: size_t gpu::DeviceInfo::freeMemory()
Returns the amount of free memory in bytes.
@@ -134,7 +134,7 @@ gpu::DeviceInfo::freeMemory
gpu::DeviceInfo::totalMemory
--------------------------------
.. cpp:function:: size_t gpu::DeviceInfo::totalMemory()
.. ocv:function:: size_t gpu::DeviceInfo::totalMemory()
Returns the amount of total memory in bytes.
@@ -142,17 +142,17 @@ gpu::DeviceInfo::totalMemory
gpu::DeviceInfo::supports
-----------------------------
.. cpp:function:: bool gpu::DeviceInfo::supports(GpuFeature feature)
.. ocv:function:: bool gpu::DeviceInfo::supports(GpuFeature feature)
Provides information on GPU feature support. This function returns true if the device has the specified GPU feature. Otherwise, it returns false.
:param feature: Feature to be checked. See :cpp:class:`gpu::GpuFeature`.
:param feature: Feature to be checked. See :ocv:class:`gpu::GpuFeature`.
.. index:: gpu::DeviceInfo::isCompatible
gpu::DeviceInfo::isCompatible
---------------------------------
.. cpp:function:: bool gpu::DeviceInfo::isCompatible()
.. ocv:function:: bool gpu::DeviceInfo::isCompatible()
Checks the GPU module and device compatibility. This function returns ``true`` if the GPU module can be run on the specified device. Otherwise, it returns false.
@@ -162,31 +162,31 @@ gpu::DeviceInfo::isCompatible
gpu::TargetArchs
----------------
.. cpp:class:: gpu::TargetArchs
.. ocv:class:: gpu::TargetArchs
This class provides a set of static methods to check what NVIDIA* card architecture the GPU module was built for.
The following method checks whether the module was built with the support of the given feature:
.. cpp:function:: static bool gpu::TargetArchs::builtWith(GpuFeature feature)
.. ocv:function:: static bool gpu::TargetArchs::builtWith(GpuFeature feature)
:param feature: Feature to be checked. See :cpp:class:`gpu::GpuFeature`.
:param feature: Feature to be checked. See :ocv:class:`gpu::GpuFeature`.
There is a set of methods to check whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s):
.. cpp:function:: static bool gpu::TargetArchs::has(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::has(int major, int minor)
.. cpp:function:: static bool gpu::TargetArchs::hasPtx(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::hasPtx(int major, int minor)
.. cpp:function:: static bool gpu::TargetArchs::hasBin(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::hasBin(int major, int minor)
.. cpp:function:: static bool gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor)
.. cpp:function:: static bool gpu::TargetArchs::hasEqualOrGreater(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::hasEqualOrGreater(int major, int minor)
.. cpp:function:: static bool gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor)
.. cpp:function:: static bool gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor)
.. ocv:function:: static bool gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor)
:param major: Major compute capability version.
modules/gpu/doc/introduction.rst
+6 -6
View File
@@ -15,9 +15,9 @@ The GPU module depends on the CUDA Toolkit and NVIDIA Performance Primitives lib
The OpenCV GPU module is designed for ease of use and does not require any knowledge of CUDA. Though, such a knowledge will certainly be useful to handle non-trivial cases or achieve the highest performance. It is helpful to understand the cost of various operations, what the GPU does, what the preferred data formats are, and so on. The GPU module is an effective instrument for quick implementation of GPU-accelerated computer vision algorithms. However, if your algorithm involves many simple operations, then, for the best possible performance, you may still need to write your own kernels to avoid extra write and read operations on the intermediate results.
To enable CUDA support, configure OpenCV using ``CMake`` with ``WITH_CUDA=ON`` . When the flag is set and if CUDA is installed, the full-featured OpenCV GPU module is built. Otherwise, the module is still built, but at runtime all functions from the module throw
:cpp:func:`Exception` with ``CV_GpuNotSupported`` error code, except for
:cpp:func:`gpu::getCudaEnabledDeviceCount()`. The latter function returns zero GPU count in this case. Building OpenCV without CUDA support does not perform device code compilation, so it does not require the CUDA Toolkit installed. Therefore, using the
:cpp:func:`gpu::getCudaEnabledDeviceCount()` function, you can implement a high-level algorithm that will detect GPU presence at runtime and choose an appropriate implementation (CPU or GPU) accordingly.
:ocv:func:`Exception` with ``CV_GpuNotSupported`` error code, except for
:ocv:func:`gpu::getCudaEnabledDeviceCount()`. The latter function returns zero GPU count in this case. Building OpenCV without CUDA support does not perform device code compilation, so it does not require the CUDA Toolkit installed. Therefore, using the
:ocv:func:`gpu::getCudaEnabledDeviceCount()` function, you can implement a high-level algorithm that will detect GPU presence at runtime and choose an appropriate implementation (CPU or GPU) accordingly.
Compilation for Different NVIDIA* Platforms
-------------------------------------------
@@ -34,12 +34,12 @@ By default, the OpenCV GPU module includes:
PTX code for compute capabilities 1.1 and 1.3 (controlled by ``CUDA_ARCH_PTX`` in ``CMake``)
This means that for devices with CC 1.3 and 2.0 binary images are ready to run. For all newer platforms, the PTX code for 1.3 is JIT'ed to a binary image. For devices with CC 1.1 and 1.2, the PTX for 1.1 is JIT'ed. For devices with CC 1.0, no code is available and the functions throw
:cpp:func:`Exception`. For platforms where JIT compilation is performed first, the run is slow.
:ocv:func:`Exception`. For platforms where JIT compilation is performed first, the run is slow.
On a GPU with CC 1.0, you can still compile the GPU module and most of the functions will run flawlessly. To achieve this, add "1.0" to the list of binaries, for example, ``CUDA_ARCH_BIN="1.0 1.3 2.0"`` . The functions that cannot be run on CC 1.0 GPUs throw an exception.
You can always determine at runtime whether the OpenCV GPU-built binaries (or PTX code) are compatible with your GPU. The function
:cpp:func:`gpu::DeviceInfo::isCompatible` returns the compatibility status (true/false).
:ocv:func:`gpu::DeviceInfo::isCompatible` returns the compatibility status (true/false).
Threading and Multi-threading
------------------------------
@@ -57,7 +57,7 @@ In the current version, each of the OpenCV GPU algorithms can use only a single
*
If you use only synchronous functions, create several CPU threads (one per each GPU) and from within each thread create a CUDA context for the corresponding GPU using
:cpp:func:`gpu::setDevice()` or Driver API. Each of the threads will use the associated GPU.
:ocv:func:`gpu::setDevice()` or Driver API. Each of the threads will use the associated GPU.
*
If you use asynchronous functions, you can use the Driver API to create several CUDA contexts associated with different GPUs but attached to one CPU thread. Within the thread you can switch from one GPU to another by making the corresponding context "current". With non-blocking GPU calls, managing algorithm is clear.
modules/gpu/doc/matrix_reductions.rst
+22 -22
View File
@@ -7,7 +7,7 @@ Matrix Reductions
gpu::meanStdDev
-------------------
.. cpp:function:: void gpu::meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
.. ocv:function:: void gpu::meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
Computes a mean value and a standard deviation of matrix elements.
@@ -17,15 +17,15 @@ gpu::meanStdDev
:param stddev: Standard deviation value.
See Also: :cpp:func:`meanStdDev`
See Also: :ocv:func:`meanStdDev`
.. index:: gpu::norm
gpu::norm
-------------
.. cpp:function:: double gpu::norm(const GpuMat\& src1, int normType=NORM_L2)
.. cpp:function:: double gpu::norm(const GpuMat\& src1, int normType, GpuMat\& buf)
.. cpp:function:: double norm(const GpuMat\& src1, const GpuMat\& src2, int normType=NORM_L2)
.. ocv:function:: double gpu::norm(const GpuMat\& src1, int normType=NORM_L2)
.. ocv:function:: double gpu::norm(const GpuMat\& src1, int normType, GpuMat\& buf)
.. ocv:function:: double norm(const GpuMat\& src1, const GpuMat\& src2, int normType=NORM_L2)
Returns the norm of matrix (or difference of two matrices).
@@ -37,15 +37,15 @@ gpu::norm
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
See Also: :cpp:func:`norm`
See Also: :ocv:func:`norm`
.. index:: gpu::sum
gpu::sum
------------
.. cpp:function:: Scalar gpu::sum(const GpuMat\& src)
.. ocv:function:: Scalar gpu::sum(const GpuMat\& src)
.. cpp:function:: Scalar gpu::sum(const GpuMat\& src, GpuMat\& buf)
.. ocv:function:: Scalar gpu::sum(const GpuMat\& src, GpuMat\& buf)
Returns the sum of matrix elements.
@@ -53,15 +53,15 @@ gpu::sum
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
See Also: :cpp:func:`sum`
See Also: :ocv:func:`sum`
.. index:: gpu::absSum
gpu::absSum
---------------
.. cpp:function:: Scalar gpu::absSum(const GpuMat\& src)
.. ocv:function:: Scalar gpu::absSum(const GpuMat\& src)
.. cpp:function:: Scalar gpu::absSum(const GpuMat\& src, GpuMat\& buf)
.. ocv:function:: Scalar gpu::absSum(const GpuMat\& src, GpuMat\& buf)
Returns the sum of absolute values for matrix elements.
@@ -73,9 +73,9 @@ gpu::absSum
gpu::sqrSum
---------------
.. cpp:function:: Scalar gpu::sqrSum(const GpuMat\& src)
.. ocv:function:: Scalar gpu::sqrSum(const GpuMat\& src)
.. cpp:function:: Scalar gpu::sqrSum(const GpuMat\& src, GpuMat\& buf)
.. ocv:function:: Scalar gpu::sqrSum(const GpuMat\& src, GpuMat\& buf)
Returns the squared sum of matrix elements.
@@ -87,9 +87,9 @@ gpu::sqrSum
gpu::minMax
---------------
.. cpp:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal=0, const GpuMat\& mask=GpuMat())
.. ocv:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal=0, const GpuMat\& mask=GpuMat())
.. cpp:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal, const GpuMat\& mask, GpuMat\& buf)
.. ocv:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal, const GpuMat\& mask, GpuMat\& buf)
Finds global minimum and maximum matrix elements and returns their values.
@@ -105,15 +105,15 @@ gpu::minMax
The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
See Also: :cpp:func:`minMaxLoc`
See Also: :ocv:func:`minMaxLoc`
.. index:: gpu::minMaxLoc
gpu::minMaxLoc
------------------
.. cpp:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, const GpuMat& mask=GpuMat())
.. ocv:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, const GpuMat& mask=GpuMat())
.. cpp:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf)
.. ocv:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf)
Finds global minimum and maximum matrix elements and returns their values with locations.
@@ -135,15 +135,15 @@ gpu::minMaxLoc
The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3.
See Also: :cpp:func:`minMaxLoc`
See Also: :ocv:func:`minMaxLoc`
.. index:: gpu::countNonZero
gpu::countNonZero
---------------------
.. cpp:function:: int gpu::countNonZero(const GpuMat\& src)
.. ocv:function:: int gpu::countNonZero(const GpuMat\& src)
.. cpp:function:: int gpu::countNonZero(const GpuMat\& src, GpuMat\& buf)
.. ocv:function:: int gpu::countNonZero(const GpuMat\& src, GpuMat\& buf)
Counts non-zero matrix elements.
@@ -153,4 +153,4 @@ gpu::countNonZero
The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
See Also: :cpp:func:`countNonZero`
See Also: :ocv:func:`countNonZero`
modules/gpu/doc/object_detection.rst
+22 -22
View File
@@ -7,7 +7,7 @@ Object Detection
gpu::HOGDescriptor
------------------
.. cpp:class:: gpu::HOGDescriptor
.. ocv:class:: gpu::HOGDescriptor
This class provides a histogram of Oriented Gradients [Navneet Dalal and Bill Triggs. Histogram of oriented gradients for human detection. 2005.] descriptor and detector.
::
@@ -67,7 +67,7 @@ Interfaces of all methods are kept similar to the ``CPU HOG`` descriptor and det
gpu::HOGDescriptor::HOGDescriptor
-------------------------------------
.. cpp:function:: gpu::HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128),
.. ocv:function:: gpu::HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128),
Size block_size=Size(16, 16), Size block_stride=Size(8, 8),
Size cell_size=Size(8, 8), int nbins=9,
double win_sigma=DEFAULT_WIN_SIGMA,
@@ -98,7 +98,7 @@ gpu::HOGDescriptor::HOGDescriptor
gpu::HOGDescriptor::getDescriptorSize
-----------------------------------------
.. cpp:function:: size_t gpu::HOGDescriptor::getDescriptorSize() const
.. ocv:function:: size_t gpu::HOGDescriptor::getDescriptorSize() const
Returns the number of coefficients required for the classification.
@@ -106,7 +106,7 @@ gpu::HOGDescriptor::getDescriptorSize
gpu::HOGDescriptor::getBlockHistogramSize
---------------------------------------------
.. cpp:function:: size_t gpu::HOGDescriptor::getBlockHistogramSize() const
.. ocv:function:: size_t gpu::HOGDescriptor::getBlockHistogramSize() const
Returns the block histogram size.
@@ -114,7 +114,7 @@ gpu::HOGDescriptor::getBlockHistogramSize
gpu::HOGDescriptor::setSVMDetector
--------------------------------------
.. cpp:function:: void gpu::HOGDescriptor::setSVMDetector(const vector<float>\& detector)
.. ocv:function:: void gpu::HOGDescriptor::setSVMDetector(const vector<float>\& detector)
Sets coefficients for the linear SVM classifier.
@@ -122,7 +122,7 @@ gpu::HOGDescriptor::setSVMDetector
gpu::HOGDescriptor::getDefaultPeopleDetector
------------------------------------------------
.. cpp:function:: static vector<float> gpu::HOGDescriptor::getDefaultPeopleDetector()
.. ocv:function:: static vector<float> gpu::HOGDescriptor::getDefaultPeopleDetector()
Returns coefficients of the classifier trained for people detection (for default window size).
@@ -130,7 +130,7 @@ gpu::HOGDescriptor::getDefaultPeopleDetector
gpu::HOGDescriptor::getPeopleDetector48x96
----------------------------------------------
.. cpp:function:: static vector<float> gpu::HOGDescriptor::getPeopleDetector48x96()
.. ocv:function:: static vector<float> gpu::HOGDescriptor::getPeopleDetector48x96()
Returns coefficients of the classifier trained for people detection (for 48x96 windows).
@@ -138,7 +138,7 @@ gpu::HOGDescriptor::getPeopleDetector48x96
gpu::HOGDescriptor::getPeopleDetector64x128
-----------------------------------------------
.. cpp:function:: static vector<float> gpu::HOGDescriptor::getPeopleDetector64x128()
.. ocv:function:: static vector<float> gpu::HOGDescriptor::getPeopleDetector64x128()
Returns coefficients of the classifier trained for people detection (for 64x128 windows).
@@ -146,7 +146,7 @@ gpu::HOGDescriptor::getPeopleDetector64x128
gpu::HOGDescriptor::detect
------------------------------
.. cpp:function:: void gpu::HOGDescriptor::detect(const GpuMat\& img,
.. ocv:function:: void gpu::HOGDescriptor::detect(const GpuMat\& img,
vector<Point>\& found_locations, double hit_threshold=0,
Size win_stride=Size(), Size padding=Size())
@@ -166,18 +166,18 @@ gpu::HOGDescriptor::detect
gpu::HOGDescriptor::detectMultiScale
----------------------------------------
.. cpp:function:: void gpu::HOGDescriptor::detectMultiScale(const GpuMat\& img,
.. ocv:function:: void gpu::HOGDescriptor::detectMultiScale(const GpuMat\& img,
vector<Rect>\& found_locations, double hit_threshold=0,
Size win_stride=Size(), Size padding=Size(),
double scale0=1.05, int group_threshold=2)
Performs object detection with a multi-scale window.
:param img: Source image. See :cpp:func:`gpu::HOGDescriptor::detect` for type limitations.
:param img: Source image. See :ocv:func:`gpu::HOGDescriptor::detect` for type limitations.
:param found_locations: Detected objects boundaries.
:param hit_threshold: Threshold for the distance between features and SVM classifying plane. See :cpp:func:`gpu::HOGDescriptor::detect` for details.
:param hit_threshold: Threshold for the distance between features and SVM classifying plane. See :ocv:func:`gpu::HOGDescriptor::detect` for details.
:param win_stride: Window stride. It must be a multiple of block stride.
@@ -185,19 +185,19 @@ gpu::HOGDescriptor::detectMultiScale
:param scale0: Coefficient of the detection window increase.
:param group_threshold: Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See :cpp:func:`groupRectangles` .
:param group_threshold: Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See :ocv:func:`groupRectangles` .
.. index:: gpu::HOGDescriptor::getDescriptors
gpu::HOGDescriptor::getDescriptors
--------------------------------------
.. cpp:function:: void gpu::HOGDescriptor::getDescriptors(const GpuMat\& img,
.. ocv:function:: void gpu::HOGDescriptor::getDescriptors(const GpuMat\& img,
Size win_stride, GpuMat\& descriptors,
int descr_format=DESCR_FORMAT_COL_BY_COL)
Returns block descriptors computed for the whole image. The function is mainly used to learn the classifier.
:param img: Source image. See :cpp:func:`gpu::HOGDescriptor::detect` for type limitations.
:param img: Source image. See :ocv:func:`gpu::HOGDescriptor::detect` for type limitations.
:param win_stride: Window stride. It must be a multiple of block stride.
@@ -214,7 +214,7 @@ gpu::HOGDescriptor::getDescriptors
gpu::CascadeClassifier_GPU
--------------------------
.. cpp:class:: gpu::CascadeClassifier_GPU
.. ocv:class:: gpu::CascadeClassifier_GPU
This cascade classifier class is used for object detection.
::
@@ -247,7 +247,7 @@ This cascade classifier class is used for object detection.
gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
-----------------------------------------------------
.. cpp:function:: gpu::CascadeClassifier_GPU(const string\& filename)
.. ocv:function:: gpu::CascadeClassifier_GPU(const string\& filename)
Loads the classifier from a file.
@@ -259,7 +259,7 @@ gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
gpu::CascadeClassifier_GPU::empty
-------------------------------------
.. cpp:function:: bool gpu::CascadeClassifier_GPU::empty() const
.. ocv:function:: bool gpu::CascadeClassifier_GPU::empty() const
Checks whether the classifier is loaded or not.
@@ -269,7 +269,7 @@ gpu::CascadeClassifier_GPU::empty
gpu::CascadeClassifier_GPU::load
------------------------------------
.. cpp:function:: bool gpu::CascadeClassifier_GPU::load(const string\& filename)
.. ocv:function:: bool gpu::CascadeClassifier_GPU::load(const string\& filename)
Loads the classifier from a file. The previous content is destroyed.
@@ -279,7 +279,7 @@ gpu::CascadeClassifier_GPU::load
gpu::CascadeClassifier_GPU::release
---------------------------------------
.. cpp:function:: void gpu::CascadeClassifier_GPU::release()
.. ocv:function:: void gpu::CascadeClassifier_GPU::release()
Destroys the loaded classifier.
@@ -287,7 +287,7 @@ gpu::CascadeClassifier_GPU::release
gpu::CascadeClassifier_GPU::detectMultiScale
------------------------------------------------
.. cpp:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.
@@ -324,5 +324,5 @@ gpu::CascadeClassifier_GPU::detectMultiScale
imshow("Faces", image_cpu);
See Also: :cpp:func:`CascadeClassifier::detectMultiScale`
See Also: :ocv:func:`CascadeClassifier::detectMultiScale`
modules/gpu/doc/operations_on_matrices.rst
+32 -32
View File
@@ -7,7 +7,7 @@ Operations on Matrices
gpu::transpose
------------------
.. cpp:function:: void gpu::transpose(const GpuMat& src, GpuMat& dst)
.. ocv:function:: void gpu::transpose(const GpuMat& src, GpuMat& dst)
Transposes a matrix.
@@ -16,13 +16,13 @@ gpu::transpose
:param dst: Destination matrix.
See Also:
:cpp:func:`transpose`
:ocv:func:`transpose`
.. index:: gpu::flip
gpu::flip
-------------
.. cpp:function:: void gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode)
.. ocv:function:: void gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode)
Flips a 2D matrix around vertical, horizontal, or both axes.
@@ -40,13 +40,13 @@ gpu::flip
See Also:
:cpp:func:`flip`
:ocv:func:`flip`
.. index:: gpu::LUT
gpu::LUT
------------
.. cpp:function:: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst)
.. ocv:function:: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst)
Transforms the source matrix into the destination matrix using the given look-up table: ``dst(I) = lut(src(I))``
@@ -57,19 +57,19 @@ gpu::LUT
:param dst: Destination matrix with the same depth as ``lut`` and the same number of channels as ``src``.
See Also: :cpp:func:`LUT`
See Also: :ocv:func:`LUT`
.. index:: gpu::merge
gpu::merge
--------------
.. cpp:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst)
.. ocv:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst)
.. cpp:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, const Stream& stream)
.. ocv:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, const Stream& stream)
.. cpp:function:: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst)
.. ocv:function:: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst)
.. cpp:function:: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst, const Stream& stream)
.. ocv:function:: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst, const Stream& stream)
Makes a multi-channel matrix out of several single-channel matrices.
@@ -81,19 +81,19 @@ gpu::merge
:param stream: Stream for the asynchronous version.
See Also: :cpp:func:`merge`
See Also: :ocv:func:`merge`
.. index:: gpu::split
gpu::split
--------------
.. cpp:function:: void gpu::split(const GpuMat& src, GpuMat* dst)
.. ocv:function:: void gpu::split(const GpuMat& src, GpuMat* dst)
.. cpp:function:: void gpu::split(const GpuMat& src, GpuMat* dst, const Stream& stream)
.. ocv:function:: void gpu::split(const GpuMat& src, GpuMat* dst, const Stream& stream)
.. cpp:function:: void gpu::split(const GpuMat& src, vector<GpuMat>& dst)
.. ocv:function:: void gpu::split(const GpuMat& src, vector<GpuMat>& dst)
.. cpp:function:: void gpu::split(const GpuMat& src, vector<GpuMat>& dst, const Stream& stream)
.. ocv:function:: void gpu::split(const GpuMat& src, vector<GpuMat>& dst, const Stream& stream)
Copies each plane of a multi-channel matrix into an array.
@@ -103,17 +103,17 @@ gpu::split
:param stream: Stream for the asynchronous version.
See Also: :cpp:func:`split`
See Also: :ocv:func:`split`
.. index:: gpu::magnitude
gpu::magnitude
------------------
.. cpp:function:: void gpu::magnitude(const GpuMat& xy, GpuMat& magnitude)
.. ocv:function:: void gpu::magnitude(const GpuMat& xy, GpuMat& magnitude)
.. cpp:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude)
.. ocv:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude)
.. cpp:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream)
.. ocv:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream)
Computes magnitudes of complex matrix elements.
@@ -128,17 +128,17 @@ gpu::magnitude
:param stream: Stream for the asynchronous version.
See Also:
:cpp:func:`magnitude`
:ocv:func:`magnitude`
.. index:: gpu::magnitudeSqr
gpu::magnitudeSqr
---------------------
.. cpp:function:: void gpu::magnitudeSqr(const GpuMat& xy, GpuMat& magnitude)
.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& xy, GpuMat& magnitude)
.. cpp:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude)
.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude)
.. cpp:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream)
.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream)
Computes squared magnitudes of complex matrix elements.
@@ -156,9 +156,9 @@ gpu::magnitudeSqr
gpu::phase
--------------
.. cpp:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false)
.. ocv:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false)
.. cpp:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, const Stream& stream)
.. ocv:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, const Stream& stream)
Computes polar angles of complex matrix elements.
@@ -173,15 +173,15 @@ gpu::phase
:param stream: Stream for the asynchronous version.
See Also:
:cpp:func:`phase`
:ocv:func:`phase`
.. index:: gpu::cartToPolar
gpu::cartToPolar
--------------------
.. cpp:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false)
.. ocv:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false)
.. cpp:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees, const Stream& stream)
.. ocv:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees, const Stream& stream)
Converts Cartesian coordinates into polar.
@@ -198,15 +198,15 @@ gpu::cartToPolar
:param stream: Stream for the asynchronous version.
See Also:
:cpp:func:`cartToPolar`
:ocv:func:`cartToPolar`
.. index:: gpu::polarToCart
gpu::polarToCart
--------------------
.. cpp:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false)
.. ocv:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false)
.. cpp:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, const Stream& stream)
.. ocv:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, const Stream& stream)
Converts polar coordinates into Cartesian.
@@ -223,4 +223,4 @@ gpu::polarToCart
:param stream: Stream for the asynchronous version.
See Also:
:cpp:func:`polarToCart`
:ocv:func:`polarToCart`
modules/gpu/doc/per_element_operations.rst
+40 -40
View File
@@ -9,9 +9,9 @@ Per-element Operations.
gpu::add
------------
.. cpp:function:: void gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::add(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
.. ocv:function:: void gpu::add(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
Computes a matrix-matrix or matrix-scalar sum.
@@ -21,15 +21,15 @@ gpu::add
:param dst: Destination matrix with the same size and type as ``src1``.
See Also: :cpp:func:`add`
See Also: :ocv:func:`add`
.. index:: gpu::subtract
gpu::subtract
-----------------
.. cpp:function:: void gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::subtract(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
.. ocv:function:: void gpu::subtract(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
Computes a matrix-matrix or matrix-scalar difference.
@@ -39,7 +39,7 @@ gpu::subtract
:param dst: Destination matrix with the same size and type as ``src1``.
See Also: :cpp:func:`subtract`
See Also: :ocv:func:`subtract`
@@ -47,9 +47,9 @@ See Also: :cpp:func:`subtract`
gpu::multiply
-----------------
.. cpp:function:: void gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::multiply(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
.. ocv:function:: void gpu::multiply(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
Computes a matrix-matrix or matrix-scalar per-element product.
@@ -59,16 +59,16 @@ gpu::multiply
:param dst: Destination matrix with the same size and type as ``src1``.
See Also: :cpp:func:`multiply`
See Also: :ocv:func:`multiply`
.. index:: gpu::divide
gpu::divide
---------------
.. cpp:function:: void gpu::divide(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::divide(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::divide(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
.. ocv:function:: void gpu::divide(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
Computes a matrix-matrix or matrix-scalar sum.
@@ -78,9 +78,9 @@ gpu::divide
:param dst: Destination matrix with the same size and type as ``src1``.
This function, in contrast to :cpp:func:`divide`, uses a round-down rounding mode.
This function, in contrast to :ocv:func:`divide`, uses a round-down rounding mode.
See Also: :cpp:func:`divide`
See Also: :ocv:func:`divide`
@@ -88,7 +88,7 @@ See Also: :cpp:func:`divide`
gpu::exp
------------
.. cpp:function:: void gpu::exp(const GpuMat& src, GpuMat& dst)
.. ocv:function:: void gpu::exp(const GpuMat& src, GpuMat& dst)
Computes an exponent of each matrix element.
@@ -96,7 +96,7 @@ gpu::exp
:param dst: Destination matrix with the same size and type as ``src``.
See Also: :cpp:func:`exp`
See Also: :ocv:func:`exp`
@@ -104,7 +104,7 @@ See Also: :cpp:func:`exp`
gpu::log
------------
.. cpp:function:: void gpu::log(const GpuMat& src, GpuMat& dst)
.. ocv:function:: void gpu::log(const GpuMat& src, GpuMat& dst)
Computes a natural logarithm of absolute value of each matrix element.
@@ -112,7 +112,7 @@ gpu::log
:param dst: Destination matrix with the same size and type as ``src``.
See Also: :cpp:func:`log`
See Also: :ocv:func:`log`
@@ -120,9 +120,9 @@ See Also: :cpp:func:`log`
gpu::absdiff
----------------
.. cpp:function:: void gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
.. ocv:function:: void gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst)
Computes per-element absolute difference of two matrices (or of matrix and scalar).
@@ -132,13 +132,13 @@ gpu::absdiff
:param dst: Destination matrix with the same size and type as ``src1``.
See Also: :cpp:func:`absdiff`
See Also: :ocv:func:`absdiff`
.. index:: gpu::compare
gpu::compare
----------------
.. cpp:function:: void gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop)
.. ocv:function:: void gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop)
Compares elements of two matrices.
@@ -157,16 +157,16 @@ gpu::compare
* **CMP_LE:** ``src1(.) <= src2(.)``
* **CMP_NE:** ``src1(.) != src2(.)``
See Also: :cpp:func:`compare`
See Also: :ocv:func:`compare`
.. index:: gpu::bitwise_not
gpu::bitwise_not
--------------------
.. cpp:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat())
.. ocv:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat())
.. cpp:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, const Stream& stream)
.. ocv:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, const Stream& stream)
Performs a per-element bitwise inversion.
@@ -184,9 +184,9 @@ gpu::bitwise_not
gpu::bitwise_or
-------------------
.. cpp:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat())
.. ocv:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat())
.. cpp:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream)
.. ocv:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream)
Performs a per-element bitwise disjunction of two matrices.
@@ -206,9 +206,9 @@ gpu::bitwise_or
gpu::bitwise_and
--------------------
.. cpp:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat())
.. ocv:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat())
.. cpp:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream)
.. ocv:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream)
Performs a per-element bitwise conjunction of two matrices.
@@ -228,9 +228,9 @@ gpu::bitwise_and
gpu::bitwise_xor
--------------------
.. cpp:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat())
.. ocv:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat())
.. cpp:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream)
.. ocv:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream)
Performs a per-element bitwise "exclusive or" operation of two matrices.
@@ -250,13 +250,13 @@ gpu::bitwise_xor
gpu::min
------------
.. cpp:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream)
.. ocv:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream)
.. cpp:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst)
.. ocv:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst)
.. cpp:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream)
.. ocv:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream)
Computes the per-element minimum of two matrices (or a matrix and a scalar).
@@ -268,7 +268,7 @@ gpu::min
:param stream: Stream for the asynchronous version.
See Also: :cpp:func:`min`
See Also: :ocv:func:`min`
@@ -276,13 +276,13 @@ See Also: :cpp:func:`min`
gpu::max
------------
.. cpp:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. ocv:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst)
.. cpp:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream)
.. ocv:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream)
.. cpp:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst)
.. ocv:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst)
.. cpp:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream)
.. ocv:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream)
Computes the per-element maximum of two matrices (or a matrix and a scalar).
@@ -294,4 +294,4 @@ gpu::max
:param stream: Stream for the asynchronous version.
See Also: :cpp:func:`max`
See Also: :ocv:func:`max`