source: inundation/ga/storm_surge/pmesh/load_mesh/test_loadASCII.py @ 1021

Last change on this file since 1021 was 1021, checked in by duncan, 20 years ago

zone is now an integer.
getting pmesh to handle geo-ref's
File size: 23.4 KB
Line 
1#!/usr/bin/env python
2#
3
4#FIXME (Ole): I think we need a unit test of write_ASCII_triangulation
5#             in order to quash bug in merimbula data
6#  - to quash the bug need a raised error in pyvolution for reading xya files
7# when the title attribute information is not consistent with the data in the
8# file - DSG
9# also test_export_mesh_file tests write_ASCII_triangulation  - DSG
10
11import tempfile
12import unittest
13
14import os
15import tempfile
16
17from os.path import splitext
18
19from Numeric import array, allclose
20   
21from loadASCII import *
22from coordinate_transforms.geo_reference import Geo_reference
23
24class loadASCIITestCase(unittest.TestCase):
25    def setUp(self):
26        self.dict ={}
27        self.dict['outline_segments'] = [(0, 1), (1, 2), (0, 2), (0, 3)]
28        self.dict['outline_segment_tags'] = ['50', '40', '30', '20']
29        self.dict['holes'] = [(0.2, 0.6)]
30        self.dict['point_attributes'] = [[5, 2], [4, 2], [3, 2], [2,2]]
31        self.dict['regions'] = [(0.3, 0.3),(0.3, 0.4)]
32        self.dict['region_tags'] = ['1.3', 'yeah']
33        self.dict['region_max_areas'] = [36.0,-7.1]
34        self.dict['points'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0), (1.0, 1.0)]
35        self.dict['vertices'] = [(0.0, 0.0), (0.0, 4.0),
36                                 (4.0, 0.0), (1.0, 1.0), (2.0, 2.0)]
37        self.dict['triangles'] = [(3, 2, 4), (1, 0, 3),
38                                             (3, 4,1), (2, 3, 0)]
39        self.dict['segments'] = [(0, 1), (1, 4), (2, 0),
40                                            (0, 3), (4, 2)]
41        self.dict['triangle_tags'] = [['1.3'], ['1.3'],
42                                      ['1.3'], ['1.3']]
43        self.dict['vertex_attributes'] = [[1.2,2.], [1.2,2.],
44                                          [1.2,2.], [1.2,2.], [1.2,3.]]
45        self.dict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
46                                           [-1, 1, 0], [1, -1, 0]]
47        self.dict['segment_tags'] = ['50', '40', '30', '20', '40']
48        self.dict['vertex_attribute_titles'] = ['bed elevation', 'height']
49        self.dict['geo_reference'] = Geo_reference(1.9,1.9,'zone65')
50       
51        self.sparse_dict ={}
52        self.sparse_dict['outline_segments'] = []
53        self.sparse_dict['outline_segment_tags'] = []
54        self.sparse_dict['holes'] = []
55        self.sparse_dict['points'] = [(0.0, 0.0),(9,8)]
56        self.sparse_dict['point_attributes'] = [[],[]] # points don't have to have
57                                                    # attributes
58        self.sparse_dict['regions'] = []
59        self.sparse_dict['region_tags'] = []
60        self.sparse_dict['region_max_areas'] = []
61
62        self.sparse_dict['vertices'] = []
63        self.sparse_dict['triangles'] = []
64        self.sparse_dict['segments'] = []
65        self.sparse_dict['triangle_tags'] = []
66        self.sparse_dict['vertex_attributes'] = []
67        self.sparse_dict['triangle_neighbors'] = []
68        self.sparse_dict['segment_tags'] = []
69        self.sparse_dict['vertex_attribute_titles'] = []
70       
71        self.blank_dict ={}
72        self.blank_dict['outline_segments'] = []
73        self.blank_dict['outline_segment_tags'] = []
74        self.blank_dict['holes'] = []
75        self.blank_dict['points'] = []
76        self.blank_dict['point_attributes'] = [] 
77        self.blank_dict['regions'] = []
78        self.blank_dict['region_tags'] = []
79        self.blank_dict['region_max_areas'] = []
80        self.blank_dict['vertices'] = []
81        self.blank_dict['triangles'] = []
82        self.blank_dict['segments'] = []
83        self.blank_dict['triangle_tags'] = []
84        self.blank_dict['vertex_attributes'] = []
85        self.blank_dict['triangle_neighbors'] = []
86        self.blank_dict['segment_tags'] = []
87        self.blank_dict['vertex_attribute_titles'] = []
88       
89        self.tri_dict ={}
90        self.tri_dict['outline_segments'] = [[0,1]]
91        self.tri_dict['outline_segment_tags'] = ['']
92        self.tri_dict['holes'] = []
93        self.tri_dict['points'] = [(9,8),(7,8)]
94        self.tri_dict['point_attributes'] = [[],[]] 
95        self.tri_dict['regions'] = []
96        self.tri_dict['region_tags'] = []
97        self.tri_dict['region_max_areas'] = []
98        self.tri_dict['vertices'] = [[9,8],[7,8], [4,5]]
99        self.tri_dict['triangles'] = [[0,1,2]]
100        self.tri_dict['segments'] = [[0,1]]
101        self.tri_dict['triangle_tags'] = [['']]
102        self.tri_dict['vertex_attributes'] = [[],[],[]]
103        self.tri_dict['triangle_neighbors'] = [[0,0,0]]
104        self.tri_dict['segment_tags'] = ['']
105        self.tri_dict['vertex_attribute_titles'] = []
106       
107        self.seg_dict ={}
108        self.seg_dict['outline_segments'] = [[0,1]]
109        self.seg_dict['outline_segment_tags'] = ['']
110        self.seg_dict['holes'] = []
111        self.seg_dict['points'] = [(9,8),(7,8)]
112        self.seg_dict['point_attributes'] = [[],[]] 
113        self.seg_dict['regions'] = [(5,4)]
114        self.seg_dict['region_tags'] = [''] 
115        self.seg_dict['region_max_areas'] = [-999]
116        self.seg_dict['vertices'] = [(9,8),(7,8)]
117        self.seg_dict['triangles'] = []
118        self.seg_dict['segments'] = [[0,1]]
119        self.seg_dict['triangle_tags'] = []
120        self.seg_dict['vertex_attributes'] = [[],[]]
121        self.seg_dict['triangle_neighbors'] = []
122        self.seg_dict['segment_tags'] = ['']
123        self.seg_dict['vertex_attribute_titles'] = []
124       
125        self.reg_dict ={}
126        self.reg_dict['outline_segments'] = [[0,1]]
127        self.reg_dict['outline_segment_tags'] = ['']
128        self.reg_dict['holes'] = []
129        self.reg_dict['points'] = [(9,8),(7,8)]
130        self.reg_dict['point_attributes'] = [[],[]] 
131        self.reg_dict['regions'] = [(5,4)]
132        self.reg_dict['region_tags'] = ['']
133        self.reg_dict['region_max_areas'] = []
134        self.reg_dict['vertices'] = [(9,8),(7,8)]
135        self.reg_dict['triangles'] = []
136        self.reg_dict['segments'] = [[0,1]]
137        self.reg_dict['triangle_tags'] = []
138        self.reg_dict['vertex_attributes'] = [[],[]]
139        self.reg_dict['triangle_neighbors'] = []
140        self.reg_dict['segment_tags'] = ['']
141        self.reg_dict['vertex_attribute_titles'] = []
142       
143    def tearDown(self):
144        pass
145
146   
147    def test_import_mesh(self):
148       
149        dict = self.dict
150        fileName = tempfile.mktemp(".txt")
151        fd = open(fileName,'w')
152        write_ASCII_outline(fd,dict)
153        fd.close()
154        loaded_dict = import_mesh(fileName) #FIXME function names are wacky
155        os.remove(fileName)
156       
157        #gen_dict =
158        #print "*********************"
159        #print dict
160        #print "**loaded_dict*******************"
161        #print loaded_dict
162        #print "*********************"
163
164       
165        self.failUnless(array(loaded_dict['points'])  ==
166                        array(dict['points']),
167                         'test_import_mesh failed. Test 1')
168        self.failUnless(array(loaded_dict['point_attributes'])  ==
169                        array(dict['point_attributes']),
170                         'test_import_mesh failed. Test 2')
171        self.failUnless(array(loaded_dict['outline_segments'])  ==
172                        array(dict['outline_segments']),
173                         'test_import_mesh failed. Test 3')
174        self.failUnless(array(loaded_dict['outline_segment_tags'])  ==
175                        array(dict['outline_segment_tags']),
176                         'test_import_mesh failed. Test 4')
177        self.failUnless(array(loaded_dict['regions'])  ==
178                        array(dict['regions']),
179                         'test_import_mesh failed. Test 5')
180        self.failUnless(array(loaded_dict['region_tags'])  ==
181                        array(dict['region_tags']),
182                         'test_import_mesh failed. Test 5')
183        self.failUnless(array(loaded_dict['region_max_areas'])  ==
184                        array(dict['region_max_areas']),
185                         'test_import_mesh failed. Test 5')
186
187        self.failUnless(array(loaded_dict['holes'])  ==
188                        array(dict['holes']),
189                         'test_import_mesh failed. Test 6')
190       
191    def test_export_mesh_file(self):
192        import os
193        import tempfile
194       
195        meshDict = self.dict
196        fileName = tempfile.mktemp(".tsh")
197        export_mesh_file(fileName, meshDict)
198        loadedDict = import_triangulation(fileName)
199       
200        #print "*(*( meshDict"
201        #print meshDict
202        #print "*(*(  loadedDcit"
203        #print loadedDict
204        #print "*(*("
205       
206        self.failUnless(array(meshDict['vertices'])  ==
207                        array(loadedDict['vertices']),
208                         'test_export_mesh_file failed. Test 1')
209        self.failUnless(array(meshDict['triangles'])  ==
210                        array(loadedDict['triangles']),
211                         'test_export_mesh_file failed. Test 2')
212        self.failUnless(array(meshDict['segments'])  ==
213                        array(loadedDict['segments']),
214                         'test_export_mesh_file failed. Test 3')
215        self.failUnless(array(meshDict['triangle_tags'])  ==
216                        array(loadedDict['triangle_tags']),
217                         'test_export_mesh_file failed. Test 4')
218       
219        self.failUnless(meshDict['vertex_attributes']  ==
220                        loadedDict['vertex_attributes'],
221                         'test_export_mesh_file failed. Test 5')
222        self.failUnless(array(meshDict['triangle_neighbors'])  ==
223                        array(loadedDict['triangle_neighbors']),
224                         'test_export_mesh_file failed. Test 6')
225        self.failUnless(array(meshDict['segment_tags'])  ==
226                        array(loadedDict['segment_tags']),
227                         'test_export_mesh_file failed. Test 7')
228        self.failUnless(array(meshDict['vertex_attribute_titles'])  ==
229                        array(loadedDict['vertex_attribute_titles']),
230                         'test_export_mesh_file failed. Test 8')
231           
232        os.remove(fileName)
233 
234    def test_read_write_msh_file(self):
235        dict = self.dict.copy()
236        fileName = tempfile.mktemp(".txt")
237        write_msh_file(fileName,dict)
238        loaded_dict = read_msh_file(fileName)
239        os.remove(fileName)
240        dict = self.dict
241        #print "*********************"
242        #print dict
243        #print "**loaded_dict*******************"
244        #print loaded_dict
245        #print "*********************"
246        self.check_mesh_dicts(loaded_dict,dict,'test_read_write_msh_file') 
247
248    def test_read_write_msh_fileII(self):
249        dict = self.sparse_dict.copy()
250        fileName = tempfile.mktemp(".txt")
251        write_msh_file(fileName,dict)
252        loaded_dict = read_msh_file(fileName)
253        os.remove(fileName)
254        dict = self.sparse_dict
255        #print "*********************"
256        #print dict
257        #print "**loaded_dict*******************"
258        #print loaded_dict
259        #print "*********************"       
260        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileII')
261             
262    def test_read_write_msh_fileIII(self):
263        dict = self.blank_dict.copy()
264        fileName = tempfile.mktemp(".txt")
265        write_msh_file(fileName,dict)
266        loaded_dict = read_msh_file(fileName)
267        os.remove(fileName)
268        dict = self.blank_dict
269        #print "*********************"
270        #print dict
271        #print "**loaded_dict*******************"
272        #print loaded_dict
273        #print "*********************"       
274        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileIII')
275       
276    def test_read_write_msh_file4(self):
277        dict = self.seg_dict.copy()
278        fileName = tempfile.mktemp(".txt")
279        write_msh_file(fileName,dict)
280        loaded_dict = read_msh_file(fileName)
281        os.remove(fileName)
282        dict = self.seg_dict
283        #print "*********************"
284        #print dict
285        #print "**loaded_dict*******************"
286        #print loaded_dict
287        #print "*********************"
288        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileIII')
289                         
290       
291    def test_read_write_msh_file5(self):
292        dict = self.tri_dict.copy()
293        fileName = tempfile.mktemp(".txt")
294        write_msh_file(fileName,dict)
295        loaded_dict = read_msh_file(fileName)
296        os.remove(fileName)
297        dict = self.tri_dict
298        #print "*********************"
299        #print dict
300        #print "**loaded_dict*******************"
301        #print loaded_dict
302        #print "*********************"
303        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileIII')
304                         
305    def check_mesh_dicts(self, loaded_dict, dict, fail_string ):
306        assert allclose(array(loaded_dict['points']),
307                        array(dict['points']))
308                       
309        assert allclose(array(loaded_dict['point_attributes']),
310                        array(dict['point_attributes']))
311        assert allclose(array(loaded_dict['outline_segments']),
312                        array(dict['outline_segments']))
313       
314        self.failUnless(loaded_dict['outline_segment_tags']  ==
315                        dict['outline_segment_tags'],
316                        fail_string + ' failed!! Test 4')
317       
318           
319        assert allclose(array(loaded_dict['regions']),
320                        array(dict['regions']))
321        self.failUnless(loaded_dict['region_tags']  ==
322                        dict['region_tags'],
323                        fail_string + ' failed!! Test 5')
324       
325        assert allclose(array(loaded_dict['region_max_areas']),
326                        array(dict['region_max_areas']))
327 
328        assert allclose(array(loaded_dict['holes']),
329                        array(dict['holes']))
330 
331        assert allclose(array(dict['vertices']),
332                        array(loaded_dict['vertices']))
333 
334        assert allclose(array(dict['triangles']),
335                        array(loaded_dict['triangles']))
336 
337        assert allclose(array(dict['segments']),
338                        array(loaded_dict['segments']))
339        for ob, ldob in map(None,dict['triangle_tags'],
340                              loaded_dict['triangle_tags']):
341            self.failUnless(ob[0]  == ldob[0],
342                        fail_string + ' failed!! Test triangle_tags')
343        self.failUnless(loaded_dict['vertex_attributes']  ==
344                        dict['vertex_attributes'],
345                        fail_string + ' failed!! Test vertex_attributes')
346 
347        assert allclose(array(dict['triangle_neighbors']),
348                        array(loaded_dict['triangle_neighbors']))
349
350        for seg, ldseg in map(None,dict['segment_tags'],
351                              loaded_dict['segment_tags']):
352            self.failUnless(seg  == ldseg,
353                        fail_string + ' failed!! Test 8')
354        try:
355            assert allclose(array(dict['vertex_attribute_titles']),
356                            array(loaded_dict['vertex_attribute_titles']))
357        except TypeError:
358            self.failUnless(array(loaded_dict['vertex_attribute_titles'])  ==
359                        array(dict['vertex_attribute_titles']),
360                        fail_string + ' failed!! Test 8')
361        try:   
362            self.failUnless(loaded_dict['geo_reference']  ==
363                        dict['geo_reference'] ,
364                        fail_string + ' failed!! Test geo_reference')
365        except KeyError:         
366            self.failUnless(not dict.has_key('geo_reference' and
367                         loaded_dict['geo_reference'] == None)   ,
368                        fail_string + ' failed!! Test geo_reference')
369           
370    def test_loadpts(self):
371       
372        from Scientific.IO.NetCDF import NetCDFFile
373
374        fileName = tempfile.mktemp(".pts")
375        # NetCDF file definition
376        outfile = NetCDFFile(fileName, 'w')
377       
378        # dimension definitions
379        outfile.createDimension('number_of_points', 3)   
380        outfile.createDimension('number_of_dimensions', 2) #This is 2d data
381   
382        # variable definitions
383        outfile.createVariable('points', Float, ('number_of_points',
384                                                 'number_of_dimensions'))
385        outfile.createVariable('elevation', Float, ('number_of_points',))
386   
387        # Get handles to the variables
388        points = outfile.variables['points']
389        elevation = outfile.variables['elevation']
390 
391        points[0, :] = [1.0,0.0]
392        elevation[0] = 10.0 
393        points[1, :] = [0.0,1.0]
394        elevation[1] = 0.0 
395        points[2, :] = [1.0,0.0]
396        elevation[2] = 10.4   
397
398        outfile.close()
399       
400        dict = load_points_file(fileName)
401        os.remove(fileName)
402        answer =  [[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]]
403        #print "dict['pointlist']",dict['pointlist']
404        #print "answer",answer
405        assert allclose(dict['pointlist'], [[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
406        assert allclose(dict['attributelist']['elevation'], [10.0, 0.0, 10.4])
407
408 
409    def test_concatinate_attributelist(self):
410        dic = {}
411        dic['one'] = array([1,2])
412        dic['2'] = array([2,7])
413        dic['three'] = array([3,79])
414        dic['4'] = array([4,47])
415        dic['five'] = array([5,17])
416        titles, block = concatinate_attributelist(dic)
417        #print "titles", titles
418        #print "array", block
419        self.failUnless(titles  == ['4', '2', 'five', 'three', 'one'],
420                         'test_concatinate_attributelist failed.')
421        assert allclose(block, [[4,2,5,3,1],[47,7,17,79,2]])
422       
423 
424    def test_writepts(self):
425        dict = {}
426        att_dict = {}
427        dict['pointlist'] = array([[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
428        att_dict['elevation'] = array([10.0, 0.0, 10.4])
429        att_dict['brightness'] = array([10.0, 0.0, 10.4])
430        dict['attributelist'] = att_dict
431        dict['geo_reference'] = Geo_reference(1.9,1.9,65)
432       
433       
434        fileName = tempfile.mktemp(".pts")
435        write_pts(fileName, dict)
436        dict2 = load_points_file(fileName)
437        #print "fileName",fileName
438        os.remove(fileName)
439        #print "dict2",dict2
440       
441        assert allclose(dict2['pointlist'],[[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
442        assert allclose(dict2['attributelist']['elevation'], [10.0, 0.0, 10.4])
443        answer = [10.0, 0.0, 10.4]
444        assert allclose(dict2['attributelist']['brightness'], answer)
445
446        #print "dict['geo_reference'] ",dict['geo_reference']
447        #print "dict2['geo_reference']",dict2['geo_reference']
448       
449        self.failUnless(dict['geo_reference'] == dict2['geo_reference'],
450                         'test_writepts failed. Test geo_reference')
451
452       
453    def test_half_pts(self):
454        dict = {}
455        att_dict = {}
456        dict['pointlist'] = array([[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
457        att_dict['elevation'] = array([10.0, 0.0, 10.4])
458        att_dict['brightness'] = array([10.0, 0.0, 10.4])
459        dict['attributelist'] = att_dict
460        out_dict = half_pts(dict)
461        assert allclose(out_dict['pointlist'],[[1.0, 0.0],[1.0, 0.0]])
462        assert allclose(out_dict['attributelist']['elevation'], [10.0, 10.4])
463        assert allclose(out_dict['attributelist']['brightness'], [10.0, 10.4])
464 
465    def test_extent_point_atts(self):
466       
467        dict = {}
468        att_dict = {}
469        dict['pointlist'] = array([[1.0, 10.0],[0.0, 1.0],[10.0, -10.0]])
470        att_dict['elevation'] = array([30.0, 0.0, 10.4])
471        att_dict['brightness'] = array([10.0, 0.0, 10.4])
472        dict['attributelist'] = att_dict
473        out_dict = extent_point_atts(dict)
474        #print "out_dict['pointlist']",out_dict #['pointlist']
475        assert allclose(out_dict['pointlist'],[[0.0, -10.0],[10.0, -10.0],[0.0, 10.0],[10.0,10.0]])
476
477        self.failUnless(dict['attributelist']  == {},
478                         'test_extent_point_atts failed. Test 1')
479       
480    def test_reduce_pts(self):
481        dict = {}
482        att_dict = {}
483        dict['pointlist'] = array([[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
484        att_dict['elevation'] = array([10.0, 0.0, 10.4])
485        att_dict['brightness'] = array([10.0, 0.0, 10.4])
486        dict['attributelist'] = att_dict
487       
488        inFileName = tempfile.mktemp(".pts")
489        write_pts(inFileName, dict)
490       
491        outFileName = tempfile.mktemp(".pts")
492       
493        dict2 = reduce_pts(inFileName,outFileName, 1 )
494        os.remove(inFileName)
495
496        dict2 = load_points_file(outFileName)
497        os.remove(outFileName)
498        #print "dict2",dict2
499       
500        assert allclose(dict2['pointlist'],[[1.0, 0.0]])
501        assert allclose(dict2['attributelist']['elevation'], [10.0])
502        assert allclose(dict2['attributelist']['brightness'], [10.0])
503       
504    def test_produce_half_point_files(self):
505        dict = {}
506        att_dict = {}
507        dict['pointlist'] = array([[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
508        att_dict['elevation'] = array([10.0, 0.0, 10.4])
509        att_dict['brightness'] = array([10.0, 0.0, 10.4])
510        dict['attributelist'] = att_dict
511       
512        inFileName = tempfile.mktemp(".pts")
513        write_pts(inFileName, dict)
514       
515        outFileName = tempfile.mktemp(".pts")
516        delimiter = '_p'
517        outfiles = produce_half_point_files(inFileName, 1,
518                                            delimiter, verbose = False )
519        os.remove(inFileName)
520        root, ext = splitext(inFileName)
521        outFileName = root + delimiter + ext
522        #print "outFileName",outfiles 
523        dict2 = load_points_file(outfiles[1])
524        for file in outfiles:
525            #print "del file",file
526            os.remove(file)
527       
528        assert allclose(dict2['pointlist'],[[1.0, 0.0]])
529        assert allclose(dict2['attributelist']['elevation'], [10.0])
530        assert allclose(dict2['attributelist']['brightness'], [10.0])
531       
532    def test_loadxy3(self):
533       
534        fileName = tempfile.mktemp(".xya")
535        file = open(fileName,"w")
536        file.write("  elevation  , speed \n\
5371.0, 0.0, 10.0, 0.0\n\
5380.0, 1.0, 0.0, 10.0\n\
5391.0, 0.0, 10.4, 40.0\n")
540        file.close()
541        #print fileName
542        dict = load_points_file(fileName,delimiter = ',')
543        os.remove(fileName)
544        assert allclose(dict['pointlist'], [[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
545        assert allclose(dict['attributelist']['elevation'], [10.0, 0.0, 10.4])
546        assert allclose(dict['attributelist']['speed'], [0.0, 10.0, 40.0])
547       
548    def test_loadxy4(self):
549        import os
550        import tempfile
551       
552        fileName = tempfile.mktemp(".xya")
553        file = open(fileName,"w")
554        file.write("  elevation   speed \n\
5551.0 0.0 10.0 0.0\n\
5560.0 1.0 0.0 10.0\n\
5571.0 0.0 10.4 40.0\n")
558        file.close()
559        #print fileName
560        dict = load_points_file(fileName,delimiter = ' ')
561        os.remove(fileName)
562        assert allclose(dict['pointlist'], [[1.0, 0.0],[0.0, 1.0],[1.0, 0.0]])
563        assert allclose(dict['attributelist']['elevation'], [10.0, 0.0, 10.4])
564        assert allclose(dict['attributelist']['speed'], [0.0, 10.0, 40.0])
565     
566    def test_loadxy5(self):
567        import os
568        import tempfile
569       
570        fileName = tempfile.mktemp(".xya")
571        file = open(fileName,"w")
572        file.write("  elevation   \n\
5731.0 0.0 10.0 0.0\n\
5740.0 1.0 0.0 10.0\n\
5751.0 0.0 10.4 40.0\n")
576        file.close()
577        #print fileName
578        try:
579            dict = load_points_file(fileName,delimiter = ' ')
580        except TitleAmountError:
581            pass
582        else:
583            self.failUnless(0 ==1,
584                        'bad xya file did not raise error!')
585       
586        os.remove(fileName)
587         
588 
589#-------------------------------------------------------------
590if __name__ == "__main__":
591
592    suite = unittest.makeSuite(loadASCIITestCase,'test')
593    #suite = unittest.makeSuite(loadASCIITestCase,'test_writepts')
594    runner = unittest.TextTestRunner() #verbosity=2)
595    runner.run(suite)
596   
Note: See TracBrowser for help on using the repository browser.