Ignore:
Timestamp:
13/07/09 13:31:56 (10 years ago)
Author:
pnorton
Message:

Made some more modifications to the ddc WMS. I've tried to reduce the amount of code duplication between the code and the cows egg.

Location:
qesdi/wms_ddc_vis/trunk/lib
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • qesdi/wms_ddc_vis/trunk/lib

    • Property svn:ignore set to
      wms_ddc_vis.egg-info
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/controllers/coastwms.py

    r5403 r5479  
    1717from cows import bbox_util 
    1818 
    19 from geoplot.layer_drawer_grid import LayerDrawerGrid 
    20  
    21 from cows.service.imps.csmlbackend.wms_csmllayer import CSMLwmsLayerMapper 
    22  
    23 from wms_ddc_vis.model.ddc_layer_mapper import DDCLayerMapper 
     19from geoplot.layer_drawer_coastline import LayerDrawerCoastlines 
     20 
    2421log = logging.getLogger(__name__) 
    2522 
    2623class CoastwmsController(ows_controller.OWSController): 
    27     layerMapper = DDCLayerMapper() 
    2824 
    2925    #layers = {}     
     
    4541    validVersions = ['1.1.1', '1.3.0'] 
    4642 
    47     #------------------------------------------------------------------------- 
    48  
    49     def __before__(self, **kwargs): 
    50         """ 
    51         This default implementation of __before__() will pass all routes 
    52         arguments to the layer mapper to retrieve a list of layers for 
    53         this WMS. 
    54  
    55         It will be called automatically by pylons before each action method. 
    56  
    57         @todo: The layer mapper needs to come from somewhere. 
    58  
    59         """ 
    60         pass 
    61         #self.updateSequence = "hello" 
    62 #        log.debug("loading layers") 
    63         #print self.layers 
    64 #        self.layers = self.layerMapper.map(**kwargs) 
    65      
    66         #------------------------------------------------------------------------- 
    67         # Methods implementing stubs in OWSController 
     43 
    6844 
    6945    def _renderCapabilities(self, version, format): 
     
    9066        ows_controller.addOperation('GetMap', formats=self._pilImageFormats.keys()) 
    9167        ows_controller.addOperation('GetContext', formats=['text/xml', 'application/json']) 
    92         ows_controller.addOperation('GetLegend', 
    93                                     formats=['image/png']) 
    94         ows_controller.addOperation('GetInfo') 
     68 
    9569         
    9670        featureInfoFormats = Set() 
     
    155129                                    formats = list(featureInfoFormats)) 
    156130 
    157     def _getLayerParamInfo(self, paramName='layers'): 
    158         """ 
    159         Retrieve the layers parameter enforcing the rule of only 
    160         selecting one layer. 
    161  
    162         @param paramName: Overrides the query string parameter name to 
    163             look for.  This is usefull for implementing GetFeatureInfo. 
    164  
    165         """ 
    166         layerName = self.getOwsParam(paramName) 
    167  
    168         # Select the first layer if several are requested. 
    169         # This plays nicer with mapClient. 
    170         if ',' in layerName: 
    171             #layerName = layerName.split(',')[0] 
    172             raise InvalidParameterValue( 
    173                 'Multi-layer GetLegend requests are not supported', 'layers') 
    174         try: 
    175             layerObj = self.layers[layerName] 
    176         except KeyError: 
    177             raise InvalidParameterValue('Layer %s not found' % layerName, 
    178                                         paramName) 
    179  
    180         return layerName, layerObj 
    181  
    182     def _getLayerParam(self, paramName='layers'): 
    183         """ 
    184         Retrieve the layers parameter enforcing the rule of only 
    185         selecting one layer. 
    186  
    187         @param paramName: Overrides the query string parameter name to 
    188             look for.  This is usefull for implementing GetFeatureInfo. 
    189  
    190         """ 
    191         layers = {} 
    192         layerNames = self.getOwsParam(paramName) 
    193  
    194         # Select the first layer if several are requested. 
    195         # This plays nicer with mapClient. 
    196         #if ',' in layerName: 
    197         layerNames = layerNames.split(',') 
    198         #raise InvalidParameterValue( 
    199         #    'Multi-layer GetMap requests are not supported', 'layers') 
    200         for layerName in layerNames: 
    201             try: 
    202                 layerObj = self.layers[layerName] 
    203                 layers[layerName] = layerObj 
    204             except KeyError: 
    205                 raise InvalidParameterValue('Layer %s not found' % layerName, 
    206                                         paramName) 
    207  
    208         #return layerName, layerObj 
    209         return layers 
    210  
    211     def _getFormatParam(self): 
    212         format = self.getOwsParam('format', default='image/png') 
    213         if format not in self._pilImageFormats: 
    214             raise InvalidParameterValue( 
    215                 'Format %s not supported' % format, 'format') 
    216  
    217         return format 
    218131 
    219132    _escapedDimNames = ['width', 'height', 'version', 'request', 
     
    222135                        'exceptions'] 
    223136 
    224     def _getDimValues(self, layerObj): 
    225         dimValues = {} 
    226         for dimName, dim in layerObj.dimensions.items(): 
    227             defaultValue = dim.extent[0] 
    228             escapedDimName=self._mapDimToParam(dimName) 
    229             dimValues[escapedDimName] = self.getOwsParam(escapedDimName, 
    230                                                   default=defaultValue) 
    231         return dimValues 
    232137 
    233138    def _mapDimToParam(self, dimName): 
     
    244149            return dimName 
    245150         
    246     def _mapParamToDim(self, dimParam): 
    247         """ 
    248         Maps a dimension parameter name to it's real dimension name. 
    249  
    250         @see: _mapDimToParam() 
    251  
    252         """ 
    253         try: 
    254             dimName = re.match(r'(.*)_dim$', dimParam).group(1) 
    255             if dimName.lower() in self._escapedDimNames: 
    256                 return dimName 
    257             else: 
    258                 return dimParam 
    259         except AttributeError: 
    260             return dimParam 
    261  
    262  
    263     def _retrieveSlab(self, layerObj, srs, dimValues, renderOpts): 
    264         # Find the slab in the cache first 
    265         cacheKey = layerObj.getCacheKey(srs, dimValues) 
    266         slab = self._layerSlabCache.get(cacheKey) 
    267         if slab is None: 
    268             slab = layerObj.getSlab(srs, dimValues, renderOpts) 
    269             if cacheKey is not None: 
    270                 self._layerSlabCache[cacheKey] = slab 
    271  
    272         return slab 
    273  
    274     #------------------------------------------------------------------------- 
    275     # OWS Operation methods 
    276151     
    277152    def GetMap(self): 
     
    287162 
    288163        # Layer handling 
    289         #layerName, layerObj = self._getLayerParam() 
    290 #        layers = self._getLayerParam() 
    291 #        log.debug('GetMap request for layer(s) %s  #%s ' % (layers, thread.get_ident(),) ) 
    292164        layerName = self.getOwsParam('layers') 
    293165         
     
    305177            srs = self.getOwsParam('crs') 
    306178 
    307         #if srs not in layerObj.crss: 
    308          #   raise InvalidParameterValue('Layer %s does not support SRS %s' % (layerName, srs)) 
    309  
    310         # Get format 
     179       # Get format 
    311180        format = self.getOwsParam('format') 
    312181        if format not in self._pilImageFormats: 
     
    314183                'Format %s not supported' % format, 'format') 
    315184 
    316  
    317         ldg = LayerDrawerGrid() 
     185        ldg = LayerDrawerCoastlines(transparent=transparent, 
     186                                    resolution=layerName) 
    318187 
    319188        xLimits = (bbox[0], bbox[2]) 
    320189        yLimits = (bbox[1], bbox[3])         
    321         finalImg = ldg.makeImage(xLimits, yLimits, width, height, resolution=layerName, 
    322                                  transparent=transparent)      
     190        finalImg = ldg.makeImage(xLimits, yLimits, width, height)      
    323191       
    324192         
     
    372240 
    373241        if format == 'text/xml': 
     242             
    374243            response.headers['Content-Type'] = format 
    375244            t = ows_controller.templateLoader.load('wms_context_1_1_1.xml') 
    376245            return t.generate(c=c).render() 
     246         
    377247        elif format == 'application/json': 
     248             
    378249            response.headers['Content-Type'] = format 
    379250            t = ows_controller.templateLoader.load('wms_context_json.txt', 
    380251                                                   cls=NewTextTemplate) 
    381252            return t.generate(c=c).render() 
     253         
    382254        else: 
    383255            raise InvalidParameterValue('Format %s not supported' % format) 
    384256 
    385     def GetFeatureInfo(self): 
    386         # Housekeeping 
    387         version = self.getOwsParam('version', default=self.validVersions[0]) 
    388         if version not in self.validVersions: 
    389             raise InvalidParameterValue('Version %s not supported' % version, 
    390                                         'version') 
    391  
    392         # Coordinate parameters 
    393         bbox = tuple(float(x) for x in self.getOwsParam('bbox').split(',')) 
    394         width = int(self.getOwsParam('width')) 
    395         height = int(self.getOwsParam('height')) 
    396        
    397         # Get pixel location 
    398         i = int(self.getOwsParam('i')) 
    399         j = int(self.getOwsParam('j')) 
    400  
    401         # Translate to geo-coordinates 
    402         x, y = bbox_util.pixelToGeo(i, j, bbox, width, height) 
    403         #start preparing GetFeatureInfo response. Assumes "HTML" output format 
    404  
    405         htmlResponse = "<html><body><p> <b>Feature Information about pixel position: "+self.getOwsParam('i')+","+self.getOwsParam('j')+"/geo position: "+str(x)+","+str(y) +"<b/></p>" 
    406          
    407          
    408         layers = self._getLayerParam('query_layers') 
    409         #Adjusts response for multiple layers 
    410         if len(layers) > 1: 
    411             htmlResponse = htmlResponse+" Multiple possible features found as follows:" 
    412    
    413         htmlResponse = htmlResponse+"<ul>" 
    414          
    415         format = self.getOwsParam('info_format', default='text/html') 
    416         for layerName, layerObj in layers.iteritems(): 
    417             log.debug('Format: %s' % format) 
    418             log.debug('Title: %s' % layerObj.title) 
    419             log.debug('FeatureInfoFormats: %s' % layerObj.featureInfoFormats) 
    420              
    421             if format not in layerObj.featureInfoFormats: 
    422                 raise InvalidParameterValue('Layer %s does not support GetFeatureInfo in format %s' %(layerName, format), 'info_format') 
    423  
    424         if version == '1.1.1': 
    425             srs = self.getOwsParam('srs') 
    426         else: 
    427             srs = self.getOwsParam('crs') 
    428  
    429         if srs not in layerObj.crss: 
    430             raise InvalidParameterValue('Layer %s does not support SRS %s' % 
    431                                         (layerName, srs)) 
    432  
    433         # Dimension handling 
    434         dimValues = {} 
    435         for dimName, dim in layerObj.dimensions.items(): 
    436             defaultValue = dim.extent[0] 
    437             dimValues[dimName] = self.getOwsParam(dimName, default=defaultValue) 
    438          
    439         response.headers['Content-Type'] = format 
    440         response.write(layerObj.getFeatureInfo(format, srs, (x, y), dimValues)) 
    441  
    442     def GetLegend(self): 
    443         """ 
    444         Return an image of the legend. 
    445  
    446         """ 
    447         # Parameters 
    448         layerName, layerObj = self._getLayerParamInfo() 
    449         format = self._getFormatParam() 
    450  
    451         # This hook alows extra arguments to be passed to the layer backend.  It 
    452         # is required for UKCP. 
    453         renderOpts = dict(request_params=self._owsParams) 
    454  
    455         img = layerObj.getLegendImage(renderOpts=renderOpts) 
    456  
    457         buf = StringIO() 
    458         img.save(buf, self._pilImageFormats[format]) 
    459  
    460         response.headers['Content-Type'] = format 
    461         response.write(buf.getvalue()) 
    462  
    463  
    464     def GetInfo(self): 
    465         from pprint import pformat 
    466         request.headers['Content-Type'] = 'text/ascii' 
    467         response.write('Some info about this service\n') 
    468         for layer in model.ukcip02.layers: 
    469             response.write('Layer %s: %s\n' % (layer, pformat(g.ukcip02_layers[layer].__dict__))) 
    470  
    471              
Note: See TracChangeset for help on using the changeset viewer.