Beispiel #1
0
    def __init__(self,lon=None,lat=None,xlint=None,ylint=None,nocoast=False,
                 grid=False,**keys):
        if lon != None:
            slon = keys.setdefault('llcrnrlon', lon[0])
            elon = keys.setdefault('urcrnrlon', lon[1])
        else:
            slon = keys.setdefault('llcrnrlon', 0.)
            elon = keys.setdefault('urcrnrlon', 360.)
        if lat != None:
            slat = keys.setdefault('llcrnrlat', lat[0])
            elat = keys.setdefault('urcrnrlat', lat[1])                        
        else:
            slat = -90.
            elat = 90.            
        projection = keys.setdefault('projection','cyl')
        label = keys.pop('label', True)
        # 地図に合わせたデフォルト値
        if projection == 'npstere':
            boundinglat = keys.setdefault('boundinglat',max(slat, 0.))
            keys.setdefault('lon_0',0.5*(slon+elon))
            keys.setdefault('suppress_ticks',True)
            keys.setdefault('round',True)
        elif projection == 'spstere':
            keys.setdefault('boundinglat',min(elat, 0.))
            keys.setdefault('lon_0',0.5*(slon+elon))
            keys.setdefault('suppress_ticks',True)
            keys.setdefault('round',True)
        elif projection == 'lcc':
            keys.setdefault('lon_0',0.5*(slon+elon))
#            keys.setdefault('lat_0',0.5*(slat+elat))
            keys.setdefault('suppress_ticks',True)
        if not grid: keys.setdefault('suppress_ticks',False)

        # draw map
        Basemap.__init__(self,**keys)
        self.drawmapboundary()
        if not nocoast: self.drawcoastlines(linewidth=0.5)
        ax = self.ax or self._check_ax()
        if projection == 'npstere' or projection == 'lcc' or grid:
            if xlint is None: xlint=60
            if ylint is None: ylint=20
            if label:
                self.drawmeridians(np.arange(0,360,xlint),labels=[1,1,1,1],linewidth=0.5)
                self.drawparallels(np.arange(0,90.1,ylint),labels=[1,0,0,0],linewidth=0.5)
            else:
                self.drawmeridians(np.arange(0,360,xlint),labels=[0,0,0,0],linewidth=0.5)
                self.drawparallels(np.arange(0,90.1,ylint),labels=[0,0,0,0],linewidth=0.5)
        else:
            if label:
                ax.xaxis.set_major_formatter(ticker.BasemapXaxisFormatter(self))   
                ax.yaxis.set_major_formatter(ticker.BasemapYaxisFormatter(self))
            else:
                ax.xaxis.set_major_formatter(matplotlib.ticker.NullFormatter())
                ax.yaxis.set_major_formatter(matplotlib.ticker.NullFormatter())                   
            if xlint != None:
                self.set_xlint(xlint)
            if ylint != None:
                self.set_ylint(ylint)
            ax.tick_params(direction='out', top='off', right='off')
Beispiel #2
0
 def __init__(self, region, **kwargs):
     """Init basemap instance using data from config files"""
     self.basedir = os.path.dirname(os.path.abspath(__file__))
     self.region = region
     self.inkwargs = kwargs
     self.read_configfile()
     for key in ['llcrnrlon', 'urcrnrlon']:
         self.base_kwargs[key] = self.base_kwargs[key] + self.merid_offset
     for k, v in six.iteritems(self.inkwargs):
         self.__dict__[k] = v
     Basemap.__init__(self, **self.base_kwargs)
Beispiel #3
0
 def __init__(self, region, **kwargs):
     """Init basemap instance using data from config files"""
     self.basedir =  os.path.dirname(os.path.abspath(__file__))
     self.region = region
     self.inkwargs = kwargs
     self.read_configfile()
     for key in ['llcrnrlon', 'urcrnrlon']:
         self.base_kwargs[key] =  self.base_kwargs[key] + self.merid_offset
     for key,val in six.iteritems(self.inkwargs):
         setattr(self, key, val)
     Basemap.__init__(self, **self.base_kwargs)
