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

the first round of cleaning up the RST docs

Browse Source
This commit is contained in:
Vadim Pisarevsky
2011-02-28 21:26:43 +00:00
parent eb8c0b8b4b
commit 4bb893aa9f
48 changed files with 1664 additions and 1649 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
+33 -33
View File
@@ -9,7 +9,7 @@ Camera Calibration and 3d Reconstruction
gpu::StereoBM_GPU
-----------------
.. ctype:: gpu::StereoBM_GPU
.. c:type:: gpu::StereoBM_GPU
The class for computing stereo correspondence using block matching algorithm. ::
@@ -39,7 +39,7 @@ The class for computing stereo correspondence using block matching algorithm. ::
...
};
..
This class computes the disparity map using block matching algorithm. The class also performs pre- and post- filtering steps: sobel prefiltering (if PREFILTER_XSOBEL flag is set) and low textureness filtering (if averageTexThreshols
:math:`>` 0). If ``avergeTexThreshold = 0`` low textureness filtering is disabled, otherwise disparity is set to 0 in each point ``(x, y)`` where for left image
@@ -51,9 +51,9 @@ This class computes the disparity map using block matching algorithm. The class
cv::gpu::StereoBM_GPU::StereoBM_GPU
-----------------------------------_
.. cfunction:: StereoBM_GPU::StereoBM_GPU()
.. c:function:: StereoBM_GPU::StereoBM_GPU()
.. cfunction:: StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ)
.. c:function:: StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ)
StereoBMGPU constructors.
@@ -73,9 +73,9 @@ cv::gpu::StereoBM_GPU::StereoBM_GPU
cv::gpu::StereoBM_GPU::operator ()
----------------------------------
.. cfunction:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. c:function:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. cfunction:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, const Stream\& stream)
.. c:function:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, const Stream\& stream)
The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair.
@@ -93,7 +93,7 @@ cv::gpu::StereoBM_GPU::operator ()
cv::gpu::StereoBM_GPU::checkIfGpuCallReasonable
-----------------------------------------------
.. cfunction:: bool StereoBM_GPU::checkIfGpuCallReasonable()
.. c:function:: bool StereoBM_GPU::checkIfGpuCallReasonable()
Some heuristics that tries to estmate if the current GPU will be faster then CPU in this algorithm. It queries current active device.
@@ -103,7 +103,7 @@ cv::gpu::StereoBM_GPU::checkIfGpuCallReasonable
gpu::StereoBeliefPropagation
----------------------------
.. ctype:: gpu::StereoBeliefPropagation
.. c:type:: gpu::StereoBeliefPropagation
The class for computing stereo correspondence using belief propagation algorithm. ::
@@ -147,7 +147,7 @@ The class for computing stereo correspondence using belief propagation algorithm
...
};
..
The class implements Pedro F. Felzenszwalb algorithm
felzenszwalb_bp
@@ -171,9 +171,9 @@ for data cost storage. ``width_step`` is the number of bytes in a line including
cv::gpu::StereoBeliefPropagation::StereoBeliefPropagation
---------------------------------------------------------
.. cfunction:: StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
.. c:function:: StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
.. cfunction:: 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)
.. c:function:: 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)
StereoBeliefPropagation constructors.
@@ -216,7 +216,7 @@ By default ``StereoBeliefPropagation`` uses floating-point arithmetics and ``CV_
cv::gpu::StereoBeliefPropagation::estimateRecommendedParams
----------------------------------------------------------- ```` ```` ```` ```` ````
.. cfunction:: void StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels)
.. c:function:: void StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels)
Some heuristics that tries to compute recommended parameters (ndisp, itersand levels) for specified image size (widthand height).
@@ -224,9 +224,9 @@ cv::gpu::StereoBeliefPropagation::estimateRecommendedParams
cv::gpu::StereoBeliefPropagation::operator ()
---------------------------------------------
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream)
.. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream)
The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair or data cost.
@@ -238,9 +238,9 @@ cv::gpu::StereoBeliefPropagation::operator ()
:param stream: Stream for the asynchronous version.
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity)
.. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity)
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity, Stream\& stream)
.. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity, Stream\& stream)
* **data** The user specified data cost. It must have ``msg_type`` type and :math:`\texttt{imgRows} \cdot \texttt{ndisp} \times \texttt{imgCols}` size.
@@ -254,7 +254,7 @@ cv::gpu::StereoBeliefPropagation::operator ()
gpu::StereoConstantSpaceBP
--------------------------
.. ctype:: gpu::StereoConstantSpaceBP
.. c:type:: gpu::StereoConstantSpaceBP
The class for computing stereo correspondence using constant space belief propagation algorithm. ::
@@ -305,7 +305,7 @@ The class for computing stereo correspondence using constant space belief propag
...
};
..
The class implements Q. Yang algorithm
qx_csbp
@@ -315,9 +315,9 @@ qx_csbp
cv::gpu::StereoConstantSpaceBP::StereoConstantSpaceBP
-----------------------------------------------------
.. cfunction:: 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)
.. c:function:: 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)
.. cfunction:: 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)
.. c: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)
StereoConstantSpaceBP constructors.
@@ -364,7 +364,7 @@ By default ``StereoConstantSpaceBP`` uses floating-point arithmetics and ``CV_32
cv::gpu::StereoConstantSpaceBP::estimateRecommendedParams
--------------------------------------------------------- ```` ```` ```` ``_`` ```` ````
.. cfunction:: void StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels, int\& nr_plane)
.. c:function:: void StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels, int\& nr_plane)
Some heuristics that tries to compute parameters (ndisp, iters, levelsand nrplane) for specified image size (widthand height).
@@ -372,9 +372,9 @@ cv::gpu::StereoConstantSpaceBP::estimateRecommendedParams
cv::gpu::StereoConstantSpaceBP::operator ()
-------------------------------------------
.. cfunction:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. c:function:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. cfunction:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream)
.. c:function:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream)
The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair.
@@ -392,7 +392,7 @@ cv::gpu::StereoConstantSpaceBP::operator ()
gpu::DisparityBilateralFilter
-----------------------------
.. ctype:: gpu::DisparityBilateralFilter
.. c:type:: gpu::DisparityBilateralFilter
The class for disparity map refinement using joint bilateral filtering. ::
@@ -417,7 +417,7 @@ The class for disparity map refinement using joint bilateral filtering. ::
...
};
..
The class implements Q. Yang algorithm
qx_csbp
@@ -427,9 +427,9 @@ qx_csbp
cv::gpu::DisparityBilateralFilter::DisparityBilateralFilter
-----------------------------------------------------------
.. cfunction:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
.. c:function:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
.. cfunction:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
.. c:function:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
DisparityBilateralFilter constructors.
@@ -449,9 +449,9 @@ cv::gpu::DisparityBilateralFilter::DisparityBilateralFilter
cv::gpu::DisparityBilateralFilter::operator ()
----------------------------------------------
.. cfunction:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst)
.. c:function:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst)
.. cfunction:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst, Stream\& stream)
.. c:function:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst, Stream\& stream)
Refines disparity map using joint bilateral filtering.
@@ -467,9 +467,9 @@ cv::gpu::DisparityBilateralFilter::operator ()
cv::gpu::drawColorDisp
----------------------
.. cfunction:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp)
.. c:function:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp)
.. cfunction:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp, const Stream\& stream)
.. c:function:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp, const Stream\& stream)
Does coloring of disparity image.
@@ -489,9 +489,9 @@ This function converts
cv::gpu::reprojectImageTo3D
---------------------------
.. cfunction:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q)
.. c:function:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q)
.. cfunction:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q, const Stream\& stream)
.. c:function:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q, const Stream\& stream)
Reprojects disparity image to 3D space.
modules/gpu/doc/data_structures.rst
+27 -27
View File
@@ -9,7 +9,7 @@ Data Structures
gpu::DevMem2D_
--------------
.. ctype:: gpu::DevMem2D_
.. c:type:: gpu::DevMem2D_
This is a simple lightweight class that encapsulate pitched memory on GPU. It is intended to pass to nvcc-compiled code, i.e. CUDA kernels. So it is used internally by OpenCV and by users writes own device code. Its members can be called both from host and from device code. ::
@@ -35,7 +35,7 @@ This is a simple lightweight class that encapsulate pitched memory on GPU. It is
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0);
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const;
};
..
.. index:: gpu::PtrStep_
@@ -43,7 +43,7 @@ This is a simple lightweight class that encapsulate pitched memory on GPU. It is
gpu::PtrStep_
-------------
.. ctype:: gpu::PtrStep_
.. c:type:: gpu::PtrStep_
This is structure is similar to DevMem2D_but contains only pointer and row step. Width and height fields are excluded due to performance reasons. The structure is for internal use or for users who write own device code. ::
@@ -62,7 +62,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step.
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0);
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const;
};
..
.. index:: gpu::PtrElemStrp_
@@ -70,7 +70,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step.
gpu::PtrElemStrp_
-----------------
.. ctype:: gpu::PtrElemStrp_
.. c:type:: gpu::PtrElemStrp_
This is structure is similar to DevMem2D_but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class is can only be constructed if sizeof(T) is a multiple of 256. The structure is for internal use or for users who write own device code. ::
@@ -80,7 +80,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0);
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const;
};
..
.. index:: gpu::GpuMat
@@ -88,7 +88,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step
gpu::GpuMat
-----------
.. ctype:: gpu::GpuMat
.. c:type:: gpu::GpuMat
The base storage class for GPU memory with reference counting. Its interface is almost
:func:`Mat` interface with some limitations, so using it won't be a problem. The limitations are no arbitrary dimensions support (only 2D), no functions that returns references to its data (because references on GPU are not valid for CPU), no expression templates technique support. Because of last limitation please take care with overloaded matrix operators - they cause memory allocations. The GpuMat class is convertible to
@@ -129,7 +129,7 @@ In contrast with
//! download async
void download(CudaMem& m, Stream& stream) const;
};
..
**Please note:**
Is it a bad practice to leave static or global GpuMat variables allocated, i.e. to rely on its destructor. That is because destruction order of such variables and CUDA context is undefined and GPU memory release function returns error if CUDA context has been destroyed before.
@@ -142,7 +142,7 @@ See also:
gpu::CudaMem
------------
.. ctype:: gpu::CudaMem
.. c:type:: gpu::CudaMem
This is a class with reference counting that wraps special memory type allocation functions from CUDA. Its interface is also
:func:`Mat` -like but with additional memory type parameter:
@@ -183,16 +183,16 @@ Please note that allocation size of such memory types is usually limited. For mo
int alloc_type;
};
..
.. index:: gpu::CudaMem::createMatHeader
cv::gpu::CudaMem::createMatHeader
---------------------------------
:func:`Mat`
.. cfunction:: Mat CudaMem::createMatHeader() const
.. c:function:: Mat CudaMem::createMatHeader() const
.. cfunction:: CudaMem::operator Mat() const
.. c:function:: CudaMem::operator Mat() const
Creates header without reference counting to CudaMem data.
@@ -201,9 +201,9 @@ cv::gpu::CudaMem::createMatHeader
cv::gpu::CudaMem::createGpuMatHeader
------------------------------------
:func:`gpu::GpuMat` ``_``
.. cfunction:: GpuMat CudaMem::createGpuMatHeader() const
.. c:function:: GpuMat CudaMem::createGpuMatHeader() const
.. cfunction:: CudaMem::operator GpuMat() const
.. c:function:: CudaMem::operator GpuMat() const
Maps CPU memory to GPU address space and creates header without reference counting for it. This can be done only if memory was allocated with ALLOCZEROCOPYflag and if it is supported by hardware (laptops often share video and CPU memory, so address spaces can be mapped, and that eliminates extra copy).
@@ -211,7 +211,7 @@ cv::gpu::CudaMem::createGpuMatHeader
cv::gpu::CudaMem::canMapHostMemory
---------------------------------- ``_``
.. cfunction:: static bool CudaMem::canMapHostMemory()
.. c:function:: static bool CudaMem::canMapHostMemory()
Returns true if the current hardware supports address space mapping and ALLOCZEROCOPYmemory allocation
@@ -221,7 +221,7 @@ cv::gpu::CudaMem::canMapHostMemory
gpu::Stream
-----------
.. ctype:: gpu::Stream
.. c:type:: gpu::Stream
This class encapsulated queue of the asynchronous calls. Some functions have overloads with additional
:func:`gpu::Stream` parameter. The overloads do initialization work (allocate output buffers, upload constants, etc.), start GPU kernel and return before results are ready. A check if all operation are complete can be performed via
@@ -266,13 +266,13 @@ This class encapsulated queue of the asynchronous calls. Some functions have ove
void enqueueConvert(const GpuMat& src, GpuMat& dst, int type,
double a = 1, double b = 0);
};
..
.. index:: gpu::Stream::queryIfComplete
cv::gpu::Stream::queryIfComplete
--------------------------------
.. cfunction:: bool Stream::queryIfComplete()
.. c:function:: bool Stream::queryIfComplete()
Returns true if the current stream queue is finished, otherwise false.
@@ -280,7 +280,7 @@ cv::gpu::Stream::queryIfComplete
cv::gpu::Stream::waitForCompletion
----------------------------------
.. cfunction:: void Stream::waitForCompletion()
.. c:function:: void Stream::waitForCompletion()
Blocks until all operations in the stream are complete.
@@ -290,7 +290,7 @@ cv::gpu::Stream::waitForCompletion
gpu::StreamAccessor
-------------------
.. ctype:: gpu::StreamAccessor
.. c:type:: gpu::StreamAccessor
This class provides possibility to get ``cudaStream_t`` from
:func:`gpu::Stream` . This class is declared in ``stream_accessor.hpp`` because that is only public header that depend on Cuda Runtime API. Including it will bring the dependency to your code. ::
@@ -299,13 +299,13 @@ This class provides possibility to get ``cudaStream_t`` from
{
CV_EXPORTS static cudaStream_t getStream(const Stream& stream);
};
..
.. index:: gpu::createContinuous
cv::gpu::createContinuous
-------------------------
.. cfunction:: void createContinuous(int rows, int cols, int type, GpuMat\& m)
.. c:function:: void createContinuous(int rows, int cols, int type, GpuMat\& m)
Creates continuous matrix in GPU memory.
@@ -319,11 +319,11 @@ cv::gpu::createContinuous
Also the following wrappers are available:
.. cfunction:: GpuMat createContinuous(int rows, int cols, int type)
.. c:function:: GpuMat createContinuous(int rows, int cols, int type)
.. cfunction:: void createContinuous(Size size, int type, GpuMat\& m)
.. c:function:: void createContinuous(Size size, int type, GpuMat\& m)
.. cfunction:: GpuMat createContinuous(Size size, int type)
.. c:function:: GpuMat createContinuous(Size size, int type)
Matrix is called continuous if its elements are stored continuously, i.e. wuthout gaps in the end of each row.
@@ -331,7 +331,7 @@ Matrix is called continuous if its elements are stored continuously, i.e. wuthou
cv::gpu::ensureSizeIsEnough
---------------------------
.. cfunction:: void ensureSizeIsEnough(int rows, int cols, int type, GpuMat\& m)
.. c:function:: void ensureSizeIsEnough(int rows, int cols, int type, GpuMat\& m)
Ensures that size of matrix is big enough and matrix has proper type. The function doesn't reallocate memory if the matrix has proper attributes already.
@@ -345,5 +345,5 @@ cv::gpu::ensureSizeIsEnough
Also the following wrapper is available:
.. cfunction:: void ensureSizeIsEnough(Size size, int type, GpuMat\& m)
.. c:function:: void ensureSizeIsEnough(Size size, int type, GpuMat\& m)
modules/gpu/doc/feature_detection_and_description.rst
+19 -19
View File
@@ -9,7 +9,7 @@ Feature Detection and Description
gpu::SURF_GPU
-------------
.. ctype:: gpu::SURF_GPU
.. c:type:: gpu::SURF_GPU
Class for extracting Speeded Up Robust Features from an image. ::
@@ -62,7 +62,7 @@ Class for extracting Speeded Up Robust Features from an image. ::
GpuMat maxPosBuffer;
GpuMat featuresBuffer;
};
..
The class ``SURF_GPU`` implements Speeded Up Robust Features descriptor. There is fast multi-scale Hessian keypoint detector that can be used to find the keypoints (which is the default option), but the descriptors can be also computed for the user-specified keypoints. Supports only 8 bit grayscale images.
@@ -81,7 +81,7 @@ See also:
gpu::BruteForceMatcher_GPU
--------------------------
.. ctype:: gpu::BruteForceMatcher_GPU
.. c:type:: gpu::BruteForceMatcher_GPU
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. ::
@@ -166,7 +166,7 @@ Brute-force descriptor matcher. For each descriptor in the first set, this match
private:
std::vector<GpuMat> trainDescCollection;
};
..
The class ``BruteForceMatcher_GPU`` has the similar interface to class
. It has two groups of match methods: for matching descriptors of one image with other image or with image set. Also all functions have alternative: save results to GPU memory or to CPU memory.
@@ -180,9 +180,9 @@ See also:,.
cv::gpu::BruteForceMatcher_GPU::match
-------------------------------------
.. cfunction:: void match(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector<DMatch>\& matches, const GpuMat\& mask = GpuMat())
.. c:function:: void match(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector<DMatch>\& matches, const GpuMat\& mask = GpuMat())
.. cfunction:: void match(const GpuMat\& queryDescs, std::vector<DMatch>\& matches, const std::vector<GpuMat>\& masks = std::vector<GpuMat>())
.. c:function:: void 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.
@@ -195,7 +195,7 @@ See also:
cv::gpu::BruteForceMatcher_GPU::matchSingle
-------------------------------------------
.. cfunction:: void matchSingle(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, const GpuMat\& mask = GpuMat())
.. c:function:: void matchSingle(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, const GpuMat\& mask = GpuMat())
Finds the best match for each query descriptor. Results will be stored to GPU memory.
@@ -212,7 +212,7 @@ cv::gpu::BruteForceMatcher_GPU::matchSingle
cv::gpu::BruteForceMatcher_GPU::matchCollection
-----------------------------------------------
.. cfunction:: void matchCollection(const GpuMat\& queryDescs, const GpuMat\& trainCollection, GpuMat\& trainIdx, GpuMat\& imgIdx, GpuMat\& distance, const GpuMat\& maskCollection)
.. c:function:: void matchCollection(const GpuMat\& queryDescs, const GpuMat\& trainCollection, GpuMat\& trainIdx, GpuMat\& imgIdx, GpuMat\& distance, const GpuMat\& maskCollection)
Find the best match for each query descriptor from train collection. Results will be stored to GPU memory.
@@ -231,7 +231,7 @@ cv::gpu::BruteForceMatcher_GPU::matchCollection
cv::gpu::BruteForceMatcher_GPU::makeGpuCollection
-------------------------------------------------
.. cfunction:: void makeGpuCollection(GpuMat\& trainCollection, GpuMat\& maskCollection, const vector<GpuMat>\& masks = std::vector<GpuMat>())
.. c:function:: void makeGpuCollection(GpuMat\& trainCollection, GpuMat\& maskCollection, const vector<GpuMat>\& masks = std::vector<GpuMat>())
Makes gpu collection of train descriptors and masks in suitable format for function.
@@ -241,9 +241,9 @@ cv::gpu::BruteForceMatcher_GPU::makeGpuCollection
cv::gpu::BruteForceMatcher_GPU::matchDownload
--------------------------------------------- ```` ```` ````
.. cfunction:: void matchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector<DMatch>\& matches)
.. c:function:: void matchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector<DMatch>\& matches)
.. cfunction:: void matchDownload(const GpuMat\& trainIdx, GpuMat\& imgIdx, const GpuMat\& distance, std::vector<DMatch>\& matches)
.. c:function:: void matchDownload(const GpuMat\& trainIdx, GpuMat\& imgIdx, const GpuMat\& distance, std::vector<DMatch>\& matches)
Downloads trainIdx, imgIdxand distancematrices obtained via or to CPU vector with .
@@ -253,11 +253,11 @@ cv::gpu::BruteForceMatcher_GPU::matchDownload
cv::gpu::BruteForceMatcher_GPU::knnMatch
----------------------------------------
.. cfunction:: void knnMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, int k, const GpuMat\& mask = GpuMat(), bool compactResult = false)
.. c:function:: void 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. Found k (or less if not possible) matches are returned in distance increasing order.
.. cfunction:: void knnMatch(const GpuMat\& queryDescs, std::vector< std::vector<DMatch> >\& matches, int k, const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), bool compactResult = false )
.. c: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:
:func:`DescriptorMatcher::knnMatch` .
@@ -268,7 +268,7 @@ See also:
cv::gpu::BruteForceMatcher_GPU::knnMatch
----------------------------------------
.. cfunction:: void knnMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, GpuMat\& allDist, int k, const GpuMat\& mask = GpuMat())
.. c:function:: void 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. Found k (or less if not possible) matches are returned in distance increasing order. Results will be stored to GPU memory.
@@ -291,7 +291,7 @@ cv::gpu::BruteForceMatcher_GPU::knnMatch
cv::gpu::BruteForceMatcher_GPU::knnMatchDownload
------------------------------------------------ ```` ```` ```` ````
.. cfunction:: void knnMatchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false)
.. c:function:: void knnMatchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false)
Downloads trainIdxand distancematrices obtained via to CPU vector with . If compactResultis true matchesvector will not contain matches for fully masked out query descriptors.
@@ -301,11 +301,11 @@ cv::gpu::BruteForceMatcher_GPU::knnMatchDownload
cv::gpu::BruteForceMatcher_GPU::radiusMatch
-------------------------------------------
.. cfunction:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const GpuMat\& mask = GpuMat(), bool compactResult = false)
.. c:function:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const GpuMat\& mask = GpuMat(), bool compactResult = false)
Finds the best matches for each query descriptor which have distance less than given threshold. Found matches are returned in distance increasing order.
.. cfunction:: void radiusMatch(const GpuMat\& queryDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), bool compactResult = false)
.. c:function:: void 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 Compute Capability
:math:`>=` 1.1.
@@ -319,7 +319,7 @@ See also:
cv::gpu::BruteForceMatcher_GPU::radiusMatch
-------------------------------------------
.. cfunction:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& nMatches, GpuMat\& distance, float maxDistance, const GpuMat\& mask = GpuMat())
.. c:function:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& nMatches, GpuMat\& distance, float maxDistance, const GpuMat\& mask = GpuMat())
Finds the best matches for each query descriptor which have distance less than given threshold. Results will be stored to GPU memory.
@@ -347,7 +347,7 @@ This function works only on devices with Compute Capability
cv::gpu::BruteForceMatcher_GPU::radiusMatchDownload
--------------------------------------------------- ```` ```` ```` ```` ````
.. cfunction:: void radiusMatchDownload(const GpuMat\& trainIdx, const GpuMat\& nMatches, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false)
.. c:function:: void radiusMatchDownload(const GpuMat\& trainIdx, const GpuMat\& nMatches, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false)
Downloads trainIdx, nMatchesand distancematrices obtained via to CPU vector with . If compactResultis true matchesvector will not contain matches for fully masked out query descriptors.
modules/gpu/doc/image_filtering.rst
+44 -44
View File
@@ -13,7 +13,7 @@ See also:
gpu::BaseRowFilter_GPU
----------------------
.. ctype:: gpu::BaseRowFilter_GPU
.. c:type:: gpu::BaseRowFilter_GPU
The 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. ::
@@ -25,7 +25,7 @@ The base class for linear or non-linear filters that processes rows of 2D arrays
virtual void operator()(const GpuMat& src, GpuMat& dst) = 0;
int ksize, anchor;
};
..
**Please note:**
This class doesn't allocate memory for destination image. Usually this class is used inside
@@ -37,7 +37,7 @@ This class doesn't allocate memory for destination image. Usually this class is
gpu::BaseColumnFilter_GPU
-------------------------
.. ctype:: gpu::BaseColumnFilter_GPU
.. c:type:: gpu::BaseColumnFilter_GPU
The 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,7 +49,7 @@ The base class for linear or non-linear filters that processes columns of 2D arr
virtual void operator()(const GpuMat& src, GpuMat& dst) = 0;
int ksize, anchor;
};
..
**Please note:**
This class doesn't allocate memory for destination image. Usually this class is used inside
@@ -61,7 +61,7 @@ This class doesn't allocate memory for destination image. Usually this class is
gpu::BaseFilter_GPU
-------------------
.. ctype:: gpu::BaseFilter_GPU
.. c:type:: gpu::BaseFilter_GPU
The base class for non-separable 2D filters. ::
@@ -74,7 +74,7 @@ The base class for non-separable 2D filters. ::
Size ksize;
Point anchor;
};
..
**Please note:**
This class doesn't allocate memory for destination image. Usually this class is used inside
@@ -86,7 +86,7 @@ This class doesn't allocate memory for destination image. Usually this class is
gpu::FilterEngine_GPU
---------------------
.. ctype:: gpu::FilterEngine_GPU
.. c:type:: gpu::FilterEngine_GPU
The base class for Filter Engine. ::
@@ -98,7 +98,7 @@ The base class for Filter Engine. ::
virtual void apply(const GpuMat& src, GpuMat& dst,
Rect roi = Rect(0,0,-1,-1)) = 0;
};
..
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
:func:`gpu::filter2D`,:func:`gpu::erode`,:func:`gpu::Sobel` etc.
@@ -124,7 +124,7 @@ By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary mem
}
// Release buffers only once
filter.release();
..
``FilterEngine_GPU`` can process a rectangular sub-region of an image. By default, if ``roi == Rect(0,0,-1,-1)``,``FilterEngine_GPU`` processes inner region of image ( ``Rect(anchor.x, anchor.y, src_size.width - ksize.width, src_size.height - ksize.height)`` ), because some filters doesn't check if indices are outside the image for better perfomace. See below which filters supports processing the whole image and which not and image type limitations.
**Please note:**
@@ -138,7 +138,7 @@ See also:,,,,,,,,,,
cv::gpu::createFilter2D_GPU
---------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createFilter2D_GPU( const Ptr<BaseFilter_GPU>\& filter2D, int srcType, int dstType)
.. c:function:: Ptr<FilterEngine_GPU> createFilter2D_GPU( const Ptr<BaseFilter_GPU>\& filter2D, int srcType, int dstType)
Creates non-separable filter engine with the specified filter.
@@ -156,7 +156,7 @@ Usually this function is used inside high-level functions, like,.
cv::gpu::createSeparableFilter_GPU
----------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>\& rowFilter, const Ptr<BaseColumnFilter_GPU>\& columnFilter, int srcType, int bufType, int dstType)
.. c:function:: Ptr<FilterEngine_GPU> createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>\& rowFilter, const Ptr<BaseColumnFilter_GPU>\& columnFilter, int srcType, int bufType, int dstType)
Creates separable filter engine with the specified filters.
@@ -178,7 +178,7 @@ Usually this function is used inside high-level functions, like
cv::gpu::getRowSumFilter_GPU
----------------------------
.. cfunction:: Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1)
.. c:function:: Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1)
Creates horizontal 1D box filter.
@@ -199,7 +199,7 @@ This filter doesn't check out of border accesses, so only proper submatrix of bi
cv::gpu::getColumnSumFilter_GPU
-------------------------------
.. cfunction:: Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1)
.. c:function:: Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1)
Creates vertical 1D box filter.
@@ -220,11 +220,11 @@ This filter doesn't check out of border accesses, so only proper submatrix of bi
cv::gpu::createBoxFilter_GPU
----------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, const Point\& anchor = Point(-1,-1))
.. c:function:: Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, const Point\& anchor = Point(-1,-1))
Creates normalized 2D box filter.
.. cfunction:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1, -1))
.. c: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`` .
@@ -244,7 +244,7 @@ See also:
cv::gpu::boxFilter
------------------
.. cfunction:: void boxFilter(const GpuMat\& src, GpuMat\& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1))
.. c:function:: void boxFilter(const GpuMat\& src, GpuMat\& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1))
Smooths the image using the normalized box filter.
@@ -268,7 +268,7 @@ See also:
cv::gpu::blur
-------------
.. cfunction:: void blur(const GpuMat\& src, GpuMat\& dst, Size ksize, Point anchor = Point(-1,-1))
.. c:function:: void blur(const GpuMat\& src, GpuMat\& dst, Size ksize, Point anchor = Point(-1,-1))
A synonym for normalized box filter.
@@ -292,11 +292,11 @@ See also:
cv::gpu::createMorphologyFilter_GPU
-----------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Point\& anchor = Point(-1,-1), int iterations = 1)
.. c:function:: Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Point\& anchor = Point(-1,-1), int iterations = 1)
Creates 2D morphological filter.
.. cfunction:: Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Size\& ksize, Point anchor=Point(-1,-1))
.. c: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.}
@@ -318,7 +318,7 @@ See also:
cv::gpu::erode
--------------
.. cfunction:: void erode(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1)
.. c:function:: void 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.
@@ -342,7 +342,7 @@ See also:
cv::gpu::dilate
---------------
.. cfunction:: void dilate(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1)
.. c:function:: void 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.
@@ -366,25 +366,25 @@ See also:
cv::gpu::morphologyEx
---------------------
.. cfunction:: void morphologyEx(const GpuMat\& src, GpuMat\& dst, int op, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1)
.. c:function:: void 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 image.
:param src: Source image. Supports ``CV_8UC1`` and ``CV_8UC4`` source type.
:param dst: Destination image. It will have the same size and the same type as ``src``
:param op: Type of morphological operation, one of the following:
:param op: Type of morphological operation, one of the following:
* **MORPH_OPEN** opening
* **MORPH_CLOSE** closing
* **MORPH_GRADIENT** morphological gradient
* **MORPH_TOPHAT** "top hat"
* **MORPH_BLACKHAT** "black hat"
:param kernel: Structuring element.
@@ -404,11 +404,11 @@ See also:
cv::gpu::createLinearFilter_GPU
-------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Point\& anchor = Point(-1,-1))
.. c:function:: Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Point\& anchor = Point(-1,-1))
Creates the non-separable linear filter.
.. cfunction:: Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Size\& ksize, Point anchor = Point(-1, -1))
.. c:function:: Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Size\& ksize, Point anchor = Point(-1, -1))
:param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4`` .
@@ -430,7 +430,7 @@ See also:
cv::gpu::filter2D
-----------------
.. cfunction:: void filter2D(const GpuMat\& src, GpuMat\& dst, int ddepth, const Mat\& kernel, Point anchor=Point(-1,-1))
.. c:function:: void filter2D(const GpuMat\& src, GpuMat\& dst, int ddepth, const Mat\& kernel, Point anchor=Point(-1,-1))
Applies non-separable 2D linear filter to image.
@@ -454,7 +454,7 @@ See also:
cv::gpu::Laplacian
------------------
.. cfunction:: void Laplacian(const GpuMat\& src, GpuMat\& dst, int ddepth, int ksize = 1, double scale = 1)
.. c:function:: void Laplacian(const GpuMat\& src, GpuMat\& dst, int ddepth, int ksize = 1, double scale = 1)
Applies Laplacian operator to image.
@@ -480,7 +480,7 @@ See also:
cv::gpu::getLinearRowFilter_GPU
-------------------------------
.. cfunction:: Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat\& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
.. c:function:: Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat\& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates primitive row filter with the specified kernel.
@@ -504,7 +504,7 @@ See also:,:func:`createSeparableLinearFilter` .
cv::gpu::getLinearColumnFilter_GPU
----------------------------------
.. cfunction:: Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat\& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
.. c:function:: Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat\& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates the primitive column filter with the specified kernel.
@@ -527,7 +527,7 @@ See also:,:func:`createSeparableLinearFilter` .
cv::gpu::createSeparableLinearFilter_GPU
----------------------------------------
.. cfunction:: Ptr<FilterEngine_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)
.. c:function:: Ptr<FilterEngine_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 the separable linear filter engine.
@@ -548,7 +548,7 @@ See also:,,
cv::gpu::sepFilter2D
--------------------
.. cfunction:: void 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)
.. c:function:: void 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 separable 2D linear filter to the image.
@@ -572,7 +572,7 @@ See also:,:func:`sepFilter2D` .
cv::gpu::createDerivFilter_GPU
------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. c:function:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates filter engine for the generalized Sobel operator.
@@ -594,7 +594,7 @@ See also:,:func:`createDerivFilter` .
cv::gpu::Sobel
--------------
.. cfunction:: void 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)
.. c:function:: void 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 generalized Sobel operator to the image.
@@ -620,7 +620,7 @@ See also:,:func:`Sobel` .
cv::gpu::Scharr
---------------
.. cfunction:: void Scharr(const GpuMat\& src, GpuMat\& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. c:function:: void 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 Scharr operator.
@@ -645,7 +645,7 @@ See also:,:func:`Scharr` .
cv::gpu::createGaussianFilter_GPU
---------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. c:function:: Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates Gaussian filter engine.
@@ -665,7 +665,7 @@ See also:,:func:`createGaussianFilter` .
cv::gpu::GaussianBlur
---------------------
.. cfunction:: void GaussianBlur(const GpuMat\& src, GpuMat\& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
.. c:function:: void GaussianBlur(const GpuMat\& src, GpuMat\& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Smooths the image using Gaussian filter.
@@ -687,7 +687,7 @@ See also:,:func:`GaussianBlur` .
cv::gpu::getMaxFilter_GPU
-------------------------
.. cfunction:: Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1))
.. c:function:: Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1))
Creates maximum filter.
@@ -708,7 +708,7 @@ This filter doesn't check out of border accesses, so only proper submatrix of bi
cv::gpu::getMinFilter_GPU
-------------------------
.. cfunction:: Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1))
.. c:function:: Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1))
Creates minimum filter.
modules/gpu/doc/image_processing.rst
+75 -67
View File
@@ -7,7 +7,10 @@ Image Processing
cv::gpu::meanShiftFiltering
---------------------------
.. cfunction:: void meanShiftFiltering(const GpuMat\& src, GpuMat\& dst,
.. c:function:: void 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, and as the result we have new color and new position of each point.
@@ -25,7 +28,10 @@ cv::gpu::meanShiftFiltering
cv::gpu::meanShiftProc
----------------------
.. c:function:: void meanShiftProc(const GpuMat\& src, GpuMat\& dstr, GpuMat\& dstsp,
int sp, int sr,
TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER
+ TermCriteria::EPS, 5, 1))
Performs mean-shift procedure and stores information about processed points (i.e. their colors and positions) into two images.
@@ -48,7 +54,10 @@ See also:
cv::gpu::meanShiftSegmentation
------------------------------
:func:`gpu::meanShiftFiltering` .
.. c:function:: void meanShiftSegmentation(const GpuMat\& src, Mat\& dst,
int sp, int sr, int minsize,
TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER
+ TermCriteria::EPS, 5, 1))
Performs mean-shift segmentation of the source image and eleminates small segments.
@@ -68,9 +77,9 @@ cv::gpu::meanShiftSegmentation
cv::gpu::integral
-----------------
.. c:function:: void integral(const GpuMat\& src, GpuMat\& sum)
.. c:function:: void integral(const GpuMat\& src, GpuMat\& sum, GpuMat\& sqsum)
Computes integral image and squared integral image.
@@ -87,7 +96,7 @@ See also:
cv::gpu::sqrIntegral
--------------------
:param sqsum: Squared integral image. Will have ``CV_32FC1`` type.
.. c:function:: void sqrIntegral(const GpuMat\& src, GpuMat\& sqsum)
Computes squared integral image.
@@ -99,7 +108,7 @@ cv::gpu::sqrIntegral
cv::gpu::columnSum
------------------
.. c:function:: void columnSum(const GpuMat\& src, GpuMat\& sum)
Computes vertical (column) sum.
@@ -111,7 +120,9 @@ cv::gpu::columnSum
cv::gpu::cornerHarris
---------------------
.. c:function:: void cornerHarris(const GpuMat\& src, GpuMat\& dst,
int blockSize, int ksize, double k,
int borderType=BORDER_REFLECT101)
Computes Harris cornerness criteria at each image pixel.
@@ -134,7 +145,9 @@ See also:
cv::gpu::cornerMinEigenVal
--------------------------
:param k: Harris detector free parameter.
.. c:function:: void cornerMinEigenVal(const GpuMat\& src, GpuMat\& dst,
int blockSize, int ksize,
int borderType=BORDER_REFLECT101)
Computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria.
@@ -157,7 +170,8 @@ See also:
cv::gpu::mulSpectrums
---------------------
:param ksize: Aperture parameter for the Sobel operator.
.. c:function:: void mulSpectrums(const GpuMat\& a, const GpuMat\& b,
GpuMat\& c, int flags, bool conjB=false)
Performs per-element multiplication of two Fourier spectrums.
@@ -180,7 +194,8 @@ See also:
cv::gpu::mulAndScaleSpectrums
-----------------------------
.. c:function:: void mulAndScaleSpectrums(const GpuMat\& a, const GpuMat\& b,
GpuMat\& c, int flags, float scale, bool conjB=false)
Performs per-element multiplication of two Fourier spectrums and scales the result.
@@ -205,7 +220,7 @@ See also:
cv::gpu::dft
------------ ``_`` ``_``
:param flags: Mock paramter is kept for CPU/GPU interfaces similarity.
.. c:function:: void dft(const GpuMat\& src, GpuMat\& dst, Size dft_size, int flags=0)
Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix. Can handle real matrices (CV32FC1) and complex matrices in the interleaved format (CV32FC2).
@@ -215,7 +230,7 @@ cv::gpu::dft
:param dft_size: Size of discrete Fourier transform.
:param flags: Optional flags:
* **DFT_ROWS** Transform each individual row of the source matrix.
@@ -224,7 +239,7 @@ cv::gpu::dft
* **DFT_INVERSE** Inverse DFT must be perfromed for complex-complex case (real-complex and complex-real cases are respectively forward and inverse always).
* **DFT_REAL_OUTPUT** The source matrix is the result of real-complex transform, so the destination matrix must be real.
:param src: Source matrix (real or complex).
The source matrix should be continuous, otherwise reallocation and data copying will be performed. Function chooses the operation mode depending on the flags, size and channel count of the source matrix:
@@ -244,9 +259,11 @@ See also:
cv::gpu::convolve
-----------------
If the source matrix is complex and the output isn't specified as real then the destination matrix will be complex, will have ``dft_size`` size and ``CV_32FC2`` type. It will contain full result of the DFT (forward or inverse).
.. c:function:: void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result,
bool ccorr=false)
*
.. c:function:: void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result,
bool ccorr, ConvolveBuf\& buf)
Computes convolution (or cross-correlation) of two images.
@@ -266,7 +283,7 @@ cv::gpu::convolve
gpu::ConvolveBuf
----------------
.. c:type:: gpu::ConvolveBuf
Memory buffer for the
:func:`gpu::convolve` function. ::
@@ -281,17 +298,17 @@ Memory buffer for the
private:
// Hidden
};
gpu::ConvolveBuf
.. index:: gpu::ConvolveBuf::ConvolveBuf
cv::gpu::ConvolveBuf::ConvolveBuf
---------------------------------
.. c:function:: ConvolveBuf::ConvolveBuf()
Constructs an empty buffer which will be properly resized after first call of the convolve function.
ConvolveBuf(Size image_size, Size templ_size)
.. c:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size)
Constructs a buffer for the convolve function with respectively arguments.
@@ -299,7 +316,8 @@ Constructs a buffer for the convolve function with respectively arguments.
cv::gpu::matchTemplate
----------------------
.. c:function:: void 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.
@@ -307,37 +325,24 @@ cv::gpu::matchTemplate
:param templ: Template image. Must have the same size and type as ``image`` .
:param result: Map containing comparison results ( ``CV_32FC1`` ). If ``image`` is :math:`W \times H` and
``templ`` is :math:`w \times h` then ``result`` must be :math:`(W-w+1) \times (H-h+1)` .
:param method: Specifies the way which the template must be compared with the image.
Following methods are supported for the ``CV_8U`` depth images for now:
cv::gpu::matchTemplate
----------------------
.. cfunction:: void 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.
:param image: Source image. ``CV_32F`` and ``CV_8U`` depth images (1..4 channels) are supported for now.
:param templ: Template image. Must have the same size and type as ``image`` .
:param result: Map containing comparison results ( ``CV_32FC1`` ). If ``image`` is :math:`W \times H` and
``templ`` is :math:`w \times h` then ``result`` must be :math:`(W-w+1) \times (H-h+1)` .
:param method: Specifies the way which the template must be compared with the image.
* CV_TM_SQDIFF
* CV_TM_SQDIFF_NORMED
* CV_TM_CCORR
* CV_TM_CCORR_NORMED
* CV_TM_CCOEFF
* CV_TM_CCOEFF_NORMED
Following methods are supported for the ``CV_32F`` images for now:
CV_ TM_ SQDIFF
*
CV_ TM_ SQDIFF_ NORMED
* CV_TM_SQDIFF
* CV_TM_CCORR
See also:
:func:`matchTemplate` .
@@ -346,7 +351,7 @@ See also:
cv::gpu::remap
--------------
.. c:function:: void remap(const GpuMat\& src, GpuMat\& dst, const GpuMat\& xmap, const GpuMat\& ymap)
Applies a generic geometrical transformation to an image.
@@ -362,7 +367,7 @@ The function transforms the source image using the specified map:
.. math::
\texttt{dst} (x,y) = \texttt{src} (xmap(x,y), ymap(x,y))
Values of pixels with non-integer coordinates are computed using bilinear interpolation.
@@ -373,9 +378,9 @@ See also:
cv::gpu::cvtColor
-----------------
:param xmap: X values. Only ``CV_32FC1`` type is supported.
.. c:function:: void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn = 0)
:param ymap: Y values. Only ``CV_32FC1`` type is supported.
.. c:function:: void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn, const Stream\& stream)
Converts image from one color space to another.
@@ -398,9 +403,9 @@ See also:
cv::gpu::threshold
------------------
:param src: Source image with ``CV_8U`` , ``CV_16U`` or ``CV_32F`` depth and 1, 3 or 4 channels.
.. c:function:: double threshold(const GpuMat\& src, GpuMat\& dst, double thresh, double maxval, int type)
:param dst: Destination image; will have the same size and the same depth as ``src`` .
.. c:function:: double threshold(const GpuMat\& src, GpuMat\& dst, double thresh, double maxval, int type, const Stream\& stream)
Applies a fixed-level threshold to each array element.
@@ -423,7 +428,7 @@ See also:
cv::gpu::resize
---------------
:param src: Source array (single-channel, ``CV_64F`` depth isn't supported).
.. c:function:: void resize(const GpuMat\& src, GpuMat\& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR)
Resizes an image.
@@ -431,25 +436,28 @@ cv::gpu::resize
:param dst: Destination image. It will have size ``dsize`` (when it is non-zero) or the size computed from ``src.size()`` and ``fx`` and ``fy`` . The type of ``dst`` will be the same as of ``src`` .
:param thresholdType: Thresholding type. For details see :func:`threshold` . ``THRESH_OTSU`` thresholding type doesn't supported.
:param dsize: Destination image size. If it is zero, then it is computed as:
.. math::
See also:
\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}
Either ``dsize`` or both ``fx`` or ``fy`` must be non-zero.
:param fx: Scale factor along the horizontal axis. When 0, it is computed as
.. math::
\texttt{(double)dsize.width/src.cols}
:param fy: Scale factor along the vertical axis. When 0, it is computed as
.. math::
\texttt{(double)dsize.height/src.rows}
:param interpolation: Interpolation method. Supports only ``INTER_NEAREST`` and ``INTER_LINEAR`` .
@@ -460,7 +468,7 @@ See also:
cv::gpu::warpAffine
-------------------
.. c:function:: void warpAffine(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR)
Applies an affine transformation to an image.
@@ -481,7 +489,7 @@ See also:
cv::gpu::warpPerspective
------------------------
-------------------
.. c:function:: void warpPerspective(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR)
Applies a perspective transformation to an image.
@@ -503,7 +511,7 @@ See also:
cv::gpu::rotate
---------------
.. cfunction:: void warpPerspective(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR)
.. c:function:: void 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.
@@ -528,7 +536,7 @@ See also:
cv::gpu::copyMakeBorder
-----------------------
.. c:function:: void copyMakeBorder(const GpuMat\& src, GpuMat\& dst, int top, int bottom, int left, int right, const Scalar\& value = Scalar())
Copies 2D array to a larger destination array and pads borders with the given constant.
@@ -546,7 +554,7 @@ See also:
cv::gpu::rectStdDev
-------------------
.. index:: gpu::copyMakeBorder
.. c:function:: void rectStdDev(const GpuMat\& src, const GpuMat\& sqr, GpuMat\& dst, const Rect\& rect)
Computes standard deviation of integral images.
@@ -562,7 +570,7 @@ cv::gpu::rectStdDev
cv::gpu::evenLevels
-------------------
See also:
.. c:function:: void evenLevels(GpuMat\& levels, int nLevels, int lowerLevel, int upperLevel)
Computes levels with even distribution.
@@ -578,9 +586,9 @@ cv::gpu::evenLevels
cv::gpu::histEven
-----------------
:param rect: Rectangular window.
.. c:function:: void histEven(const GpuMat\& src, GpuMat\& hist, int histSize, int lowerLevel, int upperLevel)
.. index:: gpu::evenLevels
.. c:function:: void histEven(const GpuMat\& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4])
Calculates histogram with evenly distributed bins.
@@ -598,9 +606,9 @@ cv::gpu::histEven
cv::gpu::histRange
------------------
cv::gpu::histEven
.. c:function:: void histRange(const GpuMat\& src, GpuMat\& hist, const GpuMat\& levels)
.. cfunction:: void histEven(const GpuMat\& src, GpuMat\& hist, int histSize, int lowerLevel, int upperLevel)
.. c:function:: void histRange(const GpuMat\& src, GpuMat hist[4], const GpuMat levels[4])
Calculates histogram with bins determined by levels array.
modules/gpu/doc/initalization_and_information.rst
+26 -26
View File
@@ -7,7 +7,7 @@ Initalization and Information
cv::gpu::getCudaEnabledDeviceCount
----------------------------------
.. cfunction:: int getCudaEnabledDeviceCount()
.. c:function:: int getCudaEnabledDeviceCount()
Returns number of CUDA-enabled devices installed. It is to be used before any other GPU functions calls. If OpenCV is compiled without GPU support this function returns 0.
@@ -15,7 +15,7 @@ cv::gpu::getCudaEnabledDeviceCount
cv::gpu::setDevice
------------------
.. cfunction:: void setDevice(int device)
.. c:function:: void setDevice(int device)
Sets device and initializes it for the current thread. Call of this function can be omitted, but in this case a default device will be initialized on fist GPU usage.
@@ -25,7 +25,7 @@ cv::gpu::setDevice
cv::gpu::getDevice
------------------
.. cfunction:: int getDevice()
.. c:function:: int getDevice()
Returns the current device index, which was set by {gpu::getDevice} or initialized by default.
@@ -35,7 +35,7 @@ cv::gpu::getDevice
gpu::GpuFeature
---------------
.. ctype:: gpu::GpuFeature
.. c:type:: gpu::GpuFeature
GPU compute features. ::
@@ -46,7 +46,7 @@ GPU compute features. ::
COMPUTE_20, COMPUTE_21,
ATOMICS, NATIVE_DOUBLE
};
..
.. index:: gpu::DeviceInfo
@@ -54,7 +54,7 @@ GPU compute features. ::
gpu::DeviceInfo
---------------
.. ctype:: gpu::DeviceInfo
.. c:type:: gpu::DeviceInfo
This class provides functionality for querying the specified GPU properties. ::
@@ -77,15 +77,15 @@ This class provides functionality for querying the specified GPU properties. ::
bool supports(GpuFeature feature) const;
bool isCompatible() const;
};
..
.. index:: gpu::DeviceInfo::DeviceInfo
cv::gpu::DeviceInfo::DeviceInfo
------------------------------- ``_``
.. cfunction:: DeviceInfo::DeviceInfo()
.. c:function:: DeviceInfo::DeviceInfo()
.. cfunction:: DeviceInfo::DeviceInfo(int device_id)
.. c:function:: DeviceInfo::DeviceInfo(int device_id)
Constructs DeviceInfo object for the specified device. If deviceidparameter is missed it constructs object for the current device.
@@ -95,7 +95,7 @@ cv::gpu::DeviceInfo::DeviceInfo
cv::gpu::DeviceInfo::name
-------------------------
.. cfunction:: string DeviceInfo::name()
.. c:function:: string DeviceInfo::name()
Returns the device name.
@@ -103,7 +103,7 @@ cv::gpu::DeviceInfo::name
cv::gpu::DeviceInfo::majorVersion
---------------------------------
.. cfunction:: int DeviceInfo::majorVersion()
.. c:function:: int DeviceInfo::majorVersion()
Returns the major compute capability version.
@@ -111,7 +111,7 @@ cv::gpu::DeviceInfo::majorVersion
cv::gpu::DeviceInfo::minorVersion
---------------------------------
.. cfunction:: int DeviceInfo::minorVersion()
.. c:function:: int DeviceInfo::minorVersion()
Returns the minor compute capability version.
@@ -119,7 +119,7 @@ cv::gpu::DeviceInfo::minorVersion
cv::gpu::DeviceInfo::multiProcessorCount
----------------------------------------
.. cfunction:: int DeviceInfo::multiProcessorCount()
.. c:function:: int DeviceInfo::multiProcessorCount()
Returns the number of streaming multiprocessors.
@@ -127,7 +127,7 @@ cv::gpu::DeviceInfo::multiProcessorCount
cv::gpu::DeviceInfo::freeMemory
-------------------------------
.. cfunction:: size_t DeviceInfo::freeMemory()
.. c:function:: size_t DeviceInfo::freeMemory()
Returns the amount of free memory in bytes.
@@ -135,7 +135,7 @@ cv::gpu::DeviceInfo::freeMemory
cv::gpu::DeviceInfo::totalMemory
--------------------------------
.. cfunction:: size_t DeviceInfo::totalMemory()
.. c:function:: size_t DeviceInfo::totalMemory()
Returns the amount of total memory in bytes.
@@ -143,7 +143,7 @@ cv::gpu::DeviceInfo::totalMemory
cv::gpu::DeviceInfo::supports
-----------------------------
.. cfunction:: bool DeviceInfo::supports(GpuFeature feature)
.. c:function:: bool DeviceInfo::supports(GpuFeature feature)
Returns true if the device has the given GPU feature, otherwise false.
@@ -153,7 +153,7 @@ cv::gpu::DeviceInfo::supports
cv::gpu::DeviceInfo::isCompatible
---------------------------------
.. cfunction:: bool DeviceInfo::isCompatible()
.. c:function:: bool DeviceInfo::isCompatible()
Returns true if the GPU module can be run on the specified device, otherwise false.
@@ -163,32 +163,32 @@ cv::gpu::DeviceInfo::isCompatible
gpu::TargetArchs
----------------
.. ctype:: gpu::TargetArchs
.. c:type:: gpu::TargetArchs
This class provides functionality (as set of static methods) for checking which NVIDIA card architectures the GPU module was built for.
bigskip
The following method checks whether the module was built with the support of the given feature:
.. cfunction:: static bool builtWith(GpuFeature feature)
.. c:function:: static bool builtWith(GpuFeature feature)
:param feature: Feature to be checked. See .
There are a set of methods for checking whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s):
.. cfunction:: static bool has(int major, int minor)
.. c:function:: static bool has(int major, int minor)
.. cfunction:: static bool hasPtx(int major, int minor)
.. c:function:: static bool hasPtx(int major, int minor)
.. cfunction:: static bool hasBin(int major, int minor)
.. c:function:: static bool hasBin(int major, int minor)
.. cfunction:: static bool hasEqualOrLessPtx(int major, int minor)
.. c:function:: static bool hasEqualOrLessPtx(int major, int minor)
.. cfunction:: static bool hasEqualOrGreater(int major, int minor)
.. c:function:: static bool hasEqualOrGreater(int major, int minor)
.. cfunction:: static bool hasEqualOrGreaterPtx(int major, int minor)
.. c:function:: static bool hasEqualOrGreaterPtx(int major, int minor)
.. cfunction:: static bool hasEqualOrGreaterBin(int major, int minor)
.. c:function:: static bool hasEqualOrGreaterBin(int major, int minor)
* **major** Major compute capability version.
modules/gpu/doc/matrix_reductions.rst
+23 -16
View File
@@ -7,7 +7,7 @@ Matrix Reductions
cv::gpu::meanStdDev
-------------------
.. cfunction:: void meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
.. c:function:: void meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
Computes mean value and standard deviation of matrix elements.
@@ -24,7 +24,7 @@ See also:
cv::gpu::norm
-------------
.. cfunction:: double norm(const GpuMat\& src, int normType=NORM_L2)
.. c:function:: double norm(const GpuMat\& src, int normType=NORM_L2)
Returns norm of matrix (or of two matrices difference).
@@ -32,7 +32,7 @@ cv::gpu::norm
:param normType: Norm type. ``NORM_L1`` , ``NORM_L2`` and ``NORM_INF`` are supported for now.
.. cfunction:: double norm(const GpuMat\& src, int normType, GpuMat\& buf)
.. c:function:: double norm(const GpuMat\& src, int normType, GpuMat\& buf)
* **src** Source matrix. Any matrices except 64F are supported.
@@ -40,7 +40,8 @@ cv::gpu::norm
* **buf** Optional buffer to avoid extra memory allocations. It's resized automatically.
.. cfunction:: double norm(const GpuMat\& src1, const GpuMat\& src2,
.. c:function:: double norm(const GpuMat\& src1, const GpuMat\& src2,
int normType=NORM_L2)
* **src1** First source matrix. ``CV_8UC1`` matrices are supported for now.
@@ -56,9 +57,9 @@ See also:
cv::gpu::sum
------------
------------
.. c:function:: Scalar sum(const GpuMat\& src)
.. c:function:: Scalar sum(const GpuMat\& src, GpuMat\& buf)
Returns sum of matrix elements.
@@ -73,9 +74,9 @@ See also:
cv::gpu::absSum
---------------
---------------
.. c:function:: Scalar absSum(const GpuMat\& src)
.. c:function:: Scalar absSum(const GpuMat\& src, GpuMat\& buf)
Returns sum of matrix elements absolute values.
@@ -87,9 +88,9 @@ cv::gpu::absSum
cv::gpu::sqrSum
---------------
---------------
.. c:function:: Scalar sqrSum(const GpuMat\& src)
.. c:function:: Scalar sqrSum(const GpuMat\& src, GpuMat\& buf)
Returns squared sum of matrix elements.
@@ -101,9 +102,11 @@ cv::gpu::sqrSum
cv::gpu::minMax
---------------
---------------
.. c:function:: void minMax(const GpuMat\& src, double* minVal,
double* maxVal=0, const GpuMat\& mask=GpuMat())
double* maxVal=0, const GpuMat\& mask=GpuMat())
.. c:function:: void minMax(const GpuMat\& src, double* minVal, double* maxVal,
const GpuMat\& mask, GpuMat\& buf)
Finds global minimum and maximum matrix elements and returns their values.
@@ -126,9 +129,13 @@ See also:
cv::gpu::minMaxLoc
------------------
.. c:function:: void minMaxLoc(const GpuMat\& src, double\* minVal, double* maxVal=0,
Point* minLoc=0, Point* maxLoc=0,
const GpuMat\& mask=GpuMat())
------------------
.. c:function:: void 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.
@@ -157,9 +164,9 @@ See also:
cv::gpu::countNonZero
---------------------
See also:
.. c:function:: int countNonZero(const GpuMat\& src)
.. c:function:: int countNonZero(const GpuMat\& src, GpuMat\& buf)
Counts non-zero matrix elements.
modules/gpu/doc/object_detection.rst
+34 -22
View File
@@ -9,7 +9,7 @@ Object Detection
gpu::HOGDescriptor
------------------
.. ctype:: gpu::HOGDescriptor
.. c:type:: gpu::HOGDescriptor
Histogram of Oriented Gradients
dalal_hog
@@ -62,7 +62,7 @@ descriptor and detector. ::
private:
// Hidden
}
..
Interfaces of all methods are kept similar to CPU HOG descriptor and detector analogues as much as possible.
@@ -70,7 +70,12 @@ Interfaces of all methods are kept similar to CPU HOG descriptor and detector an
cv::gpu::HOGDescriptor::HOGDescriptor
-------------------------------------
.. cfunction:: HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128),
.. c:function:: 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,
double threshold_L2hys=0.2, bool gamma_correction=true,
int nlevels=DEFAULT_NLEVELS)
Creates HOG descriptor and detector.
@@ -96,7 +101,7 @@ cv::gpu::HOGDescriptor::HOGDescriptor
cv::gpu::HOGDescriptor::getDescriptorSize
-----------------------------------------
.. c:function:: size_t HOGDescriptor::getDescriptorSize() const
Returns number of coefficients required for the classification.
@@ -104,7 +109,7 @@ cv::gpu::HOGDescriptor::getDescriptorSize
cv::gpu::HOGDescriptor::getBlockHistogramSize
---------------------------------------------
.. c:function:: size_t HOGDescriptor::getBlockHistogramSize() const
Returns block histogram size.
@@ -112,7 +117,7 @@ cv::gpu::HOGDescriptor::getBlockHistogramSize
cv::gpu::HOGDescriptor::setSVMDetector
--------------------------------------
.. c:function:: void HOGDescriptor::setSVMDetector(const vector<float>\& detector)
Sets coefficients for the linear SVM classifier.
@@ -120,7 +125,7 @@ cv::gpu::HOGDescriptor::setSVMDetector
cv::gpu::HOGDescriptor::getDefaultPeopleDetector
------------------------------------------------
.. c:function:: static vector<float> HOGDescriptor::getDefaultPeopleDetector()
Returns coefficients of the classifier trained for people detection (for default window size).
@@ -128,7 +133,7 @@ cv::gpu::HOGDescriptor::getDefaultPeopleDetector
cv::gpu::HOGDescriptor::getPeopleDetector48x96
----------------------------------------------
.. c:function:: static vector<float> HOGDescriptor::getPeopleDetector48x96()
Returns coefficients of the classifier trained for people detection (for 48x96 windows).
@@ -136,7 +141,7 @@ cv::gpu::HOGDescriptor::getPeopleDetector48x96
cv::gpu::HOGDescriptor::getPeopleDetector64x128
-----------------------------------------------
.. c:function:: static vector<float> HOGDescriptor::getPeopleDetector64x128()
Returns coefficients of the classifier trained for people detection (for 64x128 windows).
@@ -144,7 +149,9 @@ cv::gpu::HOGDescriptor::getPeopleDetector64x128
cv::gpu::HOGDescriptor::detect
------------------------------
.. c:function:: void HOGDescriptor::detect(const GpuMat\& img,
vector<Point>\& found_locations, double hit_threshold=0,
Size win_stride=Size(), Size padding=Size())
Perfroms object detection without multiscale window.
@@ -162,7 +169,10 @@ cv::gpu::HOGDescriptor::detect
cv::gpu::HOGDescriptor::detectMultiScale
----------------------------------------
.. c:function:: void 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)
Perfroms object detection with multiscale window.
@@ -185,7 +195,9 @@ cv::gpu::HOGDescriptor::detectMultiScale
cv::gpu::HOGDescriptor::getDescriptors
--------------------------------------
.. c:function:: void 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. It's mainly used for classifier learning purposes.
@@ -195,12 +207,12 @@ cv::gpu::HOGDescriptor::getDescriptors
:param descriptors: 2D array of descriptors.
.. cfunction:: void HOGDescriptor::getDescriptors(const GpuMat\& img,
:param descr_format: Descriptor storage format:
* **DESCR_FORMAT_ROW_BY_ROW** Row-major order.
* **DESCR_FORMAT_COL_BY_COL** Column-major order.
.. index:: gpu::CascadeClassifier_GPU
@@ -208,7 +220,7 @@ cv::gpu::HOGDescriptor::getDescriptors
gpu::CascadeClassifier_GPU
--------------------------
.. c:type:: gpu::CascadeClassifier_GPU
The cascade classifier class for object detection. ::
@@ -234,7 +246,7 @@ The cascade classifier class for object detection. ::
Size getClassifierSize() const;
};
.. index:: cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
@@ -242,7 +254,7 @@ The cascade classifier class for object detection. ::
cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
-----------------------------------------------------
bool visualizeInPlace;
.. c:function:: cv::CascadeClassifier_GPU(const string\& filename)
Loads the classifier from file.
@@ -254,7 +266,7 @@ cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
cv::gpu::CascadeClassifier_GPU::empty
-------------------------------------
.. cfunction:: cv::CascadeClassifier_GPU(const string\& filename)
.. c:function:: bool CascadeClassifier_GPU::empty() const
Checks if the classifier has been loaded or not.
@@ -264,7 +276,7 @@ cv::gpu::CascadeClassifier_GPU::empty
cv::gpu::CascadeClassifier_GPU::load
------------------------------------
cv::gpu::CascadeClassifier_GPU::empty
.. c:function:: bool CascadeClassifier_GPU::load(const string\& filename)
Loads the classifier from file. The previous content is destroyed.
@@ -276,7 +288,7 @@ cv::gpu::CascadeClassifier_GPU::load
cv::gpu::CascadeClassifier_GPU::release
---------------------------------------
.. cfunction:: bool CascadeClassifier_GPU::load(const string\& filename)
.. c:function:: void CascadeClassifier_GPU::release()
Destroys loaded classifier.
@@ -286,7 +298,7 @@ cv::gpu::CascadeClassifier_GPU::release
cv::gpu::CascadeClassifier_GPU::detectMultiScale
------------------------------------------------
cv::gpu::CascadeClassifier_GPU::release
.. c:function:: int 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.
@@ -320,7 +332,7 @@ The function returns number of detected objects, so you can retrieve them as in
cv::rectangle(image_cpu, faces[i], Scalar(255));
imshow("Faces", image_cpu);
int detections_number = cascade_gpu.detectMultiScale( image_gpu,
See also:
:func:`CascadeClassifier::detectMultiScale` .
modules/gpu/doc/operations_on_matrices.rst
+40 -28
View File
@@ -7,7 +7,7 @@ Operations on Matrices
cv::gpu::transpose
------------------
.. cfunction:: void transpose(const GpuMat\& src, GpuMat\& dst)
.. c:function:: void transpose(const GpuMat\& src, GpuMat\& dst)
Transposes a matrix.
@@ -22,7 +22,7 @@ See also:
cv::gpu::flip
-------------
.. cfunction:: void flip(const GpuMat\& a, GpuMat\& b, int flipCode)
.. c:function:: void flip(const GpuMat\& a, GpuMat\& b, int flipCode)
Flips a 2D matrix around vertical, horizontal or both axes.
@@ -30,14 +30,14 @@ cv::gpu::flip
:param b: Destination matrix.
:param flipCode: Specifies how to flip the source:
:param flipCode: Specifies how to flip the source:
* **0** Flip around x-axis.
* **:math:`>`0** Flip around y-axis.
* **:math:`<`0** Flip around both axes.
See also:
:func:`flip` .
@@ -50,7 +50,7 @@ cv::gpu::LUT
dst(I) = lut(src(I))
.. cfunction:: void LUT(const GpuMat\& src, const Mat\& lut, GpuMat\& dst)
.. c:function:: void LUT(const GpuMat\& src, const Mat\& lut, GpuMat\& dst)
Transforms the source matrix into the destination matrix using given look-up table:
@@ -67,9 +67,10 @@ See also:
cv::gpu::merge
--------------
.. cfunction:: void merge(const GpuMat* src, size_t n, GpuMat\& dst)
.. c:function:: void merge(const GpuMat* src, size_t n, GpuMat\& dst)
.. cfunction:: void merge(const GpuMat* src, size_t n, GpuMat\& dst,
.. c:function:: void merge(const GpuMat* src, size_t n, GpuMat\& dst,
const Stream\& stream)
Makes a multi-channel matrix out of several single-channel matrices.
@@ -81,9 +82,10 @@ cv::gpu::merge
:param stream: Stream for the asynchronous version.
.. c:function:: void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst)
.. c:function:: void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst,
const Stream\& stream)
* **src** Vector of the source matrices.
@@ -98,9 +100,9 @@ See also:
cv::gpu::split
--------------
cv::gpu::split
.. c:function:: void split(const GpuMat\& src, GpuMat* dst)
.. cfunction:: void split(const GpuMat\& src, GpuMat* dst)
.. c:function:: void split(const GpuMat\& src, GpuMat* dst, const Stream\& stream)
Copies each plane of a multi-channel matrix into an array.
@@ -110,9 +112,10 @@ cv::gpu::split
:param stream: Stream for the asynchronous version.
:param stream: Stream for the asynchronous version.
.. c:function:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst)
.. cfunction:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst)
.. c:function:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst,
const Stream\& stream)
* **src** Source matrix.
@@ -127,7 +130,7 @@ See also:
cv::gpu::magnitude
------------------
.. c:function:: void magnitude(const GpuMat\& x, GpuMat\& magnitude)
Computes magnitudes of complex matrix elements.
@@ -135,9 +138,10 @@ cv::gpu::magnitude
:param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ).
.. c:function:: void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude)
.. c:function:: void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
const Stream\& stream)
* **x** Source matrix, containing real components ( ``CV_32FC1`` ).
@@ -154,7 +158,7 @@ See also:
cv::gpu::magnitudeSqr
---------------------
.. index:: gpu::magnitudeSqr
.. c:function:: void magnitudeSqr(const GpuMat\& x, GpuMat\& magnitude)
Computes squared magnitudes of complex matrix elements.
@@ -162,9 +166,10 @@ cv::gpu::magnitudeSqr
:param magnitude: Destination matrix of float magnitude squares ( ``CV_32FC1`` ).
:param x: Source complex matrix in the interleaved format ( ``CV_32FC2`` ).
.. c:function:: void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude)
:param magnitude: Destination matrix of float magnitude squares ( ``CV_32FC1`` ).
.. c:function:: void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
const Stream\& stream)
* **x** Source matrix, containing real components ( ``CV_32FC1`` ).
@@ -178,9 +183,11 @@ cv::gpu::magnitudeSqr
cv::gpu::phase
--------------
.. c:function:: void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,
bool angleInDegrees=false)
.. c:function:: void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,
bool angleInDegrees, const Stream\& stream)
Computes polar angles of complex matrix elements.
@@ -201,9 +208,11 @@ See also:
cv::gpu::cartToPolar
--------------------
See also:
.. c:function:: void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
GpuMat\& angle, bool angleInDegrees=false)
.. c:function:: void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
GpuMat\& angle, bool angleInDegrees, const Stream\& stream)
Converts Cartesian coordinates into polar.
@@ -226,9 +235,12 @@ See also:
cv::gpu::polarToCart
--------------------
:param stream: Stream for the asynchronous version.
.. c:function:: void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,
GpuMat\& x, GpuMat\& y, bool angleInDegrees=false)
See also:
.. c:function:: void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,
GpuMat\& x, GpuMat\& y, bool angleInDegrees,
const Stream\& stream)
Converts polar coordinates into Cartesian.
modules/gpu/doc/per_element_operations..rst
+50 -38
View File
@@ -7,7 +7,7 @@ Per-element Operations.
cv::gpu::add
------------
.. cfunction:: void add(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
.. c:function:: void add(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Computes matrix-matrix or matrix-scalar sum.
@@ -17,7 +17,7 @@ cv::gpu::add
:param c: Destination matrix. Will have the same size and type as ``a`` .
.. cfunction:: void add(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
.. c:function:: void add(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@@ -32,7 +32,7 @@ See also:
cv::gpu::subtract
-----------------
.. cfunction:: void subtract(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
.. c:function:: void subtract(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Subtracts matrix from another matrix (or scalar from matrix).
@@ -42,7 +42,7 @@ cv::gpu::subtract
:param c: Destination matrix. Will have the same size and type as ``a`` .
.. cfunction:: void subtract(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
.. c:function:: void subtract(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@@ -57,7 +57,7 @@ See also:
cv::gpu::multiply
-----------------
.. cfunction:: void multiply(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
.. c:function:: void multiply(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Computes per-element product of two matrices (or of matrix and scalar).
@@ -67,7 +67,7 @@ cv::gpu::multiply
:param c: Destionation matrix. Will have the same size and type as ``a`` .
.. cfunction:: void multiply(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
.. c:function:: void multiply(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@@ -82,7 +82,7 @@ See also:
cv::gpu::divide
---------------
.. cfunction:: void divide(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
.. c:function:: void divide(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Performs per-element division of two matrices (or division of matrix by scalar).
@@ -92,7 +92,7 @@ cv::gpu::divide
:param c: Destionation matrix. Will have the same size and type as ``a`` .
.. cfunction:: void divide(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
.. c:function:: void divide(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@@ -110,7 +110,7 @@ See also:
cv::gpu::exp
------------
.. cfunction:: void exp(const GpuMat\& a, GpuMat\& b)
.. c:function:: void exp(const GpuMat\& a, GpuMat\& b)
Computes exponent of each matrix element.
@@ -125,7 +125,7 @@ See also:
cv::gpu::log
------------
.. cfunction:: void log(const GpuMat\& a, GpuMat\& b)
.. c:function:: void log(const GpuMat\& a, GpuMat\& b)
Computes natural logarithm of absolute value of each matrix element.
@@ -140,7 +140,7 @@ See also:
cv::gpu::absdiff
----------------
.. cfunction:: void absdiff(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
.. c:function:: void absdiff(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Computes per-element absolute difference of two matrices (or of matrix and scalar).
@@ -150,7 +150,7 @@ cv::gpu::absdiff
:param c: Destionation matrix. Will have the same size and type as ``a`` .
.. cfunction:: void absdiff(const GpuMat\& a, const Scalar\& s, GpuMat\& c)
.. c:function:: void absdiff(const GpuMat\& a, const Scalar\& s, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` matrixes are supported for now.
@@ -165,7 +165,7 @@ See also:
cv::gpu::compare
----------------
.. cfunction:: void compare(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int cmpop)
.. c:function:: void compare(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int cmpop)
Compares elements of two matrices.
@@ -175,15 +175,15 @@ cv::gpu::compare
:param c: Destination matrix. Will have the same size as ``a`` and be ``CV_8UC1`` type.
:param cmpop: Flag specifying the relation between the elements to be checked:
* **CMP_EQ** :math:`=`
* **CMP_GT** :math:`>`
* **CMP_GE** :math:`\ge`
* **CMP_LT** :math:`<`
* **CMP_LE** :math:`\le`
* **CMP_NE** :math:`\ne`
:param cmpop: Flag specifying the relation between the elements to be checked:
* **CMP_EQ** :math:`=`
* **CMP_GT** :math:`>`
* **CMP_GE** :math:`\ge`
* **CMP_LT** :math:`<`
* **CMP_LE** :math:`\le`
* **CMP_NE** :math:`\ne`
See also:
:func:`compare` .
@@ -194,9 +194,11 @@ See also:
cv::gpu::bitwise_not
--------------------
.. cfunction:: void bitwise_not(const GpuMat\& src, GpuMat\& dst,
.. c:function:: void bitwise_not(const GpuMat\& src, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. c:function:: void bitwise_not(const GpuMat\& src, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise inversion.
@@ -217,9 +219,11 @@ See also:
cv::gpu::bitwise_or
-------------------
cv::gpu::bitwise_or
.. c:function:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. cfunction:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
.. c:function:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise disjunction of two matrices.
@@ -242,9 +246,11 @@ See also:
cv::gpu::bitwise_and
--------------------
.. _cv::gpu::bitwise_and:
.. c:function:: void bitwise_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
cv::gpu::bitwise_and
.. c:function:: void bitwise_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise conjunction of two matrices.
@@ -267,9 +273,11 @@ See also:
cv::gpu::bitwise_xor
--------------------
.. index:: cv::gpu::bitwise_xor
.. c:function:: void bitwise_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. _cv::gpu::bitwise_xor:
.. c:function:: void bitwise_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise "exclusive or" of two matrices.
@@ -290,9 +298,10 @@ See also:
cv::gpu::min
------------
.. c:function:: void min(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst)
.
.. c:function:: void min(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const Stream\& stream)
Computes per-element minimum of two matrices (or of matrix and scalar).
@@ -304,9 +313,10 @@ cv::gpu::min
:param stream: Stream for the asynchronous version.
.. c:function:: void min(const GpuMat\& src1, double src2, GpuMat\& dst)
.. c:function:: void min(const GpuMat\& src1, double src2, GpuMat\& dst,
const Stream\& stream)
* **src1** Source matrix.
@@ -323,9 +333,10 @@ See also:
cv::gpu::max
------------
.. c:function:: void max(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst)
.. c:function:: void max(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const Stream\& stream)
Computes per-element maximum of two matrices (or of matrix and scalar).
@@ -337,9 +348,10 @@ cv::gpu::max
:param stream: Stream for the asynchronous version.
.. c:function:: void max(const GpuMat\& src1, double src2, GpuMat\& dst)
.. c:function:: void max(const GpuMat\& src1, double src2, GpuMat\& dst,
const Stream\& stream)
* **src1** Source matrix.