Ignore:
Timestamp:
18/06/07 14:53:58 (13 years ago)
Author:
spascoe
Message:

WMS now works sufficiently to be crudely viewable with openlayers but
bugs remain.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/tests/test_extract.py

    r2596 r2599  
    1111import Numeric as N 
    1212 
     13# For image dump 
     14import Image 
     15from matplotlib import cm, colors 
     16 
     17 
    1318here = os.path.dirname(os.path.abspath(__file__)) 
    1419data_csml = os.path.join(here, 'data', 'test.csml') 
     20 
     21#---------------------------------------------------------------------------- 
     22# Utility functions 
    1523 
    1624def extract_csml(file, field, **sel): 
     
    4149    return var 
    4250 
     51def dump_img(var, filename, width=100, height=100): 
     52    norm = colors.normalize(0, 1000.) 
     53    cmap = cm.get_cmap() 
     54    a = norm(var) 
     55    img_buf = (cmap(a)*255).astype('b') 
     56    (y, x, c) = img_buf.shape 
     57    img = Image.frombuffer("RGBA", (x, y), img_buf.tostring(), 'raw', 'RGBA', 
     58                           0, 1) 
     59    img.save(filename) 
     60 
     61#--------------------------------------------------------------------------- 
     62 
    4363class TestExtractAll(TestCase): 
     64    """ 
     65    Extract the entire lat/lon grid and check for correct shape and border. 
     66     
     67    """ 
     68    def setUp(self): 
     69        self._testKeys = ['cross_0_360p', 'cross_0_360m', 'cross_m180_180m', 
     70                          'cross_m180_180p'] 
     71        self._selectors = { 
     72            'cross_0_360p': dict(time='1980-01-01T00:00:00.0'), 
     73            'cross_0_360m': dict(time='1980-01-01T00:00:00.0'), 
     74            'cross_m180_180m': dict(time='1980-01-01T00:00:00.0'), 
     75            'cross_m180_180p': dict(time='1980-01-01T00:00:00.0'), 
     76            }                     
    4477 
    4578    def _checkBorder(self, var): 
     
    4881 
    4982        """ 
    50         lat5 = var.getLatitude().getValue()[5] 
    51         lon5 = var.getLongitude().getValue()[5] 
    52         self.assertEquals(var[0,5], lat5) 
    53         self.assertEquals(var[5,0], lon5) 
    54  
    55         lat30 = var.getLatitude().getValue()[30] 
    56         lon30 = var.getLongitude().getValue()[30] 
    57         self.assertEquals(var[0,30], lat30) 
    58         self.assertEquals(var[30,0], lon30) 
    59      
    60     def test1(self): 
     83        lat = var.getLatitude().getValue() 
     84        lon = var.getLongitude().getValue() 
     85 
     86        try: 
     87            self.assertEquals(var[0,5], lat[5]) 
     88            self.assertEquals(var[0,30], lat[30]) 
     89        except Exception, e: 
     90            print 'Latitude: %s' % lat 
     91            print 'var[0]: %s' % var[0] 
     92            raise e 
     93 
     94        try: 
     95            self.assertEquals(var[30,0], lon[30]) 
     96            self.assertEquals(var[5,0], lon[5]) 
     97        except Exception, e: 
     98            print 'Longitude: %s' % lon 
     99            print 'var[:,0]: %s' % var[:,0] 
     100            raise e 
     101             
     102 
     103    def _extract(self, i): 
     104        k = self._testKeys[i] 
     105        return extract_csml(data_csml, k, **self._selectors[k]) 
     106             
     107    def test1(self): 
     108        var = self._extract(0) 
     109        self.assertEquals(var.shape, (36,36)) 
     110        try: 
     111            self._checkBorder(var) 
     112        except Exception, e: 
     113            dump_img(var, '%s.png' % self._testKeys[0]) 
     114            raise e 
     115 
     116    def test2(self): 
     117        var = self._extract(1) 
     118        self.assertEquals(var.shape, (36,36)) 
     119        self._checkBorder(var) 
     120 
     121 
     122    def test3(self): 
     123        var = self._extract(2) 
     124        self.assertEquals(var.shape, (36,36)) 
     125        try: 
     126            self._checkBorder(var) 
     127        except Exception, e: 
     128            dump_img(var, '%s.png' % self._testKeys[2]) 
     129            raise e 
     130 
     131 
     132    def test4(self): 
     133        var = self._extract(3) 
     134        self.assertEquals(var.shape, (36,36)) 
     135        try: 
     136            self._checkBorder(var) 
     137        except Exception, e: 
     138            dump_img(var, '%s.png' % self._testKeys[3]) 
     139            raise e 
     140 
     141 
     142class TestExtractAll_360(TestExtractAll): 
     143    """ 
     144    Extract everything with explicit latitude/longitude selection 
     145 
     146    """ 
     147    def setUp(self): 
     148        super(TestExtractAll_360, self).setUp() 
     149        for k in self._selectors: 
     150            self._selectors[k].update( 
     151                dict(longitude=(0, 360), latitude=(-90, 90)) 
     152                ) 
     153 
     154class TestExtractAll_180(TestExtractAll): 
     155    """ 
     156    Extract everything with explicit latitude/longitude selection 
     157 
     158    """ 
     159    def setUp(self): 
     160        super(TestExtractAll_180, self).setUp() 
     161        for k in self._selectors: 
     162            self._selectors[k].update( 
     163                dict(longitude=(-180, 180), latitude=(-90, 90)) 
     164                ) 
     165 
     166 
     167#--------------------------------------------------------------------------- 
     168 
     169 
     170class TestExtract(TestCase): 
     171    """ 
     172    Abstract base class to set things up. 
     173 
     174    """ 
     175    def _extract1(self): 
    61176        var = extract_csml(data_csml, 'cross_0_360p', 
    62                             time='1980-01-01T00:00:00.0') 
     177                            time='1980-01-01T00:00:00.0', 
     178                            latitude=(0, 90), 
     179                            longitude=(0,180)) 
     180        return var 
     181     
     182    def _extract2(self): 
     183        var = extract_csml(data_csml, 'cross_0_360m', 
     184                            time='1980-01-01T00:00:00.0', 
     185                            latitude=(0, 90), 
     186                            longitude=(0,180)) 
     187        return var 
     188     
     189    def _extract3(self): 
     190        var = extract_csml(data_csml, 'cross_m180_180m', 
     191                            time='1980-01-01T00:00:00.0', 
     192                            latitude=(0, 90), 
     193                            longitude=(-180,0)) 
     194        return var 
     195     
     196    def _extract4(self): 
     197        var = extract_csml(data_csml, 'cross_m180_180p', 
     198                            time='1980-01-01T00:00:00.0', 
     199                            latitude=(0, 90), 
     200                            longitude=(-180,0)) 
     201        return var 
     202 
     203class TestExtractShape(TestExtract): 
     204    """ 
     205    Test the shape of extracted GridSeries. 
     206 
     207    """ 
     208    def test1(self): 
     209        var = self._extract1() 
     210        self.assertEquals(var.shape, (18,18)) 
     211 
     212    def test2(self): 
     213        var = self._extract2() 
     214        self.assertEquals(var.shape, (18,18)) 
     215 
     216    def test3(self): 
     217        var = self._extract3() 
     218        self.assertEquals(var.shape, (18,18)) 
     219 
     220    def test4(self): 
     221        var = self._extract4() 
     222        self.assertEquals(var.shape, (18,18)) 
     223 
     224 
     225class TestLatOrdering(TestExtract): 
     226    """ 
     227    Test the shape of extracted GridSeries. 
     228 
     229    """ 
     230    def test1(self): 
     231        var = self._extract1() 
     232        lat = var.getLatitude() 
     233        dlat = lat[1] - lat[0] 
     234        assert dlat > 0 
    63235         
    64         self.assertEquals(var.shape, (36,36)) 
    65         self._checkBorder(var) 
    66  
    67     def test2(self): 
    68         var = extract_csml(data_csml, 'cross_0_360m', 
    69                             time='1980-01-01T00:00:00.0') 
    70         self.assertEquals(var.shape, (36,36)) 
    71         self._checkBorder(var) 
    72  
    73     def test3(self): 
    74         var = extract_csml(data_csml, 'cross_m180_180m', 
    75                             time='1980-01-01T00:00:00.0') 
    76         self.assertEquals(var.shape, (36,36)) 
    77         self._checkBorder(var) 
    78  
    79     def test4(self): 
    80         var = extract_csml(data_csml, 'cross_m180_180p', 
    81                             time='1980-01-01T00:00:00.0') 
    82         self.assertEquals(var.shape, (36,36)) 
    83         self._checkBorder(var) 
    84  
    85  
    86 class TestLatOrder(TestCase): 
    87     """ 
    88     Test how the latitude ordering of the data and the order of the 
    89     latitude extraction parameter affects the results. 
    90  
    91     """ 
    92  
    93     def testLatOrder1(self): 
    94         var = extract_csml(data_csml, 'cross_0_360p', 
    95                             time='1980-01-01T00:00:00.0', 
    96                             latitude=(0, 90), 
    97                             longitude=(0,180)) 
    98         self.assertEquals(var.shape, (18,18)) 
    99         #assert N.trace(var[:,-1::-1]) == 180 
    100  
    101     def testLatOrder2(self): 
    102         var = extract_csml(data_csml, 'cross_0_360m', 
    103                             time='1980-01-01T00:00:00.0', 
    104                             latitude=(0, 90), 
    105                             longitude=(0,180)) 
    106         self.assertEquals(var.shape, (18,18)) 
    107         #assert N.trace(var[:,-1::-1]) == 180 
    108  
    109     def testLatOrder3(self): 
    110         var = extract_csml(data_csml, 'cross_m180_180m', 
    111                             time='1980-01-01T00:00:00.0', 
    112                             latitude=(0, 90), 
    113                             longitude=(-180,0)) 
    114         self.assertEquals(var.shape, (18,18)) 
    115         #assert N.trace(var[:,-1::-1]) == 180 
    116  
    117     def testLatOrder4(self): 
    118         var = extract_csml(data_csml, 'cross_m180_180p', 
    119                             time='1980-01-01T00:00:00.0', 
    120                             latitude=(0, 90), 
    121                             longitude=(-180,0)) 
    122         self.assertEquals(var.shape, (18,18)) 
    123         #assert N.trace(var[:,-1::-1]) == 180 
    124  
     236 
     237    def test2(self): 
     238        var = self._extract2() 
     239        lat = var.getLatitude() 
     240        dlat = lat[1] - lat[0] 
     241        assert dlat < 0 
     242 
     243 
     244    def test3(self): 
     245        var = self._extract3() 
     246        lat = var.getLatitude() 
     247        dlat = lat[1] - lat[0] 
     248        assert dlat < 0 
     249 
     250 
     251    def test4(self): 
     252        var = self._extract4() 
     253        lat = var.getLatitude() 
     254        dlat = lat[1] - lat[0] 
     255        assert dlat > 0 
     256 
     257class TestLonOrdering(TestExtract): 
     258    """ 
     259    Test the shape of extracted GridSeries. 
     260 
     261    """ 
     262    def test1(self): 
     263        var = self._extract1() 
     264        lon = var.getLongitude() 
     265        dlon = lon[1] - lon[0] 
     266        assert dlon > 0 
     267         
     268 
     269    def test2(self): 
     270        var = self._extract2() 
     271        lon = var.getLongitude() 
     272        dlon = lon[1] - lon[0] 
     273        assert dlon > 0 
     274 
     275 
     276    def test3(self): 
     277        var = self._extract3() 
     278        lon = var.getLongitude() 
     279        dlon = lon[1] - lon[0] 
     280        assert dlon > 0 
     281 
     282 
     283    def test4(self): 
     284        var = self._extract4() 
     285        lon = var.getLongitude() 
     286        dlon = lon[1] - lon[0] 
     287        assert dlon > 0 
     288 
     289 
Note: See TracChangeset for help on using the changeset viewer.