Beispiel #4
0
  def __init__(self,pole,resolution='c',boundinglat=0,lon_0=0,**kargs):

    if pole=='north': prj='npstere'
    else: prj='spstere'

    Basemap.__init__(self,resolution=resolution,
                     boundinglat=boundinglat,
                     lon_0=lon_0,projection=prj,
                     **kargs)

    self._tasks_done=False
Beispiel #5
0
    def __init__(self, pole, resolution='c', boundinglat=0, lon_0=0, **kargs):

        if pole == 'north': prj = 'npstere'
        else: prj = 'spstere'

        Basemap.__init__(self,
                         resolution=resolution,
                         boundinglat=boundinglat,
                         lon_0=lon_0,
                         projection=prj,
                         **kargs)

        self._tasks_done = False
Beispiel #6
0
    def __init__(
        self,
        projection="hammer",
        lat_0=0.0,
        lon_0=0.0,
        suppress_ticks=True,
        boundinglat=None,
        fix_aspect=True,
        anchor=str("C"),
        ax=None,
    ):

        if projection != "hammer" and projection != "moll":
            raise ValueError("Only hammer and moll projections supported!")

        # Use Basemap's init, enforcing the values of many parameters that
        # aren't used or whose Basemap defaults would not be altered for all-sky
        # celestial maps.
        Basemap.__init__(
            self,
            llcrnrlon=None,
            llcrnrlat=None,
            urcrnrlon=None,
            urcrnrlat=None,
            llcrnrx=None,
            llcrnry=None,
            urcrnrx=None,
            urcrnry=None,
            width=None,
            height=None,
            projection=projection,
            resolution=None,
            area_thresh=None,
            rsphere=1.0,
            lat_ts=None,
            lat_1=None,
            lat_2=None,
            lat_0=lat_0,
            lon_0=lon_0,
            suppress_ticks=suppress_ticks,
            satellite_height=1.0,
            boundinglat=None,
            fix_aspect=True,
            anchor=anchor,
            celestial=True,
            ax=ax,
        )

        # Keep a local ref to lon_0 for hemisphere checking.
        self._lon_0 = self.projparams["lon_0"]
        self._limb = None
Beispiel #7
0
    def __init__(self,
                 projection='hammer',
                 lat_0=0.,
                 lon_0=0.,
                 suppress_ticks=True,
                 boundinglat=None,
                 fix_aspect=True,
                 anchor=str('C'),
                 ax=None):

        if projection != 'hammer' and projection != 'moll':
            raise ValueError('Only hammer and moll projections supported!')

        # Use Basemap's init, enforcing the values of many parameters that
        # aren't used or whose Basemap defaults would not be altered for all-sky
        # celestial maps.
        Basemap.__init__(self,
                         llcrnrlon=None,
                         llcrnrlat=None,
                         urcrnrlon=None,
                         urcrnrlat=None,
                         llcrnrx=None,
                         llcrnry=None,
                         urcrnrx=None,
                         urcrnry=None,
                         width=None,
                         height=None,
                         projection=projection,
                         resolution=None,
                         area_thresh=None,
                         rsphere=1.,
                         lat_ts=None,
                         lat_1=None,
                         lat_2=None,
                         lat_0=lat_0,
                         lon_0=lon_0,
                         suppress_ticks=suppress_ticks,
                         satellite_height=1.,
                         boundinglat=None,
                         fix_aspect=True,
                         anchor=anchor,
                         celestial=True,
                         ax=ax)

        # Keep a local ref to lon_0 for hemisphere checking.
        self._lon_0 = self.projparams['lon_0']
        self._limb = None
