Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Changed tests for support intersection between expected and actual lists of lines.

Browse Source
pull/2658/head
Alexander Karsakov 11 years ago
parent 751264f88a
commit f3d1001c5d
3 changed files with 138 additions and 65 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      modules/imgproc/perf/perf_houghLines.cpp
  2. 3
      modules/imgproc/src/hough.cpp
  3. 191
      modules/imgproc/test/test_houghLines.cpp

9
modules/imgproc/perf/perf_houghLines.cpp
Unescape View File

@ -8,6 +8,11 @@ using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
bool polarComp(Vec2f a, Vec2f b)
{
return a[1] > b[1] || (a[1] == b[1] && a[0] < b[0]);
}
typedef std::tr1::tuple<string, double, double, int> Image_RhoStep_ThetaStep_Threshold_t;
typedef perf::TestBaseWithParam<Image_RhoStep_ThetaStep_Threshold_t> Image_RhoStep_ThetaStep_Threshold;
@ -36,6 +41,6 @@ PERF_TEST_P(Image_RhoStep_ThetaStep_Threshold, HoughLines,
TEST_CYCLE() HoughLines(image, lines, rhoStep, thetaStep, threshold);
transpose(lines, lines);
SANITY_CHECK(lines);
EXPECT_FALSE(lines.empty());
SANITY_CHECK_NOTHING();
}

3
modules/imgproc/src/hough.cpp
Unescape View File

