Point_test.cpp
Go to the documentation of this file.
1 //=============================================================================
2 // Copyright (C) 2021-2024 Wageningen University - All Rights Reserved
3 // Author: Gonzalo Mier
4 // BSD-3 License
5 //=============================================================================
6 
7 #include <gtest/gtest.h>
8 #include "fields2cover/utils/random.h"
9 #include "fields2cover/types.h"
10 
11 namespace f2c {
12 
13 TEST(fields2cover_types_point, minus) {
14  F2CPoint p1(1.1, 2.2, 3.3), p2(-0.5, 0.6, 1);
15  auto p3 = p2 - p1;
16  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
17  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
18  EXPECT_NEAR(p1.getZ(), 3.3, 1e-7);
19  EXPECT_NEAR(p2.getX(), -0.5, 1e-7);
20  EXPECT_NEAR(p2.getY(), 0.6, 1e-7);
21  EXPECT_NEAR(p2.getZ(), 1, 1e-7);
22  EXPECT_NEAR(p3.getX(), -1.6, 1e-7);
23  EXPECT_NEAR(p3.getY(), -1.6, 1e-7);
24  EXPECT_NEAR(p3.getZ(), -2.3, 1e-7);
25 
26  auto p4 = p2 - p1;
27  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
28  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
29  EXPECT_NEAR(p1.getZ(), 3.3, 1e-7);
30  EXPECT_NEAR(p2.getX(), -0.5, 1e-7);
31  EXPECT_NEAR(p2.getY(), 0.6, 1e-7);
32  EXPECT_NEAR(p2.getZ(), 1, 1e-7);
33  EXPECT_NEAR(p4.getX(), -1.6, 1e-7);
34  EXPECT_NEAR(p4.getY(), -1.6, 1e-7);
35  EXPECT_NEAR(p4.getZ(), -2.3, 1e-7);
36 
37  OGRPoint op2(-0.5, 0.6, 1);
38  auto op4 = op2 - p1;
39  EXPECT_NEAR(op4.getX(), -1.6, 1e-7);
40  EXPECT_NEAR(op4.getY(), -1.6, 1e-7);
41  EXPECT_NEAR(op4.getZ(), -2.3, 1e-7);
42 }
43 
44 TEST(fields2cover_types_point, plus) {
45  F2CPoint p1(1.1, 2.2, 3.3), p2(-0.5, 0.6, 1);
46  auto p3 = p2 + p1;
47  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
48  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
49  EXPECT_NEAR(p1.getZ(), 3.3, 1e-7);
50  EXPECT_NEAR(p2.getX(), -0.5, 1e-7);
51  EXPECT_NEAR(p2.getY(), 0.6, 1e-7);
52  EXPECT_NEAR(p2.getZ(), 1, 1e-7);
53  EXPECT_NEAR(p3.getX(), 0.6, 1e-7);
54  EXPECT_NEAR(p3.getY(), 2.8, 1e-7);
55  EXPECT_NEAR(p3.getZ(), 4.3, 1e-7);
56 
57  OGRPoint op2(-0.5, 0.6, 1);
58  auto p4 = op2 + p1;
59  EXPECT_NEAR(p4.getX(), 0.6, 1e-7);
60  EXPECT_NEAR(p4.getY(), 2.8, 1e-7);
61  EXPECT_NEAR(p4.getZ(), 4.3, 1e-7);
62 }
63 
64 TEST(fields2cover_types_point, mult_equal) {
65  F2CPoint p1(1.1, 2.2, 3);
66  p1 *= 1.5;
67  EXPECT_NEAR(p1.getX(), 1.65, 1e-7);
68  EXPECT_NEAR(p1.getY(), 3.3, 1e-7);
69  EXPECT_NEAR(p1.getZ(), 4.5, 1e-7);
70 }
71 
72 TEST(fields2cover_types_point, multiply) {
73  F2CPoint p1(1.1, 2.2, 3);
74  auto p2 = p1 * 1.5;
75  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
76  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
77  EXPECT_NEAR(p1.getZ(), 3, 1e-7);
78  EXPECT_NEAR(p2.getX(), 1.65, 1e-7);
79  EXPECT_NEAR(p2.getY(), 3.3, 1e-7);
80  EXPECT_NEAR(p2.getZ(), 4.5, 1e-7);
81 }
82 
83 TEST(fields2cover_types_point, plus_v) {
84  F2CPoint p1(1.1, 2.2);
85  std::vector<F2CPoint> v {F2CPoint(0.0, 0.0), F2CPoint(1.0, 2.0)};
86  auto p2 = v + p1;
87  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
88  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
89  EXPECT_NEAR(v[0].getX(), 0, 1e-7);
90  EXPECT_NEAR(v[0].getY(), 0, 1e-7);
91  EXPECT_NEAR(v[1].getX(), 1, 1e-7);
92  EXPECT_NEAR(v[1].getY(), 2, 1e-7);
93  EXPECT_NEAR(p2[0].getX(), 1.1, 1e-7);
94  EXPECT_NEAR(p2[0].getY(), 2.2, 1e-7);
95  EXPECT_NEAR(p2[1].getX(), 2.1, 1e-7);
96  EXPECT_NEAR(p2[1].getY(), 4.2, 1e-7);
97 }
98 
99 TEST(fields2cover_types_point, minus_v) {
100  F2CPoint p1(1.1, 2.2);
101  std::vector<F2CPoint> v {F2CPoint(0.0, 0.0), F2CPoint(1.0, 2.0)};
102  auto p2 = v - p1;
103  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
104  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
105  EXPECT_NEAR(v[0].getX(), 0, 1e-7);
106  EXPECT_NEAR(v[0].getY(), 0, 1e-7);
107  EXPECT_NEAR(v[1].getX(), 1, 1e-7);
108  EXPECT_NEAR(v[1].getY(), 2, 1e-7);
109  EXPECT_NEAR(p2[0].getX(), -1.1, 1e-7);
110  EXPECT_NEAR(p2[0].getY(), -2.2, 1e-7);
111  EXPECT_NEAR(p2[1].getX(), -0.1, 1e-7);
112  EXPECT_NEAR(p2[1].getY(), -0.2, 1e-7);
113 
114  auto p3 = p1 - v;
115  EXPECT_NEAR(p1.getX(), 1.1, 1e-7);
116  EXPECT_NEAR(p1.getY(), 2.2, 1e-7);
117  EXPECT_NEAR(v[0].getX(), 0, 1e-7);
118  EXPECT_NEAR(v[0].getY(), 0, 1e-7);
119  EXPECT_NEAR(v[1].getX(), 1, 1e-7);
120  EXPECT_NEAR(v[1].getY(), 2, 1e-7);
121  EXPECT_NEAR(p3[0].getX(), 1.1, 1e-7);
122  EXPECT_NEAR(p3[0].getY(), 2.2, 1e-7);
123  EXPECT_NEAR(p3[1].getX(), 0.1, 1e-7);
124  EXPECT_NEAR(p3[1].getY(), 0.2, 1e-7);
125 }
126 
127 TEST(fields2cover_types_point, clone) {
128  F2CPoint a(2, 3);
129  F2CPoint b = a.clone();
130  a.setX(10);
131  EXPECT_EQ(b.getX(), 2);
132 }
133 
134 TEST(fields2cover_types_point, set) {
135  F2CPoint a(1, 2);
136  EXPECT_EQ(a, F2CPoint(1, 2, 0));
137  a.setPoint(3, 4, 5);
138  EXPECT_EQ(a, F2CPoint(3, 4, 5));
139  a.setPoint(OGRPoint(6, 7));
140  EXPECT_EQ(a, F2CPoint(6, 7, 0));
141  a.setPoint(F2CPoint(8, 9, 10));
142  EXPECT_EQ(a, F2CPoint(8, 9, 10));
143 }
144 
145 TEST(fields2cover_types_point, print) {
146  F2CPoint a(1, 2);
147  std::ostringstream ss_a;
148  ss_a << a;
149  EXPECT_EQ(ss_a.str(), "Point(1, 2, 0)");
150  a.setZ(-5);
151  std::ostringstream ss_a2;
152  ss_a2 << a;
153  EXPECT_EQ(ss_a2.str(), "Point(1, 2, -5)");
154 }
155 
156 TEST(fields2cover_types_point, rotateFromPoint) {
157  F2CPoint p0(0, 0), p1(0, 1), p2(2, 0);
158  F2CMultiPoint ps {p1, p2};
159  F2CLineString ls {p1, p2};
160  F2CLineString ls2 {p1};
161  F2CMultiLineString mls {ls, ls2};
162  std::vector<F2CPoint> vp {p1, p2};
163  std::vector<F2CMultiPoint> pss {ps};
164  std::vector<F2CLineString> vls {ls, ls2};
165  std::vector<F2CMultiLineString> vmls {mls};
166 
167  EXPECT_NEAR(ps.getGeometry(1).getX(), 2, 1e-7);
168  EXPECT_NEAR(ls.getGeometry(1).getX(), 2, 1e-7);
169 
170  auto r_ls = p0.rotateFromPoint(0.5*boost::math::constants::half_pi<double>(), ls);
171  EXPECT_NEAR(r_ls.getGeometry(0).getX(), -1./sqrt(2), 1e-7);
172  EXPECT_NEAR(r_ls.getGeometry(0).getY(), 1./sqrt(2), 1e-7);
173  EXPECT_NEAR(r_ls.getGeometry(1).getX(), sqrt(2), 1e-7);
174  EXPECT_NEAR(r_ls.getGeometry(1).getY(), sqrt(2), 1e-7);
175 
176  auto r_mls = p0.rotateFromPoint(0.5*boost::math::constants::half_pi<double>(), mls);
177  EXPECT_EQ(r_mls.size(), 2);
178  auto r_ls3 = r_mls.getGeometry(0);
179  EXPECT_NEAR(r_ls3.getGeometry(0).getX(), -1./sqrt(2), 1e-7);
180  EXPECT_NEAR(r_ls3.getGeometry(0).getY(), 1./sqrt(2), 1e-7);
181  EXPECT_NEAR(r_ls3.getGeometry(1).getX(), sqrt(2), 1e-7);
182  EXPECT_NEAR(r_ls3.getGeometry(1).getY(), sqrt(2), 1e-7);
183 
184  auto r_vmls = p0.rotateFromPoint(0.5*boost::math::constants::half_pi<double>(), vmls);
185  EXPECT_EQ(r_vmls.size(), 1);
186  EXPECT_EQ(r_vmls[0].size(), 2);
187  auto r_ls4 = r_vmls[0].getGeometry(0);
188  EXPECT_NEAR(r_ls4.getGeometry(0).getX(), -1./sqrt(2), 1e-7);
189  EXPECT_NEAR(r_ls4.getGeometry(0).getY(), 1./sqrt(2), 1e-7);
190  EXPECT_NEAR(r_ls4.getGeometry(1).getX(), sqrt(2), 1e-7);
191  EXPECT_NEAR(r_ls4.getGeometry(1).getY(), sqrt(2), 1e-7);
192 
193  auto r_vls = p0.rotateFromPoint(0.5*boost::math::constants::half_pi<double>(), vls);
194  EXPECT_EQ(r_vls.size(), 2);
195  auto r_ls5 = r_vls[0];
196  EXPECT_NEAR(r_ls5.getGeometry(0).getX(), -1./sqrt(2), 1e-7);
197  EXPECT_NEAR(r_ls5.getGeometry(0).getY(), 1./sqrt(2), 1e-7);
198  EXPECT_NEAR(r_ls5.getGeometry(1).getX(), sqrt(2), 1e-7);
199  EXPECT_NEAR(r_ls5.getGeometry(1).getY(), sqrt(2), 1e-7);
200 
201  auto r_p1 = p0.rotateFromPoint(boost::math::constants::half_pi<double>(), p1);
202  EXPECT_NEAR(r_p1.getX(), -1, 1e-7);
203  EXPECT_NEAR(r_p1.getY(), 0, 1e-7);
204  auto r_p2 = p0.rotateFromPoint(boost::math::constants::half_pi<double>(), p2);
205  EXPECT_NEAR(r_p2.getX(), 0, 1e-7);
206  EXPECT_NEAR(r_p2.getY(), 2, 1e-7);
207 
208  auto r_ps = p0.rotateFromPoint(boost::math::constants::half_pi<double>(), ps);
209  EXPECT_NEAR(r_ps.getGeometry(0).getX(), -1, 1e-7);
210  EXPECT_NEAR(r_ps.getGeometry(0).getY(), 0, 1e-7);
211  EXPECT_NEAR(r_ps.getGeometry(1).getX(), 0, 1e-7);
212  EXPECT_NEAR(r_ps.getGeometry(1).getY(), 2, 1e-7);
213  auto r_pss = p0.rotateFromPoint(boost::math::constants::half_pi<double>(), pss);
214  EXPECT_NEAR(r_pss[0].getGeometry(0).getX(), -1, 1e-7);
215  EXPECT_NEAR(r_pss[0].getGeometry(0).getY(), 0, 1e-7);
216  EXPECT_NEAR(r_pss[0].getGeometry(1).getX(), 0, 1e-7);
217  EXPECT_NEAR(r_pss[0].getGeometry(1).getY(), 2, 1e-7);
218  auto r_vp = p0.rotateFromPoint(boost::math::constants::half_pi<double>(), vp);
219  EXPECT_NEAR(r_vp[1].getX(), 0, 1e-7);
220  EXPECT_NEAR(r_vp[1].getY(), 2, 1e-7);
221 
222  f2c::Random rand(42);
223  auto field = rand.generateRandField(1e4, 3);
224  EXPECT_NEAR(field.area(), 1e4, 1e-7);
225  F2CCells cells = field.getField();
226  EXPECT_NEAR(cells.area(), 1e4, 1e-7);
227  auto r_cells = p0.rotateFromPoint(boost::math::constants::pi<double>(), cells);
228  F2CPoint start = cells.getGeometry(0).getGeometry(0).getGeometry(1);
229  F2CPoint r_start = r_cells.getGeometry(0).getGeometry(0).getGeometry(1);
230  EXPECT_NEAR(cells.area(), 1e4, 1e-7);
231  EXPECT_NEAR(r_cells.area(), 1e4, 1e-7);
232  EXPECT_NEAR(start.getX(), -r_start.getX(), 1e-7);
233  EXPECT_NEAR(start.getY(), -r_start.getY(), 1e-7);
234 
235  auto r_cell = p0.rotateFromPoint(boost::math::constants::pi<double>(),
236  cells.getGeometry(0));
237  F2CPoint r_start2 = r_cell.getGeometry(0).getGeometry(1);
238  EXPECT_NEAR(start.getX(), -r_start2.getX(), 1e-7);
239  EXPECT_NEAR(start.getY(), -r_start2.getY(), 1e-7);
240 
241  std::vector<F2CLinearRing> v_ring {cells.getGeometry(0).getGeometry(0)};
242  auto r_v_ring = p0.rotateFromPoint(boost::math::constants::pi<double>(),
243  v_ring);
244  F2CPoint r_v_start6 = r_v_ring[0].getGeometry(1);
245  EXPECT_NEAR(start.getX(), -r_v_start6.getX(), 1e-7);
246  EXPECT_NEAR(start.getY(), -r_v_start6.getY(), 1e-7);
247 
248  std::vector<F2CCell> v_cell {cells.getGeometry(0)};
249  auto r_v_cell = p0.rotateFromPoint(boost::math::constants::pi<double>(),
250  v_cell);
251  F2CPoint r_v_start2 = r_v_cell[0].getGeometry(0).getGeometry(1);
252  EXPECT_NEAR(start.getX(), -r_v_start2.getX(), 1e-7);
253  EXPECT_NEAR(start.getY(), -r_v_start2.getY(), 1e-7);
254 
255  std::vector<F2CCells> v_cells {cells};
256  auto r_v_cells = p0.rotateFromPoint(boost::math::constants::pi<double>(),
257  v_cells);
258  F2CPoint r_v_start3 = r_v_cells[0].getGeometry(0).getGeometry(0).getGeometry(1);
259  EXPECT_NEAR(start.getX(), -r_v_start3.getX(), 1e-7);
260  EXPECT_NEAR(start.getY(), -r_v_start3.getY(), 1e-7);
261 }
262 
263 TEST(fields2cover_types_point, signedDistance2Segment) {
264  F2CPoint p00 {0, 0};
265  F2CPoint p10 {1, 0};
266  F2CPoint p_10 {-1, 0};
267  F2CPoint p11 {1, 1};
268  F2CPoint p1_1 {1, -1};
269  F2CPoint p2_2 {2, -2};
270  F2CPoint p90 {9, 0};
271 
272  EXPECT_EQ(p00.signedDistance2Segment(p10, p_10), 0.0);
273  EXPECT_EQ(p11.signedDistance2Segment(p_10, p10), 1.0);
274  EXPECT_EQ(p11.signedDistance2Segment(p10, p_10), -1.0);
275  EXPECT_EQ(p1_1.signedDistance2Segment(p_10, p10), -1.0);
276  EXPECT_EQ(p1_1.signedDistance2Segment(p10, p_10), 1.0);
277  EXPECT_EQ(p2_2.signedDistance2Segment(p_10, p10), -2.0);
278  EXPECT_EQ(p11.signedDistance2Segment(p00, p90), 1.0);
279 }
280 
281 TEST(fields2cover_types_point, intersectionOfLines) {
282  F2CPoint p00 {0, 0};
283  F2CPoint p10 {1, 0};
284  F2CPoint p_10 {-1, 0};
285  F2CPoint p11 {1, 1};
286  F2CPoint p_11 {-1, 1};
287  F2CPoint p1_1 {1, -1};
288  F2CPoint p_1_1 {-1, -1};
289  F2CPoint p2_2 {2, -2};
290  EXPECT_EQ(F2CPoint::intersectionOfLines(p_10, p10, p_10, p2_2).distance(p_10), 0.0);
291  EXPECT_EQ(F2CPoint::intersectionOfLines(p00, p10, p_10, p10).distance(p00), 0.0);
292  EXPECT_EQ(F2CPoint::intersectionOfLines(p_11, p1_1, p11, p_1_1).distance(p00), 0.0);
293  EXPECT_EQ(F2CPoint::intersectionOfLines(p00, p_10, p11, p1_1).distance(p10), 0.0);
294 }
295 
296 TEST(fields2cover_types_point, closestPointInSegment) {
297  F2CPoint s1_s {-1, 1}; F2CPoint s1_e {1, 1};
298  F2CPoint p1 {2, 1};
299  F2CPoint p2 {-2, -5};
300  F2CPoint p3 {0, 2};
301  EXPECT_EQ(p1.closestPointInSegment(s1_s, s1_e), s1_e);
302  EXPECT_EQ(p2.closestPointInSegment(s1_s, s1_e), s1_s);
303  EXPECT_EQ(p3.closestPointInSegment(s1_s, s1_e), F2CPoint(0, 1));
304 
305 
306  F2CPoint s2_s {1, -1}; F2CPoint s2_e {3, 1};
307  F2CPoint p4 {1, 1};
308  EXPECT_EQ(p4.closestPointInSegment(s2_s, s2_e), F2CPoint(2, 0));
309 }
310 
311 
312 
313 } // namespace f2c
314 
1_basic_types.cells
cells
Definition: 1_basic_types.py:93
1_basic_types.p1
p1
Definition: 1_basic_types.py:11
types.h
1_basic_types.p3
p3
Definition: 1_basic_types.py:22
3_headland_generator.rand
rand
Definition: 3_headland_generator.py:11
f2c::types::Point::intersectionOfLines
static Point intersectionOfLines(const Point &l1_s, const Point &l1_e, const Point &l2_s, const Point &l2_e)
Definition: Point.cpp:157
f2c::types::MultiLineString
Definition: MultiLineString.h:18
1_basic_types.p4
p4
Definition: 1_basic_types.py:28
random.h
f2c::types::Point::setX
void setX(double x)
Definition: Point.cpp:99
1_basic_types.p2
p2
Definition: 1_basic_types.py:15
f2c::TEST
TEST(fields2cover_types_point, minus)
Definition: Point_test.cpp:13
f2c::types::MultiPoint
Definition: MultiPoint.h:18
f2c::types::Point::clone
Point clone() const
Definition: Point.cpp:88
f2c::types::Point::setPoint
void setPoint(double x, double y, double z=0)
Definition: Point.cpp:103
f2c::types::LineString
Definition: LineString.h:19
8_complete_flow.ps
list ps
Definition: 8_complete_flow.py:43
f2c::types::Cells
Definition: Cells.h:21
f2c::types::Point
Definition: Point.h:21
f2c::Random
Definition: random.h:23
2_objective_functions.field
field
Definition: 2_objective_functions.py:16
f2c
Main namespace of the fields2cover library.
Definition: boustrophedon_decomp.h:14
f2c::types::Point::getY
double getY() const
Definition: Point.cpp:96
f2c::types::Point::getX
double getX() const
Definition: Point.cpp:95
F2CPoint
f2c::types::Point F2CPoint
Definition: types.h:38

fields2cover
Author(s):
autogenerated on Fri Apr 25 2025 02:18:31