Changeset 6506 for cowsserver


Ignore:
Timestamp:
08/02/10 08:58:04 (9 years ago)
Author:
pnorton
Message:

Improved the getfigure code so that more of the display options are used to generate the figure.

Location:
cowsserver/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • cowsserver/trunk/buildout/buildout.cfg

    r6145 r6506  
    1212  basemap 
    1313  matplotlib 
    14   numpy 
     14  numpy==1.3.0 
    1515  image_utils 
    1616  decorator==3.0.1 
     
    2020  PasteScript 
    2121  Genshi 
    22   csml 
     22  csml=2.7.9 
    2323  cows 
    2424  nose 
  • cowsserver/trunk/development.ini

    r6145 r6506  
    2525cache_dir = %(here)s/data 
    2626 
    27 cache_enabled = True 
     27cache_enabled = False 
    2828 
    2929############################################################################## 
     
    8686 
    8787[logger_pylons] 
    88 level = INFO 
     88level = DEBUG 
    8989handlers = console 
    9090propagate = 0 
     
    104104 
    105105[logger_cows_ows] 
    106 level = INFO 
     106level = DEBUG 
    107107handlers = console 
    108108propagate = 0 
  • cowsserver/trunk/lib/cowsserver/controllers/coastwms.py

    r6395 r6506  
    3333from cows.xml.iso19115_subset import OnlineResource 
    3434 
    35 from cowsserver.lib.modified_beaker_cache_decorator import beaker_cache 
     35from cowsserver.lib.modified_beaker_cache_decorator import cows_controller_beaker_cache 
    3636 
    3737log = logging.getLogger(__name__) 
     
    188188            return dimName 
    189189         
    190     #@beaker_cache() 
    191190    def GetMap(self):         
    192191        startTime = time.time() 
     
    347346            raise InvalidParameterValue('Format %s not supported' % format) 
    348347 
     348    @cows_controller_beaker_cache(expire=3600) 
    349349    def GetDisplayOptions(self): 
    350350         
  • cowsserver/trunk/lib/cowsserver/controllers/csmlwms.py

    r6395 r6506  
    22import time 
    33 
    4 from geoplot.plot_lat_lon import PlotLatLon  
     4from geoplot.grid_plot import GridPlot  
    55from geoplot.contour_plot import ContourPlot 
    66from geoplot.interval_plot import IntervalPlot 
     
    1313from cows.service.imps.geoplot_wms_backend.geoplot_wms_layer import GeoplotWmsLayer 
    1414from cows.service.imps.geoplot_wms_backend.slab_options_json_generator import SlabJSONGenerator 
     15from cows.service.imps.geoplot_wms_backend.slab_options_parser import SlabOptionsParser 
    1516 
    1617GeoplotWmsLayer.EnableDisplayOptions = True 
     
    2021from cowsserver.lib.wms_request_log_utils import buildLogString, wms_request_logger 
    2122 
    22 from cowsserver.lib.modified_beaker_cache_decorator import beaker_cache 
     23from cowsserver.lib.modified_beaker_cache_decorator import cows_controller_beaker_cache 
     24 
     25from pylons.decorators.cache import beaker_cache 
    2326 
    2427log = logging.getLogger(__name__) 
     
    4245        WMSController.__before__(self, **kwargs) 
    4346         
    44 #    @beaker_cache(expire=600, query_args=True) 
     47    @cows_controller_beaker_cache(expire=3600) 
    4548    def GetDisplayOptions(self): 
     49        log.info("running GetDisplayOptions") 
    4650         
    4751        #create a list of names for each of the styles (each slabClass has its onw style) 
     
    5963         
    6064        response.write( jsonString ) 
    61  
     65     
     66    @cows_controller_beaker_cache(expire=3600) 
    6267    def GetAxisConfig(self): 
     68        log.info("running GetAxisConfig") 
    6369        log.debug("self.layers = %s" % (self.layers,)) 
    6470         
     
    7682        response.write(fin.read()) 
    7783         
    78  
    79 #    @beaker_cache(expire=600, query_args=True) 
     84    @cows_controller_beaker_cache(expire=3600) 
    8085    def GetFigure(self): 
    81         log.debug("entering GetFigure") 
     86        log.info("running GetFigure") 
     87         
    8288        #!TODO: clearup! 
    8389        # Get the parameters 
     90         
    8491        version      = self._getVersionParam() 
    8592        format = self.getOwsParam('format', default='image/png') 
     
    103110         
    104111        styles       = self._getStylesParam(len(layerObjects)) 
     112         
     113        if styles == "": 
     114            style = None 
     115        else: 
     116            style = styles[0] 
     117         
     118        slab_class = layerObj._getSlabClass(style) 
     119         
    105120        srs          = self._getSrsParam(version) 
    106121         
     122        log.info("GetFigure: format=%s, transparent =%s, bgcolor =%s, bbox =%s, width =%s, height =%s, style =%s, srs = %s" % (format, transparent, bgcolor, bbox, width, height, style, srs,)) 
     123        log.debug("slab_class = %s" % (slab_class,)) 
     124         
    107125        dimValues = self._getDimValues(layerObj) 
    108          
    109126         
    110127        log.debug("dimValues = %s" % (dimValues,)) 
    111128        variable = layerObj.dataReader.getNetcdfVar(layerObj.title, dimValues) 
    112129         
    113                              
    114         params = self._getLowerCaseParams() 
    115          
     130         
     131        expectedParams = [] 
     132        expectedParams.extend(self._escapedDimNames) 
     133        expectedParams.extend(layerObj.dimensions.keys()) 
     134        expectedParams.append('service') 
     135         
     136        #get any other parameters on the request that the layer might need 
     137        additionalParams = self._getAdditionalParameters(expectedParams) 
     138         
     139        parser = SlabOptionsParser(slab_class.renderingOptions, additionalParams) 
     140         
     141        log.debug("additionalParams = %s" % (additionalParams,))         
    116142        log.debug("variable.shape = %s" % (variable.shape,)) 
    117143        log.debug("bbox = %s" % (bbox,)) 
     
    129155        kwargs['width'] = width 
    130156        kwargs['height'] = height 
    131  
    132         if 'cmap' in params: 
    133             kwargs['cmap']= params['cmap'] 
    134          
    135         if 'intervalcolourbar' in params: 
    136             kwargs['intervalColourbar'] = params['intervalcolourbar'].lower() == 'true' 
    137          
    138         if 'intervalnames' in params: 
    139             kwargs['intervalNames'] = params['intervalnames'].split(',') 
    140              
    141         if 'num_intervals' in params: 
    142             kwargs['numIntervals'] = int(params['num_intervals']) 
    143          
    144         if 'cmap_max' in params: 
    145             kwargs['colourBarMax'] = float(params['cmap_max']) 
    146         else: 
    147             kwargs['colourBarMax'] = variable[:].max() 
    148  
    149         if 'cmap_min' in params: 
    150             kwargs['colourBarMin'] = float(params['cmap_min']) 
    151         else: 
    152             kwargs['colourBarMin'] = variable[:].min()         
    153          
    154         log.info("kwargs = %s" % (kwargs,)) 
    155          
    156         if styles == "" or styles[0] == 'grid': 
    157              
    158             if 'show_grid_lines' in params: 
    159                 kwargs['showGridLines'] = params['show_grid_lines'].lower() == 'true' 
    160                  
    161             plt = PlotLatLon(variable, **kwargs) 
    162  
    163         elif styles[0] == 'contour': 
    164              
    165             if 'num_contour_lines' in params: 
    166                 kwargs['numContourLines'] = int(params['num_contour_lines']) 
    167          
    168             if 'contour_label_interval' in params: 
    169                 kwargs['contourLabelInterval'] = int(params['contour_label_interval']) 
    170                  
    171             log.debug("kwargs = %s" % (kwargs,)) 
    172             plt = ContourPlot(cdmsVar=variable, **kwargs) 
    173          
    174         elif styles[0] == 'interval': 
    175              
    176             plt = IntervalPlot(cdmsVar=variable, **kwargs) 
    177          
     157         
     158        #common rendering options 
     159         
     160        argMap = {'cmap':'cmap', 
     161                  'cmap_scale':'colourBarScale', 
     162                  'cmap_min':'colourBarMin', 
     163                  'cmap_max':'colourBarMax'} 
     164 
     165        if style is None or style == 'grid': 
     166            plot_class = GridPlot 
     167            argMap.update({'show_grid_lines':'showGridLines', 
     168                      'hide_outside':'hideOutsideBounds',}) 
     169 
     170        elif style == 'contour': 
     171            plot_class = ContourPlot 
     172            argMap.update({'num_contour_lines':'numContourLines', 
     173                      'contour_label_interval':'contourLabelInterval', 
     174                      'contour_font_size':'contourFontSize', 
     175                      'intervals':'intervals'}) 
     176             
     177        elif style == 'interval': 
     178            plot_class = IntervalPlot 
     179            argMap.update({ 
     180                      'hide_outside':'hideOutsideBounds', 
     181                      'show_grid_lines':'showGridLines', 
     182                      'num_intervals': 'numIntervals', 
     183                      'intervalNames': 'intervalNames', 
     184                      'intervals':'intervals'}) 
     185             
    178186        else: 
    179187            raise Exception("unknown style %s" % (styles[0],)) 
    180   
     188         
     189        # set the defaults for the min and max colourmap 
     190        kwargs['colourBarMax'] = parser.getOption('cmap_max') 
     191        if kwargs['colourBarMax'] is None: 
     192            kwargs['colourBarMax'] = variable[:].max() 
     193 
     194        kwargs['colourBarMin'] = parser.getOption('cmap_min') 
     195        if kwargs['colourBarMin'] is None: 
     196            kwargs['colourBarMin'] = variable[:].min()         
     197 
     198         
     199 
     200        self._addArguments(kwargs, argMap, parser, slab_class) 
     201        log.debug("kwargs = %s" % (kwargs,)) 
     202        kwargs['cdmsVar'] = variable 
     203        plt = plot_class(**kwargs) 
     204 
     205        log.info("format = %s" % (format, )) 
    181206        if format in self.nonPILFormats.keys(): 
    182207            plt.format = self.nonPILFormats[format] 
     
    188213             
    189214            img = plt.drawToImage() 
    190              
    191             log.debug("img.format = %s" % (img.format,)) 
    192              
    193             log.debug("variable.getAxisIds() = %s" % (variable.getAxisIds(),)) 
    194              
    195215            self._writeImageResponse(img, format) 
    196          
    197         log.debug("dir(response) = %s" % (dir(response),)) 
    198         log.debug("id(response) = %s" % (id(response),)) 
    199          
     216                 
    200217        log.debug("finished getFigure") 
    201          
    202 #    @beaker_cache(expire=600, query_args=True) 
     218     
     219    def _addArguments(self, kwargs, argMap, parser, slab_class): 
     220         
     221        for renderingOpt in slab_class.renderingOptions: 
     222            if renderingOpt.name not in argMap: 
     223                log.warning("GetFigure has now means of passing on argument %s = %s to plot" % (renderingOpt.name, parser.getOption(renderingOpt.name))) 
     224         
     225        for parameterArgName, plotArgName in argMap.items(): 
     226            kwargs[plotArgName] = parser.getOption(parameterArgName) 
     227             
     228             
     229     
     230    @cows_controller_beaker_cache(expire=3600) 
    203231    def GetLegend(self): 
     232        log.info("running GetLegend") 
    204233        return WMSController.GetLegend(self) 
    205234     
    206 #    @beaker_cache(expire=600, query_args=True) 
     235    @cows_controller_beaker_cache(expire=3600) 
    207236    def GetCapabilities(self): 
     237        log.info("running GetCapabilities") 
    208238        return WMSController.GetCapabilities(self) 
    209239         
     
    225255        return lowerDictionary 
    226256 
    227  
     257    @cows_controller_beaker_cache(expire=3600) 
    228258    def GetMap(self): 
     259        log.info("running GetMap") 
    229260        st = time.time() 
    230261        WMSController.GetMap(self) 
  • cowsserver/trunk/lib/cowsserver/lib/modified_beaker_cache_decorator.py

    r5849 r6506  
    55 
    66This is a modified version of the beaker_cache decorator found in pylons.decorators.cache, 
    7 I've customised it to only use the GET parameters to generate the key and to round 
    8 the BBOX arguments. 
    97''' 
    108 
     
    1412from decorator import decorator 
    1513from paste.deploy.converters import asbool 
    16  
    1714import pylons 
    1815 
    1916log = logging.getLogger(__name__) 
    2017 
    21 def beaker_cache(type='dbm', expire='never'): 
     18def cows_controller_beaker_cache(key="cache_default", expire="never", type="dbm", 
     19    **b_kwargs): 
     20     
     21    """ 
     22    This is a modified version of the pylons.decorators.beaker_cache that generates 
     23    a key from the fileoruri and GET request arguments. It is intended for use on  
     24    COWS controllers. 
     25    """ 
    2226     
    2327    def wrapper(func, *args, **kwargs): 
    2428        """Decorator wrapper""" 
    25 #        log.debug("Wrapped with key: %s, expire: %s, type: %s, query_args: %s", 
    26 #                  key, expire, type, query_args) 
     29         
     30        log.debug("Wrapped with expire: %s, type: %s"% (expire, type)) 
     31         
    2732        enabled = pylons.config.get("cache_enabled", "True") 
    2833        if not asbool(enabled): 
     
    3136         
    3237        my_cache = pylons.cache.get_cache('%s.%s' % (func.__module__, func.__name__), type=type) 
     38         
    3339        cache_key = _make_key() 
    3440         
     
    3743        else: 
    3844            cache_expire = expire 
     45 
    3946         
    4047        def create_func(): 
    41             log.debug("generating !") 
    4248            result = func(*args, **kwargs) 
    4349             
     
    5561                                      expiretime=cache_expire,) 
    5662 
    57         log.debug("Cached response with key: %s" % (cache_key,)) 
     63        log.debug("response with key: %s" % (cache_key,)) 
    5864             
    5965        glob_response = pylons.response._current_obj() 
     
    7076          
    7177    dic = {} 
    72          
     78     
    7379    for k,v in pylons.request.GET.items(): 
    74         if k.lower() == 'bbox': 
    75             try: 
    76                 floatValues = tuple([float(x) for x in v.split(',') ]) 
    77                 fmtString = "%.5f,"*4 
    78                 fmtString = fmtString[:-1] 
    79                 newValues = fmtString % floatValues 
    80                 dic[k] = newValues 
    81             except Exception, e: 
    82                 log.info("Exception occurred trying to re-format %s=%s: %s" % (k,v,e) ) 
    83             break; 
    84         else: 
    85             dic[k] = str(v) 
     80        dic[k] = str(v) 
    8681 
     82    fileoruri = pylons.request.environ['pylons.routes_dict']['fileoruri'] 
     83    dic['fileoruri'] = fileoruri 
     84     
    8785    cache_key = repr(dic) 
    8886    return cache_key 
Note: See TracChangeset for help on using the changeset viewer.