Skip to content

O
opencv
Commit 1a76242d authored by Vladislav Vinogradov's avatar Vladislav Vinogradov
Browse files
Options

added GPU_TEST_P macros

parent 4ba33fa1
Expand all Show whitespace changes
Inline Side-by-side
Showing with 302 additions and 336 deletions
modules/gpu/test/nvidia/main_nvidia.cpp
View file @ 1a76242d
...@@ -276,6 +276,8 @@ static void devNullOutput(const std::string& msg) ...@@ -276,6 +276,8 @@ static void devNullOutput(const std::string& msg)
(void)msg; (void)msg;
} }
}
bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel) bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
{ {
path = test_data_path.c_str(); path = test_data_path.c_str();
...@@ -292,8 +294,6 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel ...@@ -292,8 +294,6 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel
return testListerII.invoke(); return testListerII.invoke();
} }
}
bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel) bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
{ {
path = test_data_path; path = test_data_path;
......
modules/gpu/test/test_bgfg.cpp 0 → 100644
View file @ 1a76242d
This diff is collapsed.
modules/gpu/test/test_calib3d.cpp
View file @ 1a76242d
...@@ -43,8 +43,6 @@ ...@@ -43,8 +43,6 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace {
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// StereoBM // StereoBM
...@@ -60,7 +58,7 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -60,7 +58,7 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(StereoBM, Regression) GPU_TEST_P(StereoBM, Regression)
{ {
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE); cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE); cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
...@@ -95,7 +93,7 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -95,7 +93,7 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(StereoBeliefPropagation, Regression) GPU_TEST_P(StereoBeliefPropagation, Regression)
{ {
cv::Mat left_image = readImage("stereobp/aloe-L.png"); cv::Mat left_image = readImage("stereobp/aloe-L.png");
cv::Mat right_image = readImage("stereobp/aloe-R.png"); cv::Mat right_image = readImage("stereobp/aloe-R.png");
...@@ -133,7 +131,7 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -133,7 +131,7 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(StereoConstantSpaceBP, Regression) GPU_TEST_P(StereoConstantSpaceBP, Regression)
{ {
cv::Mat left_image = readImage("csstereobp/aloe-L.png"); cv::Mat left_image = readImage("csstereobp/aloe-L.png");
cv::Mat right_image = readImage("csstereobp/aloe-R.png"); cv::Mat right_image = readImage("csstereobp/aloe-R.png");
...@@ -177,7 +175,7 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -177,7 +175,7 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(TransformPoints, Accuracy) GPU_TEST_P(TransformPoints, Accuracy)
{ {
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10); cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1); cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
...@@ -225,7 +223,7 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -225,7 +223,7 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(ProjectPoints, Accuracy) GPU_TEST_P(ProjectPoints, Accuracy)
{ {
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10); cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1); cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
...@@ -275,7 +273,7 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -275,7 +273,7 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(SolvePnPRansac, Accuracy) GPU_TEST_P(SolvePnPRansac, Accuracy)
{ {
cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100); cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1); cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
...@@ -324,7 +322,7 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use ...@@ -324,7 +322,7 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
} }
}; };
TEST_P(ReprojectImageTo3D, Accuracy) GPU_TEST_P(ReprojectImageTo3D, Accuracy)
{ {
cv::Mat disp = randomMat(size, depth, 5.0, 30.0); cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0); cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
...@@ -344,6 +342,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine( ...@@ -344,6 +342,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
testing::Values(MatDepth(CV_8U), MatDepth(CV_16S)), testing::Values(MatDepth(CV_8U), MatDepth(CV_16S)),
WHOLE_SUBMAT)); WHOLE_SUBMAT));
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_color.cpp
View file @ 1a76242d
This diff is collapsed.
modules/gpu/test/test_copy_make_border.cpp
View file @ 1a76242d
...@@ -43,9 +43,10 @@ ...@@ -43,9 +43,10 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace { namespace
{
IMPLEMENT_PARAM_CLASS(Border, int) IMPLEMENT_PARAM_CLASS(Border, int)
}
PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border, BorderType, UseRoi) PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border, BorderType, UseRoi)
{ {
...@@ -69,7 +70,7 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border, ...@@ -69,7 +70,7 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border,
} }
}; };
TEST_P(CopyMakeBorder, Accuracy) GPU_TEST_P(CopyMakeBorder, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Scalar val = randomScalar(0, 255); cv::Scalar val = randomScalar(0, 255);
...@@ -99,6 +100,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine( ...@@ -99,6 +100,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
ALL_BORDER_TYPES, ALL_BORDER_TYPES,
WHOLE_SUBMAT)); WHOLE_SUBMAT));
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_core.cpp
View file @ 1a76242d
This diff is collapsed.
modules/gpu/test/test_denoising.cpp
View file @ 1a76242d
...@@ -69,7 +69,7 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType) ...@@ -69,7 +69,7 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
} }
}; };
TEST_P(BilateralFilter, Accuracy) GPU_TEST_P(BilateralFilter, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -105,7 +105,7 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -105,7 +105,7 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(BruteForceNonLocalMeans, Regression) GPU_TEST_P(BruteForceNonLocalMeans, Regression)
{ {
using cv::gpu::GpuMat; using cv::gpu::GpuMat;
...@@ -134,8 +134,6 @@ TEST_P(BruteForceNonLocalMeans, Regression) ...@@ -134,8 +134,6 @@ TEST_P(BruteForceNonLocalMeans, Regression)
INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES); INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
// Fast Force Non local means // Fast Force Non local means
...@@ -150,7 +148,7 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -150,7 +148,7 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(FastNonLocalMeans, Regression) GPU_TEST_P(FastNonLocalMeans, Regression)
{ {
using cv::gpu::GpuMat; using cv::gpu::GpuMat;
...@@ -167,8 +165,8 @@ TEST_P(FastNonLocalMeans, Regression) ...@@ -167,8 +165,8 @@ TEST_P(FastNonLocalMeans, Regression)
fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10); fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10);
#if 0 #if 0
//dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr)); dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
//dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray)); dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
#endif #endif
cv::Mat bgr_gold = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR); cv::Mat bgr_gold = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
...@@ -181,5 +179,4 @@ TEST_P(FastNonLocalMeans, Regression) ...@@ -181,5 +179,4 @@ TEST_P(FastNonLocalMeans, Regression)
INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES); INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_features2d.cpp
View file @ 1a76242d
...@@ -43,10 +43,10 @@ ...@@ -43,10 +43,10 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace { namespace
bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
{ {
bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
{
const double maxPtDif = 1.0; const double maxPtDif = 1.0;
const double maxSizeDif = 1.0; const double maxSizeDif = 1.0;
const double maxAngleDif = 2.0; const double maxAngleDif = 2.0;
...@@ -65,18 +65,18 @@ bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2) ...@@ -65,18 +65,18 @@ bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
} }
return false; return false;
} }
struct KeyPointLess : std::binary_function<cv::KeyPoint, cv::KeyPoint, bool> struct KeyPointLess : std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
{ {
bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
{ {
return kp1.pt.y < kp2.pt.y || (kp1.pt.y == kp2.pt.y && kp1.pt.x < kp2.pt.x); return kp1.pt.y < kp2.pt.y || (kp1.pt.y == kp2.pt.y && kp1.pt.x < kp2.pt.x);
} }
}; };
testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual) testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
{ {
if (gold.size() != actual.size()) if (gold.size() != actual.size())
{ {
return testing::AssertionFailure() << "KeyPoints size mistmach\n" return testing::AssertionFailure() << "KeyPoints size mistmach\n"
...@@ -106,12 +106,12 @@ testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char ...@@ -106,12 +106,12 @@ testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char
} }
return ::testing::AssertionSuccess(); return ::testing::AssertionSuccess();
} }
#define ASSERT_KEYPOINTS_EQ(gold, actual) EXPECT_PRED_FORMAT2(assertKeyPointsEquals, gold, actual); #define ASSERT_KEYPOINTS_EQ(gold, actual) EXPECT_PRED_FORMAT2(assertKeyPointsEquals, gold, actual);
int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual) int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
{ {
std::sort(actual.begin(), actual.end(), KeyPointLess()); std::sort(actual.begin(), actual.end(), KeyPointLess());
std::sort(gold.begin(), gold.end(), KeyPointLess()); std::sort(gold.begin(), gold.end(), KeyPointLess());
...@@ -127,10 +127,10 @@ int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPo ...@@ -127,10 +127,10 @@ int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPo
} }
return validCount; return validCount;
} }
int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches) int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches)
{ {
int validCount = 0; int validCount = 0;
for (size_t i = 0; i < matches.size(); ++i) for (size_t i = 0; i < matches.size(); ++i)
...@@ -145,16 +145,20 @@ int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std ...@@ -145,16 +145,20 @@ int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std
} }
return validCount; return validCount;
}
} }
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// SURF // SURF
IMPLEMENT_PARAM_CLASS(SURF_HessianThreshold, double) namespace
IMPLEMENT_PARAM_CLASS(SURF_Octaves, int) {
IMPLEMENT_PARAM_CLASS(SURF_OctaveLayers, int) IMPLEMENT_PARAM_CLASS(SURF_HessianThreshold, double)
IMPLEMENT_PARAM_CLASS(SURF_Extended, bool) IMPLEMENT_PARAM_CLASS(SURF_Octaves, int)
IMPLEMENT_PARAM_CLASS(SURF_Upright, bool) IMPLEMENT_PARAM_CLASS(SURF_OctaveLayers, int)
IMPLEMENT_PARAM_CLASS(SURF_Extended, bool)
IMPLEMENT_PARAM_CLASS(SURF_Upright, bool)
}
PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves, SURF_OctaveLayers, SURF_Extended, SURF_Upright) PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves, SURF_OctaveLayers, SURF_Extended, SURF_Upright)
{ {
...@@ -178,7 +182,7 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves, ...@@ -178,7 +182,7 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
} }
}; };
TEST_P(SURF, Detector) GPU_TEST_P(SURF, Detector)
{ {
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty()); ASSERT_FALSE(image.empty());
...@@ -226,7 +230,7 @@ TEST_P(SURF, Detector) ...@@ -226,7 +230,7 @@ TEST_P(SURF, Detector)
} }
} }
TEST_P(SURF, Detector_Masked) GPU_TEST_P(SURF, Detector_Masked)
{ {
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty()); ASSERT_FALSE(image.empty());
...@@ -277,7 +281,7 @@ TEST_P(SURF, Detector_Masked) ...@@ -277,7 +281,7 @@ TEST_P(SURF, Detector_Masked)
} }
} }
TEST_P(SURF, Descriptor) GPU_TEST_P(SURF, Descriptor)
{ {
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty()); ASSERT_FALSE(image.empty());
...@@ -343,8 +347,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine( ...@@ -343,8 +347,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// FAST // FAST
IMPLEMENT_PARAM_CLASS(FAST_Threshold, int) namespace
IMPLEMENT_PARAM_CLASS(FAST_NonmaxSupression, bool) {
IMPLEMENT_PARAM_CLASS(FAST_Threshold, int)
IMPLEMENT_PARAM_CLASS(FAST_NonmaxSupression, bool)
}
PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression) PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression)
{ {
...@@ -362,7 +369,7 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression ...@@ -362,7 +369,7 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
} }
}; };
TEST_P(FAST, Accuracy) GPU_TEST_P(FAST, Accuracy)
{ {
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty()); ASSERT_FALSE(image.empty());
...@@ -402,14 +409,17 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine( ...@@ -402,14 +409,17 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// ORB // ORB
IMPLEMENT_PARAM_CLASS(ORB_FeaturesCount, int) namespace
IMPLEMENT_PARAM_CLASS(ORB_ScaleFactor, float) {
IMPLEMENT_PARAM_CLASS(ORB_LevelsCount, int) IMPLEMENT_PARAM_CLASS(ORB_FeaturesCount, int)
IMPLEMENT_PARAM_CLASS(ORB_EdgeThreshold, int) IMPLEMENT_PARAM_CLASS(ORB_ScaleFactor, float)
IMPLEMENT_PARAM_CLASS(ORB_firstLevel, int) IMPLEMENT_PARAM_CLASS(ORB_LevelsCount, int)
IMPLEMENT_PARAM_CLASS(ORB_WTA_K, int) IMPLEMENT_PARAM_CLASS(ORB_EdgeThreshold, int)
IMPLEMENT_PARAM_CLASS(ORB_PatchSize, int) IMPLEMENT_PARAM_CLASS(ORB_firstLevel, int)
IMPLEMENT_PARAM_CLASS(ORB_BlurForDescriptor, bool) IMPLEMENT_PARAM_CLASS(ORB_WTA_K, int)
IMPLEMENT_PARAM_CLASS(ORB_PatchSize, int)
IMPLEMENT_PARAM_CLASS(ORB_BlurForDescriptor, bool)
}
CV_ENUM(ORB_ScoreType, cv::ORB::HARRIS_SCORE, cv::ORB::FAST_SCORE) CV_ENUM(ORB_ScoreType, cv::ORB::HARRIS_SCORE, cv::ORB::FAST_SCORE)
...@@ -443,7 +453,7 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR ...@@ -443,7 +453,7 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
} }
}; };
TEST_P(ORB, Accuracy) GPU_TEST_P(ORB, Accuracy)
{ {
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty()); ASSERT_FALSE(image.empty());
...@@ -505,8 +515,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB, testing::Combine( ...@@ -505,8 +515,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB, testing::Combine(
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// BruteForceMatcher // BruteForceMatcher
IMPLEMENT_PARAM_CLASS(DescriptorSize, int) namespace
IMPLEMENT_PARAM_CLASS(UseMask, bool) {
IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
IMPLEMENT_PARAM_CLASS(UseMask, bool)
}
PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize, UseMask) PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize, UseMask)
{ {
...@@ -568,7 +581,7 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize ...@@ -568,7 +581,7 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
} }
}; };
TEST_P(BruteForceMatcher, Match_Single) GPU_TEST_P(BruteForceMatcher, Match_Single)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -595,7 +608,7 @@ TEST_P(BruteForceMatcher, Match_Single) ...@@ -595,7 +608,7 @@ TEST_P(BruteForceMatcher, Match_Single)
ASSERT_EQ(0, badCount); ASSERT_EQ(0, badCount);
} }
TEST_P(BruteForceMatcher, Match_Collection) GPU_TEST_P(BruteForceMatcher, Match_Collection)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -649,7 +662,7 @@ TEST_P(BruteForceMatcher, Match_Collection) ...@@ -649,7 +662,7 @@ TEST_P(BruteForceMatcher, Match_Collection)
ASSERT_EQ(0, badCount); ASSERT_EQ(0, badCount);
} }
TEST_P(BruteForceMatcher, KnnMatch_2_Single) GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -688,7 +701,7 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Single) ...@@ -688,7 +701,7 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Single)
ASSERT_EQ(0, badCount); ASSERT_EQ(0, badCount);
} }
TEST_P(BruteForceMatcher, KnnMatch_3_Single) GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -727,7 +740,7 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Single) ...@@ -727,7 +740,7 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Single)
ASSERT_EQ(0, badCount); ASSERT_EQ(0, badCount);
} }
TEST_P(BruteForceMatcher, KnnMatch_2_Collection) GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -789,7 +802,7 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Collection) ...@@ -789,7 +802,7 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
ASSERT_EQ(0, badCount); ASSERT_EQ(0, badCount);
} }
TEST_P(BruteForceMatcher, KnnMatch_3_Collection) GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -851,7 +864,7 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Collection) ...@@ -851,7 +864,7 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
ASSERT_EQ(0, badCount); ASSERT_EQ(0, badCount);
} }
TEST_P(BruteForceMatcher, RadiusMatch_Single) GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -900,7 +913,7 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single) ...@@ -900,7 +913,7 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single)
} }
} }
TEST_P(BruteForceMatcher, RadiusMatch_Collection) GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
{ {
cv::gpu::BFMatcher_GPU matcher(normCode); cv::gpu::BFMatcher_GPU matcher(normCode);
...@@ -985,6 +998,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine( ...@@ -985,6 +998,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)), testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)),
testing::Values(UseMask(false), UseMask(true)))); testing::Values(UseMask(false), UseMask(true))));
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_filters.cpp
View file @ 1a76242d
...@@ -43,27 +43,30 @@ ...@@ -43,27 +43,30 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace { namespace
IMPLEMENT_PARAM_CLASS(KSize, cv::Size)
cv::Mat getInnerROI(cv::InputArray m_, cv::Size ksize)
{ {
IMPLEMENT_PARAM_CLASS(KSize, cv::Size)
IMPLEMENT_PARAM_CLASS(Anchor, cv::Point)
IMPLEMENT_PARAM_CLASS(Deriv_X, int)
IMPLEMENT_PARAM_CLASS(Deriv_Y, int)
IMPLEMENT_PARAM_CLASS(Iterations, int)
cv::Mat getInnerROI(cv::InputArray m_, cv::Size ksize)
{
cv::Mat m = getMat(m_); cv::Mat m = getMat(m_);
cv::Rect roi(ksize.width, ksize.height, m.cols - 2 * ksize.width, m.rows - 2 * ksize.height); cv::Rect roi(ksize.width, ksize.height, m.cols - 2 * ksize.width, m.rows - 2 * ksize.height);
return m(roi); return m(roi);
} }
cv::Mat getInnerROI(cv::InputArray m, int ksize) cv::Mat getInnerROI(cv::InputArray m, int ksize)
{ {
return getInnerROI(m, cv::Size(ksize, ksize)); return getInnerROI(m, cv::Size(ksize, ksize));
}
} }
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// Blur // Blur
IMPLEMENT_PARAM_CLASS(Anchor, cv::Point)
PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, UseRoi) PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, UseRoi)
{ {
cv::gpu::DeviceInfo devInfo; cv::gpu::DeviceInfo devInfo;
...@@ -86,7 +89,7 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use ...@@ -86,7 +89,7 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
} }
}; };
TEST_P(Blur, Accuracy) GPU_TEST_P(Blur, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -110,9 +113,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine( ...@@ -110,9 +113,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// Sobel // Sobel
IMPLEMENT_PARAM_CLASS(Deriv_X, int)
IMPLEMENT_PARAM_CLASS(Deriv_Y, int)
PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize, Deriv_X, Deriv_Y, BorderType, UseRoi) PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize, Deriv_X, Deriv_Y, BorderType, UseRoi)
{ {
cv::gpu::DeviceInfo devInfo; cv::gpu::DeviceInfo devInfo;
...@@ -145,7 +145,7 @@ PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize, ...@@ -145,7 +145,7 @@ PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize,
} }
}; };
TEST_P(Sobel, Accuracy) GPU_TEST_P(Sobel, Accuracy)
{ {
if (dx == 0 && dy == 0) if (dx == 0 && dy == 0)
return; return;
...@@ -208,7 +208,7 @@ PARAM_TEST_CASE(Scharr, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Deriv ...@@ -208,7 +208,7 @@ PARAM_TEST_CASE(Scharr, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Deriv
} }
}; };
TEST_P(Scharr, Accuracy) GPU_TEST_P(Scharr, Accuracy)
{ {
if (dx + dy != 1) if (dx + dy != 1)
return; return;
...@@ -268,7 +268,7 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ...@@ -268,7 +268,7 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
} }
}; };
TEST_P(GaussianBlur, Accuracy) GPU_TEST_P(GaussianBlur, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
double sigma1 = randomDouble(0.1, 1.0); double sigma1 = randomDouble(0.1, 1.0);
...@@ -347,7 +347,7 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi ...@@ -347,7 +347,7 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
} }
}; };
TEST_P(Laplacian, Accuracy) GPU_TEST_P(Laplacian, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -370,8 +370,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine( ...@@ -370,8 +370,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// Erode // Erode
IMPLEMENT_PARAM_CLASS(Iterations, int)
PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iterations, UseRoi) PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iterations, UseRoi)
{ {
cv::gpu::DeviceInfo devInfo; cv::gpu::DeviceInfo devInfo;
...@@ -394,7 +392,7 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration ...@@ -394,7 +392,7 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
} }
}; };
TEST_P(Erode, Accuracy) GPU_TEST_P(Erode, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
...@@ -443,7 +441,7 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio ...@@ -443,7 +441,7 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
} }
}; };
TEST_P(Dilate, Accuracy) GPU_TEST_P(Dilate, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
...@@ -497,7 +495,7 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor ...@@ -497,7 +495,7 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
} }
}; };
TEST_P(MorphEx, Accuracy) GPU_TEST_P(MorphEx, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
...@@ -551,7 +549,7 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, ...@@ -551,7 +549,7 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
} }
}; };
TEST_P(Filter2D, Accuracy) GPU_TEST_P(Filter2D, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0); cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
...@@ -574,6 +572,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine( ...@@ -574,6 +572,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)),
WHOLE_SUBMAT)); WHOLE_SUBMAT));
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_global_motion.cpp
View file @ 1a76242d
...@@ -51,7 +51,7 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo> ...@@ -51,7 +51,7 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo>
virtual void SetUp() { gpu::setDevice(GetParam().deviceID()); } virtual void SetUp() { gpu::setDevice(GetParam().deviceID()); }
}; };
TEST_P(CompactPoints, CanCompactizeSmallInput) GPU_TEST_P(CompactPoints, CanCompactizeSmallInput)
{ {
Mat src0(1, 3, CV_32FC2); Mat src0(1, 3, CV_32FC2);
src0.at<Point2f>(0,0) = Point2f(0,0); src0.at<Point2f>(0,0) = Point2f(0,0);
......
modules/gpu/test/test_gpumat.cpp
View file @ 1a76242d
...@@ -44,8 +44,6 @@ ...@@ -44,8 +44,6 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// SetTo // SetTo
...@@ -67,7 +65,7 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) ...@@ -67,7 +65,7 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
} }
}; };
TEST_P(SetTo, Zero) GPU_TEST_P(SetTo, Zero)
{ {
cv::Scalar zero = cv::Scalar::all(0); cv::Scalar zero = cv::Scalar::all(0);
...@@ -77,7 +75,7 @@ TEST_P(SetTo, Zero) ...@@ -77,7 +75,7 @@ TEST_P(SetTo, Zero)
EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0); EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
} }
TEST_P(SetTo, SameVal) GPU_TEST_P(SetTo, SameVal)
{ {
cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0)); cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
...@@ -102,7 +100,7 @@ TEST_P(SetTo, SameVal) ...@@ -102,7 +100,7 @@ TEST_P(SetTo, SameVal)
} }
} }
TEST_P(SetTo, DifferentVal) GPU_TEST_P(SetTo, DifferentVal)
{ {
cv::Scalar val = randomScalar(0.0, 255.0); cv::Scalar val = randomScalar(0.0, 255.0);
...@@ -127,7 +125,7 @@ TEST_P(SetTo, DifferentVal) ...@@ -127,7 +125,7 @@ TEST_P(SetTo, DifferentVal)
} }
} }
TEST_P(SetTo, Masked) GPU_TEST_P(SetTo, Masked)
{ {
cv::Scalar val = randomScalar(0.0, 255.0); cv::Scalar val = randomScalar(0.0, 255.0);
cv::Mat mat_gold = randomMat(size, type); cv::Mat mat_gold = randomMat(size, type);
...@@ -184,7 +182,7 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) ...@@ -184,7 +182,7 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
} }
}; };
TEST_P(CopyTo, WithOutMask) GPU_TEST_P(CopyTo, WithOutMask)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -195,7 +193,7 @@ TEST_P(CopyTo, WithOutMask) ...@@ -195,7 +193,7 @@ TEST_P(CopyTo, WithOutMask)
EXPECT_MAT_NEAR(src, dst, 0.0); EXPECT_MAT_NEAR(src, dst, 0.0);
} }
TEST_P(CopyTo, Masked) GPU_TEST_P(CopyTo, Masked)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
...@@ -255,7 +253,7 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us ...@@ -255,7 +253,7 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
} }
}; };
TEST_P(ConvertTo, WithOutScaling) GPU_TEST_P(ConvertTo, WithOutScaling)
{ {
cv::Mat src = randomMat(size, depth1); cv::Mat src = randomMat(size, depth1);
...@@ -285,7 +283,7 @@ TEST_P(ConvertTo, WithOutScaling) ...@@ -285,7 +283,7 @@ TEST_P(ConvertTo, WithOutScaling)
} }
} }
TEST_P(ConvertTo, WithScaling) GPU_TEST_P(ConvertTo, WithScaling)
{ {
cv::Mat src = randomMat(size, depth1); cv::Mat src = randomMat(size, depth1);
double a = randomDouble(0.0, 1.0); double a = randomDouble(0.0, 1.0);
...@@ -336,7 +334,7 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -336,7 +334,7 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(EnsureSizeIsEnough, BufferReuse) GPU_TEST_P(EnsureSizeIsEnough, BufferReuse)
{ {
cv::gpu::GpuMat buffer(100, 100, CV_8U); cv::gpu::GpuMat buffer(100, 100, CV_8U);
cv::gpu::GpuMat old = buffer; cv::gpu::GpuMat old = buffer;
...@@ -358,6 +356,4 @@ TEST_P(EnsureSizeIsEnough, BufferReuse) ...@@ -358,6 +356,4 @@ TEST_P(EnsureSizeIsEnough, BufferReuse)
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES); INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_hough.cpp
View file @ 1a76242d
...@@ -43,8 +43,6 @@ ...@@ -43,8 +43,6 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace {
/////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////
// HoughLines // HoughLines
...@@ -79,7 +77,7 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi) ...@@ -79,7 +77,7 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
} }
}; };
TEST_P(HoughLines, Accuracy) GPU_TEST_P(HoughLines, Accuracy)
{ {
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID()); cv::gpu::setDevice(devInfo.deviceID());
...@@ -88,7 +86,7 @@ TEST_P(HoughLines, Accuracy) ...@@ -88,7 +86,7 @@ TEST_P(HoughLines, Accuracy)
const float rho = 1.0f; const float rho = 1.0f;
const float theta = (float) (1.5 * CV_PI / 180.0); const float theta = (float) (1.5 * CV_PI / 180.0);
onst int threshold = 100; const int threshold = 100;
cv::Mat src(size, CV_8UC1); cv::Mat src(size, CV_8UC1);
generateLines(src); generateLines(src);
...@@ -124,7 +122,7 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi) ...@@ -124,7 +122,7 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
} }
}; };
TEST_P(HoughCircles, Accuracy) GPU_TEST_P(HoughCircles, Accuracy)
{ {
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID()); cv::gpu::setDevice(devInfo.deviceID());
...@@ -188,7 +186,7 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi) ...@@ -188,7 +186,7 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
{ {
}; };
TEST_P(GeneralizedHough, POSITION) GPU_TEST_P(GeneralizedHough, POSITION)
{ {
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID()); cv::gpu::setDevice(devInfo.deviceID());
...@@ -251,6 +249,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine( ...@@ -251,6 +249,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine(
ALL_DEVICES, ALL_DEVICES,
WHOLE_SUBMAT)); WHOLE_SUBMAT));
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_imgproc.cpp
View file @ 1a76242d
This diff is collapsed.
modules/gpu/test/test_labeling.cpp
View file @ 1a76242d
...@@ -43,8 +43,8 @@ ...@@ -43,8 +43,8 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace { namespace
{
struct GreedyLabeling struct GreedyLabeling
{ {
struct dot struct dot
...@@ -166,7 +166,7 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo> ...@@ -166,7 +166,7 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
} }
}; };
TEST_P(Labeling, ConnectedComponents) GPU_TEST_P(Labeling, ConnectedComponents)
{ {
cv::Mat image; cv::Mat image;
cvtColor(loat_image(), image, CV_BGR2GRAY); cvtColor(loat_image(), image, CV_BGR2GRAY);
...@@ -191,6 +191,6 @@ TEST_P(Labeling, ConnectedComponents) ...@@ -191,6 +191,6 @@ TEST_P(Labeling, ConnectedComponents)
host.checkCorrectness(cv::Mat(components)); host.checkCorrectness(cv::Mat(components));
} }
INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES); INSTANTIATE_TEST_CASE_P(GPU_ConnectedComponents, Labeling, ALL_DEVICES);
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_nvidia.cpp
View file @ 1a76242d
...@@ -41,11 +41,9 @@ ...@@ -41,11 +41,9 @@
#include "test_precomp.hpp" #include "test_precomp.hpp"
#if defined HAVE_CUDA #ifdef HAVE_CUDA
OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
#endif
#if defined HAVE_CUDA && !defined(CUDA_DISABLER) OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
using namespace cvtest; using namespace cvtest;
using namespace testing; using namespace testing;
...@@ -69,77 +67,77 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo> ...@@ -69,77 +67,77 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
struct NPPST : NVidiaTest {}; struct NPPST : NVidiaTest {};
struct NCV : NVidiaTest {}; struct NCV : NVidiaTest {};
//TEST_P(NPPST, Integral) GPU_TEST_P(NPPST, Integral)
//{ {
// bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel); bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
// ASSERT_TRUE(res); ASSERT_TRUE(res);
//} }
TEST_P(NPPST, SquaredIntegral) GPU_TEST_P(NPPST, SquaredIntegral)
{ {
bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel); bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NPPST, RectStdDev) GPU_TEST_P(NPPST, RectStdDev)
{ {
bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel); bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NPPST, Resize) GPU_TEST_P(NPPST, Resize)
{ {
bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel); bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NPPST, VectorOperations) GPU_TEST_P(NPPST, VectorOperations)
{ {
bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel); bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NPPST, Transpose) GPU_TEST_P(NPPST, Transpose)
{ {
bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel); bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NCV, VectorOperations) GPU_TEST_P(NCV, VectorOperations)
{ {
bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel); bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NCV, HaarCascadeLoader) GPU_TEST_P(NCV, HaarCascadeLoader)
{ {
bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel); bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NCV, HaarCascadeApplication) GPU_TEST_P(NCV, HaarCascadeApplication)
{ {
bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel); bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NCV, HypothesesFiltration) GPU_TEST_P(NCV, HypothesesFiltration)
{ {
bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel); bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res); ASSERT_TRUE(res);
} }
TEST_P(NCV, Visualization) GPU_TEST_P(NCV, Visualization)
{ {
// this functionality doesn't used in gpu module // this functionality doesn't used in gpu module
bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel); bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
......
modules/gpu/test/test_objdetect.cpp
View file @ 1a76242d
...@@ -43,8 +43,6 @@ ...@@ -43,8 +43,6 @@
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
namespace {
//#define DUMP //#define DUMP
struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
...@@ -176,7 +174,7 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor ...@@ -176,7 +174,7 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
}; };
// desabled while resize does not fixed // desabled while resize does not fixed
TEST_P(HOG, DISABLED_Detect) GPU_TEST_P(HOG, Detect)
{ {
cv::Mat img_rgb = readImage("hog/road.png"); cv::Mat img_rgb = readImage("hog/road.png");
ASSERT_FALSE(img_rgb.empty()); ASSERT_FALSE(img_rgb.empty());
...@@ -201,7 +199,7 @@ TEST_P(HOG, DISABLED_Detect) ...@@ -201,7 +199,7 @@ TEST_P(HOG, DISABLED_Detect)
f.close(); f.close();
} }
TEST_P(HOG, GetDescriptors) GPU_TEST_P(HOG, GetDescriptors)
{ {
// Load image (e.g. train data, composed from windows) // Load image (e.g. train data, composed from windows)
cv::Mat img_rgb = readImage("hog/train_data.png"); cv::Mat img_rgb = readImage("hog/train_data.png");
...@@ -288,6 +286,7 @@ TEST_P(HOG, GetDescriptors) ...@@ -288,6 +286,7 @@ TEST_P(HOG, GetDescriptors)
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES); INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
//============== caltech hog tests =====================// //============== caltech hog tests =====================//
struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string> > struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string> >
{ {
cv::gpu::DeviceInfo devInfo; cv::gpu::DeviceInfo devInfo;
...@@ -303,7 +302,7 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device ...@@ -303,7 +302,7 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
} }
}; };
TEST_P(CalTech, HOG) GPU_TEST_P(CalTech, HOG)
{ {
cv::gpu::GpuMat d_img(img); cv::gpu::GpuMat d_img(img);
cv::Mat markedImage(img.clone()); cv::Mat markedImage(img.clone());
...@@ -350,7 +349,7 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int) ...@@ -350,7 +349,7 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
} }
}; };
TEST_P(LBP_Read_classifier, Accuracy) GPU_TEST_P(LBP_Read_classifier, Accuracy)
{ {
cv::gpu::CascadeClassifier_GPU classifier; cv::gpu::CascadeClassifier_GPU classifier;
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml"; std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
...@@ -372,7 +371,7 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int) ...@@ -372,7 +371,7 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
} }
}; };
TEST_P(LBP_classify, Accuracy) GPU_TEST_P(LBP_classify, Accuracy)
{ {
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml"; std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png"; std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
...@@ -422,6 +421,4 @@ TEST_P(LBP_classify, Accuracy) ...@@ -422,6 +421,4 @@ TEST_P(LBP_classify, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify, INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
testing::Combine(ALL_DEVICES, testing::Values<int>(0))); testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
} // namespace
#endif // HAVE_CUDA #endif // HAVE_CUDA
modules/gpu/test/test_opengl.cpp
View file @ 1a76242d
...@@ -68,7 +68,7 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType) ...@@ -68,7 +68,7 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
} }
}; };
TEST_P(GlBuffer, Constructor1) GPU_TEST_P(GlBuffer, Constructor1)
{ {
cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
...@@ -77,7 +77,7 @@ TEST_P(GlBuffer, Constructor1) ...@@ -77,7 +77,7 @@ TEST_P(GlBuffer, Constructor1)
EXPECT_EQ(type, buf.type()); EXPECT_EQ(type, buf.type());
} }
TEST_P(GlBuffer, Constructor2) GPU_TEST_P(GlBuffer, Constructor2)
{ {
cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
...@@ -86,7 +86,7 @@ TEST_P(GlBuffer, Constructor2) ...@@ -86,7 +86,7 @@ TEST_P(GlBuffer, Constructor2)
EXPECT_EQ(type, buf.type()); EXPECT_EQ(type, buf.type());
} }
TEST_P(GlBuffer, ConstructorFromMat) GPU_TEST_P(GlBuffer, ConstructorFromMat)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -98,7 +98,7 @@ TEST_P(GlBuffer, ConstructorFromMat) ...@@ -98,7 +98,7 @@ TEST_P(GlBuffer, ConstructorFromMat)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, ConstructorFromGpuMat) GPU_TEST_P(GlBuffer, ConstructorFromGpuMat)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
cv::gpu::GpuMat d_gold(gold); cv::gpu::GpuMat d_gold(gold);
...@@ -111,7 +111,7 @@ TEST_P(GlBuffer, ConstructorFromGpuMat) ...@@ -111,7 +111,7 @@ TEST_P(GlBuffer, ConstructorFromGpuMat)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, ConstructorFromGlBuffer) GPU_TEST_P(GlBuffer, ConstructorFromGlBuffer)
{ {
cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true); cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
...@@ -123,7 +123,7 @@ TEST_P(GlBuffer, ConstructorFromGlBuffer) ...@@ -123,7 +123,7 @@ TEST_P(GlBuffer, ConstructorFromGlBuffer)
EXPECT_EQ(buf_gold.type(), buf.type()); EXPECT_EQ(buf_gold.type(), buf.type());
} }
TEST_P(GlBuffer, ConstructorFromGlTexture2D) GPU_TEST_P(GlBuffer, ConstructorFromGlTexture2D)
{ {
const int depth = CV_MAT_DEPTH(type); const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type); const int cn = CV_MAT_CN(type);
...@@ -142,7 +142,7 @@ TEST_P(GlBuffer, ConstructorFromGlTexture2D) ...@@ -142,7 +142,7 @@ TEST_P(GlBuffer, ConstructorFromGlTexture2D)
EXPECT_MAT_NEAR(gold, bufData, 1e-2); EXPECT_MAT_NEAR(gold, bufData, 1e-2);
} }
TEST_P(GlBuffer, Create) GPU_TEST_P(GlBuffer, Create)
{ {
cv::GlBuffer buf; cv::GlBuffer buf;
buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
...@@ -152,7 +152,7 @@ TEST_P(GlBuffer, Create) ...@@ -152,7 +152,7 @@ TEST_P(GlBuffer, Create)
EXPECT_EQ(type, buf.type()); EXPECT_EQ(type, buf.type());
} }
TEST_P(GlBuffer, CopyFromMat) GPU_TEST_P(GlBuffer, CopyFromMat)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -165,7 +165,7 @@ TEST_P(GlBuffer, CopyFromMat) ...@@ -165,7 +165,7 @@ TEST_P(GlBuffer, CopyFromMat)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, CopyFromGpuMat) GPU_TEST_P(GlBuffer, CopyFromGpuMat)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
cv::gpu::GpuMat d_gold(gold); cv::gpu::GpuMat d_gold(gold);
...@@ -179,7 +179,7 @@ TEST_P(GlBuffer, CopyFromGpuMat) ...@@ -179,7 +179,7 @@ TEST_P(GlBuffer, CopyFromGpuMat)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, CopyFromGlBuffer) GPU_TEST_P(GlBuffer, CopyFromGlBuffer)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true); cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
...@@ -195,7 +195,7 @@ TEST_P(GlBuffer, CopyFromGlBuffer) ...@@ -195,7 +195,7 @@ TEST_P(GlBuffer, CopyFromGlBuffer)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, CopyFromGlTexture2D) GPU_TEST_P(GlBuffer, CopyFromGlTexture2D)
{ {
const int depth = CV_MAT_DEPTH(type); const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type); const int cn = CV_MAT_CN(type);
...@@ -215,7 +215,7 @@ TEST_P(GlBuffer, CopyFromGlTexture2D) ...@@ -215,7 +215,7 @@ TEST_P(GlBuffer, CopyFromGlTexture2D)
EXPECT_MAT_NEAR(gold, bufData, 1e-2); EXPECT_MAT_NEAR(gold, bufData, 1e-2);
} }
TEST_P(GlBuffer, CopyToGpuMat) GPU_TEST_P(GlBuffer, CopyToGpuMat)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -227,7 +227,7 @@ TEST_P(GlBuffer, CopyToGpuMat) ...@@ -227,7 +227,7 @@ TEST_P(GlBuffer, CopyToGpuMat)
EXPECT_MAT_NEAR(gold, dst, 0); EXPECT_MAT_NEAR(gold, dst, 0);
} }
TEST_P(GlBuffer, CopyToGlBuffer) GPU_TEST_P(GlBuffer, CopyToGlBuffer)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -244,7 +244,7 @@ TEST_P(GlBuffer, CopyToGlBuffer) ...@@ -244,7 +244,7 @@ TEST_P(GlBuffer, CopyToGlBuffer)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, CopyToGlTexture2D) GPU_TEST_P(GlBuffer, CopyToGlTexture2D)
{ {
const int depth = CV_MAT_DEPTH(type); const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type); const int cn = CV_MAT_CN(type);
...@@ -265,7 +265,7 @@ TEST_P(GlBuffer, CopyToGlTexture2D) ...@@ -265,7 +265,7 @@ TEST_P(GlBuffer, CopyToGlTexture2D)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlBuffer, Clone) GPU_TEST_P(GlBuffer, Clone)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -281,7 +281,7 @@ TEST_P(GlBuffer, Clone) ...@@ -281,7 +281,7 @@ TEST_P(GlBuffer, Clone)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, MapHostRead) GPU_TEST_P(GlBuffer, MapHostRead)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -294,7 +294,7 @@ TEST_P(GlBuffer, MapHostRead) ...@@ -294,7 +294,7 @@ TEST_P(GlBuffer, MapHostRead)
buf.unmapHost(); buf.unmapHost();
} }
TEST_P(GlBuffer, MapHostWrite) GPU_TEST_P(GlBuffer, MapHostWrite)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -311,7 +311,7 @@ TEST_P(GlBuffer, MapHostWrite) ...@@ -311,7 +311,7 @@ TEST_P(GlBuffer, MapHostWrite)
EXPECT_MAT_NEAR(gold, bufData, 0); EXPECT_MAT_NEAR(gold, bufData, 0);
} }
TEST_P(GlBuffer, MapDevice) GPU_TEST_P(GlBuffer, MapDevice)
{ {
cv::Mat gold = randomMat(size, type); cv::Mat gold = randomMat(size, type);
...@@ -358,7 +358,7 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType) ...@@ -358,7 +358,7 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
} }
}; };
TEST_P(GlTexture2D, Constructor1) GPU_TEST_P(GlTexture2D, Constructor1)
{ {
cv::GlTexture2D tex(size.height, size.width, format, true); cv::GlTexture2D tex(size.height, size.width, format, true);
...@@ -367,7 +367,7 @@ TEST_P(GlTexture2D, Constructor1) ...@@ -367,7 +367,7 @@ TEST_P(GlTexture2D, Constructor1)
EXPECT_EQ(format, tex.format()); EXPECT_EQ(format, tex.format());
} }
TEST_P(GlTexture2D, Constructor2) GPU_TEST_P(GlTexture2D, Constructor2)
{ {
cv::GlTexture2D tex(size, format, true); cv::GlTexture2D tex(size, format, true);
...@@ -376,7 +376,7 @@ TEST_P(GlTexture2D, Constructor2) ...@@ -376,7 +376,7 @@ TEST_P(GlTexture2D, Constructor2)
EXPECT_EQ(format, tex.format()); EXPECT_EQ(format, tex.format());
} }
TEST_P(GlTexture2D, ConstructorFromMat) GPU_TEST_P(GlTexture2D, ConstructorFromMat)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
...@@ -388,7 +388,7 @@ TEST_P(GlTexture2D, ConstructorFromMat) ...@@ -388,7 +388,7 @@ TEST_P(GlTexture2D, ConstructorFromMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlTexture2D, ConstructorFromGpuMat) GPU_TEST_P(GlTexture2D, ConstructorFromGpuMat)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::gpu::GpuMat d_gold(gold); cv::gpu::GpuMat d_gold(gold);
...@@ -401,7 +401,7 @@ TEST_P(GlTexture2D, ConstructorFromGpuMat) ...@@ -401,7 +401,7 @@ TEST_P(GlTexture2D, ConstructorFromGpuMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlTexture2D, ConstructorFromGlBuffer) GPU_TEST_P(GlTexture2D, ConstructorFromGlBuffer)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
...@@ -414,7 +414,7 @@ TEST_P(GlTexture2D, ConstructorFromGlBuffer) ...@@ -414,7 +414,7 @@ TEST_P(GlTexture2D, ConstructorFromGlBuffer)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlTexture2D, ConstructorFromGlTexture2D) GPU_TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
{ {
cv::GlTexture2D tex_gold(size, format, true); cv::GlTexture2D tex_gold(size, format, true);
cv::GlTexture2D tex(tex_gold); cv::GlTexture2D tex(tex_gold);
...@@ -425,7 +425,7 @@ TEST_P(GlTexture2D, ConstructorFromGlTexture2D) ...@@ -425,7 +425,7 @@ TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
EXPECT_EQ(tex_gold.format(), tex.format()); EXPECT_EQ(tex_gold.format(), tex.format());
} }
TEST_P(GlTexture2D, Create) GPU_TEST_P(GlTexture2D, Create)
{ {
cv::GlTexture2D tex; cv::GlTexture2D tex;
tex.create(size.height, size.width, format, true); tex.create(size.height, size.width, format, true);
...@@ -435,7 +435,7 @@ TEST_P(GlTexture2D, Create) ...@@ -435,7 +435,7 @@ TEST_P(GlTexture2D, Create)
EXPECT_EQ(format, tex.format()); EXPECT_EQ(format, tex.format());
} }
TEST_P(GlTexture2D, CopyFromMat) GPU_TEST_P(GlTexture2D, CopyFromMat)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
...@@ -448,7 +448,7 @@ TEST_P(GlTexture2D, CopyFromMat) ...@@ -448,7 +448,7 @@ TEST_P(GlTexture2D, CopyFromMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlTexture2D, CopyFromGpuMat) GPU_TEST_P(GlTexture2D, CopyFromGpuMat)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::gpu::GpuMat d_gold(gold); cv::gpu::GpuMat d_gold(gold);
...@@ -462,7 +462,7 @@ TEST_P(GlTexture2D, CopyFromGpuMat) ...@@ -462,7 +462,7 @@ TEST_P(GlTexture2D, CopyFromGpuMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlTexture2D, CopyFromGlBuffer) GPU_TEST_P(GlTexture2D, CopyFromGlBuffer)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
...@@ -476,7 +476,7 @@ TEST_P(GlTexture2D, CopyFromGlBuffer) ...@@ -476,7 +476,7 @@ TEST_P(GlTexture2D, CopyFromGlBuffer)
EXPECT_MAT_NEAR(gold, texData, 1e-2); EXPECT_MAT_NEAR(gold, texData, 1e-2);
} }
TEST_P(GlTexture2D, CopyToGpuMat) GPU_TEST_P(GlTexture2D, CopyToGpuMat)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
...@@ -488,7 +488,7 @@ TEST_P(GlTexture2D, CopyToGpuMat) ...@@ -488,7 +488,7 @@ TEST_P(GlTexture2D, CopyToGpuMat)
EXPECT_MAT_NEAR(gold, dst, 1e-2); EXPECT_MAT_NEAR(gold, dst, 1e-2);
} }
TEST_P(GlTexture2D, CopyToGlBuffer) GPU_TEST_P(GlTexture2D, CopyToGlBuffer)
{ {
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
......
modules/gpu/test/test_optflow.cpp 0 → 100644
View file @ 1a76242d
This diff is collapsed.
modules/gpu/test/test_precomp.hpp
View file @ 1a76242d
...@@ -51,6 +51,7 @@ ...@@ -51,6 +51,7 @@
#define __OPENCV_TEST_PRECOMP_HPP__ #define __OPENCV_TEST_PRECOMP_HPP__
#include <cmath> #include <cmath>
#include <ctime>
#include <cstdio> #include <cstdio>
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
......
modules/gpu/test/test_pyramids.cpp
View file @ 1a76242d
...@@ -64,7 +64,7 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) ...@@ -64,7 +64,7 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
} }
}; };
TEST_P(PyrDown, Accuracy) GPU_TEST_P(PyrDown, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -104,7 +104,7 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) ...@@ -104,7 +104,7 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
} }
}; };
TEST_P(PyrUp, Accuracy) GPU_TEST_P(PyrUp, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
......
modules/gpu/test/test_remap.cpp
View file @ 1a76242d
...@@ -152,7 +152,7 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo ...@@ -152,7 +152,7 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo
} }
}; };
TEST_P(Remap, Accuracy) GPU_TEST_P(Remap, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Scalar val = randomScalar(0.0, 255.0); cv::Scalar val = randomScalar(0.0, 255.0);
......
modules/gpu/test/test_resize.cpp
View file @ 1a76242d
...@@ -136,7 +136,7 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol ...@@ -136,7 +136,7 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
} }
}; };
TEST_P(Resize, Accuracy) GPU_TEST_P(Resize, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -157,8 +157,8 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine( ...@@ -157,8 +157,8 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
WHOLE_SUBMAT)); WHOLE_SUBMAT));
///////////////// /////////////////
PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpolation, UseRoi) PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpolation, UseRoi)
{ {
cv::gpu::DeviceInfo devInfo; cv::gpu::DeviceInfo devInfo;
...@@ -182,7 +182,7 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double ...@@ -182,7 +182,7 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
}; };
// downscaling only: used for classifiers // downscaling only: used for classifiers
TEST_P(ResizeSameAsHost, Accuracy) GPU_TEST_P(ResizeSameAsHost, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
...@@ -224,7 +224,7 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation) ...@@ -224,7 +224,7 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
} }
}; };
TEST_P(ResizeNPP, Accuracy) GPU_TEST_P(ResizeNPP, Accuracy)
{ {
cv::Mat src = readImageType("stereobp/aloe-L.png", type); cv::Mat src = readImageType("stereobp/aloe-L.png", type);
ASSERT_FALSE(src.empty()); ASSERT_FALSE(src.empty());
......
modules/gpu/test/test_softcascade.cpp
View file @ 1a76242d
...@@ -40,14 +40,14 @@ ...@@ -40,14 +40,14 @@
// //
//M*/ //M*/
#include <test_precomp.hpp> #include "test_precomp.hpp"
#include <time.h>
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
using cv::gpu::GpuMat; using cv::gpu::GpuMat;
// show detection results on input image with cv::imshow // show detection results on input image with cv::imshow
// #define SHOW_DETECTIONS //#define SHOW_DETECTIONS
#if defined SHOW_DETECTIONS #if defined SHOW_DETECTIONS
# define SHOW(res) \ # define SHOW(res) \
...@@ -57,22 +57,22 @@ using cv::gpu::GpuMat; ...@@ -57,22 +57,22 @@ using cv::gpu::GpuMat;
# define SHOW(res) # define SHOW(res)
#endif #endif
#define GPU_TEST_P(fixture, name, params) \ TEST(SCascadeTest, readCascade)
class fixture##_##name : public fixture { \ {
public: \ std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
fixture##_##name() {} \ cv::gpu::SCascade cascade;
protected: \
virtual void body(); \
}; \
TEST_P(fixture##_##name, name /*none*/){ body();} \
INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params); \
void fixture##_##name::body()
namespace { cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(fs.isOpened());
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
}
namespace
{
typedef cv::gpu::SCascade::Detection Detection; typedef cv::gpu::SCascade::Detection Detection;
static cv::Rect getFromTable(int idx) cv::Rect getFromTable(int idx)
{ {
static const cv::Rect rois[] = static const cv::Rect rois[] =
{ {
...@@ -92,16 +92,16 @@ namespace { ...@@ -92,16 +92,16 @@ namespace {
return rois[idx]; return rois[idx];
} }
static std::string itoa(long i) std::string itoa(long i)
{ {
static char s[65]; static char s[65];
sprintf(s, "%ld", i); sprintf(s, "%ld", i);
return std::string(s); return std::string(s);
} }
static void print(std::ostream &out, const Detection& d) void print(std::ostream &out, const Detection& d)
{ {
#if defined SHOW_DETECTIONS #if defined SHOW_DETECTIONS
out << "\x1b[32m[ detection]\x1b[0m (" out << "\x1b[32m[ detection]\x1b[0m ("
<< std::setw(4) << d.x << std::setw(4) << d.x
<< " " << " "
...@@ -113,22 +113,22 @@ namespace { ...@@ -113,22 +113,22 @@ namespace {
<< ") " << ") "
<< std::setw(12) << d.confidence << std::setw(12) << d.confidence
<< std::endl; << std::endl;
#else #else
(void)out; (void)d; (void)out; (void)d;
#endif #endif
} }
static void printTotal(std::ostream &out, int detbytes) void printTotal(std::ostream &out, int detbytes)
{ {
#if defined SHOW_DETECTIONS #if defined SHOW_DETECTIONS
out << "\x1b[32m[ ]\x1b[0m Total detections " << (detbytes / sizeof(Detection)) << std::endl; out << "\x1b[32m[ ]\x1b[0m Total detections " << (detbytes / sizeof(Detection)) << std::endl;
#else #else
(void)out; (void)detbytes; (void)out; (void)detbytes;
#endif #endif
} }
#if defined SHOW_DETECTIONS #if defined SHOW_DETECTIONS
static std::string getImageName(int level) std::string getImageName(int level)
{ {
time_t rawtime; time_t rawtime;
struct tm * timeinfo; struct tm * timeinfo;
...@@ -141,7 +141,7 @@ namespace { ...@@ -141,7 +141,7 @@ namespace {
return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png"; return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
} }
static void writeResult(const cv::Mat& result, const int level) void writeResult(const cv::Mat& result, const int level)
{ {
std::string path = cv::tempfile(getImageName(level).c_str()); std::string path = cv::tempfile(getImageName(level).c_str());
cv::imwrite(path, result); cv::imwrite(path, result);
...@@ -150,13 +150,11 @@ namespace { ...@@ -150,13 +150,11 @@ namespace {
#endif #endif
} }
typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestRoi; PARAM_TEST_CASE(SCascadeTestRoi, cv::gpu::DeviceInfo, std::string, std::string, int)
GPU_TEST_P(SCascadeTestRoi, detect, {
testing::Combine( };
ALL_DEVICES,
testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")), GPU_TEST_P(SCascadeTestRoi, Detect)
testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
testing::Range(0, 5)))
{ {
cv::gpu::setDevice(GET_PARAM(0).deviceID()); cv::gpu::setDevice(GET_PARAM(0).deviceID());
cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2)); cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
...@@ -202,26 +200,24 @@ GPU_TEST_P(SCascadeTestRoi, detect, ...@@ -202,26 +200,24 @@ GPU_TEST_P(SCascadeTestRoi, detect,
} }
SHOW(result); SHOW(result);
} }
TEST(SCascadeTest, readCascade) INSTANTIATE_TEST_CASE_P(GPU_SoftCascade, SCascadeTestRoi, testing::Combine(
{ ALL_DEVICES,
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml"; testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
cv::gpu::SCascade cascade; testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
testing::Range(0, 5)));
cv::FileStorage fs(xml, cv::FileStorage::READ);
ASSERT_TRUE(fs.isOpened());
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
}
typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll; struct SCascadeTestAll : testing::TestWithParam<cv::gpu::DeviceInfo>
GPU_TEST_P(SCascadeTestAll, detect,
ALL_DEVICES
)
{ {
virtual void SetUp()
{
cv::gpu::setDevice(GetParam().deviceID()); cv::gpu::setDevice(GetParam().deviceID());
}
};
GPU_TEST_P(SCascadeTestAll, detect)
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml"; std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
cv::gpu::SCascade cascade; cv::gpu::SCascade cascade;
...@@ -239,20 +235,16 @@ GPU_TEST_P(SCascadeTestAll, detect, ...@@ -239,20 +235,16 @@ GPU_TEST_P(SCascadeTestAll, detect,
GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2)); GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
sub.setTo(cv::Scalar::all(1)); sub.setTo(cv::Scalar::all(1));
objectBoxes.setTo(0);
cascade.detect(colored, rois, objectBoxes); cascade.detect(colored, rois, objectBoxes);
typedef cv::gpu::SCascade::Detection Detection; typedef cv::gpu::SCascade::Detection Detection;
cv::Mat detections(objectBoxes); cv::Mat detections(objectBoxes);
int a = *(detections.ptr<int>(0)); int a = *(detections.ptr<int>(0));
ASSERT_EQ(a ,2448); ASSERT_EQ(a, 2448);
} }
GPU_TEST_P(SCascadeTestAll, detectOnIntegral, GPU_TEST_P(SCascadeTestAll, detectOnIntegral)
ALL_DEVICES
)
{ {
cv::gpu::setDevice(GetParam().deviceID());
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml"; std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
cv::gpu::SCascade cascade; cv::gpu::SCascade cascade;
...@@ -283,15 +275,11 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral, ...@@ -283,15 +275,11 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
typedef cv::gpu::SCascade::Detection Detection; typedef cv::gpu::SCascade::Detection Detection;
cv::Mat detections(objectBoxes); cv::Mat detections(objectBoxes);
int a = *(detections.ptr<int>(0)); int a = *(detections.ptr<int>(0));
ASSERT_EQ(a, 1024);
ASSERT_EQ( a ,1024);
} }
GPU_TEST_P(SCascadeTestAll, detectStream, GPU_TEST_P(SCascadeTestAll, detectStream)
ALL_DEVICES
)
{ {
cv::gpu::setDevice(GetParam().deviceID());
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml"; std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
cv::gpu::SCascade cascade; cv::gpu::SCascade cascade;
...@@ -318,8 +306,9 @@ GPU_TEST_P(SCascadeTestAll, detectStream, ...@@ -318,8 +306,9 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
typedef cv::gpu::SCascade::Detection Detection; typedef cv::gpu::SCascade::Detection Detection;
cv::Mat detections(objectBoxes); cv::Mat detections(objectBoxes);
int a = *(detections.ptr<int>(0)); int a = *(detections.ptr<int>(0));
ASSERT_EQ(a ,2448); ASSERT_EQ(a, 2448);
} }
INSTANTIATE_TEST_CASE_P(GPU_SoftCascade, SCascadeTestAll, ALL_DEVICES);
#endif #endif
modules/gpu/test/test_threshold.cpp
View file @ 1a76242d
...@@ -66,7 +66,7 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use ...@@ -66,7 +66,7 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use
} }
}; };
TEST_P(Threshold, Accuracy) GPU_TEST_P(Threshold, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
double maxVal = randomDouble(20.0, 127.0); double maxVal = randomDouble(20.0, 127.0);
......
modules/gpu/test/test_video.cpp
View file @ 1a76242d
This diff is collapsed.
modules/gpu/test/test_warp_affine.cpp
View file @ 1a76242d
...@@ -48,6 +48,7 @@ namespace ...@@ -48,6 +48,7 @@ namespace
cv::Mat createTransfomMatrix(cv::Size srcSize, double angle) cv::Mat createTransfomMatrix(cv::Size srcSize, double angle)
{ {
cv::Mat M(2, 3, CV_64FC1); cv::Mat M(2, 3, CV_64FC1);
M.at<double>(0, 0) = std::cos(angle); M.at<double>(0, 1) = -std::sin(angle); M.at<double>(0, 2) = srcSize.width / 2; M.at<double>(0, 0) = std::cos(angle); M.at<double>(0, 1) = -std::sin(angle); M.at<double>(0, 2) = srcSize.width / 2;
M.at<double>(1, 0) = std::sin(angle); M.at<double>(1, 1) = std::cos(angle); M.at<double>(1, 2) = 0.0; M.at<double>(1, 0) = std::sin(angle); M.at<double>(1, 1) = std::cos(angle); M.at<double>(1, 2) = 0.0;
...@@ -74,22 +75,23 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse) ...@@ -74,22 +75,23 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
} }
}; };
TEST_P(BuildWarpAffineMaps, Accuracy) GPU_TEST_P(BuildWarpAffineMaps, Accuracy)
{ {
cv::Mat M = createTransfomMatrix(size, CV_PI / 4); cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
cv::gpu::GpuMat xmap, ymap; cv::gpu::GpuMat xmap, ymap;
cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap); cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
int interpolation = cv::INTER_NEAREST; int interpolation = cv::INTER_NEAREST;
int borderMode = cv::BORDER_CONSTANT; int borderMode = cv::BORDER_CONSTANT;
int flags = interpolation;
if (inverse)
flags |= cv::WARP_INVERSE_MAP;
cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
cv::Mat dst; cv::Mat dst;
cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode); cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
int flags = interpolation;
if (inverse)
flags |= cv::WARP_INVERSE_MAP;
cv::Mat dst_gold; cv::Mat dst_gold;
cv::warpAffine(src, dst_gold, M, size, flags, borderMode); cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
...@@ -199,7 +201,7 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int ...@@ -199,7 +201,7 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
} }
}; };
TEST_P(WarpAffine, Accuracy) GPU_TEST_P(WarpAffine, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat M = createTransfomMatrix(size, CV_PI / 3); cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
...@@ -247,7 +249,7 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat ...@@ -247,7 +249,7 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
} }
}; };
TEST_P(WarpAffineNPP, Accuracy) GPU_TEST_P(WarpAffineNPP, Accuracy)
{ {
cv::Mat src = readImageType("stereobp/aloe-L.png", type); cv::Mat src = readImageType("stereobp/aloe-L.png", type);
cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4); cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
......
modules/gpu/test/test_warp_perspective.cpp
View file @ 1a76242d
...@@ -48,6 +48,7 @@ namespace ...@@ -48,6 +48,7 @@ namespace
cv::Mat createTransfomMatrix(cv::Size srcSize, double angle) cv::Mat createTransfomMatrix(cv::Size srcSize, double angle)
{ {
cv::Mat M(3, 3, CV_64FC1); cv::Mat M(3, 3, CV_64FC1);
M.at<double>(0, 0) = std::cos(angle); M.at<double>(0, 1) = -std::sin(angle); M.at<double>(0, 2) = srcSize.width / 2; M.at<double>(0, 0) = std::cos(angle); M.at<double>(0, 1) = -std::sin(angle); M.at<double>(0, 2) = srcSize.width / 2;
M.at<double>(1, 0) = std::sin(angle); M.at<double>(1, 1) = std::cos(angle); M.at<double>(1, 2) = 0.0; M.at<double>(1, 0) = std::sin(angle); M.at<double>(1, 1) = std::cos(angle); M.at<double>(1, 2) = 0.0;
M.at<double>(2, 0) = 0.0 ; M.at<double>(2, 1) = 0.0 ; M.at<double>(2, 2) = 1.0; M.at<double>(2, 0) = 0.0 ; M.at<double>(2, 1) = 0.0 ; M.at<double>(2, 2) = 1.0;
...@@ -75,21 +76,25 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse ...@@ -75,21 +76,25 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
} }
}; };
TEST_P(BuildWarpPerspectiveMaps, Accuracy) GPU_TEST_P(BuildWarpPerspectiveMaps, Accuracy)
{ {
cv::Mat M = createTransfomMatrix(size, CV_PI / 4); cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
cv::gpu::GpuMat xmap, ymap; cv::gpu::GpuMat xmap, ymap;
cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap); cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1); cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
cv::Mat dst; int interpolation = cv::INTER_NEAREST;
cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT); int borderMode = cv::BORDER_CONSTANT;
int flags = interpolation;
int flags = cv::INTER_NEAREST;
if (inverse) if (inverse)
flags |= cv::WARP_INVERSE_MAP; flags |= cv::WARP_INVERSE_MAP;
cv::Mat dst;
cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
cv::Mat dst_gold; cv::Mat dst_gold;
cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT); cv::warpPerspective(src, dst_gold, M, size, flags, borderMode);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0); EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
} }
...@@ -199,7 +204,7 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse ...@@ -199,7 +204,7 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
} }
}; };
TEST_P(WarpPerspective, Accuracy) GPU_TEST_P(WarpPerspective, Accuracy)
{ {
cv::Mat src = randomMat(size, type); cv::Mat src = randomMat(size, type);
cv::Mat M = createTransfomMatrix(size, CV_PI / 3); cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
...@@ -247,7 +252,7 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter ...@@ -247,7 +252,7 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
} }
}; };
TEST_P(WarpPerspectiveNPP, Accuracy) GPU_TEST_P(WarpPerspectiveNPP, Accuracy)
{ {
cv::Mat src = readImageType("stereobp/aloe-L.png", type); cv::Mat src = readImageType("stereobp/aloe-L.png", type);
cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4); cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
......
modules/gpu/test/utility.cpp
View file @ 1a76242d
...@@ -67,7 +67,7 @@ double randomDouble(double minVal, double maxVal) ...@@ -67,7 +67,7 @@ double randomDouble(double minVal, double maxVal)
Size randomSize(int minVal, int maxVal) Size randomSize(int minVal, int maxVal)
{ {
return cv::Size(randomInt(minVal, maxVal), randomInt(minVal, maxVal)); return Size(randomInt(minVal, maxVal), randomInt(minVal, maxVal));
} }
Scalar randomScalar(double minVal, double maxVal) Scalar randomScalar(double minVal, double maxVal)
...@@ -83,7 +83,7 @@ Mat randomMat(Size size, int type, double minVal, double maxVal) ...@@ -83,7 +83,7 @@ Mat randomMat(Size size, int type, double minVal, double maxVal)
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// GpuMat create // GpuMat create
cv::gpu::GpuMat createMat(cv::Size size, int type, bool useRoi) GpuMat createMat(Size size, int type, bool useRoi)
{ {
Size size0 = size; Size size0 = size;
...@@ -122,21 +122,13 @@ Mat readImageType(const std::string& fname, int type) ...@@ -122,21 +122,13 @@ Mat readImageType(const std::string& fname, int type)
if (CV_MAT_CN(type) == 4) if (CV_MAT_CN(type) == 4)
{ {
Mat temp; Mat temp;
cvtColor(src, temp, cv::COLOR_BGR2BGRA); cvtColor(src, temp, COLOR_BGR2BGRA);
swap(src, temp); swap(src, temp);
} }
src.convertTo(src, CV_MAT_DEPTH(type), CV_MAT_DEPTH(type) == CV_32F ? 1.0 / 255.0 : 1.0); src.convertTo(src, CV_MAT_DEPTH(type), CV_MAT_DEPTH(type) == CV_32F ? 1.0 / 255.0 : 1.0);
return src; return src;
} }
//////////////////////////////////////////////////////////////////////
// Image dumping
void dumpImage(const std::string& fileName, const cv::Mat& image)
{
cv::imwrite(TS::ptr()->get_data_path() + fileName, image);
}
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Gpu devices // Gpu devices
...@@ -156,7 +148,7 @@ void DeviceManager::load(int i) ...@@ -156,7 +148,7 @@ void DeviceManager::load(int i)
devices_.clear(); devices_.clear();
devices_.reserve(1); devices_.reserve(1);
ostringstream msg; std::ostringstream msg;
if (i < 0 || i >= getCudaEnabledDeviceCount()) if (i < 0 || i >= getCudaEnabledDeviceCount())
{ {
...@@ -195,21 +187,39 @@ void DeviceManager::loadAll() ...@@ -195,21 +187,39 @@ void DeviceManager::loadAll()
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Additional assertion // Additional assertion
Mat getMat(InputArray arr) namespace
{ {
if (arr.kind() == _InputArray::GPU_MAT) template <typename T, typename OutT> std::string printMatValImpl(const Mat& m, Point p)
{ {
Mat m; const int cn = m.channels();
arr.getGpuMat().download(m);
return m; std::ostringstream ostr;
ostr << "(";
p.x /= cn;
ostr << static_cast<OutT>(m.at<T>(p.y, p.x * cn));
for (int c = 1; c < m.channels(); ++c)
{
ostr << ", " << static_cast<OutT>(m.at<T>(p.y, p.x * cn + c));
} }
ostr << ")";
return arr.getMat(); return ostr.str();
} }
double checkNorm(InputArray m1, InputArray m2) std::string printMatVal(const Mat& m, Point p)
{ {
return norm(getMat(m1), getMat(m2), NORM_INF); typedef std::string (*func_t)(const Mat& m, Point p);
static const func_t funcs[] =
{
printMatValImpl<uchar, int>, printMatValImpl<schar, int>, printMatValImpl<ushort, int>, printMatValImpl<short, int>,
printMatValImpl<int, int>, printMatValImpl<float, float>, printMatValImpl<double, double>
};
return funcs[m.depth()](m, p);
}
} }
void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minLoc_, Point* maxLoc_, const Mat& mask) void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minLoc_, Point* maxLoc_, const Mat& mask)
...@@ -229,8 +239,8 @@ void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minL ...@@ -229,8 +239,8 @@ void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minL
for (int y = 0; y < src.rows; ++y) for (int y = 0; y < src.rows; ++y)
{ {
const schar* src_row = src.ptr<signed char>(y); const schar* src_row = src.ptr<schar>(y);
const uchar* mask_row = mask.empty() ? 0 : mask.ptr<unsigned char>(y); const uchar* mask_row = mask.empty() ? 0 : mask.ptr<uchar>(y);
for (int x = 0; x < src.cols; ++x) for (int x = 0; x < src.cols; ++x)
{ {
...@@ -260,42 +270,19 @@ void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minL ...@@ -260,42 +270,19 @@ void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minL
if (maxLoc_) *maxLoc_ = maxLoc; if (maxLoc_) *maxLoc_ = maxLoc;
} }
namespace Mat getMat(InputArray arr)
{ {
template <typename T, typename OutT> std::string printMatValImpl(const Mat& m, Point p) if (arr.kind() == _InputArray::GPU_MAT)
{
const int cn = m.channels();
ostringstream ostr;
ostr << "(";
p.x /= cn;
ostr << static_cast<OutT>(m.at<T>(p.y, p.x * cn));
for (int c = 1; c < m.channels(); ++c)
{ {
ostr << ", " << static_cast<OutT>(m.at<T>(p.y, p.x * cn + c)); Mat m;
} arr.getGpuMat().download(m);
ostr << ")"; return m;
return ostr.str();
} }
std::string printMatVal(const Mat& m, Point p) return arr.getMat();
{
typedef std::string (*func_t)(const Mat& m, Point p);
static const func_t funcs[] =
{
printMatValImpl<uchar, int>, printMatValImpl<schar, int>, printMatValImpl<ushort, int>, printMatValImpl<short, int>,
printMatValImpl<int, int>, printMatValImpl<float, float>, printMatValImpl<double, double>
};
return funcs[m.depth()](m, p);
}
} }
testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1_, cv::InputArray m2_, double eps) AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, InputArray m1_, InputArray m2_, double eps)
{ {
Mat m1 = getMat(m1_); Mat m1 = getMat(m1_);
Mat m2 = getMat(m2_); Mat m2 = getMat(m2_);
...@@ -344,18 +331,6 @@ double checkSimilarity(InputArray m1, InputArray m2) ...@@ -344,18 +331,6 @@ double checkSimilarity(InputArray m1, InputArray m2)
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Helper structs for value-parameterized tests // Helper structs for value-parameterized tests
vector<MatDepth> depths(int depth_start, int depth_end)
{
vector<MatDepth> v;
v.reserve((depth_end - depth_start + 1));
for (int depth = depth_start; depth <= depth_end; ++depth)
v.push_back(depth);
return v;
}
vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end) vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end)
{ {
vector<MatType> v; vector<MatType> v;
...@@ -366,7 +341,7 @@ vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end) ...@@ -366,7 +341,7 @@ vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end)
{ {
for (int cn = cn_start; cn <= cn_end; ++cn) for (int cn = cn_start; cn <= cn_end; ++cn)
{ {
v.push_back(CV_MAKETYPE(depth, cn)); v.push_back(MatType(CV_MAKE_TYPE(depth, cn)));
} }
} }
...@@ -401,6 +376,14 @@ void PrintTo(const Inverse& inverse, std::ostream* os) ...@@ -401,6 +376,14 @@ void PrintTo(const Inverse& inverse, std::ostream* os)
(*os) << "direct"; (*os) << "direct";
} }
//////////////////////////////////////////////////////////////////////
// Other
void dumpImage(const std::string& fileName, const Mat& image)
{
imwrite(TS::ptr()->get_data_path() + fileName, image);
}
void showDiff(InputArray gold_, InputArray actual_, double eps) void showDiff(InputArray gold_, InputArray actual_, double eps)
{ {
Mat gold = getMat(gold_); Mat gold = getMat(gold_);
......
modules/gpu/test/utility.hpp
View file @ 1a76242d
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment