Changeset 3371


Ignore:
Timestamp:
11/02/08 17:12:10 (12 years ago)
Author:
spascoe
Message:

Basic GetMap? works. No GetCapabilities? yet.

Location:
DPPP/ukcip02_server/trunk/ukcip_server/ukcip_server
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • DPPP/ukcip02_server/trunk/ukcip_server/ukcip_server/config/ukcip02.py

    r3367 r3371  
    88 
    99from pylons import config 
    10 from ukcip_server.model.pywms.wms_cdms import SimpleCdmsLayer 
     10from ukcip_server.model.pywms.wms_cdms import SimpleCdmsLayer, CdmsBNGGrid 
    1111 
    1212import cdms 
     
    2121        for varName in ds.listvariables(): 
    2222            #!TODO: Min/Max values 
    23             layers[varName] = SimpleCdmsLayer(ds[varName], 0, 100) 
     23            layers[varName] = SimpleCdmsLayer(ds[varName], 0, 100, GridClass=CdmsBNGGrid) 
    2424        datasets[f] = ds 
    2525         
  • DPPP/ukcip02_server/trunk/ukcip_server/ukcip_server/controllers/ukcip_wms.py

    r3367 r3371  
    11import logging 
     2from cStringIO import StringIO 
     3 
     4from matplotlib.cm import get_cmap 
    25 
    36from ows_common.pylons.ows_controller import OwsController 
     
    710from ukcip_server.lib.base import * 
    811from ukcip_server.model.pywms.wms_cdms import SimpleCdmsLayer  
     12from ukcip_server.model.pywms.render_imp import RGBARenderer 
    913 
    1014log = logging.getLogger(__name__) 
     
    1418    # Overriding OwsController class attributes 
    1519    validVersions = ['1.1.1'] 
    16  
    17     def index(self): 
    18         return 'UKCIP WMS controller' 
    1920 
    2021 
     
    2829        raise NotImplementedError 
    2930 
    30     @ows_operation(['version', 'layers', 'styles', 'srs', 'bbox', 
    31                     'width', 'height', 'format'], 
    32                    ['transparent', 'bgcolor', 'exceptions', 'time']) 
    33     def GetMap(self, file, version, layers, styles, srs, bbox, width, height, format, 
    34                transparent='FALSE', bgcolor='0xFFFFFF', exceptions='text/xml', 
    35                time=None): 
     31    @ows_operation 
     32    def GetMap(self): 
    3633 
     34        # Housekeeping 
     35        version = self.getOwsParam('version', default=self.validVersions[0]) 
    3736        if version not in self.validVersions: 
    38             raise InvalidParameterValue('Version %s not supported' % version, 'version') 
     37            raise InvalidParameterValue('Version %s not supported' % version, 
     38                                        'version') 
     39        styles = self.getOwsParam('styles', default='') 
     40        transparent = self.getOwsParam('transparent', default='FALSE') 
     41        bgcolor = self.getOwsParam('bgcolor', default='0xFFFFFF') 
     42                 
     43        # Coordinate parameters 
     44        bbox = tuple(float(x) for x in self.getOwsParam('bbox').split(',')) 
     45        width = int(self.getOwsParam('width')) 
     46        height = int(self.getOwsParam('height')) 
     47        srs = self.getOwsParam('srs') 
     48        if srs != 'EPSG:4326': 
     49            raise InvalidParameterValue('SRS %s not supported' % srs, 
     50                                              'srs') 
    3951 
     52 
     53        # Layer handling 
     54        layer = self.getOwsParam('layers') 
     55        if ',' in layer: 
     56            raise InvalidParameterValue( 
     57                'Multi-layer GetMap requests are not supported', 'layers') 
     58        try: 
     59            layerObj = g.ukcip02_layers[layer] 
     60        except KeyError: 
     61            raise InvalidParameterValue('Layer %s not found' % layer, 'layers') 
     62 
     63        # Get format and create a renderer 
     64        format = self.getOwsParam('format') 
     65        renderer = RGBARenderer(layerObj.minValue, layerObj.maxValue) 
     66        if format != renderer.mimeType: 
     67            raise InvalidParameterValue( 
     68                'Format %s not supported' % format, 'format') 
     69 
     70 
     71        # Dimension handling 
     72        dims = dict(time=self.getOwsParam('time')) 
     73 
     74 
     75        # The real work 
     76        grid = layerObj.selectGrid(bbox, dims) 
     77        img = renderer.renderGrid(grid, bbox, width, height, cmap=get_cmap()) 
     78 
     79        # IE < 7 doesn't display the alpha layer right.  Here we sniff the 
     80        # user agent and remove the alpha layer if necessary. 
     81        try: 
     82            ua = request.headers['User-Agent'] 
     83        except: 
     84            pass 
     85        else: 
     86            if 'MSIE' in ua and 'MSIE 7' not in ua: 
     87                img = img.convert('RGB') 
     88 
     89        buf = StringIO() 
     90        img.save(buf, 'PNG') 
     91 
     92        response.headers['Content-Type'] = renderer.mimeType 
     93        response.write(buf.getvalue()) 
     94 
     95        return request 
     96 
     97    @ows_operation 
     98    def GetInfo(self): 
     99        from pprint import pformat 
     100        request.headers['Content-Type'] = 'text/ascii' 
     101        response.write('Some info about this service\n') 
     102        for layer in g.ukcip02_layers: 
     103            response.write('Layer %s: %s\n' % (layer, pformat(g.ukcip02_layers[layer].__dict__))) 
     104 
     105             
  • DPPP/ukcip02_server/trunk/ukcip_server/ukcip_server/model/pywms/wms_cdms.py

    r3367 r3371  
    1010import Numeric as N 
    1111 
    12 ### Not needed for within Pylons 
    13 ## 
    14 ## class CdmsWMS(WebMapService): 
    15 ##     """ 
    16 ##     Layer objects are created for each variable from the CDMS file and 
    17 ##     placed in a flat layer hierarchy. 
    18  
    19 ##     """ 
    20  
    21 ##     def __init__(self, title, cdmsFilename, exclude=[], layerPrefs={}): 
    22 ##         """ 
    23 ##         @param exclude: Variable names to exclude. 
    24 ##         """ 
    25 ##         super(CdmsWMS, self).__init__(title) 
    26 ##         self._cdmsFile = cdms.open(cdmsFilename) 
    27 ##         self._exclude = exclude 
    28 ##         self._makeLayers(layerPrefs) 
    29  
    30 ##     def _makeLayers(self, layerPrefs): 
    31 ##         for field in self._cdmsFile.listvariables(): 
    32 ##             if field in self._exclude: 
    33 ##                 continue 
    34  
    35 ##             if field in layerPrefs: 
    36 ##                 minValue = layerPrefs[field].get('minValue') 
    37 ##                 maxValue = layerPrefs[field].get('maxValue') 
    38 ##             else: 
    39 ##                 minValue = None 
    40 ##                 maxValue = None 
    41              
    42 ##             self.layers[field] = SimpleCdmsLayer(self._cdmsFile[field], 
    43 ##                                            minValue=minValue, 
    44 ##                                            maxValue=maxValue) 
    45 ##         self.layerFolder.contents.append(field) 
     12 
     13class GridError(Exception): 
     14    pass 
     15 
     16class CdmsGrid(Grid): 
     17    """An adaptor for a cdms variable. 
     18    """ 
     19 
     20    def __init__(self, var, title=None): 
     21        """ 
     22        @param var: The cdms variable.  This should be of shape (x, lat). 
     23        """ 
     24 
     25        try: 
     26            self._var = var 
     27            self._setGrid() 
     28        except GridError, e: 
     29            # This isn't a simple grid 
     30            #!TODO: we could regrid here. 
     31            raise e 
     32        self._setMetadata(title=title) 
     33 
     34 
     35    def _setGrid(self): 
     36        """Check the grid is simple and initialise. 
     37        """ 
     38 
     39        y = self.getYAxis() 
     40        dy_a = y[1:] - y[:-1] 
     41        if not (dy_a == (N.ones(len(dy_a)) * dy_a[0])): 
     42            raise SimpleGridError, "Y Axis not equally spaced" 
     43        self.y0 = y[0] 
     44        self.dy = dy_a[0] 
     45        self.ny = len(y) 
     46        self.iy = self._var.getAxisList().index(y) 
     47 
     48        x = self.getXAxis() 
     49        dx_a = x[1:] - x[:-1] 
     50        if not (dx_a == (N.ones(len(dx_a)) * dx_a[0])): 
     51            raise SimpleGridError, "X Axis not equally spaced" 
     52        self.x0 = x[0] 
     53        self.dx = dx_a[0] 
     54        self.nx = len(x) 
     55        self.ix = self._var.getAxisList().index(x) 
     56 
     57 
     58    def _setMetadata(self, title=None): 
     59        if title: 
     60            self.long_name = title 
     61        else: 
     62            try: 
     63                self.long_name = self._var.long_name 
     64            except AttributeError: 
     65                self.long_name = 'Unknown' 
     66 
     67        try: 
     68            self.units = self._var.units 
     69        except AttributeError: 
     70            self.units = '' 
     71 
     72    def _getValue(self): 
     73        return self._var 
     74    value = property(_getValue) 
     75 
     76 
     77class CdmsLatLonGrid(CdmsGrid): 
     78    """ 
     79    Specialise CdmsGrid for EPSG:4326 
     80 
     81    """ 
     82 
     83    crs = 'EPSG:4326' 
     84 
     85    def getXAxis(self): 
     86        return self._var.getLongitude() 
     87    def getYAxis(self): 
     88        return self._var.getLatitude() 
     89 
     90class CdmsBNGGrid(CdmsGrid): 
     91    """ 
     92    Specialise CdmsGrid for British National Grid coordinate system 
     93 
     94    EPSG:27700 OSGB:36 
     95 
     96    """ 
     97 
     98    crs = 'EPSG:27700' 
     99     
     100    def getXAxis(self): 
     101        return self._var.getAxisList()[1] 
     102    def getYAxis(self): 
     103        return self._var.getAxisList()[0] 
     104 
    46105 
    47106 
    48107class SimpleCdmsLayer(Layer): 
    49     def __init__(self, cdmsVar, minValue=None, maxValue=None): 
     108    def __init__(self, cdmsVar, minValue=None, maxValue=None, GridClass=CdmsGrid): 
    50109        """ 
    51110        @param cdmsVar: variable object 
     
    53112        @todo: Add crs attribute 
    54113        """ 
     114 
     115        self.GridClass = GridClass 
    55116 
    56117        self.var = cdmsVar 
     
    90151             
    91152        v = self.var(**sel) 
    92         return CdmsGrid(v, title=self.title) 
     153        return self.GridClass(v, title=self.title) 
    93154 
    94155    def describe(self, dimensionSpec): 
    95156        return self.var.long_name + ' at ' + self.dimensions['time'] 
     157 
     158 
     159 
    96160 
    97161class CdmsTimeDimension(Dimension): 
     
    121185        return [self.iso2reltime(x) for x in time.split('D')] 
    122186 
    123 class GridError(Exception): 
    124     pass 
    125  
    126 class CdmsGrid(Grid): 
    127     """An adaptor for a cdms variable. 
    128     """ 
    129  
    130     def __init__(self, var, title=None): 
    131         """ 
    132         @param var: The cdms variable.  This should be of shape (x, lat). 
    133         """ 
    134  
    135         try: 
    136             self._var = var 
    137             self._setGrid() 
    138         except GridError, e: 
    139             # This isn't a simple grid 
    140             #!TODO: we could regrid here. 
    141             raise e 
    142         self._setMetadata(title=title) 
    143  
    144  
    145     def _setGrid(self): 
    146         """Check the grid is simple and initialise. 
    147         """ 
    148  
    149         y = self.getYAxis() 
    150         dy_a = y[1:] - y[:-1] 
    151         if not (dy_a == (N.ones(len(dy_a)) * dy_a[0])): 
    152             raise SimpleGridError, "Y Axis not equally spaced" 
    153         self.y0 = y[0] 
    154         self.dy = dy_a[0] 
    155         self.ny = len(y) 
    156         self.iy = self._var.getAxisList().index(y) 
    157  
    158         x = self.getXAxis() 
    159         dx_a = x[1:] - x[:-1] 
    160         if not (dx_a == (N.ones(len(dx_a)) * dx_a[0])): 
    161             raise SimpleGridError, "X Axis not equally spaced" 
    162         self.x0 = x[0] 
    163         self.dx = dx_a[0] 
    164         self.nx = len(x) 
    165         self.ix = self._var.getAxisList().index(x) 
    166  
    167  
    168     def _setMetadata(self, title=None): 
    169         if title: 
    170             self.long_name = title 
    171         else: 
    172             try: 
    173                 self.long_name = self._var.long_name 
    174             except AttributeError: 
    175                 self.long_name = 'Unknown' 
    176  
    177         try: 
    178             self.units = self._var.units 
    179         except AttributeError: 
    180             self.units = '' 
    181  
    182     def _getValue(self): 
    183         return self._var 
    184     value = property(_getValue) 
    185  
    186  
    187 class CdmsLatLonGrid(CdmsGrid): 
    188     """ 
    189     Specialise CdmsGrid for EPSG:4326 
    190  
    191     """ 
    192  
    193     crs = 'EPSG:4326' 
    194  
    195     def getXAxis(self): 
    196         return self._var.getLongitude() 
    197     def getYAxis(self): 
    198         return self._var.getLatitude() 
    199  
    200 class CdmsBNGGrid(CdmsGrid): 
    201     """ 
    202     Specialise CdmsGrid for British National Grid coordinate system 
    203  
    204     EPSG:27700 OSGB:36 
    205  
    206     """ 
    207  
    208     crs = 'EPSG:27700' 
    209      
    210     def getXAxis(self): 
    211         return self._var.getAxisList()[1] 
    212     def getYAxis(self): 
    213         return self._var.getAxisList()[0] 
    214  
    215187 
    216188#---------------------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.