← Back to branch summary

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

« back to all changes in this revision

Viewing changes to temporal/t.vect.algebra/testsuite/test_vector_algebra.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.vect.algebra/testsuite/test_vector_algebra.py
 
1
"""
 
2
(C) 2014 by the GRASS Development Team
 
3
This program is free software under the GNU General Public
 
4
License (>=v2). Read the file COPYING that comes with GRASS
 
5
for details.
 
6
 
 
7
:authors: Soeren Gebbert and Thomas Leppelt
 
8
"""
 
9
 
 
10
import datetime
 
11
import os
 
12
import grass.script
 
13
import grass.temporal as tgis
 
14
import grass.gunittest as gunittest
 
15
 
 
16
class TestTemporalVectorAlgebra(gunittest.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(True) # Raise on error instead of exit(1)
 
24
        cls.use_temp_region()
 
25
        cls.runModule("g.region", n=80.0, s=0.0, e=120.0,
 
26
                                       w=0.0, t=1.0, b=0.0, res=10.0)
 
27
 
 
28
        cls.runModule("v.random", quiet=True, npoints=20, seed=1,  output='a1')
 
29
        cls.runModule("v.random", quiet=True, npoints=20, seed=1,  output='a2')
 
30
        cls.runModule("v.random", quiet=True, npoints=20, seed=1,  output='a3')
 
31
        cls.runModule("v.random", quiet=True, npoints=20, seed=1,  output='a4')
 
32
        cls.runModule("v.random", quiet=True, npoints=20, seed=2,  output='b1')
 
33
        cls.runModule("v.random", quiet=True, npoints=20, seed=2,  output='b2')
 
34
        cls.runModule("v.random", quiet=True, npoints=20, seed=3,  output='c1')
 
35
        cls.runModule("v.random", quiet=True, npoints=20, seed=4,  output='d1')
 
36
        cls.runModule("v.random", quiet=True, npoints=20, seed=4,  output='d2')
 
37
        cls.runModule("v.random", quiet=True, npoints=20, seed=4,  output='d3')
 
38
        cls.runModule("v.random", quiet=True, npoints=20, seed=5,  output='singletmap')
 
39
        cls.runModule("v.random", quiet=True, npoints=20, seed=6,  output='singlemap')        
 
40
 
 
41
        tgis.open_new_stds(name="A", type="stvds", temporaltype="absolute",
 
42
                                         title="A", descr="A", semantic="field")
 
43
        tgis.open_new_stds(name="B", type="stvds", temporaltype="absolute",
 
44
                                         title="B", descr="B", semantic="field")
 
45
        tgis.open_new_stds(name="C", type="stvds", temporaltype="absolute",
 
46
                                         title="B", descr="C", semantic="field")
 
47
        tgis.open_new_stds(name="D", type="stvds", temporaltype="absolute",
 
48
                                         title="D", descr="D", semantic="field")
 
49
 
 
50
        tgis.register_maps_in_space_time_dataset(type="vector", name="A", maps="a1,a2,a3,a4",
 
51
                                                 start="2001-01-01", increment="1 day", interval=True)
 
52
        tgis.register_maps_in_space_time_dataset(type="vector", name="B", maps="b1,b2",
 
53
                                                 start="2001-01-01", increment="2 day", interval=True)
 
54
        tgis.register_maps_in_space_time_dataset(type="vector", name="C", maps="c1",
 
55
                                                 start="2001-01-02", increment="2 day", interval=True)
 
56
        tgis.register_maps_in_space_time_dataset(type="vector", name="D", maps="d1,d2,d3",
 
57
                                                 start="2001-01-03", increment="1 day", interval=True)
 
58
        tgis.register_maps_in_space_time_dataset(type="vector", name=None,  maps="singletmap", 
 
59
                                                start="2001-01-03", end="2001-01-04", interval=True)
 
60
    
 
61
    def tearDown(self):
 
62
        self.runModule("t.remove", type="stvds", inputs="R", quiet=True)
 
63
 
 
64
    @classmethod
 
65
    def tearDownClass(cls):
 
66
        """Remove the temporary region 
 
67
        """
 
68
        cls.runModule("t.remove", flags="rf", inputs="A,B,C,D", type='stvds',  quiet=True)
 
69
        cls.del_temp_region()
 
70
 
 
71
    def test_temporal_select(self):
 
72
        """Testing the temporal select operator. """
 
73
        
 
74
        self.assertModule("t.vect.algebra",  expression="R = A : A", basename="r")
 
75
 
 
76
        D = tgis.open_old_stds("R", type="stvds")
 
77
        
 
78
        self.assertEqual(D.metadata.get_number_of_maps(), 4)
 
79
        self.assertEqual(D.metadata.get_number_of_points(), 80) 
 
80
        self.assertEqual(D.metadata.get_number_of_areas(), 0) 
 
81
        self.assertEqual(D.metadata.get_number_of_centroids(), 0) 
 
82
        start, end = D.get_absolute_time()
 
83
        self.assertEqual(start, datetime.datetime(2001, 1, 1))
 
84
        self.assertEqual(end, datetime.datetime(2001, 1, 5))
 
85
        self.assertEqual( D.check_temporal_topology(),  True)
 
86
        self.assertEqual(D.get_granularity(),  u'1 day')
 
87
 
 
88
    def test_temporal_select_operators(self):
 
89
        """Testing the temporal select operator. Including temporal relations. """
 
90
        
 
91
        self.assertModule("t.vect.algebra",  expression="R = A {:,during} C", basename="r")
 
92
 
 
93
        D = tgis.open_old_stds("R", type="stvds")
 
94
        
 
95
        self.assertEqual(D.metadata.get_number_of_maps(), 2)
 
96
        self.assertEqual(D.metadata.get_number_of_points(), 40) 
 
97
        self.assertEqual(D.metadata.get_number_of_areas(), 0) 
 
98
        self.assertEqual(D.metadata.get_number_of_centroids(), 0) 
 
99
        start, end = D.get_absolute_time()
 
100
        self.assertEqual(start, datetime.datetime(2001, 1, 2))
 
101
        self.assertEqual(end, datetime.datetime(2001, 1, 4))
 
102
        self.assertEqual( D.check_temporal_topology(),  True)
 
103
        self.assertEqual(D.get_granularity(),  u'1 day')
 
104
 
 
105
    def test_temporal_buff_operators_1(self):
 
106
        """Testing the bufferoperator."""
 
107
        
 
108
        self.assertModule("t.vect.algebra",  expression="R = buff_p(A,0.5)", basename="r")
 
109
 
 
110
        D = tgis.open_old_stds("R", type="stvds")
 
111
        
 
112
        self.assertEqual(D.metadata.get_number_of_maps(), 4)
 
113
        self.assertEqual(D.metadata.get_number_of_points(), 0) 
 
114
        self.assertEqual(D.metadata.get_number_of_areas(), 80) 
 
115
        self.assertEqual(D.metadata.get_number_of_centroids(), 80) 
 
116
        start, end = D.get_absolute_time()
 
117
        self.assertEqual(start, datetime.datetime(2001, 1, 1))
 
118
        self.assertEqual(end, datetime.datetime(2001, 1, 5))
 
119
        self.assertEqual( D.check_temporal_topology(),  True)
 
120
        self.assertEqual(D.get_granularity(),  u'1 day')
 
121
 
 
122
    def test_temporal_buff_operators_2(self):
 
123
        """Testing the bufferoperator."""
 
124
        
 
125
        self.assertModule("t.vect.algebra",  expression="R = buff_a(buff_p(A,1),10)", basename="r")
 
126
 
 
127
        D = tgis.open_old_stds("R", type="stvds")
 
128
        
 
129
        self.assertEqual(D.metadata.get_number_of_maps(), 4)
 
130
        self.assertEqual(D.metadata.get_number_of_points(), 0) 
 
131
        self.assertEqual(D.metadata.get_number_of_areas(), 20) 
 
132
        self.assertEqual(D.metadata.get_number_of_centroids(), 20) 
 
133
        start, end = D.get_absolute_time()
 
134
        self.assertEqual(start, datetime.datetime(2001, 1, 1))
 
135
        self.assertEqual(end, datetime.datetime(2001, 1, 5))
 
136
        self.assertEqual( D.check_temporal_topology(),  True)
 
137
        self.assertEqual(D.get_granularity(),  u'1 day')
 
138
 
 
139
    def test_temporal_overlay_operators_1(self):
 
140
        """Testing the spatial overlay operator."""
 
141
        
 
142
        self.assertModule("t.vect.algebra",  expression="R = buff_p(A,2) & buff_p(D,2)", basename="r")
 
143
 
 
144
        D = tgis.open_old_stds("R", type="stvds")
 
145
        
 
146
        self.assertEqual(D.metadata.get_number_of_maps(), 2)
 
147
        self.assertEqual(D.metadata.get_number_of_points(), 0)
 
148
        self.assertEqual(D.metadata.get_number_of_areas(), 6)
 
149
        self.assertEqual(D.metadata.get_number_of_centroids(), 6)
 
150
        start, end = D.get_absolute_time()
 
151
        self.assertEqual(start, datetime.datetime(2001, 1, 3))
 
152
        self.assertEqual(end, datetime.datetime(2001, 1, 5))
 
153
        self.assertEqual( D.check_temporal_topology(),  True)
 
154
        self.assertEqual(D.get_granularity(),  u'1 day')
 
155
 
 
156
    def test_temporal_overlay_operators_2(self):
 
157
        """Testing the spatial overlay operator."""
 
158
        
 
159
        self.assertModule("t.vect.algebra",  expression="R = buff_p(A,1.5) {&,during,r} buff_p(B,1.5)", basename="r")
 
160
 
 
161
        D = tgis.open_old_stds("R", type="stvds")
 
162
        
 
163
        self.assertEqual(D.metadata.get_number_of_maps(), 4)
 
164
        self.assertEqual(D.metadata.get_number_of_points(), 0)
 
165
        self.assertEqual(D.metadata.get_number_of_areas(), 8)
 
166
        self.assertEqual(D.metadata.get_number_of_centroids(), 8)
 
167
        start, end = D.get_absolute_time()
 
168
        self.assertEqual(start, datetime.datetime(2001, 1, 1))
 
169
        self.assertEqual(end, datetime.datetime(2001, 1, 5))
 
170
        self.assertEqual( D.check_temporal_topology(),  False)
 
171
        self.assertEqual(D.get_granularity(),  u'2 days')
 
172
 
 
173
    def test_temporal_overlay_operators_3(self):
 
174
        """Testing the spatial overlay operator."""
 
175
        
 
176
        self.assertModule("t.vect.algebra",  expression="R = buff_p(A,2.5) {&,during,l} buff_p(C,2.5)", basename="r")
 
177
 
 
178
        D = tgis.open_old_stds("R", type="stvds")
 
179
        
 
180
        self.assertEqual(D.metadata.get_number_of_maps(), 2)
 
181
        self.assertEqual(D.metadata.get_number_of_points(), 0)
 
182
        self.assertEqual(D.metadata.get_number_of_areas(), 8)
 
183
        self.assertEqual(D.metadata.get_number_of_centroids(), 8)
 
184
        start, end = D.get_absolute_time()
 
185
        self.assertEqual(start, datetime.datetime(2001, 1, 2))
 
186
        self.assertEqual(end, datetime.datetime(2001, 1, 4))
 
187
        self.assertEqual( D.check_temporal_topology(),  True)
 
188
        self.assertEqual(D.get_granularity(),  u'1 day')
 
189
 
 
190
if __name__ == '__main__':
 
191
    gunittest.test()
 
192
 
 
193
 
 
194