Changeset 5636 for qesdi


Ignore:
Timestamp:
19/08/09 15:24:19 (10 years ago)
Author:
pnorton
Message:

Fixed a problem with imshow drawing a grid when there was no data to draw. Also fixed some of the tests.

Location:
qesdi/geoplot/trunk/lib/geoplot
Files:
1 added
1 deleted
12 edited
2 moved

Legend:

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

    r5605 r5636  
    1111 
    1212from matplotlib.collections import LineCollection 
     13 
     14from geoplot.utils import ispointInLimits, isRangeInLimits, isValueInLimits 
    1315 
    1416log = logging.getLogger(__name__) 
     
    278280        [segs.append(x) for x in newLines] 
    279281         
    280          
    281  
    282 def ispointInLimits(point, xLimits, yLimits): 
    283     x,y = point 
    284      
    285     if isValueInLimits(x, xLimits) and isValueInLimits(y, yLimits): 
    286         return True 
    287     else: 
    288         return False 
    289  
    290 def isRangeInLimits(range, limits): 
    291          
    292          
    293         if isValueInLimits(range[0], limits): 
    294             return True 
    295          
    296         if isValueInLimits(range[1], limits): 
    297             return True 
    298          
    299         if range[0] <= limits[0] and range[1] >= limits[1]: 
    300             return True 
    301          
    302         return False 
    303          
    304  
    305 def isValueInLimits(val, limits):    
    306      
    307     if val >= limits[0] and val <= limits[1]: 
    308         return True 
    309     else: 
    310         return False 
    311      
  • qesdi/geoplot/trunk/lib/geoplot/grid.py

    r5552 r5636  
    4444                        transformedMidpointsX, transformedMidpointsY, 
    4545                        self.values.copy()) 
    46              
    4746     
    48  
     47     
    4948if __name__ == '__main__': 
    5049 
  • qesdi/geoplot/trunk/lib/geoplot/grid_drawer.py

    r5635 r5636  
    7373            norm = matplotlib.colors.Normalize(grid.values.min(), grid.values.max())      
    7474 
     75        xLimits, yLimits = self._transformLimits(limits, basemap) 
     76         
     77        # check that the grid being drawn has data inside the limits, if there 
     78        # is no data in the limits there is no point drawing anything. 
     79        # can only check the grid is in the limits if they are provided 
     80        if limits != None: 
     81            if not self._isGridDataWithinLimits(grid, xLimits, yLimits): 
     82                return 
     83                 
    7584        grid_mapUnits = grid.transform(basemap) 
    7685 
     
    8291        if self.drawValues == True: 
    8392            log.debug('drawing grid values') 
    84  
    85             xLimits, yLimits = self._transformLimits(limits, basemap) 
    8693             
    8794            #draw the vlaues onto the grid 
     
    204211        kwargs.pop('linewidth') 
    205212        kwargs.pop('antialiased') 
     213         
     214        log.debug("extent = %s" % (extent,)) 
     215        log.debug("Z.shape = %s" % (Z.shape,)) 
    206216         
    207217        im = axes.imshow(Z, extent=extent, 
     
    406416 
    407417        return cellList 
    408   
     418     
     419    def _isGridDataWithinLimits(self, grid, xLimits, yLimits): 
     420         
     421        xRange = (grid.boundsX.min(), grid.boundsX.max()) 
     422        yRange = (grid.boundsY.min(), grid.boundsY.max()) 
     423         
     424        log.debug("xRange = %s" % (xRange,)) 
     425        log.debug("yRange = %s" % (yRange,)) 
     426         
     427        isInLimits = geoplot_utils.isRangeInLimits(xRange, xLimits) and \ 
     428                     geoplot_utils.isRangeInLimits(yRange, yLimits) 
     429         
     430        return isInLimits 
     431     
    409432if __name__ == '__main__': 
    410433    import geoplot.log_util as log_util 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer.py

    r5552 r5636  
    1717from geoplot.grid_builder_rotated import GridBuilderRotated 
    1818 
    19 from geoplot.map_lat_lon import MapLatLon 
    20 from geoplot.map_national_grid import MapNationalGrid 
     19from geoplot.grid_factory import GridFactory 
     20from geoplot.map_factory import MapFactory 
    2121 
    2222import geoplot.utils as geoplot_utils 
     
    3737                 resolution='c'): 
    3838         
    39         self.resolution = resolution 
    40         self.projection = projection 
    4139        self.transparent = transparent 
    42         self.gridType = gridType 
     40        #self.gridType = gridType 
     41         
     42        self._gridFactory = GridFactory(dataType=gridType) 
     43        self._mapFactory = MapFactory(projection, drawCoast=True, drawRivers=False, resolution=resolution) 
    4344         
    4445    def makeImage(self, xLimits=None, yLimits=None, width=800, height=600, dpi=100): 
     
    104105        """ 
    105106         
    106         builderClass = self._getGridBuilderClass() 
    107          
    108         gridBuilder = builderClass(cdmsVar) 
    109          
    110         grid = gridBuilder.buildGrid(xLimits=xLimits, yLimits=yLimits) 
     107        self._gridFactory.cdmsVar = cdmsVar 
     108         
     109        grid = self._gridFactory.getGrid(xLimits, yLimits) 
    111110         
    112111        return grid 
     
    143142        """ 
    144143         
    145         if self.projection == 'latlon': 
    146             map = MapLatLon(xLimits, yLimits, drawCoast=True, drawRivers=False, 
    147                             resolution=self.resolution) 
    148         else: 
    149             map = MapNationalGrid(xLimits, yLimits, drawCoast=True, drawRivers=False, 
    150                                   resolution=self.resolution) 
     144        self._mapFactory.xLimits = xLimits 
     145        self._mapFactory.yLimits = yLimits 
     146         
     147        map = self._mapFactory.buildMap() 
    151148             
    152149        return map         
    153          
    154  
    155      
    156     def _getGridBuilderClass(self): 
    157         """ 
    158         Returns the correct bridge builder class for the value of self.gridType. 
    159         """ 
    160          
    161         if self.gridType == 'latlon': 
    162             return GridBuilderLatLon 
    163          
    164         elif self.gridType == 'national': 
    165             return GridBuilderNational 
    166          
    167         elif self.gridType == 'rotated': 
    168             return GridBuilderRotated 
    169150     
    170151    ### properties ###         
     
    177158                % (value, VALID_GRID_TYPES,)) 
    178159             
    179         self._gridType = value 
     160        self._gridFactory.dataType = value 
    180161 
    181162    def __get_gridType(self): 
    182         return self._gridType 
     163        return self._gridFactory.dataType 
    183164     
    184165    gridType = property(__get_gridType, __set_gridType, None, None) 
     
    224205                % (value, VALID_PROJECTIONS,)) 
    225206             
    226         self._projection = value 
     207        self._mapFactory.projection = value 
    227208 
    228209    def __get_projection(self): 
    229         return self._projection 
     210        return self._mapFactory.projection 
    230211     
    231212    projection = property(__get_projection, __set_projection, None, None) 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_coastline.py

    r5412 r5636  
    3131    """ 
    3232     
    33     def __init__(self, projection='latlon', resolution='i', transparent=False): 
     33    def __init__(self, projection='latlon', resolution='i', transparent=False, drawRivers=False): 
    3434         
    3535        LayerDrawerBase.__init__(self, transparent=transparent, 
    3636                                 projection=projection, 
    3737                                 resolution=resolution) 
     38         
     39        # must be done after the base constructor or the _mapFactory won't be  
     40        # created 
     41        self._mapFactory.drawRivers = drawRivers 
    3842 
    39      
    40      
    4143    def _drawToAxes(self, axes, xLimits, yLimits): 
    4244        """ 
     
    4850        #draw the map onto the axes  
    4951        map.drawMap(axes) 
     52         
     53        #map.basemap.fillcontinents(color='coral',lake_color='aqua', ax=axes) 
     54        #map.basemap.bluemarble(ax=axes) 
     55 
     56    def __set_drawRivers(self, value): 
     57        self._mapFactory.drawRivers = value 
     58         
     59    def __get_drawRivers(self): 
     60        return self._mapFactory.drawRivers 
    5061     
    51  
     62    drawRivers = property(__get_drawRivers, __set_drawRivers)     
    5263      
    5364                 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_grid_builder_national.py

    r5403 r5636  
    2525 
    2626 
    27  
    2827if __name__ == '__main__': 
    2928 
     
    3130    testDataDir = pkg_resources.resource_filename('geoplot', 'tests/data') 
    3231     
     32    from geoplot.tests.drawing import getDrawingOutputDir 
     33    from geoplot.log_util import SHORT_LOG_FORMAT_STRING, LOG_FORMAT_STRING 
     34    logging.basicConfig(level=logging.DEBUG, format=SHORT_LOG_FORMAT_STRING) 
     35     
     36    outputDir = getDrawingOutputDir() 
    3337     
    3438    logging.basicConfig(level=logging.DEBUG, format=log_util.LOG_FORMAT_STRING) 
     
    7478 
    7579    canvas = FigureCanvasAgg(fig) 
    76     filename = os.path.join(outputsDir, "grid_builder_national.png") 
     80    filename = os.path.join(outputDir, "grid_builder_national.png") 
    7781    canvas.print_figure(filename) 
    7882    log.debug("Wrote " + filename) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_colour_bar.py

    r5403 r5636  
    55 
    66import nose 
     7import nose.tools as nt 
     8 
     9import numpy 
     10 
    711import matplotlib 
    812import matplotlib.ticker 
     
    3236        self.colourBarPosition = "horizontal" 
    3337        self.colourBarRange = (25.0, 75.0) 
    34         self.cb = ColourBar(self.colourBarLabel, self.colourBarPosition, self.colourBarRange) 
     38        self.cb = ColourBar(colourBarLabel=self.colourBarLabel,  
     39                            colourBarPosition=self.colourBarPosition,  
     40                            colourBarMin=self.colourBarRange[0], 
     41                            colourBarMax=self.colourBarRange[1]) 
    3542 
    3643        self.sm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.prism) 
     
    4148 
    4249    def test_001_checkInitialisaion(self): 
    43         assert(self.cb.label == self.colourBarLabel) 
    44         assert(self.cb.position == self.colourBarPosition) 
    45         print self.colourBarRange 
    46         print self.cb.range 
    47         assert(self.cb.range == self.colourBarRange) 
     50        assert(self.cb.colourBarLabel == self.colourBarLabel) 
     51        assert(self.cb.colourBarPosition == self.colourBarPosition) 
     52        assert(self.cb.colourBarMin == self.colourBarRange[0]) 
     53        assert(self.cb.colourBarMax == self.colourBarRange[1]) 
    4854 
    4955    def test_002_checkLabelFont(self): 
     
    5359        assert(self.cb.labelFont.getDict('large')  == colourBarFont.getDict('large')) 
    5460 
    55     def test_003_setsMaxLimit(self): 
    56         newMax = 100.52 
    57         self.cb.range = [None, newMax] 
    58         (minBefore, maxBefore) = self.sm.get_clim() 
    59         print self.sm.get_clim() 
    60         self.cb._setLimits(self.sm) 
    61         (minAfter, maxAfter) = self.sm.get_clim() 
    62         print self.sm.get_clim() 
    63         assert(minAfter == minBefore) 
    64         assert(maxAfter == newMax) 
    65  
    66     def test_004_setsMinLimit(self): 
    67         newMin = 10.5 
    68  
    69         self.cb.range = (newMin, None) 
    70         (minBefore, maxBefore) = self.sm.get_clim() 
    71         self.cb._setLimits(self.sm) 
    72         (minAfter, maxAfter) = self.sm.get_clim() 
    73         assert(minAfter == newMin) 
    74         assert(maxAfter == maxBefore ) 
    75  
    76     def test_005_setsBothLimits(self): 
    77         newRange = (50.5, 75.0) 
    78         self.cb.range = newRange 
    79         self.cb._setLimits(self.sm) 
    80         (minAfter, maxAfter) = self.sm.get_clim() 
    81         assert(minAfter == newRange[0]) 
    82         assert(maxAfter == newRange[1]) 
    83  
    84     def test_006_setsNeitherLimit(self): 
    85         newRange = (None, None) 
    86         self.cb.range = newRange 
    87         (minBefore, maxBefore) = self.sm.get_clim() 
    88         self.cb._setLimits(self.sm) 
    89         (minAfter, maxAfter) = self.sm.get_clim() 
    90         assert(minBefore == minAfter) 
    91         assert(maxBefore == maxAfter) 
    92  
    93     def test_007_raisesErrorWhenMinGraterThanMax(self): 
    94         newRange = (10.0, 5.0) 
    95         nose.tools.assert_raises(ValueError, setattr, self.cb, 'range', newRange) 
    96  
    97     def test_008_raisesErrorWhenMinGraterThanMax(self): 
    98         newRange = (10.0, 5.0) 
    99         nose.tools.assert_raises(ValueError, setattr, self.cb, 'range', newRange) 
    100  
    101     def test_009_raisesErrorWhenMinEqualsMax(self): 
    102         newRange = (10.0, 10.0) 
    103         nose.tools.assert_raises(ValueError, setattr, self.cb, 'range', newRange) 
    104  
    105     def test_010_raisesErrorWhenRangeNotListOrTuple(self): 
    106         newRange = "1, 10" 
    107         nose.tools.assert_raises(ValueError, setattr, self.cb, 'range', newRange) 
    108  
    109     def test_011_raisesErrorWhenRangeNotLength2(self): 
    110         newRange = (10.0, 5.0, 2.5) 
    111         nose.tools.assert_raises(ValueError, setattr, self.cb, 'range', newRange) 
     61    def test_003_getNormalize(self): 
     62         
     63        norm = self.cb.getNormalize() 
     64        nt.assert_equal((norm.vmin, norm.vmax), self.colourBarRange) 
     65         
     66        dMin = -10.0; dMax = 143.2 
     67         
     68        self.cb.colourBarMin = None 
     69        norm = self.cb.getNormalize(dataMin=dMin, dataMax=dMax) 
     70        nt.assert_equal((norm.vmin, norm.vmax), (dMin, self.colourBarRange[1])) 
     71         
     72        self.cb.colourBarMin = self.colourBarRange[0] 
     73        self.cb.colourBarMax = None 
     74        norm = self.cb.getNormalize(dataMin=dMin, dataMax=dMax) 
     75        nt.assert_equal((norm.vmin, norm.vmax), (self.colourBarRange[0], dMax)) 
     76         
     77        self.cb.colourBarMin = None 
     78        norm = self.cb.getNormalize(dataMin=dMin, dataMax=dMax) 
     79        nt.assert_equal((norm.vmin, norm.vmax), (dMin, dMax)) 
     80         
     81        dMin = numpy.ma.MaskedArray([0], mask=True) 
     82        dMax = numpy.ma.MaskedArray([0], mask=True) 
     83         
     84        norm = self.cb.getNormalize(dataMin=dMin, dataMax=dMax) 
     85        nt.assert_equal((norm.vmin, norm.vmax), (0.0, 1.0)) 
    11286 
    11387    #position ticks (if 
     
    135109 
    136110    def test_013_raiseErrorWhenSettingInvalidPositionValue(self): 
    137         nose.tools.assert_raises(ValueError, setattr, self.cb, 'position', 'sideways') 
     111        nose.tools.assert_raises(ValueError, setattr, self.cb, 'colourBarPosition', 'sideways') 
    138112 
    139113 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_layer_drawer.py

    r5605 r5636  
    2323import geoplot.utils as geoplot_utils 
    2424 
    25 layer_drawer.GridBuilderLatLon 
    26 layer_drawer_grid.GridDrawer 
    2725 
    2826 
     
    7068        #apply the mocks and run the code 
    7169        @apply 
    72         @patch('geoplot.layer_drawer.GridBuilderLatLon', mockGridBuilderLatLon) 
     70        @patch('geoplot.grid_factory.GridBuilderLatLon', mockGridBuilderLatLon) 
    7371        @patch('geoplot.layer_drawer_grid.GridDrawer',mockGridDrawer) 
    7472        def do_test(): 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_metadata_box.py

    r5403 r5636  
    1414 
    1515import geoplot.tests.test_config as testConfig 
     16#testConfig._conf = None 
    1617config = testConfig.getConfig() 
     18 
    1719 
    1820FONTS_SECTION = 'Fonts' 
     
    3133 
    3234    def test_001_checkInitialisation(self): 
    33         assert(self.mdb.dataList == self.metadataList) 
     35        assert(self.mdb.metadataList == self.metadataList) 
    3436 
    3537    def test_002_raisesExceptionWhenListWrongType(self): 
    36         nose.tools.assert_raises(ValueError, setattr, self.mdb, 'dataList', {"key":"value"}) 
    37         nose.tools.assert_raises(ValueError, setattr, self.mdb, 'dataList', [{"key":"value"}]) 
     38        nose.tools.assert_raises(ValueError, setattr, self.mdb, 'metadataList', {"key":"value"}) 
     39        nose.tools.assert_raises(ValueError, setattr, self.mdb, 'metadataList', [{"key":"value"}]) 
    3840 
    3941    def test_002_raisesExceptionWhenTuplesAreTheWrongLength(self): 
     
    4547                        ("Percentile", "10th")] 
    4648 
    47         nose.tools.assert_raises(ValueError, setattr, self.mdb, 'dataList', newMetadata) 
     49        nose.tools.assert_raises(ValueError, setattr, self.mdb, 'metadataList', newMetadata) 
    4850 
    4951    def test_003_checkDataFont(self): 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_plot_base_new.py

    r5605 r5636  
    1010import cdms2 as cdms 
    1111 
    12 from geoplot.contour_plot_base import ContourPlotBase 
     12from geoplot.plot_base import PlotBase 
    1313 
    1414from geoplot.config import getConfig 
     
    3838     
    3939    def test_001_createsInternalObjectsFromDefaults(self): 
    40         base = ContourPlotBase() 
     40        base = PlotBase() 
    4141 
    4242        for att in testValues.keys(): 
     
    5454    def test_002_dynamicAttributeReading(self): 
    5555         
    56         base = ContourPlotBase() 
     56        base = PlotBase() 
    5757         
    5858        #first set the values on the private attributes directly 
     
    7373        #mentioned in the config file 
    7474         
    75         base = ContourPlotBase() 
     75        base = PlotBase() 
    7676 
    7777        original = base._colourBar.draw 
     
    8484    def test_004_dynamicAttributeSetting(self): 
    8585         
    86         base = ContourPlotBase() 
     86        base = PlotBase() 
    8787         
    8888        #set the values using the base directly 
     
    108108            kwargs.update(testVals) 
    109109         
    110         base = ContourPlotBase(**kwargs) 
     110        base = PlotBase(**kwargs) 
    111111         
    112112        for key, value in kwargs.items(): 
     
    115115    def test_006_dynamicColourBarPosition(self): 
    116116        a = (1.0, 10.0); b = (2.0, 10.0) 
    117         base = ContourPlotBase(xLimits=a, yLimits=b) 
     117        base = PlotBase(xLimits=a, yLimits=b) 
    118118        assert base.colourBarPosition == None 
    119119        base._setColourBarPosition() 
    120120        nt.assert_equal(base.colourBarPosition, 'horizontal') 
    121121         
    122         base = ContourPlotBase(xLimits=b, yLimits=a) 
     122        base = PlotBase(xLimits=b, yLimits=a) 
    123123        assert base.colourBarPosition == None 
    124124        base._setColourBarPosition() 
     
    126126     
    127127        #check no change if already set 
    128         base = ContourPlotBase(xLimits=b, yLimits=a, colourBarPosition='horizontal') 
     128        base = PlotBase(xLimits=b, yLimits=a, colourBarPosition='horizontal') 
    129129        assert base.colourBarPosition == 'horizontal' 
    130130        base._setColourBarPosition() 
     
    133133    def test_007_dynamicColourBarLabel(self): 
    134134         
    135         base = ContourPlotBase(units='some unit') 
     135        base = PlotBase(units='some unit') 
    136136        assert base.colourBarLabel == None 
    137137        base._setColourBarLabel() 
     
    139139         
    140140        #check no change if already set 
    141         base = ContourPlotBase(colourBarLabel='some label', units='some unit') 
     141        base = PlotBase(colourBarLabel='some label', units='some unit') 
    142142        assert base.colourBarLabel == 'some label' 
    143143        base._setColourBarLabel() 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_plot_base_old.py

    r5605 r5636  
    1212import geoplot 
    1313from geoplot.plot_base import PlotBase 
     14from geoplot.map_factory import MapFactory 
     15from geoplot.grid_factory import GridFactory 
    1416 
    1517import geoplot.tests.test_utils as test_utils 
    16  
    17 import geoplot.tests.test_config as testConfig 
    18 config = testConfig.getConfig() 
    19          
    20          
    21 arguments = {'format':'jpg', 'width': 400, 'height': 601, 'drawValues': True, 
     18        
     19from geoplot.config import getConfig 
     20config = getConfig() 
     21        
     22arguments = {'format':'jpg', 'width': 400, 'height': 601,  
    2223             'xLimits': (-13.0, 3.0), 'yLimits': (49.0, 60.0), 'dpi': 92, 
    23              'cmap': matplotlib.cm.hot, 'valueFormat': "%.2f", 'drawColourBar': False, 
     24             'cmap':'hot', 'drawColourBar': False, 
    2425             'colourBarLabel': "temperature change",  
    25              'colourBarPosition': 'horizontal', 'colourBarMin': 1, 
    26              'colourBarMax': 10, 'drawLogo': False, 'drawCoast': False, 
    27              'drawRivers': False, 'plotTitle': " some plot", 
     26             'colourBarPosition': 'horizontal', 'colourBarMin': 1.0, 
     27             'colourBarMax': 10.0, 'drawLogo': False, 'drawCoast': False, 
     28             'drawRivers': False, 'plotTitle': " some plot", 'dataType':'national', 
     29             'resolution':'h', 'cdmsVar':cdms.createVariable(range(10)), 
     30             'drawMetadata':False, 'projection':'national', 
    2831             'metadataList': [('Name one', 'value 1'), ('Name two', 'value 2')], 
    29              'fontSize': "large", 'units': "degrees", 'showGridLines':True, 
    30              'outputCMYK':True, 'addShapefile':'some/shape/file/','drawValuesFile':'some/draw/value/file.csv', 'drawContour':True} 
    31  
    32 argumentTypes = {'format':str, 'width': int, 'height':int, 'drawValues': bool, 
     32             'fontSize': "large", 'units': "degrees",  
     33             'outputCMYK':True, 'addShapefile':'some/shape/file/'} 
     34 
     35argumentTypes = {'format':str, 'width': int, 'height':int,  
    3336                 'xLimits': tuple, 'yLimits': tuple, 'dpi': int, 
    34                  'cmap': matplotlib.colors.LinearSegmentedColormap, 
    35                  'valueFormat': str, 'drawColourBar': bool, 
     37                 'cmap': str, 'drawMetadata':bool, 'projection':str, 
     38                 'dataType':str, 'resolution':str, 'cdmsVar':cdms.tvariable.TransientVariable, 
     39                 'drawColourBar': bool, 
    3640                 'colourBarLabel': str, 'colourBarPosition': str, 
    3741                 'colourBarMin': float, 'colourBarMax': float, 
    3842                 'drawLogo': bool, 'drawCoast': bool, 'drawRivers': bool,  
    3943                 'plotTitle': str, 'metadataList': list, 'fontSize': str, 
    40                  'units': str, 'showGridLines':bool, 'outputCMYK':bool, 
    41                  'addShapefile':str,'drawValuesFile':str, 'drawContour':bool} 
     44                 'units': str, 'outputCMYK':bool, 
     45                 'addShapefile':str} 
    4246 
    4347dynamicDefaultArgs = ['colourBarLabel', 'colourBarPosition', 'cmap'] 
     
    4549DEFAULTS_SECTION = 'PlotBaseDefaults' 
    4650 
     51accessableClasses = ['ColourBar',  'PlotArea',   'MetadataBox', 'PlotWriter',  'MapFactory', 'GridFactory'] 
     52 
     53 
    4754class Test_PlotBase(object): 
    4855 
    4956    def setUp(self): 
    50         self.oldConfig = geoplot.plot_base.config 
    51         geoplot.plot_base.config = config 
    5257        self.cdmsVar = cdms.createVariable([1,2,3,4]) 
     58         
     59        self.validConstructorKWArgs = [] 
     60        for klass in accessableClasses: 
     61            self.validConstructorKWArgs.extend(config['Defaults'][klass].keys()) 
     62         
    5363 
    5464    def tearDown(self): 
    55         geoplot.plot_base.config = self.oldConfig 
     65        pass 
    5666     
    5767    def constructUsingDefaults(self): 
    58         self.pb = SimplePlot(self.cdmsVar) 
     68        self.pb = PlotBase() 
    5969         
    6070    def constructUsingArguments(self): 
    61         self.pb = SimplePlot(self.cdmsVar, **arguments) 
     71        self.pb = PlotBase(**arguments) 
    6272     
    6373    def test_001_checkDefaultArguments(self): 
     
    6676         
    6777        #for each of the keys form the valid constructor keys dictionary  
    68         for key in self.pb.validConstructorKWArgs: 
     78        for klass in accessableClasses: 
     79            for key, default in config['Defaults'][klass].items(): 
    6980             
    70             #if the default is set dynamically ignore it 
    71             if key in dynamicDefaultArgs: continue 
    72              
    73             currentValue = getattr(self.pb, key) 
    74             print "Testing key:", key 
    75              
    76             #if they key is in the config defaults section then it should match 
    77             #the current attribute, otherwise it will be none 
    78             if key in config[DEFAULTS_SECTION]: 
    79                 default = config[DEFAULTS_SECTION][key] 
     81                currentValue = getattr(self.pb, key) 
     82                print "Testing key:", key 
     83                 
     84                #if they key is in the config defaults section then it should match 
     85                #the current attribute, otherwise it will be none 
    8086                nose.tools.assert_equals(currentValue, default) 
    81             else: 
    82                 nose.tools.assert_equals(currentValue, None) 
    8387 
    8488    def test_002_checkInitialiserSetsProperties(self): 
     
    103107         
    104108        #set each of the proerties using the arguments dictionary  
    105         for key in self.pb.validConstructorKWArgs: 
     109        for key in self.validConstructorKWArgs: 
    106110            newValue = arguments[key] 
    107111            setattr(self.pb, key, newValue) 
     
    114118        """ 
    115119        self.constructUsingArguments() 
    116                  
    117         for key in self.pb.validConstructorKWArgs: 
     120         
     121         
     122         
     123        for key in self.validConstructorKWArgs: 
    118124            print "Testing key", key 
    119125            propertyValue = getattr(self.pb, key) 
     
    129135        self.constructUsingArguments() 
    130136         
    131         map = getattr(self.pb, 'map') 
    132         gridBuilder = getattr(self.pb, 'gridBuilder') 
    133          
    134         nose.tools.assert_true(map.__class__ == MockMap) 
    135         nose.tools.assert_true(gridBuilder.__class__ == MockGridBuilder) 
     137        mapFactory = getattr(self.pb, '_mapFactory') 
     138        gridFactory = getattr(self.pb, '_gridFactory') 
     139         
     140        nose.tools.assert_true(mapFactory.__class__ == MapFactory) 
     141        nose.tools.assert_true(gridFactory.__class__ == GridFactory) 
    136142         
    137143        #test the map attributes match 
    138         nose.tools.assert_equal(map.xLimits , self.pb.xLimits) 
    139         nose.tools.assert_equal(map.yLimits , self.pb.yLimits) 
    140         nose.tools.assert_equal(map.drawCoast , self.pb.drawCoast) 
    141         nose.tools.assert_equal(map.drawRivers , self.pb.drawRivers) 
     144        nose.tools.assert_equal(mapFactory.xLimits , self.pb.xLimits) 
     145        nose.tools.assert_equal(mapFactory.yLimits , self.pb.yLimits) 
     146        nose.tools.assert_equal(mapFactory.drawCoast , self.pb.drawCoast) 
     147        nose.tools.assert_equal(mapFactory.drawRivers , self.pb.drawRivers) 
    142148         
    143149        #test the grid attributes 
    144         nose.tools.assert_true(gridBuilder.cdmsVar is self.pb.cdmsVar)    
     150        nose.tools.assert_true(gridFactory.cdmsVar is self.pb.cdmsVar)    
    145151             
    146152    def test_006_testDefaultColourbarOrientation(self): 
    147         pbLattudeGreater = SimplePlot(self.cdmsVar, xLimits=[1,10], yLimits=[2,8]) 
    148         pbLongitudeGreater = SimplePlot(self.cdmsVar, xLimits=[50,60], yLimits=[2,30]) 
    149          
     153        pbLattudeGreater = PlotBase(xLimits=[1,10], yLimits=[2,8]) 
     154        pbLongitudeGreater = PlotBase(xLimits=[50,60], yLimits=[2,30]) 
     155        pbLattudeGreater._setDynamicArgs() 
     156        pbLongitudeGreater._setDynamicArgs() 
    150157        nose.tools.assert_equal(pbLattudeGreater.colourBarPosition , 'horizontal') 
    151158        nose.tools.assert_equal(pbLongitudeGreater.colourBarPosition , 'vertical') 
    152159         
    153160    def test_007_testDefautColourBarLabel(self): 
    154         pb = SimplePlot(self.cdmsVar, units='feet') 
    155          
     161        pb = PlotBase(units='feet') 
     162        pb._setDynamicArgs() 
    156163        nose.tools.assert_equal(pb.units, 'feet') 
    157164        nose.tools.assert_equal(pb.colourBarLabel , pb.units) 
     
    159166    def test_008_testPlotsColourBar(self): 
    160167        self.constructUsingArguments() 
    161         nose.tools.assert_equal(self.pb.colourBar.__class__ , 
     168        nose.tools.assert_equal(self.pb._colourBar.__class__ , 
    162169                               geoplot.colour_bar.ColourBar) 
    163170        nose.tools.assert_equal(self.pb.colourBarLabel , 
    164                                 self.pb.colourBar.label) 
     171                                self.pb._colourBar.colourBarLabel) 
    165172        nose.tools.assert_equal(self.pb.colourBarPosition , 
    166                                 self.pb.colourBar.position) 
     173                                self.pb._colourBar.colourBarPosition) 
    167174        nose.tools.assert_equal( (self.pb.colourBarMin, self.pb.colourBarMax) , 
    168                                 self.pb.colourBar.range) 
     175                                 (self.pb._colourBar.colourBarMin,self.pb._colourBar.colourBarMax) 
     176                                 ) 
    169177         
    170178    def test_009_testPlotsMetadata(self): 
    171179        self.constructUsingArguments() 
    172180         
    173         nose.tools.assert_equal(self.pb.metadataBox.__class__ , 
     181        nose.tools.assert_equal(self.pb._metadataBox.__class__ , 
    174182                               geoplot.metadata_box.MetadataBox) 
    175183        nose.tools.assert_equal(self.pb.metadataList , 
    176                                 self.pb.metadataBox.dataList) 
     184                                self.pb._metadataBox.metadataList) 
    177185 
    178186    def test_010_testPlotsPlotArea(self): 
    179187        self.constructUsingArguments() 
    180188         
    181         nose.tools.assert_equal(self.pb.plotArea.__class__ , 
     189        nose.tools.assert_equal(self.pb._plotArea.__class__ , 
    182190                               geoplot.plotarea.PlotArea) 
    183191        nose.tools.assert_equal(self.pb.width, 
    184                                 self.pb.plotArea.width) 
     192                                self.pb._plotArea.width) 
    185193        nose.tools.assert_equal(self.pb.height, 
    186                                 self.pb.plotArea.height) 
     194                                self.pb._plotArea.height) 
    187195        nose.tools.assert_equal(self.pb.dpi, 
    188                                 self.pb.plotArea.dpi) 
     196                                self.pb._plotArea.dpi) 
    189197        nose.tools.assert_equal(self.pb.fontSize, 
    190                                 self.pb.plotArea.fontSize) 
     198                                self.pb._plotArea.fontSize) 
    191199        nose.tools.assert_equal(self.pb.plotTitle, 
    192                                 self.pb.plotArea.plotTitle) 
     200                                self.pb._plotArea.plotTitle) 
    193201                
    194202    def test_011_testPlotWriterAttribute(self): 
    195203        self.constructUsingArguments() 
    196204         
    197         nose.tools.assert_equal(self.pb.plotWriter.__class__ , 
     205        nose.tools.assert_equal(self.pb._plotWriter.__class__ , 
    198206                               geoplot.plot_writer.PlotWriter) 
    199207        nose.tools.assert_equal(self.pb.format, 
    200                                 self.pb.plotWriter.format) 
     208                                self.pb._plotWriter.format) 
    201209        nose.tools.assert_equal(self.pb.outputCMYK, 
    202                                 self.pb.plotWriter.outputCMYK) 
    203     def test_012_testDefaultCmap(self): 
    204         self.constructUsingDefaults() 
    205          
    206         defaultCmap = matplotlib.cm.get_cmap() 
    207         defaultCmap.set_bad("w") 
    208          
    209         nose.tools.assert_equal(self.pb.cmap.__class__, defaultCmap.__class__) 
    210          
    211         nose.tools.assert_true(test_utils._comparePublicAttribues(defaultCmap,  
    212                                                                self.pb.cmap)) 
    213          
    214 class SimplePlot(PlotBase): 
    215     """ 
    216     A simple implementation of the abstract PlotBase class that uses Mock grid 
    217     and map objects. 
    218     """ 
    219     def __init__(self, cdmsVar, **kwargs): 
    220         PlotBase.__init__(self, cdmsVar, **kwargs) 
    221  
    222     def _getMap(self, xLimits, yLimits, drawCoast, drawRivers, addShapefile): 
    223         return MockMap(xLimits, yLimits, drawCoast, drawRivers, addShapefile) 
    224  
    225     def _getGridBuilder(self, cdmsVar): 
    226         return MockGridBuilder(cdmsVar) 
    227  
    228 class MockGridBuilder(object): 
    229     def __init__(self, cdmsVar): 
    230         self.cdmsVar = cdmsVar 
    231  
    232 class MockMap(object): 
    233     def __init__(self,xLimits, yLimits, drawCoast, drawRivers, addShapefile): 
    234         self.xLimits = xLimits 
    235         self.yLimits = yLimits 
    236         self.drawCoast = drawCoast 
    237         self.drawRivers = drawRivers 
    238         self.addShapefile = addShapefile 
     210                                self.pb._plotWriter.outputCMYK) 
    239211         
    240212if __name__ == '__main__': 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_plot_rotated_grid.py

    r5403 r5636  
    22# test_map_rotated_grid.py 
    33import unittest 
     4import logging 
     5import nose 
     6import nose.tools as nt 
    47 
    58import cdms2 as cdms 
    6 import matplotlib 
    7  
    89from geoplot.plot_rotated_grid import PlotRotatedGrid 
    910 
    10 import geoplot.map_base as map_base 
    11  
    12 import geoplot.config as geoplot_config 
    13 geoplot_config._conf = None 
    14 config = geoplot_config.getConfig() 
    15  
    16 from matplotlib import cm 
    17  
    18 from geoplot.tests import testDataDir, outputsDir 
    19  
    20 DEFAULTS_SECTION = 'PlotBaseDefaults' 
     11log = logging.getLogger(__name__) 
    2112 
    2213class TestPlotRotatedGrid(unittest.TestCase): 
    2314 
    2415 
    25  
    26     rg_arguments = {'format':'jpg', 
    27                    'width': 400, 
    28                    'height': 601, 
    29                    'drawValues': True, 
    30                    'xLimits': (-13.0, 3.0), 
    31                    'yLimits': (49.0, 60.0), 
    32                    'dpi': 92, 
    33                    'cmap': cm.hot, 
    34                    'valueFormat': "%.2f", 
    35                    'drawColourBar': False, 
    36                    'colourBarLabel': "temperature change", 
    37                    'colourBarPosition': 'horizontal', 
    38                    'colourBarMin': 1, 
    39                    'colourBarMax': 10, 
    40                    'drawLogo': False, 
    41                    'drawCoast': False, 
    42                    'drawRivers': False, 
    43                    'plotTitle': " some plot", 
    44                    'metadataList': [('Name one', 'value 1'), ('Name two', 'value 2')], 
    45                    'fontSize': "large", 
    46                    'units': "degrees"} 
    47  
    48  
    49  
    50     rg_propertyTypes = {'format':str, 
    51                    'width': int, 
    52                    'height':int, 
    53                    'drawValues': bool, 
    54                    'xLimits': tuple, 
    55                    'yLimits': tuple, 
    56                    'dpi': int, 
    57                    'cmap': matplotlib.colors.LinearSegmentedColormap, 
    58                    'valueFormat': str, 
    59                    'drawColourBar': bool, 
    60                    'colourBarLabel': str, 
    61                    'colourBarPosition': str, 
    62                    'colourBarMin': float, 
    63                    'colourBarMax': float, 
    64                    'drawLogo': bool, 
    65                    'drawCoast': bool, 
    66                    'drawRivers': bool, 
    67                    'plotTitle': str, 
    68                    'metadataList': list, 
    69                    'fontSize': str, 
    70                    'units': str} 
    71  
    72  
    7316    def setUp(self): 
    74         #set the basemap resolution to coarse to improve construction time 
    75         self.oldResolution = map_base.BASEMAP_RESOLUTION 
    76         map_base.BASEMAP_RESOLUTION = 'c' 
     17        self.dataVar = cdms.createVariable([[2,3],[1,2]]) 
     18        self.rotVar = cdms.createVariable([0]) 
     19        self.rotVar.grid_north_pole_longitude = 198.0 
     20        self.rotVar.grid_north_pole_latitude = 39.25 
     21        self.rotVar.north_pole_grid_longitude = 0.0 
    7722         
    78         self.f = cdms.open(testDataDir +'/rg_test.nc') 
    79         var = self.f('air_temperature',squeeze=1) 
    80          
    81         self.rg_default = PlotRotatedGrid(var, self.f[var.grid_mapping]) 
    82         self.rg = PlotRotatedGrid(var, self.f[var.grid_mapping],  **TestPlotRotatedGrid.rg_arguments) 
     23        self.prg = PlotRotatedGrid(self.dataVar, self.rotVar) 
    8324         
    8425    def tearDown(self): 
    85         map_base.BASEMAP_RESOLUTION = self.oldResolution 
     26        pass 
    8627 
    87     def testConstructor(self): 
    88         #check that the same cdms variable can be retrieved from a new instance 
    89         for k in TestPlotRotatedGrid.rg_arguments.keys(): 
    90             self.assertEqual(getattr(self.rg,k), TestPlotRotatedGrid.rg_arguments[k]) 
     28    def test_001_checkAttributesCopied(self): 
    9129 
    92     def testDefaultValues(self): 
    93  
    94  
    95         valid_arguments = ['format', 'width', 'height', 'drawValues', 'xLimits', 
    96                      'yLimits', 'dpi', 'valueFormat' ,'drawColourBar', 'colourBarLabel', 
    97                      'colourBarMin', 'colourBarMax', 'drawLogo', 
    98                      'drawCoast', 'drawRivers', 'plotTitle', 'fontSize', 
    99                      'units', 'showGridLines', 'cmap', 'metadataList'] 
    100  
    101         defaults = {} 
    102         for arg in valid_arguments: 
    103             defaults[arg] = None 
    104  
     30        for a in ['grid_north_pole_longitude', 'grid_north_pole_latitude', 
     31                  'north_pole_grid_longitude']: 
     32             
     33            newVal = getattr(self.prg.cdmsVar,a) 
     34            oldVal = getattr(self.rotVar, a) 
     35            nt.assert_equal(newVal, oldVal) 
     36             
     37    def test_001_checkProjectionAndDataType(self): 
    10538         
    106         for arg in valid_arguments: 
    107             defaults[arg] = config[DEFAULTS_SECTION].get(arg) 
    108  
    109         if defaults['colourBarLabel']==None :  
    110             defaults['colourBarLabel'] = defaults['units'] 
    111  
    112         #need to convert xLimits and yLimits to tuples 
    113         if defaults['xLimits'] != None: 
    114             defaults['xLimits'] = tuple(defaults['xLimits']) 
    115  
    116         if defaults['yLimits'] != None: 
    117             defaults['yLimits'] = tuple(defaults['yLimits']) 
     39        nt.assert_equal(self.prg.projection, 'latlon') 
     40        nt.assert_equal(self.prg.dataType, 'rotated') 
    11841         
    119         print self.rg_default.width 
    120          
    121         #check that the default vlaues are applied correctly 
    122         for k in valid_arguments: 
    123             if k == 'cmap': 
    124                 continue  
    125             print k 
    126             self.assertEqual(getattr(self.rg_default,k), defaults[k]) 
    127  
    128     def testDefaultColourBarPosition(self): 
    129         pass 
    130         #!TODO: 
    131  
    132     def testTypes(self): 
    133         #check that the default vlaues are applied correctly 
    134         for k in TestPlotRotatedGrid.rg_propertyTypes.keys(): 
    135             if not getattr(self.rg_default,k) == None: 
    136                 self.assert_(isinstance(getattr(self.rg_default,k), 
    137                                         TestPlotRotatedGrid.rg_propertyTypes[k])) 
    138  
    139  
    140     def testCheckFilename(self): 
    141         self.rg.format = 'jpg' 
    142         self.assertRaises(Exception,  
    143                           self.rg.plotWriter.checkFileExtension, 
    144                           "somefolder/somefile.png") 
    145  
    146  
    14742def suite(): 
    14843    suite = unittest.TestSuite() 
    14944 
    15045    #use all methods that start with 'test' to make the suite 
    151 #    suite.addTest(unittest.makeSuite(TestPlotRotatedGrid)) 
     46    suite.addTest(unittest.makeSuite(TestPlotRotatedGrid)) 
    15247 
    153     suite.addTest(TestPlotRotatedGrid("testConstructor")) 
    154     suite.addTest(TestPlotRotatedGrid("testDefaultValues")) 
    155     suite.addTest(TestPlotRotatedGrid("testDefaultColourBarPosition")) 
    156     suite.addTest(TestPlotRotatedGrid("testTypes")) 
    157     suite.addTest(TestPlotRotatedGrid("testCheckFilename")) 
    158  
     48#    suite.addTest(TestPlotRotatedGrid("testConstructor")) 
    15949    return suite 
    16050 
    16151if __name__=='__main__': 
    162  
    163     import logging 
    164     fh = logging.FileHandler(outputsDir + '/test_map_rotated_grid.log') 
    165     fh.setLevel(logging.DEBUG) 
    166     fh.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) 
    167     from geoplot import log_util 
    168     log_util.addGeoplotHandler(fh) 
    169  
    170  
    171     #unittest.main() 
    172  
    173     s = suite() 
    174     unittest.TextTestRunner(verbosity=2).run(s) 
     52    nose.runmodule() 
     53     
     54    #s = suite() 
     55    #unittest.TextTestRunner(verbosity=2).run(s) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_utils.py

    r5612 r5636  
    1010import nose.tools as nt 
    1111import matplotlib 
     12import numpy 
    1213 
    1314import geoplot.utils 
     15 
     16from geoplot.utils import ispointInLimits, isValueInLimits, isRangeInLimits 
    1417 
    1518class Test_ScaleRGBList(object): 
     
    6265class TestRoundToN(object): 
    6366 
    64     def setUp(self): 
    65         pass 
    66  
    67     def tearDown(self): 
    68         pass 
    69  
    70     def testRoundToN(self): 
     67    def test_001_roundScalars(self): 
    7168        n = 4 
    7269        for value, answer in [(1.23451, 1.235),  
    7370                              (111111111.0, 111100000.0), 
    7471                              (0.0000000012321, 0.000000001232), 
     72                              (0.0, 0.0), 
    7573                               ]: 
    7674            recieved = geoplot.utils.round_to_n(value, n) 
    7775            nt.assert_equal(answer, recieved) 
    7876 
     77    def test_002_roundArrays(self): 
     78        n = 3 
     79        arr = numpy.array([238974.34, 0.00003435654, 0.69783456, 12320000000.23445]) 
     80        answer = numpy.array([239000.0, 0.0000344, 0.698, 12300000000.0]) 
     81         
     82        res = geoplot.utils.round_to_n(arr, n) 
     83        print repr(res[2]) 
     84        print repr(answer[2]) 
     85        print res[2] == answer[2] 
     86        assert numpy.allclose(answer, res) 
     87         
     88    def test_003_compareWithStringMethod(self): 
     89        # compare round_to_n with the old string method used 
     90        def rnd(x, n): 
     91            return float("%.*e" % (n-1,x)) 
     92         
     93        n=5 
     94        for val in [1232.231, 9481729412.0, 0.0000124124]: 
     95             
     96            answer = geoplot.utils.round_to_n(val, n) 
     97            oldAnswer = rnd(val, n) 
     98              
     99            nt.assert_almost_equal(answer, oldAnswer) 
     100         
     101 
     102class TestIsRangeInLimits(object): 
     103    def testRangeInLimits(self): 
     104        nt.assert_true( isRangeInLimits([1.5,2.5], [1.0,2.0]) ) 
     105        nt.assert_true( isRangeInLimits([0.5,1.5], [1.0,2.0]) ) 
     106        nt.assert_true( isRangeInLimits([0.5,2.5], [1.0,2.0]) ) 
     107         
     108        nt.assert_false( isRangeInLimits([0.5,0.99], [1.0,2.0]) ) 
     109        nt.assert_false( isRangeInLimits([2.01,12.0], [1.0,2.0]) ) 
     110 
     111class TestIsPointInLimits(object): 
     112    def testPointInLimits(self): 
     113        xlimits = (0.0,1.0) 
     114        ylimits = (2.0,3.0) 
     115         
     116        nt.assert_true( ispointInLimits((0.5,2.5), xlimits, ylimits )) 
     117        nt.assert_true( ispointInLimits((1.0,2.5), xlimits, ylimits )) 
     118        nt.assert_true( ispointInLimits((0.5,2.2), xlimits, ylimits )) 
     119         
     120        nt.assert_false( ispointInLimits((-0.5,2.2), xlimits, ylimits )) 
     121        nt.assert_false( ispointInLimits((1.5,2.2), xlimits, ylimits )) 
     122        nt.assert_false( ispointInLimits((0.5,5.2), xlimits, ylimits )) 
     123        nt.assert_false( ispointInLimits((0.5,0.2), xlimits, ylimits )) 
     124         
     125class TestValueInLimits(object): 
     126    def testValueInLimits(self): 
     127        nt.assert_true( isValueInLimits(1.5, [0.0,2.0])) 
     128        nt.assert_false( isValueInLimits(2.5, [0.0,2.0])) 
    79129 
    80130# Magic to run tests if executed as a script 
  • qesdi/geoplot/trunk/lib/geoplot/utils.py

    r5612 r5636  
    1010import StringIO 
    1111import logging 
     12import numpy 
    1213 
    1314import matplotlib.colors as colors 
     
    9394    return im 
    9495 
    95 def roundArr_to_n(arr, n): 
     96def round_to_n(arr, n): 
    9697    
    97     for ind in getAllIndices(arr.shape): 
    98         arr[ind] = round_to_n(arr[ind], n) 
    99          
    100     return arr 
    101  
    102 def round_to_n(x,n): 
    103     if n < 1: 
    104         raise Exception("cant round to %n significant figures" % (n,)) 
    105     return float("%.*e" % (n-1,x)) 
    106  
    107  
     98     
     99    c = numpy.log10(arr) 
     100    log.debug("c = %s" % (c,)) 
     101     
     102    if c.__class__ == numpy.ndarray: 
     103        c[numpy.isinf(c)] = 0.0 
     104    else: 
     105        if numpy.isinf(c) : 
     106            c = 0.0 
     107    log.debug("c = %s" % (c,))         
     108    c = numpy.power(10,numpy.floor(c)) 
     109    log.debug("c = %s" % (c,)) 
     110    res = (arr/c).round(n-1) * c 
     111    log.debug("res = %s" % (res,)) 
     112     
     113    return res 
    108114 
    109115def getAllIndices(shape): 
     
    125131        yield tuple(res) 
    126132     
     133         
     134 
     135def ispointInLimits(point, xLimits, yLimits): 
     136    x,y = point 
     137     
     138    if isValueInLimits(x, xLimits) and isValueInLimits(y, yLimits): 
     139        return True 
     140    else: 
     141        return False 
     142 
     143def isRangeInLimits(range, limits): 
     144         
     145    if isValueInLimits(range[0], limits): 
     146        return True 
     147     
     148    if isValueInLimits(range[1], limits): 
     149        return True 
     150     
     151    if range[0] <= limits[0] and range[1] >= limits[1]: 
     152        return True 
     153     
     154    return False 
     155         
     156def isValueInLimits(val, limits):    
     157    return  val >= limits[0] and val <= limits[1] 
Note: See TracChangeset for help on using the changeset viewer.