Debian Codegraph @

raster/r.slope.aspect/testsuite/test_r_slope_aspect.py

raw
1 from grass.gunittest.case import TestCase
2 from grass.gunittest.main import test
3 from grass.gunittest.gmodules import call_module
4
5 SMALL_MAP = """\
6 north: 15
7 south: 10
8 east: 25
9 west: 20
10 rows: 5
11 cols: 5
12
13 100.0 150.0 150.0 100.0 100.0
14 100.0 150.0 150.0 100.0 100.0
15 100.0 150.0 150.0 150.0 150.0
16 100.0 150.0 150.0 100.0 100.0
17 100.0 150.0 150.0 100.0 100.0
18 """
19
20
21 class TestSlopeAspect(TestCase):
22 slope = "limits_slope"
23 aspect = "limits_aspect"
24 slope_threaded = "limits_slope_threaded"
25 aspect_threaded = "limits_aspect_threaded"
26
27 def setUp(self):
28 self.use_temp_region()
29 call_module("g.region", raster="elevation")
30
31 def tearDown(self):
32 self.del_temp_region()
33 call_module(
34 "g.remove",
35 flags="f",
36 type_="raster",
37 name=[self.slope, self.aspect, self.aspect_threaded, self.slope_threaded],
38 )
39
40 def test_limits(self):
41 self.assertModule(
42 "r.slope.aspect",
43 elevation="elevation",
44 slope=self.slope,
45 aspect=self.aspect,
46 )
47 self.assertModule(
48 "r.slope.aspect",
49 elevation="elevation",
50 slope=self.slope_threaded,
51 aspect=self.aspect_threaded,
52 nprocs=8,
53 )
54 self.assertRasterMinMax(
55 map=self.slope,
56 refmin=0,
57 refmax=90,
58 msg="Slope in degrees must be between 0 and 90",
59 )
60 self.assertRasterMinMax(
61 map=self.slope_threaded,
62 refmin=0,
63 refmax=90,
64 msg="Slope in degrees must be between 0 and 90",
65 )
66 self.assertRasterMinMax(
67 map=self.aspect,
68 refmin=0,
69 refmax=360,
70 msg="Aspect in degrees must be between 0 and 360",
71 )
72 self.assertRasterMinMax(
73 map=self.aspect_threaded,
74 refmin=0,
75 refmax=360,
76 msg="Aspect in degrees must be between 0 and 360",
77 )
78
79 def test_limits_percent(self):
80 """Assumes NC elevation and allows slope up to 100% (45deg)"""
81 self.assertModule(
82 "r.slope.aspect",
83 elevation="elevation",
84 slope=self.slope,
85 aspect=self.aspect,
86 format="percent",
87 )
88 self.assertModule(
89 "r.slope.aspect",
90 elevation="elevation",
91 slope=self.slope_threaded,
92 aspect=self.aspect_threaded,
93 format="percent",
94 nprocs=8,
95 )
96 self.assertRasterMinMax(
97 map=self.slope,
98 refmin=0,
99 refmax=100,
100 msg="Slope in percent must be between 0 and 100",
101 )
102 self.assertRasterMinMax(
103 map=self.slope_threaded,
104 refmin=0,
105 refmax=100,
106 msg="Slope in percent must be between 0 and 100",
107 )
108 self.assertRasterMinMax(
109 map=self.aspect,
110 refmin=0,
111 refmax=360,
112 msg="Aspect in degrees must be between 0 and 360",
113 )
114 self.assertRasterMinMax(
115 map=self.aspect_threaded,
116 refmin=0,
117 refmax=360,
118 msg="Aspect in degrees must be between 0 and 360",
119 )
120
121
122 class TestSlopeAspectAgainstReference(TestCase):
123 """
124
125 Data created using::
126
127 g.region n=20 s=10 e=25 w=15 res=1
128 r.surf.fractal output=fractal_surf
129 r.out.ascii input=fractal_surf output=data/fractal_surf.ascii
130 gdaldem slope .../fractal_surf.ascii .../gdal_slope.grd -of GSAG
131 gdaldem aspect .../fractal_surf.ascii .../gdal_aspect.grd -of GSAG -trigonometric
132
133 GDAL version 1.11.0 was used. Note: GDAL-slope/aspect implementation is originally based on
134 GRASS GIS 4.1.
135 """
136
137 # precision for comparisons
138 precision = 1e-14
139 ref_aspect = "reference_aspect"
140 aspect = "fractal_aspect"
141 aspect_threaded = "fractal_aspect_threaded"
142 ref_slope = "reference_slope"
143 slope = "fractal_slope"
144 slope_threaded = "fractal_slope_threaded"
145
146 @classmethod
147 def setUpClass(cls):
148 cls.use_temp_region()
149 call_module("g.region", n=20, s=10, e=25, w=15, res=1)
150 cls.elevation = "fractal_surf"
151 cls.runModule(
152 "r.in.ascii", input="data/fractal_surf.ascii", output=cls.elevation
153 )
154
155 @classmethod
156 def tearDownClass(cls):
157 cls.del_temp_region()
158 cls.runModule(
159 "g.remove",
160 flags="f",
161 type="raster",
162 name=[
163 cls.elevation,
164 cls.slope,
165 cls.slope_threaded,
166 cls.aspect,
167 cls.aspect_threaded,
168 cls.ref_aspect,
169 cls.ref_slope,
170 ],
171 )
172
173 def test_slope(self):
174 # TODO: using gdal instead of ascii because of cannot seek error
175 self.runModule(
176 "r.in.gdal", flags="o", input="data/gdal_slope.ascii", output=self.ref_slope
177 )
178 self.assertModule("r.slope.aspect", elevation=self.elevation, slope=self.slope)
179 self.assertModule(
180 "r.slope.aspect",
181 elevation=self.elevation,
182 slope=self.slope_threaded,
183 nprocs=8,
184 )
185 # check we have expected values
186 self.assertRasterMinMax(
187 map=self.slope,
188 refmin=0,
189 refmax=90,
190 msg="Slope in degrees must be between 0 and 90",
191 )
192 self.assertRasterMinMax(
193 map=self.slope_threaded,
194 refmin=0,
195 refmax=90,
196 msg="Slope in degrees must be between 0 and 90",
197 )
198 # check against reference data
199 self.assertRastersNoDifference(
200 actual=self.slope, reference=self.ref_slope, precision=self.precision
201 )
202 self.assertRastersNoDifference(
203 actual=self.slope_threaded,
204 reference=self.ref_slope,
205 precision=self.precision,
206 )
207
208 def test_aspect(self):
209 # TODO: using gdal instead of ascii because of cannot seek error
210 self.runModule(
211 "r.in.gdal",
212 flags="o",
213 input="data/gdal_aspect.ascii",
214 output=self.ref_aspect,
215 )
216 self.assertModule(
217 "r.slope.aspect", elevation=self.elevation, aspect=self.aspect
218 )
219 self.assertModule(
220 "r.slope.aspect",
221 elevation=self.elevation,
222 aspect=self.aspect_threaded,
223 nprocs=8,
224 )
225 # check we have expected values
226 self.assertRasterMinMax(
227 map=self.aspect,
228 refmin=0,
229 refmax=360,
230 msg="Aspect in degrees must be between 0 and 360",
231 )
232 self.assertRasterMinMax(
233 map=self.aspect_threaded,
234 refmin=0,
235 refmax=360,
236 msg="Aspect in degrees must be between 0 and 360",
237 )
238 # check against reference data
239 self.assertRastersNoDifference(
240 actual=self.aspect,
241 reference=self.ref_aspect,
242 precision=0.0001, # TODO: Explore why a larger threshold is needed rather than self.precision
243 )
244 self.assertRastersNoDifference(
245 actual=self.aspect_threaded,
246 reference=self.ref_aspect,
247 precision=0.0001, # TODO: Explore why a larger threshold is needed rather than self.precision
248 )
249
250
251 class TestSlopeAspectAgainstItself(TestCase):
252 precision = 1e-14
253 elevation = "elevation"
254
255 t_aspect = "sa_together_aspect"
256 t_slope = "sa_together_slope"
257 t_aspect_threaded = "sa_together_aspect_threaded"
258 t_slope_threaded = "sa_together_slope_threaded"
259
260 s_aspect = "sa_separately_aspect"
261 s_slope = "sa_separately_slope"
262 s_aspect_threaded = "sa_separately_aspect_threaded"
263 s_slope_threaded = "sa_separately_slope_threaded"
264
265 @classmethod
266 def setUpClass(cls):
267 cls.use_temp_region()
268 call_module("g.region", raster="elevation")
269
270 @classmethod
271 def tearDownClass(cls):
272 cls.del_temp_region()
273 call_module(
274 "g.remove",
275 flags="f",
276 type_="raster",
277 name=[
278 cls.t_aspect,
279 cls.t_slope,
280 cls.s_slope,
281 cls.s_aspect,
282 cls.t_aspect_threaded,
283 cls.t_slope_threaded,
284 cls.s_slope_threaded,
285 cls.s_aspect_threaded,
286 ],
287 )
288
289 def test_slope_aspect_together(self):
290 """Slope and aspect computed separately and together should be the same"""
291 self.assertModule(
292 "r.slope.aspect", elevation=self.elevation, aspect=self.s_aspect
293 )
294 self.assertModule(
295 "r.slope.aspect",
296 elevation=self.elevation,
297 aspect=self.s_aspect_threaded,
298 nprocs=8,
299 )
300 self.assertModule(
301 "r.slope.aspect", elevation=self.elevation, slope=self.s_slope
302 )
303 self.assertModule(
304 "r.slope.aspect",
305 elevation=self.elevation,
306 slope=self.s_slope_threaded,
307 nprocs=8,
308 )
309 self.assertModule(
310 "r.slope.aspect",
311 elevation=self.elevation,
312 slope=self.t_slope,
313 aspect=self.t_aspect,
314 )
315 self.assertModule(
316 "r.slope.aspect",
317 elevation=self.elevation,
318 slope=self.t_slope_threaded,
319 aspect=self.t_aspect_threaded,
320 nprocs=8,
321 )
322 self.assertRastersNoDifference(
323 actual=self.t_aspect, reference=self.s_aspect, precision=self.precision
324 )
325 self.assertRastersNoDifference(
326 actual=self.t_aspect_threaded,
327 reference=self.s_aspect,
328 precision=self.precision,
329 )
330 self.assertRastersNoDifference(
331 actual=self.t_slope, reference=self.s_slope, precision=self.precision
332 )
333 self.assertRastersNoDifference(
334 actual=self.t_slope_threaded,
335 reference=self.s_slope,
336 precision=self.precision,
337 )
338
339
340 # TODO: implement this class
341 class TestExtremes(TestCase):
342 slope = "small_slope"
343 aspect = "small_aspect"
344 slope_threaded = "small_slope_threaded"
345 aspect_threaded = "small_aspect_threaded"
346 elevation = "small_elevation"
347
348 def setUp(self):
349 self.use_temp_region()
350
351 def tearDown(self):
352 self.del_temp_region()
353 call_module(
354 "g.remove",
355 flags="f",
356 type_="raster",
357 name=[
358 self.slope,
359 self.aspect,
360 self.slope_threaded,
361 self.aspect_threaded,
362 self.elevation,
363 ],
364 )
365
366 def test_small(self):
367 self.runModule("r.in.ascii", input="-", output=self.elevation, stdin_=SMALL_MAP)
368 call_module("g.region", raster=self.elevation)
369 self.assertModule(
370 "r.slope.aspect",
371 elevation=self.elevation,
372 slope=self.slope,
373 aspect=self.aspect,
374 )
375 self.assertModule(
376 "r.slope.aspect",
377 elevation=self.elevation,
378 slope=self.slope_threaded,
379 aspect=self.aspect_threaded,
380 nprocs=8,
381 )
382 self.assertRasterMinMax(
383 map=self.slope,
384 refmin=0,
385 refmax=90,
386 msg="Slope in degrees must be between 0 and 90",
387 )
388 self.assertRasterMinMax(
389 map=self.slope_threaded,
390 refmin=0,
391 refmax=90,
392 msg="Slope in degrees must be between 0 and 90",
393 )
394 self.assertRasterMinMax(
395 map=self.aspect,
396 refmin=0,
397 refmax=360,
398 msg="Aspect in degrees must be between 0 and 360",
399 )
400 self.assertRasterMinMax(
401 map=self.aspect_threaded,
402 refmin=0,
403 refmax=360,
404 msg="Aspect in degrees must be between 0 and 360",
405 )
406
407
408 class TestSlopeAspectEdge(TestCase):
409 """Test -e flag on slope. Only tests results didn't change between
410 serial and parallelized version.
411 """
412
413 # precision for comparisons
414 precision = 1e-14
415 slope = "elevation_slope"
416 slope_threaded = "elevation_slope_threaded"
417 slope_edge = "elevation_slope_edge"
418 slope_threaded_edge = "elevation_slope_threaded_edge"
419
420 @classmethod
421 def setUpClass(cls):
422 cls.use_temp_region()
423 cls.elevation = "elevation@PERMANENT"
424 call_module("g.region", raster=cls.elevation)
425
426 @classmethod
427 def tearDownClass(cls):
428 cls.del_temp_region()
429 cls.runModule(
430 "g.remove",
431 flags="f",
432 type="raster",
433 name=[
434 cls.slope,
435 cls.slope_threaded,
436 cls.slope_edge,
437 cls.slope_threaded_edge,
438 ],
439 )
440
441 def test_slope(self):
442 self.assertModule("r.slope.aspect", elevation=self.elevation, slope=self.slope)
443 self.assertModule(
444 "r.slope.aspect",
445 elevation=self.elevation,
446 slope=self.slope_threaded,
447 nprocs=8,
448 )
449 values = "null_cells=5696\nmean=3.86452240667335"
450 self.assertRasterFitsUnivar(
451 raster=self.slope, reference=values, precision=self.precision
452 )
453 self.assertRasterFitsUnivar(
454 raster=self.slope_threaded, reference=values, precision=self.precision
455 )
456 # check we have expected values
457 self.assertModule(
458 "r.slope.aspect", elevation=self.elevation, slope=self.slope_edge, flags="e"
459 )
460 self.assertModule(
461 "r.slope.aspect",
462 elevation=self.elevation,
463 slope=self.slope_threaded_edge,
464 flags="e",
465 nprocs=8,
466 )
467 values = "null_cells=0\nmean=3.86118542369876"
468 self.assertRasterFitsUnivar(
469 raster=self.slope_edge, reference=values, precision=self.precision
470 )
471 self.assertRasterFitsUnivar(
472 raster=self.slope_threaded_edge, reference=values, precision=self.precision
473 )
474
475
476 class TestSlopeAspectAllOutputs(TestCase):
477 """Test all outputs. Only tests results didn't change between
478 serial and parallelized version.
479 """
480
481 # precision for comparisons
482 precision = 1e-11
483 slope = "elevation_slope"
484 slope_threaded = "elevation_slope_threaded"
485 aspect = "elevation_aspect"
486 aspect_threaded = "elevation_aspect_threaded"
487 pcurvature = "elevation_pcurvature"
488 pcurvature_threaded = "elevation_pcurvature_threaded"
489 tcurvature = "elevation_tcurvature"
490 tcurvature_threaded = "elevation_tcurvature_threaded"
491 dx = "elevation_dx"
492 dx_threaded = "elevation_dx_threaded"
493 dy = "elevation_dy"
494 dy_threaded = "elevation_dy_threaded"
495 dxx = "elevation_dxx"
496 dxx_threaded = "elevation_dxx_threaded"
497 dyy = "elevation_dyy"
498 dyy_threaded = "elevation_dyy_threaded"
499 dxy = "elevation_dxy"
500 dxy_threaded = "elevation_dxy_threaded"
501
502 @classmethod
503 def setUpClass(cls):
504 cls.use_temp_region()
505 cls.elevation = "elevation@PERMANENT"
506 call_module("g.region", raster=cls.elevation)
507
508 @classmethod
509 def tearDownClass(cls):
510 cls.del_temp_region()
511 cls.runModule(
512 "g.remove",
513 flags="f",
514 type="raster",
515 name=[
516 cls.slope,
517 cls.slope_threaded,
518 cls.aspect,
519 cls.aspect_threaded,
520 cls.pcurvature,
521 cls.pcurvature_threaded,
522 cls.tcurvature,
523 cls.tcurvature_threaded,
524 cls.dx,
525 cls.dx_threaded,
526 cls.dy,
527 cls.dy_threaded,
528 cls.dxx,
529 cls.dxx_threaded,
530 cls.dyy,
531 cls.dyy_threaded,
532 cls.dxy,
533 cls.dxy_threaded,
534 ],
535 )
536
537 def test_slope(self):
538 self.assertModule("r.slope.aspect", elevation=self.elevation, slope=self.slope)
539 self.assertModule(
540 "r.slope.aspect",
541 elevation=self.elevation,
542 slope=self.slope_threaded,
543 nprocs=8,
544 )
545 values = "mean=3.86452240667335\nrange=38.6893920898438"
546 self.assertRasterFitsUnivar(
547 raster=self.slope, reference=values, precision=self.precision
548 )
549 self.assertRasterFitsUnivar(
550 raster=self.slope_threaded, reference=values, precision=self.precision
551 )
552
553 def test_aspect(self):
554 self.assertModule(
555 "r.slope.aspect", elevation=self.elevation, aspect=self.aspect
556 )
557 self.assertModule(
558 "r.slope.aspect",
559 elevation=self.elevation,
560 aspect=self.aspect_threaded,
561 nprocs=8,
562 )
563 values = "mean=190.022878119363\nrange=360"
564 self.assertRasterFitsUnivar(
565 raster=self.aspect, reference=values, precision=self.precision
566 )
567 self.assertRasterFitsUnivar(
568 raster=self.aspect_threaded, reference=values, precision=self.precision
569 )
570
571 def test_pcurvature(self):
572 self.assertModule(
573 "r.slope.aspect", elevation=self.elevation, pcurvature=self.pcurvature
574 )
575 self.assertModule(
576 "r.slope.aspect",
577 elevation=self.elevation,
578 pcurvature=self.pcurvature_threaded,
579 nprocs=8,
580 )
581 values = "mean=-8.11389945677247e-06\nrange=0.18258623033762"
582 self.assertRasterFitsUnivar(
583 raster=self.pcurvature, reference=values, precision=self.precision
584 )
585 self.assertRasterFitsUnivar(
586 raster=self.pcurvature_threaded, reference=values, precision=self.precision
587 )
588
589 def test_tcurvature(self):
590 self.assertModule(
591 "r.slope.aspect", elevation=self.elevation, tcurvature=self.tcurvature
592 )
593 self.assertModule(
594 "r.slope.aspect",
595 elevation=self.elevation,
596 tcurvature=self.tcurvature_threaded,
597 nprocs=8,
598 )
599 values = "mean=9.98676512087167e-06\nrange=0.173980213701725"
600 self.assertRasterFitsUnivar(
601 raster=self.tcurvature, reference=values, precision=self.precision
602 )
603 self.assertRasterFitsUnivar(
604 raster=self.tcurvature_threaded, reference=values, precision=self.precision
605 )
606
607 def test_dx(self):
608 self.assertModule("r.slope.aspect", elevation=self.elevation, dx=self.dx)
609 self.assertModule(
610 "r.slope.aspect",
611 elevation=self.elevation,
612 dx=self.dx_threaded,
613 nprocs=8,
614 )
615 values = "mean=0.00298815584231336\nrange=1.22372794151306"
616 self.assertRasterFitsUnivar(
617 raster=self.dx, reference=values, precision=self.precision
618 )
619 self.assertRasterFitsUnivar(
620 raster=self.dx_threaded, reference=values, precision=self.precision
621 )
622
623 def test_dy(self):
624 self.assertModule("r.slope.aspect", elevation=self.elevation, dy=self.dy)
625 self.assertModule(
626 "r.slope.aspect",
627 elevation=self.elevation,
628 dy=self.dy_threaded,
629 nprocs=8,
630 )
631 values = "mean=-0.000712442231985616\nrange=1.43247389793396"
632 self.assertRasterFitsUnivar(
633 raster=self.dy, reference=values, precision=self.precision
634 )
635 self.assertRasterFitsUnivar(
636 raster=self.dy_threaded, reference=values, precision=self.precision
637 )
638
639 def test_dxx(self):
640 self.assertModule("r.slope.aspect", elevation=self.elevation, dxx=self.dxx)
641 self.assertModule(
642 "r.slope.aspect",
643 elevation=self.elevation,
644 dxx=self.dxx_threaded,
645 nprocs=8,
646 )
647 values = "mean=1.3698233535033e-06\nrange=0.211458221077919"
648 self.assertRasterFitsUnivar(
649 raster=self.dxx, reference=values, precision=self.precision
650 )
651 self.assertRasterFitsUnivar(
652 raster=self.dxx_threaded, reference=values, precision=self.precision
653 )
654
655 def test_dyy(self):
656 self.assertModule("r.slope.aspect", elevation=self.elevation, dyy=self.dyy)
657 self.assertModule(
658 "r.slope.aspect",
659 elevation=self.elevation,
660 dyy=self.dyy_threaded,
661 nprocs=8,
662 )
663 values = "mean=1.58118857641799e-06\nrange=0.217463649809361"
664 self.assertRasterFitsUnivar(
665 raster=self.dyy, reference=values, precision=self.precision
666 )
667 self.assertRasterFitsUnivar(
668 raster=self.dyy_threaded, reference=values, precision=self.precision
669 )
670
671 def test_dxy(self):
672 self.assertModule("r.slope.aspect", elevation=self.elevation, dxy=self.dxy)
673 self.assertModule(
674 "r.slope.aspect",
675 elevation=self.elevation,
676 dxy=self.dxy_threaded,
677 nprocs=8,
678 )
679 values = "mean=2.07370162614472e-07\nrange=0.0772973857820034"
680 self.assertRasterFitsUnivar(
681 raster=self.dxy, reference=values, precision=self.precision
682 )
683 self.assertRasterFitsUnivar(
684 raster=self.dxy_threaded, reference=values, precision=self.precision
685 )
686
687
688 if __name__ == "__main__":
689 test()