source: TI02-CSML/trunk/csml/tests/test_extract.py @ 2638

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/csml/tests/test_extract.py@2638
Revision 2638, 10.5 KB checked in by domlowe, 13 years ago (diff)

fixing subsetting at point, and test scripts

Line 
1"""
2Test CSML subsetToGridSeries against cdms equivilent.
3
4"""
5
6import csml, cdms
7import os
8import tempfile
9
10from unittest import TestCase
11import Numeric as N
12
13# For image dump
14import Image
15from matplotlib import cm, colors
16
17
18here = os.path.dirname(os.path.abspath(__file__))
19data_csml = os.path.join(here, 'data', 'test.csml')
20
21#----------------------------------------------------------------------------
22# Utility functions
23
24def extract_csml(file, field, **sel):
25    d = csml.parser.Dataset()
26    d.parse(file)
27   
28    # Find feature by name
29    for id in d.getFeatureList():
30        f = d.getFeature(id)
31        if f.name.CONTENT == field:
32            break
33    else:
34        raise ValueError, 'No feature found with name %s' % field
35
36    # Extract to a temporary file
37    (fd, tmp) = tempfile.mkstemp('.nc', 'test_csml_'); os.close(fd)
38    try:
39        f.subsetToGridSeries(outputdir=os.path.dirname(tmp),
40                             ncname=os.path.basename(tmp),
41                             **sel)
42
43        # Open temporary file
44        d2 = cdms.open(tmp)
45        var = d2(field, squeeze=1)
46    finally:
47        os.remove(tmp)
48    return var
49
50def dump_img(var, filename, width=100, height=100):
51    norm = colors.normalize(0, 1000.)
52    cmap = cm.get_cmap()
53    a = norm(var)
54    img_buf = (cmap(a)*255).astype('b')
55    (y, x, c) = img_buf.shape
56    img = Image.frombuffer("RGBA", (x, y), img_buf.tostring(), 'raw', 'RGBA',
57                           0, 1)
58    img.save(filename)
59
60#---------------------------------------------------------------------------
61
62class TestExtractAll(TestCase):
63    """
64    Extract the entire lat/lon grid and check for correct shape and border.
65   
66    """
67    def setUp(self):
68        self._testKeys = ['test_0_360p', 'test_0_360m', 'test_m180_180m',
69                          'test_m180_180p']
70        self._selectors = {
71            'test_0_360p': dict(time='1980-01-01T00:00:00.0'),
72            'test_0_360m': dict(time='1980-01-01T00:00:00.0'),
73            'test_m180_180m': dict(time='1980-01-01T00:00:00.0'),
74            'test_m180_180p': dict(time='1980-01-01T00:00:00.0'),
75            }                   
76
77    def _checkValues(self, var):
78        """
79        Values should be the sum of lat and lon
80
81        """
82        lat = var.getLatitude().getValue()
83        lon = var.getLongitude().getValue()
84
85        print lat
86        print lon
87
88        print var[:10, :10]
89
90        self.assertEquals(var[0,5], lat[0] + lon[5])
91        self.assertEquals(var[0,30], lat[0] + lon[30])
92
93        self.assertEquals(var[30,0], lat[30] + lon[0])
94        self.assertEquals(var[5,0], lat[5] + lon[0])
95           
96
97    def _extract(self, i):
98        k = self._testKeys[i]
99        return extract_csml(data_csml, k, **self._selectors[k])
100           
101    def test1(self):
102        var = self._extract(0)
103        self.assertEquals(var.shape, (36,36))
104        self._checkValues(var)
105
106    def test2(self):
107        var = self._extract(1)
108        self.assertEquals(var.shape, (36,36))
109        self._checkValues(var)
110
111
112    def test3(self):
113        var = self._extract(2)
114        self.assertEquals(var.shape, (36,36))
115        self._checkValues(var)
116
117    def test4(self):
118        var = self._extract(3)
119        self.assertEquals(var.shape, (36,36))
120        self._checkValues(var)
121
122
123class TestExtractAll_360(TestExtractAll):
124    """
125    Extract everything with explicit latitude/longitude selection
126
127    """
128    def setUp(self):
129        super(TestExtractAll_360, self).setUp()
130        for k in self._selectors:
131            self._selectors[k].update(
132                dict(longitude=(0, 360), latitude=(-90, 90))
133                )
134
135class TestExtractAll_180(TestExtractAll):
136    """
137    Extract everything with explicit latitude/longitude selection
138
139    """
140    def setUp(self):
141        super(TestExtractAll_180, self).setUp()
142        for k in self._selectors:
143            self._selectors[k].update(
144                dict(longitude=(-180, 180), latitude=(-90, 90))
145                )
146
147
148#---------------------------------------------------------------------------
149
150
151class TestExtractQuadrant(TestCase):
152    """
153    Abstract base class to set things up.
154
155    """
156    def _extract1(self):
157        var = extract_csml(data_csml, 'test_0_360p',
158                            time='1980-01-01T00:00:00.0',
159                            latitude=(0, 90),
160                            longitude=(0,180))
161        return var
162   
163    def _extract2(self):
164        var = extract_csml(data_csml, 'test_0_360m',
165                            time='1980-01-01T00:00:00.0',
166                            latitude=(0, 90),
167                            longitude=(0,180))
168        return var
169   
170    def _extract3(self):
171        var = extract_csml(data_csml, 'test_m180_180m',
172                            time='1980-01-01T00:00:00.0',
173                            latitude=(0, 90),
174                            longitude=(-180,0))
175        return var
176   
177    def _extract4(self):
178        var = extract_csml(data_csml, 'test_m180_180p',
179                            time='1980-01-01T00:00:00.0',
180                            latitude=(0, 90),
181                            longitude=(-180,0))
182        return var
183
184class TestExtractShape(TestExtractQuadrant):
185    """
186    Test the shape of extracted GridSeries.
187
188    """
189    def test1(self):
190        var = self._extract1()
191        self.assertEquals(var.shape, (18,18))
192
193    def test2(self):
194        var = self._extract2()
195        self.assertEquals(var.shape, (18,18))
196
197    def test3(self):
198        var = self._extract3()
199        self.assertEquals(var.shape, (18,18))
200
201    def test4(self):
202        var = self._extract4()
203        self.assertEquals(var.shape, (18,18))
204
205
206class TestLatOrdering(TestExtractQuadrant):
207    """
208    Test the shape of extracted GridSeries.
209
210    """
211    def test1(self):
212        var = self._extract1()
213        lat = var.getLatitude()
214        dlat = lat[1] - lat[0]
215        assert dlat > 0
216       
217
218    def test2(self):
219        var = self._extract2()
220        lat = var.getLatitude()
221        dlat = lat[1] - lat[0]
222        assert dlat > 0
223
224
225    def test3(self):
226        var = self._extract3()
227        lat = var.getLatitude()
228        dlat = lat[1] - lat[0]
229        assert dlat > 0
230
231
232    def test4(self):
233        var = self._extract4()
234        lat = var.getLatitude()
235        dlat = lat[1] - lat[0]
236        assert dlat > 0
237
238class TestLonOrdering(TestExtractQuadrant):
239    """
240    Test the shape of extracted GridSeries.
241
242    """
243    def test1(self):
244        var = self._extract1()
245        lon = var.getLongitude()
246        dlon = lon[1] - lon[0]
247        assert dlon > 0
248       
249
250    def test2(self):
251        var = self._extract2()
252        lon = var.getLongitude()
253        dlon = lon[1] - lon[0]
254        assert dlon > 0
255
256
257    def test3(self):
258        var = self._extract3()
259        lon = var.getLongitude()
260        dlon = lon[1] - lon[0]
261        assert dlon > 0
262
263
264    def test4(self):
265        var = self._extract4()
266        lon = var.getLongitude()
267        dlon = lon[1] - lon[0]
268        assert dlon > 0
269
270#---------------------------------------------------------------------------------------------------------
271
272class TestExtractPoint(TestCase):
273    """
274    Extract a single grid box using min/max lat/lon.
275
276    """
277    def _extract1(self, lon, lat):
278        var = extract_csml(data_csml, 'test_0_360p',
279                            time='1980-01-01T00:00:00.0',
280                            latitude=lat,
281                            longitude=lon)
282        return var
283   
284    def _extract2(self, lon, lat):
285        var = extract_csml(data_csml, 'test_0_360m',
286                            time='1980-01-01T00:00:00.0',
287                            latitude=lat,
288                            longitude=lon)
289        return var
290   
291    def _extract3(self, lon, lat):
292        var = extract_csml(data_csml, 'test_m180_180m',
293                            time='1980-01-01T00:00:00.0',
294                            latitude=lat,
295                            longitude=lon)
296        return var
297   
298    def _extract4(self, lon, lat):
299        var = extract_csml(data_csml, 'test_m180_180p',
300                            time='1980-01-01T00:00:00.0',
301                            latitude=lat,
302                            longitude=lon)
303        return var
304
305    def test1(self):
306        var = self._extract1(85, 42.5)
307        self.assertEquals(type(var), float)
308        self.assertEquals(var, 85.0+42.5)
309       
310    def test2(self):
311        var = self._extract2(85, 42.5)
312        self.assertEquals(type(var), float)
313        self.assertEquals(var, 85.0+42.5)
314
315    def test3(self):
316        var = self._extract3(85, 42.5)
317        self.assertEquals(type(var), float)
318        self.assertEquals(var, 85.0+42.5)
319
320    def test4(self):
321        var = self._extract4(85, 42.5)
322        self.assertEquals(type(var), float)
323        self.assertEquals(var, 85.0+42.5)
324       
325
326#---------------------------------------------------------------------------------------------------------
327
328class TestExtractPointWithBounds(TestCase):
329    """
330    Extract a single grid box using min/max lat/lon.
331
332    """
333    def _extract1(self, lon, lat):
334        var = extract_csml(data_csml, 'test_0_360p',
335                            time='1980-01-01T00:00:00.0',
336                            latitude=(lat-2.5, lat+2.5),
337                            longitude=(lon-5, lon+5))
338        return var
339   
340    def _extract2(self, lon, lat):
341        var = extract_csml(data_csml, 'test_0_360m',
342                            time='1980-01-01T00:00:00.0',
343                            latitude=(lat-2.5, lat+2.5),
344                            longitude=(lon-5, lon+5))
345        return var
346   
347    def _extract3(self, lon, lat):
348        var = extract_csml(data_csml, 'test_m180_180m',
349                            time='1980-01-01T00:00:00.0',
350                            latitude=(lat-2.5, lat+2.5),
351                            longitude=(lon-5, lon+5))
352        return var
353   
354    def _extract4(self, lon, lat):
355        var = extract_csml(data_csml, 'test_m180_180p',
356                            time='1980-01-01T00:00:00.0',
357                            latitude=(lat-2.5, lat+2.5),
358                            longitude=(lon-5, lon+5))
359        return var
360
361    def test1(self):
362        var = self._extract1(85, 42.5)
363        self.assertEquals(type(var), float)
364       
365    def test2(self):
366        var = self._extract2(85, 42.5)
367        self.assertEquals(type(var), float)
368       
369    def test3(self):
370        var = self._extract3(85, 42.5)
371        self.assertEquals(type(var), float)
372       
373    def test4(self):
374        var = self._extract4(85, 42.5)
375        self.assertEquals(type(var), float)
376               
Note: See TracBrowser for help on using the repository browser.