added more assertion on device features to gpu functions and tests

moved TargerArchs and DeviceInfo to core
fixed bug in GpuMat::copy with mask (incorrect index in function tab)

modules/core/include/opencv2/core/gpumat.hpp

@@ -50,6 +50,96 @@
 
 namespace cv { namespace gpu
 {
+    //////////////////////////////// Initialization & Info ////////////////////////
+
+    //! This is the only function that do not throw exceptions if the library is compiled without Cuda.
+    CV_EXPORTS int getCudaEnabledDeviceCount();
+
+    //! Functions below throw cv::Expception if the library is compiled without Cuda.
+
+    CV_EXPORTS void setDevice(int device);
+    CV_EXPORTS int getDevice();
+
+    //! Explicitly destroys and cleans up all resources associated with the current device in the current process.
+    //! Any subsequent API call to this device will reinitialize the device.
+    CV_EXPORTS void resetDevice();
+
+    enum FeatureSet
+    {
+        FEATURE_SET_COMPUTE_10 = 10,
+        FEATURE_SET_COMPUTE_11 = 11,
+        FEATURE_SET_COMPUTE_12 = 12,
+        FEATURE_SET_COMPUTE_13 = 13,
+        FEATURE_SET_COMPUTE_20 = 20,
+        FEATURE_SET_COMPUTE_21 = 21,
+        GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
+        SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
+        NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13
+    };
+
+    // Gives information about what GPU archs this OpenCV GPU module was
+    // compiled for
+    class CV_EXPORTS TargetArchs
+    {
+    public:
+        static bool builtWith(FeatureSet feature_set);
+        static bool has(int major, int minor);
+        static bool hasPtx(int major, int minor);
+        static bool hasBin(int major, int minor);
+        static bool hasEqualOrLessPtx(int major, int minor);
+        static bool hasEqualOrGreater(int major, int minor);
+        static bool hasEqualOrGreaterPtx(int major, int minor);
+        static bool hasEqualOrGreaterBin(int major, int minor);
+    private:
+        TargetArchs();
+    };
+
+    // Gives information about the given GPU
+    class CV_EXPORTS DeviceInfo
+    {
+    public:
+        // Creates DeviceInfo object for the current GPU
+        DeviceInfo() : device_id_(getDevice()) { query(); }
+
+        // Creates DeviceInfo object for the given GPU
+        DeviceInfo(int device_id) : device_id_(device_id) { query(); }
+
+        std::string name() const { return name_; }
+
+        // Return compute capability versions
+        int majorVersion() const { return majorVersion_; }
+        int minorVersion() const { return minorVersion_; }
+
+        int multiProcessorCount() const { return multi_processor_count_; }
+
+        size_t freeMemory() const;
+        size_t totalMemory() const;
+
+        // Checks whether device supports the given feature
+        bool supports(FeatureSet feature_set) const;
+
+        // Checks whether the GPU module can be run on the given device
+        bool isCompatible() const;
+
+        int deviceID() const { return device_id_; }
+
+    private:
+        void query();
+        void queryMemory(size_t& free_memory, size_t& total_memory) const;
+
+        int device_id_;
+
+        std::string name_;
+        int multi_processor_count_;
+        int majorVersion_;
+        int minorVersion_;
+    };
+
+    CV_EXPORTS void printCudaDeviceInfo(int device);
+    CV_EXPORTS void printShortCudaDeviceInfo(int device);
+
+    //////////////////////////////// GpuMat ///////////////////////////////
+
     //! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
     class CV_EXPORTS GpuMat
     {

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -54,94 +54,6 @@
 
 namespace cv { namespace gpu {
 
-//////////////////////////////// Initialization & Info ////////////////////////
-
-//! This is the only function that do not throw exceptions if the library is compiled without Cuda.
-CV_EXPORTS int getCudaEnabledDeviceCount();
-
-//! Functions below throw cv::Expception if the library is compiled without Cuda.
-
-CV_EXPORTS void setDevice(int device);
-CV_EXPORTS int getDevice();
-
-//! Explicitly destroys and cleans up all resources associated with the current device in the current process.
-//! Any subsequent API call to this device will reinitialize the device.
-CV_EXPORTS void resetDevice();
-
-enum FeatureSet
-{
-    FEATURE_SET_COMPUTE_10 = 10,
-    FEATURE_SET_COMPUTE_11 = 11,
-    FEATURE_SET_COMPUTE_12 = 12,
-    FEATURE_SET_COMPUTE_13 = 13,
-    FEATURE_SET_COMPUTE_20 = 20,
-    FEATURE_SET_COMPUTE_21 = 21,
-    GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
-    SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
-    NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13
-};
-
-// Gives information about what GPU archs this OpenCV GPU module was
-// compiled for
-class CV_EXPORTS TargetArchs
-{
-public:
-    static bool builtWith(FeatureSet feature_set);
-    static bool has(int major, int minor);
-    static bool hasPtx(int major, int minor);
-    static bool hasBin(int major, int minor);
-    static bool hasEqualOrLessPtx(int major, int minor);
-    static bool hasEqualOrGreater(int major, int minor);
-    static bool hasEqualOrGreaterPtx(int major, int minor);
-    static bool hasEqualOrGreaterBin(int major, int minor);
-private:
-    TargetArchs();
-};
-
-// Gives information about the given GPU
-class CV_EXPORTS DeviceInfo
-{
-public:
-    // Creates DeviceInfo object for the current GPU
-    DeviceInfo() : device_id_(getDevice()) { query(); }
-
-    // Creates DeviceInfo object for the given GPU
-    DeviceInfo(int device_id) : device_id_(device_id) { query(); }
-
-    std::string name() const { return name_; }
-
-    // Return compute capability versions
-    int majorVersion() const { return majorVersion_; }
-    int minorVersion() const { return minorVersion_; }
-
-    int multiProcessorCount() const { return multi_processor_count_; }
-
-    size_t freeMemory() const;
-    size_t totalMemory() const;
-
-    // Checks whether device supports the given feature
-    bool supports(FeatureSet feature_set) const;
-
-    // Checks whether the GPU module can be run on the given device
-    bool isCompatible() const;
-
-    int deviceID() const { return device_id_; }
-
-private:
-    void query();
-    void queryMemory(size_t& free_memory, size_t& total_memory) const;
-
-    int device_id_;
-
-    std::string name_;
-    int multi_processor_count_;
-    int majorVersion_;
-    int minorVersion_;
-};
-
-CV_EXPORTS void printCudaDeviceInfo(int device);
-CV_EXPORTS void printShortCudaDeviceInfo(int device);
-
 //////////////////////////////// CudaMem ////////////////////////////////
 // CudaMem is limited cv::Mat with page locked memory allocation.
 // Page locked memory is only needed for async and faster coping to GPU.

modules/gpu/src/matrix_reductions.cpp

@@ -118,6 +118,9 @@ void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev, GpuMat
 {
     CV_Assert(src.type() == CV_8UC1);
 
+    if (!TargetArchs::builtWith(FEATURE_SET_COMPUTE_13) || !DeviceInfo().supports(FEATURE_SET_COMPUTE_13))
+        CV_Error(CV_StsNotImplemented, "Not sufficient compute capebility");
+
     NppiSize sz;
     sz.width  = src.cols;
     sz.height = src.rows;

modules/gpu/src/split_merge.cpp

@@ -76,6 +76,12 @@ namespace
         int depth = src[0].depth();
         Size size = src[0].size();
 
+        if (depth == CV_64F)
+        {
+            if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+        }
+
         bool single_channel_only = true;
         int total_channels = 0;
 
@@ -115,6 +121,12 @@ namespace
         int num_channels = src.channels();
         Size size = src.size();
 
+        if (depth == CV_64F)
+        {
+            if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+        }
+
         if (num_channels == 1)
         {
             src.copyTo(dst[0]);

modules/gpu/test/test_core.cpp

@@ -43,6 +43,138 @@
 
 namespace {
 
+////////////////////////////////////////////////////////////////////////////////
+// Merge
+
+PARAM_TEST_CASE(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    int depth;
+    int channels;
+    bool useRoi;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        depth = GET_PARAM(2);
+        channels = GET_PARAM(3);
+        useRoi = GET_PARAM(4);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+TEST_P(Merge, Accuracy)
+{
+    std::vector<cv::Mat> src;
+    src.reserve(channels);
+    for (int i = 0; i < channels; ++i)
+        src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
+
+    std::vector<cv::gpu::GpuMat> d_src;
+    for (int i = 0; i < channels; ++i)
+        d_src.push_back(loadMat(src[i], useRoi));
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat dst;
+            cv::gpu::merge(d_src, dst);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::merge(d_src, dst);
+
+        cv::Mat dst_gold;
+        cv::merge(src, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Core, Merge, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    ALL_DEPTH,
+    testing::Values(1, 2, 3, 4),
+    WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// Split
+
+PARAM_TEST_CASE(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    int depth;
+    int channels;
+    bool useRoi;
+
+    int type;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        depth = GET_PARAM(2);
+        channels = GET_PARAM(3);
+        useRoi = GET_PARAM(4);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        type = CV_MAKE_TYPE(depth, channels);
+    }
+};
+
+TEST_P(Split, Accuracy)
+{
+    cv::Mat src = randomMat(size, type);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            std::vector<cv::gpu::GpuMat> dst;
+            cv::gpu::split(loadMat(src), dst);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        std::vector<cv::gpu::GpuMat> dst;
+        cv::gpu::split(loadMat(src, useRoi), dst);
+
+        std::vector<cv::Mat> dst_gold;
+        cv::split(src, dst_gold);
+
+        ASSERT_EQ(dst_gold.size(), dst.size());
+
+        for (size_t i = 0; i < dst_gold.size(); ++i)
+        {
+            EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
+        }
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Core, Split, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    ALL_DEPTH,
+    testing::Values(1, 2, 3, 4),
+    WHOLE_SUBMAT));
+
 ////////////////////////////////////////////////////////////////////////////////
 // Add_Array
 
@@ -1974,7 +2106,7 @@ TEST_P(AddWeighted, Accuracy)
         cv::Mat dst_gold;
         cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-12);
+        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
     }
 }
 
@@ -2487,6 +2619,21 @@ TEST_P(MeanStdDev, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_8UC1);
 
+    if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+    {
+        try
+        {
+            cv::Scalar mean;
+            cv::Scalar stddev;
+            cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         cv::Scalar mean;
         cv::Scalar stddev;
         cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
@@ -2497,6 +2644,7 @@ TEST_P(MeanStdDev, Accuracy)
 
         EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
         EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, MeanStdDev, testing::Combine(

modules/gpu/test/test_gpumat.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.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other GpuMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or bpied warranties, including, but not limited to, the bpied
+// 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"
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+// SetTo
+
+PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    int type;
+    bool useRoi;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        type = GET_PARAM(2);
+        useRoi = GET_PARAM(3);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+TEST_P(SetTo, Zero)
+{
+    cv::Scalar zero = cv::Scalar::all(0);
+
+    cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+    mat.setTo(zero);
+
+    EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
+}
+
+TEST_P(SetTo, SameVal)
+{
+    cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+            mat.setTo(val);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(val);
+
+        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+    }
+}
+
+TEST_P(SetTo, DifferentVal)
+{
+    cv::Scalar val = randomScalar(0.0, 255.0);
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+            mat.setTo(val);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(val);
+
+        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+    }
+}
+
+TEST_P(SetTo, Masked)
+{
+    cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat mat_gold = randomMat(size, type);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+            mat.setTo(val, loadMat(mask));
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
+        mat.setTo(val, loadMat(mask, useRoi));
+
+        mat_gold.setTo(val, mask);
+
+        EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_GpuMat, SetTo, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    ALL_TYPES,
+    WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// CopyTo
+
+PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    int type;
+    bool useRoi;
+
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        type = GET_PARAM(2);
+        useRoi = GET_PARAM(3);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+TEST_P(CopyTo, WithOutMask)
+{
+    cv::Mat src = randomMat(size, type);
+
+    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    d_src.copyTo(dst);
+
+    EXPECT_MAT_NEAR(src, dst, 0.0);
+}
+
+TEST_P(CopyTo, Masked)
+{
+    cv::Mat src = randomMat(size, type);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
+            d_src.copyTo(dst, loadMat(mask, useRoi));
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
+        d_src.copyTo(dst, loadMat(mask, useRoi));
+
+        cv::Mat dst_gold = cv::Mat::zeros(size, type);
+        src.copyTo(dst_gold, mask);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_GpuMat, CopyTo, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    ALL_TYPES,
+    WHOLE_SUBMAT));
+
+////////////////////////////////////////////////////////////////////////////////
+// ConvertTo
+
+PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    int depth1;
+    int depth2;
+    bool useRoi;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        depth1 = GET_PARAM(2);
+        depth2 = GET_PARAM(3);
+        useRoi = GET_PARAM(4);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+TEST_P(ConvertTo, WithOutScaling)
+{
+    cv::Mat src = randomMat(size, depth1);
+
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
+            d_src.convertTo(dst, depth2);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+        d_src.convertTo(dst, depth2);
+
+        cv::Mat dst_gold;
+        src.convertTo(dst_gold, depth2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+}
+
+TEST_P(ConvertTo, WithScaling)
+{
+    cv::Mat src = randomMat(size, depth1);
+    double a = randomDouble(0.0, 1.0);
+    double b = randomDouble(-10.0, 10.0);
+
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
+            d_src.convertTo(dst, depth2, a, b);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+        d_src.convertTo(dst, depth2, a, b);
+
+        cv::Mat dst_gold;
+        src.convertTo(dst_gold, depth2, a, b);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 0.0 : 1e-4);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    ALL_DEPTH,
+    ALL_DEPTH,
+    WHOLE_SUBMAT));
+
+} // namespace

modules/gpu/test/test_hog.cpp → modules/gpu/test/test_objdetect.cpp

@@ -41,38 +41,31 @@
 
 #include "precomp.hpp"
 
-#ifdef HAVE_CUDA
-
-using namespace cvtest;
-using namespace testing;
+namespace {
 
 //#define DUMP
 
-struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
+struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
 {
-    void run() 
-    {       
-        cv::Mat img_rgb = readImage("hog/road.png");
-        ASSERT_FALSE(img_rgb.empty());
+    cv::gpu::DeviceInfo devInfo;
 
 #ifdef DUMP
-        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        ASSERT_TRUE(f.is_open());
+    std::ofstream f;
 #else
-        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        ASSERT_TRUE(f.is_open());
+    std::ifstream f;
 #endif
 
-        // Test on color image
-        cv::Mat img;
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        test(img);
+    int wins_per_img_x;
+    int wins_per_img_y;
+    int blocks_per_win_x;
+    int blocks_per_win_y;
+    int block_hist_size;
 
-        // Test on gray image
-        cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
-        test(img);
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
 
-        f.close();
+        cv::gpu::setDevice(devInfo.deviceID());
     }
 
 #ifdef DUMP
@@ -80,6 +73,7 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
     {
         f.write((char*)&block_hists.rows, sizeof(block_hists.rows));
         f.write((char*)&block_hists.cols, sizeof(block_hists.cols));
+
         for (int i = 0; i < block_hists.rows; ++i)
         {
             for (int j = 0; j < block_hists.cols; ++j)
@@ -88,8 +82,10 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
                 f.write((char*)&val, sizeof(val));
             }
         }
+
         int nlocations = locations.size();
         f.write((char*)&nlocations, sizeof(nlocations));
+
         for (int i = 0; i < locations.size(); ++i)
             f.write((char*)&locations[i], sizeof(locations[i]));
     }
@@ -97,12 +93,11 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
     void compare(const cv::Mat& block_hists, const std::vector<cv::Point>& locations)
     {
         int rows, cols;
-        int nlocations;
-
         f.read((char*)&rows, sizeof(rows));
         f.read((char*)&cols, sizeof(cols));
         ASSERT_EQ(rows, block_hists.rows);
         ASSERT_EQ(cols, block_hists.cols);
+
         for (int i = 0; i < block_hists.rows; ++i)
         {
             for (int j = 0; j < block_hists.cols; ++j)
@@ -112,8 +107,11 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
                 ASSERT_NEAR(val, block_hists.at<float>(i, j), 1e-3);
             }
         }
+
+        int nlocations;
         f.read((char*)&nlocations, sizeof(nlocations));
         ASSERT_EQ(nlocations, static_cast<int>(locations.size()));
+
         for (int i = 0; i < nlocations; ++i)
         {
             cv::Point location;
@@ -123,22 +121,18 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
     }
 #endif
 
-    void test(const cv::Mat& img) 
+    void testDetect(const cv::Mat& img)
     {
-        cv::gpu::GpuMat d_img(img);
-
         gamma_correction = false;
         setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-        //cpu detector may be updated soon
-        //hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());
 
         std::vector<cv::Point> locations;
 
         // Test detect
-        detect(d_img, locations, 0);
+        detect(loadMat(img), locations, 0);
 
 #ifdef DUMP
-        dump(block_hists, locations);
+        dump(cv::Mat(block_hists), locations);
 #else
         compare(cv::Mat(block_hists), locations);
 #endif
@@ -146,58 +140,66 @@ struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
         // Test detect on smaller image
         cv::Mat img2;
         cv::resize(img, img2, cv::Size(img.cols / 2, img.rows / 2));
-        detect(cv::gpu::GpuMat(img2), locations, 0);
+        detect(loadMat(img2), locations, 0);
 
 #ifdef DUMP
-        dump(block_hists, locations);
+        dump(cv::Mat(block_hists), locations);
 #else
         compare(cv::Mat(block_hists), locations);
 #endif
 
         // Test detect on greater image
         cv::resize(img, img2, cv::Size(img.cols * 2, img.rows * 2));
-        detect(cv::gpu::GpuMat(img2), locations, 0);
+        detect(loadMat(img2), locations, 0);
 
 #ifdef DUMP
-        dump(block_hists, locations);
+        dump(cv::Mat(block_hists), locations);
 #else
         compare(cv::Mat(block_hists), locations);
 #endif
     }
 
-#ifdef DUMP
-    std::ofstream f;
-#else
-    std::ifstream f;
-#endif
+    // Does not compare border value, as interpolation leads to delta
+    void compare_inner_parts(cv::Mat d1, cv::Mat d2)
+    {
+        for (int i = 1; i < blocks_per_win_y - 1; ++i)
+            for (int j = 1; j < blocks_per_win_x - 1; ++j)
+                for (int k = 0; k < block_hist_size; ++k)
+                {
+                    float a = d1.at<float>(0, (i * blocks_per_win_x + j) * block_hist_size);
+                    float b = d2.at<float>(0, (i * blocks_per_win_x + j) * block_hist_size);
+                    ASSERT_FLOAT_EQ(a, b);
+                }
+    }
 };
 
-struct Detect : TestWithParam<cv::gpu::DeviceInfo>
+TEST_P(HOG, Detect)
 {
-    cv::gpu::DeviceInfo devInfo;
+    cv::Mat img_rgb = readImage("hog/road.png");
+    ASSERT_FALSE(img_rgb.empty());
 
-    virtual void SetUp()
-    {
-        devInfo = GetParam();
+#ifdef DUMP
+    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+    ASSERT_TRUE(f.is_open());
+#else
+    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+    ASSERT_TRUE(f.is_open());
+#endif
 
-        cv::gpu::setDevice(devInfo.deviceID());
-    }
-};
+    // Test on color image
+    cv::Mat img;
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    testDetect(img);
 
-TEST_P(Detect, Accuracy)
-{
-    CV_GpuHogDetectTestRunner runner;
-    runner.run();
-}
+    // Test on gray image
+    cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+    testDetect(img);
 
-INSTANTIATE_TEST_CASE_P(HOG, Detect, ALL_DEVICES);
+    f.close();
+}
 
-struct CV_GpuHogGetDescriptorsTestRunner : cv::gpu::HOGDescriptor
+TEST_P(HOG, GetDescriptors)
 {
-    CV_GpuHogGetDescriptorsTestRunner(): cv::gpu::HOGDescriptor(cv::Size(64, 128)) {}
-
-    void run()
-    {
     // Load image (e.g. train data, composed from windows)
     cv::Mat img_rgb = readImage("hog/train_data.png");
     ASSERT_FALSE(img_rgb.empty());
@@ -278,46 +280,8 @@ struct CV_GpuHogGetDescriptorsTestRunner : cv::gpu::HOGDescriptor
     cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
     computeBlockHistograms(cv::gpu::GpuMat(img));
     compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
-    }
-
-    // Does not compare border value, as interpolation leads to delta
-    void compare_inner_parts(cv::Mat d1, cv::Mat d2)
-    {
-        for (int i = 1; i < blocks_per_win_y - 1; ++i)
-            for (int j = 1; j < blocks_per_win_x - 1; ++j)
-                for (int k = 0; k < block_hist_size; ++k)
-                {
-                    float a = d1.at<float>(0, (i * blocks_per_win_x + j) * block_hist_size);
-                    float b = d2.at<float>(0, (i * blocks_per_win_x + j) * block_hist_size);
-                    ASSERT_FLOAT_EQ(a, b);
-                }
-    }
-
-    int wins_per_img_x;
-    int wins_per_img_y;
-    int blocks_per_win_x;
-    int blocks_per_win_y;
-    int block_hist_size;
-};
-
-struct GetDescriptors : TestWithParam<cv::gpu::DeviceInfo>
-{
-    cv::gpu::DeviceInfo devInfo;
-    
-    virtual void SetUp()
-    {
-        devInfo = GetParam();
-
-        cv::gpu::setDevice(devInfo.deviceID());
-    }
-};
-
-TEST_P(GetDescriptors, Accuracy)
-{
-    CV_GpuHogGetDescriptorsTestRunner runner;
-    runner.run();
 }
 
-INSTANTIATE_TEST_CASE_P(HOG, GetDescriptors, ALL_DEVICES);
+INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
 
-#endif // HAVE_CUDA
+} // namespace