moved gpu cvtColor tests to separate file

added more tests for gpu cvtColor
fixed RGB->YUV conversion

modules/gpu/src/opencv2/gpu/device/detail/color_detail.hpp

@@ -147,7 +147,7 @@ namespace cv { namespace gpu { namespace device
     namespace color_detail
     {
         template <int green_bits, int bidx> struct RGB2RGB5x5Converter;
-        template<int bidx> struct RGB2RGB5x5Converter<6, bidx> 
+        template<int bidx> struct RGB2RGB5x5Converter<6, bidx>
         {
             static __device__ __forceinline__ ushort cvt(const uchar3& src)
             {
@@ -161,7 +161,7 @@ namespace cv { namespace gpu { namespace device
                 return (ushort)((b >> 3) | ((g & ~3) << 3) | ((r & ~7) << 8));
             }
         };
-        template<int bidx> struct RGB2RGB5x5Converter<5, bidx> 
+        template<int bidx> struct RGB2RGB5x5Converter<5, bidx>
         {
             static __device__ __forceinline__ ushort cvt(const uchar3& src)
             {
@@ -206,17 +206,17 @@ namespace cv { namespace gpu { namespace device
 
     namespace color_detail
     {
-        template <int green_bits, int bidx> struct RGB5x52RGBConverter;    
+        template <int green_bits, int bidx> struct RGB5x52RGBConverter;
         template <int bidx> struct RGB5x52RGBConverter<5, bidx>
         {
             static __device__ __forceinline__ void cvt(uint src, uchar3& dst)
-            {            
+            {
                 (&dst.x)[bidx] = src << 3;
                 dst.y = (src >> 2) & ~7;
                 (&dst.x)[bidx ^ 2] = (src >> 7) & ~7;
             }
             static __device__ __forceinline__ void cvt(uint src, uint& dst)
-            {   
+            {
                 dst = 0;
 
                 dst |= (0xffu & (src << 3)) << (bidx * 8);
@@ -228,13 +228,13 @@ namespace cv { namespace gpu { namespace device
         template <int bidx> struct RGB5x52RGBConverter<6, bidx>
         {
             static __device__ __forceinline__ void cvt(uint src, uchar3& dst)
-            {            
+            {
                 (&dst.x)[bidx] = src << 3;
                 dst.y = (src >> 3) & ~3;
                 (&dst.x)[bidx ^ 2] = (src >> 8) & ~7;
             }
             static __device__ __forceinline__ void cvt(uint src, uint& dst)
-            {           
+            {
                 dst = 0xffu << 24;
 
                 dst |= (0xffu & (src << 3)) << (bidx * 8);
@@ -284,7 +284,7 @@ namespace cv { namespace gpu { namespace device
             {
                 typename TypeVec<T, dcn>::vec_type dst;
 
-                dst.z = dst.y = dst.x = src;            
+                dst.z = dst.y = dst.x = src;
                 setAlpha(dst, ColorChannel<T>::max());
 
                 return dst;
@@ -318,14 +318,14 @@ namespace cv { namespace gpu { namespace device
     namespace color_detail
     {
         template <int green_bits> struct Gray2RGB5x5Converter;
-        template<> struct Gray2RGB5x5Converter<6> 
+        template<> struct Gray2RGB5x5Converter<6>
         {
             static __device__ __forceinline__ ushort cvt(uint t)
             {
                 return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
             }
         };
-        template<> struct Gray2RGB5x5Converter<5> 
+        template<> struct Gray2RGB5x5Converter<5>
         {
             static __device__ __forceinline__ ushort cvt(uint t)
             {
@@ -358,20 +358,20 @@ namespace cv { namespace gpu { namespace device
     namespace color_detail
     {
         template <int green_bits> struct RGB5x52GrayConverter;
-        template <> struct RGB5x52GrayConverter<6> 
+        template <> struct RGB5x52GrayConverter<6>
         {
             static __device__ __forceinline__ uchar cvt(uint t)
             {
                 return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 3) & 0xfc) * G2Y + ((t >> 8) & 0xf8) * R2Y, yuv_shift);
             }
         };
-        template <> struct RGB5x52GrayConverter<5> 
+        template <> struct RGB5x52GrayConverter<5>
         {
             static __device__ __forceinline__ uchar cvt(uint t)
             {
                 return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 2) & 0xf8) * G2Y + ((t >> 7) & 0xf8) * R2Y, yuv_shift);
             }
-        };   
+        };
 
         template<int green_bits> struct RGB5x52Gray : unary_function<ushort, uchar>
         {
@@ -455,22 +455,7 @@ namespace cv { namespace gpu { namespace device
             dst.y = saturate_cast<T>(Cr);
             dst.z = saturate_cast<T>(Cb);
         }
-        template <int bidx> static __device__ uint RGB2YUVConvert(uint src)
-        {
-            const uint delta = ColorChannel<uchar>::half() * (1 << yuv_shift);
-
-            const uint Y = CV_DESCALE((0xffu & src) * c_RGB2YUVCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YUVCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YUVCoeffs_i[bidx], yuv_shift);
-            const uint Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YUVCoeffs_i[3] + delta, yuv_shift);
-            const uint Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YUVCoeffs_i[4] + delta, yuv_shift);
-
-            uint dst = 0;
-
-            dst |= saturate_cast<uchar>(Y);
-            dst |= saturate_cast<uchar>(Cr) << 8;
-            dst |= saturate_cast<uchar>(Cb) << 16;
 
-            return dst;
-        }
         template <int bidx, typename D> static __device__ __forceinline__ void RGB2YUVConvert(const float* src, D& dst)
         {
             dst.x = src[0] * c_RGB2YUVCoeffs_f[bidx^2] + src[1] * c_RGB2YUVCoeffs_f[1] + src[2] * c_RGB2YUVCoeffs_f[bidx];
@@ -487,13 +472,6 @@ namespace cv { namespace gpu { namespace device
                 return dst;
             }
         };
-        template <int bidx> struct RGB2YUV<uchar, 4, 4, bidx> : unary_function<uint, uint>
-        {
-            __device__ __forceinline__ uint operator ()(uint src) const
-            {
-                return RGB2YUVConvert<bidx>(src);
-            }
-        };
     }
 
 #define OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(name, scn, dcn, bidx) \
@@ -509,7 +487,7 @@ namespace cv { namespace gpu { namespace device
     namespace color_detail
     {
         __constant__ float c_YUV2RGBCoeffs_f[5] = { 2.032f, -0.395f, -0.581f, 1.140f };
-        __constant__ int   c_YUV2RGBCoeffs_i[5] = { 33292, -6472, -9519, 18678 }; 
+        __constant__ int   c_YUV2RGBCoeffs_i[5] = { 33292, -6472, -9519, 18678 };
 
         template <int bidx, typename T, typename D> static __device__ void YUV2RGBConvert(const T& src, D* dst)
         {
@@ -526,10 +504,10 @@ namespace cv { namespace gpu { namespace device
             const int x = 0xff & (src);
             const int y = 0xff & (src >> 8);
             const int z = 0xff & (src >> 16);
-            
-            const uint b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
-            const uint g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
-            const uint r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
+
+            const int b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
+            const int g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
+            const int r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
 
             uint dst = 0xffu << 24;
 
@@ -578,7 +556,7 @@ namespace cv { namespace gpu { namespace device
     };
 
 ///////////////////////////////////// RGB <-> YCrCb //////////////////////////////////////
-    
+
     namespace color_detail
     {
         __constant__ float c_RGB2YCrCbCoeffs_f[5] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
@@ -600,9 +578,9 @@ namespace cv { namespace gpu { namespace device
         {
             const int delta = ColorChannel<uchar>::half() * (1 << yuv_shift);
 
-            const uint Y = CV_DESCALE((0xffu & src) * c_RGB2YCrCbCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YCrCbCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
-            const uint Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
-            const uint Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
+            const int Y = CV_DESCALE((0xffu & src) * c_RGB2YCrCbCoeffs_i[bidx^2] + (0xffu & (src >> 8)) * c_RGB2YCrCbCoeffs_i[1] + (0xffu & (src >> 16)) * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
+            const int Cr = CV_DESCALE(((0xffu & (src >> ((bidx ^ 2) * 8))) - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
+            const int Cb = CV_DESCALE(((0xffu & (src >> (bidx * 8))) - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
 
             uint dst = 0;
 
@@ -667,10 +645,10 @@ namespace cv { namespace gpu { namespace device
             const int x = 0xff & (src);
             const int y = 0xff & (src >> 8);
             const int z = 0xff & (src >> 16);
-            
-            const uint b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
-            const uint g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
-            const uint r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
+
+            const int b = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
+            const int g = x + CV_DESCALE((z - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[2] + (y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
+            const int r = x + CV_DESCALE((y - ColorChannel<uchar>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
 
             uint dst = 0xffu << 24;
 
@@ -897,7 +875,7 @@ namespace cv { namespace gpu { namespace device
             const int b = 0xff & (src >> (bidx * 8));
             const int g = 0xff & (src >> 8);
             const int r = 0xff & (src >> ((bidx ^ 2) * 8));
-            
+
             int h, s, v = b;
             int vmin = b, diff;
             int vr, vg;
@@ -1014,7 +992,7 @@ namespace cv { namespace gpu { namespace device
         template <int bidx, int hr, typename T> static __device__ void HSV2RGBConvert(const T& src, float* dst)
         {
             const float hscale = 6.f / hr;
-            
+
             float h = src.x, s = src.y, v = src.z;
             float b = v, g = v, r = v;
 

modules/gpu/test/test_color.cpp

+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// cvtColor
+
+PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    int depth;
+    bool useRoi;
+
+    cv::Mat img;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        depth = GET_PARAM(2);
+        useRoi = GET_PARAM(3);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        img = randomMat(size, CV_MAKE_TYPE(depth, 3), 0.0, depth == CV_32F ? 1.0 : 255.0);
+    }
+};
+
+TEST_P(CvtColor, BGR2RGB)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2RGBA)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2BGRA)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2RGB)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2RGBA)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2GRAY)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGB2GRAY)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, GRAY2BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, GRAY2BGRA)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2GRAY)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGBA2GRAY)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2BGR565)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, RGB2BGR565)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5652BGR)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5652RGB)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2BGR565)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, RGBA2BGR565)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5652BGRA)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5652RGBA)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, GRAY2BGR565)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5652GRAY)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2BGR555)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, RGB2BGR555)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5552BGR)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5552RGB)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2BGR555)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, RGBA2BGR555)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5552BGRA)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5552RGBA)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, GRAY2BGR555)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR5552GRAY)
+{
+    if (depth != CV_8U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2XYZ)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGB2XYZ)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2XYZ4)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGRA2XYZ4)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, XYZ2BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, XYZ2RGB)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, XYZ42BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, XYZ42BGRA)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2YCrCb)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGB2YCrCb)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2YCrCb4)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGBA2YCrCb4)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, YCrCb2BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YCrCb2RGB)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YCrCb42RGB)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YCrCb42RGBA)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2HSV)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HSV)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HSV4)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGBA2HSV4)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2HLS)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HLS)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HLS4)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGBA2HLS4)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV2BGR)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV2RGB)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV42BGR)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV42BGRA)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS2BGR)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS2RGB)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS42RGB)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS42RGBA)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2HSV_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HSV_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HSV4_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGBA2HSV4_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2HLS_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HLS_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGB2HLS4_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, RGBA2HLS4_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV2BGR_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV2RGB_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV42RGB_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV42RGBA_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS2BGR_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS2RGB_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS42RGB_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS42RGBA_FULL)
+{
+    if (depth == CV_16U)
+        return;
+
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2YUV)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGB2YUV)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YUV2BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YUV42BGR)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YUV42BGRA)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
+
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YUV2RGB)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2YUV4)
+{
+    cv::Mat src = img;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, RGBA2YUV4)
+{
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),
+    WHOLE_SUBMAT));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// swapChannels
+
+PARAM_TEST_CASE(SwapChannels, 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());
+    }
+};
+
+TEST_P(SwapChannels, Accuracy)
+{
+    cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
+    ASSERT_FALSE(src.empty());
+
+    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+
+    const int dstOrder[] = {2, 1, 0, 3};
+    cv::gpu::swapChannels(d_src, dstOrder);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+
+    EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    WHOLE_SUBMAT));

