← Back to branch summary

~ubuntu-branches/ubuntu/vivid/grass/vivid-proposed

« back to all changes in this revision

Viewing changes to temporal/t.rast.aggregate/testsuite/test_aggregation_relative.py

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-02-20 23:12:08 UTC
  • mfrom: (8.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20150220231208-1u6qvqm84v430b10
Tags: 7.0.0-1~exp1
* New upstream release.
* Update python-ctypes-ternary.patch to use if/else instead of and/or.
* Drop check4dev patch, rely on upstream check.
* Add build dependency on libpq-dev to grass-dev for libpq-fe.h.
* Drop patches applied upstream, refresh remaining patches.
* Update symlinks for images switched from jpg to png.

Show diffs side-by-side

added added

removed removed

Lines of Context:
temporal/t.rast.aggregate/testsuite/test_aggregation_relative.py
 
1
"""Test t.rast.aggregation
 
2
 
 
3
(C) 2014 by the GRASS Development Team
 
4
This program is free software under the GNU General Public
 
5
License (>=v2). Read the file COPYING that comes with GRASS
 
6
for details.
 
7
 
 
8
:authors: Soeren Gebbert
 
9
"""
 
10
import os
 
11
import grass.pygrass.modules as pymod
 
12
import grass.temporal as tgis
 
13
from grass.gunittest.case import TestCase
 
14
from grass.gunittest.gmodules import SimpleModule
 
15
 
 
16
class TestAggregationRelative(TestCase):
 
17
 
 
18
    @classmethod
 
19
    def setUpClass(cls):
 
20
        """Initiate the temporal GIS and set the region
 
21
        """
 
22
        os.putenv("GRASS_OVERWRITE",  "1")
 
23
        tgis.init()
 
24
        cls.use_temp_region()
 
25
        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  
 
26
                      t=50,  res=10,  res3=10)
 
27
        cls.runModule("r.mapcalc", expression="a1 = 100",  overwrite=True)
 
28
        cls.runModule("r.mapcalc", expression="a2 = 200",  overwrite=True)
 
29
        cls.runModule("r.mapcalc", expression="a3 = 300",  overwrite=True)
 
30
        cls.runModule("r.mapcalc", expression="a4 = 400",  overwrite=True)
 
31
        cls.runModule("r.mapcalc", expression="a5 = 500",  overwrite=True)
 
32
        cls.runModule("r.mapcalc", expression="a6 = 600",  overwrite=True)
 
33
        cls.runModule("r.mapcalc", expression="a7 = null()",  overwrite=True)
 
34
 
 
35
        cls.runModule("t.create",  type="strds",  temporaltype="relative",  
 
36
                                    output="A",  title="A test",  
 
37
                                    description="A test",  overwrite=True)
 
38
 
 
39
        cls.runModule("t.register", flags="i",  type="raster",  input="A",  
 
40
                                     maps="a1,a2,a3,a4,a5,a6,a7",
 
41
                                     start=0, unit="days", increment=3, 
 
42
                                     overwrite=True)
 
43
    @classmethod
 
44
    def tearDownClass(cls):
 
45
        """Remove the temporary region
 
46
        """
 
47
        cls.del_temp_region()        
 
48
        cls.runModule("t.remove", flags="rf", type="strds", inputs="A")
 
49
 
 
50
    def tearDown(self):
 
51
        """Remove generated data"""    
 
52
        self.runModule("t.remove", flags="rf", type="strds", inputs="B")
 
53
 
 
54
    def test_1(self):
 
55
        """Simple test"""
 
56
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
57
                          basename="b", granularity=6, 
 
58
                          method="average",
 
59
                          sampling=["overlaps","overlapped","contains"], 
 
60
                          nprocs=2)
 
61
 
 
62
        tinfo_string="""start_time=0
 
63
                        end_time=18
 
64
                        unit=days
 
65
                        granularity=6
 
66
                        map_time=interval
 
67
                        aggregation_type=average
 
68
                        number_of_maps=3
 
69
                        min_min=150.0
 
70
                        min_max=550.0
 
71
                        max_min=150.0
 
72
                        max_max=550.0"""
 
73
 
 
74
        info = SimpleModule("t.info", flags="g", input="B")
 
75
        #info.run()
 
76
        #print info.outputs.stdout
 
77
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
78
                                  precision=2, sep="=")
 
79
 
 
80
    def test_2(self):
 
81
        """Simple test register null maps"""
 
82
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
83
                          basename="b", granularity=9, 
 
84
                          method="maximum",
 
85
                          sampling=["contains"], 
 
86
                          nprocs=4, flags="n")
 
87
 
 
88
        tinfo_string="""semantic_type=mean
 
89
                        start_time=0
 
90
                        end_time=27
 
91
                        unit=days
 
92
                        granularity=9
 
93
                        map_time=interval
 
94
                        aggregation_type=maximum
 
95
                        number_of_maps=3
 
96
                        min_min=300.0
 
97
                        min_max=600.0
 
98
                        max_min=300.0
 
99
                        max_max=600.0"""
 
100
 
 
101
        info = SimpleModule("t.info", flags="g", input="B")
 
102
        #info.run()
 
103
        #print info.outputs.stdout
 
104
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
105
                                  precision=2, sep="=")
 
106
 
 
107
    def test_3(self):
 
108
        """Simple test"""
 
109
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
110
                          basename="b", granularity=9, 
 
111
                          method="maximum",
 
112
                          sampling=["contains"], 
 
113
                          nprocs=4)
 
114
 
 
115
        tinfo_string="""semantic_type=mean
 
116
                        start_time=0
 
117
                        end_time=18
 
118
                        unit=days
 
119
                        granularity=9
 
120
                        map_time=interval
 
121
                        aggregation_type=maximum
 
122
                        number_of_maps=2
 
123
                        min_min=300.0
 
124
                        min_max=600.0
 
125
                        max_min=300.0
 
126
                        max_max=600.0"""
 
127
 
 
128
        info = SimpleModule("t.info", flags="g", input="B")
 
129
        #info.run()
 
130
        #print info.outputs.stdout
 
131
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
132
                                  precision=2, sep="=")
 
133
 
 
134
    def test_4(self):
 
135
        """Simple test"""
 
136
        self.assertModule("t.rast.aggregate", input="A", output="B",
 
137
                          basename="b", granularity=21, 
 
138
                          method="average",
 
139
                          sampling=["contains"],
 
140
                          nprocs=4)
 
141
 
 
142
        tinfo_string="""semantic_type=mean
 
143
                        start_time=0
 
144
                        end_time=21
 
145
                        unit=days
 
146
                        granularity=21
 
147
                        map_time=interval
 
148
                        aggregation_type=average
 
149
                        number_of_maps=2
 
150
                        min_min=350.0
 
151
                        min_max=350.0
 
152
                        max_min=350.0
 
153
                        max_max=350.0"""
 
154
 
 
155
        info = SimpleModule("t.info", flags="g", input="B")
 
156
        #info.run()
 
157
        #print info.outputs.stdout
 
158
        self.assertModuleKeyValue(module=info, reference=tinfo_string, 
 
159
                                  precision=2, sep="=")
 
160
 
 
161
if __name__ == '__main__':
 
162
    from grass.gunittest.main import test
 
163
    test()