N=cmap.shape[0]) figure(6) clf() levs = arange(0, 1.0570833e-07, 1e-8) levs = [ -0.125e-8, 0., 0.125e-8, 0.25e-8, 0.625e-8, 1e-8, 2e-8, 3e-8, 4e-8, 5e-8, 6e-8, 7e-8, 7.5e-8, 8e-8, 9e-8, 1.0570833e-07 ] subplot(111, projection=proj()) pactive, lon = add_cyclic_point(pactive, lon) #contourf(lon,lat,pactive,cmap=get_cmap('jet'),levels=levs,extend='both') contourf(lon, lat, pactive, cmap=cmap, levels=levs) cmap.set_under('w') gca().coastlines('50m') gca().xlocator = mticker.FixedLocator([-180, -45, 0, 45, 180]) xformatter = LONGITUDE_FORMATTER title('Observation-based species dist. model') letter_label(ypos=1.05) cb = colorbar() cb.set_label('More AM $\longleftarrow \longrightarrow$ More ECM') tight_layout() savefig('test_sulman.png', dpi=300) sys.exit() figure(4) clf() subplot(223, projection=proj()) Eobs, lon = add_cyclic_point(ECM_obs.isel(band=0).values, ECM_obs.x) contourf(lon, ECM_obs.y, Eobs, vmin=0.0, vmax=1.0, cmap=get_cmap('YlGn'))
def peek(self, title="GOES Xray Flux", **kwargs): """ Plots GOES XRS light curve is the usual manner. An example is shown below: .. plot:: import sunpy.timeseries import sunpy.data.sample ts_goes = sunpy.timeseries.TimeSeries(sunpy.data.sample.GOES_XRS_TIMESERIES, source='XRS') ts_goes.peek() Parameters ---------- title : `str`. optional The title of the plot. Defaults to "GOES Xray Flux". **kwargs : `dict` Additional plot keyword arguments that are handed to `axes.plot` functions """ # Check we have a timeseries valid for plotting self._validate_data_for_plotting() fig, ax = plt.subplots() dates = matplotlib.dates.date2num( parse_time(self.to_dataframe().index).datetime) ax.plot_date(dates, self.to_dataframe()['xrsa'], '-', label=r'0.5--4.0 $\AA$', color='blue', lw=2, **kwargs) ax.plot_date(dates, self.to_dataframe()['xrsb'], '-', label=r'1.0--8.0 $\AA$', color='red', lw=2, **kwargs) ax.set_yscale("log") ax.set_ylim(1e-9, 1e-2) ax.set_title(title) ax.set_ylabel('Watts m$^{-2}$') ax.set_xlabel( datetime.datetime.isoformat(self.to_dataframe().index[0])[0:10]) ax2 = ax.twinx() ax2.set_yscale("log") ax2.set_ylim(1e-9, 1e-2) labels = ['A', 'B', 'C', 'M', 'X'] centers = np.logspace(-7.5, -3.5, len(labels)) ax2.yaxis.set_minor_locator(mticker.FixedLocator(centers)) ax2.set_yticklabels(labels, minor=True) ax2.set_yticklabels([]) ax.yaxis.grid(True, 'major') ax.xaxis.grid(False, 'major') ax.legend() # TODO: display better tick labels for date range (e.g. 06/01 - 06/05) formatter = matplotlib.dates.DateFormatter('%H:%M') ax.xaxis.set_major_formatter(formatter) ax.fmt_xdata = matplotlib.dates.DateFormatter('%H:%M') fig.autofmt_xdate() return fig
def execute(context): plotting.setup() hts_name = context.config("hts") df_census = context.stage("census") df_hts, df_correction = context.stage("hts") # PLOT: Work / education flows plt.figure(figsize=plotting.WIDE_FIGSIZE) figures = [{ "slot": "work", "title": "Work", "top": 12 }, { "slot": "education", "title": "Education", "top": 12, "factor": 0.7 }] for index, figure in enumerate(figures): plt.subplot(1, 2, index + 1) slot = figure["slot"] df = context.stage("data")[slot] df = pd.merge(df, df_census[slot].rename(columns={"weight": "reference"}), on=["home", slot]) df = pd.merge(df, df_correction[slot], on="home") df["scaled_reference"] = df["reference"] * ( figure["factor"] if "factor" in figure else df["factor"]) count = figure["top"] df = df.sort_values(by="scaled_reference", ascending=False).head(count) plt.bar(np.arange(count), df["reference"], width=0.4, align="edge", linewidth=0.5, edgecolor="white", color=plotting.COLORS["census"], alpha=0.25) plt.bar(np.arange(count), df["scaled_reference"], width=0.4, label="Census", align="edge", linewidth=0.5, edgecolor="white", color=plotting.COLORS["census"]) plt.bar(np.arange(count) + 0.4, df["mean"] / SAMPLING_RATE, width=0.4, label="Synthetic", align="edge", linewidth=0.5, edgecolor="white", color=plotting.COLORS["synthetic"]) for index, (min, max) in enumerate(zip(df["min"].values, df["max"].values)): index += 0.4 + 0.2 plt.plot([index, index], [min / SAMPLING_RATE, max / SAMPLING_RATE], color='k', linewidth=1.0) plt.grid() plt.gca().set_axisbelow(True) plt.gca().xaxis.grid(alpha=0.0) plt.gca().yaxis.set_major_locator( tck.FixedLocator(np.arange(100) * 1e5)) plt.gca().yaxis.set_major_formatter( tck.FuncFormatter(lambda x, p: "%d" % (x * 1e-3, ))) origins, destinations = df["home"].values, df[figure["slot"]].values plt.gca().xaxis.set_major_locator( tck.FixedLocator(np.arange(count) + 0.4)) plt.gca().xaxis.set_major_formatter( tck.FixedFormatter( ["%s\n%s" % item for item in zip(origins, destinations)])) plt.ylabel("Commuters [x1000]") plt.legend(loc="best") plt.title(figure["title"]) plt.tight_layout() plt.savefig("%s/commute_flows.pdf" % context.path()) plt.close() # PLOT: Scatter plt.figure(figsize=plotting.SHORT_FIGSIZE) parts = [{ "slot": "work", "title": "Work", "marker": ".", "color": "k" }, { "slot": "education", "title": "Education", "factor": 0.7, "marker": ".", "color": plotting.COLORS[hts_name] }] minimum = np.inf maximum = -np.inf for part in parts: slot = part["slot"] df = context.stage("data")[slot] df = pd.merge(df, df_census[slot].rename(columns={"weight": "reference"}), on=["home", slot]) df = pd.merge(df, df_correction[slot], on="home") df["scaled_reference"] = df["reference"] * (part["factor"] if "factor" in part else df["factor"]) plt.loglog(df["scaled_reference"], df["mean"] / SAMPLING_RATE, markersize=2, marker=part["marker"], color=part["color"], linestyle="none", label=part["title"]) minimum = np.minimum(minimum, df["scaled_reference"].min() * 0.9) maximum = np.maximum(maximum, df["scaled_reference"].max() * 1.1) x = np.linspace(minimum, maximum, 100) plt.fill_between(x, x * 0.8, x * 1.2, color="k", alpha=0.2, linewidth=0.0, label=r"20% Error") plt.xlim([minimum, maximum]) plt.ylim([minimum, maximum]) plt.grid() plt.gca().set_axisbelow(True) plt.legend() plt.xlabel("Reference flow") plt.ylabel("Synthetic flow") plt.tight_layout() plt.savefig("%s/commute_scatter.pdf" % context.path()) plt.close() # PLOT: Histogram plt.figure(figsize=plotting.SHORT_FIGSIZE) parts = [{ "slot": "work", "title": "Work" }, { "slot": "education", "title": "Education", "factor": 0.7 }] for index, part in enumerate(parts): slot = part["slot"] df = context.stage("data")[slot] df = pd.merge(df, df_census[slot].rename(columns={"weight": "reference"}), on=["home", slot]) df = pd.merge(df, df_correction[slot], on="home") df["scaled_reference"] = df["reference"] * (part["factor"] if "factor" in part else df["factor"]) df["difference"] = 100 * ( df["mean"] / SAMPLING_RATE - df["scaled_reference"]) / df["scaled_reference"] min = df["difference"].min() max = df["difference"].max() mean = df["difference"].mean() values = df["difference"].values outliers = values # values[(values < min) | (values > max)] plt.plot([index - 0.2, index + 0.2], [min, min], color="k", linewidth=1.0) plt.plot([index - 0.2, index + 0.2], [max, max], color="k", linewidth=1.0) plt.plot([index - 0.2, index + 0.2], [mean, mean], color="k", linewidth=1.0, linestyle=":") plt.plot([index - 0.2, index - 0.2], [min, max], color="k", linewidth=1.0) plt.plot([index + 0.2, index + 0.2], [min, max], color="k", linewidth=1.0) plt.plot([index] * len(outliers), outliers, color="k", marker=".", markersize=2, linestyle="none") plt.gca().xaxis.set_major_locator(tck.FixedLocator([0, 1])) plt.gca().xaxis.set_major_formatter( tck.FixedFormatter(["Work", "Education"])) plt.ylabel("Error [%]") plt.xlim([-0.5, 1.5]) plt.grid() plt.gca().set_axisbelow(True) plt.gca().xaxis.grid(alpha=0.0) plt.bar([np.nan], [np.nan], color="none", edgecolor="k", linewidth=1.0, label="5% - 95%") plt.plot([np.nan], color="k", linestyle=":", label="Mean") plt.legend(loc="best") plt.tight_layout() plt.savefig("%s/commute_flow_boxplot.pdf" % context.path()) plt.close()
def plot_on_map_L3(data, lat, lon, cmapt, cbartitle=None, title=None, centrelon=None): import numpy as np import numpy.ma as ma import matplotlib.pyplot as plt plt.switch_backend('agg') import matplotlib.ticker as mticker import cartopy.crs as ccrs from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER from cartopy.feature import LAND #Get relative path to subroutines import os import sys dirname, filename = os.path.split(os.path.abspath(sys.argv[0])) os.environ[ "CARTOPY_USER_BACKGROUNDS"] = dirname + '/Blue_marble_data/BlueMarbleNG-TB/' proj = ccrs.Stereographic(central_latitude=90.0) ax = plt.axes(projection=proj) ax.coastlines() gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True) gl.top_labels = False gl.left_labels = False gl.xlocator = mticker.FixedLocator([-180, -120, -60, 0, 60, 120, 180]) gl.ylocator = mticker.FixedLocator([-90, -60, -30, 0, 30, 60, 90]) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER mi = data.min() ma = data.max() mapped = plt.pcolormesh(lon, lat, data, cmap=cmapt, vmin=mi, vmax=ma, transform=ccrs.PlateCarree()) cbar = plt.colorbar(mapped, ax=ax, orientation='horizontal', pad=0.05, extend='both') if cbartitle is not None: cbar.set_label(cbartitle) #Maximize and save PNG file if title is not None: plt.title(title) ax.xaxis.labelpad = 20 plt.gcf().subplots_adjust(bottom=0.00) fig = plt.gcf() return fig
extent = [73.5,140,14,53.6] # <codecell> fig = plt.figure(figsize=(20,13)) gs = gridspec.GridSpec(3, 3) #############--------------################-------------#############--------------################------------- # PLOT TOP LEFT ax1 = fig.add_subplot(gs[0,0], projection=ccrs.AlbersEqualArea(central_longitude=105, central_latitude=15)) ax1.set_extent(extent) ax1.coastlines(resolution='110m') gl1 = ax1.gridlines() gl1.xlocator = mticker.FixedLocator([50, 70,90,110,130,150,170]) gl1.ylocator = mticker.FixedLocator([10, 20, 30, 40, 50, 60]) gl1.xformatter = LONGITUDE_FORMATTER gl1.yformatter = LATITUDE_FORMATTER ax1.add_feature(cfeature.LAND, facecolor='0.85') # # classify each county based on column ID_3 # for record, county in zip(china_adm3_shp.records(), china_adm3_shp.geometries()): # # extract for each row the value corresponding to the column header # ID = record.attributes['ID_3'] # # Classify the records in to groups # if ID <= 500: # facecolor = 'k' # edgecolor = 'k' # if (ID > 500) and (x <= 1000):
} obs_tracks = da.read_nc( 'detection/JRA55/JRA55_all_tracks_knutson2007.nc')['all_tracks'] nc = da.read_nc('data/JRA55/atl_2010_MSLP.nc') lons, lats = nc.lon, nc.lat lons[lons > 180] -= 360 # sparial stuff plt.close('all') plt.figure(figsize=(10, 5)) ax = plt.axes(projection=rot_pole) ax.set_global() ax.coastlines() gl = ax.gridlines(color='#8470ff', linewidth=1) gl.ylocator = mticker.FixedLocator(np.arange(-20, 60, 10)) gl.xlocator = mticker.FixedLocator(np.arange(-120, 20, 10)) for yy in np.arange(-10, 40, 10): ax.text(-15, yy, str(yy), color='#8470ff', transform=plate_carree) for xx in np.arange(-100, 0, 10): ax.text(xx, 8, str(xx), color='#8470ff', transform=plate_carree) ax.add_feature(cartopy.feature.LAND, facecolor='darkgreen') ax.add_feature(cartopy.feature.OCEAN, facecolor='darkblue') ax.set_xlim(np.min(grid_lons) - 5, np.max(grid_lons) + 20) ax.set_ylim(np.min(grid_lats) - 5, np.max(grid_lats) + 5) reg = Polygon([(grid_lons[0], grid_lats[0]), (grid_lons[-1], grid_lats[0]), (grid_lons[-1], grid_lats[-1]), (grid_lons[0], grid_lats[-1]), (grid_lons[0], grid_lats[0])]) ax.add_geometries([reg], rot_pole, color='lightgreen',
def make_plot(fnum, all_data, ylab, ylab2, xlim=None): major_locator = ticker.FixedLocator([1, 8, 15, 22, 29]) minor_locator = ticker.MultipleLocator(1) f,ax1 = plt.subplots(num=fnum, clear=True) f.set_size_inches(10, 6) present_year = datetime.datetime.now().year x_max = 1 for data in all_data: # Calculate difference to current year: this_year = data['datetime'][0].astype(object).year this_month = data['datetime'][0].astype(object).month month_start_dt64 = np.datetime64(f"{this_year}-{this_month:02d}-01", 'ms') # Flesh out the year from this years_ago = present_year - this_year x = (data['datetime'] - month_start_dt64) / np.timedelta64(1,'D') + 1.0 # +1, because May 0 looks a bit weird # Add that amount of years to offset: years_ago = data # Averate the two channels y = np.nanmean( np.append(data['pool1'][:, None], data['pool2'][:, None], axis=1), axis=1 ) ax1.plot(x, y, label=f"{this_year}") x_max = max(x_max, x[-1]) ax1.set_ylabel(ylab) l = ax1.legend() ax1.spines['top'].set_visible(False) ax1.spines['right'].set_visible(False) # format the ticks ax1.xaxis.set_major_locator(major_locator) # ax1.xaxis.set_major_formatter(x_major_fmt) ax1.xaxis.set_minor_locator(minor_locator) # ax1.xaxis.set_minor_formatter(x_minor_fmt) #f.autofmt_xdate() ax2 = ax1.twinx() ax2.set_ylabel(ylab2) plt.setp(ax1.xaxis.get_majorticklabels(), rotation=0, horizontalalignment='center' ) plt.setp(ax1.xaxis.get_minorticklabels(), rotation=0, horizontalalignment='center', fontsize=9 ) #ax1.set_xlabel("Day of month") ax1.set_title(data['datetime'][0].astype(object).strftime("%b")) # Adjust x range x_min = 1 ax1.set_xlim(x_min, x_max) # Round the y axis similarly y_min, y_max = ax1.get_ylim() yt = ax1.get_yticks() ax1.set_ylim(yt[0], yt[-1]) # ax2 is empty, so the default y range is 0.0 to 1.0. # Set it to match such that the ticks line up: ax2.set_ylim(yt[0], yt[-1]) # Overwrite the tick decorator to convert C to F dynamically: ax2.yaxis.set_major_formatter(c2f_formatter) ax1.grid(b=True, which='major', color=(0.75,0.75,0.75), linestyle='-') ax1.grid(b=True, which='minor', color=(0.8,0.8,0.8), linestyle=':') #f.tight_layout() return f, ax1
ax.yaxis.set_major_formatter(ticker.ScalarFormatter()) ax.axhline(96**2, ls='--', c='blue') ax.axhline(32**2, ls='--', c='orange') plt.xticks(rotation=40, ha="right") # plt.legend(bbox_to_anchor=(1.01, 1), borderaxespad=0) plt.xlabel('Klasse') plt.ylabel('Fläche in Pixelanzahl') plt.savefig(os.path.join(output_directory, 'box_area.png'), bbox_inches='tight') # Seitenverhältnisse der Boxen plt.figure(figsize=(9,8)) ax = sns.boxenplot(data=object_dataframe, x='class', y='ratio') ax.set_yscale('log') # sns.move_legend(ax, loc='upper left', bbox_to_anchor=(1, 1)) locs = [0.3, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2, 2.5, 3, 3.5, 4, 4.5, 5] ax.yaxis.set_major_locator(ticker.FixedLocator(locs)) ax.yaxis.set_major_formatter(ticker.ScalarFormatter()) plt.xticks(rotation=40, ha="right") # plt.legend(bbox_to_anchor=(1.01, 1), borderaxespad=0) plt.xlabel('Klasse') plt.ylabel('Seitenverhältnis Weite / Höhe') plt.savefig(os.path.join(output_directory, 'box_ratio.png'), bbox_inches='tight') # Gewicht in Abhängigkeit von Anzahl der Objekte plt.figure(figsize=(8,8)) g = sns.catplot(data=file_dataframe, y='weight', x='objects', hue='objects', col='class', col_wrap=4, jitter=0.4, alpha=0.8) for ax in g.axes.flat: ax.yaxis.set_major_locator(ticker.MultipleLocator(500)) ax.yaxis.set_major_formatter(ticker.ScalarFormatter()) # sns.move_legend(ax, loc='upper left', bbox_to_anchor=(1, 1)) g.set_ylabels('Gewicht in Gramm', fontsize=15) # not set_label
def _plot_scalings_multiple( scalings, x_key, y_key, x_label, y_label, series_labels, title, ): # Wrap single instance in list if needed if isinstance(scalings, (pandas.DataFrame, TraceSet, MetricSet)): scalings = [scalings] # Make sure we are dealing with all pd.Dataframe scalings = [_get_dataframe(dataset) for dataset in scalings] # Sort out labels as needed if x_label is None: x_label = x_key if y_label is None: y_label = y_key if series_labels is None: if len(scalings) == 1: series_labels = [y_label] else: series_labels = range(len(scalings)) # Calculate x and y ranges cores_min = numpy.nan cores_max = numpy.nan y_max = numpy.nan for dataset in scalings: cores_min = numpy.nanmin([cores_min, dataset[x_key].min()]) cores_max = numpy.nanmax([cores_max, dataset[x_key].max()]) y_max = numpy.nanmax((y_max, dataset[y_key].max())) # And pad appropriately y_max *= 1.2 x_margin = 0.02 * cores_max # Calculate ideal scalings ideal_scaling_cores = numpy.linspace(cores_min - x_margin, cores_max + x_margin) ideal_scaling = ideal_scaling_cores / cores_min ideal_scaling_80pc = 0.2 + 0.8 * ideal_scaling # Finally, plot fig = plt.figure(figsize=figparams["single.figsize"]) ax = fig.add_axes(figparams["single.axlayout"][0]) ax.fill_between( ideal_scaling_cores, 0, ideal_scaling_80pc, label="80% Scaling", alpha=0.1, color="g", linestyle="-", ) ax.fill_between( ideal_scaling_cores, ideal_scaling_80pc, ideal_scaling, label="Ideal Scaling", alpha=0.2, color="g", linestyle="-", ) for dataset, label in zip(scalings, series_labels): ax.plot( dataset[x_key], dataset[y_key], label=label, marker="x", linestyle="-", alpha=0.8, ) ax.set_xlim(ideal_scaling_cores.min(), ideal_scaling_cores.max()) ax.set_ylim(0, y_max) ax.set_xlabel(x_label) ax.set_ylabel(y_label) ax.xaxis.set_major_locator(mtick.FixedLocator(scalings[0][x_key], 6)) ax.legend() if title: ax.set_title(title) return fig
def parallel_coordinates(df, target_column, lower_is_better=True, **kwds): minimum_target = df[target_column].min() maximum_target = df[target_column].max() # process target column for plotting target_colors = df[target_column] target_colors = np.true_divide(target_colors - target_colors.min(), np.ptp(target_colors)) if lower_is_better: target_colors = (target_colors - 1) * (-1) # sort df such that during plotting the better ones are drawn over the others df = df.sort_values(target_column, ascending=not lower_is_better) df = df.drop(columns=target_column) cols = df.columns x_ticks = list(range(len(cols))) # Create (X-1) sublots along x axis fig, axes = plt.subplots(1, len(x_ticks) - 1, sharey=False, figsize=(15, 5)) # handle case X-1 == 1, in which case axes is not a list if len(x_ticks) - 1 == 1: axes = [axes] # Get min, max and range for each column # Normalize the data for each column tick_dict = {} for col in cols: tick_dict[col] = {} if type(df[col] [0]) is str: # treat variables of type string as categorical df[col] = df[col].astype('category') codes = df[col].cat.codes.copy() codes = np.true_divide(codes - codes.min(), np.ptp(codes)) # Save the ticks and ticklabels # I assume that unique() returns the values in the order that they appear in the Series tick_dict[col]['ticks'] = codes.unique() tick_dict[col]['tick_labels'] = df[col].unique() # replace the categories with the computed codes df[col] = codes else: # not categorical tick_dict[col]['tick_labels'] = df[col].unique() df[col] = np.true_divide(df[col] - df[col].min(), np.ptp(df[col])) tick_dict[col]['ticks'] = df[col].unique() df[col] = df[col] + np.random.normal(size=len(df), scale=0.02) # Loop over horizontally stacked subplots for i, ax in enumerate(axes): # loop over lines for idx in df.index: y = target_colors[idx] ax.plot(x_ticks, df.loc[idx, cols], color=cm.viridis(y), linewidth=3) ax.set_xlim([x_ticks[i], x_ticks[i + 1]]) norm = mpl.colors.Normalize(vmin=minimum_target, vmax=maximum_target) cmap = mpl.cm.ScalarMappable( norm=norm, cmap=mpl.cm.viridis_r if lower_is_better else mpl.cm.viridis) cmap.set_array([]) fig.subplots_adjust(right=0.8) cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7]) fig.colorbar(cmap, cax=cbar_ax) # Set the tick positions and labels on y axis for each plot # Tick positions based on normalised data # Tick labels are based on original data for idx, ax in enumerate(axes): ax.yaxis.set_ticks(tick_dict[cols[idx]]['ticks']) ax.set_yticklabels(tick_dict[cols[idx]]['tick_labels']) ax.xaxis.set_major_locator(ticker.FixedLocator([idx])) ax.set_xticklabels([cols[idx]]) # Move the final axis' ticks to the right-hand side ax = plt.twinx(axes[-1]) idx = len(axes) ax.yaxis.set_ticks(tick_dict[cols[idx]]['ticks']) ax.set_yticklabels(tick_dict[cols[idx]]['tick_labels']) ax.xaxis.set_major_locator(ticker.FixedLocator([x_ticks[-2], x_ticks[-1]])) ax.set_xticklabels([cols[-2], cols[-1]]) # Remove space between subplots plt.subplots_adjust(wspace=0)
def __init__( self, ax, cmap=None, norm=None, alpha=None, values=None, boundaries=None, orientation='vertical', ticklocation='auto', extend='neither', spacing='uniform', # uniform or proportional ticks=None, format=None, drawedges=False, filled=True, extendfrac=None, extendrect=False, label='', ): #: The axes that this colorbar lives in. self.ax = ax self._patch_ax() if cmap is None: cmap = cm.get_cmap() if norm is None: norm = colors.Normalize() self.alpha = alpha cm.ScalarMappable.__init__(self, cmap=cmap, norm=norm) self.values = values self.boundaries = boundaries self.extend = extend self._inside = self._slice_dict[extend] self.spacing = spacing self.orientation = orientation self.drawedges = drawedges self.filled = filled self.extendfrac = extendfrac self.extendrect = extendrect self.solids = None self.lines = list() self.outline = None self.patch = None self.dividers = None if ticklocation == 'auto': ticklocation = 'bottom' if orientation == 'horizontal' else 'right' self.ticklocation = ticklocation self.set_label(label) if cbook.iterable(ticks): self.locator = ticker.FixedLocator(ticks, nbins=len(ticks)) else: self.locator = ticks # Handle default in _ticker() if format is None: if isinstance(self.norm, colors.LogNorm): self.formatter = ticker.LogFormatterSciNotation() elif isinstance(self.norm, colors.SymLogNorm): self.formatter = ticker.LogFormatterSciNotation( linthresh=self.norm.linthresh) else: self.formatter = ticker.ScalarFormatter() elif isinstance(format, six.string_types): self.formatter = ticker.FormatStrFormatter(format) else: self.formatter = format # Assume it is a Formatter # The rest is in a method so we can recalculate when clim changes. self.config_axis() self.draw_all()
def main(): for p_level in plot_levels: # Set pressure height contour min/max if p_level == 925: clev_min = 660. clev_max = 810. elif p_level == 850: clev_min = 1435. clev_max = 1530. elif p_level == 700: clev_min = 3090. clev_max = 3155. elif p_level == 500: clev_min = 5800. clev_max = 5890. else: print 'Contour min/max not set for this pressure level' # Set potential temperature min/max if p_level == 925: clevpt_min = 300. clevpt_max = 312. elif p_level == 850: clevpt_min = 302. clevpt_max = 310. elif p_level == 700: clevpt_min = 312. clevpt_max = 320. elif p_level == 500: clevpt_min = 325. clevpt_max = 332. else: print 'Potential temperature min/max not set for this pressure level' # Set specific humidity min/max if p_level == 925: clevsh_min = 0.012 clevsh_max = 0.020 elif p_level == 850: clevsh_min = 0.007 clevsh_max = 0.017 elif p_level == 700: clevsh_min = 0.002 clevsh_max = 0.010 elif p_level == 500: clevsh_min = 0.001 clevsh_max = 0.005 else: print 'Specific humidity min/max not set for this pressure level' #clevs_col = np.arange(clev_min, clev_max) clevs_lin = np.arange(clev_min, clev_max, 5) p_level_constraint = iris.Constraint(pressure=p_level) for plot_diag in plot_diags: for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] # For each day in cube height_pp_file = '%s_408_on_p_levs_mean_by_day.pp' % ( experiment_id) height_pfile = '%s%s/%s/%s' % (pp_file_path, expmin1, experiment_id, height_pp_file) cube = iris.load_cube(height_pfile, p_level_constraint) #print pcube #print height_cube time_coords = cube.coord('time') #add_hour_of_day(pcube, pcube.coord('time')) #add_hour_of_day(height_cube, height_cube.coord('time')) iris.coord_categorisation.add_day_of_year(cube, time_coords, name='day_of_year') #pcube.remove_coord('time') #cube_diff.remove_coord('time') #height_cube.remove_coord('time') #height_cube_diff.remove_coord('time') #p_cube_difference = iris.analysis.maths.subtract(pcube, cube_diff, dim='hour') #height_cube_difference = iris.analysis.maths.subtract(height_cube, height_cube_diff, dim='hour') #pdb.set_trace() #del height_cube, pcube, height_cube_diff, cube_diff for t, time_cube in enumerate( cube.slices(['grid_latitude', 'grid_longitude'])): #pdb.set_trace() # Get time of averagesfor plot title h = u.num2date( np.array(time_cube.coord('time').points, dtype=float)[0]).strftime('%d%b') #Convert to India time from_zone = tz.gettz('UTC') to_zone = tz.gettz('Asia/Kolkata') h_utc = u.num2date( np.array(time_cube.coord('day_of_year').points, dtype=float)[0]).replace(tzinfo=from_zone) h_local = h_utc.astimezone(to_zone).strftime('%H%M') fig = plt.figure(**figprops) cmap = plt.cm.RdBu_r ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low, lon_high, lat_low + degs_crop_bottom, lat_high - degs_crop_top)) m =\ Basemap(llcrnrlon=lon_low,llcrnrlat=lat_low,urcrnrlon=lon_high,urcrnrlat=lat_high, rsphere = 6371229) #pdb.set_trace() lat = cube.coord('grid_latitude').points lon = cube.coord('grid_longitude').points cs = cube.coord_system('CoordSystem') lons, lats = np.meshgrid(lon, lat) lons, lats = iris.analysis.cartography.unrotate_pole\ (lons,lats, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) x, y = m(lons, lats) # if plot_diag=='temp': # min_contour = clevpt_min # max_contour = clevpt_max # cb_label='K' # main_title='8km Explicit model (dklyu) minus 8km parametrised model geopotential height (grey contours), potential temperature (colours),\ # and wind (vectors) %s UTC %s IST' % (h, h_local) # tick_interval=2 # clev_number=max_contour-min_contour+1 # elif plot_diag=='sp_hum': # min_contour = clevsh_min # max_contour = clevsh_max # cb_label='kg/kg' # main_title='8km Explicit model (dklyu) minus 8km parametrised model geopotential height (grey contours), specific humidity (colours),\ # and wind (vectors) %s UTC %s IST' % (h, h_local) # tick_interval=0.002 # clev_number=max_contour-min_contour+0.001 # clevs = np.linspace(min_contour, max_contour, clev_number) # #clevs = np.linspace(-3, 3, 32) # cont = plt.contourf(x,y,time_cube.data, clevs, cmap=cmap, extend='both') #cont = iplt.contourf(time_cube, clevs, cmap=cmap, extend='both') cs_lin = iplt.contour(time_cube, clevs_lin, colors='#262626', linewidths=1.) plt.clabel(cs_lin, fontsize=14, fmt='%d', color='black') #del time_cube #plt.clabel(cont, fmt='%d') #ax.stock_img() ax.coastlines(resolution='110m', color='#262626') gl = ax.gridlines(draw_labels=True, linewidth=0.5, color='#262626', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_right = False #gl.xlines = False dx, dy = 10, 10 gl.xlocator = mticker.FixedLocator( range(int(lon_low_tick), int(lon_high_tick) + dx, dx)) gl.ylocator = mticker.FixedLocator( range(int(lat_low_tick), int(lat_high_tick) + dy, dy)) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 12, 'color': '#262626'} #gl.xlabel_style = {'color': '#262626', 'weight': 'bold'} gl.ylabel_style = {'size': 12, 'color': '#262626'} # cbar = fig.colorbar(cont, orientation='horizontal', pad=0.05, extend='both') # cbar.set_label('%s' % cb_label, fontsize=10, color='#262626') # #cbar.set_label(time_cube.units, fontsize=10, color='#262626') # cbar.set_ticks(np.arange(min_contour, max_contour+tick_interval,tick_interval)) # ticks = (np.arange(min_contour, max_contour+tick_interval,tick_interval)) # cbar.set_ticklabels(['${%.1f}$' % i for i in ticks]) # cbar.ax.tick_params(labelsize=10, color='#262626') #main_title='Mean Rainfall for EMBRACE Period -%s UTC (%s IST)' % (h, h_local) #main_title=time_cube.standard_name.title().replace('_',' ') #model_info = re.sub(r'[(\']', ' ', model_info) #model_info = re.sub(r'[\',)]', ' ', model_info) #print model_info file_save_name = '%s_%s_%s_hPa_and_geop_height_%s' % ( experiment_id, plot_diag, p_level, h) save_dir = '%s%s/%s' % (save_path, experiment_id, plot_diag) if not os.path.exists('%s' % save_dir): os.makedirs('%s' % (save_dir)) #plt.show() #fig.savefig('%s/%s_notitle.png' % (save_dir, file_save_name), format='png', bbox_inches='tight') plt.title('%s UTC' % (h)) fig.savefig('%s/%s_short_title.png' % (save_dir, file_save_name), format='png', bbox_inches='tight') #model_info=re.sub('(.{68} )', '\\1\n', str(model_name_convert_title.main(experiment_id)), 0, re.DOTALL) #plt.title('\n'.join(wrap('%s\n%s' % (main_title, model_info), 1000,replace_whitespace=False)), fontsize=16) #fig.savefig('%s/%s.png' % (save_dir, file_save_name), format='png', bbox_inches='tight') fig.clf() plt.close() #del time_cube gc.collect()
ax.set_yticklabels(['i', 't', 'c']) ax.xaxis.set_major_locator(plt.NullLocator()) belief_pack[0, 0] = 1.0 ax = plt.subplot(313) ax.set_yticks([0., 4., 8.]) cnt = plt.contourf(belief_time, torch.arange(pomdp.n_actions), adv_vals.T, 40) for c in cnt.collections: c.set_edgecolor("face") plt.step(belief_time, belief_actions, color='k') if colorbar: heatmap = plt.pcolor(belief_pack) cb = plt.colorbar(heatmap, aspect=colorbar_aspect) cb.set_label('Advantage values') tick_locator = ticker.FixedLocator([0.0, 0.5, 1.0]) cb.locator = tick_locator cb.update_ticks() ax.set_ylabel('Action') ax.set_xlabel('Time') plt.savefig('aloha_' + str(int(colorbar))) plt.show() # extra plot for heatmap plt.figure() heatmap = plt.pcolor(belief_pack) plt.gca().set_xlabel('time') cb = plt.colorbar(heatmap, aspect=25) tick_locator = ticker.FixedLocator([0.0, 0.5, 1.0])
def main(): def draw_screen_poly_iris( lats, lons): #x, y = m( lons, lats ) xy = zip(lons,lats) poly = Polygon( xy, edgecolor='#262626', facecolor='none', alpha=1, linewidth=2 ) if (plot_coords[2]=='Southern Indian Ocean'): poly = Polygon( xy, edgecolor='red', facecolor='none', alpha=0.4, linewidth=5, label=l+1 ) plt.gca().add_patch(poly) legendEntries.append(l+1) legendtext.append(plot_coords[2]) def label(lats, lons, text): #y = xy[1] - 0.15 # shift y-value for label so that it's below the artist lons_label = (np.max(lons)+np.min(lons)) / 2 lats_label = (np.max(lats) + np.min(lats)) / 2 x, y = (lons_label, lats_label ) #plt.text(x, y, text, color='#262626', ha="center", va="center", size=32, backgroundcolor='white', alpha=0.4 ) font0 = FontProperties() font0.set_family('sans-serif') plt.text(x, y, text, color='black', ha="center", va="center", size=64 , fontweight='bold', fontproperties=font0) if (plot_coords[2]=='Southern Indian Ocean'): plt.text(x, y, text, color='red', ha="center", va="center", size=64, fontproperties=font0) #experiment_ids = ['djzny', 'djzns', 'djznw', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq' ] #experiment_ids = ['djznq', 'djzny', 'djzns', 'djznu', 'dkbhu', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq', 'dkhgu'] experiment_ids = ['djznq' ] #experiment_ids = ['dkhgu','dkjxq'] # Bit above Western Ghats lats_1 = [20, 28, 28, 20] lons_1 = [67, 67, 71, 71] label_1 = 'Bit above Western Ghats' # Western Ghats #lats_2 = [8, 21, 21, 8] #lons_2 = [72, 72, 77, 77] #label_2 = 'Western Ghats' # Western Ghats lats_2 = [8.75, 22., 22., 8.75] lons_2 = [73.75, 70., 73.75, 77.75] label_2 = 'Western Ghats' # Bay of Bengal lats_3 = [10, 25, 25, 10] lons_3 = [80, 80, 100, 100] label_3 = 'Bay of Bengal' # Southern , western Indian Ocean lats_4 = [-10, 5, 5, -10] lons_4 = [64.12, 64.12, 80, 80] label_4 = 'Southern, western Indian Ocean' # Southern , western Indian Ocean lats_5 = [-10, 5, 5, -10] lons_5 = [80, 80, 101.87, 101.87] label_5 = 'Southern, eastern Indian Ocean' # Southern Indian Ocean lats_6 = [-10, 5, 5, -10] lons_6 = [64.12, 64.12, 101.87, 101.87] label_6 = 'Southern Indian Ocean' # Monsoon Trough lats_7 = [21., 16., 22., 27] lons_7 = [73., 83., 87., 75] label_7 = 'Monsoon Trough' # Himalayas lats_8 = [25.8, 26.3, 30., 30., 28.5, 27.8, 27.8, 25.8] lons_8 = [90., 83., 76.3, 82.7, 86.3, 90., 95., 95.] label_8 = 'Himalayas' #Ganga Basin lats_9 = [22, 27., 30., 26.2, 25.8, 22] lons_9 = [87, 75, 76.3, 83, 90., 90.] label_9 = 'Ganga Basin' lats_poly = lats_1, lats_2, lats_3, lats_4, lats_5, lats_6, lats_7, lats_8, lats_9 lons_poly = lons_1, lons_2, lons_3, lons_4, lons_5, lons_6, lons_7, lons_8, lons_9 labels = label_1, label_2, label_3, label_4, label_5, label_6, label_7, label_8, label_9 for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] pfile = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % (expmin1, experiment_id, pp_file) if (experiment_id=='djznq'): pfile = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/rain_mean.pp' % (expmin1, experiment_id) legendEntries=[] legendtext=[] #pc = iris(pfile) pcube = iris.load_cube(pfile) print pcube #print pc # Get min and max latitude/longitude and unrotate to get min/max corners to crop plot automatically - otherwise end with blank bits on the edges if (experiment_id=='djznq'): lats = pcube.coord('grid_latitude').points lons = pcube.coord('grid_longitude').points else: lats = pcube.coord('latitude').points lons = pcube.coord('longitude').points cs = pcube.coord_system('CoordSystem') if isinstance(cs, iris.coord_systems.RotatedGeogCS): print 'Rotated CS %s' % cs lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high)) lon_corner_u,lat_corner_u = unrotate.unrotate_pole(lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon_low = lon_corner_u[0,0] lon_high = lon_corner_u[0,1] lat_low = lat_corner_u[0,0] lat_high = lat_corner_u[1,0] else: lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) #lon_low= 62 #lon_high = 102 #lat_low = -7 #lat_high = 33 #lon_high_box = 101.866 #lon_low_box = 64.115 #lat_high_box = 33. #lat_low_box =-6.79 #lon_high = 101.866 #lon_low = 64.115 #lat_high = 33. #lat_low =-6.79 lon_low_tick=lon_low -(lon_low%divisor) lon_high_tick=math.ceil(lon_high/divisor)*divisor lat_low_tick=lat_low - (lat_low%divisor) lat_high_tick=math.ceil(lat_high/divisor)*divisor print lat_high_tick print lat_low_tick plt.figure(figsize=(8,8)) cmap=cm.s3pcpn_l ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low,lon_high,lat_low+degs_crop_bottom,lat_high-degs_crop_top)) #ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low,lon_high,lat_low,lat_high)) #ax = plt.axes(projection=ccrs.PlateCarree()) clevs = np.linspace(min_contour, max_contour,256) pcubeplot=iris.analysis.maths.multiply(pcube,3600) cont = iplt.contourf(pcubeplot, clevs, cmap=cmap, extend='both') #plt.clabel(cont, fmt='%d') #ax.stock_img() ax.coastlines(resolution='110m', color='#262626') gl = ax.gridlines(draw_labels=True,linewidth=0.5, color='#262626', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_right = False #gl.xlines = False dx, dy = 10, 10 gl.xlocator = mticker.FixedLocator(range(int(lon_low_tick),int(lon_high_tick)+dx,dx)) gl.ylocator = mticker.FixedLocator(range(int(lat_low_tick),int(lat_high_tick)+dy,dy)) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 12, 'color':'#262626'} #gl.xlabel_style = {'color': '#262626', 'weight': 'bold'} gl.ylabel_style = {'size': 12, 'color':'#262626'} cbar = plt.colorbar(cont, orientation='horizontal', pad=0.05, extend='both') cbar.set_label('mm/h', fontsize=10, color='#262626') #cbar.set_label(pcube.units, fontsize=10, color='#262626') cbar.set_ticks(np.arange(min_contour, max_contour+tick_interval,tick_interval)) ticks = (np.arange(min_contour, max_contour+tick_interval,tick_interval)) cbar.set_ticklabels(['%.1f' % i for i in ticks]) cbar.ax.tick_params(labelsize=10, color='#262626') main_title='Mean Rainfall for EMBRACE Period (smoothed to 24km)' #main_title=pcube.standard_name.title().replace('_',' ') model_info=re.sub('(.{68} )', '\\1\n', str(model_name_convert_title.main(experiment_id)), 0, re.DOTALL) #model_info = re.sub(r'[(\']', ' ', model_info) #model_info = re.sub(r'[\',)]', ' ', model_info) #print model_info for l,plot_coords in enumerate(zip(lats_poly,lons_poly, labels)): #colour = cmap(1.*(l*2)/(NUM_COLOURS*2)) draw_screen_poly_iris( plot_coords[0], plot_coords[1]) label(plot_coords[0], plot_coords[1], l+1) if not os.path.exists('%s%s/%s' % (save_path, experiment_id, pp_file)): os.makedirs('%s%s/%s' % (save_path, experiment_id, pp_file)) plt.savefig('%s%s/%s/%s_%s_area_boxes_notitle.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') plt.title('\n'.join(wrap('%s\n%s' % (main_title, model_info), 1000,replace_whitespace=False)), fontsize=16) #plt.show() plt.savefig('%s%s/%s/%s_%s_area_boxes.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') plt.close()
def __call__(self, field, ct=False, logscale=True, log=False, ax=None, bnds=[0, 360, -90, 90], title='', units='', cbfrac=0.11, projection_name='PlateCarree', **plt_kwargs): # Central longitude must be between -180 and 180 (greenwich meridian is 0) #lon_0 = (bnds[0] + bnds[1])/2 - 360 lon_0 = (bnds[0] + bnds[1]) / 2 #print('lon_0', lon_0) if projection_name == 'PlateCarree': proj = cart.crs.PlateCarree(central_longitude=lon_0) elif projection_name == 'Robinson': proj = cart.crs.Robinson(central_longitude=lon_0) elif projection_name == 'AlbersEqualArea': proj = cart.crs.AlbersEqualArea(central_longitude=lon_0) else: print('Projection name is invalid.') if projection_name == 'PlateCarree': proj2 = cart.crs.PlateCarree() elif projection_name == 'Robinson': proj2 = cart.crs.Robinson() elif projection_name == 'AlbersEqualArea': proj2 = cart.crs.AlbersEqualArea() else: print('Projection name is invalid.') if ax is None: fig, ax = plt.subplots(figsize=(12, 6)) #print(self.orig_grid.shape) #print(da.values.shape) #print(self.new_grid.shape) vmax = plt_kwargs.pop('vmax', field.max()) vmin = plt_kwargs.pop('vmin', field.min()) m = plt.axes(projection=proj) x, y = field.lon, field.lat #ax= plt.gca() pardiff = 30. merdiff = 60. if np.abs(bnds[1] - bnds[0]) < 180: merdiff = 30. #if np.abs(bnds[1] - bnds[0]) < 90: # merdiff = 15. #if np.abs(bnds[3]- bnds[2]) < 90: # pardiff = 15. par = np.arange(-90., 90. + pardiff, pardiff) mer = np.arange(-180., 180. + merdiff, merdiff) ax = plt.gca() ax.set_xticks(mer, crs=proj2) ax.set_yticks(par, crs=proj2) lon_formatter = LongitudeFormatter(zero_direction_label=True) lat_formatter = LatitudeFormatter() ax.xaxis.set_major_formatter(lon_formatter) ax.yaxis.set_major_formatter(lat_formatter) ax.get_yaxis().set_tick_params(direction='out') ax.get_xaxis().set_tick_params(direction='out') ax.set_extent((bnds[0], bnds[1], bnds[2], bnds[3]), crs=proj2) # Find index where data is splitted for mapping #split_lon_idx = round(x.shape[1]/(360/(lon_0 if lon_0>0 else lon_0+360))) #norm=LogNorm(vmin=vmin, vmax=vmax) lognorm = LogNorm(vmin=vmin, vmax=vmax) if log: p = m.pcolormesh(x, y, field, vmax=vmax, vmin=vmin, norm=lognorm, transform=proj2, zorder=1, **plt_kwargs) else: p = m.pcolormesh(x, y, field, vmax=vmax, vmin=vmin, transform=proj2, zorder=1, **plt_kwargs) #p = m.pcolormesh(x[:,split_lon_idx:], y[:,split_lon_idx:], field[:,split_lon_idx:], # vmax=vmax, vmin=vmin, transform=cart.crs.PlateCarree(), zorder=2, **plt_kwargs) if ct: ctstep = np.abs(vmax - vmin) / 20 ctlevels = np.arange(vmin, vmax + ctstep, ctstep) ct = plt.contour(x, y, field, colors='k', levels=ctlevels, linewidths=1, transform=proj2) if np.any(np.round(ct.levels, 5) == 0): ct.collections[np.where( np.round(ct.levels, 5) == 0)[0][0]].set_linewidth(0) #ax.clabel(ct, fontsize=9, inline=1, fmt='%1.1f') for line in ct.collections: if line.get_linestyle() != [(None, None)]: line.set_linestyle([(0, (8.0, 8.0))]) gl = ax.gridlines(crs=proj2, linewidth=0.5, color='black', alpha=0.6, linestyle='-.', zorder=10) gl.xlocator = mticker.FixedLocator(mer) gl.ylocator = mticker.FixedLocator(par) #ax.set_facecolor('grey') m.add_feature(cart.feature.LAND, edgecolor='k', facecolor='grey', zorder=3) #m.add_feature(cart.feature.COASTLINE,linewidth=0.5, zorder=15) plt.title(title) orient = 'vertical' if np.abs(bnds[1] - bnds[0]) > (np.abs(bnds[3] - bnds[2]) - 10): orient = 'horizontal' cb = plt.colorbar(p, label=units, fraction=cbfrac, pad=0.11, orientation=orient) #cb.set_ticks([-0.4,1.0,1.6,2.0]) #cb.ax.set_ticklabels([-0.4,1.0,1.6,2.0]) if logscale: if vmin >= 0: ticklabels = [vmin, 0.1, 1.0, vmax] else: #ticklabels = [vmin,-0.01,0,0.01,vmax] #ticklabels = [vmin,-0.1,0,0.1,vmax] ticklabels = [vmin, -0.1, 0, 0.1, vmax] #ticklabels = [vmin,-1.0,-0.1,0.1,1.0,vmax] cb.set_ticks(ticklabels) cb.ax.set_xticklabels(ticklabels) cb.ax.tick_params(labelsize=24) return m, ax
def parallel_coordinates(frame, class_column, cols=None, ax=None, color=None, use_columns=False, xticks=None, colormap=None, title = None, cblabel = None, savetitle = None, **kwds): import matplotlib.pyplot as plt import matplotlib as mpl from matplotlib import ticker from mpl_toolkits.axes_grid1 import make_axes_locatable n = len(frame) class_col = frame[class_column] class_min = np.amin(class_col) class_max = np.amax(class_col) if cols is None: df = frame.drop(class_column, axis=1) else: df = frame[cols] #used_legends = set([]) fig = plt.figure(1, figsize=(9,4.5)) ncols = len(df.columns) Colorm = plt.get_cmap(colormap) #gs0 = gridspec.GridSpec(1, 2, height_ratios=[1], # width_ratios=[0.9, 0.1],) #gs0.update(left=0.05, right=0.95, bottom=0.08, top=0.93, # wspace=0.0, hspace=0.03) #gs1 = GridSpec(3, 3) #gs1.update(left=0.05, right=0.48, wspace=0.05) #gs00 = gridspec.GridSpecFromSubplotSpec(3, 3, subplot_spec=gs0[0]) gs = gridspec.GridSpec(1,ncols - 1, height_ratios=[1], width_ratios=[1]*(ncols - 1)) gs.update(left=0.05, right=0.85, wspace=0.0) gs_cb = gridspec.GridSpec(1,1, height_ratios=[1], width_ratios=[1]) gs_cb.update(left=0.92, right=0.95) #fig, axes = plt.subplots(1, ncols - 1, sharey=False, figsize=(8,5)) x = [i for i, _ in enumerate(df.columns)] if title is not None: plt.suptitle(title, fontsize=16) min_max_range = {} cols = df.columns for col in cols: min_max_range[col] = [df[col].min(), df[col].max(), np.ptp(df[col])] df[col] = np.true_divide(df[col] - df[col].min(), np.ptp(df[col])) for i in range(ncols - 1): ax = plt.subplot(gs[0,i]) ax.set_ylim([-0.1,1.1]) for idx in df.index: kls = class_col.iat[idx] ax.plot(x, df.loc[idx, cols], linewidth=2, alpha = 0.5, color=Colorm((kls - class_min)/(class_max-class_min))) ax.set_xlim([x[i], x[i+1]]) ''' if i == (ncols - 1): ax = plt.twinx(ax) dim = ncols - 1 ax.xaxis.set_major_locator(ticker.FixedLocator([x[-2], x[-1]])) set_ticks_for_axis(dim, ax, min_max_range, df, cols, ticks=6) ax.set_xticklabels([cols[-2], cols[-1]]) ''' #print(gs.get_subplot_params()) for i in range(ncols - 1): ax = plt.subplot(gs[0,i]) #for i, ax in enumerate(axes): ax.xaxis.set_major_locator(ticker.FixedLocator([i])) set_ticks_for_axis(i, ax, min_max_range, df, cols, ticks=6) ax.set_xticklabels([cols[i]]) # Move the final axis' ticks to the right-hand side last_ax = plt.subplot(gs[0,ncols - 2]) ax = plt.twinx(last_ax) #ax.set_ylim([-0.1,1.1]) #ax = plt.twinx(axes[-1]) #dim = len(axes) dim = ncols - 1 ax.xaxis.set_major_locator(ticker.FixedLocator([x[-2], x[-1]])) set_ticks_for_axis(dim, ax, min_max_range, df, cols, ticks=6) ax.set_xticklabels([cols[-2], cols[-1]]) # Remove space between subplots #plt.subplots_adjust(right = 0.75) #a = twiny(ax) #print(ax.get_aspect()) #[0.85, 0.1, 0.03, 0.73] #divider = make_axes_locatable(axes) #cbaxes = divider.append_axes("right", size="5%", pad=0.45) #plt.colorbar(cax = cbaxes, cmap = Colorm) #cbaxes = fig.add_axes([0.85, 0.12, 0.03, 0.76]) #cb = plt.colorbar(ax1, cax = cbaxes) #divider = make_axes_locatable(ax) #cax = divider.append_axes("right", size="5%", pad=0.35) #cbar_ax = fig.add_axes([0.85, 0.0, 0.05, 0.8]) #ax = fig.add_subplot(231) bounds = np.linspace(class_min,class_max,10) #ax = plt.gca() #cax = plt.subplot(gs[0,ncols - 1]) cax = plt.subplot(gs_cb[0,0]) #pos1 = cax.get_position() #pos2 = [pos1.x0 + 0.1, pos1.y0, pos1.width, pos1.height] #cax.set_position(pos2) #cax,_ = mpl.colorbar.make_axes(ax) cb = mpl.colorbar.ColorbarBase(cax, cmap=Colorm, spacing='proportional', ticks=bounds, boundaries=bounds, format='%.2f', label = cblabel) #cb.set_label(cblabel) plt.gcf().subplots_adjust(right=0.15) #plt.tight_layout(h_pad = 2) if savetitle is not None: plt.savefig(savetitle, dpi=400, bbox_inches="tight") plt.show() return fig
y_wrd = y_wrd[::-1] xx_wrd, yy_wrd = np.meshgrid(x_wrd, y_wrd) ax = plt.axes(projection=ccrs.PlateCarree()) ax.pcolormesh(xx_wrd, yy_wrd, smap_9km_mean_1, transform=ccrs.PlateCarree()) gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=2, color='gray', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_left = False gl.xlines = False gl.xlocator = mticker.FixedLocator([-180, -45, 0, 45, 180]) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 15, 'color': 'gray'} gl.xlabel_style = {'color': 'red', 'weight': 'bold'} map_wrd_mesh = plt.pcolormesh(xx_wrd, yy_wrd, smap_9km_mean_1, vmin=0, vmax=0.5, cmap='gist_earth_r') # ax.set_extent(map_extent) ax.imshow(smap_9km_mean_1, origin='upper', transform=ccrs.PlateCarree(),
def __init__(self, axes, crs, draw_labels=False, xlocator=None, ylocator=None, collection_kwargs=None, xformatter=None, yformatter=None, dms=False, x_inline=None, y_inline=None, auto_inline=True, xlim=None, ylim=None, rotate_labels=None, xlabel_style=None, ylabel_style=None, labels_bbox_style=None, xpadding=5, ypadding=5, offset_angle=25, auto_update=False, formatter_kwargs=None): """ Object used by :meth:`cartopy.mpl.geoaxes.GeoAxes.gridlines` to add gridlines and tick labels to a map. Parameters ---------- axes The :class:`cartopy.mpl.geoaxes.GeoAxes` object to be drawn on. crs The :class:`cartopy.crs.CRS` defining the coordinate system that the gridlines are drawn in. draw_labels: optional Toggle whether to draw labels. For finer control, attributes of :class:`Gridliner` may be modified individually. Defaults to False. - string: "x" or "y" to only draw labels of the respective coordinate in the CRS. - list: Can contain the side identifiers and/or coordinate types to select which ones to draw. For all labels one would use `["x", "y", "top", "bottom", "left", "right", "geo"]`. - dict: The keys are the side identifiers ("top", "bottom", "left", "right") and the values are the coordinates ("x", "y"); this way you can precisely decide what kind of label to draw and where. For x labels on the bottom and y labels on the right you could pass in `{"bottom": "x", "left": "y"}`. Note that, by default, x and y labels are not drawn on left/right and top/bottom edges respectively, unless explicitly requested. xlocator: optional A :class:`matplotlib.ticker.Locator` instance which will be used to determine the locations of the gridlines in the x-coordinate of the given CRS. Defaults to None, which implies automatic locating of the gridlines. ylocator: optional A :class:`matplotlib.ticker.Locator` instance which will be used to determine the locations of the gridlines in the y-coordinate of the given CRS. Defaults to None, which implies automatic locating of the gridlines. xformatter: optional A :class:`matplotlib.ticker.Formatter` instance to format labels for x-coordinate gridlines. It defaults to None, which implies the use of a :class:`cartopy.mpl.ticker.LongitudeFormatter` initiated with the ``dms`` argument, if the crs is of :class:`~cartopy.crs.PlateCarree` type. yformatter: optional A :class:`matplotlib.ticker.Formatter` instance to format labels for y-coordinate gridlines. It defaults to None, which implies the use of a :class:`cartopy.mpl.ticker.LatitudeFormatter` initiated with the ``dms`` argument, if the crs is of :class:`~cartopy.crs.PlateCarree` type. collection_kwargs: optional Dictionary controlling line properties, passed to :class:`matplotlib.collections.Collection`. Defaults to None. dms: bool When default locators and formatters are used, ticks are able to stop on minutes and seconds if minutes is set to True, and not fraction of degrees. x_inline: optional Toggle whether the x labels drawn should be inline. y_inline: optional Toggle whether the y labels drawn should be inline. auto_inline: optional Set x_inline and y_inline automatically based on projection. xlim: optional Set a limit for the gridlines so that they do not go all the way to the edge of the boundary. xlim can be a single number or a (min, max) tuple. If a single number, the limits will be (-xlim, +xlim). ylim: optional Set a limit for the gridlines so that they do not go all the way to the edge of the boundary. ylim can be a single number or a (min, max) tuple. If a single number, the limits will be (-ylim, +ylim). rotate_labels: optional, bool, str Allow the rotation of non-inline labels. - False: Do not rotate the labels. - True: Rotate the labels parallel to the gridlines. - None: no rotation except for some projections (default). - A float: Rotate labels by this value in degrees. xlabel_style: dict A dictionary passed through to ``ax.text`` on x label creation for styling of the text labels. ylabel_style: dict A dictionary passed through to ``ax.text`` on y label creation for styling of the text labels. labels_bbox_style: dict bbox style for all text labels xpadding: float Padding for x labels. If negative, the labels are drawn inside the map. ypadding: float Padding for y labels. If negative, the labels are drawn inside the map. offset_angle: float Difference of angle in degrees from 90 to define when a label must be flipped to be more readable. For example, a value of 10 makes a vertical top label to be flipped only at 100 degrees. auto_update: bool Whether to redraw the gridlines and labels when the figure is updated. formatter_kwargs: dict, optional Options passed to the default formatters. See :class:`~cartopy.mpl.ticker.LongitudeFormatter` and :class:`~cartopy.mpl.ticker.LatitudeFormatter` Notes ----- The "x" and "y" labels for locators and formatters do not necessarily correspond to X and Y, but to the first and second coordinates of the specified CRS. For the common case of PlateCarree gridlines, these correspond to longitudes and latitudes. Depending on the projection used for the map, meridians and parallels can cross both the X axis and the Y axis. """ self.axes = axes #: The :class:`~matplotlib.ticker.Locator` to use for the x #: gridlines and labels. if xlocator is not None: if not isinstance(xlocator, mticker.Locator): xlocator = mticker.FixedLocator(xlocator) self.xlocator = xlocator elif isinstance(crs, PlateCarree): self.xlocator = LongitudeLocator(dms=dms) else: self.xlocator = classic_locator #: The :class:`~matplotlib.ticker.Locator` to use for the y #: gridlines and labels. if ylocator is not None: if not isinstance(ylocator, mticker.Locator): ylocator = mticker.FixedLocator(ylocator) self.ylocator = ylocator elif isinstance(crs, PlateCarree): self.ylocator = LatitudeLocator(dms=dms) else: self.ylocator = classic_locator formatter_kwargs = { **(formatter_kwargs or {}), "dms": dms, } if xformatter is None: if isinstance(crs, PlateCarree): xformatter = LongitudeFormatter(**formatter_kwargs) else: xformatter = classic_formatter() #: The :class:`~matplotlib.ticker.Formatter` to use for the lon labels. self.xformatter = xformatter if yformatter is None: if isinstance(crs, PlateCarree): yformatter = LatitudeFormatter(**formatter_kwargs) else: yformatter = classic_formatter() #: The :class:`~matplotlib.ticker.Formatter` to use for the lat labels. self.yformatter = yformatter # Draw label argument if isinstance(draw_labels, list): # Select to which coordinate it is applied if 'x' not in draw_labels and 'y' not in draw_labels: value = True elif 'x' in draw_labels and 'y' in draw_labels: value = ['x', 'y'] elif 'x' in draw_labels: value = 'x' else: value = 'y' #: Whether to draw labels on the top of the map. self.top_labels = value if 'top' in draw_labels else False #: Whether to draw labels on the bottom of the map. self.bottom_labels = value if 'bottom' in draw_labels else False #: Whether to draw labels on the left hand side of the map. self.left_labels = value if 'left' in draw_labels else False #: Whether to draw labels on the right hand side of the map. self.right_labels = value if 'right' in draw_labels else False #: Whether to draw labels near the geographic limits of the map. self.geo_labels = value if 'geo' in draw_labels else False elif isinstance(draw_labels, dict): self.top_labels = draw_labels.get('top', False) self.bottom_labels = draw_labels.get('bottom', False) self.left_labels = draw_labels.get('left', False) self.right_labels = draw_labels.get('right', False) self.geo_labels = draw_labels.get('geo', False) else: self.top_labels = draw_labels self.bottom_labels = draw_labels self.left_labels = draw_labels self.right_labels = draw_labels self.geo_labels = draw_labels for loc in 'top', 'bottom', 'left', 'right', 'geo': value = getattr(self, f'{loc}_labels') if isinstance(value, str): value = value.lower() if (not isinstance(value, (list, bool)) and value not in ('x', 'y')): raise ValueError(f"Invalid draw_labels argument: {value}") if auto_inline: if isinstance(self.axes.projection, _X_INLINE_PROJS): self.x_inline = True self.y_inline = False elif isinstance(self.axes.projection, _POLAR_PROJS): self.x_inline = False self.y_inline = True else: self.x_inline = False self.y_inline = False # overwrite auto_inline if necessary if x_inline is not None: #: Whether to draw x labels inline self.x_inline = x_inline elif not auto_inline: self.x_inline = False if y_inline is not None: #: Whether to draw y labels inline self.y_inline = y_inline elif not auto_inline: self.y_inline = False # Apply inline args if not draw_labels: self.inline_labels = False elif self.x_inline and self.y_inline: self.inline_labels = True elif self.x_inline: self.inline_labels = "x" elif self.y_inline: self.inline_labels = "y" else: self.inline_labels = False # Gridline limits so that the gridlines don't extend all the way # to the edge of the boundary self.xlim = xlim self.ylim = ylim #: Whether to draw the x gridlines. self.xlines = True #: Whether to draw the y gridlines. self.ylines = True #: A dictionary passed through to ``ax.text`` on x label creation #: for styling of the text labels. self.xlabel_style = xlabel_style or {} #: A dictionary passed through to ``ax.text`` on y label creation #: for styling of the text labels. self.ylabel_style = ylabel_style or {} #: bbox style for grid labels self.labels_bbox_style = ( labels_bbox_style or {'pad': 0, 'visible': False}) #: The padding from the map edge to the x labels in points. self.xpadding = xpadding #: The padding from the map edge to the y labels in points. self.ypadding = ypadding #: Control the rotation of labels. if rotate_labels is None: rotate_labels = ( self.axes.projection.__class__ in _ROTATE_LABEL_PROJS) if not isinstance(rotate_labels, (bool, float, int)): raise ValueError("Invalid rotate_labels argument") self.rotate_labels = rotate_labels self.offset_angle = offset_angle # Current transform self.crs = crs # if the user specifies tick labels at this point, check if they can # be drawn. The same check will take place at draw time in case # public attributes are changed after instantiation. if draw_labels and not (x_inline or y_inline or auto_inline): self._assert_can_draw_ticks() #: The number of interpolation points which are used to draw the #: gridlines. self.n_steps = 100 #: A dictionary passed through to #: ``matplotlib.collections.LineCollection`` on grid line creation. self.collection_kwargs = collection_kwargs #: The x gridlines which were created at draw time. self.xline_artists = [] #: The y gridlines which were created at draw time. self.yline_artists = [] # List of all labels (Label objects) self._labels = [] # Draw status self._drawn = False self._auto_update = auto_update # Check visibility of labels at each draw event # (or once drawn, only at resize event ?) self.axes.figure.canvas.mpl_connect('draw_event', self._draw_event)
def main(): #experiment_ids = ['djzns', 'djznq', 'djzny', 'djznw', 'dkhgu', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq','dkbhu' ] experiment_ids = ['djzny' ] for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] pfile = '/projects/cascade/pwille/moose_retrievals/%s/%s/%s.pp' % (expmin1, experiment_id, pp_file) #pc = iris(pfile) pcube = iris.load_cube(pfile) print pcube #print pc # Get min and max latitude/longitude and unrotate to get min/max corners to crop plot automatically - otherwise end with blank bits on the edges lats = pcube.coord('grid_latitude').points lons = pcube.coord('grid_longitude').points cs = pcube.coord_system('CoordSystem') if isinstance(cs, iris.coord_systems.RotatedGeogCS): print 'Rotated CS %s' % cs lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high)) lon_corner_u,lat_corner_u = unrotate.unrotate_pole(lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon_low = lon_corner_u[0,0] lon_high = lon_corner_u[0,1] lat_low = lat_corner_u[0,0] lat_high = lat_corner_u[1,0] else: lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_low_tick=lon_low -(lon_low%divisor) lon_high_tick=math.ceil(lon_high/divisor)*divisor lat_low_tick=lat_low - (lat_low%divisor) lat_high_tick=math.ceil(lat_high/divisor)*divisor print lat_high_tick print lat_low_tick plt.figure(figsize=(8,8)) cmap= cmap=plt.cm.RdBu_r ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low,lon_high,lat_low+degs_crop_bottom,lat_high-degs_crop_top)) clevs = np.linspace(min_contour, max_contour,256) cont = iplt.contourf(pcube, clevs, cmap=cmap, extend='both') #plt.clabel(cont, fmt='%d') #ax.stock_img() ax.coastlines(resolution='110m', color='#262626') gl = ax.gridlines(draw_labels=True,linewidth=0.5, color='#262626', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_right = True #gl.xlines = False dx, dy = 10, 10 gl.xlocator = mticker.FixedLocator(range(int(lon_low_tick),int(lon_high_tick)+dx,dx)) gl.ylocator = mticker.FixedLocator(range(int(lat_low_tick),int(lat_high_tick)+dy,dy)) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 12, 'color':'#262626'} #gl.xlabel_style = {'color': '#262626', 'weight': 'bold'} gl.ylabel_style = {'size': 12, 'color':'#262626'} cbar = plt.colorbar(cont, orientation='horizontal', pad=0.05, extend='both', format = '%d') #cbar.set_label('') cbar.set_label(pcube.units) cbar.set_ticks(np.arange(min_contour, max_contour+tick_interval,tick_interval)) ticks = (np.arange(min_contour, max_contour+tick_interval,tick_interval)) cbar.set_ticklabels(['%d' % i for i in ticks]) main_title=pcube.standard_name.title().replace('_',' ') model_info=re.sub('(.{75})', '\\1\n', str(model_name_convert_title.main(experiment_id)), 0, re.DOTALL) model_info = re.sub(r'[(\']', ' ', model_info) model_info = re.sub(r'[\',)]', ' ', model_info) print model_info plt.title('\n'.join(wrap('%s\n%s' % (main_title, model_info), 1000,replace_whitespace=False)), fontsize=12) plt.show() if not os.path.exists('/home/pwille/figures/%s/%s' % (experiment_id, plot_diag)): os.makedirs('/home/pwille/figures/%s/%s' % (experiment_id, plot_diag))
ds = (snm2 - snm1) * filter_coeff # Love numbers kn = pgfl.LoveNumbers(deg_max) # Legendre functions lf = pgfl.LegendreFunctions(deg_max) if __name__ == '__main__': # calculations w = ewh_calc() # Plot of result fig = plt.figure(figsize=[15, 8]) ax = plt.subplot(projection=ccrs.PlateCarree()) imgextend = [-180, 180, -90, 90] t = ax.imshow(w, origin='upper', extent=imgextend, transform=ccrs.PlateCarree(), cmap='RdBu') ax.coastlines('110m') # 50m is also available lonLabels = np.arange(-180, 181, 60) latLabels = np.arange(-90, 91, 30) gl = ax.gridlines(draw_labels=True, color='k', linewidth=1.5) gl.xlocator = mticker.FixedLocator(lonLabels) gl.ylocator = mticker.FixedLocator(latLabels) gl.xformatter = LongitudeFormatter() gl.yformatter = LatitudeFormatter() cbar = plt.colorbar(t) cbar.set_label('EWH / m', rotation=90) plt.show()
def plot_violins_multiwarp(depth_vals_global, dists, outer_all=None): data_epi = [] data_epi_nostack = [] data_fs5 = [] data_fs9 = [] data_stack = [] for dd in dists: d = str(dd) if outer_all == "outer": ####### Multiwarp-outer ########## data_epi.append(depth_vals_global[d + "_multiwarp-outer_epi"].flatten()) data_epi_nostack.append(depth_vals_global[d + "_multiwarp-outer_epi_without_disp_stack"].flatten()) data_fs5.append(depth_vals_global[d + "_multiwarp-outer_focalstack-17-5"].flatten()) data_fs9.append(depth_vals_global[d + "_multiwarp-outer_focalstack-17-9"].flatten()) data_stack.append(depth_vals_global[d + "_multiwarp-outer_stack"].flatten()) elif outer_all == "all": ####### Multiwarp-all ########## data_epi.append(depth_vals_global[d + "_multiwarp-all_epi"].flatten()) data_epi_nostack.append(depth_vals_global[d + "_multiwarp-all_epi_without_disp_stack"].flatten()) data_fs5.append(depth_vals_global[d + "_multiwarp-all_focalstack-17-5"].flatten()) data_fs9.append(depth_vals_global[d + "_multiwarp-all_focalstack-17-9"].flatten()) data_stack.append(depth_vals_global[d + "_multiwarp-all_stack"].flatten()) else: ####### Multiwarp-5 ########## data_epi.append(depth_vals_global[d + "_multiwarp-5_epi"].flatten()) data_epi_nostack.append(depth_vals_global[d + "_multiwarp-5_epi_without_disp_stack"].flatten()) data_fs5.append(depth_vals_global[d + "_multiwarp-5_focalstack-17-5"].flatten()) data_fs9.append(depth_vals_global[d + "_multiwarp-5_focalstack-17-9"].flatten()) data_stack.append(depth_vals_global[d + "_multiwarp-5_stack"].flatten()) plt.figure() xvals = np.linspace(1, 5, len(dists)) * 0.6 true_depth = np.array(dists).astype(np.float) / 1000.0 violin_width = 0.1 plt.violinplot(data_stack, positions=xvals - 0.2, showextrema=True, showmeans=True, widths=violin_width) plt.violinplot(data_fs5, positions=xvals - 0.1, showextrema=True, showmeans=True, widths=violin_width) plt.violinplot(data_fs9, positions=xvals, showextrema=True, showmeans=True, widths=violin_width) # plt.violinplot(data_epi, positions=xvals + 0.1, showextrema=True, showmeans=True, widths=violin_width) plt.violinplot(data_epi_nostack, positions=xvals + 0.2, showextrema=True, showmeans=True, widths=violin_width) plt.step(np.concatenate(([0], xvals))+0.3, np.concatenate(([0.4], true_depth)), 'k') # plt.xticks(xvals) # plt.xlim([0.3, 10.5]) # plt.ylim([0.3, 0.85]) ax = plt.gca() # Customize minor tick labels dists_str = ['0.4', '0.5', '0.6', '0.7', '0.8'] ax.xaxis.set_major_locator(ticker.FixedLocator(xvals)) # ax.xaxis.set_major_formatter(ticker.NullFormatter()) ax.xaxis.set_major_formatter(ticker.FixedFormatter(dists_str)) ax.xaxis.set_minor_locator(ticker.FixedLocator(xvals-0.3)) ax.tick_params(axis="x", labelsize=14) ax.tick_params(axis="y", labelsize=14) ax.tick_params(axis='x', which='minor', length=0) ax.tick_params(axis='x', which='major', length=0) plt.grid(axis='x', which='minor', linestyle='dashed') plt.title("Depth estimates in multi-warp reconstruction", fontsize=14) plt.xlabel("Distance of planar object from the EPIModule [m]", fontsize=14) plt.ylabel("Estimated distance [m]", fontsize=14) custom_patches = [Patch(facecolor='C0', edgecolor='None', label="volumetric stack"), Patch(facecolor='C1', edgecolor='None', label="focalstack-5"), Patch(facecolor='C2', edgecolor='None', label="focalstack-9"), # Patch(facecolor='C3', edgecolor='None', label="epi"), Patch(facecolor='C3', edgecolor='None', label="ours"), Line2D([0], [0], color='k', lw=2, label='Ground truth depth')] ax.legend(handles=custom_patches, loc='lower right')
fig = plt.figure() ax = fig.add_subplot( projection='aacgmv2',\ map_projection = cartopy.crs.NorthPolarStereo(),\ coords="aacgmv2_mlt", plot_date=plot_date ) # uncomment lines below to add coastlines and lakes individually # ax.coastlines() # ax.add_feature( cartopy.feature.LAKES) # or add coastlines and lakes together! ax.overaly_coast_lakes() # plot set the map bounds ax.set_extent([-180, 180, 50, 90], crs=cartopy.crs.PlateCarree()) # plot a random line! # ax.scatter(54, 60, transform=cartopy.crs.Geodetic()) ax.plot([-175, 175], [60, 60], transform=cartopy.crs.Geodetic()) # overaly gridlines! # the example here is for plotting gridlines plt_lons = numpy.arange(0, 361, 30) mark_lons = numpy.arange(0, 360, 30) plt_lats = numpy.arange(30, 90, 10) gl = ax.gridlines(crs=cartopy.crs.Geodetic(), linewidth=0.5) gl.xlocator = mticker.FixedLocator(plt_lons) gl.ylocator = mticker.FixedLocator(plt_lats) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.n_steps = 90 # mark the longitudes ax.mark_latitudes(plt_lats, fontsize=10) ax.mark_longitudes(lon_arr=mark_lons, fontsize=10) plt.savefig("test_plots/carto_test.png")
def PlotOneDiffMapsWInconclusives_ax(ax,Wmatrix,Vest,filename,titletext,showax=False,colors='no'): rc('text', usetex=True) rc('font', family='serif') N=len(Wmatrix) cmap1,vmin1,vmax1=maphatchBase2() cmap2,vmin2,vmax2=maphatch2() cmapc,vminc,vmaxc=map_w_inconclusives() Vtrue=np.zeros([N,N]) for i in range(N): for j in range(N): if Wmatrix[i,j]!=0: Vtrue[i,j]=1 diffmat=np.zeros([N,N]) for i in range(N): for j in range(N): if Vest[i,j]==0: if Vtrue[i,j]==0: diffmat[i,j]=0 if Vtrue[i,j]==1: diffmat[i,j]=2 if Vest[i,j]==1: if Vtrue[i,j]==0: diffmat[i,j]=3 if Vtrue[i,j]==1: diffmat[i,j]=1 if Vest[i,j]==-2: if Vtrue[i,j]==0: diffmat[i,j]=4 if Vtrue[i,j]==1: diffmat[i,j]=5 if colors=='no': ax.pcolor(diffmat, cmap=cmap1, vmin=vmin1, vmax=vmax1, edgecolors='black' ,hatch='///') ax.pcolor(diffmat, cmap=cmap2, vmin=vmin2, vmax=vmax2, edgecolors='black') else: ax.pcolor(diffmat, cmap=cmapc, vmin=0, vmax=vmaxc, edgecolors='black' ) if showax: ax.set_title(titletext,y=1.12) ax.set_ylabel("Presynaptic") ax.set_xlabel("Postsynaptic") ax.set(frame_on=False, aspect=1, xticks=range(1,N+1), yticks=range(1,N+1)) else: ax.set_title(titletext) ax.set(frame_on=False, aspect=1,xticks=[],yticks=[]) ax.invert_yaxis() if showax: ax.xaxis.set_label_position('top') ax.xaxis.tick_top() tickpos=list(np.array(range(N))+0.5) ticknames=[str(i) for i in range(1,N+1)] ax.tick_params(axis=u'both', which=u'both',length=0) ax.xaxis.set_major_formatter(ticker.NullFormatter()) ax.xaxis.set_minor_locator(ticker.FixedLocator(tickpos)) ax.xaxis.set_minor_formatter(ticker.FixedFormatter(ticknames)) ax.tick_params(axis=u'both', which=u'both',length=0) ax.yaxis.set_major_formatter(ticker.NullFormatter()) ax.yaxis.set_minor_locator(ticker.FixedLocator(tickpos)) ax.yaxis.set_minor_formatter(ticker.FixedFormatter(ticknames))
print(' -> Done!') ## ---- Station info ---- ## df = pd.read_excel(beachFile) ## ---- draw map ---- ## print('--- Now plot ---') fig = plt.figure(figsize=(7,5)) ax = fig.add_subplot(111, projection=ccrs.Mercator()) ax.set_extent([lonLims[0], lonLims[1], latLims[0], latLims[1]], crs=ccrs.PlateCarree()) ax.add_feature(cpf.NaturalEarthFeature('physical', 'coastline', '50m', edgecolor='k', alpha=0.7, linewidth=0.6, facecolor='black'), zorder=1) m=ax.gridlines(linewidth=0.5, color='black', draw_labels=True, alpha=0.5) m.xlabels_top=False m.ylabels_right=False m.xlocator = mticker.FixedLocator([-60, -58, -56, -54, -52]) m.ylocator = mticker.FixedLocator([46, 48, 50, 52, 54]) m.xformatter = LONGITUDE_FORMATTER m.yformatter = LATITUDE_FORMATTER m.ylabel_style = {'size': 7, 'color': 'black', 'weight':'bold'} m.xlabel_style = {'size': 7, 'color': 'black', 'weight':'bold'} lightdeep = cmocean.tools.lighten(cmo.deep, 0.5) c = plt.contourf(lon, lat, -Z, v, transform=ccrs.PlateCarree(), cmap=lightdeep, extend='max', zorder=5) cc = plt.contour(lon, lat, -Z, [100, 500], colors='silver', linewidths=.5, transform=ccrs.PlateCarree(), zorder=10) plt.clabel(cc, inline=True, fontsize=7, fmt='%i') # plot Beaches beach = df.Short_name.values lats = df.Lat.values lons = df.Long.values ax.plot(lons, lats, '.', color='magenta', transform=ccrs.PlateCarree(), markersize=13, zorder=10)
out = ax.plot(data1, data2, **param_dict) return out[0] fig = plt.gcf() ax1 = fig.add_subplot(1, 1, 1) show_time = [0, 250, 500, 750, 1000, 1250, 1500, 1686] x_time = np.array(range(records_npy.shape[0])) for i in range(records_npy.shape[1]): print(x_time, records_npy[:, i]) gen_artist( ax1, x_time, records_npy[:, i], {"label": 'DEVICE-' + ("2" if item_list[i] == "11" else item_list[i])}) ax1.legend(prop=font_en) ax1.xaxis.set_major_locator( ticker.FixedLocator(show_time) ) # https://matplotlib.org/api/ticker_api.html?highlight=multiplelocator ax1.xaxis.set_major_formatter( ticker.FixedFormatter([time_list[i][4:] for i in show_time])) for t in ax1.get_xticklabels(): t.set_fontproperties(font_en) t.set_rotation(30) for t in ax1.get_yticklabels(): t.set_fontproperties(font_en) for i in range(records_npy.shape[1]): ax1.text(1686, records_npy[-1, i], str(records_npy[-1, i]), fontproperties=font_en, horizontalalignment='right', verticalalignment='top')
def loss_fn(output, depth, mode, img=None): if mode == 'classification': depth_np = depth.cpu().numpy() label = np.digitize(np.clip(depth_np, 0, b), bins) label = torch.Tensor(label).long().cuda() C = output.size()[1] mask = (depth != 0.).cuda() mask = mask[:, None, :, :].repeat_interleave(C, dim=1) h = torch.arange(0., C).view(1, -1).cuda() information_gain = torch.exp(-0.5 * (h - h.T) ** 2) H = information_gain[label.view(-1), :].view(*label.size(), C).cuda() H = H.permute(0, 3, 1, 2)[mask] P = F.log_softmax(output, dim=1)[mask] return - torch.mean((H * P)) * C if mode in ['regression', 'reg_of_cls']: mask = (depth != 0).cuda() gt_mask = depth.clamp(0, b)[mask] pred_mask = output.clamp(1e-3, b).squeeze()[mask] # dlog = torch.log(gt_mask) - torch.log(pred_mask) # loss = torch.mean(dlog ** 2) - torch.mean(dlog) ** 2 if mode == 'regression': criterion = nn.MSELoss() return criterion(pred_mask, gt_mask) if mode == 'reg_of_cls': return torch.mean(torch.log(torch.cosh(pred_mask - gt_mask + 1e-12))) if mode[:4] == 'sord': mask = (depth != 0).cuda() gt = depth.clamp(0, b)[:, :, :, None] # phi = (torch.log(gt) - torch.log(torch.tensor(center).float().cuda()).view(1,1,1,-1))**2 phi = (gt - torch.tensor(center).float().cuda().view(1, 1, 1, -1)) ** 2 gt_sord = F.softmax(-phi, dim=3)[mask] log_p = F.log_softmax(output, dim=1).permute(0, 2, 3, 1)[mask] if VISUALIZE_sord: fig1 = plt.figure(0) plt.cla() axes = fig1.subplots(1, 2, sharex=True, sharey=True) axes[0].bar(center, gt_sord.detach().cpu().numpy()[0], width=np.diff(np.append(center, [80])) / 2, align='edge', color=cmap(np.arange(K).astype(float) / K)) axes[0].set_title('Ground-truth SORD of a pixel') axes[0].set_facecolor('black') axes[0].set_xscale('log') axes[0].set_xlim(0.5, 80) axes[0].set_ylim(0, 1) axes[0].xaxis.set_minor_locator(ticker.FixedLocator([1] + list(range(10, 81, 10)))) axes[0].xaxis.set_major_locator(ticker.NullLocator()) axes[0].xaxis.set_minor_formatter(ticker.ScalarFormatter()) axes[1].bar(center, np.exp(log_p.detach().cpu().numpy())[0], width=np.diff(np.append(center, [80])) / 2, align='edge', color=cmap(np.arange(K).astype(float) / K)) axes[1].set_title('Output of the same pixel') axes[1].set_facecolor('black') log_p_unmask = F.log_softmax(output, dim=1).permute(0, 2, 3, 1) p_unmask = F.softmax(output, dim=1).permute(0, 2, 3, 1) E = -1 / np.log2(output.shape[1]) * torch.sum((p_unmask * log_p_unmask), dim=3) pred_map = depth_inference(output.detach().cpu().numpy(), mode=mode) fig2 = plt.figure(1) plt.cla() axes = fig2.subplots(2, 2) axes[0,0].imshow(img[0].cpu().permute(1, 2, 0)) axes[0,0].set_title('RGB image') axes[0,1].imshow(depth[0].cpu().numpy(), cmap='jet') axes[0,1].set_title('depth map') axes[1,0].imshow(pred_map[0], cmap='jet') axes[1,0].set_title('predicted depth map') axes[1,1].imshow(E[0].detach().cpu().numpy(), cmap='jet') axes[1,1].set_title('pixel-wise entropy of predicted') plt.pause(0.1) plt.show() if mode == 'sord': # Normal KLDivergence loss criterion = nn.KLDivLoss(reduction='batchmean') return criterion(log_p, gt_sord) elif mode == 'sord_ent_weighted': # KLDivergence loss weighted according to ground truth depthmap local entropy ## entropy kernel 16x16 gt_entropy = torch.Tensor(local_entropy(depth.cpu().numpy(), kernel=16, mask=True)).cuda() if VISUALIZE_sord_ent_weighted: for i in range(output.size()[0]): fig = plt.figure(i) plt.cla() plt.axis('off') axes = fig.subplots(1, 3, sharex=True, sharey=True) axes[0].imshow(img[i].cpu().permute(1, 2, 0)) axes[0].set_title('RGB image') axes[1].imshow(depth[i].cpu().numpy(), cmap='jet') axes[1].set_title('Depth map (ground truth)') axes[2].imshow(gt_entropy[i].cpu().numpy(), cmap='gray') axes[2].set_title('Depth map Entropy') plt.pause(0.1) plt.show() gt_entropy_mask = gt_entropy[mask] ## linear # weight_by_entropy = torch.clamp(1 - gt_entropy_mask / 6, min=0) ## entropy kernel 16x16, divide by 6; entropy kernel 3x3, divide by 3 # weight_by_entropy = 1 - gt_entropy_mask / gt_entropy_mask.max() ## sigmoid weight_by_entropy = 1 - F.sigmoid(gt_entropy_mask) KLDiv = torch.sum(F.kl_div(log_p, gt_sord, reduction='none'), dim=1) return torch.sum(KLDiv * weight_by_entropy) / torch.sum(weight_by_entropy) elif mode == 'sord_min_local_ent': # Normal KLDivergence loss criterion = nn.KLDivLoss(reduction='batchmean') loss_sord = criterion(log_p, gt_sord) pred_map = depth_inference(output.detach().cpu().numpy(), mode=mode) # entropy of masked predicted depth map (could be wrong) pred_entropy = torch.Tensor(local_entropy(pred_map, kernel=16)).cuda() if VISUALIZE_sord_min_local_ent: for i in range(output.size()[0]): fig = plt.figure(i) plt.cla() plt.axis('off') axes = fig.subplots(2, 2, sharex=True, sharey=True) axes[0, 0].imshow(img[i].cpu().permute(1, 2, 0)) axes[0, 0].set_title('RGB image') axes[0, 1].imshow(depth[i].cpu().numpy(), cmap='jet') axes[0, 1].set_title('Depth map (ground truth)') axes[1, 0].imshow(pred_map[i], cmap='jet') axes[1, 0].set_title('Predicted depth map') axes[1, 1].imshow(pred_entropy[i].cpu().numpy(), cmap='gray') axes[1, 1].set_title('Predicted depth map Entropy') plt.pause(0.1) plt.show() loss_min_ent = torch.mean(pred_entropy) print('loss_sord', loss_sord, 'loss_min_ent', loss_min_ent) # return loss_sord + 0.1 * loss_min_ent return loss_sord + 1 * loss_min_ent # return loss_sord + F.sigmoid(loss_min_ent) * 2 - 1 ? elif mode == 'sord_weighted_minent': # compute loss_kl_weighted gt_entropy = torch.Tensor(local_entropy(depth.cpu().numpy(), kernel=16, mask=True)).cuda() gt_entropy_mask = gt_entropy[mask] ## linear # weight_by_entropy = torch.clamp(1 - gt_entropy_mask / 6, min=0) ## entropy kernel 16x16, divide by 6; entropy kernel 3x3, divide by 3 # weight_by_entropy = 1 - gt_entropy_mask / gt_entropy_mask.max() ## sigmoid weight_by_entropy = 1 - F.sigmoid(gt_entropy_mask) KLDiv = torch.sum(F.kl_div(log_p, gt_sord, reduction='none'), dim=1) loss_sord_weighted = torch.sum(KLDiv * weight_by_entropy) / torch.sum(weight_by_entropy) # compute loss_minEnt pred_map = depth_inference(output.detach().cpu().numpy(), mode=mode) # entropy of masked predicted depth map (could be wrong) pred_entropy = torch.Tensor(local_entropy(pred_map, kernel=16)).cuda() loss_min_ent = torch.mean(pred_entropy) print('loss_sord_weighted', loss_sord_weighted, 'loss_min_ent', loss_min_ent) return loss_sord_weighted + 1 * loss_min_ent elif mode == 'sord_align_grad': assert img is not None # Normal KLDivergence loss criterion = nn.KLDivLoss(reduction='batchmean') loss_sord = criterion(log_p, gt_sord) pred_map = depth_inference(output.detach().cpu().numpy(), mode=mode) img_edge = torch.Tensor(edge(img.cpu().numpy())).cuda() pred_edge = torch.Tensor(edge(pred_map)).cuda() if VISUALIZE_sord_align_grad: for i in range(output.size()[0]): fig = plt.figure(i) plt.cla() plt.axis('off') axes = fig.subplots(2, 2, sharex=True, sharey=True) axes[0, 0].imshow(img[i].cpu().permute(1, 2, 0)) axes[0, 0].set_title('RGB image') axes[0, 1].imshow(img_edge[i].cpu().numpy(), cmap='gray') axes[0, 1].set_title('RGB Edge') axes[1, 0].imshow(pred_map[i], cmap='jet') axes[1, 0].set_title('Predicted depth map') axes[1, 1].imshow(pred_edge[i].cpu().numpy(), cmap='gray') axes[1, 1].set_title('Predicted depth map Edge') plt.pause(0.1) plt.show() ## loss mean absolute error loss_align_grad = torch.mean(torch.abs(img_edge - pred_edge)) ## loss KLDivergence # loss_align_grad = F.kl_div(img_edge, pred_edge) ? ## with mask # img_edge_mask = img_edge[mask] # pred_edge_mask = pred_edge[mask] # loss_align_grad = torch.mean(torch.abs(img_edge_mask - pred_edge_mask)) print('loss_sord', loss_sord, 'loss_align_grad', loss_align_grad) return loss_sord + 0.1 * loss_align_grad
def plotCoordinatesPlot(Inputdata = "Clustereddata", X = None, labels = None, core_samples_mask = None, axis = [1,2]): print("- plotClustering") if (Inputdata == "Clustereddata"): df2 = rd.readClusteredDataDF() axis.append("Label") axis.append("Clustercore") df2 = df2[axis] else: X, labels = rd.readTransformedData() core_samples_mask = [0] * len(labels) df2 = df2.drop('Clustercore', axis = 'columns') df2[0] = df2['Label']+2 df2 = df2.drop('Label', axis = 'columns') df2 = df2.rename(columns={0:'Label'}) df = df2 # d = {'Label': [2,4,3,2,5,3], 1: [70,23,53,53,12,85], 2: [23,45,23,90,35,12] , 3: [12,34,15,23,56,23], 4: [223,423,125,125,125,522], 5: [2,3,2,3,4,5]} # df = pd.DataFrame(data=d) # df[1] = pd.to_numeric(df[1].replace('?', np.nan)) array_to_use = list(set(df['Label'])) array_to_use.insert(0, min(df['Label'])-1) df['Label'] = pd.cut(df['Label'],array_to_use) plt.figure() cols = list(x for x in df.columns) cols.remove("Label") x = [i for i, _ in enumerate(cols)] # colours = ['#2e8ad8', '#cd3785', '#c64c00', '#889a00'] # colours = ['red', 'blue', 'green', 'yellow', 'black'] # create dict of categories: colours colours = get_N_HexCol(len(df['Label'].cat.categories)) colours = {df['Label'].cat.categories[i]: colours[i] for i, _ in enumerate(df['Label'].cat.categories)} # Create (X-1) subplots along x axis fig, axes = plt.subplots(1, len(x) - 1, sharey=False, figsize=(15, 5)) # Get min, max and range for each column # Normalize the data for each column min_max_range = {} for col in cols: min_max_range[col] = [df[col].min(), df[col].max(), np.ptp(df[col])] ### Normalize on/off df[col] = np.true_divide(df[col] - df[col].min(), np.ptp(df[col])) # Plot each row if len(cols) == 2: for idx in df.index: Label_category = df.loc[idx, 'Label'] axes.plot(x, df.loc[idx, cols], colours[Label_category]) axes.set_xlim([x[0], x[0 + 1]]) else: for i, ax in enumerate(axes): for idx in df.index: Label_category = df.loc[idx, 'Label'] ax.plot(x, df.loc[idx, cols], colours[Label_category]) ax.set_xlim([x[i], x[i + 1]]) # Set the tick positions and labels on y axis for each plot # Tick positions based on normalised data # Tick labels are based on original data def set_ticks_for_axis(dim, ax, ticks): min_val, max_val, val_range = min_max_range[cols[dim]] step = val_range / float(ticks - 1) tick_labels = [round(min_val + step * i, 2) for i in range(ticks)] norm_min = df[cols[dim]].min() norm_range = np.ptp(df[cols[dim]]) norm_step = norm_range / float(ticks - 1) ticks = [round(norm_min + norm_step * i, 2) for i in range(ticks)] ax.yaxis.set_ticks(ticks) ax.set_yticklabels(tick_labels) if len(cols) == 2: axes.xaxis.set_major_locator(ticker.FixedLocator([0])) set_ticks_for_axis(0, axes, ticks=6) axes.set_xticklabels([cols[0]]) axes.xaxis.set_major_locator(ticker.FixedLocator([1])) set_ticks_for_axis(1, axes, ticks=6) axes.set_xticklabels([cols[1]]) else: for dim, ax in enumerate(axes): ax.xaxis.set_major_locator(ticker.FixedLocator([dim])) set_ticks_for_axis(dim, ax, ticks=6) ax.set_xticklabels([cols[dim]]) # Move the final axis' ticks to the right-hand side if not len(cols) == 2: ax = plt.twinx(axes[-1]) dim = len(axes) ax.xaxis.set_major_locator(ticker.FixedLocator([x[-2], x[-1]])) set_ticks_for_axis(dim, ax, ticks=6) ax.set_xticklabels([cols[-2], cols[-1]]) else: axes.xaxis.set_major_locator(ticker.FixedLocator([x[-2], x[-1]])) set_ticks_for_axis(1, axes, ticks=6) axes.set_xticklabels([cols[-2], cols[-1]]) # Remove space between subplots plt.subplots_adjust(wspace=0) legends = list(range(1,len(colours)+1)) # Add legend to plot plt.legend( [plt.Line2D((0, 1), (0, 0), color=colours[cat]) for cat in df['Label'].cat.categories], legends, bbox_to_anchor=(1.2, 1), loc=2, borderaxespad=-1.5) img = BytesIO() plt.savefig(img) # plt.show() img.seek(0) plt.close() return img
#### color bar and axis properties ### #cbar.ax.set_ylabel(text, rotation=270,labelpad=20,fontsize=10) cbar.ax.tick_params(labelsize=8) ax1.tick_params(axis='y', which='major', labelsize=8) ax1.tick_params(axis='x', which='major', labelsize=10) #### axis adjustments #### if yr_end - yr_start > 30: # reduces overcrowding of y-axis tick labels (less frequent ticks with longer data) ax1.locator_params(axis='y', nbins=(yr_end - yr_start) / 2, tight=True) #set number of y ticks else: ax1.locator_params(axis='y', nbins=(yr_end - yr_start), tight=True) #set number of y ticks ax1.xaxis.set_minor_locator( ticker.FixedLocator( [31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365])) ax1.xaxis.set_major_locator( ticker.FixedLocator( [15, 45, 74, 105, 135, 166, 196, 227, 258, 288, 319, 349])) ax1.set_xticklabels([ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]) ax1.xaxis.grid(b=True, which='minor', color='k', linestyle='--') ### set tick marks properties ax1.tick_params(which='minor', length=5, width=1.5) ax1.tick_params(axis='x', which='major', length=0, width=0) lala = ax1.yaxis.get_majorticklocs( ) # find the automatic tick mark locations
def plot_time_series_profile( t, z, d, filename='/Users/lederer/tmp/rompy.time_series_profile.png', clim=None, cmap='banas_hsv_cm', varname=None, title=None, caxis_label=None): fontsize = 8 cmap, sm, norm = make_cmap_sm_norm(d=d, clim=clim, cmap=cmap) fig = Figure(facecolor='white') ax1 = fig.add_axes([0.1, 0.55, 0.75, 0.32]) ax2 = fig.add_axes([0.1, 0.18, 0.75, 0.32]) cax = fig.add_axes([0.9, 0.18, 0.02, 0.69], frameon=False) my_plot11 = ax1.contourf(t, z, d, 100, norm=norm, cmap=cmap) my_plot12 = ax1.contour(t, z, d, 100, linewidths=1, linestyle=None, norm=norm, cmap=cmap) my_plot21 = ax2.contourf(t, z, d, 100, norm=norm, cmap=cmap) my_plot22 = ax2.contour(t, z, d, 100, linewidths=1, linestyle=None, norm=norm, cmap=cmap) my_colorbar = fig.colorbar(sm, cax=cax) if not caxis_label == None: my_colorbar.set_label(caxis_label) ax1.set_ylim(-20, 2) ax1.set_xlim(t[0][0], t[-1][-1]) # lets pick some x ticks that aren't stupid xmin_dt = dt.datetime.fromtimestamp(t[0][0]) xmax_dt = dt.datetime.fromtimestamp(t[-1][-1]) time_window = xmax_dt - xmin_dt if (time_window) < dt.timedelta(hours=48): date_list = [] next_time = xmax_dt - dt.timedelta(seconds=xmax_dt.minute * 60 + xmax_dt.second) while next_time >= xmin_dt: date_list.append(next_time) next_time = next_time - dt.timedelta(hours=6) elif (time_window) < dt.timedelta(days=8): date_list = [] next_time = xmax_dt - dt.timedelta( seconds=(xmax_dt.hour * 60 + xmax_dt.minute) * 60 + xmax_dt.second) while next_time >= xmin_dt: date_list.append(next_time) next_time = next_time - dt.timedelta(days=1) elif (time_window) < dt.timedelta(days=50): date_list = [] next_time = xmax_dt - dt.timedelta( seconds=(xmax_dt.hour * 60 + xmax_dt.minute) * 60 + xmax_dt.second) while next_time >= xmin_dt: date_list.append(next_time) next_time = next_time - dt.timedelta(days=7) else: date_list = [xmin_dt, xmax_dt] x_tick_list = [] for date in date_list: x_tick_list.append(time.mktime(date.timetuple())) ax2.xaxis.set_major_locator(ticker.FixedLocator(x_tick_list)) for yticklabel in ax1.get_yticklabels(): yticklabel.set_fontsize(fontsize) ax1.set_xticklabels('') ax2.set_xlim(t[0][0], t[-1][-1]) ax2.set_ylim(np.min(z[0, :]), np.max(z[-1, :])) for yticklabel in ax2.get_yticklabels(): yticklabel.set_fontsize(fontsize) locs = ax2.get_xticks() new_labels = [] ax2.xaxis.set_major_formatter(ticker.FuncFormatter(time_series_formatter)) for label in ax2.get_xticklabels(): label.set_ha('right') label.set_rotation(30) if title == None or title == '': ax1.set_title('%s Over Time at a Point' % map_varname(varname)) else: ax1.set_title(title) FigureCanvas(fig).print_png(filename)
def style_map(ax, plot_extent, add_grid=True, map_resolution=globals.naturalearth_resolution, add_topo=False, add_coastline=True, add_land=True, add_borders=True, add_us_states=False): ax.set_extent(plot_extent, crs=globals.data_crs) ax.outline_patch.set_linewidth(0.4) if add_grid: # add gridlines. Bcs a bug in cartopy, draw girdlines first and then grid labels. # https://github.com/SciTools/cartopy/issues/1342 try: grid_interval = max((plot_extent[1] - plot_extent[0]), (plot_extent[3] - plot_extent[2])) / 5 # create apprx. 5 gridlines in the bigger dimension if grid_interval <= min(globals.grid_intervals): raise RuntimeError grid_interval = min(globals.grid_intervals, key=lambda x: abs( x - grid_interval)) # select the grid spacing from the list which fits best gl = ax.gridlines(crs=globals.data_crs, draw_labels=False, linewidth=0.5, color='grey', linestyle='--', zorder=3) # draw only gridlines. # todo this can slow the plotting down!! xticks = np.arange(-180, 180.001, grid_interval) yticks = np.arange(-90, 90.001, grid_interval) gl.xlocator = mticker.FixedLocator(xticks) gl.ylocator = mticker.FixedLocator(yticks) except RuntimeError: pass else: try: # drawing labels fails for most projections gltext = ax.gridlines(crs=globals.data_crs, draw_labels=True, linewidth=0.5, color='grey', alpha=0., linestyle='-', zorder=4) # draw only grid labels. xticks = xticks[(xticks >= plot_extent[0]) & (xticks <= plot_extent[1])] yticks = yticks[(yticks >= plot_extent[2]) & (yticks <= plot_extent[3])] gltext.xformatter = LONGITUDE_FORMATTER gltext.yformatter = LATITUDE_FORMATTER gltext.top_labels = False gltext.left_labels = False gltext.xlocator = mticker.FixedLocator(xticks) gltext.ylocator = mticker.FixedLocator(yticks) except RuntimeError as e: print("No tick labels plotted.\n" + str(e)) if add_topo: ax.stock_img() if add_coastline: coastline = cfeature.NaturalEarthFeature('physical', 'coastline', map_resolution, edgecolor='black', facecolor='none') ax.add_feature(coastline, linewidth=0.4, zorder=3) if add_land: land = cfeature.NaturalEarthFeature('physical', 'land', map_resolution, edgecolor='none', facecolor='white') ax.add_feature(land, zorder=1) if add_borders: borders = cfeature.NaturalEarthFeature('cultural', 'admin_0_countries', map_resolution, edgecolor='black', facecolor='none') ax.add_feature(borders, linewidth=0.2, zorder=3) if add_us_states: ax.add_feature(cfeature.STATES, linewidth=0.1, zorder=3) return ax