def drawmap_Moll(): ax = plt.axes(projection=ccrs.Mollweide()) ax.coastlines() ax.set_xticks(range(-180,180,60),crs=ccrs.Mollweide()) ax.set_yticks(range(-90,90,30),crs=ccrs.Mollweide()) return ax
def test_offset(): crs = ccrs.Mollweide() crs_offset = ccrs.Mollweide(false_easting=1234, false_northing=-4321) other_args = {'a=6378137.0', 'lon_0=0', 'x_0=1234', 'y_0=-4321'} check_proj_params('moll', crs_offset, other_args) assert tuple(np.array(crs.x_limits) + 1234) == crs_offset.x_limits assert tuple(np.array(crs.y_limits) - 4321) == crs_offset.y_limits
def map1(z1, lons, lats): import cartopy from mpl_toolkits.axes_grid1 import AxesGrid proj = ccrs.Mollweide() dproj = ccrs.PlateCarree() cv = np.arange(-4, 5, 1) vm = 4 ax = plt.axes(projection=ccrs.Mollweide()) ax.coastlines(resolution='110m') ax.gridlines() plt.contourf(lons, lats, z1, levels=cv, cmap='RdBu_r', transform=dproj, extend='both') # plt.pcolormesh(lons, lats, z1,vmin=-1*vm,vmax=vm, cmap='RdBu_r',transform=dproj) #plt.contourf(lons, lats, sst, levels=cv, extend='both', cmap='RdBu', transform=dproj) plt.colorbar() ax.add_feature(cartopy.feature.LAND, zorder=0, edgecolor='black', color='white') return
def test_globe(self): # Ensure the globe affects output. rugby_globe = ccrs.Globe(semimajor_axis=9000000, semiminor_axis=9000000, ellipse=None) footy_globe = ccrs.Globe(semimajor_axis=1000000, semiminor_axis=1000000, ellipse=None) rugby_moll = ccrs.Mollweide(globe=rugby_globe) footy_moll = ccrs.Mollweide(globe=footy_globe) rugby_pt = rugby_moll.transform_point( 10, 10, rugby_moll.as_geodetic(), ) footy_pt = footy_moll.transform_point( 10, 10, footy_moll.as_geodetic(), ) assert_arr_almost_eq(rugby_pt, (1400915, 1741319), decimal=0) assert_arr_almost_eq(footy_pt, (155657, 193479), decimal=0)
def main(): # Load data filepath = iris.sample_data_path("orca2_votemper.nc") cube = iris.load_cube(filepath) # Choose plot projections projections = {} projections["Mollweide"] = ccrs.Mollweide() projections["PlateCarree"] = ccrs.PlateCarree() projections["NorthPolarStereo"] = ccrs.NorthPolarStereo() projections["Orthographic"] = ccrs.Orthographic(central_longitude=-90, central_latitude=45) pcarree = projections["PlateCarree"] # Transform cube to target projection new_cube, extent = iris.analysis.cartography.project(cube, pcarree, nx=400, ny=200) # Plot data in each projection for name in sorted(projections): fig = plt.figure() fig.suptitle("ORCA2 Data Projected to {}".format(name)) # Set up axes and title ax = plt.subplot(projection=projections[name]) # Set limits ax.set_global() # plot with Iris quickplot pcolormesh qplt.pcolormesh(new_cube) # Draw coastlines ax.coastlines() iplt.show()
def test_grid(): # USGS Professional Paper 1395, pg 252, Table 42 globe = ccrs.Globe(ellipse=None, semimajor_axis=0.5**0.5, semiminor_axis=0.5**0.5) moll = ccrs.Mollweide(globe=globe) geodetic = moll.as_geodetic() other_args = {'a=0.7071067811865476', 'b=0.7071067811865476', 'lon_0=0'} check_proj_params('moll', moll, other_args) assert_almost_equal(np.array(moll.x_limits), [-2, 2]) assert_almost_equal(np.array(moll.y_limits), [-1, 1]) lats = np.arange(0, 91, 5)[::-1] lons = np.full_like(lats, 90) result = moll.transform_points(geodetic, lons, lats) expected_x = np.array([ 0.00000, 0.20684, 0.32593, 0.42316, 0.50706, 0.58111, 0.64712, 0.70617, 0.75894, 0.80591, 0.84739, 0.88362, 0.91477, 0.94096, 0.96229, 0.97882, 0.99060, 0.99765, 1.00000, ]) assert_almost_equal(result[:, 0], expected_x, decimal=5) expected_y = np.array([ 1.00000, 0.97837, 0.94539, 0.90606, 0.86191, 0.81382, 0.76239, 0.70804, 0.65116, 0.59204, 0.53097, 0.46820, 0.40397, 0.33850, 0.27201, 0.20472, 0.13681, 0.06851, 0.00000, ]) assert_almost_equal(result[:, 1], expected_y, decimal=5)
def plot_sphere_density(lonlat, probs, npts, uniform=False): # lon in [0,2pi], lat in [0,pi] fig = plt.figure(figsize=(3, 2), dpi=200) proj = ccrs.Mollweide() ax = fig.add_subplot(111, projection=proj) lon, lat = lonlat[:, 0], lonlat[:, 1] lon = lon.cpu().numpy().reshape(npts, npts) lat = lat.cpu().numpy().reshape(npts, npts) lon -= np.pi lat -= np.pi / 2 probs = probs.cpu().numpy().reshape(npts, npts) if not uniform: ax.pcolormesh(lon * 180 / np.pi, lat * 180 / np.pi, probs, transform=ccrs.PlateCarree(), cmap='magma') else: # uniform color colormap = plt.cm.get_cmap('magma') norm = matplotlib.colors.Normalize(vmin=0, vmax=1) probs[probs > 0] = .5 ax.pcolormesh(lon * 180 / np.pi, lat * 180 / np.pi, probs, transform=ccrs.PlateCarree(), cmap='magma', norm=norm) plt.grid(False) ax.set_xticks([]) ax.set_yticks([]) ax.set_global()
def plot_it(p_, iss_lat, iss_lon, user_lat, user_lon): iss_lat = float(iss_lat) iss_lon = float(iss_lon) ax = plt.axes(projection=ccrs.Mollweide()) ax.stock_img() ''' print(iss_lat,iss_lon) print(type(iss_lat),type(iss_lon)) print(user_lat,user_lon)''' plt.plot( [iss_lon], [iss_lat], color='blue', linewidth=2, marker='o', transform=ccrs.Geodetic(), ) plt.plot( [user_lon], [user_lat], color='green', linewidth=2, marker='x', transform=ccrs.Geodetic(), ) plt.draw()
def base_map(projection='local', center_lat=0, center_lon=0, extent=None, **kwargs): """ Function to plot a basic map which can be used to add data later. :param projection: Cartopy projection string :param center_lat: Latitude to center map :param center_lon: Longitude to center map :param extent: List of coordinates for map boundaries """ plt.figure() if projection == 'global': ax = plt.axes(projection=ccrs.Mollweide(central_longitude=center_lon)) elif projection == 'local': ax = plt.axes(projection=ccrs.AlbersEqualArea( central_latitude=center_lat, central_longitude=center_lon)) if extent: ax.set_extent(extent) elif projection == 'AzimuthalEquidistant': ax = plt.axes(projection=ccrs.AzimuthalEquidistant( central_longitude=center_lon, central_latitude=center_lat)) else: print('Projection not supported') ax.coastlines() ax.add_feature(cfeature.LAND) ax.add_feature(cfeature.BORDERS, linestyle='-') return ax
def test_simple(self): # First sub-plot plt.subplot(221) plt.title('Default') iplt.contourf(self.cube) plt.gca().coastlines() # Second sub-plot plt.subplot(222, projection=ccrs.Mollweide(central_longitude=120)) plt.title('Molleweide') iplt.contourf(self.cube) plt.gca().coastlines() # Third sub-plot (the projection part is redundant, but a useful # test none-the-less) ax = plt.subplot(223, projection=iplt.default_projection(self.cube)) plt.title('Native') iplt.contour(self.cube) ax.coastlines() # Fourth sub-plot ax = plt.subplot(2, 2, 4, projection=ccrs.PlateCarree()) plt.title('PlateCarree') iplt.contourf(self.cube) ax.coastlines() self.check_graphic()
def _get_ccrs(self): """ given the projection and the domain, returns the cartopy projection of the map (the data projection, i.e. the 'transform' argument, is always assumed to be ccrs.PlateCarree(central_longitude=0)) """ if not(self.proj): self.proj = 'cyl' self.crs = ccrs.PlateCarree(central_longitude=0) if self.proj in ['cyl', 'merc']: self.crs = ccrs.PlateCarree(central_longitude=180) if self.proj == 'moll': self.crs = ccrs.Mollweide(central_longitude=180) if self.proj == 'spstere': self.crs = ccrs.SouthPolarStereo(central_longitude=180) if self.proj == 'npstere': self.crs = ccrs.NorthPolarStereo(central_longitude=180) return self
def plot_synthetic_poles(ax=None, title=''): if ax is None: if proj_type == 'M': myax = plt.axes(projection=ccrs.Mollweide(200. - lon_shift)) elif proj_type == 'O': myax = plt.axes( projection=ccrs.Orthographic(200. - lon_shift, 30.)) else: myax = ax myax.gridlines() colorcycle = itertools.cycle(colors) lons, lats, ages = path.compute_synthetic_poles(n=100) for i in range(len(poles)): c = colorcycle.next() poles[i].plot(ax, color=c) myax.scatter(lons[:, i], lats[:, i], color=c, transform=ccrs.PlateCarree()) if title != '': myax.set_title(title) if ax is None: plt.savefig("keweenawan_poles_" + str(n_euler_rotations) + ".pdf")
def plot_tomo_map(sph_file, depth, vmin=-2.0, vmax=2.0, lmin=0, lmax=40, contour_levels=20): sph_splines = read_sph(sph_file, lmin, lmax) spl_vals = find_spl_vals(depth) map_dv = 0.0 fig = plt.figure(figsize=[8, 5]) tomo_map = plt.subplot(1, 1, 1, projection=ccrs.Mollweide(180)) for i, sph_spline in enumerate(sph_splines): grid = sph_spline.expand() map_dv += spl_vals[i] * grid.data lons, lats = np.meshgrid(grid.lons(), grid.lats()) cf = tomo_map.pcolormesh(grid.lons(), grid.lats(), map_dv * 100.0, transform=ccrs.PlateCarree(), cmap='jet_r', vmin=vmin, vmax=vmax) tomo_map.coastlines(zorder=99) plt.colorbar(cf, fraction=0.02, pad=0.02, label='$\delta$Vs (%)') plt.title('depth = {} km, lmin = {}, lmax = {}'.format(depth, lmin, lmax)) plt.show()
def plot_nino_regions(): import matplotlib.pyplot as plt import cartopy.crs as ccrs fig = plt.figure(figsize=(12, 8)) ax = plt.axes(projection=ccrs.Mollweide(-160)) #ax.coastlines(); ax.stock_img() ax.gridlines() from shapely.geometry import Polygon nino12 = Polygon([(-90, 0), (-80, 0), (-80, -10), (-90, -10)]) nino3 = Polygon([(-150, 5), (-90, 5), (-90, -5), (-150, -5)]) nino34 = Polygon([(-170, 5), (-120, 5), (-120, -5), (-170, -5)]) nino4 = Polygon([(-200, 5), (-150, 5), (-150, -5), (-200, -5)]) ninos = [[x] for x in [nino12, nino3, nino34, nino4]] color = ['none', "orange", 'none', "green"] for e, nino in enumerate(ninos): ax.add_geometries(nino, ccrs.PlateCarree(), facecolor=color[e], linewidth=2, edgecolor='k', alpha=0.6, label="sd") ax.text(-88, 2, "Nino\n1+2", transform=ccrs.PlateCarree()) ax.text(-155, 7, "Nino 3.4", transform=ccrs.PlateCarree()) ax.text(-125, 7, "Nino 3", transform=ccrs.PlateCarree()) ax.text(-180, 7, "Nino 4", transform=ccrs.PlateCarree()) ax.set_extent([-250, -40, -60, 60], crs=ccrs.PlateCarree())
def plot_global_map(map_in, proj='Mollweide', vmin_in=-999.0, vmax_in=999.0, lower_zero=False, title='Plot', units=' ', central_longitude=90.0, ct_name='jet'): import matplotlib.pyplot as plt import numpy as np import cartopy.crs as ccrs figsize = (8.0, 4.0) fig = plt.figure(figsize=figsize) if proj == 'Rectangular': ax = plt.axes(projection=ccrs.PlateCarree( central_longitude=central_longitude)) elif proj == 'Mollweide': ax = plt.axes(projection=ccrs.Mollweide( central_longitude=central_longitude)) else: print 'Can not find projection ' + proj print 'Setting proj to rectangular' proj = 'Rectangular' ax = plt.axes(projection=ccrs.PlateCarree( central_longitude=central_longitude)) nlats, nlons = map_in.shape lats = np.rad2deg(np.linspace(-np.pi / 2, np.pi / 2, nlats + 1)) lons = np.rad2deg(np.linspace(0.0, 2.0 * np.pi, nlons + 1)) acmap = plt.get_cmap(ct_name) [vmin, vmax] = bounds_pretty(map_in, vmin_in, vmax_in, lower_zero) if proj == 'Rectangular': p = plt.pcolormesh(lons, lats, map_in, cmap=acmap, transform=ccrs.PlateCarree(), vmin=vmin, vmax=vmax) elif proj == 'Mollweide': p = plt.pcolormesh(lons, lats, map_in, cmap=acmap, transform=ccrs.PlateCarree(), vmin=vmin, vmax=vmax) ax.coastlines() ax.set_global() cb = plt.colorbar(p, orientation='horizontal', shrink=0.6) cb.ax.set_title(title) plt.show()
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_sphere_globe(): globe = ccrs.Globe(semimajor_axis=1000, ellipse=None) moll = ccrs.Mollweide(globe=globe) other_args = {'a=1000', 'lon_0=0'} check_proj_params('moll', moll, other_args) assert_almost_equal(moll.x_limits, [-2828.4271247, 2828.4271247]) assert_almost_equal(moll.y_limits, [-1414.2135624, 1414.2135624])
def mollweide_data_dist_sphere(lat, lon, fname=None, Title=None): fig = plt.figure() ax = plt.axes(projection=ccrs.Mollweide(central_longitude=0)) ax.set_global() ax.coastlines() ax.scatter(lon, lat, transform=ccrs.PlateCarree()) plt.tight_layout() plt.show()
def test_basic_click_projection_kwarg(): import cartopy.crs as ccrs """ Test init without fig """ fig = plt.figure() click_map = survey.click_map(fig=fig, projection=ccrs.Mollweide()) return plt.gcf()
def test_eccentric_globe(): globe = ccrs.Globe(semimajor_axis=1000, semiminor_axis=500, ellipse=None) moll = ccrs.Mollweide(globe=globe) other_args = {'a=1000', 'b=500', 'lon_0=0'} check_proj4_params(moll, other_args) assert_almost_equal(np.array(moll.x_limits), [-2828.4271247, 2828.4271247]) assert_almost_equal(np.array(moll.y_limits), [-1414.2135623731, 1414.2135623731])
def _matplotlib_map(dset): # Local imports since only this function uses plotting import cartopy.crs as ccrs from matplotlib import cm import matplotlib.pyplot as plt stations = dset.unique("station") baselines = dset.unique("baseline") b_width = {b: dset.num(baseline=b) / dset.num_obs * 40 for b in baselines} s_size = [int(dset.num(station=s) / dset.num_obs * 400) for s in stations] lat = np.degrees([dset.meta[station]["latitude"] for station in stations]) lon = np.degrees([dset.meta[station]["longitude"] for station in stations]) rms = [dset.rms("residual", station=station) for station in stations] if "residual" in dset._fields else None plt.figure() ax = plt.axes(projection=ccrs.Mollweide()) ax.set_global() ax.coastlines() cmap = cm.get_cmap(config.there.colormap.str) for baseline in baselines: sta_1, _, sta_2 = baseline.partition("/") sta_1_lon = np.degrees(dset.meta[sta_1]["longitude"]) sta_2_lon = np.degrees(dset.meta[sta_2]["longitude"]) sta_1_lat = np.degrees(dset.meta[sta_1]["latitude"]) sta_2_lat = np.degrees(dset.meta[sta_2]["latitude"]) b_rms = dset.rms( "residual", baseline=baseline) if "residual" in dset._fields else 0 color = cmap(b_rms) plt.plot( [sta_1_lon, sta_2_lon], [sta_1_lat, sta_2_lat], c=color, linestyle="--", linewidth=b_width[baseline], transform=ccrs.Geodetic(), zorder=0, ) plt.scatter(lon, lat, c=rms, transform=ccrs.PlateCarree(), cmap=cmap, s=s_size, zorder=10) plt.title(f"{dset.meta['input']['session_code']}") plt.figtext(0.99, 0.01, "Size: number of observations", horizontalalignment="right") if rms is not None: cbar = plt.colorbar() cbar.set_label("RMS of residual [m]") plt.show()
def test_default(): moll = ccrs.Mollweide() other_args = {'a=6378137.0', 'lon_0=0'} check_proj_params('moll', moll, other_args) assert_almost_equal(np.array(moll.x_limits), [-18040095.6961473, 18040095.6961473]) assert_almost_equal(np.array(moll.y_limits), [-9020047.8480736, 9020047.8480736])
def map_plot(fig: Figure, source: Origin, reciever: Station, position=221, resolution="110m"): """ Plot a map with a great-circle between source and reciever """ source_lon, source_lat = source.longitude % 360, source.latitude reciever_lon, reciever_lat = reciever.longitude % 360, reciever.latitude proj = ccrs.Mollweide(central_longitude=(source_lon + reciever_lon) / 2) ax = fig.add_subplot(position, projection=proj) ax.set_global() borders = cfeature.NaturalEarthFeature(cfeature.BORDERS.category, cfeature.BORDERS.name, resolution, edgecolor='none', facecolor='none') land = cfeature.NaturalEarthFeature(cfeature.LAND.category, cfeature.LAND.name, resolution, edgecolor='face', facecolor='none') ocean = cfeature.NaturalEarthFeature(cfeature.OCEAN.category, cfeature.OCEAN.name, resolution, edgecolor='face', facecolor='none') # ax.set_axis_bgcolor('1.0') ax.add_feature(ocean, facecolor='1.0') ax.add_feature(land, facecolor='0.8') ax.add_feature(borders, edgecolor='0.75') ax.coastlines(resolution=resolution, color='0.4') ax.gridlines(xlocs=range(-180, 181, 30), ylocs=range(-90, 91, 30)) source_scatter = ax.scatter(source_lon, source_lat, marker="o", s=100, c="red", zorder=10, transform=ccrs.Geodetic(), label="Source") reciever_scatter = ax.scatter(reciever_lon, reciever_lat, marker="v", s=100, c="blue", zorder=10, transform=ccrs.Geodetic(), label="Receiver") # Plot great circle ax.plot([source_lon, reciever_lon], [source_lat, reciever_lat], "k", transform=ccrs.Geodetic()) ax.legend() return fig, ax
def make_map(self): #set basemap try: self.fig.delaxes(self.ax) except AttributeError: pass #TODO: ADD TRANSVERSE MERCATOR AT STRIKE AS OPTION if self.proj_box.GetValue() == 'North Polar Stereographic': self.proj = ccrs.NorthPolarStereo( central_longitude=self.center_lon, true_scale_latitude=None, globe=None) self.ax = self.fig.add_subplot(111, projection=self.proj) pgeo.make_circular_ax(self.ax) elif self.proj_box.GetValue() == 'South Polar Stereographic': self.proj = ccrs.SouthPolarStereo( central_longitude=self.center_lon, true_scale_latitude=None, globe=None) self.ax = self.fig.add_subplot(111, projection=self.proj) pgeo.make_circular_ax(self.ax) elif self.proj_box.GetValue() == 'Mercator': self.proj = ccrs.Mercator(central_longitude=self.center_lon) self.ax = self.fig.add_subplot(111, projection=self.proj) path = mpath.Path( np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]])) self.ax.set_boundary(path, transform=self.ax.transAxes) elif self.proj_box.GetValue() == 'Mollweide': self.proj = ccrs.Mollweide(central_longitude=self.center_lon, globe=None) self.ax = self.fig.add_subplot(111, projection=self.proj) # path = mpath.Path(np.array([[0.05,0.05],[0.95,0.05],[0.95,0.95],[0.05,0.95],[0.05,0.05]])) # self.ax.set_boundary(path, transform=self.fig.transFigure) else: self.parent.user_warning("Projection %s not supported" % str(self.proj_box.GetValue())) return self.ax.set_xticks(np.arange(0, 370, 10.), crs=ccrs.PlateCarree()) self.ax.set_yticks(np.arange(-80, 90, 10.), crs=ccrs.PlateCarree()) self.ax.tick_params(grid_linewidth=.5, grid_linestyle=":", color="k", labelsize=8) lon_formatter = LongitudeFormatter(zero_direction_label=True) lat_formatter = LatitudeFormatter() self.ax.xaxis.set_major_formatter(lon_formatter) self.ax.yaxis.set_major_formatter(lat_formatter) # self.ax.gridlines(color='grey', alpha=0.5, linestyle='--',linewidth=.5) land = cfeature.NaturalEarthFeature('physical', 'land', '110m', edgecolor="black", facecolor="", linewidth=2) self.ax.add_feature(land)
def create_map(self, name, lon=0): if name == 'mollweide': ax = plt.axes(projection=ccrs.Mollweide(central_longitude=lon)) elif name == 'robinson': ax = plt.axes(projection=ccrs.Robinson(central_longitude=lon)) else: #'rectangular' and by default ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=lon)) ax.gridlines() ax.set_global() return ax
def test_central_longitude(lon): moll = ccrs.Mollweide(central_longitude=lon) other_args = {'a=6378137.0', 'lon_0={}'.format(lon)} check_proj_params('moll', moll, other_args) assert_almost_equal(np.array(moll.x_limits), [-18040095.6961473, 18040095.6961473], decimal=5) assert_almost_equal(np.array(moll.y_limits), [-9020047.8480736, 9020047.8480736])
def test_gshhs(): ax = plt.axes(projection=ccrs.Mollweide()) ax.set_extent([138, 142, 32, 42], ccrs.Geodetic()) ax.stock_img() # Draw coastlines. ax.add_feature(cfeature.GSHHSFeature('coarse', edgecolor='red')) # Draw higher resolution lakes (and test overriding of kwargs) ax.add_feature(cfeature.GSHHSFeature('low', levels=[2], facecolor='green'), facecolor='blue')
def main(): ax = plt.axes(projection=ccrs.Mollweide()) lons, lats, data = sample_data() ax.contourf(lons, lats, data, transform=ccrs.PlateCarree(), cmap='spectral') ax.coastlines() ax.set_global() plt.show()
def spherical_plot(time_temp): # projections: https://scitools.org.uk/cartopy/docs/latest/crs/projections.html # PlateCarree(), Orthographic(-80, 35) p = time_temp.isel(time=0).plot( subplot_kws=dict(projection=ccrs.Mollweide(), facecolor="gray"), transform=ccrs.PlateCarree(), ) p.axes.set_global() p.axes.coastlines() plt.savefig(f"{savepath}{output}_sphere.png") plt.close()
def test_plot_regions_projection(): # if none is given -> no projection with figure_context(): ax = r1.plot_regions(subsample=False) assert not hasattr(ax, "projection") # projection given with axes is respected with figure_context() as f: ax = f.subplots(subplot_kw=dict(projection=ccrs.Mollweide())) ax = r1.plot_regions(subsample=False, ax=ax) assert isinstance(ax.projection, ccrs.Mollweide)