Changeset 5978


Ignore:
Timestamp:
09/11/09 11:59:49 (10 years ago)
Author:
pnorton
Message:

Added some experimental caching to the coastline layer that will hopefully east the large overhead of drawing the rivers onto the map.

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

Legend:

Unmodified
Added
Removed
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/controllers/coastwms.py

    r5879 r5978  
    1717 
    1818import time 
     19import numpy 
     20from paste.deploy.converters import asbool 
     21 
     22import pylons 
    1923 
    2024from geoplot.layer_drawer_coastline import LayerDrawerCoastlines 
    21  
     25import matplotlib.colors 
     26 
     27from wms_ddc_vis.lib.image_import import Image 
    2228from wms_ddc_vis.lib.base import request, response, c 
    2329 
     
    3137class CoastwmsController(ows_controller.OWSController): 
    3238 
    33     renderingOptions = [ 
    34         RenderingOption('show_rivers', "Show Rivers" ,bool , False ), 
    35         RenderingOption('coastline_colour', "Coastline Colour" ,str , "black" ), 
    36         RenderingOption('land_colour', "Land Colour" ,str , None ), 
     39    coastlineRenderingOptions = [ 
     40        RenderingOption('coastline_colour', "Coastline Colour" ,str , 'black'), 
    3741        RenderingOption('coastline_width', "Coastline Width" ,float , 0.5 ), 
    3842        RenderingOption('resolution', "Coastline Resolution" ,str , "auto", ["coarse","low", "intermediate", "high", "auto"]  ),             
     43    ] 
     44     
     45    riverRenderingOptions = [ 
     46        RenderingOption('resolution', "River Resolution" ,str , "auto", ["coarse","low", "intermediate", "high", "auto"]  ),                                                              
     47        RenderingOption('river_colour', "River Colour" ,str , 'blue'),  
     48    ] 
     49     
     50    landMassRenderingOptions = [ 
     51        RenderingOption('resolution', "Coastline Resolution" ,str , "auto", ["coarse","low", "intermediate", "high", "auto"]  ),                                 
     52        RenderingOption('land_colour', "Land Colour" ,str , 'green'),                                 
    3953    ] 
    4054        
     
    93107        c.capabilities.contents = Contents() 
    94108         
    95          
    96    
    97          
    98         layers = ( ('coastline', 'coastline', 'Coast Outline'), ) 
     109        layers = ( ('coastline', 'coastline', 'Coast Outline'),  
     110                   ('rivers', 'rivers', 'Rivers'), 
     111                   ('landmass', 'landmass', 'Land Mass'),) 
    99112         
    100113         
     
    171184            return dimName 
    172185         
    173     @beaker_cache() 
     186    #@beaker_cache() 
    174187    def GetMap(self):         
    175188        st = time.time() 
    176189 
    177         parser = SlabOptionsParser(CoastwmsController.renderingOptions, request.params) 
    178          
     190        # Layer handling 
     191        layerName = self.getOwsParam('layers') 
     192         
     193        if layerName == 'rivers': 
     194            renderingOpts = CoastwmsController.riverRenderingOptions 
     195        elif layerName == 'landmass': 
     196            renderingOpts = CoastwmsController.landMassRenderingOptions 
     197        else: 
     198            renderingOpts = CoastwmsController.coastlineRenderingOptions 
     199             
     200        parser = SlabOptionsParser(renderingOpts, request.params) 
    179201 
    180202         
     
    185207                                        'version') 
    186208        styles = self.getOwsParam('styles', default='') 
    187         transparent = self.getOwsParam('transparent', default='FALSE') 
    188209        bgcolor = self.getOwsParam('bgcolor', default='0xFFFFFF') 
    189  
    190         # Layer handling 
    191         layerName = self.getOwsParam('layers') 
    192          
    193         transparent = self.getOwsParam('transparent').lower() == 'true' 
    194          
     210        transparent = self.getOwsParam('transparent', default='FALSE').lower() == 'true' 
    195211         
    196212        # Coordinate parameters 
     
    210226                'Format %s not supported' % format, 'format') 
    211227 
    212   
     228 
    213229        longResolution = parser.getOption('resolution') 
    214         #log.debug("longResolution = %s" % (longResolution,)) 
    215         resMap = {'coarse':'c', 
    216                   'low':'l', 
    217                   'intermediate':'i', 
    218                   'high':'h', 
    219                   'full':'f', 
    220                   'auto':None 
    221                   } 
     230        resMap = {'coarse':'c','low':'l','intermediate':'i','high':'h', 'full':'f', 'auto':None} 
    222231        resolution = resMap[longResolution] 
    223           
    224         #log.debug("resolution = %s" % (resolution,)) 
    225  
     232         
    226233        #make the colour compatable with matplotlib 
    227234        if bgcolor.find('0x') == 0: 
    228235            bgcolor = '#' + bgcolor[2:] 
    229         #log.debug("bgcolor = %s" % (bgcolor,)) 
    230         ldg = LayerDrawerCoastlines(transparent=transparent, 
    231                                     resolution=resolution, 
    232                                     bgcolour=bgcolor) 
    233  
    234         ldg.landColour = parser.getOption('land_colour') 
    235         ldg.drawRivers = parser.getOption('show_rivers') 
    236         ldg.coastlineColour = parser.getOption('coastline_colour') 
    237         ldg.coastlineWidth = parser.getOption('coastline_width') 
    238  
     236         
     237        log.debug("bgcolor = %s" % (bgcolor,)) 
     238         
     239        ldgArgs = {'transparent':transparent, 
     240                   'resolution':resolution, 
     241                   'bgcolour':bgcolor} 
     242         
     243        convertColour = None 
     244         
     245         
     246        # if transparency is true then matplotlib will make the image all one colour  
     247        # and use the alpha channel to draw the lines, to aid in caching we can 
     248        # request the image in black and then convert the colour afterwards (so 
     249        # only the black coloured image is cached.)  
     250         
     251        if transparent == True: 
     252             
     253            if layerName  == 'rivers': 
     254                convertColour = self._colourToRGB(parser.getOption('river_colour'), 'blue') 
     255                ldgArgs['riverColour'] = 'black' 
     256                ldgArgs['coastlineColour'] = None 
     257                 
     258            elif layerName == 'landmass': 
     259                convertColour = self._colourToRGB(parser.getOption('land_colour'), 'green') 
     260                ldgArgs['landColour'] = 'black' 
     261                ldgArgs['coastlineColour'] = None 
     262            else: 
     263                convertColour = self._colourToRGB(parser.getOption('coastline_colour'), 'black') 
     264                ldgArgs['coastlineColour'] = 'black' 
     265                ldgArgs['coastlineWidth']  = parser.getOption('coastline_width') 
     266        else: 
     267             
     268            if layerName == 'rivers': 
     269                ldgArgs['riverColour'] = self._colourToRGB(parser.getOption('river_colour'), 'blue') 
     270                ldgArgs['coastlineColour'] = None 
     271                 
     272            elif layerName == 'landmass': 
     273                ldgArgs['landColour'] = self._colourToRGB(parser.getOption('land_colour'), 'green') 
     274                ldgArgs['coastlineColour'] = None 
     275            else: 
     276                ldgArgs['coastlineColour'] = self._colourToRGB(parser.getOption('coastline_colour'), 'black') 
     277                ldgArgs['coastlineWidth']  = parser.getOption('coastline_width')             
     278             
     279             
     280             
     281             
    239282        xLimits = (bbox[0], bbox[2]) 
    240         yLimits = (bbox[1], bbox[3])         
    241         finalImg = ldg.makeImage(xLimits, yLimits, width, height)      
    242  
     283        yLimits = (bbox[1], bbox[3]) 
     284         
     285        finalImg = self._getLDCImage(ldgArgs, xLimits, yLimits, width, height) 
     286         
     287        if convertColour != None: 
     288             
     289            log.debug("convertColour = %s" % (convertColour,)) 
     290            st = time.time() 
     291            imgArr = numpy.asarray(finalImg) 
     292 
     293            arr = numpy.zeros(imgArr.shape, dtype=numpy.uint8) 
     294            arr[:,:,0] = int(round(convertColour[0] * 255.0)) 
     295            arr[:,:,1] = int(round(convertColour[1] * 255.0)) 
     296            arr[:,:,2] = int(round(convertColour[2] * 255.0)) 
     297            arr[:,:,3] =  imgArr[:,:,3] 
     298             
     299            finalImg = Image.fromarray(arr, 'RGBA') 
     300            log.debug("converted in %ss" % (time.time() - st,)) 
    243301         
    244302        # IE < 7 doesn't display the alpha layer right.  Here we sniff the 
     
    258316        response.headers['Content-Type'] = format 
    259317        response.write(buf.getvalue()) 
    260  
    261318         
    262319        #log.debug("got coastline in %s" % (time.time() - st,)) 
     
    311368    def GetDisplayOptions(self): 
    312369         
    313          
    314         generator = SlabJSONGenerator({'':CoastwmsController.renderingOptions}) 
     370        layer = self.getOwsParam('layers', default=None) 
     371         
     372         
     373        log.debug("layer = %s" % (layer,)) 
     374        if layer == 'rivers': 
     375            generator = SlabJSONGenerator({'':CoastwmsController.riverRenderingOptions}) 
     376        elif layer == 'landmass': 
     377            generator = SlabJSONGenerator({'':CoastwmsController.landMassRenderingOptions}) 
     378        else: 
     379            generator = SlabJSONGenerator({'':CoastwmsController.coastlineRenderingOptions}) 
     380             
    315381        request.headers['Content-Type'] = 'application/json' 
    316382        response.write( generator.generateJSON() ) 
    317383 
     384    def _colourToRGB(self, colour, default=None): 
     385         
     386        if colour == None: 
     387            return default 
     388         
     389        try: 
     390            if colour.find('0x') == 0: 
     391                colour = '#' + colour[2:] 
     392                 
     393            convertColour = matplotlib.colors.colorConverter.to_rgb(colour) 
     394        except: 
     395            log.warning("Error converting colour %s to rgb value." % (colour,)) 
     396            return default 
     397        else: 
     398            return convertColour 
     399 
     400    def _getLDCImage(self, ldgArgs, xLimits, yLimits, width, height, expire='never'): 
     401         
     402        dic = ldgArgs.copy() 
     403        dic['xLimits'] = xLimits 
     404        dic['yLimits'] = yLimits 
     405        dic['width'] = width 
     406        dic['height'] = height 
     407         
     408        cache_key = repr(dic) 
     409        log.debug("cache_key = %s" % (cache_key,)) 
     410 
     411        def create_func(): 
     412            log.debug("generating, cache_key = %s" % (cache_key,)) 
     413             
     414            log.debug("ldgArgs = %s" % (ldgArgs,)) 
     415            ldg = LayerDrawerCoastlines(**ldgArgs) 
     416            return ldg.makeImage(xLimits, yLimits, width, height) 
     417     
     418        enabled = pylons.config.get("cache_enabled", "True") 
     419        enabled = False 
     420        if not asbool(enabled): 
     421            log.debug("Caching disabled, skipping cache lookup") 
     422            return create_func() 
     423         
     424        my_cache = pylons.cache.get_cache('LayerDrawerCoastlineCache') 
     425         
     426        if expire == "never": 
     427            cache_expire = None 
     428        else: 
     429            cache_expire = expire 
     430         
     431        img = my_cache.get_value(cache_key, createfunc=create_func,  
     432                                      expiretime=cache_expire,) 
     433      
     434        return img 
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/controllers/csmlwms.py

    r5879 r5978  
    190190         
    191191        log.debug("finished getFigure") 
    192      
    193 #    @beaker_cache(expire=600, query_args=True) 
    194     def GetMap(self): 
    195         return WMSController.GetMap(self) 
    196      
     192         
    197193#    @beaker_cache(expire=600, query_args=True) 
    198194    def GetLegend(self): 
Note: See TracChangeset for help on using the changeset viewer.