generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fixed compilation errors

Browse Source
This commit is contained in:
Vladislav Vinogradov
2013-04-17 15:24:53 +04:00
parent 8fdab9f631
commit 54e7c76d99
41 changed files with 205 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
modules/gpu/test/test_bgfg.cpp
View File

@@ -41,6 +41,7 @@
//M*/
#include "test_precomp.hpp"
#include "opencv2/legacy.hpp"
#ifdef HAVE_CUDA

89
modules/gpu/test/test_core.cpp
View File

@@ -89,7 +89,7 @@ GPU_TEST_P(Merge, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -151,7 +151,7 @@ GPU_TEST_P(Split, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -221,7 +221,7 @@ GPU_TEST_P(Add_Array, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -283,7 +283,7 @@ GPU_TEST_P(Add_Array_Mask, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -340,7 +340,7 @@ GPU_TEST_P(Add_Scalar, WithOutMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -371,7 +371,7 @@ GPU_TEST_P(Add_Scalar, WithMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -436,7 +436,7 @@ GPU_TEST_P(Subtract_Array, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -498,7 +498,7 @@ GPU_TEST_P(Subtract_Array_Mask, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -555,7 +555,7 @@ GPU_TEST_P(Subtract_Scalar, WithOutMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -586,7 +586,7 @@ GPU_TEST_P(Subtract_Scalar, WithMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -651,7 +651,7 @@ GPU_TEST_P(Multiply_Array, WithOutScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -681,7 +681,7 @@ GPU_TEST_P(Multiply_Array, WithScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -836,7 +836,7 @@ GPU_TEST_P(Multiply_Scalar, WithOutScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -867,7 +867,7 @@ GPU_TEST_P(Multiply_Scalar, WithScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -931,7 +931,7 @@ GPU_TEST_P(Divide_Array, WithOutScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -961,7 +961,7 @@ GPU_TEST_P(Divide_Array, WithScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1116,7 +1116,7 @@ GPU_TEST_P(Divide_Scalar, WithOutScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1146,7 +1146,7 @@ GPU_TEST_P(Divide_Scalar, WithScale)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1202,7 +1202,7 @@ GPU_TEST_P(Divide_Scalar_Inv, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1258,7 +1258,7 @@ GPU_TEST_P(AbsDiff, Array)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1287,7 +1287,7 @@ GPU_TEST_P(AbsDiff, Scalar)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1649,7 +1649,7 @@ GPU_TEST_P(Compare_Array, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -1759,7 +1759,7 @@ GPU_TEST_P(Compare_Scalar, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2110,7 +2110,7 @@ GPU_TEST_P(Min, Array)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2138,7 +2138,7 @@ GPU_TEST_P(Min, Scalar)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2193,7 +2193,7 @@ GPU_TEST_P(Max, Array)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2221,7 +2221,7 @@ GPU_TEST_P(Max, Scalar)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2279,7 +2279,7 @@ GPU_TEST_P(Pow, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2342,7 +2342,7 @@ GPU_TEST_P(AddWeighted, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2410,7 +2410,7 @@ GPU_TEST_P(GEMM, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else if (type == CV_64FC2 && flags != 0)
@@ -2422,7 +2422,7 @@ GPU_TEST_P(GEMM, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else
@@ -2480,7 +2480,7 @@ GPU_TEST_P(Transpose, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -2871,7 +2871,7 @@ GPU_TEST_P(MeanStdDev, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else
@@ -3153,7 +3153,7 @@ GPU_TEST_P(MinMax, WithoutMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3183,7 +3183,7 @@ GPU_TEST_P(MinMax, WithMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3213,7 +3213,7 @@ GPU_TEST_P(MinMax, NullPtr)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3298,7 +3298,7 @@ GPU_TEST_P(MinMaxLoc, WithoutMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3334,7 +3334,7 @@ GPU_TEST_P(MinMaxLoc, WithMask)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3372,7 +3372,7 @@ GPU_TEST_P(MinMaxLoc, NullPtr)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3438,7 +3438,7 @@ GPU_TEST_P(CountNonZero, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -3460,8 +3460,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, CountNonZero, testing::Combine(
//////////////////////////////////////////////////////////////////////////////
// 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))
CV_ENUM(ReduceCode, REDUCE_SUM, REDUCE_AVG, REDUCE_MAX, REDUCE_MIN)
PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, UseRoi)
{
@@ -3489,9 +3488,9 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
type = CV_MAKE_TYPE(depth, channels);
if (reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN)
if (reduceOp == cv::REDUCE_MAX || reduceOp == cv::REDUCE_MIN)
dst_depth = depth;
else if (reduceOp == CV_REDUCE_SUM)
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;
@@ -3539,7 +3538,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
MatDepth(CV_32F),
MatDepth(CV_64F)),
ALL_CHANNELS,
ALL_REDUCE_CODES,
ReduceCode::all(),
WHOLE_SUBMAT));
//////////////////////////////////////////////////////////////////////////////

4
modules/gpu/test/test_denoising.cpp
View File

@@ -116,7 +116,7 @@ GPU_TEST_P(BruteForceNonLocalMeans, Regression)
ASSERT_FALSE(bgr.empty());
cv::Mat gray;
cv::cvtColor(bgr, gray, CV_BGR2GRAY);
cv::cvtColor(bgr, gray, cv::COLOR_BGR2GRAY);
GpuMat dbgr, dgray;
cv::gpu::nonLocalMeans(GpuMat(bgr), dbgr, 20);
@@ -159,7 +159,7 @@ GPU_TEST_P(FastNonLocalMeans, Regression)
ASSERT_FALSE(bgr.empty());
cv::Mat gray;
cv::cvtColor(bgr, gray, CV_BGR2GRAY);
cv::cvtColor(bgr, gray, cv::COLOR_BGR2GRAY);
GpuMat dbgr, dgray;
cv::gpu::FastNonLocalMeansDenoising fnlmd;

8
modules/gpu/test/test_features2d.cpp
View File

@@ -88,7 +88,7 @@ GPU_TEST_P(FAST, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else
@@ -176,7 +176,7 @@ GPU_TEST_P(ORB, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else
@@ -581,7 +581,7 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else
@@ -646,7 +646,7 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else

2
modules/gpu/test/test_filters.cpp
View File

@@ -286,7 +286,7 @@ GPU_TEST_P(GaussianBlur, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else

12
modules/gpu/test/test_gpumat.cpp
View File

@@ -90,7 +90,7 @@ GPU_TEST_P(SetTo, SameVal)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -115,7 +115,7 @@ GPU_TEST_P(SetTo, DifferentVal)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -142,7 +142,7 @@ GPU_TEST_P(SetTo, Masked)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -210,7 +210,7 @@ GPU_TEST_P(CopyTo, Masked)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -269,7 +269,7 @@ GPU_TEST_P(ConvertTo, WithOutScaling)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else
@@ -301,7 +301,7 @@ GPU_TEST_P(ConvertTo, WithScaling)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
ASSERT_EQ(cv::Error::StsUnsupportedFormat, e.code);
}
}
else

2
modules/gpu/test/test_hough.cpp
View File

@@ -149,7 +149,7 @@ GPU_TEST_P(HoughCircles, Accuracy)
drawCircles(src, circles_gold, true);
cv::gpu::GpuMat d_circles;
cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, cv::HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
std::vector<cv::Vec3f> circles;
cv::gpu::HoughCirclesDownload(d_circles, circles);

16
modules/gpu/test/test_imgproc.cpp
View File

@@ -104,7 +104,7 @@ GPU_TEST_P(HistEven, Accuracy)
ASSERT_FALSE(img.empty());
cv::Mat hsv;
cv::cvtColor(img, hsv, CV_BGR2HSV);
cv::cvtColor(img, hsv, cv::COLOR_BGR2HSV);
int hbins = 30;
float hranges[] = {0.0f, 180.0f};
@@ -353,7 +353,7 @@ GPU_TEST_P(Canny, Accuracy)
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
ASSERT_EQ(cv::Error::StsNotImplemented, e.code);
}
}
else
@@ -417,7 +417,7 @@ GPU_TEST_P(MeanShift, Filtering)
cv::Mat dst(d_dst);
cv::Mat result;
cv::cvtColor(dst, result, CV_BGRA2BGR);
cv::cvtColor(dst, result, cv::COLOR_BGRA2BGR);
EXPECT_MAT_NEAR(img_template, result, 0.0);
}
@@ -490,7 +490,7 @@ GPU_TEST_P(MeanShiftSegmentation, Regression)
cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
cv::Mat dst_rgb;
cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
cv::cvtColor(dst, dst_rgb, cv::COLOR_BGRA2BGR);
EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
}
@@ -828,7 +828,7 @@ GPU_TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
ASSERT_FALSE(pattern.empty());
cv::gpu::GpuMat d_dst;
cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, cv::TM_CCOEFF_NORMED);
cv::Mat dst(d_dst);
@@ -837,7 +837,7 @@ GPU_TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
cv::Mat dstGold;
cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
cv::matchTemplate(image, pattern, dstGold, cv::TM_CCOEFF_NORMED);
double minValGold, maxValGold;
cv::Point minLocGold, maxLocGold;
@@ -877,7 +877,7 @@ GPU_TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
ASSERT_FALSE(templ.empty());
cv::gpu::GpuMat d_result;
cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, cv::TM_SQDIFF_NORMED);
cv::Mat result(d_result);
@@ -900,7 +900,7 @@ GPU_TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
ASSERT_FALSE(templ.empty());
cv::gpu::GpuMat d_result;
cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, cv::TM_SQDIFF);
cv::Mat result(d_result);

4
modules/gpu/test/test_labeling.cpp
View File

@@ -170,9 +170,9 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
GPU_TEST_P(Labeling, DISABLED_ConnectedComponents)
{
cv::Mat image;
cvtColor(loat_image(), image, CV_BGR2GRAY);
cvtColor(loat_image(), image, cv::COLOR_BGR2GRAY);
cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
cv::threshold(image, image, 150, 255, cv::THRESH_BINARY);
ASSERT_TRUE(image.type() == CV_8UC1);

22
modules/gpu/test/test_objdetect.cpp
View File

@@ -192,11 +192,11 @@ GPU_TEST_P(HOG, Detect)
// Test on color image
cv::Mat img;
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
testDetect(img);
// Test on gray image
cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2GRAY);
testDetect(img);
f.close();
@@ -210,7 +210,7 @@ GPU_TEST_P(HOG, GetDescriptors)
// Convert to C4
cv::Mat img;
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
cv::gpu::GpuMat d_img(img);
@@ -250,38 +250,38 @@ GPU_TEST_P(HOG, GetDescriptors)
img_rgb = readImage("hog/positive1.png");
ASSERT_TRUE(!img_rgb.empty());
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
computeBlockHistograms(cv::gpu::GpuMat(img));
// Everything is fine with interpolation for left top subimage
ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
img_rgb = readImage("hog/positive2.png");
ASSERT_TRUE(!img_rgb.empty());
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
computeBlockHistograms(cv::gpu::GpuMat(img));
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
img_rgb = readImage("hog/negative1.png");
ASSERT_TRUE(!img_rgb.empty());
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
computeBlockHistograms(cv::gpu::GpuMat(img));
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
img_rgb = readImage("hog/negative2.png");
ASSERT_TRUE(!img_rgb.empty());
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
computeBlockHistograms(cv::gpu::GpuMat(img));
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
img_rgb = readImage("hog/positive3.png");
ASSERT_TRUE(!img_rgb.empty());
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
computeBlockHistograms(cv::gpu::GpuMat(img));
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
img_rgb = readImage("hog/negative3.png");
ASSERT_TRUE(!img_rgb.empty());
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA);
computeBlockHistograms(cv::gpu::GpuMat(img));
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
}
@@ -385,7 +385,7 @@ GPU_TEST_P(LBP_classify, Accuracy)
cv::Mat image = cv::imread(imagePath);
image = image.colRange(0, image.cols/2);
cv::Mat grey;
cvtColor(image, grey, CV_BGR2GRAY);
cvtColor(image, grey, cv::COLOR_BGR2GRAY);
ASSERT_FALSE(image.empty());
std::vector<cv::Rect> rects;
@@ -394,7 +394,7 @@ GPU_TEST_P(LBP_classify, Accuracy)
std::vector<cv::Rect>::iterator it = rects.begin();
for (; it != rects.end(); ++it)
cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
cv::rectangle(markedImage, *it, cv::Scalar(255, 0, 0));
cv::gpu::CascadeClassifier_GPU gpuClassifier;
ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));

1
modules/gpu/test/test_optflow.cpp
View File

@@ -41,6 +41,7 @@
//M*/
#include "test_precomp.hpp"
#include "opencv2/legacy.hpp"
#ifdef HAVE_CUDA