Beispiel #8
0
    def __init__(self, 
                       projection='hammer',
                       lat_0=0., lon_0=0.,
                       llcrnrx=None, llcrnry=None,
                       urcrnrx=None, urcrnry=None,
                       suppress_ticks=True,
                       boundinglat=None,
                       fix_aspect=True,
                       anchor='C',
                       ax=None):

        #if projection != 'hammer' and projection !='moll':
        #   raise ValueError('Only hammer and moll projections supported!')

        # Use Basemap's init, enforcing the values of many parameters that
        # aren't used or whose Basemap defaults would not be altered for all-sky
        # celestial maps.
        Basemap.__init__(self, llcrnrlon=None, llcrnrlat=None,
                       urcrnrlon=None, urcrnrlat=None,
                       llcrnrx=llcrnrx, llcrnry=llcrnry,
                       urcrnrx=urcrnrx, urcrnry=urcrnry,
                       width=None, height=None,
                       projection=projection, resolution=None,
                       area_thresh=None, rsphere=1.,
                       lat_ts=None,
                       lat_1=None, lat_2=None,
                       lat_0=lat_0, lon_0=lon_0,
                       suppress_ticks=suppress_ticks,
                       satellite_height=1.,
                       boundinglat=None,
                       fix_aspect=True,
                       anchor=anchor,
                       celestial=True,
                       ax=ax)

        # Keep a local ref to lon_0 for hemisphere checking.
        self._lon_0 = self.projparams['lon_0']
        self._limb = None
Beispiel #9
0
    def __init__(self, domain, **kwargs):
        """ Set attributes
        Get proj4 from the given domain and convert the proj4 projection to
        the basemap projection.

        Parameters
        -----------
        domain : domain object
        kwargs : dictionary
            parameters that are used for all operations.

        Modifies
        ---------
        self.fig : figure
            matplotlib.pyplot.figure
        self.colorbar : boolean
            if colorbar is True, it is possible to put colorbar.
            e.g. contour_plots(contour_style='fill'), put_color()
        self.mpl : list
            elements are matplotlib.contour.QuadContourSet instance,
                         matplotlib.quiver.Quiver instance or
                         matplotlib.collections.QuadMesh object

        See also
        ----------
        http://matplotlib.org/basemap/api/basemap_api.html

        """
        self.domain = domain

        # get proj4
        proj4 = NSR(domain.vrt.get_projection()).ExportToProj4()

        # convert proj4 to basemap projection
        projStr = proj4.split(' ')[0][6:]
        projection = {
            'aea': 'aea',
            'ocea': 'aea',
            'aeqd': 'aeqd',
            'xxx1': 'spaeqd',
            'xxx2': 'npaeqd',
            'cass': 'cass',
            'cea': 'cea',
            'eqc': 'cyl',
            'longlat': 'cyl',
            'eck4': 'eck4',
            'eqdc': 'eqdc',
            'gall': 'gall',
            'geos': 'geos',
            'gnom': 'gnom',
            'hammer': 'hammer',
            'nell_h': 'hammer',
            'kav7': 'kav7',
            'laea': 'laea',
            'xxx3': 'splaea',
            'xxx4': 'nplaea',
            'lcc': 'lcc',
            'lcca': 'lcc',
            'mbtfpq': 'mbtfpq',
            'somerc': 'merc',
            'merc': 'merc',
            'mill': 'mill',
            'moll': 'moll',
            'nsper': 'nsper',
            'omerc': 'omerc',
            'ortho': 'ortho',
            'poly': 'poly',
            'rpoly': 'poly',
            'imw_p': 'poly',
            'robin': 'robin',
            'sinu': 'sinu',
            'fouc_s': 'sinu',
            'gn_sinu': 'sinu',
            'mbtfps': 'sinu',
            'urmfps': 'sinu',
            'stere': 'stere',
            'sterea': 'stere',
            'lee_os': 'stere',
            'mil_os': 'stere',
            'rouss': 'stere',
            'ups': 'npstere',
            'tmerc': 'tmerc',
            'gstmerc': 'tmerc',
            'utm': 'tmerc',
            'vandg': 'vandg',
            'vandg2': 'vandg',
            'vandg3': 'vandg',
            'vandg4': 'vandg',
        }.get(projStr, 'cyl')

        if projection in ['stere']:
            lon_0 = float(
                re.findall('lon_0=+[-+]?\d*[.\d*]*', proj4)[0].split('=')[1])
            lat_0 = float(
                re.findall('lat_0=+[-+]?\d*[.\d*]*', proj4)[0].split('=')[1])
            kwargs['lon_0'] = lon_0
            kwargs['lat_0'] = lat_0

        if projStr == 'utm':
            kwargs['lon_0'] = -180 + NSR(proj4).GetUTMZone() * 6 - 3
            kwargs['lat_0'] = 0

        self.extensionList = [
            'png', 'emf', 'eps', 'pdf', 'rgba', 'ps', 'raw', 'svg', 'svgz'
        ]

        # set llcrnrlat, urcrnrlat, llcrnrlon and urcrnrlon to kwargs.
        # if required, modify them from -90. to 90.
        # get min/max lon/lat
        lonCrn, latCrn = domain.get_corners()
        self.lonMin = min(lonCrn)
        self.lonMax = max(lonCrn)
        self.latMin = max(min(latCrn), -90.)
        self.latMax = min(max(latCrn), 90.)

        if not ('llcrnrlat' in kwargs.keys()):
            kwargs['llcrnrlat'] = latCrn[1]
        if not ('urcrnrlat' in kwargs.keys()):
            kwargs['urcrnrlat'] = latCrn[2]
        if not ('llcrnrlon' in kwargs.keys()):
            kwargs['llcrnrlon'] = lonCrn[1]
        if not ('urcrnrlon' in kwargs.keys()):
            kwargs['urcrnrlon'] = lonCrn[2]

        # separate kwarge of plt.figure() from kwargs
        figArgs = [
            'num', 'figsize', 'dpi', 'facecolor', 'edgecolor', 'frameon'
        ]
        figKwargs = {}
        for iArg in figArgs:
            if iArg in kwargs.keys():
                figKwargs[iArg] = kwargs.pop(iArg)

        Basemap.__init__(self, projection=projection, **kwargs)

        # create figure and set it as an attribute
        plt.close()
        self.fig = plt.figure(**figKwargs)
 def __init__(self, *args, **kwargs):
     Basemap.__init__(self, *args, **kwargs)
     self.lon_split = 180.
     self.epsilon = 1.0e-10
