Changeset 6118


Ignore:
Timestamp:
14/12/09 14:57:03 (10 years ago)
Author:
pnorton
Message:

Fixed lots of small bugs and tidied up the layer drawer code a bit.

Location:
qesdi/geoplot/trunk/lib/geoplot
Files:
13 edited

Legend:

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

    r6103 r6118  
    2323class COLOUR_BAR_STYLES: 
    2424    LEGEND='legend' 
    25     CONTINUOUS = 'continuous'  
     25    CONTINUOUS = 'continuous' 
     26    INTERVAL = 'interval'   
    2627    LINE = 'line' 
    2728 
    2829    @staticmethod 
    2930    def all(): 
    30         return [COLOUR_BAR_STYLES.CONTINUOUS, COLOUR_BAR_STYLES.LEGEND, COLOUR_BAR_STYLES.LINE] 
     31        return [COLOUR_BAR_STYLES.CONTINUOUS, COLOUR_BAR_STYLES.LEGEND, COLOUR_BAR_STYLES.LINE, COLOUR_BAR_STYLES.INTERVAL] 
    3132 
    3233class COLOUR_SCHEME_SCALE: 
    3334    LINEAR='linear' 
    3435    LOG='log' 
     36     
     37    @staticmethod 
     38    def all(): 
     39        return [COLOUR_SCHEME_SCALE.LINEAR, COLOUR_SCHEME_SCALE.LOG] 
     40     
    3541 
    3642class ColourBar(object): 
     
    4652        self.labelFont = config[FONTS_SECTION]['ColourBarLabel'] 
    4753 
    48     def draw(self, colourBarAxis, colourScheme, fontSize='medium'): 
     54    def draw(self, colourBarAxis, colourScheme, fontSize='medium', intervalNames=None): 
    4955        """ 
    5056        Adds the colour bar to the (and optionally a label) to the figure. 
     
    5965         
    6066        if self.colourBarStyle == COLOUR_BAR_STYLES.LEGEND: 
    61             self._drawLegendColourBar(colourBarAxis, colourScheme, fontSize) 
     67            self._drawLegendColourBar(colourBarAxis, colourScheme, fontSize, intervalNames) 
     68             
    6269        elif self.colourBarStyle == COLOUR_BAR_STYLES.LINE: 
    6370            self._drawLineColourBar(colourBarAxis, colourScheme, fontSize) 
     71             
     72        elif self.colourBarStyle == COLOUR_BAR_STYLES.INTERVAL: 
     73            self._drawIntervalColourBar(colourBarAxis, colourScheme, fontSize) 
     74             
    6475        else: 
    6576            self._drawContiunousColourBar(colourBarAxis, colourScheme, fontSize) 
     
    6980    def _drawContiunousColourBar(self, axes, colourScheme, fontSize): 
    7081         
    71         intervalColourbar = isinstance(colourScheme, geoplot.colour_scheme.IntervalColourScheme) 
    72           
    7382        kwargs = {} 
    74         kwargs['cmap'] = colourScheme.colourMap 
     83        kwargs['cmap'] = colourScheme.cmap 
    7584        kwargs['norm'] = colourScheme.norm 
    7685         
    7786        kwargs['orientation'] = self.colourBarPosition 
    7887         
    79         if intervalColourbar: 
    80             kwargs['ticks'] = colourScheme.midpoints 
    81             kwargs['format'] = matplotlib.ticker.FixedFormatter(colourScheme.labels) 
    82             kwargs['spacing'] = 'proportional' 
     88#        if intervalColourbar: 
     89#            kwargs['ticks'] = colourScheme.midpoints 
     90#            kwargs['format'] = matplotlib.ticker.FixedFormatter(colourScheme.labels) 
     91#            kwargs['spacing'] = 'proportional' 
    8392         
    8493        cb = ColorbarBase(axes, **kwargs) 
    8594 
    86         if cb.cmap.__class__ == ListedColormap \ 
    87            and not intervalColourbar: 
     95        if cb.cmap.__class__ == ListedColormap: 
    8896            ColourBar._repositionColourBarTicks(cb) 
    8997             
     
    94102        return cb 
    95103     
    96     def _drawLegendColourBar(self, colourBarAxis, colourScheme, fontSize): 
    97         """ 
    98          
    99         """ 
     104 
     105    def _drawIntervalColourBar(self, axes, colourScheme, fontSize): 
     106         
    100107        kwargs = {} 
    101          
    102         cmap = colourScheme.colourMap 
     108        kwargs['cmap'] = colourScheme.getListedCmap() 
     109        kwargs['norm'] = colourScheme.getBoundaryNorm() 
     110        kwargs['orientation'] = self.colourBarPosition 
     111         
     112        kwargs['ticks'] = colourScheme.intervals.bounds 
     113  
     114        labelFormat = "%.2f" 
     115        labels  = [ labelFormat % (bound,) for bound in colourScheme.intervals.bounds] 
     116         
     117        kwargs['format'] = matplotlib.ticker.FixedFormatter(labels) 
     118        kwargs['spacing'] = 'proportional' 
     119         
     120        cb = ColorbarBase(axes, **kwargs) 
     121             
     122        if self.colourBarLabel != None: 
     123            labelDictionary = self.labelFont.getDict(fontSize) 
     124            cb.set_label(self.colourBarLabel, fontdict=labelDictionary) 
     125         
     126        return cb     
     127     
     128    def _drawLegendColourBar(self, colourBarAxis, colourScheme, fontSize, intervalNames): 
     129        """ 
     130         
     131        """ 
     132        kwargs = {} 
     133         
     134        cmap = colourScheme.cmap 
    103135        norm = colourScheme.norm 
    104136         
    105         locations, labels = colourScheme.midpoints, colourScheme.labels 
     137        bounds = colourScheme.intervals.bounds 
     138        labels = None 
     139         
     140        log.debug("intervalNames = %s" % (intervalNames,)) 
     141         
     142        if not intervalNames is None: 
     143             
     144            labels = filter(lambda x: x.strip() != '', intervalNames.split(',')) 
     145             
     146            if len(labels) != len(colourScheme.intervals.midpoints): 
     147                 
     148                log.warning("Number of labels found (%s) is != to the number of midpoints (%s), using default labels instead" \ 
     149                                % (len(labels), len(colourScheme.intervals.midpoints))) 
     150                labels = None                  
     151         
     152        if labels is None: 
     153            if colourScheme.scale == COLOUR_SCHEME_SCALE.LOG: 
     154                labelFormat = "%.1e" 
     155            else: 
     156                labelFormat = "%.2f" 
     157                 
     158            lfString = labelFormat + " - " + labelFormat 
     159            labels  = [ lfString % (bounds[index], bounds[index + 1]) for index in range(len(bounds)-1)]         
     160         
     161        locations = colourScheme.intervals.midpoints 
    106162 
    107163        kwargs['orientation'] = self.colourBarPosition 
     
    110166        labels = labels 
    111167         
    112         if self.colourBarPosition == 'horizontal': 
    113             if len(handles) < 3: 
    114                 ncol = len(handles) 
     168        log.debug("locations = %s" % ([i for i in locations],)) 
     169        log.debug("norm = %s" % ([norm(i) for i in locations],)) 
     170        log.debug("legend colours = %s" % ([cmap(norm(i)) for i in locations],)) 
     171         
     172        x = 1.5e-3 
     173        log.debug(" %s, norm = %s, colour = %s" % (x, norm(x), cmap(norm(x)))) 
     174         
     175        if self.colourBarPosition == 'horizontal' : 
     176            if colourScheme.scale == COLOUR_SCHEME_SCALE.LINEAR: 
     177                numCols = 3 
    115178            else: 
    116                 ncol = 3 
     179                numCols = 2 
     180                 
     181            if len(handles) < numCols: 
     182                numCols = len(handles) 
    117183        else: 
    118             ncol = 1 
     184            numCols = 1 
    119185 
    120186        leg = colourBarAxis.legend(handles, labels, loc=10, mode='expand',  
    121                                    ncol=ncol, borderaxespad=0) 
     187                                   ncol=numCols, borderaxespad=0) 
    122188         
    123189        colourBarAxis.set_xticks([]) 
     
    138204         
    139205        """ 
    140         kwargs = {} 
    141          
    142         cmap = colourScheme.colourMap 
     206         
     207        cmap = colourScheme.cmap 
    143208        norm = colourScheme.norm 
    144         levels = colourScheme.bounds 
     209        levels = colourScheme.intervals.bounds 
    145210        colours = [cmap(norm(x)) for x in levels] 
    146211        widths = [1.0 for x in levels] 
    147212         
    148          
    149         cb = ColorbarBase(colourBarAxis, norm=norm,  
    150                           orientation='horizontal',  
    151                           filled=False) 
     213        # to stop the lines being mixed up with the edges of the colour 
     214        # bar extend the normalisation limits a bit. 
     215        downShift = (levels[1] - levels[0])/4.0 
     216        upShift = (levels[-1] - levels[-2])/4.0 
     217         
     218        n2 =norm.__class__(norm.vmin - downShift, norm.vmax + upShift) 
     219         
     220        kwargs = {} 
     221        kwargs['norm'] = n2 
     222        kwargs['ticks'] =  colourScheme.intervals.bounds 
     223  
     224        labelFormat = "%.2f" 
     225        labels  = [ labelFormat % (bound,) for bound in colourScheme.intervals.bounds] 
     226         
     227        kwargs['orientation'] = 'horizontal' 
     228        kwargs['filled'] = False 
     229        kwargs['extend'] = 'neither' 
     230        kwargs['format'] = matplotlib.ticker.FixedFormatter(labels) 
     231         
     232        if colourScheme.scale == COLOUR_SCHEME_SCALE.LOG: 
     233            kwargs['spacing'] = 'uniform' 
     234        else: 
     235            kwargs['spacing'] = 'proportional' 
     236        log.debug("kwargs = %s" % (kwargs,)) 
     237         
     238        log.debug("norm.__class__ = %s" % (norm.__class__,)) 
     239        log.debug("n2.__class__ = %s" % (n2.__class__,)) 
     240        log.debug("colourScheme.scale = %s" % (colourScheme.scale,)) 
     241         
     242        cb = ColorbarBase(colourBarAxis, **kwargs) 
     243         
     244        log.debug("cb.dividers = %s" % (cb.dividers,)) 
    152245         
    153246        cb.add_lines(levels, colours, widths) 
    154  
    155 #        colourBarAxis.set_xticks([]) 
    156 #        colourBarAxis.set_yticks([]) 
    157247         
    158248        if self.colourBarLabel != None: 
     
    160250            cb.set_label(self.colourBarLabel, fontdict=labelDictionary) 
    161251         
     252        #get rid of any additional tick on the colourBarAxis 
     253        colourBarAxis.minorticks_off() 
     254        for ax in (colourBarAxis.xaxis, colourBarAxis.yaxis): 
     255            ax.set_ticks_position('none') 
     256 
    162257        return cb 
    163258         
     
    261356     
    262357    #build a colour scheme 
    263     log.debug("colourBarScale = %s" % (colourBarScale,)) 
     358    log.debug("intervalNames = %s" % (intervalNames,)) 
    264359    schemeBuilder = geoplot.colour_scheme.ColourSchemeBuilder(cmap=cmap,  
    265360                 colourBarMin=colourBarMin,  
     
    267362                 colourBarScale=colourBarScale, 
    268363                 numIntervals=numIntervals, 
    269                  intervals=intervals, 
    270                  intervalNames=intervalNames) 
     364                 intervals=intervals) 
    271365     
    272366    colourScheme = schemeBuilder.buildScheme(colourBarStyle)     
     
    293387         
    294388    cbHeight = 0.9 - cbBottom 
    295     axes = fig.add_axes([0.05, cbBottom, 0.9, cbHeight], frameon=False) 
     389    axes = fig.add_axes([0.05, cbBottom, 0.9, cbHeight], frameon=False, xticks=[], yticks=[]) 
    296390     
    297391    cb = ColourBar(colourBarLabel=label,  
     
    299393                   colourBarStyle=colourBarStyle) 
    300394     
    301     cb.draw(axes, colourScheme)     
     395    cb.draw(axes, colourScheme, 
     396            intervalNames=intervalNames)     
    302397     
    303398    return geoplot.utils.figureToImage(fig) 
  • qesdi/geoplot/trunk/lib/geoplot/colour_scheme.py

    r6103 r6118  
    1414from geoplot.range import Range 
    1515from geoplot.fixed_boundary_norm import FixedBoundaryNorm 
    16 from geoplot.colour_bar import COLOUR_BAR_STYLES, COLOUR_SCHEME_SCALE 
     16from geoplot.colour_bar import COLOUR_SCHEME_SCALE 
    1717from geoplot.colour_scheme_intervals import ColourSchemeIntervalBuilder 
    1818 
     
    2222 
    2323class ColourScheme(object): 
     24    """ 
     25    A colour scheme object used to keep track of the colourbar, normalization and 
     26    intervals asociated with a plot 
     27    """ 
    2428     
    25     def __init__(self, colourMap, norm, scale): 
    26         self.colourMap = colourMap 
     29    def __init__(self, cmap, norm, intervals, scale): 
     30        ''' 
     31        @param cmap: the supplied matplotlib colourmap (may be listed if one 
     32          was given) 
     33        @type cmap: 
     34        @param norm: a Normalize instance for the colour bar boundaries given 
     35        @type norm: 
     36        @param intervals: the colour bar intervals supplied (or default intervals) 
     37        @type intervals: 
     38        ''' 
     39         
     40        self.cmap = cmap 
    2741        self.norm = norm 
     42        self.intervals = intervals 
    2843        self.scale = scale 
     44         
     45    def getListedCmap(self): 
     46        if self.cmap.__class__ != matplotlib.colors.ListedColormap: 
     47             
     48            if len(self.intervals.midpoints) == 1: 
     49                #only one interval value so pick the middle of the cmap 
     50                colors = [ self.cmap(0.5) ] 
     51                cmap = matplotlib.colors.ListedColormap(colors) 
     52            else: 
     53                colors = [self.cmap(self.norm(x)) for x in self.intervals.midpoints] 
     54                cmap = matplotlib.colors.ListedColormap(colors) 
     55        else: 
     56            cmap = self.cmap 
     57         
     58        return cmap      
     59     
     60    def getBoundaryNorm(self): 
     61        return FixedBoundaryNorm(self.intervals.bounds, len(self.intervals.bounds) - 1 ) 
    2962 
    30 class ContinuousColourScheme(ColourScheme): 
    31     pass 
    32  
    33 class IntervalColourScheme(ColourScheme): 
    34          
    35     def __init__(self, colourMap, norm, scale, labels, midpoints, bounds, labelFormat): 
    36         self.labels = labels 
    37         self.midpoints = midpoints 
    38         self.bounds = bounds 
    39         self.labelFormat = labelFormat 
    40         ColourScheme.__init__(self, colourMap, norm, scale) 
    41          
    4263 
    4364class ColourSchemeBuilder(object): 
    4465     
    45     def __init__(self, cmap=None,  
     66    def __init__(self, cmap='jet',  
    4667                 colourBarMin=None,  
    4768                 colourBarMax=None, 
    48                  colourBarScale=COLOUR_SCHEME_SCALE.LINEAR,  
    49                  hideOutsideBounds=False, 
     69                 colourBarScale=COLOUR_SCHEME_SCALE.LINEAR, 
    5070                 numIntervals=6, 
    51                  labelFormat=None, 
    52                  intervals=None, 
    53                  intervalNames=None): 
     71                 intervals=None): 
    5472 
    55         self._numIntervals = None 
    56          
     73        self._numIntervals = 6 
    5774        self.cmap = cmap 
    5875        self.colourBarMin = colourBarMin 
    5976        self.colourBarMax = colourBarMax 
    6077        self.colourBarScale = colourBarScale 
    61         self.hideOutsideBounds = hideOutsideBounds 
    6278        self.numIntervals = numIntervals 
    6379        self.intervals = intervals 
    64         self.intervalNames = intervalNames 
    6580        self._intervalBuilder = ColourSchemeIntervalBuilder() 
    66         self.labelFormat = labelFormat 
    6781         
    68     def buildScheme(self, colourBarStyle, grid=None): 
     82    def buildScheme(self, grid=None): 
    6983         
    7084        cbRange = self._getCbarRange(grid) 
    71         initialCmap = self._getColourMap() 
    7285         
    73         assert colourBarStyle in COLOUR_BAR_STYLES.all(), " %s not in %s" % (colourBarStyle, COLOUR_BAR_STYLES.all()) 
    74  
     86        if self.colourBarScale == COLOUR_SCHEME_SCALE.LOG: 
     87            cbRange = self._adjustCBRangeForLog(cbRange) 
    7588         
    76         if self.labelFormat is None: 
    77             if self.colourBarScale == COLOUR_SCHEME_SCALE.LINEAR: 
    78                 self.labelFormat = "%.2f" 
     89        cmap = self._getColourMap() 
     90         
     91        intervals = self._intervalBuilder.buildCSInterval(cbRange,  
     92                            self.colourBarScale,  
     93                            self.intervals,  
     94                            numIntervals=self.numIntervals) 
     95         
     96        norm = self._buildNorm(cbRange)         
     97         
     98        return ColourScheme(cmap, norm, intervals, self.colourBarScale) 
     99     
     100    def _buildNorm(self, cbRange): 
     101         
     102        norm = None 
     103         
     104        if self.colourBarScale == COLOUR_SCHEME_SCALE.LOG: 
     105             
     106            if cbRange.minimum is not None and cbRange.minimum > 0 \ 
     107               and cbRange.maximum is not None and cbRange.maximum > 0: 
     108                norm = matplotlib.colors.LogNorm(cbRange.minimum, cbRange.maximum) 
    79109            else: 
    80                 self.labelFormat = "%.1E" 
    81   
     110                log.warning("Can't create a log colour scheme with min = %s and max = %s"  
     111                             % (cbRange.minimum, cbRange.maximum)) 
     112                
     113        if norm == None:     
     114            norm = matplotlib.colors.Normalize(cbRange.minimum, cbRange.maximum) 
    82115         
    83         if colourBarStyle in [COLOUR_BAR_STYLES.LEGEND, 
    84                               COLOUR_BAR_STYLES.LINE]: 
    85             builder = self._getIntervalBuilder(cbRange, initialCmap) 
    86         else: 
    87             builder = self._getContinuousBuilder(cbRange, initialCmap) 
    88  
    89         scheme = builder.buildScheme() 
    90          
    91         if self.hideOutsideBounds: 
    92             scheme.norm.clip = False 
    93          
    94         return scheme 
     116        return norm 
    95117     
    96     def _getIntervalBuilder(self,cbRange, initialCmap): 
    97          
    98         interval = self._intervalBuilder.buildCSInterval(cbRange, self.colourBarScale, self.labelFormat,  
    99                                                          self.intervals, self.intervalNames,  
    100                                                          numIntervals=self.numIntervals) 
    101         log.debug("interval = %s" % (interval,)) 
    102         builder = _IntervalSchemeBuidler(cbRange, self.colourBarScale, initialCmap, interval, self.labelFormat) 
    103          
    104         return builder 
    105      
    106     def _getContinuousBuilder(self, cbRange, initialCmap): 
    107         builder = _ConinuousSchemeBuilder(cbRange, self.colourBarScale, initialCmap) 
    108         return builder 
    109  
    110118    def _getColourMap(self): 
    111119        """ 
     
    127135            cmap = self.cmap 
    128136                 
    129         if self.hideOutsideBounds: 
    130             log.debug("self.hideOutsideBounds = %s" % (self.hideOutsideBounds,)) 
    131             cmap.set_under('0.25', alpha=0.0) 
    132             cmap.set_over('0.75', alpha=0.0) 
    133              
    134137        return cmap 
    135138     
     
    156159        return Range(cbMin, cbMax) 
    157160     
    158      
     161    def _adjustCBRangeForLog(self, cbRange): 
     162        adjustedRange = Range(cbRange.minimum, cbRange.maximum) 
     163         
     164        if adjustedRange.maximum <= 0.0: 
     165            adjustedRange.maximum = 1.0 
     166         
     167        if adjustedRange.minimum <= 0.0: 
     168                             
     169            if adjustedRange.maximum >= 10.0: 
     170                adjustedRange.minimum = 1.0 
     171            else: 
     172                adjustedRange.minimum = 10 ** (numpy.log10(adjustedRange.maximum) - 2) 
     173         
     174        return adjustedRange 
    159175     
    160176    def __set_numIntervals(self, value): 
     
    168184         
    169185    numIntervals = property(__get_numIntervals, __set_numIntervals, None, None) 
    170  
    171 class _ConinuousSchemeBuilder(): 
    172     """ 
    173     This class knows how to buld a continuous colour scheme. 
    174     """ 
    175      
    176     def __init__(self, cbRange, cbScale, initialCmap): 
    177         self.cbRange = cbRange 
    178         self.initialCmap = initialCmap 
    179         self.cbScale = cbScale 
    180      
    181     def buildScheme(self): 
    182         cmap = self._buildColourMap() 
    183         norm = self._buildNorm() 
    184         return ContinuousColourScheme(cmap, norm, self.cbScale) 
    185      
    186     def _buildColourMap(self): 
    187         return self.initialCmap 
    188      
    189     def _buildNorm(self): 
    190          
    191         norm = None 
    192          
    193         if self.cbScale == 'log': 
    194              
    195             if self.cbRange.minimum is not None and self.cbRange.minimum > 0 \ 
    196                and self.cbRange.maximum is not None and self.cbRange.maximum > 0: 
    197                 norm = matplotlib.colors.LogNorm(self.cbRange.minimum, self.cbRange.maximum) 
    198             else: 
    199                 log.warning("Can't create a log colour scheme with min = %s and max = %s"  
    200                              % (self.cbRange.minimum, self.cbRange.maximum)) 
    201                  
    202          
    203         if norm == None:     
    204             norm = matplotlib.colors.Normalize(self.cbRange.minimum, self.cbRange.maximum) 
    205          
    206         return norm 
    207  
    208 class _IntervalSchemeBuidler(): 
    209      
    210     def __init__(self, cbRange, cbScale, initialCmap, csInterval, labelFormat): 
    211         self.cbRange = cbRange 
    212         self.cbScale = cbScale 
    213         self.initialCmap = initialCmap 
    214         self.csInterval = csInterval 
    215         self.labelFormat = labelFormat 
    216          
    217     def buildScheme(self): 
    218         """ 
    219         Builds an interval colour scheme using either the unique values form 
    220         the grid or the bounds in the intervalBoundsString 
    221         """ 
    222          
    223         labels = self.csInterval.labels 
    224         cmap = self._buildColourMap() 
    225         norm = self._getNorm() 
    226          
    227         return IntervalColourScheme(cmap, norm, self.cbScale, labels, self.csInterval.midpoints, self.csInterval.bounds, self.labelFormat) 
    228      
    229     def _buildColourMap(self): 
    230         """ 
    231         Returns a (possibly) modified version of the initialCmap that corresponds 
    232         to the values given by the _ColourSchemeInterval. 
    233         """         
    234         if self.initialCmap.__class__ != matplotlib.colors.ListedColormap: 
    235              
    236             if len(self.csInterval.midpoints) == 1: 
    237                 #only one interval value so pick the middle of the cmap 
    238                 colors = [ self.initialCmap(0.5) ] 
    239                 cmap = matplotlib.colors.ListedColormap(colors) 
    240             else: 
    241                 n = matplotlib.colors.Normalize(self.csInterval.midpoints.min(),  
    242                                                 self.csInterval.midpoints.max()) 
    243      
    244                 colors = [self.initialCmap(n(x)) for x in self.csInterval.midpoints] 
    245                 cmap = matplotlib.colors.ListedColormap(colors) 
    246         else: 
    247             cmap = self.initialCmap 
    248          
    249         return cmap      
    250                          
    251     def _getNorm(self): 
    252         """ 
    253         Returns a Boundary Normalisation object for the given _ColourSchemeInterval. 
    254         """ 
    255         norm = FixedBoundaryNorm(self.csInterval.bounds, len(self.csInterval.bounds) - 1 ) 
    256         return norm 
    257      
  • qesdi/geoplot/trunk/lib/geoplot/colour_scheme_intervals.py

    r6103 r6118  
    77import numpy 
    88import utils 
     9from geoplot.range import Range 
    910from geoplot.colour_bar import COLOUR_SCHEME_SCALE 
    1011 
     
    1920    """ 
    2021     
    21     def __init__(self, midpoints, bounds, labels): 
     22    def __init__(self, midpoints, bounds): 
    2223        self.midpoints = midpoints 
    2324        self.bounds = bounds 
    24         self.labels = labels 
    2525         
    2626class ColourSchemeIntervalBuilder(object): 
     
    2929        pass 
    3030     
    31     def buildCSInterval(self, cbRange, scale, labelFormat="%.2f", boundsString=None, labelsString=None, numIntervals=None): 
     31    def buildCSInterval(self, cbRange, scale, boundsString=None, numIntervals=None): 
    3232         
     33        if numIntervals is None: 
     34            numIntervals = DEFAULT_NUM_INTERVALS 
     35             
    3336        bounds = None 
    3437        if boundsString is not None: 
    3538             
    36             log.debug("boundsString = %s" % (boundsString,)) 
    37             log.debug("cbRange.minimum = %s, cbRange.maximum = %s" % (cbRange.minimum, cbRange.maximum,)) 
    3839            bounds = numpy.array([float(x) for x in self._splitString(boundsString)]) 
    3940            bounds = sorted(bounds) 
     
    4546             
    4647        if bounds is None: 
    47             if numIntervals is None: 
    48                 numIntervals = DEFAULT_NUM_INTERVALS 
    4948                 
    5049            bounds = self._getBoundsFromRange(cbRange, scale, numIntervals) 
    5150             
    52         interval = self._buildCSIntervalFromBounds(bounds, labelsString, labelFormat)         
     51        interval = self._buildCSIntervalFromBounds(bounds)         
    5352         
    5453        return interval 
    5554         
    56     def _buildCSIntervalFromBounds(self, bounds, labelsString, labelFormat): 
     55    def _buildCSIntervalFromBounds(self, bounds): 
    5756        """ 
    5857        Builds a _ColourSchemeInterval object from a list of bounds. 
     
    6059        midpoints = utils.getMidpoints(bounds) 
    6160 
    62         labels = self._getLabels(labelsString) 
    63          
    64         # check that there are the right number of labels 
    65         if labels is not None and len(labels) != len(midpoints): 
    66             log.warning("Number of labels found (%s) is != to the number of midpoints (%s), using default labels instead" \ 
    67                             % (len(labels), len(midpoints))) 
    68             labels = None 
    69          
    70         # build some default labels 
    71         if labels is None: 
    72             lfString = labelFormat + " - " + labelFormat 
    73             labels  = [ lfString % (bounds[index], bounds[index + 1]) for index in range(len(bounds)-1)] 
    74              
    75         return ColourSchemeInterval(midpoints, bounds, labels) 
     61        return ColourSchemeInterval(midpoints, bounds) 
    7662 
    77     def _getLabels(self, labelsString): 
    78         if labelsString == None: 
    79             return None 
    80         else: 
    81             return self._splitString(labelsString) 
    82                  
    8363     
    8464    def _splitString(self, csvString): 
     
    11393        #start with the lower of the top bound 
    11494        for i in range(len(bounds) - 1, -1, -1): 
    115             print  range(len(bounds) - 1, -1, -1) 
    116             print bounds[i] 
    11795            if bounds[i] > cbRange.maximum: 
    11896                upperBoundRemoved = True 
     
    134112        if scale == COLOUR_SCHEME_SCALE.LOG: 
    135113 
    136             lmin = numpy.log10(cbRange.minimum) 
    137             lmax = numpy.log10(cbRange.maximum) 
     114            logRange = Range(numpy.log10(cbRange.minimum),  
     115                             numpy.log10(cbRange.maximum)) 
    138116             
    139             bounds = numpy.logspace(lmin, lmax, numLabels + 1) 
     117            bounds = numpy.logspace(logRange.minimum, logRange.maximum,  
     118                                    numLabels + 1, endpoint=True) 
    140119        else: 
    141120            bounds = numpy.linspace(cbRange.minimum, cbRange.maximum, numLabels + 1) 
  • qesdi/geoplot/trunk/lib/geoplot/config.ini

    r5946 r6118  
    132132family=sans-serif 
    133133sizeSmall=6 
    134 sizeMedium=10 
    135 sizeLarge=14 
    136 sizeXL=18 
    137 sizeXXL=22 
     134sizeMedium=8 
     135sizeLarge=12 
     136sizeXL=16 
     137sizeXXL=20 
  • qesdi/geoplot/trunk/lib/geoplot/contour_drawer.py

    r6103 r6118  
    3535    """ 
    3636 
    37     def __init__(self, numContourLines=10, contourLabelInterval=1, contourLineWidth=0.5): 
     37    def __init__(self, numContourLines=10, contourLabelInterval=1,  
     38                 contourLineWidth=0.5, 
     39                 contourLabelFormat="%.2f"): 
    3840        """ 
    3941        Constructs a ContourDrawer object               
     
    4345        self.contourLabelInterval = contourLabelInterval 
    4446        self.contourLineWidth = contourLineWidth 
     47        self.contourLabelFormat = contourLabelFormat 
    4548        self._contourFont = config['Fonts']['ContourLines'] 
    4649         
     
    8588#                labelFormat = "%1.3f" 
    8689             
    87              
     90            levels = scheme.intervals.bounds 
     91            # make sure the upper contour line is drawn if it is the highest 
     92            # value in Z 
     93            if levels[-1] == grid_mapUnits.values.max(): 
     94                levels[-1] = levels[-1] * 0.999999 
    8895             
    8996            CS = axes.contour(grid_mapUnits.midpointsX,  
    9097                              grid_mapUnits.midpointsY,  
    9198                              grid_mapUnits.values, 
    92                               scheme.bounds, 
    93                  cmap=scheme.colourMap, 
     99                              levels, 
     100                 cmap=scheme.cmap, 
    94101                 origin='lower', 
    95102                 linewidths=self.contourLineWidth, 
     
    101108             
    102109            axes.clabel(CS, 
    103                         scheme.bounds[0::self.contourLabelInterval],  
     110                        levels[0::self.contourLabelInterval],  
    104111                        fontsize=labelDictionary['size'], 
    105                         fmt=scheme.labelFormat) 
     112                        fmt=self.contourLabelFormat) 
    106113             
    107114            axes.set_aspect('auto') 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer.py

    r6089 r6118  
    1313 
    1414import geoplot.utils as geoplot_utils 
    15 from geoplot.colour_bar import COLOUR_BAR_STYLES 
    1615from geoplot.grid_factory import GridFactory 
    1716from geoplot.map_factory import MapFactory 
     
    3938                 colourBarMax=None,  
    4039                 colourBarScale='linear', 
    41                  colourBarStyle=COLOUR_BAR_STYLES.CONTINUOUS, 
    4240                 intervals=None,  
    43                  bgcolour='white'): 
     41                 bgcolor='white'): 
    4442         
    4543         
    4644        self._csBuilder = ColourSchemeBuilder() 
    47         self._bgcolour = 'white' 
    48          
    49         self.colourBarStyle = colourBarStyle 
     45        self._bgcolor = 'white' 
    5046         
    5147        self.colourBarScale = colourBarScale 
    5248        self.transparent = transparent 
    5349        self.cmap = cmap 
    54          
    55         log.debug("bgcolour = %s" % (bgcolour,)) 
    56         self.bgcolour = bgcolour 
     50        self.bgcolor = bgcolor 
    5751         
    5852        self._gridFactory = GridFactory(dataType=gridType) 
     
    10397 
    10498        figsize=(width / float(dpi), height / float(dpi)) 
    105  
    106         fig = Figure(figsize=figsize, dpi=dpi, facecolor=self.bgcolour, edgecolor=self.bgcolour, 
     99        log.debug("creating figure, facecolor = %s, transparent = %s, " % (self.bgcolor, self.transparent)) 
     100        fig = Figure(figsize=figsize, dpi=dpi, facecolor=self.bgcolor, edgecolor=self.bgcolor, 
    107101                     frameon=(not self.transparent)) 
     102         
     103        log.debug("fig.get_facecolor() = %s" % (fig.get_facecolor(),))         
    108104         
    109105        return fig         
     
    120116         
    121117        axes = matplotlib.axes.Axes(figure, [0.0, 0.0, 1.0, 1.0],  
    122                                     xticks=[], yticks=[], frameon=False) 
     118                                    xticks=[], yticks=[], frameon=False, axisbg=self.bgcolor) 
    123119         
    124120        figure.add_axes(axes) 
     
    130126            axes.set_alpha(0.0) 
    131127            axes.patch.set_alpha(0.0) 
    132              
     128         
     129        log.debug("axes.get_axis_bgcolor() = %s" % (axes.get_axis_bgcolor(),)) 
    133130         
    134131        return axes 
     
    277274 
    278275    colourBarMax = property(__get_colourBarMax, __set_colourBarMax) 
    279      
    280     def __set_colourBarScale(self, value): 
    281         self._csBuilder.colourBarScale = value 
    282      
    283     def __get_colourBarScale(self): 
    284         return self._csBuilder.colourBarScale 
    285  
    286     colourBarScale = property(__get_colourBarScale, __set_colourBarScale) 
    287              
    288     def __set_bgcolour(self, value): 
     276                
     277    def __set_bgcolor(self, value): 
    289278         
    290279        try: 
     
    293282            log.warning("Error occurred getting matplotlib colour form %s, Exception:%s" % (value, e)) 
    294283        else: 
    295             self._bgcolour = newVal 
     284            self._bgcolor = newVal 
    296285                 
    297     def __get_bgcolour(self): 
    298         return self._bgcolour 
    299      
    300     bgcolour = property(__get_bgcolour, __set_bgcolour)     
    301      
     286    def __get_bgcolor(self): 
     287        return self._bgcolor 
     288     
     289    bgcolor = property(__get_bgcolor, __set_bgcolor)     
     290     
     291    def __set_colourBarScale(self, value): 
     292        if value in COLOUR_SCHEME_SCALE.all(): 
     293            self._csBuilder.colourBarScale = value 
     294        else: 
     295            log.warning("colour scheme scale %s isn't in %s" % (value, COLOUR_SCHEME_SCALE.all()))  
     296     
     297    def __get_colourBarScale(self): 
     298        return self._csBuilder.colourBarScale 
     299     
     300    colourBarScale = property(__get_colourBarScale, __set_colourBarScale, None, None)     
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_coastline.py

    r5980 r6118  
    2222                 resolution='i',  
    2323                 transparent=False,  
    24                  bgcolour='white', 
     24                 bgcolor='white', 
    2525                 coastlineColour='black', 
    2626                 riverColour=None, 
     
    4141                                 projection=projection, 
    4242                                 resolution=resolution, 
    43                                  bgcolour=bgcolour 
     43                                 bgcolor=bgcolor 
    4444                                 ) 
    4545         
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_contour.py

    r6103 r6118  
    2323        self.labelInterval =labelInterval 
    2424        self.lineWidth = lineWidth 
    25         log.debug("kwargs = %s" % (kwargs,)) 
    2625        self.numLines = numLines 
    2726         
     
    3332        grid = self._buildGrid(self.cdmsVar, xLimits, yLimits) 
    3433         
    35         scheme = self._csBuilder.buildScheme(self.colourBarStyle, grid=grid) 
     34        scheme = self._csBuilder.buildScheme(grid=grid) 
    3635         
    3736        #if the projection is 'latlon' then no transformation is needed. 
     
    4241            basemap = map.basemap         
    4342         
    44          
    45         cmap = scheme.colourMap 
    46          
    4743        #set the bad colour to transparent 
    48         cmap.set_bad('w', 0.0) 
     44        scheme.cmap.set_bad('w', 0.0) 
    4945         
    5046        self._contourDrawer.draw(axes, grid, scheme, 
    51                                  basemap=basemap, fontSize=self.fontSize) 
     47                                 basemap=basemap,  
     48                                 fontSize=self.fontSize) 
    5249     
    5350    ### properties ### 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid.py

    r6089 r6118  
    44 
    55import logging 
    6 import time 
    76 
    8 import geoplot.utils as geoplot_utils 
    97from geoplot.grid_drawer import GridDrawer 
    108from geoplot.layer_drawer import LayerDrawerBase 
     
    1715    def __init__(self, cdmsVar, showGridLines=False, outline=False, 
    1816                 hideOutside=False,  
     17                 drawIntervals=False, 
    1918                 numIntervals = None, **kwargs): 
    2019         
     20        LayerDrawerBase.__init__(self, **kwargs) 
     21         
     22        self._gridDrawer = GridDrawer() 
     23 
     24        self.cdmsVar = cdmsVar 
    2125        self.numIntervals = numIntervals 
    2226        self.hideOutside = hideOutside 
    23          
    24          
    25         self._gridDrawer = GridDrawer() 
    26          
    27         self.cdmsVar = cdmsVar 
    2827        self.showGridLines = showGridLines 
    2928        self.outline = outline 
     29        self.drawIntervals = drawIntervals 
    3030         
    31         LayerDrawerBase.__init__(self, **kwargs) 
    3231         
    3332    def _drawToAxes(self, axes, xLimits, yLimits): 
     
    3837        grid = self._buildGrid(self.cdmsVar, xLimits, yLimits) 
    3938         
     39        scheme = self._csBuilder.buildScheme(grid=grid) 
     40         
     41        self._applyMask(grid, scheme, self.hideOutside) 
     42         
     43        #draw the grid on the axis 
     44        self._gridDrawer.draw(axes, grid, 
     45                              basemap=self._getBasemap(xLimits, yLimits),  
     46                              limits=(xLimits, yLimits), 
     47                              norm=scheme.norm, 
     48                              cmap=self._getCmap(scheme) 
     49                              ) 
     50     
     51     
     52    def _getBasemap(self, xLimits, yLimits): 
     53         
    4054        # if the projection is latlon then there is no need to transform 
    4155        # the data on the grid. 
     
    4458        else: 
    4559            map = self._getMap(xLimits, yLimits) 
    46             basemap = map.basemap         
    47          
    48 #        map = self._getMap(xLimits, yLimits) 
    49 #        map.basemap.drawcoastlines(ax=axes, xLimits=xLimits, yLimits=yLimits) 
    50  
    51         scheme = self._csBuilder.buildScheme(self.colourBarStyle, grid=grid) 
    52         cmap = scheme.colourMap 
     60            basemap = map.basemap 
     61                     
     62        return basemap         
     63     
     64    def _getCmap(self, scheme): 
     65        if self.drawIntervals: 
     66            cmap = scheme.getListedCmap() 
     67        else: 
     68            cmap = scheme.cmap 
     69             
    5370        #set the bad colour to transparent 
    5471        cmap.set_bad('w', 0.0) 
    5572         
    56         self._applyMask(grid, scheme, self.hideOutside) 
    57          
    58         #draw the grid on the axis 
    59         self._gridDrawer.draw(axes, grid, 
    60                               basemap=basemap,  
    61                               limits=(xLimits, yLimits), 
    62                               norm=scheme.norm, 
    63                               cmap=cmap) 
    64          
     73        return cmap 
    6574     
    6675    ### properties ### 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid_fast.py

    r6089 r6118  
    77 
    88import geoplot.utils as geoplot_utils 
    9 from geoplot.grid_drawer import GridDrawer 
    10 from geoplot.layer_drawer import LayerDrawerBase 
    11 from geoplot.colour_scheme import ColourSchemeBuilder 
     9from geoplot.layer_drawer_grid import LayerDrawerGrid 
    1210from geoplot.grid_builder_lat_lon_subset import GridBuilderLatLonSubset 
    13  
    14 import numpy 
    15  
    16 from geoplot.colour_bar import COLOUR_BAR_STYLES 
    1711 
    1812log = logging.getLogger(__name__) 
    1913 
    20 class LayerDrawerGridFast(LayerDrawerBase): 
     14class LayerDrawerGridFast(LayerDrawerGrid): 
    2115    "Draw a lat/lon grid using subsampling and assuming that the bounds are paralell" 
    2216     
    23     def __init__(self, cdmsVar, 
    24                  showGridLines=False,  
    25                  cmap=None,  
    26                  numIntervals=None, 
    27                  colourBarMin=None, 
    28                  colourBarMax=None,  
    29                  hideOutside=False, 
    30                  transparent=False, 
    31                  colourBarScale='linear', 
    32                  colourBarStyle=COLOUR_BAR_STYLES.CONTINUOUS, 
    33                  intervals=None,  
    34                  bgcolour='white'): 
    35          
    36         self._gridDrawer = GridDrawer() 
    37         self._csBuilder = ColourSchemeBuilder() 
    38         self.numIntervals = numIntervals 
    39         self.hideOutside = hideOutside 
    40          
    41         log.debug("self._csBuilder.hideOutsideBounds = %s" % (self._csBuilder.hideOutsideBounds,)) 
    42          
    43         self.colourBarStyle = colourBarStyle 
    44         self.cdmsVar = cdmsVar 
    45         self.showGridLines = showGridLines 
    46         self._bgcolour = 'white' 
    47          
    48         self.transparent = transparent 
    49         self.cmap = cmap 
    50         self.bgcolour = bgcolour 
    51          
    52         self.colourBarScale = colourBarScale 
    53         self.colourBarMin = colourBarMin 
    54         self.colourBarMax = colourBarMax 
    55         self.intervals = intervals 
    5617 
    5718    def makeImage(self, xLimits=None, yLimits=None, width=800, height=600, dpi=200): 
     
    6728        axTime = time.time()  
    6829 
     30        # modified the _buildGrid call to pass it the xLimits and yLimits to be  
     31        # used in the subsetting. 
    6932        grid = self._buildGrid(self.cdmsVar, width, height, xLimits, yLimits) 
    7033        gridTime = time.time()  
     
    10063        """ 
    10164         
    102              
     65        scheme = self._csBuilder.buildScheme(grid=grid) 
    10366         
    104         scheme = self._csBuilder.buildScheme(self.colourBarStyle, grid=grid) 
    105         cmap = scheme.colourMap 
     67        self._applyMask(grid, scheme, self.hideOutside) 
    10668         
    107         grid = self._applyMask(grid, scheme, self.hideOutside) 
    108          
    109         if self.transparent: 
    110             #set the bad colour to transparent 
    111             cmap.set_bad('w', 0.0) 
    112          
    113         #draw the grid on the axis 
     69        # draw the grid on the axis, not the basemap is None as it  
     70        # must be lat/lon 
    11471        self._gridDrawer.draw(axes, grid, 
    115                               basemap=None,  
     72                              basemap=self._getBasemap(xLimits, yLimits),  
    11673                              limits=(xLimits, yLimits), 
    11774                              norm=scheme.norm, 
    118                               cmap=cmap, 
     75                              cmap=self._getCmap(scheme), 
    11976                              assumeBoundsParallel=True) 
    120      
    121  
    12277                 
    12378     
    12479    ### properties ### 
    125                              
    126     def __set_showGridLines(self, value): 
    127         self._gridDrawer.showGridLines = value 
    128      
    129     def __get_showGridLines(self): 
    130         return self._gridDrawer.showGridLines 
    131      
    132     showGridLines = property(__get_showGridLines, __set_showGridLines)  
    133      
    134     def __set_outline(self, value): 
    135         self._gridDrawer.outline = value 
    13680         
    137     def __get_outline(self): 
    138         return self._gridDrawer.outline 
    139      
    140     outline = property(__get_outline, __set_outline) 
    141      
    14281    def __set_gridType(self, value): 
    14382        if value != 'latlon': 
     
    166105    projection = property(__get_projection, __set_projection, None, None) 
    167106     
    168     def __set_numIntervals(self, value): 
    169  
    170         self._csBuilder.numIntervals = value 
    171  
    172     def __get_numIntervals(self): 
    173         return self._csBuilder.numIntervals 
    174          
    175     numIntervals = property(__get_numIntervals, __set_numIntervals, None, None) 
    176      
    177     def __set_hideOutside(self, value): 
    178         self._hideOutsideBounds = value 
    179  
    180     def __get_hideOutside(self): 
    181         return self._hideOutsideBounds 
    182          
    183     hideOutside = property(__get_hideOutside, __set_hideOutside, None, None) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_colour_scheme_builder.py

    r6089 r6118  
    1313import matplotlib 
    1414import geoplot 
    15 from geoplot.colour_scheme import ColourSchemeBuilder, _ConinuousSchemeBuilder, _IntervalSchemeBuidler 
    16 from geoplot.colour_scheme_intervals import ColourSchemeInterval 
     15from geoplot.colour_bar import COLOUR_SCHEME_SCALE 
     16from geoplot.colour_scheme import ColourSchemeBuilder 
     17from geoplot.colour_scheme_intervals import ColourSchemeIntervalBuilder, ColourSchemeInterval 
    1718from geoplot.grid import Grid 
    1819from geoplot.range import Range 
    19 import geoplot.colour_scheme 
     20 
    2021 
    2122log = logging.getLogger(__name__) 
     
    2526    def setUp(self): 
    2627        self.builder = ColourSchemeBuilder() 
     28        self.builder._intervalBuilder = Mock(spec=ColourSchemeIntervalBuilder) 
     29        self.builder._intervalBuilder.return_value = Mock(spec=ColourSchemeInterval) 
     30         
    2731     
    2832    @patch('matplotlib.cm.get_cmap') 
    29     def test_001_getColouMap(self, mockGetCmap): 
     33    def test_001_returns_default_colour_map(self, mockGetCmap): 
    3034         
    31         # make sure that the _getColourMap function returns the correct  
    32         # colour map for the value of the cmap attribute 
     35        self.builder.cmap = None 
     36        mockGetCmap.return_value = Mock(spec=matplotlib.colors.Colormap) 
    3337         
    34         # when a cmap object is provided then that is used as the initial  
    35         # colour map 
    36         self.builder.cmap = Mock(spec=matplotlib.colors.ListedColormap) 
    37         returnedCmap = self.builder._getColourMap() 
    38         nt.assert_equal(id(self.builder.cmap), id(returnedCmap))         
     38        scheme = self.builder.buildScheme() 
    3939         
    40         # when a string is provided then the named colour map is retireved 
    41         self.builder.cmap = 'jet' 
     40        assert scheme.cmap == mockGetCmap.return_value 
     41        nt.assert_equal(mockGetCmap.call_args, ((),{}) )  
     42     
     43    @patch('matplotlib.cm.get_cmap') 
     44    def test_002_returns_named_colour_map(self, mockGetCmap): 
    4245         
    43         returnedCmap = self.builder._getColourMap() 
    44         nt.assert_equal(mockGetCmap.call_count, 1) # called the get_cmap function 
    45         nt.assert_equal(mockGetCmap.call_args, (('jet',), {})) # called with the right name 
    46         #check that the bad colour has been set on the new cmap 
    47         nt.assert_equal(returnedCmap.method_calls, [('set_bad', ('w',), {})]) 
     46        self.builder.cmap = 'some_name' 
     47        mockGetCmap.return_value = Mock(spec=matplotlib.colors.Colormap) 
    4848         
    49         mockGetCmap.reset_mock() 
     49        scheme = self.builder.buildScheme() 
    5050         
    51         # when cmap is None then get_cmap is called with no arguments to return 
    52         # the defaul colourmap 
    53         self.builder.cmap = None 
     51        assert scheme.cmap == mockGetCmap.return_value 
     52        nt.assert_equal(mockGetCmap.call_args, (('some_name',),{}) ) 
    5453         
    55         returnedCmap = self.builder._getColourMap() 
    56         nt.assert_equal(mockGetCmap.call_count, 1) # called the get_cmap function 
    57         nt.assert_equal(mockGetCmap.call_args, ((), {})) # called with no arguments 
    58         #check that the bad colour has been set on the new cmap 
    59         nt.assert_equal(returnedCmap.method_calls, [('set_bad', ('w',), {})]) 
     54    def test_003_buildsCBRange(self): 
    6055         
    61     def test_002_getCBMinMaxSwapsValues(self): 
     56        # no grid 
     57        scheme = self.builder.buildScheme() 
     58        nt.assert_equal( (scheme.norm.vmin, scheme.norm.vmax), (0,1)) 
     59         
     60        # with a grid 
     61        mockGrid = Mock(spec=Grid) 
     62        mockGrid.getMinValue.return_value = 19 
     63        mockGrid.getMaxValue.return_value = 200 
     64         
     65        scheme = self.builder.buildScheme(mockGrid) 
     66        nt.assert_equal( (scheme.norm.vmin, scheme.norm.vmax),  
     67                         (mockGrid.getMinValue.return_value, mockGrid.getMaxValue.return_value)) 
     68         
     69        # with cbar min/max 
     70        self.builder.colourBarMin = -100 
     71        self.builder.colourBarMax = -50 
     72        scheme = self.builder.buildScheme(mockGrid) 
     73        nt.assert_equal( (scheme.norm.vmin, scheme.norm.vmax),  
     74                         (self.builder.colourBarMin, self.builder.colourBarMax)) 
     75     
     76    def test_004_buildsNorm(self):       
     77         
     78        # linear norm 
     79        self.builder.colourBarMin = -100 
     80        self.builder.colourBarMax = -50 
     81        self.builder.colourBarScale = COLOUR_SCHEME_SCALE.LINEAR         
     82        scheme = self.builder.buildScheme() 
     83         
     84        nt.assert_equal(scheme.norm.__class__, matplotlib.colors.Normalize) 
     85        nt.assert_equal((scheme.norm.vmin, scheme.norm.vmax),  
     86                        (self.builder.colourBarMin, self.builder.colourBarMax)) 
     87         
     88        #log norm 
     89        self.builder.colourBarMin = 10 
     90        self.builder.colourBarMax = 50 
     91        self.builder.colourBarScale = COLOUR_SCHEME_SCALE.LOG         
     92        scheme = self.builder.buildScheme() 
     93         
     94        nt.assert_equal(scheme.norm.__class__, matplotlib.colors.LogNorm) 
     95        nt.assert_equal((scheme.norm.vmin, scheme.norm.vmax),  
     96                        (self.builder.colourBarMin, self.builder.colourBarMax))         
     97 
     98    def test_005_getCBMinMaxSwapsValues(self): 
    6299         
    63100        # when the values are the wrong way round the getCBMinMax function 
     
    77114        )         
    78115     
    79     @patch('geoplot.colour_scheme._ConinuousSchemeBuilder', spec=True) 
    80     @patch('geoplot.colour_scheme._IntervalSchemeBuidler', spec=True) 
    81     def test_003_usesCorrectSchemeBuilders(self,  
    82                                         mockIntSchemeBuilder, mockContSchemeBuilder): 
     116    def test_006_logBoundsWhenRangeNegative(self): 
     117        adjustedRange = self.builder._adjustCBRangeForLog(Range(-10,1000)) 
     118        nt.assert_almost_equal(adjustedRange.minimum, 1) 
     119        nt.assert_almost_equal(adjustedRange.maximum, 1000)         
    83120         
    84         # make sure that the right scheme builder classes are used to  
    85         # build the colour schemes. 
     121    def test_007_smallLogBoundsWhenRangeNegative(self): 
     122 
     123        adjustedRange = self.builder._adjustCBRangeForLog(Range(-10,1e-1)) 
     124        nt.assert_almost_equal(adjustedRange.minimum, 1e-3) 
     125        nt.assert_almost_equal(adjustedRange.maximum, 1e-1) 
    86126         
    87         # set the attributes 
    88         self.builder.cmap = Mock() 
    89         self.builder.colourBarMin, self.builder.colourBarMax =  10, 100 
    90         self.builder.intervals = None 
    91         self.builder.intervalNames = None 
    92         mockGrid = Mock(spec=Grid) 
    93         mockIntBuilder = Mock(spec=geoplot.colour_scheme_intervals.ColourSchemeIntervalBuilder) 
    94         mockIntBuilder.buildCSInterval.return_value = Mock(spec=geoplot.colour_scheme_intervals.ColourSchemeInterval) 
     127    def test_008_logBoungsWhenBothNegative(self): 
    95128         
    96         self.builder._intervalBuilder = mockIntBuilder  
     129        adjustedRange = self.builder._adjustCBRangeForLog(Range(-10,-1)) 
     130        nt.assert_almost_equal(adjustedRange.minimum, 1e-2) 
     131        nt.assert_almost_equal(adjustedRange.maximum, 1)         
    97132         
    98         # when intervalColourbar is false should use the _ConinuousSchemeBuilder  
    99         self.builder.intervalColourbar = False 
    100          
    101         scheme = self.builder.buildScheme('continuous', mockGrid) 
    102          
    103         nt.assert_equal(mockContSchemeBuilder.call_count, 1) 
    104         nt.assert_equal(mockIntSchemeBuilder.call_count, 0) 
    105         nt.assert_equals(mockContSchemeBuilder.call_args, ((Range(10, 100), self.builder.colourBarScale, self.builder.cmap, ),{})) 
    106  
    107         # check the build command was called on the object returned from the class 
    108         nt.assert_equal(mockContSchemeBuilder.return_value.buildScheme.call_count, 1) 
    109         nt.assert_equals(mockContSchemeBuilder.return_value.buildScheme.call_args, ((),{})) 
    110          
    111         # check the scheme is the result of this call 
    112         nt.assert_equal(mockContSchemeBuilder.return_value.buildScheme.return_value, scheme) 
    113          
    114         mockIntSchemeBuilder.reset_mock() 
    115         mockContSchemeBuilder.reset_mock() 
    116          
    117         # when intervalColourbar is true use the _IntervalSchemeBuidler 
    118          
    119         scheme = self.builder.buildScheme('legend',mockGrid) 
    120          
    121         nt.assert_equal(mockIntSchemeBuilder.call_count, 1) 
    122         nt.assert_equal(mockContSchemeBuilder.call_count, 0) 
    123         nt.assert_equals(mockIntSchemeBuilder.call_args,  
    124             ((Range(10, 100),  
    125               self.builder.colourBarScale,  
    126               self.builder.cmap,  
    127               mockIntBuilder.buildCSInterval.return_value ),{})) 
    128  
    129         # check the build command was called on the object returned 
    130         nt.assert_equal(mockIntSchemeBuilder.return_value.buildScheme.call_count, 1) 
    131         nt.assert_equals(mockIntSchemeBuilder.return_value.buildScheme.call_args, ((),{})) 
    132          
    133         # check the scheme is the result of this call 
    134         nt.assert_equal(mockIntSchemeBuilder.return_value.buildScheme.return_value, scheme) 
    135                  
    136          
    137     def test_004_checkHideOutsideBoundsSet(self): 
    138          
    139         # when HideOutsideBounds is true the set_under and set_over methods 
    140         # should be called on the colour map 
    141          
    142         # test without first 
    143         self.builder.hideOutsideBounds = False        
    144         self.builder.cmap = Mock(spec=matplotlib.colors.ListedColormap) 
    145         returnedCmap = self.builder._getColourMap() 
    146          
    147         nt.assert_equal(self.builder.cmap, returnedCmap) 
    148         nt.assert_equal(returnedCmap.method_calls, []) 
    149          
    150         self.builder.cmap.reset_mock() 
    151          
    152         #test with 
    153         self.builder.hideOutsideBounds = True 
    154         returnedCmap = self.builder._getColourMap() 
    155          
    156         nt.assert_equal(self.builder.cmap, returnedCmap) 
    157         nt.assert_equal(returnedCmap.method_calls, [('set_under', ('0.25',), {'alpha': 0.0}), ('set_over', ('0.75',), {'alpha': 0.0})]) 
    158          
    159         self.builder.cmap.reset_mock() 
    160          
    161  
    162 class Test_ContinuousColourSchemeBuilder(object): 
    163      
    164     def setUp(self): 
    165         self.builder = _ConinuousSchemeBuilder(Range(10, 100), 'linear' , 
    166                                                Mock(spec=matplotlib.colors.LinearSegmentedColormap)) 
    167      
    168     def test_001_returnedSchemeIsContinuouse(self): 
    169          
    170         scheme = self.builder.buildScheme() 
    171         nt.assert_true(isinstance(scheme, geoplot.colour_scheme.ContinuousColourScheme)) 
    172      
    173     def test_002_returndCmapIsUnchanged(self): 
    174          
    175         # for a continuous colour scheme the cmap should be unchanged form the  
    176         # inital cmap 
    177          
    178         scheme = self.builder.buildScheme() 
    179         nt.assert_equal(scheme.colourMap, self.builder.initialCmap) 
    180         nt.assert_equal(scheme.colourMap.method_calls, []) 
    181      
    182     def test_003_returnedNormHasVminVmaxSet(self): 
    183          
    184         # make sure the min/max of the grid values are used when the colour bar 
    185         # min/max is set to None 
    186          
    187  
    188         self.builder.cbRange = Range(5.0, 10.0) 
    189         scheme = self.builder.buildScheme() 
    190              
    191         nt.assert_equal((scheme.norm.vmin, scheme.norm.vmax), (5.0, 10.0))                    
    192          
    193     def test_004_returnsLogNorm(self): 
    194         self.builder.cbScale = 'log' 
    195         scheme = self.builder.buildScheme() 
    196  
    197         nt.assert_true(isinstance(scheme.norm, matplotlib.colors.LogNorm)) 
    198          
    199 class Test_IntervalSchemeBuidler(object): 
    200      
    201     def setUp(self): 
    202         interval = ColourSchemeInterval(numpy.array([25.0,35.0,45.0,55.0]),  
    203                                         numpy.array([20.0,30.0,40.0,50.0,60.0]),  
    204                                         ['a','b','c','d']) 
    205         self.builder = _IntervalSchemeBuidler(Range(10.0, 100.0),  'linear' , 
    206                                               Mock(spec=matplotlib.colors.LinearSegmentedColormap),  
    207                                               interval) 
    208      
    209     def test_001_returnedCmapForNamedIntervals(self): 
    210          
    211         #check that the right number of colours appear in the listed colourmap 
    212          
    213         scheme = self.builder.buildScheme() 
    214                  
    215         nt.assert_equal(scheme.colourMap.N, 4) 
    216         nt.assert_equal(scheme.colourMap.__class__, matplotlib.colors.ListedColormap) 
    217     
    218  
    219     def test_002_returnIntervalCmapUntouched(self): 
    220          
    221         colours = [(0.4, 0.4, 0.5, 1.0), 
    222                    (0.5, 0.5, 0.6, 1.0), 
    223                    (0.6, 0.6, 0.7, 1.0),] 
    224          
    225         self.builder.initialCmap = matplotlib.colors.ListedColormap(colours, "test_colourmap") 
    226          
    227         scheme = self.builder.buildScheme() 
    228         nt.assert_equal(scheme.colourMap.colors, colours) 
    229         nt.assert_equal(scheme.colourMap.name, "test_colourmap") 
    230      
    231     def test_003_returnedLabelsCorrect(self): 
    232          
    233         #labels for the unique values 
    234         self.builder.csInterval.bounds = numpy.array([5.0,15.0,25.0,35.0]) 
    235         self.builder.csInterval.midpoints = numpy.array([10.0,20.0,30.0]) 
    236         self.builder.csInterval.labels = ['5.0 - 15.0', '15.0 - 25.0', '25.0 - 35.0'] 
    237         self.builder.cbRange = Range(0, 100) 
    238  
    239         #labels for specified bounds 
    240         scheme = self.builder.buildScheme() 
    241         nt.assert_equal(scheme.labels, ['5.0 - 15.0', '15.0 - 25.0', '25.0 - 35.0']) 
    242  
    243         #labels for given bounds 
    244         self.builder.csInterval.labels = ["one","two","three"] 
    245         scheme = self.builder.buildScheme() 
    246          
    247         nt.assert_equal(scheme.labels, ["one", "two", "three"]) 
    248                  
    249  
    250       
    251  
    252133if __name__ == '__main__': 
    253134 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_colour_scheme_interval_builder.py

    r6089 r6118  
    77import geoplot 
    88from geoplot.colour_scheme_intervals import ColourSchemeIntervalBuilder 
     9from geoplot.colour_bar import COLOUR_SCHEME_SCALE 
    910import matplotlib 
    1011 
     
    2324         
    2425        boundsString = "10,20,30,40" 
    25         labelsString = "a,b,c" 
    2626         
    27         cbInterval = self.builder.buildCSInterval( Range(0,100), boundsString, labelsString) 
     27        cbInterval = self.builder.buildCSInterval( Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString) 
    2828         
    2929        expectedBounds = [10.0, 20.0, 30.0, 40.0] 
    3030        expectedMidpoints = geoplot.utils.getMidpoints(expectedBounds)  
    31         expectedLabels = ['a','b','c'] 
    3231         
    3332        nt.assert_true(test_utils._areNumericListsEqual(cbInterval.bounds, expectedBounds),  
     
    3736                       "midpoints %s didn't match expected %s" % (cbInterval.midpoints, expectedMidpoints)) 
    3837         
    39         nt.assert_equal(expectedLabels, cbInterval.labels) 
    40  
    4138    @patch('geoplot.colour_scheme_intervals.DEFAULT_NUM_INTERVALS',5) 
    4239    def test_002_buildIntervalsFromRange(self): 
    43         cbInterval = self.builder.buildCSInterval(Range(0,100), None, None) 
     40         
     41        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR) 
    4442 
    4543        expectedBounds = [0.0, 20.0, 40.0, 60.0, 80.0, 100.0] 
    4644        expectedMidpoints = geoplot.utils.getMidpoints(expectedBounds) 
    47         expectedLabels = ['0.0 - 20.0','20.0 - 40.0','40.0 - 60.0', '60.0 - 80.0', '80.0 - 100.0'] 
    48          
     45 
    4946        nt.assert_true(test_utils._areNumericListsEqual(cbInterval.bounds, expectedBounds),  
    5047                       "bounds %s didn't match expected %s" % (cbInterval.bounds, expectedBounds)) 
     
    5350                       "midpoints %s didn't match expected %s" % (cbInterval.midpoints, expectedMidpoints)) 
    5451         
    55         nt.assert_equal(expectedLabels, cbInterval.labels) 
    56  
    5752    def test_003_filterBoundsUsingRange(self): 
    5853        boundsString = "10,20,30,40,50" 
    5954 
    60         cbInterval = self.builder.buildCSInterval(Range(25,45), boundsString, None) 
     55        cbInterval = self.builder.buildCSInterval(Range(25,45), COLOUR_SCHEME_SCALE.LINEAR, boundsString) 
    6156 
    6257        expectedBounds = [25.0, 30.0, 40.0, 45] 
     
    7065                       "midpoints %s didn't match expected %s" % (cbInterval.midpoints, expectedMidpoints)) 
    7166         
    72      
    73     def test_004_useDefaultLabelsWhenWrongGiven(self): 
    74         boundsString = "10,20,30,40" 
    75         labelsString = "a,b,c,d,e,f,g" 
    76          
    77         expectedLabels = ['10.0 - 20.0','20.0 - 30.0','30.0 - 40.0'] 
    78          
    79         cbInterval = self.builder.buildCSInterval( Range(0,100), boundsString, labelsString) 
    80          
    81         nt.assert_equal(expectedLabels, cbInterval.labels) 
    82      
     67 
    8368    def test_005_buildSpecificNumberOfIntervals(self): 
    84         cbInterval = self.builder.buildCSInterval(Range(0,100), None, None, 11) 
     69        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, None, 11) 
    8570         
    8671        nt.assert_equal(len(cbInterval.midpoints), 11) 
     
    8974        boundsString = "10," 
    9075        #if the bounds string is incorrect should use the default intervals. 
    91         cbInterval = self.builder.buildCSInterval(Range(0,100), boundsString, None, 11) 
     76        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString, 11) 
    9277 
    9378        nt.assert_equal(len(cbInterval.midpoints), 11) 
     
    9681        boundsString = "150,160," 
    9782        #if the bounds are outside the range then the default should be used 
    98         cbInterval = self.builder.buildCSInterval(Range(0,100), boundsString, None, 11) 
     83        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString, 11) 
    9984 
    10085        nt.assert_equal(len(cbInterval.midpoints), 11) 
     
    10489        # if the bounds string is entierly outside the range then should use  
    10590        # default intervals 
    106         cbInterval = self.builder.buildCSInterval(Range(0,100), boundsString, None, 11) 
     91        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString, 11) 
    10792 
    10893        nt.assert_equal(len(cbInterval.midpoints), 11)             
     
    11095    def test_008_boundsPartiallyOutsideRangeAreCorrected(self): 
    11196        boundsString = "10,160," 
    112         cbInterval = self.builder.buildCSInterval(Range(0,100), boundsString, None, 11) 
     97        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString, 11) 
    11398        expectedBounds = [10.0,100.0] 
    11499         
     
    117102 
    118103        boundsString = "-10,50" 
    119         cbInterval = self.builder.buildCSInterval(Range(0,100), boundsString, None, 11) 
     104        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString, 11) 
    120105        expectedBounds = [0.0,50.0] 
    121106         
     
    125110    def test_009_boundsInWrongOrderAreCorrected(self): 
    126111        boundsString = "10,,5,100," 
    127         cbInterval = self.builder.buildCSInterval(Range(0,100), boundsString, None, 11) 
     112        cbInterval = self.builder.buildCSInterval(Range(0,100), COLOUR_SCHEME_SCALE.LINEAR, boundsString, 11) 
    128113        expectedBounds = [5.0,10.0,100.0] 
    129114 
  • qesdi/geoplot/trunk/lib/geoplot/utils.py

    r5980 r6118  
    7979#    log.debug("im.palette.mode = %s" % (im.palette.mode,)) 
    8080    #im.-convert("RGBA") 
     81     
     82    log.debug("fig.get_facecolor() = %s" % (fig.get_facecolor(),)) 
    8183     
    8284    buffer = StringIO.StringIO() 
Note: See TracChangeset for help on using the changeset viewer.