Skip to content

Commit 235221c

Browse files
rikbarikba
committed
Polygon comparison for permutations.
1 parent 67cfa45 commit 235221c

File tree

2 files changed

+75
-75
lines changed

2 files changed

+75
-75
lines changed

‎polygon_coverage_geometry/include/polygon_coverage_geometry/cgal_definitions.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ typedef CGAL::Exact_predicates_exact_constructions_kernel K;
2828
typedef K::FT FT;
2929
typedef K::Point_2 Point_2;
3030
typedef K::Point_3 Point_3;
31+
typedef K::Ray_2 Ray_2;
3132
typedef K::Vector_2 Vector_2;
3233
typedef K::Direction_2 Direction_2;
3334
typedef K::Line_2 Line_2;

‎polygon_coverage_geometry/test/visibility_polygon-test.cpp‎

Lines changed: 74 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -19,95 +19,94 @@
1919

2020
#include <CGAL/is_y_monotone_2.h>
2121
#include <gtest/gtest.h>
22+
#include <CGAL/intersections.h>
2223

2324
#include "polygon_coverage_geometry/cgal_comm.h"
2425
#include "polygon_coverage_geometry/test_comm.h"
2526
#include "polygon_coverage_geometry/visibility_polygon.h"
2627

2728
using namespace polygon_coverage_planning;
2829

29-
TEST(VisibilityPolygonTest, computeVisibilityPolygon) {
30-
PolygonWithHoles rectangle_in_rectangle(
31-
createRectangleInRectangle<Polygon_2, PolygonWithHoles>());
32-
Polygon_2 visibility_polygon;
30+
TEST(VisibilityPolygonTest, computeVisibilityPolygon
31+
) {
32+
PolygonWithHoles rectangle_in_rectangle(
33+
createRectangleInRectangle<Polygon_2, PolygonWithHoles>());
34+
Polygon_2 visibility_polygon;
3335

34-
// Query on polygon vertex.
35-
Point_2 query(0.0, 0.0);
36-
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
37-
&visibility_polygon));
38-
// Result manually checked.
39-
VertexConstIterator vit = visibility_polygon.vertices_begin();
40-
EXPECT_EQ(static_cast<size_t>(9), visibility_polygon.size());
41-
EXPECT_EQ(Point_2(0.0, 2.0), *vit++);
42-
EXPECT_EQ(Point_2(0.0, 0.0), *vit++);
43-
EXPECT_EQ(Point_2(2.0, 0.0), *vit++);
44-
EXPECT_EQ(Point_2(2.0, 2.0), *vit++);
45-
vit++; // Skip inexact point. (1.6,2)
46-
EXPECT_EQ(Point_2(1.0, 1.25), *vit++);
47-
EXPECT_EQ(Point_2(0.5, 1.25), *vit++);
48-
EXPECT_EQ(Point_2(0.5, 1.75), *vit++);
49-
vit++; // Skip inexact point. (0.571429,2)
36+
// Query on polygon vertex.
37+
Point_2 query(0.0, 0.0);
38+
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
39+
&visibility_polygon)
40+
);
41+
// Result manually checked.
42+
Line_2 line(Point_2(0, 2), Point_2(2, 2));
43+
Ray_2 ray_1(Point_2(0, 0), Point_2(0.5, 1.75));
44+
Ray_2 ray_2(Point_2(0, 0), Point_2(1.0, 1.25));
45+
auto inter_1 = CGAL::intersection(ray_1, line);
46+
auto inter_2 = CGAL::intersection(ray_2, line);
5047

51-
// Query on hole vertex.
52-
query = Point_2(1.0, 1.25);
53-
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
54-
&visibility_polygon));
55-
vit = visibility_polygon.vertices_begin();
56-
EXPECT_EQ(static_cast<size_t>(6), visibility_polygon.size())
57-
<< "Query point: " << query << " PWH: " << rectangle_in_rectangle
58-
<< "Visibility: " << visibility_polygon;
59-
EXPECT_EQ(Point_2(1, 1.25), *vit++);
60-
EXPECT_EQ(Point_2(0, 1.25), *vit++);
61-
EXPECT_EQ(Point_2(0, 0), *vit++);
62-
EXPECT_EQ(Point_2(2, 0), *vit++);
63-
EXPECT_EQ(Point_2(2, 2), *vit++);
64-
EXPECT_EQ(Point_2(1, 2), *vit++);
48+
Point_2 points_1[] = {{0.0, 2.0}, {0.0, 0.0}, {2.0, 0.0}, {2.0, 2.0},
49+
*boost::get<Point_2>(&*inter_2), {1.0, 1.25}, {0.5, 1.25},
50+
{0.5, 1.75}, *boost::get<Point_2>(&*inter_1)};
51+
Polygon_2 visibility_polygon_expected_1
52+
(points_1, points_1 + sizeof(points_1) / sizeof(points_1[0]));
53+
EXPECT_EQ(visibility_polygon_expected_1, visibility_polygon
54+
);
6555

