1 | import os |
---|
2 | import unittest |
---|
3 | import tempfile |
---|
4 | import numpy as num |
---|
5 | |
---|
6 | from anuga.utilities.system_tools import get_pathname_from_package |
---|
7 | |
---|
8 | from csv_file import load_csv_as_array, load_csv_as_dict, store_parameters, \ |
---|
9 | load_csv_as_matrix |
---|
10 | |
---|
11 | class Test_csv(unittest.TestCase): |
---|
12 | def setUp(self): |
---|
13 | pass |
---|
14 | |
---|
15 | def tearDown(self): |
---|
16 | pass |
---|
17 | |
---|
18 | def _create_csv_file(self): |
---|
19 | """ |
---|
20 | Create a dummy csv file. |
---|
21 | Return its filename. |
---|
22 | """ |
---|
23 | filename = tempfile.mktemp(".txt") |
---|
24 | file = open(filename,"w") |
---|
25 | file.write("elevation, stage\n\ |
---|
26 | 1.0, 3 \n\ |
---|
27 | 0.0, 4 \n\ |
---|
28 | 4.0, 3 \n\ |
---|
29 | 1.0, 6 \n") |
---|
30 | file.close() |
---|
31 | return filename |
---|
32 | |
---|
33 | def test_get_data_from_file1(self): |
---|
34 | filename = self._create_csv_file() |
---|
35 | |
---|
36 | x = load_csv_as_array(filename) |
---|
37 | |
---|
38 | os.remove(filename) |
---|
39 | |
---|
40 | assert num.allclose(x['elevation'], [1.0, 0.0, 4.0, 1.0]) |
---|
41 | assert num.allclose(x['stage'], [3.0, 4.0, 3.0, 6.0]) |
---|
42 | |
---|
43 | |
---|
44 | def test_get_data_from_file(self): |
---|
45 | filename = self._create_csv_file() |
---|
46 | |
---|
47 | header,x = load_csv_as_matrix(filename) |
---|
48 | os.remove(filename) |
---|
49 | |
---|
50 | assert num.allclose(x[:,0], [1.0, 0.0,4.0, 1.0]) |
---|
51 | |
---|
52 | |
---|
53 | def test_store_parameters(self): |
---|
54 | """tests store temporary file |
---|
55 | """ |
---|
56 | |
---|
57 | from os import sep, getenv |
---|
58 | |
---|
59 | output_dir='' |
---|
60 | file_name='details.csv' |
---|
61 | |
---|
62 | kwargs = {'file_name':'new2.txt', |
---|
63 | 'output_dir':output_dir, |
---|
64 | 'file_name':file_name, |
---|
65 | 'who':'me', |
---|
66 | 'what':'detail', |
---|
67 | 'how':2, |
---|
68 | 'why':241, |
---|
69 | # 'completed':345 |
---|
70 | } |
---|
71 | store_parameters(verbose=False,**kwargs) |
---|
72 | |
---|
73 | temp='detail_temp.csv' |
---|
74 | fid = open(temp) |
---|
75 | file_header = fid.readline() |
---|
76 | file_line = fid.readline() |
---|
77 | fid.close() |
---|
78 | |
---|
79 | |
---|
80 | keys = kwargs.keys() |
---|
81 | keys.sort() |
---|
82 | line='' |
---|
83 | header='' |
---|
84 | count=0 |
---|
85 | #used the sorted keys to create the header and line data |
---|
86 | for k in keys: |
---|
87 | # print "%s = %s" %(k, kwargs[k]) |
---|
88 | header = header+str(k) |
---|
89 | line = line+str(kwargs[k]) |
---|
90 | count+=1 |
---|
91 | if count <len(kwargs): |
---|
92 | header = header+',' |
---|
93 | line = line+',' |
---|
94 | header+='\n' |
---|
95 | line+='\n' |
---|
96 | |
---|
97 | |
---|
98 | #file exists |
---|
99 | assert os.access(temp, os.F_OK) |
---|
100 | assert header == file_header |
---|
101 | assert line == file_line |
---|
102 | |
---|
103 | os.remove(temp) |
---|
104 | |
---|
105 | def test_store_parameters1(self): |
---|
106 | """tests store in temporary file and other file |
---|
107 | """ |
---|
108 | |
---|
109 | from os import sep, getenv |
---|
110 | |
---|
111 | output_dir='' |
---|
112 | file_name='details.csv' |
---|
113 | |
---|
114 | kwargs = {'file_name':'new2.txt', |
---|
115 | 'output_dir':output_dir, |
---|
116 | 'file_name':file_name, |
---|
117 | 'who':'me', |
---|
118 | 'what':'detail', |
---|
119 | 'how':2, |
---|
120 | 'why':241, |
---|
121 | # 'completed':345 |
---|
122 | } |
---|
123 | store_parameters(verbose=False,**kwargs) |
---|
124 | |
---|
125 | kwargs['how']=55 |
---|
126 | kwargs['completed']=345 |
---|
127 | |
---|
128 | keys = kwargs.keys() |
---|
129 | keys.sort() |
---|
130 | line='' |
---|
131 | header='' |
---|
132 | count=0 |
---|
133 | #used the sorted keys to create the header and line data |
---|
134 | for k in keys: |
---|
135 | # print "%s = %s" %(k, kwargs[k]) |
---|
136 | header = header+str(k) |
---|
137 | line = line+str(kwargs[k]) |
---|
138 | count+=1 |
---|
139 | if count <len(kwargs): |
---|
140 | header = header+',' |
---|
141 | line = line+',' |
---|
142 | header+='\n' |
---|
143 | line+='\n' |
---|
144 | |
---|
145 | kwargs['how']=55 |
---|
146 | kwargs['completed']=345 |
---|
147 | |
---|
148 | store_parameters(verbose=False,**kwargs) |
---|
149 | |
---|
150 | # temp='detail_temp.csv' |
---|
151 | fid = open(file_name) |
---|
152 | file_header = fid.readline() |
---|
153 | file_line1 = fid.readline() |
---|
154 | file_line2 = fid.readline() |
---|
155 | fid.close() |
---|
156 | |
---|
157 | |
---|
158 | #file exists |
---|
159 | # print 'header',header,'line',line |
---|
160 | # print 'file_header',file_header,'file_line1',file_line1,'file_line2',file_line2 |
---|
161 | assert os.access(file_name, os.F_OK) |
---|
162 | assert header == file_header |
---|
163 | assert line == file_line1 |
---|
164 | |
---|
165 | temp='detail_temp.csv' |
---|
166 | os.remove(temp) |
---|
167 | os.remove(file_name) |
---|
168 | |
---|
169 | def test_store_parameters2(self): |
---|
170 | """tests appending the data to the end of an existing file |
---|
171 | """ |
---|
172 | |
---|
173 | from os import sep, getenv |
---|
174 | |
---|
175 | output_dir='' |
---|
176 | file_name='details.csv' |
---|
177 | |
---|
178 | kwargs = {'file_name':'new2.txt', |
---|
179 | 'output_dir':output_dir, |
---|
180 | 'file_name':file_name, |
---|
181 | 'who':'me', |
---|
182 | 'what':'detail', |
---|
183 | 'how':2, |
---|
184 | 'why':241, |
---|
185 | 'completed':345 |
---|
186 | } |
---|
187 | store_parameters(verbose=False,**kwargs) |
---|
188 | |
---|
189 | kwargs['how']=55 |
---|
190 | kwargs['completed']=23.54532 |
---|
191 | |
---|
192 | store_parameters(verbose=False,**kwargs) |
---|
193 | |
---|
194 | keys = kwargs.keys() |
---|
195 | keys.sort() |
---|
196 | line='' |
---|
197 | header='' |
---|
198 | count=0 |
---|
199 | #used the sorted keys to create the header and line data |
---|
200 | for k in keys: |
---|
201 | # print "%s = %s" %(k, kwargs[k]) |
---|
202 | header = header+str(k) |
---|
203 | line = line+str(kwargs[k]) |
---|
204 | count+=1 |
---|
205 | if count <len(kwargs): |
---|
206 | header = header+',' |
---|
207 | line = line+',' |
---|
208 | header+='\n' |
---|
209 | line+='\n' |
---|
210 | |
---|
211 | fid = open(file_name) |
---|
212 | file_header = fid.readline() |
---|
213 | file_line1 = fid.readline() |
---|
214 | file_line2 = fid.readline() |
---|
215 | fid.close() |
---|
216 | |
---|
217 | assert os.access(file_name, os.F_OK) |
---|
218 | assert header == file_header |
---|
219 | assert line == file_line2 |
---|
220 | |
---|
221 | os.remove(file_name) |
---|
222 | |
---|
223 | |
---|
224 | |
---|
225 | def test_csv2polygons(self): |
---|
226 | """test loading of a csv polygon file. |
---|
227 | """ |
---|
228 | |
---|
229 | path = get_pathname_from_package('anuga.shallow_water') |
---|
230 | testfile = os.path.join(path, 'polygon_values_example.csv') |
---|
231 | |
---|
232 | polygons, values = load_csv_as_polygons(testfile, |
---|
233 | value_name='floors') |
---|
234 | |
---|
235 | assert len(polygons) == 7, 'Must have seven polygons' |
---|
236 | assert len(values) == 7, 'Must have seven values' |
---|
237 | |
---|
238 | # Known floor values |
---|
239 | floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1} |
---|
240 | |
---|
241 | # Known polygon values |
---|
242 | known_polys = {'1': [[422681.61,871117.55], |
---|
243 | [422691.02,871117.60], |
---|
244 | [422690.87,871084.23], |
---|
245 | [422649.36,871081.85], |
---|
246 | [422649.36,871080.39], |
---|
247 | [422631.86,871079.50], |
---|
248 | [422631.72,871086.75], |
---|
249 | [422636.75,871087.20], |
---|
250 | [422636.75,871091.50], |
---|
251 | [422649.66,871092.09], |
---|
252 | [422649.83,871084.91], |
---|
253 | [422652.94,871084.90], |
---|
254 | [422652.84,871092.39], |
---|
255 | [422681.83,871093.73], |
---|
256 | [422681.61,871117.55]], |
---|
257 | '2': [[422664.22,870785.46], |
---|
258 | [422672.48,870780.14], |
---|
259 | [422668.17,870772.62], |
---|
260 | [422660.35,870777.17], |
---|
261 | [422664.22,870785.46]], |
---|
262 | '3': [[422661.30,871215.06], |
---|
263 | [422667.50,871215.70], |
---|
264 | [422668.30,871204.86], |
---|
265 | [422662.21,871204.33], |
---|
266 | [422661.30,871215.06]], |
---|
267 | '4': [[422473.44,871191.22], |
---|
268 | [422478.33,871192.26], |
---|
269 | [422479.52,871186.03], |
---|
270 | [422474.78,871185.14], |
---|
271 | [422473.44,871191.22]], |
---|
272 | '5': [[422369.69,871049.29], |
---|
273 | [422378.63,871053.58], |
---|
274 | [422383.91,871044.51], |
---|
275 | [422374.97,871040.32], |
---|
276 | [422369.69,871049.29]], |
---|
277 | '8': [[422730.56,871203.13], |
---|
278 | [422734.10,871204.90], |
---|
279 | [422735.26,871202.18], |
---|
280 | [422731.87,871200.58], |
---|
281 | [422730.56,871203.13]], |
---|
282 | '9': [[422659.85,871213.80], |
---|
283 | [422660.91,871210.97], |
---|
284 | [422655.42,871208.85], |
---|
285 | [422654.36,871211.68], |
---|
286 | [422659.85,871213.80]] |
---|
287 | } |
---|
288 | |
---|
289 | |
---|
290 | |
---|
291 | |
---|
292 | for id in ['1', '2', '3', '4', '5' ,'8' ,'9']: |
---|
293 | assert id in polygons.keys() |
---|
294 | assert id in values.keys() |
---|
295 | |
---|
296 | assert int(values[id]) == int(floors[id]) |
---|
297 | assert len(polygons[id]) == len(known_polys[id]) |
---|
298 | assert num.allclose(polygons[id], known_polys[id]) |
---|
299 | |
---|
300 | |
---|
301 | def test_csv2polygons_with_clipping(self): |
---|
302 | """test_csv2polygons with optional clipping |
---|
303 | """ |
---|
304 | #FIXME(Ole): Not Done!! |
---|
305 | |
---|
306 | path = get_pathname_from_package('anuga.shallow_water') |
---|
307 | testfile = os.path.join(path, 'polygon_values_example.csv') |
---|
308 | |
---|
309 | polygons, values = load_csv_as_polygons(testfile, |
---|
310 | value_name='floors', |
---|
311 | clipping_polygons=None) |
---|
312 | |
---|
313 | assert len(polygons) == 7, 'Must have seven polygons' |
---|
314 | assert len(values) == 7, 'Must have seven values' |
---|
315 | |
---|
316 | # Known floor values |
---|
317 | floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1} |
---|
318 | |
---|
319 | # Known polygon values |
---|
320 | known_polys = {'1': [[422681.61,871117.55], |
---|
321 | [422691.02,871117.60], |
---|
322 | [422690.87,871084.23], |
---|
323 | [422649.36,871081.85], |
---|
324 | [422649.36,871080.39], |
---|
325 | [422631.86,871079.50], |
---|
326 | [422631.72,871086.75], |
---|
327 | [422636.75,871087.20], |
---|
328 | [422636.75,871091.50], |
---|
329 | [422649.66,871092.09], |
---|
330 | [422649.83,871084.91], |
---|
331 | [422652.94,871084.90], |
---|
332 | [422652.84,871092.39], |
---|
333 | [422681.83,871093.73], |
---|
334 | [422681.61,871117.55]], |
---|
335 | '2': [[422664.22,870785.46], |
---|
336 | [422672.48,870780.14], |
---|
337 | [422668.17,870772.62], |
---|
338 | [422660.35,870777.17], |
---|
339 | [422664.22,870785.46]], |
---|
340 | '3': [[422661.30,871215.06], |
---|
341 | [422667.50,871215.70], |
---|
342 | [422668.30,871204.86], |
---|
343 | [422662.21,871204.33], |
---|
344 | [422661.30,871215.06]], |
---|
345 | '4': [[422473.44,871191.22], |
---|
346 | [422478.33,871192.26], |
---|
347 | [422479.52,871186.03], |
---|
348 | [422474.78,871185.14], |
---|
349 | [422473.44,871191.22]], |
---|
350 | '5': [[422369.69,871049.29], |
---|
351 | [422378.63,871053.58], |
---|
352 | [422383.91,871044.51], |
---|
353 | [422374.97,871040.32], |
---|
354 | [422369.69,871049.29]], |
---|
355 | '8': [[422730.56,871203.13], |
---|
356 | [422734.10,871204.90], |
---|
357 | [422735.26,871202.18], |
---|
358 | [422731.87,871200.58], |
---|
359 | [422730.56,871203.13]], |
---|
360 | '9': [[422659.85,871213.80], |
---|
361 | [422660.91,871210.97], |
---|
362 | [422655.42,871208.85], |
---|
363 | [422654.36,871211.68], |
---|
364 | [422659.85,871213.80]] |
---|
365 | } |
---|
366 | |
---|
367 | |
---|
368 | |
---|
369 | |
---|
370 | for id in ['1', '2', '3', '4', '5' ,'8' ,'9']: |
---|
371 | assert id in polygons.keys() |
---|
372 | assert id in values.keys() |
---|
373 | |
---|
374 | assert int(values[id]) == int(floors[id]) |
---|
375 | assert len(polygons[id]) == len(known_polys[id]) |
---|
376 | assert num.allclose(polygons[id], known_polys[id]) |
---|
377 | |
---|
378 | |
---|
379 | |
---|
380 | |
---|
381 | |
---|
382 | def test_csv2building_polygons(self): |
---|
383 | """test_csv2building_polygons |
---|
384 | """ |
---|
385 | |
---|
386 | path = get_pathname_from_package('anuga.shallow_water') |
---|
387 | testfile = os.path.join(path, 'polygon_values_example.csv') |
---|
388 | |
---|
389 | polygons, values = load_csv_as_building_polygons(testfile, |
---|
390 | floor_height=3) |
---|
391 | |
---|
392 | assert len(polygons) == 7, 'Must have seven polygons' |
---|
393 | assert len(values) == 7, 'Must have seven values' |
---|
394 | |
---|
395 | # Known floor values |
---|
396 | floors = {'1': 6, '2': 0, '3': 3, '4': 6, '5': 0, '8': 3, '9': 3} |
---|
397 | |
---|
398 | |
---|
399 | for id in ['1', '2', '3', '4', '5' ,'8' ,'9']: |
---|
400 | assert id in polygons.keys() |
---|
401 | assert id in values.keys() |
---|
402 | |
---|
403 | assert float(values[id]) == float(floors[id]) |
---|
404 | |
---|
405 | |
---|
406 | |
---|
407 | ################################################################################# |
---|
408 | |
---|
409 | if __name__ == "__main__": |
---|
410 | suite = unittest.makeSuite(Test_csv, 'test') |
---|
411 | runner = unittest.TextTestRunner(verbosity=1) |
---|
412 | runner.run(suite) |
---|