1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
10 /// @file PositionVectorTest.cpp
11 /// @author Matthias Heppner
12 /// @author Michael Behrisch
13 /// @author Jakob Erdmann
14 /// @date 2009-10-24
15 /// @version $Id$
16 ///
17 // Tests the class PositionVector
18 /****************************************************************************/
19
20 #include <gtest/gtest.h>
21 #include <utils/geom/PositionVector.h>
22 #include <utils/geom/Boundary.h>
23 #include <utils/geom/GeomHelper.h>
24 #include <utils/common/UtilExceptions.h>
25 #include <utils/common/MsgHandler.h>
26 #include <utils/iodevices/OutputDevice.h>
27
28
29 #define EXPECT_DOUBLEVEC_EQUAL(v1, v2) \
30 { \
31 EXPECT_EQ(v1.size(), v2.size()); \
32 if (v1.size() == v2.size()) { \
33 for (int i = 0; i < (int)v1.size(); ++i) { \
34 EXPECT_DOUBLE_EQ(v1[i], v2[i]); \
35 } \
36 } \
37 } \
38
39 class PositionVectorTest : public testing::Test {
40 protected :
41 PositionVector *vectorPolygon;
42 PositionVector *vectorLine;
43
SetUp()44 virtual void SetUp(){
45 vectorPolygon = new PositionVector();
46 vectorPolygon->push_back(Position(0,0));
47 vectorPolygon->push_back(Position(0,2));
48 vectorPolygon->push_back(Position(2,4));
49 vectorPolygon->push_back(Position(4,2));
50 vectorPolygon->push_back(Position(4,0));
51
52 vectorLine = new PositionVector();
53 vectorLine->push_back(Position(0,0));
54 vectorLine->push_back(Position(2,2));
55 }
56
TearDown()57 virtual void TearDown(){
58 delete vectorPolygon;
59 delete vectorLine;
60 }
61
62 };
63
64 /* Test the method 'around'*/
TEST_F(PositionVectorTest,test_method_around)65 TEST_F(PositionVectorTest, test_method_around) {
66
67 EXPECT_TRUE(vectorPolygon->around(Position(1,1)));
68 EXPECT_TRUE(vectorPolygon->around(Position(1,2)));
69 EXPECT_FALSE(vectorPolygon->around(Position(4,4)));
70 EXPECT_FALSE(vectorPolygon->around(Position(0,0)));
71
72 EXPECT_FALSE(vectorLine->around(Position(1,1)));
73 EXPECT_FALSE(vectorLine->around(Position(0,2)));
74
75 // with positive offset
76 EXPECT_TRUE(vectorPolygon->around(Position(4,2), 1));
77 EXPECT_FALSE(vectorPolygon->around(Position(5,2), 1));
78 // what was true remains true
79 EXPECT_TRUE(vectorPolygon->around(Position(1,1), POSITION_EPS));
80 EXPECT_TRUE(vectorPolygon->around(Position(1,2), POSITION_EPS));
81
82 // with negative offset
83 EXPECT_FALSE(vectorPolygon->around(Position(4,2), -POSITION_EPS));
84 EXPECT_TRUE(vectorPolygon->around(Position(1,1), -1));
85 EXPECT_FALSE(vectorPolygon->around(Position(0.5,0.5), -1));
86 }
87
88 /* Test the method 'area'*/
TEST_F(PositionVectorTest,test_method_area)89 TEST_F(PositionVectorTest, test_method_area) {
90 PositionVector square;
91 square.push_back(Position(0,0));
92 square.push_back(Position(1,0));
93 square.push_back(Position(1,1));
94 square.push_back(Position(0,1)); // open
95 EXPECT_DOUBLE_EQ(square.area(), 1);
96 square.push_back(Position(0,0)); // closed
97 EXPECT_DOUBLE_EQ(square.area(), 1);
98 }
99
100 /* Test the method 'scaleRelative'.*/
TEST_F(PositionVectorTest,test_method_scaleRelative)101 TEST_F(PositionVectorTest, test_method_scaleRelative) {
102 PositionVector square;
103 square.push_back(Position(0,0));
104 square.push_back(Position(1,0));
105 square.push_back(Position(1,1));
106 square.push_back(Position(0,1));
107 square.push_back(Position(0,0));
108 EXPECT_DOUBLE_EQ(square.area(), 1);
109 square.scaleRelative(3);
110 EXPECT_DOUBLE_EQ(square.area(), 9);
111
112 PositionVector expected;
113 expected.push_back(Position(-1,-1));
114 expected.push_back(Position(2,-1));
115 expected.push_back(Position(2,2));
116 expected.push_back(Position(-1,2));
117 expected.push_back(Position(-1,-1));
118
119 EXPECT_EQ(expected.getCentroid(), square.getCentroid());
120 for (int i = 0; i < (int)square.size(); i++) {
121 EXPECT_DOUBLE_EQ(expected[i].x(), square[i].x());
122 EXPECT_DOUBLE_EQ(expected[i].y(), square[i].y());
123 }
124 }
125
126 /* Test the method 'getCentroid'.*/
TEST_F(PositionVectorTest,test_method_getCentroid)127 TEST_F(PositionVectorTest, test_method_getCentroid) {
128 PositionVector square;
129 square.push_back(Position(0,0));
130 square.push_back(Position(1,0));
131 square.push_back(Position(1,1));
132 square.push_back(Position(0,1));
133 EXPECT_EQ(Position(0.5, 0.5), square.getCentroid());
134
135 Position pos2 = vectorLine->getCentroid();
136 EXPECT_DOUBLE_EQ(1, pos2.x());
137 EXPECT_DOUBLE_EQ(1, pos2.y());
138 }
139
140 /* Test the method 'getPolygonCenter'.*/
TEST_F(PositionVectorTest,test_method_getPolygonCenter)141 TEST_F(PositionVectorTest, test_method_getPolygonCenter) {
142 Position pos = vectorPolygon->getPolygonCenter();
143 EXPECT_DOUBLE_EQ(2, pos.x());
144 EXPECT_DOUBLE_EQ(1.6, pos.y());
145 Position pos2 = vectorLine->getPolygonCenter();
146 }
147
148
149 /* Test the method 'getBoxBoundary'*/
TEST_F(PositionVectorTest,test_method_getBoxBoundary)150 TEST_F(PositionVectorTest, test_method_getBoxBoundary) {
151 Boundary bound = vectorPolygon->getBoxBoundary();
152 EXPECT_DOUBLE_EQ(bound.xmax(), 4);
153 EXPECT_DOUBLE_EQ(bound.xmin(), 0);
154 EXPECT_DOUBLE_EQ(bound.ymax(), 4);
155 EXPECT_DOUBLE_EQ(bound.ymin(), 0);
156 }
157
158 /* Test the method 'splitAt'*/
TEST_F(PositionVectorTest,test_method_splitAt)159 TEST_F(PositionVectorTest, test_method_splitAt) {
160 PositionVector vec;
161 vec.push_back(Position(0,0));
162 vec.push_back(Position(2,0));
163 vec.push_back(Position(5,0));
164 double smallDiff = POSITION_EPS / 2;
165 std::pair<PositionVector, PositionVector> result;
166 // split in first segment
167 result = vec.splitAt(1);
168 EXPECT_EQ(2, (int)result.first.size());
169 EXPECT_DOUBLE_EQ(0., result.first[0].x());
170 EXPECT_DOUBLE_EQ(1., result.first[1].x());
171 EXPECT_EQ(3, (int)result.second.size());
172 EXPECT_DOUBLE_EQ(1., result.second[0].x());
173 EXPECT_DOUBLE_EQ(2., result.second[1].x());
174 EXPECT_DOUBLE_EQ(5., result.second[2].x());
175 // split in second segment
176 result = vec.splitAt(4);
177 EXPECT_EQ(3, (int)result.first.size());
178 EXPECT_DOUBLE_EQ(0., result.first[0].x());
179 EXPECT_DOUBLE_EQ(2., result.first[1].x());
180 EXPECT_DOUBLE_EQ(4., result.first[2].x());
181 EXPECT_EQ(2, (int)result.second.size());
182 EXPECT_DOUBLE_EQ(4., result.second[0].x());
183 EXPECT_DOUBLE_EQ(5., result.second[1].x());
184 // split close before inner point
185 result = vec.splitAt(2 - smallDiff);
186 EXPECT_EQ(2, (int)result.first.size());
187 EXPECT_DOUBLE_EQ(0., result.first[0].x());
188 EXPECT_DOUBLE_EQ(2., result.first[1].x());
189 EXPECT_EQ(2, (int)result.second.size());
190 EXPECT_DOUBLE_EQ(2., result.second[0].x());
191 EXPECT_DOUBLE_EQ(5., result.second[1].x());
192 // split close after inner point
193 result = vec.splitAt(2 + smallDiff);
194 EXPECT_EQ(2, (int)result.first.size());
195 EXPECT_DOUBLE_EQ(0., result.first[0].x());
196 EXPECT_DOUBLE_EQ(2., result.first[1].x());
197 EXPECT_EQ(2, (int)result.second.size());
198 EXPECT_DOUBLE_EQ(2., result.second[0].x());
199 EXPECT_DOUBLE_EQ(5., result.second[1].x());
200
201 // catch a bug
202 vec.push_back(Position(6,0));
203 vec.push_back(Position(8,0));
204 // split at inner point
205 result = vec.splitAt(5);
206 EXPECT_EQ(3, (int)result.first.size());
207 EXPECT_DOUBLE_EQ(0., result.first[0].x());
208 EXPECT_DOUBLE_EQ(2., result.first[1].x());
209 EXPECT_DOUBLE_EQ(5., result.first[2].x());
210 EXPECT_EQ(3, (int)result.second.size());
211 EXPECT_DOUBLE_EQ(5., result.second[0].x());
212 EXPECT_DOUBLE_EQ(6., result.second[1].x());
213 EXPECT_DOUBLE_EQ(8., result.second[2].x());
214
215 // split short vector
216 PositionVector vec2;
217 vec2.push_back(Position(0,0));
218 vec2.push_back(Position(2,0));
219 result = vec2.splitAt(1);
220 EXPECT_EQ(2, (int)result.first.size());
221 EXPECT_DOUBLE_EQ(0., result.first[0].x());
222 EXPECT_DOUBLE_EQ(1., result.first[1].x());
223 EXPECT_EQ(2, (int)result.second.size());
224 EXPECT_DOUBLE_EQ(1., result.second[0].x());
225 EXPECT_DOUBLE_EQ(2. ,result.second[1].x());
226
227 // split very short vector
228 PositionVector vec3;
229 vec3.push_back(Position(0,0));
230 vec3.push_back(Position(POSITION_EPS,0));
231 // supress expected warning
232 MsgHandler::getWarningInstance()->removeRetriever(&OutputDevice::getDevice("stderr"));
233 result = vec3.splitAt(smallDiff);
234 MsgHandler::getWarningInstance()->addRetriever(&OutputDevice::getDevice("stderr"));
235
236 EXPECT_EQ(2, (int)result.first.size());
237 EXPECT_DOUBLE_EQ(0., result.first[0].x());
238 EXPECT_DOUBLE_EQ(smallDiff, result.first[1].x());
239 EXPECT_EQ(2, (int)result.second.size());
240 EXPECT_DOUBLE_EQ(smallDiff, result.second[0].x());
241 EXPECT_DOUBLE_EQ(POSITION_EPS, result.second[1].x());
242 }
243
244
245 /* Test the method 'intersectsAtLengths2D'*/
TEST_F(PositionVectorTest,test_method_intersectsAtLenghts2D)246 TEST_F(PositionVectorTest, test_method_intersectsAtLenghts2D) {
247 PositionVector vec1;
248 vec1.push_back(Position(0,0,42));
249 vec1.push_back(Position(100,0,0));
250
251 PositionVector vec2;
252 vec2.push_back(Position(0,0,0));
253 vec2.push_back(Position(3,1,0));
254 EXPECT_DOUBLE_EQ(0, vec1.intersectsAtLengths2D(vec2)[0]);
255 }
256
257
258 /* Test the method 'nearest_offset_to_point2D'*/
TEST_F(PositionVectorTest,test_method_nearest_offset_to_point2D)259 TEST_F(PositionVectorTest, test_method_nearest_offset_to_point2D) {
260 PositionVector vec1;
261 vec1.push_back(Position(0,1,0));
262 vec1.push_back(Position(0,0,0));
263 vec1.push_back(Position(1,0,0));
264
265 EXPECT_DOUBLE_EQ(1, vec1.nearest_offset_to_point2D(Position(-1,-1), false));
266 EXPECT_DOUBLE_EQ(1, vec1.nearest_offset_to_point2D(Position(-1,-1), true));
267 EXPECT_DOUBLE_EQ(2, vec1.nearest_offset_to_point2D(Position(2,1), false));
268 EXPECT_DOUBLE_EQ(0, vec1.nearest_offset_to_point2D(Position(2,1), true));
269 EXPECT_DOUBLE_EQ(2, vec1.nearest_offset_to_point2D(Position(3,2), false));
270 EXPECT_DOUBLE_EQ(-1, vec1.nearest_offset_to_point2D(Position(3,2), true));
271 }
272
273
TEST_F(PositionVectorTest,test_method_extrapolate2D)274 TEST_F(PositionVectorTest, test_method_extrapolate2D) {
275 PositionVector vec1;
276 vec1.push_back(Position(0,1,0));
277 vec1.push_back(Position(0,0,0));
278 vec1.push_back(Position(1,0,0));
279 vec1.extrapolate2D(1);
280 EXPECT_EQ(Position(0,2,0), vec1[0]);
281 EXPECT_EQ(Position(0,0,0), vec1[1]);
282 EXPECT_EQ(Position(2,0,0), vec1[2]);
283
284 PositionVector vec2;
285 vec2.push_back(Position(0,1,0));
286 vec2.push_back(Position(0,0,1));
287 vec2.push_back(Position(1,0,0));
288 vec2.extrapolate2D(1);
289 // EXPECT_EQ(Position(0,2,0), vec2[0]);
290 // EXPECT_EQ(Position(0,0,0), vec2[1]);
291 // EXPECT_EQ(Position(2,0,0), vec2[2]);
292
293 PositionVector vec3;
294 vec3.push_back(Position(-.5,1));
295 vec3.push_back(Position(-.5,-.5));
296 vec3.push_back(Position(1,-.5));
297 vec3.extrapolate2D(.5);
298 EXPECT_EQ(Position(-.5,1.5), vec3[0]);
299 EXPECT_EQ(Position(-.5,-.5), vec3[1]);
300 EXPECT_EQ(Position(1.5,-.5), vec3[2]);
301
302 }
303
304
305 /* Test the method 'move2side'*/
TEST_F(PositionVectorTest,test_method_move2side)306 TEST_F(PositionVectorTest, test_method_move2side) {
307 PositionVector vec1;
308 vec1.push_back(Position(0,1,0));
309 vec1.push_back(Position(0,0,0));
310 vec1.push_back(Position(1,0,0));
311 vec1.move2side(.5);
312 EXPECT_EQ(Position(-.5,1), vec1[0]);
313 EXPECT_EQ(Position(-.5,-.5), vec1[1]);
314 EXPECT_EQ(Position(1,-.5), vec1[2]);
315 vec1.move2side(-1);
316 EXPECT_EQ(Position(.5,1), vec1[0]);
317 EXPECT_EQ(Position(.5,.5), vec1[1]);
318 EXPECT_EQ(Position(1,.5), vec1[2]);
319
320 // parallel case
321 PositionVector vec2;
322 vec2.push_back(Position(0,0,0));
323 vec2.push_back(Position(1,0,0));
324 vec2.push_back(Position(3,0,0));
325 vec2.move2side(.5);
326 EXPECT_EQ(Position(0,-.5), vec2[0]);
327 EXPECT_EQ(Position(1,-.5), vec2[1]);
328 EXPECT_EQ(Position(3,-.5), vec2[2]);
329 vec2.move2side(-1);
330 EXPECT_EQ(Position(0,.5), vec2[0]);
331 EXPECT_EQ(Position(1,.5), vec2[1]);
332 EXPECT_EQ(Position(3,.5), vec2[2]);
333
334 // counterparallel case
335 {
336 PositionVector vec3;
337 vec3.push_back(Position(0,0,0));
338 vec3.push_back(Position(3,0,0));
339 vec3.push_back(Position(1,0,0));
340 vec3.move2side(.5);
341 EXPECT_EQ(Position(0,-.5), vec3[0]);
342 EXPECT_EQ(Position(3.5,0), vec3[1]);
343 EXPECT_EQ(Position(1,.5), vec3[2]);
344 }
345 // bad input: subsequent identical points
346 {
347 PositionVector vec4;
348 vec4.push_back(Position(0,0,0));
349 vec4.push_back(Position(0,0,0));
350 vec4.push_back(Position(1,0,0));
351 vec4.move2side(-2);
352 EXPECT_EQ(2, (int)vec4.size());
353 EXPECT_EQ(Position(0,2), vec4[0]);
354 EXPECT_EQ(Position(1,2), vec4[1]);
355 }
356 }
357
358 /* Test the method 'transformToVectorCoordinates'*/
TEST_F(PositionVectorTest,test_method_transformToVectorCoordinates)359 TEST_F(PositionVectorTest, test_method_transformToVectorCoordinates) {
360 {
361 PositionVector vec1;
362 vec1.push_back(Position(1,0));
363 vec1.push_back(Position(10,0));
364 vec1.push_back(Position(10,5));
365 vec1.push_back(Position(20,5));
366 Position on(4,0);
367 Position left(4,1);
368 Position right(4,-1);
369 Position left2(4,2);
370 Position right2(4,-2);
371 Position cornerRight(13,-4);
372 Position cornerLeft(7,9);
373 Position before(0,-1);
374 Position beyond(24,9);
375
376 EXPECT_EQ(Position(3, 0), vec1.transformToVectorCoordinates(on));
377 EXPECT_EQ(Position(3, -1), vec1.transformToVectorCoordinates(left));
378 EXPECT_EQ(Position(3, 1), vec1.transformToVectorCoordinates(right));
379 EXPECT_EQ(Position(3, -2), vec1.transformToVectorCoordinates(left2));
380 EXPECT_EQ(Position(3, 2), vec1.transformToVectorCoordinates(right2));
381 EXPECT_EQ(Position(9, 5), vec1.transformToVectorCoordinates(cornerRight));
382 EXPECT_EQ(Position(14, -5), vec1.transformToVectorCoordinates(cornerLeft));
383
384 EXPECT_EQ(Position::INVALID, vec1.transformToVectorCoordinates(before));
385 EXPECT_EQ(Position::INVALID, vec1.transformToVectorCoordinates(beyond));
386 EXPECT_EQ(Position(-1, 1), vec1.transformToVectorCoordinates(before, true));
387 EXPECT_EQ(Position(28, -4), vec1.transformToVectorCoordinates(beyond, true));
388 }
389
390 {
391 PositionVector vec1; // the same tests as before, mirrored on x-axis
392 vec1.push_back(Position(1,0));
393 vec1.push_back(Position(10,0));
394 vec1.push_back(Position(10,-5));
395 vec1.push_back(Position(20,-5));
396 Position on(4,0);
397 Position left(4,-1);
398 Position right(4,1);
399 Position left2(4,-2);
400 Position right2(4,2);
401 Position cornerRight(13,4);
402 Position cornerLeft(7,-9);
403 Position before(0,1);
404 Position beyond(24,-9);
405
406 EXPECT_EQ(Position(3, 0), vec1.transformToVectorCoordinates(on));
407 EXPECT_EQ(Position(3, 1), vec1.transformToVectorCoordinates(left));
408 EXPECT_EQ(Position(3, -1), vec1.transformToVectorCoordinates(right));
409 EXPECT_EQ(Position(3, 2), vec1.transformToVectorCoordinates(left2));
410 EXPECT_EQ(Position(3, -2), vec1.transformToVectorCoordinates(right2));
411 EXPECT_EQ(Position(9, -5), vec1.transformToVectorCoordinates(cornerRight));
412 EXPECT_EQ(Position(14, 5), vec1.transformToVectorCoordinates(cornerLeft));
413
414 EXPECT_EQ(Position::INVALID, vec1.transformToVectorCoordinates(before));
415 EXPECT_EQ(Position::INVALID, vec1.transformToVectorCoordinates(beyond));
416 EXPECT_EQ(Position(-1, -1), vec1.transformToVectorCoordinates(before, true));
417 EXPECT_EQ(Position(28, 4), vec1.transformToVectorCoordinates(beyond, true));
418 }
419 }
420
421
422 /* Test the method 'distance'*/
TEST_F(PositionVectorTest,test_method_distance)423 TEST_F(PositionVectorTest, test_method_distance) {
424 {
425 PositionVector vec1;
426 vec1.push_back(Position(1,0));
427 vec1.push_back(Position(10,0));
428 vec1.push_back(Position(10,5));
429 vec1.push_back(Position(20,5));
430 Position on(4,0);
431 Position left(4,1);
432 Position right(4,-1);
433 Position left2(4,2);
434 Position right2(4,-2);
435 Position cornerRight(13,-4);
436 Position cornerLeft(7,9);
437 Position before(-3,-3);
438 Position beyond(24,8);
439
440 EXPECT_EQ(0, vec1.distance2D(on));
441 EXPECT_EQ(1, vec1.distance2D(left));
442 EXPECT_EQ(1, vec1.distance2D(right));
443 EXPECT_EQ(2, vec1.distance2D(left2));
444 EXPECT_EQ(2, vec1.distance2D(right2));
445 EXPECT_EQ(5, vec1.distance2D(cornerRight));
446 EXPECT_EQ(5, vec1.distance2D(cornerLeft));
447
448 EXPECT_EQ(GeomHelper::INVALID_OFFSET, vec1.distance2D(before, true));
449 EXPECT_EQ(GeomHelper::INVALID_OFFSET, vec1.distance2D(beyond, true));
450 EXPECT_EQ(5, vec1.distance2D(before));
451 EXPECT_EQ(5, vec1.distance2D(beyond));
452 }
453
454 {
455 PositionVector vec1; // the same tests as before, mirrored on x-axis
456 vec1.push_back(Position(1,0));
457 vec1.push_back(Position(10,0));
458 vec1.push_back(Position(10,-5));
459 vec1.push_back(Position(20,-5));
460 Position on(4,0);
461 Position left(4,-1);
462 Position right(4,1);
463 Position left2(4,-2);
464 Position right2(4,2);
465 Position cornerRight(13,4);
466 Position cornerLeft(7,-9);
467 Position before(-3,3);
468 Position beyond(24,-8);
469
470 EXPECT_EQ(0, vec1.distance2D(on));
471 EXPECT_EQ(1, vec1.distance2D(left));
472 EXPECT_EQ(1, vec1.distance2D(right));
473 EXPECT_EQ(2, vec1.distance2D(left2));
474 EXPECT_EQ(2, vec1.distance2D(right2));
475 EXPECT_EQ(5, vec1.distance2D(cornerRight));
476 EXPECT_EQ(5, vec1.distance2D(cornerLeft));
477
478 EXPECT_EQ(GeomHelper::INVALID_OFFSET, vec1.distance2D(before, true));
479 EXPECT_EQ(GeomHelper::INVALID_OFFSET, vec1.distance2D(beyond, true));
480 EXPECT_EQ(5, vec1.distance2D(before));
481 EXPECT_EQ(5, vec1.distance2D(beyond));
482 }
483 }
484
485
486 /* Test the method 'distance'*/
TEST_F(PositionVectorTest,test_method_distances)487 TEST_F(PositionVectorTest, test_method_distances) {
488 {
489 PositionVector vec1;
490 vec1.push_back(Position(0,0));
491 vec1.push_back(Position(10,0));
492
493 PositionVector vec2;
494 vec2.push_back(Position(1,0));
495 vec2.push_back(Position(5,2));
496 vec2.push_back(Position(10,0));
497 vec2.push_back(Position(14,3));
498
499 PositionVector vec3;
500
501 std::vector<double> res1;
502 res1.push_back(1);
503 res1.push_back(0);
504 res1.push_back(0);
505 res1.push_back(2);
506 res1.push_back(0);
507 res1.push_back(5);
508 EXPECT_DOUBLEVEC_EQUAL(res1, vec1.distances(vec2));
509
510
511 std::vector<double> res2;
512 //invalid: res1.push_back(1);
513 res2.push_back(0);
514 res2.push_back(0);
515 res2.push_back(2);
516 res2.push_back(0);
517 //invalid: res2.push_back(5);
518 EXPECT_DOUBLEVEC_EQUAL(res2, vec1.distances(vec2, true));
519
520
521 std::vector<double> res3;
522 res3.push_back(std::numeric_limits<double>::max());
523 res3.push_back(std::numeric_limits<double>::max());
524 EXPECT_DOUBLEVEC_EQUAL(res3, vec1.distances(vec3));
525 }
526
527 }
528
529 /* Test the method 'overlapsWith'*/
TEST_F(PositionVectorTest,test_method_overlapsWith)530 TEST_F(PositionVectorTest, test_method_overlapsWith) {
531 PositionVector vec1;
532 vec1.push_back(Position(1, 2));
533 vec1.push_back(Position(3, 2));
534 vec1.push_back(Position(3, 6));
535 vec1.push_back(Position(1, 6));
536
537 PositionVector vec2;
538 vec2.push_back(Position(10, 17));
539 vec2.push_back(Position(13, 17));
540 vec2.push_back(Position(13, 16));
541 vec2.push_back(Position(10, 16));
542
543 PositionVector vec3;
544 vec3.push_back(Position(-1, -7));
545 vec3.push_back(Position( 2, -7));
546 vec3.push_back(Position( 2, 4));
547 vec3.push_back(Position(-1, 4));
548
549 PositionVector vec4;
550 vec4.push_back(Position(0, 3));
551 vec4.push_back(Position(4, 3));
552 vec4.push_back(Position(4, 5));
553 vec4.push_back(Position(0, 5));
554
555 PositionVector vec5;
556 vec5.push_back(Position(4, 2));
557 vec5.push_back(Position(5, 2));
558 vec5.push_back(Position(5, 7));
559 vec5.push_back(Position(4, 7));
560
561 PositionVector empty;
562
563 EXPECT_TRUE(vec1.overlapsWith(vec1));
564 EXPECT_FALSE(vec1.overlapsWith(vec2));
565 EXPECT_TRUE(vec1.overlapsWith(vec3));
566 EXPECT_TRUE(vec1.overlapsWith(vec4));
567 EXPECT_FALSE(vec1.overlapsWith(vec5, 0));
568 // growth is from centroid and thus different from Boundary behavior
569 EXPECT_FALSE(vec1.overlapsWith(vec5, 1));
570 EXPECT_TRUE(vec1.overlapsWith(vec5, 3));
571 EXPECT_TRUE(vec1.overlapsWith(vec5, 6));
572 EXPECT_FALSE(vec1.overlapsWith(empty));
573 }
574