Changeset 5876


Ignore:
Timestamp:
23/10/09 16:25:45 (10 years ago)
Author:
pnorton
Message:

Added a faster layer drawer for the grid, a new style of colour bar and colour schemes which now hold the normalisation and colour map instances.

Location:
qesdi/geoplot/trunk/lib/geoplot
Files:
6 added
18 edited

Legend:

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

    r5835 r5876  
    22import math 
    33import logging 
    4 import numpy 
    54 
    65from matplotlib.colors import Normalize, ListedColormap 
     
    98from matplotlib.figure import Figure 
    109from matplotlib.colorbar import ColorbarBase 
     10from matplotlib.patches import Rectangle 
    1111import matplotlib.cm as cm 
    12 import operator 
    13 import time 
    14  
    15  
    16 from geoplot.fixed_boundary_norm import FixedBoundaryNorm 
    1712import geoplot.config as geoplot_config 
    18 import geoplot.utils 
     13import geoplot 
    1914 
    2015 
     
    2924class ColourBar(object): 
    3025 
    31     def __init__(self, colourBarLabel="",colourBarPosition='horizontal',  
    32                        cmap=None, colourBarMin=None, colourBarMax=None, 
    33                        intervalColourbar=False, intervalNames=None, 
    34                        hideOutsideBounds=False): 
     26    def __init__(self, colourBarLabel="",colourBarPosition='horizontal', colourBarStyle='continuous'): 
    3527 
    3628        self._position = None 
    37         self._range = None 
    38         self._cmap = None 
    39  
    40         self.cmap = cmap 
     29 
    4130        self.colourBarLabel = colourBarLabel 
    4231        self.colourBarPosition = colourBarPosition 
    43         self.colourBarMin = colourBarMin 
    44         self.colourBarMax = colourBarMax 
    45         self.hideOutsideBounds = hideOutsideBounds 
    46         self.intervalColourbar = intervalColourbar 
    47         self.intervalNames = intervalNames 
     32        self.colourBarStyle = colourBarStyle 
    4833         
    4934        self.labelFont = config[FONTS_SECTION]['ColourBarLabel'] 
    5035 
    51     def draw(self, colourBarAxis, fontSize='medium', grid=None): 
     36    def draw(self, colourBarAxis, colourScheme, fontSize='medium'): 
    5237        """ 
    5338        Adds the colour bar to the (and optionally a label) to the figure. 
     
    6045        """ 
    6146        log.debug("drawing colour bar") 
     47         
     48        intervalColourbar = isinstance(colourScheme, geoplot.colour_scheme.IntervalColourScheme) 
     49         
     50        if self.colourBarStyle == 'legend' and intervalColourbar: 
     51            self._drawLegendColourBar(colourBarAxis, colourScheme, fontSize) 
     52        else: 
     53            self._drawContiunousColourBar(colourBarAxis, colourScheme, fontSize) 
     54                 
     55        log.debug("finished drawing colour bar") 
     56 
     57    def _drawContiunousColourBar(self, axes, colourScheme, fontSize): 
     58        intervalColourbar = isinstance(colourScheme, geoplot.colour_scheme.IntervalColourScheme) 
     59          
    6260        kwargs = {} 
    6361         
    64         kwargs['cmap'] = self.getColourMap(grid) 
    65         kwargs['norm'] = self.getNormalize(grid) 
     62        kwargs['cmap'] = colourScheme.colourMap 
     63        kwargs['norm'] = colourScheme.norm 
    6664         
    6765        kwargs['orientation'] = self.colourBarPosition 
    6866         
    69         if self.intervalColourbar: 
    70              
    71             cbMin, cbMax = self._getCbarMinMax() 
    72              
    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              
     67        if intervalColourbar: 
     68            kwargs['ticks'] = colourScheme.labelLocations 
     69            kwargs['format'] = matplotlib.ticker.FixedFormatter(colourScheme.labels) 
    8270            kwargs['spacing'] = 'proportional' 
    83              
    84             log.debug("kwargs['cmap'].N = %s" % (kwargs['cmap'].N,)) 
    85          
    86         cb = ColorbarBase(colourBarAxis, **kwargs) 
     71         
     72        cb = ColorbarBase(axes, **kwargs) 
    8773 
    8874        if cb.cmap.__class__ == ListedColormap \ 
    89            and not self.intervalColourbar: 
     75           and not intervalColourbar: 
    9076            ColourBar._repositionColourBarTicks(cb) 
    9177             
     
    9480            cb.set_label(self.colourBarLabel, fontdict=labelDictionary) 
    9581         
    96         log.debug("finished drawing colour bar") 
    97  
    98     def getColourMap(self, grid=None): 
    99          
    100         if self.cmap == None: 
    101             cmap = matplotlib.cm.get_cmap() 
    102             cmap.set_bad("w")         
    103          
    104         elif type(self.cmap) in [str, unicode]: 
    105             cmap = cm.get_cmap(self.cmap) 
    106             cmap.set_bad("w")      
     82        return cb 
     83     
     84    def _drawLegendColourBar(self, colourBarAxis, colourScheme, fontSize): 
     85        """ 
     86         
     87        """ 
     88         
     89        #to make a legend colour bar we need an interval colour scheme  
     90        assert isinstance(colourScheme, geoplot.colour_scheme.IntervalColourScheme) 
     91          
     92        kwargs = {} 
     93         
     94        cmap = colourScheme.colourMap 
     95        norm = colourScheme.norm 
     96         
     97        kwargs['orientation'] = self.colourBarPosition 
     98   
     99        handles = [Rectangle((0,0), 1, 1, fc=cmap(norm(i))) for i in colourScheme.labelLocations] 
     100        labels = colourScheme.labels 
     101         
     102        if self.colourBarPosition == 'horizontal': 
     103            if len(handles) < 3: 
     104                ncol = len(handles) 
     105            else: 
     106                ncol = 3 
    107107        else: 
    108             cmap = self.cmap 
    109      
    110         if self.intervalColourbar and  cmap.__class__ != ListedColormap: 
     108            ncol = 1 
     109 
     110        leg = colourBarAxis.legend(handles, labels, loc=10, mode='expand',  
     111                                   ncol=ncol, borderaxespad=0) 
     112         
     113        colourBarAxis.set_xticks([]) 
     114        colourBarAxis.set_yticks([]) 
     115         
     116        if self.colourBarLabel != None: 
     117            labelDictionary = self.labelFont.getDict(fontSize) 
    111118             
    112             cbMin, cbMax = self._getCbarMinMax() 
    113              
    114             oldCmap = cmap 
    115             uniqueVals = grid.getUniqueValues(cbMin, cbMax) 
    116             n = Normalize(uniqueVals[0], uniqueVals[-1]) 
    117             colours = [oldCmap(n(x)) for x in uniqueVals] 
    118             cmap = ListedColormap(colours) 
     119            if self.colourBarPosition == 'horizontal': 
     120                colourBarAxis.set_xlabel(self.colourBarLabel, fontdict=labelDictionary)      
     121            else: 
     122                colourBarAxis.set_ylabel(self.colourBarLabel, fontdict=labelDictionary) 
    119123                 
    120         if self.hideOutsideBounds: 
    121             log.debug("self.hideOutsideBounds = %s" % (self.hideOutsideBounds,)) 
    122             cmap.set_under('0.25', alpha=0.0) 
    123             cmap.set_over('0.75', alpha=0.0) 
    124              
    125         return cmap 
    126  
     124                         
     125         
     126        return leg 
     127         
    127128    @staticmethod 
    128129    def _repositionColourBarTicks(cb): 
     
    193194            cb.ax.xaxis.set_ticks_position('default') 
    194195     
    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 = 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): 
    223         cbMin = self.colourBarMin 
    224         cbMax = self.colourBarMax 
    225          
    226         if cbMin is not None and cbMax is not None and cbMin > cbMax: 
    227             log.warning("min(=%s) > max(=%s) reversing values" % (cbMin, cbMax)) 
    228             cbMax, cbMin = cbMin, cbMax 
    229              
    230         return cbMin, cbMax         
    231      
     196  
    232197    def __get_position(self): return self._position 
    233198 
     
    241206                    "colour bar position, 'horizontal' or 'vertical'") 
    242207 
    243     def __get_cmap(self):  
    244         if self._cmap == None: 
    245             cmap = cm.jet 
    246             cmap.set_bad('w') 
    247             self.cmap = cmap 
    248              
    249         return self.cmap 
    250      
    251     def __set_cmap(self, value): 
    252         self._cmap = value; 
    253208         
    254209 
     
    256211                      label=None,  
    257212                      cmap=cm.jet,  
    258                       cmapRange=(0,1),  
     213                      colourBarMin=None,  
     214                      colourBarMax=None,  
    259215                      orientation='horizontal', 
     216                      intervals=None, 
     217                      intervalNames=None, 
     218                      colourBarStyle='continuous', 
    260219                      dpi=100): 
    261220     
    262221    figsize=(width / float(dpi), height / float(dpi)) 
    263222    fig = Figure(figsize=figsize, dpi=dpi, facecolor='w') 
     223     
     224    #build a colour scheme 
     225     
     226    schemeBuilder = geoplot.colour_scheme.ColourSchemeBuilder(cmap=cmap,  
     227                 colourBarMin=colourBarMin,  
     228                 colourBarMax=colourBarMax,  
     229                 intervals=intervals, 
     230                 intervalNames=intervalNames) 
     231     
     232    colourScheme = schemeBuilder.buildScheme()     
    264233     
    265234    #for agg bakcend 
     
    269238     
    270239    #for cairo backend 
    271     x = 50.0 
    272     cbMin = 0.6 
    273      
     240    if colourBarStyle == 'legend': 
     241        x = 40.0 
     242        cbMin = 0.6 
     243    else: 
     244        x = 70.0 
     245        cbMin = 0.6 
    274246    cbBottom = x/height 
    275247     
     
    283255    axes = fig.add_axes([0.05, cbBottom, 0.9, cbHeight], frameon=False) 
    284256     
    285     log.debug("cbBottom = %s, cbHeight = %s" % (cbBottom, cbHeight,)) 
    286      
    287     if cmapRange[0] > cmapRange[1]: 
    288         log.warning("cmapRange[0] > cmapRange[1], swapping values") 
    289         cmapRange = (cmapRange[1], cmapRange[0]) 
    290      
    291257    cb = ColourBar(colourBarLabel=label,  
    292                    colourBarPosition=orientation,  
    293                    cmap=cmap,  
    294                    colourBarMin=cmapRange[0],  
    295                    colourBarMax=cmapRange[1] ) 
    296      
    297     cb.draw(axes)     
     258                   colourBarPosition=orientation, 
     259                   colourBarStyle=colourBarStyle) 
     260     
     261    cb.draw(axes, colourScheme)     
    298262     
    299263    return geoplot.utils.figureToImage(fig) 
    300  
    301 def 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

    r5753 r5876  
    33renderer=cairo 
    44 
     5[Defaults:ColourBar] 
     6colourBarLabel = None 
     7colourBarPosition = None 
    58 
    6 [Defaults:ColourBar] 
     9[Defaults:ColourSchemeBuilder] 
    710colourBarMin = None 
    811colourBarMax = None 
    912cmap = jet 
    10 colourBarLabel = None 
    11 colourBarPosition = None 
    12 intervalColourbar = False 
    1313intervalNames = None 
     14intervals = None 
    1415 
    1516[Defaults:MetadataBox] 
  • qesdi/geoplot/trunk/lib/geoplot/contour_plot.py

    r5699 r5876  
    1717        Creates the contour plot 
    1818        ''' 
    19          
    2019        self._contourDrawer = ContourDrawer(**self._getArgs(kwargs, ContourDrawer.__name__)) 
    2120                 
    2221        PlotBase.__init__(self, **kwargs) 
    2322         
    24     def _drawDiagram(self, map, grid, axes): 
     23    def _drawDiagram(self, map, grid, axes, colourScheme): 
    2524         
    26         log.debug("grid.values.min() = %s, grid.values.max() = %s" % (grid.values.min() , grid.values.max(),)) 
    27         norm = self._colourBar.getNormalize(grid=grid) 
    28         cmap = self._colourBar.getColourMap(grid=grid) 
    29          
    30         self._contourDrawer.draw(axes, grid, map.basemap, norm, cmap, self.fontSize) 
     25        self._contourDrawer.draw(axes, grid, map.basemap,  
     26                                 colourScheme.norm, colourScheme.colourMap,  
     27                                 self.fontSize) 
    3128     
  • qesdi/geoplot/trunk/lib/geoplot/fixed_boundary_norm.py

    r5699 r5876  
    2121         
    2222    def __call__(self,x, clip=None): 
    23         log.debug("x.shape = %s" % (x.shape,)) 
    2423         
    2524        if x.shape == (): 
  • qesdi/geoplot/trunk/lib/geoplot/grid.py

    r5835 r5876  
    2424    """ 
    2525 
    26     def __init__(self, boundsX, boundsY, midpointsX, midpointsY, values): 
     26    def __init__(self, boundsX, boundsY, midpointsX, midpointsY,  
     27                 values, maxValue, minValue): 
    2728        """ 
    2829        Constructs a new Grid object 
     
    3334        self.midpointsY = midpointsY 
    3435        self._values = values 
    35         self._uniqueValues = None 
     36        self._maxValue = maxValue 
     37        self._minValue = minValue 
    3638         
    3739    def transform(self, transfrom): 
     
    3941         
    4042        if transfrom == None: 
    41             return Grid(self.boundsX.copy(), self.boundsY.copy(), self.midpointsX.copy(), self.midpointsY.copy(), self.values.copy()) 
     43            return Grid(self.boundsX.copy(), self.boundsY.copy(), self.midpointsX.copy(), 
     44                        self.midpointsY.copy(), self.values.copy(), 
     45                        self._maxValue, self._minValue) 
    4246         
    4347        else: 
     
    4751            return Grid(transformedBoundsX, transfromedBoundsY, 
    4852                        transformedMidpointsX, transformedMidpointsY, 
    49                         self.values.copy()) 
     53                        self.values.copy(), self._maxValue, self.minValue) 
    5054     
    51     def getUniqueValues(self, minVal=None, maxVal=None): 
    52         """ 
    53         Returns a sorted numpy array of the unique non-masked values found in the 
    54         .values array. If minVal and maxVal are both specified then only the unique 
    55         values between these bounds (inclusive) will be returned. 
    56         """ 
    57          
    58         if self._uniqueValues is None: 
    59             st = time.time() 
    60             self._uniqueValues = N.unique(self.values) 
    61             log.debug(" unique sorted list in %s" % (time.time() - st,)) 
    62          
    63         if minVal != None and maxVal != None: 
    64             uniqueVals = filter(lambda x: minVal <= x <= maxVal, self._uniqueValues) 
    65             return N.array(uniqueVals) 
    66         else: 
    67             return self._uniqueValues 
    68              
    69          
     55    def getMaxValue(self): 
     56        return self._maxValue 
    7057     
    71     def getUniqueValueBounds(self, minVal=None, maxVal=None): 
    72         """ 
    73         Returns an array of bounds for the unique values found in the .values array. 
    74         The first and last bounds are interpolated using the first two and 
    75         the last two data points but the rest of the bounds are calculated. 
    76         """ 
    77         return utils.getBounds(self.getUniqueValues(minVal, maxVal)) 
     58    def getMinValue(self): 
     59        return self._minValue 
    7860     
    7961    def __get_values(self): 
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_base.py

    r5826 r5876  
    1111#python modules 
    1212import logging 
     13import time 
    1314 
    1415#third party modules 
     
    6768#        log.debug("self.cdmsVar.shape = %s" % (self.cdmsVar.shape,)) 
    6869 
    69         xmid, ymid = self._buildGridMidpoints(self.cdmsVar) 
     70         
     71#        xmid, ymid = self._buildGridMidpoints(self.cdmsVar) 
    7072         
    7173#        log.debug("y midpoints min =[" + str(ymid.min()) + \ 
     
    7375#        log.debug("x midpoints min =[" + str(xmid.min()) + \ 
    7476#                "] max =[" + str(xmid.max()) + "]") 
    75 #         
     77 
     78        st = time.time() 
    7679        reducedVar = self._getResizedVar(xLimits, yLimits) 
    77          
    78              
     80        log.debug("Reduced variable in %ss" % (time.time() - st,)) 
     81         
     82        st = time.time()     
    7983        (gridBoundsX, gridBoundsY) = self._buildGridBounds(reducedVar) 
     84        log.debug("built bounds in %ss" % (time.time() - st,)) 
     85         
     86        st = time.time()     
    8087        (gridMidpointX, gridMidpointY) = self._buildGridMidpoints(reducedVar) 
    81  
     88        log.debug("built midpoints in %ss" % (time.time() - st,)) 
     89         
     90        st = time.time()     
    8291        gridValues = self._buildGridValues(reducedVar) 
     92        log.debug("built values in %ss" % (time.time() - st,)) 
     93         
    8394                 
    8495#        log.debug("After resize:") 
     
    97108#        log.debug("gridBoundsX.shape = %s" % (gridBoundsX.shape,)) 
    98109 
    99         return Grid(gridBoundsX, gridBoundsY, gridMidpointX, gridMidpointY, gridValues) 
     110        return Grid(gridBoundsX, gridBoundsY, gridMidpointX, gridMidpointY, gridValues, 
     111                    self.cdmsVar[:].max(), self.cdmsVar[:].min()) 
    100112 
    101113    def _getResizedVar(self, xLimits, yLimits): 
     
    324336 
    325337        if not self.__class__._areAxisInOrderYX(cdmsVar): 
     338            log.warning("axis are in order y,x. Swapping them.") 
    326339            data = data.swapaxes(0,1) 
    327340                  
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_lat_lon.py

    r5826 r5876  
    101101        """ 
    102102 
     103        import time 
     104        st = time.time() 
    103105        lon = cdmsVar.getLongitude() 
    104106        lat = cdmsVar.getLatitude() 
    105107         
     108        log.debug("lat/lon in = %s" % (time.time() - st ,)) 
     109         
     110        st = time.time() 
    106111        latBoundsMerged = GridBuilderBase._getBoundsFromAxis(lat) 
    107         lonBoundsMerged = GridBuilderBase._getBoundsFromAxis(lon)  
    108  
     112        lonBoundsMerged = GridBuilderBase._getBoundsFromAxis(lon) 
     113         
     114        log.debug("lat/lon bounds merged in = %s" % (time.time() - st ,))  
     115 
     116        st = time.time() 
    109117        gridBoundsX, gridBoundsY = N.meshgrid(lonBoundsMerged, latBoundsMerged,) 
     118        log.debug("meshed grid in = %s" % (time.time() - st ,)) 
    110119         
    111120        return (gridBoundsX, gridBoundsY) 
  • qesdi/geoplot/trunk/lib/geoplot/grid_drawer.py

    r5826 r5876  
    3939    def __init__(self, drawValues=False, drawValuesFile=False,  
    4040                 valueFormat="%.2f", showGridLines=False, 
    41                  outline=False, forcePcolor=False): 
     41                 outline=False): 
    4242        """ 
    4343        Constructs a GridDrawer object               
     
    4848        self.showGridLines = showGridLines 
    4949        self.outline = outline 
    50         self.forcePcolor = forcePcolor 
    5150 
    5251    def draw(self, axes, grid, limits=None, basemap=None, norm=None, 
    53              cmap=None, fontSize='medium' ): 
     52             cmap=None, fontSize='medium', assumeBoundsParallel=None): 
    5453        """ 
    5554        Draws the grid given on the axis. 
     
    7776        # is no data in the limits there is no point drawing anything. 
    7877        # can only check the grid is in the limits if they are provided 
    79         if limits != None: 
     78        if limits != (None, None): 
    8079            if not self._isGridDataWithinLimits(grid, xLimits, yLimits): 
    8180                return 
     
    8382        grid_mapUnits = grid.transform(basemap) 
    8483 
    85         self._drawGridBoxes(axes, grid_mapUnits, basemap, cmap, norm) 
     84        self._drawGridBoxes(axes, grid_mapUnits, basemap, cmap, norm, 
     85                            assumeBoundsParallel) 
    8686         
    8787#        log.debug("self.drawValues = %s" % (self.drawValues,)) 
     
    107107            return basemap(limits[0], limits[1]) 
    108108 
    109     def _drawGridBoxes(self, axes,  grid_mapUnits, basemap, cmap, norm): 
     109    def _drawGridBoxes(self, axes,  grid_mapUnits, basemap, cmap, norm, 
     110                       assumeBoundsParallel): 
    110111        """ 
    111112        Draws the grid boxes onto the axes. 
    112113        """ 
     114         
    113115         
    114116        gridColour = 'k' 
     
    135137        #check the values aren't all masked 
    136138         
     139         
    137140        # Its possible that this test becomes time consuming for large arrays,  
    138141        # it is pssible that using sum might be faster, but this will only work 
     
    143146        # for now this is so quick it doesn't matter. 
    144147        valuesFound = not reduce(operator.and_, grid_mapUnits.values.mask.flat) 
     148 
    145149 
    146150        #if all the values are masked make sure the outline is drawn 
     
    154158        if valuesFound == True: 
    155159            
    156             st = time.time() 
    157              
    158              
    159160            log.debug("grid_mapUnits: boundsX.shape = %s, boundsY.shape = %s, values.shape = %s"  
    160161                      % (grid_mapUnits.boundsX.shape, grid_mapUnits.boundsY.shape, grid_mapUnits.values.shape)) 
     
    178179                raise Exception(message) 
    179180                                
    180  
    181  
     181            if assumeBoundsParallel == True: 
     182                useImshow = True 
     183            elif assumeBoundsParallel == False: 
     184                useImshow = False 
     185            else: 
     186                useImshow = self._areBoundsParralel(grid_mapUnits.boundsX, grid_mapUnits.boundsY) 
     187             
    182188            #if the bounds are parralel then use imshow, otherwise stick with pcolormesh 
    183             if self.forcePcolor == False and \ 
    184                self._areBoundsParralel(grid_mapUnits.boundsX, grid_mapUnits.boundsY): 
     189            if useImshow: 
    185190                 
    186191                self._drawImshow(axes,  
     
    189194                                 values,  
    190195                                 kwargs) 
    191                 log.debug("drawn imshow in %s" % (time.time() - st ,)) 
    192196                 
    193197            else: 
     
    198202                                     kwargs) 
    199203                 
    200                 log.debug("drawn pcolormesh in %s" % (time.time() - st ,)) 
    201204             
    202205             
     
    216219        The kwargs dictionary is passed to the imshow method. 
    217220        """ 
     221        st1 = time.time() 
     222         
    218223        yStart = Y[0,0] 
    219224        yEnd = Y[-1,-1] 
    220225         
    221         log.debug("yStart = %s, yEnd = %s" % (yStart, yEnd)) 
     226        #log.debug("yStart = %s, yEnd = %s" % (yStart, yEnd)) 
    222227         
    223228        if yStart < yEnd: 
     
    232237        #kwargs['origin'] = 'lower' 
    233238         
    234         log.debug("extent = %s" % (extent,)) 
     239        log.debug("got extent = %s yStart = %s yEnd = %s" % (extent, yStart, yEnd,)) 
    235240         
    236241        im = axes.imshow(Z, extent=extent, 
     
    273278 
    274279        yEq = equal 
     280         
    275281        log.debug("xEq = %s, yEq = %s worked out in = %s" % (xEq, yEq, time.time() - st,)) 
    276282         
     
    443449        yRange = (grid.boundsY.min(), grid.boundsY.max()) 
    444450         
    445         log.debug("xRange = %s" % (xRange,)) 
    446         log.debug("yRange = %s" % (yRange,)) 
     451        #log.debug("xRange = %s" % (xRange,)) 
     452        #log.debug("yRange = %s" % (yRange,)) 
    447453         
    448454        isInLimits = geoplot_utils.isRangeInLimits(xRange, xLimits) and \ 
  • qesdi/geoplot/trunk/lib/geoplot/grid_plot.py

    r5710 r5876  
    5050    __init__.doc = _construtorDocString 
    5151         
    52     def _drawDiagram(self, map, grid, axes): 
     52    def _drawDiagram(self, map, grid, axes, colourScheme): 
    5353        """ 
    5454        Uses the self._gridDrawer object to draw the grid onto the axis given,  
    5555        using the projection described by map.basemap. 
    5656        """ 
    57          
    58         log.debug("grid.values.min() = %s" % (grid.values.min(),)) 
    59         log.debug("grid.values.max() = %s" % (grid.values.max(),)) 
    60          
    61         norm = self._colourBar.getNormalize(grid=grid) 
    62         cmap = self._colourBar.getColourMap(grid=grid) 
     57        log.debug("grid.values.min() = %s, grid.values.max() = %s" % (grid.values.min() , grid.values.max(),)) 
    6358         
    6459        self._gridDrawer.draw(axes, grid, limits=(self.xLimits, self.yLimits), 
    6560                              basemap=map.basemap,  
    66                               norm=norm, cmap=cmap,  
     61                              norm=colourScheme.norm, cmap=colourScheme.colourMap,  
    6762                              fontSize=self.fontSize) 
    6863 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer.py

    r5826 r5876  
    1515from geoplot.grid_factory import GridFactory 
    1616from geoplot.map_factory import MapFactory 
    17  
     17from geoplot.colour_scheme import ColourSchemeBuilder 
     18import matplotlib 
    1819 
    1920 
     
    3334                 resolution=None, 
    3435                 cmap=None,  
    35                  cmapRange=(None,None),  
    36                  intervalColourbar=False,  
    37                  bgcolour='white', 
    38                  intervalNames=None): 
    39          
    40         self._cb = ColourBar() 
     36                 colourBarMin=None, 
     37                 colourBarMax=None,  
     38                 intervals=None,  
     39                 bgcolour='white'): 
     40         
     41         
     42        self._csBuilder = ColourSchemeBuilder() 
     43        self._bgcolour = 'white' 
     44         
    4145        self.transparent = transparent 
    4246        self.cmap = cmap 
    43         self._bgcolour = 'white' 
    4447        self.bgcolour = bgcolour 
    45          
    46         log.debug("cmapRange = %s" % (cmapRange,)) 
    47          
    48         if cmapRange[0] is not None and cmapRange[1] is not None and \ 
    49             cmapRange[0] > cmapRange[1]: 
    50             log.warning("cmapRange[0] > cmapRange[1], swapping values") 
    51             cmapRange = (cmapRange[1], cmapRange[0])              
    52          
    53         self.cmapRange = cmapRange 
    54         self.intervalColourbar = intervalColourbar 
    55         self.intervalNames = intervalNames 
    5648         
    5749        self._gridFactory = GridFactory(dataType=gridType) 
    5850        self._mapFactory = MapFactory(projection, drawCoast=True, drawRivers=False, resolution=resolution) 
    5951         
     52        self.colourBarMin = colourBarMin 
     53        self.colourBarMax = colourBarMax 
     54        self.intervals = intervals 
     55         
    6056    def makeImage(self, xLimits=None, yLimits=None, width=800, height=600, dpi=200): 
    6157        """ 
     
    6359        """ 
    6460        st = time.time() 
     61 
    6562        fig = self._getFigure(width, height, dpi) 
    66          
     63        figTime = time.time()  
     64 
    6765        axes = self._addAxes(fig) 
    68          
     66        axTime = time.time()  
     67 
    6968        self._drawToAxes(axes, xLimits, yLimits) 
     69        drawAxTime = time.time()  
    7070         
    7171        self._resetAxes(axes, xLimits, yLimits) 
     72        resetTime = time.time()  
    7273         
    7374        im = geoplot_utils.figureToImage(fig) 
    74          
    75         log.debug("drawn layer in %s" % (time.time() -st ,)) 
     75        figToImTime = time.time()  
     76         
     77        log.debug("drawn layer in %.4fs : fig=%.2f ax=%.2f draw=%.2f res=%.2f im=%.2f" %  
     78                  (time.time() -st , figTime - st, axTime - figTime, drawAxTime - axTime, resetTime - drawAxTime, figToImTime - resetTime)) 
    7679         
    7780        return im 
     
    106109        then the Figure's frameon should be set to true not the axis. 
    107110        """ 
    108         axes = figure.add_axes([0.0, 0.0, 1.0, 1.0],  
    109                                xticks=[], yticks=[], frameon=False) 
     111         
     112        axes = matplotlib.axes.Axes(figure, [0.0, 0.0, 1.0, 1.0],  
     113                                    xticks=[], yticks=[], frameon=False) 
     114         
     115        figure.add_axes(axes) 
     116         
     117        #axes = figure.add_axes([0.0, 0.0, 1.0, 1.0],  
     118        #                       xticks=[], yticks=[], frameon=False) 
    110119         
    111120        if self.transparent: 
    112121            axes.set_alpha(0.0) 
    113122            axes.patch.set_alpha(0.0) 
     123             
    114124         
    115125        return axes 
     
    229239 
    230240    def __set_cmap(self, value): 
    231         self._cb.cmap = value 
     241        self._csBuilder.cmap = value 
    232242         
    233243    def __get_cmap(self): 
    234         return self._cb.cmap  
     244        return self._csBuilder.cmap  
    235245     
    236246    cmap = property(__get_cmap, __set_cmap) 
    237      
    238     def __set_cmapRange(self, value): 
    239         self._cb.colourBarMin = value[0] 
    240         self._cb.colourBarMax = value[1] 
    241          
    242     def __get_cmapRange(self): 
    243         return (self._cb.colourBarMin, self._cb.colourBarMax) 
    244      
    245     cmapRange = property(__get_cmapRange, __set_cmapRange) 
    246      
    247     def __set_intervalColourbar(self, value): 
    248         self._cb.intervalColourbar = value 
    249          
    250     def __get_intervalColourbar(self): 
    251         return self._cb.intervalColourbar  
    252      
    253     intervalColourbar = property(__get_intervalColourbar, __set_intervalColourbar)     
    254      
    255     def __set_intervalNames(self, value): 
    256         self._cb.intervalNames = value 
    257          
    258     def __get_intervalNames(self): 
    259         return self._cb.intervalNames  
    260      
    261     intervalNames = property(__get_intervalNames, __set_intervalNames) 
    262      
    263      
     247 
     248 
     249    def __set_intervals(self, value): 
     250        self._csBuilder.intervals = value 
     251     
     252    def __get_intervals(self): 
     253        return self._csBuilder.intervals 
     254     
     255    intervals = property(__get_intervals, __set_intervals) 
     256     
     257    def __set_colourBarMin(self, value): 
     258        self._csBuilder.colourBarMin = value 
     259     
     260    def __get_colourBarMin(self): 
     261        return self._csBuilder.colourBarMin 
     262     
     263    colourBarMin = property(__get_colourBarMin, __set_colourBarMin) 
     264     
     265    def __set_colourBarMax(self, value): 
     266        self._csBuilder.colourBarMax = value 
     267     
     268    def __get_colourBarMax(self): 
     269        return self._csBuilder.colourBarMax 
     270 
     271    colourBarMax = property(__get_colourBarMax, __set_colourBarMax) 
     272         
    264273    def __set_bgcolour(self, value): 
    265274         
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_contour.py

    r5760 r5876  
    1313    "Draw only the layer section of the plot" 
    1414     
    15     def __init__(self, cdmsVar, gridType='latlon', projection='latlon', cmap = None,  cmapRange=(None,None), 
    16                  transparent=False, numLines=10, fontSize='medium', labelInterval=1,  
    17                  bgcolour='white', 
    18                  intervalColourbar=False, intervalNames=None, lineWidth=0.5): 
     15    def __init__(self, cdmsVar,  numLines=10, fontSize='medium', labelInterval=1,  
     16                 lineWidth=0.5, **kwargs): 
    1917         
    2018        self._contourDrawer = ContourDrawer() 
     
    2523        self.lineWidth = lineWidth 
    2624         
    27         LayerDrawerBase.__init__(self, gridType=gridType, transparent=transparent, cmap=cmap, cmapRange=cmapRange) 
     25        LayerDrawerBase.__init__(self, **kwargs) 
    2826         
    2927    def _drawToAxes(self, axes, xLimits, yLimits): 
     
    3432        grid = self._buildGrid(self.cdmsVar, xLimits, yLimits) 
    3533         
     34        scheme = self._csBuilder.buildScheme(grid) 
     35         
    3636        #if the projection is 'latlon' then no transformation is needed. 
    3737        if self.projection == 'latlon': 
     
    4141            basemap = map.basemap         
    4242         
    43         norm = self._cb.getNormalize(grid=grid) 
    44         cmap = self._cb.getColourMap(grid=grid) 
     43         
     44        cmap = scheme.colourMap 
    4545         
    4646        #set the bad colour to transparent 
    4747        cmap.set_bad('w', 0.0) 
    4848         
    49         self._contourDrawer.draw(axes, grid, normalize=norm, cmap=cmap, 
     49        self._contourDrawer.draw(axes, grid, normalize=scheme.norm, cmap=cmap, 
    5050                                 basemap=basemap, fontSize=self.fontSize) 
    5151     
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid.py

    r5826 r5876  
    44 
    55import logging 
     6import time 
    67 
    78import geoplot.utils as geoplot_utils 
     
    1415    "Draw only the layer section of the plot" 
    1516     
    16     def __init__(self, cdmsVar, gridType='latlon', showGridLines=False, cmap=None, cmapRange=(None,None), outline=False, 
    17                  transparent=False,  
    18                  intervalColourbar=False,  
    19                  bgcolour='white', 
    20                  intervalNames=None): 
     17    def __init__(self, cdmsVar, showGridLines=False, outline=False, **kwargs): 
    2118         
    2219        self._gridDrawer = GridDrawer() 
     
    2623        self.outline = outline 
    2724         
    28         LayerDrawerBase.__init__(self, gridType=gridType, transparent=transparent, cmap=cmap, cmapRange=cmapRange, bgcolour=bgcolour) 
     25        LayerDrawerBase.__init__(self, **kwargs) 
    2926         
    3027    def _drawToAxes(self, axes, xLimits, yLimits): 
     
    4441         
    4542#        map = self._getMap(xLimits, yLimits) 
    46 #        map.basemap.drawcoastlines(ax=axes, xLimits=xLimits, yLimits=yLimits)      
    47          
    48         norm = self._cb.getNormalize(grid=grid) 
    49         cmap = self._cb.getColourMap(grid=grid) 
     43#        map.basemap.drawcoastlines(ax=axes, xLimits=xLimits, yLimits=yLimits) 
    5044 
     45        scheme = self._csBuilder.buildScheme(grid) 
     46        cmap = scheme.colourMap 
    5147        #set the bad colour to transparent 
    5248        cmap.set_bad('w', 0.0) 
     
    5652                              basemap=basemap,  
    5753                              limits=(xLimits, yLimits), 
    58                               norm=norm, 
     54                              norm=scheme.norm, 
    5955                              cmap=cmap) 
    60                                
     56         
    6157     
    6258    ### properties ### 
  • qesdi/geoplot/trunk/lib/geoplot/plot_base.py

    r5699 r5876  
    77from geoplot.plot_writer import PlotWriter 
    88from geoplot.metadata_box import MetadataBox 
     9from geoplot.colour_scheme import ColourSchemeBuilder 
    910 
    1011from geoplot.config import getConfig 
     
    8586        self.units = kwargs.pop('units', None) 
    8687         
     88        self._schemeBuilder = ColourSchemeBuilder(**self._getArgs(kwargs, ColourSchemeBuilder.__name__)) 
     89         
    8790        self._colourBar   = ColourBar  (**self._getArgs(kwargs, ColourBar.__name__)) 
    8891         
     
    142145        grid = self._gridFactory.getGrid(self.xLimits, self.yLimits) 
    143146         
    144         self._drawDiagram(map, grid, self._plotArea.axes) 
    145  
     147        colourScheme = self._schemeBuilder.buildScheme(grid) 
     148         
     149        self._drawDiagram(map, grid, self._plotArea.axes, colourScheme) 
     150         
    146151        #the map has to be drawn after the grid, otherwise it distorts the axis 
    147152        map.drawMap(self._plotArea.axes) 
     
    151156 
    152157        if self.drawColourBar: 
    153             self._colourBar.draw(self._plotArea.cbAxes, self.fontSize,  
    154                                  grid=grid) 
     158            self._colourBar.draw(self._plotArea.cbAxes, colourScheme, self.fontSize) 
    155159 
    156160    def drawToImage(self): 
  • qesdi/geoplot/trunk/lib/geoplot/plot_writer.py

    r5710 r5876  
    6262 
    6363        log.info("Writing File :" + filename) 
    64  
     64        log.debug("self.format = %s" % (self.format,)) 
    6565        if self.format in ['png', 'jpg']: 
    6666            initialFormat = 'png' 
    6767        elif self.format in ['ps', 'pdf']: 
    6868            initialFormat = 'ps' 
     69        elif self.format in ['svg']: 
     70            initialFormat = self.format 
    6971        else: 
    7072            raise Exception("Unknown format %s" % (self.format,)) 
     
    7577            initialFileName = filename 
    7678 
     79        log.debug("initialFormat = %s" % (initialFormat,)) 
    7780 
    7881 
     
    8083                self._addLogo(figure, logoAx) 
    8184 
    82         self._printFigure(initialFileName, figure) 
     85        self._printFigure(initialFileName, figure, initialFormat) 
    8386         
    8487        #convert to cmyk (if postscript) 
     
    233236        return buffer       
    234237 
    235     def _printFigure(self, filename, figure): 
     238    def _printFigure(self, filename, figure, format=None): 
    236239        """ 
    237240        Instantiate a canvas class and call its print_figure method. 
     
    246249        """ 
    247250 
    248         if self.format == 'ps': 
     251        if format == None: 
     252            format = self.format 
     253         
     254        if format == 'ps': 
    249255            CanvasClass=FigureCanvasPS 
    250         elif self.format == 'png': 
     256        elif format == 'png': 
    251257            CanvasClass=FigureCanvasAgg 
    252         elif self.format == 'pdf': 
     258        elif format == 'pdf': 
    253259            CanvasClass=FigureCanvasPdf 
    254         elif self.format == 'svg': 
     260        elif format == 'svg': 
    255261            CanvasClass = FigureCanvasSVG 
    256262        else: 
  • qesdi/geoplot/trunk/lib/geoplot/plotarea.py

    r5710 r5876  
    2222 
    2323OUTLINE_LOGO_REGION = False 
    24 OUTLINE_COLOUR_BAR_REGION = True 
     24OUTLINE_COLOUR_BAR_REGION = False 
    2525OUTLINE_METADATA_REGION = False 
    2626OUTLINE_PLOT = False 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_grid_plot.py

    r5699 r5876  
    22import logging 
    33 
     4import geoplot 
    45from geoplot.tests.make_data_functions import fnSinXAddCosY_10to10 
    56 
     
    3940 
    4041    #var = makeLLVar(lonBounds=xLimits, latBounds=yLimits, nx=20, ny=20) 
     42    from geoplot.legend_colour_bar import LegendColourBar 
     43    geoplot.plot_base.ColourBar = LegendColourBar 
     44    LegendColourBar.__name__ = 'ColourBar' 
    4145     
    4246    var = makeLLVar(lonBounds=xLimits, latBounds=yLimits, nx=20, ny=20, function=fnSinXAddCosY_10to10, missing_value=-999) 
     
    4953                    drawColourBar = True, drawValues = True, 
    5054                    xLimits=xLimits, yLimits=yLimits, 
    51                     intervalColourbar=True, intervalNames=list('abcdefghijklmnopqrstu')) 
     55                    colourBarPosition='vertical', 
     56                    intervalColourbar=True, 
     57                     
     58                    intervals="-10,-7.5,-5,-2.5,0,2.5,5,7.5,10", 
     59                    #intervalNames=','.join(list('abcdefgh')) 
     60                     
     61                    #intervalNames=','.join(list('abcdefghijklmnopqrst')) 
     62                    ) 
    5263 
    5364    plot.drawMap(outputFile) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_grid_plot_rotated.py

    r5610 r5876  
    2121    testDataDir = pkg_resources.resource_filename('geoplot', 'tests/data') 
    2222     
    23 #    dataFile = testDataDir + '/rg_test.nc' 
    24 #    dataVariable = 'air_temperature' 
     23    dataFile = testDataDir + '/rg_test.nc' 
     24    dataVariable = 'air_temperature' 
    2525 
    26     dataFile = testDataDir + '/rg_test3.nc' 
    27     dataVariable = 'temp' 
     26#    dataFile = testDataDir + '/rg_test3.nc' 
     27#    dataVariable = 'temp' 
    2828 
    2929#    dataFile = testDataDir +'/grid_box_25km_subset.nc' 
     
    4141    var = f(dataVariable, squeeze=1) 
    4242    rotated_pole_var = f['rotated_pole'] 
     43 
    4344     
    44 #    from geoplot.tests.make_rotated_grid_data import makeRotatedGridVar 
    45 #    var, rotated_pole_var = makeRotatedGridVar() 
     45     
     46    from geoplot.tests.make_rotated_grid_data import makeRotatedGridVar 
     47    var, rotated_pole_var = makeRotatedGridVar() 
    4648 
    4749    eg_metadata_list = [("Dataset", "MOHC Probabilistic Land"), 
  • qesdi/geoplot/trunk/lib/geoplot/utils.py

    r5760 r5876  
    6666 
    6767def figureToImage(fig): 
    68     st = time.time() 
    69      
    70     log.debug("started converting figure to image") 
     68    #st = time.time() 
     69     
    7170    canvas = FigureCanvas(fig) 
    72      
    73 #    canvas.print_figure('/tmp/tmp.png') 
    74      
    75      
     71         
    7672    # a shortcut with the agg backend 
    7773#    canvas.draw() 
     
    8884    im = Image.open(buffer) 
    8985     
    90 #    canvas.print_figure('/tmp/tmp.png', dpi=fig.get_dpi(), facecolor=fig.get_facecolor(), edgecolor=fig.get_edgecolor()) 
    91 #    fin = open(file,'rb') 
    92 #    im = Image.open(fin) 
    93      
    94     log.debug("converted figure to image in %s" % (time.time() - st,)) 
     86    #log.debug("converted figure to image in %s" % (time.time() - st,)) 
    9587     
    9688    return im 
     
    9890def round_to_n(arr, n): 
    9991    
    100      
    101     c = numpy.log10(arr) 
    102     log.debug("c = %s" % (c,)) 
     92    a = abs(arr) 
     93    c = numpy.log10(a) 
    10394     
    10495    if c.__class__ == numpy.ndarray: 
     
    10798        if numpy.isinf(c) : 
    10899            c = 0.0 
    109     log.debug("c = %s" % (c,))         
    110100    c = numpy.power(10,numpy.floor(c)) 
    111     log.debug("c = %s" % (c,)) 
    112101    res = (arr/c).round(n-1) * c 
    113     log.debug("res = %s" % (res,)) 
    114      
     102 
     103    #log.debug("arr = %s, a = %s, n=%s, c=%s, res = %s" % (arr, a, n, c, res,)) 
     104 
    115105    return res 
    116106 
     
    186176    assert len(arr.shape) == 1 
    187177     
     178    if len(arr) == 1: 
     179        return numpy.array([arr[0]/2.0, arr[0] * 2.0]) 
     180     
    188181    #guess the first and the last bounds  
    189182    start = arr[0] - (arr[1]- arr[0])/2.0   
     
    203196    return arrC 
    204197     
    205      
    206      
    207      
     198def getMidpoints(bounds): 
     199    x = [(bounds[i] + bounds[i+1])/2.0 for i in range(len(bounds) -1)] 
     200    return  numpy.array(x)     
     201     
     202     
Note: See TracChangeset for help on using the changeset viewer.