Changeset 5412


Ignore:
Timestamp:
24/06/09 16:19:28 (10 years ago)
Author:
pnorton
Message:

Cleaned up the layers drawing code slightly and added some additional tests that create images using the layer drawing objects.

Location:
qesdi/geoplot/trunk
Files:
6 added
1 deleted
19 edited

Legend:

Unmodified
Added
Removed
  • qesdi/geoplot/trunk

    • Property svn:ignore set to
      .project
      .pydevproject
  • qesdi/geoplot/trunk/buildout

    • Property svn:ignore set to
      bin
      develop-eggs
      eggs
      parts
      .installed.cfg
  • qesdi/geoplot/trunk/buildout/buildout.cfg

    r5403 r5412  
    44develop =  
    55  ../ 
    6   ../../../image_utils/trunk/ 
     6  ../../image_utils_trunk/ 
    77download-cache = /home/users/pnorton/python_eggs/ 
    88 
  • qesdi/geoplot/trunk/lib

    • Property svn:ignore set to
      geoplot.egg-info
  • qesdi/geoplot/trunk/lib/geoplot/colour_bar.py

    r5403 r5412  
    55import matplotlib.colors 
    66import matplotlib.ticker 
     7from matplotlib.figure import Figure 
     8from matplotlib.colorbar import ColorbarBase 
     9import matplotlib.cm as cm 
    710 
    811import geoplot.config as geoplot_config 
     12import geoplot.utils 
     13 
     14 
    915config = geoplot_config.getConfig() 
    1016 
     
    204210                    "colour bar position, 'horizontal' or 'vertical'") 
    205211 
     212 
     213def getColourBarImage(width=600, height=100, 
     214                      label=None,  
     215                      cmap=cm.jet,  
     216                      cmapRange=(0,1),  
     217                      orientation='horizontal', 
     218                      dpi=100): 
     219     
     220    figsize=(width / float(dpi), height / float(dpi)) 
     221    fig = Figure(figsize=figsize, dpi=dpi, facecolor='w') 
     222     
     223    #need about 40px at the bottom of the axes to draw the labels 
     224    x = 40.0 
     225     
     226    cbBottom = 40.0/height 
     227     
     228    if cbBottom < 0.1: 
     229        cbBottom = 0.1 
     230     
     231    if cbBottom > 0.5: 
     232        cbBottom = 0.5 
     233         
     234    cbHeight = 0.9 - cbBottom 
     235     
     236    axes = fig.add_axes([0.05, cbBottom, 0.9, cbHeight], frameon=False) 
     237     
     238    cb = ColorbarBase(axes, cmap=cmap, norm=matplotlib.colors.Normalize(cmapRange[0],cmapRange[1]),  
     239                      orientation=orientation) 
     240     
     241    if label != None: 
     242        cb.set_label(label) 
     243#    axes.set_xticks([]) 
     244#    axes.set_yticks([]) 
     245     
     246    return geoplot.utils.figureToImage(fig) 
     247     
     248     
     249     
    206250if __name__ == '__main__': 
    207251 
  • qesdi/geoplot/trunk/lib/geoplot/contour_drawer.py

    r5403 r5412  
    3434class ContourDrawer(object): 
    3535    """ 
    36     Responsible for knwoing how to draw a Grid object onto a given matplotlib  
    37     axes 
     36    Responsible for knowing how to draw contours onto an axis, the data 
     37    for the contours is taken form a grid object 
    3838    """ 
    3939 
    4040    def __init__(self, cmap=None): 
    4141        """ 
    42         Constructs a GridDrawer object               
     42        Constructs a ContourDrawer object               
    4343        """ 
    4444 
     
    5151    def draw(self, axes, grid, basemap=None, cmapRange=(None,None)): 
    5252        """ 
    53         Draws the grid given on the axis. 
     53        Draws contour lines from the grid's data on the axis. 
    5454         
    5555        @param axes: the axes the grid will be drawn on 
     
    5757        @param grid: the grid to be drawn 
    5858        @type grid: geoplot.grid 
    59         @keyword limits: the limits of the drawing (in lat lon) 
    60         @type limits: tuple 
    6159        @keyword basemap: the basemap instance to scale the grid values to be  
    6260            drawn on the axis. 
    6361        """ 
    6462 
    65          
     63        #transform the grid data to the correct projection 
    6664        grid_mapUnits = grid.transform(basemap) 
    6765                 
    68 #        log.debug("xLimits = %s" % (xLimits,)) 
    69 #        log.debug("yLimits = %s" % (yLimits,)) 
    70  
    71         #draw the grid return the quadmesh for use 
    7266        self._drawContours(axes, grid_mapUnits, cmapRange) 
    7367         
    7468    def _drawContours(self, axes,  grid_mapUnits, cmapRange): 
    7569        """ 
    76         Draws the grid boxes onto the axes. 
     70        Draws the contour lines onto the axes. 
    7771        """ 
    7872 
    7973        #check the values aren't all masked 
    80          
    81         # Its possible that this test becomes time consuming for large arrays,  
    82         # it is pssible that using sum might be faster, but this will only work 
    83         # if True + True = 2. 
    84         # valuesFound = not grid.values.mask.sum() == len(grid.values.mask.flatten()) 
    85          
    86         # for now this is so quick it doesn't matter. 
    8774        valuesFound = not reduce(operator.and_, grid_mapUnits.values.mask.flat) 
    8875         
     
    9683             
    9784                log.debug("levels = %s" % (levels,)) 
    98              
    99              
    10085             
    10186            extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
  • qesdi/geoplot/trunk/lib/geoplot/filtered_basemap.py

    r5403 r5412  
    3939            ax = self.ax 
    4040         
    41 #        print "self.coastsegs has %s lines and %s points" % (len(self.coastsegs), 
    42 #                                                             sum([len(x) for x in self.coastsegs])) 
    43          
    44         segs = self.__getSegments(xLimits, yLimits) 
    45  
    46 #        print "segs has %s lines and %s points" % (len(segs), 
    47 #                                        sum([len(x) for x in segs])) 
     41        print "self.coastsegs has %s lines and %s points" % (len(self.coastsegs), 
     42                                                             sum([len(x) for x in self.coastsegs])) 
     43         
     44        xLimitsMapUnits, yLimitsMapUnits = self.__call__(xLimits, yLimits) 
     45         
     46        segs = self.__getSegments(xLimitsMapUnits, yLimitsMapUnits) 
     47 
     48        print "segs has %s lines and %s points" % (len(segs), 
     49                                        sum([len(x) for x in segs])) 
    4850 
    4951#        width = (xLimits[1] - xLimits[0]) 
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_lat_lon.py

    r5403 r5412  
    6868#        log.debug("selecting longitude=%s latitude=%s" % (lonSelection, latSelection)) 
    6969         
    70         newVar = self.cdmsVar(longitude=lonSelection, 
    71                               latitude =latSelection) 
     70        try: 
     71            newVar = self.cdmsVar(longitude=lonSelection, 
     72                                  latitude =latSelection) 
     73        except:  
     74            log.exception("Exception occurred while subsetting variable") 
     75            newVar = self.cdmsVar 
    7276         
    7377#        log.debug("New longitude from %s to %s" % ( newVar.getLongitude().getValue()[0], newVar.getLongitude().getValue()[-1])) 
  • qesdi/geoplot/trunk/lib/geoplot/grid_builder_rotated.py

    r5403 r5412  
    3737    """ 
    3838 
    39     def __init__(self, cdmsVar, rotatedPoleVar): 
     39    def __init__(self, cdmsVar, rotatedPoleVar=None): 
    4040        """ 
    4141        constructs a new instance of the GridBuilderRotated class 
    4242        """ 
    4343        GridBuilderBase.__init__(self, cdmsVar) 
    44         self.rotatedPoleVar = rotatedPoleVar 
     44         
     45        if rotatedPoleVar == None: 
     46           self.rotatedPoleVar = cdmsVar 
     47        else: 
     48            self.rotatedPoleVar = rotatedPoleVar 
     49         
    4550 
    4651    def _resizeVar(self, xLimits, yLimits): 
  • qesdi/geoplot/trunk/lib/geoplot/grid_drawer.py

    r5403 r5412  
    141141         
    142142        #if all the values are masked make sure the outline is drawn 
    143         if self.showGridLines == True or valuesFound == False: 
    144             pass 
     143        if self.showGridLines == True: 
    145144            # this will draw all the grid cells even if their contents is missing 
    146 #            self._drawGridAsLines(axes, xBounds_mapUnits, yBounds_mapUnits,  
    147 #                           color=gridColour, linewidth=gridLineWidth) 
     145            self._drawGridAsLines(axes, grid_mapUnits.boundsX, grid_mapUnits.boundsY,  
     146                           color=gridColour, linewidth=gridLineWidth) 
    148147         
    149148        if valuesFound == True: 
     
    165164#            log.debug("grid_mapUnits.values.shape = %s" % (grid_mapUnits.values.shape,)) 
    166165             
    167 #            sm = axes.pcolormesh(grid_mapUnits.boundsX,  
    168 #                                 grid_mapUnits.boundsY,  
    169 #                                 grid_mapUnits.values, **kwargs) 
    170              
    171             extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
    172                     grid_mapUnits.boundsY.min(), grid_mapUnits.boundsY.max()) 
    173  
    174             im = axes.imshow(grid_mapUnits.values, extent=extent, 
    175 #                 vmin=cmapRange[0], vmax=cmapRange[1], 
    176                  interpolation='nearest', 
    177 #                 interpolation='bicubic', 
    178 #                 interpolation='bilinear', 
    179                  norm=norm 
    180             ) 
    181             log.debug("extent = %s" % (extent,)) 
    182              
    183             axes.set_aspect('auto') 
    184              
    185             sm = matplotlib.collections.Collection() 
    186             sm.set_array(N.array([0,1]))             
    187              
    188              
    189             log.debug("extent = %s" % (extent,)) 
    190              
    191             CS = axes.contour(grid_mapUnits.midpointsX,  
    192                               grid_mapUnits.midpointsY,  
    193                               grid_mapUnits.values, 
    194                               levels, 
    195                  cmap=matplotlib.cm.gray, 
    196                  origin='lower', 
    197                  linewidths=1, 
    198                  norm=norm, 
    199                  extend='neither', 
    200                  ) 
    201              
    202             axes.clabel(CS) 
    203              
    204             axes.set_aspect('auto') 
     166            sm = axes.pcolormesh(grid_mapUnits.boundsX,  
     167                                 grid_mapUnits.boundsY,  
     168                                 grid_mapUnits.values, **kwargs) 
     169             
     170#            extent=(grid_mapUnits.boundsX.min(), grid_mapUnits.boundsX.max(), 
     171#                    grid_mapUnits.boundsY.min(), grid_mapUnits.boundsY.max()) 
     172             
     173# 
     174#            im = axes.imshow(grid_mapUnits.values, extent=extent, 
     175##                 vmin=cmapRange[0], vmax=cmapRange[1], 
     176#                 interpolation='nearest', 
     177##                 interpolation='bicubic', 
     178##                 interpolation='bilinear', 
     179#                 norm=norm 
     180#            ) 
     181#            log.debug("extent = %s" % (extent,)) 
     182#             
     183#            axes.set_aspect('auto') 
     184#             
     185#            sm = matplotlib.collections.Collection() 
     186#            sm.set_array(N.array([0,1]))             
     187#             
     188#             
     189#            log.debug("extent = %s" % (extent,)) 
     190#             
     191#            CS = axes.contour(grid_mapUnits.midpointsX,  
     192#                              grid_mapUnits.midpointsY,  
     193#                              grid_mapUnits.values, 
     194#                              levels, 
     195#                 cmap=matplotlib.cm.gray, 
     196#                 origin='lower', 
     197#                 linewidths=1, 
     198#                 norm=norm, 
     199#                 extend='neither', 
     200#                 ) 
     201#             
     202#            axes.clabel(CS) 
     203#             
     204#            axes.set_aspect('auto') 
    205205                         
    206206        else: 
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer.py

    r5403 r5412  
    1919 
    2020from geoplot.map_lat_lon import MapLatLon 
    21  
    22 from geoplot.grid_drawer import GridDrawer 
     21from geoplot.map_national_grid import MapNationalGrid 
     22 
    2323import geoplot.utils as geoplot_utils 
    2424 
     
    2727VALID_GRID_TYPES = ['latlon', 'national', 'rotated'] 
    2828 
    29 class LayerDrawer(object): 
    30     "Draw only the layer section of the plot" 
    31      
    32     def __init__(self, gridType='latlon', showGridLines=False, cmap=None, cmapRange=(None,None), outline=False): 
    33          
    34         self._gridDrawer = GridDrawer() 
    35          
    36         self.cmapRange = cmapRange 
    37         self.showGridLines = showGridLines 
     29VALID_PROJECTIONS = ['latlon', 'national'] 
     30 
     31class LayerDrawerBase(object): 
     32    "Draws only the layer section of the plot to create a PIL image object" 
     33     
     34    def __init__(self,  
     35                 gridType='latlon',  
     36                 transparent=False, 
     37                 projection='latlon', 
     38                 resolution='c'): 
     39         
     40        self.resolution = resolution 
     41        self.projection = projection 
     42        self.transparent = transparent 
    3843        self.gridType = gridType 
    39         self.cmap = cmap 
    40         self.outline = outline 
    41      
    42     def makeImage(self, cdmsVar, xLimits=None, yLimits=None, width=800, height=600, dpi=100, 
    43                   rotatedPoleVar=None): 
    44          
    45         st = time.time() 
    46         fig = self._drawToFigure(cdmsVar, xLimits, yLimits, width, height, dpi, rotatedPoleVar) 
     44         
     45    def makeImage(self, xLimits=None, yLimits=None, width=800, height=600, dpi=100): 
     46        """ 
     47        Creates a PIL image of the selected area of the layer. 
     48        """ 
     49         
     50        fig = self._getFigure(width, height, dpi) 
     51         
     52        axes = self._addAxes(fig) 
     53         
     54        self._drawToAxes(axes, xLimits, yLimits) 
     55         
     56        self._resetAxes(axes, xLimits, yLimits) 
    4757         
    4858        im = geoplot_utils.figureToImage(fig) 
    49         log.debug(" made image id=%s (xlim=%s, ylim=%s) in %.2fs (%sx%s) #%s" % (cdmsVar.id, xLimits, yLimits, time.time() - st, width, height, thread.get_ident() )) 
    5059         
    5160        return im 
    5261     
    53     def _drawToFigure(self, cdmsVar, xLimits, yLimits, width, height, dpi, rotatedPoleVar): 
    54          
    55         figsize=(width / dpi, height / dpi) 
    56         fig = Figure(figsize=figsize, dpi=dpi, facecolor='w', frameon=True) 
    57                  
    58         axes = fig.add_axes([0.0, 0.0, 1.0, 1.0], xticks=[], yticks=[],  
    59                             frameon=False) 
     62     
     63    def _drawToAxes(self, *args, **kwargs): 
     64        """ 
     65        Draw the layer onto the axis, should be overidden by all subclasses. 
     66        """ 
     67         
     68        raise NotImplementedError() 
     69     
     70    def _getFigure(self, width, height, dpi): 
     71        """ 
     72        Returns a new figure object that is ready to be drawn on. 
     73        """ 
     74 
     75        figsize=(width / float(dpi), height / float(dpi)) 
     76 
     77        fig = Figure(figsize=figsize, dpi=dpi, facecolor='w',  
     78                     frameon=(not self.transparent)) 
     79         
     80        return fig         
     81     
     82    def _addAxes(self, figure): 
     83        """ 
     84        Adds an axis to the figure object provided. The axes has no border and takes 
     85        up all the area on the figure so that anything drawn on the axis will  
     86        completly cover the figure. 
     87         
     88        The axis background is transparent, if self.transparency is set to false 
     89        then the Figure's frameon should be set to true not the axis. 
     90        """ 
     91        axes = figure.add_axes([0.0, 0.0, 1.0, 1.0], xticks=[], yticks=[], 
     92                             frameon=False) 
     93         
     94        return axes 
     95     
     96    def _buildGrid(self, cdmsVar, xLimits, yLimits): 
     97        """ 
     98        Builds a new grid object using the data found in the cdmsVar. 
     99        """ 
    60100         
    61101        builderClass = self._getGridBuilderClass() 
    62102         
    63         if rotatedPoleVar == None: 
    64             gridBuilder = builderClass(cdmsVar) 
     103        gridBuilder = builderClass(cdmsVar) 
     104         
     105        grid = gridBuilder.buildGrid(xLimits=xLimits, yLimits=yLimits) 
     106         
     107        return grid 
     108     
     109    def _resetAxes(self, axes, xLimits=None, yLimits=None): 
     110        """ 
     111        resets the axis to the original limis and aspect after they have 
     112        been drawn on, this is needed as some methods of drawing to the axis 
     113        (notably basemap) change these properties. 
     114        """ 
     115         
     116        axes.set_aspect('auto') 
     117         
     118        axes.set_xticks([]) 
     119        axes.set_yticks([]) 
     120         
     121        if self.projection == 'latlon': 
     122            xLimitsMapUnits, yLimitsMapUnits = xLimits, yLimits 
    65123        else: 
    66             gridBuilder = builderClass(cdmsVar, rotatedPoleVar) 
    67          
    68         grid = gridBuilder.buildGrid(xLimits=xLimits, yLimits=yLimits) 
    69                  
    70         self._gridDrawer.draw(axes, grid, limits=(xLimits, yLimits), cmapRange=self.cmapRange) 
    71          
    72 #        if xLimits == None: 
    73 #            mapXLim = (grid.boundsX.min(), grid.boundsX.max()) 
    74 #        else: 
    75 #            mapXLim = xLimits 
    76 #             
    77 #        if yLimits == None: 
    78 #            mapYLim = (grid.boundsY.min(), grid.boundsY.max()) 
    79 #        else: 
    80 #            mapYLim = yLimits 
    81 #         
    82 #        map = MapLatLon(mapXLim, mapYLim, drawCoast=True, drawRivers=False) 
    83 #         
    84 #        map.drawMap(axes) 
    85          
    86         axes.set_aspect('auto') 
    87          
    88 #        log.debug("axes.get_xlim() = %s" % (axes.get_xlim(),)) 
    89 #        log.debug("axes.get_ylim() = %s" % (axes.get_ylim(),)) 
     124            map = self._getMap(xLimits, yLimits) 
     125            xLimitsMapUnits, yLimitsMapUnits = map.basemap(xLimits, yLimits) 
    90126         
    91127        #reset the limits after drawing the grid 
    92128        if xLimits != None: 
    93             axes.set_xlim(float(xLimits[0]), float(xLimits[1])) 
     129            axes.set_xlim(float(xLimitsMapUnits[0]), float(xLimitsMapUnits[1])) 
    94130         
    95131        if yLimits != None: 
    96             axes.set_ylim(float(yLimits[0]), float(yLimits[1])) 
    97              
    98         return fig         
    99      
     132            axes.set_ylim(float(yLimitsMapUnits[0]), float(yLimitsMapUnits[1]))     
     133         
     134    def _getMap(self, xLimits, yLimits, ): 
     135        """ 
     136        Returns a map object that corresponds to the current projection, 
     137        map objects can be used for transformation or drawing data. 
     138        """ 
     139         
     140        if self.projection == 'latlon': 
     141            map = MapLatLon(xLimits, yLimits, drawCoast=True, drawRivers=False, 
     142                            resolution=self.resolution) 
     143        else: 
     144            map = MapNationalGrid(xLimits, yLimits, drawCoast=True, drawRivers=False, 
     145                                  resolution=self.resolution) 
     146             
     147        return map         
     148         
     149 
    100150     
    101151    def _getGridBuilderClass(self): 
     152        """ 
     153        Returns the correct bridge builder class for the value of self.gridType. 
     154        """ 
    102155         
    103156        if self.gridType == 'latlon': 
    104157            return GridBuilderLatLon 
     158         
    105159        elif self.gridType == 'national': 
    106160            return GridBuilderNational 
     161         
    107162        elif self.gridType == 'rotated': 
    108163            return GridBuilderRotated 
    109              
    110              
     164     
     165    ### properties ###         
     166     
    111167    def __set_gridType(self, value): 
    112168        if value not in VALID_GRID_TYPES: 
     
    154210     
    155211    outline = property(__get_outline, __set_outline) 
     212 
     213         
     214    def __set_projection(self, value): 
     215        if value not in VALID_PROJECTIONS: 
     216             
     217            raise Exception(\ 
     218             "Invalid value of '%s' for projection property, must be one of %s"  
     219                % (value, VALID_PROJECTIONS,)) 
     220             
     221        self._projection = value 
     222 
     223    def __get_projection(self): 
     224        return self._projection 
     225     
     226    projection = property(__get_projection, __set_projection, None, None) 
     227     
     228         
     229     
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_contour.py

    r5403 r5412  
    1010import thread 
    1111 
    12 import numpy as N 
    13  
    14 from matplotlib.patches import Rectangle 
    15 from matplotlib.figure import Figure 
    16 from matplotlib.backends.backend_agg import FigureCanvasAgg 
    17 from matplotlib.lines import Line2D 
    18  
    19 from geoplot.grid_builder_lat_lon import GridBuilderLatLon 
    20 from geoplot.grid_builder_national import GridBuilderNational 
    21 from geoplot.grid_builder_rotated import GridBuilderRotated 
    22  
    23 from geoplot.map_lat_lon import MapLatLon 
    24  
    2512from geoplot.contour_drawer import ContourDrawer 
    2613import geoplot.utils as geoplot_utils 
    2714 
    28 from matplotlib.collections import LineCollection 
     15from geoplot.layer_drawer import LayerDrawerBase 
    2916 
    3017log = logging.getLogger(__name__) 
    3118 
    32 VALID_GRID_TYPES = ['latlon', 'national', 'rotated'] 
    33  
    34 class LayerDrawerContour(object): 
     19class LayerDrawerContour(LayerDrawerBase): 
    3520    "Draw only the layer section of the plot" 
    3621     
    37     def __init__(self, gridType='latlon', cmap = None,  cmapRange=(None,None)): 
     22    def __init__(self, cdmsVar, gridType='latlon', projection='latlon', cmap = None,  cmapRange=(None,None), 
     23                 transparent=False): 
    3824         
    39         self.gridType = gridType 
     25        self._contourDrawer = ContourDrawer() 
     26         
    4027        self.cmap = cmap 
    4128        self.cmapRange = cmapRange 
     29        self.cdmsVar = cdmsVar 
     30          
     31        LayerDrawerBase.__init__(self, gridType, transparent, projection) 
     32         
     33    def _drawToAxes(self, axes, xLimits, yLimits): 
     34        """ 
     35        Draw the contours onto the axes. 
     36        """ 
     37         
     38        grid = self._buildGrid(self.cdmsVar, xLimits, yLimits) 
     39         
     40        #if the projection is 'latlon' then no transformation is needed. 
     41        if self.projection == 'latlon': 
     42            basemap = None 
     43        else: 
     44            map = self._getMap(xLimits, yLimits) 
     45            basemap = map.basemap         
     46         
     47        self._contourDrawer.draw(axes, grid, cmapRange=self.cmapRange, 
     48                                 basemap=basemap) 
    4249     
    43     def makeImage(self, cdmsVar, xLimits=None, yLimits=None, width=800, height=600, dpi=100, 
    44                   rotatedPoleVar=None, transparent=False): 
     50    ### properties ### 
    4551         
    46         fig = self._drawToFigure(cdmsVar, xLimits, yLimits, width, height, dpi, rotatedPoleVar, 
    47                                  transparent) 
     52    def __set_cmap(self, value): 
     53        self._contourDrawer.cmap = value 
    4854         
    49         im = geoplot_utils.figureToImage(fig) 
     55    def __get_cmap(self): 
     56        return self._contourDrawer.cmap  
     57     
     58    cmap = property(__get_cmap, __set_cmap) 
     59     
     60 
     61    def __set_cmapRange(self, value): 
     62        self._cmapRange = value 
    5063         
    51         return im 
     64    def __get_cmapRange(self): 
     65        return self._cmapRange 
    5266     
    53     def _drawToFigure(self, cdmsVar, xLimits, yLimits, width, height, dpi,  
    54                       rotatedPoleVar, transparent): 
    55           
    56         figsize=(width / dpi, height / dpi) 
     67    cmapRange = property(__get_cmapRange, __set_cmapRange)     
    5768         
    58         frameon = transparent == False 
    59          
    60         fig = Figure(figsize=figsize, dpi=dpi, facecolor='w', frameon=False) 
    61  
    62         axes = fig.add_axes([0.0, 0.0, 1.0, 1.0], xticks=[], yticks=[], frameon=False) 
    63          
    64         builderClass = self._getGridBuilderClass() 
    65          
    66         if rotatedPoleVar == None: 
    67             gridBuilder = builderClass(cdmsVar) 
    68         else: 
    69             gridBuilder = builderClass(cdmsVar, rotatedPoleVar) 
    70  
    71         grid = gridBuilder.buildGrid(xLimits=xLimits, yLimits=yLimits) 
    72          
    73         cd = ContourDrawer(self.cmap) 
    74          
    75         cd.draw(axes, grid, cmapRange=self.cmapRange) 
    76          
    77         #reset the limits after drawing the grid 
    78         if xLimits != None: 
    79             axes.set_xlim(float(xLimits[0]), float(xLimits[1])) 
    80          
    81         if yLimits != None: 
    82             axes.set_ylim(float(yLimits[0]), float(yLimits[1]))         
    83                      
    84         return fig 
    85      
    86     def _getGridBuilderClass(self): 
    87          
    88         if self.gridType == 'latlon': 
    89             return GridBuilderLatLon 
    90         elif self.gridType == 'national': 
    91             return GridBuilderNational 
    92         elif self.gridType == 'rotated': 
    93             return GridBuilderRotated 
    94              
    95     def __set_gridType(self, value): 
    96         if value not in VALID_GRID_TYPES: 
    97              
    98             raise Exception(\ 
    99              "Invalid value of '%s' for LayerDrawer.gridType property, must be one of %s"  
    100                 % (value, VALID_GRID_TYPES,)) 
    101              
    102         self._gridType = value 
    103  
    104     def __get_gridType(self): 
    105         return self._gridType 
    106      
    107     gridType = property(__get_gridType, __set_gridType, None, None) 
    108          
  • qesdi/geoplot/trunk/lib/geoplot/layer_drawer_grid.py

    r5403 r5412  
    2626import geoplot.utils as geoplot_utils 
    2727 
     28from geoplot.layer_drawer import LayerDrawerBase 
     29 
    2830from matplotlib.collections import LineCollection 
    2931 
     
    3234VALID_GRID_TYPES = ['latlon', 'national', 'rotated'] 
    3335 
    34 class LayerDrawerGrid(object): 
     36class LayerDrawerGrid(LayerDrawerBase): 
    3537    "Draw only the layer section of the plot" 
    3638     
    37     def __init__(self, gridType='latlon'): 
     39    def __init__(self, cdmsVar, gridType='latlon', showGridLines=False, cmap=None, cmapRange=(None,None), outline=False, 
     40                 transparent=False): 
    3841         
    39         self.gridType = gridType 
     42        self._gridDrawer = GridDrawer() 
     43         
     44        self.cdmsVar = cdmsVar 
     45        self.cmap = cmap 
     46        self.cmapRange = cmapRange 
     47        self.showGridLines = showGridLines 
     48        self.outline = outline 
     49         
     50        LayerDrawerBase.__init__(self, gridType, transparent) 
     51         
     52    def _drawToAxes(self, axes, xLimits, yLimits): 
     53        """ 
     54        Creates a new grid object and draws it onto the axis. 
     55        """ 
     56        #create a new grid, this grid will be in terms of lat/lon 
     57        grid = self._buildGrid(self.cdmsVar, xLimits, yLimits) 
     58         
     59        # if the projection is latlon then there is no need to transform 
     60        # the data on the grid. 
     61        if self.projection == 'latlon': 
     62            basemap = None 
     63        else: 
     64            map = self._getMap(xLimits, yLimits) 
     65            basemap = map.basemap         
     66         
     67        #draw the grid on the axis 
     68        self._gridDrawer.draw(axes, grid, 
     69                              basemap=basemap,  
     70                              limits=(xLimits, yLimits),  
     71                              cmapRange=self.cmapRange) 
    4072     
    41     def makeImage(self, xLimits=None, yLimits=None, width=800, height=600, dpi=100, 
    42                   resolution=None, transparent=False): 
     73    ### properties ### 
     74                         
     75    def __set_showGridLines(self, value): 
     76        self._gridDrawer.showGridLines = value 
     77     
     78    def __get_showGridLines(self): 
     79        return self._gridDrawer.showGridLines 
     80     
     81    showGridLines = property(__get_showGridLines, __set_showGridLines)  
     82     
     83    def __set_cmap(self, value): 
     84        self._gridDrawer.cmap = value 
    4385         
    44         fig = self._drawToFigure(xLimits, yLimits, width, height, dpi, resolution, transparent) 
     86    def __get_cmap(self): 
     87        return self._gridDrawer.cmap  
     88     
     89    cmap = property(__get_cmap, __set_cmap) 
     90     
     91    def __set_cmapRange(self, value): 
     92        self._cmapRange = value 
    4593         
    46         im = geoplot_utils.figureToImage(fig) 
     94    def __get_cmapRange(self): 
     95        return self._cmapRange 
     96     
     97    cmapRange = property(__get_cmapRange, __set_cmapRange) 
     98     
     99    def __set_outline(self, value): 
     100        self._gridDrawer.outline = value 
    47101         
    48         return im 
     102    def __get_outline(self): 
     103        return self._gridDrawer.outline 
    49104     
    50     def _drawToFigure(self, xLimits, yLimits, width, height, dpi, resolution, transparent): 
    51          
    52         
    53         figsize=(width / dpi, height / dpi) 
    54          
    55         fig = Figure(figsize=figsize, dpi=dpi, facecolor='w', frameon=False) 
    56  
    57         axes = fig.add_axes([0.0, 0.0, 1.0, 1.0], xticks=[], yticks=[], frameon=False) 
    58          
    59 #        width = (xLimits[1] - xLimits[0]) 
    60 #        height = (yLimits[1] - yLimits[0]) 
    61 #        boxLeftEdge = width * 0.25 + xLimits[0] 
    62 #        boxBottomEdge = height * 0.25 + yLimits[0]         
    63 #         
    64 #        xdata = N.array([xLimits[0] + 0.1*width,xLimits[0] + 0.9* width]) 
    65 #        ydata = N.array([yLimits[0] + 0.5* height, yLimits[0] + 0.5* height]) 
    66 #        line = Line2D(xdata,ydata, color='k') 
    67 #        axes.add_line(line) 
    68 #         
    69 #        boxWidth = width * 0.5 
    70 #        boxHeight = height * 0.5 
    71 #                 
    72 #         
    73 #        axes.add_patch(Rectangle((boxLeftEdge, boxBottomEdge), 
    74 #                                  boxWidth, boxHeight, 
    75 #                                edgecolor='k', 
    76 #                                fill=False, 
    77 #                                linewidth=1)) 
    78          
    79          
    80          
    81         #draw the map 
    82                  
    83         map = MapLatLon(xLimits, yLimits, drawCoast=True, drawRivers=False, 
    84                         resolution=resolution)         
    85          
    86         map.drawMap(axes)         
    87          
    88          
    89         midX = width * 0.5 + xLimits[0] 
    90         midY = height * 0.5 + yLimits[0] 
    91 #        lines = [  
    92 #                 [ (xLimits[0],midY), (midX,yLimits[0]), (xLimits[1],midY), 
    93 #                   (midX,yLimits[1]),  (xLimits[0],midY), ], 
    94 ##                 [ (xLimits[0],midY), (xLimits[1],midY) ],                  
    95 ##                 [ (midX,yLimits[0]), (midX, yLimits[1]) ], 
    96 #                ] 
    97 ##         
    98 #        lc = LineCollection(lines) 
    99 #        lc.set_color('k') 
    100 #        lc.set_linewidth(1.) 
    101 #        axes.add_collection(lc)      
    102          
    103 #        lines = [  
    104 #                 [ (xLimits[0] + 0.1*width,yLimits[0] + 0.1*height),  
    105 #                   (xLimits[1] - 0.1*width, yLimits[0]+ 0.1*height),  
    106 #                   (xLimits[1] - 0.1*width, yLimits[1] - 0.1*height), 
    107 #                   (xLimits[0] + 0.1*width, yLimits[1] - 0.1*height), 
    108 #                   (xLimits[0] + 0.1*width,yLimits[0] + 0.1*height), ]  
    109 #                    
    110 ##                 [ (xLimits[0],midY), (xLimits[1],midY) ],                  
    111 ##                 [ (midX,yLimits[0]), (midX, yLimits[1]) ], 
    112 #        ] 
    113 #         
    114 #        lc = LineCollection(lines) 
    115 #        lc.set_color('k') 
    116 #        lc.set_linewidth(1.) 
    117 #        axes.add_collection(lc)                           
    118          
    119         #reset the limits after drawing the grid 
    120         if xLimits != None: 
    121             axes.set_xlim(float(xLimits[0]), float(xLimits[1])) 
    122          
    123         if yLimits != None: 
    124             axes.set_ylim(float(yLimits[0]), float(yLimits[1]))         
    125                      
    126          
    127         return fig 
    128  
    129         
    130  
    131  
    132  
    133         width = (xLimits[1] - xLimits[0]) 
    134         height = (yLimits[1] - yLimits[0]) 
    135         boxLeftEdge = width * 0.25 + xLimits[0] 
    136         boxBottomEdge = height * 0.25 + yLimits[0] 
    137         boxWidth = width * 0.5 
    138         boxHeight = height * 0.5 
    139          
    140          
    141         midX = width * 0.5 + xLimits[0] 
    142         midY = height * 0.5 + yLimits[0] 
    143         lines = [  
    144                  [ (xLimits[0],midY), (midX,yLimits[0]), (xLimits[1],midY), 
    145                    (midX,yLimits[1]),  (xLimits[0],midY), ], 
    146 #                 [ (xLimits[0],midY), (xLimits[1],midY) ],                  
    147 #                 [ (midX,yLimits[0]), (midX, yLimits[1]) ], 
    148                 ] 
    149          
    150         lc = LineCollection(lines) 
    151          
    152         lc.set_color('k') 
    153          
    154         lc.set_linewidth(1.) 
    155         log.debug("lc.get_linewidths() = %s" % (lc.get_linewidths(),)) 
    156                  
    157         log.debug("lc.get_clip_path() = %s" % (lc.get_clip_path(),)) 
    158         axes.add_collection(lc, autolim=False)    
    159          
    160          
    161         axes.add_patch(Rectangle((boxLeftEdge, boxBottomEdge), 
    162                           boxWidth, boxHeight, 
    163                         edgecolor='k', 
    164                         fill=False, 
    165                         linewidth=1)) 
    166          
    167         x= [midX, midX] 
    168         y = [yLimits[0], yLimits[1]] 
    169 #        axes.plot(x,y, color='k') 
    170  
    171         xdata = N.array(x) 
    172         ydata = N.array(y) 
    173          
    174         line = Line2D(xdata,ydata, color='k') 
    175         log.debug("line.get_clip_path() = %s" % (line.get_clip_path(),)) 
    176         axes.add_line(line) 
    177          
    178  
    179          
    180         axes.set_aspect('auto') 
    181          
    182          
    183         log.debug("fig.lines = %s" % (fig.lines,)) 
    184         log.debug("fig.axes = %s" % (fig.axes,)) 
    185         log.debug("axes.lines = %s" % (axes.lines,)) 
    186         log.debug("axes.collections = %s" % (axes.collections,)) 
    187          
    188 #        log.debug("axes.get_xlim() = %s" % (axes.get_xlim(),)) 
    189 #        log.debug("axes.get_ylim() = %s" % (axes.get_ylim(),)) 
    190          
    191         #reset the limits after drawing the grid 
    192         if xLimits != None: 
    193             axes.set_xlim(float(xLimits[0]), float(xLimits[1])) 
    194          
    195         if yLimits != None: 
    196             axes.set_ylim(float(yLimits[0]), float(yLimits[1])) 
    197              
    198         return fig         
    199      
    200      
    201     def _getGridBuilderClass(self): 
    202          
    203         if self.gridType == 'latlon': 
    204             return GridBuilderLatLon 
    205         elif self.gridType == 'national': 
    206             return GridBuilderNational 
    207         elif self.gridType == 'rotated': 
    208             return GridBuilderRotated 
    209              
    210              
    211     def __set_gridType(self, value): 
    212         if value not in VALID_GRID_TYPES: 
    213              
    214             raise Exception(\ 
    215              "Invalid value of '%s' for LayerDrawer.gridType property, must be one of %s"  
    216                 % (value, VALID_GRID_TYPES,)) 
    217              
    218         self._gridType = value 
    219  
    220     def __get_gridType(self): 
    221         return self._gridType 
    222      
    223     gridType = property(__get_gridType, __set_gridType, None, None) 
    224          
     105    outline = property(__get_outline, __set_outline) 
     106  
  • qesdi/geoplot/trunk/lib/geoplot/map_national_grid.py

    r5403 r5412  
    1313from geoplot.mpl_imports import basemap 
    1414from geoplot.map_base import MapBase 
     15from geoplot.filtered_basemap import FilteredBasemap 
    1516 
    1617log = logging.getLogger(__name__) 
    1718log.setLevel(logging.DEBUG) 
     19 
     20BASEMAP_RESOLUTION = 'l' 
    1821 
    1922# National Grid parameters 
    2023trueOrigin = (358.0, 49.0) 
    2124falseOrigin = (-400000, 100000) 
     25 
     26bmxLimits = (-20,20); bmyLimits = (40,70) 
     27 
     28llBasemaps = {} 
     29 
     30def getBasemap(resolution): 
     31     
     32    if resolution not in llBasemaps.keys(): 
     33        addBasemap(resolution) 
     34     
     35    return llBasemaps[resolution] 
     36 
     37def addBasemap(resolution): 
     38     
     39    llBasemaps[resolution] = \ 
     40        FilteredBasemap(projection='tmerc', 
     41                    lon_0=trueOrigin[0], 
     42                    lat_0=trueOrigin[1], 
     43                    llcrnrlon=bmxLimits[0], 
     44                    llcrnrlat=bmyLimits[0], 
     45                    urcrnrlon=bmxLimits[1], 
     46                    urcrnrlat=bmyLimits[1], 
     47                    resolution=resolution, 
     48                    suppress_ticks=False) 
     49         
    2250 
    2351class MapNationalGrid(MapBase): 
     
    2755    and basemap to draw the map. 
    2856    """ 
    29     def __init__(self, xLimits, yLimits, drawCoast=True, drawRivers=True, addShapefile=False): 
     57    def __init__(self, xLimits, yLimits, drawCoast=True, drawRivers=True, addShapefile=False, 
     58                 resolution=None): 
    3059        """ 
    3160        Constructs the map object. 
     
    4372        """ 
    4473 
     74        if resolution == None: 
     75            self.basemap = getBasemap(BASEMAP_RESOLUTION) 
     76        else: 
     77            self.basemap = getBasemap(resolution) 
     78 
    4579        MapBase.__init__(self, xLimits, yLimits, drawCoast, drawRivers, addShapefile) 
    4680 
     
    5185        limits of the map. 
    5286        """ 
     87        pass 
    5388        st = time.time() 
    54         self.basemap = basemap.Basemap(projection='tmerc', 
    55                                        lon_0=trueOrigin[0], 
    56                                        lat_0=trueOrigin[1], 
    57                                        llcrnrlon=self.xLimits[0], 
    58                                        llcrnrlat=self.yLimits[0], 
    59                                        urcrnrlon=self.xLimits[1], 
    60                                        urcrnrlat=self.yLimits[1], 
    61                                        resolution=self._getBasemapResolution(), 
    62                                        suppress_ticks=False) 
    63          
    64         log.debug("created basemap in %.2fs" % (time.time() - st,)) 
     89#        self.basemap = basemap.Basemap(projection='tmerc', 
     90#                                       lon_0=trueOrigin[0], 
     91#                                       lat_0=trueOrigin[1], 
     92#                                       llcrnrlon=self.xLimits[0], 
     93#                                       llcrnrlat=self.yLimits[0], 
     94#                                       urcrnrlon=self.xLimits[1], 
     95#                                       urcrnrlat=self.yLimits[1], 
     96#                                       resolution=self._getBasemapResolution(), 
     97#                                       suppress_ticks=False) 
     98#         
     99#        log.debug("created basemap in %.2fs" % (time.time() - st,)) 
    65100         
    66101    def _configAxes(self, axes): 
  • qesdi/geoplot/trunk/lib/geoplot/tests/drawing/test_draw_grid.py

    r5403 r5412  
    88import os 
    99 
    10 from geoplot.tests.integration.drawing import getDrawingOutputDir 
     10from geoplot.tests.drawing import getDrawingOutputDir 
    1111 
    1212from numpy import meshgrid 
  • qesdi/geoplot/trunk/lib/geoplot/tests/integration/test_output_layer_drawer.py

    r5403 r5412  
    5050    cmap = matplotlib.cm.winter 
    5151    cmapRange = (50,100) 
    52     print dir(cmap) 
    53     ld = LayerDrawer(cmap=cmap, cmapRange=cmapRange) 
     52 
     53    ld = LayerDrawer(v,cmap=cmap, cmapRange=cmapRange) 
    5454    ld.showGridLines = True 
    55     im = ld.makeImage(v, xLimits=(-2,10.5), yLimits=(-1.5,10.0), width=1000, height=1000) 
     55    im = ld.makeImage(xLimits=(-2,10.5), yLimits=(-1.5,10.0), width=1000, height=1000) 
    5656     
    5757    lon = v.getLongitude() 
    5858    lat = v.getLatitude() 
    5959 
    60  
    61     im.save(os.path.join(outputsDir, 'layerImageTest.png')) 
    62      
     60    filepath = os.path.join(outputsDir, 'layerImageTest.png')  
     61    im.save(filepath) 
     62    print "wrote %s" % (filepath,) 
  • qesdi/geoplot/trunk/lib/geoplot/tests/make_data_functions.py

    r5403 r5412  
    22import numpy as N 
    33 
    4 def fnSinXAddCosY(shape): 
     4def fnSinXAddCosY(shape, xMax=5.0, yMax=7.0): 
    55     
    66    data = N.zeros(shape, dtype=float) 
    7      
    8     xMax = 5.0 
    9     yMax = 7.0 
    107     
    118    xvals = N.linspace(0, xMax, shape[0]) 
     
    2118             
    2219    return data 
     20 
     21def fnSinXsqAddCosYsq(shape, xMax=5.0, yMax=7.0): 
     22     
     23    data = N.zeros(shape, dtype=float) 
     24     
     25    xvals = N.linspace(0, xMax, shape[0]) 
     26    yvals = N.linspace(0, yMax, shape[1]) 
     27 
     28    for i in range(shape[0]): 
     29        for j in range(shape[1]): 
     30             
     31            x = xvals[i] 
     32            y = yvals[j] 
     33             
     34            data[i,j] =  sin(x*x) + cos(y*y) 
     35             
     36    return data 
  • qesdi/geoplot/trunk/lib/geoplot/utils.py

    r5403 r5412  
    6666     
    6767    size = canvas.get_width_height() 
     68 
    6869    buffer = canvas.buffer_rgba(0,0) 
    6970     
  • qesdi/geoplot/trunk/outputs

    • Property svn:ignore set to
      *
Note: See TracChangeset for help on using the changeset viewer.