Changeset 5699 for qesdi/geoplot


Ignore:
Timestamp:
09/09/09 10:14:58 (10 years ago)
Author:
pnorton
Message:

Extended geoplot so it can now create a discrete colour bar with named labels instead of a continuouse one.

I've also modified the layer drawing code to fix a transparency bug and to make more use of the new colourbar features.

Location:
qesdi/geoplot/trunk/lib/geoplot
Files:
2 added
17 edited

Legend:

Unmodified
Added
Removed
  • qesdi/geoplot/trunk/lib/geoplot/colour_bar.py

    r5688 r5699  
    55 
    66import matplotlib.colors 
     7from matplotlib.colors import Normalize, ListedColormap, BoundaryNorm 
     8 
    79import matplotlib.ticker 
    810from matplotlib.figure import Figure 
     
    1113import operator 
    1214 
     15 
     16from geoplot.fixed_boundary_norm import FixedBoundaryNorm 
    1317import geoplot.config as geoplot_config 
    1418import geoplot.utils 
     
    2731    def __init__(self, colourBarLabel="",colourBarPosition='horizontal',  
    2832                       cmap=None, colourBarMin=None, colourBarMax=None, 
     33                       intervalColourbar=False, intervalNames=None, 
    2934                       hideOutsideBounds=False): 
    3035 
     
    3944        self.colourBarMax = colourBarMax 
    4045        self.hideOutsideBounds = hideOutsideBounds 
     46        self.intervalColourbar = intervalColourbar 
     47        self.intervalNames = intervalNames 
    4148         
    4249        self.labelFont = config[FONTS_SECTION]['ColourBarLabel'] 
    4350 
    44     def draw(self, colourBarAxis, fontSize='medium', data=None): 
     51    def draw(self, colourBarAxis, fontSize='medium', grid=None): 
    4552        """ 
    4653        Adds the colour bar to the (and optionally a label) to the figure. 
     
    5259        @type units: string 
    5360        """ 
    54          
    55         cmap = self.getColourMap() 
    56  
    57         norm = self.getNormalize(data) 
    58          
    59         cb = ColorbarBase(colourBarAxis, 
    60                           cmap=cmap,  
    61                           norm=norm,  
    62                           orientation=self.colourBarPosition) 
    63  
    64         if cb.cmap.__class__ == matplotlib.colors.ListedColormap: 
     61        log.debug("drawing colour bar") 
     62        kwargs = {} 
     63         
     64         
     65         
     66        kwargs['cmap'] = self.getColourMap(grid) 
     67        kwargs['norm'] = self.getNormalize(grid) 
     68        kwargs['orientation'] = self.colourBarPosition 
     69         
     70        if self.intervalColourbar: 
     71             
     72            cbMin, cbMax = self._getCbarMinMax() 
     73            kwargs['ticks'] = grid.getUniqueValues(cbMin, cbMax) 
     74             
     75            if self.intervalNames != None: 
     76                 
     77                if len(self.intervalNames) == len(kwargs['ticks']): 
     78                    kwargs['format'] = matplotlib.ticker.FixedFormatter(self.intervalNames) 
     79                else: 
     80                    log.warning("Incorrect number of interval names, expected %s but recieved %s" % (len(kwargs['ticks']), len(self.intervalNames))) 
     81             
     82            kwargs['spacing'] = 'proportional' 
     83             
     84            log.debug("kwargs['cmap'].N = %s" % (kwargs['cmap'].N,)) 
     85         
     86        cb = ColorbarBase(colourBarAxis, **kwargs) 
     87 
     88        if cb.cmap.__class__ == matplotlib.colors.ListedColormap \ 
     89           and not self.intervalColourbar: 
    6590            ColourBar._repositionColourBarTicks(cb) 
    6691             
     
    6893            labelDictionary = self.labelFont.getDict(fontSize) 
    6994            cb.set_label(self.colourBarLabel, fontdict=labelDictionary) 
    70  
    71     def getColourMap(self): 
     95         
     96        log.debug("finished drawing colour bar") 
     97 
     98    def getColourMap(self, grid=None): 
    7299         
    73100        if self.cmap == None: 
     
    80107        else: 
    81108            cmap = self.cmap 
    82              
     109     
     110        if self.intervalColourbar and  cmap.__class__ != matplotlib.colors.ListedColormap: 
     111             
     112            cbMin, cbMax = self._getCbarMinMax() 
     113             
     114            oldCmap = cmap 
     115            uniqueVals = grid.getUniqueValues(cbMin, cbMax) 
     116            n = matplotlib.colors.Normalize(uniqueVals[0], uniqueVals[-1]) 
     117            colours = [oldCmap(n(x)) for x in uniqueVals] 
     118            cmap = matplotlib.colors.ListedColormap(colours) 
     119                 
    83120        if self.hideOutsideBounds: 
    84121            log.debug("self.hideOutsideBounds = %s" % (self.hideOutsideBounds,)) 
     
    156193            cb.ax.xaxis.set_ticks_position('default') 
    157194     
    158     def getNormalize(self, data=None): 
    159          
     195    def getNormalize(self, grid=None): 
     196         
     197        cbMin, cbMax = self._getCbarMinMax() 
     198         
     199        if self.intervalColourbar: 
     200            bounds = grid.getUniqueValueBounds(cbMin, cbMax) 
     201            n = len(grid.getUniqueValues(cbMin, cbMax)) 
     202            norm = FixedBoundaryNorm(bounds, n) 
     203        else: 
     204            norm = matplotlib.colors.Normalize(cbMin,  cbMax) 
     205            # this should work event if data is none (as N.ma.maximum(None) = None) 
     206            data = None 
     207            if grid != None: 
     208                data = grid.values 
     209             
     210            norm.autoscale_None(data) 
     211             
     212             
     213            # check for masked values in vmin and vmax, can occur when data is completly masked 
     214            if norm.vmin.__class__ == numpy.ma.MaskedArray and norm.vmin.mask == True: 
     215                norm.vmin = None 
     216                 
     217            if norm.vmax.__class__ == numpy.ma.MaskedArray and norm.vmax.mask == True: 
     218                norm.vmax = None 
     219                 
     220        return norm 
     221     
     222    def _getCbarMinMax(self): 
    160223        cbMin = self.colourBarMin 
    161224        cbMax = self.colourBarMax 
     
    164227            log.warning("min(=%s) > max(=%s) reversing values" % (cbMin, cbMax)) 
    165228            cbMax, cbMin = cbMin, cbMax 
    166          
    167         norm = matplotlib.colors.Normalize(cbMin,  cbMax) 
    168          
    169         # this should work event if data is none (as N.ma.maximum(None) = None) 
    170         norm.autoscale_None(data) 
    171          
    172         # check for masked values in vmin and vmax, can occur when data is completly masked 
    173         if norm.vmin.__class__ == numpy.ma.MaskedArray and norm.vmin.mask == True: 
    174             norm.vmin = None 
    175              
    176         if norm.vmax.__class__ == numpy.ma.MaskedArray and norm.vmax.mask == True: 
    177             norm.vmax = None 
    178  
    179         return norm 
    180      
    181     def _getColourBarLimit(self, limit, data=None): 
    182         assert limit in ['min','max'] 
    183          
    184         #use the value set 
    185         if limit == 'min': 
    186             setVal = self.colourBarMin 
    187         else: 
    188             setVal = self.colourBarMax 
    189          
    190         # if there is no vlaue set try using the data to get 
    191         # the min and max 
    192         if setVal is None: 
    193              
    194             dataVal = None 
    195              
    196             if data is not None: 
    197                 if limit == 'min': 
    198                     dataVal = data.min() 
    199                 else: 
    200                     dataVal = data.max() 
    201                  
    202                 # can't use a masked array as the min or max value 
    203                 if dataVal.__class__.__name__ == 'MaskedArray': 
    204                     dataMin = None 
    205              
    206             if dataVal is not None: 
    207                 setVal = dataVal 
    208             else: 
    209                 if limit == 'min': 
    210                     setVal = 0 
    211                 else: 
    212                     setVal = 1 
    213          
    214         return setVal 
    215      
     229             
     230        return cbMin, cbMax         
    216231     
    217232    def __get_position(self): return self._position 
     
    282297    cb.draw(axes)     
    283298     
    284 #    cb = ColorbarBase(axes, cmap=cmap, norm=matplotlib.colors.Normalize(cmapRange[0],cmapRange[1]),  
    285 #                      orientation=orientation) 
    286 #     
    287 #    if label != None: 
    288 #        cb.set_label(label, weight='normal') 
    289  
    290299    return geoplot.utils.figureToImage(fig) 
    291      
     300 
     301def getIntervalColourBarImage(grid, width=600, height=100, 
     302                      label=None,  
     303                      cmap=cm.jet,  
     304                      cmapRange=(None, None),  
     305                      orientation='horizontal', 
     306                      intervalNames=None, 
     307                      dpi=100): 
     308     
     309    figsize=(width / float(dpi), height / float(dpi)) 
     310    fig = Figure(figsize=figsize, dpi=dpi, facecolor='w') 
     311     
     312    #for agg bakcend 
     313    #need about 40px at the bottom of the axes to draw the labels 
     314    #x = 40.0 
     315    #cbMin = 0.5 
     316     
     317    #for cairo backend 
     318    x = 50.0 
     319    cbMin = 0.6 
     320     
     321    cbBottom = x/height 
     322     
     323    if cbBottom < 0.1: 
     324        cbBottom = 0.1 
     325     
     326    if cbBottom > cbMin: 
     327        cbBottom = cbMin 
     328         
     329    cbHeight = 0.9 - cbBottom 
     330    axes = fig.add_axes([0.05, cbBottom, 0.9, cbHeight], frameon=False) 
     331     
     332    log.debug("cbBottom = %s, cbHeight = %s" % (cbBottom, cbHeight,)) 
     333     
     334    if cmapRange[0] > cmapRange[1]: 
     335        log.warning("cmapRange[0] > cmapRange[1], swapping values") 
     336        cmapRange = (cmapRange[1], cmapRange[0]) 
     337     
     338    cb = ColourBar(colourBarLabel=label,  
     339                   colourBarPosition=orientation,  
     340                   cmap=cmap,  
     341                   colourBarMin=cmapRange[0],  
     342                   colourBarMax=cmapRange[1], 
     343                   intervalNames=intervalNames, 
     344                   intervalColourbar=True) 
     345     
     346    cb.draw(axes, grid=grid)     
     347     
     348    return geoplot.utils.figureToImage(fig) 
  • qesdi/geoplot/trunk/lib/geoplot/config.ini

    r5683 r5699  
    1010colourBarLabel = None 
    1111colourBarPosition = None 
     12intervalColourbar = False 
     13intervalNames = None 
    1214 
    1315[Defaults:MetadataBox] 
  • qesdi/geoplot/trunk/lib/geoplot/contour_drawer.py

    r5605 r5699  
    8585            levels = N.linspace(normalize.vmin, normalize.vmax, self.numContourLines) 
    8686             
    87             log.debug("levels = %s" % (levels,)) 
    88             log.debug("levels[0::2] = %s" % (levels[0::2],)) 
    89          
    9087            extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
    9188                    grid_mapUnits.boundsY.min(), grid_mapUnits.boundsY.max()) 
    92              
    93             log.debug("extent = %s" % (extent,)) 
    9489             
    9590            CS = axes.contour(grid_mapUnits.midpointsX,  
     
    105100             
    106101            labelDictionary = self._contourFont.getDict(fontSize) 
     102             
    107103            axes.clabel(CS,levels[0::self.contourLabelInterval], fontsize=labelDictionary['size']) 
    108104             
  • qesdi/geoplot/trunk/lib/geoplot/contour_plot.py

    r5691 r5699  
    2525         
    2626        log.debug("grid.values.min() = %s, grid.values.max() = %s" % (grid.values.min() , grid.values.max(),)) 
    27         norm = self._colourBar.getNormalize(data=grid.values) 
    28         cmap = self._colourBar.getColourMap() 
     27        norm = self._colourBar.getNormalize(grid=grid) 
     28        cmap = self._colourBar.getColourMap(grid=grid) 
    2929         
    3030        self._contourDrawer.draw(axes, grid, map.basemap, norm, cmap, self.fontSize) 
  • qesdi/geoplot/trunk/lib/geoplot/grid.py

    r5636 r5699  
    88#python modules 
    99import logging 
     10import numpy as N 
     11import sets 
    1012 
    1113#third party modules 
    1214 
    1315#internal modules 
    14  
     16import geoplot.utils as utils 
    1517#setup the logging 
    1618log = logging.getLogger(__name__) 
     
    3032        self.midpointsY = midpointsY 
    3133        self.values = values 
     34        self._uniqueValues = None 
    3235         
    3336    def transform(self, transfrom): 
     
    4548                        self.values.copy()) 
    4649     
     50    def getUniqueValues(self, minVal=None, maxVal=None): 
     51        uniqueVals = list(sets.Set(self.values.compressed().tolist())) 
     52        uniqueVals.sort() 
     53         
     54        if minVal != None and maxVal != None: 
     55            uniqueVals = filter(lambda x: minVal <= x <= maxVal, uniqueVals) 
     56             
     57        return N.array(uniqueVals) 
     58     
     59    def getUniqueValueBounds(self, minVal=None, maxVal=None): 
     60        return utils.getBounds(self.getUniqueValues(minVal, maxVal)) 
     61             
    4762     
    4863if __name__ == '__main__': 
  • qesdi/geoplot/trunk/lib/geoplot/grid_drawer.py

    r5683 r5699  
    109109        Draws the grid boxes onto the axes. 
    110110        """ 
     111                         
    111112 
    112113        gridColour = 'k' 
     
    170171                if values.shape[1] == boundsShape[0] -1 and values.shape[0] == boundsShape[1] -1: 
    171172                    values = N.transpose(values)            
     173 
    172174 
    173175            #if the bounds are parralel then use imshow, otherwise stick with pcolormesh 
  • qesdi/geoplot/trunk/lib/geoplot/grid_plot.py

    r5688 r5699  
    6060        log.debug("grid.values.max() = %s" % (grid.values.max(),)) 
    6161         
    62         norm = self._colourBar.getNormalize(data=grid.values) 
    63         cmap = self._colourBar.getColourMap() 
     62        norm = self._colourBar.getNormalize(grid=grid) 
     63        cmap = self._colourBar.getColourMap(grid=grid) 
    6464         
    6565        self._gridDrawer.draw(axes, grid, limits=(self.xLimits, self.yLimits), 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer.py

    r5688 r5699  
    3939                 resolution=None, 
    4040                 cmap=None,  
    41                  cmapRange=(None,None), ): 
     41                 cmapRange=(None,None),  
     42                 intervalColourbar=False,  
     43                 intervalNames=None): 
    4244         
    4345        self._cb = ColourBar() 
     
    4547        self.cmap = cmap 
    4648        self.cmapRange = cmapRange 
     49        self.intervalColourbar = intervalColourbar 
     50        self.intervalNames = intervalNames 
    4751         
    4852        self._gridFactory = GridFactory(dataType=gridType) 
     
    8589        fig = Figure(figsize=figsize, dpi=dpi, facecolor='w',  
    8690                     frameon=(not self.transparent)) 
     91         
     92        log.debug("fig.frameon = %s" % (fig.frameon,)) 
    8793         
    8894        return fig         
     
    179185    showGridLines = property(__get_showGridLines, __set_showGridLines)  
    180186     
    181     def __set_cmap(self, value): 
    182         self._gridDrawer.cmap = value 
    183          
    184     def __get_cmap(self): 
    185         return self._gridDrawer.cmap  
    186      
    187     cmap = property(__get_cmap, __set_cmap) 
    188      
    189187    def __set_cmapRange(self, value): 
    190188        self._cmapRange = value 
     
    215213    def __get_projection(self): 
    216214        return self._mapFactory.projection 
     215     
     216    projection = property(__get_projection, __set_projection, None, None) 
    217217 
    218218    def __set_cmap(self, value): 
     
    233233    cmapRange = property(__get_cmapRange, __set_cmapRange) 
    234234     
    235  
    236     projection = property(__get_projection, __set_projection, None, None) 
    237      
    238          
    239      
     235    def __set_intervalColourbar(self, value): 
     236        self._cb.intervalColourbar = value 
     237         
     238    def __get_intervalColourbar(self): 
     239        return self._cb.intervalColourbar  
     240     
     241    intervalColourbar = property(__get_intervalColourbar, __set_intervalColourbar)     
     242     
     243    def __set_intervalNames(self, value): 
     244        self._cb.intervalNames = value 
     245         
     246    def __get_intervalNames(self): 
     247        return self._cb.intervalNames  
     248     
     249    intervalNames = property(__get_intervalNames, __set_intervalNames) 
     250     
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_contour.py

    r5688 r5699  
    2121     
    2222    def __init__(self, cdmsVar, gridType='latlon', projection='latlon', cmap = None,  cmapRange=(None,None), 
    23                  transparent=False, numLines=10, fontSize='medium', labelInterval=1): 
     23                 transparent=False, numLines=10, fontSize='medium', labelInterval=1,  
     24                 intervalColourbar=False,  
     25                 intervalNames=None): 
    2426         
    2527        self._contourDrawer = ContourDrawer() 
     
    4547            basemap = map.basemap         
    4648         
    47         norm = self._cb.getNormalize() 
     49        norm = self._cb.getNormalize(grid=grid) 
     50        cmap = self._cb.getColourMap(grid=grid) 
    4851         
    49         self._contourDrawer.draw(axes, grid, normalize=norm, cmap=self._cb.getColourMap(), 
     52        #set the bad colour to transparent 
     53        cmap.set_bad('w', 0.0) 
     54         
     55        self._contourDrawer.draw(axes, grid, normalize=norm, cmap=cmap, 
    5056                                 basemap=basemap, fontSize=self.fontSize) 
    5157     
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid.py

    r5688 r5699  
    3939     
    4040    def __init__(self, cdmsVar, gridType='latlon', showGridLines=False, cmap=None, cmapRange=(None,None), outline=False, 
    41                  transparent=False): 
     41                 transparent=False,  
     42                 intervalColourbar=False,  
     43                 intervalNames=None): 
    4244         
    43  
     45        log.debug("transparent = %s" % (transparent,)) 
    4446        self._gridDrawer = GridDrawer() 
    4547         
     
    7173            basemap = map.basemap         
    7274         
    73         norm = self._cb.getNormalize() 
    74                  
     75        norm = self._cb.getNormalize(grid=grid) 
     76        cmap = self._cb.getColourMap(grid=grid) 
     77 
     78        #set the bad colour to transparent 
     79        cmap.set_bad('w', 0.0) 
     80         
    7581        #draw the grid on the axis 
    7682        self._gridDrawer.draw(axes, grid, 
     
    7884                              limits=(xLimits, yLimits), 
    7985                              norm=norm, 
    80                               cmap=self._cb.getColourMap()) 
     86                              cmap=cmap) 
    8187                               
    8288     
  • qesdi/geoplot/trunk/lib/geoplot/plot_base.py

    r5688 r5699  
    152152        if self.drawColourBar: 
    153153            self._colourBar.draw(self._plotArea.cbAxes, self.fontSize,  
    154                                  data=grid.values) 
     154                                 grid=grid) 
    155155 
    156156    def drawToImage(self): 
  • qesdi/geoplot/trunk/lib/geoplot/tests/data/make_test_data.py

    r5683 r5699  
    77from geoplot.tests.make_ll_grid_data import makeLLVar 
    88from geoplot.plot_lat_lon import PlotLatLon 
     9from matplotlib.figure import Figure 
     10import matplotlib.cm as cm 
    911log = logging.getLogger(__name__) 
    1012 
     
    6163    print "var 2: latMin = %s, latMax = %s, lonMin = %s, lonMax = %s, nLat = %s, nLon = %s" % (latMin, latMax, lonMin, lonMax, nLat, nLon) 
    6264    print "var2: getAxisIds = %s, shape=%s" % (var2.getAxisIds(), var2[:].shape)     
     65 
     66    file = os.path.join(outputDir, 'make_test_data_plot.png') 
    6367     
    6468    #assert var2[:].shape == var[:].shape, " var2[:].shape(=%s) != var[:].shape(=%s)" % (var2[:].shape, var[:].shape) 
    6569    #assert var2.mask.shape == var.mask.shape , "var2.mask.shape(=%s) != var.mask.shape(=%s)" % (var2.mask.shape, var.mask.shape) 
     70#     
     71#    plt = PlotLatLon(var2, width=900, height=600, drawRivers=False) 
     72#    plt.drawMap(file) 
     73 
    6674     
    67     plt = PlotLatLon(var2, width=900, height=600, drawRivers=False) 
    68     file = os.path.join(outputDir, 'make_test_data_plot.png') 
    69     plt.drawMap(file) 
    70                  
     75#    from matplotlib.backends.backend_cairo import FigureCanvasCairo as FigureCanvas 
     76#    width = 1600; height = 1200; dpi = 100;transparent = True 
     77#    figsize=(width / float(dpi), height / float(dpi)) 
     78#    fig = Figure(figsize=figsize, dpi=dpi, facecolor='g', frameon=(not transparent)) 
     79#     
     80#    axes = fig.add_axes([0.1, 0.1, 0.8, 0.8], xticks=[], yticks=[], frameon=False) 
     81#     
     82#    delta = 0.025 
     83# 
     84#    x = N.arange(-3.0, 3.0, delta) 
     85#    y = N.arange(-2.0, 2.0, delta) 
     86#    X, Y = N.meshgrid(x, y) 
     87#    import matplotlib.mlab as mlab 
     88#    Z1 = mlab.bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0) 
     89#    Z2 = mlab.bivariate_normal(X, Y, 1.5, 0.5, 1, 1) 
     90# 
     91#    # difference of Gaussians 
     92#    Z = 10.0 * (Z2 - Z1) 
     93# 
     94#    levels = N.arange(-1.2, 1.6, 0.2) 
     95# 
     96#    CS = axes.contour(Z, levels, origin='lower', linewidths=2, extent=(-3,3,-2,2), 
     97#                      cmap=cm.gray, alpha=1.0) 
     98#     
     99#    canvas = FigureCanvas(fig) 
     100#    canvas.print_figure(file, dpi=fig.get_dpi(), facecolor=fig.get_facecolor(), edgecolor=fig.get_edgecolor()) 
     101     
     102     
     103     
     104    from geoplot.layer_drawer_grid import LayerDrawerGrid 
     105    xLimits=(-20.0,  15.0); yLimits=( 40.0, 70.0) 
     106    ld = LayerDrawerGrid(var , transparent=True) 
     107    im = ld.makeImage(xLimits, yLimits, 900, 1200) 
     108    im.save(file) 
     109     
     110     
     111    print "saved ", file 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_contour_plot.py

    r5610 r5699  
    33import logging 
    44 
     5from geoplot.tests.make_data_functions import fnSinXAddCosY_10to10 
    56from geoplot.tests.drawing import getDrawingOutputDir 
    67from geoplot.colour_bar import ColourBar 
     
    2223    xLimits = (-15,10) 
    2324    yLimits = (40,60) 
    24     var = makeLLVar(lonBounds=xLimits, latBounds=yLimits) 
     25    #var = makeLLVar(lonBounds=xLimits, latBounds=yLimits) 
     26     
     27         
     28    var = makeLLVar(lonBounds=xLimits, latBounds=yLimits, nx=20, ny=20, function=fnSinXAddCosY_10to10, missing_value=-999) 
     29 
     30     
     31     
    2532    data = var[:] 
    26     print data.shape, data.max(), data.min() 
    27     plot = ContourPlot(cdmsVar=var, xLimits=xLimits, yLimits=yLimits) 
     33    plot = ContourPlot(cdmsVar=var, xLimits=xLimits, yLimits=yLimits, intervalColourbar=True) 
    2834     
    2935    filename = "draw_contour_latlon.png" 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_grid_plot.py

    r5610 r5699  
    11import os 
    22import logging 
     3 
     4from geoplot.tests.make_data_functions import fnSinXAddCosY_10to10 
    35 
    46log = logging.getLogger(__name__) 
     
    3638    #xLimits=( -8.0,   1.0), yLimits=( 52.0, 64.0) , 
    3739 
    38     var = makeLLVar(lonBounds=xLimits, latBounds=yLimits, nx=20, ny=20) 
     40    #var = makeLLVar(lonBounds=xLimits, latBounds=yLimits, nx=20, ny=20) 
     41     
     42    var = makeLLVar(lonBounds=xLimits, latBounds=yLimits, nx=20, ny=20, function=fnSinXAddCosY_10to10, missing_value=-999) 
    3943 
    4044    plot =  GridPlot(cdmsVar=var, format = plot_format, 
     
    4448                    drawCoast = True, drawRivers = True, 
    4549                    drawColourBar = True, drawValues = True, 
    46                     xLimits=xLimits, yLimits=yLimits) 
     50                    xLimits=xLimits, yLimits=yLimits, 
     51                    intervalColourbar=True, intervalNames=list('abcdefghijklmnopqrstu')) 
    4752 
    4853    plot.drawMap(outputFile) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/make_data_functions.py

    r5683 r5699  
    4040            data[i,j] =  sin(x*x) + cos(y*y) 
    4141             
     42    return data 
     43 
     44def fnSinXAddCosY_10to10(shape=(10,10), missing_value=N.float32(1e20), xMax=7.0, yMax=5.0): 
     45     
     46    data = N.zeros(shape, dtype=float) 
     47     
     48    xvals = N.linspace(0, xMax, shape[0]) 
     49    yvals = N.linspace(0, yMax, shape[1]) 
     50     
     51    for i in range(shape[0]): 
     52        for j in range(shape[1]): 
     53             
     54            x = xvals[i] 
     55            y = yvals[j] 
     56             
     57            data[i,j] = sin(x) + cos(y) 
     58    data = data * 5 
     59    data = data.round(0) 
     60    data = N.array(data, dtype=int) 
    4261    return data 
    4362 
     
    86105    logging.basicConfig(level=logging.DEBUG, format=SHORT_LOG_FORMAT_STRING) 
    87106     
    88     arr = randomFill(shape=(2,2,2)) 
    89     print arr 
     107    arr = fnSinXAddCosY_10to10(shape=(100,100)) 
     108    print arr.max(), arr.min() 
    90109         
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_utils.py

    r5636 r5699  
    1313 
    1414import geoplot.utils 
     15from geoplot.tests.test_utils import _areNumericListsEqual 
    1516 
    16 from geoplot.utils import ispointInLimits, isValueInLimits, isRangeInLimits 
     17from geoplot.utils import ispointInLimits, isValueInLimits, isRangeInLimits, getBounds 
    1718 
    1819class Test_ScaleRGBList(object): 
     
    128129        nt.assert_false( isValueInLimits(2.5, [0.0,2.0])) 
    129130 
     131class TestGetBounds(object): 
     132    def testGetBounds(self): 
     133        assert _areNumericListsEqual( getBounds(numpy.array([1.0,2.0,3.0,5.0,6.0])).tolist() ,[0.5, 1.5, 2.5, 4.0, 5.5, 6.5]) 
     134        assert _areNumericListsEqual( getBounds(numpy.array([1.4,2.4,3.5,5.5,6.8])).tolist() , [0.9, 1.9, 2.95, 4.5, 6.15, 7.45]) 
     135        assert _areNumericListsEqual( getBounds(numpy.array([6.0,5.0,4.0,3.0,2.0])).tolist() ,[6.5, 5.5, 4.5, 3.5, 2.5, 1.5]) 
     136         
     137 
    130138# Magic to run tests if executed as a script 
    131139if __name__ == '__main__': 
  • qesdi/geoplot/trunk/lib/geoplot/utils.py

    r5688 r5699  
    180180         
    181181    return l 
     182 
     183def getBounds(arr): 
     184     
     185    assert len(arr.shape) == 1 
     186     
     187    #guess the first and the last bounds  
     188    start = arr[0] - (arr[1]- arr[0])/2.0   
     189    end = (arr[-1] - arr[-2])/2.0 + arr[-1] 
     190     
     191    shape = (arr.shape[0] + 1,) 
     192    arrA = numpy.zeros(shape, dtype=arr.dtype) 
     193    arrB = numpy.zeros(shape, dtype=arr.dtype) 
     194     
     195    arrA[:-1] = arr 
     196    arrB[1:] = arr 
     197     
     198    arrC = (arrA + arrB) / 2.0 
     199    arrC[0] = start 
     200    arrC[-1] = end 
     201     
     202    return arrC 
     203     
     204     
     205     
     206     
Note: See TracChangeset for help on using the changeset viewer.