Debian Codegraph @

general/g.region/testsuite/test_g_region.py

raw
1 """Test of g.region
2
3 @author Anna Petrasova
4 """
5
6 import json
7 from copy import deepcopy
8
9 from grass.gunittest.case import TestCase
10 from grass.gunittest.gmodules import call_module
11 import grass.script as gs
12
13
14 class TestRegion(TestCase):
15 @classmethod
16 def setUpClass(cls):
17 """Use temporary region settings"""
18 cls.use_temp_region()
19
20 @classmethod
21 def tearDownClass(cls):
22 """!Remove the temporary region"""
23 cls.del_temp_region()
24
25 def test_d_flag(self):
26 n = 228500
27 res = 1
28 n_default = 320000
29 res_default = 500
30
31 self.runModule("g.region", res=res, n=n)
32 region = gs.region()
33 self.assertEqual(n, region["n"])
34 self.assertEqual(res, region["nsres"])
35
36 # test default with no update flag
37 self.runModule("g.region", flags="dup")
38 region = gs.region()
39 self.assertEqual(n, region["n"])
40 self.assertEqual(res, region["nsres"])
41
42 # test set default
43 self.runModule("g.region", flags="d")
44 region = gs.region()
45 self.assertEqual(n_default, region["n"])
46 self.assertEqual(res_default, region["nsres"])
47
48 def test_f_flag(self):
49 line = call_module("g.region", flags="flecn3", capture_stdout=True)
50 self.assertEqual(1, len(line.splitlines()))
51
52 # Test that the -f flag ignores the format option
53 plain_result = call_module(
54 "g.region", flags="flecn3", format="plain", capture_stdout=True
55 )
56 self.assertEqual(plain_result, line)
57
58 shell_result = call_module(
59 "g.region", flags="flecn3", format="shell", capture_stdout=True
60 )
61 self.assertEqual(shell_result, line)
62
63 json_result = call_module(
64 "g.region", flags="flecn3", format="json", capture_stdout=True
65 )
66 self.assertEqual(json_result, line)
67
68 def test_plain_format(self):
69 """Test plain format with plectwmn3b flags"""
70 actual = call_module(
71 "g.region", flags="plectwmn3b", capture_stdout=True
72 ).splitlines()
73 expected = [
74 "projection: 99 (Lambert Conformal Conic)",
75 "zone: 0",
76 "datum: nad83",
77 "ellipsoid: a=6378137 es=0.006694380022900787",
78 "north: 320000",
79 "south: 10000",
80 "west: 120000",
81 "east: 935000",
82 "top: 500.00000000",
83 "bottom: -500.00000000",
84 "nsres: 500",
85 "nsres3: 1000",
86 "ewres: 500",
87 "ewres3: 1000",
88 "tbres: 100",
89 "rows: 620",
90 "rows3: 310",
91 "cols: 1630",
92 "cols3: 815",
93 "depths: 10",
94 "cells: 1010600",
95 "cells3: 2526500",
96 "north-west corner: long: 84:28:04.377741W lat: 36:30:46.34437N",
97 "north-east corner: long: 75:21:49.978849W lat: 36:34:50.504N",
98 "south-east corner: long: 75:29:11.170792W lat: 33:47:17.613554N",
99 "south-west corner: long: 84:17:01.637788W lat: 33:43:21.583472N",
100 "center longitude: 79:54:07.438969W",
101 "center latitude: 35:14:02.62575N",
102 "north-south extent: 310000.000000",
103 "east-west extent: 815000.000000",
104 "center easting: 527500.000000",
105 "center northing: 165000.000000",
106 "120000/935000/10000/320000",
107 "bbox=120000,10000,935000,320000",
108 "convergence angle: -0.520646",
109 "north latitude: 36:38:03.826722N",
110 "south latitude: 33:43:21.583472N",
111 "west longitude: 84:28:04.377741W",
112 "east longitude: 75:21:49.978849W",
113 "center longitude: 79:54:57.178295W",
114 "center latitude: 35:10:42.705097N",
115 ]
116 self.assertEqual(actual, expected)
117
118 plain_actual = call_module(
119 "g.region", flags="plectwmn3b", format="plain", capture_stdout=True
120 ).splitlines()
121 self.assertEqual(plain_actual, actual)
122
123 def test_shell_format(self):
124 """Test shell format with plectwmn3b flags"""
125 actual = call_module(
126 "g.region", flags="gplectwmn3b", capture_stdout=True
127 ).splitlines()
128 expected = [
129 "projection=99",
130 "zone=0",
131 "n=320000",
132 "s=10000",
133 "w=120000",
134 "e=935000",
135 "t=500",
136 "b=-500",
137 "nsres=500",
138 "nsres3=1000",
139 "ewres=500",
140 "ewres3=1000",
141 "tbres=100",
142 "rows=620",
143 "rows3=310",
144 "cols=1630",
145 "cols3=815",
146 "depths=10",
147 "cells=1010600",
148 "cells3=2526500",
149 "nw_long=-84.46788271",
150 "nw_lat=36.51287344",
151 "ne_long=-75.36388301",
152 "ne_lat=36.58069556",
153 "se_long=-75.48643633",
154 "se_lat=33.78822599",
155 "sw_long=-84.28378827",
156 "sw_lat=33.72266208",
157 "center_long=-79.90206638",
158 "center_lat=35.23406271",
159 "ns_extent=310000.000000",
160 "ew_extent=815000.000000",
161 "center_easting=527500.000000",
162 "center_northing=165000.000000",
163 "120000/935000/10000/320000",
164 "bbox=120000,10000,935000,320000",
165 "converge_angle=-0.520646",
166 "ll_n=36.63439631",
167 "ll_s=33.72266208",
168 "ll_w=-84.46788271",
169 "ll_e=-75.36388301",
170 "ll_clon=-79.91588286",
171 "ll_clat=35.17852919",
172 ]
173 self.assertEqual(actual, expected)
174
175 shell_actual = call_module(
176 "g.region", flags="plectwmn3b", format="shell", capture_stdout=True
177 ).splitlines()
178 self.assertEqual(shell_actual, actual)
179
180 def test_format_json(self):
181 """Test default json format output"""
182 expected = {
183 "north": 320000,
184 "south": 10000,
185 "west": 120000,
186 "east": 935000,
187 "nsres": 500,
188 "ewres": 500,
189 "rows": 620,
190 "cols": 1630,
191 "cells": 1010600,
192 "crs": {
193 "name": "Lambert Conformal Conic",
194 "type": "other",
195 "type_code": 99,
196 "zone": None,
197 },
198 }
199
200 output = call_module("g.region", flags="p", format="json")
201 output_json = json.loads(output)
202
203 self.assertEqual(expected, output_json)
204
205 def test_json_with_flags(self):
206 """Test json format with plectwmn3b flags"""
207 expected = {
208 "north": 320000,
209 "south": 10000,
210 "west": 120000,
211 "east": 935000,
212 "nsres": 500,
213 "ewres": 500,
214 "rows": 620,
215 "cols": 1630,
216 "nsres3": 1000,
217 "ewres3": 1000,
218 "top": 500,
219 "bottom": -500,
220 "rows3": 310,
221 "cols3": 815,
222 "tbres": 100,
223 "depths": 10,
224 "cells": 1010600,
225 "cells3": 2526500,
226 "nw_long": -84.46788270593447,
227 "nw_lat": 36.51287343603797,
228 "ne_long": -75.36388301356145,
229 "ne_lat": 36.58069555564893,
230 "se_long": -75.48643633119754,
231 "se_lat": 33.788225987168964,
232 "sw_long": -84.28378827453474,
233 "sw_lat": 33.72266207547134,
234 "center_long": -79.90206638014922,
235 "center_lat": 35.23406270825776,
236 "ns_extent": 310000,
237 "ew_extent": 815000,
238 "center_easting": 527500,
239 "center_northing": 165000,
240 "GMT": "120000/935000/10000/320000",
241 "WMS": "bbox=120000,10000,935000,320000",
242 "converge_angle": -0.5206458828749483,
243 "ll_n": 36.634396311574996,
244 "ll_s": 33.72266207547134,
245 "ll_w": -84.46788270593447,
246 "ll_e": -75.36388301356145,
247 "ll_clon": -79.91588285974797,
248 "ll_clat": 35.17852919352317,
249 "crs": {
250 "name": "Lambert Conformal Conic",
251 "type": "other",
252 "type_code": 99,
253 "zone": None,
254 },
255 }
256
257 output = call_module("g.region", flags="plectwmn3b", format="json")
258 output_json = json.loads(output)
259
260 self.assertCountEqual(list(expected.keys()), list(output_json.keys()))
261 for key, value in expected.items():
262 if isinstance(value, float):
263 self.assertAlmostEqual(value, output_json[key], places=6)
264 else:
265 self.assertEqual(value, output_json[key])
266
267 def test_2d_region(self):
268 region_before = gs.region()
269 test_nsres = region_before["nsres"] / 2
270 test_ewres = region_before["ewres"] / 2
271 self.runModule("g.region", nsres=test_nsres, ewres=test_ewres)
272 region_after = gs.region()
273 self.assertAlmostEqual(test_nsres, region_after["nsres"])
274 self.assertAlmostEqual(test_ewres, region_after["ewres"])
275
276 def test_3d_region(self):
277 # Make sure region is default
278 self.runModule("g.region", flags="d")
279 region_before = deepcopy(gs.region(region3d=True))
280 test_nsres3 = region_before["nsres3"] / 5
281 test_ewres3 = region_before["ewres3"] / 2
282 test_tbres = region_before["tbres"] / 4
283 precision = 7
284 self.runModule(
285 "g.region", nsres3=test_nsres3, ewres3=test_ewres3, tbres=test_tbres
286 )
287 region_after = gs.region(region3d=True)
288 # Setting 3D resolution does not change the extent or 2D resolution
289 self.assertEqual(region_before["n"], region_after["n"])
290 self.assertEqual(region_before["s"], region_after["s"])
291 self.assertEqual(region_before["e"], region_after["e"])
292 self.assertEqual(region_before["w"], region_after["w"])
293 self.assertEqual(region_before["t"], region_after["t"])
294 self.assertEqual(region_before["b"], region_after["b"])
295 self.assertEqual(region_before["nsres"], region_after["nsres"])
296 self.assertEqual(region_before["ewres"], region_after["ewres"])
297
298 # 3D resolution settings are applied correctly
299 self.assertAlmostEqual(region_after["nsres3"], test_nsres3, places=precision)
300 self.assertAlmostEqual(region_after["ewres3"], test_ewres3, places=precision)
301 self.assertAlmostEqual(region_after["tbres"], test_tbres, places=precision)
302
303 # res3 is applied to all 3D resolutions
304 test_res3 = 2
305 self.runModule("g.region", res3=test_res3)
306 region_after = gs.region(region3d=True)
307 self.assertAlmostEqual(region_after["nsres3"], test_res3, places=precision)
308 self.assertAlmostEqual(region_after["ewres3"], test_res3, places=precision)
309 self.assertAlmostEqual(region_after["tbres"], test_res3, places=precision)
310
311 # res3 is overridden by individual settings
312 # tbres
313 self.runModule("g.region", res3=test_res3, tbres=test_tbres)
314 region_after = gs.region(region3d=True)
315 self.assertAlmostEqual(region_after["nsres3"], test_res3, places=precision)
316 self.assertAlmostEqual(region_after["ewres3"], test_res3, places=precision)
317 self.assertAlmostEqual(region_after["tbres"], test_tbres, places=precision)
318 # ewres3
319 self.runModule("g.region", res3=test_res3, ewres3=test_ewres3)
320 region_after = gs.region(region3d=True)
321 self.assertAlmostEqual(region_after["nsres3"], test_res3, places=precision)
322 self.assertAlmostEqual(region_after["ewres3"], test_ewres3, places=precision)
323 self.assertAlmostEqual(region_after["tbres"], test_res3, places=precision)
324 # nsres3
325 self.runModule("g.region", res3=test_res3, nsres3=test_nsres3)
326 region_after = gs.region(region3d=True)
327 self.assertAlmostEqual(region_after["nsres3"], test_nsres3, places=precision)
328 self.assertAlmostEqual(region_after["ewres3"], test_res3, places=precision)
329 self.assertAlmostEqual(region_after["tbres"], test_res3, places=precision)
330
331
332 if __name__ == "__main__":
333 from grass.gunittest.main import test
334
335 test()