Beispiel #11
0
    def __init__(self, basemap_kwargs, shp_file, shp_key, figsize=(22, 12)):
        """
        Initialization:
        Preps for plotting. Does the heavy lifting of finding polygon areas and centroids.

        Parameters:
        Positional:
            basemap_kwargs (dict): kwargs to pass into Basemap.
            shp_file (string): path to a shp_file without the ".shp" extension in the string.
            shp_key (string): the attribute in the shape file which contains the indices used in the data.
        Optional:
            drawbounds (bool): passed into Basemap.readshapefile method. draws borders on map.
            figsize (tuple): matplotlib figure size.
        """
        Basemap.__init__(self, **basemap_kwargs)

        self.fig = plt.figure(figsize=figsize)
        self.ax = self.fig.add_axes([0.1, 0.1, .95, 0.95], frame_on=False)

        # shp file
        self.readshapefile(shp_file, 'area', drawbounds=True, zorder=1)  # read shapefile

        self.area_names = [areas[shp_key] for areas in self.area_info]  # congregate names into list

        # define default name, shape coordinates tuple
        self.indexer = {}  # holds index value for first name of each area in self.shapes
        self.shapes = list(zip(self.area_names, self.area)
                           )  # original coordinates
        self.corr_shapes = []  # corrected coordinates which hold any modifications to shapes
        self.centroids = {}  # original centroids
        self.corr_centroids = {}  # corrected centroids
        for i, (name_glob, shape) in enumerate(self.shapes):
            self.corr_shapes.append((name_glob, shape))

            # when end of index is reached, "j - 1" is caught
            try:
                if (self.area_names[i] != self.area_names[i - 1]):
                    # start index to search for shapes (to find areas)
                    start = i
                    self.indexer.update({name_glob: start})

                # only conduct linear search once for each state
                if (self.area_names[i] != self.area_names[i + 1]):
                    end = i + 1  # end index

                    shapes = [shapes for name, shapes in self.corr_shapes[start:end]]

                    poly_centroid = self.__set_centroids(shapes)

                    # record name and centroid
                    self.centroids.update({name_glob: poly_centroid})
                    self.corr_centroids.update({name_glob: poly_centroid})

            except IndexError:
                pass

        self.x_lims = self.ax.get_xlim()
        self.y_lims = self.ax.get_ylim()

        ###
        # dictionary which holds annotations created in set_pie_offset method
        self.annotations = {}