66-
// Query in face.
67-
query = Point_2(1.0, 0.5);
68-
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
69-
&visibility_polygon));
70-
// Result manually checked.
71-
vit = visibility_polygon.vertices_begin();
72-
EXPECT_EQ(static_cast<size_t>(7), visibility_polygon.size());
73-
EXPECT_EQ(Point_2(0, 0), *vit++);
74-
EXPECT_EQ(Point_2(2, 0), *vit++);
75-
EXPECT_EQ(Point_2(2, 2), *vit++);
76-
EXPECT_EQ(Point_2(1, 2), *vit++);
77-
EXPECT_EQ(Point_2(1, 1.25), *vit++);
78-
EXPECT_EQ(Point_2(0.5, 1.25), *vit++);
79-
EXPECT_EQ(Point_2(0, 2), *vit++);
56+
// Query on hole vertex.
57+
query = Point_2(1.0, 1.25);
58+
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
59+
&visibility_polygon)
60+
);
61+
Point_2 points_2[] = {{0, 0}, {2, 0}, {2, 2}, {1, 2}, {1, 1.25}, {0, 1.25}};
62+
Polygon_2 visibility_polygon_expected_2
63+
(points_2, points_2 + sizeof(points_2) / sizeof(points_2[0]));
64+
EXPECT_EQ(visibility_polygon_expected_2, visibility_polygon
65+
);
8066

81-
// Query on polygon halfedge.
82-
query = Point_2(1.0, 0.0);
83-
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
84-
&visibility_polygon));
85-
// Result manually checked.
86-
vit = visibility_polygon.vertices_begin();
87-
EXPECT_EQ(static_cast<size_t>(8), visibility_polygon.size());
88-
EXPECT_EQ(Point_2(0, 2), *vit++);
89-
EXPECT_EQ(Point_2(0, 0), *vit++);
90-
EXPECT_EQ(Point_2(2, 0), *vit++);
91-
EXPECT_EQ(Point_2(2, 2), *vit++);
92-
EXPECT_EQ(Point_2(1, 2), *vit++);
93-
EXPECT_EQ(Point_2(1, 1.25), *vit++);
94-
EXPECT_EQ(Point_2(0.5, 1.25), *vit++);
95-
// EXPECT_EQ(Point_2(0.2, 2), *vit++); Skip inexact.
67+
// Query in face.
68+
query = Point_2(1.0, 0.5);
69+
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
70+
&visibility_polygon)
71+
);
72+
// Result manually checked.
73+
Point_2 points_3[] =
74+
{{0, 0}, {2, 0}, {2, 2}, {1, 2}, {1, 1.25}, {0.5, 1.25}, {0, 2}};
75+
Polygon_2 visibility_polygon_expected_3
76+
(points_3, points_3 + sizeof(points_3) / sizeof(points_3[0]));
77+
EXPECT_EQ(visibility_polygon_expected_3, visibility_polygon
78+
);
9679

97-
// Query on hole halfedge.
98-
query = Point_2(0.75, 1.25);
99-
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
100-
&visibility_polygon));
101-
// Result manually checked.
102-
vit = visibility_polygon.vertices_begin();
103-
EXPECT_EQ(static_cast<size_t>(4), visibility_polygon.size());
104-
EXPECT_EQ(Point_2(2, 1.25), *vit++);
105-
EXPECT_EQ(Point_2(0, 1.25), *vit++);
106-
EXPECT_EQ(Point_2(0, 0), *vit++);
107-
EXPECT_EQ(Point_2(2, 0), *vit++);
80+
// Query on polygon halfedge.
81+
query = Point_2(1.0, 0.0);
82+
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
83+
&visibility_polygon)
84+
);
85+
// Result manually checked.
86+
Ray_2 ray_3(Point_2(1, 0), Point_2(0.5, 1.25));
87+
auto inter_3 = CGAL::intersection(ray_3, line);
88+
Point_2 points_4[] =
89+
{{0, 2}, {0, 0}, {2, 0}, {2, 2}, {1, 2}, {1, 1.25}, {0.5, 1.25},
90+
*boost::get<Point_2>(&*inter_3)};
91+
Polygon_2 visibility_polygon_expected_4
92+
(points_4, points_4 + sizeof(points_4) / sizeof(points_4[0]));
93+
EXPECT_EQ(visibility_polygon_expected_4, visibility_polygon
94+
);
95+
96+
// Query on hole halfedge.
97+
query = Point_2(0.75, 1.25);
98+
EXPECT_TRUE(computeVisibilityPolygon(rectangle_in_rectangle, query,
99+
&visibility_polygon)
100+
);
101+
// Result manually checked.
102+
Point_2 points_5[] = {{2, 1.25}, {0, 1.25}, {0, 0}, {2, 0}};
103+
Polygon_2 visibility_polygon_expected_5
104+
(points_5, points_5 + sizeof(points_5) / sizeof(points_5[0]));
105+
EXPECT_EQ(visibility_polygon_expected_5, visibility_polygon
106+
);
108107
}
109108

110-
int main(int argc, char** argv) {
109+
int main(int argc, char **argv) {
111110
testing::InitGoogleTest(&argc, argv);
112111
return RUN_ALL_TESTS();
113112
}

0 commit comments

Comments
 (0)