Changeset 5612


Ignore:
Timestamp:
13/08/09 13:25:02 (10 years ago)
Author:
pnorton
Message:

Have added some code that allows the grid drawer to decide if it should use imshow or pcolormesh to render the grid. This was done to get arround the problem of the grid cells having outlines when pcolormesh is used.

Also implemented a map function that chooses which basemap resolution to use if one isn't set.

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

Legend:

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

    r5610 r5612  
    1 from geoplot.contour_plot_base import ContourPlotBase 
     1from geoplot.plot_base import PlotBase 
    22from geoplot.contour_drawer import ContourDrawer 
    33 
     
    66log = logging.getLogger(__name__) 
    77 
    8 class ContourPlot(ContourPlotBase): 
     8class ContourPlot(PlotBase): 
    99    ''' 
    1010    Creates a contour plot form the data stored in a netCDF file 
    1111    ''' 
    1212    _accessableObjects = ['_contourDrawer'] 
    13     _accessableObjects.extend(ContourPlotBase._accessableObjects) 
     13    _accessableObjects.extend(PlotBase._accessableObjects) 
    1414     
    1515    def __init__(self, **kwargs): 
     
    2020        self._contourDrawer = ContourDrawer(**self._getArgs(kwargs, ContourDrawer.__name__)) 
    2121                 
    22         ContourPlotBase.__init__(self, **kwargs) 
     22        PlotBase.__init__(self, **kwargs) 
    2323         
    2424    def _drawDiagram(self, map, grid, axes): 
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_base.py

    r5610 r5612  
    230230        """ 
    231231        bounds = [] 
    232         log.debug("values = %s" % (values,)) 
    233232        shift = (values[1] - values[0])/2 
    234233        bounds.append(values[0] - shift) 
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_national.py

    r5610 r5612  
    128128        yAxis = cdmsVar.getAxis(0) 
    129129        xAxis = cdmsVar.getAxis(1) 
    130  
    131         log.debug("xAxis = %s" % (xAxis,)) 
    132130         
    133131        xBounds = GridBuilderBase._getBoundsFromAxis(xAxis) 
  • qesdi/geoplot/trunk/lib/geoplot/grid_drawer.py

    r5610 r5612  
    2828from geoplot.grid import Grid 
    2929from geoplot.grid_builder_base import GridBuilderBase 
     30import geoplot.utils as geoplot_utils 
    3031 
    3132#setup the logging 
     
    7778         
    7879        grid_mapUnits = grid.transform(basemap) 
     80         
     81         
     82         
     83         
    7984                 
    8085#        log.debug("xLimits = %s" % (xLimits,)) 
     
    8388        #draw the grid return the quadmesh for use 
    8489        sm = self._drawGridBoxes(axes, grid_mapUnits, basemap, cmap, norm) 
     90         
     91         
    8592         
    8693#        log.debug("self.drawValues = %s" % (self.drawValues,)) 
     
    126133            kwargs['linewidth'] = gridLineWidth 
    127134            kwargs['linestyle'] = 'solid' 
    128             kwargs['antialiased'] = False 
     135            kwargs['antialiased'] = True 
    129136 
    130137        #check the values aren't all masked 
     
    141148        #if all the values are masked make sure the outline is drawn 
    142149        if self.showGridLines == True: 
     150            st = time.time() 
    143151            # this will draw all the grid cells even if their contents is missing 
    144152            self._drawGridAsLines(axes, grid_mapUnits.boundsX, grid_mapUnits.boundsY,  
    145153                           color=gridColour, linewidth=gridLineWidth) 
     154            log.debug("drawn grid lines in = %s" % (time.time() - st,)) 
    146155         
    147156        if valuesFound == True: 
     
    164173                #check if the axis were in the opposite order 
    165174                if values.shape[1] == boundsShape[0] -1 and values.shape[0] == boundsShape[1] -1: 
    166                     values = N.transpose(values) 
    167                   
    168             log.debug("values.shape = %s" % (values.shape,)) 
    169  
    170             axes.pcolormesh(grid_mapUnits.boundsX,  
    171                             grid_mapUnits.boundsY,  
    172                             values,  
    173                             **kwargs) 
    174              
    175             log.debug("drawn mesh in %s" % (time.time() - st ,)) 
    176  
    177 #            st = time.time() 
    178 #             
    179 #            boundsMin = grid_mapUnits.boundsY[0,0] 
    180 #            boundsMax = grid_mapUnits.boundsY[-1,-1] 
    181 #             
    182 #            log.debug("boundsMin = %s" % (boundsMin,)) 
    183 #            log.debug("boundsMax = %s" % (boundsMax,)) 
    184 #             
    185 #            if boundsMin < boundsMax: 
    186 #                extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
    187 #                        grid_mapUnits.boundsY.max(), grid_mapUnits.boundsY.min())                 
    188 #            else: 
    189 #                extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
    190 #                        grid_mapUnits.boundsY.min(), grid_mapUnits.boundsY.max()) 
    191 #             
    192 #            im = axes.imshow(grid_mapUnits.values, extent=extent, 
    193 #                 interpolation='nearest', 
    194 #                 **kwargs 
    195 #            ) 
    196 #                         
    197 #            axes.set_aspect('auto') 
    198 #             
    199 #            log.debug("drawn imshow in %s" % (time.time() - st ,)) 
    200  
    201      
     175                    values = N.transpose(values)            
     176 
     177            #if the bounds are parralel then use imshow, otherwise stick with pcolormesh 
     178            if self._areBoundsParralel(grid_mapUnits.boundsX, grid_mapUnits.boundsY): 
     179                 
     180                self._drawImshow(axes,  
     181                                 grid_mapUnits.boundsX,  
     182                                 grid_mapUnits.boundsY,  
     183                                 values,  
     184                                 kwargs) 
     185                log.debug("drawn imshow in %s" % (time.time() - st ,)) 
     186                 
     187            else: 
     188                self._drawPcolormesh(axes,  
     189                                     grid_mapUnits.boundsX,  
     190                                     grid_mapUnits.boundsY,  
     191                                     values,  
     192                                     kwargs) 
     193                log.debug("drawn mesh in %s" % (time.time() - st ,)) 
     194             
     195             
     196 
     197 
     198    def _drawPcolormesh(self, axes, X, Y, Z, kwargs): 
     199        res = axes.pcolormesh(X, Y, Z, **kwargs) 
     200        return res 
     201     
     202    def _drawImshow(self, axes, X, Y, Z, kwargs): 
     203        yStart = Y[0,0] 
     204        yEnd = Y[-1,-1] 
     205         
     206        log.debug("yStart = %s" % (yStart,)) 
     207        log.debug("yEnd = %s" % (yEnd,)) 
     208         
     209        if yStart < yEnd: 
     210            extent=(X.min(), X.max(),Y.max(), Y.min())                 
     211        else: 
     212            extent=(X.min(), X.max(),Y.min(), Y.max()) 
     213         
     214        kwargs.pop('edgecolors') 
     215        kwargs.pop('linestyle') 
     216        kwargs.pop('linewidth') 
     217        kwargs.pop('antialiased') 
     218         
     219        im = axes.imshow(Z, extent=extent, 
     220             interpolation='nearest', 
     221             **kwargs 
     222        ) 
     223                     
     224        axes.set_aspect('auto') 
     225         
     226    def _areBoundsParralel(self, X, Y ): 
     227        """ 
     228        checks if all the bound are parallel, this is a test to see if using 
     229        imshow is possible. 
     230         
     231        Checks the equality to 5 significant figures. 
     232        """ 
     233        n = 5 
     234        frmt = "%." + str(n) + "e" 
     235        st = time.time() 
     236         
     237        equal = True 
     238        x_first = [frmt % x for x in X[0]] 
     239         
     240        for i in range(1, X.shape[0]): 
     241            x_row = [frmt % x for x in X[i]] 
     242            equal = x_first == x_row 
     243            if not equal: 
     244                break 
     245 
     246        xEq = equal 
     247         
     248        if equal: 
     249            y_first = [frmt % y for y in Y[:,0]] 
     250             
     251            for i in range(1, Y.shape[1]): 
     252                y_col = [frmt % y for y in Y[:,i]] 
     253                equal = y_first == y_col 
     254                if not equal: 
     255                    break 
     256 
     257        yEq = equal 
     258        log.debug("xEq = %s, yEq = %s worked out in = %s" % (xEq, yEq, time.time() - st,)) 
     259         
     260        return equal  
     261             
     262 
    202263    def _drawGridAsLines(self, axes, X, Y, color='0.25', linewidth=0.3): 
    203264        """ 
  • qesdi/geoplot/trunk/lib/geoplot/grid_plot.py

    r5610 r5612  
    1313import logging 
    1414 
    15 from geoplot.contour_plot_base import PlotBase 
     15from geoplot.plot_base import PlotBase 
    1616from geoplot.grid_drawer import GridDrawer 
    1717 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid.py

    r5605 r5612  
    2828from geoplot.layer_drawer import LayerDrawerBase 
    2929 
    30 from matplotlib.collections import LineCollection 
     30from matplotlib.colors import Normalize 
    3131 
    3232log = logging.getLogger(__name__) 
     
    4242        self._cmap = None 
    4343        self._gridDrawer = GridDrawer() 
     44         
     45        log.debug("cmapRange = %s" % (cmapRange,)) 
    4446         
    4547        if cmapRange[0] > cmapRange[1]: 
     
    7072            basemap = map.basemap         
    7173         
     74        norm = Normalize(self.cmapRange[0], self.cmapRange[1]) 
     75         
    7276        #draw the grid on the axis 
    7377        self._gridDrawer.draw(axes, grid, 
    7478                              basemap=basemap,  
    75                               limits=(xLimits, yLimits),  
    76                               cmapRange=self.cmapRange, 
     79                              limits=(xLimits, yLimits), 
     80                              norm=norm, 
    7781                              cmap=self.cmap) 
     82                               
    7883     
    7984    ### properties ### 
  • qesdi/geoplot/trunk/lib/geoplot/map_base.py

    r5605 r5612  
    5151        self._yLimits = yLimits 
    5252 
    53         self._setBasemap() 
    54  
    5553    def drawMap(self, axes): 
    5654        """ 
     
    219217                            % (limits, name)) 
    220218 
     219    def _guessResolution(self, xLimits, yLimits): 
     220        smallestDim = min([xLimits[1] -xLimits[0], yLimits[1] - yLimits[0]]) 
     221         
     222        if smallestDim < 5: 
     223            res = 'h' 
     224        elif smallestDim < 20: 
     225            res = 'i'  
     226        elif smallestDim < 100: 
     227            res = 'l' 
     228        else: 
     229            res = 'c' 
     230             
     231        log.debug("smallestDim = %s, res = %s" % (smallestDim, res,)) 
     232        return res 
     233 
    221234    #getters and setters for the xLimit and yLimit properties, these are needed 
    222235    #to try and ensure that the basemap which is dependent on the limits is  
  • qesdi/geoplot/trunk/lib/geoplot/map_lat_lon.py

    r5552 r5612  
    6767         
    6868        if resolution == None: 
    69             self.basemap = getBasemap(BASEMAP_RESOLUTION) 
    70         else: 
    71             self.basemap = getBasemap(resolution) 
     69            resolution = self._guessResolution(xLimits, yLimits) 
     70 
     71        self.basemap = getBasemap(resolution) 
    7272 
    7373        MapBase.__init__(self, xLimits, yLimits, drawCoast, drawRivers, addShapefile) 
    7474 
    75     def _setBasemap(self): 
    76         """ 
    77         Sets the self.basemap to a new basemap that repreesents the lat-lon grid within the 
    78         limits of the map. 
    79         """ 
    80         pass 
    81 #        st = time.time() 
    82 #        self.basemap = basemap.Basemap(lon_0=0.0, 
    83 #                                       lat_0=0.0, 
    84 #                                       llcrnrlon=self.xLimits[0], 
    85 #                                       llcrnrlat=self.yLimits[0], 
    86 #                                       urcrnrlon=self.xLimits[1], 
    87 #                                       urcrnrlat=self.yLimits[1], 
    88 #                                       resolution=self._getBasemapResolution(), 
    89 #                                       suppress_ticks=False) 
     75    def _configAxes(self, axes): 
    9076         
    91 #        log.debug("created basemap in %.2fs" % (time.time() - st,)) 
    92              
    93     def _configAxes(self, axes): 
     77        axes.set_xlabel("Longitude") 
     78        axes.set_ylabel("Latitude") 
    9479        pass 
    9580 
  • qesdi/geoplot/trunk/lib/geoplot/map_national_grid.py

    r5552 r5612  
    7878        MapBase.__init__(self, xLimits, yLimits, drawCoast, drawRivers, addShapefile) 
    7979 
    80  
    81     def _setBasemap(self): 
    82         """ 
    83         Sets the self.basemap to a new basemap that repreesents the national grid within the 
    84         limits of the map. 
    85         """ 
    86         pass 
    87         st = time.time() 
    88 #        self.basemap = basemap.Basemap(projection='tmerc', 
    89 #                                       lon_0=trueOrigin[0], 
    90 #                                       lat_0=trueOrigin[1], 
    91 #                                       llcrnrlon=self.xLimits[0], 
    92 #                                       llcrnrlat=self.yLimits[0], 
    93 #                                       urcrnrlon=self.xLimits[1], 
    94 #                                       urcrnrlat=self.yLimits[1], 
    95 #                                       resolution=self._getBasemapResolution(), 
    96 #                                       suppress_ticks=False) 
    97 #         
    98 #        log.debug("created basemap in %.2fs" % (time.time() - st,)) 
    9980         
    10081    def _configAxes(self, axes): 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_grid_plot_latlon.py

    r5610 r5612  
    4646    pll = PlotLatLon(var, format = plot_format, 
    4747                    fontSize = 'medium', units = 'A Test Plot', 
    48                     plotTitle = "A Test Plot", showGridLines = True, 
     48                    plotTitle = "A Test Plot", showGridLines = False, 
    4949                    drawLogo = True, metadataList = eg_metadata_list, 
    50                     drawCoast = True, drawRivers = True, 
     50                    drawCoast = True, drawRivers = False, 
    5151                    drawColourBar = True, drawValues = False, 
    5252                    xLimits=xLimits, yLimits=yLimits) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/draw_test_grid_plot_national_onll.py

    r5610 r5612  
    1414    from geoplot.tests.drawing import getDrawingOutputDir 
    1515    from geoplot.log_util import SHORT_LOG_FORMAT_STRING, LOG_FORMAT_STRING 
    16     logging.basicConfig(level=logging.DEBUG, format=SHORT_LOG_FORMAT_STRING) 
     16    logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT_STRING) 
    1717     
    18     from geoplot.plot_national_grid import PlotNationalGrid 
     18    from geoplot.grid_plot import GridPlot 
    1919     
    2020    outputsDir = getDrawingOutputDir() 
     
    3737    #var = f(dataVariable, meaning_period=1, squeeze=1) 
    3838 
    39     outputFile = outputsDir + '/national_grid_test.png' 
     39    outputFile = outputsDir + '/ng_plot_on_latlon.png' 
    4040 
    4141    eg_metadata_list = [("Dataset", "MOHC Probabilistic Land"), 
     
    5959# show the whole grid xLimits=(-13.0, 6.2), yLimits=(47.0, 61.0) 
    6060# show the whole of the uk xLimits=(-11.0, 2.8), yLimits=(48.0, 60.0) 
    61 #xLimits=( -2.0,   2.0), yLimits=( 50.0, 54.0) 
     61#    xLimits=( 0.2,   0.4); yLimits=( 51.4, 51.5) 
    6262#xLimits=(  0.0, 359.8), yLimits=(-90.0, 89.8), 
    6363    xLimits=(-20.0,  15.0); yLimits=( 40.0, 70.0) 
    6464#xLimits=( -7.0,   2.0), yLimits=( 54.0, 64.0)  scotland 
    6565 
    66 #    png = PlotNationalGrid(var, format='png', drawValues=False, 
    67 #                         fontSize="medium", units="degrees C", drawLogo=False, 
    68 #                         plotTitle="A Test Plot", showGridLines=True, 
    69 #                         cmap=cmap, drawColourBar=True, metadataList=None, 
    70 #                         xLimits=(-13.0, 7.0), yLimits=(47.0, 62.0) 
    71 #                         #colourBarMin=-10, colourBarMax=110 
    72 #                         ) 
    73 #                         #xLimits=(-1.0, 0.75), yLimits=(53.0, 54.0)) 
    74 #                         #drawLogo=True, metadataList = eg_metadata_list, 
    75 #                         #drawColourBar = True) 
    7666 
    77     png = PlotNationalGrid(var, format='png', units='degrees C', cmap = cmap, 
    78                            metadataList=[('one',1), ('two',2)], 
    79                            plotTitle="A Test Plot", 
    80                            xLimits=xLimits, yLimits=yLimits) 
     67    png = GridPlot(cdmsVar=var, format='png', units='degrees C', cmap = cmap, 
     68                   metadataList=[('one',1), ('two',2)], drawRivers=False, 
     69                   plotTitle="A Test Plot", showGridLines=False, 
     70                   dataType='national', projection='latlon', 
     71                   xLimits=xLimits, yLimits=yLimits) 
    8172 
    8273    png.drawMap(outputFile) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/test_draw_grid.py

    r5412 r5612  
    1818from geoplot.mpl_imports import basemap 
    1919from matplotlib.backends.backend_agg import FigureCanvasAgg 
     20from matplotlib.backends.backend_cairo import FigureCanvasCairo 
     21 
    2022from matplotlib.backends.backend_ps import FigureCanvasPS 
    2123from matplotlib.figure import Figure 
     
    6062    cmap.set_bad("w") 
    6163 
    62     sm = bm.pcolormesh(grid.boundsX, grid.boundsY, grid.values, cmap=cmap, ax=axes, edgecolors='k') 
     64    sm = bm.pcolor(grid.boundsX, grid.boundsY, grid.values, cmap=cmap, ax=axes, antialiased=False,  edgecolors='None') 
    6365 
    6466    bm.drawcoastlines(ax = axes) 
     
    6971    canvas = FigureCanvasAgg(fig) 
    7072    filename = os.path.join(getDrawingOutputDir(), "grid.png") 
     73    canvas.print_figure(filename) 
     74     
     75    log.debug("Wrote " + filename) 
     76     
     77    canvas = FigureCanvasCairo(fig) 
     78    filename = os.path.join(getDrawingOutputDir(), "grid2.png") 
    7179    canvas.print_figure(filename) 
    7280     
  • qesdi/geoplot/trunk/lib/geoplot/tests/unit/test_utils.py

    r5403 r5612  
    88# Import third-party software 
    99import nose 
     10import nose.tools as nt 
    1011import matplotlib 
    1112 
     
    5859        scaledList = geoplot.utils._scaleRGBList(self.l) 
    5960        assert(scaledList == self.cmap.colors) 
     61         
     62class TestRoundToN(object): 
     63 
     64    def setUp(self): 
     65        pass 
     66 
     67    def tearDown(self): 
     68        pass 
     69 
     70    def testRoundToN(self): 
     71        n = 4 
     72        for value, answer in [(1.23451, 1.235),  
     73                              (111111111.0, 111100000.0), 
     74                              (0.0000000012321, 0.000000001232), 
     75                               ]: 
     76            recieved = geoplot.utils.round_to_n(value, n) 
     77            nt.assert_equal(answer, recieved) 
     78 
    6079 
    6180# Magic to run tests if executed as a script 
  • qesdi/geoplot/trunk/lib/geoplot/utils.py

    r5552 r5612  
    9191    log.debug("converted figure to image in %s" % (time.time() - st,)) 
    9292     
    93     return im   
     93    return im 
     94 
     95def roundArr_to_n(arr, n): 
     96    
     97    for ind in getAllIndices(arr.shape): 
     98        arr[ind] = round_to_n(arr[ind], n) 
     99         
     100    return arr 
     101 
     102def 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 
     108 
     109def getAllIndices(shape): 
     110    totalSize = 1 
     111    for dim in shape: 
     112        totalSize *= dim 
     113 
     114    #build a list to hold the results  
     115    res = [0] * len(shape) 
     116 
     117    for i in range(totalSize): 
     118         
     119        for dimInd, dim in enumerate(shape): 
     120             
     121            step = i % dim # step along this dimension 
     122            i = i / dim    # reduce the remaining steps 
     123            res[dimInd] = step 
     124         
     125        yield tuple(res) 
     126     
Note: See TracChangeset for help on using the changeset viewer.