Beispiel #12
0
    def __init__(self,
                 lon=None,
                 lat=None,
                 xlint=None,
                 ylint=None,
                 nocoast=False,
                 grid=False,
                 **keys):
        if lon != None:
            slon = keys.setdefault('llcrnrlon', lon[0])
            elon = keys.setdefault('urcrnrlon', lon[1])
        else:
            slon = keys.setdefault('llcrnrlon', 0.)
            elon = keys.setdefault('urcrnrlon', 360.)
        if lat != None:
            slat = keys.setdefault('llcrnrlat', lat[0])
            elat = keys.setdefault('urcrnrlat', lat[1])
        else:
            slat = -90.
            elat = 90.
        projection = keys.setdefault('projection', 'cyl')
        label = keys.pop('label', True)
        # 地図に合わせたデフォルト値
        if projection == 'npstere':
            boundinglat = keys.setdefault('boundinglat', max(slat, 0.))
            keys.setdefault('lon_0', 0.5 * (slon + elon))
            keys.setdefault('suppress_ticks', True)
            keys.setdefault('round', True)
        elif projection == 'spstere':
            keys.setdefault('boundinglat', min(elat, 0.))
            keys.setdefault('lon_0', 0.5 * (slon + elon))
            keys.setdefault('suppress_ticks', True)
            keys.setdefault('round', True)
        elif projection == 'lcc':
            keys.setdefault('lon_0', 0.5 * (slon + elon))
            #            keys.setdefault('lat_0',0.5*(slat+elat))
            keys.setdefault('suppress_ticks', True)
        if not grid: keys.setdefault('suppress_ticks', False)

        # draw map
        Basemap.__init__(self, **keys)
        self.drawmapboundary()
        if not nocoast: self.drawcoastlines(linewidth=0.5)
        ax = self.ax or self._check_ax()
        if projection == 'npstere' or projection == 'lcc' or grid:
            if xlint is None: xlint = 60
            if ylint is None: ylint = 20
            if label:
                self.drawmeridians(np.arange(0, 360, xlint),
                                   labels=[1, 1, 1, 1],
                                   linewidth=0.5)
                self.drawparallels(np.arange(0, 90.1, ylint),
                                   labels=[1, 0, 0, 0],
                                   linewidth=0.5)
            else:
                self.drawmeridians(np.arange(0, 360, xlint),
                                   labels=[0, 0, 0, 0],
                                   linewidth=0.5)
                self.drawparallels(np.arange(0, 90.1, ylint),
                                   labels=[0, 0, 0, 0],
                                   linewidth=0.5)
        else:
            if label:
                ax.xaxis.set_major_formatter(
                    ticker.BasemapXaxisFormatter(self))
                ax.yaxis.set_major_formatter(
                    ticker.BasemapYaxisFormatter(self))
            else:
                ax.xaxis.set_major_formatter(matplotlib.ticker.NullFormatter())
                ax.yaxis.set_major_formatter(matplotlib.ticker.NullFormatter())
            if xlint != None:
                self.set_xlint(xlint)
            if ylint != None:
                self.set_ylint(ylint)
            ax.tick_params(direction='out', top='off', right='off')
