Changeset 5672 for cows


Ignore:
Timestamp:
27/08/09 16:23:55 (10 years ago)
Author:
pnorton
Message:

Improved the legend min and max handling in the csml backend, also changed the controller slightly to pass the dimensions to the getLegendImage function.

Location:
cows/trunk/cows
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • cows/trunk/cows/pylons/wms_controller.py

    r5640 r5672  
    495495        additionalParams = self._getAdditionalParameters(['format']) 
    496496         
    497         img = layerObj.getLegendImage(renderOpts=additionalParams) 
     497        dimValues = self._getDimValues(layerObj) 
     498         
     499        img = layerObj.getLegendImage(dimValues, renderOpts=additionalParams) 
    498500         
    499501        self._writeImageResponse(img, format) 
  • cows/trunk/cows/service/imps/csml_geoplot_backend/csml_geoplot_wms_layer.py

    r5641 r5672  
    77import logging 
    88 
     9import time 
    910import os 
    1011import csml 
     
    4647        self._feature=feature 
    4748        self.legendSize=(630,80) 
    48         self._minval=0 
    49         self._maxval=10.0 #dummy values 
     49         
     50        # dummy values, will need to be set when the data is opened 
     51        self._minval = None 
     52        self._maxval = None  
     53         
    5054        self.name = name 
    5155         
     
    106110        log.debug("dimValues = %s" % (dimValues,)) 
    107111         
    108         #unicode conversion 
     112        st = time.time() 
     113        netcdfVar = self._getNetcdfVar(dimValues) 
     114        log.debug("got netcdf in %ss" % (time.time() - st,)) 
     115         
     116        bbox=self.getBBox(crs) 
     117         
     118        slabClass = self._getSlabClass(style) 
     119         
     120        slab = slabClass(netcdfVar, self.title, crs, dimValues, transparent, bbox, additionalParams) 
     121                
     122        return slab 
     123   
     124    def _getNetcdfVar(self, dimValues): 
     125        "Opens up the csml and retrieves the variable described by the dimensions" 
     126         
     127        convertedDimVals = self._convertDimValues(dimValues) 
     128         
     129        if type(self._feature) == csml.parser.GridSeriesFeature: 
     130             
     131            randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc' 
     132             
     133            log.debug("getting csml feature") 
     134             
     135            result= self._feature.subsetToGridSeries(config['tmpdir'],  
     136                                        ncname=randomname, **convertedDimVals) 
     137             
     138            #for now have to read netcdf back from  
     139            #disk (limitiation of CSML api) 
     140            netcdf=cdms.open(result[1]) 
     141             
     142            #and then delete the temporary file 
     143            os.system('rm %s'%result[1]) 
     144             
     145            log.debug("removed temp file %s" % (result[1],)) 
     146             
     147        else: 
     148            raise NotImplementedError 
     149         
     150        variable =  netcdf(self.title, squeeze=1) 
     151         
     152        return variable 
     153     
     154    def _convertDimValues(self, dimValues): 
     155        """ 
     156        Converts the string dimension values to floats (except for time values) 
     157        """ 
     158        convertedVals = {} 
     159         
    109160        for dimval in dimValues: 
    110161            if dimval != 'time': 
    111                 dimValues[dimval]=float(dimValues[dimval]) 
     162                convertedVals[dimval]=float(dimValues[dimval]) 
    112163            else: 
    113164                #remove any trailing Zs from time string 
    114165                if dimValues[dimval] [-1:] in ['Z', 'z']: 
    115                     dimValues[dimval]=dimValues[dimval][:-1] 
    116          
    117          
    118         netcdf = self._getNetcdfVar(dimValues) 
    119  
    120         bbox=self.getBBox(crs) 
    121          
    122         slabClass = self._getSlabClass(style) 
    123          
    124         slab = slabClass(netcdf, self.title, crs, dimValues, transparent, bbox, additionalParams) 
    125          
    126         self._minval=slab.minval #needed for legend rendering. 
    127         self._maxval=slab.maxval 
    128          
    129         return slab         
    130    
    131     def _getNetcdfVar(self, dimValues): 
    132         "Opens up the csml and retrieves the variable described by the dimensions" 
    133          
    134         if type(self._feature) == csml.parser.GridSeriesFeature: 
    135              
    136             randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc' 
    137              
    138             result= self._feature.subsetToGridSeries(config['tmpdir'],  
    139                                         ncname=randomname, **dimValues) 
    140              
    141             #for now have to read netcdf back from  
    142             #disk (limitiation of CSML api) 
    143             netcdf=cdms.open(result[1]) 
    144              
    145             #and then delete the temporary file 
    146             os.system('rm %s'%result[1]) 
    147              
    148         else: 
    149             raise NotImplementedError 
    150          
    151         return netcdf 
    152      
     166                    convertedVals[dimval]=dimValues[dimval][:-1] 
     167                else: 
     168                    convertedVals[dimval] = dimValues[dimval]   
     169 
     170        return convertedVals 
     171 
    153172    def _getSlabClass(self, style): 
    154173        "Gets the slab class for a style value" 
     
    256275        return value 
    257276 
    258     def getLegendImage(self, width=None, height=None, orientation='horizontal', renderOpts={}): 
     277    def getLegendImage(self, dimValues, width=None, height=None, orientation='horizontal', renderOpts={}): 
    259278        """ 
    260279        Create an image of the colourbar for this layer. 
     
    269288            height = self.legendSize[1] 
    270289         
    271         parser = CSMLGeoplotRenderOptionsParser(renderOpts, self._minval, self._maxval) 
     290         
     291         
     292        variable = self._getNetcdfVar(dimValues) 
     293         
     294        minval = variable.min() 
     295        maxval = variable.max() 
     296         
     297        log.debug("dimValues = %s, minval = %s, maxval = %s" % (dimValues, minval , maxval,)) 
     298         
     299        parser = CSMLGeoplotRenderOptionsParser(renderOpts, minval, maxval) 
    272300         
    273301        cmapRange = (parser.getOption('cmap_min'), parser.getOption('cmap_max')) 
  • cows/trunk/cows/service/imps/csml_geoplot_backend/csml_geoplot_wms_layer_slab_base.py

    r5641 r5672  
    3333        some custom rendering options. 
    3434    """ 
    35     def __init__(self, netcdf, title, crs, dimValues, transparent, bbox, renderOpts): 
    36         self._netcdf=netcdf 
     35    def __init__(self, variable, title, crs, dimValues, transparent, bbox, renderOpts): 
     36 
    3737        self.title = title 
    3838        self.crs = crs 
     
    4141        self.transparent = transparent 
    4242        self.bbox=bbox 
     43        self.variable = variable 
    4344         
    44         self.variable =  self._netcdf(self.title, squeeze=1)  
     45        self.minval = variable.min() 
     46        self.maxval = variable.max() 
    4547         
    46         self.minval = self.variable.min() 
    47         self.maxval = self.variable.max() 
    48   
    4948        #log.debug("renderOpts = %s" % (renderOpts,)) 
    5049         
     
    108107        xRange = [ lonAx.getBounds().min(), lonAx.getBounds().max()] 
    109108        yRange = [ latAx.getBounds().min(), latAx.getBounds().max()] 
    110         log.debug("xLimits = %s" % (xLimits,)) 
    111         log.debug("yLimits = %s" % (yLimits,)) 
    112         log.debug("xRange = %s" % (xRange,)) 
    113         log.debug("yRange = %s" % (yRange,)) 
     109#        log.debug("xLimits = %s" % (xLimits,)) 
     110#        log.debug("yLimits = %s" % (yLimits,)) 
     111#        log.debug("xRange = %s" % (xRange,)) 
     112#        log.debug("yRange = %s" % (yRange,)) 
    114113         
    115114        xRange = self._fixLongitudeRange(xLimits, xRange) 
     
    139138                range180to360 = True 
    140139         
    141         log.debug("range180to360 = %s, range_180to0 = %s" % (range180to360, range_180to0,)) 
     140#        log.debug("range180to360 = %s, range_180to0 = %s" % (range180to360, range_180to0,)) 
    142141        assert not (range_180to0 and range180to360), "confusing bounds found on longitude range %s " % (xLimits,) 
    143142         
     
    157156                    break 
    158157                 
    159         log.debug("returnRange = %s" % (returnRange,)) 
     158#        log.debug("returnRange = %s" % (returnRange,)) 
    160159        return returnRange 
    161160         
  • cows/trunk/cows/service/imps/csmlbackend/wms_csmllayer.py

    r5629 r5672  
    281281        return value 
    282282 
    283     def getLegendImage(self, orientation='horizontal', renderOpts={}): 
     283    def getLegendImage(self, dimValues, orientation='horizontal', renderOpts={}): 
    284284        """ 
    285285        Create an image of the colourbar for this layer. 
     
    299299        renderer=RGBARenderer(self._minval, self._maxval) 
    300300         
     301        log.debug("dimValues = %s" % (dimValues,)) 
     302 
    301303        if orientation =='vertical': 
    302304            legendImage= renderer.renderColourbar(630, 30, cmap, isVertical=True) 
Note: See TracChangeset for help on using the changeset viewer.