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):
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 spikesplot_cb(position, cmap='viridis', fig=None):
# Add colorbar
if fig is None:
fig = plt.gcf()
cax = fig.add_axes(position)
cb = ColorbarBase(cax, cmap=get_cmap(cmap), spacing='proportional',
orientation='horizontal', drawedges=False)
cb.set_ticks([0, 0.5, 1.0])
cb.set_ticklabels(['Inferior', '(axial slice)', 'Superior'])
cb.outline.set_linewidth(0)
cb.ax.xaxis.set_tick_params(width=0)
return cax
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 __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 ($\mathsf{dB/\sqrt{Hz}}$)')
colour = hex2color(self.settings.background)
colour += (1,)
self.axes.w_xaxis.set_pane_color(colour)
self.axes.w_yaxis.set_pane_color(colour)
self.axes.w_zaxis.set_pane_color(colour)
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))
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(utc_to_mpl(now), utc_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.__setup_measure()
self.__setup_overflow()
self.hide_measure()
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 _colorbar_show(self, im, threshold):
if threshold is None:
offset = 0
else:
offset = threshold
if offset > im.norm.vmax:
offset = im.norm.vmax
# create new axis for the colorbar
figure = self.frame_axes.figure
_, y0, x1, y1 = self.rect
height = y1 - y0
x_adjusted_width = self._colorbar_width / len(self.axes)
x_adjusted_margin = self._colorbar_margin['right'] / len(self.axes)
lt_wid_top_ht = [x1 - (x_adjusted_width + x_adjusted_margin),
y0 + self._colorbar_margin['top'],
x_adjusted_width,
height - (self._colorbar_margin['top'] +
self._colorbar_margin['bottom'])]
self._colorbar_ax = figure.add_axes(lt_wid_top_ht, axis_bgcolor='w')
our_cmap = im.cmap
# edge case where the data has a single value
# yields a cryptic matplotlib error message
# when trying to plot the color bar
nb_ticks = 5 if im.norm.vmin != im.norm.vmax else 1
ticks = np.linspace(im.norm.vmin, im.norm.vmax, nb_ticks)
bounds = np.linspace(im.norm.vmin, im.norm.vmax, our_cmap.N)
# some colormap hacking
cmaplist = [our_cmap(i) for i in range(our_cmap.N)]
istart = int(im.norm(-offset, clip=True) * (our_cmap.N - 1))
istop = int(im.norm(offset, clip=True) * (our_cmap.N - 1))
for i in range(istart, istop):
cmaplist[i] = (0.5, 0.5, 0.5, 1.) # just an average gray color
if im.norm.vmin == im.norm.vmax: # len(np.unique(data)) == 1 ?
return
else:
our_cmap = our_cmap.from_list('Custom cmap', cmaplist, our_cmap.N)
self._cbar = ColorbarBase(
self._colorbar_ax, ticks=ticks, norm=im.norm,
orientation='vertical', cmap=our_cmap, boundaries=bounds,
spacing='proportional')
self._cbar.set_ticklabels(["%.2g" % t for t in ticks])
self._colorbar_ax.yaxis.tick_left()
tick_color = 'w' if self._black_bg else 'k'
for tick in self._colorbar_ax.yaxis.get_ticklabels():
tick.set_color(tick_color)
self._colorbar_ax.yaxis.set_tick_params(width=0)
self._cbar.update_ticks()
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
def __init__(self, parent, colourMap):
wx.Panel.__init__(self, parent)
dpi = wx.ScreenDC().GetPPI()[0]
figure = matplotlib.figure.Figure(facecolor='white', dpi=dpi)
figure.set_size_inches(200.0 / dpi, 25.0 / dpi)
self.canvas = FigureCanvas(self, -1, figure)
axes = figure.add_subplot(111)
figure.subplots_adjust(0, 0, 1, 1)
norm = Normalize(vmin=0, vmax=1)
self.bar = ColorbarBase(axes, norm=norm, orientation='horizontal',
cmap=cm.get_cmap(colourMap))
axes.xaxis.set_visible(False)
def pic_switch(event):
bounds = roi1.export()
if zoom.value_selected == 'Zoom':
axpic.cla()
axpic.imshow(start.pic_list[int(pic_swap.val)], vmin=vmin.val, vmax=vmax.val, cmap=gray.value_selected)
axpic.set_title(start.file_list[int(pic_swap.val)])
axpic.set_xlim(bounds[2], bounds[3])
axpic.set_ylim(bounds[1], bounds[0])
axpic.axvline(x=bounds[2])
axpic.axvline(x=bounds[3])
axpic.axhline(y=bounds[0])
axpic.axhline(y=bounds[1])
axbar.cla()
norm = Normalize(vmin=vmin.val, vmax=vmax.val)
col = ColorbarBase(axbar, cmap=gray.value_selected, norm=norm, orientation='horizontal')
col.set_ticks([vmin.val, vmax.val], update_ticks=True)
else:
axpic.cla()
axpic.imshow(start.pic_list[int(pic_swap.val)], vmin=vmin.val, vmax=vmax.val, cmap=gray.value_selected)
axpic.set_title(start.file_list[int(pic_swap.val)])
axpic.axvline(x=bounds[2])
axpic.axvline(x=bounds[3])
axpic.axhline(y=bounds[0])
axpic.axhline(y=bounds[1])
axbar.cla()
norm = Normalize(vmin=vmin.val, vmax=vmax.val)
col = ColorbarBase(axbar, cmap=gray.value_selected, norm=norm, orientation='horizontal')
col.set_ticks([vmin.val, vmax.val], update_ticks=True)
def display_median_price_animation(self):
"""Kicks off the animation of median price information."""
fig = plotter.figure(num = 1, figsize = (10, 12), tight_layout = True)
fig.canvas.set_window_title('Percent increase in median house ' + \
'price since 1996')
axis = fig.add_axes([0.85, 0.04, 0.03, 0.92])
colorbar_ticks = [0, .2, .4, .6, .8, 1.0]
colorbar_labels = ['-100%', '0%', '250%', '500%', '750%', '>1000%']
colorbar = ColorbarBase(axis, self._colormap, orientation='vertical')
colorbar.set_ticks(colorbar_ticks)
colorbar.set_ticklabels(colorbar_labels)
fig.add_axes([0.0, 0.0, 0.82, 1.0])
anim = FuncAnimation(fig,
self._animate,
frames = self.endyear + 1 - self.startyear,
interval = 1000,
blit = True,
init_func = self._init_animate,
repeat_delay = 3000)
plotter.show()
def __init__(self, parent=None):
FigureCanvas.__init__(self, Figure())
self._telemetry = None
self._resolution = None
self._cmap = None
self._wireframe = False
self.setParent(parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setFocus()
colour = self.palette().color(self.backgroundRole()).getRgbF()
self.figure.patch.set_facecolor(colour[:-1])
gs = GridSpec(1, 2, width_ratios=[9.5, 0.5])
self._axes = self.figure.add_subplot(gs[0], projection='3d')
self._axes.set_title('3D Plot')
self._axes.set_xlabel('Longitude')
self._axes.set_ylabel('Latitude')
self._axes.set_zlabel('Level (dB)')
self._axes.tick_params(axis='both', which='major', labelsize='smaller')
self._axes.grid(True)
formatMaj = ScalarFormatter(useOffset=False)
self._axes.xaxis.set_major_formatter(formatMaj)
self._axes.yaxis.set_major_formatter(formatMaj)
self._axes.zaxis.set_major_formatter(formatMaj)
formatMinor = AutoMinorLocator(10)
self._axes.xaxis.set_minor_locator(formatMinor)
self._axes.yaxis.set_minor_locator(formatMinor)
self._axes.zaxis.set_minor_locator(formatMinor)
self._axesBar = self.figure.add_subplot(gs[1])
self._axesBar.tick_params(axis='both', which='major',
labelsize='smaller')
self._bar = ColorbarBase(self._axesBar)
if matplotlib.__version__ >= '1.2':
self.figure.tight_layout()
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_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 ($\mathsf{dB/\sqrt{Hz}}$)')
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)
self.set_colourmap_use(self.settings.colourMapUse)
self.__setup_measure()
self.__setup_overflow()
self.hide_measure()
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 __init__(self, cmap, vmin, vmax=None, label=True, label_position=None,
label_rotation=None,
clipmin=None, clipmax=None, orientation='horizontal',
unit=None, contours=(), width=None, ticks=None, threshold=None,
ticklocation='auto', background='white', tight=True,
h=None, w=None, *args, **kwargs):
# get Colormap
if isinstance(cmap, np.ndarray):
if threshold is not None:
raise NotImplementedError("threshold parameter with cmap=array")
if cmap.max() > 1:
cmap = cmap / 255.
cm = mpl.colors.ListedColormap(cmap, 'LUT')
else:
cm = mpl.cm.get_cmap(cmap)
# prepare layout
if orientation == 'horizontal':
if h is None and w is None:
h = 1
ax_aspect = 4
elif orientation == 'vertical':
if h is None and w is None:
h = 4
ax_aspect = 0.3
else:
raise ValueError("orientation=%s" % repr(orientation))
layout = Layout(1, ax_aspect, 2, tight, False, h, w, *args, **kwargs)
EelFigure.__init__(self, cm.name, layout)
ax = self._axes[0]
# translate between axes and data coordinates
if isinstance(vmin, Normalize):
norm = vmin
else:
vmin, vmax = fix_vlim_for_cmap(vmin, vmax, cm.name)
norm = Normalize(vmin, vmax)
# value ticks
if ticks is False:
ticks = ()
tick_labels = None
elif isinstance(ticks, dict):
tick_dict = ticks
ticks = sorted(tick_dict)
tick_labels = [tick_dict[t] for t in ticks]
else:
tick_labels = None
if orientation == 'horizontal':
axis = ax.xaxis
contour_func = ax.axhline
else:
axis = ax.yaxis
contour_func = ax.axvline
if label is True:
if unit:
label = unit
else:
label = cm.name
elif not label:
label = ''
# show only part of the colorbar
if clipmin is not None or clipmax is not None:
if isinstance(norm, SymmetricNormalize):
raise NotImplementedError(
"clipmin or clipmax with SymmetricNormalize")
boundaries = norm.inverse(np.linspace(0, 1, cm.N + 1))
if clipmin is None:
start = None
else:
start = np.digitize(clipmin, boundaries, True)
if clipmax is None:
stop = None
else:
stop = np.digitize(clipmax, boundaries) + 1
boundaries = boundaries[start:stop]
else:
boundaries = None
colorbar = ColorbarBase(ax, cm, norm, boundaries=boundaries,
orientation=orientation,
ticklocation=ticklocation, ticks=ticks,
label=label)
# fix tick location
if isinstance(norm, SymmetricNormalize) and ticks is not None:
tick_norm = Normalize(norm.vmin, norm.vmax, norm.clip)
axis.set_ticks(tick_norm(ticks))
# unit-based tick-labels
if unit and tick_labels is None:
formatter, label = find_axis_params_data(unit, label)
tick_labels = tuple(map(formatter, colorbar.get_ticks()))
if tick_labels is not None:
if clipmin is not None:
tick_labels = [l for l, t in zip(tick_labels, ticks) if t >= clipmin]
axis.set_ticklabels(tick_labels)
# label position/rotation
if label_position is not None:
axis.set_label_position(label_position)
if label_rotation is not None:
axis.label.set_rotation(label_rotation)
if orientation == 'vertical':
if (label_rotation + 10) % 360 < 20:
axis.label.set_va('center')
elif orientation == 'vertical' and len(label) <= 3:
axis.label.set_rotation(0)
axis.label.set_va('center')
self._contours = [contour_func(c, c='k') for c in contours]
self._draw_hooks.append(self.__fix_alpha)
self._draw_hooks.append(self.__update_bar_tickness)
self._background = background
self._colorbar = colorbar
self._orientation = orientation
self._width = width
self._show()
class Plotter3d(object):
def __init__(self, notify, figure, settings):
self.notify = notify
self.figure = figure
self.settings = settings
self.axes = None
self.bar = None
self.barBase = None
self.plot = None
self.extent = None
self.threadPlot = None
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 ($\mathsf{dB/\sqrt{Hz}}$)')
colour = hex2color(self.settings.background)
colour += (1, )
self.axes.w_xaxis.set_pane_color(colour)
self.axes.w_yaxis.set_pane_color(colour)
self.axes.w_zaxis.set_pane_color(colour)
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(utc_to_mpl(now), utc_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))
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, EventThread(Event.DRAW))
def get_axes(self):
return self.axes
def get_axes_bar(self):
return self.barBase.ax
def get_plot_thread(self):
return self.threadPlot
def set_title(self, title):
self.axes.set_title(title, fontsize='medium')
def set_plot(self, spectrum, extent, annotate=False):
self.extent = extent
self.threadPlot = ThreadPlot(self, self.settings, self.axes, spectrum,
self.extent, 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_line" 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
#To incorporate difference between Map State Name and Data Loc Name
if statename == "Telangana":
statename = "Telengana"
if statename in color_dict:
pop = color_dict[statename]
colors[statename] = mapper.to_rgba(pop)
statenames.append(statename)
for nshape, seg in enumerate(m.INDIA):
color = rgb2hex(colors[statenames[nshape]])
poly = Polygon(seg, facecolor=color, edgecolor=color)
ax.add_patch(poly)
plt.title('Confirmed Cases on ' + data['data'][ind]['day'])
cax = fig.add_axes([0.27, 0.1, 0.5, 0.05]) # posititon
cb = ColorbarBase(cax, cmap=cmap, norm=norm, orientation='horizontal')
cb.ax.set_xlabel('Number of Cases')
fig1 = plt.gcf()
plt.show()
fig1.savefig(folder + "/file%02d.png" % ind)
video_name = 'time_map.avi'
images = [img for img in os.listdir(folder) if img.endswith(".png")]
frame = cv2.imread(os.path.join(folder, images[0]))
height, width, layers = frame.shape
#0.7 is the fps (frame per second)
video = cv2.VideoWriter(video_name, 0, 0.7, (width, height))
for image in sorted(images):
def axplot_ChangeProbs(ax,
change_probs,
wt_colors,
ttl='',
vmin=0,
vmax=1,
cmap='Blues',
cbar_ttl=''):
'axes plot cluster change probabilities'
num_clusters = change_probs.shape[0]
# clsuter transition plot
pc = ax.pcolor(
change_probs,
cmap=cmap,
vmin=vmin,
vmax=vmax,
)
# add colorbar
cbar = plt.colorbar(pc, ax=ax)
cbar.ax.tick_params(labelsize=8)
if vmin != 0 or vmax != 1:
cbar.set_ticks(np.linspace(vmin, vmax, 6))
cbar.ax.set_ylabel(cbar_ttl, rotation=270, labelpad=20)
# customize axes
ax.set_xticks(np.arange(num_clusters) + 0.5)
ax.set_yticks(np.arange(num_clusters) + 0.5)
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_title(ttl, {'fontsize': 10, 'fontweight': 'bold'})
# add custom color axis
ccmap = mcolors.ListedColormap([tuple(r) for r in wt_colors])
# custom color axis positions
ax_pos = ax.get_position()
cax_x_pos = [ax_pos.x0, ax_pos.y0 - 0.03, ax_pos.width, 0.02]
cax_y_pos = [
ax_pos.x0 - 0.03 / _faspect, ax_pos.y0, 0.02 / _faspect, ax_pos.height
]
# custom color axis X
cax_x = ax.figure.add_axes(cax_x_pos)
cbar_x = ColorbarBase(
cax_x,
cmap=ccmap,
orientation='horizontal',
norm=mcolors.Normalize(vmin=0, vmax=num_clusters),
)
cbar_x.set_ticks([])
# custom color axis Y
cax_y = ax.figure.add_axes(cax_y_pos)
cbar_y = ColorbarBase(
cax_y,
cmap=ccmap,
orientation='vertical',
norm=mcolors.Normalize(vmin=0, vmax=num_clusters),
)
cbar_y.set_ticks([])
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()
'''
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 plot_us_data(fig, ax, m, m_, data, label_text, title_text):
#%% -------- choose a color for each state based on population density. -------
colors = {}
statenames = []
cmap = plt.cm.hot_r # use 'reversed hot' colormap
#find max/min. Then round to 2 dp.
vmin = round(np.nanmin(data.values), 2)
vmax = round(np.nanmax(data.values), 2) # set range.
norm = Normalize(vmin=vmin, vmax=vmax)
for shapedict in m.states_info:
statename = shapedict['NAME']
# skip DC and Puerto Rico.
if statename not in ['District of Columbia', 'Puerto Rico']:
pop = data[statename]
# calling colormap with value between 0 and 1 returns
# rgba value. Invert color range (hot colors are high
# population), take sqrt root to spread out colors more.
if np.isnan(pop):
pop = vmin
colors[statename] = cmap(((pop - vmin) / (vmax - vmin)))[:3]
statenames.append(statename)
#%% --------- cycle through state names, color each one. --------------------
for nshape, seg in enumerate(m.states):
# skip DC and Puerto Rico.
if statenames[nshape] not in ['Puerto Rico', 'District of Columbia']:
color = rgb2hex(colors[statenames[nshape]])
poly = Polygon(seg, facecolor=color, edgecolor=color)
ax.add_patch(poly)
AREA_1 = 0.005 # exclude small Hawaiian islands that are smaller than AREA_1
AREA_2 = AREA_1 * 30.0 # exclude Alaskan islands that are smaller than AREA_2
AK_SCALE = 0.19 # scale down Alaska to show as a map inset
HI_OFFSET_X = -1900000 # X coordinate offset amount to move Hawaii "beneath" Texas
HI_OFFSET_Y = 250000 # similar to above: Y offset for Hawaii
AK_OFFSET_X = -250000 # X offset for Alaska (These four values are obtained
AK_OFFSET_Y = -750000 # via manual trial and error, thus changing them is not recommended.)
for nshape, shapedict in enumerate(
m_.states_info): # plot Alaska and Hawaii as map insets
if shapedict['NAME'] in ['Alaska', 'Hawaii']:
seg = m_.states[int(shapedict['SHAPENUM'] - 1)]
if shapedict['NAME'] == 'Hawaii' and float(
shapedict['AREA']) > AREA_1:
seg = [(x + HI_OFFSET_X, y + HI_OFFSET_Y) for x, y in seg]
color = rgb2hex(colors[statenames[nshape]])
elif shapedict['NAME'] == 'Alaska' and float(
shapedict['AREA']) > AREA_2:
seg = [(x*AK_SCALE + AK_OFFSET_X, y*AK_SCALE + AK_OFFSET_Y)\
for x, y in seg]
color = rgb2hex(colors[statenames[nshape]])
poly = Polygon(seg,
facecolor=color,
edgecolor='gray',
linewidth=.45)
ax.add_patch(poly)
#%% --------- Plot bounding boxes for Alaska and Hawaii insets --------------
light_gray = [0.8] * 3 # define light gray color RGB
x1, y1 = m_([-190, -183, -180, -180, -175, -171, -171],
[29, 29, 26, 26, 26, 22, 20])
x2, y2 = m_([-180, -180, -177],
[26, 23, 20]) # these numbers are fine-tuned manually
m_.plot(x1, y1, color=light_gray,
linewidth=0.8) # do not change them drastically
m_.plot(x2, y2, color=light_gray, linewidth=0.8)
ax.set_title(title_text)
#%% --------- Show color bar ---------------------------------------
ax_c = fig.add_axes([0.9, 0.1, 0.03, 0.8])
cb = ColorbarBase(ax_c,
cmap=cmap,
norm=norm,
orientation='vertical',
label=label_text)
plt.show()
linewidth=1.0)
ax[s].axvline(x=2.0,
ymin=0,
ymax=len(picks),
color='black',
linestyle='dashed',
linewidth=1.0)
colormap = cm.get_cmap('RdBu_r')
orientation = 'vertical'
norm = Normalize(vmin=-5.0, vmax=5.0)
divider = make_axes_locatable(ax[s])
cax = divider.append_axes('right', size='2.5%', pad=0.2)
cbar = ColorbarBase(cax,
cm.get_cmap('RdBu_r'),
ticks=[-5.0, 0., 5.0],
norm=norm,
label=r'Difference B-A ($\mu$V)',
orientation=orientation)
cbar.outline.set_visible(False)
cbar.ax.set_frame_on(True)
label = r'Difference B-A (in $\mu V$)'
for key in ('left', 'top',
'bottom' if orientation == 'vertical' else 'right'):
cbar.ax.spines[key].set_visible(False)
fig.subplots_adjust(left=0.05,
right=0.95,
bottom=0.15,
wspace=0.3,
hspace=0.25)
def _draw_colorbar(stat_map_img, axes,
threshold=.1,
nb_ticks=5,
edge_color="0.5",
edge_alpha=1,
aspect=40,
fraction=0.025,
anchor=(10.0,0.5),
cut_coords=None,
positive_only=False,
negative_only=False,
cmap=None,
really_draw=True,
bypass_cmap=False,
pad=0.05,
panchor=(10.0, 0.5),
shrink=1.0,
):
if bypass_cmap:
bypass_cmap = cmap
if isinstance(stat_map_img, str):
stat_map_img = path.abspath(path.expanduser(stat_map_img))
stat_map_img = nib.load(stat_map_img)
stat_map_img_dat = _safe_get_data(stat_map_img, ensure_finite=True)
else:
stat_map_img_dat = stat_map_img
cbar_vmin,cbar_vmax,vmin, vmax = _get_colorbar_and_data_ranges(stat_map_img_dat,None,"auto","")
if cmap:
try:
cmap = plt.cm.get_cmap(cmap)
except TypeError:
cmap = mcolors.LinearSegmentedColormap.from_list('SAMRI cmap from list', cmap*256, N=256)
colors = cmap(np.linspace(0,1,256))
if positive_only:
cmap_plus = mcolors.LinearSegmentedColormap.from_list('my_colormap', colors[0:255,:])
elif negative_only:
cmap_minus = mcolors.LinearSegmentedColormap.from_list('my_colormap', colors[0:255,:])
else:
cmap_minus = mcolors.LinearSegmentedColormap.from_list('my_colormap', colors[0:128,:])
cmap_plus = mcolors.LinearSegmentedColormap.from_list('my_colormap', colors[128:255,:])
else:
cmap_minus = MYMAP_MINUS
cmap_plus = MYMAP_PLUS
cmap = MYMAP
if cbar_vmin is not None or positive_only:
vmin = 0
colmap = cmap_plus
elif cbar_vmax is not None or negative_only:
vmax = 0
colmap = cmap_minus
else:
colmap = cmap
ticks = np.linspace(vmin, vmax, nb_ticks)
bounds = np.linspace(vmin, vmax, colmap.N)
norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
# some colormap hacking
cmaplist = [colmap(i) for i in range(colmap.N)]
istart = int(norm(-threshold, clip=True) * (colmap.N - 1))
istop = int(norm(threshold, clip=True) * (colmap.N - 1))
for i in range(istart, (istop+1)):
# just an average gray color
cmaplist[i] = (0.5, 0.5, 0.5, 1.)
try:
our_cmap = colmap.from_list('Custom cmap', cmaplist, colmap.N)
except AttributeError:
pass
if really_draw:
cbar_ax, p_ax = make_axes(axes,
fraction=fraction,
pad=pad,
shrink=shrink,
aspect=aspect,
anchor=anchor,
panchor=panchor,
)
cbar = ColorbarBase(
cbar_ax,
ticks=ticks,
norm=norm,
orientation="vertical",
cmap=our_cmap,
boundaries=bounds,
spacing="proportional",
format="%.2g",
)
cbar.outline.set_edgecolor(edge_color)
cbar.outline.set_alpha(edge_alpha)
cbar_ax.yaxis.tick_left()
tick_color = 'k'
for tick in cbar_ax.yaxis.get_ticklabels():
tick.set_color(tick_color)
cbar_ax.yaxis.set_tick_params(width=0)
else:
cbar_ax = None
p_ax = None
if bypass_cmap:
colmap = bypass_cmap
return cbar_ax, p_ax,vmin,vmax,colmap
def plotter(fdict):
""" Go """
ctx = get_autoplot_context(fdict, get_description())
df = get_data(ctx)
cmap = 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
def _colormap_plot_beamforming_polar(cmaps):
"""
Plot for illustrating colormaps: beamforming.
:param cmaps: list of :class:`~matplotlib.colors.Colormap`
:rtype: None
"""
import matplotlib.pyplot as plt
from matplotlib.colorbar import ColorbarBase
from matplotlib.colors import Normalize
from obspy import UTCDateTime
from obspy.signal.array_analysis import array_processing
# Execute array_processing
kwargs = dict(
# slowness grid: X min, X max, Y min, Y max, Slow Step
sll_x=-3.0,
slm_x=3.0,
sll_y=-3.0,
slm_y=3.0,
sl_s=0.03,
# sliding window properties
win_len=1.0,
win_frac=0.05,
# frequency properties
frqlow=1.0,
frqhigh=8.0,
prewhiten=0,
# restrict output
semb_thres=-1e9,
vel_thres=-1e9,
stime=UTCDateTime("20080217110515"),
etime=UTCDateTime("20080217110545"))
st = _get_beamforming_example_stream()
out = array_processing(st, **kwargs)
# make output human readable, adjust backazimuth to values between 0 and
# 360
t, rel_power, abs_power, baz, slow = out.T
baz[baz < 0.0] += 360
# choose number of fractions in plot (desirably 360 degree/N is an
# integer!)
num = 36
num2 = 30
abins = np.arange(num + 1) * 360. / num
sbins = np.linspace(0, 3, num2 + 1)
# sum rel power in bins given by abins and sbins
hist, baz_edges, sl_edges = \
np.histogram2d(baz, slow, bins=[abins, sbins], weights=rel_power)
# transform to radian
baz_edges = np.radians(baz_edges)
dh = abs(sl_edges[1] - sl_edges[0])
dw = abs(baz_edges[1] - baz_edges[0])
for cmap in cmaps:
# add polar and colorbar axes
fig = plt.figure(figsize=(8, 8))
cax = fig.add_axes([0.85, 0.2, 0.05, 0.5])
ax = fig.add_axes([0.10, 0.1, 0.70, 0.7], polar=True)
ax.set_theta_direction(-1)
ax.set_theta_zero_location("N")
# circle through backazimuth
for i, row in enumerate(hist):
ax.bar((i * dw) * np.ones(num2),
height=dh * np.ones(num2),
width=dw,
bottom=dh * np.arange(num2),
color=cmap(row / hist.max()))
ax.set_xticks(np.linspace(0, 2 * np.pi, 4, endpoint=False))
ax.set_xticklabels(['N', 'E', 'S', 'W'])
# set slowness limits
ax.set_ylim(0, 3)
[i.set_color('grey') for i in ax.get_yticklabels()]
ColorbarBase(cax,
cmap=cmap,
norm=Normalize(vmin=hist.min(), vmax=hist.max()))
plt.show()
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.decode(),
"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', end=' ')
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
def main(infold, mns_path, epsg_code, outfile, titre):
"""Main plotting function."""
files = {}
for file in infold.iterdir():
files.update({file.name: file})
# Extract the info
nb = list(files.keys())[0].split("_")[-1].split(".")[0]
width = list(files.keys())[0].split("_")[-3]
azi = list(files.keys())[0].split("_")[-5]
# Open gdal raster
MNS_data, MNS_gt, MNS_ds = open_large_raster(str(mns_path))
# Open transect
data_tr = {}
for fname, pth in files.items():
if "transect" in fname:
with open(pth, "rb") as f:
transects = pickle.load(f)
else:
data_tr.update({"_".join(fname.split("_")[0:2]): pd.read_hdf(pth)})
# Get very approximate center of transects
midishline = transects[int(len(transects) / 2)]
mid_point = midishline.interpolate(0.5, normalized=True)
midpoint_buffer = mid_point.buffer(midishline.length / 2)
envelope = midpoint_buffer.envelope
# Turn interactive plotting off
plt.ioff()
# Create figure
fig = plt.figure(figsize=(15.4, 6.6))
fig.suptitle(titre)
# Epsg
proj_code = ccrs.epsg(epsg_code)
# 2 by 2 grid
gs = GridSpec(ncols=3, nrows=2, figure=fig, width_ratios=[0.1, 1.5, 4])
ax = plt.subplot(gs[0, 1], projection=proj_code)
ax1 = plt.subplot(gs[:, 0])
ax2 = plt.subplot(gs[-1, 1], projection=proj_code)
ax3 = plt.subplot(gs[:, -1])
# AX
mns_masked = np.ma.masked_where(MNS_data < 0, MNS_data)
extent = (
MNS_gt[0],
MNS_gt[0] + MNS_ds.RasterXSize * MNS_gt[1],
MNS_gt[3] + MNS_ds.RasterYSize * MNS_gt[5],
MNS_gt[3],
)
ax.imshow(
mns_masked, extent=extent, origin="upper", cmap="gist_earth"
)
ax.plot(
[midishline.coords[0][0], midishline.coords[-1][0]],
[midishline.coords[0][1], midishline.coords[-1][1]],
linestyle="-",
color="red",
linewidth=1,
)
norm = Normalize(vmin=np.min(mns_masked), vmax=np.max(mns_masked))
cbar = ColorbarBase(
ax1, cmap=plt.get_cmap("gist_earth"), norm=norm, orientation="vertical"
)
cbar.ax.yaxis.set_label_position("left")
cbar.ax.set_ylabel("Altitude / m")
# AX2
ax2.imshow(
mns_masked, extent=extent, origin="upper", cmap="gist_earth"
)
for line in transects:
ax2.plot(
[line.coords[0][0], line.coords[-1][0]],
[line.coords[0][1], line.coords[-1][1]],
linestyle="-",
color="black",
alpha=0.6,
linewidth=0.5,
)
ax2.set_extent(
[
envelope.bounds[0],
envelope.bounds[2],
envelope.bounds[1],
envelope.bounds[-1],
],
crs=ccrs.epsg(epsg_code),
)
ax2.set_title("Zoom on transects", y=-0.2)
# AX3
# Plot MNT/ MNS ground
data_tr["MNT_solnu"].T.plot(
ax=ax3, color="sienna", alpha=0.1, legend=False
)
data_tr["MNT_solnu"].T.mean(axis=1).plot(
ax=ax3, color="sienna", legend=True, label="Mean summer DTM"
)
data_tr["MNS_solnu"].T.plot(
ax=ax3, color="lightgreen", alpha=0.1, legend=False
)
data_tr["MNS_solnu"].T.mean(axis=1).plot(
ax=ax3, color="lightgreen", legend=True, label="Mean summer DSM"
)
# Plot MNS neige
data_tr["MNS_neige"].T.plot(
ax=ax3, color="midnightblue", alpha=0.2, legend=False
)
data_tr["MNS_neige"].T.mean(axis=1).plot(
ax=ax3, color="midnightblue", legend=True, label="Mean winter DSM"
)
ax3.set_title(
"Azimuth: %s°, Width: %sm, # of transects: %s" % (azi, width, nb)
)
ax3.set_xlabel("Distance along transect / m")
ax3.set_ylabel("Altitude / m")
ax3.set_xlim(0, midishline.length)
ax3.set_ylim(
np.nanmin(data_tr["MNT_solnu"].T.mean(axis=1)) - 5,
np.nanmax(data_tr["MNS_neige"].T.mean(axis=1)) + 5,
)
ax3.xaxis.set_major_locator(MultipleLocator(10))
ax3.xaxis.set_minor_locator(MultipleLocator(5))
ax3.yaxis.set_major_locator(MultipleLocator(1))
ax3.yaxis.set_minor_locator(MultipleLocator(0.5))
ax3.xaxis.set_ticks_position("both")
ax3.yaxis.set_ticks_position("both")
ax3.tick_params(direction="inout", which="both")
fig.savefig(infold.joinpath(outfile), bbox_inches="tight", dpi=300)
def plot_heatmap(dataframe,
vmin=None,
vmax=None,
cmap=None,
center=None,
robust=False,
annot=None,
fmt='.2g',
annot_kws=None,
linewidths=0,
linecolor='white',
cbar=False,
cbar_kws=None,
cbar_ax=None,
square=False,
xticklabels=False,
yticklabels=False,
mask=None,
figure_size=FIGURE_SIZE,
data_type='continuous',
normalization_method=None,
normalization_axis=0,
max_std=3,
axis_to_sort=None,
cluster=False,
row_annotation=(),
column_annotation=(),
annotation_colors=(),
title=None,
xlabel=None,
ylabel=None,
xlabel_rotation=0,
ylabel_rotation=90,
xtick_rotation=90,
ytick_rotation=0,
filepath=None,
file_extension='pdf',
dpi=DPI,
**kwargs):
"""
Plot heatmap.
:param dataframe:
:param vmin:
:param vmax:
:param cmap:
:param center:
:param robust:
:param annot:
:param fmt:
:param annot_kws:
:param linewidths:
:param linecolor:
:param cbar:
:param cbar_kws:
:param cbar_ax:
:param square:
:param xticklabels:
:param yticklabels:
:param mask:
:param figure_size:
:param data_type:
:param normalization_method:
:param normalization_axis:
:param max_std:
:param axis_to_sort:
:param cluster:
:param row_annotation:
:param column_annotation:
:param annotation_colors: list; a list of matplotlib color specifications
:param title:
:param xlabel:
:param ylabel:
:param xlabel_rotation:
:param ylabel_rotation:
:param xtick_rotation:
:param ytick_rotation:
:param filepath:
:param file_extension:
:param dpi:
:param kwargs:
:return: None
"""
df = dataframe.copy()
if normalization_method:
df = normalize_2d_or_1d(df,
normalization_method,
axis=normalization_axis).clip(
-max_std, max_std)
if len(row_annotation) or len(column_annotation):
if len(row_annotation):
if isinstance(row_annotation, Series):
row_annotation = row_annotation.copy()
if not len(row_annotation.index & df.index): # Series
# but without proper index
row_annotation.index = df.index
else:
row_annotation = Series(row_annotation, index=df.index)
row_annotation.sort_values(inplace=True)
df = df.ix[row_annotation.index, :]
if len(column_annotation):
if isinstance(column_annotation, Series):
column_annotation = column_annotation.copy()
# Series but without proper index
if not len(column_annotation.index & df.columns):
column_annotation.index = df.columns
else:
column_annotation = Series(column_annotation, index=df.columns)
column_annotation.sort_values(inplace=True)
df = df.ix[:, column_annotation.index]
if axis_to_sort in (0, 1):
a = array(df)
a.sort(axis=axis_to_sort)
df = DataFrame(a, index=df.index)
elif cluster:
row_indices, column_indices = get_dendrogram_leaf_indices(dataframe)
df = df.iloc[row_indices, column_indices]
if isinstance(row_annotation, Series):
row_annotation = row_annotation.iloc[row_indices]
if isinstance(column_annotation, Series):
column_annotation = column_annotation.iloc[column_indices]
figure(figsize=figure_size)
gridspec = GridSpec(10, 10)
ax_top = subplot(gridspec[0:1, 2:-2])
ax_center = subplot(gridspec[1:8, 2:-2])
ax_bottom = subplot(gridspec[8:10, 2:-2])
ax_left = subplot(gridspec[1:8, 1:2])
ax_right = subplot(gridspec[1:8, 8:9])
ax_top.axis('off')
ax_bottom.axis('off')
ax_left.axis('off')
ax_right.axis('off')
if not cmap:
if data_type == 'continuous':
cmap = CMAP_CONTINUOUS
elif data_type == 'categorical':
cmap = CMAP_CATEGORICAL
elif data_type == 'binary':
cmap = CMAP_BINARY
else:
raise ValueError(
'Target data type must be continuous, categorical, or binary.')
heatmap(df,
vmin=vmin,
vmax=vmax,
cmap=cmap,
center=center,
robust=robust,
annot=annot,
fmt=fmt,
annot_kws=annot_kws,
linewidths=linewidths,
linecolor=linecolor,
cbar=cbar,
cbar_kws=cbar_kws,
cbar_ax=cbar_ax,
square=square,
ax=ax_center,
xticklabels=xticklabels,
yticklabels=yticklabels,
mask=mask,
**kwargs)
# Get values for making legend
values = unique(df.values)
values = values[~isnull(values)]
if data_type == 'continuous': # Plot colorbar
# Get not-nan values for computing min, mean, & max
min_ = values.min()
mean_ = values.mean()
max_ = values.max()
cax, kw = make_axes(ax_bottom,
location='bottom',
fraction=0.16,
cmap=cmap,
norm=Normalize(min_, max_),
ticks=[min_, mean_, max_])
ColorbarBase(cax, **kw)
decorate(ax=cax, xtick_rotation=90)
elif data_type in ('categorical', 'binary'): # Plot category legends
if len(values) < 30:
horizontal_span = ax_center.axis()[1]
vertical_span = ax_center.axis()[3]
colors = assign_colors_to_states(values, colors=cmap)
columns = df.columns.tolist()
if isinstance(columns[0], str):
max_len_c = max([len(c) for c in columns])
else:
max_len_c = 10
vertical_offset = 0.016 * max_len_c
for i, v in enumerate(values):
x = (horizontal_span / len(values) / 2) + \
i * horizontal_span / len(values)
y = 0 - vertical_span * vertical_offset
c = colors[v]
ax_center.plot(x,
y,
'o',
color=c,
markersize=16,
aa=True,
clip_on=False)
ax_center.text(x,
y - vertical_span * 0.05,
v,
horizontalalignment='center',
**FONT_STANDARD)
decorate(title=title,
xlabel=xlabel,
ylabel=ylabel,
xlabel_rotation=xlabel_rotation,
ylabel_rotation=ylabel_rotation,
xtick_rotation=xtick_rotation,
ytick_rotation=ytick_rotation,
ax=ax_center)
if len(row_annotation):
if len(set(row_annotation)) <= 2:
cmap = CMAP_BINARY
else:
if len(annotation_colors):
cmap = ListedColormap(annotation_colors)
else:
cmap = CMAP_CATEGORICAL
heatmap(DataFrame(row_annotation),
ax=ax_right,
cbar=False,
xticklabels=False,
yticklabels=False,
cmap=cmap)
if len(column_annotation):
if len(set(column_annotation)) <= 2:
cmap = CMAP_BINARY
else:
if len(annotation_colors):
cmap = ListedColormap(annotation_colors)
else:
cmap = CMAP_CATEGORICAL
heatmap(DataFrame(column_annotation).T,
ax=ax_top,
cbar=False,
xticklabels=False,
yticklabels=False,
annot=True,
cmap=cmap)
if filepath:
save_plot(filepath, file_extension=file_extension, dpi=dpi)
time_hrs,
results[theta][var],
color=str(lightest_grey - theta * lightest_grey),
)
# Shrink margins
ax.set_ylim((90, 310) if var.startswith("Q") else (-2.5, 2))
ax.set_ylabel(
"Flow Rate [m³/s]" if var.startswith("Q") else "Water Level [m]")
ax.set_xlabel("Time [hrs]")
fig.tight_layout()
# Output Plot
plt.savefig(f"{var}.{file_type}")
# Generate a Bar Scale Legend
width = 4
height = 2
fig, axarr = plt.subplots(1, 5, figsize=(width, height))
for i, ax in enumerate(axarr):
if i != 2:
ax.set_axis_off()
cmap = ListedColormap(np.linspace(lightest_grey, 0.0, 256, dtype=str))
norm = Normalize(vmin=0.0, vmax=1.0)
cb = ColorbarBase(axarr[2], cmap=cmap, norm=norm, orientation="vertical")
plt.savefig(f"colorbar.{file_type}")
# 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 calendarplot(
data,
how="sum",
yearlabels=True,
yearascending=True,
yearlabel_kws=None,
subplot_kws=None,
gridspec_kws=None,
fig_kws=None,
fig_suptitle=None,
vmin=0,
vmax=16,
cmap="YlGn",
**kwargs
):
"""
Plot a timeseries as a calendar heatmap.
Parameters
----------
data : Series
Data for the plot. Must be indexed by a DatetimeIndex.
how : string
Method for resampling data by day. If `None`, assume data is already
sampled by day and don't resample. Otherwise, this is passed to Pandas
`Series.resample`.
yearlabels : bool
Whether or not to draw the year for each subplot.
yearascending : bool
Sort the calendar in ascending or descending order.
yearlabel_kws : dict
Keyword arguments passed to the matplotlib `set_ylabel` call which is
used to draw the year for each subplot.
subplot_kws : dict
Keyword arguments passed to the matplotlib `add_subplot` call used to
create each subplot.
gridspec_kws : dict
Keyword arguments passed to the matplotlib `GridSpec` constructor used
to create the grid the subplots are placed on.
fig_kws : dict
Keyword arguments passed to the matplotlib `figure` call.
vmin, vmax : floats
Values to anchor the colormap. If `None`, min and max are used after
resampling data by day.
kwargs : other keyword arguments
All other keyword arguments are passed to `yearplot`.
Returns
-------
fig, axes : matplotlib Figure and Axes
Tuple where `fig` is the matplotlib Figure object `axes` is an array
of matplotlib Axes objects with the calendar heatmaps, one per year.
Examples
--------
With `calendarplot` we can plot several years in one figure:
.. plot::
:context: close-figs
calmap.calendarplot(events)
"""
yearlabel_kws = yearlabel_kws or {}
subplot_kws = subplot_kws or {}
gridspec_kws = gridspec_kws or {}
fig_kws = fig_kws or {}
years = np.unique(data.index.year)
if not yearascending:
years = years[::-1]
if gridspec_kws == {}:
gridspec_kws = {'height_ratios': [5]*len(years)+[1]}
fig, axes = plt.subplots(
nrows=len(years)+1,
ncols=1,
squeeze=False,
subplot_kw=subplot_kws,
gridspec_kw=gridspec_kws,
**fig_kws
)
axes = axes.T[0]
plt.suptitle(fig_suptitle)
# We explicitely resample by day only once. This is an optimization.
if how is None:
by_day = data
else:
if _pandas_18:
by_day = data.resample("D").agg(how)
else:
by_day = data.resample("D", how=how)
ylabel_kws = dict(
fontsize=32,
color=kwargs.get("fillcolor", "silver"),
fontweight="bold",
fontname="Arial",
ha="center",
)
ylabel_kws.update(yearlabel_kws)
max_weeks = 0
for year, ax in zip(years, axes[:-1]):
yearplot(by_day, year=year, how=None, ax=ax, cmap=cmap, vmin=vmin, vmax=vmax, **kwargs)
max_weeks = max(max_weeks, ax.get_xlim()[1])
if yearlabels:
ax.set_ylabel(str(year), **ylabel_kws)
# In a leap year it might happen that we have 54 weeks (e.g., 2012).
# Here we make sure the width is consistent over all years.
for ax in axes:
ax.set_xlim(0, max_weeks)
cmap = plt.get_cmap(cmap)
bounds = range(vmin, vmax +1)
norm = BoundaryNorm(bounds, cmap.N, extend='both')
cb1 = ColorbarBase(axes[-1],
cmap=cmap,
norm=norm,
orientation='horizontal',
ticks=range(vmin, vmax + 1))
cb1.set_label('CTimer clocks')
# Make the axes look good.
plt.tight_layout()
return fig, axes
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",
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:
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)
def setup_axes(fig, cmap, norm):
ax = fig.add_axes([0.92, 0.12, 0.04, 0.35])
cbar = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='vertical', drawedges=False)
cbar.ax.tick_params(labelsize=8)
return ax, cbar
for i in range(nrows):
for j in range(ncols):
axis = ax[i][j]
axis.tick_params(labelbottom='off', labelleft='off')
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,
#!/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 WidgetPlot(FigureCanvas):
def __init__(self, parent=None):
FigureCanvas.__init__(self, Figure())
self._telemetry = None
self._resolution = None
self._cmap = None
self._wireframe = False
self.setParent(parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setFocus()
colour = self.palette().color(self.backgroundRole()).getRgbF()
self.figure.patch.set_facecolor(colour[:-1])
gs = GridSpec(1, 2, width_ratios=[9.5, 0.5])
self._axes = self.figure.add_subplot(gs[0], projection='3d')
self._axes.set_title('3D Plot')
self._axes.set_xlabel('Longitude')
self._axes.set_ylabel('Latitude')
self._axes.set_zlabel('Level (dB)')
self._axes.tick_params(axis='both', which='major', labelsize='smaller')
self._axes.grid(True)
formatMaj = ScalarFormatter(useOffset=False)
self._axes.xaxis.set_major_formatter(formatMaj)
self._axes.yaxis.set_major_formatter(formatMaj)
self._axes.zaxis.set_major_formatter(formatMaj)
formatMinor = AutoMinorLocator(10)
self._axes.xaxis.set_minor_locator(formatMinor)
self._axes.yaxis.set_minor_locator(formatMinor)
self._axes.zaxis.set_minor_locator(formatMinor)
self._axesBar = self.figure.add_subplot(gs[1])
self._axesBar.tick_params(axis='both',
which='major',
labelsize='smaller')
self._bar = ColorbarBase(self._axesBar)
if matplotlib.__version__ >= '1.2':
self.figure.tight_layout()
def set(self, telemetry):
self._telemetry = telemetry
def set_cmap(self, cmap):
self._cmap = cmap
def set_resolution(self, res):
self._resolution = res
def set_wireframe(self, wireframe):
self._wireframe = wireframe
def plot(self):
self.clear()
x, y, z = unique_locations(self._telemetry)
east = max(x)
west = min(x)
north = max(y)
south = min(y)
width = east - west
height = north - south
if width != 0 and height != 0:
xi = numpy.linspace(west, east, self._resolution)
yi = numpy.linspace(south, north, self._resolution)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
xSurf, ySurf = numpy.meshgrid(xi, yi)
zSurf = mlab.griddata(x, y, z, xi=xi, yi=yi)
vmin = numpy.min(zSurf)
vmax = numpy.max(zSurf)
zSurf[numpy.where(numpy.ma.getmask(zSurf) == True)] = vmin
zSurf.mask = False
if self._wireframe:
self._axes.plot_wireframe(xSurf,
ySurf,
zSurf,
linewidth=0.5,
gid='plot')
self._axesBar.set_visible(False)
else:
self._axes.plot_surface(xSurf,
ySurf,
zSurf,
vmin=vmin,
vmax=vmax,
rstride=1,
cstride=1,
linewidth=0.1,
cmap=self._cmap,
gid='plot')
self._bar.set_cmap(self._cmap)
self._bar.set_clim(vmin, vmax)
self._axesBar.set_ylim(vmin, vmax)
self._axesBar.set_visible(True)
self.draw()
def clear(self):
children = self._axes.get_children()
for child in children:
gid = child.get_gid()
if gid is not None and gid == 'plot':
child.remove()
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
AK_OFFSET_X = -250000 # X offset for Alaska (These four values are obtained
AK_OFFSET_Y = -750000 # via manual trial and error, thus changing them is not recommended.)
for nshape, shapedict in enumerate(m_.states_info): # plot Alaska and Hawaii as map insets
if shapedict['NAME'] in ['Alaska', 'Hawaii']:
seg = m_.states[int(shapedict['SHAPENUM'] - 1)]
if shapedict['NAME'] == 'Hawaii' and float(shapedict['AREA']) > AREA_1:
seg = [(x + HI_OFFSET_X, y + HI_OFFSET_Y) for x, y in seg]
color = rgb2hex(colors[statenames[nshape]])
elif shapedict['NAME'] == 'Alaska' and float(shapedict['AREA']) > AREA_2:
seg = [(x*AK_SCALE + AK_OFFSET_X, y*AK_SCALE + AK_OFFSET_Y)\
for x, y in seg]
color = rgb2hex(colors[statenames[nshape]])
poly = Polygon(seg, facecolor=color, edgecolor='gray', linewidth=.45)
ax.add_patch(poly)
ax.set_title('Number of electors')
#%% --------- Plot bounding boxes for Alaska and Hawaii insets --------------
light_gray = [0.8]*3 # define light gray color RGB
x1,y1 = m_([-190,-183,-180,-180,-175,-171,-171],[29,29,26,26,26,22,20])
x2,y2 = m_([-180,-180,-177],[26,23,20]) # these numbers are fine-tuned manually
m_.plot(x1,y1,color=light_gray,linewidth=0.8) # do not change them drastically
m_.plot(x2,y2,color=light_gray,linewidth=0.8)
#%% --------- Show color bar ---------------------------------------
ax_c = fig.add_axes([0.9, 0.1, 0.03, 0.8])
cb = ColorbarBase(ax_c,cmap=cmap,norm=norm,orientation='vertical',
label=r'[population per $\mathregular{km^2}$]')
plt.show()
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 corr_plot(x_cof,
x_name=None,
left_down="circle",
right_top="pie",
threshold_left=0.0,
threshold_right=0.0,
title=None,
label_axis="off",
front_raito=1):
"""
相关系数图,比较耗时，不要超过25个特征。
Examples
-----------
>>> data = load_boston(return_X_y=False)
>>> name0 = data["feature_names"]
>>> x = data["data"]
>>> ys = data["target"]
>>> x_cof = np.corrcoef(x.T)
>>> #plot
>>> plt = corr_plot(x_cof, name0, left_down="circle", right_top="text", threshold_right=0.7, label_axis="off")
>>> plt.show()
Parameters
----------
x_cof:np.ndarray
correlation coefficient matrix
x_name:list,None
feature names
left_down:None,"pie","fill","text","circle"
type for left_down
right_top:None,"pie","fill","text","circle"
type for right_top
threshold_left:float
threshold for show.
threshold_right:float
threshold for show.
title:str
picture title
label_axis:"left","right","off"
label_axis
front_raito:float
front scare for show
"""
assert x_cof.shape[0] == x_cof.shape[1]
x_cof = np.round(x_cof, 2)
if x_name is None:
name = ["$x_{{{i}}}$".format(i=i) for i in range(x_cof.shape[1])]
size = x_cof
or_size = np.nan_to_num((abs(size) / size) * (1 - abs(size)))
n = size.shape[0]
explode = (0, 0)
gs = gridspec.GridSpec(n, n)
gs.update(wspace=0, hspace=0)
cmap = plt.get_cmap("bwr") # args
fill_colors = cmap(size / 2 + 0.5) # args
fig = plt.figure(figsize=(12, 12), frameon=True) # args
title_fontsize = round(22 * front_raito) # c_args
ax_fontsize = round(22 * front_raito)
score_fontsize = round(16 * front_raito)
circle_size = round(600 * front_raito)
fig.text(0.5,
0.05,
title,
fontsize=title_fontsize,
horizontalalignment='center',
verticalalignment='center') # zou, xia
for i, j in product(range(n), range(n)):
if j < i and abs(size[i, j]) >= threshold_left:
types = left_down
elif j > i and abs(size[i, j]) >= threshold_right:
types = right_top
else:
types = None
if types == "pie":
ax = plt.subplot(gs[i, j])
ax.pie(
(abs(size[i, j]), abs(or_size[i, j])),
explode=explode,
labels=None,
autopct=None,
shadow=False,
startangle=90,
colors=[fill_colors[i, j], 'w'],
wedgeprops=dict(width=1, edgecolor='black', linewidth=0.5),
counterclock=False,
frame=False,
center=(0, 0),
)
ax.set_xlim(-1, 1)
ax.axis('equal')
elif types == "fill":
ax = plt.subplot(gs[i, j])
ax.set_facecolor(fill_colors[i, j])
[
ax.spines[_].set_color('w')
for _ in ['right', 'top', 'left', 'bottom']
]
ax.set_xticks([])
ax.set_yticks([])
elif types == "fillandtext":
ax = plt.subplot(gs[i, j])
ax.set_facecolor(fill_colors[i, j])
[
ax.spines[_].set_color('w')
for _ in ['right', 'top', 'left', 'bottom']
]
ax.text(
0.5,
0.5,
size[i, j],
fontdict={"color": "black"}, # args
fontsize=score_fontsize, # c_arg
horizontalalignment='center',
verticalalignment='center')
elif types == "text":
ax = plt.subplot(gs[i, j])
ax.text(
0.5,
0.5,
size[i, j],
fontdict={"color": "b"}, # args
fontsize=score_fontsize, # c_arg
horizontalalignment='center',
verticalalignment='center')
ax.set_xticks([])
ax.set_yticks([])
# plt.axis('off')
elif types == "circle":
ax = plt.subplot(gs[i, j])
ax.axis('equal')
ax.set_xlim(-1, 1)
ax.scatter(0,
0,
color=fill_colors[i, j],
s=circle_size * abs(size[i, j])**2)
ax.set_xticks([])
ax.set_yticks([])
# plt.axis('off')
else:
pass
for k in range(n):
ax = plt.subplot(gs[k, k])
# ax.axis('equal')
# ax.set_xlim(-1, 1)
# ax.scatter(0, 0, color=fill_colors[k, k], s=circle_size * abs(size[k, k]))
# ax.set_xticks([])
#
# ax.set_yticks([])
ax.text(0.5,
0.5,
name[k],
fontsize=ax_fontsize,
horizontalalignment='center',
verticalalignment='center')
ax.set_xticks([])
ax.set_yticks([])
if label_axis == "left":
color = ["w", "w", "b", "b"]
[
ax.spines[i].set_color(j)
for i, j in zip(['right', 'top', 'left', 'bottom'], color)
]
elif label_axis == "right":
color = ["b", "b", "w", "w"]
[
ax.spines[i].set_color(j)
for i, j in zip(['right', 'top', 'left', 'bottom'], color)
]
else:
plt.axis('off')
@pyplot.FuncFormatter
def fake_(x, pos):
return round(2 * (x - 0.5), 1)
fig.subplots_adjust(right=0.80)
cbar_ax = fig.add_axes([0.85, 0.125, 0.03, 0.75])
ColorbarBase(cbar_ax,
cmap=cmap,
ticks=[0, 0.25, 0.5, 0.75, 1],
format=fake_)
fig.set_size_inches(9, 8.5, forward=True)
return plt
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()
def change_cbar_text(cbar:ColorbarBase, tick:list, text:list):
cbar.set_ticks(tick)
cbar.set_ticklabels(text)
def plot(self, figname=None, db=True, **kwargs):
""" Plot the HEALPix :attr:`~nenupy.astro.hpxsky.HpxSky.skymap`
on an equatorial grid with a Elliptical frame.
:param figname:
Figure name, if ``None`` (default value), the
figure is not saved.
:type figname: `str`
:param db:
Sacle the data in decibel units. Default is
``True``.
:type db: `bool`
:param cmap:
Name of the colormap. Default is ``'YlGnBu_r'``.
:type cmap: `str`
:param vmin:
Minimum value to scale the figure. Default is
min(:attr:`~nenupy.astro.hpxsky.HpxSky.skymap`).
:type vmin: `float`
:param vmax:
Maximum value to scale the figure. Default is
max(:attr:`~nenupy.astro.hpxsky.HpxSky.skymap`).
:type vmax: `float`
:param tickscol:
Color of the RA ticks. Default is ``'black'``.
:type tickscol: `str`
:param title:
Title of the plot. Default is ``None``.
:type title: `str`
:param cblabel:
Colorbar label. Default is ``'Amp'`` if ``db=False``
of ``'dB'`` if ``db=True``.
:type cblabel: `str`
:param grid:
Show the equatorial grid.
:type grid: `bool`
:param cbar:
Plot a colorbar.
:type cbar: `bool`
:param center:
Center of the plot. Default is
``SkyCoord(0.*u.deg, 0.*u.deg)``.
:type center: :class:`~astropy.coordinates.SkyCoord`
:param size:
Diameter of the cutout. Default is whole sky.
:type size: `float` or :class:`~astropy.units.Quantity`
:param figsize:
Figure size in inches. Default is ``(15, 10)``.
:type figsize: `tuple`
:param indices:
Default is ``None``. If not, a scatter plot is
made on the desired HEALPix indices:
``(indices, size, color)``.
:type indices: `tuple`
:param scatter:
Default is ``None``. If not, a scatter plot is
made on the desired equatorial coordinates:
``(ra (deg), dec (deg), size, color)``.
:type scatter: `tuple`
:param text:
Default is ``None``. If not, text is overplotted
on the desired equatorial coordinates:
``(ra (deg), dec (deg), text, color)``.
:type text: `tuple`
:param curve:
Default is ``None``. If not, a curve plot is
made on the desired equatorial coordinates:
``(ra (deg), dec (deg), linestyle, color)``.
:type curve: `tuple`
"""
# Lot of imports for this one...
from reproject import reproject_from_healpix
from astropy.coordinates import ICRS
from astropy.visualization.wcsaxes.frame import EllipticalFrame
import matplotlib.pyplot as plt
from matplotlib.colorbar import ColorbarBase
from matplotlib.ticker import LinearLocator
from matplotlib.colors import Normalize
from matplotlib.cm import get_cmap
from mpl_toolkits.axes_grid1.inset_locator import inset_axes
# Cutout?
raauto = True
if 'center' not in kwargs.keys():
kwargs['center'] = SkyCoord(0. * u.deg, 0. * u.deg)
if not isinstance(kwargs['center'], SkyCoord):
raise TypeError('center must be a SkyCoord object.')
# Preparing WCS projection
dangle = 0.675
scale = int(dangle / self.resolution.deg)
scale = 1 if scale <= 1 else scale
nra = 480 * scale
ndec = 240 * scale
if 'size' in kwargs.keys():
if isinstance(kwargs['size'], u.Quantity):
kwargs['size'] = kwargs['size'].to(u.deg).value
resol = dangle / scale
nra = int(kwargs['size'] / resol)
ndec = nra
raauto = False
wcs = WCS(naxis=2)
wcs.wcs.crpix = [nra / 2 + 0.5, ndec / 2 + 0.5]
wcs.wcs.cdelt = np.array([-dangle / scale, dangle / scale])
wcs.wcs.crval = [kwargs['center'].ra.deg, kwargs['center'].dec.deg]
wcs.wcs.ctype = ['RA---AIT', 'DEC--AIT']
# Make an array out of HEALPix representation
skymap = self.skymap.copy()
if self.visible_sky:
skymap[~self._is_visible] = np.nan
array, fp = reproject_from_healpix((skymap, ICRS()),
wcs,
nested=False,
shape_out=(ndec, nra))
# Decibel or linear?
if db:
data = 10 * np.log10(array)
cblabel = 'dB'
else:
data = array
cblabel = 'Amp'
mask = ~np.isnan(data) * ~np.isinf(data)
# Make sure everything is correctly set up
if 'cmap' not in kwargs.keys():
kwargs['cmap'] = 'YlGnBu_r'
if 'vmin' not in kwargs.keys():
kwargs['vmin'] = np.min(data[mask])
elif kwargs['vmin'] is None:
kwargs['vmin'] = np.min(data[mask])
else:
pass
if 'vmax' not in kwargs.keys():
kwargs['vmax'] = np.max(data[mask])
elif kwargs['vmax'] is None:
kwargs['vmax'] = np.max(data[mask])
else:
pass
if 'tickscol' not in kwargs.keys():
kwargs['tickscol'] = 'black'
if 'title' not in kwargs.keys():
kwargs['title'] = None
if 'cblabel' not in kwargs.keys():
kwargs['cblabel'] = cblabel
if 'grid' not in kwargs.keys():
kwargs['grid'] = True
if 'cbar' not in kwargs.keys():
kwargs['cbar'] = True
if 'figsize' not in kwargs.keys():
kwargs['figsize'] = (15, 10)
if 'indices' not in kwargs.keys():
kwargs['indices'] = None
if 'scatter' not in kwargs.keys():
kwargs['scatter'] = None
if 'curve' not in kwargs.keys():
kwargs['curve'] = None
if 'text' not in kwargs.keys():
kwargs['text'] = None
# Initialize figure
fig = plt.figure(figsize=kwargs['figsize'])
ax = plt.subplot(projection=wcs, frame_class=EllipticalFrame)
# Full sky
im = ax.imshow(data,
origin='lower',
interpolation='none',
cmap=kwargs['cmap'],
vmin=kwargs['vmin'],
vmax=kwargs['vmax'])
axra = ax.coords[0]
axdec = ax.coords[1]
if kwargs['grid']:
ax.coords.grid(color=kwargs['tickscol'], alpha=0.5)
axra.set_ticks_visible(False)
axra.set_ticklabel(color=kwargs['tickscol'])
axra.set_axislabel('RA', color=kwargs['tickscol'])
axra.set_major_formatter('d')
if raauto:
axra.set_ticks([0, 45, 90, 135, 225, 270, 315] * u.degree)
else:
axra.set_ticks(number=10)
axdec.set_ticks_visible(False)
axdec.set_axislabel('Dec')
axdec.set_major_formatter('d')
axdec.set_ticks(number=10)
else:
axra.set_ticks_visible(False)
axdec.set_ticks_visible(False)
axra.set_ticklabel_visible(False)
axdec.set_ticklabel_visible(False)
# Overplot
if kwargs['indices'] is not None:
ax.scatter(x=self.eq_coords[kwargs['indices'][0]].ra.deg,
y=self.eq_coords[kwargs['indices'][0]].dec.deg,
s=[kwargs['indices'][1]] * len(kwargs['indices'][0]),
color=kwargs['indices'][2],
transform=ax.get_transform('world'))
if kwargs['scatter'] is not None:
ax.scatter(x=kwargs['scatter'][0],
y=kwargs['scatter'][1],
s=[kwargs['scatter'][2]] * len(kwargs['scatter'][0]),
color=kwargs['scatter'][3],
transform=ax.get_transform('world'))
if kwargs['curve'] is not None:
ax.plot(kwargs['curve'][0],
kwargs['curve'][1],
linestyle=kwargs['curve'][2],
color=kwargs['curve'][3],
transform=ax.get_transform('world'))
if kwargs['text'] is not None:
for i in range(len(kwargs['text'][0])):
ax.text(x=kwargs['text'][0][i],
y=kwargs['text'][1][i],
s=kwargs['text'][2][i],
color=kwargs['text'][3],
transform=ax.get_transform('world'))
im.set_clip_path(ax.coords.frame.patch)
ax.set_title(kwargs['title'], pad=25)
# Colorbar
if kwargs['cbar']:
cax = inset_axes(
ax,
width='3%',
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=kwargs['cmap']),
orientation='vertical',
norm=Normalize(vmin=kwargs['vmin'],
vmax=kwargs['vmax']),
ticks=LinearLocator())
cb.solids.set_edgecolor('face')
cb.set_label(kwargs['cblabel'])
cb.formatter.set_powerlimits((0, 0))
# Save or show
if figname is None:
plt.show()
elif figname.lower() == 'return':
return fig, ax
else:
fig.savefig(figname,
dpi=300,
transparent=True,
bbox_inches='tight')
plt.close('all')
return
def display_forces(simulation_folder, lower_percentile=97.5, upper_percentile=99, save_plot = True, arrow_factor=5):
"""
show the force density field of the masked force components
simulation_folder: path to simulation folder
lower_percentile and upper_percentile give range of forces 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
"""
# load in forces and coordinates
r = np.genfromtxt(os.path.join(simulation_folder, "R.dat")) # positions
f = np.genfromtxt(os.path.join(simulation_folder, "Fden.dat")) # force densities
fabs = np.sqrt(np.sum(f ** 2., axis=1)) # absolute values for filtering
# filter
mask = (fabs > np.percentile(fabs, lower_percentile)) & (fabs < np.percentile(fabs, upper_percentile))
r2 = r[mask]
f2 = f[mask]
fabs2 = fabs[mask]
# Force
fig2 = plt.figure()
ax2 = fig2.gca(projection='3d', label='fitted-forces', rasterized=True)
color_bounds2 = np.array([np.percentile(fabs2, 0.1), np.percentile(fabs2, 99.9)]) * 10 ** -6
for r2i, f2i, fabs2i in tqdm(zip(r2 * 10 ** 6, f2 * 10 ** -6, fabs2 * (10 ** -6))): #*f_scale
color = plt.cm.hot(((fabs2i - color_bounds2[0]) / (color_bounds2[1] - color_bounds2[0])))
# alpha = 1. - (r2i[0] - r2i[1]) / (270. * 1.25)
# if alpha > 1:
# alpha = 1.
alpha = 1.
ax2.quiver(r2i[0], r2i[1], r2i[2], f2i[0], f2i[1], f2i[2], length=fabs2i * arrow_factor ,
color=color, arrow_length_ratio=0, alpha=alpha, pivot='tip', linewidth=0.5)
# plot colorbar ---------------------------------------------------------
cbaxes = fig2.add_axes([0.15, 0.1, 0.125, 0.010])
cmap = plt.cm.hot
norm = plt.Normalize(vmin=color_bounds2[0], vmax=color_bounds2[1])
cb1 = ColorbarBase(cbaxes, cmap=cmap, norm=norm, orientation='horizontal')
cb1.set_label('Force Den. [pN/µm³]')
tick_locator = ticker.MaxNLocator(nbins=3)
cb1.locator = tick_locator
cb1.update_ticks()
# -------------------------------------------------------------------------
#ax2.set_xlim([-150, 150]) can be used to make an individual plot
#ax2.set_ylim([-150, 150])
#ax2.set_zlim([-150, 150])
#ax2.set_xticks([-100, -50, 0, 50, 100])
#ax2.set_yticks([-100, -50, 0, 50, 100])
#ax2.set_zticks([-100, -50, 0, 50, 100])
# ax2.set_xticklabels(['']*5)
# ax2.set_yticklabels(['']*5)
# ax2.set_zticklabels(['']*5)
ax2.w_xaxis.set_pane_color((0.2, 0.2, 0.2, 1.0))
ax2.w_yaxis.set_pane_color((0.2, 0.2, 0.2, 1.0))
ax2.w_zaxis.set_pane_color((0.2, 0.2, 0.2, 1.0))
if save_plot:
plt.savefig( os.path.join(simulation_folder,'force_density_plot_lower_{}_upper_{}.png'.format(lower_percentile, upper_percentile)), dpi=500 , bbox_inches="tight", pad_inches=0)
return
class Plotter(object):
def __init__(self, notify, figure, settings):
self.notify = notify
self.figure = figure
self.settings = settings
self.colourMap = self.settings.colourMap
self.axes = None
self.bar = None
self.barBase = None
self.threadPlot = None
self.extent = None
self.lines = {}
self.labels = {}
self.overflowLabels = {}
self.overflow = {'left': [],
'right': [],
'top': [],
'bottom': []}
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 ($\mathsf{dB/\sqrt{Hz}}$)')
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)
self.set_colourmap_use(self.settings.colourMapUse)
self.__setup_measure()
self.__setup_overflow()
self.hide_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.lines[Markers.MIN] = Line2D([0, 0], [0, 0], linestyle='--',
color='black')
self.lines[Markers.MAX] = Line2D([0, 0], [0, 0], linestyle='-.',
color='black')
self.lines[Markers.AVG] = Line2D([0, 0], [0, 0], dashes=dashesAvg,
color='magenta')
self.lines[Markers.GMEAN] = Line2D([0, 0], [0, 0], dashes=dashesGM,
color='green')
self.lines[Markers.HP] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='purple')
self.lines[Markers.HFS] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='purple')
self.lines[Markers.HFE] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='purple')
self.lines[Markers.OP] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='#996600')
self.lines[Markers.OFS] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='#996600')
self.lines[Markers.OFE] = 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.lines[Markers.MIN].set_path_effects([effect])
self.lines[Markers.MAX].set_path_effects([effect])
self.lines[Markers.AVG].set_path_effects([effect])
self.lines[Markers.GMEAN].set_path_effects([effect])
self.lines[Markers.HP].set_path_effects([effect])
self.lines[Markers.HFS].set_path_effects([effect])
self.lines[Markers.HFE].set_path_effects([effect])
self.lines[Markers.OP].set_path_effects([effect])
self.lines[Markers.OFS].set_path_effects([effect])
self.lines[Markers.OFE].set_path_effects([effect])
for line in self.lines.itervalues():
self.axes.add_line(line)
bbox = self.axes.bbox
box = dict(boxstyle='round', fc='white', ec='black', clip_box=bbox)
self.labels[Markers.MIN] = Text(0, 0, 'Min', fontsize='xx-small',
ha="right", va="bottom", bbox=box,
color='black')
self.labels[Markers.MAX] = Text(0, 0, 'Max', fontsize='xx-small',
ha="right", va="top", bbox=box,
color='black')
box['ec'] = 'magenta'
self.labels[Markers.AVG] = Text(0, 0, 'Mean', fontsize='xx-small',
ha="right", va="center", bbox=box,
color='magenta')
box['ec'] = 'green'
self.labels[Markers.GMEAN] = Text(0, 0, 'GMean', fontsize='xx-small',
ha="right", va="center", bbox=box,
color='green')
box['ec'] = 'purple'
self.labels[Markers.HP] = Text(0, 0, '-3dB', fontsize='xx-small',
ha="right", va="center", bbox=box,
color='purple')
self.labels[Markers.HFS] = Text(0, 0, '-3dB Start', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='purple')
self.labels[Markers.HFE] = Text(0, 0, '-3dB End', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='purple')
box['ec'] = '#996600'
self.labels[Markers.OP] = Text(0, 0, 'OBW', fontsize='xx-small',
ha="right", va="center", bbox=box,
color='#996600')
self.labels[Markers.OFS] = Text(0, 0, 'OBW Start', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='#996600')
self.labels[Markers.OFE] = Text(0, 0, 'OBW End', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='#996600')
for label in self.labels.itervalues():
self.axes.add_artist(label)
def __setup_overflow(self):
bbox = self.axes.bbox
box = dict(boxstyle='round', fc='white', ec='black', alpha=0.5,
clip_box=bbox)
self.overflowLabels['left'] = Text(0, 0.9, '', fontsize='xx-small',
ha="left", va="top", bbox=box,
transform=self.axes.transAxes,
alpha=0.5)
self.overflowLabels['right'] = Text(1, 0.9, '', fontsize='xx-small',
ha="right", va="top", bbox=box,
transform=self.axes.transAxes,
alpha=0.5)
self.overflowLabels['top'] = Text(0.9, 1, '', fontsize='xx-small',
ha="right", va="top", bbox=box,
transform=self.axes.transAxes,
alpha=0.5)
self.overflowLabels['bottom'] = Text(0.9, 0, '', fontsize='xx-small',
ha="right", va="bottom", bbox=box,
transform=self.axes.transAxes,
alpha=0.5)
for label in self.overflowLabels.itervalues():
self.axes.add_artist(label)
def __clear_overflow(self):
for label in self.overflowLabels:
self.overflow[label] = []
def __draw_hline(self, marker, y):
line = self.lines[marker]
label = self.labels[marker]
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)
elif y is not None and y < yLim[0]:
self.overflow['bottom'].append(marker)
elif y is not None and y > yLim[1]:
self.overflow['top'].append(marker)
def __draw_vline(self, marker, x):
line = self.lines[marker]
label = self.labels[marker]
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)
elif x is not None and x < xLim[0]:
self.overflow['left'].append(marker)
elif x is not None and x > xLim[1]:
self.overflow['right'].append(marker)
def __draw_overflow(self):
for pos, overflow in self.overflow.iteritems():
if len(overflow) > 0:
text = ''
for measure in overflow:
if len(text) > 0:
text += '\n'
text += self.labels[measure].get_text()
label = self.overflowLabels[pos]
if pos == 'top':
textMath = '$\\blacktriangle$\n' + text
elif pos == 'bottom':
textMath = '$\\blacktriangledown$\n' + text
elif pos == 'left':
textMath = '$\\blacktriangleleft$\n' + text
elif pos == 'right':
textMath = '$\\blacktriangleright$\n' + text
label.set_text(textMath)
label.set_visible(True)
self.axes.draw_artist(label)
def draw_measure(self, measure, show):
if self.axes.get_renderer_cache() is None:
return
self.hide_measure()
self.__clear_overflow()
if show[Measure.MIN]:
y = measure.get_min_p()[1]
self.__draw_hline(Markers.MIN, y)
if show[Measure.MAX]:
y = measure.get_max_p()[1]
self.__draw_hline(Markers.MAX, y)
if show[Measure.AVG]:
y = measure.get_avg_p()
self.__draw_hline(Markers.AVG, y)
if show[Measure.GMEAN]:
y = measure.get_gmean_p()
self.__draw_hline(Markers.GMEAN, y)
if show[Measure.HBW]:
xStart, xEnd, y = measure.get_hpw()
self.__draw_hline(Markers.HP, y)
self.__draw_vline(Markers.HFS, xStart)
self.__draw_vline(Markers.HFE, xEnd)
if show[Measure.OBW]:
xStart, xEnd, y = measure.get_obw()
self.__draw_hline(Markers.OP, y)
self.__draw_vline(Markers.OFE, xStart)
self.__draw_vline(Markers.OFE, xEnd)
self.__draw_overflow()
def hide_measure(self):
for line in self.lines.itervalues():
line.set_visible(False)
for label in self.labels.itervalues():
label.set_visible(False)
for label in self.overflowLabels.itervalues():
label.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())
if self.settings.plotFunc == PlotFunc.VAR and len(self.axes.collections) > 0:
norm = self.axes.collections[0].norm
self.barBase.set_clim((norm.vmin, norm.vmax))
else:
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, EventThread(Event.DRAW))
def get_axes(self):
return self.axes
def get_axes_bar(self):
return self.barBase.ax
def get_plot_thread(self):
return self.threadPlot
def set_title(self, title):
self.axes.set_title(title, fontsize='medium')
def set_plot(self, spectrum, extent, annotate=False):
self.extent = extent
self.threadPlot = ThreadPlot(self, self.settings,
self.axes,
spectrum,
self.extent,
self.barBase,
annotate)
self.threadPlot.start()
return self.threadPlot
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_bar(self, on):
self.barBase.ax.set_visible(on)
if on:
self.axes.change_geometry(1, 2, 1)
self.axes.get_subplotspec().get_gridspec().set_width_ratios([9.5, 0.5])
else:
self.axes.change_geometry(1, 1, 1)
self.figure.subplots_adjust()
def set_axes(self, on):
if on:
self.axes.set_axis_on()
self.bar.set_axis_on()
else:
self.axes.set_axis_off()
self.bar.set_axis_off()
def set_colourmap_use(self, on):
self.set_bar(on)
if on:
colourMap = self.settings.colourMap
else:
colourMap = ' Pure Blue'
self.set_colourmap(colourMap)
def set_colourmap(self, colourMap):
self.colourMap = colourMap
for collection in self.axes.collections:
collection.set_cmap(colourMap)
if colourMap.startswith(' Pure'):
self.bar.set_visible(False)
else:
self.bar.set_visible(True)
self.barBase.set_cmap(colourMap)
try:
self.barBase.draw_all()
except:
pass
def close(self):
self.figure.clear()
self.figure = None
def plot(self, **kwargs):
r""" Display the selected content of the :attr:`~nenupy.astro.sky.Sky.value`
attribute belonging to a :class:`~nenupy.astro.sky.Sky` instance as
a celestial map in equatorial coordinates.
This method is available on a :class:`~nenupy.astro.sky.SkySlice` instance,
resulting from a selection upon a :class:`~nenupy.astro.sky.Sky` instance
(using the indexing operator).
Several parameters, listed below, can be tuned to adapt the plot
to the user requirements:
.. rubric:: Data display keywords
:param center:
Coordinates of the celestial map to be displayed
at the center of the image.
Default is ``(RA=0deg, Dec=0deg)``.
:type center:
:class:`~astropy.coordinates.SkyCoord`
:param radius:
Angular radius from the center of the image above
which the plot should be cropped.
Default is ``None`` (i.e., full sky image).
:type radius:
:class:`~astropy.units.Quantity`
:param resolution:
Set the pixel resolution. The upper threshold is 0.775 deg,
any value above that does not affect the figure appearence.
Default is ``astropy.units.Quantity(1, unit="deg")``.
:type resolution:
:class:`~astropy.units.Quantity`
:param only_visible:
If set to ``True`` only the sky above the horizon is displayed.
Setting this parameter to ``False`` does not really make sense
for :class:`~nenupy.astro.sky.Sky` instances representing antenna
response for instance.
Default is ``True``.
:type only_visible:
`bool`
:param decibel:
If set to ``True``, the data values are displayed at the decibel scale,
i.e., :math:`10 \log( \rm{data} )`.
Default is ``False``.
:type decibel:
`bool`
.. rubric:: Overplot keywords
:param scatter:
Add a scatter plot (as defined in `matplotlib.pyplot.scatter`).
Expected syntax is ``(<SkyCoord>, <marker_size>, <color>)``.
Default is ``None`` (i.e., no scatter overplot).
:type scatter:
`tuple`
:param text:
Add a text overlay (as defined in `matplotlib.pyplot.text`).
Expected syntax is ``(<SkyCoord>, <[text]>, <color>)``.
Default is ``None`` (i.e., no text overplot).
:type text:
`tuple`
:param contour:
Add a contour plot (as defined in `matplotlib.pyplot.contour`).
Expected syntax is ``(<numpy.ndarray>, <[levels]>, <colormap>)``.
Default is ``None`` (i.e., no contour overplot).
:type contour:
`tuple`
.. rubric:: Plotting layout keywords
:param altaz_overlay:
If set to ``True``, the horizontal coordinates grid is overplotted
in addition to the equatorial one.
Default is ``False``.
:type altaz_overlay:
`bool`
:param cmap:
Color map applied while representing the data (see
`Matplotlib colormaps <https://matplotlib.org/stable/gallery/color/colormap_reference.html>`_).
Default is ``"YlGnBu_r"``.
:type cmap:
`str`
:param show_colorbar:
Show or not the color bar.
Default is ``True``.
:type show_colorbar:
`bool`
:param colorbar_label:
Set the label of the color bar.
Default is ``""``.
:type colorbar_label:
`str`
:param figname:
Name of the file (absolute or relative path) to save the figure.
If set to ``"return"``, the method returns the `tuple` ``(fig, ax)``
(as defined by `matplotlib <https://matplotlib.org/>`_).
Default is ``None`` (i.e., only show the figure).
:type figname:
`str`
:param figsize:
Set the figure size.
Default is ``(15, 10)``.
:type figsize:
`tuple`
:param ticks_color:
Set the color of the equatorial grid and the Right Ascension ticks.
Default is ``"0.9"`` (grey).
:type ticks_color:
`str`
:param title:
Set the figure title.
Default is ``"<time>, <frequency>"``.
:type title:
`str`
"""
# Parsing the keyword arguments
resolution = kwargs.get("resolution", 1*u.deg)
figname = kwargs.get("figname", None)
cmap = kwargs.get("cmap", "YlGnBu_r")
figsize = kwargs.get("figsize", (15, 10))
center = kwargs.get("center", SkyCoord(0*u.deg, 0*u.deg))
radius = kwargs.get("radius", None)
ticks_color = kwargs.get("ticks_color", "0.9")
colorbar_label = kwargs.get("colorbar_label", "")
title = kwargs.get("title", f"{self.time.isot.split('.')[0]}, {self.frequency:.2f}")
visible_sky = kwargs.get("only_visible", True)
decibel = kwargs.get("decibel", False)
altaz_overlay = kwargs.get("altaz_overlay", False)
# Initialize figure
wcs, shape = self._compute_wcs(
center=center,
resolution=getattr(self, "resolution", resolution),
radius=radius
)
fig = plt.figure(figsize=figsize)
ax = plt.subplot(
projection=wcs,
frame_class=EllipticalFrame
)
# Get the data projected on fullsky
data = self._fullsky_projection(
wcs=wcs,
shape=shape,
display_visible_sky=visible_sky
)
# Scale the data in decibel
if decibel:
data = 10 * np.log10(data)
vmin = kwargs.get("vmin", np.nanmin(data))
vmax = kwargs.get("vmax", np.nanmax(data))
# Plot the data
im = ax.imshow(
data,
origin="lower",
interpolation="quadric",
cmap=cmap,
vmin=vmin,
vmax=vmax
)
# Define ax ticks
ax.coords.grid(color=ticks_color, alpha=0.5)
path_effects=[patheffects.withStroke(linewidth=3, foreground='black')]
ra_axis = ax.coords[0]
dec_axis = ax.coords[1]
ra_axis.set_ticks_visible(False)
ra_axis.set_ticklabel_visible(True)
ra_axis.set_ticklabel(color=ticks_color, exclude_overlapping=True, path_effects=path_effects)
ra_axis.set_axislabel("RA", color=ticks_color, path_effects=path_effects)
ra_axis.set_major_formatter("d")
ra_axis.set_ticks(number=12)
dec_axis.set_ticks_visible(False)
dec_axis.set_ticklabel_visible(True)
dec_axis.set_axislabel("Dec", minpad=2)
dec_axis.set_major_formatter("d")
dec_axis.set_ticks(number=10)
if altaz_overlay:
frame = AltAz(obstime=self.time, location=self.observer)
overlay = ax.get_coords_overlay(frame)
overlay.grid(color="tab:orange", alpha=0.5)
az_axis = overlay[0]
alt_axis = overlay[1]
az_axis.set_axislabel("Azimuth", color=ticks_color, path_effects=path_effects)
az_axis.set_ticks_visible(False)
az_axis.set_ticklabel_visible(True)
az_axis.set_ticklabel(color=ticks_color, path_effects=path_effects)
az_axis.set_major_formatter("d")
az_axis.set_ticks(number=12)
alt_axis.set_axislabel("Elevation")
alt_axis.set_ticks_visible(False)
alt_axis.set_ticklabel_visible(True)
alt_axis.set_major_formatter("d")
alt_axis.set_ticks(number=10)
# Add NSEW points
nesw_labels = np.array(["N", "E", "S", "W"])
nesw = SkyCoord(
np.array([0, 90, 180, 270]),
np.array([0, 0, 0, 0]),
unit="deg",
frame=frame
).transform_to(ICRS)
for label, coord in zip(nesw_labels, nesw):
ax.text(
x=coord.ra.deg,
y=coord.dec.deg,
s=label,
color="tab:orange",
transform=ax.get_transform("world"),
path_effects=path_effects,
verticalalignment="center",
horizontalalignment="center",
clip_on=True
)
# Colorbar
if kwargs.get("show_colorbar", True):
cax = inset_axes(
ax,
width='3%',
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=cmap),
orientation='vertical',
norm=Normalize(
vmin=vmin,
vmax=vmax
),
ticks=LinearLocator()
)
cb.solids.set_edgecolor("face")
cb.set_label(colorbar_label)
cb.formatter.set_powerlimits((0, 0))
# Overplot
# if kwargs.get("circle", None) is not None:
# from matplotlib.patches import Circle
# frame = AltAz(obstime=self.time, location=self.observer)
# c = Circle(
# (0, 75),
# 20,
# edgecolor='yellow',
# linewidth=5,
# facecolor='none',
# #transform=ax.get_transform('world')
# #transform=ax.get_transform('fk5')
# transform=ax.get_transform(frame)
# )
# ax.add_patch(c)
if kwargs.get("moc", None) is not None:
# In order fo that to work; I had to comment #axis_viewport.set(ax, wcs)
# from add_patches_to_mpl_axe() in mocpy/moc/plot/fill.py
# OR re-set the limits (done here)
try:
frame = AltAz(obstime=self.time, location=self.observer)
xlimits = ax.get_xlim()
ylimits = ax.get_ylim()
mocs = kwargs["moc"] if isinstance(kwargs["moc"], list) else [kwargs["moc"]]
for moc, color in zip(mocs, ["tab:red", "tab:green"]):
moc.fill(
ax=ax,
wcs=wcs,
alpha=0.5,
fill=True,
color=color,
linewidth=0,
)
ax.set_xlim(xlimits)
ax.set_ylim(ylimits)
except AttributeError:
log.warning("A 'MOC' object, generated from mocpy is expected.")
raise
if kwargs.get("altaz_moc", None) is not None:
xlimits = ax.get_xlim()
ylimits = ax.get_ylim()
altaz = self.horizontal_coordinates
mask = kwargs["altaz_moc"].contains(altaz.az, altaz.alt)
ax.scatter(
x=self.coordinates[mask].ra.deg,
y=self.coordinates[mask].dec.deg,
s=0.1,#[marker_size]*coords.size,
facecolor="red",
edgecolor=None,
alpha=0.5,
transform=ax.get_transform("world")
)
ax.set_xlim(xlimits)
ax.set_ylim(ylimits)
if kwargs.get("scatter", None) is not None:
parameters = kwargs["scatter"]
if len(parameters) != 3:
raise ValueError(
"'scatter' syntax should be: (<SkyCoord>, <size>, <color>)"
)
coords = parameters[0]
if coords.isscalar:
coords = coords.reshape((1,))
marker_size = parameters[1]
marker_color = parameters[2]
ax.scatter(
x=coords.ra.deg,
y=coords.dec.deg,
s=[marker_size]*coords.size,
color=marker_color,
transform=ax.get_transform("world")
)
if kwargs.get("text", None) is not None:
parameters = kwargs["text"]
if len(parameters) != 3:
raise ValueError(
"'text' syntax should be: (<SkyCoord>, <[text]>, <color>)"
)
coords = parameters[0]
if coords.isscalar:
coords = coords.reshape((1,))
text = parameters[1]
text_color = parameters[2]
for i in range(coords.size):
ax.text(
x=coords[i].ra.deg,
y=coords[i].dec.deg,
s=text[i],
color=text_color,
transform=ax.get_transform("world"),
clip_on=True
)
if kwargs.get("contour", None) is not None:
parameters = kwargs["contour"]
data = parameters[0]
if len(parameters) != 3:
raise ValueError(
"'contour' syntax should be: (<numpy.ndarray>, <[levels]>, <colormap>)"
)
contour, _ = reproject_from_healpix(
(data, ICRS()),
wcs,
nested=False,
shape_out=shape#(ndec, nra)
)
ax.contour(
contour,
levels=parameters[1],
cmap=parameters[2],
)
# Other
im.set_clip_path(ax.coords.frame.patch)
ax.set_title(title, pad=20)
# Save or show
if figname is None:
plt.show()
elif figname.lower() == "return":
return fig, ax
else:
fig.savefig(
figname,
dpi=300,
transparent=True,
bbox_inches='tight'
)
plt.close('all')
class Plotter3d():
def __init__(self, notify, figure, settings):
self.notify = notify
self.figure = figure
self.settings = settings
self.axes = None
self.bar = None
self.barBase = 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 ($\mathsf{dB/\sqrt{Hz}}$)')
colour = hex2color(self.settings.background)
colour += (1,)
self.axes.w_xaxis.set_pane_color(colour)
self.axes.w_yaxis.set_pane_color(colour)
self.axes.w_zaxis.set_pane_color(colour)
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))
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, EventThread(Event.DRAW))
def get_axes(self):
return self.axes
def get_axes_bar(self):
return self.barBase.ax
def get_plot_thread(self):
return self.threadPlot
def set_title(self, title):
self.axes.set_title(title, fontsize='medium')
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_events_stations_map_depth(events,
inv=None,
figsize=(8, 8),
out=None,
show=True,
dpi=300,
convert_coords=False,
plotall=True,
colorbar=True,
label=True,
ms=9):
id_, time, lon, lat, dep, mag, *_ = zip(
*events2lists(events.filter('magnitude > 1.8')))
_, _, lon2, lat2, dep2, _, *_ = zip(*events2lists(events))
print(time[0], time[-1])
fig = plt.figure(figsize=figsize)
ax3 = fig.add_axes((0.1, 0.5, 0.4, 0.4))
ax4 = fig.add_axes((0.52, 0.5, 0.35, 0.4), sharey=ax3)
ax5 = fig.add_axes((0.1, 0.5 - 0.37, 0.4, 0.35), sharex=ax3)
def _on_lims_changed(ax, boo=[True]):
if boo[0]:
boo[0] = False
if ax == ax5:
ax4.set_xlim(ax5.get_ylim()[::-1])
if ax == ax4:
ax5.set_ylim(ax4.get_xlim()[::-1])
boo[0] = True
mpl = [t.matplotlib_date for t in time]
ax5.invert_yaxis()
ax5.callbacks.connect('ylim_changed', _on_lims_changed)
ax4.callbacks.connect('xlim_changed', _on_lims_changed)
ax4.yaxis.tick_right()
ax4.yaxis.set_label_position("right")
ax3.xaxis.tick_top()
ax3.xaxis.set_label_position("top")
ax4.xaxis.tick_top()
ax4.xaxis.set_label_position("top")
if convert_coords:
latlon0 = None if convert_coords == True else convert_coords
x, y = zip(*convert_coords2km(list(zip(lat, lon)), latlon0=latlon0))
x2, y2 = zip(
*convert_coords2km(list(zip(lat2, lon2)), latlon0=latlon0))
else:
x, y = lon, lat
x2, y2 = lon2, lat2
mag = np.array(mag)
cmap, norm = get_cmap()
if plotall:
ax3.scatter(x2, y2, 4, color='0.6')
ax4.scatter(dep2, y2, 4, color='0.6')
ax5.scatter(x2, dep2, 4, color='0.6')
ax3.scatter(x, y, ms, mpl, cmap=cmap, norm=norm)
ax4.scatter(dep, y, ms, mpl, cmap=cmap, norm=norm)
ax5.scatter(x, dep, ms, mpl, cmap=cmap, norm=norm)
if colorbar:
ax7 = fig.add_axes([0.56, 0.42, 0.34, 0.02])
cmap, norm = get_cmap(extend=True)
cbar = ColorbarBase(ax7,
cmap=cmap,
norm=norm,
orientation='horizontal',
format=DateFormatter('%Y-%m-%d'),
extend='max',
spacing='proportional') #, extendfrac=0.2)
cbar.ax.set_xticklabels(cbar.ax.get_xticklabels()[:-1] +
['until 2018-06-19'],
rotation=60,
ha='right',
rotation_mode='anchor')
xticks = cbar.ax.get_xticks()
xticks = np.mean([xticks[1:], xticks[:-1]], axis=0)
for xpos, label in zip(xticks, 'abcde'):
# this line only works for matplotlib 3.1 at the moment
cbar.ax.annotate(label, (xpos, 0.1),
ha='center',
fontstyle='italic')
ax4.set_xlabel('depth (km)')
ax5.set_ylabel('depth (km)')
if convert_coords:
if label:
ax3.set_xlabel('easting (km)')
ax3.set_ylabel('northing (km)')
ax5.set_xlabel('easting (km)')
ax4.set_ylabel('northing (km)')
else:
if label:
ax3.set_xlabel('longitude')
ax3.set_ylabel('latitude')
ax5.set_xlabel('longitude')
ax4.set_ylabel('latitude')
if out:
plt.savefig(out, dpi=dpi)
if show:
plt.show()
return fig
class Spectrogram(object):
def __init__(self, notify, figure, settings):
self.notify = notify
self.figure = figure
self.settings = settings
self.data = [[], [], []]
self.axes = None
self.plot = None
self.extent = None
self.bar = None
self.barBase = None
self.lines = {}
self.labels = {}
self.overflowLabels = {}
self.overflow = {'left': [],
'right': []}
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(utc_to_mpl(now), utc_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.__setup_measure()
self.__setup_overflow()
self.hide_measure()
def __setup_measure(self):
dashesHalf = [1, 5, 5, 5, 5, 5]
self.lines[Markers.HFS] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='purple')
self.lines[Markers.HFE] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='purple')
self.lines[Markers.OFS] = Line2D([0, 0], [0, 0], dashes=dashesHalf,
color='#996600')
self.lines[Markers.OFE] = 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.lines[Markers.HFS].set_path_effects([effect])
self.lines[Markers.HFE].set_path_effects([effect])
self.lines[Markers.OFS].set_path_effects([effect])
self.lines[Markers.OFE].set_path_effects([effect])
for line in self.lines.itervalues():
self.axes.add_line(line)
bbox = self.axes.bbox
box = dict(boxstyle='round', fc='white', ec='purple', clip_box=bbox)
self.labels[Markers.HFS] = Text(0, 0, '-3dB', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='purple')
self.labels[Markers.HFE] = Text(0, 0, '-3dB', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='purple')
box['ec'] = '#996600'
self.labels[Markers.OFS] = Text(0, 0, 'OBW', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='#996600')
self.labels[Markers.OFE] = Text(0, 0, 'OBW', fontsize='xx-small',
ha="center", va="top", bbox=box,
color='#996600')
for label in self.labels.itervalues():
self.axes.add_artist(label)
def __setup_overflow(self):
bbox = self.axes.bbox
box = dict(boxstyle='round', fc='white', ec='black', alpha=0.5,
clip_box=bbox)
self.overflowLabels['left'] = Text(0, 0.9, '', fontsize='xx-small',
ha="left", va="top", bbox=box,
transform=self.axes.transAxes,
alpha=0.5)
self.overflowLabels['right'] = Text(1, 0.9, '', fontsize='xx-small',
ha="right", va="top", bbox=box,
transform=self.axes.transAxes,
alpha=0.5)
for label in self.overflowLabels.itervalues():
self.axes.add_artist(label)
def __clear_overflow(self):
for label in self.overflowLabels:
self.overflow[label] = []
def __draw_vline(self, marker, x):
line = self.lines[marker]
label = self.labels[marker]
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)
elif x is not None and x < xLim[0]:
self.overflow['left'].append(marker)
elif x is not None and x > xLim[1]:
self.overflow['right'].append(marker)
def __draw_overflow(self):
for pos, overflow in self.overflow.iteritems():
if len(overflow) > 0:
text = ''
for measure in overflow:
if len(text) > 0:
text += '\n'
text += self.labels[measure].get_text()
label = self.overflowLabels[pos]
if pos == 'left':
textMath = '$\\blacktriangleleft$\n' + text
elif pos == 'right':
textMath = '$\\blacktriangleright$\n' + text
label.set_text(textMath)
label.set_visible(True)
self.axes.draw_artist(label)
def draw_measure(self, measure, show):
if self.axes.get_renderer_cache() is None:
return
self.hide_measure()
self.__clear_overflow()
if show[Measure.HBW]:
xStart, xEnd, _y = measure.get_hpw()
self.__draw_vline(Markers.HFS, xStart)
self.__draw_vline(Markers.HFE, xEnd)
if show[Measure.OBW]:
xStart, xEnd, _y = measure.get_obw()
self.__draw_vline(Markers.OFS, xStart)
self.__draw_vline(Markers.OFE, xEnd)
self.__draw_overflow()
def hide_measure(self):
for line in self.lines.itervalues():
line.set_visible(False)
for label in self.labels.itervalues():
label.set_visible(False)
for label in self.overflowLabels.itervalues():
label.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, EventThread(Event.DRAW))
def get_axes(self):
return self.axes
def get_axes_bar(self):
return self.barBase.ax
def get_plot_thread(self):
return self.threadPlot
def set_title(self, title):
self.axes.set_title(title, fontsize='medium')
def set_plot(self, spectrum, extent, annotate=False):
self.extent = extent
self.threadPlot = ThreadPlot(self, self.settings,
self.axes,
spectrum,
self.extent,
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_line" 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
def plot_events2018_interpretation(events):
fig = plot_events_stations_map_depth(events,
show=False,
plotall=False,
colorbar=False,
label=False,
ms=4)
# eqs = load_webnet(stations=False)
# color = 'gray'
# color = '#9bd7ff'
# fig.axes[0].scatter(eqs.lon.values, eqs.lat.values, 4, eqs.time.values, marker='o', zorder=-1)
# fig.axes[1].scatter(eqs.dep.values, eqs.lat.values, 4, eqs.time.values, marker='o', zorder=-1)
# fig.axes[2].scatter(eqs.lon.values, eqs.dep.values, 4, eqs.time.values, marker='o', zorder=-1)
# fig.axes[0].set_xlim(-2.5, 2.5)
# fig.axes[0].set_ylim(-2.3, 2.7)
# lon, lat, dep = 12.42396, 50.22187, 8.5
# lon, lat, dep = 12.45993, 50.27813, 8.5
# lon, lat, dep = 12.45993, 50.22187, 11.5
lon, lat, dep = 12.45993, 50.22187, 8.5
kw = dict(zorder=-1,
vmin=3,
vmax=4,
cmap='Greys',
edgecolors='face',
linewidths=0.01)
# kw = dict(zorder=-1, vmin=5, vmax=6.5, cmap='Greys')
# kw = dict(zorder=-1, vmin=1.55, vmax=1.75, cmap='Greys')
# load_mousavi()
try:
plot_mousavi(2, dep, 0, 1, 4, ax=fig.axes[0], **kw)
plot_mousavi(0, lon, 2, 1, 4, ax=fig.axes[1], **kw)
im = plot_mousavi(1, lat, 0, 2, 4, ax=fig.axes[2], **kw)
except OSError:
import traceback
print(traceback.format_exc())
print('Mousavi model is not provided in this repository')
im = None
kw = dict(color='red', lw=2, zorder=0)
kw = dict(color='C1', alpha=0.8, lw=2, zorder=0)
ax0, ax1, ax2, *_ = fig.axes
ax0.axhline(lat, **kw)
ax0.axvline(lon, **kw)
ax1.axvline(dep, **kw)
ax2.axhline(dep, **kw)
ax0.set_xlim(12.388, 12.53187)
ax0.set_ylim(50.10935, 50.3344)
ax1.set_xlim(0, 12)
ax1.set_xticks(ax2.get_yticks())
cax2 = fig.add_axes([0.56, 0.42, 0.34, 0.02])
cmap, norm = get_cmap()
cbar = ColorbarBase(cax2,
cmap=cmap,
norm=norm,
orientation='horizontal',
format=DateFormatter('%Y-%m-%d'))
cax2.set_xticklabels([])
cax2.set_xlabel('intra-cluster\nS wave velocity (km/s)', labelpad=12)
for i, label in enumerate('abcde'):
cax2.annotate(label, ((i + 0.5) / 5, 0.1),
xycoords='axes fraction',
ha='center',
fontstyle='italic')
for i, label in enumerate([4.16, 3.49, 3.66, 3.85, 3.72]):
cax2.annotate(label, ((i + 0.5) / 5, -1.2),
xycoords='axes fraction',
ha='center')
lonticks = [12.40, 12.45, 12.50]
latticks = [50.15, 50.20, 50.25, 50.30]
add_ticklabels(ax0, lonticks, latticks, fmt='%.2f°')
if im is not None:
cax = fig.add_axes([0.56, 0.27, 0.34, 0.02])
fig.colorbar(im, cax=cax, orientation='horizontal')
for i, label in enumerate([4.16, 3.49, 3.66, 3.85, 3.72]):
cax.annotate(
'', (label - 3, 1.1), (label - 3, 2.5),
xycoords='axes fraction',
textcoords='axes fraction',
arrowprops=dict(width=1,
headwidth=4,
headlength=6,
color=cmap(i))) #, xycoords='axes fraction',
cax.set_xlabel('S wave velocity (km/s)\nMousavi et al. (2015)')
fig.savefig('figs/eventmap_interpretation.pdf',
bbox_inches='tight',
pad_inches=0.1)
plt.show()
def draw(self):
PlotBase.draw(self)
self.x_formatter_cb(self.ax)
if self.gdata.isEmpty():
return None
# Evaluate the bar width
width = float(self.width)
offset = 0.
if self.gdata.key_type == 'time':
width = width / 86400.0
start_plot = 0
end_plot = 0
if "starttime" in self.prefs and "endtime" in self.prefs:
start_plot = date2num(
datetime.datetime.fromtimestamp(
to_timestamp(self.prefs['starttime'])))
end_plot = date2num(
datetime.datetime.fromtimestamp(
to_timestamp(self.prefs['endtime'])))
labels = self.gdata.getLabels()
nKeys = self.gdata.getNumberOfKeys()
tmp_b = []
tmp_x = []
tmp_y = []
self.bars = []
labels = self.gdata.getLabels()
nLabel = 0
labelNames = []
colors = []
xmin = None
xmax = None
for label, _num in labels:
labelNames.append(label)
for key, value, _error in self.gdata.getPlotNumData(label):
if xmin is None or xmin > (key + offset):
xmin = key + offset
if xmax is None or xmax < (key + offset):
xmax = key + offset
if value is not None:
colors.append(self.getQualityColor(value))
tmp_x.append(key + offset)
tmp_y.append(1.)
tmp_b.append(float(nLabel))
nLabel += 1
self.bars += self.ax.bar(tmp_x,
tmp_y,
bottom=tmp_b,
width=width,
color=colors)
dpi = self.prefs.get('dpi', 100)
setp(self.bars, linewidth=pixelToPoint(0.5, dpi), edgecolor='#AAAAAA')
#pivots = keys
#for idx in range(len(pivots)):
# self.coords[ pivots[idx] ] = self.bars[idx]
ymax = float(nLabel)
self.ax.set_xlim(xmin=0., xmax=xmax + width + offset)
self.ax.set_ylim(ymin=0., ymax=ymax)
if self.gdata.key_type == 'time':
if start_plot and end_plot:
self.ax.set_xlim(xmin=start_plot, xmax=end_plot)
else:
self.ax.set_xlim(xmin=min(tmp_x), xmax=max(tmp_x))
self.ax.set_yticks([i + 0.5 for i in range(nLabel)])
self.ax.set_yticklabels(labelNames)
setp(self.ax.get_xticklines(), markersize=0.)
setp(self.ax.get_yticklines(), markersize=0.)
cax, kw = make_axes(self.ax, orientation='vertical', fraction=0.07)
cb = ColorbarBase(
cax,
cmap=cm.RdYlGn,
norm=self.norms, #pylint: disable=no-member
boundaries=self.cbBoundaries,
values=self.cbValues,
ticks=self.cbTicks)
cb.draw_all()
def Plot_Compare_PerpYear(num_clusters,
bmus_values_sim,
bmus_dates_sim,
bmus_values_hist,
bmus_dates_hist,
n_sim=1,
month_ini=1,
show=True):
'''
Plot simulated - historical bmus comparison in a perpetual year
bmus_dates requires 1 day resolution time
bmus_values set min value has to be 1 (not 0)
'''
# check dates have 1 day time resolution
td_h = bmus_dates_hist[1] - bmus_dates_hist[0]
td_s = bmus_dates_sim[1] - bmus_dates_sim[0]
if td_h.days != 1 or td_s.days != 1:
print('PerpetualYear bmus comparison skipped.')
print('timedelta (days): Hist - {0}, Sim - {1})'.format(
td_h.days, td_s.days))
return
# plot figure
fig, (ax_hist, ax_sim) = plt.subplots(2,
1,
figsize=(_faspect * _fsize, _fsize))
# historical perpetual year
axplot_PerpYear(
ax_hist,
num_clusters,
bmus_values_hist,
bmus_dates_hist,
num_sim=1,
month_ini=month_ini,
)
ax_hist.set_title('Historical')
# simulated perpetual year
axplot_PerpYear(
ax_sim,
num_clusters,
bmus_values_sim,
bmus_dates_sim,
num_sim=n_sim,
month_ini=month_ini,
)
ax_sim.set_title('Simulation')
# add custom colorbar
np_colors_int = GetClusterColors(num_clusters)
ccmap = mcolors.ListedColormap([tuple(r) for r in np_colors_int])
cax = fig.add_axes([0.92, 0.125, 0.025, 0.755])
cbar = ColorbarBase(
cax,
cmap=ccmap,
norm=mcolors.Normalize(vmin=0, vmax=num_clusters),
ticks=np.arange(num_clusters) + 0.5,
)
cbar.ax.tick_params(labelsize=8)
cbar.set_ticklabels(range(1, num_clusters + 1))
# text
fig.suptitle('Perpetual Year', fontweight='bold', fontsize=12)
# show and return figure
if show: plt.show()
return fig
def setup_axes(fig:Any, cmap:Any, norm:Any) -> tuple:
ax = fig.add_axes([0.92, 0.06, 0.045, 0.38])
cbar = ColorbarBase(ax, cmap=cmap, norm=norm, orientation='vertical', drawedges=False)
cbar.ax.tick_params(axis='both', which='both', length=0, labelsize=10)
cbar.outline.set_visible(False)
return ax, cbar
def test_colorbarbase():
# smoke test from #3805
ax = plt.gca()
ColorbarBase(ax, cmap=plt.cm.bone)
