Changeset 2599


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

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

Location:
TI05-delivery/ows_framework/trunk/ows_server/ows_server
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/config/middleware.py

    r2484 r2599  
    1313import ows_server.lib.helpers 
    1414import ows_server.lib.app_globals as app_globals 
     15 
     16import logging 
    1517 
    1618def make_app(global_conf, full_stack=True, **app_conf): 
     
    4244    # Put your own middleware here, so that any problems are caught by the error 
    4345    # handling middleware underneath 
     46 
     47    # Configure logging 
     48    logging.basicConfig(format='%(thread)s %(name)s %(levelname)s %(message)s') 
    4449     
    4550    # If errror handling and exception catching will be handled by middleware 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/csml_wms.py

    r2592 r2599  
    121121    @parameter('CRS', possibleValues=['CRS:84'], required=True) 
    122122    @parameter('Bbox', required=True, validator=V.bbox_2d) 
    123     @parameter('Width', required=True, validator=V.integer('Width', 0, 640)) 
    124     @parameter('Height', required=True, validator=V.integer('Height', 0, 320)) 
     123    @parameter('Width', required=True, validator=V.integer('Width')) 
     124    @parameter('Height', required=True, validator=V.integer('Height')) 
    125125    @parameter('Format', required=True) 
    126126    @parameter('Transparent', validator=V.boolean('Transparent')) 
     
    147147             
    148148            try: 
    149                 sel[dim] = request.params[dim] 
     149                sel[dim] = self.ows_params[dim] 
    150150            except KeyError: 
    151151                raise OWS_E.MissingParameterValue('%s dimension not specified' % dim, dim) 
    152152 
    153         # Extract via CSML.subsetToGridSeries() 
    154         var = extractToVariable(feature, sel) 
    155          
    156         # Deduce min and max 
    157         varmin = MA.minimum(var, None) 
    158         varmax = MA.maximum(var, None) 
     153        try: 
     154            # Extract via CSML.subsetToGridSeries() 
     155            var = extractToVariable(feature, sel) 
    159156 
    160         # Render variable to a PIL image 
    161         img = render.render_variable(var, bbox, width, height, varmin, varmax) 
     157            # Deduce min and max 
     158            varmin = MA.minimum(var, None) 
     159            varmax = MA.maximum(var, None) 
    162160 
    163         # Serialise it to PNG 
    164         buf = StringIO() 
    165         img.save(buf, 'PNG') 
     161            # Render variable to a PIL image 
     162            img = render.render_variable(var, bbox, width, height, 0, 100) # varmin, varmax 
     163 
     164            # Serialise it to PNG 
     165            buf = StringIO() 
     166            img.save(buf, 'PNG') 
     167        except Exception, e: 
     168            if isinstance(e, OWS_E.OwsError): 
     169                raise e 
     170            else: 
     171                raise OWS_E.NoApplicableCode(e) 
    166172 
    167173        return Response(content=buf.getvalue(), mimetype='image/png') 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/base.py

    r2577 r2599  
    1313import ows_common.xml 
    1414from elementtree import ElementTree as ET 
     15 
     16import logging 
     17logger = logging.getLogger('ows_server.lib.base') 
    1518 
    1619class BaseController(WSGIController): 
     
    3437            return super(OwsController, self).__call__(environ, start_response) 
    3538        except OWS_E.OwsError, e: 
     39            logger.exception(e) 
    3640            return render_response('exception_report', report=e.report, 
    3741                                   format='xml') 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/csml_util.py

    r2594 r2599  
    5959    filename = extractToNetCDF(feature, sel) 
    6060    d = cdms.open(filename) 
    61     #var = d(feature.name.CONTENT, squeeze=1) 
     61    var = d(feature.name.CONTENT, squeeze=1) 
    6262    # Work around for CSML bug 
    63     var = d(feature.name.CONTENT, longitude=sel['longitude'], latitude=sel['latitude'], 
    64             squeeze=1) 
     63    #var = d(feature.name.CONTENT, longitude=sel['longitude'], latitude=sel['latitude'], 
     64    #        squeeze=1) 
    6565 
    6666    d.close() 
    67     os.remove(filename) 
     67    #os.remove(filename) 
    6868    return var 
    6969         
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/render.py

    r2594 r2599  
    1313from ows_server.lib.grid_util import * 
    1414from matplotlib import cm, colors 
     15 
     16import MA 
     17 
     18# Configure logging to log general infomation 
     19import logging 
     20logger = logging.getLogger('ows_server.lib.render') 
     21logger.setLevel(logging.INFO) 
    1522 
    1623class BBox(object): 
     
    114121    # If var isn't defined on a uniform grid regrid 
    115122    if not is_uniform_grid(var): 
     123        # debug  
     124        logger.info('Regridding') 
    116125        var = var_to_uniform_grid(var) 
    117126 
     
    120129    lon0, lon1 = var.getLongitude()[:2]; dlon = lon1 - lon0 
    121130 
     131    # debug 
     132    logger.info('grid spacing: %s, %s' % (dlat, dlon)) 
     133 
    122134    def render(var, width, height): 
    123135        # Normalise variable to varmin, varmax 
    124136        norm = colors.normalize(varmin, varmax) 
    125         a = norm(var.getValue()) 
    126         order = var.getOrder() 
     137        a = norm(var) 
    127138         
    128139        # Render the normalised variable by converting it into a byte array then to a PIL image 
    129140        img_buf = (cmap(a) * 255).astype('b') 
    130141        (y, x, c) = img_buf.shape 
    131  
    132142        img = Image.frombuffer("RGBA", (x, y), img_buf.tostring(), "raw", "RGBA", 0, 1) 
    133143 
  • 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.