mirror of
https://github.com/opencv/opencv.git
synced 2024-12-13 16:09:23 +08:00
266 lines
6.5 KiB
C++
266 lines
6.5 KiB
C++
#include "test_precomp.hpp"
|
|
|
|
#include <vector>
|
|
|
|
using namespace cv;
|
|
using namespace std;
|
|
|
|
const Size img_size(640, 480);
|
|
const int LSD_TEST_SEED = 0x134679;
|
|
const int EPOCHS = 20;
|
|
|
|
class LSDBase : public testing::Test
|
|
{
|
|
public:
|
|
LSDBase() { }
|
|
|
|
protected:
|
|
Mat test_image;
|
|
vector<Vec4i> lines;
|
|
RNG rng;
|
|
int passedtests;
|
|
|
|
void GenerateWhiteNoise(Mat& image);
|
|
void GenerateConstColor(Mat& image);
|
|
void GenerateLines(Mat& image, const unsigned int numLines);
|
|
void GenerateRotatedRect(Mat& image);
|
|
virtual void SetUp();
|
|
};
|
|
|
|
class Imgproc_LSD_ADV: public LSDBase
|
|
{
|
|
public:
|
|
Imgproc_LSD_ADV() { }
|
|
protected:
|
|
|
|
};
|
|
|
|
class Imgproc_LSD_STD: public LSDBase
|
|
{
|
|
public:
|
|
Imgproc_LSD_STD() { }
|
|
protected:
|
|
|
|
};
|
|
|
|
class Imgproc_LSD_NONE: public LSDBase
|
|
{
|
|
public:
|
|
Imgproc_LSD_NONE() { }
|
|
protected:
|
|
|
|
};
|
|
|
|
void LSDBase::GenerateWhiteNoise(Mat& image)
|
|
{
|
|
image = Mat(img_size, CV_8UC1);
|
|
rng.fill(image, RNG::UNIFORM, 0, 256);
|
|
}
|
|
|
|
void LSDBase::GenerateConstColor(Mat& image)
|
|
{
|
|
image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 256)));
|
|
}
|
|
|
|
void LSDBase::GenerateLines(Mat& image, const unsigned int numLines)
|
|
{
|
|
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), 3);
|
|
}
|
|
}
|
|
|
|
void LSDBase::GenerateRotatedRect(Mat& image)
|
|
{
|
|
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.f, 360.f);
|
|
|
|
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), 3);
|
|
}
|
|
}
|
|
|
|
void LSDBase::SetUp()
|
|
{
|
|
lines.clear();
|
|
test_image = Mat();
|
|
rng = RNG(LSD_TEST_SEED);
|
|
passedtests = 0;
|
|
}
|
|
|
|
|
|
TEST_F(Imgproc_LSD_ADV, whiteNoise)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateWhiteNoise(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_ADV);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(40u >= lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_ADV, constColor)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateConstColor(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_ADV);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(0u == lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_ADV, lines)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
const unsigned int numOfLines = 1;
|
|
GenerateLines(test_image, numOfLines);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_ADV);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(numOfLines * 2 == lines.size()) ++passedtests; // * 2 because of Gibbs effect
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_ADV, rotatedRect)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateRotatedRect(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_ADV);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(2u <= lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_STD, whiteNoise)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateWhiteNoise(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_STD);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(50u >= lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_STD, constColor)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateConstColor(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_STD);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(0u == lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_STD, lines)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
const unsigned int numOfLines = 1;
|
|
GenerateLines(test_image, numOfLines);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_STD);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(numOfLines * 2 == lines.size()) ++passedtests; // * 2 because of Gibbs effect
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_STD, rotatedRect)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateRotatedRect(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_STD);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(4u <= lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_NONE, whiteNoise)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateWhiteNoise(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_STD);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(50u >= lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_NONE, constColor)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateConstColor(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_NONE);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(0u == lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_NONE, lines)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
const unsigned int numOfLines = 1;
|
|
GenerateLines(test_image, numOfLines);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_NONE);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(numOfLines * 2 == lines.size()) ++passedtests; // * 2 because of Gibbs effect
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|
|
|
|
TEST_F(Imgproc_LSD_NONE, rotatedRect)
|
|
{
|
|
for (int i = 0; i < EPOCHS; ++i)
|
|
{
|
|
GenerateRotatedRect(test_image);
|
|
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_NONE);
|
|
detector->detect(test_image, lines);
|
|
|
|
if(8u <= lines.size()) ++passedtests;
|
|
}
|
|
ASSERT_EQ(EPOCHS, passedtests);
|
|
}
|