Test code - GpuMatND & Mat interoperability

Author: cognex-nalee

modules/cudev/test/test_nd.cu

@@ -0,0 +1,198 @@
+#include "test_precomp.hpp"
+
+using namespace cv;
+using namespace cv::cuda;
+using namespace cvtest;
+
+using ElemTypes = ::testing::Types<
+    Vec<uchar, 1>, Vec<uchar, 2>, Vec<uchar, 3>, Vec<uchar, 4>, // CV_8U
+    Vec<schar, 1>, Vec<schar, 2>, Vec<schar, 3>, Vec<schar, 4>, // CV_8S
+    Vec<ushort, 1>, Vec<ushort, 2>, Vec<ushort, 3>, Vec<ushort, 4>, // CV_16U
+    Vec<short, 1>, Vec<short, 2>, Vec<short, 3>, Vec<short, 4>, // CV_16S
+    Vec<int, 1>, Vec<int, 2>, Vec<int, 3>, Vec<int, 4>, // CV_32S
+    Vec<float, 1>, Vec<float, 2>, Vec<float, 3>, Vec<float, 4>, // CV_32F
+    Vec<double, 1>, Vec<double, 2>, Vec<double, 3>, Vec<double, 4>, //CV_64F
+    Vec<float16_t, 1>, Vec<float16_t, 2>, Vec<float16_t, 3>, Vec<float16_t, 4> // CV_16F
+>;
+
+template <typename ElemType>
+class GpuMatNDTest : public ::testing::Test
+{
+public:
+    using MatType = Mat_<ElemType>;
+    using CnType = typename Mat_<ElemType>::channel_type;
+    static constexpr int cn = DataType<ElemType>::channels;
+    using SizeArray = GpuMatND::SizeArray;
+
+    static void doTest(const SizeArray& size)
+    {
+        const int dims = static_cast<int>(size.size());
+
+        MatType gold(dims, size.data());
+        MatType dst;
+
+        // init gold with random data
+        for (ElemType& elem : gold)
+            for (int i = 0; i < cn; ++i)
+                elem[i] = static_cast<CnType>(std::rand());
+
+        GpuMatND gmat;
+
+        {
+            // simple upload, download test for GpuMatND
+
+            gmat.upload(gold);
+            gmat.download(dst);
+
+            EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
+        }
+
+        std::vector<Range> ranges;
+        for (int s : size)
+            if (s > 2)
+                ranges.emplace_back(1, s-1);
+            else
+                ranges.push_back(Range::all());
+
+        if (dims == 1)
+        {
+            std::vector<Range> ranges_1dfix = ranges;
+            ranges_1dfix.push_back(Range::all());
+
+            // Mat expects two ranges even in this case
+            ranges = std::move(ranges_1dfix);
+        }
+
+        MatType goldSub = gold(ranges);
+
+        {
+            // upload partial mat, download it, and compare
+
+            gmat.upload(goldSub);
+            gmat.download(dst);
+
+            EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
+        }
+
+        {
+            // upload full mat, extract partial mat from it, download it, and compare
+
+            gmat.upload(gold);
+            gmat = gmat(ranges);
+            gmat.download(dst);
+
+            EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
+        }
+
+        if (std::is_same<CnType, float16_t>::value)
+        {
+            // The rest of the test uses GpuMat::convertTo
+            // but currently it is not implemented for CV_16F
+            return;
+        }
+
+        {
+            // Test GpuMatND to GpuMat conversion:
+
+            // extract a 2D-plane and set its elements in the extracted region to 1
+            // compare the values of the full mat between Mat and GpuMatND
+
+            gmat.upload(gold);
+
+            for (int i = 0; i < dims - 2; ++i)
+                if (size[i] > 1)
+                    ranges[i] = Range(1, 2);
+                else
+                    ranges[i] = Range::all();
+
+            GpuMat plane = gmat(ranges).createGpuMatHeader();
+
+            EXPECT_TRUE(!plane.refcount); // plane points to externally allocated memory(a part of gmat)
+
+            const GpuMat dummy = plane.clone();
+
+            EXPECT_TRUE(dummy.refcount); // dummy is clone()-ed from plane, so it manages its memory
+
+            // currently, plane(GpuMat) points to a sub-matrix of gmat(GpuMatND)
+            // in this case, dummy and plane have same size and type,
+            // so plane does not get reallocated inside convertTo,
+            // so this convertTo sets a sub-matrix region of gmat to 1
+            dummy.convertTo(plane, -1, 0, 1);
+
+            EXPECT_TRUE(!plane.refcount); // plane still points to externally allocated memory(a part of gmat)
+
+            gmat.download(dst);
+
+            // set a sub-matrix region of gold to 1
+            Mat plane_ = gold(ranges);
+            const Mat dummy_ = plane_.clone();
+            dummy_.convertTo(plane_, -1, 0, 1);
+
+            EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
+        }
+
+        {
+            // Test handling external memory
+
+            GpuMatND external(gmat.size, gmat.type(), gmat.getDevicePtr(), {gmat.step.begin(), gmat.step.end() - 1});
+
+            for (int i = 0; i < dims - 2; ++i)
+                ranges[i] = Range(0, 1);
+
+            // set a sub-matrix region of external to 2
+            GpuMat plane = external(ranges).createGpuMatHeader();
+            const GpuMat dummy = plane.clone();
+            dummy.convertTo(plane, -1, 0, 2);
+            external.download(dst);
+
+            // set a sub-matrix region of gold to 2
+            Mat plane_ = gold(ranges);
+            const Mat dummy_ = plane_.clone();
+            dummy_.convertTo(plane_, -1, 0, 2);
+
+            EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
+        }
+
+        {
+            // Upload a sub-mat, add 1 to a sub-region of the sub-mat, download, and compare
+
+            gmat.upload(gold(ranges));
+
+            MatType gold_sub = gold(ranges);
+
+            for (int i = 0; i < dims; ++i)
+                if (gmat.size[i] > 2)
+                    ranges[i] = Range(1, 3);
+                else
+                    ranges[i] = Range::all();
+
+            GpuMat plane = gmat(ranges).createGpuMatHeader();
+            const GpuMat dummy = plane.clone();
+            dummy.convertTo(plane, -1, 1, 1);
+            gmat.download(dst);
+
+            Mat plane_ = gold_sub(ranges);
+            const Mat dummy_ = plane_.clone();
+            dummy_.convertTo(plane_, -1, 1, 1);
+
+            EXPECT_TRUE(std::equal(gold_sub.begin(), gold_sub.end(), dst.begin()));
+        }
+    }
+};
+
+TYPED_TEST_CASE(GpuMatNDTest, ElemTypes);
+
+TYPED_TEST(GpuMatNDTest, Test1)
+{
+    using SizeArray = GpuMatND::SizeArray;
+
+    std::vector<SizeArray> sizes = {
+        SizeArray{1}, SizeArray{1, 1}, SizeArray{1, 1, 1}, SizeArray{1, 1, 1, 1},
+        SizeArray{2}, SizeArray{2, 1}, SizeArray{1, 2}, SizeArray{1, 2, 1}, SizeArray{2, 1, 2}, SizeArray{2, 2, 2},
+        SizeArray{64}, SizeArray{64, 64}, SizeArray{16, 64, 64}, SizeArray{4, 16, 64, 64}, SizeArray{2, 4, 16, 64, 64},
+        SizeArray{129}, SizeArray{127, 129}, SizeArray{1, 127, 129}, SizeArray{3, 1, 127, 129}, SizeArray{7, 3, 1, 127, 129},
+    };
+
+    for (auto& size : sizes)
+        GpuMatNDTest<TypeParam>::doTest(size);
+}