Changeset 5605


Ignore:
Timestamp:
12/08/09 12:59:01 (10 years ago)
Author:
pnorton
Message:

First attempt at adding the contour plot. I've tried to re-use existing components where possible. There is still a lot of duplication between the contour plot base and plot base classes.

Location:
qesdi/geoplot/trunk/lib/geoplot
Files:
15 added
23 edited
1 moved

Legend:

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

    r5403 r5605  
    5858 
    5959""" 
     60 
     61 
     62 
  • qesdi/geoplot/trunk/lib/geoplot/colour_bar.py

    r5552 r5605  
    2525class ColourBar(object): 
    2626 
    27     def __init__(self, label, position, valueRange): 
     27    def __init__(self, colourBarLabel="",colourBarPosition='horizontal',  
     28                       cmap=None, colourBarMin=None, colourBarMax=None ): 
    2829 
    2930        self._position = None 
    3031        self._range = None 
    31  
    32         self.label = label 
    33         self.position = position 
    34         self.range = valueRange 
     32        self._cmap = None 
     33 
     34        self.cmap = cmap 
     35        self.colourBarLabel = colourBarLabel 
     36        self.colourBarPosition = colourBarPosition 
     37        self.colourBarMin = colourBarMin 
     38        self.colourBarMax = colourBarMax 
     39         
    3540        self.labelFont = config[FONTS_SECTION]['ColourBarLabel'] 
    3641 
    37     def draw(self, figure, colourBarAxis, sm, fontSize): 
     42    def draw(self, colourBarAxis, fontSize='medium', dataMin=None, dataMax=None): 
    3843        """ 
    3944        Adds the colour bar to the (and optionally a label) to the figure. 
     
    4550        @type units: string 
    4651        """ 
    47  
    48 #        log.debug("Drawing colour bar") 
    49  
    50         self._setLimits(sm) 
    51          
    52         cb = figure.colorbar(sm, cax = colourBarAxis, orientation=self.position) 
    53  
    54         log.debug("cb.cmap = %s" % (cb.cmap,)) 
     52         
     53        cmap = self.getColourMap() 
     54 
     55        norm = self.getNormalize(dataMin, dataMax) 
     56         
     57        cb = ColorbarBase(colourBarAxis, 
     58                          cmap=cmap,  
     59                          norm=norm,  
     60                          orientation=self.colourBarPosition) 
     61 
    5562        if cb.cmap.__class__ == matplotlib.colors.ListedColormap: 
    5663            ColourBar._repositionColourBarTicks(cb) 
    5764             
    58         if self.label != None: 
     65        if self.colourBarLabel != None: 
    5966            labelDictionary = self.labelFont.getDict(fontSize) 
    60             cb.set_label(self.label, fontdict=labelDictionary) 
    61  
    62         log.debug("tick position = %s" % (colourBarAxis.yaxis.get_ticks_position(),)) 
    63  
    64     def _setLimits(self, sm): 
    65         """ 
    66         Changes the limits of the given scalar mesh to the limits specified in 
    67         the constructor. 
    68  
    69         First checks if the min/max value is not None before using it to set the 
    70         value on the scalar mesh. If the min/max value is None then the mesh 
    71         limit is not changed. 
    72  
    73         @param sm: the scalar mappable generated by applying the grid to the axis 
    74         @type sm: an instance of matplotlib.cm.ScalarMappable 
    75         """ 
    76  
    77 #        log.debug("setting limits, colourbar range is:" + str(self.range)) 
    78  
    79         log.debug("Setting limits") 
    80          
    81         (dataMin, dataMax) = sm.get_clim() 
    82         (minVal, maxVal) = self.range 
    83  
    84         if minVal != None and maxVal != None: 
    85             sm.set_clim(minVal, maxVal) 
    86  
    87         elif minVal != None: 
    88             sm.set_clim(minVal, dataMax) 
    89  
    90         elif maxVal != None: 
    91             sm.set_clim(dataMin, maxVal) 
     67            cb.set_label(self.colourBarLabel, fontdict=labelDictionary) 
     68 
     69    def getColourMap(self): 
     70         
     71        if self.cmap == None: 
     72            cmap = matplotlib.cm.get_cmap() 
     73            cmap.set_bad("w")         
     74         
     75        elif type(self.cmap) == str: 
     76            cmap = cm.get_cmap(self.cmap) 
     77            cmap.set_bad("w")      
     78        else: 
     79            cmap = self.cmap 
     80             
     81        return cmap 
    9282 
    9383    @staticmethod 
     
    158148            log.debug("Resetting xaxis ticks position to default") 
    159149            cb.ax.xaxis.set_ticks_position('default') 
    160              
    161     #properties code 
    162     def __get_range(self): 
    163         if self._range == None: 
    164             return (None, None) 
    165         else: 
    166             return self._range 
    167  
    168     def __set_range(self, value): 
    169  
    170         if value == None: 
    171             self._range = None 
    172         else: 
    173             #check the new value 
    174             if not (type(value) == list or type(value) == tuple): 
    175                 raise ValueError("Cant set range to a value of " + str(type(value))) 
    176  
    177             if type(value) == list: 
    178                 value == tuple(value) 
    179  
    180             if len(value) != 2: 
    181                 raise ValueError("Cant set range to a value of length " 
    182                                 + str(len(value)) + ", length should be 2.") 
    183  
    184             (minVal, maxVal) = value 
    185  
    186             if minVal != None and maxVal != None: 
    187                 #convert the values to floats     
    188                 minVal = float(minVal) 
    189                 maxVal = float(maxVal) 
    190                  
    191                 if minVal > maxVal: 
    192                     raise ValueError("Cant set range to have minimum > maximum, " + str(value)) 
    193                 elif minVal == maxVal: 
    194                     raise ValueError("Cant set range to have minimum == maximum, " + str(value)) 
    195  
    196             self._range = (minVal, maxVal) 
    197  
    198     range = property(__get_range, __set_range, None, "range of colour bar values (min, max)") 
    199  
     150     
     151    def getNormalize(self, dataMin=None, dataMax=None): 
     152         
     153        min, max = self.colourBarMin, self.colourBarMax 
     154         
     155        if min == None and dataMin != None: 
     156            min = dataMin 
     157        elif min == None: 
     158            min = 0 
     159             
     160        if max == None and dataMax != None: 
     161            max = dataMax 
     162        elif max == None: 
     163            max = 1 
     164         
     165        if min > max: 
     166            log.warning("min(=%s) > max(=%s) reversing values" % (min, max)) 
     167            max, min = min, max 
     168             
     169         
     170        return matplotlib.colors.Normalize(min,  max) 
     171     
     172     
     173     
    200174    def __get_position(self): return self._position 
    201175 
    202176    def __set_position(self, value): 
    203         if value not in ['horizontal', 'vertical']: 
     177        if value not in ['horizontal', 'vertical', None]: 
    204178            raise ValueError("ColourBar position value must be 'horizontal'" + \ 
    205179                             " or 'vertical, value recieved :" + str(value)) 
    206180        self._position = value 
    207181 
    208     position = property(__get_position, __set_position, None, 
     182    colourBarPosition = property(__get_position, __set_position, None, 
    209183                    "colour bar position, 'horizontal' or 'vertical'") 
    210184 
     185    def __get_cmap(self):  
     186        if self._cmap == None: 
     187            cmap = cm.jet 
     188            cmap.set_bad('w') 
     189            self.cmap = cmap 
     190             
     191        return self.cmap 
     192     
     193    def __set_cmap(self, value): 
     194        self._cmap == value; 
     195         
    211196 
    212197def getColourBarImage(width=600, height=100, 
     
    220205    fig = Figure(figsize=figsize, dpi=dpi, facecolor='w') 
    221206     
     207    #for agg bakcend 
    222208    #need about 40px at the bottom of the axes to draw the labels 
    223     x = 40.0 
    224      
    225     cbBottom = 40.0/height 
     209    #x = 40.0 
     210    #cbMin = 0.5 
     211     
     212    #for cairo backend 
     213    x = 50.0 
     214    cbMin = 0.6 
     215     
     216    cbBottom = x/height 
    226217     
    227218    if cbBottom < 0.1: 
    228219        cbBottom = 0.1 
    229220     
    230     if cbBottom > 0.5: 
    231         cbBottom = 0.5 
     221    if cbBottom > cbMin: 
     222        cbBottom = cbMin 
    232223         
    233224    cbHeight = 0.9 - cbBottom 
    234      
    235225    axes = fig.add_axes([0.05, cbBottom, 0.9, cbHeight], frameon=False) 
     226     
     227    log.debug("cbBottom = %s, cbHeight = %s" % (cbBottom, cbHeight,)) 
    236228     
    237229    if cmapRange[0] > cmapRange[1]: 
     
    243235     
    244236    if label != None: 
    245         cb.set_label(label) 
    246 #    axes.set_xticks([]) 
    247 #    axes.set_yticks([]) 
    248      
     237        cb.set_label(label, weight='normal') 
     238 
    249239    return geoplot.utils.figureToImage(fig) 
    250240     
    251      
    252      
    253 if __name__ == '__main__': 
    254  
    255  
    256  
    257     from cdms_utils.cdms_compat import N 
    258     import geoplot.utils 
    259     import geoplot.log_util 
    260     from matplotlib.backends.backend_agg import FigureCanvasAgg 
    261     from matplotlib.figure import Figure 
    262     import matplotlib 
    263  
    264     geoplot.log_util.setupGeoplotConsoleHandler(log) 
    265  
    266     cb = ColourBar("label", "vertical", None) 
    267  
    268     filename = "out.png" 
    269  
    270     xlim = 5 
    271     ylim = 7 
    272  
    273     x = range(0,xlim+1) 
    274     y = range(0,ylim+1) 
    275     X,Y = N.meshgrid(x,y) 
    276  
    277     X[1][1] = 2 
    278     X[1][2] = 3 
    279  
    280     Z=[[0]*xlim for i in range(ylim)] 
    281     for i in range(0 , xlim*ylim): 
    282         vX= i%xlim 
    283         vY= (i - i%xlim) / xlim 
    284         Z[vY][vX] = i 
    285  
    286     Z[0][1] = 0.0009 
    287     Z[6][1] = Z[6][2] = Z[6][3] = 30; 
    288     Z[6][4] = 38.545 
    289  
    290     c255 = [( 53, 192, 157), ( 25, 162, 151), ( 28, 126, 114), ( 18,  86,  98), 
    291             ( 30,  45,  78), ( 15,  68, 121), ( 61,  73, 182), ( 88,  96, 220), 
    292             (121, 126, 255), (153, 153, 255), (156, 182, 255), (156, 209, 255), 
    293             (156, 237, 255), (166, 255, 246), (196, 255, 217), (224, 255, 189), 
    294             (249, 255, 161), (255, 236, 153), (255, 207, 153), (255, 180, 153), 
    295             (255, 153, 153), (255, 121, 131), (240,  88, 104), (215,  78,  91), 
    296             (192,  66,  83), (167,  13,  61), (131,  13,  61), ( 98,   0,  48), 
    297             (121,  45, 116), (151,  83, 169)] 
    298  
    299     cmap = geoplot.utils.generateDiscreteCmap(c255, "temp") 
    300     cmap = matplotlib.cm.jet 
    301      
    302     fig = Figure() 
    303 #    axes = fig.add_axes([0.1, 0.2, 0.8, 0.7])     
    304 #    cbAxes = fig.add_axes([0.1,0.1,0.8,0.05]) 
    305      
    306     axes = fig.add_axes([0.1, 0.1, 0.6, 0.8]) 
    307     cbAxes = fig.add_axes([0.8, 0.1, 0.1, 0.8]) 
    308      
    309     sm = axes.pcolor(X,Y,Z,shading='faceted', cmap=cmap) 
    310     cb.draw(fig, cbAxes, sm, "medium") 
    311     canvas = FigureCanvasAgg(fig) 
    312     canvas.print_figure(filename) 
    313     print "Written:", filename 
  • qesdi/geoplot/trunk/lib/geoplot/config.ini

    r5530 r5605  
    11[Defaults] 
    22type=bool 
     3renderer=cairo 
    34 
    45[PlotBaseDefaults] 
     
    910drawValues=False 
    1011drawValuesFile=False 
    11 xLimits=-179 180  
    12 yLimits=-89 90 
    13 #xLimits=-11.0 2.8 
    14 #yLimits=49.0 60.0 
     12xLimits = (-179.0, 180.0)  
     13yLimits = ( -89.0,  90.0) 
     14#xLimits = ( -11.0,  2.8) 
     15#yLimits = (  49.0, 60.0) 
    1516dpi=100 
    1617valueFormat=%.2f 
     
    2526showGridLines=False 
    2627outputCMYK=False 
     28drawMetadata = True 
     29 
     30[Defaults:ColourBar] 
     31colourBarMin = None 
     32colourBarMax = None 
     33cmap = jet 
     34colourBarLabel = None 
     35colourBarPosition = None 
     36 
     37[Defaults:MetadataBox] 
     38metadataList = None 
     39 
     40[Defaults:MapFactory] 
     41projection = None 
     42xLimits = (-180, 180)  
     43yLimits = (-90, 90) 
     44drawCoast = True  
     45drawRivers = True 
     46addShapefile = False 
     47resolution = None 
     48 
     49[Defaults:PlotWriter] 
     50format = 'png' 
     51outputCMYK = False 
     52 
     53[Defaults:GridFactory] 
     54dataType = latlon 
     55cdmsVar = None 
     56 
     57[Defaults:PlotArea] 
     58width = 600  
     59height = 900 
     60dpi = 100 
     61fontSize = 'medium' 
     62plotTitle = '' 
     63drawColourBar=True 
     64drawLogo=True 
     65drawMetadata=True 
     66 
     67[Defaults:ContourDrawer] 
     68numContourLines=10 
     69contourLabelInterval=1 
    2770 
    2871[PlotProperties] 
    2972metadataBoxTitle=Plot Details: 
    30 metadataFrameColour=0.75 
     73metadataFrameColour='0.75' 
    3174 
    3275logoPath=/home/users/pnorton/svn/qesdi/geoplot_trunk/data/logo.png 
     
    3881[PlotRegions] 
    3982#  Top Left Height Width as proportions of the figure (1.0 = 100%) 
    40 metadataRegion=     0.25 0.85 0.7 0.13 
    41 logoRegion=         0.025 0.85 0.2 0.13 
     83metadataRegion=     (0.25 , 0.85, 0.7 ,0.13) 
     84logoRegion=         (0.025, 0.85, 0.2 ,0.13) 
    4285 
    43 plotRegionShort=    0.15 0.15 0.8 0.65 
    44 plotRegionThin=     0.15 0.1 0.6 0.7 
    45 plotRegionFull=     0.15 0.1 0.8 0.7 
    46 plotRegionAll =     0.15 0.1 0.7 0.9 
     86plotRegionShort=    (0.15 , 0.15, 0.8 ,0.65) 
     87plotRegionThin=     (0.15 , 0.1 , 0.6 ,0.7) 
     88plotRegionFull=     (0.15 , 0.1 , 0.8 ,0.7) 
     89plotRegionAll =     (0.15 , 0.1 , 0.7 ,0.9) 
    4790 
    48 cbHorizontalRegion= 0.15 0.1 0.8 0.025 
    49 cbVerticalRegion=   0.875 0.1 0.05 0.7 
     91cbHorizontalRegion= (0.15 , 0.1 , 0.8 , 0.025) 
     92cbVerticalRegion=   (0.875, 0.1 , 0.05, 0.7) 
    5093 
    5194[PlotFont:ColourBarLabel] 
    52 weight=regular 
     95weight=normal 
    5396family=sans-serif 
    5497sizeSmall=8 
     
    68111 
    69112[PlotFont:Metadata] 
    70 weight=regular 
     113weight=normal 
    71114family=sans-serif 
    72115sizeSmall=4 
     
    86129 
    87130[PlotFont:AxisTick] 
    88 weight=regular 
     131weight=normal 
    89132family=sans-serif 
    90133sizeSmall=6 
     
    97140# are not used 
    98141[PlotFont:ContourLines] 
    99 weight=regular 
     142weight=normal 
    100143family=sans-serif 
    101144sizeSmall=6 
  • qesdi/geoplot/trunk/lib/geoplot/config.py

    r5552 r5605  
    1414from geoplot.plot_font import PlotFont 
    1515 
     16from geoplot.simple_string_parsing import evalString 
    1617log = logging.getLogger(__name__) 
    1718 
    18 intPattern = re.compile('^\-?\d+$') 
    19 floatPattern = re.compile('^\-?\d+\.\d*$') 
    20 stringPattern = re.compile('^[\'"].*[\'"]$') 
    2119 
    2220configFile = pkg_resources.resource_filename('geoplot', 'config.ini') 
     
    2826 
    2927 
    30 conversionList = [(PlotFont, 'PlotFont:', 'Fonts'),] 
     28 
     29def defaultBuilder(**kwargs): 
     30    return kwargs 
     31 
     32 
     33conversionList = [(PlotFont, 'PlotFont:', 'Fonts'), 
     34                  (defaultBuilder, 'Defaults:', 'Defaults'),] 
    3135 
    3236exceptionsList = [("PlotProperties", "metadataFrameColour", str), 
     
    5559    confDict = {} 
    5660    for section in conf.sections(): 
     61#        log.debug("section = %s" % (section,)) 
    5762        sectionDict = {} 
    5863 
    5964        for item in conf.items(section): 
    60             sectionDict[item[0]] = _convertVal(item[1]) 
    61  
     65            sectionDict[item[0]] = evalString(item[1]) 
     66             
     67#        log.debug("sectionDict = %s" % (sectionDict,)) 
    6268        confDict[section] = sectionDict 
    6369 
    6470    #automatic object creation from config parameters 
    65      
    6671    for (targetClass, indicatorString, targetSection) in conversionList: 
    6772         
     
    8489                confDict[targetSection][instanceName]=instance 
    8590 
    86     #exceptions to the automatic conversion 
    87     for section, name, correctType in exceptionsList: 
    88         if section in confDict: 
    89             if name in confDict[section]: 
    90                 confDict[section][name] = _getVal(conf, section, name, correctType) 
     91 
     92 
     93#    #exceptions to the automatic conversion 
     94#    for section, name, correctType in exceptionsList: 
     95#        if section in confDict: 
     96#            if name in confDict[section]: 
     97#                confDict[section][name] = _getVal(conf, section, name, correctType) 
    9198 
    9299 
     
    184191    return valNew 
    185192 
     193 
    186194if __name__ == '__main__': 
    187  
    188     import log_util 
    189     console = log_util.getBasicStreamHandler() 
    190     log.addHandler(console) 
    191     log_util.addGeoplotHandler(console) 
    192  
     195     
     196    from geoplot.log_util import SHORT_LOG_FORMAT_STRING 
     197    logging.basicConfig(level=logging.DEBUG, format=SHORT_LOG_FORMAT_STRING) 
     198     
    193199#    xLim = get('PlotBaseDefaults','xLimits') 
    194200#    dpi = get('PlotBaseDefaults','dpi') 
     
    196202 
    197203    conf = getConfig() 
    198     conf = getConfig() 
    199  
    200     log.debug(conf) 
    201     log.debug(conf['PlotBaseDefaults']) 
    202     log.debug(conf['PlotBaseDefaults']['xLimits']) 
    203     log.debug(str(conf['Fonts']['Metadata'])) 
     204#    conf = getConfig() 
     205# 
     206    log.debug(conf['Defaults']) 
     207#    log.debug(conf['PlotBaseDefaults']) 
     208#    log.debug(conf['PlotBaseDefaults']['xLimits']) 
     209#    log.debug(str(conf['Fonts']['Metadata'])) 
    204210     
    205211    #log.debug(conf) 
  • qesdi/geoplot/trunk/lib/geoplot/contour_drawer.py

    r5552 r5605  
    4040    """ 
    4141 
    42     def __init__(self, cmap=None, numLines=10, fontSize='medium', labelInterval=1): 
     42    def __init__(self, numContourLines=10, contourLabelInterval=1): 
    4343        """ 
    4444        Constructs a ContourDrawer object               
    4545        """ 
    4646 
    47         if cmap == None: 
    48             cmap = matplotlib.cm.get_cmap() 
    49             cmap.set_bad("w") 
    50              
    51         self.cmap = cmap 
    52         self.numLines = numLines 
     47        self.numContourLines = numContourLines 
     48        self.contourLabelInterval = contourLabelInterval 
    5349        self._contourFont = config['Fonts']['ContourLines'] 
    54         self.fontSize = fontSize 
    55         self.labelInterval = labelInterval 
    5650         
    57     def draw(self, axes, grid, basemap=None, cmapRange=(None,None)): 
     51    def draw(self, axes, grid, basemap=None, normalize=None, cmap=None, fontSize='medium'): 
    5852        """ 
    5953        Draws contour lines from the grid's data on the axis. 
     
    6761        """ 
    6862 
     63        if cmap == None: 
     64            cmap = matplotlib.cm.get_cmap() 
     65            cmap.set_bad("w") 
     66             
    6967        #transform the grid data to the correct projection 
    7068        grid_mapUnits = grid.transform(basemap) 
    7169                 
    72         self._drawContours(axes, grid_mapUnits, cmapRange) 
     70        self._drawContours(axes, cmap, grid_mapUnits, normalize, fontSize) 
    7371         
    74     def _drawContours(self, axes,  grid_mapUnits, cmapRange): 
     72    def _drawContours(self, axes, cmap, grid_mapUnits, normalize, fontSize): 
    7573        """ 
    7674        Draws the contour lines onto the axes. 
     
    8280        if valuesFound == True: 
    8381 
    84             norm = None 
    85             if cmapRange != None and cmapRange != (None, None): 
    86                 log.debug("cmapRange = %s" % (cmapRange,)) 
    87                 norm = matplotlib.colors.Normalize(cmapRange[0], cmapRange[1]) 
    88                 levels = N.linspace(cmapRange[0], cmapRange[1], self.numLines) 
     82            if normalize == None : 
     83                normalize = matplotlib.colors.Normalize(0, 1) 
     84                         
     85            levels = N.linspace(normalize.vmin, normalize.vmax, self.numContourLines) 
    8986             
    90                 log.debug("levels = %s" % (levels,)) 
    91                 log.debug("levels[0::2] = %s" % (levels[0::2],)) 
    92              
     87            log.debug("levels = %s" % (levels,)) 
     88            log.debug("levels[0::2] = %s" % (levels[0::2],)) 
     89         
    9390            extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
    9491                    grid_mapUnits.boundsY.min(), grid_mapUnits.boundsY.max()) 
     
    10097                              grid_mapUnits.values, 
    10198                              levels, 
    102                  cmap=self.cmap, 
     99                 cmap=cmap, 
    103100                 origin='lower', 
    104101                 linewidths=1, 
    105                  norm=norm, 
     102                 norm=normalize, 
    106103                 extend='neither', 
    107104                 ) 
    108             labelDictionary = self._contourFont.getDict(self.fontSize) 
    109             axes.clabel(CS,levels[0::self.labelInterval], fontsize=labelDictionary['size']) 
     105             
     106            labelDictionary = self._contourFont.getDict(fontSize) 
     107            axes.clabel(CS,levels[0::self.contourLabelInterval], fontsize=labelDictionary['size']) 
    110108             
    111109            axes.set_aspect('auto') 
  • qesdi/geoplot/trunk/lib/geoplot/filtered_basemap.py

    r5552 r5605  
    2525    def __init__(self, *args, **kwargs): 
    2626        self.__lines = None 
     27        self.__riverLines = None 
    2728        Basemap.__init__(self, *args, **kwargs) 
    2829 
     
    7980        self.set_axes_limits(ax=ax) 
    8081        return coastlines 
     82 
     83 
     84    def drawrivers(self,linewidth=0.5,color='k',antialiased=1,ax=None,zorder=None, 
     85                   xLimits=None, yLimits=None): 
     86 
     87        st = time.time() 
     88         
     89        if self.resolution is None: 
     90            raise AttributeError, 'there are no boundary datasets associated with this Basemap instance' 
     91        # read in river line segments, only keeping those that 
     92        # intersect map boundary polygon. 
     93        if not hasattr(self,'riversegs'): 
     94            self.riversegs, types = self._readboundarydata('rivers') 
     95             
     96        # get current axes instance (if none specified). 
     97        if ax is None and self.ax is None: 
     98            try: 
     99                ax = plt.gca() 
     100            except: 
     101                import matplotlib.pyplot as plt 
     102                ax = plt.gca() 
     103        elif ax is None and self.ax is not None: 
     104            ax = self.ax 
     105         
     106        xLimitsMapUnits, yLimitsMapUnits = self.__call__(xLimits, yLimits) 
     107         
     108        segs = self.__getRiverSegments(xLimitsMapUnits, yLimitsMapUnits) 
     109 
     110        log.debug("segs has %s lines and %s points" % (len(segs), 
     111                                        sum([len(x) for x in segs]))) 
     112  
     113        self._cairoLengthFix(segs) 
     114  
     115        rivers = LineCollection(segs, antialiaseds=(antialiased,)) 
     116        rivers.set_color(color) 
     117        rivers.set_linewidth(linewidth) 
     118        rivers.set_label('_nolabel_') 
     119         
     120        if zorder is not None: 
     121            rivers.set_zorder(zorder) 
     122             
     123        ax.add_collection(rivers) 
     124        # set axes limits to fit map region. 
     125        self.set_axes_limits(ax=ax) 
     126         
     127        log.debug("added rivers linecollection in %ss" % (time.time() - st,)) 
     128        return rivers 
    81129     
    82130     
     
    87135         
    88136        if self.__lines == None: 
    89             self.__buildLines() 
    90              
    91         st = time.time() 
    92         segs = self.__filterLines(xLimits, yLimits)  
    93  
    94         return segs         
    95      
    96      
    97     def __buildLines(self): 
    98          
    99         self.__lines = [] 
    100          
    101         for points in self.coastsegs: 
     137            self.__lines = self.__buildLines(self.coastsegs) 
     138             
     139        segs = self.__filterLines(xLimits, yLimits, self.__lines)  
     140 
     141        return segs 
     142     
     143    def __getRiverSegments(self, xLimits, yLimits): 
     144         
     145        if xLimits == None and yLimits == None: 
     146            return self.riversegs 
     147         
     148        if self.__riverLines == None: 
     149            self.__riverLines = self.__buildLines(self.riversegs) 
     150         
     151        segs = self.__filterLines(xLimits, yLimits, self.__riverLines) 
     152         
     153        return segs 
     154     
     155    def __buildLines(self, segs): 
     156         
     157        lines = [] 
     158         
     159        for points in segs: 
    102160             
    103161            lons = [i[0] for i in points] 
     
    107165            latRange = (min(lats), max(lats)) 
    108166             
    109             self.__lines.append(Line(points, lonRange, latRange)) 
    110  
    111     def __filterLines(self, xLimits, yLimits): 
     167            lines.append(Line(points, lonRange, latRange)) 
     168         
     169        return lines 
     170 
     171    def __filterLines(self, xLimits, yLimits, lines): 
    112172        """ 
    113173        Work out which of the lines fits between the limits of the plot 
     
    124184            return True 
    125185             
    126         linesInLimits = filter(isLineInSelectionLimits, self.__lines) 
     186        linesInLimits = filter(isLineInSelectionLimits, lines) 
    127187         
    128188        segs = [l.points for l in linesInLimits] 
    129          
    130189         
    131190        segs = self.__filterSegments(segs, xLimits, yLimits) 
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_lat_lon.py

    r5552 r5605  
    4545        latVals = self.cdmsVar.getLatitude()[:] 
    4646         
    47 #        log.debug("Starting longitude from %s to %s" % ( self.cdmsVar.getLongitude().getValue()[0], self.cdmsVar.getLongitude().getValue()[-1])) 
    48 #        log.debug("Starting latitude  from %s to %s" % ( self.cdmsVar.getLatitude().getValue()[0] , self.cdmsVar.getLatitude().getValue()[-1])) 
     47        log.debug("Starting longitude from %s to %s" % ( self.cdmsVar.getLongitude().getValue()[0], self.cdmsVar.getLongitude().getValue()[-1])) 
     48        log.debug("Starting latitude  from %s to %s" % ( self.cdmsVar.getLatitude().getValue()[0] , self.cdmsVar.getLatitude().getValue()[-1])) 
    4949         
    5050        lonLowHigh = lonVals[0] <= lonVals[-1] 
     
    5454        # is drawn right to the edge. 
    5555        indicator = 'cce' 
     56         
     57        additional_halo = 1 
    5658         
    5759        if lonLowHigh: 
     
    6466        else: 
    6567            latSelection = (yLimits[1], yLimits[0], indicator) 
    66                  
    67 #        log.debug("selecting longitude=%s latitude=%s" % (lonSelection, latSelection)) 
    6868         
     69        #!TODO: should implement a fix like this that can be turned on as needed 
     70        #lonSelection = (lonSelection[0] - 5, lonSelection[1] + 5) 
     71        #latSelection = (latSelection[0] - 5, latSelection[1] + 5) 
     72         
     73        log.debug("selecting longitude=%s latitude=%s" % (lonSelection, latSelection)) 
     74                             
    6975        try: 
    7076            newVar = self.cdmsVar(longitude=lonSelection, 
  • qesdi/geoplot/trunk/lib/geoplot/grid_drawer.py

    r5552 r5605  
    3838    """ 
    3939 
    40     def __init__(self, cmap=None, drawValues=False, drawValuesFile=False,  
     40    def __init__(self, drawValues=False, drawValuesFile=False,  
    4141                 valueFormat="%.2f", showGridLines=False, 
    4242                 outline=False): 
     
    4444        Constructs a GridDrawer object               
    4545        """ 
    46  
    47         if cmap == None: 
    48             cmap = matplotlib.cm.get_cmap() 
    49             cmap.set_bad("w") 
    50  
    51         self.cmap = cmap 
    5246        self.drawValues = drawValues 
    5347        self.drawValuesFile = drawValuesFile 
     
    5650        self.outline = outline 
    5751 
    58     def draw(self, axes, grid, limits=None, basemap=None, cmapRange=(None,None)): 
     52    def draw(self, axes, grid, limits=None, basemap=None, cmapRange=(None,None), 
     53             cmap=None): 
    5954        """ 
    6055        Draws the grid given on the axis. 
     
    7065        """ 
    7166 
     67        if cmap == None: 
     68            cmap = matplotlib.cm.get_cmap() 
     69            cmap.set_bad("w")         
     70 
    7271#        log.info("Drawing Grid") 
    7372 
     
    8079 
    8180        #draw the grid return the quadmesh for use 
    82         sm = self._drawGridBoxes(axes, grid_mapUnits, cmapRange, basemap) 
     81        sm = self._drawGridBoxes(axes, grid_mapUnits, cmapRange, basemap, cmap) 
    8382         
    8483#        log.debug("self.drawValues = %s" % (self.drawValues,)) 
     
    103102            return basemap(limits[0], limits[1]) 
    104103 
    105     def _drawGridBoxes(self, axes,  grid_mapUnits, cmapRange, basemap): 
     104    def _drawGridBoxes(self, axes,  grid_mapUnits, cmapRange, basemap, cmap): 
    106105        """ 
    107106        Draws the grid boxes onto the axes. 
     
    111110        gridLineWidth = 0.25 
    112111 
    113         kwargs = {'cmap':self.cmap} 
     112        kwargs = {'cmap':cmap} 
    114113         
    115114        if self.outline == True : 
     
    159158                log.debug("levels = %s" % (levels,)) 
    160159             
    161 #            log.debug("grid_mapUnits.boundsX.shape = %s" % (grid_mapUnits.boundsX.shape,)) 
    162 #            log.debug("grid_mapUnits.boundsY.shape = %s" % (grid_mapUnits.boundsY.shape,)) 
    163 #            log.debug("grid_mapUnits.midpointsX.shape = %s" % (grid_mapUnits.midpointsX.shape,)) 
    164 #            log.debug("grid_mapUnits.midpointsY.shape = %s" % (grid_mapUnits.midpointsY.shape,)) 
    165 #            log.debug("grid_mapUnits.values.shape = %s" % (grid_mapUnits.values.shape,)) 
    166             
    167             
    168 #             
    169160#            st = time.time() 
    170161#             
     
    174165#             
    175166#            log.debug("drawn mesh in %s" % (time.time() - st ,)) 
    176 #            
    177             
     167 
    178168            st = time.time() 
    179             
    180169             
    181170            boundsMin = grid_mapUnits.boundsY[0,0] 
     
    192181                        grid_mapUnits.boundsY.min(), grid_mapUnits.boundsY.max()) 
    193182             
    194              
    195  
    196183            im = axes.imshow(grid_mapUnits.values, extent=extent, 
    197 #                 vmin=cmapRange[0], vmax=cmapRange[1], 
    198184                 interpolation='nearest', 
    199 #                 interpolation='bicubic', 
    200 #                 interpolation='bilinear', 
    201185                 norm=norm, 
    202186                 cmap=kwargs['cmap'], 
     
    269253        ni, nj = N.shape(xMidpoints_mapUnits) 
    270254         
    271 #        log.debug("xLimits = %s" % (xLimits,)) 
    272 #        log.debug("yLimits = %s" % (yLimits,)) 
    273          
    274255        if xLimits != None: 
    275256            xRangeMaximum = max(xLimits) 
    276257            xRangeMinumum = min(xLimits) 
    277     #        log.debug("xRangeMaximum = %s" % (xRangeMaximum,)) 
    278     #        log.debug("xRangeMinumum = %s" % (xRangeMinumum,)) 
    279258             
    280259        if yLimits != None: 
    281260            yRangeMaximum = max(yLimits) 
    282261            yRangeMinumum = min(yLimits) 
    283     #        log.debug("yRangeMaximum = %s" % (yRangeMaximum,)) 
    284     #        log.debug("yRangeMinumum = %s" % (yRangeMinumum,)) 
    285          
    286  
    287 #       log.debug("beginning loop") 
     262 
    288263        for j in range(nj): 
    289264            for i in range(ni): 
     
    293268                    if [i, j] not in drawValuesList: continue 
    294269 
    295 #                log.debug("retriving value (i, j):(" + str(i) + "," + str(j) + ")") 
    296270                x = grid_mapUnits.midpointsX[i][j] 
    297271                y = grid_mapUnits.midpointsY[i][j] 
    298272 
    299                 #log.debug("position :" + str(x) + "," + str(y) + ")") 
    300                 #log.debug("type:" + str(type(cdmsVar)) + " class:" + str(cdmsVar.__class__)) 
    301                 #log.debug("type:" + str(type(cdmsVar[0])) + " class:" + str(cdmsVar[0].__class__)) 
    302273                v = grid_mapUnits.values[i,j] 
    303 #                print v, v.__class__, v.__class__ == MA.MaskedArray 
    304 #                log.debug("grid.values[i,j] = %s" % (grid.values[i,j],)) 
    305 #                if hasattr(v, 'mask'): 
    306 #                    print v.mask 
    307  
    308 #                log.debug("position :" + str(x) + "," + str(y) + " " + "value is :" + str(v)) 
    309274 
    310275                #skip masked array values: 
     
    327292                yBottom = min(yBounds) 
    328293                 
    329 #                log.debug("xTop=%s, xBottom=%s, yTop=%s, yBottom=%s" % \ 
    330 #                          (xTop, xBottom, yTop, yBottom)) 
    331  
    332 #                log.debug("xLimits %s yLimits %s" % (xLimits, yLimits)) 
    333 #                log.debug("xbounds = %s - %s" % (xBottom, xTop)) 
    334 #                log.debug("ybounds = %s - %s" % (yBottom, yTop))? 
    335  
    336294                if xLimits != None: 
    337295                    if xTop > xRangeMaximum or xBottom < xRangeMinumum: 
     
    341299                    if yTop > yRangeMaximum or yBottom < yRangeMinumum: 
    342300                        continue 
    343  
    344 #                log.debug("drawing value:" + str(self.valueFormat % v) + \ 
    345 #                          " at (" + str(x) + "," + str(y) + ")") 
    346301 
    347302                axes.text(float(x), float(y), self.valueFormat % v, 
     
    421376        @type range: 2 item tuple of (min, max)         
    422377        """ 
    423  
    424 #        log.debug("setting limits, colourbar range is:" + str(self.range)) 
    425  
    426 #        log.debug("Setting limits") 
    427          
     378        
    428379        (dataMin, dataMax) = sm.get_clim() 
    429380        (minVal, maxVal) = range 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_contour.py

    r5530 r5605  
    99import StringIO 
    1010import thread 
     11 
     12from matplotlib.colors import Normalize 
    1113 
    1214from geoplot.contour_drawer import ContourDrawer 
     
    4850            basemap = map.basemap         
    4951         
    50         self._contourDrawer.draw(axes, grid, cmapRange=self.cmapRange, 
    51                                  basemap=basemap) 
     52        norm = Normalize(self.cmapRange[0], self.cmapRange[1]) 
     53        self._contourDrawer.draw(axes, grid, normalize=norm, cmap=self.cmap, 
     54                                 basemap=basemap, fontSize=self.fontSize) 
    5255     
    5356    ### properties ### 
    5457         
    5558    def __set_cmap(self, value): 
    56         self._contourDrawer.cmap = value 
     59        self._cmap = value 
    5760         
    5861    def __get_cmap(self): 
    59         return self._contourDrawer.cmap  
     62        return self._cmap  
    6063     
    6164    cmap = property(__get_cmap, __set_cmap) 
    6265     
    6366    def __set_numLines(self, value): 
    64         self._contourDrawer.numLines = value 
     67        self._contourDrawer.numContourLines = value 
    6568     
    6669    def __get_numLines(self): 
    67         return self._contourDrawer.numLines 
     70        return self._contourDrawer.numContourLines 
    6871 
    6972    numLines = property(__get_numLines, __set_numLines) 
    7073     
    7174    def __set_fontSize(self, value): 
    72         self._contourDrawer.fontSize = value 
     75        self._fontSize = value 
    7376     
    7477    def __get_fontSize(self): 
    75         return self._contourDrawer.fontSize 
     78        return self._fontSize 
    7679 
    7780    fontSize = property(__get_fontSize, __set_fontSize) 
     
    7982     
    8083    def __set_labelInterval(self, value): 
    81         self._contourDrawer.labelInterval = value 
     84        self._contourDrawer.contourLabelInterval = value 
    8285     
    8386    def __get_labelInterval(self): 
    84         return self._contourDrawer.labelInterval 
     87        return self._contourDrawer.contourLabelInterval 
    8588 
    8689    labelInterval = property(__get_labelInterval, __set_labelInterval) 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid.py

    r5530 r5605  
    4040                 transparent=False): 
    4141         
     42        self._cmap = None 
    4243        self._gridDrawer = GridDrawer() 
    4344         
     
    7374                              basemap=basemap,  
    7475                              limits=(xLimits, yLimits),  
    75                               cmapRange=self.cmapRange) 
     76                              cmapRange=self.cmapRange, 
     77                              cmap=self.cmap) 
    7678     
    7779    ### properties ### 
     
    8688     
    8789    def __set_cmap(self, value): 
    88         self._gridDrawer.cmap = value 
     90        self._cmap = value 
    8991         
    9092    def __get_cmap(self): 
    91         return self._gridDrawer.cmap  
     93        return self._cmap  
    9294     
    9395    cmap = property(__get_cmap, __set_cmap) 
  • qesdi/geoplot/trunk/lib/geoplot/log_util.py

    r5403 r5605  
    1111 
    1212LOG_FORMAT_STRING = '%(name)-20s %(asctime)s ln:%(lineno)-3s %(levelname)-8s\n %(message)s\n' 
    13  
     13SHORT_LOG_FORMAT_STRING = '%(name)-20s ln:%(lineno)-3s %(levelname)-8s %(message)s' 
    1414 
    1515#module list 
  • qesdi/geoplot/trunk/lib/geoplot/map_base.py

    r5552 r5605  
    8686 
    8787        if self.drawRivers: 
    88             self.basemap.drawrivers(ax = axes, color='b', linewidth=0.3) 
     88            self.basemap.drawrivers(ax = axes, color='b', linewidth=0.3, 
     89                                    antialiased=0, 
     90                                    xLimits=self.xLimits, yLimits=self.yLimits) 
    8991             
    9092        if self.addShapefile != False: 
     
    225227        self._xLimits = value 
    226228        self._setBasemap() 
     229         
    227230    def __get_xLimits(self): return self._xLimits 
    228231    xLimits = property(__get_xLimits, __set_xLimits)     
     
    232235        self._yLimits = value 
    233236        self._setBasemap() 
     237         
    234238    def __get_yLimits(self): return self._yLimits 
    235239    yLimits = property(__get_yLimits, __set_yLimits)         
  • qesdi/geoplot/trunk/lib/geoplot/metadata_box.py

    r5552 r5605  
    1414class MetadataBox(object): 
    1515 
    16     def __init__(self, dataList): 
     16    def __init__(self, metadataList=None): 
    1717        self._dataList = None 
    1818 
    19         self.dataList = dataList 
     19        self.metadataList = metadataList 
    2020 
    2121        self.dataFont  = config[FONTS_SECTION]['Metadata'] 
     
    8181 
    8282        # 0.2 0.13 
    83         lines = self.dataList 
     83        lines = self.metadataList 
    8484 
    8585        # Compile the lines 
    86         lines = ["%s: %s" % i for i in lines] 
     86        if lines == None: 
     87            lines = [""] 
     88        else: 
     89            lines = ["%s: %s" % i for i in lines] 
    8790 
    8891        metadataDict = self.dataFont.getDict(fontSize) 
     
    125128 
    126129 
    127     dataList = property(__get_dataList, __set_dataList, None, 
     130    metadataList = property(__get_dataList, __set_dataList, None, 
    128131                        "The list of items ('label, 'value') to appear in the metadata box.") 
  • qesdi/geoplot/trunk/lib/geoplot/plot_base.py

    r5552 r5605  
    2020from geoplot.metadata_box import MetadataBox 
    2121from geoplot.grid_drawer import GridDrawer 
     22from geoplot.contour_drawer import ContourDrawer 
    2223 
    2324import geoplot.config as geoplot_config 
    24  
     25import geoplot.utils as geoplot_utils 
    2526 
    2627config = geoplot_config.getConfig() 
     
    4445                              'colourBarMin', 'colourBarMax', 'drawLogo', 'drawCoast', 
    4546                              'drawRivers', 'plotTitle', 'metadataList', 'fontSize' , 
    46                               'units', 'showGridLines', 'outputCMYK', 'addShapefile'] 
     47                              'units', 'showGridLines', 'outputCMYK', 'addShapefile',  
     48                              'drawMetadata'] 
    4749 
    4850    def __init__(self, cdmsVar, **kwargs): 
     
    115117        for key in kwargs: 
    116118            if key not in self.validConstructorKWArgs: 
    117                 raise TypeError("__init__ got an unexpected keyword arument '" \ 
     119                raise TypeError("__init__ got an unexpected keyword argument '" \ 
    118120                                + key + "'") 
    119121        
     
    122124        for key in self.validConstructorKWArgs: 
    123125            argDict[key] = None 
     126             
    124127           
    125128        #apply the default arguments form the config file, if an argument 
     
    127130        argDict.update(config[DEFAULTS_SECTION]) 
    128131         
     132         
    129133        #apply the kwargs in the function call, these values will overwrite the 
    130134        #default ones. 
     
    134138 
    135139        self.units = argDict['units'] 
    136         self.drawLogo = argDict['drawLogo'] 
    137         self.drawColourBar = argDict['drawColourBar'] 
     140         
    138141 
    139142        self.map = self._getMap(argDict['xLimits'], argDict['yLimits'],  
     
    144147        self.gridBuilder = self._getGridBuilder(cdmsVar) 
    145148         
    146         self.gridDrawer = GridDrawer( argDict['cmap'], argDict['drawValues'],  
     149        self.gridDrawer = GridDrawer( argDict['drawValues'],  
    147150                             argDict['drawValuesFile'], 
    148151                             argDict['valueFormat'], argDict['showGridLines']) 
    149152         
     153         
    150154        self.plotArea = PlotArea(argDict['width'], argDict['height'],  
    151155                                 argDict['dpi'], argDict['fontSize'],  
    152                                  argDict['plotTitle']) 
     156                                 argDict['plotTitle'], argDict['drawColourBar'], 
     157                                 argDict['drawLogo'], argDict['drawMetadata']) 
    153158 
    154159        self.metadataBox = MetadataBox(argDict['metadataList']) 
    155160 
    156         self.colourBar = ColourBar(argDict['colourBarLabel'],  
    157                                    argDict['colourBarPosition'], 
    158                                    (argDict['colourBarMin'],  
    159                                     argDict['colourBarMax'])) 
     161        self.colourBar = ColourBar(colourBarLabel = argDict['colourBarLabel'],  
     162                                   colourBarPosition = argDict['colourBarPosition'], 
     163                                   cmap = argDict['cmap'], 
     164                                   colourBarMin = argDict['colourBarMin'],  
     165                                   colourBarMax =  argDict['colourBarMax']) 
    160166 
    161167        self.plotWriter = PlotWriter(argDict['format'], argDict['outputCMYK']) 
     168         
    162169 
    163170    def _setDynamicArgs(self, kwargs): 
     
    237244        self.plotWriter.checkFileExtension(filename) 
    238245 
    239         self.plotArea.setupArea(self.drawMetadata, self.drawLogo, self.drawColourBar, self.colourBarPosition) 
     246        self._drawMap() 
     247 
     248        st = time.time() 
     249        self.plotWriter.writeFile(self.plotArea.figure, filename, self.drawLogo, self.plotArea.logoAxes) 
     250        log.debug("wrote output file in %.3fs" % (time.time() - st, )) 
     251         
     252        log.info("Finished drawing " + os.path.split(filename)[1] + " in %.3fs" % (time.time() - startTime,)) 
     253 
     254    def drawToImage(self): 
     255        if self.format not in 'png': 
     256            raise Exception("format %s not yet supported for image retrival" % (self.format,)) 
     257         
     258        self._drawMap() 
     259         
     260        im = geoplot_utils.figureToImage(self.plotArea.figure) 
     261         
     262        return im 
     263     
     264    def _drawMap(self): 
     265        self.plotArea.setupArea(self.colourBarPosition) 
    240266 
    241267        #get the grid 
     
    249275                                  limits=[self.xLimits, self.yLimits],   
    250276                                  basemap=self.map.basemap, 
     277                                  cmap=self.colourBar.getColourMap(), 
    251278                                  cmapRange=(self.colourBarMin, self.colourBarMax)) 
    252279         
    253280        log.debug("drawn grid in %.3fs" % (time.time() - st, )) 
     281 
    254282 
    255283        st = time.time() 
     
    266294        if self.drawColourBar: 
    267295            st = time.time() 
    268             self.colourBar.draw(self.plotArea.figure, self.plotArea.cbAxes, 
    269                                 sm, self.fontSize) 
     296            self.colourBar.draw(self.plotArea.cbAxes, self.fontSize, dataMin=grid.values.min(), dataMax=grid.values.max()) 
     297             
    270298            log.debug("drawn colourBar in %.3fs" % (time.time() - st, )) 
    271299 
    272         st = time.time() 
    273         self.plotWriter.writeFile(self.plotArea.figure, filename, self.drawLogo, self.plotArea.logoAxes) 
    274         log.debug("wrote output file in %.3fs" % (time.time() - st, )) 
    275          
    276         log.info("Finished drawing " + os.path.split(filename)[1] + " in %.3fs" % (time.time() - startTime,)) 
     300#        self.plotArea.axes.set_xlim(-180, 180) 
     301#        self.plotArea.axes.set_ylim(-90, 90) 
     302 
     303             
    277304 
    278305    #properies, because the properties are sread about several internal object 
     
    306333                    "A list of key, vlaue pairs containing the plot metadata") 
    307334 
    308     def __get_drawMetadata(self): return self.metadataList!=None 
    309     drawMetadata = property(__get_drawMetadata, None, None, 
     335    def __get_drawMetadata(self): return self.plotArea.drawMetadata 
     336    def __set_drawMetadata(self, value): self.plotArea.drawMetadata=value 
     337    drawMetadata = property(__get_drawMetadata, __set_drawMetadata, None, 
    310338                    "value indicating if the metadata should be drawn on the plot.") 
     339 
     340    def __get_drawColourBar(self): return self.plotArea.drawColourBar 
     341    def __set_drawColourBar(self, value): self.plotArea.drawColourBar=value 
     342    drawColourBar = property(__get_drawColourBar, __set_drawColourBar, None, 
     343                    "value indicating if the colour bar should be drawn on the plot.") 
     344 
     345    def __get_drawLogo(self): return self.plotArea.drawLogo 
     346    def __set_drawLogo(self, value): self.plotArea.drawLogo=value 
     347    drawLogo = property(__get_drawLogo, __set_drawLogo, None, 
     348                    "value indicating if the metadata should be drawn on the plot.") 
     349 
    311350 
    312351 
     
    316355                         "The title of the plot") 
    317356 
    318     def __get_colourBarLabel(self): return self.colourBar.label 
    319     def __set_colourBarLabel(self, value): self.colourBar.label = value 
     357    def __get_colourBarLabel(self): return self.colourBar.colourBarLabel 
     358    def __set_colourBarLabel(self, value): self.colourBar.colourBarLabel = value 
    320359    colourBarLabel = property(__get_colourBarLabel, __set_colourBarLabel, 
    321360                              None, "The label for the colour bar") 
    322361 
    323     def __get_colourBarPosition(self): return self.colourBar.position 
    324     def __set_colourBarPosition(self, value): self.colourBar.position = value 
     362    def __get_colourBarPosition(self): return self.colourBar.colourBarPosition 
     363    def __set_colourBarPosition(self, value): self.colourBar.colourBarPosition = value 
    325364    colourBarPosition = property(__get_colourBarPosition, 
    326365                                 __set_colourBarPosition, None, 
    327366                    "colour bar position, 'horizontal' or 'vertical'") 
    328367 
    329     def __get_colourBarMin(self): return self.colourBar.range[0] 
    330     def __set_colourBarMin(self, value): 
    331         self.colourBar.range = (value, self.colourBar.range[1]) 
     368    def __get_colourBarMin(self): return self.colourBar.colourBarMin 
     369    def __set_colourBarMin(self, value): self.colourBar.colourBarMin = value 
    332370    colourBarMin = property(__get_colourBarMin, __set_colourBarMin, None, 
    333371                        "The minimum for the colour bar range") 
    334372 
    335     def __get_colourBarMax(self): return self.colourBar.range[1] 
    336     def __set_colourBarMax(self, value): 
    337         self.colourBar.range = (self.colourBar.range[0], value) 
     373    def __get_colourBarMax(self): return self.colourBar.colourBarMax 
     374    def __set_colourBarMax(self, value): self.colourBar.colourBarMax = value 
    338375    colourBarMax = property(__get_colourBarMax, __set_colourBarMax, None, 
    339376                        "The maximum for the colour bar range") 
     
    371408                       "The cdms variable that conatins the plot data") 
    372409 
    373     def __get_cmap(self): return self.gridDrawer.cmap 
    374     def __set_cmap(self, value): self.gridDrawer.cmap = value 
     410    def __get_cmap(self): return self.colourBar.cmap 
     411    def __set_cmap(self, value): self.colourBar.cmap = value 
    375412    cmap = property(__get_cmap, __set_cmap, None, 
    376413                    "The colour map used to draw the grid") 
  • qesdi/geoplot/trunk/lib/geoplot/plot_rotated_grid.py

    r5552 r5605  
    9999 
    100100        self._rotatedPoleVar = rotatedPoleVar 
    101  
     101         
     102        for a in ['grid_north_pole_longitude', 'grid_north_pole_latitude', 
     103                  'north_pole_grid_longitude']: 
     104            if hasattr(rotatedPoleVar, a): 
     105                setattr(cdmsVar, a, getattr(rotatedPoleVar, a)) 
     106         
     107         
    102108        PlotBase.__init__(self, cdmsVar, **kwargs) 
    103109 
  • qesdi/geoplot/trunk/lib/geoplot/plot_writer.py

    r5552 r5605  
    3131POSITION_LOGO_IN_CENTER = True 
    3232 
    33 class PlotWriter: 
     33class PlotWriter(object): 
    3434    """ 
    3535    A class that takes a plotarea after the plot has been done and writes it 
  • qesdi/geoplot/trunk/lib/geoplot/plotarea.py

    r5552 r5605  
    4545    """ 
    4646 
    47     def __init__(self, width, height, dpi, fontSize, plotTitle): 
     47    def __init__(self, width=600, height=900, dpi=100, fontSize='medium', plotTitle='', 
     48                 drawColourBar=True, drawLogo=True, drawMetadata=True): 
    4849        """ 
    4950        @param width: the width of the figure in pixels 
     
    6566        self.dpi = dpi 
    6667        self.plotTitle = plotTitle 
     68        self.drawColourBar = drawColourBar 
     69        self.drawLogo = drawLogo 
     70        self.drawMetadata = drawMetadata 
    6771 
    6872        #values for the metadata box 
     
    8387        
    8488 
    85     def setupArea(self, drawMetadata, drawLogo, drawColourBar, colourBarPosition): 
     89    def setupArea(self, colourBarPosition): 
    8690        """ 
    8791        Initialises the axes and fonts to be used in plotting the graph. 
     
    9599        self._setAxisTickSize() 
    96100 
    97         self._setupAxes(drawMetadata, drawLogo, drawColourBar, colourBarPosition) 
     101        self._setupAxes(colourBarPosition) 
    98102 
    99103        #set the plot title 
     
    110114        rcParams['ytick.labelsize'] = tickSize 
    111115 
    112     def _setupAxes(self, drawMetadata, drawLogo, drawColourBar, colourBarPosition): 
     116    def _setupAxes(self, colourBarPosition): 
    113117        """ 
    114118        Adds the required axis to the figure object ready for the plot, the main axis is 
     
    121125         
    122126        figsize=(self.width / self.dpi, self.height / self.dpi) 
    123         self.figure = Figure(figsize=figsize, dpi=self.dpi) 
     127        self.figure = Figure(figsize=figsize, dpi=self.dpi, facecolor='w') 
    124128 
    125129        #outline plot 
     
    130134        #need to make sure the local regions are copies as changing one of them 
    131135        #will change the value in the config object 
    132         if drawColourBar == False: 
     136        if self.drawColourBar == False: 
    133137            pRegion = copy(self.plotRegionFull) 
    134138        elif colourBarPosition == 'horizontal': 
     
    140144        else: 
    141145            raise ValueError, "unknown value for colour bar position :", self.colourBarPosition 
     146         
     147        pRegion = list(pRegion) 
    142148 
    143149        # if there is no metadata or logo then make the plot taller by the hight of the 
     
    147153#                  " DrawLogo:" + str(drawLogo)) 
    148154         
    149         if drawMetadata == False and drawLogo == False: 
     155        if self.drawMetadata == False and self.drawLogo == False: 
    150156#            log.debug("Shifting Region Up") 
    151157            pRegion[3] += self.metadataRegion[3] 
     
    154160 
    155161        #construct the axes obejcts for the colour bar, the plot and the metadata box 
    156         if drawColourBar == True: 
     162        if self.drawColourBar == True: 
     163            log.debug("cbRegion , cbRegion.__class__ = %s, %s" % (cbRegion, cbRegion.__class__)) 
    157164            self.cbAxes = self.figure.add_axes(cbRegion, 
    158165                                               frameon=OUTLINE_COLOUR_BAR_REGION, 
    159166                                               xticks=[], yticks=[]) 
    160167 
    161         if drawMetadata == True: 
     168        if self.drawMetadata == True: 
    162169            self.metadataAxes = self.figure.add_axes(self.metadataRegion, 
    163170                                                     frameon=OUTLINE_METADATA_REGION, 
    164171                                                     xticks=[], yticks=[]) 
    165172 
    166         if drawLogo == True: 
     173        if self.drawLogo == True: 
    167174            self.logoAxes = self.figure.add_axes(self.logoRegion, 
    168175                                                 frameon=OUTLINE_LOGO_REGION, 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_get_colour_bar_image.py

    r5412 r5605  
    1313def drawColourBar(width, height, name_segment=""): 
    1414 
    15     im = geoplot.colour_bar.getColourBarImage(width,height, label='colour bar') 
     15    im = geoplot.colour_bar.getColourBarImage(width,height, label='Units of Measure: mm/day') 
    1616     
    1717    filename = os.path.join(outputDir, '%scolourBar.png' % (name_segment,)) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/make_data_functions.py

    r5412 r5605  
    11from math import cos, sin 
    22import numpy as N 
     3import numpy.ma as MA 
     4import random 
    35 
    4 def fnSinXAddCosY(shape, xMax=5.0, yMax=7.0): 
     6import logging 
     7log = logging.getLogger(__name__) 
     8random.seed() 
     9 
     10def fnSinXAddCosY(shape=(10,10), missing_value=N.float32(1e20), xMax=5.0, yMax=7.0): 
    511     
    612    data = N.zeros(shape, dtype=float) 
     
    3541             
    3642    return data 
     43 
     44 
     45def randomFill(shape=(10,10), missing_value=N.float32(1e20), 
     46                min=-20, max=30, missing_percent=25 ): 
     47     
     48    arr = _buildEmptyMA(shape, missing_value) 
     49     
     50    for ind in getAllIndices(shape): 
     51        x = random.random()* 100 
     52        if x<=float(missing_percent): 
     53            continue 
     54         
     55        arr[ind] = random.random() * (max-min) + min 
     56     
     57    return arr 
     58 
     59def getAllIndices(shape): 
     60    totalSize = 1 
     61    for dim in shape: 
     62        totalSize *= dim 
     63 
     64    #build a list to hold the results  
     65    res = [0] * len(shape) 
     66 
     67    for i in range(totalSize): 
     68         
     69        for dimInd, dim in enumerate(shape): 
     70             
     71            step = i % dim # step along this dimension 
     72            i = i / dim    # reduce the remaining steps 
     73            res[dimInd] = step 
     74         
     75        yield tuple(res) 
     76     
     77 
     78def _buildEmptyMA(shape, missing_value): 
     79    array = N.zeros(shape, 'f') 
     80    array.fill(missing_value) 
     81    return MA.masked_values(array, missing_value) 
     82 
     83 
     84if __name__ == '__main__': 
     85    from geoplot.log_util import SHORT_LOG_FORMAT_STRING 
     86    logging.basicConfig(level=logging.DEBUG, format=SHORT_LOG_FORMAT_STRING) 
     87     
     88    arr = randomFill(shape=(2,2,2)) 
     89    print arr 
     90         
  • qesdi/geoplot/trunk/lib/geoplot/tests/make_ll_grid_data.py

    r5403 r5605  
    11import cdms2 as cdms 
    22import numpy as N 
     3import numpy.ma as MA 
    34 
    45import logging 
     
    67log = logging.getLogger(__name__) 
    78 
    8 from geoplot.tests.make_data_functions import fnSinXAddCosY 
     9from geoplot.tests.make_data_functions import randomFill, fnSinXAddCosY 
     10 
     11 
     12def midpoints(bounds): 
     13    x = [(bounds[i] + bounds[i+1])/2.0 for i in range(len(bounds) -1)] 
     14    return  N.array(x) 
    915 
    1016def makeLLVar(id='var', 
    1117              lonBounds=(-180,180), latBounds=(-90,90),  
    12               nx=361, ny=181,  
    13               function=fnSinXAddCosY): 
     18              nx=360, ny=180,  
     19              function=fnSinXAddCosY, 
     20              functionArgs={}, 
     21              variableProperties = {}, 
     22              missing_value = N.float32(1e+20)): 
    1423     
    15     lonVals = N.linspace(lonBounds[0], lonBounds[1], nx) 
    16     latVals = N.linspace(latBounds[0], latBounds[1], ny) 
     24    lon_bounds = N.linspace(lonBounds[0], lonBounds[1], nx+1) 
     25    lat_bounds = N.linspace(latBounds[0], latBounds[1], ny+1) 
     26     
     27    lon_mid = midpoints(lon_bounds) 
     28    lat_mid = midpoints(lat_bounds) 
     29     
     30    lonAxis = cdms.createAxis(lon_mid) 
     31    lonAxis.axes = 'X' 
     32    latAxis = cdms.createAxis(lat_mid) 
     33    latAxis.axes = 'Y' 
     34     
     35    for att in ['id','name','title','long_name']: 
     36        setattr(lonAxis, att, 'longiude') 
     37        setattr(latAxis, att, 'latitude') 
     38     
     39    lonAxis.topology = "circular" 
     40    lonAxis.units = "degrees_east" 
     41    lonAxis.modulo = 360. 
     42    latAxis.units = "degrees_north" 
     43     
     44    data = function(shape=(nx,ny), missing_value=missing_value, **functionArgs) 
     45     
     46    var = cdms.createVariable(data, axes=[lonAxis, latAxis], id=id) 
     47    var.missing_value = missing_value 
     48     
     49    for k,v in variableProperties.items(): 
     50        setattr(var, k, v) 
     51     
     52    return var 
     53 
     54 
     55 
     56def makePrecipTestVar(lonBounds=(0,360), latBounds=(90,-90)): 
     57 
     58    props = {'long_name':"Precipitation", 
     59             'standard_name':"precipitation_amount", 
     60             'units':"mm/day", } 
     61     
     62    return makeLLVar(id='pre', 
     63              lonBounds=lonBounds, latBounds=latBounds, 
     64              nx=720, ny=360, 
     65              variableProperties=props, 
     66              function=randomFill, 
     67               ) 
    1768     
    1869     
    19     lon = cdms.createAxis(lonVals, id='longitude') 
    20     lat = cdms.createAxis(latVals, id='latitude') 
    21      
    22     data = function((nx,ny)) 
    23      
    24     var = cdms.createVariable(data, axes=[lon, lat], id=id) 
    25     return var 
    26  
    2770if __name__ == '__main__': 
    2871    var =  makeLLVar() 
    29     from geoplot.layer_drawer import LayerDrawer 
     72#    var = makePrecipTestVar() 
     73    from geoplot.layer_drawer_grid import LayerDrawerGrid 
    3074    from geoplot.tests import outputsDir 
    3175    import os 
     
    3579     
    3680    log.info("STARTING") 
    37     ld = LayerDrawer() 
     81    ld = LayerDrawerGrid(var) 
    3882     
    39     img = ld.makeImage(var) 
     83    img = ld.makeImage() 
    4084     
    4185    file = os.path.join(outputsDir, 'make_ll_var_test.png') 
  • qesdi/geoplot/trunk/lib/geoplot/tests/runPlot.py

    r5403 r5605  
    4242            'drawCoast': False,  
    4343            'drawColourBar':False, 
    44  
    4544            'colourBarLabel': 'Change in mean temperature (deg C)',  
    4645            'xLimits': (-12.0, 3.0),  
     
    8382if __name__ == '__main__': 
    8483    from geoplot.mpl_imports import basemap 
     84    from geoplot.log_util import SHORT_LOG_FORMAT_STRING 
    8585     
    8686    runPlot() 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_grid_builder_lat_lon.py

    r5403 r5605  
    5151        yLimits = (7,9) 
    5252        resized = self.builder._resizeVar(xLimits, yLimits) 
    53  
    54         valAboveXmin = self.tempVar.getLongitude()[-1] # the max longitude 
    55         valBelowXmax = self.tempVar.getLongitude()[0] 
    56         print self.tempVar.getLongitude().getValue() 
    57         print resized.getLongitude().getValue()    
    58         for val in self.tempVar.getLongitude(): 
    59             if val < valAboveXmin and val >= xLimits[0]: valAboveXmin = val 
    60             if val > valBelowXmax and val <= xLimits[1]: valBelowXmax = val 
    6153         
    62         valAboveYmin = self.tempVar.getLatitude()[-1] # the max longitude 
    63         valBelowYmax = self.tempVar.getLatitude()[0] 
    64         for val in self.tempVar.getLatitude(): 
    65             if val < valAboveYmin and val >= yLimits[0]: valAboveYmin = val 
    66             if val > valBelowYmax and val <= yLimits[1]: valBelowYmax = val 
     54        resizedLon = resized.getLongitude()[:].tolist() 
     55        resizedLat =  resized.getLatitude()[:].tolist() 
    6756         
    68         nose.tools.assert_equal(resized.getLongitude()[0]  ,valAboveXmin) 
    69         nose.tools.assert_equal(resized.getLongitude()[-1] ,valBelowXmax) 
    70         nose.tools.assert_equal(resized.getLatitude()[0]  ,valAboveYmin) 
    71         nose.tools.assert_equal(resized.getLatitude()[-1] ,valBelowYmax) 
     57        nose.tools.assert_equal(resizedLon ,[20, 30, 40, 50]) 
     58        nose.tools.assert_equal(resizedLat ,[6, 7, 8, 9]) 
    7259     
    7360    def test_002_buildBounds(self): 
     
    10895        nose.tools.assert_equal(missingArr.tolist(9999), valArr.tolist(9999)) 
    10996     
    110      
    111     def test_005_gettingSelections(self): 
    112          
    113         limits = (20, 50) 
    114         values = N.arange(55, 5, -5) 
    115          
    116         # the selection should be slightly larger than the original limits 
    117         assert (15, 55) == self.builder._getSelection(limits, values) 
    118          
    119         #check the values aren't changed 
    120         assert (values == N.arange(55,5,-5)).all() 
    121          
    122         assert (10, 55) == self.builder._getSelection(limits, values,  
    123                                                       additionalCells=2) 
    124          
    125         values = N.arange(2.5,10.5, 1) 
    126         limits = (3.6,6.51) 
    127         print values, self.builder._getSelection(limits, values) 
    128         assert (3.5, 8.5) == self.builder._getSelection(limits, values) 
    129         assert (2.5, 9.5) == self.builder._getSelection(limits, values, additionalCells=2) 
    130         print self.builder._getSelection(limits, values, additionalCells=0) 
    131          
    132          
    133         assert(False) 
    13497 
    13598if __name__ == '__main__': 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_layer_drawer.py

    r5403 r5605  
    99import cdms2 as cdms 
    1010import numpy 
     11import nose 
    1112 
    1213from matplotlib.figure import Figure 
     
    1617from mock import patch, patch_object, Mock, sentinel 
    1718 
    18 from geoplot.layer_drawer import LayerDrawer 
     19from geoplot.layer_drawer import LayerDrawerBase 
    1920 
    2021import geoplot.layer_drawer as layer_drawer 
     22import geoplot.layer_drawer_grid as layer_drawer_grid 
    2123import geoplot.utils as geoplot_utils 
    2224 
    2325layer_drawer.GridBuilderLatLon 
    24 layer_drawer.GridDrawer 
     26layer_drawer_grid.GridDrawer 
     27 
    2528 
    2629log = logging.getLogger(__name__) 
     
    3538 
    3639    def test_001_ExceptionWhenUnknownGridType(self): 
    37         ld = LayerDrawer() 
     40        ld = layer_drawer.LayerDrawerBase() 
    3841         
    3942        nt.assert_raises(Exception, 
     
    4649        mockGridBuilderLatLon.return_value = mockGridBuilderLatLon 
    4750        #create a mock grid drawer 
    48         mockGridDrawer = Mock(spec=layer_drawer.GridDrawer) 
     51        mockGridDrawer = Mock(spec=layer_drawer_grid.GridDrawer) 
    4952        mockGridDrawer.return_value = mockGridDrawer 
    5053         
     
    5558        #use this function to create a test image 
    5659        width = 150; height=100; 
    57         fig = Figure((width / 100, height / 100), dpi=100, facecolor='w') 
     60        fig = Figure((width / 100.0, height / 100.0), dpi=100, facecolor='w') 
    5861        axes = fig.add_axes([0.0, 0.0, 1.0, 1.0], xticks=[], yticks=[], frameon=False) 
    5962        drawBoxOnAxis(axes, None) 
     
    6871        @apply 
    6972        @patch('geoplot.layer_drawer.GridBuilderLatLon', mockGridBuilderLatLon) 
    70         @patch('geoplot.layer_drawer.GridDrawer',mockGridDrawer) 
     73        @patch('geoplot.layer_drawer_grid.GridDrawer',mockGridDrawer) 
    7174        def do_test(): 
    72             ld = LayerDrawer() 
    73             im = ld.makeImage(sentinel, width=width, height=height) 
     75            ld = layer_drawer_grid.LayerDrawerGrid(sentinel) 
     76            im = ld.makeImage(width=width, height=height) 
    7477             
    7578            assert issubclass(im.__class__, Image.Image) 
     79            testImage.save('/tmp/test_image.png') 
     80            im.save('/tmp/resulting_image.png') 
    7681            assert compareImages(testImage, im) 
    7782     
     
    8590        arr = numpy.zeros((len(lat),len(lon))) 
    8691        v = cdms.createVariable(arr, axes=[lat,lon]) 
    87         ld = LayerDrawer() 
    88          
     92        ld = layer_drawer_grid.LayerDrawerGrid(v) 
    8993        xLims = (-5,2) 
    9094        yLims = (6,11) 
    91         fig = ld._drawToFigure(v, xLimits=xLims, yLimits=yLims, width=100, height=100, dpi=100) 
     95         
     96        fig = ld._getFigure(width=100, height=100, dpi=100) 
     97         
     98        axes = ld._addAxes(fig) 
     99        ld._drawToAxes(axes, xLimits=xLims, yLimits=yLims) 
     100        ld._resetAxes(axes,  xLimits=xLims, yLimits=yLims) 
    92101         
    93102        print dir(fig) 
    94         axes = fig.get_axes()[0] 
    95103         
    96         assert axes.get_xlim() == xLims 
    97         assert axes.get_ylim() == yLims 
    98          
    99          
     104        nt.assert_equal(axes.get_xlim(), xLims) 
     105        nt.assert_equal(axes.get_ylim(), yLims) 
    100106 
    101107def compareImages(image1, image2): 
     
    108114 
    109115if __name__ == "__main__": 
    110     unittest.TextTestRunner(verbosity=1).run(suite()) 
     116    nose.runmodule() 
     117     
     118#    unittest.TextTestRunner(verbosity=1).run(suite()) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_plot_base.py

    r5403 r5605  
    2828             'metadataList': [('Name one', 'value 1'), ('Name two', 'value 2')], 
    2929             'fontSize': "large", 'units': "degrees", 'showGridLines':True, 
    30              'outputCMYK':True, 'addShapefile':'some/shape/file/','drawValuesFile':'some/draw/value/file.csv'} 
     30             'outputCMYK':True, 'addShapefile':'some/shape/file/','drawValuesFile':'some/draw/value/file.csv', 'drawContour':True} 
    3131 
    3232argumentTypes = {'format':str, 'width': int, 'height':int, 'drawValues': bool, 
     
    3939                 'plotTitle': str, 'metadataList': list, 'fontSize': str, 
    4040                 'units': str, 'showGridLines':bool, 'outputCMYK':bool, 
    41                  'addShapefile':str,'drawValuesFile':str} 
     41                 'addShapefile':str,'drawValuesFile':str, 'drawContour':bool} 
    4242 
    4343dynamicDefaultArgs = ['colourBarLabel', 'colourBarPosition', 'cmap'] 
     
    6262     
    6363    def test_001_checkDefaultArguments(self): 
    64         """ 
    65         Checks that the default values are applied correctly 
    66         """ 
    6764         
    6865        self.constructUsingDefaults() 
Note: See TracChangeset for help on using the changeset viewer.