Cell_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/types.h"
9 
10 TEST(fields2cover_types_cell, constructor) {
11  F2CLinearRing line{
12  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
13  F2CCell cell {line};
14  F2CCell cell_clone{cell.get()};
15  F2CCell cell2 {cell};
16  F2CCell cell3 {static_cast<OGRGeometry*>(cell.get())};
17 
18  EXPECT_EQ(cell.area(), 4);
19  EXPECT_EQ(cell2.area(), 4);
20  EXPECT_EQ(cell3.area(), 4);
21  EXPECT_EQ(cell_clone.area(), 4);
22  EXPECT_EQ(F2CCell(cell.get()).area(), 4);
23  EXPECT_EQ(F2CCell(cell).area(), 4);
24  EXPECT_THROW(F2CCell(line.get()), std::invalid_argument);
25 }
26 
27 TEST(fields2cover_types_cell, setGeometry) {
28  F2CLinearRing line {
29  F2CPoint(0,0), F2CPoint(2,0), F2CPoint(2,2), F2CPoint(0,2), F2CPoint(0,0)};
30  F2CLinearRing line2 {
31  F2CPoint(0,0), F2CPoint(4,0), F2CPoint(4,4), F2CPoint(0,4), F2CPoint(0,0)};
32  F2CCell cell;
33  EXPECT_EQ(cell.area(), 0);
34  EXPECT_EQ(cell.size(), 0);
35 
36  cell.setGeometry(0, line2);
37  EXPECT_EQ(cell.area(), 16);
38  EXPECT_EQ(cell.size(), 1);
39 
40  cell.setGeometry(0, line);
41  EXPECT_EQ(cell.area(), 4);
42  EXPECT_EQ(cell.size(), 1);
43 
44  cell.setGeometry(1, F2CLinearRing());
45  EXPECT_EQ(cell.area(), 4);
46  EXPECT_EQ(cell.size(), 2);
47 
48  cell.setGeometry(10, line);
49  EXPECT_EQ(cell.area(), 0);
50  EXPECT_EQ(cell.size(), 11);
51 
52  cell.setGeometry(0, line2);
53  EXPECT_EQ(cell.area(), 12);
54  EXPECT_EQ(cell.size(), 11);
55 }
56 
57 TEST(fields2cover_types_cell, area) {
58  F2CCell cell(F2CLinearRing({
59  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)}));
60  EXPECT_EQ(cell.area(), 4);
61 }
62 
63 TEST(fields2cover_types_cell, eq_mult_operator) {
64  F2CCell cell(F2CLinearRing({
65  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)}));
66  cell *= 10.0;
67  EXPECT_EQ(cell.area(), 400);
68 }
69 
70 
71 TEST(fields2cover_types_cell, addRing) {
72  F2CCell cell1;
73  F2CLinearRing ring1{
74  F2CPoint(0, 0), F2CPoint(2, 0),F2CPoint(2, 2), F2CPoint(0, 2), F2CPoint(0, 0)};
75 
76  F2CLinearRing ring2{
77  F2CPoint(0.5, 0.5), F2CPoint(1.5, 0.5), F2CPoint(1.5, 1.5), F2CPoint(0.5, 1.5), F2CPoint(0.5, 0.5)};
78 
79  EXPECT_EQ(ring1.size(), 5);
80  EXPECT_EQ(ring2.size(), 5);
81 
82  cell1.addRing(ring1);
83  EXPECT_EQ(cell1.area(), 4);
84 
85  cell1.addRing(ring2);
86  EXPECT_EQ(cell1.area(), 3);
87  EXPECT_EQ(cell1.size(), 2);
88 
89  auto cell_ring1 = cell1.getGeometry(0);
90  EXPECT_EQ(cell_ring1.size(), 5);
91  EXPECT_EQ(cell_ring1.length(), 8);
92  auto cell_ring2 = cell1.getGeometry(1);
93  EXPECT_EQ(cell_ring2.size(), 5);
94  EXPECT_EQ(cell_ring2.length(), 4);
95 
96  F2CLinearRing cell_ring3, cell_ring4;
97  cell1.getGeometry(0, cell_ring3);
98  EXPECT_EQ(cell_ring3.size(), 5);
99  EXPECT_EQ(cell_ring3.length(), 8);
100  cell1.getGeometry(1, cell_ring4);
101  EXPECT_EQ(cell_ring4.size(), 5);
102  EXPECT_EQ(cell_ring4.length(), 4);
103 
104  const F2CCell cell2 = cell1.clone();
105 
106  F2CLinearRing cell_ring5, cell_ring6;
107  cell2.getGeometry(0, cell_ring5);
108  EXPECT_EQ(cell_ring5.size(), 5);
109  EXPECT_EQ(cell_ring5.length(), 8);
110  cell2.getGeometry(1, cell_ring6);
111  EXPECT_EQ(cell_ring6.size(), 5);
112  EXPECT_EQ(cell_ring6.length(), 4);
113 
114  auto cell_ring7 = cell2.getGeometry(0);
115  EXPECT_EQ(cell_ring7.size(), 5);
116  EXPECT_EQ(cell_ring7.length(), 8);
117  auto cell_ring8 = cell2.getGeometry(1);
118  EXPECT_EQ(cell_ring8.size(), 5);
119  EXPECT_EQ(cell_ring8.length(), 4);
120 
121  F2CLinearRing error_ring;
122  EXPECT_THROW(cell1.getGeometry(100, error_ring), std::out_of_range);
123  EXPECT_THROW(cell2.getGeometry(100, error_ring), std::out_of_range);
124  EXPECT_THROW(cell1.getGeometry(100), std::out_of_range);
125  EXPECT_THROW(cell2.getGeometry(100), std::out_of_range);
126 }
127 
128 TEST(fields2cover_types_cell, createLineUntilBorder) {
129  F2CCell cell;
130  F2CLinearRing ring{
131  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
132  cell.addRing(ring);
133 
134  auto line = cell.createLineUntilBorder(F2CPoint(1, 1), 0);
135 
136  EXPECT_EQ(line.size(), 2);
137  if (line.size() == 2) {
138  EXPECT_EQ(line.getX(0), 1);
139  EXPECT_EQ(line.getY(0), 1);
140  EXPECT_EQ(line.getX(1), 2);
141  EXPECT_EQ(line.getY(1), 1);
142  }
143 
144  auto line2 = cell.createLineUntilBorder(F2CPoint(-1, 1), 0);
145  EXPECT_EQ(line2.size(), 2);
146  EXPECT_EQ(line2.getX(0), -1);
147  EXPECT_EQ(line2.getY(0), 1);
148  EXPECT_EQ(line2.getX(1), 0);
149  EXPECT_EQ(line2.getY(1), 1);
150 }
151 
152 TEST(fields2cover_types_cell, isPointInBorder) {
153  F2CCell cell;
154  F2CLinearRing ring{
155  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
156  cell.addRing(ring);
157 
158  EXPECT_TRUE(cell.isPointInBorder(F2CPoint(2,2)));
159  EXPECT_TRUE(cell.isPointInBorder(F2CPoint(1,2)));
160  EXPECT_FALSE(cell.isPointInBorder(F2CPoint(1,1)));
161  EXPECT_FALSE(cell.isPointInBorder(F2CPoint(10,10)));
162 }
163 
164 TEST(fields2cover_types_cell, isPointIn) {
165  F2CCell cell;
166  F2CLinearRing ring{
167  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
168  cell.addRing(ring);
169 
170  EXPECT_TRUE(cell.isPointIn(F2CPoint(1,1)));
171  EXPECT_FALSE(cell.isPointIn(F2CPoint(2,2)));
172  EXPECT_FALSE(cell.isPointIn(F2CPoint(-1,1)));
173  EXPECT_FALSE(cell.isPointIn(F2CPoint(10,-10)));
174 }
175 
176 TEST(fields2cover_types_cell, convexHull) {
177  F2CLinearRing ring {
178  F2CPoint(0,0), F2CPoint(1,0),F2CPoint(1,1),F2CPoint(0.5, 0.5), F2CPoint(0,1), F2CPoint(0,0)};
179  F2CCell cell(ring);
180  EXPECT_EQ(cell.area(), 0.75);
181  EXPECT_EQ(cell.convexHull().area(), 1.0);
182 }
183 
184 
185 TEST(fields2cover_types_cell, buffer) {
186  F2CLinearRing ring {
187  F2CPoint(0,0), F2CPoint(1,0),F2CPoint(1,1),F2CPoint(0,1), F2CPoint(0,0)};
188  F2CCell cell(ring);
189  EXPECT_EQ(cell.area(), 1);
190 
191  auto ring_buffer = F2CCell::buffer(ring, 0.01);
192  EXPECT_NEAR(ring_buffer.area(), 0.08, 1e-5);
193 
194  auto cell_buffer = F2CCell::buffer(cell, 2.0);
195  EXPECT_EQ(cell.area(), 1);
196  EXPECT_NEAR(cell_buffer.area(), 5*5, 1e-2);
197 
198  F2CPoint p {1, 2};
199  auto point_buffer = F2CCell::buffer(p, 3.0);
200  EXPECT_NEAR(point_buffer.area(), 9*3.141593, 1e-1);
201  EXPECT_EQ(p.getX(), 1);
202  EXPECT_EQ(p.getY(), 2);
203 
204  F2CLineString line {F2CPoint(3,4), F2CPoint(3,6)};
205  auto line_buffer = F2CCell::buffer(line, 4.0);
206  EXPECT_NEAR(line_buffer.area(), 2 * 2 * 4, 1e-1);
207 }
208 
209 TEST(fields2cover_types_sstr, NumberStringConcat) {
210  auto result = f2c::types::sstr("word", 10, "another word", 20, 30);
211  EXPECT_EQ(result, "word10another word2030");
212 
213  std::stringstream ss;
214  ss << std::hex << 10 << f2c::types::sstr(10, 0xA, "10", "a");
215  result = ss.str();
216  EXPECT_EQ(result, "a101010a");
217 
218  result = f2c::types::sstr(std::hex, 10, 10, std::dec, 10, 10);
219  EXPECT_EQ(result, "aa1010");
220 }
221 
222 
223 
f2c::types::Cell::buffer
static Cell buffer(const Cell &geom, double width)
Definition: Cell.cpp:99
f2c::types::Geometries::area
double area() const
Compute area of the geometry.
Definition: Geometries_impl.hpp:14
1_basic_types.line2
line2
Definition: 1_basic_types.py:61
f2c::types::Cell::addRing
void addRing(const LinearRing &ring)
Definition: Cell.cpp:123
types.h
f2c::types::Geometries::clone
SAMETYPE clone() const
Definition: Geometries_impl.hpp:19
F2CCell
f2c::types::Cell F2CCell
Definition: types.h:43
1_basic_types.cell
cell
Definition: 1_basic_types.py:88
f2c::types::sstr
std::string sstr(Args &&... args)
Definition: Cell.h:24
TEST
TEST(fields2cover_types_cell, constructor)
Definition: Cell_test.cpp:10
f2c::types::LinearRing
Definition: LinearRing.h:18
f2c::types::Cell
Definition: Cell.h:32
1_basic_types.ring
ring
Definition: 1_basic_types.py:68
f2c::types::LineString
Definition: LineString.h:19
F2CLinearRing
f2c::types::LinearRing F2CLinearRing
Definition: types.h:41
f2c::types::Point
Definition: Point.h:21
f2c::types::Cell::size
size_t size() const
Definition: Cell.cpp:89
f2c::types::LinearRing::size
size_t size() const
Definition: LinearRing.cpp:55
f2c::types::Cell::getGeometry
void getGeometry(size_t i, LinearRing &ring)
Definition: Cell.cpp:35
F2CPoint
f2c::types::Point F2CPoint
Definition: types.h:38
f2c::types::LinearRing::length
double length() const
Definition: LinearRing.cpp:47

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