Cells_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_cells, constructor) {
11  F2CLinearRing ring1{
12  F2CPoint(0,0), F2CPoint(1,0),F2CPoint(1, 1),F2CPoint(0, 1), F2CPoint(0, 0)};
13  F2CCell cell {ring1};
14  F2CCells cells;
15  EXPECT_EQ(cells.size(), 0);
16  cells.addGeometry(cell);
17  const F2CCells cells_clone {cells.get()};
18 
19  EXPECT_EQ(cells.area(), 1);
20  EXPECT_EQ(cells_clone.area(), 1);
21  EXPECT_EQ(cells_clone.getGeometry(0).area(), 1);
22 
23 
24  auto ring2 = ring1.clone();
25  ring2 *= 2.0;
26  auto ring3 = ring1 + F2CPoint(0.5, 0.5);
27  F2CCell cell2;
28  EXPECT_EQ(cell2.area(), 0);
29  cells.addGeometry(cell2);
30  cells.addRing(1, ring2);
31  cells.addRing(1, ring3);
32  EXPECT_EQ(cells.getInteriorRing(1, 0).length(), 4);
33 
34  OGRGeometryCollection gc;
35  F2CCells empty_cells{&gc};
36  EXPECT_EQ(empty_cells.size(), 0);
37 
38  F2CCell error_cell;
39  EXPECT_THROW(cells.getGeometry(100, error_cell), std::out_of_range);
40  EXPECT_THROW(cells_clone.getGeometry(100, error_cell), std::out_of_range);
41  EXPECT_THROW(cells.getGeometry(100), std::out_of_range);
42  EXPECT_THROW(cells_clone.getGeometry(100), std::out_of_range);
43 }
44 
45 TEST(fields2cover_types_cells, difference) {
46  F2CCell cell1, cell2;
47  F2CLinearRing ring1{F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
48  F2CLinearRing ring2{F2CPoint(1,0), F2CPoint(3,0),F2CPoint(3,2),F2CPoint(1,2), F2CPoint(1,0)};
49  cell1.addRing(ring1);
50  cell2.addRing(ring2);
51 
52  EXPECT_EQ(ring1.size(), 5);
53  EXPECT_EQ(ring2.size(), 5);
54  EXPECT_EQ(cell1.area(), 4);
55  EXPECT_EQ(cell2.area(), 4);
56  EXPECT_EQ(F2CCells(cell1).area(), 4);
57  EXPECT_EQ(F2CCells(cell2).area(), 4);
58  EXPECT_EQ(F2CCells(cell1).difference(F2CCells(cell2)).area(), 2);
59 }
60 
61 TEST(fields2cover_types_cells, unionOp) {
62  F2CCell cell1, cell2;
63  F2CLinearRing ring1{F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
64  F2CLinearRing ring2{F2CPoint(1,0), F2CPoint(3,0),F2CPoint(3,2),F2CPoint(1,2), F2CPoint(1,0)};
65  cell1.addRing(ring1);
66  cell2.addRing(ring2);
67 
68  EXPECT_EQ(ring1.size(), 5);
69  EXPECT_EQ(ring2.size(), 5);
70  EXPECT_EQ(cell1.area(), 4);
71  EXPECT_EQ(cell2.area(), 4);
72  EXPECT_EQ(F2CCells(cell1).area(), 4);
73  EXPECT_EQ(F2CCells(cell2).area(), 4);
74  EXPECT_EQ(F2CCells(cell1).unionOp(F2CCells(cell2)).area(), 6);
75 }
76 
77 TEST(fields2cover_types_cells, buffer) {
78  F2CLineString line {
79  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
80  F2CCells cells = F2CCells::buffer(line, 2);
81  EXPECT_GE(cells.area(), 32);
82  EXPECT_LE(cells.area(), 36);
83  cells = F2CCells::buffer(line, -1);
84  EXPECT_EQ(cells.area(), 0);
85 
86  cells = F2CCells::buffer(line, 2);
87  F2CCells cells2 = F2CCells::buffer(cells, -0.1);
88  EXPECT_LT(cells2.area(), cells.area());
89  EXPECT_GT(cells2.area(), 0.8 * cells.area());
90 
91  cells = F2CCells::buffer(F2CLineString(), 20);
92  EXPECT_EQ(cells.area(), 0);
93 }
94 
95 TEST(fields2cover_types_cells, intersection) {
96  F2CCell cell1, cell2;
97  F2CLinearRing ring1{F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
98  F2CLinearRing ring2{F2CPoint(1,0), F2CPoint(3,0),F2CPoint(3,2),F2CPoint(1,2), F2CPoint(1,0)};
99  cell1.addRing(ring1);
100  cell2.addRing(ring2);
101  F2CCells cells2{cell2};
102  EXPECT_EQ(F2CCells::intersection(cell1, cell2).area(), 2);
103  EXPECT_EQ(cells2.intersection(cell1).area(), 2);
104 }
105 
106 
107 TEST(fields2cover_types_cells, LongLines) {
108  F2CCells cells {
109  F2CCell(F2CLinearRing({
110  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)
111  }))
112  };
113 
114  auto line1 = cells.createSemiLongLine(F2CPoint(0,0), 3.0*M_PI/4.0);
115  auto line2 = cells.createStraightLongLine(F2CPoint(0,0), 3.0*M_PI/4.0);
116 
117  EXPECT_NEAR(line1.getX(0), 0, 1e-3);
118  EXPECT_NEAR(line1.getY(0), 0, 1e-3);
119  EXPECT_NEAR(line1.getX(1), -2*sqrt(2.), 1e-3);
120  EXPECT_NEAR(line1.getY(1), 2*sqrt(2.), 1e-3);
121  EXPECT_NEAR(line2.getX(0), 2*sqrt(2.), 1e-3);
122  EXPECT_NEAR(line2.getY(0), -2*sqrt(2.), 1e-3);
123  EXPECT_NEAR(line2.getX(1), -2*sqrt(2.), 1e-3);
124  EXPECT_NEAR(line2.getY(1), 2*sqrt(2.), 1e-3);
125 }
126 
127 TEST(fields2cover_types_cells, WherePoint) {
128  F2CCells cells {
129  F2CCell(F2CLinearRing({
130  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)
131  }))
132  };
133  cells.addGeometry(F2CCell(F2CLinearRing({
134  F2CPoint(10,9), F2CPoint(12,9),F2CPoint(12,12),F2CPoint(10,12), F2CPoint(10,9)
135  })));
136 
137  EXPECT_TRUE(cells.isPointInBorder(F2CPoint(0, 0)));
138  EXPECT_TRUE(cells.isPointInBorder(F2CPoint(1, 0)));
139  EXPECT_TRUE(cells.isPointInBorder(F2CPoint(11, 12)));
140  EXPECT_FALSE(cells.isPointInBorder(F2CPoint(1, 1)));
141  EXPECT_FALSE(cells.isPointInBorder(F2CPoint(5, 5)));
142  EXPECT_EQ(cells.getCellWherePoint(F2CPoint(5, 5)).area(), 0);
143  EXPECT_EQ(cells.getCellWherePoint(F2CPoint(1, 1)).area(), 4);
144  EXPECT_EQ(cells.getCellWherePoint(F2CPoint(0, 0)).area(), 4);
145  EXPECT_EQ(cells.getCellWherePoint(F2CPoint(11, 11)).area(), 6);
146 }
147 
148 TEST(fields2cover_types_cells, setGeometry) {
149  F2CLinearRing line {
150  F2CPoint(0,0), F2CPoint(2,0), F2CPoint(2,2), F2CPoint(0,2), F2CPoint(0,0)};
151  F2CLinearRing line2 {
152  F2CPoint(0,0), F2CPoint(4,0), F2CPoint(4,4), F2CPoint(0,4), F2CPoint(0,0)};
153  F2CCell cell1 {line + F2CPoint(100,100)};
154  F2CCell cell2 {line2 + F2CPoint(200,0)};
155  F2CCell cell3 {line2 + F2CPoint(-30,-80)};
156  F2CCells cells;
157  EXPECT_EQ(cells.area(), 0);
158  EXPECT_EQ(cells.size(), 0);
159 
160  cells.setGeometry(0, cell2);
161  EXPECT_EQ(cells.area(), 16);
162  EXPECT_EQ(cells.size(), 1);
163 
164  cells.setGeometry(0, cell1);
165  EXPECT_EQ(cells.area(), 4);
166  EXPECT_EQ(cells.size(), 1);
167 
168  cells.setGeometry(1, F2CCell());
169  EXPECT_EQ(cells.area(), 4);
170  EXPECT_EQ(cells.size(), 2);
171 
172  cells.setGeometry(10, cell2);
173  EXPECT_EQ(cells.area(), 20);
174  EXPECT_EQ(cells.size(), 11);
175 
176  cells.setGeometry(0, cell3);
177  EXPECT_EQ(cells.area(), 32);
178  EXPECT_EQ(cells.size(), 11);
179 }
180 
181 
182 TEST(fields2cover_types_cells, splitByLine) {
183  F2CCells cells {F2CCell(F2CLinearRing({
184  F2CPoint(0,0), F2CPoint(5,0), F2CPoint(5,4), F2CPoint(0,4), F2CPoint(0,0)}))};
185  F2CLineString line1{F2CPoint(3,0), F2CPoint(3,4)};
186  F2CLineString line2 = cells.createLineUntilBorder(F2CPoint(0,3), 0.0);
187  F2CMultiLineString lines;
188  lines.setGeometry(0, line1);
189  lines.setGeometry(1, line2);
190 
191  F2CCells split_cells = cells.splitByLine(lines);
192  EXPECT_NEAR(split_cells.size(), 4, 1e-7);
193  EXPECT_NEAR(split_cells.getGeometry(0).area(), 9, 1e-7);
194  EXPECT_NEAR(split_cells.getGeometry(1).area(), 3, 1e-7);
195  EXPECT_NEAR(split_cells.getGeometry(2).area(), 2, 1e-7);
196  EXPECT_NEAR(split_cells.getGeometry(3).area(), 6, 1e-7);
197 }
198 
199 TEST(fields2cover_types_cells, isPointIn) {
200  F2CCell cell;
201  F2CLinearRing ring{
202  F2CPoint(0,0), F2CPoint(2,0),F2CPoint(2,2),F2CPoint(0,2), F2CPoint(0,0)};
203  cell.addRing(ring);
204  F2CCells cells{cell};
205 
206  EXPECT_TRUE(cells.isPointIn(F2CPoint(1,1)));
207  EXPECT_FALSE(cells.isPointIn(F2CPoint(2,2)));
208  EXPECT_FALSE(cells.isPointIn(F2CPoint(-1,1)));
209  EXPECT_FALSE(cells.isPointIn(F2CPoint(10,-10)));
210 }
211 
212 
f2c::types::Geometries::area
double area() const
Compute area of the geometry.
Definition: Geometries_impl.hpp:14
1_basic_types.cells
cells
Definition: 1_basic_types.py:93
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::Cells::intersection
static Cells intersection(const Cell &cell, const Cell &c)
Definition: Cells.cpp:148
F2CCell
f2c::types::Cell F2CCell
Definition: types.h:43
1_basic_types.cell
cell
Definition: 1_basic_types.py:88
F2CCells
f2c::types::Cells F2CCells
Definition: types.h:44
f2c::types::Cells::size
size_t size() const
Definition: Cells.cpp:135
f2c::types::MultiLineString
Definition: MultiLineString.h:18
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::Cells
Definition: Cells.h:21
F2CLineString
f2c::types::LineString F2CLineString
Definition: types.h:40
TEST
TEST(fields2cover_types_cells, constructor)
Definition: Cells_test.cpp:10
f2c::types::Point
Definition: Point.h:21
f2c::types::Cells::getGeometry
void getGeometry(size_t i, Cell &cell)
Definition: Cells.cpp:63
f2c::types::Cells::buffer
static Cells buffer(const Geometry< T, R > &geom, double width, int side=0)
Definition: Cells.h:99
1_basic_types.lines
lines
Definition: 1_basic_types.py:73
1_basic_types.line1
line1
Definition: 1_basic_types.py:56
F2CPoint
f2c::types::Point F2CPoint
Definition: types.h:38

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