From e51e00ac5fd32625cf73c55af0f360da8aaee7bd Mon Sep 17 00:00:00 2001 From: Daniel Angelov Date: Sat, 13 Jul 2013 00:25:33 +0300 Subject: [PATCH] Added LSD accuracy tests. --- modules/imgproc/include/opencv2/imgproc.hpp | 2 +- modules/imgproc/src/lsd.cpp | 14 +- modules/imgproc/test/test_lsd.cpp | 212 ++++++++++++++++++++++++++++ 3 files changed, 217 insertions(+), 11 deletions(-) create mode 100644 modules/imgproc/test/test_lsd.cpp diff --git a/modules/imgproc/include/opencv2/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc.hpp index 000059f..5f71c59 100644 --- a/modules/imgproc/include/opencv2/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc.hpp @@ -844,7 +844,7 @@ public: * Create an LSD object. Specifying scale, number of subdivisions for the image, should the lines be refined and other constants as follows: * * @param _refine How should the lines found be refined? - * NO_REFINE - No refinement applied. + * REFINE_NONE - No refinement applied. * REFINE_STD - Standard refinement is applied. E.g. breaking arches into smaller line approximations. * REFINE_ADV - Advanced refinement. Number of false alarms is calculated, * lines are refined through increase of precision, decrement in size, etc. diff --git a/modules/imgproc/src/lsd.cpp b/modules/imgproc/src/lsd.cpp index a4384d5..f0098a8 100644 --- a/modules/imgproc/src/lsd.cpp +++ b/modules/imgproc/src/lsd.cpp @@ -1,4 +1,4 @@ -/*/////////////////////////////////////////////////////////////////////////////////////// +/*M/////////////////////////////////////////////////////////////////////////////////////// // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to this license. @@ -37,13 +37,8 @@ // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. // -//*/ +//M*/ -#include -#include -#include -#include -#include #include #include "precomp.hpp" @@ -61,13 +56,12 @@ using namespace cv; // PI #ifndef M_PI -#define M_PI CV_PI // 3.14159265358979323846 +#define M_PI CV_PI // 3.14159265358979323846 #endif #define M_3_2_PI (3 * CV_PI) / 2 // 4.71238898038 // 3/2 pi #define M_2__PI 2 * CV_PI // 6.28318530718 // 2 pi -// Label for pixels with undefined gradient. -#define NOTDEF double(-1024.0) +#define NOTDEF double(-1024.0) // Label for pixels with undefined gradient. #define NOTUSED 0 // Label for pixels not used in yet. #define USED 1 // Label for pixels already used in detection. diff --git a/modules/imgproc/test/test_lsd.cpp b/modules/imgproc/test/test_lsd.cpp new file mode 100644 index 0000000..3ed08ba --- /dev/null +++ b/modules/imgproc/test/test_lsd.cpp @@ -0,0 +1,212 @@ +#include "test_precomp.hpp" + +#include + +using namespace cv; +using namespace std; + +const Size img_size(640, 480); + +class LSDBase : public testing::Test +{ +public: + LSDBase() {}; + +protected: + Mat test_image; + vector lines; + + void GenerateWhiteNoise(Mat& image); + void GenerateConstColor(Mat& image); + void GenerateLines(Mat& image, const unsigned int numLines); + void GenerateRotatedRect(Mat& image); + virtual void SetUp(); +}; + +class LSD_ADV: public LSDBase +{ +public: + LSD_ADV() {}; +protected: + +}; + +class LSD_STD: public LSDBase +{ +public: + LSD_STD() {}; +protected: + +}; + +class LSD_NONE: public LSDBase +{ +public: + LSD_NONE() {}; +protected: + +}; + +void LSDBase::GenerateWhiteNoise(Mat& image) +{ + image = Mat(img_size, CV_8UC1); + RNG rng(getTickCount()); + rng.fill(image, RNG::UNIFORM, 0, 256); +} + +void LSDBase::GenerateConstColor(Mat& image) +{ + RNG rng(getTickCount()); + image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 256))); +} + +void LSDBase::GenerateLines(Mat& image, const unsigned int numLines) +{ + RNG rng(getTickCount()); + image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 128))); + + for(unsigned int i = 0; i < numLines; ++i) + { + int y = rng.uniform(10, img_size.width - 10); + Point p1(y, 10); + Point p2(y, img_size.height - 10); + line(image, p1, p2, Scalar(255), 1); + } +} + +void LSDBase::GenerateRotatedRect(Mat& image) +{ + RNG rng(getTickCount()); + image = Mat::zeros(img_size, CV_8UC1); + + Point center(rng.uniform(img_size.width/4, img_size.width*3/4), + rng.uniform(img_size.height/4, img_size.height*3/4)); + Size rect_size(rng.uniform(img_size.width/8, img_size.width/6), + rng.uniform(img_size.height/8, img_size.height/6)); + float angle = rng.uniform(0, 360); + + Point2f vertices[4]; + + RotatedRect rRect = RotatedRect(center, rect_size, angle); + + rRect.points(vertices); + for (int i = 0; i < 4; i++) + { + line(image, vertices[i], vertices[(i + 1) % 4], Scalar(255)); + } +} + +void LSDBase::SetUp() +{ + lines.clear(); + test_image = Mat(); +} + + +TEST_F(LSD_ADV, whiteNoise) +{ + GenerateWhiteNoise(test_image); + LSD detector(LSD_REFINE_ADV); + detector.detect(test_image, lines); + + ASSERT_GE(40, lines.size()); +} + +TEST_F(LSD_ADV, constColor) +{ + GenerateConstColor(test_image); + LSD detector(LSD_REFINE_ADV); + detector.detect(test_image, lines); + + ASSERT_EQ(0, lines.size()); +} + +TEST_F(LSD_ADV, lines) +{ + const int numOfLines = 3; + GenerateLines(test_image, numOfLines); + LSD detector(LSD_REFINE_ADV); + detector.detect(test_image, lines); + + ASSERT_EQ(numOfLines * 2, lines.size()); // * 2 because of Gibbs effect +} + +TEST_F(LSD_ADV, rotatedRect) +{ + GenerateRotatedRect(test_image); + LSD detector(LSD_REFINE_ADV); + detector.detect(test_image, lines); + ASSERT_LE(4, lines.size()); +} + +TEST_F(LSD_STD, whiteNoise) +{ + GenerateWhiteNoise(test_image); + LSD detector(LSD_REFINE_STD); + detector.detect(test_image, lines); + + ASSERT_GE(50, lines.size()); +} + +TEST_F(LSD_STD, constColor) +{ + GenerateConstColor(test_image); + LSD detector(LSD_REFINE_STD); + detector.detect(test_image, lines); + + ASSERT_EQ(0, lines.size()); +} + +TEST_F(LSD_STD, lines) +{ + const int numOfLines = 3; //1 + GenerateLines(test_image, numOfLines); + LSD detector(LSD_REFINE_STD); + detector.detect(test_image, lines); + + ASSERT_EQ(numOfLines * 2, lines.size()); // * 2 because of Gibbs effect +} + +TEST_F(LSD_STD, rotatedRect) +{ + GenerateRotatedRect(test_image); + LSD detector(LSD_REFINE_STD); + detector.detect(test_image, lines); + ASSERT_EQ(8, lines.size()); +} + +TEST_F(LSD_NONE, whiteNoise) +{ + GenerateWhiteNoise(test_image); + LSD detector(LSD_REFINE_NONE); + detector.detect(test_image, lines); + + ASSERT_GE(50, lines.size()); +} + +TEST_F(LSD_NONE, constColor) +{ + GenerateConstColor(test_image); + LSD detector(LSD_REFINE_NONE); + detector.detect(test_image, lines); + + ASSERT_EQ(0, lines.size()); +} + +TEST_F(LSD_NONE, lines) +{ + const int numOfLines = 3; //1 + GenerateLines(test_image, numOfLines); + LSD detector(LSD_REFINE_NONE); + detector.detect(test_image, lines); + + ASSERT_EQ(numOfLines * 2, lines.size()); // * 2 because of Gibbs effect +} + +TEST_F(LSD_NONE, rotatedRect) +{ + GenerateRotatedRect(test_image); + LSD detector(LSD_REFINE_NONE); + detector.detect(test_image, lines); + ASSERT_EQ(8, lines.size()); +} -- 2.7.4