Beispiel #13
0
    def __init__(self, *args, **kwargs):
        #                 resolution='i',
        #                 xoffset=.05,
        #                 yoffset=.05,
        #                 length=50.,
        #                 scale_lon=None,
        #                 scale_lat=None,
        #                 s=25,
        #                 c='k',
        #                 limit=None,cp -rf /home/du2_dev/dev/OCTANT/incl/*
        #                 edgecolor='none'):

        #Startup sequence
        #################

        c = kwargs.pop('c', 'k')
        s = kwargs.pop('s', 25)
        edgecolor = kwargs.pop('edgecolor', 'none')
        limit = kwargs.pop('limit', None)
        resolution = kwargs.pop('resolution', 'i')
        projection = kwargs.pop('projection', 'merc')
        xoffset = kwargs.pop('xoffset', 0.05)
        yoffset = kwargs.pop('yoffset', 0.05)
        length = kwargs.pop('length', 50.)
        scale_lon = kwargs.pop('scale_lon', None)
        scale_lat = kwargs.pop('scale_lat', None)

        lon = []
        lat = []
        z = []
        if len(args) >= 2:
            lon = args[0]
            lat = args[1]
        if len(args) == 3:
            z = args[2]
        if np.size(lon) == 1: c = 'o' + c

        #Force fields
        lon = np.array(lon)
        lat = np.array(lat)

        #Load default values (requested by Basemap.__init__()
        if limit is None:
            limit = np.array([
                lat.min() - 0.5,
                lon.min() - 0.5,
                lat.max() + 0.5,
                lon.max() + 0.5
            ])
        else:
            limit = np.array(limit)

        clon = limit[[1, 3]].mean()
        clat = limit[[0, 2]].mean()

        #Init sequence
        ##############

        # Init Basemap class
        Basemap.__init__(self,
                         projection=projection,
                         resolution=resolution,
                         llcrnrlat=limit[0],
                         llcrnrlon=limit[1],
                         urcrnrlat=limit[2],
                         urcrnrlon=limit[3],
                         lat_0=clat,
                         lon_0=clon)

        #Set map characteristics fields
        self.limit = limit
        self.clon = clon
        self.clat = clat
        self.mcenter = self(self.clon, self.clat)  #central position
        cparallel = np.array(
            self(self.limit[[1, 3]],
                 [self.clat, self.clat
                  ]))  #Get central paralell and meridian coordinates
        cmeridian = np.array(self(self.limit[[0, 2]], [self.clon, self.clon]))
        self.mllcorner = self(self.limit[1], self.limit[0])
        self.width = np.sqrt(
            np.diff(cparallel[:, 0])**2 + np.diff(cparallel[:, 1]))
        self.heigth = np.sqrt(
            np.diff(cmeridian[:, 0])**2 + np.diff(cmeridian[:, 1]))
        self.mxoffset = xoffset * self.width
        self.myoffset = yoffset * self.heigth

        if scale_lon is None:
            self.scale_lon = 0.9 * self.width + self.mllcorner[0]
            self.scale_lat = 0.1 * self.heigth + self.mllcorner[1]
        else:
            self.scale_lon = self(scale_lon, self.clat)
            self.scale_lat = self(self.clon, scale_lat)

        #Set plot characterisitics fields
        self.resolution = resolution
        self.length = length

        #Draw map
        if np.size(z) > 1:
            self.scatter(lon, lat, z, s=s, edgecolor=edgecolor, **kwargs)
        elif np.size(z) == 1:
            if z != 0:
                self.plot(lon, lat, z, s=s, edgecolor=edgecolor, **kwargs)
            else:
                if lon != 0: self.plot(lon, lat, c, s=s, **kwargs)
        elif np.size(z) == 0:
            if lon != 0: self.plot(lon, lat, c, s=s, **kwargs)

        self.setup_map(**kwargs)