modules/gpu/test/test_imgproc.cpp

@@ -93,1958 +93,6 @@ INSTANTIATE_TEST_CASE_P(ImgProc, Integral, Combine(
                         ALL_DEVICES,
                         WHOLE_SUBMAT));
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// cvtColor
-
-PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, MatType, UseRoi)
-{
-    cv::gpu::DeviceInfo devInfo;
-    int type;
-    bool useRoi;
-
-    cv::Mat img;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        type = GET_PARAM(1);
-        useRoi = GET_PARAM(2);
-
-        cv::gpu::setDevice(devInfo.deviceID());
-
-        cv::Mat imgBase = readImage("stereobm/aloe-L.png");
-        ASSERT_FALSE(imgBase.empty());
-
-        imgBase.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
-    }
-};
-
-TEST_P(CvtColor, BGR2RGB)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR2RGBA)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2RGBA);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR2BGRA)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2BGRA);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGRA2RGB)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGRA2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGRA2BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGRA2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGRA2RGBA)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGRA2RGBA);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR2GRAY)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2GRAY);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGB2GRAY)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2GRAY);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, GRAY2BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_GRAY2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, GRAY2BGRA)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_GRAY2BGRA, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGRA2GRAY)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGRA2GRAY);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGBA2GRAY)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGBA2GRAY);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2BGR565)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2BGR565);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, RGB2BGR565)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2BGR565);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5652BGR)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5652BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5652RGB)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5652RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGRA2BGR565)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGRA2BGR565);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, RGBA2BGR565)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGBA2BGR565);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5652BGRA)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5652BGRA, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5652RGBA)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5652RGBA, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, GRAY2BGR565)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_GRAY2BGR565);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5652GRAY)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5652GRAY);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR2BGR555)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2BGR555);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, RGB2BGR555)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2BGR555);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5552BGR)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5552BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5552RGB)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5552RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGRA2BGR555)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGRA2BGR555);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, RGBA2BGR555)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGBA2BGR555);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5552BGRA)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5552BGRA, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5552RGBA)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5552RGBA, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, GRAY2BGR555)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_GRAY2BGR555);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR5552GRAY)
-{
-    if (type != CV_8U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR5552GRAY);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-TEST_P(CvtColor, BGR2XYZ)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2XYZ);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGB2XYZ)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2XYZ);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2XYZ4)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2XYZ, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGRA2XYZ4)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2XYZ, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, XYZ2BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_XYZ2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, XYZ2RGB)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_XYZ2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, XYZ42BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_XYZ2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, XYZ42BGRA)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_XYZ2BGR, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2YCrCb)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2YCrCb);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGB2YCrCb)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2YCrCb);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2YCrCb4)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2YCrCb, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGBA2YCrCb4)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2YCrCb, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YCrCb2BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YCrCb2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YCrCb2RGB)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YCrCb2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YCrCb42RGB)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YCrCb2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YCrCb42RGBA)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YCrCb2RGB, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2HSV)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2HSV);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HSV)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HSV);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HSV4)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HSV, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGBA2HSV4)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HSV, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, BGR2HLS)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2HLS);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HLS)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HLS);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HLS4)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HLS, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGBA2HLS4)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HLS, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV2BGR)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV2RGB)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV42BGR)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV42BGRA)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2BGR, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS2BGR)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS2RGB)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS42RGB)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS42RGBA)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2RGB, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, BGR2HSV_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2HSV_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HSV_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HSV_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HSV4_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HSV_FULL, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGBA2HSV4_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HSV_FULL, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, BGR2HLS_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2HLS_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HLS_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HLS_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGB2HLS4_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HLS_FULL, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, RGBA2HLS4_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2HLS_FULL, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV2BGR_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2BGR_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV2RGB_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2RGB_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV42RGB_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2RGB_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HSV42RGBA_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HSV2RGB_FULL, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS2BGR_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2BGR_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS2RGB_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2RGB_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS42RGB_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2RGB_FULL);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, HLS42RGBA_FULL)
-{
-    if (type == CV_16U)
-        return;
-
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_HLS2RGB_FULL, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
-}
-
-TEST_P(CvtColor, BGR2YUV)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2YUV);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGB2YUV)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGB);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2YUV);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YUV2BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YUV2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YUV42BGR)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YUV2BGR);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YUV42BGRA)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
-
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), type, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YUV2BGR, 4);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, YUV2RGB)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_YUV2RGB);
-
-    gpuRes.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2YUV4)
-{
-    cv::Mat src = img;
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_BGR2YUV, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-TEST_P(CvtColor, RGBA2YUV4)
-{
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
-
-    cv::Mat dst;
-
-    cv::gpu::GpuMat gpuRes;
-
-    cv::gpu::cvtColor(loadMat(src, useRoi), gpuRes, cv::COLOR_RGB2YUV, 4);
-
-    gpuRes.download(dst);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat channels[4];
-    cv::split(dst, channels);
-    cv::merge(channels, 3, dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, Combine(
-                        ALL_DEVICES,
-                        Values(CV_8U, CV_16U, CV_32F),
-                        WHOLE_SUBMAT));
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// swapChannels
-
-PARAM_TEST_CASE(SwapChannels, cv::gpu::DeviceInfo, UseRoi)
-{
-    cv::gpu::DeviceInfo devInfo;
-    bool useRoi;
-
-    cv::Mat img;
-
-    cv::Mat dst_gold;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        useRoi = GET_PARAM(1);
-
-        cv::gpu::setDevice(devInfo.deviceID());
-
-        cv::Mat imgBase = readImage("stereobm/aloe-L.png");
-        ASSERT_FALSE(imgBase.empty());
-
-        cv::cvtColor(imgBase, img, cv::COLOR_BGR2BGRA);
-
-        cv::cvtColor(img, dst_gold, cv::COLOR_BGRA2RGBA);
-    }
-};
-
-TEST_P(SwapChannels, Accuracy)
-{
-    cv::gpu::GpuMat gpuImage = loadMat(img, useRoi);
-
-    const int dstOrder[] = {2, 1, 0, 3};
-    cv::gpu::swapChannels(gpuImage, dstOrder);
-
-    cv::Mat dst;
-    gpuImage.download(dst);
-
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, Combine(ALL_DEVICES, WHOLE_SUBMAT));
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // histograms