set(the_description "GPU-accelerated Operations on Matrices")
-ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations)
+ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
ocv_add_module(gpuarithm opencv_core OPTIONAL opencv_gpulegacy)
--- /dev/null
+Arithm Operations on Matrices
+=============================
+
+.. highlight:: cpp
+
+
+
+gpu::gemm
+------------------
+Performs generalized matrix multiplication.
+
+.. ocv:function:: void gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null())
+
+ :param src1: First multiplied input matrix that should have ``CV_32FC1`` , ``CV_64FC1`` , ``CV_32FC2`` , or ``CV_64FC2`` type.
+
+ :param src2: Second multiplied input matrix of the same type as ``src1`` .
+
+ :param alpha: Weight of the matrix product.
+
+ :param src3: Third optional delta matrix added to the matrix product. It should have the same type as ``src1`` and ``src2`` .
+
+ :param beta: Weight of ``src3`` .
+
+ :param dst: Destination matrix. It has the proper size and the same type as input matrices.
+
+ :param flags: Operation flags:
+
+ * **GEMM_1_T** transpose ``src1``
+ * **GEMM_2_T** transpose ``src2``
+ * **GEMM_3_T** transpose ``src3``
+
+ :param stream: Stream for the asynchronous version.
+
+The function performs generalized matrix multiplication similar to the ``gemm`` functions in BLAS level 3. For example, ``gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)`` corresponds to
+
+.. math::
+
+ \texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T
+
+.. note:: Transposition operation doesn't support ``CV_64FC2`` input type.
+
+.. seealso:: :ocv:func:`gemm`
+
+
+
+gpu::mulSpectrums
+---------------------
+Performs a per-element multiplication of two Fourier spectrums.
+
+.. ocv:function:: void gpu::mulSpectrums( const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false, Stream& stream=Stream::Null() )
+
+ :param a: First spectrum.
+
+ :param b: Second spectrum with the same size and type as ``a`` .
+
+ :param c: Destination spectrum.
+
+ :param flags: Mock parameter used for CPU/GPU interfaces similarity.
+
+ :param conjB: Optional flag to specify if the second spectrum needs to be conjugated before the multiplication.
+
+ Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
+
+.. seealso:: :ocv:func:`mulSpectrums`
+
+
+
+gpu::mulAndScaleSpectrums
+-----------------------------
+Performs a per-element multiplication of two Fourier spectrums and scales the result.
+
+.. ocv:function:: void gpu::mulAndScaleSpectrums( const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false, Stream& stream=Stream::Null() )
+
+ :param a: First spectrum.
+
+ :param b: Second spectrum with the same size and type as ``a`` .
+
+ :param c: Destination spectrum.
+
+ :param flags: Mock parameter used for CPU/GPU interfaces similarity.
+
+ :param scale: Scale constant.
+
+ :param conjB: Optional flag to specify if the second spectrum needs to be conjugated before the multiplication.
+
+ Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
+
+.. seealso:: :ocv:func:`mulSpectrums`
+
+
+
+gpu::dft
+------------
+Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
+
+.. ocv:function:: void gpu::dft( const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0, Stream& stream=Stream::Null() )
+
+ :param src: Source matrix (real or complex).
+
+ :param dst: Destination matrix (real or complex).
+
+ :param dft_size: Size of a discrete Fourier transform.
+
+ :param flags: Optional flags:
+
+ * **DFT_ROWS** transforms each individual row of the source matrix.
+
+ * **DFT_SCALE** scales the result: divide it by the number of elements in the transform (obtained from ``dft_size`` ).
+
+ * **DFT_INVERSE** inverts DFT. Use for complex-complex cases (real-complex and complex-real cases are always forward and inverse, respectively).
+
+ * **DFT_REAL_OUTPUT** specifies the output as real. The source matrix is the result of real-complex transform, so the destination matrix must be real.
+
+Use to handle real matrices ( ``CV32FC1`` ) and complex matrices in the interleaved format ( ``CV32FC2`` ).
+
+The source matrix should be continuous, otherwise reallocation and data copying is performed. The function chooses an operation mode depending on the flags, size, and channel count of the source matrix:
+
+ * If the source matrix is complex and the output is not specified as real, the destination matrix is complex and has the ``dft_size`` size and ``CV_32FC2`` type. The destination matrix contains a full result of the DFT (forward or inverse).
+
+ * If the source matrix is complex and the output is specified as real, the function assumes that its input is the result of the forward transform (see the next item). The destination matrix has the ``dft_size`` size and ``CV_32FC1`` type. It contains the result of the inverse 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.
+
+.. seealso:: :ocv:func:`dft`
+
+
+
+gpu::ConvolveBuf
+----------------
+.. ocv:struct:: gpu::ConvolveBuf
+
+Class providing a memory buffer for :ocv:func:`gpu::convolve` function, plus it allows to adjust some specific parameters. ::
+
+ struct CV_EXPORTS ConvolveBuf
+ {
+ Size result_size;
+ Size block_size;
+ Size user_block_size;
+ Size dft_size;
+ int spect_len;
+
+ GpuMat image_spect, templ_spect, result_spect;
+ GpuMat image_block, templ_block, result_data;
+
+ void create(Size image_size, Size templ_size);
+ static Size estimateBlockSize(Size result_size, Size templ_size);
+ };
+
+You can use field `user_block_size` to set specific block size for :ocv:func:`gpu::convolve` function. If you leave its default value `Size(0,0)` then automatic estimation of block size will be used (which is optimized for speed). By varying `user_block_size` you can reduce memory requirements at the cost of speed.
+
+
+
+gpu::ConvolveBuf::create
+------------------------
+.. ocv:function:: gpu::ConvolveBuf::create(Size image_size, Size templ_size)
+
+Constructs a buffer for :ocv:func:`gpu::convolve` function with respective arguments.
+
+
+
+gpu::convolve
+-----------------
+Computes a convolution (or cross-correlation) of two images.
+
+.. ocv: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, ConvolveBuf& buf, Stream& stream=Stream::Null() )
+
+ :param image: Source image. Only ``CV_32FC1`` images are supported for now.
+
+ :param templ: Template image. The size is not greater than the ``image`` size. The type is the same as ``image`` .
+
+ :param result: Result image. If ``image`` is *W x H* and ``templ`` is *w x h*, then ``result`` must be *W-w+1 x H-h+1*.
+
+ :param ccorr: Flags to evaluate cross-correlation instead of convolution.
+
+ :param buf: Optional buffer to avoid extra memory allocations and to adjust some specific parameters. See :ocv:struct:`gpu::ConvolveBuf`.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`gpu::filter2D`
+
+
+
+gpu::integral
+-----------------
+Computes an integral image.
+
+.. ocv:function:: void gpu::integral(const GpuMat& src, GpuMat& sum, Stream& stream = Stream::Null())
+
+ :param src: Source image. Only ``CV_8UC1`` images are supported for now.
+
+ :param sum: Integral image containing 32-bit unsigned integer values packed into ``CV_32SC1`` .
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`integral`
+
+
+
+gpu::sqrIntegral
+--------------------
+Computes a squared integral image.
+
+.. ocv:function:: void gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& stream = Stream::Null())
+
+ :param src: Source image. Only ``CV_8UC1`` images are supported for now.
+
+ :param sqsum: Squared integral image containing 64-bit unsigned integer values packed into ``CV_64FC1`` .
+
+ :param stream: Stream for the asynchronous version.
--- /dev/null
+Core Operations on Matrices
+===========================
+
+.. highlight:: cpp
+
+
+
+gpu::merge
+--------------
+Makes a multi-channel matrix out of several single-channel matrices.
+
+.. ocv:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null())
+
+ :param src: Array/vector of source matrices.
+
+ :param n: Number of source matrices.
+
+ :param dst: Destination matrix.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`merge`
+
+
+
+gpu::split
+--------------
+Copies each plane of a multi-channel matrix into an array.
+
+.. ocv:function:: void gpu::split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null())
+
+.. ocv:function:: void gpu::split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null())
+
+ :param src: Source matrix.
+
+ :param dst: Destination array/vector of single-channel matrices.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`split`
+
+
+
+gpu::copyMakeBorder
+-----------------------
+Forms a border around an image.
+
+.. ocv:function:: void gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType, const Scalar& value = Scalar(), Stream& stream = Stream::Null())
+
+ :param src: Source image. ``CV_8UC1`` , ``CV_8UC4`` , ``CV_32SC1`` , and ``CV_32FC1`` types are supported.
+
+ :param dst: Destination image with the same type as ``src``. The size is ``Size(src.cols+left+right, src.rows+top+bottom)`` .
+
+ :param top:
+
+ :param bottom:
+
+ :param left:
+
+ :param right: Number of pixels in each direction from the source image rectangle to extrapolate. For example: ``top=1, bottom=1, left=1, right=1`` mean that 1 pixel-wide border needs to be built.
+
+ :param borderType: Border type. See :ocv:func:`borderInterpolate` for details. ``BORDER_REFLECT101`` , ``BORDER_REPLICATE`` , ``BORDER_CONSTANT`` , ``BORDER_REFLECT`` and ``BORDER_WRAP`` are supported for now.
+
+ :param value: Border value.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`copyMakeBorder`
+
+
+
+gpu::transpose
+------------------
+Transposes a matrix.
+
+.. ocv:function:: void gpu::transpose( const GpuMat& src1, GpuMat& dst, Stream& stream=Stream::Null() )
+
+ :param src1: Source matrix. 1-, 4-, 8-byte element sizes are supported for now (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc).
+
+ :param dst: Destination matrix.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`transpose`
+
+
+
+gpu::flip
+-------------
+Flips a 2D matrix around vertical, horizontal, or both axes.
+
+.. ocv:function:: void gpu::flip( const GpuMat& a, GpuMat& b, int flipCode, Stream& stream=Stream::Null() )
+
+ :param a: Source matrix. Supports 1, 3 and 4 channels images with ``CV_8U``, ``CV_16U``, ``CV_32S`` or ``CV_32F`` depth.
+
+ :param b: Destination matrix.
+
+ :param flipCode: Flip mode for the source:
+
+ * ``0`` Flips around x-axis.
+
+ * ``>0`` Flips around y-axis.
+
+ * ``<0`` Flips around both axes.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`flip`
+
+
+
+gpu::LUT
+------------
+Transforms the source matrix into the destination matrix using the given look-up table: ``dst(I) = lut(src(I))``
+
+.. ocv:function:: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null())
+
+ :param src: Source matrix. ``CV_8UC1`` and ``CV_8UC3`` matrices are supported for now.
+
+ :param lut: Look-up table of 256 elements. It is a continuous ``CV_8U`` matrix.
+
+ :param dst: Destination matrix with the same depth as ``lut`` and the same number of channels as ``src`` .
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`LUT`
Per-element Operations
-=======================
+======================
.. highlight:: cpp
.. seealso:: :ocv:func:`divide`
+
gpu::addWeighted
----------------
Computes the weighted sum of two arrays.
:param stream: Stream for the asynchronous version.
.. seealso:: :ocv:func:`threshold`
+
+
+
+gpu::magnitude
+------------------
+Computes magnitudes of complex matrix elements.
+
+.. ocv:function:: void gpu::magnitude( const GpuMat& xy, GpuMat& magnitude, Stream& stream=Stream::Null() )
+
+.. ocv:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null())
+
+ :param xy: Source complex matrix in the interleaved format ( ``CV_32FC2`` ).
+
+ :param x: Source matrix containing real components ( ``CV_32FC1`` ).
+
+ :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
+
+ :param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ).
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`magnitude`
+
+
+
+gpu::magnitudeSqr
+---------------------
+Computes squared magnitudes of complex matrix elements.
+
+.. ocv:function:: void gpu::magnitudeSqr( const GpuMat& xy, GpuMat& magnitude, Stream& stream=Stream::Null() )
+
+.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null())
+
+ :param xy: Source complex matrix in the interleaved format ( ``CV_32FC2`` ).
+
+ :param x: Source matrix containing real components ( ``CV_32FC1`` ).
+
+ :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
+
+ :param magnitude: Destination matrix of float magnitude squares ( ``CV_32FC1`` ).
+
+ :param stream: Stream for the asynchronous version.
+
+
+
+gpu::phase
+--------------
+Computes polar angles of complex matrix elements.
+
+.. ocv:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false, Stream& stream = Stream::Null())
+
+ :param x: Source matrix containing real components ( ``CV_32FC1`` ).
+
+ :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
+
+ :param angle: Destination matrix of angles ( ``CV_32FC1`` ).
+
+ :param angleInDegrees: Flag for angles that must be evaluated in degrees.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`phase`
+
+
+
+gpu::cartToPolar
+--------------------
+Converts Cartesian coordinates into polar.
+
+.. ocv:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false, Stream& stream = Stream::Null())
+
+ :param x: Source matrix containing real components ( ``CV_32FC1`` ).
+
+ :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
+
+ :param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ).
+
+ :param angle: Destination matrix of angles ( ``CV_32FC1`` ).
+
+ :param angleInDegrees: Flag for angles that must be evaluated in degrees.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`cartToPolar`
+
+
+
+gpu::polarToCart
+--------------------
+Converts polar coordinates into Cartesian.
+
+.. ocv:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false, Stream& stream = Stream::Null())
+
+ :param magnitude: Source matrix containing magnitudes ( ``CV_32FC1`` ).
+
+ :param angle: Source matrix containing angles ( ``CV_32FC1`` ).
+
+ :param x: Destination matrix of real components ( ``CV_32FC1`` ).
+
+ :param y: Destination matrix of imaginary components ( ``CV_32FC1`` ).
+
+ :param angleInDegrees: Flag that indicates angles in degrees.
+
+ :param stream: Stream for the asynchronous version.
+
+.. seealso:: :ocv:func:`polarToCart`
-*******************************************
-gpu. GPU-accelerated Operations on Matrices
-*******************************************
+*************************************************
+gpuarithm. GPU-accelerated Operations on Matrices
+*************************************************
.. toctree::
:maxdepth: 1
- operations_on_matrices
- per_element_operations
- matrix_reductions
+ core
+ element_operations
+ reductions
+ arithm
+++ /dev/null
-Operations on Matrices
-======================
-
-.. highlight:: cpp
-
-
-
-gpu::gemm
-------------------
-Performs generalized matrix multiplication.
-
-.. ocv:function:: void gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null())
-
- :param src1: First multiplied input matrix that should have ``CV_32FC1`` , ``CV_64FC1`` , ``CV_32FC2`` , or ``CV_64FC2`` type.
-
- :param src2: Second multiplied input matrix of the same type as ``src1`` .
-
- :param alpha: Weight of the matrix product.
-
- :param src3: Third optional delta matrix added to the matrix product. It should have the same type as ``src1`` and ``src2`` .
-
- :param beta: Weight of ``src3`` .
-
- :param dst: Destination matrix. It has the proper size and the same type as input matrices.
-
- :param flags: Operation flags:
-
- * **GEMM_1_T** transpose ``src1``
- * **GEMM_2_T** transpose ``src2``
- * **GEMM_3_T** transpose ``src3``
-
- :param stream: Stream for the asynchronous version.
-
-The function performs generalized matrix multiplication similar to the ``gemm`` functions in BLAS level 3. For example, ``gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)`` corresponds to
-
-.. math::
-
- \texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T
-
-.. note:: Transposition operation doesn't support ``CV_64FC2`` input type.
-
-.. seealso:: :ocv:func:`gemm`
-
-
-
-gpu::transpose
-------------------
-Transposes a matrix.
-
-.. ocv:function:: void gpu::transpose( const GpuMat& src1, GpuMat& dst, Stream& stream=Stream::Null() )
-
- :param src1: Source matrix. 1-, 4-, 8-byte element sizes are supported for now (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc).
-
- :param dst: Destination matrix.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`transpose`
-
-
-
-gpu::flip
--------------
-Flips a 2D matrix around vertical, horizontal, or both axes.
-
-.. ocv:function:: void gpu::flip( const GpuMat& a, GpuMat& b, int flipCode, Stream& stream=Stream::Null() )
-
- :param a: Source matrix. Supports 1, 3 and 4 channels images with ``CV_8U``, ``CV_16U``, ``CV_32S`` or ``CV_32F`` depth.
-
- :param b: Destination matrix.
-
- :param flipCode: Flip mode for the source:
-
- * ``0`` Flips around x-axis.
-
- * ``>0`` Flips around y-axis.
-
- * ``<0`` Flips around both axes.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`flip`
-
-
-
-gpu::LUT
-------------
-Transforms the source matrix into the destination matrix using the given look-up table: ``dst(I) = lut(src(I))``
-
-.. ocv:function:: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null())
-
- :param src: Source matrix. ``CV_8UC1`` and ``CV_8UC3`` matrices are supported for now.
-
- :param lut: Look-up table of 256 elements. It is a continuous ``CV_8U`` matrix.
-
- :param dst: Destination matrix with the same depth as ``lut`` and the same number of channels as ``src`` .
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`LUT`
-
-
-
-gpu::merge
---------------
-Makes a multi-channel matrix out of several single-channel matrices.
-
-.. ocv:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null())
-
-.. ocv:function:: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null())
-
- :param src: Array/vector of source matrices.
-
- :param n: Number of source matrices.
-
- :param dst: Destination matrix.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`merge`
-
-
-
-gpu::split
---------------
-Copies each plane of a multi-channel matrix into an array.
-
-.. ocv:function:: void gpu::split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null())
-
-.. ocv:function:: void gpu::split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null())
-
- :param src: Source matrix.
-
- :param dst: Destination array/vector of single-channel matrices.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`split`
-
-
-
-gpu::magnitude
-------------------
-Computes magnitudes of complex matrix elements.
-
-.. ocv:function:: void gpu::magnitude( const GpuMat& xy, GpuMat& magnitude, Stream& stream=Stream::Null() )
-
-.. ocv:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null())
-
- :param xy: Source complex matrix in the interleaved format ( ``CV_32FC2`` ).
-
- :param x: Source matrix containing real components ( ``CV_32FC1`` ).
-
- :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
-
- :param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ).
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`magnitude`
-
-
-
-gpu::magnitudeSqr
----------------------
-Computes squared magnitudes of complex matrix elements.
-
-.. ocv:function:: void gpu::magnitudeSqr( const GpuMat& xy, GpuMat& magnitude, Stream& stream=Stream::Null() )
-
-.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null())
-
- :param xy: Source complex matrix in the interleaved format ( ``CV_32FC2`` ).
-
- :param x: Source matrix containing real components ( ``CV_32FC1`` ).
-
- :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
-
- :param magnitude: Destination matrix of float magnitude squares ( ``CV_32FC1`` ).
-
- :param stream: Stream for the asynchronous version.
-
-
-
-gpu::phase
---------------
-Computes polar angles of complex matrix elements.
-
-.. ocv:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false, Stream& stream = Stream::Null())
-
- :param x: Source matrix containing real components ( ``CV_32FC1`` ).
-
- :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
-
- :param angle: Destination matrix of angles ( ``CV_32FC1`` ).
-
- :param angleInDegrees: Flag for angles that must be evaluated in degrees.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`phase`
-
-
-
-gpu::cartToPolar
---------------------
-Converts Cartesian coordinates into polar.
-
-.. ocv:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false, Stream& stream = Stream::Null())
-
- :param x: Source matrix containing real components ( ``CV_32FC1`` ).
-
- :param y: Source matrix containing imaginary components ( ``CV_32FC1`` ).
-
- :param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ).
-
- :param angle: Destination matrix of angles ( ``CV_32FC1`` ).
-
- :param angleInDegrees: Flag for angles that must be evaluated in degrees.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`cartToPolar`
-
-
-
-gpu::polarToCart
---------------------
-Converts polar coordinates into Cartesian.
-
-.. ocv:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false, Stream& stream = Stream::Null())
-
- :param magnitude: Source matrix containing magnitudes ( ``CV_32FC1`` ).
-
- :param angle: Source matrix containing angles ( ``CV_32FC1`` ).
-
- :param x: Destination matrix of real components ( ``CV_32FC1`` ).
-
- :param y: Destination matrix of imaginary components ( ``CV_32FC1`` ).
-
- :param angleInDegrees: Flag that indicates angles in degrees.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`polarToCart`
-
-
-
-gpu::normalize
---------------
-Normalizes the norm or value range of an array.
-
-.. ocv:function:: void gpu::normalize(const GpuMat& src, GpuMat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, const GpuMat& mask = GpuMat())
-
-.. ocv:function:: void gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf)
-
- :param src: input array.
-
- :param dst: output array of the same size as ``src`` .
-
- :param alpha: norm value to normalize to or the lower range boundary in case of the range normalization.
-
- :param beta: upper range boundary in case of the range normalization; it is not used for the norm normalization.
-
- :param normType: normalization type (see the details below).
-
- :param dtype: when negative, the output array has the same type as ``src``; otherwise, it has the same number of channels as ``src`` and the depth ``=CV_MAT_DEPTH(dtype)``.
-
- :param mask: optional operation mask.
-
- :param norm_buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
-
- :param cvt_buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
-
-.. seealso:: :ocv:func:`normalize`
-
-
-
-gpu::mulSpectrums
----------------------
-Performs a per-element multiplication of two Fourier spectrums.
-
-.. ocv:function:: void gpu::mulSpectrums( const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false, Stream& stream=Stream::Null() )
-
- :param a: First spectrum.
-
- :param b: Second spectrum with the same size and type as ``a`` .
-
- :param c: Destination spectrum.
-
- :param flags: Mock parameter used for CPU/GPU interfaces similarity.
-
- :param conjB: Optional flag to specify if the second spectrum needs to be conjugated before the multiplication.
-
- Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
-
-.. seealso:: :ocv:func:`mulSpectrums`
-
-
-
-gpu::mulAndScaleSpectrums
------------------------------
-Performs a per-element multiplication of two Fourier spectrums and scales the result.
-
-.. ocv:function:: void gpu::mulAndScaleSpectrums( const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false, Stream& stream=Stream::Null() )
-
- :param a: First spectrum.
-
- :param b: Second spectrum with the same size and type as ``a`` .
-
- :param c: Destination spectrum.
-
- :param flags: Mock parameter used for CPU/GPU interfaces similarity.
-
- :param scale: Scale constant.
-
- :param conjB: Optional flag to specify if the second spectrum needs to be conjugated before the multiplication.
-
- Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
-
-.. seealso:: :ocv:func:`mulSpectrums`
-
-
-
-gpu::dft
-------------
-Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
-
-.. ocv:function:: void gpu::dft( const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0, Stream& stream=Stream::Null() )
-
- :param src: Source matrix (real or complex).
-
- :param dst: Destination matrix (real or complex).
-
- :param dft_size: Size of a discrete Fourier transform.
-
- :param flags: Optional flags:
-
- * **DFT_ROWS** transforms each individual row of the source matrix.
-
- * **DFT_SCALE** scales the result: divide it by the number of elements in the transform (obtained from ``dft_size`` ).
-
- * **DFT_INVERSE** inverts DFT. Use for complex-complex cases (real-complex and complex-real cases are always forward and inverse, respectively).
-
- * **DFT_REAL_OUTPUT** specifies the output as real. The source matrix is the result of real-complex transform, so the destination matrix must be real.
-
-Use to handle real matrices ( ``CV32FC1`` ) and complex matrices in the interleaved format ( ``CV32FC2`` ).
-
-The source matrix should be continuous, otherwise reallocation and data copying is performed. The function chooses an operation mode depending on the flags, size, and channel count of the source matrix:
-
- * If the source matrix is complex and the output is not specified as real, the destination matrix is complex and has the ``dft_size`` size and ``CV_32FC2`` type. The destination matrix contains a full result of the DFT (forward or inverse).
-
- * If the source matrix is complex and the output is specified as real, the function assumes that its input is the result of the forward transform (see the next item). The destination matrix has the ``dft_size`` size and ``CV_32FC1`` type. It contains the result of the inverse 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.
-
-.. seealso:: :ocv:func:`dft`
-
-
-gpu::ConvolveBuf
-----------------
-.. ocv:struct:: gpu::ConvolveBuf
-
-Class providing a memory buffer for :ocv:func:`gpu::convolve` function, plus it allows to adjust some specific parameters. ::
-
- struct CV_EXPORTS ConvolveBuf
- {
- Size result_size;
- Size block_size;
- Size user_block_size;
- Size dft_size;
- int spect_len;
-
- GpuMat image_spect, templ_spect, result_spect;
- GpuMat image_block, templ_block, result_data;
-
- void create(Size image_size, Size templ_size);
- static Size estimateBlockSize(Size result_size, Size templ_size);
- };
-
-You can use field `user_block_size` to set specific block size for :ocv:func:`gpu::convolve` function. If you leave its default value `Size(0,0)` then automatic estimation of block size will be used (which is optimized for speed). By varying `user_block_size` you can reduce memory requirements at the cost of speed.
-
-gpu::ConvolveBuf::create
-------------------------
-.. ocv:function:: gpu::ConvolveBuf::create(Size image_size, Size templ_size)
-
-Constructs a buffer for :ocv:func:`gpu::convolve` function with respective arguments.
-
-
-gpu::convolve
------------------
-Computes a convolution (or cross-correlation) of two images.
-
-.. ocv: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, ConvolveBuf& buf, Stream& stream=Stream::Null() )
-
- :param image: Source image. Only ``CV_32FC1`` images are supported for now.
-
- :param templ: Template image. The size is not greater than the ``image`` size. The type is the same as ``image`` .
-
- :param result: Result image. If ``image`` is *W x H* and ``templ`` is *w x h*, then ``result`` must be *W-w+1 x H-h+1*.
-
- :param ccorr: Flags to evaluate cross-correlation instead of convolution.
-
- :param buf: Optional buffer to avoid extra memory allocations and to adjust some specific parameters. See :ocv:struct:`gpu::ConvolveBuf`.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`gpu::filter2D`
-
-
-
-gpu::copyMakeBorder
------------------------
-Forms a border around an image.
-
-.. ocv:function:: void gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType, const Scalar& value = Scalar(), Stream& stream = Stream::Null())
-
- :param src: Source image. ``CV_8UC1`` , ``CV_8UC4`` , ``CV_32SC1`` , and ``CV_32FC1`` types are supported.
-
- :param dst: Destination image with the same type as ``src``. The size is ``Size(src.cols+left+right, src.rows+top+bottom)`` .
-
- :param top:
-
- :param bottom:
-
- :param left:
-
- :param right: Number of pixels in each direction from the source image rectangle to extrapolate. For example: ``top=1, bottom=1, left=1, right=1`` mean that 1 pixel-wide border needs to be built.
-
- :param borderType: Border type. See :ocv:func:`borderInterpolate` for details. ``BORDER_REFLECT101`` , ``BORDER_REPLICATE`` , ``BORDER_CONSTANT`` , ``BORDER_REFLECT`` and ``BORDER_WRAP`` are supported for now.
-
- :param value: Border value.
-
- :param stream: Stream for the asynchronous version.
-
-.. seealso:: :ocv:func:`copyMakeBorder`
-gpu::meanStdDev
--------------------
-Computes a mean value and a standard deviation of matrix elements.
-
-.. ocv:function:: void gpu::meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev)
-.. ocv:function:: void gpu::meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev, GpuMat& buf)
-
- :param mtx: Source matrix. ``CV_8UC1`` matrices are supported for now.
-
- :param mean: Mean value.
-
- :param stddev: Standard deviation value.
-
- :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
-
-.. seealso:: :ocv:func:`meanStdDev`
-
-
-
gpu::norm
-------------
Returns the norm of a matrix (or difference of two matrices).
The function ``reduce`` reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of ``CV_REDUCE_SUM`` and ``CV_REDUCE_AVG`` , the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.
.. seealso:: :ocv:func:`reduce`
+
+
+
+gpu::normalize
+--------------
+Normalizes the norm or value range of an array.
+
+.. ocv:function:: void gpu::normalize(const GpuMat& src, GpuMat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, const GpuMat& mask = GpuMat())
+
+.. ocv:function:: void gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf)
+
+ :param src: input array.
+
+ :param dst: output array of the same size as ``src`` .
+
+ :param alpha: norm value to normalize to or the lower range boundary in case of the range normalization.
+
+ :param beta: upper range boundary in case of the range normalization; it is not used for the norm normalization.
+
+ :param normType: normalization type (see the details below).
+
+ :param dtype: when negative, the output array has the same type as ``src``; otherwise, it has the same number of channels as ``src`` and the depth ``=CV_MAT_DEPTH(dtype)``.
+
+ :param mask: optional operation mask.
+
+ :param norm_buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
+
+ :param cvt_buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
+
+.. seealso:: :ocv:func:`normalize`
+
+
+
+gpu::meanStdDev
+-------------------
+Computes a mean value and a standard deviation of matrix elements.
+
+.. ocv:function:: void gpu::meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev)
+.. ocv:function:: void gpu::meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev, GpuMat& buf)
+
+ :param mtx: Source matrix. ``CV_8UC1`` matrices are supported for now.
+
+ :param mean: Mean value.
+
+ :param stddev: Standard deviation value.
+
+ :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
+
+.. seealso:: :ocv:func:`meanStdDev`
+
+
+
+gpu::rectStdDev
+-------------------
+Computes a standard deviation of integral images.
+
+.. ocv:function:: void gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& stream = Stream::Null())
+
+ :param src: Source image. Only the ``CV_32SC1`` type is supported.
+
+ :param sqr: Squared source image. Only the ``CV_32FC1`` type is supported.
+
+ :param dst: Destination image with the same type and size as ``src`` .
+
+ :param rect: Rectangular window.
+
+ :param stream: Stream for the asynchronous version.
CV_EXPORTS void normalize(const GpuMat& src, GpuMat& dst, double a, double b,
int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf);
-//! computes mean value and standard deviation of all or selected array elements
-//! supports only CV_8UC1 type
-CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
-//! buffered version
-CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev, GpuMat& buf);
-
//! computes norm of array
//! supports NORM_INF, NORM_L1, NORM_L2
//! supports all matrices except 64F
//! reduces a matrix to a vector
CV_EXPORTS void reduce(const GpuMat& mtx, GpuMat& vec, int dim, int reduceOp, int dtype = -1, Stream& stream = Stream::Null());
-//! applies fixed threshold to the image
-CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
+//! computes mean value and standard deviation of all or selected array elements
+//! supports only CV_8UC1 type
+CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
+//! buffered version
+CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev, GpuMat& buf);
//! computes the standard deviation of integral images
//! supports only CV_32SC1 source type and CV_32FC1 sqr type
CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType,
const Scalar& value = Scalar(), Stream& stream = Stream::Null());
+//! applies fixed threshold to the image
+CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
+
//! computes the integral image
//! sum will have CV_32S type, but will contain unsigned int values
//! supports only CV_8UC1 source type
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace testing;
+using namespace perf;
+
+//////////////////////////////////////////////////////////////////////
+// GEMM
+
+CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)
+#define ALL_GEMM_FLAGS Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), \
+ GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
+
+DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags);
+
+PERF_TEST_P(Sz_Type_Flags, GEMM,
+ Combine(Values(cv::Size(512, 512), cv::Size(1024, 1024)),
+ Values(CV_32FC1, CV_32FC2, CV_64FC1),
+ ALL_GEMM_FLAGS))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int type = GET_PARAM(1);
+ const int flags = GET_PARAM(2);
+
+ cv::Mat src1(size, type);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, type);
+ declare.in(src2, WARMUP_RNG);
+
+ cv::Mat src3(size, type);
+ declare.in(src3, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ declare.time(5.0);
+
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ const cv::gpu::GpuMat d_src3(src3);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, dst, flags);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ declare.time(50.0);
+
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MulSpectrums
+
+CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
+
+DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);
+
+PERF_TEST_P(Sz_Flags, MulSpectrums,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(0, DftFlags(cv::DFT_ROWS))))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int flag = GET_PARAM(1);
+
+ cv::Mat a(size, CV_32FC2);
+ cv::Mat b(size, CV_32FC2);
+ declare.in(a, b, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_a(a);
+ const cv::gpu::GpuMat d_b(b);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::mulSpectrums(d_a, d_b, dst, flag);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::mulSpectrums(a, b, dst, flag);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MulAndScaleSpectrums
+
+PERF_TEST_P(Sz, MulAndScaleSpectrums,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ const float scale = 1.f / size.area();
+
+ cv::Mat src1(size, CV_32FC2);
+ cv::Mat src2(size, CV_32FC2);
+ declare.in(src1,src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, dst, cv::DFT_ROWS, scale, false);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Dft
+
+PERF_TEST_P(Sz_Flags, Dft,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))
+{
+ declare.time(10.0);
+
+ const cv::Size size = GET_PARAM(0);
+ const int flag = GET_PARAM(1);
+
+ cv::Mat src(size, CV_32FC2);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::dft(d_src, dst, size, flag);
+
+ GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::dft(src, dst, flag);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Convolve
+
+DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);
+
+PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(17, 27, 32, 64),
+ Bool()))
+{
+ declare.time(10.0);
+
+ const cv::Size size = GET_PARAM(0);
+ const int templ_size = GET_PARAM(1);
+ const bool ccorr = GET_PARAM(2);
+
+ const cv::Mat image(size, CV_32FC1);
+ const cv::Mat templ(templ_size, templ_size, CV_32FC1);
+ declare.in(image, templ, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
+ d_image.upload(image);
+
+ cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
+ d_templ.upload(templ);
+
+ cv::gpu::GpuMat dst;
+ cv::gpu::ConvolveBuf d_buf;
+
+ TEST_CYCLE() cv::gpu::convolve(d_image, d_templ, dst, ccorr, d_buf);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ if (ccorr)
+ FAIL_NO_CPU();
+
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::filter2D(image, dst, image.depth(), templ);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Integral
+
+PERF_TEST_P(Sz, Integral,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src(size, CV_8UC1);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+ cv::gpu::GpuMat d_buf;
+
+ TEST_CYCLE() cv::gpu::integralBuffered(d_src, dst, d_buf);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::integral(src, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// IntegralSqr
+
+PERF_TEST_P(Sz, IntegralSqr,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src(size, CV_8UC1);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::sqrIntegral(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
}
//////////////////////////////////////////////////////////////////////
-// AddMat
-
-PERF_TEST_P(Sz_Depth, AddMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::add(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::add(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// AddScalar
-
-PERF_TEST_P(Sz_Depth, AddScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::add(d_src, s, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::add(src, s, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// SubtractMat
-
-PERF_TEST_P(Sz_Depth, SubtractMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::subtract(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// SubtractScalar
-
-PERF_TEST_P(Sz_Depth, SubtractScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::subtract(d_src, s, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::subtract(src, s, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MultiplyMat
-
-PERF_TEST_P(Sz_Depth, MultiplyMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::multiply(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MultiplyScalar
-
-PERF_TEST_P(Sz_Depth, MultiplyScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::multiply(d_src, s, dst);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::multiply(src, s, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// DivideMat
-
-PERF_TEST_P(Sz_Depth, DivideMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::divide(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// DivideScalar
-
-PERF_TEST_P(Sz_Depth, DivideScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::divide(d_src, s, dst);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::divide(src, s, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// DivideScalarInv
-
-PERF_TEST_P(Sz_Depth, DivideScalarInv,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::divide(s[0], d_src, dst);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::divide(s, src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// AbsDiffMat
-
-PERF_TEST_P(Sz_Depth, AbsDiffMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::absdiff(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// AbsDiffScalar
-
-PERF_TEST_P(Sz_Depth, AbsDiffScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::absdiff(d_src, s, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::absdiff(src, s, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Abs
-
-PERF_TEST_P(Sz_Depth, Abs,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_16S, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::abs(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Sqr
-
-PERF_TEST_P(Sz_Depth, Sqr,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16S, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::sqr(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Sqrt
-
-PERF_TEST_P(Sz_Depth, Sqrt,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16S, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- cv::randu(src, 0, 100000);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::sqrt(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::sqrt(src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Log
-
-PERF_TEST_P(Sz_Depth, Log,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16S, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- cv::randu(src, 0, 100000);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::log(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::log(src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Exp
-
-PERF_TEST_P(Sz_Depth, Exp,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16S, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- cv::randu(src, 0, 10);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::exp(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::exp(src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Pow
-
-DEF_PARAM_TEST(Sz_Depth_Power, cv::Size, MatDepth, double);
-
-PERF_TEST_P(Sz_Depth_Power, Pow,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16S, CV_32F),
- Values(0.3, 2.0, 2.4)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const double power = GET_PARAM(2);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::pow(d_src, power, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::pow(src, power, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// CompareMat
-
-CV_ENUM(CmpCode, CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE)
-
-DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CmpCode);
-
-PERF_TEST_P(Sz_Depth_Code, CompareMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH,
- CmpCode::all()))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int cmp_code = GET_PARAM(2);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, dst, cmp_code);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::compare(src1, src2, dst, cmp_code);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// CompareScalar
-
-PERF_TEST_P(Sz_Depth_Code, CompareScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- ARITHM_MAT_DEPTH,
- CmpCode::all()))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int cmp_code = GET_PARAM(2);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::compare(d_src, s, dst, cmp_code);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::compare(src, s, dst, cmp_code);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseNot
-
-PERF_TEST_P(Sz_Depth, BitwiseNot,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_not(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_not(src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseAndMat
-
-PERF_TEST_P(Sz_Depth, BitwiseAndMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_and(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseAndScalar
-
-PERF_TEST_P(Sz_Depth_Cn, BitwiseAndScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
- cv::Scalar_<int> is = s;
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_and(d_src, is, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_and(src, is, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseOrMat
-
-PERF_TEST_P(Sz_Depth, BitwiseOrMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_or(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseOrScalar
-
-PERF_TEST_P(Sz_Depth_Cn, BitwiseOrScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
- cv::Scalar_<int> is = s;
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_or(d_src, is, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_or(src, is, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseXorMat
-
-PERF_TEST_P(Sz_Depth, BitwiseXorMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_xor(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// BitwiseXorScalar
-
-PERF_TEST_P(Sz_Depth_Cn, BitwiseXorScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar s;
- declare.in(s, WARMUP_RNG);
- cv::Scalar_<int> is = s;
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::bitwise_xor(d_src, is, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::bitwise_xor(src, is, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// RShift
-
-PERF_TEST_P(Sz_Depth_Cn, RShift,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- const cv::Scalar_<int> val = cv::Scalar_<int>::all(4);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::rshift(d_src, val, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// LShift
-
-PERF_TEST_P(Sz_Depth_Cn, LShift,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- const cv::Scalar_<int> val = cv::Scalar_<int>::all(4);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::lshift(d_src, val, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MinMat
-
-PERF_TEST_P(Sz_Depth, MinMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::min(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::min(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MinScalar
-
-PERF_TEST_P(Sz_Depth, MinScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar val;
- declare.in(val, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::min(d_src, val[0], dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::min(src, val[0], dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MaxMat
-
-PERF_TEST_P(Sz_Depth, MaxMat,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src1(size, depth);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::max(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::max(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MaxScalar
-
-PERF_TEST_P(Sz_Depth, MaxScalar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- cv::Scalar val;
- declare.in(val, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::max(d_src, val[0], dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::max(src, val[0], dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// AddWeighted
-
-DEF_PARAM_TEST(Sz_3Depth, cv::Size, MatDepth, MatDepth, MatDepth);
-
-PERF_TEST_P(Sz_3Depth, AddWeighted,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F, CV_64F),
- Values(CV_8U, CV_16U, CV_32F, CV_64F),
- Values(CV_8U, CV_16U, CV_32F, CV_64F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth1 = GET_PARAM(1);
- const int depth2 = GET_PARAM(2);
- const int dst_depth = GET_PARAM(3);
-
- cv::Mat src1(size, depth1);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, depth2);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, dst, dst_depth);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// GEMM
-
-CV_FLAGS(GemmFlags, 0, GEMM_1_T, GEMM_2_T, GEMM_3_T)
-#define ALL_GEMM_FLAGS Values(0, (int)cv::GEMM_1_T, (int)cv::GEMM_2_T, (int)cv::GEMM_3_T, \
- (int)cv::GEMM_1_T | cv::GEMM_2_T, (int)cv::GEMM_1_T | cv::GEMM_3_T, \
- (int)cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T)
-
-DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags);
-
-PERF_TEST_P(Sz_Type_Flags, GEMM,
- Combine(Values(cv::Size(512, 512), cv::Size(1024, 1024)),
- Values(CV_32FC1, CV_32FC2, CV_64FC1),
- ALL_GEMM_FLAGS))
-{
- const cv::Size size = GET_PARAM(0);
- const int type = GET_PARAM(1);
- const int flags = GET_PARAM(2);
-
- cv::Mat src1(size, type);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, type);
- declare.in(src2, WARMUP_RNG);
-
- cv::Mat src3(size, type);
- declare.in(src3, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- declare.time(5.0);
-
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- const cv::gpu::GpuMat d_src3(src3);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, dst, flags);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- declare.time(50.0);
-
- cv::Mat dst;
-
- TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Transpose
-
-PERF_TEST_P(Sz_Type, Transpose,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)))
-{
- const cv::Size size = GET_PARAM(0);
- const int type = GET_PARAM(1);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::transpose(d_src, dst);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::transpose(src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Flip
-
-enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
-CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
-
-DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, MatCn, FlipCode);
-
-PERF_TEST_P(Sz_Depth_Cn_Code, Flip,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F),
- GPU_CHANNELS_1_3_4,
- FlipCode::all()))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
- const int flipCode = GET_PARAM(3);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::flip(d_src, dst, flipCode);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::flip(src, dst, flipCode);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// LutOneChannel
-
-PERF_TEST_P(Sz_Type, LutOneChannel,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8UC1, CV_8UC3)))
-{
- const cv::Size size = GET_PARAM(0);
- const int type = GET_PARAM(1);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- cv::Mat lut(1, 256, CV_8UC1);
- declare.in(lut, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::LUT(d_src, lut, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::LUT(src, lut, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// LutMultiChannel
-
-PERF_TEST_P(Sz_Type, LutMultiChannel,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values<MatType>(CV_8UC3)))
-{
- const cv::Size size = GET_PARAM(0);
- const int type = GET_PARAM(1);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src.channels()));
- declare.in(lut, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::LUT(d_src, lut, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::LUT(src, lut, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MagnitudeComplex
-
-PERF_TEST_P(Sz, MagnitudeComplex,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src(size, CV_32FC2);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::magnitude(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat xy[2];
- cv::split(src, xy);
-
- cv::Mat dst;
-
- TEST_CYCLE() cv::magnitude(xy[0], xy[1], dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MagnitudeSqrComplex
-
-PERF_TEST_P(Sz, MagnitudeSqrComplex,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src(size, CV_32FC2);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Magnitude
-
-PERF_TEST_P(Sz, Magnitude,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src1(size, CV_32FC1);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, CV_32FC1);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::magnitude(src1, src2, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MagnitudeSqr
-
-PERF_TEST_P(Sz, MagnitudeSqr,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src1(size, CV_32FC1);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, CV_32FC1);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Phase
-
-DEF_PARAM_TEST(Sz_AngleInDegrees, cv::Size, bool);
-
-PERF_TEST_P(Sz_AngleInDegrees, Phase,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Bool()))
-{
- const cv::Size size = GET_PARAM(0);
- const bool angleInDegrees = GET_PARAM(1);
-
- cv::Mat src1(size, CV_32FC1);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, CV_32FC1);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, dst, angleInDegrees);
-
- GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::phase(src1, src2, dst, angleInDegrees);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// CartToPolar
-
-PERF_TEST_P(Sz_AngleInDegrees, CartToPolar,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Bool()))
-{
- const cv::Size size = GET_PARAM(0);
- const bool angleInDegrees = GET_PARAM(1);
-
- cv::Mat src1(size, CV_32FC1);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, CV_32FC1);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat magnitude;
- cv::gpu::GpuMat angle;
-
- TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, magnitude, angle, angleInDegrees);
-
- GPU_SANITY_CHECK(magnitude);
- GPU_SANITY_CHECK(angle, 1e-6, ERROR_RELATIVE);
- }
- else
- {
- cv::Mat magnitude;
- cv::Mat angle;
-
- TEST_CYCLE() cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
-
- CPU_SANITY_CHECK(magnitude);
- CPU_SANITY_CHECK(angle);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// PolarToCart
-
-PERF_TEST_P(Sz_AngleInDegrees, PolarToCart,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Bool()))
-{
- const cv::Size size = GET_PARAM(0);
- const bool angleInDegrees = GET_PARAM(1);
-
- cv::Mat magnitude(size, CV_32FC1);
- declare.in(magnitude, WARMUP_RNG);
-
- cv::Mat angle(size, CV_32FC1);
- declare.in(angle, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_magnitude(magnitude);
- const cv::gpu::GpuMat d_angle(angle);
- cv::gpu::GpuMat x;
- cv::gpu::GpuMat y;
-
- TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, x, y, angleInDegrees);
-
- GPU_SANITY_CHECK(x);
- GPU_SANITY_CHECK(y);
- }
- else
- {
- cv::Mat x;
- cv::Mat y;
-
- TEST_CYCLE() cv::polarToCart(magnitude, angle, x, y, angleInDegrees);
-
- CPU_SANITY_CHECK(x);
- CPU_SANITY_CHECK(y);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MeanStdDev
-
-PERF_TEST_P(Sz, MeanStdDev,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src(size, CV_8UC1);
- declare.in(src, WARMUP_RNG);
-
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- cv::Scalar gpu_mean;
- cv::Scalar gpu_stddev;
-
- TEST_CYCLE() cv::gpu::meanStdDev(d_src, gpu_mean, gpu_stddev, d_buf);
-
- SANITY_CHECK(gpu_mean);
- SANITY_CHECK(gpu_stddev);
- }
- else
- {
- cv::Scalar cpu_mean;
- cv::Scalar cpu_stddev;
-
- TEST_CYCLE() cv::meanStdDev(src, cpu_mean, cpu_stddev);
-
- SANITY_CHECK(cpu_mean);
- SANITY_CHECK(cpu_stddev);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Norm
-
-DEF_PARAM_TEST(Sz_Depth_Norm, cv::Size, MatDepth, NormType);
-
-PERF_TEST_P(Sz_Depth_Norm, Norm,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32S, CV_32F),
- Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int normType = GET_PARAM(2);
-
- cv::Mat src(size, depth);
- if (depth == CV_8U)
- cv::randu(src, 0, 254);
- else
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- double gpu_dst;
-
- TEST_CYCLE() gpu_dst = cv::gpu::norm(d_src, normType, d_buf);
-
- SANITY_CHECK(gpu_dst, 1e-6, ERROR_RELATIVE);
- }
- else
- {
- double cpu_dst;
-
- TEST_CYCLE() cpu_dst = cv::norm(src, normType);
-
- SANITY_CHECK(cpu_dst, 1e-6, ERROR_RELATIVE);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// NormDiff
-
-DEF_PARAM_TEST(Sz_Norm, cv::Size, NormType);
-
-PERF_TEST_P(Sz_Norm, NormDiff,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
-{
- const cv::Size size = GET_PARAM(0);
- const int normType = GET_PARAM(1);
-
- cv::Mat src1(size, CV_8UC1);
- declare.in(src1, WARMUP_RNG);
-
- cv::Mat src2(size, CV_8UC1);
- declare.in(src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- double gpu_dst;
-
- TEST_CYCLE() gpu_dst = cv::gpu::norm(d_src1, d_src2, normType);
-
- SANITY_CHECK(gpu_dst);
-
- }
- else
- {
- double cpu_dst;
-
- TEST_CYCLE() cpu_dst = cv::norm(src1, src2, normType);
-
- SANITY_CHECK(cpu_dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Sum
-
-PERF_TEST_P(Sz_Depth_Cn, Sum,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- cv::Scalar gpu_dst;
-
- TEST_CYCLE() gpu_dst = cv::gpu::sum(d_src, d_buf);
-
- SANITY_CHECK(gpu_dst, 1e-5, ERROR_RELATIVE);
- }
- else
- {
- cv::Scalar cpu_dst;
-
- TEST_CYCLE() cpu_dst = cv::sum(src);
-
- SANITY_CHECK(cpu_dst, 1e-6, ERROR_RELATIVE);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// SumAbs
-
-PERF_TEST_P(Sz_Depth_Cn, SumAbs,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F),
- GPU_CHANNELS_1_3_4))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
-
- cv::Mat src(size, type);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- cv::Scalar gpu_dst;
-
- TEST_CYCLE() gpu_dst = cv::gpu::absSum(d_src, d_buf);
-
- SANITY_CHECK(gpu_dst, 1e-6, ERROR_RELATIVE);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// SumSqr
+// Transpose
-PERF_TEST_P(Sz_Depth_Cn, SumSqr,
+PERF_TEST_P(Sz_Type, Transpose,
Combine(GPU_TYPICAL_MAT_SIZES,
- Values<MatDepth>(CV_8U, CV_16U, CV_32F),
- GPU_CHANNELS_1_3_4))
+ Values(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)))
{
const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int channels = GET_PARAM(2);
-
- const int type = CV_MAKE_TYPE(depth, channels);
+ const int type = GET_PARAM(1);
cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
{
const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- cv::Scalar gpu_dst;
-
- TEST_CYCLE() gpu_dst = cv::gpu::sqrSum(d_src, d_buf);
-
- SANITY_CHECK(gpu_dst, 1e-6, ERROR_RELATIVE);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MinMax
-
-PERF_TEST_P(Sz_Depth, MinMax,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F, CV_64F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- if (depth == CV_8U)
- cv::randu(src, 0, 254);
- else
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- double gpu_minVal, gpu_maxVal;
-
- TEST_CYCLE() cv::gpu::minMax(d_src, &gpu_minVal, &gpu_maxVal, cv::gpu::GpuMat(), d_buf);
-
- SANITY_CHECK(gpu_minVal, 1e-10);
- SANITY_CHECK(gpu_maxVal, 1e-10);
- }
- else
- {
- double cpu_minVal, cpu_maxVal;
-
- TEST_CYCLE() cv::minMaxLoc(src, &cpu_minVal, &cpu_maxVal);
-
- SANITY_CHECK(cpu_minVal);
- SANITY_CHECK(cpu_maxVal);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MinMaxLoc
-
-PERF_TEST_P(Sz_Depth, MinMaxLoc,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F, CV_64F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- if (depth == CV_8U)
- cv::randu(src, 0, 254);
- else
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_valbuf, d_locbuf;
- double gpu_minVal, gpu_maxVal;
- cv::Point gpu_minLoc, gpu_maxLoc;
-
- TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &gpu_minVal, &gpu_maxVal, &gpu_minLoc, &gpu_maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
-
- SANITY_CHECK(gpu_minVal, 1e-10);
- SANITY_CHECK(gpu_maxVal, 1e-10);
- }
- else
- {
- double cpu_minVal, cpu_maxVal;
- cv::Point cpu_minLoc, cpu_maxLoc;
-
- TEST_CYCLE() cv::minMaxLoc(src, &cpu_minVal, &cpu_maxVal, &cpu_minLoc, &cpu_maxLoc);
-
- SANITY_CHECK(cpu_minVal);
- SANITY_CHECK(cpu_maxVal);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// CountNonZero
-
-PERF_TEST_P(Sz_Depth, CountNonZero,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F, CV_64F)))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
- int gpu_dst = 0;
+ cv::gpu::GpuMat dst;
- TEST_CYCLE() gpu_dst = cv::gpu::countNonZero(d_src, d_buf);
+ TEST_CYCLE() cv::gpu::transpose(d_src, dst);
- SANITY_CHECK(gpu_dst);
+ GPU_SANITY_CHECK(dst, 1e-10);
}
else
{
- int cpu_dst = 0;
+ cv::Mat dst;
- TEST_CYCLE() cpu_dst = cv::countNonZero(src);
+ TEST_CYCLE() cv::transpose(src, dst);
- SANITY_CHECK(cpu_dst);
+ CPU_SANITY_CHECK(dst);
}
}
//////////////////////////////////////////////////////////////////////
-// Reduce
+// Flip
-enum {Rows = 0, Cols = 1};
-CV_ENUM(ReduceCode, REDUCE_SUM, REDUCE_AVG, REDUCE_MAX, REDUCE_MIN)
-CV_ENUM(ReduceDim, Rows, Cols)
+enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
+CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
-DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim);
+DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, MatCn, FlipCode);
-PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Reduce,
+PERF_TEST_P(Sz_Depth_Cn_Code, Flip,
Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_16S, CV_32F),
- Values(1, 2, 3, 4),
- ReduceCode::all(),
- ReduceDim::all()))
+ Values(CV_8U, CV_16U, CV_32F),
+ GPU_CHANNELS_1_3_4,
+ FlipCode::all()))
{
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
const int channels = GET_PARAM(2);
- const int reduceOp = GET_PARAM(3);
- const int dim = GET_PARAM(4);
+ const int flipCode = GET_PARAM(3);
const int type = CV_MAKE_TYPE(depth, channels);
const cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat dst;
- TEST_CYCLE() cv::gpu::reduce(d_src, dst, dim, reduceOp);
+ TEST_CYCLE() cv::gpu::flip(d_src, dst, flipCode);
GPU_SANITY_CHECK(dst);
}
{
cv::Mat dst;
- TEST_CYCLE() cv::reduce(src, dst, dim, reduceOp);
+ TEST_CYCLE() cv::flip(src, dst, flipCode);
CPU_SANITY_CHECK(dst);
}
}
-//////////////////////////////////////////////////////////////////////
-// Normalize
-DEF_PARAM_TEST(Sz_Depth_NormType, cv::Size, MatDepth, NormType);
+//////////////////////////////////////////////////////////////////////
+// LutOneChannel
-PERF_TEST_P(Sz_Depth_NormType, Normalize,
+PERF_TEST_P(Sz_Type, LutOneChannel,
Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F, CV_64F),
- Values(NormType(cv::NORM_INF),
- NormType(cv::NORM_L1),
- NormType(cv::NORM_L2),
- NormType(cv::NORM_MINMAX))))
+ Values(CV_8UC1, CV_8UC3)))
{
const cv::Size size = GET_PARAM(0);
const int type = GET_PARAM(1);
- const int norm_type = GET_PARAM(2);
-
- const double alpha = 1;
- const double beta = 0;
cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
- cv::gpu::GpuMat d_norm_buf, d_cvt_buf;
-
- TEST_CYCLE() cv::gpu::normalize(d_src, dst, alpha, beta, norm_type, type, cv::gpu::GpuMat(), d_norm_buf, d_cvt_buf);
-
- GPU_SANITY_CHECK(dst, 1e-6);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::normalize(src, dst, alpha, beta, norm_type, type);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// MulSpectrums
-
-CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
-
-DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);
-
-PERF_TEST_P(Sz_Flags, MulSpectrums,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(0, DftFlags(cv::DFT_ROWS))))
-{
- const cv::Size size = GET_PARAM(0);
- const int flag = GET_PARAM(1);
-
- cv::Mat a(size, CV_32FC2);
- cv::Mat b(size, CV_32FC2);
- declare.in(a, b, WARMUP_RNG);
+ cv::Mat lut(1, 256, CV_8UC1);
+ declare.in(lut, WARMUP_RNG);
if (PERF_RUN_GPU())
{
- const cv::gpu::GpuMat d_a(a);
- const cv::gpu::GpuMat d_b(b);
+ const cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat dst;
- TEST_CYCLE() cv::gpu::mulSpectrums(d_a, d_b, dst, flag);
+ TEST_CYCLE() cv::gpu::LUT(d_src, lut, dst);
GPU_SANITY_CHECK(dst);
}
{
cv::Mat dst;
- TEST_CYCLE() cv::mulSpectrums(a, b, dst, flag);
+ TEST_CYCLE() cv::LUT(src, lut, dst);
CPU_SANITY_CHECK(dst);
}
}
//////////////////////////////////////////////////////////////////////
-// MulAndScaleSpectrums
-
-PERF_TEST_P(Sz, MulAndScaleSpectrums,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- const float scale = 1.f / size.area();
-
- cv::Mat src1(size, CV_32FC2);
- cv::Mat src2(size, CV_32FC2);
- declare.in(src1,src2, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src1(src1);
- const cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, dst, cv::DFT_ROWS, scale, false);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Dft
+// LutMultiChannel
-PERF_TEST_P(Sz_Flags, Dft,
+PERF_TEST_P(Sz_Type, LutMultiChannel,
Combine(GPU_TYPICAL_MAT_SIZES,
- Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))
+ Values<MatType>(CV_8UC3)))
{
- declare.time(10.0);
-
const cv::Size size = GET_PARAM(0);
- const int flag = GET_PARAM(1);
+ const int type = GET_PARAM(1);
- cv::Mat src(size, CV_32FC2);
+ cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
+ cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src.channels()));
+ declare.in(lut, WARMUP_RNG);
+
if (PERF_RUN_GPU())
{
const cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat dst;
- TEST_CYCLE() cv::gpu::dft(d_src, dst, size, flag);
+ TEST_CYCLE() cv::gpu::LUT(d_src, lut, dst);
- GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+ GPU_SANITY_CHECK(dst);
}
else
{
cv::Mat dst;
- TEST_CYCLE() cv::dft(src, dst, flag);
+ TEST_CYCLE() cv::LUT(src, lut, dst);
CPU_SANITY_CHECK(dst);
}
CPU_SANITY_CHECK(dst);
}
}
-
-//////////////////////////////////////////////////////////////////////
-// Integral
-
-PERF_TEST_P(Sz, Integral,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src(size, CV_8UC1);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
- cv::gpu::GpuMat d_buf;
-
- TEST_CYCLE() cv::gpu::integralBuffered(d_src, dst, d_buf);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::integral(src, dst);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// IntegralSqr
-
-PERF_TEST_P(Sz, IntegralSqr,
- GPU_TYPICAL_MAT_SIZES)
-{
- const cv::Size size = GetParam();
-
- cv::Mat src(size, CV_8UC1);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::sqrIntegral(d_src, dst);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- FAIL_NO_CPU();
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Convolve
-
-DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);
-
-PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(17, 27, 32, 64),
- Bool()))
-{
- declare.time(10.0);
-
- const cv::Size size = GET_PARAM(0);
- const int templ_size = GET_PARAM(1);
- const bool ccorr = GET_PARAM(2);
-
- const cv::Mat image(size, CV_32FC1);
- const cv::Mat templ(templ_size, templ_size, CV_32FC1);
- declare.in(image, templ, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
- d_image.upload(image);
-
- cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
- d_templ.upload(templ);
-
- cv::gpu::GpuMat dst;
- cv::gpu::ConvolveBuf d_buf;
-
- TEST_CYCLE() cv::gpu::convolve(d_image, d_templ, dst, ccorr, d_buf);
-
- GPU_SANITY_CHECK(dst);
- }
- else
- {
- if (ccorr)
- FAIL_NO_CPU();
-
- cv::Mat dst;
-
- TEST_CYCLE() cv::filter2D(image, dst, image.depth(), templ);
-
- CPU_SANITY_CHECK(dst);
- }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Threshold
-
-CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
-#define ALL_THRESH_OPS ValuesIn(ThreshOp::all())
-
-DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);
-
-PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold,
- Combine(GPU_TYPICAL_MAT_SIZES,
- Values(CV_8U, CV_16U, CV_32F, CV_64F),
- ALL_THRESH_OPS))
-{
- const cv::Size size = GET_PARAM(0);
- const int depth = GET_PARAM(1);
- const int threshOp = GET_PARAM(2);
-
- cv::Mat src(size, depth);
- declare.in(src, WARMUP_RNG);
-
- if (PERF_RUN_GPU())
- {
- const cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat dst;
-
- TEST_CYCLE() cv::gpu::threshold(d_src, dst, 100.0, 255.0, threshOp);
-
- GPU_SANITY_CHECK(dst, 1e-10);
- }
- else
- {
- cv::Mat dst;
-
- TEST_CYCLE() cv::threshold(src, dst, 100.0, 255.0, threshOp);
-
- CPU_SANITY_CHECK(dst);
- }
-}
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace testing;
+using namespace perf;
+
+#define ARITHM_MAT_DEPTH Values(CV_8U, CV_16U, CV_32F, CV_64F)
+
+//////////////////////////////////////////////////////////////////////
+// AddMat
+
+PERF_TEST_P(Sz_Depth, AddMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::add(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::add(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// AddScalar
+
+PERF_TEST_P(Sz_Depth, AddScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::add(d_src, s, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::add(src, s, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// SubtractMat
+
+PERF_TEST_P(Sz_Depth, SubtractMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::subtract(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// SubtractScalar
+
+PERF_TEST_P(Sz_Depth, SubtractScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::subtract(d_src, s, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::subtract(src, s, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MultiplyMat
+
+PERF_TEST_P(Sz_Depth, MultiplyMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::multiply(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MultiplyScalar
+
+PERF_TEST_P(Sz_Depth, MultiplyScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::multiply(d_src, s, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::multiply(src, s, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// DivideMat
+
+PERF_TEST_P(Sz_Depth, DivideMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::divide(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// DivideScalar
+
+PERF_TEST_P(Sz_Depth, DivideScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::divide(d_src, s, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::divide(src, s, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// DivideScalarInv
+
+PERF_TEST_P(Sz_Depth, DivideScalarInv,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::divide(s[0], d_src, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::divide(s, src, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// AbsDiffMat
+
+PERF_TEST_P(Sz_Depth, AbsDiffMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::absdiff(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// AbsDiffScalar
+
+PERF_TEST_P(Sz_Depth, AbsDiffScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::absdiff(d_src, s, dst);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::absdiff(src, s, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Abs
+
+PERF_TEST_P(Sz_Depth, Abs,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_16S, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::abs(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Sqr
+
+PERF_TEST_P(Sz_Depth, Sqr,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16S, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::sqr(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Sqrt
+
+PERF_TEST_P(Sz_Depth, Sqrt,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16S, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ cv::randu(src, 0, 100000);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::sqrt(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::sqrt(src, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Log
+
+PERF_TEST_P(Sz_Depth, Log,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16S, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ cv::randu(src, 0, 100000);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::log(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::log(src, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Exp
+
+PERF_TEST_P(Sz_Depth, Exp,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16S, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ cv::randu(src, 0, 10);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::exp(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::exp(src, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Pow
+
+DEF_PARAM_TEST(Sz_Depth_Power, cv::Size, MatDepth, double);
+
+PERF_TEST_P(Sz_Depth_Power, Pow,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16S, CV_32F),
+ Values(0.3, 2.0, 2.4)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const double power = GET_PARAM(2);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::pow(d_src, power, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::pow(src, power, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// CompareMat
+
+CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE)
+
+DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CmpCode);
+
+PERF_TEST_P(Sz_Depth_Code, CompareMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH,
+ CmpCode::all()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int cmp_code = GET_PARAM(2);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, dst, cmp_code);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::compare(src1, src2, dst, cmp_code);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// CompareScalar
+
+PERF_TEST_P(Sz_Depth_Code, CompareScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ ARITHM_MAT_DEPTH,
+ CmpCode::all()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int cmp_code = GET_PARAM(2);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::compare(d_src, s, dst, cmp_code);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::compare(src, s, dst, cmp_code);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseNot
+
+PERF_TEST_P(Sz_Depth, BitwiseNot,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_not(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_not(src, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseAndMat
+
+PERF_TEST_P(Sz_Depth, BitwiseAndMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_and(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseAndScalar
+
+PERF_TEST_P(Sz_Depth_Cn, BitwiseAndScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+ cv::Scalar_<int> is = s;
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_and(d_src, is, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_and(src, is, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseOrMat
+
+PERF_TEST_P(Sz_Depth, BitwiseOrMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_or(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseOrScalar
+
+PERF_TEST_P(Sz_Depth_Cn, BitwiseOrScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+ cv::Scalar_<int> is = s;
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_or(d_src, is, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_or(src, is, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseXorMat
+
+PERF_TEST_P(Sz_Depth, BitwiseXorMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_xor(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// BitwiseXorScalar
+
+PERF_TEST_P(Sz_Depth_Cn, BitwiseXorScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar s;
+ declare.in(s, WARMUP_RNG);
+ cv::Scalar_<int> is = s;
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::bitwise_xor(d_src, is, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::bitwise_xor(src, is, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// RShift
+
+PERF_TEST_P(Sz_Depth_Cn, RShift,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ const cv::Scalar_<int> val = cv::Scalar_<int>::all(4);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::rshift(d_src, val, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// LShift
+
+PERF_TEST_P(Sz_Depth_Cn, LShift,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ const cv::Scalar_<int> val = cv::Scalar_<int>::all(4);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::lshift(d_src, val, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MinMat
+
+PERF_TEST_P(Sz_Depth, MinMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::min(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::min(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MinScalar
+
+PERF_TEST_P(Sz_Depth, MinScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar val;
+ declare.in(val, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::min(d_src, val[0], dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::min(src, val[0], dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MaxMat
+
+PERF_TEST_P(Sz_Depth, MaxMat,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src1(size, depth);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::max(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::max(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MaxScalar
+
+PERF_TEST_P(Sz_Depth, MaxScalar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ cv::Scalar val;
+ declare.in(val, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::max(d_src, val[0], dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::max(src, val[0], dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// AddWeighted
+
+DEF_PARAM_TEST(Sz_3Depth, cv::Size, MatDepth, MatDepth, MatDepth);
+
+PERF_TEST_P(Sz_3Depth, AddWeighted,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F, CV_64F),
+ Values(CV_8U, CV_16U, CV_32F, CV_64F),
+ Values(CV_8U, CV_16U, CV_32F, CV_64F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth1 = GET_PARAM(1);
+ const int depth2 = GET_PARAM(2);
+ const int dst_depth = GET_PARAM(3);
+
+ cv::Mat src1(size, depth1);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, depth2);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, dst, dst_depth);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MagnitudeComplex
+
+PERF_TEST_P(Sz, MagnitudeComplex,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src(size, CV_32FC2);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::magnitude(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat xy[2];
+ cv::split(src, xy);
+
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::magnitude(xy[0], xy[1], dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MagnitudeSqrComplex
+
+PERF_TEST_P(Sz, MagnitudeSqrComplex,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src(size, CV_32FC2);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Magnitude
+
+PERF_TEST_P(Sz, Magnitude,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src1(size, CV_32FC1);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, CV_32FC1);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::magnitude(src1, src2, dst);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MagnitudeSqr
+
+PERF_TEST_P(Sz, MagnitudeSqr,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src1(size, CV_32FC1);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, CV_32FC1);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, dst);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Phase
+
+DEF_PARAM_TEST(Sz_AngleInDegrees, cv::Size, bool);
+
+PERF_TEST_P(Sz_AngleInDegrees, Phase,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Bool()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const bool angleInDegrees = GET_PARAM(1);
+
+ cv::Mat src1(size, CV_32FC1);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, CV_32FC1);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, dst, angleInDegrees);
+
+ GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::phase(src1, src2, dst, angleInDegrees);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// CartToPolar
+
+PERF_TEST_P(Sz_AngleInDegrees, CartToPolar,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Bool()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const bool angleInDegrees = GET_PARAM(1);
+
+ cv::Mat src1(size, CV_32FC1);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, CV_32FC1);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat magnitude;
+ cv::gpu::GpuMat angle;
+
+ TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, magnitude, angle, angleInDegrees);
+
+ GPU_SANITY_CHECK(magnitude);
+ GPU_SANITY_CHECK(angle, 1e-6, ERROR_RELATIVE);
+ }
+ else
+ {
+ cv::Mat magnitude;
+ cv::Mat angle;
+
+ TEST_CYCLE() cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
+
+ CPU_SANITY_CHECK(magnitude);
+ CPU_SANITY_CHECK(angle);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// PolarToCart
+
+PERF_TEST_P(Sz_AngleInDegrees, PolarToCart,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Bool()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const bool angleInDegrees = GET_PARAM(1);
+
+ cv::Mat magnitude(size, CV_32FC1);
+ declare.in(magnitude, WARMUP_RNG);
+
+ cv::Mat angle(size, CV_32FC1);
+ declare.in(angle, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_magnitude(magnitude);
+ const cv::gpu::GpuMat d_angle(angle);
+ cv::gpu::GpuMat x;
+ cv::gpu::GpuMat y;
+
+ TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, x, y, angleInDegrees);
+
+ GPU_SANITY_CHECK(x);
+ GPU_SANITY_CHECK(y);
+ }
+ else
+ {
+ cv::Mat x;
+ cv::Mat y;
+
+ TEST_CYCLE() cv::polarToCart(magnitude, angle, x, y, angleInDegrees);
+
+ CPU_SANITY_CHECK(x);
+ CPU_SANITY_CHECK(y);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Threshold
+
+CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
+
+DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);
+
+PERF_TEST_P(Sz_Depth_Op, Threshold,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F, CV_64F),
+ ThreshOp::all()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int threshOp = GET_PARAM(2);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::threshold(d_src, dst, 100.0, 255.0, threshOp);
+
+ GPU_SANITY_CHECK(dst, 1e-10);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::threshold(src, dst, 100.0, 255.0, threshOp);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace testing;
+using namespace perf;
+
+//////////////////////////////////////////////////////////////////////
+// Norm
+
+DEF_PARAM_TEST(Sz_Depth_Norm, cv::Size, MatDepth, NormType);
+
+PERF_TEST_P(Sz_Depth_Norm, Norm,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32S, CV_32F),
+ Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int normType = GET_PARAM(2);
+
+ cv::Mat src(size, depth);
+ if (depth == CV_8U)
+ cv::randu(src, 0, 254);
+ else
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ double gpu_dst;
+
+ TEST_CYCLE() gpu_dst = cv::gpu::norm(d_src, normType, d_buf);
+
+ SANITY_CHECK(gpu_dst, 1e-6, ERROR_RELATIVE);
+ }
+ else
+ {
+ double cpu_dst;
+
+ TEST_CYCLE() cpu_dst = cv::norm(src, normType);
+
+ SANITY_CHECK(cpu_dst, 1e-6, ERROR_RELATIVE);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// NormDiff
+
+DEF_PARAM_TEST(Sz_Norm, cv::Size, NormType);
+
+PERF_TEST_P(Sz_Norm, NormDiff,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int normType = GET_PARAM(1);
+
+ cv::Mat src1(size, CV_8UC1);
+ declare.in(src1, WARMUP_RNG);
+
+ cv::Mat src2(size, CV_8UC1);
+ declare.in(src2, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src1(src1);
+ const cv::gpu::GpuMat d_src2(src2);
+ double gpu_dst;
+
+ TEST_CYCLE() gpu_dst = cv::gpu::norm(d_src1, d_src2, normType);
+
+ SANITY_CHECK(gpu_dst);
+
+ }
+ else
+ {
+ double cpu_dst;
+
+ TEST_CYCLE() cpu_dst = cv::norm(src1, src2, normType);
+
+ SANITY_CHECK(cpu_dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Sum
+
+PERF_TEST_P(Sz_Depth_Cn, Sum,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ cv::Scalar gpu_dst;
+
+ TEST_CYCLE() gpu_dst = cv::gpu::sum(d_src, d_buf);
+
+ SANITY_CHECK(gpu_dst, 1e-5, ERROR_RELATIVE);
+ }
+ else
+ {
+ cv::Scalar cpu_dst;
+
+ TEST_CYCLE() cpu_dst = cv::sum(src);
+
+ SANITY_CHECK(cpu_dst, 1e-6, ERROR_RELATIVE);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// SumAbs
+
+PERF_TEST_P(Sz_Depth_Cn, SumAbs,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ cv::Scalar gpu_dst;
+
+ TEST_CYCLE() gpu_dst = cv::gpu::absSum(d_src, d_buf);
+
+ SANITY_CHECK(gpu_dst, 1e-6, ERROR_RELATIVE);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// SumSqr
+
+PERF_TEST_P(Sz_Depth_Cn, SumSqr,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values<MatDepth>(CV_8U, CV_16U, CV_32F),
+ GPU_CHANNELS_1_3_4))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ cv::Scalar gpu_dst;
+
+ TEST_CYCLE() gpu_dst = cv::gpu::sqrSum(d_src, d_buf);
+
+ SANITY_CHECK(gpu_dst, 1e-6, ERROR_RELATIVE);
+ }
+ else
+ {
+ FAIL_NO_CPU();
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MinMax
+
+PERF_TEST_P(Sz_Depth, MinMax,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F, CV_64F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ if (depth == CV_8U)
+ cv::randu(src, 0, 254);
+ else
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ double gpu_minVal, gpu_maxVal;
+
+ TEST_CYCLE() cv::gpu::minMax(d_src, &gpu_minVal, &gpu_maxVal, cv::gpu::GpuMat(), d_buf);
+
+ SANITY_CHECK(gpu_minVal, 1e-10);
+ SANITY_CHECK(gpu_maxVal, 1e-10);
+ }
+ else
+ {
+ double cpu_minVal, cpu_maxVal;
+
+ TEST_CYCLE() cv::minMaxLoc(src, &cpu_minVal, &cpu_maxVal);
+
+ SANITY_CHECK(cpu_minVal);
+ SANITY_CHECK(cpu_maxVal);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MinMaxLoc
+
+PERF_TEST_P(Sz_Depth, MinMaxLoc,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F, CV_64F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ if (depth == CV_8U)
+ cv::randu(src, 0, 254);
+ else
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_valbuf, d_locbuf;
+ double gpu_minVal, gpu_maxVal;
+ cv::Point gpu_minLoc, gpu_maxLoc;
+
+ TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &gpu_minVal, &gpu_maxVal, &gpu_minLoc, &gpu_maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
+
+ SANITY_CHECK(gpu_minVal, 1e-10);
+ SANITY_CHECK(gpu_maxVal, 1e-10);
+ }
+ else
+ {
+ double cpu_minVal, cpu_maxVal;
+ cv::Point cpu_minLoc, cpu_maxLoc;
+
+ TEST_CYCLE() cv::minMaxLoc(src, &cpu_minVal, &cpu_maxVal, &cpu_minLoc, &cpu_maxLoc);
+
+ SANITY_CHECK(cpu_minVal);
+ SANITY_CHECK(cpu_maxVal);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// CountNonZero
+
+PERF_TEST_P(Sz_Depth, CountNonZero,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F, CV_64F)))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+
+ cv::Mat src(size, depth);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ int gpu_dst = 0;
+
+ TEST_CYCLE() gpu_dst = cv::gpu::countNonZero(d_src, d_buf);
+
+ SANITY_CHECK(gpu_dst);
+ }
+ else
+ {
+ int cpu_dst = 0;
+
+ TEST_CYCLE() cpu_dst = cv::countNonZero(src);
+
+ SANITY_CHECK(cpu_dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Reduce
+
+CV_ENUM(ReduceCode, REDUCE_SUM, REDUCE_AVG, REDUCE_MAX, REDUCE_MIN)
+
+enum {Rows = 0, Cols = 1};
+CV_ENUM(ReduceDim, Rows, Cols)
+
+DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim);
+
+PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Reduce,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_16S, CV_32F),
+ Values(1, 2, 3, 4),
+ ReduceCode::all(),
+ ReduceDim::all()))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int depth = GET_PARAM(1);
+ const int channels = GET_PARAM(2);
+ const int reduceOp = GET_PARAM(3);
+ const int dim = GET_PARAM(4);
+
+ const int type = CV_MAKE_TYPE(depth, channels);
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+
+ TEST_CYCLE() cv::gpu::reduce(d_src, dst, dim, reduceOp);
+
+ GPU_SANITY_CHECK(dst);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::reduce(src, dst, dim, reduceOp);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// Normalize
+
+DEF_PARAM_TEST(Sz_Depth_NormType, cv::Size, MatDepth, NormType);
+
+PERF_TEST_P(Sz_Depth_NormType, Normalize,
+ Combine(GPU_TYPICAL_MAT_SIZES,
+ Values(CV_8U, CV_16U, CV_32F, CV_64F),
+ Values(NormType(cv::NORM_INF),
+ NormType(cv::NORM_L1),
+ NormType(cv::NORM_L2),
+ NormType(cv::NORM_MINMAX))))
+{
+ const cv::Size size = GET_PARAM(0);
+ const int type = GET_PARAM(1);
+ const int norm_type = GET_PARAM(2);
+
+ const double alpha = 1;
+ const double beta = 0;
+
+ cv::Mat src(size, type);
+ declare.in(src, WARMUP_RNG);
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat dst;
+ cv::gpu::GpuMat d_norm_buf, d_cvt_buf;
+
+ TEST_CYCLE() cv::gpu::normalize(d_src, dst, alpha, beta, norm_type, type, cv::gpu::GpuMat(), d_norm_buf, d_cvt_buf);
+
+ GPU_SANITY_CHECK(dst, 1e-6);
+ }
+ else
+ {
+ cv::Mat dst;
+
+ TEST_CYCLE() cv::normalize(src, dst, alpha, beta, norm_type, type);
+
+ CPU_SANITY_CHECK(dst);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////
+// MeanStdDev
+
+PERF_TEST_P(Sz, MeanStdDev,
+ GPU_TYPICAL_MAT_SIZES)
+{
+ const cv::Size size = GetParam();
+
+ cv::Mat src(size, CV_8UC1);
+ declare.in(src, WARMUP_RNG);
+
+
+ if (PERF_RUN_GPU())
+ {
+ const cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
+ cv::Scalar gpu_mean;
+ cv::Scalar gpu_stddev;
+
+ TEST_CYCLE() cv::gpu::meanStdDev(d_src, gpu_mean, gpu_stddev, d_buf);
+
+ SANITY_CHECK(gpu_mean);
+ SANITY_CHECK(gpu_stddev);
+ }
+ else
+ {
+ cv::Scalar cpu_mean;
+ cv::Scalar cpu_stddev;
+
+ TEST_CYCLE() cv::meanStdDev(src, cpu_mean, cpu_stddev);
+
+ SANITY_CHECK(cpu_mean);
+ SANITY_CHECK(cpu_stddev);
+ }
+}
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
void cv::gpu::gemm(const GpuMat&, const GpuMat&, double, const GpuMat&, double, GpuMat&, int, Stream&) { throw_no_cuda(); }
-void cv::gpu::transpose(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::flip(const GpuMat&, GpuMat&, int, Stream&) { throw_no_cuda(); }
-void cv::gpu::LUT(const GpuMat&, const Mat&, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::magnitude(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::magnitudeSqr(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::magnitude(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::magnitudeSqr(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::phase(const GpuMat&, const GpuMat&, GpuMat&, bool, Stream&) { throw_no_cuda(); }
-void cv::gpu::cartToPolar(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool, Stream&) { throw_no_cuda(); }
-void cv::gpu::polarToCart(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool, Stream&) { throw_no_cuda(); }
-void cv::gpu::normalize(const GpuMat&, GpuMat&, double, double, int, int, const GpuMat&) { throw_no_cuda(); }
-void cv::gpu::normalize(const GpuMat&, GpuMat&, double, double, int, int, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
-void cv::gpu::copyMakeBorder(const GpuMat&, GpuMat&, int, int, int, int, int, const Scalar&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::integral(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::integralBuffered(const GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::sqrIntegral(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::mulSpectrums(const GpuMat&, const GpuMat&, GpuMat&, int, bool, Stream&) { throw_no_cuda(); }
void cv::gpu::mulAndScaleSpectrums(const GpuMat&, const GpuMat&, GpuMat&, int, float, bool, Stream&) { throw_no_cuda(); }
+
void cv::gpu::dft(const GpuMat&, GpuMat&, Size, int, Stream&) { throw_no_cuda(); }
+
void cv::gpu::ConvolveBuf::create(Size, Size) { throw_no_cuda(); }
void cv::gpu::convolve(const GpuMat&, const GpuMat&, GpuMat&, bool) { throw_no_cuda(); }
void cv::gpu::convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&, Stream&) { throw_no_cuda(); }
}
////////////////////////////////////////////////////////////////////////
-// transpose
-
-namespace arithm
-{
- template <typename T> void transpose(PtrStepSz<T> src, PtrStepSz<T> dst, cudaStream_t stream);
-}
-
-void cv::gpu::transpose(const GpuMat& src, GpuMat& dst, Stream& s)
-{
- CV_Assert( src.elemSize() == 1 || src.elemSize() == 4 || src.elemSize() == 8 );
-
- dst.create( src.cols, src.rows, src.type() );
-
- cudaStream_t stream = StreamAccessor::getStream(s);
-
- if (src.elemSize() == 1)
- {
- NppStreamHandler h(stream);
-
- NppiSize sz;
- sz.width = src.cols;
- sz.height = src.rows;
-
- nppSafeCall( nppiTranspose_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
- dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );
-
- if (stream == 0)
- cudaSafeCall( cudaDeviceSynchronize() );
- }
- else if (src.elemSize() == 4)
- {
- arithm::transpose<int>(src, dst, stream);
- }
- else // if (src.elemSize() == 8)
- {
- if (!deviceSupports(NATIVE_DOUBLE))
- CV_Error(cv::Error::StsUnsupportedFormat, "The device doesn't support double");
-
- arithm::transpose<double>(src, dst, stream);
- }
-}
-
-////////////////////////////////////////////////////////////////////////
-// flip
-
-namespace
-{
- template<int DEPTH> struct NppTypeTraits;
- template<> struct NppTypeTraits<CV_8U> { typedef Npp8u npp_t; };
- template<> struct NppTypeTraits<CV_8S> { typedef Npp8s npp_t; };
- template<> struct NppTypeTraits<CV_16U> { typedef Npp16u npp_t; };
- template<> struct NppTypeTraits<CV_16S> { typedef Npp16s npp_t; };
- template<> struct NppTypeTraits<CV_32S> { typedef Npp32s npp_t; };
- template<> struct NppTypeTraits<CV_32F> { typedef Npp32f npp_t; };
- template<> struct NppTypeTraits<CV_64F> { typedef Npp64f npp_t; };
-
- template <int DEPTH> struct NppMirrorFunc
- {
- typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
-
- typedef NppStatus (*func_t)(const npp_t* pSrc, int nSrcStep, npp_t* pDst, int nDstStep, NppiSize oROI, NppiAxis flip);
- };
-
- template <int DEPTH, typename NppMirrorFunc<DEPTH>::func_t func> struct NppMirror
- {
- typedef typename NppMirrorFunc<DEPTH>::npp_t npp_t;
-
- static void call(const GpuMat& src, GpuMat& dst, int flipCode, cudaStream_t stream)
- {
- NppStreamHandler h(stream);
-
- NppiSize sz;
- sz.width = src.cols;
- sz.height = src.rows;
-
- nppSafeCall( func(src.ptr<npp_t>(), static_cast<int>(src.step),
- dst.ptr<npp_t>(), static_cast<int>(dst.step), sz,
- (flipCode == 0 ? NPP_HORIZONTAL_AXIS : (flipCode > 0 ? NPP_VERTICAL_AXIS : NPP_BOTH_AXIS))) );
-
- if (stream == 0)
- cudaSafeCall( cudaDeviceSynchronize() );
- }
- };
-}
-
-void cv::gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode, Stream& stream)
-{
- typedef void (*func_t)(const GpuMat& src, GpuMat& dst, int flipCode, cudaStream_t stream);
- static const func_t funcs[6][4] =
- {
- {NppMirror<CV_8U, nppiMirror_8u_C1R>::call, 0, NppMirror<CV_8U, nppiMirror_8u_C3R>::call, NppMirror<CV_8U, nppiMirror_8u_C4R>::call},
- {0,0,0,0},
- {NppMirror<CV_16U, nppiMirror_16u_C1R>::call, 0, NppMirror<CV_16U, nppiMirror_16u_C3R>::call, NppMirror<CV_16U, nppiMirror_16u_C4R>::call},
- {0,0,0,0},
- {NppMirror<CV_32S, nppiMirror_32s_C1R>::call, 0, NppMirror<CV_32S, nppiMirror_32s_C3R>::call, NppMirror<CV_32S, nppiMirror_32s_C4R>::call},
- {NppMirror<CV_32F, nppiMirror_32f_C1R>::call, 0, NppMirror<CV_32F, nppiMirror_32f_C3R>::call, NppMirror<CV_32F, nppiMirror_32f_C4R>::call}
- };
-
- CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32S || src.depth() == CV_32F);
- CV_Assert(src.channels() == 1 || src.channels() == 3 || src.channels() == 4);
-
- dst.create(src.size(), src.type());
-
- funcs[src.depth()][src.channels() - 1](src, dst, flipCode, StreamAccessor::getStream(stream));
-}
-
-////////////////////////////////////////////////////////////////////////
-// LUT
-
-void cv::gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& s)
-{
- const int cn = src.channels();
-
- CV_Assert( src.type() == CV_8UC1 || src.type() == CV_8UC3 );
- CV_Assert( lut.depth() == CV_8U );
- CV_Assert( lut.channels() == 1 || lut.channels() == cn );
- CV_Assert( lut.rows * lut.cols == 256 && lut.isContinuous() );
-
- dst.create(src.size(), CV_MAKE_TYPE(lut.depth(), cn));
-
- NppiSize sz;
- sz.height = src.rows;
- sz.width = src.cols;
-
- Mat nppLut;
- lut.convertTo(nppLut, CV_32S);
-
- int nValues3[] = {256, 256, 256};
-
- Npp32s pLevels[256];
- for (int i = 0; i < 256; ++i)
- pLevels[i] = i;
-
- const Npp32s* pLevels3[3];
-
-#if (CUDA_VERSION <= 4020)
- pLevels3[0] = pLevels3[1] = pLevels3[2] = pLevels;
-#else
- GpuMat d_pLevels;
- d_pLevels.upload(Mat(1, 256, CV_32S, pLevels));
- pLevels3[0] = pLevels3[1] = pLevels3[2] = d_pLevels.ptr<Npp32s>();
-#endif
-
- cudaStream_t stream = StreamAccessor::getStream(s);
- NppStreamHandler h(stream);
-
- if (src.type() == CV_8UC1)
- {
-#if (CUDA_VERSION <= 4020)
- nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
- dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, nppLut.ptr<Npp32s>(), pLevels, 256) );
-#else
- GpuMat d_nppLut(Mat(1, 256, CV_32S, nppLut.data));
- nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
- dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, d_nppLut.ptr<Npp32s>(), d_pLevels.ptr<Npp32s>(), 256) );
-#endif
- }
- else
- {
- const Npp32s* pValues3[3];
-
- Mat nppLut3[3];
- if (nppLut.channels() == 1)
- {
-#if (CUDA_VERSION <= 4020)
- pValues3[0] = pValues3[1] = pValues3[2] = nppLut.ptr<Npp32s>();
-#else
- GpuMat d_nppLut(Mat(1, 256, CV_32S, nppLut.data));
- pValues3[0] = pValues3[1] = pValues3[2] = d_nppLut.ptr<Npp32s>();
-#endif
- }
- else
- {
- cv::split(nppLut, nppLut3);
-
-#if (CUDA_VERSION <= 4020)
- pValues3[0] = nppLut3[0].ptr<Npp32s>();
- pValues3[1] = nppLut3[1].ptr<Npp32s>();
- pValues3[2] = nppLut3[2].ptr<Npp32s>();
-#else
- GpuMat d_nppLut0(Mat(1, 256, CV_32S, nppLut3[0].data));
- GpuMat d_nppLut1(Mat(1, 256, CV_32S, nppLut3[1].data));
- GpuMat d_nppLut2(Mat(1, 256, CV_32S, nppLut3[2].data));
-
- pValues3[0] = d_nppLut0.ptr<Npp32s>();
- pValues3[1] = d_nppLut1.ptr<Npp32s>();
- pValues3[2] = d_nppLut2.ptr<Npp32s>();
-#endif
- }
-
- nppSafeCall( nppiLUT_Linear_8u_C3R(src.ptr<Npp8u>(), static_cast<int>(src.step),
- dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, pValues3, pLevels3, nValues3) );
- }
-
- if (stream == 0)
- cudaSafeCall( cudaDeviceSynchronize() );
-}
-
-////////////////////////////////////////////////////////////////////////
-// NPP magnitide
-
-namespace
-{
- typedef NppStatus (*nppMagnitude_t)(const Npp32fc* pSrc, int nSrcStep, Npp32f* pDst, int nDstStep, NppiSize oSizeROI);
-
- inline void npp_magnitude(const GpuMat& src, GpuMat& dst, nppMagnitude_t func, cudaStream_t stream)
- {
- CV_Assert(src.type() == CV_32FC2);
-
- dst.create(src.size(), CV_32FC1);
-
- NppiSize sz;
- sz.width = src.cols;
- sz.height = src.rows;
-
- NppStreamHandler h(stream);
-
- nppSafeCall( func(src.ptr<Npp32fc>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
-
- if (stream == 0)
- cudaSafeCall( cudaDeviceSynchronize() );
- }
-}
-
-void cv::gpu::magnitude(const GpuMat& src, GpuMat& dst, Stream& stream)
-{
- npp_magnitude(src, dst, nppiMagnitude_32fc32f_C1R, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::magnitudeSqr(const GpuMat& src, GpuMat& dst, Stream& stream)
-{
- npp_magnitude(src, dst, nppiMagnitudeSqr_32fc32f_C1R, StreamAccessor::getStream(stream));
-}
-
-////////////////////////////////////////////////////////////////////////
-// Polar <-> Cart
-
-namespace cv { namespace gpu { namespace cudev
-{
- namespace mathfunc
- {
- void cartToPolar_gpu(PtrStepSzf x, PtrStepSzf y, PtrStepSzf mag, bool magSqr, PtrStepSzf angle, bool angleInDegrees, cudaStream_t stream);
- void polarToCart_gpu(PtrStepSzf mag, PtrStepSzf angle, PtrStepSzf x, PtrStepSzf y, bool angleInDegrees, cudaStream_t stream);
- }
-}}}
-
-namespace
-{
- inline void cartToPolar_caller(const GpuMat& x, const GpuMat& y, GpuMat* mag, bool magSqr, GpuMat* angle, bool angleInDegrees, cudaStream_t stream)
- {
- using namespace ::cv::gpu::cudev::mathfunc;
-
- CV_Assert(x.size() == y.size() && x.type() == y.type());
- CV_Assert(x.depth() == CV_32F);
-
- if (mag)
- mag->create(x.size(), x.type());
- if (angle)
- angle->create(x.size(), x.type());
-
- GpuMat x1cn = x.reshape(1);
- GpuMat y1cn = y.reshape(1);
- GpuMat mag1cn = mag ? mag->reshape(1) : GpuMat();
- GpuMat angle1cn = angle ? angle->reshape(1) : GpuMat();
-
- cartToPolar_gpu(x1cn, y1cn, mag1cn, magSqr, angle1cn, angleInDegrees, stream);
- }
-
- inline void polarToCart_caller(const GpuMat& mag, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, cudaStream_t stream)
- {
- using namespace ::cv::gpu::cudev::mathfunc;
-
- CV_Assert((mag.empty() || mag.size() == angle.size()) && mag.type() == angle.type());
- CV_Assert(mag.depth() == CV_32F);
-
- x.create(mag.size(), mag.type());
- y.create(mag.size(), mag.type());
-
- GpuMat mag1cn = mag.reshape(1);
- GpuMat angle1cn = angle.reshape(1);
- GpuMat x1cn = x.reshape(1);
- GpuMat y1cn = y.reshape(1);
-
- polarToCart_gpu(mag1cn, angle1cn, x1cn, y1cn, angleInDegrees, stream);
- }
-}
-
-void cv::gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& dst, Stream& stream)
-{
- cartToPolar_caller(x, y, &dst, false, 0, false, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& dst, Stream& stream)
-{
- cartToPolar_caller(x, y, &dst, true, 0, false, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, Stream& stream)
-{
- cartToPolar_caller(x, y, 0, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& mag, GpuMat& angle, bool angleInDegrees, Stream& stream)
-{
- cartToPolar_caller(x, y, &mag, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, Stream& stream)
-{
- polarToCart_caller(magnitude, angle, x, y, angleInDegrees, StreamAccessor::getStream(stream));
-}
-
-////////////////////////////////////////////////////////////////////////
-// normalize
-
-void cv::gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask)
-{
- GpuMat norm_buf;
- GpuMat cvt_buf;
- normalize(src, dst, a, b, norm_type, dtype, mask, norm_buf, cvt_buf);
-}
-
-void cv::gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf)
-{
- double scale = 1, shift = 0;
- if (norm_type == NORM_MINMAX)
- {
- double smin = 0, smax = 0;
- double dmin = std::min(a, b), dmax = std::max(a, b);
- gpu::minMax(src, &smin, &smax, mask, norm_buf);
- scale = (dmax - dmin) * (smax - smin > std::numeric_limits<double>::epsilon() ? 1.0 / (smax - smin) : 0.0);
- shift = dmin - smin * scale;
- }
- else if (norm_type == NORM_L2 || norm_type == NORM_L1 || norm_type == NORM_INF)
- {
- scale = gpu::norm(src, norm_type, mask, norm_buf);
- scale = scale > std::numeric_limits<double>::epsilon() ? a / scale : 0.0;
- shift = 0;
- }
- else
- {
- CV_Error(cv::Error::StsBadArg, "Unknown/unsupported norm type");
- }
-
- if (mask.empty())
- {
- src.convertTo(dst, dtype, scale, shift);
- }
- else
- {
- src.convertTo(cvt_buf, dtype, scale, shift);
- cvt_buf.copyTo(dst, mask);
- }
-}
-
-////////////////////////////////////////////////////////////////////////
-// copyMakeBorder
-
-namespace cv { namespace gpu { namespace cudev
-{
- namespace imgproc
- {
- template <typename T, int cn> void copyMakeBorder_gpu(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderMode, const T* borderValue, cudaStream_t stream);
- }
-}}}
-
-namespace
-{
- template <typename T, int cn> void copyMakeBorder_caller(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderType, const Scalar& value, cudaStream_t stream)
- {
- using namespace ::cv::gpu::cudev::imgproc;
-
- Scalar_<T> val(saturate_cast<T>(value[0]), saturate_cast<T>(value[1]), saturate_cast<T>(value[2]), saturate_cast<T>(value[3]));
-
- copyMakeBorder_gpu<T, cn>(src, dst, top, left, borderType, val.val, stream);
- }
-}
-
-#if defined __GNUC__ && __GNUC__ > 2 && __GNUC_MINOR__ > 4
-typedef Npp32s __attribute__((__may_alias__)) Npp32s_a;
-#else
-typedef Npp32s Npp32s_a;
-#endif
-
-void cv::gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType, const Scalar& value, Stream& s)
-{
- CV_Assert(src.depth() <= CV_32F && src.channels() <= 4);
- CV_Assert(borderType == BORDER_REFLECT_101 || borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT || borderType == BORDER_REFLECT || borderType == BORDER_WRAP);
-
- dst.create(src.rows + top + bottom, src.cols + left + right, src.type());
-
- cudaStream_t stream = StreamAccessor::getStream(s);
-
- if (borderType == BORDER_CONSTANT && (src.type() == CV_8UC1 || src.type() == CV_8UC4 || src.type() == CV_32SC1 || src.type() == CV_32FC1))
- {
- NppiSize srcsz;
- srcsz.width = src.cols;
- srcsz.height = src.rows;
-
- NppiSize dstsz;
- dstsz.width = dst.cols;
- dstsz.height = dst.rows;
-
- NppStreamHandler h(stream);
-
- switch (src.type())
- {
- case CV_8UC1:
- {
- Npp8u nVal = saturate_cast<Npp8u>(value[0]);
- nppSafeCall( nppiCopyConstBorder_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), srcsz,
- dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
- break;
- }
- case CV_8UC4:
- {
- Npp8u nVal[] = {saturate_cast<Npp8u>(value[0]), saturate_cast<Npp8u>(value[1]), saturate_cast<Npp8u>(value[2]), saturate_cast<Npp8u>(value[3])};
- nppSafeCall( nppiCopyConstBorder_8u_C4R(src.ptr<Npp8u>(), static_cast<int>(src.step), srcsz,
- dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
- break;
- }
- case CV_32SC1:
- {
- Npp32s nVal = saturate_cast<Npp32s>(value[0]);
- nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), srcsz,
- dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
- break;
- }
- case CV_32FC1:
- {
- Npp32f val = saturate_cast<Npp32f>(value[0]);
- Npp32s nVal = *(reinterpret_cast<Npp32s_a*>(&val));
- nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), srcsz,
- dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
- break;
- }
- }
-
- if (stream == 0)
- cudaSafeCall( cudaDeviceSynchronize() );
- }
- else
- {
- typedef void (*caller_t)(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderType, const Scalar& value, cudaStream_t stream);
- static const caller_t callers[6][4] =
- {
- { copyMakeBorder_caller<uchar, 1> , copyMakeBorder_caller<uchar, 2> , copyMakeBorder_caller<uchar, 3> , copyMakeBorder_caller<uchar, 4>},
- {0/*copyMakeBorder_caller<schar, 1>*/, 0/*copyMakeBorder_caller<schar, 2>*/ , 0/*copyMakeBorder_caller<schar, 3>*/, 0/*copyMakeBorder_caller<schar, 4>*/},
- { copyMakeBorder_caller<ushort, 1> , 0/*copyMakeBorder_caller<ushort, 2>*/, copyMakeBorder_caller<ushort, 3> , copyMakeBorder_caller<ushort, 4>},
- { copyMakeBorder_caller<short, 1> , 0/*copyMakeBorder_caller<short, 2>*/ , copyMakeBorder_caller<short, 3> , copyMakeBorder_caller<short, 4>},
- {0/*copyMakeBorder_caller<int, 1>*/, 0/*copyMakeBorder_caller<int, 2>*/ , 0/*copyMakeBorder_caller<int, 3>*/, 0/*copyMakeBorder_caller<int , 4>*/},
- { copyMakeBorder_caller<float, 1> , 0/*copyMakeBorder_caller<float, 2>*/ , copyMakeBorder_caller<float, 3> , copyMakeBorder_caller<float ,4>}
- };
-
- caller_t func = callers[src.depth()][src.channels() - 1];
- CV_Assert(func != 0);
-
- func(src, dst, top, left, borderType, value, stream);
- }
-}
-
-////////////////////////////////////////////////////////////////////////
// integral
void cv::gpu::integral(const GpuMat& src, GpuMat& sum, Stream& s)
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace cv::gpu;
+
+#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
+
+void cv::gpu::merge(const GpuMat* /*src*/, size_t /*count*/, GpuMat& /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
+void cv::gpu::merge(const std::vector<GpuMat>& /*src*/, GpuMat& /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
+
+void cv::gpu::split(const GpuMat& /*src*/, GpuMat* /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
+void cv::gpu::split(const GpuMat& /*src*/, std::vector<GpuMat>& /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
+
+void cv::gpu::transpose(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::flip(const GpuMat&, GpuMat&, int, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::LUT(const GpuMat&, const Mat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::copyMakeBorder(const GpuMat&, GpuMat&, int, int, int, int, int, const Scalar&, Stream&) { throw_no_cuda(); }
+
+#else /* !defined (HAVE_CUDA) */
+
+////////////////////////////////////////////////////////////////////////
+// merge/split
+
+namespace cv { namespace gpu { namespace cudev
+{
+ namespace split_merge
+ {
+ void merge_caller(const PtrStepSzb* src, PtrStepSzb& dst, int total_channels, size_t elem_size, const cudaStream_t& stream);
+ void split_caller(const PtrStepSzb& src, PtrStepSzb* dst, int num_channels, size_t elem_size1, const cudaStream_t& stream);
+ }
+}}}
+
+namespace
+{
+ void merge(const GpuMat* src, size_t n, GpuMat& dst, const cudaStream_t& stream)
+ {
+ using namespace ::cv::gpu::cudev::split_merge;
+
+ CV_Assert(src);
+ CV_Assert(n > 0);
+
+ int depth = src[0].depth();
+ Size size = src[0].size();
+
+ if (depth == CV_64F)
+ {
+ if (!deviceSupports(NATIVE_DOUBLE))
+ CV_Error(cv::Error::StsUnsupportedFormat, "The device doesn't support double");
+ }
+
+ bool single_channel_only = true;
+ int total_channels = 0;
+
+ for (size_t i = 0; i < n; ++i)
+ {
+ CV_Assert(src[i].size() == size);
+ CV_Assert(src[i].depth() == depth);
+ single_channel_only = single_channel_only && src[i].channels() == 1;
+ total_channels += src[i].channels();
+ }
+
+ CV_Assert(single_channel_only);
+ CV_Assert(total_channels <= 4);
+
+ if (total_channels == 1)
+ src[0].copyTo(dst);
+ else
+ {
+ dst.create(size, CV_MAKETYPE(depth, total_channels));
+
+ PtrStepSzb src_as_devmem[4];
+ for(size_t i = 0; i < n; ++i)
+ src_as_devmem[i] = src[i];
+
+ PtrStepSzb dst_as_devmem(dst);
+ merge_caller(src_as_devmem, dst_as_devmem, total_channels, CV_ELEM_SIZE(depth), stream);
+ }
+ }
+
+ void split(const GpuMat& src, GpuMat* dst, const cudaStream_t& stream)
+ {
+ using namespace ::cv::gpu::cudev::split_merge;
+
+ CV_Assert(dst);
+
+ int depth = src.depth();
+ int num_channels = src.channels();
+
+ if (depth == CV_64F)
+ {
+ if (!deviceSupports(NATIVE_DOUBLE))
+ CV_Error(cv::Error::StsUnsupportedFormat, "The device doesn't support double");
+ }
+
+ if (num_channels == 1)
+ {
+ src.copyTo(dst[0]);
+ return;
+ }
+
+ for (int i = 0; i < num_channels; ++i)
+ dst[i].create(src.size(), depth);
+
+ CV_Assert(num_channels <= 4);
+
+ PtrStepSzb dst_as_devmem[4];
+ for (int i = 0; i < num_channels; ++i)
+ dst_as_devmem[i] = dst[i];
+
+ PtrStepSzb src_as_devmem(src);
+ split_caller(src_as_devmem, dst_as_devmem, num_channels, src.elemSize1(), stream);
+ }
+}
+
+void cv::gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream)
+{
+ ::merge(src, n, dst, StreamAccessor::getStream(stream));
+}
+
+
+void cv::gpu::merge(const std::vector<GpuMat>& src, GpuMat& dst, Stream& stream)
+{
+ ::merge(&src[0], src.size(), dst, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::split(const GpuMat& src, GpuMat* dst, Stream& stream)
+{
+ ::split(src, dst, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::split(const GpuMat& src, std::vector<GpuMat>& dst, Stream& stream)
+{
+ dst.resize(src.channels());
+ if(src.channels() > 0)
+ ::split(src, &dst[0], StreamAccessor::getStream(stream));
+}
+
+////////////////////////////////////////////////////////////////////////
+// transpose
+
+namespace arithm
+{
+ template <typename T> void transpose(PtrStepSz<T> src, PtrStepSz<T> dst, cudaStream_t stream);
+}
+
+void cv::gpu::transpose(const GpuMat& src, GpuMat& dst, Stream& s)
+{
+ CV_Assert( src.elemSize() == 1 || src.elemSize() == 4 || src.elemSize() == 8 );
+
+ dst.create( src.cols, src.rows, src.type() );
+
+ cudaStream_t stream = StreamAccessor::getStream(s);
+
+ if (src.elemSize() == 1)
+ {
+ NppStreamHandler h(stream);
+
+ NppiSize sz;
+ sz.width = src.cols;
+ sz.height = src.rows;
+
+ nppSafeCall( nppiTranspose_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
+ dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );
+
+ if (stream == 0)
+ cudaSafeCall( cudaDeviceSynchronize() );
+ }
+ else if (src.elemSize() == 4)
+ {
+ arithm::transpose<int>(src, dst, stream);
+ }
+ else // if (src.elemSize() == 8)
+ {
+ if (!deviceSupports(NATIVE_DOUBLE))
+ CV_Error(cv::Error::StsUnsupportedFormat, "The device doesn't support double");
+
+ arithm::transpose<double>(src, dst, stream);
+ }
+}
+
+////////////////////////////////////////////////////////////////////////
+// flip
+
+namespace
+{
+ template<int DEPTH> struct NppTypeTraits;
+ template<> struct NppTypeTraits<CV_8U> { typedef Npp8u npp_t; };
+ template<> struct NppTypeTraits<CV_8S> { typedef Npp8s npp_t; };
+ template<> struct NppTypeTraits<CV_16U> { typedef Npp16u npp_t; };
+ template<> struct NppTypeTraits<CV_16S> { typedef Npp16s npp_t; };
+ template<> struct NppTypeTraits<CV_32S> { typedef Npp32s npp_t; };
+ template<> struct NppTypeTraits<CV_32F> { typedef Npp32f npp_t; };
+ template<> struct NppTypeTraits<CV_64F> { typedef Npp64f npp_t; };
+
+ template <int DEPTH> struct NppMirrorFunc
+ {
+ typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
+
+ typedef NppStatus (*func_t)(const npp_t* pSrc, int nSrcStep, npp_t* pDst, int nDstStep, NppiSize oROI, NppiAxis flip);
+ };
+
+ template <int DEPTH, typename NppMirrorFunc<DEPTH>::func_t func> struct NppMirror
+ {
+ typedef typename NppMirrorFunc<DEPTH>::npp_t npp_t;
+
+ static void call(const GpuMat& src, GpuMat& dst, int flipCode, cudaStream_t stream)
+ {
+ NppStreamHandler h(stream);
+
+ NppiSize sz;
+ sz.width = src.cols;
+ sz.height = src.rows;
+
+ nppSafeCall( func(src.ptr<npp_t>(), static_cast<int>(src.step),
+ dst.ptr<npp_t>(), static_cast<int>(dst.step), sz,
+ (flipCode == 0 ? NPP_HORIZONTAL_AXIS : (flipCode > 0 ? NPP_VERTICAL_AXIS : NPP_BOTH_AXIS))) );
+
+ if (stream == 0)
+ cudaSafeCall( cudaDeviceSynchronize() );
+ }
+ };
+}
+
+void cv::gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode, Stream& stream)
+{
+ typedef void (*func_t)(const GpuMat& src, GpuMat& dst, int flipCode, cudaStream_t stream);
+ static const func_t funcs[6][4] =
+ {
+ {NppMirror<CV_8U, nppiMirror_8u_C1R>::call, 0, NppMirror<CV_8U, nppiMirror_8u_C3R>::call, NppMirror<CV_8U, nppiMirror_8u_C4R>::call},
+ {0,0,0,0},
+ {NppMirror<CV_16U, nppiMirror_16u_C1R>::call, 0, NppMirror<CV_16U, nppiMirror_16u_C3R>::call, NppMirror<CV_16U, nppiMirror_16u_C4R>::call},
+ {0,0,0,0},
+ {NppMirror<CV_32S, nppiMirror_32s_C1R>::call, 0, NppMirror<CV_32S, nppiMirror_32s_C3R>::call, NppMirror<CV_32S, nppiMirror_32s_C4R>::call},
+ {NppMirror<CV_32F, nppiMirror_32f_C1R>::call, 0, NppMirror<CV_32F, nppiMirror_32f_C3R>::call, NppMirror<CV_32F, nppiMirror_32f_C4R>::call}
+ };
+
+ CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32S || src.depth() == CV_32F);
+ CV_Assert(src.channels() == 1 || src.channels() == 3 || src.channels() == 4);
+
+ dst.create(src.size(), src.type());
+
+ funcs[src.depth()][src.channels() - 1](src, dst, flipCode, StreamAccessor::getStream(stream));
+}
+
+////////////////////////////////////////////////////////////////////////
+// LUT
+
+void cv::gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& s)
+{
+ const int cn = src.channels();
+
+ CV_Assert( src.type() == CV_8UC1 || src.type() == CV_8UC3 );
+ CV_Assert( lut.depth() == CV_8U );
+ CV_Assert( lut.channels() == 1 || lut.channels() == cn );
+ CV_Assert( lut.rows * lut.cols == 256 && lut.isContinuous() );
+
+ dst.create(src.size(), CV_MAKE_TYPE(lut.depth(), cn));
+
+ NppiSize sz;
+ sz.height = src.rows;
+ sz.width = src.cols;
+
+ Mat nppLut;
+ lut.convertTo(nppLut, CV_32S);
+
+ int nValues3[] = {256, 256, 256};
+
+ Npp32s pLevels[256];
+ for (int i = 0; i < 256; ++i)
+ pLevels[i] = i;
+
+ const Npp32s* pLevels3[3];
+
+#if (CUDA_VERSION <= 4020)
+ pLevels3[0] = pLevels3[1] = pLevels3[2] = pLevels;
+#else
+ GpuMat d_pLevels;
+ d_pLevels.upload(Mat(1, 256, CV_32S, pLevels));
+ pLevels3[0] = pLevels3[1] = pLevels3[2] = d_pLevels.ptr<Npp32s>();
+#endif
+
+ cudaStream_t stream = StreamAccessor::getStream(s);
+ NppStreamHandler h(stream);
+
+ if (src.type() == CV_8UC1)
+ {
+#if (CUDA_VERSION <= 4020)
+ nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
+ dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, nppLut.ptr<Npp32s>(), pLevels, 256) );
+#else
+ GpuMat d_nppLut(Mat(1, 256, CV_32S, nppLut.data));
+ nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
+ dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, d_nppLut.ptr<Npp32s>(), d_pLevels.ptr<Npp32s>(), 256) );
+#endif
+ }
+ else
+ {
+ const Npp32s* pValues3[3];
+
+ Mat nppLut3[3];
+ if (nppLut.channels() == 1)
+ {
+#if (CUDA_VERSION <= 4020)
+ pValues3[0] = pValues3[1] = pValues3[2] = nppLut.ptr<Npp32s>();
+#else
+ GpuMat d_nppLut(Mat(1, 256, CV_32S, nppLut.data));
+ pValues3[0] = pValues3[1] = pValues3[2] = d_nppLut.ptr<Npp32s>();
+#endif
+ }
+ else
+ {
+ cv::split(nppLut, nppLut3);
+
+#if (CUDA_VERSION <= 4020)
+ pValues3[0] = nppLut3[0].ptr<Npp32s>();
+ pValues3[1] = nppLut3[1].ptr<Npp32s>();
+ pValues3[2] = nppLut3[2].ptr<Npp32s>();
+#else
+ GpuMat d_nppLut0(Mat(1, 256, CV_32S, nppLut3[0].data));
+ GpuMat d_nppLut1(Mat(1, 256, CV_32S, nppLut3[1].data));
+ GpuMat d_nppLut2(Mat(1, 256, CV_32S, nppLut3[2].data));
+
+ pValues3[0] = d_nppLut0.ptr<Npp32s>();
+ pValues3[1] = d_nppLut1.ptr<Npp32s>();
+ pValues3[2] = d_nppLut2.ptr<Npp32s>();
+#endif
+ }
+
+ nppSafeCall( nppiLUT_Linear_8u_C3R(src.ptr<Npp8u>(), static_cast<int>(src.step),
+ dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, pValues3, pLevels3, nValues3) );
+ }
+
+ if (stream == 0)
+ cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+////////////////////////////////////////////////////////////////////////
+// copyMakeBorder
+
+namespace cv { namespace gpu { namespace cudev
+{
+ namespace imgproc
+ {
+ template <typename T, int cn> void copyMakeBorder_gpu(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderMode, const T* borderValue, cudaStream_t stream);
+ }
+}}}
+
+namespace
+{
+ template <typename T, int cn> void copyMakeBorder_caller(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderType, const Scalar& value, cudaStream_t stream)
+ {
+ using namespace ::cv::gpu::cudev::imgproc;
+
+ Scalar_<T> val(saturate_cast<T>(value[0]), saturate_cast<T>(value[1]), saturate_cast<T>(value[2]), saturate_cast<T>(value[3]));
+
+ copyMakeBorder_gpu<T, cn>(src, dst, top, left, borderType, val.val, stream);
+ }
+}
+
+#if defined __GNUC__ && __GNUC__ > 2 && __GNUC_MINOR__ > 4
+typedef Npp32s __attribute__((__may_alias__)) Npp32s_a;
+#else
+typedef Npp32s Npp32s_a;
+#endif
+
+void cv::gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType, const Scalar& value, Stream& s)
+{
+ CV_Assert(src.depth() <= CV_32F && src.channels() <= 4);
+ CV_Assert(borderType == BORDER_REFLECT_101 || borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT || borderType == BORDER_REFLECT || borderType == BORDER_WRAP);
+
+ dst.create(src.rows + top + bottom, src.cols + left + right, src.type());
+
+ cudaStream_t stream = StreamAccessor::getStream(s);
+
+ if (borderType == BORDER_CONSTANT && (src.type() == CV_8UC1 || src.type() == CV_8UC4 || src.type() == CV_32SC1 || src.type() == CV_32FC1))
+ {
+ NppiSize srcsz;
+ srcsz.width = src.cols;
+ srcsz.height = src.rows;
+
+ NppiSize dstsz;
+ dstsz.width = dst.cols;
+ dstsz.height = dst.rows;
+
+ NppStreamHandler h(stream);
+
+ switch (src.type())
+ {
+ case CV_8UC1:
+ {
+ Npp8u nVal = saturate_cast<Npp8u>(value[0]);
+ nppSafeCall( nppiCopyConstBorder_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), srcsz,
+ dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
+ break;
+ }
+ case CV_8UC4:
+ {
+ Npp8u nVal[] = {saturate_cast<Npp8u>(value[0]), saturate_cast<Npp8u>(value[1]), saturate_cast<Npp8u>(value[2]), saturate_cast<Npp8u>(value[3])};
+ nppSafeCall( nppiCopyConstBorder_8u_C4R(src.ptr<Npp8u>(), static_cast<int>(src.step), srcsz,
+ dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
+ break;
+ }
+ case CV_32SC1:
+ {
+ Npp32s nVal = saturate_cast<Npp32s>(value[0]);
+ nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), srcsz,
+ dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
+ break;
+ }
+ case CV_32FC1:
+ {
+ Npp32f val = saturate_cast<Npp32f>(value[0]);
+ Npp32s nVal = *(reinterpret_cast<Npp32s_a*>(&val));
+ nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), srcsz,
+ dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
+ break;
+ }
+ }
+
+ if (stream == 0)
+ cudaSafeCall( cudaDeviceSynchronize() );
+ }
+ else
+ {
+ typedef void (*caller_t)(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderType, const Scalar& value, cudaStream_t stream);
+ static const caller_t callers[6][4] =
+ {
+ { copyMakeBorder_caller<uchar, 1> , copyMakeBorder_caller<uchar, 2> , copyMakeBorder_caller<uchar, 3> , copyMakeBorder_caller<uchar, 4>},
+ {0/*copyMakeBorder_caller<schar, 1>*/, 0/*copyMakeBorder_caller<schar, 2>*/ , 0/*copyMakeBorder_caller<schar, 3>*/, 0/*copyMakeBorder_caller<schar, 4>*/},
+ { copyMakeBorder_caller<ushort, 1> , 0/*copyMakeBorder_caller<ushort, 2>*/, copyMakeBorder_caller<ushort, 3> , copyMakeBorder_caller<ushort, 4>},
+ { copyMakeBorder_caller<short, 1> , 0/*copyMakeBorder_caller<short, 2>*/ , copyMakeBorder_caller<short, 3> , copyMakeBorder_caller<short, 4>},
+ {0/*copyMakeBorder_caller<int, 1>*/, 0/*copyMakeBorder_caller<int, 2>*/ , 0/*copyMakeBorder_caller<int, 3>*/, 0/*copyMakeBorder_caller<int , 4>*/},
+ { copyMakeBorder_caller<float, 1> , 0/*copyMakeBorder_caller<float, 2>*/ , copyMakeBorder_caller<float, 3> , copyMakeBorder_caller<float ,4>}
+ };
+
+ caller_t func = callers[src.depth()][src.channels() - 1];
+ CV_Assert(func != 0);
+
+ func(src, dst, top, left, borderType, value, stream);
+ }
+}
+
+#endif /* !defined (HAVE_CUDA) */
void cv::gpu::add(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, int, Stream&) { throw_no_cuda(); }
void cv::gpu::add(const GpuMat&, const Scalar&, GpuMat&, const GpuMat&, int, Stream&) { throw_no_cuda(); }
+
void cv::gpu::subtract(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, int, Stream&) { throw_no_cuda(); }
void cv::gpu::subtract(const GpuMat&, const Scalar&, GpuMat&, const GpuMat&, int, Stream&) { throw_no_cuda(); }
+
void cv::gpu::multiply(const GpuMat&, const GpuMat&, GpuMat&, double, int, Stream&) { throw_no_cuda(); }
void cv::gpu::multiply(const GpuMat&, const Scalar&, GpuMat&, double, int, Stream&) { throw_no_cuda(); }
+
void cv::gpu::divide(const GpuMat&, const GpuMat&, GpuMat&, double, int, Stream&) { throw_no_cuda(); }
void cv::gpu::divide(const GpuMat&, const Scalar&, GpuMat&, double, int, Stream&) { throw_no_cuda(); }
void cv::gpu::divide(double, const GpuMat&, GpuMat&, int, Stream&) { throw_no_cuda(); }
+
void cv::gpu::absdiff(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::absdiff(const GpuMat&, const Scalar&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::abs(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::sqr(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::sqrt(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::exp(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::log(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::pow(const GpuMat&, double, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::compare(const GpuMat&, const GpuMat&, GpuMat&, int, Stream&) { throw_no_cuda(); }
void cv::gpu::compare(const GpuMat&, Scalar, GpuMat&, int, Stream&) { throw_no_cuda(); }
+
void cv::gpu::bitwise_not(const GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::bitwise_or(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::bitwise_or(const GpuMat&, const Scalar&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::bitwise_and(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::bitwise_and(const GpuMat&, const Scalar&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::bitwise_xor(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::bitwise_xor(const GpuMat&, const Scalar&, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::rshift(const GpuMat&, Scalar_<int>, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::lshift(const GpuMat&, Scalar_<int>, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::min(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::min(const GpuMat&, double, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::max(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
void cv::gpu::max(const GpuMat&, double, GpuMat&, Stream&) { throw_no_cuda(); }
-void cv::gpu::pow(const GpuMat&, double, GpuMat&, Stream&) { throw_no_cuda(); }
+
void cv::gpu::addWeighted(const GpuMat&, double, const GpuMat&, double, double, GpuMat&, int, Stream&) { throw_no_cuda(); }
+
double cv::gpu::threshold(const GpuMat&, GpuMat&, double, double, int, Stream&) {throw_no_cuda(); return 0.0;}
+void cv::gpu::magnitude(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+void cv::gpu::magnitude(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::magnitudeSqr(const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+void cv::gpu::magnitudeSqr(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::phase(const GpuMat&, const GpuMat&, GpuMat&, bool, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::cartToPolar(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::polarToCart(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool, Stream&) { throw_no_cuda(); }
+
#else
////////////////////////////////////////////////////////////////////////
return thresh;
}
+////////////////////////////////////////////////////////////////////////
+// NPP magnitide
+
+namespace
+{
+ typedef NppStatus (*nppMagnitude_t)(const Npp32fc* pSrc, int nSrcStep, Npp32f* pDst, int nDstStep, NppiSize oSizeROI);
+
+ inline void npp_magnitude(const GpuMat& src, GpuMat& dst, nppMagnitude_t func, cudaStream_t stream)
+ {
+ CV_Assert(src.type() == CV_32FC2);
+
+ dst.create(src.size(), CV_32FC1);
+
+ NppiSize sz;
+ sz.width = src.cols;
+ sz.height = src.rows;
+
+ NppStreamHandler h(stream);
+
+ nppSafeCall( func(src.ptr<Npp32fc>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
+
+ if (stream == 0)
+ cudaSafeCall( cudaDeviceSynchronize() );
+ }
+}
+
+void cv::gpu::magnitude(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+ npp_magnitude(src, dst, nppiMagnitude_32fc32f_C1R, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::magnitudeSqr(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+ npp_magnitude(src, dst, nppiMagnitudeSqr_32fc32f_C1R, StreamAccessor::getStream(stream));
+}
+
+////////////////////////////////////////////////////////////////////////
+// Polar <-> Cart
+
+namespace cv { namespace gpu { namespace cudev
+{
+ namespace mathfunc
+ {
+ void cartToPolar_gpu(PtrStepSzf x, PtrStepSzf y, PtrStepSzf mag, bool magSqr, PtrStepSzf angle, bool angleInDegrees, cudaStream_t stream);
+ void polarToCart_gpu(PtrStepSzf mag, PtrStepSzf angle, PtrStepSzf x, PtrStepSzf y, bool angleInDegrees, cudaStream_t stream);
+ }
+}}}
+
+namespace
+{
+ inline void cartToPolar_caller(const GpuMat& x, const GpuMat& y, GpuMat* mag, bool magSqr, GpuMat* angle, bool angleInDegrees, cudaStream_t stream)
+ {
+ using namespace ::cv::gpu::cudev::mathfunc;
+
+ CV_Assert(x.size() == y.size() && x.type() == y.type());
+ CV_Assert(x.depth() == CV_32F);
+
+ if (mag)
+ mag->create(x.size(), x.type());
+ if (angle)
+ angle->create(x.size(), x.type());
+
+ GpuMat x1cn = x.reshape(1);
+ GpuMat y1cn = y.reshape(1);
+ GpuMat mag1cn = mag ? mag->reshape(1) : GpuMat();
+ GpuMat angle1cn = angle ? angle->reshape(1) : GpuMat();
+
+ cartToPolar_gpu(x1cn, y1cn, mag1cn, magSqr, angle1cn, angleInDegrees, stream);
+ }
+
+ inline void polarToCart_caller(const GpuMat& mag, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, cudaStream_t stream)
+ {
+ using namespace ::cv::gpu::cudev::mathfunc;
+
+ CV_Assert((mag.empty() || mag.size() == angle.size()) && mag.type() == angle.type());
+ CV_Assert(mag.depth() == CV_32F);
+
+ x.create(mag.size(), mag.type());
+ y.create(mag.size(), mag.type());
+
+ GpuMat mag1cn = mag.reshape(1);
+ GpuMat angle1cn = angle.reshape(1);
+ GpuMat x1cn = x.reshape(1);
+ GpuMat y1cn = y.reshape(1);
+
+ polarToCart_gpu(mag1cn, angle1cn, x1cn, y1cn, angleInDegrees, stream);
+ }
+}
+
+void cv::gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& dst, Stream& stream)
+{
+ cartToPolar_caller(x, y, &dst, false, 0, false, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& dst, Stream& stream)
+{
+ cartToPolar_caller(x, y, &dst, true, 0, false, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, Stream& stream)
+{
+ cartToPolar_caller(x, y, 0, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& mag, GpuMat& angle, bool angleInDegrees, Stream& stream)
+{
+ cartToPolar_caller(x, y, &mag, false, &angle, angleInDegrees, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, Stream& stream)
+{
+ polarToCart_caller(magnitude, angle, x, y, angleInDegrees, StreamAccessor::getStream(stream));
+}
+
#endif
#include "opencv2/gpuarithm.hpp"
#include "opencv2/core/utility.hpp"
-#include "opencv2/core/core_c.h"
#include "opencv2/core/gpu_private.hpp"
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
-void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&) { throw_no_cuda(); }
-void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&, GpuMat&) { throw_no_cuda(); }
double cv::gpu::norm(const GpuMat&, int) { throw_no_cuda(); return 0.0; }
double cv::gpu::norm(const GpuMat&, int, GpuMat&) { throw_no_cuda(); return 0.0; }
double cv::gpu::norm(const GpuMat&, int, const GpuMat&, GpuMat&) { throw_no_cuda(); return 0.0; }
double cv::gpu::norm(const GpuMat&, const GpuMat&, int) { throw_no_cuda(); return 0.0; }
+
Scalar cv::gpu::sum(const GpuMat&) { throw_no_cuda(); return Scalar(); }
Scalar cv::gpu::sum(const GpuMat&, GpuMat&) { throw_no_cuda(); return Scalar(); }
Scalar cv::gpu::sum(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); return Scalar(); }
+
Scalar cv::gpu::absSum(const GpuMat&) { throw_no_cuda(); return Scalar(); }
Scalar cv::gpu::absSum(const GpuMat&, GpuMat&) { throw_no_cuda(); return Scalar(); }
Scalar cv::gpu::absSum(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); return Scalar(); }
+
Scalar cv::gpu::sqrSum(const GpuMat&) { throw_no_cuda(); return Scalar(); }
Scalar cv::gpu::sqrSum(const GpuMat&, GpuMat&) { throw_no_cuda(); return Scalar(); }
Scalar cv::gpu::sqrSum(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); return Scalar(); }
+
void cv::gpu::minMax(const GpuMat&, double*, double*, const GpuMat&) { throw_no_cuda(); }
void cv::gpu::minMax(const GpuMat&, double*, double*, const GpuMat&, GpuMat&) { throw_no_cuda(); }
+
void cv::gpu::minMaxLoc(const GpuMat&, double*, double*, Point*, Point*, const GpuMat&) { throw_no_cuda(); }
void cv::gpu::minMaxLoc(const GpuMat&, double*, double*, Point*, Point*, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
+
int cv::gpu::countNonZero(const GpuMat&) { throw_no_cuda(); return 0; }
int cv::gpu::countNonZero(const GpuMat&, GpuMat&) { throw_no_cuda(); return 0; }
+
void cv::gpu::reduce(const GpuMat&, GpuMat&, int, int, int, Stream&) { throw_no_cuda(); }
+
+void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&) { throw_no_cuda(); }
+void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&, GpuMat&) { throw_no_cuda(); }
+
void cv::gpu::rectStdDev(const GpuMat&, const GpuMat&, GpuMat&, const Rect&, Stream&) { throw_no_cuda(); }
+void cv::gpu::normalize(const GpuMat&, GpuMat&, double, double, int, int, const GpuMat&) { throw_no_cuda(); }
+void cv::gpu::normalize(const GpuMat&, GpuMat&, double, double, int, int, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
+
#else
namespace
};
}
-
-////////////////////////////////////////////////////////////////////////
-// meanStdDev
-
-void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev)
-{
- GpuMat buf;
- meanStdDev(src, mean, stddev, buf);
-}
-
-void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev, GpuMat& buf)
-{
- CV_Assert(src.type() == CV_8UC1);
-
- if (!deviceSupports(FEATURE_SET_COMPUTE_13))
- CV_Error(cv::Error::StsNotImplemented, "Not sufficient compute capebility");
-
- NppiSize sz;
- sz.width = src.cols;
- sz.height = src.rows;
-
- DeviceBuffer dbuf(2);
-
- int bufSize;
-#if (CUDA_VERSION <= 4020)
- nppSafeCall( nppiMeanStdDev8uC1RGetBufferHostSize(sz, &bufSize) );
-#else
- nppSafeCall( nppiMeanStdDevGetBufferHostSize_8u_C1R(sz, &bufSize) );
-#endif
-
- ensureSizeIsEnough(1, bufSize, CV_8UC1, buf);
-
- nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), sz, buf.ptr<Npp8u>(), dbuf, (double*)dbuf + 1) );
-
- cudaSafeCall( cudaDeviceSynchronize() );
-
- double* ptrs[2] = {mean.val, stddev.val};
- dbuf.download(ptrs);
-}
-
////////////////////////////////////////////////////////////////////////
// norm
}
}
+////////////////////////////////////////////////////////////////////////
+// meanStdDev
+
+void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev)
+{
+ GpuMat buf;
+ meanStdDev(src, mean, stddev, buf);
+}
+
+void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev, GpuMat& buf)
+{
+ CV_Assert(src.type() == CV_8UC1);
+
+ if (!deviceSupports(FEATURE_SET_COMPUTE_13))
+ CV_Error(cv::Error::StsNotImplemented, "Not sufficient compute capebility");
+
+ NppiSize sz;
+ sz.width = src.cols;
+ sz.height = src.rows;
+
+ DeviceBuffer dbuf(2);
+
+ int bufSize;
+#if (CUDA_VERSION <= 4020)
+ nppSafeCall( nppiMeanStdDev8uC1RGetBufferHostSize(sz, &bufSize) );
+#else
+ nppSafeCall( nppiMeanStdDevGetBufferHostSize_8u_C1R(sz, &bufSize) );
+#endif
+
+ ensureSizeIsEnough(1, bufSize, CV_8UC1, buf);
+
+ nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), sz, buf.ptr<Npp8u>(), dbuf, (double*)dbuf + 1) );
+
+ cudaSafeCall( cudaDeviceSynchronize() );
+
+ double* ptrs[2] = {mean.val, stddev.val};
+ dbuf.download(ptrs);
+}
+
//////////////////////////////////////////////////////////////////////////////
// rectStdDev
cudaSafeCall( cudaDeviceSynchronize() );
}
+////////////////////////////////////////////////////////////////////////
+// normalize
+
+void cv::gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask)
+{
+ GpuMat norm_buf;
+ GpuMat cvt_buf;
+ normalize(src, dst, a, b, norm_type, dtype, mask, norm_buf, cvt_buf);
+}
+
+void cv::gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf)
+{
+ double scale = 1, shift = 0;
+ if (norm_type == NORM_MINMAX)
+ {
+ double smin = 0, smax = 0;
+ double dmin = std::min(a, b), dmax = std::max(a, b);
+ gpu::minMax(src, &smin, &smax, mask, norm_buf);
+ scale = (dmax - dmin) * (smax - smin > std::numeric_limits<double>::epsilon() ? 1.0 / (smax - smin) : 0.0);
+ shift = dmin - smin * scale;
+ }
+ else if (norm_type == NORM_L2 || norm_type == NORM_L1 || norm_type == NORM_INF)
+ {
+ scale = gpu::norm(src, norm_type, mask, norm_buf);
+ scale = scale > std::numeric_limits<double>::epsilon() ? a / scale : 0.0;
+ shift = 0;
+ }
+ else
+ {
+ CV_Error(cv::Error::StsBadArg, "Unknown/unsupported norm type");
+ }
+
+ if (mask.empty())
+ {
+ src.convertTo(dst, dtype, scale, shift);
+ }
+ else
+ {
+ src.convertTo(cvt_buf, dtype, scale, shift);
+ cvt_buf.copyTo(dst, mask);
+ }
+}
+
#endif
+++ /dev/null
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-// By downloading, copying, installing or using the software you agree to this license.
-// If you do not agree to this license, do not download, install,
-// copy or use the software.
-//
-//
-// License Agreement
-// For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// * Redistribution's of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistribution's in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// * The name of the copyright holders may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "precomp.hpp"
-
-using namespace cv;
-using namespace cv::gpu;
-
-#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
-
-void cv::gpu::merge(const GpuMat* /*src*/, size_t /*count*/, GpuMat& /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
-void cv::gpu::merge(const std::vector<GpuMat>& /*src*/, GpuMat& /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
-void cv::gpu::split(const GpuMat& /*src*/, GpuMat* /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
-void cv::gpu::split(const GpuMat& /*src*/, std::vector<GpuMat>& /*dst*/, Stream& /*stream*/) { throw_no_cuda(); }
-
-#else /* !defined (HAVE_CUDA) */
-
-namespace cv { namespace gpu { namespace cudev
-{
- namespace split_merge
- {
- void merge_caller(const PtrStepSzb* src, PtrStepSzb& dst, int total_channels, size_t elem_size, const cudaStream_t& stream);
- void split_caller(const PtrStepSzb& src, PtrStepSzb* dst, int num_channels, size_t elem_size1, const cudaStream_t& stream);
- }
-}}}
-
-namespace
-{
- void merge(const GpuMat* src, size_t n, GpuMat& dst, const cudaStream_t& stream)
- {
- using namespace ::cv::gpu::cudev::split_merge;
-
- CV_Assert(src);
- CV_Assert(n > 0);
-
- int depth = src[0].depth();
- Size size = src[0].size();
-
- if (depth == CV_64F)
- {
- if (!deviceSupports(NATIVE_DOUBLE))
- CV_Error(cv::Error::StsUnsupportedFormat, "The device doesn't support double");
- }
-
- bool single_channel_only = true;
- int total_channels = 0;
-
- for (size_t i = 0; i < n; ++i)
- {
- CV_Assert(src[i].size() == size);
- CV_Assert(src[i].depth() == depth);
- single_channel_only = single_channel_only && src[i].channels() == 1;
- total_channels += src[i].channels();
- }
-
- CV_Assert(single_channel_only);
- CV_Assert(total_channels <= 4);
-
- if (total_channels == 1)
- src[0].copyTo(dst);
- else
- {
- dst.create(size, CV_MAKETYPE(depth, total_channels));
-
- PtrStepSzb src_as_devmem[4];
- for(size_t i = 0; i < n; ++i)
- src_as_devmem[i] = src[i];
-
- PtrStepSzb dst_as_devmem(dst);
- merge_caller(src_as_devmem, dst_as_devmem, total_channels, CV_ELEM_SIZE(depth), stream);
- }
- }
-
- void split(const GpuMat& src, GpuMat* dst, const cudaStream_t& stream)
- {
- using namespace ::cv::gpu::cudev::split_merge;
-
- CV_Assert(dst);
-
- int depth = src.depth();
- int num_channels = src.channels();
-
- if (depth == CV_64F)
- {
- if (!deviceSupports(NATIVE_DOUBLE))
- CV_Error(cv::Error::StsUnsupportedFormat, "The device doesn't support double");
- }
-
- if (num_channels == 1)
- {
- src.copyTo(dst[0]);
- return;
- }
-
- for (int i = 0; i < num_channels; ++i)
- dst[i].create(src.size(), depth);
-
- CV_Assert(num_channels <= 4);
-
- PtrStepSzb dst_as_devmem[4];
- for (int i = 0; i < num_channels; ++i)
- dst_as_devmem[i] = dst[i];
-
- PtrStepSzb src_as_devmem(src);
- split_caller(src_as_devmem, dst_as_devmem, num_channels, src.elemSize1(), stream);
- }
-}
-
-void cv::gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream)
-{
- ::merge(src, n, dst, StreamAccessor::getStream(stream));
-}
-
-
-void cv::gpu::merge(const std::vector<GpuMat>& src, GpuMat& dst, Stream& stream)
-{
- ::merge(&src[0], src.size(), dst, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::split(const GpuMat& src, GpuMat* dst, Stream& stream)
-{
- ::split(src, dst, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::split(const GpuMat& src, std::vector<GpuMat>& dst, Stream& stream)
-{
- dst.resize(src.channels());
- if(src.channels() > 0)
- ::split(src, &dst[0], StreamAccessor::getStream(stream));
-}
-
-#endif /* !defined (HAVE_CUDA) */
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+using namespace cvtest;
+
+//////////////////////////////////////////////////////////////////////////////
+// GEMM
+
+#ifdef HAVE_CUBLAS
+
+CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
+#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
+
+PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int type;
+ int flags;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ type = GET_PARAM(2);
+ flags = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(GEMM, Accuracy)
+{
+ cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
+ cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
+ cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
+ double alpha = randomDouble(-10.0, 10.0);
+ double beta = randomDouble(-10.0, 10.0);
+
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else if (type == CV_64FC2 && flags != 0)
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
+
+ cv::Mat dst_gold;
+ cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, GEMM, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatType(CV_32FC1), MatType(CV_32FC2), MatType(CV_64FC1), MatType(CV_64FC2)),
+ ALL_GEMM_FLAGS,
+ WHOLE_SUBMAT));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// Integral
+
+PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ useRoi = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Integral, Accuracy)
+{
+ cv::Mat src = randomMat(size, CV_8UC1);
+
+ cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
+ cv::gpu::integral(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::integral(src, dst_gold, CV_32S);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Integral, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////
+// MulSpectrums
+
+CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
+
+PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int flag;
+
+ cv::Mat a, b;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ flag = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ a = randomMat(size, CV_32FC2);
+ b = randomMat(size, CV_32FC2);
+ }
+};
+
+GPU_TEST_P(MulSpectrums, Simple)
+{
+ cv::gpu::GpuMat c;
+ cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
+
+ cv::Mat c_gold;
+ cv::mulSpectrums(a, b, c_gold, flag, false);
+
+ EXPECT_MAT_NEAR(c_gold, c, 1e-2);
+}
+
+GPU_TEST_P(MulSpectrums, Scaled)
+{
+ float scale = 1.f / size.area();
+
+ cv::gpu::GpuMat c;
+ cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
+
+ cv::Mat c_gold;
+ cv::mulSpectrums(a, b, c_gold, flag, false);
+ c_gold.convertTo(c_gold, c_gold.type(), scale);
+
+ EXPECT_MAT_NEAR(c_gold, c, 1e-2);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, MulSpectrums, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
+
+////////////////////////////////////////////////////////////////////////////
+// Dft
+
+struct Dft : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+ cv::gpu::DeviceInfo devInfo;
+
+ virtual void SetUp()
+ {
+ devInfo = GetParam();
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+namespace
+{
+ void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)
+ {
+ SCOPED_TRACE(hint);
+
+ cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC2, 0.0, 10.0);
+
+ cv::Mat b_gold;
+ cv::dft(a, b_gold, flags);
+
+ cv::gpu::GpuMat d_b;
+ cv::gpu::GpuMat d_b_data;
+ if (inplace)
+ {
+ d_b_data.create(1, a.size().area(), CV_32FC2);
+ d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+ }
+ cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), flags);
+
+ EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
+ ASSERT_EQ(CV_32F, d_b.depth());
+ ASSERT_EQ(2, d_b.channels());
+ EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);
+ }
+}
+
+GPU_TEST_P(Dft, C2C)
+{
+ int cols = randomInt(2, 100);
+ int rows = randomInt(2, 100);
+
+ for (int i = 0; i < 2; ++i)
+ {
+ bool inplace = i != 0;
+
+ testC2C("no flags", cols, rows, 0, inplace);
+ testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
+ testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
+ testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
+ testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
+ testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
+ testC2C("single col", 1, rows, 0, inplace);
+ testC2C("single row", cols, 1, 0, inplace);
+ testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
+ testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
+ testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
+ testC2C("size 1 2", 1, 2, 0, inplace);
+ testC2C("size 2 1", 2, 1, 0, inplace);
+ }
+}
+
+namespace
+{
+ void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
+ {
+ SCOPED_TRACE(hint);
+
+ cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC1, 0.0, 10.0);
+
+ cv::gpu::GpuMat d_b, d_c;
+ cv::gpu::GpuMat d_b_data, d_c_data;
+ if (inplace)
+ {
+ if (a.cols == 1)
+ {
+ d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
+ d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+ }
+ else
+ {
+ d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
+ d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
+ }
+ d_c_data.create(1, a.size().area(), CV_32F);
+ d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
+ }
+
+ cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), 0);
+ cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
+
+ EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
+ EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());
+ ASSERT_EQ(CV_32F, d_c.depth());
+ ASSERT_EQ(1, d_c.channels());
+
+ cv::Mat c(d_c);
+ EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);
+ }
+}
+
+GPU_TEST_P(Dft, R2CThenC2R)
+{
+ int cols = randomInt(2, 100);
+ int rows = randomInt(2, 100);
+
+ testR2CThenC2R("sanity", cols, rows, false);
+ testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
+ testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
+ testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
+ testR2CThenC2R("single col", 1, rows, false);
+ testR2CThenC2R("single col 1", 1, rows + 1, false);
+ testR2CThenC2R("single row", cols, 1, false);
+ testR2CThenC2R("single row 1", cols + 1, 1, false);
+
+ testR2CThenC2R("sanity", cols, rows, true);
+ testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
+ testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
+ testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
+ testR2CThenC2R("single row", cols, 1, true);
+ testR2CThenC2R("single row 1", cols + 1, 1, true);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Dft, ALL_DEVICES);
+
+////////////////////////////////////////////////////////
+// Convolve
+
+namespace
+{
+ void convolveDFT(const cv::Mat& A, const cv::Mat& B, cv::Mat& C, bool ccorr = false)
+ {
+ // reallocate the output array if needed
+ C.create(std::abs(A.rows - B.rows) + 1, std::abs(A.cols - B.cols) + 1, A.type());
+ cv::Size dftSize;
+
+ // compute the size of DFT transform
+ dftSize.width = cv::getOptimalDFTSize(A.cols + B.cols - 1);
+ dftSize.height = cv::getOptimalDFTSize(A.rows + B.rows - 1);
+
+ // allocate temporary buffers and initialize them with 0s
+ cv::Mat tempA(dftSize, A.type(), cv::Scalar::all(0));
+ cv::Mat tempB(dftSize, B.type(), cv::Scalar::all(0));
+
+ // copy A and B to the top-left corners of tempA and tempB, respectively
+ cv::Mat roiA(tempA, cv::Rect(0, 0, A.cols, A.rows));
+ A.copyTo(roiA);
+ cv::Mat roiB(tempB, cv::Rect(0, 0, B.cols, B.rows));
+ B.copyTo(roiB);
+
+ // now transform the padded A & B in-place;
+ // use "nonzeroRows" hint for faster processing
+ cv::dft(tempA, tempA, 0, A.rows);
+ cv::dft(tempB, tempB, 0, B.rows);
+
+ // multiply the spectrums;
+ // the function handles packed spectrum representations well
+ cv::mulSpectrums(tempA, tempB, tempA, 0, ccorr);
+
+ // transform the product back from the frequency domain.
+ // Even though all the result rows will be non-zero,
+ // you need only the first C.rows of them, and thus you
+ // pass nonzeroRows == C.rows
+ cv::dft(tempA, tempA, cv::DFT_INVERSE + cv::DFT_SCALE, C.rows);
+
+ // now copy the result back to C.
+ tempA(cv::Rect(0, 0, C.cols, C.rows)).copyTo(C);
+ }
+
+ IMPLEMENT_PARAM_CLASS(KSize, int)
+ IMPLEMENT_PARAM_CLASS(Ccorr, bool)
+}
+
+PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int ksize;
+ bool ccorr;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ ksize = GET_PARAM(2);
+ ccorr = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Convolve, Accuracy)
+{
+ cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
+ cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
+
+ cv::gpu::GpuMat dst;
+ cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
+
+ cv::Mat dst_gold;
+ convolveDFT(src, kernel, dst_gold, ccorr);
+
+ EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Convolve, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(KSize(3), KSize(7), KSize(11), KSize(17), KSize(19), KSize(23), KSize(45)),
+ testing::Values(Ccorr(false), Ccorr(true))));
+
+#endif // HAVE_CUBLAS
+
+#endif // HAVE_CUDA
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
-// Add_Array
-
-PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- int channels;
- bool useRoi;
-
- int stype;
- int dtype;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- stype = CV_MAKE_TYPE(depth.first, channels);
- dtype = CV_MAKE_TYPE(depth.second, channels);
- }
-};
-
-GPU_TEST_P(Add_Array, Accuracy)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Array, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- ALL_CHANNELS,
- WHOLE_SUBMAT));
-
-PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- int stype;
- int dtype;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- stype = CV_MAKE_TYPE(depth.first, 1);
- dtype = CV_MAKE_TYPE(depth.second, 1);
- }
-};
-
-GPU_TEST_P(Add_Array_Mask, Accuracy)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
- cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::add(mat1, mat2, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Array_Mask, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Add_Scalar
-
-PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Add_Scalar, WithOutMask)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-GPU_TEST_P(Add_Scalar, WithMask)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::add(mat, val, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Scalar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Subtract_Array
-
-PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- int channels;
- bool useRoi;
-
- int stype;
- int dtype;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- stype = CV_MAKE_TYPE(depth.first, channels);
- dtype = CV_MAKE_TYPE(depth.second, channels);
- }
-};
-
-GPU_TEST_P(Subtract_Array, Accuracy)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Array, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- ALL_CHANNELS,
- WHOLE_SUBMAT));
-
-PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- int stype;
- int dtype;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- stype = CV_MAKE_TYPE(depth.first, 1);
- dtype = CV_MAKE_TYPE(depth.second, 1);
- }
-};
-
-GPU_TEST_P(Subtract_Array_Mask, Accuracy)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Array_Mask, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Subtract_Scalar
-
-PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Subtract_Scalar, WithOutMask)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-GPU_TEST_P(Subtract_Scalar, WithMask)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::subtract(mat, val, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Scalar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Multiply_Array
-
-PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- int channels;
- bool useRoi;
-
- int stype;
- int dtype;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- stype = CV_MAKE_TYPE(depth.first, channels);
- dtype = CV_MAKE_TYPE(depth.second, channels);
- }
-};
-
-GPU_TEST_P(Multiply_Array, WithOutScale)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
- }
-}
-
-GPU_TEST_P(Multiply_Array, WithScale)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
- double scale = randomDouble(0.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Array, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- ALL_CHANNELS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Multiply_Array_Special
-
-PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- useRoi = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
-{
- cv::Mat mat1 = randomMat(size, CV_8UC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
- cv::Mat h_dst(dst);
-
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
-
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4b val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4b actual = dst_row[x];
-
- cv::Vec4b gold;
-
- gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
- gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
- gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
- gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
-
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
- }
-}
-
-GPU_TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
-{
- cv::Mat mat1 = randomMat(size, CV_16SC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
- cv::Mat h_dst(dst);
-
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
-
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4s val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4s actual = dst_row[x];
-
- cv::Vec4s gold;
-
- gold[0] = cv::saturate_cast<short>(val1[0] * val2);
- gold[1] = cv::saturate_cast<short>(val1[1] * val2);
- gold[2] = cv::saturate_cast<short>(val1[2] * val2);
- gold[3] = cv::saturate_cast<short>(val1[3] * val2);
-
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Array_Special, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Multiply_Scalar
-
-PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Multiply_Scalar, WithOutScale)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat, val, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
- }
-}
-
-
-GPU_TEST_P(Multiply_Scalar, WithScale)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
- double scale = randomDouble(0.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat, val, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Scalar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Divide_Array
-
-PARAM_TEST_CASE(Divide_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- int channels;
- bool useRoi;
-
- int stype;
- int dtype;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- stype = CV_MAKE_TYPE(depth.first, channels);
- dtype = CV_MAKE_TYPE(depth.second, channels);
- }
-};
-
-GPU_TEST_P(Divide_Array, WithOutScale)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat1, mat2, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
- }
-}
-
-GPU_TEST_P(Divide_Array, WithScale)
-{
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
- double scale = randomDouble(0.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat1, mat2, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Array, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- ALL_CHANNELS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Divide_Array_Special
-
-PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- useRoi = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
-{
- cv::Mat mat1 = randomMat(size, CV_8UC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
-
- cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
- cv::Mat h_dst(dst);
-
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
-
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4b val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4b actual = dst_row[x];
-
- cv::Vec4b gold;
-
- gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
- gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
- gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
- gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
-
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
- }
-}
-
-GPU_TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
-{
- cv::Mat mat1 = randomMat(size, CV_16SC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
-
- cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
- cv::Mat h_dst(dst);
-
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
-
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4s val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4s actual = dst_row[x];
-
- cv::Vec4s gold;
-
- gold[0] = cv::saturate_cast<short>(val1[0] / val2);
- gold[1] = cv::saturate_cast<short>(val1[1] / val2);
- gold[2] = cv::saturate_cast<short>(val1[2] / val2);
- gold[3] = cv::saturate_cast<short>(val1[3] / val2);
-
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Array_Special, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Divide_Scalar
-
-PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Divide_Scalar, WithOutScale)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(1.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat, val, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
- }
-}
-
-GPU_TEST_P(Divide_Scalar, WithScale)
-{
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(1.0, 255.0);
- double scale = randomDouble(0.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat, val, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Scalar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Divide_Scalar_Inv
-
-PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- std::pair<MatDepth, MatDepth> depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Divide_Scalar_Inv, Accuracy)
-{
- double scale = randomDouble(0.0, 255.0);
- cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
-
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(scale, mat, dst_gold, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Scalar_Inv, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- DEPTH_PAIRS,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// AbsDiff
-
-PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(AbsDiff, Array)
-{
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::absdiff(src1, src2, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-GPU_TEST_P(AbsDiff, Scalar)
-{
- cv::Mat src = randomMat(size, depth);
- cv::Scalar val = randomScalar(0.0, 255.0);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::absdiff(loadMat(src), val, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold;
- cv::absdiff(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, AbsDiff, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Abs
-
-PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Abs, Accuracy)
-{
- cv::Mat src = randomMat(size, depth);
-
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::abs(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold = cv::abs(src);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Abs, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Sqr
-
-PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Sqr, Accuracy)
-{
- cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
-
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::sqr(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::multiply(src, src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sqr, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32F)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Sqrt
-
-namespace
-{
- template <typename T> void sqrtImpl(const cv::Mat& src, cv::Mat& dst)
- {
- dst.create(src.size(), src.type());
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- dst.at<T>(y, x) = static_cast<T>(std::sqrt(static_cast<float>(src.at<T>(y, x))));
- }
- }
-
- void sqrtGold(const cv::Mat& src, cv::Mat& dst)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
-
- const func_t funcs[] =
- {
- sqrtImpl<uchar>, sqrtImpl<schar>, sqrtImpl<ushort>, sqrtImpl<short>,
- sqrtImpl<int>, sqrtImpl<float>
- };
-
- funcs[src.depth()](src, dst);
- }
-}
-
-PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Sqrt, Accuracy)
-{
- cv::Mat src = randomMat(size, depth);
-
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::sqrt(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- sqrtGold(src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sqrt, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32F)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Log
-
-namespace
-{
- template <typename T> void logImpl(const cv::Mat& src, cv::Mat& dst)
- {
- dst.create(src.size(), src.type());
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- dst.at<T>(y, x) = static_cast<T>(std::log(static_cast<float>(src.at<T>(y, x))));
- }
- }
-
- void logGold(const cv::Mat& src, cv::Mat& dst)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
-
- const func_t funcs[] =
- {
- logImpl<uchar>, logImpl<schar>, logImpl<ushort>, logImpl<short>,
- logImpl<int>, logImpl<float>
- };
-
- funcs[src.depth()](src, dst);
- }
-}
-
-PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Log, Accuracy)
-{
- cv::Mat src = randomMat(size, depth, 1.0, 255.0);
-
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::log(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- logGold(src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Log, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32F)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Exp
-
-namespace
-{
- template <typename T> void expImpl(const cv::Mat& src, cv::Mat& dst)
- {
- dst.create(src.size(), src.type());
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- dst.at<T>(y, x) = cv::saturate_cast<T>(static_cast<int>(std::exp(static_cast<float>(src.at<T>(y, x)))));
- }
- }
- void expImpl_float(const cv::Mat& src, cv::Mat& dst)
- {
- dst.create(src.size(), src.type());
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- dst.at<float>(y, x) = std::exp(static_cast<float>(src.at<float>(y, x)));
- }
- }
-
- void expGold(const cv::Mat& src, cv::Mat& dst)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
-
- const func_t funcs[] =
- {
- expImpl<uchar>, expImpl<schar>, expImpl<ushort>, expImpl<short>,
- expImpl<int>, expImpl_float
- };
-
- funcs[src.depth()](src, dst);
- }
-}
-
-PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Exp, Accuracy)
-{
- cv::Mat src = randomMat(size, depth, 0.0, 10.0);
-
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::exp(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- expGold(src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Exp, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32F)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Compare_Array
-
-CV_ENUM(CmpCode, CMP_EQ, CMP_NE, CMP_GT, CMP_GE, CMP_LT, CMP_LE)
-
-PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- int cmp_code;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- cmp_code = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Compare_Array, Accuracy)
-{
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
- cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
-
- cv::Mat dst_gold;
- cv::compare(src1, src2, dst_gold, cmp_code);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Compare_Array, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- CmpCode::all(),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Compare_Scalar
-
-namespace
-{
- template <template <typename> class Op, typename T>
- void compareScalarImpl(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst)
- {
- Op<T> op;
-
- const int cn = src.channels();
-
- dst.create(src.size(), CV_MAKE_TYPE(CV_8U, cn));
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- {
- for (int c = 0; c < cn; ++c)
- {
- T src_val = src.at<T>(y, x * cn + c);
- T sc_val = cv::saturate_cast<T>(sc.val[c]);
- dst.at<uchar>(y, x * cn + c) = static_cast<uchar>(static_cast<int>(op(src_val, sc_val)) * 255);
- }
- }
- }
- }
-
- void compareScalarGold(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst, int cmpop)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst);
- static const func_t funcs[7][6] =
- {
- {compareScalarImpl<std::equal_to, unsigned char> , compareScalarImpl<std::greater, unsigned char> , compareScalarImpl<std::greater_equal, unsigned char> , compareScalarImpl<std::less, unsigned char> , compareScalarImpl<std::less_equal, unsigned char> , compareScalarImpl<std::not_equal_to, unsigned char> },
- {compareScalarImpl<std::equal_to, signed char> , compareScalarImpl<std::greater, signed char> , compareScalarImpl<std::greater_equal, signed char> , compareScalarImpl<std::less, signed char> , compareScalarImpl<std::less_equal, signed char> , compareScalarImpl<std::not_equal_to, signed char> },
- {compareScalarImpl<std::equal_to, unsigned short>, compareScalarImpl<std::greater, unsigned short>, compareScalarImpl<std::greater_equal, unsigned short>, compareScalarImpl<std::less, unsigned short>, compareScalarImpl<std::less_equal, unsigned short>, compareScalarImpl<std::not_equal_to, unsigned short>},
- {compareScalarImpl<std::equal_to, short> , compareScalarImpl<std::greater, short> , compareScalarImpl<std::greater_equal, short> , compareScalarImpl<std::less, short> , compareScalarImpl<std::less_equal, short> , compareScalarImpl<std::not_equal_to, short> },
- {compareScalarImpl<std::equal_to, int> , compareScalarImpl<std::greater, int> , compareScalarImpl<std::greater_equal, int> , compareScalarImpl<std::less, int> , compareScalarImpl<std::less_equal, int> , compareScalarImpl<std::not_equal_to, int> },
- {compareScalarImpl<std::equal_to, float> , compareScalarImpl<std::greater, float> , compareScalarImpl<std::greater_equal, float> , compareScalarImpl<std::less, float> , compareScalarImpl<std::less_equal, float> , compareScalarImpl<std::not_equal_to, float> },
- {compareScalarImpl<std::equal_to, double> , compareScalarImpl<std::greater, double> , compareScalarImpl<std::greater_equal, double> , compareScalarImpl<std::less, double> , compareScalarImpl<std::less_equal, double> , compareScalarImpl<std::not_equal_to, double> }
- };
-
- funcs[src.depth()][cmpop](src, sc, dst);
- }
-}
-
-PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- int cmp_code;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- cmp_code = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Compare_Scalar, Accuracy)
-{
- cv::Mat src = randomMat(size, type);
- cv::Scalar sc = randomScalar(0.0, 255.0);
-
- if (src.depth() < CV_32F)
- {
- sc.val[0] = cvRound(sc.val[0]);
- sc.val[1] = cvRound(sc.val[1]);
- sc.val[2] = cvRound(sc.val[2]);
- sc.val[3] = cvRound(sc.val[3]);
- }
-
- if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
-
- cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
-
- cv::Mat dst_gold;
- compareScalarGold(src, sc, dst_gold, cmp_code);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Compare_Scalar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- TYPES(CV_8U, CV_64F, 1, 4),
- CmpCode::all(),
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// Bitwise_Array
-
-PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
-
- cv::Mat src1;
- cv::Mat src2;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- src1 = randomMat(size, type, 0.0, std::numeric_limits<int>::max());
- src2 = randomMat(size, type, 0.0, std::numeric_limits<int>::max());
- }
-};
-
-GPU_TEST_P(Bitwise_Array, Not)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_not(loadMat(src1), dst);
-
- cv::Mat dst_gold = ~src1;
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-GPU_TEST_P(Bitwise_Array, Or)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
-
- cv::Mat dst_gold = src1 | src2;
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-GPU_TEST_P(Bitwise_Array, And)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
-
- cv::Mat dst_gold = src1 & src2;
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-GPU_TEST_P(Bitwise_Array, Xor)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
-
- cv::Mat dst_gold = src1 ^ src2;
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Bitwise_Array, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- TYPES(CV_8U, CV_32S, 1, 4)));
-
-//////////////////////////////////////////////////////////////////////////////
-// Bitwise_Scalar
-
-PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- int channels;
-
- cv::Mat src;
- cv::Scalar val;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- src = randomMat(size, CV_MAKE_TYPE(depth, channels));
- cv::Scalar_<int> ival = randomScalar(0.0, std::numeric_limits<int>::max());
- val = ival;
- }
-};
-
-GPU_TEST_P(Bitwise_Scalar, Or)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_or(loadMat(src), val, dst);
-
- cv::Mat dst_gold;
- cv::bitwise_or(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-GPU_TEST_P(Bitwise_Scalar, And)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_and(loadMat(src), val, dst);
-
- cv::Mat dst_gold;
- cv::bitwise_and(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-GPU_TEST_P(Bitwise_Scalar, Xor)
-{
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_xor(loadMat(src), val, dst);
-
- cv::Mat dst_gold;
- cv::bitwise_xor(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Bitwise_Scalar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
- IMAGE_CHANNELS));
-
-//////////////////////////////////////////////////////////////////////////////
-// RShift
-
-namespace
-{
- template <typename T> void rhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
- {
- const int cn = src.channels();
-
- dst.create(src.size(), src.type());
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- {
- for (int c = 0; c < cn; ++c)
- dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) >> val.val[c];
- }
- }
- }
-
- void rhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
-
- const func_t funcs[] =
- {
- rhiftImpl<uchar>, rhiftImpl<schar>, rhiftImpl<ushort>, rhiftImpl<short>, rhiftImpl<int>
- };
-
- funcs[src.depth()](src, val, dst);
- }
-}
-
-PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- int channels;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(RShift, Accuracy)
-{
- int type = CV_MAKE_TYPE(depth, channels);
- cv::Mat src = randomMat(size, type);
- cv::Scalar_<int> val = randomScalar(0.0, 8.0);
-
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::rshift(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold;
- rhiftGold(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, RShift, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_8S),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32S)),
- IMAGE_CHANNELS,
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// LShift
-
-namespace
-{
- template <typename T> void lhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
- {
- const int cn = src.channels();
-
- dst.create(src.size(), src.type());
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- {
- for (int c = 0; c < cn; ++c)
- dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) << val.val[c];
- }
- }
- }
-
- void lhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
-
- const func_t funcs[] =
- {
- lhiftImpl<uchar>, lhiftImpl<schar>, lhiftImpl<ushort>, lhiftImpl<short>, lhiftImpl<int>
- };
-
- funcs[src.depth()](src, val, dst);
- }
-}
-
-PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- int channels;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(LShift, Accuracy)
-{
- int type = CV_MAKE_TYPE(depth, channels);
- cv::Mat src = randomMat(size, type);
- cv::Scalar_<int> val = randomScalar(0.0, 8.0);
-
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::lshift(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold;
- lhiftGold(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, LShift, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
- IMAGE_CHANNELS,
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// Min
-
-PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Min, Array)
-{
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::min(loadMat(src1), loadMat(src2), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
- cv::Mat dst_gold = cv::min(src1, src2);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-GPU_TEST_P(Min, Scalar)
-{
- cv::Mat src = randomMat(size, depth);
- double val = randomDouble(0.0, 255.0);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::min(loadMat(src), val, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::min(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold = cv::min(src, val);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Min, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// Max
-
-PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Max, Array)
-{
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::max(loadMat(src1), loadMat(src2), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
- cv::Mat dst_gold = cv::max(src1, src2);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-GPU_TEST_P(Max, Scalar)
-{
- cv::Mat src = randomMat(size, depth);
- double val = randomDouble(0.0, 255.0);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::max(loadMat(src), val, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::max(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold = cv::max(src, val);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Max, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Pow
-
-PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Pow, Accuracy)
-{
- cv::Mat src = randomMat(size, depth, 0.0, 10.0);
- double power = randomDouble(2.0, 4.0);
-
- if (src.depth() < CV_32F)
- power = static_cast<int>(power);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::pow(loadMat(src), power, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::pow(loadMat(src, useRoi), power, dst);
-
- cv::Mat dst_gold;
- cv::pow(src, power, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Pow, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// AddWeighted
-
-PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth1;
- int depth2;
- int dst_depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth1 = GET_PARAM(2);
- depth2 = GET_PARAM(3);
- dst_depth = GET_PARAM(4);
- useRoi = GET_PARAM(5);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(AddWeighted, Accuracy)
-{
- cv::Mat src1 = randomMat(size, depth1);
- cv::Mat src2 = randomMat(size, depth2);
- double alpha = randomDouble(-10.0, 10.0);
- double beta = randomDouble(-10.0, 10.0);
- double gamma = randomDouble(-10.0, 10.0);
-
- if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
- cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
-
- cv::Mat dst_gold;
- cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
-
- EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, AddWeighted, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- ALL_DEPTH,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// GEMM
-
-#ifdef HAVE_CUBLAS
-
-CV_FLAGS(GemmFlags, 0, GEMM_1_T, GEMM_2_T, GEMM_3_T);
-#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
-
-PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- int flags;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- flags = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(GEMM, Accuracy)
-{
- cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
- cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
- cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
- double alpha = randomDouble(-10.0, 10.0);
- double beta = randomDouble(-10.0, 10.0);
-
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else if (type == CV_64FC2 && flags != 0)
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
-
- cv::Mat dst_gold;
- cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
-
- EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, GEMM, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatType(CV_32FC1), MatType(CV_32FC2), MatType(CV_64FC1), MatType(CV_64FC2)),
- ALL_GEMM_FLAGS,
- WHOLE_SUBMAT));
-
-#endif // HAVE_CUBLAS
-
-////////////////////////////////////////////////////////////////////////////////
-// Transpose
-
-PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Transpose, Accuracy)
-{
- cv::Mat src = randomMat(size, type);
-
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::transpose(loadMat(src), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
- cv::gpu::transpose(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::transpose(src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Transpose, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatType(CV_8UC1),
- MatType(CV_8UC4),
- MatType(CV_16UC2),
- MatType(CV_16SC2),
- MatType(CV_32SC1),
- MatType(CV_32SC2),
- MatType(CV_64FC1)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Flip
-
-enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
-CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
-#define ALL_FLIP_CODES testing::Values(FlipCode(FLIP_BOTH), FlipCode(FLIP_X), FlipCode(FLIP_Y))
-
-PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- int flip_code;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- flip_code = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Flip, Accuracy)
-{
- cv::Mat src = randomMat(size, type);
-
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
-
- cv::Mat dst_gold;
- cv::flip(src, dst_gold, flip_code);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Flip, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatType(CV_8UC1),
- MatType(CV_8UC3),
- MatType(CV_8UC4),
- MatType(CV_16UC1),
- MatType(CV_16UC3),
- MatType(CV_16UC4),
- MatType(CV_32SC1),
- MatType(CV_32SC3),
- MatType(CV_32SC4),
- MatType(CV_32FC1),
- MatType(CV_32FC3),
- MatType(CV_32FC4)),
- ALL_FLIP_CODES,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// LUT
-
-PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(LUT, OneChannel)
-{
- cv::Mat src = randomMat(size, type);
- cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
-
- cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
- cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
-
- cv::Mat dst_gold;
- cv::LUT(src, lut, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-GPU_TEST_P(LUT, MultiChannel)
-{
- cv::Mat src = randomMat(size, type);
- cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
-
- cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
- cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
-
- cv::Mat dst_gold;
- cv::LUT(src, lut, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, LUT, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatType(CV_8UC1), MatType(CV_8UC3)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Magnitude
-
-PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- useRoi = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Magnitude, NPP)
-{
- cv::Mat src = randomMat(size, CV_32FC2);
-
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitude(loadMat(src, useRoi), dst);
-
- cv::Mat arr[2];
- cv::split(src, arr);
- cv::Mat dst_gold;
- cv::magnitude(arr[0], arr[1], dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
-}
-
-GPU_TEST_P(Magnitude, Sqr_NPP)
-{
- cv::Mat src = randomMat(size, CV_32FC2);
-
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
-
- cv::Mat arr[2];
- cv::split(src, arr);
- cv::Mat dst_gold;
- cv::magnitude(arr[0], arr[1], dst_gold);
- cv::multiply(dst_gold, dst_gold, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
-}
-
-GPU_TEST_P(Magnitude, Accuracy)
-{
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::magnitude(x, y, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
-}
-
-GPU_TEST_P(Magnitude, Sqr_Accuracy)
-{
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::magnitude(x, y, dst_gold);
- cv::multiply(dst_gold, dst_gold, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Magnitude, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Phase
-
-namespace
-{
- IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)
-}
-
-PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool angleInDegrees;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- angleInDegrees = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Phase, Accuracy)
-{
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
-
- cv::Mat dst_gold;
- cv::phase(x, y, dst_gold, angleInDegrees);
-
- EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Phase, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// CartToPolar
-
-PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool angleInDegrees;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- angleInDegrees = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(CartToPolar, Accuracy)
-{
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
- cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
- cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
-
- cv::Mat mag_gold;
- cv::Mat angle_gold;
- cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
-
- EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
- EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, CartToPolar, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// polarToCart
-
-PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool angleInDegrees;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- angleInDegrees = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(PolarToCart, Accuracy)
-{
- cv::Mat magnitude = randomMat(size, CV_32FC1);
- cv::Mat angle = randomMat(size, CV_32FC1);
-
- cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
- cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
- cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
-
- cv::Mat x_gold;
- cv::Mat y_gold;
- cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
-
- EXPECT_MAT_NEAR(x_gold, x, 1e-4);
- EXPECT_MAT_NEAR(y_gold, y, 1e-4);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, PolarToCart, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// MeanStdDev
-
-PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- useRoi = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(MeanStdDev, Accuracy)
-{
- cv::Mat src = randomMat(size, CV_8UC1);
-
- if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
- {
- try
- {
- cv::Scalar mean;
- cv::Scalar stddev;
- cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
- }
- }
- else
- {
- cv::Scalar mean;
- cv::Scalar stddev;
- cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-
- cv::Scalar mean_gold;
- cv::Scalar stddev_gold;
- cv::meanStdDev(src, mean_gold, stddev_gold);
-
- EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
- EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, MeanStdDev, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// Norm
-
-PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- int normCode;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- normCode = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Norm, Accuracy)
-{
- cv::Mat src = randomMat(size, depth);
- cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
-
- cv::gpu::GpuMat d_buf;
- double val = cv::gpu::norm(loadMat(src, useRoi), normCode, loadMat(mask, useRoi), d_buf);
-
- double val_gold = cv::norm(src, normCode, mask);
-
- EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Norm, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_8S),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32S),
- MatDepth(CV_32F)),
- testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// normDiff
-
-PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int normCode;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- normCode = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(NormDiff, Accuracy)
-{
- cv::Mat src1 = randomMat(size, CV_8UC1);
- cv::Mat src2 = randomMat(size, CV_8UC1);
-
- double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
-
- double val_gold = cv::norm(src1, src2, normCode);
-
- EXPECT_NEAR(val_gold, val, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, NormDiff, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// Sum
-
-namespace
-{
- template <typename T>
- cv::Scalar absSumImpl(const cv::Mat& src)
- {
- const int cn = src.channels();
-
- cv::Scalar sum = cv::Scalar::all(0);
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- {
- for (int c = 0; c < cn; ++c)
- sum[c] += std::abs(src.at<T>(y, x * cn + c));
- }
- }
-
- return sum;
- }
-
- cv::Scalar absSumGold(const cv::Mat& src)
- {
- typedef cv::Scalar (*func_t)(const cv::Mat& src);
-
- static const func_t funcs[] =
- {
- absSumImpl<uchar>,
- absSumImpl<schar>,
- absSumImpl<ushort>,
- absSumImpl<short>,
- absSumImpl<int>,
- absSumImpl<float>,
- absSumImpl<double>
- };
-
- return funcs[src.depth()](src);
- }
-
- template <typename T>
- cv::Scalar sqrSumImpl(const cv::Mat& src)
- {
- const int cn = src.channels();
-
- cv::Scalar sum = cv::Scalar::all(0);
-
- for (int y = 0; y < src.rows; ++y)
- {
- for (int x = 0; x < src.cols; ++x)
- {
- for (int c = 0; c < cn; ++c)
- {
- const T val = src.at<T>(y, x * cn + c);
- sum[c] += val * val;
- }
- }
- }
-
- return sum;
- }
-
- cv::Scalar sqrSumGold(const cv::Mat& src)
- {
- typedef cv::Scalar (*func_t)(const cv::Mat& src);
-
- static const func_t funcs[] =
- {
- sqrSumImpl<uchar>,
- sqrSumImpl<schar>,
- sqrSumImpl<ushort>,
- sqrSumImpl<short>,
- sqrSumImpl<int>,
- sqrSumImpl<float>,
- sqrSumImpl<double>
- };
-
- return funcs[src.depth()](src);
- }
-}
-
-PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- bool useRoi;
-
- cv::Mat src;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- src = randomMat(size, type, -128.0, 128.0);
- }
-};
-
-GPU_TEST_P(Sum, Simple)
-{
- cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
-
- cv::Scalar val_gold = cv::sum(src);
-
- EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-}
-
-GPU_TEST_P(Sum, Abs)
-{
- cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
-
- cv::Scalar val_gold = absSumGold(src);
-
- EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-}
-
-GPU_TEST_P(Sum, Sqr)
-{
- cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
-
- cv::Scalar val_gold = sqrSumGold(src);
-
- EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sum, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- TYPES(CV_8U, CV_64F, 1, 4),
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// MinMax
-
-PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(MinMax, WithoutMask)
-{
- cv::Mat src = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
-
- double minVal_gold, maxVal_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
- }
-}
-
-GPU_TEST_P(MinMax, WithMask)
-{
- cv::Mat src = randomMat(size, depth);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
-
- double minVal_gold, maxVal_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
- }
-}
-
-GPU_TEST_P(MinMax, NullPtr)
-{
- cv::Mat src = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src), &minVal, 0);
- cv::gpu::minMax(loadMat(src), 0, &maxVal);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
- cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
-
- double minVal_gold, maxVal_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMax, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////////
-// MinMaxLoc
-
-namespace
-{
- template <typename T>
- void expectEqualImpl(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
- {
- EXPECT_EQ(src.at<T>(loc_gold.y, loc_gold.x), src.at<T>(loc.y, loc.x));
- }
-
- void expectEqual(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
- {
- typedef void (*func_t)(const cv::Mat& src, cv::Point loc_gold, cv::Point loc);
-
- static const func_t funcs[] =
- {
- expectEqualImpl<uchar>,
- expectEqualImpl<schar>,
- expectEqualImpl<ushort>,
- expectEqualImpl<short>,
- expectEqualImpl<int>,
- expectEqualImpl<float>,
- expectEqualImpl<double>
- };
-
- funcs[src.depth()](src, loc_gold, loc);
- }
-}
-
-PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(MinMaxLoc, WithoutMask)
-{
- cv::Mat src = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
-
- double minVal_gold, maxVal_gold;
- cv::Point minLoc_gold, maxLoc_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
- expectEqual(src, minLoc_gold, minLoc);
- expectEqual(src, maxLoc_gold, maxLoc);
- }
-}
-
-GPU_TEST_P(MinMaxLoc, WithMask)
-{
- cv::Mat src = randomMat(size, depth);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
-
- double minVal_gold, maxVal_gold;
- cv::Point minLoc_gold, maxLoc_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
- expectEqual(src, minLoc_gold, minLoc);
- expectEqual(src, maxLoc_gold, maxLoc);
- }
-}
-
-GPU_TEST_P(MinMaxLoc, NullPtr)
-{
- cv::Mat src = randomMat(size, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-
- double minVal_gold, maxVal_gold;
- cv::Point minLoc_gold, maxLoc_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
- expectEqual(src, minLoc_gold, minLoc);
- expectEqual(src, maxLoc_gold, maxLoc);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMaxLoc, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-////////////////////////////////////////////////////////////////////////////
-// CountNonZero
-
-PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int depth;
- bool useRoi;
-
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- depth = GET_PARAM(2);
- useRoi = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(CountNonZero, Accuracy)
-{
- cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
- cv::Mat src;
- srcBase.convertTo(src, depth);
-
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::countNonZero(loadMat(src));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
- }
- }
- else
- {
- int val = cv::gpu::countNonZero(loadMat(src, useRoi));
-
- int val_gold = cv::countNonZero(src);
-
- ASSERT_EQ(val_gold, val);
- }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, CountNonZero, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- ALL_DEPTH,
- WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////////////////////////////
-// Reduce
-
-CV_ENUM(ReduceCode, REDUCE_SUM, REDUCE_AVG, REDUCE_MAX, REDUCE_MIN)
+// Transpose
-PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, UseRoi)
+PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
{
cv::gpu::DeviceInfo devInfo;
cv::Size size;
- int depth;
- int channels;
- int reduceOp;
- bool useRoi;
-
int type;
- int dst_depth;
- int dst_type;
+ bool useRoi;
virtual void SetUp()
{
devInfo = GET_PARAM(0);
size = GET_PARAM(1);
- depth = GET_PARAM(2);
- channels = GET_PARAM(3);
- reduceOp = GET_PARAM(4);
- useRoi = GET_PARAM(5);
+ type = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
cv::gpu::setDevice(devInfo.deviceID());
-
- type = CV_MAKE_TYPE(depth, channels);
-
- if (reduceOp == cv::REDUCE_MAX || reduceOp == cv::REDUCE_MIN)
- dst_depth = depth;
- else if (reduceOp == cv::REDUCE_SUM)
- dst_depth = depth == CV_8U ? CV_32S : depth < CV_64F ? CV_32F : depth;
- else
- dst_depth = depth < CV_32F ? CV_32F : depth;
-
- dst_type = CV_MAKE_TYPE(dst_depth, channels);
}
-
};
-GPU_TEST_P(Reduce, Rows)
-{
- cv::Mat src = randomMat(size, type);
-
- cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
- cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
-
- cv::Mat dst_gold;
- cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
-
- EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
-}
-
-GPU_TEST_P(Reduce, Cols)
+GPU_TEST_P(Transpose, Accuracy)
{
cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
- cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::transpose(loadMat(src), dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
+ cv::gpu::transpose(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
- dst_gold.cols = dst_gold.rows;
- dst_gold.rows = 1;
- dst_gold.step = dst_gold.cols * dst_gold.elemSize();
+ cv::Mat dst_gold;
+ cv::transpose(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
}
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Reduce, testing::Combine(
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Transpose, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
- testing::Values(MatDepth(CV_8U),
- MatDepth(CV_16U),
- MatDepth(CV_16S),
- MatDepth(CV_32F),
- MatDepth(CV_64F)),
- ALL_CHANNELS,
- ReduceCode::all(),
+ testing::Values(MatType(CV_8UC1),
+ MatType(CV_8UC4),
+ MatType(CV_16UC2),
+ MatType(CV_16SC2),
+ MatType(CV_32SC1),
+ MatType(CV_32SC2),
+ MatType(CV_64FC1)),
WHOLE_SUBMAT));
-//////////////////////////////////////////////////////////////////////////////
-// Normalize
+////////////////////////////////////////////////////////////////////////////////
+// Flip
+
+enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
+CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
+#define ALL_FLIP_CODES testing::Values(FlipCode(FLIP_BOTH), FlipCode(FLIP_X), FlipCode(FLIP_Y))
-PARAM_TEST_CASE(Normalize, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
+PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
{
cv::gpu::DeviceInfo devInfo;
cv::Size size;
int type;
- int norm_type;
+ int flip_code;
bool useRoi;
- double alpha;
- double beta;
-
virtual void SetUp()
{
devInfo = GET_PARAM(0);
size = GET_PARAM(1);
type = GET_PARAM(2);
- norm_type = GET_PARAM(3);
+ flip_code = GET_PARAM(3);
useRoi = GET_PARAM(4);
cv::gpu::setDevice(devInfo.deviceID());
-
- alpha = 1;
- beta = 0;
}
-
};
-GPU_TEST_P(Normalize, WithOutMask)
+GPU_TEST_P(Flip, Accuracy)
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::normalize(loadMat(src, useRoi), dst, alpha, beta, norm_type, type);
+ cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
cv::Mat dst_gold;
- cv::normalize(src, dst_gold, alpha, beta, norm_type, type);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
-}
-
-GPU_TEST_P(Normalize, WithMask)
-{
- cv::Mat src = randomMat(size, type);
- cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
-
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::normalize(loadMat(src, useRoi), dst, alpha, beta, norm_type, type, loadMat(mask, useRoi));
-
- cv::Mat dst_gold(size, type);
- dst_gold.setTo(cv::Scalar::all(0));
- cv::normalize(src, dst_gold, alpha, beta, norm_type, type, mask);
+ cv::flip(src, dst_gold, flip_code);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Normalize, testing::Combine(
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Flip, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
- ALL_DEPTH,
- testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF), NormCode(cv::NORM_MINMAX)),
+ testing::Values(MatType(CV_8UC1),
+ MatType(CV_8UC3),
+ MatType(CV_8UC4),
+ MatType(CV_16UC1),
+ MatType(CV_16UC3),
+ MatType(CV_16UC4),
+ MatType(CV_32SC1),
+ MatType(CV_32SC3),
+ MatType(CV_32SC4),
+ MatType(CV_32FC1),
+ MatType(CV_32FC3),
+ MatType(CV_32FC4)),
+ ALL_FLIP_CODES,
WHOLE_SUBMAT));
-////////////////////////////////////////////////////////////////////////////
-// MulSpectrums
-
-CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
+////////////////////////////////////////////////////////////////////////////////
+// LUT
-PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
+PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
{
cv::gpu::DeviceInfo devInfo;
cv::Size size;
- int flag;
-
- cv::Mat a, b;
+ int type;
+ bool useRoi;
virtual void SetUp()
{
devInfo = GET_PARAM(0);
size = GET_PARAM(1);
- flag = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
-
- a = randomMat(size, CV_32FC2);
- b = randomMat(size, CV_32FC2);
- }
-};
-
-GPU_TEST_P(MulSpectrums, Simple)
-{
- cv::gpu::GpuMat c;
- cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
-
- cv::Mat c_gold;
- cv::mulSpectrums(a, b, c_gold, flag, false);
-
- EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-}
-
-GPU_TEST_P(MulSpectrums, Scaled)
-{
- float scale = 1.f / size.area();
-
- cv::gpu::GpuMat c;
- cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
-
- cv::Mat c_gold;
- cv::mulSpectrums(a, b, c_gold, flag, false);
- c_gold.convertTo(c_gold, c_gold.type(), scale);
-
- EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, MulSpectrums, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
-
-////////////////////////////////////////////////////////////////////////////
-// Dft
-
-struct Dft : testing::TestWithParam<cv::gpu::DeviceInfo>
-{
- cv::gpu::DeviceInfo devInfo;
-
- virtual void SetUp()
- {
- devInfo = GetParam();
+ type = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
cv::gpu::setDevice(devInfo.deviceID());
}
};
-namespace
-{
- void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)
- {
- SCOPED_TRACE(hint);
-
- cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC2, 0.0, 10.0);
-
- cv::Mat b_gold;
- cv::dft(a, b_gold, flags);
-
- cv::gpu::GpuMat d_b;
- cv::gpu::GpuMat d_b_data;
- if (inplace)
- {
- d_b_data.create(1, a.size().area(), CV_32FC2);
- d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
- }
- cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), flags);
-
- EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
- ASSERT_EQ(CV_32F, d_b.depth());
- ASSERT_EQ(2, d_b.channels());
- EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);
- }
-}
-
-GPU_TEST_P(Dft, C2C)
-{
- int cols = randomInt(2, 100);
- int rows = randomInt(2, 100);
-
- for (int i = 0; i < 2; ++i)
- {
- bool inplace = i != 0;
-
- testC2C("no flags", cols, rows, 0, inplace);
- testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
- testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
- testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
- testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
- testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
- testC2C("single col", 1, rows, 0, inplace);
- testC2C("single row", cols, 1, 0, inplace);
- testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
- testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
- testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
- testC2C("size 1 2", 1, 2, 0, inplace);
- testC2C("size 2 1", 2, 1, 0, inplace);
- }
-}
-
-namespace
-{
- void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
- {
- SCOPED_TRACE(hint);
-
- cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC1, 0.0, 10.0);
-
- cv::gpu::GpuMat d_b, d_c;
- cv::gpu::GpuMat d_b_data, d_c_data;
- if (inplace)
- {
- if (a.cols == 1)
- {
- d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
- d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
- }
- else
- {
- d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
- d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
- }
- d_c_data.create(1, a.size().area(), CV_32F);
- d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
- }
-
- cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), 0);
- cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
-
- EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
- EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());
- ASSERT_EQ(CV_32F, d_c.depth());
- ASSERT_EQ(1, d_c.channels());
-
- cv::Mat c(d_c);
- EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);
- }
-}
-
-GPU_TEST_P(Dft, R2CThenC2R)
+GPU_TEST_P(LUT, OneChannel)
{
- int cols = randomInt(2, 100);
- int rows = randomInt(2, 100);
-
- testR2CThenC2R("sanity", cols, rows, false);
- testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
- testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
- testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
- testR2CThenC2R("single col", 1, rows, false);
- testR2CThenC2R("single col 1", 1, rows + 1, false);
- testR2CThenC2R("single row", cols, 1, false);
- testR2CThenC2R("single row 1", cols + 1, 1, false);
-
- testR2CThenC2R("sanity", cols, rows, true);
- testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
- testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
- testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
- testR2CThenC2R("single row", cols, 1, true);
- testR2CThenC2R("single row 1", cols + 1, 1, true);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Dft, ALL_DEVICES);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
-////////////////////////////////////////////////////////
-// Convolve
+ cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
+ cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
-namespace
-{
- void convolveDFT(const cv::Mat& A, const cv::Mat& B, cv::Mat& C, bool ccorr = false)
- {
- // reallocate the output array if needed
- C.create(std::abs(A.rows - B.rows) + 1, std::abs(A.cols - B.cols) + 1, A.type());
- cv::Size dftSize;
-
- // compute the size of DFT transform
- dftSize.width = cv::getOptimalDFTSize(A.cols + B.cols - 1);
- dftSize.height = cv::getOptimalDFTSize(A.rows + B.rows - 1);
-
- // allocate temporary buffers and initialize them with 0s
- cv::Mat tempA(dftSize, A.type(), cv::Scalar::all(0));
- cv::Mat tempB(dftSize, B.type(), cv::Scalar::all(0));
-
- // copy A and B to the top-left corners of tempA and tempB, respectively
- cv::Mat roiA(tempA, cv::Rect(0, 0, A.cols, A.rows));
- A.copyTo(roiA);
- cv::Mat roiB(tempB, cv::Rect(0, 0, B.cols, B.rows));
- B.copyTo(roiB);
-
- // now transform the padded A & B in-place;
- // use "nonzeroRows" hint for faster processing
- cv::dft(tempA, tempA, 0, A.rows);
- cv::dft(tempB, tempB, 0, B.rows);
-
- // multiply the spectrums;
- // the function handles packed spectrum representations well
- cv::mulSpectrums(tempA, tempB, tempA, 0, ccorr);
-
- // transform the product back from the frequency domain.
- // Even though all the result rows will be non-zero,
- // you need only the first C.rows of them, and thus you
- // pass nonzeroRows == C.rows
- cv::dft(tempA, tempA, cv::DFT_INVERSE + cv::DFT_SCALE, C.rows);
-
- // now copy the result back to C.
- tempA(cv::Rect(0, 0, C.cols, C.rows)).copyTo(C);
- }
+ cv::Mat dst_gold;
+ cv::LUT(src, lut, dst_gold);
- IMPLEMENT_PARAM_CLASS(KSize, int)
- IMPLEMENT_PARAM_CLASS(Ccorr, bool)
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
-PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int ksize;
- bool ccorr;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- ksize = GET_PARAM(2);
- ccorr = GET_PARAM(3);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Convolve, Accuracy)
+GPU_TEST_P(LUT, MultiChannel)
{
- cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
- cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
- cv::gpu::GpuMat dst;
- cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
+ cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
+ cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
cv::Mat dst_gold;
- convolveDFT(src, kernel, dst_gold, ccorr);
+ cv::LUT(src, lut, dst_gold);
- EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Convolve, testing::Combine(
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, LUT, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
- testing::Values(KSize(3), KSize(7), KSize(11), KSize(17), KSize(19), KSize(23), KSize(45)),
- testing::Values(Ccorr(false), Ccorr(true))));
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3)),
+ WHOLE_SUBMAT));
//////////////////////////////////////////////////////////////////////////////
// CopyMakeBorder
ALL_BORDER_TYPES,
WHOLE_SUBMAT));
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// Integral
-
-PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- useRoi = GET_PARAM(2);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Integral, Accuracy)
-{
- cv::Mat src = randomMat(size, CV_8UC1);
-
- cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
- cv::gpu::integral(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::integral(src, dst_gold, CV_32S);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Integral, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- WHOLE_SUBMAT));
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// Threshold
-
-CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
-#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))
-
-PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, UseRoi)
-{
- cv::gpu::DeviceInfo devInfo;
- cv::Size size;
- int type;
- int threshOp;
- bool useRoi;
-
- virtual void SetUp()
- {
- devInfo = GET_PARAM(0);
- size = GET_PARAM(1);
- type = GET_PARAM(2);
- threshOp = GET_PARAM(3);
- useRoi = GET_PARAM(4);
-
- cv::gpu::setDevice(devInfo.deviceID());
- }
-};
-
-GPU_TEST_P(Threshold, Accuracy)
-{
- cv::Mat src = randomMat(size, type);
- double maxVal = randomDouble(20.0, 127.0);
- double thresh = randomDouble(0.0, maxVal);
-
- cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
- cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
-
- cv::Mat dst_gold;
- cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Arithm, Threshold, testing::Combine(
- ALL_DEVICES,
- DIFFERENT_SIZES,
- testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
- ALL_THRESH_OPS,
- WHOLE_SUBMAT));
-
#endif // HAVE_CUDA
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+using namespace cvtest;
+
+////////////////////////////////////////////////////////////////////////////////
+// Add_Array
+
+PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ int channels;
+ bool useRoi;
+
+ int stype;
+ int dtype;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ stype = CV_MAKE_TYPE(depth.first, channels);
+ dtype = CV_MAKE_TYPE(depth.second, channels);
+ }
+};
+
+GPU_TEST_P(Add_Array, Accuracy)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Array, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ ALL_CHANNELS,
+ WHOLE_SUBMAT));
+
+PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ int stype;
+ int dtype;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ stype = CV_MAKE_TYPE(depth.first, 1);
+ dtype = CV_MAKE_TYPE(depth.second, 1);
+ }
+};
+
+GPU_TEST_P(Add_Array_Mask, Accuracy)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::add(mat1, mat2, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Array_Mask, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Add_Scalar
+
+PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Add_Scalar, WithOutMask)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+GPU_TEST_P(Add_Scalar, WithMask)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::add(mat, val, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Scalar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Subtract_Array
+
+PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ int channels;
+ bool useRoi;
+
+ int stype;
+ int dtype;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ stype = CV_MAKE_TYPE(depth.first, channels);
+ dtype = CV_MAKE_TYPE(depth.second, channels);
+ }
+};
+
+GPU_TEST_P(Subtract_Array, Accuracy)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Array, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ ALL_CHANNELS,
+ WHOLE_SUBMAT));
+
+PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ int stype;
+ int dtype;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ stype = CV_MAKE_TYPE(depth.first, 1);
+ dtype = CV_MAKE_TYPE(depth.second, 1);
+ }
+};
+
+GPU_TEST_P(Subtract_Array_Mask, Accuracy)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Array_Mask, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Subtract_Scalar
+
+PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Subtract_Scalar, WithOutMask)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+GPU_TEST_P(Subtract_Scalar, WithMask)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::subtract(mat, val, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Scalar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Multiply_Array
+
+PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ int channels;
+ bool useRoi;
+
+ int stype;
+ int dtype;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ stype = CV_MAKE_TYPE(depth.first, channels);
+ dtype = CV_MAKE_TYPE(depth.second, channels);
+ }
+};
+
+GPU_TEST_P(Multiply_Array, WithOutScale)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+ }
+}
+
+GPU_TEST_P(Multiply_Array, WithScale)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+ double scale = randomDouble(0.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Array, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ ALL_CHANNELS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Multiply_Array_Special
+
+PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ useRoi = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
+{
+ cv::Mat mat1 = randomMat(size, CV_8UC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+ cv::Mat h_dst(dst);
+
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4b val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4b actual = dst_row[x];
+
+ cv::Vec4b gold;
+
+ gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
+ gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
+ gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
+ gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
+
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ }
+ }
+}
+
+GPU_TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
+{
+ cv::Mat mat1 = randomMat(size, CV_16SC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+ cv::Mat h_dst(dst);
+
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4s val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4s actual = dst_row[x];
+
+ cv::Vec4s gold;
+
+ gold[0] = cv::saturate_cast<short>(val1[0] * val2);
+ gold[1] = cv::saturate_cast<short>(val1[1] * val2);
+ gold[2] = cv::saturate_cast<short>(val1[2] * val2);
+ gold[3] = cv::saturate_cast<short>(val1[3] * val2);
+
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ }
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Array_Special, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Multiply_Scalar
+
+PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Multiply_Scalar, WithOutScale)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat, val, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+ }
+}
+
+
+GPU_TEST_P(Multiply_Scalar, WithScale)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+ double scale = randomDouble(0.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat, val, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Scalar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Divide_Array
+
+PARAM_TEST_CASE(Divide_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, Channels, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ int channels;
+ bool useRoi;
+
+ int stype;
+ int dtype;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ stype = CV_MAKE_TYPE(depth.first, channels);
+ dtype = CV_MAKE_TYPE(depth.second, channels);
+ }
+};
+
+GPU_TEST_P(Divide_Array, WithOutScale)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat1, mat2, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+ }
+}
+
+GPU_TEST_P(Divide_Array, WithScale)
+{
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+ double scale = randomDouble(0.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat1, mat2, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Array, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ ALL_CHANNELS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Divide_Array_Special
+
+PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ useRoi = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
+{
+ cv::Mat mat1 = randomMat(size, CV_8UC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+ cv::Mat h_dst(dst);
+
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4b val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4b actual = dst_row[x];
+
+ cv::Vec4b gold;
+
+ gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
+ gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
+ gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
+ gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
+
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ }
+ }
+}
+
+GPU_TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
+{
+ cv::Mat mat1 = randomMat(size, CV_16SC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+ cv::Mat h_dst(dst);
+
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4s val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4s actual = dst_row[x];
+
+ cv::Vec4s gold;
+
+ gold[0] = cv::saturate_cast<short>(val1[0] / val2);
+ gold[1] = cv::saturate_cast<short>(val1[1] / val2);
+ gold[2] = cv::saturate_cast<short>(val1[2] / val2);
+ gold[3] = cv::saturate_cast<short>(val1[3] / val2);
+
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ }
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Array_Special, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Divide_Scalar
+
+PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Divide_Scalar, WithOutScale)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(1.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat, val, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+ }
+}
+
+GPU_TEST_P(Divide_Scalar, WithScale)
+{
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(1.0, 255.0);
+ double scale = randomDouble(0.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat, val, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Scalar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Divide_Scalar_Inv
+
+PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ std::pair<MatDepth, MatDepth> depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Divide_Scalar_Inv, Accuracy)
+{
+ double scale = randomDouble(0.0, 255.0);
+ cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
+
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(scale, mat, dst_gold, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Scalar_Inv, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ DEPTH_PAIRS,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// AbsDiff
+
+PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(AbsDiff, Array)
+{
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::absdiff(src1, src2, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+GPU_TEST_P(AbsDiff, Scalar)
+{
+ cv::Mat src = randomMat(size, depth);
+ cv::Scalar val = randomScalar(0.0, 255.0);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::absdiff(loadMat(src), val, dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold;
+ cv::absdiff(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, AbsDiff, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Abs
+
+PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Abs, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth);
+
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::abs(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold = cv::abs(src);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Abs, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Sqr
+
+PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Sqr, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
+
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::sqr(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::multiply(src, src, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sqr, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32F)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Sqrt
+
+namespace
+{
+ template <typename T> void sqrtImpl(const cv::Mat& src, cv::Mat& dst)
+ {
+ dst.create(src.size(), src.type());
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ dst.at<T>(y, x) = static_cast<T>(std::sqrt(static_cast<float>(src.at<T>(y, x))));
+ }
+ }
+
+ void sqrtGold(const cv::Mat& src, cv::Mat& dst)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
+
+ const func_t funcs[] =
+ {
+ sqrtImpl<uchar>, sqrtImpl<schar>, sqrtImpl<ushort>, sqrtImpl<short>,
+ sqrtImpl<int>, sqrtImpl<float>
+ };
+
+ funcs[src.depth()](src, dst);
+ }
+}
+
+PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Sqrt, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth);
+
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::sqrt(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold;
+ sqrtGold(src, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sqrt, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32F)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Log
+
+namespace
+{
+ template <typename T> void logImpl(const cv::Mat& src, cv::Mat& dst)
+ {
+ dst.create(src.size(), src.type());
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ dst.at<T>(y, x) = static_cast<T>(std::log(static_cast<float>(src.at<T>(y, x))));
+ }
+ }
+
+ void logGold(const cv::Mat& src, cv::Mat& dst)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
+
+ const func_t funcs[] =
+ {
+ logImpl<uchar>, logImpl<schar>, logImpl<ushort>, logImpl<short>,
+ logImpl<int>, logImpl<float>
+ };
+
+ funcs[src.depth()](src, dst);
+ }
+}
+
+PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Log, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth, 1.0, 255.0);
+
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::log(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold;
+ logGold(src, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Log, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32F)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Exp
+
+namespace
+{
+ template <typename T> void expImpl(const cv::Mat& src, cv::Mat& dst)
+ {
+ dst.create(src.size(), src.type());
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ dst.at<T>(y, x) = cv::saturate_cast<T>(static_cast<int>(std::exp(static_cast<float>(src.at<T>(y, x)))));
+ }
+ }
+ void expImpl_float(const cv::Mat& src, cv::Mat& dst)
+ {
+ dst.create(src.size(), src.type());
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ dst.at<float>(y, x) = std::exp(static_cast<float>(src.at<float>(y, x)));
+ }
+ }
+
+ void expGold(const cv::Mat& src, cv::Mat& dst)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
+
+ const func_t funcs[] =
+ {
+ expImpl<uchar>, expImpl<schar>, expImpl<ushort>, expImpl<short>,
+ expImpl<int>, expImpl_float
+ };
+
+ funcs[src.depth()](src, dst);
+ }
+}
+
+PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Exp, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::exp(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold;
+ expGold(src, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Exp, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32F)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Compare_Array
+
+CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE)
+#define ALL_CMP_CODES testing::Values(CmpCode(cv::CMP_EQ), CmpCode(cv::CMP_NE), CmpCode(cv::CMP_GT), CmpCode(cv::CMP_GE), CmpCode(cv::CMP_LT), CmpCode(cv::CMP_LE))
+
+PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ int cmp_code;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ cmp_code = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Compare_Array, Accuracy)
+{
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
+ cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
+
+ cv::Mat dst_gold;
+ cv::compare(src1, src2, dst_gold, cmp_code);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Compare_Array, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ ALL_CMP_CODES,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Compare_Scalar
+
+namespace
+{
+ template <template <typename> class Op, typename T>
+ void compareScalarImpl(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst)
+ {
+ Op<T> op;
+
+ const int cn = src.channels();
+
+ dst.create(src.size(), CV_MAKE_TYPE(CV_8U, cn));
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ {
+ for (int c = 0; c < cn; ++c)
+ {
+ T src_val = src.at<T>(y, x * cn + c);
+ T sc_val = cv::saturate_cast<T>(sc.val[c]);
+ dst.at<uchar>(y, x * cn + c) = static_cast<uchar>(static_cast<int>(op(src_val, sc_val)) * 255);
+ }
+ }
+ }
+ }
+
+ void compareScalarGold(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst, int cmpop)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst);
+ static const func_t funcs[7][6] =
+ {
+ {compareScalarImpl<std::equal_to, unsigned char> , compareScalarImpl<std::greater, unsigned char> , compareScalarImpl<std::greater_equal, unsigned char> , compareScalarImpl<std::less, unsigned char> , compareScalarImpl<std::less_equal, unsigned char> , compareScalarImpl<std::not_equal_to, unsigned char> },
+ {compareScalarImpl<std::equal_to, signed char> , compareScalarImpl<std::greater, signed char> , compareScalarImpl<std::greater_equal, signed char> , compareScalarImpl<std::less, signed char> , compareScalarImpl<std::less_equal, signed char> , compareScalarImpl<std::not_equal_to, signed char> },
+ {compareScalarImpl<std::equal_to, unsigned short>, compareScalarImpl<std::greater, unsigned short>, compareScalarImpl<std::greater_equal, unsigned short>, compareScalarImpl<std::less, unsigned short>, compareScalarImpl<std::less_equal, unsigned short>, compareScalarImpl<std::not_equal_to, unsigned short>},
+ {compareScalarImpl<std::equal_to, short> , compareScalarImpl<std::greater, short> , compareScalarImpl<std::greater_equal, short> , compareScalarImpl<std::less, short> , compareScalarImpl<std::less_equal, short> , compareScalarImpl<std::not_equal_to, short> },
+ {compareScalarImpl<std::equal_to, int> , compareScalarImpl<std::greater, int> , compareScalarImpl<std::greater_equal, int> , compareScalarImpl<std::less, int> , compareScalarImpl<std::less_equal, int> , compareScalarImpl<std::not_equal_to, int> },
+ {compareScalarImpl<std::equal_to, float> , compareScalarImpl<std::greater, float> , compareScalarImpl<std::greater_equal, float> , compareScalarImpl<std::less, float> , compareScalarImpl<std::less_equal, float> , compareScalarImpl<std::not_equal_to, float> },
+ {compareScalarImpl<std::equal_to, double> , compareScalarImpl<std::greater, double> , compareScalarImpl<std::greater_equal, double> , compareScalarImpl<std::less, double> , compareScalarImpl<std::less_equal, double> , compareScalarImpl<std::not_equal_to, double> }
+ };
+
+ funcs[src.depth()][cmpop](src, sc, dst);
+ }
+}
+
+PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int type;
+ int cmp_code;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ type = GET_PARAM(2);
+ cmp_code = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Compare_Scalar, Accuracy)
+{
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar sc = randomScalar(0.0, 255.0);
+
+ if (src.depth() < CV_32F)
+ {
+ sc.val[0] = cvRound(sc.val[0]);
+ sc.val[1] = cvRound(sc.val[1]);
+ sc.val[2] = cvRound(sc.val[2]);
+ sc.val[3] = cvRound(sc.val[3]);
+ }
+
+ if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
+
+ cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
+
+ cv::Mat dst_gold;
+ compareScalarGold(src, sc, dst_gold, cmp_code);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Compare_Scalar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ TYPES(CV_8U, CV_64F, 1, 4),
+ ALL_CMP_CODES,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// Bitwise_Array
+
+PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int type;
+
+ cv::Mat src1;
+ cv::Mat src2;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ type = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ src1 = randomMat(size, type, 0.0, std::numeric_limits<int>::max());
+ src2 = randomMat(size, type, 0.0, std::numeric_limits<int>::max());
+ }
+};
+
+GPU_TEST_P(Bitwise_Array, Not)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_not(loadMat(src1), dst);
+
+ cv::Mat dst_gold = ~src1;
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+GPU_TEST_P(Bitwise_Array, Or)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
+
+ cv::Mat dst_gold = src1 | src2;
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+GPU_TEST_P(Bitwise_Array, And)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
+
+ cv::Mat dst_gold = src1 & src2;
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+GPU_TEST_P(Bitwise_Array, Xor)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
+
+ cv::Mat dst_gold = src1 ^ src2;
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Bitwise_Array, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ TYPES(CV_8U, CV_32S, 1, 4)));
+
+//////////////////////////////////////////////////////////////////////////////
+// Bitwise_Scalar
+
+PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ int channels;
+
+ cv::Mat src;
+ cv::Scalar val;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ src = randomMat(size, CV_MAKE_TYPE(depth, channels));
+ cv::Scalar_<int> ival = randomScalar(0.0, std::numeric_limits<int>::max());
+ val = ival;
+ }
+};
+
+GPU_TEST_P(Bitwise_Scalar, Or)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_or(loadMat(src), val, dst);
+
+ cv::Mat dst_gold;
+ cv::bitwise_or(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+GPU_TEST_P(Bitwise_Scalar, And)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_and(loadMat(src), val, dst);
+
+ cv::Mat dst_gold;
+ cv::bitwise_and(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+GPU_TEST_P(Bitwise_Scalar, Xor)
+{
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_xor(loadMat(src), val, dst);
+
+ cv::Mat dst_gold;
+ cv::bitwise_xor(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Bitwise_Scalar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
+ IMAGE_CHANNELS));
+
+//////////////////////////////////////////////////////////////////////////////
+// RShift
+
+namespace
+{
+ template <typename T> void rhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
+ {
+ const int cn = src.channels();
+
+ dst.create(src.size(), src.type());
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ {
+ for (int c = 0; c < cn; ++c)
+ dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) >> val.val[c];
+ }
+ }
+ }
+
+ void rhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
+
+ const func_t funcs[] =
+ {
+ rhiftImpl<uchar>, rhiftImpl<schar>, rhiftImpl<ushort>, rhiftImpl<short>, rhiftImpl<int>
+ };
+
+ funcs[src.depth()](src, val, dst);
+ }
+}
+
+PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ int channels;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(RShift, Accuracy)
+{
+ int type = CV_MAKE_TYPE(depth, channels);
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::rshift(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold;
+ rhiftGold(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, RShift, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_8S),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32S)),
+ IMAGE_CHANNELS,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// LShift
+
+namespace
+{
+ template <typename T> void lhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
+ {
+ const int cn = src.channels();
+
+ dst.create(src.size(), src.type());
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ {
+ for (int c = 0; c < cn; ++c)
+ dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) << val.val[c];
+ }
+ }
+ }
+
+ void lhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
+
+ const func_t funcs[] =
+ {
+ lhiftImpl<uchar>, lhiftImpl<schar>, lhiftImpl<ushort>, lhiftImpl<short>, lhiftImpl<int>
+ };
+
+ funcs[src.depth()](src, val, dst);
+ }
+}
+
+PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ int channels;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(LShift, Accuracy)
+{
+ int type = CV_MAKE_TYPE(depth, channels);
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::lshift(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold;
+ lhiftGold(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, LShift, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
+ IMAGE_CHANNELS,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// Min
+
+PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Min, Array)
+{
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::min(loadMat(src1), loadMat(src2), dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+ cv::Mat dst_gold = cv::min(src1, src2);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+GPU_TEST_P(Min, Scalar)
+{
+ cv::Mat src = randomMat(size, depth);
+ double val = randomDouble(0.0, 255.0);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::min(loadMat(src), val, dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::min(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold = cv::min(src, val);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Min, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// Max
+
+PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Max, Array)
+{
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::max(loadMat(src1), loadMat(src2), dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+ cv::Mat dst_gold = cv::max(src1, src2);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+GPU_TEST_P(Max, Scalar)
+{
+ cv::Mat src = randomMat(size, depth);
+ double val = randomDouble(0.0, 255.0);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::max(loadMat(src), val, dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::max(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold = cv::max(src, val);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Max, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Pow
+
+PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Pow, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+ double power = randomDouble(2.0, 4.0);
+
+ if (src.depth() < CV_32F)
+ power = static_cast<int>(power);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::pow(loadMat(src), power, dst);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::pow(loadMat(src, useRoi), power, dst);
+
+ cv::Mat dst_gold;
+ cv::pow(src, power, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Pow, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// AddWeighted
+
+PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth1;
+ int depth2;
+ int dst_depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth1 = GET_PARAM(2);
+ depth2 = GET_PARAM(3);
+ dst_depth = GET_PARAM(4);
+ useRoi = GET_PARAM(5);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(AddWeighted, Accuracy)
+{
+ cv::Mat src1 = randomMat(size, depth1);
+ cv::Mat src2 = randomMat(size, depth2);
+ double alpha = randomDouble(-10.0, 10.0);
+ double beta = randomDouble(-10.0, 10.0);
+ double gamma = randomDouble(-10.0, 10.0);
+
+ if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::GpuMat dst;
+ cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
+ cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
+
+ cv::Mat dst_gold;
+ cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, AddWeighted, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ ALL_DEPTH,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Magnitude
+
+PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ useRoi = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Magnitude, NPP)
+{
+ cv::Mat src = randomMat(size, CV_32FC2);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitude(loadMat(src, useRoi), dst);
+
+ cv::Mat arr[2];
+ cv::split(src, arr);
+ cv::Mat dst_gold;
+ cv::magnitude(arr[0], arr[1], dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+}
+
+GPU_TEST_P(Magnitude, Sqr_NPP)
+{
+ cv::Mat src = randomMat(size, CV_32FC2);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
+
+ cv::Mat arr[2];
+ cv::split(src, arr);
+ cv::Mat dst_gold;
+ cv::magnitude(arr[0], arr[1], dst_gold);
+ cv::multiply(dst_gold, dst_gold, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
+}
+
+GPU_TEST_P(Magnitude, Accuracy)
+{
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::magnitude(x, y, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+}
+
+GPU_TEST_P(Magnitude, Sqr_Accuracy)
+{
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::magnitude(x, y, dst_gold);
+ cv::multiply(dst_gold, dst_gold, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Magnitude, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Phase
+
+namespace
+{
+ IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)
+}
+
+PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool angleInDegrees;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ angleInDegrees = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Phase, Accuracy)
+{
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
+
+ cv::Mat dst_gold;
+ cv::phase(x, y, dst_gold, angleInDegrees);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Phase, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// CartToPolar
+
+PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool angleInDegrees;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ angleInDegrees = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(CartToPolar, Accuracy)
+{
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
+
+ cv::Mat mag_gold;
+ cv::Mat angle_gold;
+ cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
+
+ EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
+ EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, CartToPolar, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// polarToCart
+
+PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool angleInDegrees;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ angleInDegrees = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(PolarToCart, Accuracy)
+{
+ cv::Mat magnitude = randomMat(size, CV_32FC1);
+ cv::Mat angle = randomMat(size, CV_32FC1);
+
+ cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
+
+ cv::Mat x_gold;
+ cv::Mat y_gold;
+ cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
+
+ EXPECT_MAT_NEAR(x_gold, x, 1e-4);
+ EXPECT_MAT_NEAR(y_gold, y, 1e-4);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, PolarToCart, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
+ WHOLE_SUBMAT));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// Threshold
+
+CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
+#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))
+
+PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int type;
+ int threshOp;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ type = GET_PARAM(2);
+ threshOp = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Threshold, Accuracy)
+{
+ cv::Mat src = randomMat(size, type);
+ double maxVal = randomDouble(20.0, 127.0);
+ double thresh = randomDouble(0.0, maxVal);
+
+ cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
+
+ cv::Mat dst_gold;
+ cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Threshold, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
+ ALL_THRESH_OPS,
+ WHOLE_SUBMAT));
+
+#endif // HAVE_CUDA
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+using namespace cvtest;
+
+////////////////////////////////////////////////////////////////////////////////
+// Norm
+
+PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ int normCode;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ normCode = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(Norm, Accuracy)
+{
+ cv::Mat src = randomMat(size, depth);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+
+ cv::gpu::GpuMat d_buf;
+ double val = cv::gpu::norm(loadMat(src, useRoi), normCode, loadMat(mask, useRoi), d_buf);
+
+ double val_gold = cv::norm(src, normCode, mask);
+
+ EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Norm, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_8S),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32S),
+ MatDepth(CV_32F)),
+ testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// normDiff
+
+PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int normCode;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ normCode = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(NormDiff, Accuracy)
+{
+ cv::Mat src1 = randomMat(size, CV_8UC1);
+ cv::Mat src2 = randomMat(size, CV_8UC1);
+
+ double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
+
+ double val_gold = cv::norm(src1, src2, normCode);
+
+ EXPECT_NEAR(val_gold, val, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, NormDiff, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// Sum
+
+namespace
+{
+ template <typename T>
+ cv::Scalar absSumImpl(const cv::Mat& src)
+ {
+ const int cn = src.channels();
+
+ cv::Scalar sum = cv::Scalar::all(0);
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ {
+ for (int c = 0; c < cn; ++c)
+ sum[c] += std::abs(src.at<T>(y, x * cn + c));
+ }
+ }
+
+ return sum;
+ }
+
+ cv::Scalar absSumGold(const cv::Mat& src)
+ {
+ typedef cv::Scalar (*func_t)(const cv::Mat& src);
+
+ static const func_t funcs[] =
+ {
+ absSumImpl<uchar>,
+ absSumImpl<schar>,
+ absSumImpl<ushort>,
+ absSumImpl<short>,
+ absSumImpl<int>,
+ absSumImpl<float>,
+ absSumImpl<double>
+ };
+
+ return funcs[src.depth()](src);
+ }
+
+ template <typename T>
+ cv::Scalar sqrSumImpl(const cv::Mat& src)
+ {
+ const int cn = src.channels();
+
+ cv::Scalar sum = cv::Scalar::all(0);
+
+ for (int y = 0; y < src.rows; ++y)
+ {
+ for (int x = 0; x < src.cols; ++x)
+ {
+ for (int c = 0; c < cn; ++c)
+ {
+ const T val = src.at<T>(y, x * cn + c);
+ sum[c] += val * val;
+ }
+ }
+ }
+
+ return sum;
+ }
+
+ cv::Scalar sqrSumGold(const cv::Mat& src)
+ {
+ typedef cv::Scalar (*func_t)(const cv::Mat& src);
+
+ static const func_t funcs[] =
+ {
+ sqrSumImpl<uchar>,
+ sqrSumImpl<schar>,
+ sqrSumImpl<ushort>,
+ sqrSumImpl<short>,
+ sqrSumImpl<int>,
+ sqrSumImpl<float>,
+ sqrSumImpl<double>
+ };
+
+ return funcs[src.depth()](src);
+ }
+}
+
+PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int type;
+ bool useRoi;
+
+ cv::Mat src;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ type = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ src = randomMat(size, type, -128.0, 128.0);
+ }
+};
+
+GPU_TEST_P(Sum, Simple)
+{
+ cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
+
+ cv::Scalar val_gold = cv::sum(src);
+
+ EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+}
+
+GPU_TEST_P(Sum, Abs)
+{
+ cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
+
+ cv::Scalar val_gold = absSumGold(src);
+
+ EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+}
+
+GPU_TEST_P(Sum, Sqr)
+{
+ cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
+
+ cv::Scalar val_gold = sqrSumGold(src);
+
+ EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sum, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ TYPES(CV_8U, CV_64F, 1, 4),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// MinMax
+
+PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(MinMax, WithoutMask)
+{
+ cv::Mat src = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
+
+ double minVal_gold, maxVal_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+ }
+}
+
+GPU_TEST_P(MinMax, WithMask)
+{
+ cv::Mat src = randomMat(size, depth);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
+
+ double minVal_gold, maxVal_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+ }
+}
+
+GPU_TEST_P(MinMax, NullPtr)
+{
+ cv::Mat src = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src), &minVal, 0);
+ cv::gpu::minMax(loadMat(src), 0, &maxVal);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
+ cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
+
+ double minVal_gold, maxVal_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMax, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// MinMaxLoc
+
+namespace
+{
+ template <typename T>
+ void expectEqualImpl(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
+ {
+ EXPECT_EQ(src.at<T>(loc_gold.y, loc_gold.x), src.at<T>(loc.y, loc.x));
+ }
+
+ void expectEqual(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
+ {
+ typedef void (*func_t)(const cv::Mat& src, cv::Point loc_gold, cv::Point loc);
+
+ static const func_t funcs[] =
+ {
+ expectEqualImpl<uchar>,
+ expectEqualImpl<schar>,
+ expectEqualImpl<ushort>,
+ expectEqualImpl<short>,
+ expectEqualImpl<int>,
+ expectEqualImpl<float>,
+ expectEqualImpl<double>
+ };
+
+ funcs[src.depth()](src, loc_gold, loc);
+ }
+}
+
+PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(MinMaxLoc, WithoutMask)
+{
+ cv::Mat src = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
+
+ double minVal_gold, maxVal_gold;
+ cv::Point minLoc_gold, maxLoc_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+ expectEqual(src, minLoc_gold, minLoc);
+ expectEqual(src, maxLoc_gold, maxLoc);
+ }
+}
+
+GPU_TEST_P(MinMaxLoc, WithMask)
+{
+ cv::Mat src = randomMat(size, depth);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
+
+ double minVal_gold, maxVal_gold;
+ cv::Point minLoc_gold, maxLoc_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+ expectEqual(src, minLoc_gold, minLoc);
+ expectEqual(src, maxLoc_gold, maxLoc);
+ }
+}
+
+GPU_TEST_P(MinMaxLoc, NullPtr)
+{
+ cv::Mat src = randomMat(size, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
+
+ double minVal_gold, maxVal_gold;
+ cv::Point minLoc_gold, maxLoc_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+ expectEqual(src, minLoc_gold, minLoc);
+ expectEqual(src, maxLoc_gold, maxLoc);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMaxLoc, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////
+// CountNonZero
+
+PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ bool useRoi;
+
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ useRoi = GET_PARAM(3);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(CountNonZero, Accuracy)
+{
+ cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
+ cv::Mat src;
+ srcBase.convertTo(src, depth);
+
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
+ {
+ cv::gpu::countNonZero(loadMat(src));
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ int val = cv::gpu::countNonZero(loadMat(src, useRoi));
+
+ int val_gold = cv::countNonZero(src);
+
+ ASSERT_EQ(val_gold, val);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, CountNonZero, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// Reduce
+
+CV_ENUM(ReduceCode, cv::REDUCE_SUM, cv::REDUCE_AVG, cv::REDUCE_MAX, cv::REDUCE_MIN)
+#define ALL_REDUCE_CODES testing::Values(ReduceCode(cv::REDUCE_SUM), ReduceCode(cv::REDUCE_AVG), ReduceCode(cv::REDUCE_MAX), ReduceCode(cv::REDUCE_MIN))
+
+PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int depth;
+ int channels;
+ int reduceOp;
+ bool useRoi;
+
+ int type;
+ int dst_depth;
+ int dst_type;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ depth = GET_PARAM(2);
+ channels = GET_PARAM(3);
+ reduceOp = GET_PARAM(4);
+ useRoi = GET_PARAM(5);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ type = CV_MAKE_TYPE(depth, channels);
+
+ if (reduceOp == cv::REDUCE_MAX || reduceOp == cv::REDUCE_MIN)
+ dst_depth = depth;
+ else if (reduceOp == cv::REDUCE_SUM)
+ dst_depth = depth == CV_8U ? CV_32S : depth < CV_64F ? CV_32F : depth;
+ else
+ dst_depth = depth < CV_32F ? CV_32F : depth;
+
+ dst_type = CV_MAKE_TYPE(dst_depth, channels);
+ }
+
+};
+
+GPU_TEST_P(Reduce, Rows)
+{
+ cv::Mat src = randomMat(size, type);
+
+ cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
+ cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
+
+ cv::Mat dst_gold;
+ cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+}
+
+GPU_TEST_P(Reduce, Cols)
+{
+ cv::Mat src = randomMat(size, type);
+
+ cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
+ cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
+
+ cv::Mat dst_gold;
+ cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
+ dst_gold.cols = dst_gold.rows;
+ dst_gold.rows = 1;
+ dst_gold.step = dst_gold.cols * dst_gold.elemSize();
+
+ EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Reduce, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ testing::Values(MatDepth(CV_8U),
+ MatDepth(CV_16U),
+ MatDepth(CV_16S),
+ MatDepth(CV_32F),
+ MatDepth(CV_64F)),
+ ALL_CHANNELS,
+ ALL_REDUCE_CODES,
+ WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////////////////////////////
+// Normalize
+
+PARAM_TEST_CASE(Normalize, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ int type;
+ int norm_type;
+ bool useRoi;
+
+ double alpha;
+ double beta;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ type = GET_PARAM(2);
+ norm_type = GET_PARAM(3);
+ useRoi = GET_PARAM(4);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+
+ alpha = 1;
+ beta = 0;
+ }
+
+};
+
+GPU_TEST_P(Normalize, WithOutMask)
+{
+ cv::Mat src = randomMat(size, type);
+
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::normalize(loadMat(src, useRoi), dst, alpha, beta, norm_type, type);
+
+ cv::Mat dst_gold;
+ cv::normalize(src, dst_gold, alpha, beta, norm_type, type);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
+}
+
+GPU_TEST_P(Normalize, WithMask)
+{
+ cv::Mat src = randomMat(size, type);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::normalize(loadMat(src, useRoi), dst, alpha, beta, norm_type, type, loadMat(mask, useRoi));
+
+ cv::Mat dst_gold(size, type);
+ dst_gold.setTo(cv::Scalar::all(0));
+ cv::normalize(src, dst_gold, alpha, beta, norm_type, type, mask);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, Normalize, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ ALL_DEPTH,
+ testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF), NormCode(cv::NORM_MINMAX)),
+ WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// MeanStdDev
+
+PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
+{
+ cv::gpu::DeviceInfo devInfo;
+ cv::Size size;
+ bool useRoi;
+
+ virtual void SetUp()
+ {
+ devInfo = GET_PARAM(0);
+ size = GET_PARAM(1);
+ useRoi = GET_PARAM(2);
+
+ cv::gpu::setDevice(devInfo.deviceID());
+ }
+};
+
+GPU_TEST_P(MeanStdDev, Accuracy)
+{
+ cv::Mat src = randomMat(size, CV_8UC1);
+
+ if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+ {
+ try
+ {
+ cv::Scalar mean;
+ cv::Scalar stddev;
+ cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
+ }
+ }
+ else
+ {
+ cv::Scalar mean;
+ cv::Scalar stddev;
+ cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+
+ cv::Scalar mean_gold;
+ cv::Scalar stddev_gold;
+ cv::meanStdDev(src, mean_gold, stddev_gold);
+
+ EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
+ EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Arithm, MeanStdDev, testing::Combine(
+ ALL_DEVICES,
+ DIFFERENT_SIZES,
+ WHOLE_SUBMAT));
+
+#endif // HAVE_CUDA
projects / platform / upstream / opencv.git / commitdiff