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

Merge pull request #12222 from NCBee:master

Browse Source
pull/10485/merge
Alexander Alekhin 7 years ago
parent b996b618e0 98c5ce9347
commit b907bfe3e7
2 changed files with 125 additions and 97 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. 90
      modules/imgproc/src/intersection.cpp
  2. 132
      modules/imgproc/test/test_intersection.cpp

90
modules/imgproc/src/intersection.cpp
Unescape View File

@ -51,12 +51,13 @@ int rotatedRectangleIntersection( const RotatedRect& rect1, const RotatedRect& r
{
CV_INSTRUMENT_REGION()
const float samePointEps = 0.00001f; // used to test if two points are the same
// L2 metric
const float samePointEps = std::max(1e-16f, 1e-6f * (float)std::max(rect1.size.area(), rect2.size.area()));
Point2f vec1[4], vec2[4];
Point2f pts1[4], pts2[4];
std::vector <Point2f> intersection;
std::vector <Point2f> intersection; intersection.reserve(24);
rect1.points(pts1);
rect2.points(pts2);
@ -219,41 +220,80 @@ int rotatedRectangleIntersection( const RotatedRect& rect1, const RotatedRect& r
}
}
// Get rid of dupes and order points.
for( int i = 0; i < (int)intersection.size()-1; i++ )
int N = (int)intersection.size();
if (N == 0)
{
float dx1 = intersection[i + 1].x - intersection[i].x;
float dy1 = intersection[i + 1].y - intersection[i].y;
for( size_t j = i+1; j < intersection.size(); j++ )
{
float dx = intersection[j].x - intersection[i].x;
float dy = intersection[j].y - intersection[i].y;
double d2 = dx*dx + dy*dy; // can be a really small number, need double here
return INTERSECT_NONE;
}
if( d2 < samePointEps*samePointEps )
// Get rid of duplicated points
int Nstride = N;
cv::AutoBuffer<float, 100> distPt(N * N);
cv::AutoBuffer<int> ptDistRemap(N);
for (int i = 0; i < N; ++i)
{
const Point2f pt0 = intersection[i];
ptDistRemap[i] = i;
for (int j = i + 1; j < N; )
{
const Point2f pt1 = intersection[j];
float d2 = normL2Sqr<float>(pt1 - pt0);
if(d2 <= samePointEps)
{
// Found a dupe, remove it
std::swap(intersection[j], intersection.back());
intersection.pop_back();
j--; // restart check
if (j < N - 1)
intersection[j] = intersection[N - 1];
N--;
continue;
}
else if (dx1 * dy - dy1 * dx < 0)
distPt[i*Nstride + j] = d2;
++j;
}
}
while (N > 8) // we still have duplicate points after samePointEps threshold (eliminate closest points)
{
int minI = 0;
int minJ = 1;
float minD = distPt[1];
for (int i = 0; i < N - 1; ++i)
{
float* pDist = distPt.data() + Nstride * ptDistRemap[i];
for (int j = i + 1; j < N; ++j)
{
std::swap(intersection[i + 1], intersection[j]);
dx1 = dx;
dy1 = dy;
float d = pDist[ptDistRemap[j]];
if (d < minD)
{
minD = d;
minI = i;
minJ = j;
}
}
}
CV_Assert(fabs(normL2Sqr<float>(intersection[minI] - intersection[minJ]) - minD) < 1e-6); // ptDistRemap is not corrupted
// drop minJ point
if (minJ < N - 1)
{
intersection[minJ] = intersection[N - 1];
ptDistRemap[minJ] = ptDistRemap[N - 1];
}
N--;
}
if( intersection.empty() )
// order points
for (int i = 0; i < N - 1; ++i)
{
return INTERSECT_NONE ;
Point2f diffI = intersection[i + 1] - intersection[i];
for (int j = i + 2; j < N; ++j)
{
Point2f diffJ = intersection[j] - intersection[i];
if (diffI.cross(diffJ) < 0)
{
std::swap(intersection[i + 1], intersection[j]);
diffI = diffJ;
}
}
}
// If this check fails then it means we're getting dupes, increase samePointEps
CV_Assert( intersection.size() <= 8 );
intersection.resize(N);
Mat(intersection).copyTo(intersectingRegion);
return ret;

132
modules/imgproc/test/test_intersection.cpp
Unescape View File

@ -49,29 +49,18 @@ namespace opencv_test { namespace {
#define ACCURACY 0.00001
class CV_RotatedRectangleIntersectionTest: public cvtest::ArrayTest
{
public:
protected:
void run (int);
private:
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
void test8();
void test9();
void test10();
void test11();
void test12();
void test13();
void test14();
};
// See pics/intersection.png for the scenarios we are testing
// Test the following scenarios:
// 1 - no intersection
// 2 - partial intersection, rectangle translated
// 3 - partial intersection, rectangle rotated 45 degree on the corner, forms a triangle intersection
// 4 - full intersection, rectangles of same size directly on top of each other
// 5 - partial intersection, rectangle on top rotated 45 degrees
// 6 - partial intersection, rectangle on top of different size
// 7 - full intersection, rectangle fully enclosed in the other
// 8 - partial intersection, rectangle corner just touching. point contact
// 9 - partial intersetion. rectangle side by side, line contact
static void compare(const std::vector<Point2f>& test, const std::vector<Point2f>& target)
{
@ -80,45 +69,12 @@ static void compare(const std::vector<Point2f>& test, const std::vector<Point2f>
ASSERT_TRUE(target.size() < 4 || isContourConvex(target));
for( size_t i = 0; i < test.size(); i++ )
{
double dx = test[i].x - target[i].x;
double dy = test[i].y - target[i].y;
double r = sqrt(dx*dx + dy*dy);
double r = sqrt(normL2Sqr<double>(test[i] - target[i]));
ASSERT_LT(r, ACCURACY);
}
}
void CV_RotatedRectangleIntersectionTest::run(int)
{
// See pics/intersection.png for the scenarios we are testing
// Test the following scenarios:
// 1 - no intersection
// 2 - partial intersection, rectangle translated
// 3 - partial intersection, rectangle rotated 45 degree on the corner, forms a triangle intersection
// 4 - full intersection, rectangles of same size directly on top of each other
// 5 - partial intersection, rectangle on top rotated 45 degrees
// 6 - partial intersection, rectangle on top of different size
// 7 - full intersection, rectangle fully enclosed in the other
// 8 - partial intersection, rectangle corner just touching. point contact
// 9 - partial intersetion. rectangle side by side, line contact
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
test9();
test10();
test11();
test12();
test13();
test14();
}
void CV_RotatedRectangleIntersectionTest::test1()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_1)
{
// no intersection
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 12.0f);
@ -131,7 +87,7 @@ void CV_RotatedRectangleIntersectionTest::test1()
CV_Assert(vertices.empty());
}
void CV_RotatedRectangleIntersectionTest::test2()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_2)
{
// partial intersection, rectangles translated
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -150,7 +106,7 @@ void CV_RotatedRectangleIntersectionTest::test2()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test3()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_3)
{
// partial intersection, rectangles rotated 45 degree on the corner, forms a triangle intersection
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -168,7 +124,7 @@ void CV_RotatedRectangleIntersectionTest::test3()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test4()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_4)
{
// full intersection, rectangles of same size directly on top of each other
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -187,7 +143,7 @@ void CV_RotatedRectangleIntersectionTest::test4()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test5()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_5)
{
// partial intersection, rectangle on top rotated 45 degrees
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -210,7 +166,7 @@ void CV_RotatedRectangleIntersectionTest::test5()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test6()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_6)
{
// 6 - partial intersection, rectangle on top of different size
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -229,7 +185,7 @@ void CV_RotatedRectangleIntersectionTest::test6()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test7()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_7)
{
// full intersection, rectangle fully enclosed in the other
RotatedRect rect1(Point2f(0, 0), Size2f(12.34f, 56.78f), 0.0f);
@ -248,7 +204,7 @@ void CV_RotatedRectangleIntersectionTest::test7()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test8()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_8)
{
// intersection by a single vertex
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -261,7 +217,7 @@ void CV_RotatedRectangleIntersectionTest::test8()
compare(vertices, vector<Point2f>(1, Point2f(1.0f, 1.0f)));
}
void CV_RotatedRectangleIntersectionTest::test9()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_9)
{
// full intersection, rectangle fully enclosed in the other
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -278,7 +234,7 @@ void CV_RotatedRectangleIntersectionTest::test9()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test10()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_10)
{
// three points of rect2 are inside rect1.
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
@ -298,7 +254,7 @@ void CV_RotatedRectangleIntersectionTest::test10()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test11()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_11)
{
RotatedRect rect1(Point2f(0, 0), Size2f(4, 2), 0.0f);
RotatedRect rect2(Point2f(0, 0), Size2f(2, 2), -45.0f);
@ -318,7 +274,7 @@ void CV_RotatedRectangleIntersectionTest::test11()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test12()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_12)
{
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
RotatedRect rect2(Point2f(0, 1), Size2f(1, 1), 0.0f);
@ -336,7 +292,7 @@ void CV_RotatedRectangleIntersectionTest::test12()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test13()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_13)
{
RotatedRect rect1(Point2f(0, 0), Size2f(1, 3), 0.0f);
RotatedRect rect2(Point2f(0, 1), Size2f(3, 1), 0.0f);
@ -354,7 +310,7 @@ void CV_RotatedRectangleIntersectionTest::test13()
compare(vertices, targetVertices);
}
void CV_RotatedRectangleIntersectionTest::test14()
TEST(Imgproc_RotatedRectangleIntersection, accuracy_14)
{
const int kNumTests = 100;
const float kWidth = 5;
@ -376,6 +332,38 @@ void CV_RotatedRectangleIntersectionTest::test14()
}
}
TEST (Imgproc_RotatedRectangleIntersection, accuracy) { CV_RotatedRectangleIntersectionTest test; test.safe_run(); }
TEST(Imgproc_RotatedRectangleIntersection, regression_12221_1)
{
RotatedRect r1(
Point2f(259.65081787109375, 51.58895492553711),
Size2f(5487.8779296875, 233.8921661376953),
-29.488616943359375);
RotatedRect r2(
Point2f(293.70465087890625, 112.10154724121094),
Size2f(5487.8896484375, 234.87368774414062),
-31.27001953125);
std::vector<Point2f> intersections;
int interType = cv::rotatedRectangleIntersection(r1, r2, intersections);
EXPECT_EQ(INTERSECT_PARTIAL, interType);
EXPECT_LE(intersections.size(), (size_t)8);
}
TEST(Imgproc_RotatedRectangleIntersection, regression_12221_2)
{
RotatedRect r1(
Point2f(239.78500366210938, 515.72021484375),
Size2f(70.23420715332031, 39.74684524536133),
-42.86162567138672);
RotatedRect r2(
Point2f(242.4205322265625, 510.1195373535156),
Size2f(66.85948944091797, 61.46455383300781),
-9.840961456298828);
std::vector<Point2f> intersections;
int interType = cv::rotatedRectangleIntersection(r1, r2, intersections);
EXPECT_EQ(INTERSECT_PARTIAL, interType);
EXPECT_LE(intersections.size(), (size_t)8);
}
}} // namespace

Write Preview
Loading…
Cancel
Save