def make_map_base(projection="Robinson",
proj_args={},
coastlines='k',
land='#964B00',
ocean='#006994',
statelines=None,
natborders='gray',
lakelines=None,
lakes='#006994',
**kwargs):
"""Plot gridded data on map.
Optionally add pointdata sequence of (lon,lat,data)."""
cl = proj_args.get('central_longitude', 180)
extent = proj_args.get('extent', None)
if projection.lower() in ['mollweide']:
proj = ccrs.Mollweide(central_longitude=cl)
elif projection.lower() in ['platecarree', 'flat']:
proj = ccrs.PlateCarree(central_longitude=cl)
elif projection.lower() in ['eckertiv']:
proj = ccrs.EckertIV(central_longitude=cl)
elif projection.lower() in ['robinson']:
proj = ccrs.Robinson(central_longitude=cl)
else:
print("IMPLEMENT PROJECTION!")
figsize = kwargs.get('figsize', (12, 8))
fig = plt.figure(figsize=figsize)
ax = plt.axes(projection=proj) # ccrs.PlateCarree())
if coastlines is not None:
ax.coastlines(color=coastlines)
# ax.gridlines()
if statelines is not None:
ax.add_feature(
cfeature.NaturalEarthFeature('cultural',
'admin_1_states_provinces_lines',
'50m',
edgecolor=statelines,
facecolor='none',
linestyle='-'))
if natborders is not None:
ax.add_feature(cfeature.BORDERS, color=natborders)
if (lakelines is not None) or (lakes is not None):
ax.add_feature(cfeature.LAKES, edgecolor=lakelines, facecolor=lakes)
if land is not None:
# np.array( [0.9375, 0.9375, 0.859375]))
ax.add_feature(cfeature.LAND, color=land)
if ocean is not None:
ax.add_feature(cfeature.OCEAN, color=ocean)
ftitle = kwargs.get('title', '')
ax.set_title(ftitle, fontsize=15)
if extent is not None:
ax.set_extent(extent)
ratio = abs((extent[0] - extent[1]) / (extent[2] - extent[3]))
else:
ratio = 1.0
return ax
def test_multiple_projections():
projections = [
ccrs.PlateCarree(),
ccrs.Robinson(),
ccrs.RotatedPole(pole_latitude=45, pole_longitude=180),
ccrs.OSGB(approx=True),
ccrs.TransverseMercator(approx=True),
ccrs.Mercator(globe=ccrs.Globe(semimajor_axis=math.degrees(1)),
min_latitude=-85.,
max_latitude=85.),
ccrs.LambertCylindrical(),
ccrs.Miller(),
ccrs.Gnomonic(),
ccrs.Stereographic(),
ccrs.NorthPolarStereo(),
ccrs.SouthPolarStereo(),
ccrs.Orthographic(),
ccrs.Mollweide(),
ccrs.InterruptedGoodeHomolosine(emphasis='land'),
ccrs.EckertI(),
ccrs.EckertII(),
ccrs.EckertIII(),
ccrs.EckertIV(),
ccrs.EckertV(),
ccrs.EckertVI(),
]
rows = np.ceil(len(projections) / 5).astype(int)
fig = plt.figure(figsize=(10, 2 * rows))
for i, prj in enumerate(projections, 1):
ax = fig.add_subplot(rows, 5, i, projection=prj)
ax.set_global()
ax.coastlines(resolution="110m")
plt.plot(-0.08, 51.53, 'o', transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='red',
transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='blue',
transform=ccrs.Geodetic())
def get_map_projection(
proj_name,
central_longitude=0.0,
central_latitude=0.0,
false_easting=0.0,
false_northing=0.0,
globe=None,
standard_parallels=(20.0, 50.0),
scale_factor=None,
min_latitude=-80.0,
max_latitude=84.0,
true_scale_latitude=None,
latitude_true_scale=None, ### BOTH
secant_latitudes=None,
pole_longitude=0.0,
pole_latitude=90.0,
central_rotated_longitude=0.0,
sweep_axis='y',
satellite_height=35785831,
cutoff=-30,
approx=None,
southern_hemisphere=False,
zone=15): #### numeric UTM zone
proj_name = proj_name.lower()
if (proj_name == 'albersequalarea'):
proj = ccrs.AlbersEqualArea(central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
standard_parallels=standard_parallels)
elif (proj_name == 'azimuthalequidistant'):
proj = ccrs.AzimuthalEquidistant(central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'equidistantconic'):
proj = ccrs.EquidistantConic(central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
standard_parallels=standard_parallels)
elif (proj_name == 'lambertconformal'):
proj = ccrs.LambertConformal(
central_longitude=-96.0, ##########
central_latitude=39.0, ##########
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
secant_latitudes=None,
standard_parallels=None, ## default: (33,45)
cutoff=cutoff)
elif (proj_name == 'lambertcylindrical'):
proj = ccrs.LambertCylindrical(central_longitude=central_longitude)
elif (proj_name == 'mercator'):
proj = ccrs.Mercator(central_longitude=central_longitude,
min_latitude=min_latitude,
max_latitude=max_latitude,
latitude_true_scale=latitude_true_scale,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
scale_factor=None) #########
elif (proj_name == 'miller'):
proj = ccrs.Miller(central_longitude=central_longitude, globe=globe)
elif (proj_name == 'mollweide'):
proj = ccrs.Mollweide(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'orthographic'):
proj = ccrs.Orthographic(central_longitude=central_longitude,
central_latitude=central_latitude,
globe=globe)
elif (proj_name == 'robinson'):
proj = ccrs.Robinson(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'sinusoidal'):
proj = ccrs.Sinusoidal(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'stereographic'):
proj = ccrs.Stereographic(central_latitude=central_latitude,
central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
true_scale_latitude=true_scale_latitude,
scale_factor=scale_factor)
elif (proj_name == 'transversemercator'):
proj = ccrs.TransverseMercator(
central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
scale_factor=1.0, ##########
approx=approx)
elif (proj_name == 'utm'):
proj = ccrs.UTM(zone,
southern_hemisphere=southern_hemisphere,
globe=globe)
elif (proj_name == 'interruptedgoodehomolosine'):
proj = ccrs.InterruptedGoodeHomolosine(
central_longitude=central_longitude, globe=globe)
elif (proj_name == 'rotatedpole'):
proj = ccrs.RotatedPole(
pole_longitude=pole_longitude,
pole_latitude=pole_latitude,
globe=globe,
central_rotated_longitude=central_rotated_longitude)
elif (proj_name == 'osgb'):
proj = ccrs.OSGB(approx=approx)
elif (proj_name == 'europp'):
proj = ccrs.EuroPP
elif (proj_name == 'geostationary'):
proj = ccrs.Geostationary(central_longitude=central_longitude,
satellite_height=satellite_height,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
sweep_axis=sweep_axis)
elif (proj_name == 'nearsideperspective'):
proj = ccrs.NearsidePerspective(central_longitude=central_longitude,
central_latitude=central_latitude,
satellite_height=satellite_height,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckerti'):
proj = ccrs.EckertI(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertii'):
proj = ccrs.EckertII(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertiii'):
proj = ccrs.EckertIII(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertiv'):
proj = ccrs.EckertIV(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertv'):
proj = ccrs.EckertV(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertvi'):
proj = ccrs.EckertVI(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'equalearth'):
proj = ccrs.EqualEarth(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'gnomonic'):
proj = ccrs.Gnomonic(central_latitude=central_latitude,
central_longitude=central_longitude,
globe=globe)
elif (proj_name == 'lambertazimuthalequalarea'):
proj = ccrs.LambertAzimuthalEqualArea(
central_longitude=central_longitude,
central_latitude=central_latitude,
globe=globe,
false_easting=false_easting,
false_northing=false_northing)
elif (proj_name == 'northpolarstereo'):
proj = ccrs.NorthPolarStereo(central_longitude=central_longitude,
true_scale_latitude=true_scale_latitude,
globe=globe)
elif (proj_name == 'osni'):
proj = ccrs.OSNI(approx=approx)
elif (proj_name == 'southpolarstereo'):
proj = ccrs.SouthPolarStereo(central_longitude=central_longitude,
true_scale_latitude=true_scale_latitude,
globe=globe)
else:
# This is same as "Geographic coordinates"
proj = ccrs.PlateCarree(central_longitude=central_longitude,
globe=globe)
return proj
def map_into_eckert(params, nlats=200, nlons=200, day=None):
"""
Input: the params from MCMC, the no. of latitude points to use (200 by
default for resolution purposes), the no. of longitude points to use (200
by default so that the gradient between different filled contours is
sharp), and the date of interest for the EPIC data, if desired
Produces a map of the Earth with filled countours corresponding to the
albedo of a given slice.
** CURRENTLY ONLY WORKS FOR 6 OR 8 SLICES. Should be generalized.
Output: None
"""
if not (len(params) in [6, 8]):
print("Error: Eckert projections are currently only implemented for \
6 OR 8 slice maps.")
return
# if we are showing EPIC results from ONE date
if type(day) in [int, float]:
t, phi, ref, ref_err, nans = EPIC_data(day, False)
# cartopy longitude decreases as the planet spins and is 0 at Greenwich
lons = np.linspace(2 * np.pi, 0, nlons) # longitude spanned
# if we are showing multi-day real data or artificial results
else:
lons = np.linspace(2 * np.pi, 0, nlons)
nslices = int(len(params)) # longitudinal slices in the map
interval = int(nlons /
nslices) # entries in longitude array which span one slice
# for example, if we have 200 longitude points and 8 slices, each slice
# will be made up of 200/8 = 25 longitudes
lats = np.linspace(-np.pi / 2, np.pi / 2, nlats)
lats, lons = np.meshgrid(lats, lons) # grid of longitude and latitude
lats = np.rad2deg(lats) # convert to degrees
lons = np.rad2deg(lons)
# eckert IV projection
fig = plt.figure(figsize=(12, 6))
ax = fig.add_subplot(1, 1, 1, projection=ccrs.EckertIV())
data = []
# if 6 slices:
if nslices == 6:
for i in range(nlons): # for each of the longitude points
if (i <= interval):
temp = [params[0] for i in range(nlats)]
elif (i <= 2 * interval):
temp = [params[1] for i in range(nlats)]
elif (i <= 3 * interval):
temp = [params[2] for i in range(nlats)]
elif (i <= 4 * interval):
temp = [params[3] for i in range(nlats)]
elif (i <= 5 * interval):
temp = [params[4] for i in range(nlats)]
elif (i <= 6 * interval):
temp = [params[5] for i in range(nlats)]
data.append(temp)
# if 8 slices:
if nslices == 8:
for i in range(nlons):
if (i <= interval):
temp = [params[0] for i in range(nlats)]
elif (i <= 2 * interval):
temp = [params[1] for i in range(nlats)]
elif (i <= 3 * interval):
temp = [params[2] for i in range(nlats)]
elif (i <= 4 * interval):
temp = [params[3] for i in range(nlats)]
elif (i <= 5 * interval):
temp = [params[4] for i in range(nlats)]
elif (i <= 6 * interval):
temp = [params[5] for i in range(nlats)]
elif (i <= 7 * interval):
temp = [params[6] for i in range(nlats)]
elif (i <= 8 * interval):
temp = [params[7] for i in range(nlats)]
data.append(temp)
# make the map using a Plate Carree transformation
# colour map: greys
cs = ax.contourf(lons,
lats,
data,
transform=ccrs.PlateCarree(),
cmap='gist_gray',
alpha=0.3)
cbar = fig.colorbar(cs)
cbar.ax.set_ylabel(r'Albedo $A$') # make the color bar appear
ax.coastlines() # draw coastlines
ax.set_global() # make the map global
if type(day) in [int, float]: # if one day
plt.title("EPIC albedo map - MCMC" + r" [" + r"$d = $" +
date_after(day) + "]")
elif type(day) == list: # if several days, as when obtaining minima
start_day = date_after(day[0]) # first date
end_day = date_after(day[-1]) # final date
dayspan = day[-1] - day[0] + 1 # time in days spanned by map
days_used = len(day) # how many days we actually have data for
plt.title("Albedo minima from " + start_day + " to " + end_day +
" [%d day(s) missing]" % (dayspan - days_used))
plt.rcParams.update({'font.size': 14})
else: # if just artificial data
plt.title("Albedo map - Eckert IV Projection")
def projection(self):
if self.proj is None:
return ccrs.PlateCarree()
proj_dict = ast.literal_eval(self.proj)
user_proj = proj_dict.pop("proj")
if user_proj == 'PlateCarree':
self.xylim_supported = True
return ccrs.PlateCarree(**proj_dict)
elif user_proj == 'AlbersEqualArea':
return ccrs.AlbersEqualArea(**proj_dict)
elif user_proj == 'AzimuthalEquidistant':
return ccrs.AzimuthalEquidistant(**proj_dict)
elif user_proj == 'EquidistantConic':
return ccrs.EquidistantConic(**proj_dict)
elif user_proj == 'LambertConformal':
return ccrs.LambertConformal(**proj_dict)
elif user_proj == 'LambertCylindrical':
return ccrs.LambertCylindrical(**proj_dict)
elif user_proj == 'Mercator':
return ccrs.Mercator(**proj_dict)
elif user_proj == 'Miller':
return ccrs.Miller(**proj_dict)
elif user_proj == 'Mollweide':
return ccrs.Mollweide(**proj_dict)
elif user_proj == 'Orthographic':
return ccrs.Orthographic(**proj_dict)
elif user_proj == 'Robinson':
return ccrs.Robinson(**proj_dict)
elif user_proj == 'Sinusoidal':
return ccrs.Sinusoidal(**proj_dict)
elif user_proj == 'Stereographic':
return ccrs.Stereographic(**proj_dict)
elif user_proj == 'TransverseMercator':
return ccrs.TransverseMercator(**proj_dict)
elif user_proj == 'UTM':
return ccrs.UTM(**proj_dict)
elif user_proj == 'InterruptedGoodeHomolosine':
return ccrs.InterruptedGoodeHomolosine(**proj_dict)
elif user_proj == 'RotatedPole':
return ccrs.RotatedPole(**proj_dict)
elif user_proj == 'OSGB':
self.xylim_supported = False
return ccrs.OSGB(**proj_dict)
elif user_proj == 'EuroPP':
self.xylim_supported = False
return ccrs.EuroPP(**proj_dict)
elif user_proj == 'Geostationary':
return ccrs.Geostationary(**proj_dict)
elif user_proj == 'NearsidePerspective':
return ccrs.NearsidePerspective(**proj_dict)
elif user_proj == 'EckertI':
return ccrs.EckertI(**proj_dict)
elif user_proj == 'EckertII':
return ccrs.EckertII(**proj_dict)
elif user_proj == 'EckertIII':
return ccrs.EckertIII(**proj_dict)
elif user_proj == 'EckertIV':
return ccrs.EckertIV(**proj_dict)
elif user_proj == 'EckertV':
return ccrs.EckertV(**proj_dict)
elif user_proj == 'EckertVI':
return ccrs.EckertVI(**proj_dict)
elif user_proj == 'EqualEarth':
return ccrs.EqualEarth(**proj_dict)
elif user_proj == 'Gnomonic':
return ccrs.Gnomonic(**proj_dict)
elif user_proj == 'LambertAzimuthalEqualArea':
return ccrs.LambertAzimuthalEqualArea(**proj_dict)
elif user_proj == 'NorthPolarStereo':
return ccrs.NorthPolarStereo(**proj_dict)
elif user_proj == 'OSNI':
return ccrs.OSNI(**proj_dict)
elif user_proj == 'SouthPolarStereo':
return ccrs.SouthPolarStereo(**proj_dict)
def Eckert(albedo,numOfSlices,nlats=400,nlons=400,fig=None,bar=None,
plot=True,data=False):
"""
General function to plot the Eckert map based off the number of
slices
Input(s):
albedo: takes in the albedo value at each longitudinal slices.
numOfSlices: number of longitudinal slices.
nlats, nlons = Used for the contour function. Basically, how
many points to plot in the Eckert projection.
(Default to 400, I do not recommend changing it!)
fig (Default to None): This is for animation, since the animation function updates
the fig, it needs the previous iteration.
bar (Default to None): The color bar on the side. Again for the animation to keep
the bar constant and not changing between frames.
plot (Default to TRUE): if TRUE, plots the Eckert project, else
returns longitudes, gridlines and the albedos.
Output(s):
EckertIV map projection of the results for a general number
of slices.
"""
mod = nlons%numOfSlices
if (mod==0):
interval = int(nlons/numOfSlices)
else:
interval = int(nlons/numOfSlices)
nlons=nlons-mod
nlons = nlons-mod
longitude = np.rad2deg(np.linspace(2*np.pi,0,nlons))
lattitude = np.rad2deg(np.linspace(-np.pi/2,np.pi/2,nlats))
lattitude, longitude = np.meshgrid(lattitude,longitude)
w = 0
A = []
a_dumb = []
gridlines=[360]
for i in range(nlons):
if (w == len(albedo)):
break
temp = [albedo[w] for j in range(nlats)]
temp_dum = [np.random.randint(0,2) for j in range(nlats)]
if i%interval==0 and i!=0:
w=w+1
gridlines.append(longitude[i][0])
A.append(temp)
a_dumb.append(temp_dum)
gridlines.append(0)
if plot == False:
return longitude,lattitude,A,gridlines
if type(fig)==type(None):
fig = plt.figure(figsize=(12,6))
else:
fig = fig
ax = fig.add_subplot(1,1,1,projection = ccrs.EckertIV())
#if (len(A)!=nlats):
# for i in range(nlats-len(A)):
# A.append(A[len(A)-1])
ax.clear()
cs = ax.contourf(longitude,lattitude,A,transform=ccrs.PlateCarree(),cmap='gist_gray',alpha=0.3)
if data:
return cs
#SET MAX OF COLORBAR TO 1
cbar = fig.colorbar(cs)
cbar.ax.set_ylabel(r'Apparent Albedo $A^*$')
ax.coastlines()
ax.gridlines(color='grey',linewidth=1.5,xlocs = gridlines,ylocs=None)
ax.set_global()
return longitude,lattitude,A,cs,fig,ax,gridlines
def set_proj(projection='Robinson', proj_default=True):
""" Set the projection for Cartopy.
Parameters
----------
projection : string
the map projection. Available projections:
'Robinson' (default), 'PlateCarree', 'AlbertsEqualArea',
'AzimuthalEquidistant','EquidistantConic','LambertConformal',
'LambertCylindrical','Mercator','Miller','Mollweide','Orthographic',
'Sinusoidal','Stereographic','TransverseMercator','UTM',
'InterruptedGoodeHomolosine','RotatedPole','OSGB','EuroPP',
'Geostationary','NearsidePerspective','EckertI','EckertII',
'EckertIII','EckertIV','EckertV','EckertVI','EqualEarth','Gnomonic',
'LambertAzimuthalEqualArea','NorthPolarStereo','OSNI','SouthPolarStereo'
proj_default : bool
If True, uses the standard projection attributes from Cartopy.
Enter new attributes in a dictionary to change them. Lists of attributes
can be found in the Cartopy documentation:
https://scitools.org.uk/cartopy/docs/latest/crs/projections.html#eckertiv
Returns
-------
proj : the Cartopy projection object
See Also
--------
pyleoclim.utils.mapping.map_all : mapping function making use of the projection
"""
if proj_default is not True and type(proj_default) is not dict:
raise TypeError(
'The default for the projections should either be provided' +
' as a dictionary or set to True')
# Set the projection
if projection == 'Robinson':
if proj_default is True:
proj = ccrs.Robinson()
else:
proj = ccrs.Robinson(**proj_default)
elif projection == 'PlateCarree':
if proj_default is True:
proj = ccrs.PlateCarree()
else:
proj = ccrs.PlateCarree(**proj_default)
elif projection == 'AlbersEqualArea':
if proj_default is True:
proj = ccrs.AlbersEqualArea()
else:
proj = ccrs.AlbersEqualArea(**proj_default)
elif projection == 'AzimuthalEquidistant':
if proj_default is True:
proj = ccrs.AzimuthalEquidistant()
else:
proj = ccrs.AzimuthalEquidistant(**proj_default)
elif projection == 'EquidistantConic':
if proj_default is True:
proj = ccrs.EquidistantConic()
else:
proj = ccrs.EquidistantConic(**proj_default)
elif projection == 'LambertConformal':
if proj_default is True:
proj = ccrs.LambertConformal()
else:
proj = ccrs.LambertConformal(**proj_default)
elif projection == 'LambertCylindrical':
if proj_default is True:
proj = ccrs.LambertCylindrical()
else:
proj = ccrs.LambertCylindrical(**proj_default)
elif projection == 'Mercator':
if proj_default is True:
proj = ccrs.Mercator()
else:
proj = ccrs.Mercator(**proj_default)
elif projection == 'Miller':
if proj_default is True:
proj = ccrs.Miller()
else:
proj = ccrs.Miller(**proj_default)
elif projection == 'Mollweide':
if proj_default is True:
proj = ccrs.Mollweide()
else:
proj = ccrs.Mollweide(**proj_default)
elif projection == 'Orthographic':
if proj_default is True:
proj = ccrs.Orthographic()
else:
proj = ccrs.Orthographic(**proj_default)
elif projection == 'Sinusoidal':
if proj_default is True:
proj = ccrs.Sinusoidal()
else:
proj = ccrs.Sinusoidal(**proj_default)
elif projection == 'Stereographic':
if proj_default is True:
proj = ccrs.Stereographic()
else:
proj = ccrs.Stereographic(**proj_default)
elif projection == 'TransverseMercator':
if proj_default is True:
proj = ccrs.TransverseMercator()
else:
proj = ccrs.TransverseMercator(**proj_default)
elif projection == 'TransverseMercator':
if proj_default is True:
proj = ccrs.TransverseMercator()
else:
proj = ccrs.TransverseMercator(**proj_default)
elif projection == 'UTM':
if proj_default is True:
proj = ccrs.UTM()
else:
proj = ccrs.UTM(**proj_default)
elif projection == 'UTM':
if proj_default is True:
proj = ccrs.UTM()
else:
proj = ccrs.UTM(**proj_default)
elif projection == 'InterruptedGoodeHomolosine':
if proj_default is True:
proj = ccrs.InterruptedGoodeHomolosine()
else:
proj = ccrs.InterruptedGoodeHomolosine(**proj_default)
elif projection == 'RotatedPole':
if proj_default is True:
proj = ccrs.RotatedPole()
else:
proj = ccrs.RotatedPole(**proj_default)
elif projection == 'OSGB':
if proj_default is True:
proj = ccrs.OSGB()
else:
proj = ccrs.OSGB(**proj_default)
elif projection == 'EuroPP':
if proj_default is True:
proj = ccrs.EuroPP()
else:
proj = ccrs.EuroPP(**proj_default)
elif projection == 'Geostationary':
if proj_default is True:
proj = ccrs.Geostationary()
else:
proj = ccrs.Geostationary(**proj_default)
elif projection == 'NearsidePerspective':
if proj_default is True:
proj = ccrs.NearsidePerspective()
else:
proj = ccrs.NearsidePerspective(**proj_default)
elif projection == 'EckertI':
if proj_default is True:
proj = ccrs.EckertI()
else:
proj = ccrs.EckertI(**proj_default)
elif projection == 'EckertII':
if proj_default is True:
proj = ccrs.EckertII()
else:
proj = ccrs.EckertII(**proj_default)
elif projection == 'EckertIII':
if proj_default is True:
proj = ccrs.EckertIII()
else:
proj = ccrs.EckertIII(**proj_default)
elif projection == 'EckertIV':
if proj_default is True:
proj = ccrs.EckertIV()
else:
proj = ccrs.EckertIV(**proj_default)
elif projection == 'EckertV':
if proj_default is True:
proj = ccrs.EckertV()
else:
proj = ccrs.EckertV(**proj_default)
elif projection == 'EckertVI':
if proj_default is True:
proj = ccrs.EckertVI()
else:
proj = ccrs.EckertVI(**proj_default)
elif projection == 'EqualEarth':
if proj_default is True:
proj = ccrs.EqualEarth()
else:
proj = ccrs.EqualEarth(**proj_default)
elif projection == 'Gnomonic':
if proj_default is True:
proj = ccrs.Gnomonic()
else:
proj = ccrs.Gnomonic(**proj_default)
elif projection == 'LambertAzimuthalEqualArea':
if proj_default is True:
proj = ccrs.LambertAzimuthalEqualArea()
else:
proj = ccrs.LambertAzimuthalEqualArea(**proj_default)
elif projection == 'NorthPolarStereo':
if proj_default is True:
proj = ccrs.NorthPolarStereo()
else:
proj = ccrs.NorthPolarStereo(**proj_default)
elif projection == 'OSNI':
if proj_default is True:
proj = ccrs.OSNI()
else:
proj = ccrs.OSNI(**proj_default)
elif projection == 'OSNI':
if proj_default is True:
proj = ccrs.SouthPolarStereo()
else:
proj = ccrs.SouthPolarStereo(**proj_default)
else:
raise ValueError('Invalid projection type')
return proj
import matplotlib.pyplot as plt import cartopy.crs as ccrs plt.figure(figsize=(6, 3)) ax = plt.axes(projection=ccrs.EckertIV()) ax.coastlines(resolution='110m') ax.gridlines()
fig = plt.figure(figsize=(5, 5))
gs = gridspec.GridSpec(3, 1, hspace=.33, height_ratios=(10, 10, 1))
scenarios = ('rcp45', 'rcp85')
dropcol = 'Unnamed: 0'
bounds = np.arange(0, 13, 2)
labels = ('a', 'b')
# Create a linear color map based on Claudia's Reds
cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
'ClaudiaReds', ['#F2D7D4', '#BE3526'], N=7)
cmap.set_under('#67A3C2')
cmap.set_over('#BE3526')
norm = matplotlib.colors.BoundaryNorm(bounds, ncolors=cmap.N, clip=False)
proj = ccrs.EckertIV()
# Save COP loss data to csv file
df_out = pd.DataFrame(columns=scenarios)
for n, rcp in enumerate(scenarios):
lat = np.arange(-89.5, 90, 1.0)
lon = np.arange(0, 360, 1.0)
# ax = add_subplot(2, 1, n+1, projection=proj)
ax = plt.subplot(gs[n], projection=proj)
early_df = pd.read_csv('early_' + rcp +
'_cop_mean.csv').drop(columns=dropcol)
late_df = pd.read_csv('late_' + rcp +
def to_cartopy_proj(self):
"""
Creates a `cartopy.crs.Projection` instance from PROJ4 parameters.
Returns
-------
cartopy.crs.projection
Cartopy projection representing the projection of the spatial reference system.
"""
proj4_params = self.to_proj4_dict()
proj4_name = proj4_params.get('proj')
central_longitude = proj4_params.get('lon_0', 0.)
central_latitude = proj4_params.get('lat_0', 0.)
false_easting = proj4_params.get('x_0', 0.)
false_northing = proj4_params.get('y_0', 0.)
scale_factor = proj4_params.get('k', 1.)
standard_parallels = (proj4_params.get('lat_1', 20.),
proj4_params.get('lat_2', 50.))
if proj4_name == 'longlat':
ccrs_proj = ccrs.PlateCarree(central_longitude)
elif proj4_name == 'aeqd':
ccrs_proj = ccrs.AzimuthalEquidistant(central_longitude,
central_latitude,
false_easting,
false_northing)
elif proj4_name == 'merc':
ccrs_proj = ccrs.Mercator(central_longitude,
false_easting=false_easting,
false_northing=false_northing,
scale_factor=scale_factor)
elif proj4_name == 'eck1':
ccrs_proj = ccrs.EckertI(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck2':
ccrs_proj = ccrs.EckertII(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck3':
ccrs_proj = ccrs.EckertIII(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck4':
ccrs_proj = ccrs.EckertIV(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck5':
ccrs_proj = ccrs.EckertV(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck6':
ccrs_proj = ccrs.EckertVI(central_longitude, false_easting,
false_northing)
elif proj4_name == 'aea':
ccrs_proj = ccrs.AlbersEqualArea(central_longitude,
central_latitude, false_easting,
false_northing,
standard_parallels)
elif proj4_name == 'eqdc':
ccrs_proj = ccrs.EquidistantConic(central_longitude,
central_latitude, false_easting,
false_northing,
standard_parallels)
elif proj4_name == 'gnom':
ccrs_proj = ccrs.Gnomonic(central_longitude, central_latitude)
elif proj4_name == 'laea':
ccrs_proj = ccrs.LambertAzimuthalEqualArea(central_longitude,
central_latitude,
false_easting,
false_northing)
elif proj4_name == 'lcc':
ccrs_proj = ccrs.LambertConformal(
central_longitude,
central_latitude,
false_easting,
false_northing,
standard_parallels=standard_parallels)
elif proj4_name == 'mill':
ccrs_proj = ccrs.Miller(central_longitude)
elif proj4_name == 'moll':
ccrs_proj = ccrs.Mollweide(central_longitude,
false_easting=false_easting,
false_northing=false_northing)
elif proj4_name == 'stere':
ccrs_proj = ccrs.Stereographic(central_latitude,
central_longitude,
false_easting,
false_northing,
scale_factor=scale_factor)
elif proj4_name == 'ortho':
ccrs_proj = ccrs.Orthographic(central_longitude, central_latitude)
elif proj4_name == 'robin':
ccrs_proj = ccrs.Robinson(central_longitude,
false_easting=false_easting,
false_northing=false_northing)
elif proj4_name == 'sinus':
ccrs_proj = ccrs.Sinusoidal(central_longitude, false_easting,
false_northing)
elif proj4_name == 'tmerc':
ccrs_proj = ccrs.TransverseMercator(central_longitude,
central_latitude,
false_easting, false_northing,
scale_factor)
else:
err_msg = "Projection '{}' is not supported.".format(proj4_name)
raise ValueError(err_msg)
return ccrs_proj
'Mollweide': ccrs.Mollweide(),
'Orthographic': ccrs.Orthographic(),
'Robinson': ccrs.Robinson(),
'Sinusoidal': ccrs.Sinusoidal(),
'Stereographic': ccrs.Stereographic(),
'TransverseMercator': ccrs.TransverseMercator(),
'InterruptedGoodeHomolosine': ccrs.InterruptedGoodeHomolosine(),
'RotatedPole': ccrs.RotatedPole(),
'OSGB': ccrs.OSGB(),
'EuroPP': ccrs.EuroPP(),
'Geostationary': ccrs.Geostationary(),
'NearsidePerspective': ccrs.NearsidePerspective(),
'EckertI': ccrs.EckertI(),
'EckertII': ccrs.EckertII(),
'EckertIII': ccrs.EckertIII(),
'EckertIV': ccrs.EckertIV(),
'EckertV': ccrs.EckertV(),
'EckertVI': ccrs.EckertVI(),
'Gnomonic': ccrs.Gnomonic(),
'LambertAzimuthalEqualArea': ccrs.LambertAzimuthalEqualArea(),
'NorthPolarStereo': ccrs.NorthPolarStereo(),
'OSNI': ccrs.OSNI(),
'SouthPolarStereo': ccrs.SouthPolarStereo()
}
for index, projection in enumerate(projections.items()):
ax = fig.add_subplot(7, 5, index + 1, projection=projection[1])
ax.coastlines()
ax.set_title(projection[0])
plt.show()