@ -12,6 +12,7 @@
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Copyright (C) 2014, Itseez, Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
@ -97,7 +98,7 @@ HoughLinesStandard( const Mat& img, float rho, float theta,
int numangle = cvRound((max_theta - min_theta) / theta);
int numrho = cvRound(((width + height) * 2 + 1) / rho);
#if (defined(HAVE_IPP) && IPP_VERSION_MAJOR >= 8)
#if (defined(HAVE_IPP) && !defined(HAVE_IPP_ICV_ONLY) && IPP_VERSION_X100 >= 801)
IppiSize srcSize = { width, height };
IppPointPolar delta = { rho, theta };
IppPointPolar dstRoi[2] = {{(Ipp32f) -(width + height), (Ipp32f) min_theta},{(Ipp32f) (width + height), (Ipp32f) max_theta}};

191
modules/imgproc/test/test_houghLines.cpp
Unescape View File

@ -12,6 +12,7 @@
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2014, Itseez, Inc, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
@ -45,107 +46,173 @@
using namespace cv;
using namespace std;
class CV_HoughLinesTest : public cvtest::BaseTest
template<typename T>
struct SimilarWith
{
public:
enum {STANDART = 0, PROBABILISTIC};
CV_HoughLinesTest() {}
~CV_HoughLinesTest() {}
protected:
void run_test(int type);
T value;
double eps;
double rho_eps;
SimilarWith<T>(T val, double e, double r_e): value(val), eps(e), rho_eps(r_e) { };
bool operator()(T other);
};
class CV_StandartHoughLinesTest : public CV_HoughLinesTest
template<>
bool SimilarWith<Vec2f>::operator()(Vec2f other)
{
public:
CV_StandartHoughLinesTest() {}
~CV_StandartHoughLinesTest() {}
virtual void run(int);
};
return abs(other[0] - value[0]) < rho_eps && abs(other[1] - value[1]) < eps;
}
class CV_ProbabilisticHoughLinesTest : public CV_HoughLinesTest
template<>
bool SimilarWith<Vec4i>::operator()(Vec4i other)
{
public:
CV_ProbabilisticHoughLinesTest() {}
~CV_ProbabilisticHoughLinesTest() {}
virtual void run(int);
};
return abs(other[0] - value[0]) < eps && abs(other[1] - value[1]) < eps && abs(other[2] - value[2]) < eps && abs(other[2] - value[2]) < eps;
}
void CV_StandartHoughLinesTest::run(int)
template <typename T>
int countMatIntersection(Mat expect, Mat actual, double eps, double rho_eps)
{
run_test(STANDART);
int count = 0;
if (!expect.empty() && !actual.empty())
{
for (MatIterator_<T> it=expect.begin<T>(); it!=expect.end<T>(); it++)
{
MatIterator_<T> f = std::find_if(actual.begin<T>(), actual.end<T>(), SimilarWith<T>(*it, eps, rho_eps));
if (f != actual.end<T>())
count++;
}
}
return count;
}
void CV_ProbabilisticHoughLinesTest::run(int)
String getTestCaseName(String filename)
{
run_test(PROBABILISTIC);
string temp(filename);
size_t pos = temp.find_first_of("\\/.");
while ( pos != string::npos ) {
temp.replace( pos, 1, "_" );
pos = temp.find_first_of("\\/.");
}
return String(temp);
}
void CV_HoughLinesTest::run_test(int type)
class BaseHoughLineTest
{
Mat src = imread(string(ts->get_data_path()) + "shared/pic1.png");
if (src.empty())
public:
enum {STANDART = 0, PROBABILISTIC};
protected:
void run_test(int type);
string picture_name;
double rhoStep;
double thetaStep;
int threshold;
int minLineLength;
int maxGap;
};
typedef std::tr1::tuple<string, double, double, int> Image_RhoStep_ThetaStep_Threshold_t;
class StandartHoughLinesTest : public BaseHoughLineTest, public testing::TestWithParam<Image_RhoStep_ThetaStep_Threshold_t>
{
public:
StandartHoughLinesTest()
{
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
return;
picture_name = get<0>(GetParam());
rhoStep = get<1>(GetParam());
thetaStep = get<2>(GetParam());
threshold = get<3>(GetParam());
minLineLength = 0;
maxGap = 0;
}
};
typedef std::tr1::tuple<string, double, double, int, int, int> Image_RhoStep_ThetaStep_Threshold_MinLine_MaxGap_t;
class ProbabilisticHoughLinesTest : public BaseHoughLineTest, public testing::TestWithParam<Image_RhoStep_ThetaStep_Threshold_MinLine_MaxGap_t>
{
public:
ProbabilisticHoughLinesTest()
{
picture_name = get<0>(GetParam());
rhoStep = get<1>(GetParam());
thetaStep = get<2>(GetParam());
threshold = get<3>(GetParam());
minLineLength = get<4>(GetParam());
maxGap = get<5>(GetParam());
}
};
void BaseHoughLineTest::run_test(int type)
{
string filename = cvtest::TS::ptr()->get_data_path() + picture_name;
Mat src = imread(filename, IMREAD_GRAYSCALE);
EXPECT_FALSE(src.empty()) << "Invalid test image: " << filename;
string xml;
if (type == STANDART)
xml = string(ts->get_data_path()) + "imgproc/HoughLines.xml";
xml = string(cvtest::TS::ptr()->get_data_path()) + "imgproc/HoughLines.xml";
else if (type == PROBABILISTIC)
xml = string(ts->get_data_path()) + "imgproc/HoughLinesP.xml";
else
{
ts->printf(cvtest::TS::LOG, "Error: unknown HoughLines algorithm type.\n");
ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
return;
}
xml = string(cvtest::TS::ptr()->get_data_path()) + "imgproc/HoughLinesP.xml";
Mat dst;
Canny(src, dst, 50, 200, 3);
EXPECT_FALSE(dst.empty()) << "Failed Canny edge detector";
Mat lines;
if (type == STANDART)
HoughLines(dst, lines, 1, CV_PI/180, 100, 0, 0);
HoughLines(dst, lines, rhoStep, thetaStep, threshold, 0, 0);
else if (type == PROBABILISTIC)
HoughLinesP(dst, lines, 1, CV_PI/180, 100, 0, 0);
HoughLinesP(dst, lines, rhoStep, thetaStep, threshold, minLineLength, maxGap);
String test_case_name = format("lines_%s_%.0f_%.2f_%d_%d_%d", picture_name.c_str(), rhoStep, thetaStep,
threshold, minLineLength, maxGap);
test_case_name = getTestCaseName(test_case_name);
FileStorage fs(xml, FileStorage::READ);
if (!fs.isOpened())
FileNode node = fs[test_case_name];
if (node.empty())
{
fs.open(xml, FileStorage::WRITE);
if (!fs.isOpened())
{
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
return;
}
fs << "exp_lines" << lines;
fs.release();
fs.open(xml, FileStorage::APPEND);
EXPECT_TRUE(fs.isOpened()) << "Cannot open sanity data file: " << xml;
fs << test_case_name << lines;
fs.release();
fs.open(xml, FileStorage::READ);
if (!fs.isOpened())
{
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
return;
}
EXPECT_TRUE(fs.isOpened()) << "Cannot open sanity data file: " << xml;
}
Mat exp_lines;
read( fs["exp_lines"], exp_lines, Mat() );
read( fs[test_case_name], exp_lines, Mat() );
fs.release();
if( exp_lines.size != lines.size )
transpose(lines, lines);
float eps = 1e-2f;
int count = -1;
if (type == STANDART)
count = countMatIntersection<Vec2f>(exp_lines, lines, thetaStep + FLT_EPSILON, rhoStep + FLT_EPSILON);
else if (type == PROBABILISTIC)
count = countMatIntersection<Vec4i>(exp_lines, lines, thetaStep, 0.0);
if ( exp_lines.size != lines.size || cvtest::norm(exp_lines, lines, NORM_INF) > 1e-4 )
{
ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
return;
}
EXPECT_GE( count, (int) (exp_lines.total() * 0.8) );
}
ts->set_failed_test_info(cvtest::TS::OK);
TEST_P(StandartHoughLinesTest, regression)
{
run_test(STANDART);
}
TEST(Imgproc_HoughLines, regression) { CV_StandartHoughLinesTest test; test.safe_run(); }
TEST_P(ProbabilisticHoughLinesTest, regression)
{
run_test(PROBABILISTIC);
}
TEST(Imgproc_HoughLinesP, regression) { CV_ProbabilisticHoughLinesTest test; test.safe_run(); }
INSTANTIATE_TEST_CASE_P( ImgProc, StandartHoughLinesTest, testing::Combine(testing::Values( "shared/pic5.png", "../stitching/a1.png" ),
testing::Values( 1, 10 ),
testing::Values( 0.01, 0.1 ),
testing::Values( 100, 200 )
));
INSTANTIATE_TEST_CASE_P( ImgProc, ProbabilisticHoughLinesTest, testing::Combine(testing::Values( "shared/pic5.png", "shared/pic1.png" ),
testing::Values( 5, 10 ),
testing::Values( 0.01, 0.1 ),
testing::Values( 75, 150 ),
testing::Values( 0, 10 ),
testing::Values( 0, 4 )
));

Write Preview
Loading…
Cancel
Save