gpuarithm module fixes
This commit is contained in:
Vladislav Vinogradov
439
modules/gpuarithm/test/test_arithm.cpp
Normal file
439
modules/gpuarithm/test/test_arithm.cpp
Normal file
@@ -0,0 +1,439 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
|
||||
#ifdef HAVE_CUDA
|
||||
|
||||
using namespace cvtest;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// GEMM
|
||||
|
||||
#ifdef HAVE_CUBLAS
|
||||
|
||||
CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
|
||||
#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
|
||||
|
||||
PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int type;
|
||||
int flags;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
type = GET_PARAM(2);
|
||||
flags = GET_PARAM(3);
|
||||
useRoi = GET_PARAM(4);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(GEMM, Accuracy)
|
||||
{
|
||||
cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
|
||||
cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
|
||||
cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
|
||||
double alpha = randomDouble(-10.0, 10.0);
|
||||
double beta = randomDouble(-10.0, 10.0);
|
||||
|
||||
if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
cv::gpu::GpuMat dst;
|
||||
cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else if (type == CV_64FC2 && flags != 0)
|
||||
{
|
||||
try
|
||||
{
|
||||
cv::gpu::GpuMat dst;
|
||||
cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
|
||||
cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
|
||||
|
||||
cv::Mat dst_gold;
|
||||
cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
|
||||
|
||||
EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, GEMM, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
testing::Values(MatType(CV_32FC1), MatType(CV_32FC2), MatType(CV_64FC1), MatType(CV_64FC2)),
|
||||
ALL_GEMM_FLAGS,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Integral
|
||||
|
||||
PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
useRoi = GET_PARAM(2);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(Integral, Accuracy)
|
||||
{
|
||||
cv::Mat src = randomMat(size, CV_8UC1);
|
||||
|
||||
cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
|
||||
cv::gpu::integral(loadMat(src, useRoi), dst);
|
||||
|
||||
cv::Mat dst_gold;
|
||||
cv::integral(src, dst_gold, CV_32S);
|
||||
|
||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Integral, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// MulSpectrums
|
||||
|
||||
CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
|
||||
|
||||
PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int flag;
|
||||
|
||||
cv::Mat a, b;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
flag = GET_PARAM(2);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
|
||||
a = randomMat(size, CV_32FC2);
|
||||
b = randomMat(size, CV_32FC2);
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(MulSpectrums, Simple)
|
||||
{
|
||||
cv::gpu::GpuMat c;
|
||||
cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
|
||||
|
||||
cv::Mat c_gold;
|
||||
cv::mulSpectrums(a, b, c_gold, flag, false);
|
||||
|
||||
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
|
||||
}
|
||||
|
||||
GPU_TEST_P(MulSpectrums, Scaled)
|
||||
{
|
||||
float scale = 1.f / size.area();
|
||||
|
||||
cv::gpu::GpuMat c;
|
||||
cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
|
||||
|
||||
cv::Mat c_gold;
|
||||
cv::mulSpectrums(a, b, c_gold, flag, false);
|
||||
c_gold.convertTo(c_gold, c_gold.type(), scale);
|
||||
|
||||
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MulSpectrums, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Dft
|
||||
|
||||
struct Dft : testing::TestWithParam<cv::gpu::DeviceInfo>
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GetParam();
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
namespace
|
||||
{
|
||||
void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)
|
||||
{
|
||||
SCOPED_TRACE(hint);
|
||||
|
||||
cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC2, 0.0, 10.0);
|
||||
|
||||
cv::Mat b_gold;
|
||||
cv::dft(a, b_gold, flags);
|
||||
|
||||
cv::gpu::GpuMat d_b;
|
||||
cv::gpu::GpuMat d_b_data;
|
||||
if (inplace)
|
||||
{
|
||||
d_b_data.create(1, a.size().area(), CV_32FC2);
|
||||
d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
|
||||
}
|
||||
cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), flags);
|
||||
|
||||
EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
|
||||
ASSERT_EQ(CV_32F, d_b.depth());
|
||||
ASSERT_EQ(2, d_b.channels());
|
||||
EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);
|
||||
}
|
||||
}
|
||||
|
||||
GPU_TEST_P(Dft, C2C)
|
||||
{
|
||||
int cols = randomInt(2, 100);
|
||||
int rows = randomInt(2, 100);
|
||||
|
||||
for (int i = 0; i < 2; ++i)
|
||||
{
|
||||
bool inplace = i != 0;
|
||||
|
||||
testC2C("no flags", cols, rows, 0, inplace);
|
||||
testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
|
||||
testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
|
||||
testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
|
||||
testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
|
||||
testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
|
||||
testC2C("single col", 1, rows, 0, inplace);
|
||||
testC2C("single row", cols, 1, 0, inplace);
|
||||
testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
|
||||
testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
|
||||
testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
|
||||
testC2C("size 1 2", 1, 2, 0, inplace);
|
||||
testC2C("size 2 1", 2, 1, 0, inplace);
|
||||
}
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
|
||||
{
|
||||
SCOPED_TRACE(hint);
|
||||
|
||||
cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC1, 0.0, 10.0);
|
||||
|
||||
cv::gpu::GpuMat d_b, d_c;
|
||||
cv::gpu::GpuMat d_b_data, d_c_data;
|
||||
if (inplace)
|
||||
{
|
||||
if (a.cols == 1)
|
||||
{
|
||||
d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
|
||||
d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
|
||||
}
|
||||
else
|
||||
{
|
||||
d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
|
||||
d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
|
||||
}
|
||||
d_c_data.create(1, a.size().area(), CV_32F);
|
||||
d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
|
||||
}
|
||||
|
||||
cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), 0);
|
||||
cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
|
||||
|
||||
EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
|
||||
EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());
|
||||
ASSERT_EQ(CV_32F, d_c.depth());
|
||||
ASSERT_EQ(1, d_c.channels());
|
||||
|
||||
cv::Mat c(d_c);
|
||||
EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);
|
||||
}
|
||||
}
|
||||
|
||||
GPU_TEST_P(Dft, R2CThenC2R)
|
||||
{
|
||||
int cols = randomInt(2, 100);
|
||||
int rows = randomInt(2, 100);
|
||||
|
||||
testR2CThenC2R("sanity", cols, rows, false);
|
||||
testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
|
||||
testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
|
||||
testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
|
||||
testR2CThenC2R("single col", 1, rows, false);
|
||||
testR2CThenC2R("single col 1", 1, rows + 1, false);
|
||||
testR2CThenC2R("single row", cols, 1, false);
|
||||
testR2CThenC2R("single row 1", cols + 1, 1, false);
|
||||
|
||||
testR2CThenC2R("sanity", cols, rows, true);
|
||||
testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
|
||||
testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
|
||||
testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
|
||||
testR2CThenC2R("single row", cols, 1, true);
|
||||
testR2CThenC2R("single row 1", cols + 1, 1, true);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Dft, ALL_DEVICES);
|
||||
|
||||
////////////////////////////////////////////////////////
|
||||
// Convolve
|
||||
|
||||
namespace
|
||||
{
|
||||
void convolveDFT(const cv::Mat& A, const cv::Mat& B, cv::Mat& C, bool ccorr = false)
|
||||
{
|
||||
// reallocate the output array if needed
|
||||
C.create(std::abs(A.rows - B.rows) + 1, std::abs(A.cols - B.cols) + 1, A.type());
|
||||
cv::Size dftSize;
|
||||
|
||||
// compute the size of DFT transform
|
||||
dftSize.width = cv::getOptimalDFTSize(A.cols + B.cols - 1);
|
||||
dftSize.height = cv::getOptimalDFTSize(A.rows + B.rows - 1);
|
||||
|
||||
// allocate temporary buffers and initialize them with 0s
|
||||
cv::Mat tempA(dftSize, A.type(), cv::Scalar::all(0));
|
||||
cv::Mat tempB(dftSize, B.type(), cv::Scalar::all(0));
|
||||
|
||||
// copy A and B to the top-left corners of tempA and tempB, respectively
|
||||
cv::Mat roiA(tempA, cv::Rect(0, 0, A.cols, A.rows));
|
||||
A.copyTo(roiA);
|
||||
cv::Mat roiB(tempB, cv::Rect(0, 0, B.cols, B.rows));
|
||||
B.copyTo(roiB);
|
||||
|
||||
// now transform the padded A & B in-place;
|
||||
// use "nonzeroRows" hint for faster processing
|
||||
cv::dft(tempA, tempA, 0, A.rows);
|
||||
cv::dft(tempB, tempB, 0, B.rows);
|
||||
|
||||
// multiply the spectrums;
|
||||
// the function handles packed spectrum representations well
|
||||
cv::mulSpectrums(tempA, tempB, tempA, 0, ccorr);
|
||||
|
||||
// transform the product back from the frequency domain.
|
||||
// Even though all the result rows will be non-zero,
|
||||
// you need only the first C.rows of them, and thus you
|
||||
// pass nonzeroRows == C.rows
|
||||
cv::dft(tempA, tempA, cv::DFT_INVERSE + cv::DFT_SCALE, C.rows);
|
||||
|
||||
// now copy the result back to C.
|
||||
tempA(cv::Rect(0, 0, C.cols, C.rows)).copyTo(C);
|
||||
}
|
||||
|
||||
IMPLEMENT_PARAM_CLASS(KSize, int)
|
||||
IMPLEMENT_PARAM_CLASS(Ccorr, bool)
|
||||
}
|
||||
|
||||
PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int ksize;
|
||||
bool ccorr;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
ksize = GET_PARAM(2);
|
||||
ccorr = GET_PARAM(3);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(Convolve, Accuracy)
|
||||
{
|
||||
cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
|
||||
cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
|
||||
|
||||
cv::gpu::GpuMat dst;
|
||||
cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
|
||||
|
||||
cv::Mat dst_gold;
|
||||
convolveDFT(src, kernel, dst_gold, ccorr);
|
||||
|
||||
EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Convolve, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
testing::Values(KSize(3), KSize(7), KSize(11), KSize(17), KSize(19), KSize(23), KSize(45)),
|
||||
testing::Values(Ccorr(false), Ccorr(true))));
|
||||
|
||||
#endif // HAVE_CUBLAS
|
||||
|
||||
#endif // HAVE_CUDA
|
||||
File diff suppressed because it is too large
Load Diff
2503
modules/gpuarithm/test/test_element_operations.cpp
Normal file
2503
modules/gpuarithm/test/test_element_operations.cpp
Normal file
File diff suppressed because it is too large
Load Diff
819
modules/gpuarithm/test/test_reductions.cpp
Normal file
819
modules/gpuarithm/test/test_reductions.cpp
Normal file
@@ -0,0 +1,819 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
|
||||
#ifdef HAVE_CUDA
|
||||
|
||||
using namespace cvtest;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Norm
|
||||
|
||||
PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int depth;
|
||||
int normCode;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
depth = GET_PARAM(2);
|
||||
normCode = GET_PARAM(3);
|
||||
useRoi = GET_PARAM(4);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(Norm, Accuracy)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
|
||||
|
||||
cv::gpu::GpuMat d_buf;
|
||||
double val = cv::gpu::norm(loadMat(src, useRoi), normCode, loadMat(mask, useRoi), d_buf);
|
||||
|
||||
double val_gold = cv::norm(src, normCode, mask);
|
||||
|
||||
EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Norm, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
testing::Values(MatDepth(CV_8U),
|
||||
MatDepth(CV_8S),
|
||||
MatDepth(CV_16U),
|
||||
MatDepth(CV_16S),
|
||||
MatDepth(CV_32S),
|
||||
MatDepth(CV_32F)),
|
||||
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// normDiff
|
||||
|
||||
PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int normCode;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
normCode = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(NormDiff, Accuracy)
|
||||
{
|
||||
cv::Mat src1 = randomMat(size, CV_8UC1);
|
||||
cv::Mat src2 = randomMat(size, CV_8UC1);
|
||||
|
||||
double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
|
||||
|
||||
double val_gold = cv::norm(src1, src2, normCode);
|
||||
|
||||
EXPECT_NEAR(val_gold, val, 0.0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, NormDiff, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Sum
|
||||
|
||||
namespace
|
||||
{
|
||||
template <typename T>
|
||||
cv::Scalar absSumImpl(const cv::Mat& src)
|
||||
{
|
||||
const int cn = src.channels();
|
||||
|
||||
cv::Scalar sum = cv::Scalar::all(0);
|
||||
|
||||
for (int y = 0; y < src.rows; ++y)
|
||||
{
|
||||
for (int x = 0; x < src.cols; ++x)
|
||||
{
|
||||
for (int c = 0; c < cn; ++c)
|
||||
sum[c] += std::abs(src.at<T>(y, x * cn + c));
|
||||
}
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
cv::Scalar absSumGold(const cv::Mat& src)
|
||||
{
|
||||
typedef cv::Scalar (*func_t)(const cv::Mat& src);
|
||||
|
||||
static const func_t funcs[] =
|
||||
{
|
||||
absSumImpl<uchar>,
|
||||
absSumImpl<schar>,
|
||||
absSumImpl<ushort>,
|
||||
absSumImpl<short>,
|
||||
absSumImpl<int>,
|
||||
absSumImpl<float>,
|
||||
absSumImpl<double>
|
||||
};
|
||||
|
||||
return funcs[src.depth()](src);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
cv::Scalar sqrSumImpl(const cv::Mat& src)
|
||||
{
|
||||
const int cn = src.channels();
|
||||
|
||||
cv::Scalar sum = cv::Scalar::all(0);
|
||||
|
||||
for (int y = 0; y < src.rows; ++y)
|
||||
{
|
||||
for (int x = 0; x < src.cols; ++x)
|
||||
{
|
||||
for (int c = 0; c < cn; ++c)
|
||||
{
|
||||
const T val = src.at<T>(y, x * cn + c);
|
||||
sum[c] += val * val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
cv::Scalar sqrSumGold(const cv::Mat& src)
|
||||
{
|
||||
typedef cv::Scalar (*func_t)(const cv::Mat& src);
|
||||
|
||||
static const func_t funcs[] =
|
||||
{
|
||||
sqrSumImpl<uchar>,
|
||||
sqrSumImpl<schar>,
|
||||
sqrSumImpl<ushort>,
|
||||
sqrSumImpl<short>,
|
||||
sqrSumImpl<int>,
|
||||
sqrSumImpl<float>,
|
||||
sqrSumImpl<double>
|
||||
};
|
||||
|
||||
return funcs[src.depth()](src);
|
||||
}
|
||||
}
|
||||
|
||||
PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int type;
|
||||
bool useRoi;
|
||||
|
||||
cv::Mat src;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
type = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
|
||||
src = randomMat(size, type, -128.0, 128.0);
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(Sum, Simple)
|
||||
{
|
||||
cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
|
||||
|
||||
cv::Scalar val_gold = cv::sum(src);
|
||||
|
||||
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
||||
}
|
||||
|
||||
GPU_TEST_P(Sum, Abs)
|
||||
{
|
||||
cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
|
||||
|
||||
cv::Scalar val_gold = absSumGold(src);
|
||||
|
||||
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
||||
}
|
||||
|
||||
GPU_TEST_P(Sum, Sqr)
|
||||
{
|
||||
cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
|
||||
|
||||
cv::Scalar val_gold = sqrSumGold(src);
|
||||
|
||||
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sum, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
TYPES(CV_8U, CV_64F, 1, 4),
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// MinMax
|
||||
|
||||
PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int depth;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
depth = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(MinMax, WithoutMask)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
|
||||
|
||||
double minVal_gold, maxVal_gold;
|
||||
minMaxLocGold(src, &minVal_gold, &maxVal_gold);
|
||||
|
||||
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
|
||||
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
|
||||
}
|
||||
}
|
||||
|
||||
GPU_TEST_P(MinMax, WithMask)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
|
||||
|
||||
double minVal_gold, maxVal_gold;
|
||||
minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
|
||||
|
||||
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
|
||||
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
|
||||
}
|
||||
}
|
||||
|
||||
GPU_TEST_P(MinMax, NullPtr)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::gpu::minMax(loadMat(src), &minVal, 0);
|
||||
cv::gpu::minMax(loadMat(src), 0, &maxVal);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
|
||||
cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
|
||||
|
||||
double minVal_gold, maxVal_gold;
|
||||
minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
|
||||
|
||||
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
|
||||
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMax, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
ALL_DEPTH,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// MinMaxLoc
|
||||
|
||||
namespace
|
||||
{
|
||||
template <typename T>
|
||||
void expectEqualImpl(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
|
||||
{
|
||||
EXPECT_EQ(src.at<T>(loc_gold.y, loc_gold.x), src.at<T>(loc.y, loc.x));
|
||||
}
|
||||
|
||||
void expectEqual(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
|
||||
{
|
||||
typedef void (*func_t)(const cv::Mat& src, cv::Point loc_gold, cv::Point loc);
|
||||
|
||||
static const func_t funcs[] =
|
||||
{
|
||||
expectEqualImpl<uchar>,
|
||||
expectEqualImpl<schar>,
|
||||
expectEqualImpl<ushort>,
|
||||
expectEqualImpl<short>,
|
||||
expectEqualImpl<int>,
|
||||
expectEqualImpl<float>,
|
||||
expectEqualImpl<double>
|
||||
};
|
||||
|
||||
funcs[src.depth()](src, loc_gold, loc);
|
||||
}
|
||||
}
|
||||
|
||||
PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int depth;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
depth = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(MinMaxLoc, WithoutMask)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::Point minLoc, maxLoc;
|
||||
cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::Point minLoc, maxLoc;
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
|
||||
|
||||
double minVal_gold, maxVal_gold;
|
||||
cv::Point minLoc_gold, maxLoc_gold;
|
||||
minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
|
||||
|
||||
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
|
||||
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
|
||||
|
||||
expectEqual(src, minLoc_gold, minLoc);
|
||||
expectEqual(src, maxLoc_gold, maxLoc);
|
||||
}
|
||||
}
|
||||
|
||||
GPU_TEST_P(MinMaxLoc, WithMask)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::Point minLoc, maxLoc;
|
||||
cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::Point minLoc, maxLoc;
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
|
||||
|
||||
double minVal_gold, maxVal_gold;
|
||||
cv::Point minLoc_gold, maxLoc_gold;
|
||||
minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
|
||||
|
||||
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
|
||||
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
|
||||
|
||||
expectEqual(src, minLoc_gold, minLoc);
|
||||
expectEqual(src, maxLoc_gold, maxLoc);
|
||||
}
|
||||
}
|
||||
|
||||
GPU_TEST_P(MinMaxLoc, NullPtr)
|
||||
{
|
||||
cv::Mat src = randomMat(size, depth);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::Point minLoc, maxLoc;
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double minVal, maxVal;
|
||||
cv::Point minLoc, maxLoc;
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
|
||||
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
|
||||
|
||||
double minVal_gold, maxVal_gold;
|
||||
cv::Point minLoc_gold, maxLoc_gold;
|
||||
minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
|
||||
|
||||
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
|
||||
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
|
||||
|
||||
expectEqual(src, minLoc_gold, minLoc);
|
||||
expectEqual(src, maxLoc_gold, maxLoc);
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMaxLoc, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
ALL_DEPTH,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// CountNonZero
|
||||
|
||||
PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int depth;
|
||||
bool useRoi;
|
||||
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
depth = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(CountNonZero, Accuracy)
|
||||
{
|
||||
cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
|
||||
cv::Mat src;
|
||||
srcBase.convertTo(src, depth);
|
||||
|
||||
if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
|
||||
{
|
||||
try
|
||||
{
|
||||
cv::gpu::countNonZero(loadMat(src));
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int val = cv::gpu::countNonZero(loadMat(src, useRoi));
|
||||
|
||||
int val_gold = cv::countNonZero(src);
|
||||
|
||||
ASSERT_EQ(val_gold, val);
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, CountNonZero, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
ALL_DEPTH,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Reduce
|
||||
|
||||
CV_ENUM(ReduceCode, cv::REDUCE_SUM, cv::REDUCE_AVG, cv::REDUCE_MAX, cv::REDUCE_MIN)
|
||||
#define ALL_REDUCE_CODES testing::Values(ReduceCode(cv::REDUCE_SUM), ReduceCode(cv::REDUCE_AVG), ReduceCode(cv::REDUCE_MAX), ReduceCode(cv::REDUCE_MIN))
|
||||
|
||||
PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int depth;
|
||||
int channels;
|
||||
int reduceOp;
|
||||
bool useRoi;
|
||||
|
||||
int type;
|
||||
int dst_depth;
|
||||
int dst_type;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
depth = GET_PARAM(2);
|
||||
channels = GET_PARAM(3);
|
||||
reduceOp = GET_PARAM(4);
|
||||
useRoi = GET_PARAM(5);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
|
||||
type = CV_MAKE_TYPE(depth, channels);
|
||||
|
||||
if (reduceOp == cv::REDUCE_MAX || reduceOp == cv::REDUCE_MIN)
|
||||
dst_depth = depth;
|
||||
else if (reduceOp == cv::REDUCE_SUM)
|
||||
dst_depth = depth == CV_8U ? CV_32S : depth < CV_64F ? CV_32F : depth;
|
||||
else
|
||||
dst_depth = depth < CV_32F ? CV_32F : depth;
|
||||
|
||||
dst_type = CV_MAKE_TYPE(dst_depth, channels);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
GPU_TEST_P(Reduce, Rows)
|
||||
{
|
||||
cv::Mat src = randomMat(size, type);
|
||||
|
||||
cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
|
||||
cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
|
||||
|
||||
cv::Mat dst_gold;
|
||||
cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
|
||||
|
||||
EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
|
||||
}
|
||||
|
||||
GPU_TEST_P(Reduce, Cols)
|
||||
{
|
||||
cv::Mat src = randomMat(size, type);
|
||||
|
||||
cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
|
||||
cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
|
||||
|
||||
cv::Mat dst_gold;
|
||||
cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
|
||||
dst_gold.cols = dst_gold.rows;
|
||||
dst_gold.rows = 1;
|
||||
dst_gold.step = dst_gold.cols * dst_gold.elemSize();
|
||||
|
||||
EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Reduce, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
testing::Values(MatDepth(CV_8U),
|
||||
MatDepth(CV_16U),
|
||||
MatDepth(CV_16S),
|
||||
MatDepth(CV_32F),
|
||||
MatDepth(CV_64F)),
|
||||
ALL_CHANNELS,
|
||||
ALL_REDUCE_CODES,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// Normalize
|
||||
|
||||
PARAM_TEST_CASE(Normalize, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
int type;
|
||||
int norm_type;
|
||||
bool useRoi;
|
||||
|
||||
double alpha;
|
||||
double beta;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
type = GET_PARAM(2);
|
||||
norm_type = GET_PARAM(3);
|
||||
useRoi = GET_PARAM(4);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
|
||||
alpha = 1;
|
||||
beta = 0;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
GPU_TEST_P(Normalize, WithOutMask)
|
||||
{
|
||||
cv::Mat src = randomMat(size, type);
|
||||
|
||||
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
|
||||
cv::gpu::normalize(loadMat(src, useRoi), dst, alpha, beta, norm_type, type);
|
||||
|
||||
cv::Mat dst_gold;
|
||||
cv::normalize(src, dst_gold, alpha, beta, norm_type, type);
|
||||
|
||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
|
||||
}
|
||||
|
||||
GPU_TEST_P(Normalize, WithMask)
|
||||
{
|
||||
cv::Mat src = randomMat(size, type);
|
||||
cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
|
||||
|
||||
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
|
||||
dst.setTo(cv::Scalar::all(0));
|
||||
cv::gpu::normalize(loadMat(src, useRoi), dst, alpha, beta, norm_type, type, loadMat(mask, useRoi));
|
||||
|
||||
cv::Mat dst_gold(size, type);
|
||||
dst_gold.setTo(cv::Scalar::all(0));
|
||||
cv::normalize(src, dst_gold, alpha, beta, norm_type, type, mask);
|
||||
|
||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Normalize, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
ALL_DEPTH,
|
||||
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF), NormCode(cv::NORM_MINMAX)),
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// MeanStdDev
|
||||
|
||||
PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
cv::Size size;
|
||||
bool useRoi;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GET_PARAM(0);
|
||||
size = GET_PARAM(1);
|
||||
useRoi = GET_PARAM(2);
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
}
|
||||
};
|
||||
|
||||
GPU_TEST_P(MeanStdDev, Accuracy)
|
||||
{
|
||||
cv::Mat src = randomMat(size, CV_8UC1);
|
||||
|
||||
if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
|
||||
{
|
||||
try
|
||||
{
|
||||
cv::Scalar mean;
|
||||
cv::Scalar stddev;
|
||||
cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
|
||||
}
|
||||
catch (const cv::Exception& e)
|
||||
{
|
||||
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cv::Scalar mean;
|
||||
cv::Scalar stddev;
|
||||
cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
|
||||
|
||||
cv::Scalar mean_gold;
|
||||
cv::Scalar stddev_gold;
|
||||
cv::meanStdDev(src, mean_gold, stddev_gold);
|
||||
|
||||
EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
|
||||
EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MeanStdDev, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
DIFFERENT_SIZES,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
#endif // HAVE_CUDA
|
||||
Reference in New Issue
Block a user