Beispiel #14
0
    def __init__(self, domain, **kwargs):
        ''' Set attributes
        Get proj4 from the given domain and convert the proj4 projection to
        the basemap projection.

        Parameters
        -----------
        domain : domain object
        kwargs : dictionary
            parameters that are used for all operations.

        Modifies
        ---------
        self.fig : figure
            matplotlib.pyplot.figure
        self.colorbar : boolean
            if colorbar is True, it is possible to put colorbar.
            e.g. contour_plots(contour_style='fill'), put_color()
        self.mpl : list
            elements are matplotlib.contour.QuadContourSet instance,
                         matplotlib.quiver.Quiver instance or
                         matplotlib.collections.QuadMesh object

        See also
        ----------
        http://matplotlib.org/basemap/api/basemap_api.html

        '''
        self.domain = domain

        # get proj4
        proj4 = NSR(domain.vrt.get_projection()).ExportToProj4()

        # convert proj4 to basemap projection
        projStr = proj4.split(' ')[0][6:]
        projection = {'aea': 'aea', 'ocea': 'aea',
                      'aeqd': 'aeqd', 'xxx1': 'spaeqd', 'xxx2': 'npaeqd',
                      'cass': 'cass',
                      'cea': 'cea',
                      'eqc': 'cyl', 'longlat': 'cyl',
                      'eck4': 'eck4',
                      'eqdc': 'eqdc',
                      'gall': 'gall',
                      'geos': 'geos',
                      'gnom': 'gnom',
                      'hammer': 'hammer', 'nell_h': 'hammer',
                      'kav7': 'kav7',
                      'laea': 'laea', 'xxx3': 'splaea', 'xxx4': 'nplaea',
                      'lcc': 'lcc', 'lcca': 'lcc',
                      'mbtfpq': 'mbtfpq',
                      'somerc': 'merc', 'merc': 'merc', 'omerc': 'merc',
                      'mill': 'mill',
                      'moll': 'moll',
                      'nsper': 'nsper',
                      'omerc': 'omerc',
                      'ortho': 'ortho',
                      'poly': 'poly', 'rpoly': 'poly', 'imw_p': 'poly',
                      'robin': 'robin',
                      'sinu': 'sinu', 'fouc_s': 'sinu', 'gn_sinu': 'sinu',
                      'mbtfps': 'sinu', 'urmfps': 'sinu',
                      'stere': 'stere', 'sterea': 'stere', 'lee_os': 'stere',
                      'mil_os': 'stere', 'rouss': 'stere',
                      'ups': 'npstere', 'ups': 'spstere',  # CHECK!!
                      'tmerc': 'tmerc', 'gstmerc': 'tmerc', 'utm': 'tmerc',
                      'vandg': 'vandg', 'vandg2': 'vandg',
                      'vandg3': 'vandg', 'vandg4': 'vandg',
                      }.get(projStr, 'cyl')

        if projection in ['stere']:
            lon_0 = float(re.findall('lon_0=+[-+]?\d*[.\d*]*',
                                     proj4)[0].split('=')[1])
            lat_0 = float(re.findall('lat_0=+[-+]?\d*[.\d*]*',
                                     proj4)[0].split('=')[1])
            kwargs['lon_0'] = lon_0
            kwargs['lat_0'] = lat_0

        if projStr == 'utm':
            kwargs['lon_0'] = -180 + NSR(proj4).GetUTMZone()*6 - 3
            kwargs['lat_0'] = 0

        self.extensionList = ['png', 'emf', 'eps', 'pdf', 'rgba',
                              'ps', 'raw', 'svg', 'svgz']

        # set llcrnrlat, urcrnrlat, llcrnrlon and urcrnrlon to kwargs.
        # if required, modify them from -90. to 90.
        # get min/max lon/lat
        lonCrn, latCrn = domain.get_corners()
        self.lonMin = min(lonCrn)
        self.lonMax = max(lonCrn)
        self.latMin = max(min(latCrn), -90.)
        self.latMax = min(max(latCrn), 90.)

        if not('llcrnrlat' in kwargs.keys()):
            kwargs['llcrnrlat'] = latCrn[1]
        if not('urcrnrlat' in kwargs.keys()):
            kwargs['urcrnrlat'] = latCrn[2]
        if not('llcrnrlon' in kwargs.keys()):
            kwargs['llcrnrlon'] = lonCrn[1]
        if not('urcrnrlon' in kwargs.keys()):
            kwargs['urcrnrlon'] = lonCrn[2]

        # separate kwarge of plt.figure() from kwargs
        figArgs = ['num', 'figsize', 'dpi', 'facecolor', 'edgecolor',
                   'frameon']
        figKwargs = {}
        for iArg in figArgs:
            if iArg in kwargs.keys():
                figKwargs[iArg] = kwargs.pop(iArg)

        Basemap.__init__(self, projection=projection, **kwargs)

        # create figure and set it as an attribute
        plt.close()
        self.fig = plt.figure(**figKwargs)