def make_plot(crime_counts, crime, hood_map, df, title, label, filename): print "Making plot for " + str(crime) + " in Chicago 2016" number_of_crime = get_list_of_crime_counts(crime_counts, hood_map, crime) fig = plt.figure() fig.set_size_inches(18.5, 10.5, forward=True) ax = fig.add_subplot(111) mymap = getMap(df.crimes) mymap.drawmapboundary(fill_color='#46bcec') mymap.fillcontinents(color='#f2f2f2', lake_color='#46bcec') mymap.drawcoastlines() ax.set_title(title) cax = fig.add_axes([0.73, 0.1, 0.04, 0.8]) cmap = cm.get_cmap('YlOrRd') norm = Normalize(vmin=0, vmax=max(number_of_crime) + 0.15 * max(number_of_crime)) cb = ColorbarBase(cax, cmap=cmap, norm=norm) drawNeighborhoods(mymap, ax, hood_map, crime_counts, crime, cmap, norm) cb.set_label(label) oname = filename + ".png" onameref = filename + "_RefTowns.png" fig.savefig(oname, dpi=200) plt.sca(ax) drawRefPoints(mymap, refpoints) fig.savefig(onameref, dpi=200) print "Made " + oname print "Made " + onameref
def plot_colorbar(cax, cmap, hue_norm, cnorm=None, label=None, orientation='vertical', labelsize=4, linewidth=0.5): if isinstance(cmap, str): cmap = copy.copy(get_cmap(cmap)) if cnorm is None: cnorm = Normalize(vmin=hue_norm[0], vmax=hue_norm[1]) from .utilities import smart_number_format colorbar = ColorbarBase(cax, cmap=cmap, norm=cnorm, format=ticker.FuncFormatter(smart_number_format), orientation=orientation, extend='both') colorbar.locator = ticker.MaxNLocator(nbins=3) colorbar.update_ticks() colorbar.set_label(label, fontsize=labelsize) colorbar.outline.set_linewidth(linewidth) colorbar.ax.tick_params(size=labelsize, labelsize=labelsize, width=linewidth) return cax
def get_colorbar(self, title, label, min, max): '''Create a colorbar from given data. Returns a png image as a string.''' fig = pylab.figure(figsize=(2, 5)) ax = fig.add_axes([0.35, 0.03, 0.1, 0.9]) norm = self.get_norm(min, max) formatter = self.get_formatter() if formatter: cb1 = ColorbarBase(ax, norm=norm, format=formatter, spacing='proportional', orientation='vertical') else: cb1 = ColorbarBase(ax, norm=norm, spacing='proportional', orientation='vertical') cb1.set_label(label, color='1') ax.set_title(title, color='1') for tl in ax.get_yticklabels(): tl.set_color('1') im = cStringIO.StringIO() fig.savefig(im, dpi=300, format='png', transparent=True) pylab.close(fig) s = im.getvalue() im.close() return s
def error_plot(self, ax_lb, ax_ub, cax, cborientation='vertical'): # plot the error map ttP_lb = np.zeros((self.dims[1::])) ttP_ub = ttP_lb.copy() for _i1 in xrange(self.dims[1]): for _i2 in xrange(self.dims[2]): for _i3 in xrange(self.dims[3]): ttP_lb[_i1, _i2, _i3] = scoreatpercentile(self.ttP[:, _i1, _i2, _i3], 16) ttP_ub[_i1, _i2, _i3] = scoreatpercentile(self.ttP[:, _i1, _i2, _i3], 84) mlb = copy(self.m) mlb.ax = ax_lb mub = copy(self.m) mub.ax = ax_ub cmap = cm.get_cmap(self.cmapname) cmap.set_over('grey') mlb.contourf(self.x, self.y, ttP_lb[:, :, 0], cmap=cmap, levels=np.arange(self.vmin, self.vmax + 0.5, 0.5), norm=Normalize(vmin=self.vmin, vmax=self.vmax), extend=self.extend) mub.contourf(self.x, self.y, ttP_ub[:, :, 0], cmap=cmap, levels=np.arange(self.vmin, self.vmax + 0.5, 0.5), norm=Normalize(vmin=self.vmin, vmax=self.vmax), extend=self.extend) mlb.drawcoastlines(zorder=2) mlb.drawcountries(linewidth=1.0, zorder=2) mub.drawcoastlines(zorder=2) mub.drawcountries(linewidth=1.0, zorder=2) cb = ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=self.vmin, vmax=self.vmax), orientation=cborientation, extend=self.extend) cb.set_label(self.cb_label) return mlb, mub
def scale(args): """ Draws the variable scale that is placed over the map. Returns a BytesIO object. """ dataset_name = args.get("dataset") config = DatasetConfig(dataset_name) scale = args.get("scale") scale = [float(component) for component in scale.split(",")] variable = args.get("variable") variable = variable.split(",") if len(variable) > 1: variable_unit = config.variable[",".join(variable)].unit variable_name = config.variable[",".join(variable)].name else: variable_unit = config.variable[variable[0]].unit variable_name = config.variable[variable[0]].name cmap = colormap.find_colormap(variable_name) if len(variable) == 2: cmap = colormap.colormaps.get("speed") fig = plt.figure(figsize=(2, 5), dpi=75) ax = fig.add_axes([0.05, 0.05, 0.25, 0.9]) norm = matplotlib.colors.Normalize(vmin=scale[0], vmax=scale[1]) formatter = ScalarFormatter() formatter.set_powerlimits((-3, 4)) bar = ColorbarBase(ax, cmap=cmap, norm=norm, orientation="vertical", format=formatter) if variable_name == "Potential Sub Surface Channel": bar.set_ticks([0, 1], True) bar.set_label("%s (%s)" % (variable_name.title(), utils.mathtext(variable_unit)), fontsize=12) # Increase tick font size bar.ax.tick_params(labelsize=12) buf = BytesIO() plt.savefig( buf, format="png", dpi="figure", transparent=False, bbox_inches="tight", pad_inches=0.05, ) plt.close(fig) buf.seek(0) # Move buffer back to beginning return buf
def display_displacements(simulation_folder, lower_percentile=70, upper_percentile=99.7, save_plot = True, arrow_factor=4): """ show the total displacement field or the masked range of displacements by size simulation_folder: path to simulation folder lower_percentile and upper_percentile give range of deformationsize which is used as a mask save_plot: option to save the plot to the simulation folder arrow_factor: scales the arrow length in the plot To increase plotting speed you might increase the lower percentile (e.g 30 instead 0) """ # load in deformations and coordinates r = np.genfromtxt(os.path.join(simulation_folder, "R.dat")) # positions u = np.genfromtxt(os.path.join(simulation_folder, "Ufound.dat")) #deformations uabs = np.sqrt(np.sum(u ** 2., axis=1)) # absolute values for filtering # filter displacements by absolute size mask = (uabs > np.percentile(uabs, lower_percentile)) & (uabs < np.percentile(uabs, upper_percentile)) r2 = r[mask] u2 = u[mask] uabs2 = uabs[mask] # plot the masked deformation fig = plt.figure() ax1 = fig.gca(projection='3d', label='fitted-displ', rasterized=True) color_bounds1 = np.array([np.percentile(uabs2, 0), np.percentile(uabs2, 99.8)]) * 10 ** 6 np.random.seed(1234) for r2i, u2i, uabs2i in tqdm(zip(r2 * 10 ** 6, u2 * 10 ** 6, uabs2 * (10 ** 6))): # if np.random.uniform(0, 1) < 0.2: # uabs2i/u_upper: color = plt.cm.jet(((uabs2i - color_bounds1[0]) / (color_bounds1[1] - color_bounds1[0]))) alpha = 1. - (r2i[0] - r2i[1]) / (270. * 0.5) if alpha > 1: alpha = 1. if alpha < 0: alpha = 0. plt.quiver(r2i[0], r2i[1], r2i[2], u2i[0], u2i[1], u2i[2], length=uabs2i * arrow_factor , color=color, arrow_length_ratio=0, alpha=alpha, pivot='tip', linewidth=0.5) # plot colorbar --------------------------------------------------------- cbaxes = fig.add_axes([0.15, 0.1, 0.125, 0.010]) cmap = plt.cm.jet norm = plt.Normalize(vmin=color_bounds1[0], vmax=color_bounds1[1]) cb1 = ColorbarBase(cbaxes, cmap=cmap, norm=norm, orientation='horizontal') cb1.set_label('Displacements [µm]') tick_locator = ticker.MaxNLocator(nbins=3) cb1.locator = tick_locator cb1.update_ticks() ax1.w_xaxis.set_pane_color((0.2, 0.2, 0.2, 1.0)) ax1.w_yaxis.set_pane_color((0.2, 0.2, 0.2, 1.0)) ax1.w_zaxis.set_pane_color((0.2, 0.2, 0.2, 1.0)) if save_plot: plt.savefig( os.path.join(simulation_folder,'deformations_plot_lower_{}_upper_{}.png'.format(lower_percentile, upper_percentile)), dpi=500, bbox_inches="tight", pad_inches=0) return
def plotter(fdict): """ Go """ ctx = get_autoplot_context(fdict, get_description()) station = ctx['station'] days = ctx['days'] varname = ctx['var'] df = get_data(ctx) if df.empty: raise NoDataFound('Error, no results returned!') fig = plt.figure(figsize=(8, 6)) ax = fig.add_axes([0.1, 0.3, 0.75, 0.6]) lax = fig.add_axes([0.1, 0.1, 0.75, 0.2]) cax = fig.add_axes([0.87, 0.3, 0.03, 0.6]) title = PDICT.get(varname) if days == 1: title = title.replace("Average ", "") ax.set_title(("%s [%s]\n%i Day Period with %s" ) % (ctx['_nt'].sts[station]['name'], station, days, title)) cmap = plt.get_cmap(ctx['cmap']) minval = df[XREF[varname]].min() - 1. if varname == 'wettest' and minval < 0: minval = 0 maxval = df[XREF[varname]].max() + 1. ramp = np.linspace(minval, maxval, min([int(maxval - minval), 10]), dtype='i') norm = mpcolors.BoundaryNorm(ramp, cmap.N) cb = ColorbarBase(cax, norm=norm, cmap=cmap) cb.set_label("inch" if varname == 'wettest' else r"$^\circ$F") ax.barh(df.index.values, [days]*len(df.index), left=df['doy'].values, color=cmap(norm(df[XREF[varname]].values))) ax.grid(True) lax.grid(True) xticks = [] xticklabels = [] for i in np.arange(df['doy'].min() - 5, df['doy'].max() + 5, 1): ts = datetime.datetime(2000, 1, 1) + datetime.timedelta(days=int(i)) if ts.day == 1: xticks.append(i) xticklabels.append(ts.strftime("%-d %b")) ax.set_xticks(xticks) lax.set_xticks(xticks) lax.set_xticklabels(xticklabels) counts = np.zeros(366*2) for _, row in df.iterrows(): counts[int(row['doy']):int(row['doy'] + days)] += 1 lax.bar(np.arange(366*2), counts, edgecolor='blue', facecolor='blue') lax.set_ylabel("Years") lax.text(0.02, 0.9, "Frequency of Day\nwithin period", transform=lax.transAxes, va='top') ax.set_ylim(df.index.values.min() - 3, df.index.values.max() + 3) ax.set_xlim(df['doy'].min() - 10, df['doy'].max() + 10) lax.set_xlim(df['doy'].min() - 10, df['doy'].max() + 10) ax.yaxis.set_major_locator(MaxNLocator(prune='lower')) return fig, df
def scale(args): dataset_name = args.get('dataset') scale = args.get('scale') scale = [float(component) for component in scale.split(',')] variable = args.get('variable') if variable.endswith('_anom'): variable = variable[0:-5] anom = True else: anom = False variable = variable.split(',') with open_dataset(get_dataset_url(dataset_name)) as dataset: variable_unit = get_variable_unit(dataset_name, dataset.variables[variable[0]]) variable_name = get_variable_name(dataset_name, dataset.variables[variable[0]]) if variable_unit.startswith("Kelvin"): variable_unit = "Celsius" if anom: cmap = colormap.colormaps['anomaly'] variable_name = gettext("%s Anomaly") % variable_name else: cmap = colormap.find_colormap(variable_name) if len(variable) == 2: if not anom: cmap = colormap.colormaps.get('speed') variable_name = re.sub( r"(?i)( x | y |zonal |meridional |northward |eastward )", " ", variable_name) variable_name = re.sub(r" +", " ", variable_name) fig = plt.figure(figsize=(2, 5), dpi=75) ax = fig.add_axes([0.05, 0.05, 0.25, 0.9]) norm = matplotlib.colors.Normalize(vmin=scale[0], vmax=scale[1]) formatter = ScalarFormatter() formatter.set_powerlimits((-3, 4)) bar = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='vertical', format=formatter) bar.set_label("%s (%s)" % (variable_name.title(), utils.mathtext(variable_unit))) buf = StringIO() try: plt.savefig(buf, format='png', dpi='figure', transparent=False, bbox_inches='tight', pad_inches=0.05) plt.close(fig) return buf.getvalue() finally: buf.close()
def MakeReflectColorbar(ax=None, colorbarLabel="Reflectivity [dBZ]", **kwargs): # Probably need a smarter way to allow fine-grained control of properties # like fontsize and such... if ax is None: ax = plt.gca() cbar = ColorbarBase(ax, cmap=NWS_Reflect["ref_table"], norm=NWS_Reflect["norm"], **kwargs) cbar.set_label(colorbarLabel) return cbar
def create_colorbar(cmap, norm, title=None): # Make a figure and axes with dimensions as desired. fig = Figure(figsize=(4,0.2)) canvas = FigureCanvasAgg(fig) ax = fig.add_axes([0.005, 0.1, 0.985, 0.85]) cb = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='horizontal', format=NullFormatter(), ticks=NullLocator() ) if title: cb.set_label(title, fontsize=12) fig.savefig('/home/dotcloud/data/media/plot/colorbar.png', format='png', transparent=True)
def plot(countries, values, label='', clim=None, verbose=False): """ Usage: worldmap.plot(countries, values [, label] [, clim]) """ countries_shp = shpreader.natural_earth(resolution='110m', category='cultural', name='admin_0_countries') ## Create a plot fig = plt.figure() ax = plt.axes(projection=ccrs.PlateCarree()) ## Create a colormap cmap = plt.get_cmap('RdYlGn_r') if clim: vmin = clim[0] vmax = clim[1] else: val = values[np.isfinite(values)] mean = val.mean() std = val.std() vmin = mean - 2 * std vmax = mean + 2 * std norm = Normalize(vmin=vmin, vmax=vmax) smap = ScalarMappable(norm=norm, cmap=cmap) ax2 = fig.add_axes([0.3, 0.18, 0.4, 0.03]) cbar = ColorbarBase(ax2, cmap=cmap, norm=norm, orientation='horizontal') cbar.set_label(label) ## Add countries to the map for country in shpreader.Reader(countries_shp).records(): countrycode = country.attributes['adm0_a3'] countryname = country.attributes['name_long'] ## Check for country code consistency if countrycode == 'SDS': #South Sudan countrycode = 'SSD' elif countrycode == 'ROU': #Romania countrycode = 'ROM' elif countrycode == 'COD': #Dem. Rep. Congo countrycode = 'ZAR' elif countrycode == 'KOS': #Kosovo countrycode = 'KSV' if countrycode in countries: val = values[countries == countrycode] if np.isfinite(val): color = smap.to_rgba(val) else: color = 'grey' else: color = 'w' if verbose: print("No data available for " + countrycode + ": " + countryname) ax.add_geometries(country.geometry, ccrs.PlateCarree(), facecolor=color, label=countryname) plt.show()
def MakeReflectColorbar(ax=None, colorbarLabel="Reflectivity [dBZ]", **kwargs): # Probably need a smarter way to allow fine-grained control of properties # like fontsize and such... if ax is None: ax = plt.gca() cbar = ColorbarBase(ax, cmap=NWS_Reflect['ref_table'], norm=NWS_Reflect['norm'], **kwargs) cbar.set_label(colorbarLabel) return cbar
def scale(args): dataset_name = args.get('dataset') config = DatasetConfig(dataset_name) scale = args.get('scale') scale = [float(component) for component in scale.split(',')] variable = args.get('variable') variable = variable.split(',') with open_dataset(config) as dataset: if len(variable) > 1: variable_unit = config.variable[",".join(variable)].unit variable_name = config.variable[",".join(variable)].name else: variable_unit = config.variable[dataset.variables[ variable[0]]].unit variable_name = config.variable[dataset.variables[ variable[0]]].name cmap = colormap.find_colormap(variable_name) if len(variable) == 2: cmap = colormap.colormaps.get('speed') fig = plt.figure(figsize=(2, 5), dpi=75) ax = fig.add_axes([0.05, 0.05, 0.25, 0.9]) norm = matplotlib.colors.Normalize(vmin=scale[0], vmax=scale[1]) formatter = ScalarFormatter() formatter.set_powerlimits((-3, 4)) bar = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='vertical', format=formatter) bar.set_label("%s (%s)" % (variable_name.title(), utils.mathtext(variable_unit)), fontsize=12) # Increase tick font size bar.ax.tick_params(labelsize=12) buf = BytesIO() plt.savefig(buf, format='png', dpi='figure', transparent=False, bbox_inches='tight', pad_inches=0.05) plt.close(fig) buf.seek(0) # Move buffer back to beginning return buf
def update(frame): arr = var.isel({anim_dim: frame}).data ax.pcolor(lon, lat, arr, transform=proj, **kwargs) if add_title: ax.set_title(_title_creation(data, {**indexes, anim_dim: frame})) if add_cbar: cax.clear() cbar = ColorbarBase(cax, boundaries=np.unique( arr[~np.isnan(arr)]).flatten(), **kwargs) cbar.set_label(wrap("{} ({})".format(name, var.attrs.get('units'))))
def swarmplot_with_cbar(cmap, cbar_label, *args, **kwargs): fig = plt.gcf() ax = sns.swarmplot(*args, **kwargs) # remove the legend, because we want to set a colorbar instead ax.legend().remove() ## create colorbar ## divider = make_axes_locatable(ax) ax_cb = divider.new_horizontal(size="3%", pad=0.05) fig.add_axes(ax_cb) cb = ColorbarBase(ax_cb, cmap=cmap, orientation='vertical') cb.set_label(cbar_label, labelpad=10) return fig
def _scatter_legends(df, ax, fig, cmap, ck, ondata: bool, onside: bool, fontsize: float, n_per_col: int, scale: float, ls: float, cs: float) -> None: from matplotlib.colors import Normalize from matplotlib.colorbar import ColorbarBase x, y, vc = df.columns[:3] v = df[vc] if v.nunique() <= 1: return None if v.dtype.name == 'category': centers = df[[x, y, vc]].groupby(vc).median().T for i in centers: if ondata: ax.text(centers[i][x], centers[i][y], i, fontsize=fontsize, ha='center', va='center') if onside: ax.scatter([float(centers[i][x])], [float(centers[i][y])], c=ck[i], label=i, alpha=1, s=0.01) if onside: n_cols = v.nunique() // n_per_col if v.nunique() % n_per_col > 0: n_cols += 1 ax.legend(ncol=n_cols, loc=(1, 0), frameon=False, fontsize=fontsize, markerscale=scale, labelspacing=ls, columnspacing=cs) else: if fig is not None: cbaxes = fig.add_axes([0.2, 1, 0.6, 0.05]) norm = Normalize(vmin=v.min(), vmax=v.max()) cb = ColorbarBase(cbaxes, cmap=cmap, norm=norm, orientation='horizontal') cb.set_label(vc, fontsize=fontsize) cb.ax.xaxis.set_label_position('top') else: logger.warning( "Not plotting the colorbar because fig object was not passed") return None
def plot(countries,values,label='',clim=None,verbose=False): """ Usage: worldmap.plot(countries, values [, label] [, clim]) """ countries_shp = shpreader.natural_earth(resolution='110m',category='cultural', name='admin_0_countries') ## Create a plot fig = plt.figure() ax = plt.axes(projection=ccrs.PlateCarree()) ## Create a colormap cmap = plt.get_cmap('RdYlGn_r') if clim: vmin = clim[0] vmax = clim[1] else: val = values[np.isfinite(values)] mean = val.mean() std = val.std() vmin = mean-2*std vmax = mean+2*std norm = Normalize(vmin=vmin,vmax=vmax) smap = ScalarMappable(norm=norm,cmap=cmap) ax2 = fig.add_axes([0.3, 0.18, 0.4, 0.03]) cbar = ColorbarBase(ax2,cmap=cmap,norm=norm,orientation='horizontal') cbar.set_label(label) ## Add countries to the map for country in shpreader.Reader(countries_shp).records(): countrycode = country.attributes['adm0_a3'] countryname = country.attributes['name_long'] ## Check for country code consistency if countrycode == 'SDS': #South Sudan countrycode = 'SSD' elif countrycode == 'ROU': #Romania countrycode = 'ROM' elif countrycode == 'COD': #Dem. Rep. Congo countrycode = 'ZAR' elif countrycode == 'KOS': #Kosovo countrycode = 'KSV' if countrycode in countries: val = values[countries==countrycode] if np.isfinite(val): color = smap.to_rgba(val) else: color = 'grey' else: color = 'w' if verbose: print("No data available for "+countrycode+": "+countryname) ax.add_geometries(country.geometry,ccrs.PlateCarree(),facecolor=color,label=countryname) plt.show()
def create_colorbar(cmap, norm, title=None): # Make a figure and axes with dimensions as desired. fig = Figure(figsize=(4, 0.2)) canvas = FigureCanvasAgg(fig) ax = fig.add_axes([0.005, 0.1, 0.985, 0.85]) cb = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='horizontal', format=NullFormatter(), ticks=NullLocator()) if title: cb.set_label(title, fontsize=12) fig.savefig('/home/dotcloud/data/media/plot/colorbar.png', format='png', transparent=True)
def show_colormap(base): """Display a colormap. **Argument:** *base* The name of a base colormap or a `ColormapBase` instance to plot. """ import matplotlib.pyplot as plt from matplotlib.colorbar import ColorbarBase try: base = get_colormap_base(base) except ValueError: pass cmap = create_colormap(base.ncolors, base=base.name) fig = plt.figure(figsize=(9, .7)) ax = fig.add_axes([.01, .35, .98, .63]) cb = ColorbarBase(ax, cmap=cmap, orientation='horizontal', ticks=[]) cb.set_label('{:s}: {:d} colors'.format(base.name, base.ncolors)) plt.show()
def get_colorbar(self,title,label,min,max): '''Create a colorbar from given data. Returns a png image as a string.''' fig=pylab.figure(figsize=(2,5)) ax=fig.add_axes([0.35,0.03,0.1,0.9]) norm=self.get_norm(min,max) formatter=self.get_formatter() if formatter: cb1 = ColorbarBase(ax,norm=norm,format=formatter,spacing='proportional',orientation='vertical') else: cb1 = ColorbarBase(ax,norm=norm,spacing='proportional',orientation='vertical') cb1.set_label(label,color='1') ax.set_title(title,color='1') for tl in ax.get_yticklabels(): tl.set_color('1') im=cStringIO.StringIO() fig.savefig(im,dpi=300,format='png',transparent=True) pylab.close(fig) s=im.getvalue() im.close() return s
axpbar = plt.axes([0, 0, 101, 101], zorder=2) axpbar.spines['bottom'].set_color('w') axpbar.spines['top'].set_color('w') axpbar.spines['left'].set_color('w') axpbar.spines['right'].set_color('w') axpbar.tick_params(axis='x', colors='w') axpbar.tick_params(axis='y', colors='w') axpbar.set_axes_locator(InsetPosition(ax1, [0.45, 0.91, 0.45, 0.05])) cb1 = ColorbarBase(axpbar, cmap=cmap, norm=cnorm, orientation='horizontal', ticks=[0.0, 0.25, 0.5, 0.75, 1.0]) cb1.outline.set_edgecolor('w') cb1.set_label(r'$\Delta^{op}$ (arb.)', color='w') ax2.plot(spectrum[:, 0], spectrum[:, 1] / np.max(spectrum[:, 1]), '-k') xs = np.linspace(np.min(l0), np.max(l0), 400) norm = w[wi] * np.sqrt(2 * np.pi) for j in range(npeaks): ax2.plot(xs, norm * gauss(xs, w[wi], peak[j][wi, 1] - peak[j][wi, 2] / 2), color='C' + str(j)) ax2.plot(xs, norm * gauss(xs, w[wi], peak[j][wi, 1] + peak[j][wi, 2] / 2), color='C' + str(j)) ax2.text(peak[j][wi, 1] - peak[j][wi, 2] / 2, 1.12, r'$\lambda_0 = $' + str(peak[j][wi, 1]) + ' nm',
def create_shot_chart(made_shots, missed_shots, filename, title, plot_type='hexbin', hex_size=2, **kwargs): made_x = np.array([shot.shot_x for shot in made_shots]) made_y = np.array([shot.shot_y for shot in made_shots]) missed_x = np.array([shot.shot_x for shot in missed_shots]) missed_y = np.array([shot.shot_y for shot in missed_shots]) num_made = float(len(made_shots)) num_missed = float(len(missed_shots)) frac_made = 100 * (num_made / (num_made + num_missed)) frac_missed = 100 - frac_made shot_distances_made = [euclidean(shot.shot_x, shot.shot_y) for shot in made_shots] shot_distances_missed = [euclidean(shot.shot_x, shot.shot_y) for shot in missed_shots] bins = np.linspace(0, 50, 26) frac_made_arr = np.zeros(len(bins)) shots_taken = np.zeros(len(bins)) for i, bin in enumerate(bins[:-1]): bin_made = [loc for loc in shot_distances_made if loc > bin and loc < bins[i + 1]] bin_missed = [loc for loc in shot_distances_missed if loc > bin and loc < bins[i + 1]] if len(bin_made) != 0 and len(bin_missed) != 0: frac_made_arr[i] = (float(len(bin_made)) / float(len(bin_made) + len(bin_missed))) shots_taken[i] = len(bin_made) + len(bin_missed) if plot_type == 'distance': mpl.clf() ax1 = mpl.subplot(111) # l1 = ax1.plot(bins, frac_made_arr * 100, 'go-', label='% made') ax2 = ax1.twinx() # l2 = ax2.plot(bins, shots_taken, 'rs-', label='shots taken') smooth_x = np.linspace(0, 40, 300) smooth_made = spline(bins, frac_made_arr * 100, smooth_x) smooth_taken = spline(bins, shots_taken, smooth_x) l1 = ax1.plot(smooth_x, smooth_made, 'g-', label='% made') l2 = ax2.plot(smooth_x, smooth_taken, 'r-', label='# shots taken') ax1.set_xlabel('Distance from basket') ax1.set_ylabel('Percentage made') ax2.set_ylabel('Number of shots taken') lns = l1 + l2 labels = [l.get_label() for l in lns] ax1.set_xlim(0, 40) ax2.set_ylim(0, 40) mpl.title(title) mpl.legend(lns, labels) ax1.grid(True) if plot_type == 'hexbin' or plot_type == 'hexbin_contour': return_cells = False if 'return_cells' in kwargs: return_cells = kwargs['return_cells'] hexes = create_hexes(hex_size) fig = mpl.figure() gs = gridspec.GridSpec(1, 2, width_ratios=[1, 10]) ax_cb = mpl.subplot(gs[0,0]) ax = mpl.subplot(gs[0,1]) draw_court(ax) for x, y in zip(made_x, made_y): cell = find_hex_from_xy(hexes, x, y, s=hex_size) if cell is not None: if is_shot_three(x, y): #print x, y, euclidean((x, y), (0, 0)) cell['threes'] += 1 cell['made'] += 1 else: ## this should never happen print 'made shot not in cell: ({}, {})'.format(x, y) for x, y in zip(missed_x, missed_y): cell = find_hex_from_xy(hexes, x, y, s=hex_size) if cell is not None: #if is_shot_three(x, y): # print x, y, euclidean((x, y), (0, 0)) cell['missed'] += 1 else: ## this should never happen print 'missed shot not in cell: ({}, {})'.format(x, y) max_attempts = max([cell['made'] + cell['missed'] for cell in hexes]) min_attempts = min([cell['made'] + cell['missed'] for cell in hexes if cell['made'] + cell['missed'] > 0]) total_attempts = sum([cell['made'] + cell['missed'] for cell in hexes]) max_attempts_frac = 100.0 * max_attempts / total_attempts min_attempts_frac = 100.0 * min_attempts / total_attempts #print 'max_attempts: {}, min_attempts: {}, total_attempts: {}'.format(max_attempts, min_attempts, total_attempts) #print 'max_attempts_frac: {}, min_attempts_frac: {}'.format(max_attempts_frac, min_attempts_frac) if 'scale_factor' in kwargs: max_attempts_frac = max_attempts_frac * kwargs['scale_factor'] else: # default scale factor # max_attempts_frac = min_attempts_frac * 64 pass max_size = hex_size min_size = hex_size / 8.0 if max_attempts > 1: m = (float(max_size) - min_size) / (max_attempts_frac - 1) b = min_size - m else: m = max_size / max_attempts_frac b = 0 #print 'm: {}, b: {}, max_size: {}, min_size: {}'.format(m, b, max_size, min_size) cm = mpl.cm.YlOrBr norm = Normalize(0, 1.5) total_made = 0 total_threes = 0 for cell in hexes: attempts = cell['made'] + cell['missed'] #total_attempts += attempts if attempts > 0: attempts_frac = 100.0 * attempts / total_attempts total_made += cell['made'] total_threes += cell['threes'] efg = (cell['made'] + 0.5 * cell['threes']) / attempts cell['efg'] = efg scaled_attempts = min(attempts_frac, max_attempts_frac) size = scaled_attempts * m + b #print size, scaled_attempts, attempts_frac, max_attempts_frac #print size if plot_type == 'hexbin' and not return_cells: cell['patch'] = RegularPolygon((cell['x'], cell['y']), 6, size, orientation=np.pi/6, color=cm(norm(efg)), alpha=0.75) outline = RegularPolygon((cell['x'], cell['y']), 6, hex_size, orientation=np.pi/6, fill=False, color='y', linestyle='dotted') ax.add_patch(cell['patch']) ax.add_patch(outline) if 'print_pct' in kwargs and kwargs['print_pct'] == True: ax.text(cell['x'] - 1, cell['y'] - 1, '{0:2.2f}'.format(attempts_frac)) if return_cells: return hexes if plot_type == 'hexbin': cb = ColorbarBase(ax_cb, cmap=cm, norm=norm, orientation='vertical') cb.set_label('Effective Field Goal Percentage') mpl.tight_layout() if plot_type == 'hexbin_contour': efg = [] bin_x = [cell['x'] for cell in hexes] bin_y = [cell['y'] for cell in hexes] efg = [cell['efg'] for cell in hexes] xi = np.linspace(-25, 25, 200) yi = np.linspace(0, 47.5, 200) zi = np.griddata(bin_x, bin_y, efg, xi, yi) mpl.contourf(xi, yi, zi, 5, cmap=mpl.cm.YlOrBr) mpl.colorbar() if 'overplot_shots' in kwargs: if kwargs['overplot_shots'] == True: mpl.plot(made_x, made_y, 'go') mpl.plot(missed_x, missed_y, 'rs') ax.text(0.02, 0.96, 'Total attempts: {}'.format(total_attempts), transform=ax.transAxes) ax.text(0.02, 0.93, 'Total made: {}'.format(total_made), transform=ax.transAxes) ax.text(0.02, 0.90, 'Total threes made: {}'.format(total_threes), transform=ax.transAxes) ax.text(0.02, 0.87, 'Total twos made: {}'.format(total_made - total_threes), transform=ax.transAxes) if total_attempts > 0: efg = 100 * (total_made + 0.5 * total_threes) / total_attempts else: efg = 0 ax.text(0.02, 0.84, 'eFG%: {0:2.2f}'.format(efg), transform=ax.transAxes) ax.set_title(title, fontsize='small') if plot_type == 'xo': mpl.plot(made_x, made_y, 'go') mpl.plot(missed_x, missed_y, 'rd') mpl.title(title) if plot_type == '3d': from mpl_toolkits.mplot3d import Axes3D fig = mpl.figure() ax = fig.gca(projection='3d') surf = ax.plot_surface(X, Y, frac_counts, cmap=mpl.cm.coolwarm) mpl.show() plot_dir = os.path.split(filename) if not os.path.exists(plot_dir[0]): os.makedirs(plot_dir[0]) mpl.savefig(filename)
def drawGeoms(geoms, srs=4326, ax=None, simplificationFactor=5000, colorBy=None, figsize=(12, 12), xlim=None, ylim=None, fontsize=16, hideAxis=False, cbarPadding=0.01, cbarTitle=None, vmin=None, vmax=None, cmap="viridis", cbar=True, cbax=None, cbargs=None, leftMargin=0.01, rightMargin=0.01, topMargin=0.01, bottomMargin=0.01, **mplArgs): """Draw geometries onto a matplotlib figure * Each geometry type is displayed as an appropriate plotting type -> Points/ Multipoints are displayed as points using plt.plot(...) -> Lines/ MultiLines are displayed as lines using plt.plot(...) -> Polygons/ MultiPolygons are displayed as patches using the descartes library * Each geometry can be given its own set of matplotlib plotting parameters Notes: ------ This function does not call plt.show() for the final display of the figure. This must be done manually after calling this function. Otherwise plt.savefig(...) can be called to save the output somewhere. Sometimes geometries will disappear because of the simplification procedure. If this happens, the procedure can be avoided by setting simplificationFactor to None. This will take much more memory and will take longer to plot, however Parameters: ----------- geoms : ogr.Geometry or [ogr.Geometry, ] or pd.DataFrame The geometries to be drawn * If a DataFrame is given, the function looks for geometries under a columns named 'geom' * plotting arguments can be given by adding a column named 'MPL:****' where '****' stands in for the argument to be added - For geometries that should ignore this argument, set it as None srs : Anything acceptable to geokit.srs.loadSRS(); optional The srs in which to draw each geometry * If not given, longitude/latitude is assumed * Although geometries can be given in any SRS, it is very helpful if they are already provided in the correct SRS ax : matplotlib axis; optional The axis to draw the geometries on * If not given, a new axis is generated and returned simplificationFactor : float; optional The level to which geometries should be simplified. It can be thought of as the number of verticies allowed in either the X or Y dimension across the figure * A higher value means a more detailed plot, but may take longer to draw colorBy : str; optional The column in the geoms DataFrame to color by * Only useful when geoms is given as a DataFrame figsize : (int, int); optional The figure size to create when generating a new axis * If resultign figure looks wierd, altering the figure size is your best bet to make it look nicer xlim : (float, float); optional The x-axis limits ylim : (float, float); optional The y-axis limits fontsize : int; optional A base font size to apply to tick marks which appear * Titles and labels are given a size of 'fontsize' + 2 hideAxis : bool; optional Instructs the created axis to hide its boundary * Only useful when generating a new axis cbarPadding : float; optional The spacing padding to add between the generated axis and the generated colorbar axis * Only useful when generating a new axis * Only useful when 'colorBy' is given cbarTitle : str; optional The title to give to the generated colorbar * If not given, but 'colorBy' is given, the same string for 'colorBy' is used * Only useful when 'colorBy' is given vmin : float; optional The minimum value to color * Only useful when 'colorBy' is given vmax : float; optional The maximum value to color * Only useful when 'colorBy' is given cmap : str or matplotlib ColorMap; optional The colormap to use when coloring * Only useful when 'colorBy' is given cbax : matplotlib axis; optional An explicitly given axis to use for drawing the colorbar * If not given, but 'colorBy' is given, an axis for the colorbar is automatically generated cbargs : dict; optional keyword arguments to pass on when creating the colorbar leftMargin : float; optional Additional margin to add to the left of the figure * Before using this, try adjusting the 'figsize' rightMargin : float; optional Additional margin to add to the left of the figure * Before using this, try adjusting the 'figsize' topMargin : float; optional Additional margin to add to the left of the figure * Before using this, try adjusting the 'figsize' bottomMargin : float; optional Additional margin to add to the left of the figure * Before using this, try adjusting the 'figsize' **mplArgs All other keyword arguments are passed on to the plotting functions called for each geometry * Will be applied to ALL geometries. Be careful since this can cause errors when plotting geometries of different types Returns: -------- A namedtuple containing: 'ax' -> The map axis 'handles' -> All geometry handles which were created in the order they were drawn 'cbar' -> The colorbar handle if it was drawn """ if isinstance(ax, AxHands): ax = ax.ax if ax is None: newAxis = True import matplotlib.pyplot as plt plt.figure(figsize=figsize) if colorBy is None: # We don't need a colorbar if not hideAxis: leftMargin += 0.07 ax = plt.axes([ leftMargin, bottomMargin, 1 - (rightMargin + leftMargin), 1 - (topMargin + bottomMargin) ]) cbax = None else: # We need a colorbar rightMargin += 0.08 # Add area on the right for colorbar text if not hideAxis: leftMargin += 0.07 cbarExtraPad = 0.05 cbarWidth = 0.04 ax = plt.axes([ leftMargin, bottomMargin, 1 - (rightMargin + leftMargin + cbarWidth + cbarPadding), 1 - (topMargin + bottomMargin) ]) cbax = plt.axes([ 1 - (rightMargin + cbarWidth), bottomMargin + cbarExtraPad, cbarWidth, 1 - (topMargin + bottomMargin + 2 * cbarExtraPad) ]) if hideAxis: ax.axis("off") else: ax.tick_params(labelsize=fontsize) else: newAxis = False # Be sure we have a list pargs = None isFrame = False if isinstance(geoms, ogr.Geometry): geoms = [ geoms, ] elif isinstance( geoms, pd.DataFrame): # We have a DataFrame with plotting arguments isFrame = True data = geoms.drop("geom", axis=1) geoms = geoms["geom"].values pargs = pd.DataFrame(index=data.index) for c in data.columns: if not c[:4] == "MPL:": continue pargs[c[4:]] = data[c] if pargs.size == 0: pargs = None else: #Assume its an iterable geoms = list(geoms) # Check Geometry SRS if not srs is None: srs = loadSRS(srs) for gi, g in enumerate(geoms): gsrs = g.GetSpatialReference() if gsrs is None: continue # Skip it if we don't know it... if not gsrs.IsSame(srs): geoms[gi] = transform(geoms[gi], srs) # Apply simplifications if required if not simplificationFactor is None: if xlim is None or ylim is None: xMin, yMin, xMax, yMax = 1e100, 1e100, -1e100, -1e100 for g in geoms: _xMin, _xMax, _yMin, _yMax = g.GetEnvelope() xMin = min(_xMin, xMin) xMax = max(_xMax, xMax) yMin = min(_yMin, yMin) yMax = max(_yMax, yMax) if not xlim is None: xMin, xMax = xlim if not ylim is None: yMin, yMax = ylim simplificationValue = max(xMax - xMin, yMax - yMin) / simplificationFactor oGeoms = geoms geoms = [] def doSimplify(g): ng = g.Simplify(simplificationValue) return ng for g in oGeoms: #carefulSimplification=False #if carefulSimplification and "MULTI" in g.GetGeometryName(): if False and "MULTI" in g.GetGeometryName( ): # This doesn't seem to help... subgeoms = [] for gi in range(g.GetGeometryCount()): ng = doSimplify(g.GetGeometryRef(gi)) subgeoms.append(ng) geoms.append(flatten(subgeoms)) else: geoms.append(doSimplify(g)) ### Handle color value if not colorBy is None: colorVals = data[colorBy].values if isinstance(cmap, str): from matplotlib import cm cmap = getattr(cm, cmap) cValMax = colorVals.max() if vmax is None else vmax cValMin = colorVals.min() if vmin is None else vmin _colorVals = [ cmap(v) for v in (colorVals - cValMin) / (cValMax - cValMin) ] ### Do Plotting # make patches h = [] for gi, g in enumerate(geoms): if not pargs is None: s = [not v is None for v in pargs.iloc[gi]] plotargs = pargs.iloc[gi, s].to_dict() else: plotargs = dict() plotargs.update(mplArgs) if not colorBy is None: colorVal = _colorVals[gi] else: colorVal = None # Determine type if g.GetGeometryName() == "POINT": h.append(drawPoint(g, plotargs, ax, colorVal)) elif g.GetGeometryName() == "MULTIPOINT": h.append(drawMultiPoint(g, plotargs, ax, colorVal)) elif g.GetGeometryName() == "LINESTRING": h.append(drawLine(g, plotargs, ax, colorVal)) elif g.GetGeometryName() == "MULTILINESTRING": h.append(drawMultiLine(g, plotargs, ax, colorVal)) elif g.GetGeometryName() == "LINEARRING": h.append(drawLinearRing(g, plotargs, ax, colorVal)) elif g.GetGeometryName() == "POLYGON": h.append(drawPolygon(g, plotargs, ax, colorVal)) elif g.GetGeometryName() == "MULTIPOLYGON": h.append(drawMultiPolygon(g, plotargs, ax, colorVal)) else: msg = "Could not draw geometry of type:", pargs.index[ gi], "->", g.GetGeometryName() warnings.warn(msg, UserWarning) # Add the colorbar, maybe if not colorBy is None and cbar: from matplotlib.colorbar import ColorbarBase from matplotlib.colors import Normalize norm = Normalize(vmin=cValMin, vmax=cValMax) tmp = dict(cmap=cmap, norm=norm, orientation='vertical') if not cbargs is None: tmp.update(cbargs) cbar = ColorbarBase(cbax, **tmp) cbar.ax.tick_params(labelsize=fontsize) cbar.set_label(colorBy if cbarTitle is None else cbarTitle, fontsize=fontsize + 2) else: cbar = None # Do some formatting if newAxis: ax.set_aspect('equal') ax.autoscale(enable=True) if not xlim is None: ax.set_xlim(*xlim) if not ylim is None: ax.set_ylim(*ylim) # Organize return if isFrame: return AxHands(ax, pd.Series(h, index=data.index), cbar) else: return AxHands(ax, h, cbar)
class Plotter3d(): def __init__(self, notify, figure, settings): self.notify = notify self.figure = figure self.settings = settings self.axes = None self.plot = None self.extent = None self.threadPlot = None self.wireframe = settings.wireframe self.setup_plot() self.set_grid(settings.grid) def setup_plot(self): gs = GridSpec(1, 2, width_ratios=[9.5, 0.5]) self.axes = self.figure.add_subplot(gs[0], projection='3d') numformatter = ScalarFormatter(useOffset=False) timeFormatter = DateFormatter("%H:%M:%S") self.axes.set_xlabel("Frequency (MHz)") self.axes.set_ylabel('Time') self.axes.set_zlabel('Level (dB)') self.axes.w_xaxis.set_pane_color(hex2color(self.settings.background)) self.axes.w_yaxis.set_pane_color(hex2color(self.settings.background)) self.axes.w_zaxis.set_pane_color(hex2color(self.settings.background)) self.axes.xaxis.set_major_formatter(numformatter) self.axes.yaxis.set_major_formatter(timeFormatter) self.axes.zaxis.set_major_formatter(numformatter) self.axes.xaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.yaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.zaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.set_xlim(self.settings.start, self.settings.stop) now = time.time() self.axes.set_ylim(epoch_to_mpl(now), epoch_to_mpl(now - 10)) self.axes.set_zlim(-50, 0) self.bar = self.figure.add_subplot(gs[1]) norm = Normalize(vmin=-50, vmax=0) self.barBase = ColorbarBase(self.bar, norm=norm, cmap=cm.get_cmap(self.settings.colourMap)) self.barBase.set_label('Level (dB)') def scale_plot(self, force=False): if self.extent is not None and self.plot is not None: if self.settings.autoF or force: self.axes.set_xlim(self.extent.get_f()) if self.settings.autoL or force: self.axes.set_zlim(self.extent.get_l()) self.plot.set_clim(self.extent.get_l()) self.barBase.set_clim(self.extent.get_l()) try: self.barBase.draw_all() except: pass if self.settings.autoT or force: self.axes.set_ylim(self.extent.get_t()) def draw_measure(self, *args): pass def hide_measure(self): pass def redraw_plot(self): if self.figure is not None: post_event(self.notify, EventThreadStatus(Event.DRAW)) def get_axes(self): return self.axes def get_plot_thread(self): return self.threadPlot def set_title(self, title): self.axes.set_title(title) def set_plot(self, data, extent, annotate=False): self.extent = extent self.threadPlot = ThreadPlot(self, self.axes, data, self.extent, self.settings.retainMax, self.settings.colourMap, self.settings.autoF, self.barBase, annotate) self.threadPlot.start() def clear_plots(self): children = self.axes.get_children() for child in children: if child.get_gid() is not None: if child.get_gid() == "plot" or child.get_gid() == "peak": child.remove() def set_grid(self, on): self.axes.grid(on) self.redraw_plot() def set_colourmap(self, colourMap): if self.plot is not None: self.plot.set_cmap(colourMap) self.barBase.set_cmap(colourMap) try: self.barBase.draw_all() except: pass def close(self): self.figure.clear() self.figure = None
def plot(): global DATA, store c = Config(args.config) conf = PlotConf() conf = conf.new_child(c['scatterplot'].get('conf', {})) attrs = store.get_storer(path).attrs if hasattr(attrs, 'config') and conf.get('conf_overwrite', False): attrs.config['scatterplot'] = {} c.append(attrs.config) if not DATA.empty and 'newfields' in conf: for field, expr in conf['newfields'].items(): logging.debug("executing DATA[{}] = {}]".format(field, expr)) DATA[field] = eval(expr) logging.debug("done.") pcount = 0 for p in c['scatterplot']['plots']: lcount = 0 pconf = conf.new_child(p) plt.cla() plt.clf() plt.rcParams.update(pconf['rcParams']) if pconf['figsize']: plt.figure(figsize=pconf['figsize']) else: plt.figure() if pconf['fontsize'] != conf['fontsize']: plt.rcParams.update({'font.size': pconf['fontsize']}) if pconf['colorbar_only']: plt.figure(figsize=(8, 0.25)) ax = plt.gca() norm = Normalize(vmin=pconf['z-axis']['vmin'], vmax=pconf['z-axis']['vmax']) if pconf['z-axis']['lognorm']: norm = LogNorm(vmin=pconf['z-axis']['vmin'], vmax=pconf['z-axis']['vmax']) cbar = ColorbarBase( ax, norm=norm, cmap=pconf['cmap'], orientation=pconf['z-axis']['colorbar_orientation']) if pconf['z-axis']['colorbar_orientation'] == 'horizontal': ax.xaxis.set_label_position('top') ax.xaxis.set_ticks_position('top') if pconf['z-axis']['label']: cbar.set_label(pconf['z-axis']['label']) if pconf['z-axis']['ticks']: cbar.set_ticks(pconf['z-axis']['ticks']) plt.savefig(pconf['filename'], bbox_inches='tight') plt.figure() continue if pconf['title']: plt.title(conf['title']) if 'plots' not in p: p['plots'] = [p] for l in p['plots']: # noqa: E741 lconf = pconf.new_child(l) label = lconf['label'] label = label if label else None cmap = lconf['cmap'] zorder = lconf.get('zorder', lcount) color = lconf.get('color', "C{}".format(lcount)) x = lconf.get('x-field', lconf['x-axis'].get('field', None)) y = lconf.get('y-field', lconf['y-axis'].get('field', None)) z = lconf.get('z-field', lconf['z-axis'].get('field', None)) xlabel = lconf['x-axis']['label'] ylabel = lconf['y-axis']['label'] zlabel = lconf['z-axis']['label'] if hasattr(c, 'parameters'): xlabel = c.parameters.get( x, {'latex': xlabel})['latex'] if not xlabel else xlabel ylabel = c.parameters.get( y, {'latex': ylabel})['latex'] if not ylabel else ylabel zlabel = c.parameters.get( z, {'latex': zlabel})['latex'] if not zlabel else zlabel if xlabel: plt.xlabel(xlabel) if ylabel: plt.ylabel(ylabel) if lconf['hline']: plt.axhline(y=y, color=color, linestyle='-', lw=lconf['lw'], label=label, zorder=zorder, alpha=lconf['alpha']) continue if lconf['vline']: plt.axvline(x=x, color=color, linestyle='-', lw=lconf['lw'], label=label, zorder=zorder, alpha=lconf['alpha']) continue if hasattr(c, 'parameters'): x = c.parameters.get(x, {'lha': x})['lha'] y = c.parameters.get(y, {'lha': y})['lha'] z = c.parameters.get(z, {'lha': z})['lha'] PDATA = DATA for constr in lconf['constraints']: PDATA = PDATA[eval(constr)] if (lconf['datafile'] and lconf['datafile'] != conf['datafile']): conf['datafile'] = lconf['datafile'] # TODO store.close() del DATA, PDATA, store store = HDFStore(lconf['datafile']) # TODO DATA = store['results'] # TODO PDATA = DATA if not PDATA.empty and 'newfields' in conf: for field, expr in conf['newfields'].items(): logging.debug("executing PATA[{}] = {}]".format( field, expr)) PDATA[field] = eval(expr) logging.debug("done.") for ax, field in {'x-axis': x, 'y-axis': y, 'z-axis': z}.items(): bounds = lconf[ax]['boundaries'] if len(bounds) == 2: logging.debug( "applying boundaries [{},{}] on axis {}, field {}". format(bounds[0], bounds[1], ax, field)) PDATA = PDATA[(PDATA[field] >= bounds[0]) & (PDATA[field] <= bounds[1])] if lconf['x-axis']['lognorm']: if type(lconf['x-axis']['lognorm']) == str: plt.xscale(lconf['x-axis']['lognorm']) else: plt.xscale('log') if lconf['y-axis']['lognorm']: if type(lconf['y-axis']['lognorm']) == str: plt.yscale(lconf['y-axis']['lognorm']) else: plt.yscale('log') if z: PDATA = PDATA.sort_values(by=z) color = PDATA[z] vmin = PDATA[z].min( ) if not lconf['z-axis']['vmin'] else lconf['z-axis']['vmin'] vmax = PDATA[z].max( ) if not lconf['z-axis']['vmax'] else lconf['z-axis']['vmax'] else: vmin = None vmax = None znorm = LogNorm(vmin=vmin, vmax=vmax) if lconf['z-axis']['lognorm'] else None if lconf['exec']: exec(lconf['exec']) if len(PDATA) == 0: logging.error( 'In plot {}, x:{} , y:{}; no data to plot! (wrong boundaries or constraints?)' .format(p['filename'], x, y)) continue if pconf.get('type', 'scatter') == 'scatter': cs = plt.scatter(PDATA[x], PDATA[y], zorder=zorder, label=label, cmap=cmap, c=color, vmin=vmin, vmax=vmax, norm=znorm, s=lconf['s'], alpha=lconf['alpha'], marker=lconf.get('marker', None)) else: PDATA = PDATA[[x, y]].dropna().sort_values(by=x) cs = plt.plot(PDATA[x], PDATA[y], lconf.get('fmt', '.'), zorder=zorder, c=color, alpha=lconf['alpha'], label=label, **lconf.get('kwargs', {})) plt.grid(b=True, which='major', color='#777777', linestyle='-', alpha=0.3, zorder=0) plt.minorticks_on() plt.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.1, zorder=0) plt.margins(x=0.01, y=0.01) # TODO if lconf['x-axis']['ticks']: if type(lconf['x-axis']['ticks'][0]) is not list: lconf['x-axis']['ticks'] = [ lconf['x-axis']['ticks'], ['${}$'.format(xt) for xt in lconf['x-axis']['ticks']] ] plt.xticks(lconf['x-axis']['ticks'][0], lconf['x-axis']['ticks'][1]) if lconf['y-axis']['ticks']: if type(lconf['y-axis']['ticks'][0]) is not list: lconf['y-axis']['ticks'] = [ lconf['y-axis']['ticks'], ['${}$'.format(yt) for yt in lconf['y-axis']['ticks']] ] plt.yticks(lconf['y-axis']['ticks'][0], lconf['y-axis']['ticks'][1]) if lconf['z-axis']['colorbar']: cbar = plt.colorbar( cs, orientation=lconf['z-axis']['colorbar_orientation'], **lconf['z-axis'].get('kwargs', {})) if zlabel: cbar.set_label(zlabel) if lconf['z-axis']['ticks']: if type(lconf['z-axis']['ticks'][0]) is not list: lconf['z-axis']['ticks'] = [ lconf['z-axis']['ticks'], [ '${}$'.format(zt) for zt in lconf['z-axis']['ticks'] ] ] cbar.set_ticks(lconf['z-axis']['ticks']) for label in cbar.ax.yaxis.get_ticklabels(): if lconf['z-axis']['colorbar_orientation'] == 'horizontal': label.set_ha('center') else: label.set_va('center') lcount += 1 if pconf['textbox'] and 'text' in pconf['textbox']: bbox = pconf['textbox'].get( 'bbox', dict(boxstyle='round', facecolor='white', alpha=0.2)) va = pconf['textbox'].get('va', 'top') ha = pconf['textbox'].get('ha', 'left') textsize = pconf['textbox'].get( 'fontsize', pconf['rcParams'].get('font.size', 15)) xtext = pconf['textbox'].get('x', 0.95) ytext = pconf['textbox'].get('y', 0.85) plt.gcf().text(xtext, ytext, pconf['textbox']['text'], fontsize=textsize, va=va, ha=ha, bbox=bbox) if pconf['tick_params']: plt.tick_params(**pconf['tick_params']) ax = plt.gca() for label in ax.yaxis.get_ticklabels(): label.set_verticalalignment('center') for label in ax.xaxis.get_ticklabels(): label.set_horizontalalignment('center') for ann in p.get('annotiations', []): plt.annotate(ann['label'], ann['pos'], **ann.get('kwargs', {})) if any([lbl.get('label', False) for lbl in p['plots']]): plt.legend(**pconf['legend']) plotfile = DIR + p.get('filename', 'plot{}.png'.format(pcount)) logging.info("Saving {}.".format(plotfile)) plt.savefig(plotfile, bbox_inches="tight", dpi=pconf['dpi']) pcount += 1
def show(self, **kwargs): def split_key(key): tl = list(key) wp = len(tl) // 4 + int(len(tl) % 4 > 1) return '\n'.join([' '.join(s) for s in [tl[i * len(tl) // wp: (i + 1) * len(tl) // wp] for i in range(wp)]]) out = kwargs.get('out', None) cmap = kwargs.get('cmap', 'Purples') alpha = kwargs.get('alpha', 0.6) label = kwargs.get('label', False) bulk = kwargs.get('bulk', False) if isinstance(out, str): out = [out] # check shapes created if not self.ready: self.refresh_geometry() vv = np.unique([self.variance[k] for k in self]) pscolors = plt.get_cmap(cmap)(np.linspace(0, 1, vv.size)) # Set alpha pscolors[:, -1] = alpha pscmap = ListedColormap(pscolors) norm = BoundaryNorm(np.arange(min(vv) - 0.5, max(vv) + 1), vv.size) fig, ax = plt.subplots() lbls = [] exc = frozenset.intersection(*self.keys) for k in self: lbls.append((split_key(k.difference(exc)), self.shapes[k].representative_point().coords[0])) ax.add_patch(PolygonPatch(self.shapes[k], fc=pscmap(norm(self.variance[k])), ec='none')) ax.autoscale_view() self.add_overlay(ax) if out: for o in out: lst = [self.prj.get_trimmed_uni(row[0]) for row in self.prj.unilist if o in row[4]['out']] if lst: ax.plot(np.hstack([(*seg[0], np.nan) for seg in lst]), np.hstack([(*seg[1], np.nan) for seg in lst]), lw=2, label=o) # Shrink current axis's width box = ax.get_position() ax.set_position([box.x0 + box.width * 0.07, box.y0, box.width * 0.95, box.height]) # Put a legend below current axis ax.legend(loc='upper right', bbox_to_anchor=(-0.08, 1), title='Out', borderaxespad=0, frameon=False) if label: for txt, xy in lbls: ax.annotate(s=txt, xy=xy, weight='bold', fontsize=6, ha='center', va='center') divider = make_axes_locatable(ax) cax = divider.append_axes('right', size='4%', pad=0.05) cb = ColorbarBase(ax=cax, cmap=pscmap, norm=norm, orientation='vertical', ticks=vv) cb.set_label('Variance') ax.axis(self.prj.trange + self.prj.prange) if bulk: if label: ax.set_xlabel(self.prj.name + (len(exc) * ' +{}').format(*exc)) else: ax.set_xlabel(self.prj.name) # bulk composition ox, vals = self.prj.get_bulk_composition() table = r'''\begin{tabular}{ ''' + ' | '.join(len(ox)*['c']) + '}' + ' & '.join(ox) + r''' \\\hline ''' + ' & '.join(vals) + r'''\end{tabular}''' plt.figtext(0.08, 0.94, table, size=10, va='top', usetex=True) else: if label: ax.set_title(self.prj.name + (len(exc) * ' +{}').format(*exc)) else: ax.set_title(self.prj.name) # connect button press cid = fig.canvas.mpl_connect('button_press_event', self.onclick) plt.show()
cols = ('C0', 'C1', 'C2', 'C3', 'C4', 'C5') cmap2 = ListedColormap(cols) plt.figure(figsize = (scol, 0.7 * scol)) mp = m.pcolormesh(lonedges, latedges, UTC, norm = BoundaryNorm(bounds, cmap1.N), cmap = cmap1, latlon = True, rasterized = True) for hhr, col in zip(range(t1 - t0 + 1), cols): m.contour(lons, lats, numPixelIntp[hhr] > 0, 1, colors = col, linewidths = 1, latlon = True) m.drawcoastlines(linewidth = 0.5) m.drawparallels((-60, 60)) cb = ColorbarBase(plt.axes([0.125, 0.1, 0.775, 0.025]), cmap = cmap2, orientation = 'horizontal', norm = BoundaryNorm(bounds, cmap2.N)) cb.set_label('UTC hour') plt.savefig('fig.cr.composite.pdf') plt.close() #--- Distribution figures ---# if 'dist.meanprecip' in options: meanPrecip = collapse_sat(get_processed_data('meanPrecip', year0, month0, year1, month1, tres)) numNonzero = collapse_sat(get_processed_data('numNonzero', year0, month0, year1, month1, tres))
def _scatter_legends( df, ax, cmap, ck, ondata: bool, onside: bool, fontsize: float, title: str, title_fontsize: float, hide_title: bool, n_per_col: int, scale: float, ls: float, cs: float, cbs: float, ) -> None: """ Args: df: dataframe ax: axis object cmap: color map ck: color key ondata: display legend over scatter plot? onside: display legend on side? fontsize: fontsize of legend text title: Title of subplot/axes hide_title: Whether to hide the title n_per_col: number of legends per column scale: scale legend marker size ls: line spacing cs: column spacing cbs: Cbar shrink factor Returns: """ from matplotlib.colors import Normalize from matplotlib.colorbar import ColorbarBase, make_axes_gridspec x, y, vc = df.columns[:3] v = df[vc] cax = make_axes_gridspec(ax, location="top", shrink=cbs, aspect=25, fraction=0.1)[0] if v.nunique() <= 1: cax.set_axis_off() return None if v.dtype.name == "category": if hide_title is False: if title is not None: ax.title.set_text(title) else: ax.title.set_text(vc) ax.title.set_fontsize(title_fontsize) centers = df[[x, y, vc]].groupby(vc).median().T for i in centers: if ondata: ax.text( centers[i][x], centers[i][y], i, fontsize=fontsize, ha="center", va="center", ) if onside: ax.scatter( [float(centers[i][x])], [float(centers[i][y])], c=ck[i], label=i, alpha=1, s=0.01, ) if onside: n_cols = v.nunique() // n_per_col if v.nunique() % n_per_col > 0: n_cols += 1 ax.legend( ncol=n_cols, loc=(1, 0), frameon=False, fontsize=fontsize, markerscale=scale, labelspacing=ls, columnspacing=cs, ) cax.set_axis_off() else: norm = Normalize(vmin=v.min(), vmax=v.max()) cb = ColorbarBase(cax, cmap=cmap, norm=norm, orientation="horizontal") if hide_title is False: if title is not None: cb.set_label(title, fontsize=title_fontsize) else: cb.set_label(vc, fontsize=title_fontsize) cb.ax.xaxis.set_label_position("bottom") cb.ax.xaxis.set_ticks_position("top") cb.outline.set_visible(False) return None
def make_plot(filename, grid_name, x_name='x', y_name='y', t_name='time', n_cols=6, outpath='', filename_prefix='LMA', do_save=True, image_type='pdf', colormap='gist_earth'): """ colormap: a string giving the name of a matplotlib built-in colormap, or a matplotlib.colors.Colormap instance """ f = nc.NetCDFFile(filename) data = f.variables # dictionary of variable names to nc_var objects dims = f.dimensions # dictionary of dimension names to sizes x = data[x_name] y = data[y_name] t = data[t_name] grid = data[grid_name] assert len(x.shape) == 1 assert len(y.shape) == 1 assert len(t.shape) == 1 grid_dims = grid.dimensions # tuple of dimension names name_to_idx = dict((k, i) for i, k in enumerate(grid_dims)) grid_t_idx = name_to_idx[t.dimensions[0]] grid_x_idx = name_to_idx[x.dimensions[0]] grid_y_idx = name_to_idx[y.dimensions[0]] n_frames = t.shape[0] # n_cols = 6 n_rows = int(ceil( float(n_frames) / n_cols )) if type(colormap) == type(''): colormap = get_cmap(colormap) grey_color = (0.5,)*3 frame_color = (0.2,)*3 density_maxes = [] total_counts = [] all_t = [] xedge = centers_to_edges(x) x_range = xedge.max() - xedge.min() yedge = centers_to_edges(y) y_range = yedge.max() - yedge.min() dx = (xedge[1]-xedge[0]) # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None) # count_scale_factor = dx # / 1000.0 # max_count_baseline = 450 * count_scale_factor #/ 10.0 min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0]) if (max_count == 0) | (max_count == 1 ): max_count = min_count+1 f.close() default_vmin = -0.2 if np.log10(max_count) <= default_vmin: vmin_count = np.log10(max_count) + default_vmin else: vmin_count = default_vmin fig = Figure(figsize=(w,h)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols) p.label_edges(True) pad = 0.0 # for time labels in each frame for ax in p.multiples.flat: ax.set_axis_bgcolor('black') ax.spines['top'].set_edgecolor(frame_color) ax.spines['bottom'].set_edgecolor(frame_color) ax.spines['left'].set_edgecolor(frame_color) ax.spines['right'].set_edgecolor(frame_color) # ax.yaxis.set_major_formatter(kilo_formatter) # ax.xaxis.set_major_formatter(kilo_formatter) base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S") time_delta = timedelta(0,float(t[0]),0) start_time = base_date + time_delta indexer = [slice(None),]*len(grid.shape) frame_start_times = [] for i in range(n_frames): frame_start = base_date + timedelta(0,float(t[i]),0) frame_start_times.append(frame_start) indexer[grid_t_idx] = i density = grid[indexer] # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge, np.log10(density.transpose()), vmin=vmin_count, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') text_label = p.multiples.flat[i].text(xedge[0]-pad+x_range*.015, yedge[0]-pad+y_range*.015, label_string, color=grey_color, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print label_string, x.shape, density.max(), density.sum() color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') view_x = (xedge.min(), xedge.max()) view_y = (yedge.min(), yedge.max()) print 'making multiples', p.multiples.flat[0].axis(view_x+view_y) filename = '%s-%s_%s_%05.2fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, time_delta.seconds, image_type) filename = os.path.join(outpath, filename) if do_save: fig.savefig(filename, dpi=150) return fig, p, frame_start_times, filename print ' ... done'
class Spectrogram: def __init__(self, notify, figure, settings): self.notify = notify self.figure = figure self.settings = settings self.data = [[], [], []] self.index = 0 self.axes = None self.plot = None self.extent = None self.lineHalfFS = None self.lineHalfFE = None self.lineObwFS = None self.lineObwFE = None self.labelHalfFS = None self.labelHalfFE = None self.labelObwFS = None self.labelObwFE = None self.threadPlot = None self.setup_plot() self.set_grid(self.settings.grid) def setup_plot(self): gs = GridSpec(1, 2, width_ratios=[9.5, 0.5]) self.axes = self.figure.add_subplot(gs[0], axisbg=self.settings.background) self.axes.set_xlabel("Frequency (MHz)") self.axes.set_ylabel('Time') numFormatter = ScalarFormatter(useOffset=False) timeFormatter = DateFormatter("%H:%M:%S") self.axes.xaxis.set_major_formatter(numFormatter) self.axes.yaxis.set_major_formatter(timeFormatter) self.axes.xaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.yaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.set_xlim(self.settings.start, self.settings.stop) now = time.time() self.axes.set_ylim(epoch_to_mpl(now), epoch_to_mpl(now - 10)) self.bar = self.figure.add_subplot(gs[1]) norm = Normalize(vmin=-50, vmax=0) self.barBase = ColorbarBase(self.bar, norm=norm, cmap=cm.get_cmap(self.settings.colourMap)) self.barBase.set_label('Level (dB)') self.setup_measure() def setup_measure(self): dashesHalf = [1, 5, 5, 5, 5, 5] self.lineHalfFS = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lineHalfFE = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lineObwFS = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') self.lineObwFE = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') if matplotlib.__version__ >= '1.3': effect = patheffects.withStroke(linewidth=3, foreground="w", alpha=0.75) self.lineHalfFS.set_path_effects([effect]) self.lineHalfFE.set_path_effects([effect]) self.lineObwFS.set_path_effects([effect]) self.lineObwFE.set_path_effects([effect]) self.axes.add_line(self.lineHalfFS) self.axes.add_line(self.lineHalfFE) self.axes.add_line(self.lineObwFS) self.axes.add_line(self.lineObwFE) box = dict(boxstyle='round', fc='white', ec='purple') self.labelHalfFS = Text(0, 0, '-3dB', fontsize='x-small', ha="center", va="top", bbox=box, color='purple') self.labelHalfFE = Text(0, 0, '-3dB', fontsize='x-small', ha="center", va="top", bbox=box, color='purple') box['ec'] = '#996600' self.labelObwFS = Text(0, 0, 'OBW', fontsize='x-small', ha="center", va="top", bbox=box, color='#996600') self.labelObwFE = Text(0, 0, 'OBW', fontsize='x-small', ha="center", va="top", bbox=box, color='#996600') self.axes.add_artist(self.labelHalfFS) self.axes.add_artist(self.labelHalfFE) self.axes.add_artist(self.labelObwFS) self.axes.add_artist(self.labelObwFE) self.hide_measure() def draw_vline(self, line, label, x): yLim = self.axes.get_ylim() xLim = self.axes.get_xlim() if xLim[0] < x < xLim[1]: line.set_visible(True) line.set_xdata([x, x]) line.set_ydata([yLim[0], yLim[1]]) self.axes.draw_artist(line) label.set_visible(True) label.set_position((x, yLim[1])) self.axes.draw_artist(label) def draw_measure(self, background, measure, show): if self.axes._cachedRenderer is None: return self.hide_measure() canvas = self.axes.get_figure().canvas canvas.restore_region(background) if show[Measure.HBW]: xStart, xEnd, _y = measure.get_hpw() self.draw_vline(self.lineHalfFS, self.labelHalfFS, xStart) self.draw_vline(self.lineHalfFE, self.labelHalfFE, xEnd) if show[Measure.OBW]: xStart, xEnd, _y = measure.get_obw() self.draw_vline(self.lineObwFS, self.labelObwFS, xStart) self.draw_vline(self.lineObwFE, self.labelObwFE, xEnd) canvas.blit(self.axes.bbox) def hide_measure(self): self.labelHalfFS.set_visible(False) self.labelHalfFE.set_visible(False) self.labelObwFS.set_visible(False) self.labelObwFE.set_visible(False) def scale_plot(self, force=False): if self.figure is not None and self.plot is not None: extent = self.plot.get_extent() if self.settings.autoF or force: if extent[0] == extent[1]: extent[1] += 1 self.axes.set_xlim(extent[0], extent[1]) if self.settings.autoL or force: vmin, vmax = self.plot.get_clim() self.barBase.set_clim(vmin, vmax) try: self.barBase.draw_all() except: pass if self.settings.autoT or force: self.axes.set_ylim(extent[2], extent[3]) def redraw_plot(self): if self.figure is not None: post_event(self.notify, EventThreadStatus(Event.DRAW)) def get_axes(self): return self.axes def get_plot_thread(self): return self.threadPlot def set_title(self, title): self.axes.set_title(title) def set_plot(self, data, extent, annotate=False): self.extent = extent self.threadPlot = ThreadPlot(self, self.axes, data, self.extent, self.settings.retainMax, self.settings.colourMap, self.settings.autoL, self.barBase, annotate) self.threadPlot.start() def clear_plots(self): children = self.axes.get_children() for child in children: if child.get_gid() is not None: if child.get_gid() == "plot" or child.get_gid() == "peak": child.remove() def set_grid(self, on): if on: self.axes.grid(True, color='w') else: self.axes.grid(False) self.redraw_plot() def set_colourmap(self, colourMap): if self.plot is not None: self.plot.set_cmap(colourMap) self.barBase.set_cmap(colourMap) try: self.barBase.draw_all() except: pass def close(self): self.figure.clear() self.figure = None
zorder=10) # hi zorder -> top # Plot tissots showing possible scale of candidate scatter. for l, b in zip(lvals, bvals): m.tissot(l, b, 5., 30, ec='none', color='g', alpha=0.25) # Show the closest candidate to each CR. for cr in CRs.values(): cand = cands[cr.near_id] m.geodesic(cr.l, cr.b, cand.l, cand.b, lw=0.5, ls='-', c='g') plt.title('UHE Cosmic Rays and Candidate Sources') plt.legend([cr_pts, cand_pts], ['UHE CR', 'Candidate'], frameon=False, loc='lower right', scatterpoints=1) # Plot a colorbar for the CR energies. cb_ax = plt.axes([0.25, .1, .5, .03], frameon=False) # rect=L,B,W,H #bar = ColorbarBase(cb_ax, cmap=cmap, orientation='horizontal', drawedges=False) vals = np.linspace(Evals.min(), Evals.max(), 100) bar = ColorbarBase(cb_ax, values=vals, norm=norm_E, cmap=cmap, orientation='horizontal', drawedges=False) bar.set_label('CR Energy (EeV)') plt.show()
def statistics(self, fns, fn, stationfn, eventinfo=None, latencies=None, computedelay=False, map=False, interactive=False): """ Compare predicted and observed alert times quantitatively. """ a = np.load(fn) lats_tt = a['lat'][:, :, 0] lons_tt = a['lon'][:, :, 0] times = np.median(a['ttP'], axis=-1) tree = spatial.KDTree(zip(lats_tt.ravel(), lons_tt.ravel())) vals = [] perc_max = 84 perc_min = 16 rp = ReportsParser(dmin=UTCDateTime(2012, 1, 1, 0, 0, 0), dmax=UTCDateTime(2013, 11, 1, 0, 0, 0)) # t = EventCA() t = EventSoCal() rp.sfilter = t.point_in_polygon for _f in fns: rp.read_reports(_f) correct = rp.get_correct(mmin=3.5, mmax=10.0) pid = correct[:, 0] ot = correct[:, 2].astype('float') lats = correct[:, 3].astype('float') lons = correct[:, 4].astype('float') deps = correct[:, 5].astype('float') mags = correct[:, 6].astype('float') ts1 = correct[:, 7].astype('float') lats1 = correct[:, 9].astype('float') lons1 = correct[:, 10].astype('float') mags1 = correct[:, 12].astype('float') rfns = correct[:, 21] diff = ts1 - ot magdiff = mags - mags1 cnt = 0 allcnt = 0 allm = [] dataX = [] dataY = [] popup_values = [] fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) m = self.background_map(ax) cmap = cm.ScalarMappable(norm=Normalize(vmin=0, vmax=2), cmap='RdBu_r') stats_used = [] for lon, lat, dep, delay, evid, lat1, lon1, dmag, time, mag, rfn in \ zip(lons, lats, deps, diff, pid, lats1, lons1, magdiff, ot, mags, rfns): allcnt += 1 try: if eventinfo is not None and len(eventinfo[evid]) != 4: # print "Event %s does not have 4 initial picks." % evid continue except KeyError: print "No event information available for: %s (%s)" % (evid, UTCDateTime(time)) continue if evid in self.event_excludes: print "Event %s was set to be excluded." % evid continue if computedelay: # Compute the expected alert time for the actual epicenter and # the first stations that detected the event class NetworkInfo: def __init__(self): self.networks = {'ca':{'lat': [], 'lon': [], 'chn': [], 'nw': [], 'nm': [], 'lc': [], 'color':'black', 'label':'UC Berkeley'}} def get_networks(self): return self.networks # read in SCEDC master station list fh = open(stationfn) scedc_stations = {} for _l in fh.readlines(): if _l.startswith('#'): continue net, sta, chan, loc, lt, ln, elev, ondate, offdate = _l.split() ns = '.'.join((net, sta)) if ns not in scedc_stations: scedc_stations[ns] = (float(lt), float(ln)) ni = NetworkInfo() for _st in eventinfo[evid]: ni.networks['ca']['lat'].append(scedc_stations[_st][0]) ni.networks['ca']['lon'].append(scedc_stations[_st][1]) ni.networks['ca']['nm'].append(_st) if _st not in stats_used: stats_used.append(_st) de = DelayEEW() elat, elon, edep, ttP, tstarget = \ de.compute(ni, np.array([float(lon)]), np.array([float(lat)]), np.array([float(dep)]), vp=6.5, vs=3.5, nnst=4, procdelay=True, nmaps=500, resultsfn=None, latencies=latencies) med = np.median(ttP) lb = scoreatpercentile(ttP, perc_min) ub = scoreatpercentile(ttP, perc_max) else: distance, index = tree.query(np.array([[lat, lon]])) irow, icol = divmod(index[0], lats_tt.shape[1]) med = np.median(times[:, irow, icol]) lb = scoreatpercentile(times[:, irow, icol], perc_min) ub = scoreatpercentile(times[:, irow, icol], perc_max) cnt += 1 allm.append(mag) val = (delay - lb) / (ub - lb) print med, lb, ub, delay, val, med - delay vals.append(val) cl = cmap.to_rgba(val) x, y = m(lon, lat) dataX.append(x) dataY.append(y) info = '%s: %.2f %s\n' % (UTCDateTime(time), mag, evid) info += '%.2f %.2f %.2f\n' % (delay, med, val) for _st in eventinfo[evid]: info += ' %s' % _st popup_values.append(info) m.plot(x, y, ms=8, c=cl, marker='o', picker=5.) # plt.figure() # plt.hist(times[ilon, ilat, :], bins=np.arange(0, 30), normed=True, histtype='step') # plt.show() print "Stations used in detections:" print stats_used idx = np.where((np.array(vals) <= 1.0) & (np.array(vals) >= 0)) print "%.1f lie within the %d and %d percentile" % ((idx[0].size / float(len(vals))) * 100, perc_min, perc_max) # plt.plot(allm, vals, 'bo') if interactive: self.popup(fig, dataX, dataY, popup_values) cax = fig.add_axes([0.87, 0.1, 0.05, 0.8]) cb = ColorbarBase(cax, cmap='RdBu_r', norm=Normalize(vmin=0, vmax=2)) cb.set_label('Alert accuracy') plt.figure() plt.hist(vals, bins=20) plt.show()
axis.set_xlim(ext[0], ext[1]) axis.set_ylim(ext[2], ext[3]) axis.imshow(to_plot[j][i], origin='lower', cmap=cmaps[i], norm=norm[i], aspect='auto', extent=ext) axis.plot(xcen, ycen, 'x', color='#000000', markersize=7, mew=1.5) cb = ColorbarBase(ax_cb[i], orientation='vertical', cmap=cmaps[i], norm=norm[i]) cb.solids.set_edgecolor('face') cb.set_label(barlab[i], fontsize=13) if i == 0: axis.text(0.5, 1.05, titles[j], ha='center', transform=axis.transAxes, fontsize=15) elif i == 1: axis.plot(x, y, color='#808080', linewidth=2) if j == 0: axis.text(-0.1, 0.5, mapname[i], va='center',
class MplCanvas(MyMplCanvas):#,gui.QWidget):#(MyMplCanvas): """ A class for displaying radar data in basic mode. In this mode, the width and height of plot are equal. Parameters ---------- title : string Plotting header label. colormap : ColorMap ColorMap object. Attributes ---------- figurecanvas : FigureCanvas The canvas for display. zoomer : list Storing zoom windows. _zoomWindow : QRectF Storing current zoom window. origin : list Storing the coordinates for onPress event. var_ : dict Storing variables for display. AZIMUTH : boolean Flag for azimuth display. RANGE_RING : boolean Flag for RANGE_RING display. COLORBAR : boolean Flag for colorbar display. PICKER_LABEL : boolean Flag for picker label display. cb : ColorbarBase Colorbar object. cMap : ColorMap ColorMap object. pressEvent : event Press event. pressed : boolean Flag for press event. deltaX : float X change of rubberband. Zoom window only when the change is greater than ZOOM_WINDOW_PIXEL_LIMIT. deltaY : float Y change of rubberband. startX : float Rubberband start x value. startY : float Rubberband start y value. moveLabel : QLabel Picker label sweep : Sweep Sweep object. ranges : list Sweep ranges varName : string Storing current display variable name. x : list Storing sweep x values. y : list Storing sweep y values. label : string Storing header label and sweep time stamp """ def __init__(self, title, colormap, parent=None, width=3, height=3, dpi=100): self.fig = Figure()#plt.figure()#figsize=(width, height), dpi=dpi) plt.axis('off') self.axes = self.fig.add_subplot(111,aspect='equal') self.fig.set_dpi( dpi ) self.headerLabel = title #self.axes.hold(False) #self.fig.canvas.mpl_connect('pick_event', self.onpick) self.figurecanvas = FigureCanvas.__init__(self, self.fig) self.setParent(parent) FigureCanvas.setSizePolicy(self, gui.QSizePolicy.Expanding, gui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) self.setWindow(core.QRectF(-1. * RENDER_PIXELS/2., 1. * RENDER_PIXELS/2., 1. * RENDER_PIXELS, -1. * RENDER_PIXELS)) # self.origins = core.QPoint() self.ignorePaint = False #self.bottomRight = core.QPoint() self.rubberBand = gui.QRubberBand(gui.QRubberBand.Rectangle, self) self.zoomer = [] # self.picker = [] self.origin = [RENDER_PIXELS,RENDER_PIXELS] self.scaleFactor = 1.0 # self.offsetX = 0.0 # self.offsetY = 0.0 self.var_ = {} self.AZIMUTH = False self.RANGE_RING = False self.COLORBAR = True self.PICKER_LABEL = False self.cb = None self.cMap = colormap self.pressEvent = None self.pressed = False self.deltaX = 0. self.deltaY = 0. self.startX = None self.startY = None self.moveLabel = gui.QLabel("",self) self.moveLabel.setText("") self.moveLabel.hide() self.moveLabel.setStyleSheet("font-size:12px; margin:3px; padding:4px; background:#FFFFFF; border:2px solid #000;") self.mpl_connect('button_press_event', self.onPress) self.mpl_connect('button_release_event', self.onRelease) self.mpl_connect('motion_notify_event', self.onMove) def onPress(self,event): """ method called when mouse press""" if event.button == 1: ## left button xdata = event.xdata ydata = event.ydata # check if mouse is outside the figure if xdata is None or ydata is None: return self.pressed = True self.pressEvent = event self.origin = core.QPoint(event.x, self.height() - event.y) self.rubberBand.setGeometry(core.QRect(self.origin, core.QSize())) self.rubberBand.show() # start point self.startX = xdata self.startY = ydata if event.button == 2: ## middle botton - zoom in the center pass if event.button == 3: pass def onMove(self,event): """ method called when mouse moves """ xdata = event.xdata ydata = event.ydata if xdata is None or ydata is None: self.moveLabel.hide() return if self.pressed: ## display rubberband if self.PICKER_LABEL: self.moveLabel.hide() deltaX = event.x - self.pressEvent.x ## moved distance deltaY = event.y - self.pressEvent.y ## for rubberband dx = dy = min(fabs(deltaX),fabs(deltaY)) if deltaX<0: dx = -dx if deltaY<0: dy = -dy newRect = core.QRect(self.origin.x(), self.origin.y(), int(dx), -int(dy)) newRect = newRect.normalized() self.rubberBand.setGeometry(newRect) self.deltaX = dx self.deltaY = dy else: ## display label if self.PICKER_LABEL: i,j = self.retrieve_z_value(xdata,ydata) self.moveLabel.show() if i is not None and j is not None: # self.moveLabel.setText(core.QString(r"x=%g, y=%g, z=%g" % (xdata,ydata,self.var_[i][j]))) ## TODO: should use xdata or self.x[i][j] self.moveLabel.setText(r"x=%g, y=%g, z=%g" % (xdata,ydata,self.var_[i][j])) ## TODO: should use xdata or self.x[i][j] else: # self.moveLabel.setText(core.QString(r"x=%g, y=%g, z=n/a" % (xdata,ydata))) self.moveLabel.setText(r"x=%g, y=%g, z=n/a" % (xdata,ydata)) self.moveLabel.adjustSize() offset = 10 if self.width()-event.x < self.moveLabel.width(): offset = -10 - self.moveLabel.width() self.moveLabel.move(event.x+offset,self.height()-event.y) def retrieve_z_value(self, xdata, ydata): #xpos = np.argmin(np.abs(xdata-self.x)) #ypos = np.argmin(np.abs(ydata-self.y)) MIN = 99999 iv = None jv = None for i in range(len(self.x)): j = self.findNearest(np.copy(self.x[i]),xdata) if j is not None: d = self.distance(xdata,ydata,self.x[i][j],self.y[i][j]) if d < MIN: iv = i jv = j MIN = d return iv,jv def onRelease(self,event): """ method called when mouse button is released """ if event.button == 1: self.pressed = False self.rubberBand.hide() xdata = event.xdata ## mouse real position ydata = event.ydata if xdata is None or ydata is None or self.startX is None or self.startY is None: return d0 = self.width() * FIGURE_CANCAS_RATIO x_range = self.axes.get_xlim()[1]-self.axes.get_xlim()[0] y_range = self.axes.get_ylim()[1]-self.axes.get_ylim()[0] (x1,y1) = self.startX, self.startY (x2,y2) = x1 + self.deltaX/d0 * x_range, y1+self.deltaY/d0 * y_range oldRect = core.QRectF() # last rubberband rect oldRect.setLeft(self.axes.get_xlim()[0]) oldRect.setRight(self.axes.get_xlim()[1]) oldRect.setBottom(self.axes.get_ylim()[0]) oldRect.setTop(self.axes.get_ylim()[1]) rect = core.QRectF() # current rubberband rect rect.setLeft(min(x1,x2)) rect.setRight(max(x1,x2)) rect.setBottom(min(y1,y2)) rect.setTop(max(y1,y2)) ## react only when draged region is greater than 0.01 times of old rect if fabs(self.deltaX)>ZOOM_WINDOW_PIXEL_LIMIT and \ fabs(rect.width())>ZOOM_WINDOW_WIDTH_LIMIT and \ fabs(rect.width()) >= 0.01*fabs(oldRect.width()): self.zoomer.append(oldRect) self.zoomTo(rect) self._zoomWindow = rect def zoomTo(self,rect): """ adjust zoom winodw to rect """ self.axes.set_xlim(rect.left(),rect.right()) self.axes.set_ylim(rect.bottom(),rect.top()) self.draw() def findNearest(self, array, target): """ find nearest value to target and return its index """ diff = abs(array - target) mask = np.ma.greater(diff, 0.151) ## TODO: select a threshold (range:meters_between_gates = 150.000005960464) if np.all(mask): return None # returns None if target is greater than any value masked_diff = np.ma.masked_array(diff, mask) return masked_diff.argmin() def distance(self, x1, y1, x2, y2): """ calculate distance between two points """ return sqrt((x1-x2)**2 + (y1-y2)**2) ## TODO: formula def sizeHint(self): w, h = self.get_width_height() return core.QSize(w, h) def minimumSizeHint(self): return core.QSize(10, 10) def setWindow(self, window): """ initialize the full window to use for this widget """ self._zoomWindow = window self._aspectRatio = window.width() / window.height() def resizeEvent(self, event): """ method called when resize window """ sz = event.size() width = sz.width() height = sz.height() dpival = self.fig.dpi winch = float(width)/dpival hinch = float(height)/dpival self.fig.set_size_inches( winch, hinch ) #self.draw() #self.update() self.fig.canvas.draw() self.origin = [width,height] def drawSweep(self, sweep, varName, beamWidth): """ draw sweep """ self.beamWidth = beamWidth self.ranges = sweep.ranges self.sweep = sweep self.varName = varName.lower() self.var_ = sweep.vars_[varName] #in list self.x = sweep.x self.y = sweep.y self.label = self.headerLabel + sweep.timeLabel self.update_figure() #update figure def update_figure(self): """ update figure - need to call it explicitly """ if len(self.var_) > 0: self.axes.clear() # avoid missing values of -32768 self.var_ = np.ma.array(self.var_, mask=(self.var_ < -32000)) vmin = min(min(x) for x in self.var_) vmax = max(max(x) for x in self.var_) im = self.axes.pcolormesh(self.x,self.y,self.var_, vmin=vmin, vmax=vmax, cmap=self.cMap(self.varName)) ## setup zeniths, azimuths, and colorbar if self.RANGE_RING: self.draw_range_ring() if self.AZIMUTH: self.draw_azimuth_line() if self.COLORBAR: self.draw_colorbar(im,vmin,vmax) #self.x[0:359]/1e3,self.y[0:359]/1e3,self.var_,vmin=vmin, vmax=vmax) #plt.axis('off') ## show x, y axes or not #self.adjustZoomWindow() ## zoomWindow will not change for different variable - keep using the current zoom window self.zoomTo(self._zoomWindow) self.axes.set_title(self.label, size=9) ## TODO: change size to be adaptive self.fig.canvas.draw() ## draw contour - a new feature - grayscale, no zoom in/out support ## self.axes.contour(self.x,self.y,self.var_,[0.5], linewidths=2., colors='k') #self.fig.canvas.blit(self.axes.bbox) def draw_azimuth_line(self): """ draw azimuths with 30-degree intervals """ angles = np.arange(0, 360, 30) labels = [90,60,30,0,330,300,270,240,210,180,150,120] x = R * np.cos(np.pi*angles/180) y = R * np.sin(np.pi*angles/180) for xi,yi,ang,lb in zip(x,y,angles,labels): line = plt.Line2D([0,xi],[0,yi],linestyle='dashed',color='lightgray',lw=0.8) self.axes.add_line(line) xo,yo = 0,0 if ang>90 and ang<180: xo = -10 yo = 3 elif ang == 180: xo = -15 yo = -3 elif ang>180 and ang<270: xo = -12 yo = -10 elif ang == 270: xo = -10 yo = -8 elif ang >270 and ang<360: yo = -5 self.axes.annotate(str(lb), xy=(xi,yi), xycoords='data', xytext=(xo,yo), textcoords='offset points', arrowprops=None,size=10) def draw_range_ring(self): """ draw zeniths with 30 intervals """ zeniths = np.arange(0,R+1,30) angle = 135. for r in zeniths: circ = plt.Circle((0, 0),radius=r,linestyle='dashed',color='lightgray',lw=0.8,fill=False) self.axes.add_patch(circ) x = R * np.cos(np.pi*angle/180.) * r/R y = R * np.sin(np.pi*angle/180.) * r/R print 'r=',r, x, y self.axes.annotate(int(r), xy=(x,y), xycoords='data', arrowprops=None,size=10) def draw_colorbar(self,im,vmin,vmax): """ draw colorbar """ if self.cb: self.fig.delaxes(self.fig.axes[1]) self.fig.subplots_adjust(right=0.90) pos = self.axes.get_position() l, b, w, h = pos.bounds cax = self.fig.add_axes([l, b-0.06, w, 0.03]) # colorbar axes cmap=self.cMap(self.varName) substName = self.varName if not self.cMap.ticks_label.has_key(self.varName): # we couldn't find 'vel_f', so try searching for 'vel' u = self.varName.find('_') if u: substName = self.varName[:u] if not self.cMap.ticks_label.has_key(substName): msgBox = gui.QMessageBox() msgBox.setText( """ Please define a color scale for '{0}' in your configuration file """.format(self.varName)) msgBox.exec_() raise RuntimeError( """ Please define a color scale for '{0}' in your configuration file """.format(self.varName)) bounds = self.cMap.ticks_label[substName] norm = mpl.colors.BoundaryNorm(bounds, cmap.N) self.cb = ColorbarBase(cax, cmap=cmap, norm=norm, orientation='horizontal', boundaries=bounds,ticks=bounds)#, format='%1i') ## spacing='proportional' -- divide proportionally by the value self.cb.ax.tick_params(labelsize=8) #t = [str(int(i)) for i in bounds] t = [str(i) for i in bounds] self.cb.set_ticklabels(t,update_ticks=True) self.cb.set_label('Color Scale', size=8) def resetFactors(self): """ reset factors """ self.zoomer = [] self.setWindow(core.QRect(-1 * RENDER_PIXELS/2, 1 * RENDER_PIXELS/2, 1 * RENDER_PIXELS, 1 * RENDER_PIXELS)) # self.update_figure() self.fig.canvas.draw() def changeZoomerPointer(self, ind=None): """ method called when mouse button is pressed, changing zoomer pointer """ if ind is None: if len(self.zoomer)>0: zoomWindow = self.zoomer[-1] self.zoomTo(zoomWindow) self.zoomer.pop() else: if len(self.zoomer)>0: zoomWindow = self.zoomer[0] self.zoomTo(zoomWindow) self.zoomer=[] def getAspectRatio(self): return self._aspectRatio def keyPressEvent(self, event): """ method called when key press """ print 'RadialDisplay::keyPressEvent: ', event.key() if event.key() == core.Qt.Key_C: self.resetFactors() event.accept() '''
class MplCanvas(MyMplCanvas): #,gui.QWidget):#(MyMplCanvas): """ A class for displaying radar data in basic mode. In this mode, the width and height of plot are equal. Parameters ---------- title : string Plotting header label. colormap : ColorMap ColorMap object. Attributes ---------- figurecanvas : FigureCanvas The canvas for display. zoomer : list Storing zoom windows. _zoomWindow : QRectF Storing current zoom window. origin : list Storing the coordinates for onPress event. var_ : dict Storing variables for display. AZIMUTH : boolean Flag for azimuth display. RANGE_RING : boolean Flag for RANGE_RING display. COLORBAR : boolean Flag for colorbar display. PICKER_LABEL : boolean Flag for picker label display. cb : ColorbarBase Colorbar object. cMap : ColorMap ColorMap object. pressEvent : event Press event. pressed : boolean Flag for press event. deltaX : float X change of rubberband. Zoom window only when the change is greater than ZOOM_WINDOW_PIXEL_LIMIT. deltaY : float Y change of rubberband. startX : float Rubberband start x value. startY : float Rubberband start y value. moveLabel : QLabel Picker label sweep : Sweep Sweep object. ranges : list Sweep ranges varName : string Storing current display variable name. x : list Storing sweep x values. y : list Storing sweep y values. label : string Storing header label and sweep time stamp """ def __init__(self, title, colormap, parent=None, width=3, height=3, dpi=100): self.fig = Figure() #plt.figure()#figsize=(width, height), dpi=dpi) plt.axis('off') self.axes = self.fig.add_subplot(111, aspect='equal') self.fig.set_dpi(dpi) self.headerLabel = title #self.axes.hold(False) #self.fig.canvas.mpl_connect('pick_event', self.onpick) self.figurecanvas = FigureCanvas.__init__(self, self.fig) self.setParent(parent) FigureCanvas.setSizePolicy(self, gui.QSizePolicy.Expanding, gui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) self.setWindow( core.QRectF(-1. * RENDER_PIXELS / 2., 1. * RENDER_PIXELS / 2., 1. * RENDER_PIXELS, -1. * RENDER_PIXELS)) # self.origins = core.QPoint() self.ignorePaint = False #self.bottomRight = core.QPoint() self.rubberBand = gui.QRubberBand(gui.QRubberBand.Rectangle, self) self.zoomer = [] # self.picker = [] self.origin = [RENDER_PIXELS, RENDER_PIXELS] self.scaleFactor = 1.0 # self.offsetX = 0.0 # self.offsetY = 0.0 self.var_ = {} self.AZIMUTH = False self.RANGE_RING = False self.COLORBAR = True self.PICKER_LABEL = False self.cb = None self.cMap = colormap self.pressEvent = None self.pressed = False self.deltaX = 0. self.deltaY = 0. self.startX = None self.startY = None self.moveLabel = gui.QLabel("", self) self.moveLabel.setText("") self.moveLabel.hide() self.moveLabel.setStyleSheet( "font-size:12px; margin:3px; padding:4px; background:#FFFFFF; border:2px solid #000;" ) self.mpl_connect('button_press_event', self.onPress) self.mpl_connect('button_release_event', self.onRelease) self.mpl_connect('motion_notify_event', self.onMove) def onPress(self, event): """ method called when mouse press""" if event.button == 1: ## left button xdata = event.xdata ydata = event.ydata # check if mouse is outside the figure if xdata is None or ydata is None: return self.pressed = True self.pressEvent = event self.origin = core.QPoint(event.x, self.height() - event.y) self.rubberBand.setGeometry(core.QRect(self.origin, core.QSize())) self.rubberBand.show() # start point self.startX = xdata self.startY = ydata if event.button == 2: ## middle botton - zoom in the center pass if event.button == 3: pass def onMove(self, event): """ method called when mouse moves """ xdata = event.xdata ydata = event.ydata if xdata is None or ydata is None: self.moveLabel.hide() return if self.pressed: ## display rubberband if self.PICKER_LABEL: self.moveLabel.hide() deltaX = event.x - self.pressEvent.x ## moved distance deltaY = event.y - self.pressEvent.y ## for rubberband dx = dy = min(fabs(deltaX), fabs(deltaY)) if deltaX < 0: dx = -dx if deltaY < 0: dy = -dy newRect = core.QRect(self.origin.x(), self.origin.y(), int(dx), -int(dy)) newRect = newRect.normalized() self.rubberBand.setGeometry(newRect) self.deltaX = dx self.deltaY = dy else: ## display label if self.PICKER_LABEL: i, j = self.retrieve_z_value(xdata, ydata) self.moveLabel.show() if i is not None and j is not None: # self.moveLabel.setText(core.QString(r"x=%g, y=%g, z=%g" % (xdata,ydata,self.var_[i][j]))) ## TODO: should use xdata or self.x[i][j] self.moveLabel.setText( r"x=%g, y=%g, z=%g" % (xdata, ydata, self.var_[i][j]) ) ## TODO: should use xdata or self.x[i][j] else: # self.moveLabel.setText(core.QString(r"x=%g, y=%g, z=n/a" % (xdata,ydata))) self.moveLabel.setText(r"x=%g, y=%g, z=n/a" % (xdata, ydata)) self.moveLabel.adjustSize() offset = 10 if self.width() - event.x < self.moveLabel.width(): offset = -10 - self.moveLabel.width() self.moveLabel.move(event.x + offset, self.height() - event.y) def retrieve_z_value(self, xdata, ydata): #xpos = np.argmin(np.abs(xdata-self.x)) #ypos = np.argmin(np.abs(ydata-self.y)) MIN = 99999 iv = None jv = None for i in range(len(self.x)): j = self.findNearest(np.copy(self.x[i]), xdata) if j is not None: d = self.distance(xdata, ydata, self.x[i][j], self.y[i][j]) if d < MIN: iv = i jv = j MIN = d return iv, jv def onRelease(self, event): """ method called when mouse button is released """ if event.button == 1: self.pressed = False self.rubberBand.hide() xdata = event.xdata ## mouse real position ydata = event.ydata if xdata is None or ydata is None or self.startX is None or self.startY is None: return d0 = self.width() * FIGURE_CANCAS_RATIO x_range = self.axes.get_xlim()[1] - self.axes.get_xlim()[0] y_range = self.axes.get_ylim()[1] - self.axes.get_ylim()[0] (x1, y1) = self.startX, self.startY ( x2, y2 ) = x1 + self.deltaX / d0 * x_range, y1 + self.deltaY / d0 * y_range oldRect = core.QRectF() # last rubberband rect oldRect.setLeft(self.axes.get_xlim()[0]) oldRect.setRight(self.axes.get_xlim()[1]) oldRect.setBottom(self.axes.get_ylim()[0]) oldRect.setTop(self.axes.get_ylim()[1]) rect = core.QRectF() # current rubberband rect rect.setLeft(min(x1, x2)) rect.setRight(max(x1, x2)) rect.setBottom(min(y1, y2)) rect.setTop(max(y1, y2)) ## react only when draged region is greater than 0.01 times of old rect if fabs(self.deltaX)>ZOOM_WINDOW_PIXEL_LIMIT and \ fabs(rect.width())>ZOOM_WINDOW_WIDTH_LIMIT and \ fabs(rect.width()) >= 0.01*fabs(oldRect.width()): self.zoomer.append(oldRect) self.zoomTo(rect) self._zoomWindow = rect def zoomTo(self, rect): """ adjust zoom winodw to rect """ self.axes.set_xlim(rect.left(), rect.right()) self.axes.set_ylim(rect.bottom(), rect.top()) self.draw() def findNearest(self, array, target): """ find nearest value to target and return its index """ diff = abs(array - target) mask = np.ma.greater( diff, 0.151 ) ## TODO: select a threshold (range:meters_between_gates = 150.000005960464) if np.all(mask): return None # returns None if target is greater than any value masked_diff = np.ma.masked_array(diff, mask) return masked_diff.argmin() def distance(self, x1, y1, x2, y2): """ calculate distance between two points """ return sqrt((x1 - x2)**2 + (y1 - y2)**2) ## TODO: formula def sizeHint(self): w, h = self.get_width_height() return core.QSize(w, h) def minimumSizeHint(self): return core.QSize(10, 10) def setWindow(self, window): """ initialize the full window to use for this widget """ self._zoomWindow = window self._aspectRatio = window.width() / window.height() def resizeEvent(self, event): """ method called when resize window """ sz = event.size() width = sz.width() height = sz.height() dpival = self.fig.dpi winch = float(width) / dpival hinch = float(height) / dpival self.fig.set_size_inches(winch, hinch) #self.draw() #self.update() self.fig.canvas.draw() self.origin = [width, height] def drawSweep(self, sweep, varName, beamWidth): """ draw sweep """ self.beamWidth = beamWidth self.ranges = sweep.ranges self.sweep = sweep self.varName = varName.lower() self.var_ = sweep.vars_[varName] #in list self.x = sweep.x self.y = sweep.y self.label = self.headerLabel + sweep.timeLabel self.update_figure() #update figure def update_figure(self): """ update figure - need to call it explicitly """ if len(self.var_) > 0: self.axes.clear() vmin = min(min(x) for x in self.var_) vmax = max(max(x) for x in self.var_) im = self.axes.pcolormesh(self.x, self.y, self.var_, vmin=vmin, vmax=vmax, cmap=self.cMap(self.varName)) ## setup zeniths, azimuths, and colorbar if self.RANGE_RING: self.draw_range_ring() if self.AZIMUTH: self.draw_azimuth_line() if self.COLORBAR: self.draw_colorbar(im, vmin, vmax) #self.x[0:359]/1e3,self.y[0:359]/1e3,self.var_,vmin=vmin, vmax=vmax) #plt.axis('off') ## show x, y axes or not #self.adjustZoomWindow() ## zoomWindow will not change for different variable - keep using the current zoom window self.zoomTo(self._zoomWindow) self.axes.set_title(self.label, size=9) ## TODO: change size to be adaptive self.fig.canvas.draw() ## draw contour - a new feature - grayscale, no zoom in/out support ## self.axes.contour(self.x,self.y,self.var_,[0.5], linewidths=2., colors='k') #self.fig.canvas.blit(self.axes.bbox) def draw_azimuth_line(self): """ draw azimuths with 30-degree intervals """ angles = np.arange(0, 360, 30) labels = [90, 60, 30, 0, 330, 300, 270, 240, 210, 180, 150, 120] x = R * np.cos(np.pi * angles / 180) y = R * np.sin(np.pi * angles / 180) for xi, yi, ang, lb in zip(x, y, angles, labels): line = plt.Line2D([0, xi], [0, yi], linestyle='dashed', color='lightgray', lw=0.8) self.axes.add_line(line) xo, yo = 0, 0 if ang > 90 and ang < 180: xo = -10 yo = 3 elif ang == 180: xo = -15 yo = -3 elif ang > 180 and ang < 270: xo = -12 yo = -10 elif ang == 270: xo = -10 yo = -8 elif ang > 270 and ang < 360: yo = -5 self.axes.annotate(str(lb), xy=(xi, yi), xycoords='data', xytext=(xo, yo), textcoords='offset points', arrowprops=None, size=10) def draw_range_ring(self): """ draw zeniths with 30 intervals """ zeniths = np.arange(0, R + 1, 30) angle = 135. for r in zeniths: circ = plt.Circle((0, 0), radius=r, linestyle='dashed', color='lightgray', lw=0.8, fill=False) self.axes.add_patch(circ) x = R * np.cos(np.pi * angle / 180.) * r / R y = R * np.sin(np.pi * angle / 180.) * r / R print 'r=', r, x, y self.axes.annotate(int(r), xy=(x, y), xycoords='data', arrowprops=None, size=10) def draw_colorbar(self, im, vmin, vmax): """ draw colorbar """ if self.cb: self.fig.delaxes(self.fig.axes[1]) self.fig.subplots_adjust(right=0.90) pos = self.axes.get_position() l, b, w, h = pos.bounds cax = self.fig.add_axes([l, b - 0.06, w, 0.03]) # colorbar axes cmap = self.cMap(self.varName) substName = self.varName if not self.cMap.ticks_label.has_key(self.varName): # we couldn't find 'vel_f', so try searching for 'vel' u = self.varName.find('_') if u: substName = self.varName[:u] if not self.cMap.ticks_label.has_key(substName): msgBox = gui.QMessageBox() msgBox.setText( """ Please define a color scale for '{0}' in your configuration file """ .format(self.varName)) msgBox.exec_() raise RuntimeError( """ Please define a color scale for '{0}' in your configuration file """ .format(self.varName)) bounds = self.cMap.ticks_label[substName] norm = mpl.colors.BoundaryNorm(bounds, cmap.N) self.cb = ColorbarBase( cax, cmap=cmap, norm=norm, orientation='horizontal', boundaries=bounds, ticks=bounds ) #, format='%1i') ## spacing='proportional' -- divide proportionally by the value self.cb.ax.tick_params(labelsize=8) #t = [str(int(i)) for i in bounds] t = [str(i) for i in bounds] self.cb.set_ticklabels(t, update_ticks=True) self.cb.set_label('Color Scale', size=8) def resetFactors(self): """ reset factors """ self.zoomer = [] self.setWindow( core.QRect(-1 * RENDER_PIXELS / 2, 1 * RENDER_PIXELS / 2, 1 * RENDER_PIXELS, 1 * RENDER_PIXELS)) # self.update_figure() self.fig.canvas.draw() def changeZoomerPointer(self, ind=None): """ method called when mouse button is pressed, changing zoomer pointer """ if ind is None: if len(self.zoomer) > 0: zoomWindow = self.zoomer[-1] self.zoomTo(zoomWindow) self.zoomer.pop() else: if len(self.zoomer) > 0: zoomWindow = self.zoomer[0] self.zoomTo(zoomWindow) self.zoomer = [] def getAspectRatio(self): return self._aspectRatio def keyPressEvent(self, event): """ method called when key press """ print 'RadialDisplay::keyPressEvent: ', event.key() if event.key() == core.Qt.Key_C: self.resetFactors() event.accept() '''
for svg_file in svg_files: index = float(svg_file.rsplit('_', 1)[-1].rstrip('.svg')) if int(index) > max_wind_index: continue wind = index * index2ms color = rgb2hex(cmap(int(round(index * cmap.N / max_wind_index)))) out_file = outdir + '/' + svg_file.rsplit('/')[-1] with open(svg_file, 'r') as infile, open(out_file, 'w') as outfile: line = infile.readline() while line: outfile.write(line) line = infile.readline() line = line.replace('#000000', str(color)) indices.append(index) winds.append(wind) colors.append(color) for (index, wind, color) in sorted(zip(indices, winds, colors)): print "{:2.0f} {:5.1f} {}".format(index, wind, color) # Create an image showing the colorbar for the choosen colormap fig = plt.figure(figsize=(1, 3.2), dpi=100) ax = fig.add_axes([0.05, 0.05, 0.45, 0.9]) cb = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='vertical') cbytick_obj = plt.getp(cb.ax.axes, 'yticklabels') plt.setp(cbytick_obj, fontsize=8) cb.set_label('Wind speed (mph)', fontsize=9) plt.savefig(outdir + '/amv_winds_key.png', transparent=True)
def alert_times_map(self, fns, m=None, fig=None, ax=None, scale=10000., cb=True, disterr=False, interactive=False, eventinfo=None, msscale=1, cmapname='jet'): """ Plot a map of observed alert times. """ cmap = cm.ScalarMappable(norm=Normalize(vmin=6, vmax=25), cmap=cmapname) rp = ReportsParser(dmin=UTCDateTime(2012, 1, 1, 0, 0, 0), dmax=UTCDateTime(2013, 11, 1, 0, 0, 0)) t = EventCA() rp.sfilter = t.point_in_polygon for _f in fns: rp.read_reports(_f) correct = rp.get_correct(mmin=3.5, mmax=10.0) pid = correct[:, 0] ot = correct[:, 2].astype('float') lats = correct[:, 3].astype('float') lons = correct[:, 4].astype('float') mags = correct[:, 6].astype('float') ts1 = correct[:, 7].astype('float') lats1 = correct[:, 9].astype('float') lons1 = correct[:, 10].astype('float') mags1 = correct[:, 12].astype('float') rfns = correct[:, 21] diff = ts1 - ot magdiff = mags - mags1 if m is None and fig is None and ax is None: fig = plt.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) m = self.background_map(ax) dataX = [] dataY = [] values = [] # load event info cnt = 0 allcnt = 0 for lon, lat, delay, evid, lat1, lon1, dmag, time, mag, rfn in \ zip(lons, lats, diff, pid, lats1, lons1, magdiff, ot, mags, rfns): allcnt += 1 try: if eventinfo is not None and len(eventinfo[evid]) != 4: print "Event %s does not have 4 initial picks." % evid continue except KeyError: print "No event information available for: %s (%s)" % (evid, UTCDateTime(time)) continue if evid in self.event_excludes: print "Event %s was set to be excluded." % evid continue cnt += 1 ddist, az, baz = gps2DistAzimuth(lat, lon, lat1, lon1) ddist /= 1000. x, y = m(lon, lat) dataX.append(x) dataY.append(y) info = '%s: %.2f %.2f %s' % (UTCDateTime(time), delay, mag, evid) for _st in eventinfo[evid]: info += ' %s' % _st values.append(info) cl = cmap.to_rgba(delay) if disterr: factor = math.sqrt(abs(float(ddist))) sl2 = scale * factor p2 = Wedge((x, y), sl2, 0, 360, facecolor=cl, edgecolor='black', picker=5, lw=1.0) ax.add_patch(p2) else: m.plot(x, y, ms=8 * msscale, c=cl, marker='o', picker=5.) print "Plotted %d out of %d events." % (cnt, allcnt) if interactive: self.popup(fig, dataX, dataY, values) if cb: # Colorbar cax = fig.add_axes([0.87, 0.1, 0.05, 0.8]) cb = ColorbarBase(cax, cmap=cmapname, norm=Normalize(vmin=6., vmax=25.)) cb.set_label('Time since origin time [s]')
def create_multipanel_plot(size, dpi, shape, layout, var_info, cmap, lims): fig = plt.figure(figsize=size, dpi=dpi) rings = [] # the rect parameter will be ignore as we will set axes_locator rect = (0.08, 0.08, 0.9, 0.9) nrow,ncol = shape # divide the axes rectangle into grid whose size is specified # by horiz * vert horiz = [Scaled(1.)] for i in range(ncol - 1): horiz.extend([Fixed(.2), Scaled(1.)]) vert = [Scaled(.1), Fixed(.35), Scaled(1.)] for i in range(nrow - 1): vert.extend([Fixed(.1), Scaled(1.)]) divider = Divider(fig, rect, horiz, vert, aspect=False) # ax0 = fig.add_axes(rect, label="0") # ax0.set_aspect('equal', 'datalim') # ax = [ax0] + [fig.add_axes(rect, label="%d"%i, sharex=ax0, sharey=ax0) # for i in range(1,6)] ax = [fig.add_axes(rect, label="%d"%i) for i in range(len(layout))] cax = [fig.add_axes(rect, label='cb%d'%i) for i in range(ncol)] for i,a in enumerate(ax): # a.set_axes_locator(divider.new_locator(nx=(i // nrow) * 2, # ny=((i%nrow) + 1) * 2)) a.set_axes_locator(divider.new_locator(nx=(i % ncol) * 2, ny=(nrow - (i // ncol)) * 2)) a.set_aspect('equal', 'datalim') for i,a in enumerate(cax): a.set_axes_locator(divider.new_locator(nx=2 * i, ny=0)) for num,(a,(data, label, var)) in enumerate(zip(ax, layout)): norm,ticks,units = var_info[var] ppi_plot(init_data.xlocs, init_data.ylocs, data, norm=norm, cmap=cmap, ax=a, rings=rings) # a.set_title('%s (%s)' % (moment, units)) if num >= ncol: a.set_xlabel('X Distance (km)') cbar = ColorbarBase(ax=cax[num%ncol], norm=norm, cmap=cmap, orientation='horizontal') cbar.set_label('%s (%s)' % (label, units)) cbar.set_ticks(ticks) else: a.xaxis.set_major_formatter(plt.NullFormatter()) if num % ncol == 0: a.set_ylabel('Y Distance (km)') else: a.yaxis.set_major_formatter(plt.NullFormatter()) if lims: a.xaxis.set_major_locator(plt.MultipleLocator(lims[0])) a.yaxis.set_major_locator(plt.MultipleLocator(lims[0])) a.set_xlim(*lims[1:3]) a.set_ylim(*lims[3:]) # loc = 2 is upper left. TODO: Should patch matplotlib to use # same strings as legend at = AnchoredText("%s)" % chr(97 + num), loc=2, prop=dict(size='large'), frameon=True) # at.patch.set_boxstyle("round, pad=0., rounding_size=0.2") a.add_artist(at) return fig
ppi_plot(init_data.xlocs, init_data.ylocs, init_data.vel_h_ts, norm=vel_norm, cmap=cmap, ax=ax4, rings=rings) ax4.set_title('TS Velocity (m/s)') ax6 = fig.add_subplot(nrow, ncol, 6, sharex=ax, sharey=ax) ppi_plot(init_data.xlocs, init_data.ylocs, init_data.spw_h_ts, norm=spw_norm, cmap=cmap, ax=ax6, rings=rings) ax6.set_title('TS Spectrum Width (m/s)') fig.subplots_adjust(bottom=0.15) lpos = list(ax.get_position().bounds) lpos[1] = 0.04 lpos[3] = 0.04 cax_left = fig.add_axes(lpos) cbar_left = ColorbarBase(ax=cax_left, norm=pwr_norm, cmap=cmap, orientation='horizontal') cbar_left.set_label('Power (dBm)') mpos = list(ax3.get_position().bounds) mpos[1] = 0.04 mpos[3] = 0.04 cax_mid = fig.add_axes(mpos) cbar_mid = ColorbarBase(ax=cax_mid, norm=vel_norm, cmap=cmap, orientation='horizontal') cbar_mid.set_label('Velocity (m/s)') rpos = list(ax5.get_position().bounds) rpos[1] = 0.04 rpos[3] = 0.04 cax_right = fig.add_axes(rpos) cbar_right = ColorbarBase(ax=cax_right, norm=spw_norm, cmap=cmap, orientation='horizontal')
def runtest(lmaManager=None, lma_view=None, HDFmanagers=None): # colormap = get_cmap('gist_yarg_r') colormap = get_cmap('gist_earth') density_maxes = [] total_counts = [] all_t = [] for delta_minutes in minute_intervals: time_delta = DateTimeDelta(0, 0, delta_minutes, 0) n_frames = int(ceil((end_time - start_time) / time_delta)) n_cols = 6 n_rows = int(ceil( float(n_frames) / n_cols )) w, h = figaspect(float(n_rows)/n_cols) xedge=np.arange(b.x[0], b.x[1]+dx, dx) yedge=np.arange(b.y[0], b.y[1]+dy, dy) x_range = b.x[1] - b.x[0] y_range = b.y[1] - b.y[0] min_count, max_count = 1, max_count_baseline*delta_minutes f = figure(figsize=(w,h)) p = small_multiples_plot(fig=f, rows=n_rows, columns=n_cols) p.label_edges(True) for ax in p.multiples.flat: ax.yaxis.set_major_formatter(kilo_formatter) ax.xaxis.set_major_formatter(kilo_formatter) for i in range(n_frames): frame_start = start_time + i*time_delta frame_end = frame_start + time_delta b.sec_of_day = (frame_start.abstime, frame_end.abstime) b.t = (frame_start, frame_end) do_plot = False flash_extent_density = True density = None if source_density==True: lmaManager.refresh(b) lma_view.transformed.cache_is_old() x,y,t=lma_view.transformed['x','y','t'] density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) do_plot=True else: for lmaManager in HDFmanagers: # yes, loop through every file every time and reselect data. # so wrong, yet so convenient. h5 = lmaManager.h5file if flash_extent_density == False: lmaManager.refresh(b) lma_view = AcuityView(DataSelection(lmaManager.data, b), mapProj, bounds=b) # lma_view.transformed.cache_is_old() x,y,t=lma_view.transformed['x','y','t'] if x.shape[0] > 1: do_plot = True break else: # assume here that the bounds sec_of_day day is the same as # the dataset day t0, t1 = b.sec_of_day # events = getattr(h5.root.events, lmaManager.table.name)[:] # flashes = getattr(h5.root.flashes, lmaManager.table.name)[:] event_dtype = getattr(h5.root.events, lmaManager.table.name)[0].dtype events_all = getattr(h5.root.events, lmaManager.table.name)[:] flashes = getattr(h5.root.flashes, lmaManager.table.name) def event_yielder(evs, fls): these_events = [] for fl in fls: if ( (fl['n_points']>9) & (t0 < fl['start']) & (fl['start'] <= t1) ): these_events = evs[evs['flash_id'] == fl['flash_id']] if len(these_events) <> fl['n_points']: print 'not giving all ', fl['n_points'], ' events? ', these_events.shape for an_ev in these_events: yield an_ev # events = np.fromiter((an_ev for an_ev in ( events_all[events_all['flash_id'] == fl['flash_id']] # for fl in flashes if ( # (fl['n_points']>9) & (t0 < fl['start']) & (fl['start'] <= t1) # ) # ) ), dtype=event_dtype) events = np.fromiter(event_yielder(events_all, flashes), dtype=event_dtype) # print events['flash_id'].shape ### Flash extent density ### x,y,z = mapProj.fromECEF( *geoProj.toECEF(events['lon'], events['lat'], events['alt']) ) # Convert to integer grid coordinate bins # 0 1 2 3 # | | | | | # -1.5 0.0 1.5 3.0 4.5 if x.shape[0] > 1: density, edges = extent_density(x,y,events['flash_id'].astype('int32'), b.x[0], b.y[0], dx, dy, xedge, yedge) do_plot = True break # print 'density values: ', density.min(), density.max() if do_plot == True: # need some data # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge, np.log10(density.transpose()), vmin=-0.2, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') text_label = p.multiples.flat[i].text(b.x[0]-pad+x_range*.01, b.y[0]-pad+y_range*.01, label_string, color=(0.5,)*3, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print label_string, x.shape, density.max(), density.sum() color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') # moving reference frame correction. all panels will have same limits, based on time of last frame view_dt = 0.0 # (frame_start - t0).seconds x_ctr = x0 + view_dt*u y_ctr = y0 + view_dt*v view_x = (x_ctr - view_dx/2.0 - pad, x_ctr + view_dx/2.0 + pad) view_y = (y_ctr - view_dy/2.0 - pad, y_ctr + view_dy/2.0 + pad) # view_x = (b.x[0]+view_dt*u, b.x[1]+view_dt*u) # view_y = (b.y[0]+view_dt*v, b.y[1]+view_dt*v) # print 'making timeseries', # time_series = figure(figsize=(16,9)) # ts_ax = time_series.add_subplot(111) # ts_ax.plot_date(mx2num(all_t),total_counts,'-', label='total sources', tz=tz) # ts_ax.plot_date(mx2num(all_t),density_maxes,'-', label='max pixel', tz=tz) # ts_ax.xaxis.set_major_formatter(time_series_x_fmt) # ts_ax.legend() # time_filename = 'out/LMA-timeseries_%s_%5.2fkm_%5.1fs.pdf' % (start_time.strftime('%Y%m%d_%H%M%S'), dx/1000.0, time_delta.seconds) # time_series.savefig(time_filename) # print ' ... done' print 'making multiples', p.multiples.flat[0].axis(view_x+view_y) filename = 'out/LMA-density_%s_%5.2fkm_%5.1fs.pdf' % (start_time.strftime('%Y%m%d_%H%M%S'), dx/1000.0, time_delta.seconds) f.savefig(filename, dpi=150) print ' ... done' f.clf() return events
def clusterPlot( self, metric: str = "mutual information", metric_kws: dict = None, symmetric: bool = True, # this should usually be True?? self_correlation: bool = False, savedir: str = "", verbose: bool = True, plot_unclustered: bool = False, col_for_legend: str = "zone", col_for_cbar: str = "number of probes", ): """ calculate, plot and cluster the correlation matrix """ self._checkMetricImplemented(metric) corr_matrix = np.empty((self.num_genes, self.num_genes), dtype=np.float64) corr_matrix.fill(np.nan) # the main title of the plot title = (f"Clustered Pairwise {metric}\n" f"bin size = {self.bin_size[0]} pix " f"by {self.bin_size[1]} pix") if metric == "mutual information": title += f"\n(bins = {metric_kws['bins']})" # # Set diagonal fill values for given metric # ----------------------------------------- # if metric in [ "mutual information", "JS divergence", "normalized crosscorr", "pearson", "SSIM" ]: fill_diagonal = 0. else: fill_diagonal = 0. # FIXME: might want to set diagonals values differently for some metrics. for gene1 in self.gene_index_dict: gene1_idx = self.gene_index_dict[gene1]['index'] for gene2 in self.gene_index_dict: gene2_idx = self.gene_index_dict[gene2]['index'] # ------------------------------ # skip self-correlation of genes # ------------------------------ if not self_correlation and gene2_idx == gene1_idx: corr_matrix[gene1_idx, gene2_idx] = fill_diagonal continue # # skip if already calculated # -------------------------- if not np.isnan(corr_matrix[gene1_idx, gene2_idx]): continue gene1_array = self.img_array[gene1_idx, ...] gene2_array = self.img_array[gene2_idx, ...] if verbose: print(f"Gene 1 {gene1} array shape: {gene1_array.shape}\n" f"Gene 2 {gene2} array shape: {gene2_array.shape}\n") # # run metric of choice # -------------------- # if metric == "mutual information": dist = calcImageMI(gene1_array, gene2_array, bins=metric_kws["bins"]) # dist = calcMIcustom(gene1_array, gene2_array, # bins=metric_kws["bins"]) elif metric == "normalized crosscorr": dist = normXCorr( gene1_array, gene2_array, ) elif metric == "pearson": dist = pearson( gene1_array, gene2_array, ) elif metric == "JS divergence": dist = js( gene1_array, gene2_array, ) elif metric == "SSIM": dist = ssim( gene1_array, gene2_array, ) else: raise ValueError(f"Metric {metric} not recognised") # enter result into correlation matrix corr_matrix[gene1_idx, gene2_idx] = dist if symmetric: corr_matrix[gene2_idx, gene1_idx] = dist # # set plotting params for given metrics # ------------------------------------- # print(f'plotting for {metric} ...') # these metrics start from 0 if metric in ["mutual information", "JS divergence"]: center = None cmap = "hot" # these metrics can have +ve and -ve values elif metric in ["normalized crosscorr", "pearson", "SSIM"]: center = 0 cmap = "vlag" # default settings else: center = None cmap = "hot" if verbose: print(f"Filled correlation matrix:\n" f"{corr_matrix}") # # set up row colours # ------------------ # if self.annotation_csv is not None: # # parse annotation csv file into a dataframe # ------------------------------------------ # genes_df = pd.DataFrame({"name": self.ordered_genes}, ) # print(f"genes dataframe initial:\n {genes_df}") self.annotation_df = pd.read_csv(self.annotation_csv) # print(f"annotation dataframe:\n {self.annotation_df}") self.genes_df = genes_df.merge(self.annotation_df, how="left", on="name", copy=False) self.genes_df.set_index("name", inplace=True) if verbose: print(f"genes dataframe final:\n " f"{self.genes_df}\n{self.genes_df.dtypes}") # # Generate Row-colours # -------------------- # generate row-colours dataframe, # also saving lut dictionary and category labels # row_colours = [] lut_labels_dict = {} for col in self.genes_df.columns: # sequential palette for numerical annotations if col in [ "number of probes", ]: row_colour, lut, labels = self._makeRowColours( self.genes_df[col], "Blues") else: row_colour, lut, labels = self._makeRowColours( self.genes_df[col], "Set1") row_colours.append(row_colour) lut_labels_dict[col] = (lut, labels) row_colours = pd.concat(row_colours, axis=1) if verbose: print(f"Dict of Look-up table and labels:\n") pp.pprint(lut_labels_dict) print(f"Row colours df:\n" f"{row_colours}\n{row_colours.dtypes}") else: row_colours = None # # Plot clustermap # --------------- # sns.set_style("dark") # plot heatmap without clustering if plot_unclustered: fig_mat, ax_mat = plt.subplots(figsize=(9, 9)) sns.heatmap(corr_matrix, ax=ax_mat, square=True, yticklabels=self.ordered_genes, xticklabels=self.ordered_genes) g = sns.clustermap( pd.DataFrame(data=corr_matrix, index=self.ordered_genes, columns=self.ordered_genes), square=False, yticklabels=True, xticklabels=True, # yticklabels=self.ordered_genes, # xticklabels=self.ordered_genes, center=center, cmap=cmap, row_colors=row_colours, ) # # set up annotation legend and/or colorbar # ---------------------------------------- # if self.annotation_csv is not None: lut, labels = lut_labels_dict[col_for_legend] # create a new axes on the bottom right of plot labels_ax = g.fig.add_axes([0.4, 0.01, 0.58, 0.08]) labels_ax.axis('off') for label in labels: labels_ax.bar(0, 0, color=lut[label], label=label, linewidth=0) labels_ax.legend( loc="lower right", ncol=4, frameon=False, ) cbar_params, labels = lut_labels_dict[col_for_cbar] norm, cmap = cbar_params # create a new axes on the bottom right of plot cbar_ax = g.fig.add_axes([0.35, 0.04, 0.15, 0.01]) cb1 = ColorbarBase(cbar_ax, cmap=cmap, norm=norm, orientation='horizontal') cb1.set_label(col_for_cbar) g.ax_heatmap.tick_params(axis='both', which='major', labelsize=5) g.fig.subplots_adjust(top=0.94) g.fig.suptitle(title, fontsize=12, fontweight="bold") if not os.path.exists(savedir): os.mkdir(savedir) filename = (f"{metric.replace(' ','_')}" f"_clusterplot.png") g.fig.savefig( os.path.join(savedir, filename), dpi=600, ) # list of genes in order shown on clustermap reordered_genes = [ self.ordered_genes[idx] for idx in g.dendrogram_row.reordered_ind ] if verbose: print(f"Reorderd indices:\n" f"{g.dendrogram_row.reordered_ind}\n" f"Reordered genes:\n{reordered_genes}") g.fig.clear() plt.close() return corr_matrix, reordered_genes
#!/usr/bin/env python from BRadar.plotutils import NWS_Reflect ''' Make a colorbar as a separate figure. ''' #from matplotlib import pyplot, mpl import matplotlib.pyplot as plt from matplotlib.colorbar import ColorbarBase # Make a figure and axes with dimensions as desired. fig = plt.figure() ax1 = fig.add_axes([0.45, 0.05, 0.03, 0.75]) # ColorbarBase derives from ScalarMappable and puts a colorbar # in a specified axes, so it has everything needed for a # standalone colorbar. There are many more kwargs, but the # following gives a basic continuous colorbar with ticks # and labels. cb1 = ColorbarBase(ax1, cmap=NWS_Reflect['ref_table'], norm=NWS_Reflect['norm']) cb1.set_label('Reflectivity [dBZ]') #pyplot.savefig('../../Documents/SPA/Colorbar_Raw.eps') #pyplot.savefig('../../Documents/SPA/Colorbar_Raw.png', dpi=250) plt.show()
class Plotter(): def __init__(self, notify, figure, settings): self.notify = notify self.figure = figure self.settings = settings self.average = settings.average self.axes = None self.bar = None self.threadPlot = None self.extent = None self.lineMinP = None self.lineMaxP = None self.lineAvgP = None self.lineGMP = None self.lineHalfP = None self.lineHalfFS = None self.lineHalfFE = None self.lineObwP = None self.lineObwFS = None self.lineObwFE = None self.labelMinP = None self.labelMaxP = None self.labelAvgP = None self.labelGMP = None self.labelHalfP = None self.labelHalfFS = None self.labelHalfFE = None self.labelObwFS = None self.labelObwFE = None self.setup_plot() self.set_grid(self.settings.grid) def setup_plot(self): formatter = ScalarFormatter(useOffset=False) gs = GridSpec(1, 2, width_ratios=[9.5, 0.5]) self.axes = self.figure.add_subplot(gs[0], axisbg=self.settings.background) self.axes.set_xlabel("Frequency (MHz)") self.axes.set_ylabel('Level (dB)') self.axes.xaxis.set_major_formatter(formatter) self.axes.yaxis.set_major_formatter(formatter) self.axes.xaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.yaxis.set_minor_locator(AutoMinorLocator(10)) self.axes.set_xlim(self.settings.start, self.settings.stop) self.axes.set_ylim(-50, 0) self.bar = self.figure.add_subplot(gs[1]) norm = Normalize(vmin=-50, vmax=0) self.barBase = ColorbarBase(self.bar, norm=norm, cmap=cm.get_cmap(self.settings.colourMap)) self.barBase.set_label('Level (dB)') self.setup_measure() def setup_measure(self): dashesAvg = [4, 5, 1, 5, 1, 5] dashesGM = [5, 5, 5, 5, 1, 5, 1, 5] dashesHalf = [1, 5, 5, 5, 5, 5] self.lineMinP = Line2D([0, 0], [0, 0], linestyle='--', color='black') self.lineMaxP = Line2D([0, 0], [0, 0], linestyle='-.', color='black') self.lineAvgP = Line2D([0, 0], [0, 0], dashes=dashesAvg, color='magenta') self.lineGMP = Line2D([0, 0], [0, 0], dashes=dashesGM, color='green') self.lineHalfP = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lineHalfFS = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lineHalfFE = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='purple') self.lineObwP = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') self.lineObwFS = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') self.lineObwFE = Line2D([0, 0], [0, 0], dashes=dashesHalf, color='#996600') if matplotlib.__version__ >= '1.3': effect = patheffects.withStroke(linewidth=3, foreground="w", alpha=0.75) self.lineMinP.set_path_effects([effect]) self.lineMaxP.set_path_effects([effect]) self.lineAvgP.set_path_effects([effect]) self.lineGMP.set_path_effects([effect]) self.lineHalfP.set_path_effects([effect]) self.lineHalfFS.set_path_effects([effect]) self.lineHalfFE.set_path_effects([effect]) self.lineObwP.set_path_effects([effect]) self.lineObwFS.set_path_effects([effect]) self.lineObwFE.set_path_effects([effect]) self.axes.add_line(self.lineMinP) self.axes.add_line(self.lineMaxP) self.axes.add_line(self.lineAvgP) self.axes.add_line(self.lineGMP) self.axes.add_line(self.lineHalfP) self.axes.add_line(self.lineHalfFS) self.axes.add_line(self.lineHalfFE) self.axes.add_line(self.lineObwP) self.axes.add_line(self.lineObwFS) self.axes.add_line(self.lineObwFE) box = dict(boxstyle='round', fc='white', ec='black') self.labelMinP = Text(0, 0, 'Min', fontsize='x-small', ha="right", va="bottom", bbox=box, color='black') self.labelMaxP = Text(0, 0, 'Max', fontsize='x-small', ha="right", va="top", bbox=box, color='black') box['ec'] = 'magenta' self.labelAvgP = Text(0, 0, 'Mean', fontsize='x-small', ha="right", va="center", bbox=box, color='magenta') box['ec'] = 'green' self.labelGMP = Text(0, 0, 'GMean', fontsize='x-small', ha="right", va="center", bbox=box, color='green') box['ec'] = 'purple' self.labelHalfP = Text(0, 0, '-3dB', fontsize='x-small', ha="right", va="center", bbox=box, color='purple') self.labelHalfFS = Text(0, 0, '-3dB', fontsize='x-small', ha="center", va="top", bbox=box, color='purple') self.labelHalfFE = Text(0, 0, '-3dB', fontsize='x-small', ha="center", va="top", bbox=box, color='purple') box['ec'] = '#996600' self.labelObwP = Text(0, 0, 'OBW', fontsize='x-small', ha="right", va="center", bbox=box, color='#996600') self.labelObwFS = Text(0, 0, 'OBW', fontsize='x-small', ha="center", va="top", bbox=box, color='#996600') self.labelObwFE = Text(0, 0, 'OBW', fontsize='x-small', ha="center", va="top", bbox=box, color='#996600') self.axes.add_artist(self.labelMinP) self.axes.add_artist(self.labelMaxP) self.axes.add_artist(self.labelAvgP) self.axes.add_artist(self.labelGMP) self.axes.add_artist(self.labelHalfP) self.axes.add_artist(self.labelHalfFS) self.axes.add_artist(self.labelHalfFE) self.axes.add_artist(self.labelObwP) self.axes.add_artist(self.labelObwFS) self.axes.add_artist(self.labelObwFE) self.hide_measure() def draw_hline(self, line, label, y): xLim = self.axes.get_xlim() yLim = self.axes.get_ylim() if yLim[0] < y < yLim[1]: line.set_visible(True) line.set_xdata([xLim[0], xLim[1]]) line.set_ydata([y, y]) self.axes.draw_artist(line) label.set_visible(True) label.set_position((xLim[1], y)) self.axes.draw_artist(label) def draw_vline(self, line, label, x): yLim = self.axes.get_ylim() xLim = self.axes.get_xlim() if xLim[0] < x < xLim[1]: line.set_visible(True) line.set_xdata([x, x]) line.set_ydata([yLim[0], yLim[1]]) self.axes.draw_artist(line) label.set_visible(True) label.set_position((x, yLim[1])) self.axes.draw_artist(label) def draw_measure(self, background, measure, show): if self.axes._cachedRenderer is None: return self.hide_measure() canvas = self.axes.get_figure().canvas canvas.restore_region(background) if show[Measure.MIN]: y = measure.get_min_p()[1] self.draw_hline(self.lineMinP, self.labelMinP, y) if show[Measure.MAX]: y = measure.get_max_p()[1] self.draw_hline(self.lineMaxP, self.labelMaxP, y) if show[Measure.AVG]: y = measure.get_avg_p() self.draw_hline(self.lineAvgP, self.labelAvgP, y) if show[Measure.GMEAN]: y = measure.get_gmean_p() self.draw_hline(self.lineGMP, self.labelGMP, y) if show[Measure.HBW]: xStart, xEnd, y = measure.get_hpw() self.draw_hline(self.lineHalfP, self.labelHalfP, y) self.draw_vline(self.lineHalfFS, self.labelHalfFS, xStart) self.draw_vline(self.lineHalfFE, self.labelHalfFE, xEnd) if show[Measure.OBW]: xStart, xEnd, y = measure.get_obw() self.draw_hline(self.lineObwP, self.labelObwP, y) self.draw_vline(self.lineObwFS, self.labelObwFS, xStart) self.draw_vline(self.lineObwFE, self.labelObwFE, xEnd) canvas.blit(self.axes.bbox) def hide_measure(self): self.lineMinP.set_visible(False) self.lineMaxP.set_visible(False) self.lineAvgP.set_visible(False) self.lineGMP.set_visible(False) self.lineHalfP.set_visible(False) self.lineHalfFS.set_visible(False) self.lineHalfFE.set_visible(False) self.lineObwP.set_visible(False) self.lineObwFS.set_visible(False) self.lineObwFE.set_visible(False) self.labelMinP.set_visible(False) self.labelMaxP.set_visible(False) self.labelAvgP.set_visible(False) self.labelGMP.set_visible(False) self.labelHalfP.set_visible(False) self.labelHalfFS.set_visible(False) self.labelHalfFE.set_visible(False) self.labelObwP.set_visible(False) self.labelObwFS.set_visible(False) self.labelObwFE.set_visible(False) def scale_plot(self, force=False): if self.extent is not None: if self.settings.autoF or force: self.axes.set_xlim(self.extent.get_f()) if self.settings.autoL or force: self.axes.set_ylim(self.extent.get_l()) self.barBase.set_clim(self.extent.get_l()) norm = Normalize(vmin=self.extent.get_l()[0], vmax=self.extent.get_l()[1]) for collection in self.axes.collections: collection.set_norm(norm) try: self.barBase.draw_all() except: pass def redraw_plot(self): if self.figure is not None: post_event(self.notify, EventThreadStatus(Event.DRAW)) def get_axes(self): return self.axes def get_plot_thread(self): return self.threadPlot def set_title(self, title): self.axes.set_title(title) def set_plot(self, spectrum, extent, annotate=False): self.extent = extent self.threadPlot = ThreadPlot(self, self.axes, spectrum, self.extent, self.settings.colourMap, self.settings.autoL, self.settings.lineWidth, self.barBase, self.settings.fadeScans, annotate, self.settings.average) self.threadPlot.start() def clear_plots(self): children = self.axes.get_children() for child in children: if child.get_gid() is not None: if child.get_gid() == "plot" or child.get_gid() == "peak": child.remove() def set_grid(self, on): self.axes.grid(on) self.redraw_plot() def set_colourmap(self, colourMap): for collection in self.axes.collections: collection.set_cmap(colourMap) self.barBase.set_cmap(colourMap) try: self.barBase.draw_all() except: pass def close(self): self.figure.clear() self.figure = None
def make_plot_3d(grid, grid_name, x, y, all_z, t, grid_t_idx, grid_x_idx, grid_z_idx, n_cols = 6, outpath='', filename_prefix='LMA',do_save=True, image_type='pdf', colormap='cubehelix' , grid_range=None): n_frames = t.shape[0] # n_cols = 6 n_rows = int(ceil( float(n_frames) / n_cols )) if type(colormap) == type(''): colormap = get_cmap(colormap) grey_color = (0.5,)*3 frame_color = (0.2,)*3 density_maxes = [] total_counts = [] all_t = [] xedge = centers_to_edges(x) x_range = xedge.max() - xedge.min() yedge = centers_to_edges(y) y_range = yedge.max() - yedge.min() dx = (xedge[1]-xedge[0]) # count_scale_factor = dx # / 1000.0 # max_count_baseline = 450 * count_scale_factor #/ 10.0 min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0]) if (max_count == 0) | (max_count == 1 ): max_count = min_count+1 default_vmin = -0.2 if np.log10(max_count) <= default_vmin: vmin_count = np.log10(max_count) + default_vmin else: vmin_count = default_vmin # If the range of values for the colorbar is manually specified, # overwrite what we did above if grid_range is not None: vmin_count = grid_range[0] max_count = grid_range[1] # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None) fig = Figure(figsize=(w,h)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols) p.label_edges(True) pad = 0.0 # for time labels in each frame for ax in p.multiples.flat: ax.set_axis_bgcolor('white') ax.spines['top'].set_edgecolor(frame_color) ax.spines['bottom'].set_edgecolor(frame_color) ax.spines['left'].set_edgecolor(frame_color) ax.spines['right'].set_edgecolor(frame_color) # ax.yaxis.set_major_formatter(kilo_formatter) # ax.xaxis.set_major_formatter(kilo_formatter) base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S") time_delta = timedelta(0,float(t[0]),0) start_time = base_date + time_delta for zi in range(len(all_z)): indexer = [slice(None),]*len(grid.shape) frame_start_times = [] altitude = all_z[zi] for i in range(n_frames): p.multiples.flat[i].clear() # reset (clear) the axes frame_start = base_date + timedelta(0,float(t[i]),0) frame_start_times.append(frame_start) indexer[grid_t_idx] = i indexer[grid_z_idx] = zi density = grid[indexer] density = np.ma.masked_where(density<=0.0, density) # mask grids 0 grids to reveal background color # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge, np.log10(density.transpose()), vmin=vmin_count, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') x_lab = xedge[0]-pad+x_range*.015 y_lab = yedge[0]-pad+y_range*.015 text_label = p.multiples.flat[i].text(x_lab, y_lab, label_string, color=grey_color, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print(label_string, x_lab, y_lab, grid_name, density.max(), density.sum()) color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') view_x = (xedge.min(), xedge.max()) view_y = (yedge.min(), yedge.max()) print('making multiples') p.multiples.flat[0].axis(view_x+view_y) filename = '%s-%s_%s_%05.2fkm_%04.1fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, altitude, time_delta.seconds, image_type) filename = os.path.join(outpath, filename) if do_save: fig.savefig(filename, dpi=150) print('done ', zi) return fig, p, frame_start_times, filename print(' ... done with loop')
def plotter(fdict): """ Go """ ctx = get_autoplot_context(fdict, get_description()) df = get_data(ctx) cmap = cm.get_cmap(ctx["cmap"]) maxval = df["delta"].max() if maxval > 50: bins = np.arange(0, 101, 10) elif maxval > 25: bins = np.arange(0, 51, 5) else: bins = np.arange(0, 21, 2) bins[0] = 0.01 norm = mpcolors.BoundaryNorm(bins, cmap.N) (fig, ax) = plt.subplots(1, 1, figsize=(6.4, 6.4)) yearmax = df[["year", "delta"]].groupby("year").max() for year, df2 in df.groupby("year"): for _, row in df2.iterrows(): # NOTE: minus 3.5 to center the 7 day bar ax.bar( row["doy"] - 3.5, 1, bottom=year - 0.5, width=7, ec="None", fc=cmap(norm([row["delta"]]))[0], ) sts = datetime.datetime(2000, 1, 1) + datetime.timedelta(days=int(df["doy"].min())) ets = datetime.datetime(2000, 1, 1) + datetime.timedelta(days=int(df["doy"].max())) now = sts interval = datetime.timedelta(days=1) jdays = [] labels = [] while now < ets: if now.day in [1, 8, 15, 22]: fmt = "%-d\n%b" if now.day == 1 else "%-d" jdays.append(int(now.strftime("%j"))) labels.append(now.strftime(fmt)) now += interval ax.set_xticks(jdays) ax.set_xticklabels(labels) minyear = df["year"].min() maxyear = df["year"].max() ax.set_yticks(range(minyear, maxyear + 1)) ylabels = [] for yr in range(minyear, maxyear + 1): if yr % 5 == 0: ylabels.append("%s %.0f" % (yr, yearmax.at[yr, "delta"])) else: ylabels.append("%.0f" % (yearmax.at[yr, "delta"], )) ax.set_yticklabels(ylabels, fontsize=10) ax.set_ylim(minyear - 0.5, maxyear + 0.5) ax.set_xlim(min(jdays), max(jdays)) ax.grid(linestyle="-", linewidth="0.5", color="#EEEEEE", alpha=0.7) ax.set_title(("USDA NASS Weekly %s %s Progress\n" "%s %% %s over weekly periods\n" "yearly max labelled on left hand side") % ( ctx["unit_desc"], PDICT2.get(ctx["commodity_desc"]), state_names[ctx["state"]], PDICT.get(ctx["unit_desc"]), )) ax.set_position([0.13, 0.1, 0.71, 0.78]) cax = plt.axes([0.86, 0.12, 0.03, 0.75], frameon=False, yticks=[], xticks=[]) cb = ColorbarBase(cax, norm=norm, cmap=cmap) cb.set_label("% Acres") return fig, df
# Plot candidate directions. lvals = [src.l for src in cands.values()] bvals = [src.b for src in cands.values()] x, y = m(lvals, bvals) cand_pts = m.scatter(x, y, marker='+', linewidths=.5, edgecolors='k', facecolors='none', zorder=10) # hi zorder -> top # Plot tissots showing possible scale of candidate scatter. for l, b in zip(lvals, bvals): m.tissot(l, b, 5., 30, ec='none', color='g', alpha=0.25) # Show the closest candidate to each CR. for cr in CRs.values(): cand = cands[cr.near_id] m.geodesic(cr.l, cr.b, cand.l, cand.b, lw=0.5, ls='-', c='g') plt.title('UHE Cosmic Rays and Candidate Sources') plt.legend([cr_pts, cand_pts], ['UHE CR', 'Candidate'], frameon=False, loc='lower right', scatterpoints=1) # Plot a colorbar for the CR energies. cb_ax = plt.axes([0.25, .1, .5, .03], frameon=False) # rect=L,B,W,H #bar = ColorbarBase(cb_ax, cmap=cmap, orientation='horizontal', drawedges=False) vals = np.linspace(Evals.min(), Evals.max(), 100) bar = ColorbarBase(cb_ax, values=vals, norm=norm_E, cmap=cmap, orientation='horizontal', drawedges=False) bar.set_label('CR Energy (EeV)') plt.show()
def showVarianceBar(mode_ensemble, highlights=None, **kwargs): from matplotlib.pyplot import figure, gca, annotate, subplots_adjust, plot from matplotlib.figure import Figure from matplotlib.colorbar import ColorbarBase from matplotlib.colors import Normalize, NoNorm from matplotlib import cm, colors fig = kwargs.pop('figure', None) if isinstance(fig, Figure): fig_num = fig.number elif fig is None or isinstance(fig, (int, str)): fig_num = fig else: raise TypeError( 'figure can be either an instance of matplotlib.figure.Figure ' 'or a figure number.') if SETTINGS['auto_show']: if fig_num is None: figure(figsize=(6, 2)) else: figure(fig_num) elif fig_num is not None: figure(fig_num) ax = gca() # adjust layouts box = ax.get_position() _, _, _, height = box.bounds ratio = 2.5 box.y1 = box.y0 + height / ratio #box.y0 += height/7. ax.set_position(box) fract = kwargs.pop('fraction', True) #defarrow = {'width':1, 'headwidth':2, # 'facecolor':'black', # 'headlength': 4} defarrow = {'arrowstyle': '->'} arrowprops = kwargs.pop('arrowprops', defarrow) if fract: sig = calcSignatureFractVariance(mode_ensemble) else: sig = mode_ensemble.getVariances() variances = sig.getArray().sum(axis=1) #meanVar = variances.mean() #stdVar = variances.std() #variances = (variances - meanVar)/stdVar maxVar = variances.max() minVar = variances.min() cmap = kwargs.pop('cmap', 'jet') norm = Normalize(vmin=minVar, vmax=maxVar) cb = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='horizontal') if not highlights: highlights = [] indices = [] labels = [] ens_labels = mode_ensemble.getLabels() for hl in highlights: if isinstance(hl, str): if not ens_labels: raise TypeError( 'highlights should be a list of integers because ' 'mode_ensemble has no label') indices.append(ens_labels.index(hl)) labels.append(hl) else: try: index = int(hl) except: raise TypeError( 'highlights should be a list of integers or strings') indices.append(index) if ens_labels: labels.append(ens_labels[index]) else: labels.append(str(index)) annotations = [] for i, label in zip(indices, labels): x = norm(variances[i]) an = annotate(label, xy=(x, 1), xytext=(x, ratio), arrowprops=arrowprops) annotations.append(an) for i in range(len(variances)): x = norm(variances[i]) plot([x, x], [0, 1], 'w') cb.set_label('Variances') if SETTINGS['auto_show']: showFigure() return cb, annotations
def save_png(self, figname: str = "", **kwargs): """ """ radius = self.radius.to(u.m).value colormap = kwargs.get("cmap", "YlGnBu_r") # Mini-Array positions in ENU coordinates nenufar = NenuFAR()[self.mini_arrays] ma_etrs = l93_to_etrs(nenufar.antenna_positions) ma_enu = etrs_to_enu(ma_etrs) # Plot the nearfield fig, ax = plt.subplots(figsize=kwargs.get("figsize", (10, 10))) nf_image_db = 10*np.log10(self.nearfield) ax.imshow( np.flipud(nf_image_db), # This needs to be understood... cmap=colormap, extent=[-radius, radius, -radius, radius], zorder=0, vmin=kwargs.get("vmin", np.min(nf_image_db)), vmax=kwargs.get("vmax", np.max(nf_image_db)) ) # Colorbar cax = inset_axes(ax, width="5%", height="100%", loc="lower left", bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0, ) cb = ColorbarBase( cax, cmap=get_cmap(name=colormap), orientation="vertical", norm=Normalize( vmin=kwargs.get("vmin", np.min(nf_image_db)), vmax=kwargs.get("vmax", np.max(nf_image_db)) ), ticks=LinearLocator(), format='%.2f' ) cb.solids.set_edgecolor("face") cb.set_label(f"dB (Stokes {self.stokes})") # Show the contour of the simulated source imprints ground_granularity = np.linspace(-radius, radius, self.npix) posx, posy = np.meshgrid(ground_granularity, ground_granularity) dist = np.sqrt(posx**2 + posy**2) border_min = 0.1*self.npix border_max = self.npix - 0.1*self.npix for src in self.source_imprints.keys(): # Normalize the imprint imprint = self.source_imprints[src] imprint /= imprint.max() # Plot the contours ax.contour( imprint, np.arange(0.8, 1, 0.04), cmap="copper", alpha=0.5, extent=[-radius, radius, -radius, radius], zorder=5 ) # Find the maximum of the emission max_y, max_x = np.unravel_index( imprint.argmax(), imprint.shape ) # If maximum outside the plot, recenter it if (max_x <= border_min) or (max_y <= border_min) or (max_x >= border_max) or (max_y >= border_max): dist[dist<=np.median(dist)] = 0 max_y, max_x = np.unravel_index( ((1 - dist/dist.max())*imprint).argmax(), imprint.shape ) # Show the source name associated to the imprint ax.text( ground_granularity[max_x], ground_granularity[max_y], f" {src}", color="#b35900", fontweight="bold", va="center", ha="center", zorder=30 ) # NenuFAR mini-array positions ax.scatter( ma_enu[:, 0], ma_enu[:, 1], 20, color='black', zorder=10 ) for i in range(ma_enu.shape[0]): ax.text( ma_enu[i, 0], ma_enu[i, 1], f" {self.mini_arrays[i]}", color="black", zorder=10 ) # ax.scatter( # building_enu[:, 0], # building_enu[:, 1], # 20, # color="tab:red",#'tab:orange', # zorder=10 # ) # Plot axis labels ax.set_xlabel(r"$\Delta x$ (m)") ax.set_ylabel(r"$\Delta y$ (m)") ax.set_title( f"{np.mean(self.frequency.to(u.MHz).value):.3f} MHz -- {self.time.isot}" ) # Save or show the figure if figname != "": plt.savefig( figname, dpi=300, bbox_inches="tight", transparent=True ) log.info(f"Figure '{figname}' saved.") else: plt.show() plt.close("all")
def showVarianceBar(mode_ensemble, highlights=None, **kwargs): from matplotlib.pyplot import figure, gca, annotate, subplots_adjust, plot from matplotlib.figure import Figure from matplotlib.colorbar import ColorbarBase from matplotlib.colors import Normalize, NoNorm from matplotlib import cm, colors fig = kwargs.pop('figure', None) if isinstance(fig, Figure): fig_num = fig.number elif fig is None or isinstance(fig, (int, str)): fig_num = fig else: raise TypeError('figure can be either an instance of matplotlib.figure.Figure ' 'or a figure number.') if SETTINGS['auto_show']: if fig_num is None: figure(figsize=(6, 2)) else: figure(fig_num) elif fig_num is not None: figure(fig_num) ax = gca() # adjust layouts box = ax.get_position() _, _, _, height = box.bounds ratio = 2.5 box.y1 = box.y0 + height/ratio #box.y0 += height/7. ax.set_position(box) fract = kwargs.pop('fraction', True) #defarrow = {'width':1, 'headwidth':2, # 'facecolor':'black', # 'headlength': 4} defarrow = {'arrowstyle': '->'} arrowprops = kwargs.pop('arrowprops', defarrow) if fract: sig = calcSignatureFractVariance(mode_ensemble) else: sig = mode_ensemble.getVariances() variances = sig.getArray().sum(axis=1) #meanVar = variances.mean() #stdVar = variances.std() #variances = (variances - meanVar)/stdVar maxVar = variances.max() minVar = variances.min() cmap = kwargs.pop('cmap', 'jet') norm = Normalize(vmin=minVar, vmax=maxVar) cb = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='horizontal') if not highlights: highlights = [] indices = []; labels = [] ens_labels = mode_ensemble.getLabels() for hl in highlights: if isinstance(hl, str): if not ens_labels: raise TypeError('highlights should be a list of integers because ' 'mode_ensemble has no label') indices.append(ens_labels.index(hl)) labels.append(hl) else: try: index = int(hl) except: raise TypeError('highlights should be a list of integers or strings') indices.append(index) if ens_labels: labels.append(ens_labels[index]) else: labels.append(str(index)) annotations = [] for i, label in zip(indices, labels): x = norm(variances[i]) an = annotate(label, xy=(x, 1), xytext=(x, ratio), arrowprops=arrowprops) annotations.append(an) for i in range(len(variances)): x = norm(variances[i]) plot([x, x], [0, 1], 'w') cb.set_label('Variances') if SETTINGS['auto_show']: showFigure() return cb, annotations