import numpy as np
import matplotlib.pyplot as plt
from astropy.io import ascii
import matplotlib.colors as mcolors
inputdir = "sample/girardi/"
# kepler data
data = np.load("sample/obs/nike_samples.npy")
xobso, yobso, feho = data[:, 0], data[:, 1], data[:, 2]
zs = feho #np.concatenate((feh))
min_, max_ = zs.min(), zs.max()
n = mcolors.PowerNorm(vmin=min_, vmax=max_, gamma=1.8)
feh_limits = np.percentile(feho, np.linspace(0., 100., 7))
for j in range(len(feh_limits) - 1):
idx = (feho >= feh_limits[j]) & (feho <= feh_limits[j + 1])
xobs, yobs, feh = xobso[idx], yobso[idx], feho[idx]
fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(12, 6), squeeze=False)
axes = axes.reshape(-1)
inputfiles = ["feh_m149.csv", "feh_p007.csv"]
colors = ["purple", "red"]
labels = ["[M/H]=-1.49", "[M/H]=+0.07"]
for i in range(len(inputfiles)):
data = ascii.read(inputdir + inputfiles[i])
m, L, T = data["mass"], 10.**data["logL"], 10.**data["logT"]
numax = m * L**-1. * (T / 5777)**3.5 * 3090
dnu = m**0.5 * L**-0.75 * (T / 5777)**3.0 * 135.1
pcm = ax[1].pcolor(X, Y, Z, cmap='PuBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='max')
###############################################################################
# PowerNorm: Here a power-law trend in X partially obscures a rectified
# sine wave in Y. We can remove the power law using a PowerNorm.
X, Y = np.mgrid[0:3:complex(0, N), 0:2:complex(0, N)]
Z1 = (1 + np.sin(Y * 10.)) * X**2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X,
Y,
Z1,
norm=colors.PowerNorm(gamma=1. / 2.),
cmap='PuBu_r',
shading='nearest')
fig.colorbar(pcm, ax=ax[0], extend='max')
pcm = ax[1].pcolormesh(X, Y, Z1, cmap='PuBu_r', shading='nearest')
fig.colorbar(pcm, ax=ax[1], extend='max')
###############################################################################
# SymLogNorm: two humps, one negative and one positive, The positive
# with 5-times the amplitude. Linearly, you cannot see detail in the
# negative hump. Here we logarithmically scale the positive and
# negative data separately.
#
# Note that colorbar labels do not come out looking very good.
def plot_hist(self):
print("Starting plot: histogram")
# set up figure and its panels
fig = plt.figure(figsize=(self.figwidth, self.figwidth))
gs = GridSpec(4, 4)
gs.update(left=0.1,
right=1.,
top=1.,
bottom=0.1,
hspace=0.0,
wspace=0.0)
ax_t = plt.subplot(gs[0, :-1])
ax_tco = plt.subplot(gs[1:, :-1], sharex=ax_t)
ax_co = plt.subplot(gs[1:, -1], sharey=ax_tco)
ax_t.spines['left'].set_visible(False)
ax_t.spines['right'].set_visible(False)
ax_t.spines['top'].set_visible(False)
ax_co.spines['right'].set_visible(False)
ax_co.spines['top'].set_visible(False)
ax_co.spines['bottom'].set_visible(False)
ax_t.tick_params(axis='both',
which='both',
bottom=True,
top=False,
left=False,
right=False,
labelbottom=False,
labeltop=False,
labelleft=False,
labelright=False)
ax_co.tick_params(axis='both',
which='both',
bottom=False,
top=False,
left=True,
right=False,
labelbottom=False,
labeltop=False,
labelleft=False,
labelright=False)
# plot 2D histogram as hexbin
ax_tco.hexbin(self.data['temp'],
self.data['co2'],
gridsize=50,
cmap='Blues',
mincnt=1,
norm=colors.PowerNorm(gamma=0.5))
# plot marginalizations
hist_temp1 = ax_t.hist(self.data['temp'],
bins=50,
histtype='stepfilled',
color='black',
label='all time')
hist_co21 = ax_co.hist(self.data['co2'],
bins=50,
histtype='stepfilled',
color='black',
label='all time',
orientation='horizontal')
# get date of last week and last month
today = datetime.now()
last_week = today - timedelta(days=7)
last_week = last_week.strftime('%Y-%m-%d %H:%M:%S')
last_month = today - timedelta(days=30)
last_month = last_month.strftime('%Y-%m-%d %H:%M:%S')
last_3month = today - timedelta(days=90)
last_3month = last_3month.strftime('%Y-%m-%d %H:%M:%S')
# get data index of last week and last month
self.idx_3month = 0
self.idx_month = 0
self.idx_week = 0
for i in np.arange(len(self.data) - 1, 0, -1):
if (self.data['date'][i] > last_week):
self.idx_week = i
if (self.data['date'][i] > last_month):
self.idx_month = i
if (self.data['date'][i] > last_3month):
self.idx_3month = i
else:
break
# plot historic marginalizations
ax_t.hist(self.data['temp'][self.idx_3month:-1],
bins=hist_temp1[1],
histtype='stepfilled',
color='midnightblue',
label='last 3 months')
ax_co.hist(self.data['co2'][self.idx_3month:-1],
bins=hist_co21[1],
histtype='stepfilled',
color='midnightblue',
orientation='horizontal',
label='last 3 months')
ax_t.hist(self.data['temp'][self.idx_month:-1],
bins=hist_temp1[1],
histtype='stepfilled',
color='dodgerblue',
label='last month')
ax_co.hist(self.data['co2'][self.idx_month:-1],
bins=hist_co21[1],
histtype='stepfilled',
color='dodgerblue',
orientation='horizontal',
label='last month')
ax_t.hist(self.data['temp'][self.idx_week:-1],
bins=hist_temp1[1],
histtype='stepfilled',
color='aqua',
label='last week')
ax_co.hist(self.data['co2'][self.idx_week:-1],
bins=hist_co21[1],
histtype='stepfilled',
color='aqua',
orientation='horizontal',
label='last week')
# finish figure
ax_t.set_title("Last updated " +
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
fontsize=self.fontsize)
ax_tco.grid(True)
ax_t.xaxis.grid(True)
ax_co.yaxis.grid(True)
ax_tco.set_xlabel(r"temperature [$^\circ$C]", fontsize=self.fontsize)
ax_tco.set_ylabel(r"CO concentration [ppm]", fontsize=self.fontsize)
ax_tco.tick_params(axis='both', which='major', labelsize=self.fontsize)
ax_tco.set_xscale('linear')
ax_tco.set_yscale('linear')
ax_tco.set_xlim(self.templim)
ax_tco.set_ylim(self.co2lim)
ax_t.legend(loc='lower left',
numpoints=1,
bbox_to_anchor=(1.0, 0.0, 0.33, 1.0),
ncol=1,
mode="expand",
borderaxespad=0.,
fontsize=self.fontsize,
frameon=False)
fig.savefig(os.path.join(self.plotdir, self.logname + '.hist.svg'),
bbox_inches='tight')
# store figure for later use
self.hist_plot = fig
print("Finished plot: histogram")
fig, ((ax1, ax2), (ax3, ax4), (ax5, ax6)) = plt.subplots(3, 2)
fig.suptitle('PMT{}'.format(pmt))
ax1.hist(rec['blw'], bins=100, range=[0, 60], label='blw')
ax1.axvline(blw_cut, ymin=0, ymax=1)
ax1.set_yscale('log')
ax1.legend()
rec = rec[rec['blw'] < blw_cut]
ax2.hist2d(rec['height'],
rec['dh3'],
bins=[100, 100],
range=[[0, 200], [0, 1.5]],
norm=mcolors.PowerNorm(0.3))
ax2.axhline(dh3_cut, xmin=0, xmax=1, color='k')
ax2.axvline(height_cut, ymin=0, ymax=1, color='k')
ax2.axvline(spk_cut, ymin=0, ymax=1, color='k')
rec = rec[rec['dh3'] < dh3_cut]
h_heights, bins, pat = ax3.hist(rec['height'],
bins=100,
label='height',
range=[0, 500],
histtype='step')
heights = 0.5 * (bins[1:] + bins[:-1])
ax3.axvline(height_cut, ymin=0, ymax=1)
ax3.set_yscale('log')
ax3.legend()
colors[0],
capital=False)
hist1(evalue1,
200,
data_label,
'evalue_reciprocal',
'log10(E-value)',
labels[1],
colors[1],
capital=False)
# 1.2.1.3 Scatters of E-value with other metrics
plt.hist2d(df0['logevalue'],
df0['fqa'],
bins=50,
norm=mpl_colors.PowerNorm(0.3))
plt.xlabel('log10(E-value)')
plt.ylabel('Fraction of query aligned')
plt.colorbar()
plt.savefig(f'out/blast_{data_label}/hist2d_fqa-evalue_all.png')
plt.close()
plt.hist2d(df1['logevalue'],
df1['fqa'],
bins=50,
norm=mpl_colors.PowerNorm(0.3))
plt.xlabel('log10(E-value)')
plt.ylabel('Fraction of query aligned')
plt.colorbar()
plt.savefig(f'out/blast_{data_label}/hist2d_fqa-evalue_reciprocal.png')
plt.close()
Colormap Normalizations Power
=============================
Demonstration of using norm to map colormaps onto data in non-linear ways.
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors
N = 100
X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)]
'''
PowerNorm: Here a power-law trend in X partially obscures a rectified
sine wave in Y. We can remove the power law using a PowerNorm.
'''
X, Y = np.mgrid[0:3:complex(0, N), 0:2:complex(0, N)]
Z1 = (1 + np.sin(Y * 10.)) * X**2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X, Y, Z1, norm=colors.PowerNorm(gamma=1./2.),
cmap='PuBu_r')
fig.colorbar(pcm, ax=ax[0], extend='max')
pcm = ax[1].pcolormesh(X, Y, Z1, cmap='PuBu_r')
fig.colorbar(pcm, ax=ax[1], extend='max')
plt.show()
plt.xlim((-0.75, 1.75))
plt.ylabel(f'Fraction of total {data_label} HSPs')
plt.title(f'Fraction of {data_label} HSPs with zero and non-zero E-values')
plt.legend(bbox_to_anchor=(0.5, -0.1875), loc='lower center', ncol=2)
plt.subplots_adjust(bottom=0.15)
plt.savefig(f'out/blast_{data_label}/bar_evalue_zero.png')
plt.close()
# 1.2.1.2 Histograms of non-zero E-values
hist2_1([evalue0, evalue1], 200, data_label, 'evalue', 'log10(E-value)', labels, colors, capital=False)
hist2_2([evalue0, evalue1], 200, data_label, 'evalue', 'log10(E-value)', labels, colors, capital=False)
hist1(evalue0, 200, data_label, 'evalue_all', 'log10(E-value)', labels[0], colors[0], capital=False)
hist1(evalue1, 200, data_label, 'evalue_reciprocal', 'log10(E-value)', labels[1], colors[1], capital=False)
# 1.2.1.3 Scatters of E-value with other metrics
plt.hist2d(df0['logevalue'], df0['fqa'], bins=50, norm=mpl_colors.PowerNorm(0.3))
plt.xlabel('log10(E-value)')
plt.ylabel('Fraction of query aligned')
plt.colorbar()
plt.savefig(f'out/blast_{data_label}/hist2d_fqa-evalue_all.png')
plt.close()
plt.hist2d(df1['logevalue'], df1['fqa'], bins=50, norm=mpl_colors.PowerNorm(0.3))
plt.xlabel('log10(E-value)')
plt.ylabel('Fraction of query aligned')
plt.colorbar()
plt.savefig(f'out/blast_{data_label}/hist2d_fqa-evalue_reciprocal.png')
plt.close()
g0 = df0.groupby('logevalue')
x = g0['nqa'].min()
def traj_scatter(data,
lons,
lats,
hymap,
zorder=19,
colormap=plt.cm.viridis,
edgecolor='none',
size=25,
sizedata=None,
cnormalize=None,
snormalize=None,
vmin=None,
vmax=None,
levels=11,
suppress_printmsg=False,
**kwargs):
"""
Scatter-plot of ``Trajectory``, ``TrajectoryGroup``, or ``Cluster`` data.
Parameters
----------
data : 1D ndarray of floats, ints
The information to plot as color change.
lons : 1D ndarray of floats, ints
X-coordinates of ``data`` in decimal degrees
lats : 1D ndarray of floats, ints
Y-coordinates of ``data`` in decimal degrees
hymap : ``Basemap`` instance
Any ``Basemap`` instance. For easy map creation, see ``MapDesign``
class
zorder : int
Default 19. Data zorder.
colormap : colormap
Default ``plt.cm.viridis``. Any ``matplotlib`` colormap.
edgecolor : string, tuple
Default 'none'. Any ``matplotlib``-accepted color
size : int
Default 25. Point size of data unless ``sizedata`` specified. Then,
will be multiplied with ``sizedata``.
sizedata : 1D ndarray of floats
Default ``None``. The data to plot as a change in marker size.
cnormalize : string or float
Default ``None``. [None|'boundary'|'log'|'ln'|'sqrt'|float]
Normalization of color scale. If 'boundary', will create a discrete
color map with ``levels`` number of colors. For other norms, colorbar
ticklabels will be updated with 'log' but not 'ln', 'sqrt', because
no corresponding ``matplotlib colors Normalize`` classes are available.
If a float is provided, a ``PowerNorm`` will be performed.
snormalize : string
Default ``None``. [None|'log'|'ln'|'sqrt']. Similar to cnormalize,
except 'boundary' not available and does not use ``Normalize``.
vmin : int or float
Default ``None``. Used to scale/normalize ``data``.
If ``None``, then set to ``data`` min
vmax : int or float
Default ``None``. Used to scale/normalize ``data``.
If ``None``, then set to ``data`` max
levels : int
Only used in BoundaryNorm
**kwargs
passed to ``Basemap.scatter()`` and ``Axes.scatter()``
Returns
-------
cm : ``matplotlib PathCollection`` instance
Mappable for use in creating colorbars. Colorbars may be created
in ``PySPLIT`` using ``make_cbar()`` or ``make_cax_cbar()``
"""
# cnormalize = str.lower(cnormalize)
norm = None
msg = ('Use `cbar.ax.set_yticklabels()` ' +
'or cbar.ax.set_xticklabels()` to change tick labels')
transform_dict = {'sqrt': np.sqrt, 'log': np.log10, 'ln': np.log}
if cnormalize is 'boundary':
if vmin is None:
vmin = data.min()
if vmax is None:
vmax = data.max()
bounds = np.linspace(vmin, vmax, levels)
norm = clr.BoundaryNorm(bounds, colormap.N)
elif cnormalize is 'log':
norm = clr.LogNorm(vmin=vmin, vmax=vmax)
elif cnormalize is 'ln':
data = np.log(data)
if not suppress_printmsg:
print(msg, '\nnatural log normalization')
elif cnormalize is 'sqrt':
data = np.sqrt(data)
if not suppress_printmsg:
print(msg, '\nsqrt normalization')
elif cnormalize is not None:
try:
norm = clr.PowerNorm(cnormalize, vmin=vmin, vmax=vmax)
except:
pass
if sizedata is not None:
if snormalize is not None:
sizedata = transform_dict[snormalize](sizedata)
size = sizedata * size
cm = hymap.scatter(lons,
lats,
c=data,
s=size,
cmap=colormap,
vmin=vmin,
vmax=vmax,
zorder=zorder,
edgecolor=edgecolor,
norm=norm,
latlon=True,
**kwargs)
return cm
# %%
result = match_template(im_full, im_crop)
ij = np.unravel_index(np.argmax(result), result.shape)
x, y = ij[::-1]
# %%
result.max()
# %%
fig = plt.figure(figsize=(8, 3))
ax1 = plt.subplot(1, 4, 1)
ax2 = plt.subplot(1, 4, 2)
ax4 = plt.subplot(1, 4, 3)
ax3 = plt.subplot(1, 4, 4, sharex=ax2, sharey=ax2)
ax1.imshow(im_crop, cmap=plt.cm.gray,norm=colors.PowerNorm(gamma=1/2))
ax1.set_axis_off()
ax1.set_title('template')
ax2.imshow(im_full, cmap=plt.cm.gray, norm=colors.PowerNorm(gamma=1/2))
#ax2.set_axis_off()
ax2.set_title('image')
# highlight matched region
hcoin, wcoin = im_crop.shape
rect = plt.Rectangle((x, y), wcoin, hcoin, edgecolor='r', facecolor='none')
ax2.add_patch(rect)
ax4.imshow(im_full[y:(y+hcoin), x:(x+wcoin)], cmap=plt.cm.gray, norm=colors.PowerNorm(gamma=1/2))
ax4.set_axis_off()
ax4.set_title('image')
a = np.array(
struct.unpack(
(etype + '{}' + dtype).format(int(fin.tell() / sizeofdata)), raw))
a = a.reshape((nx2, nx1))
fin.close()
# do translation
x1t = np.remainder(x1e - Utrans * t, scale)
for j in range(nx2):
y1e[0:nx1] = a[j, :]
y1e[nx1] = a[j, 0]
f = interpolate.interp1d(x1e, y1e)
a[j, :] = f(x1t)[0:nx1]
fig = plt.figure(figsize=[x1[-1], x2[-1]])
# plt.pcolormesh(x1,x2,a,vmin=-0.537284965,vmax=0.537284965)
plt.pcolormesh(x1,
x2,
a,
cmap='magma_r',
norm=colors.PowerNorm(0.5, np.amin(a), 6.0),
shading='auto')
# plt.imshow(a,origin='lower',cmap='magma_r',norm=colors.PowerNorm(0.5,np.amin(a),6.0))
plt.axis('equal')
plt.gca().set_axis_off()
plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
plt.margins(0, 0)
plt.savefig("{}.jpg".format(file), dpi=1920. / x1[-1])
plt.close(fig)
def data_density_filter(x,
y,
conv_matrix=None,
min_count=5,
return_figures=True):
"""
Use the 2D density cloud of observations to find outliers for any variables
The data density filter needs tuning to work well.
This uses convolution to create the density cloud - you can specify
the exact convolution matrix, or its shape
Parameters
----------
x : np.array / pd.Series, shape=[n, ]
e.g. temperature
y : np.array / pd.Series, shape=[n, ]
e.g. salinity
conv_matrix : int, list, np.array, optional
int = size of the isotropic round convolution window.
[int, int] = anisotropic (oval) convoltion window.
2d array is a weighted convolution window;
rectangle = np.ones([int, int]);
more advanced anisotropic windows can also be created
min_count : int, default=5, optional
masks the 2d histogram counts smaller than this limit when performing
the convolution
return_figures : bool, default=True, optional
returns figures of the data plotted for blob detection...
Returns
-------
mask : np.array, shape=[n, ]
a mask that returns only values
figure :
only returned if return_figure is True
"""
from numpy import array, c_, inf, isnan, linspace, where
from pandas import Series, cut
from scipy.signal import convolve2d
def gaussian_kernel(*shape):
"""
Returns a 2D array with gaussian values to be used in the blob_outliers
detection function. Can be anisotripic (oblong). Scaling is determined
automatically.
Parameters
----------
shape : int, int
if one integer is passed the kernel will be isotropic
if two integers are passed the kernel will be anisotropic
Returns
-------
array (float)
The 2D representation of the kernel
"""
from matplotlib.cbook import flatten
from numpy import exp, mgrid
# make shape a list regardless of input
shape = [int(a // 2) for a in flatten([shape])]
# anisotropic if len(2) else isotropic
if len(shape) == 1:
sx, sy = shape[0], shape[0]
elif len(shape) == 2:
sx, sy = shape
# create the x and y grid
x, y = mgrid[-sx:sx + 1, -sy:sy + 1]
sigma = [sx / 8, sy / 8] # sigma scaled by shape
c = tuple([sx, sy]) # centre index of x and y
g = 1 * exp(-((x - x[c])**2 / (2 * sigma[0])**2 + (y - y[c])**2 /
(2 * sigma[1])**2))
return g
# turning input into pandas.Series
x = Series(x, name="X" if not isinstance(x, Series) else x.name)
y = Series(y, name="Y" if not isinstance(y, Series) else y.name)
###############
# BINNING #
###############
# create bins for the data - equal bins
xbins = linspace(x.min(), x.max(), 250)
ybins = linspace(y.min(), y.max(), 250)
# binning the data with pandas. This is quick to find outliers at the end
xcut = cut(x, xbins, labels=c_[xbins[:-1], xbins[1:]].mean(1), right=False)
ycut = cut(y, ybins, labels=c_[ybins[:-1], ybins[1:]].mean(1), right=False)
# binning the data and returning as a 2D array (pandas.DataFrame)
count = x.groupby([xcut, ycut]).count()
count.name = "count" # to avoid an error when unstacking
count = count.unstack()
count = count.sort_index().sort_index(axis=1)
###################
# CONVOLUTION #
###################
# make convolution matrix if not given
if conv_matrix is None:
conv_matrix = (gaussian_kernel(21) > 1e-5).astype(int)
elif isinstance(conv_matrix, (list, int, float)):
conv_matrix = (gaussian_kernel(conv_matrix) > 1e-5).astype(int)
else:
ndim = array(conv_matrix).ndim
if ndim != 2:
raise UserWarning("conv_matrix must have 2 dimensions")
# An array with which the convolution is done
# use a threshold to mask out bins with low counts
# thus only dense regions of data are considered
count0 = count.fillna(0).values
count0[count0 < min_count] = 0
# 2d convolution with the input matrix
convolved_count = convolve2d(count0, conv_matrix, mode="same")
outliers = (convolved_count == 0) & ~isnan(count)
cols = count.index
rows = count.columns
########################################
# FINDING OUTLIERS AND CREATE MASK #
########################################
# find indicies of of the where there is no convolution,
# but there are data. Then get the x and y values of these
# points. Turn these into pairs for pandas multi-indexing.
i, j = where(outliers)
xi = cols[i].values
yj = rows[j].values
ij = list(zip(xi, yj))
# Create a pandas dataframe with the pd.cut data as indicies
# with a column for a numerical index.
if len(ij) > 0:
idx = x.to_frame().reset_index().drop(x.name, axis=1)
idx = idx.set_axis([xcut, ycut], inplace=False)
idx = idx.loc[ij]["index"].values
else:
idx = None
# create a placeholder mask and fill outliers with True
mask = (x > inf).values
mask[idx] = True
###############
# FIGURES #
###############
if return_figures:
from matplotlib import cm, colors
from matplotlib import pyplot as plt
from numpy import ma, r_
# x and y plotting coordinates
xp = cols.values.astype(float)
yp = rows.values.astype(float)
# plotting variables a, b, c
a = ma.masked_invalid(count.T, 0)
b = convolved_count.T
c = ma.masked_where(a.mask, ~outliers.T)
# create the figure
fig, ax = plt.subplots(1, 2, figsize=[10, 5], dpi=90, sharey=True)
# properties for the pcolormesh and contours
pn = colors.PowerNorm(0.3)
mesh_props = dict(cmap=cm.Spectral_r, norm=pn)
# create the pcolormesh plots
im = (
ax[0].pcolormesh(xp, yp, a, vmax=a.max() / 2, **mesh_props),
ax[1].pcolormesh(xp, yp, c, vmin=0, vmax=1),
)
ax[1].contour(xp,
yp,
b,
levels=[0.5],
linestyles="-",
colors="r",
linewidths=2)
# change figure parameters
ax[0].set_title("Histogram of data (min_count = {})".format(min_count))
ax[1].set_title(
"{} Outliers found using\n{} convolution decision boundary".format(
mask.sum(), str(conv_matrix.shape)))
ax[0].set_xticks([])
ax[0].set_ylabel(y.name)
ax[1].set_xlabel(x.name)
# tight layout before creating the axes for pcolomesh plots
fig.tight_layout()
# make colorbar axes based on axes [0, 1]
p = ax[0].get_position()
cax = fig.add_axes([p.x0, p.y0 - 0.05, p.width, 0.04])
cb = plt.colorbar(im[0], cax=cax, orientation="horizontal")
cb.set_label("Count")
cb.set_ticks([1, 2, 3, 5, 10, 30, 80, 200])
# plot the min_count on the colorbar
cx = pn(r_[cb.get_clim(), min_count])[-1]
cb.ax.plot(cx, 0, marker="^", color="k", markersize=8)
cb.ax.plot(cx, 1, marker="v", color="k", markersize=8)
return mask, fig
return mask
def pcolormesh(variable,x=None,y=None,projection=None,cmap="viridis",
shading='Gouraud',norm=None,vmin=None,vmax=None,invertx=False,
inverty=False,linthresh=1.0e-3,linscale=1.0,gamma=1.0,bounds=None,
symmetric=False,ncolors=256,**kwargs):
if symmetric==True: #assumes zero is the midpoint
if vmin and vmax:
vmin=-max(abs(vmin),abs(vmax))
vmax= max(abs(vmin),abs(vmax))
elif vmin:
vmax=-vmin
elif vmax:
vmin=-vmax
else:
vmax = np.nanmax(abs(variable))
vmin = -vmax
elif type(symmetric)!=type(None) and type(symmetric)!=type(False): # a midpoint is specified
if vmin and vmax:
vmin = symmetric - max(abs(vmin-symmetric),abs(vmax-symmetric))
vmax = 2*symmetric - vmin
elif vmin:
vmax = 2*symmetric - vmin
elif vmax:
vmin = 2*symmetric - vmax
else:
vmax = symmetric + np.nanmax(abs(variable-symmetric))
vmin = 2*symmetric - vmax
else:
if not vmin:
vmin = np.nanmin(variable)
if not vmax:
vmax = np.nanmax(variable)
if norm=="Log":
normalization=colors.LogNorm(vmin=vmin,vmax=vmax)
elif norm=="SymLog":
normalization=colors.SymLogNorm(vmin=vmin,vmax=vmax,linthresh=linthresh,linscale=linscale)
elif norm=="PowerLog":
normalization=colors.PowerNorm(gamma,vmin=vmin,vmax=vmax)
elif norm=="Bounds":
if type(bounds)==type(None):
bounds = np.linspace(vmin,vmax,num=ncolors+1)
normalization=colors.BoundaryNorm(bounds,ncolors)
else:
normalization=colors.Normalize(vmin=vmin,vmax=vmax)
if len(variable.shape)>2:
variable=make2d(variable)
if type(x)==type(None) or type(y)==type(None):
im = plt.pcolormesh(variable,norm=normalization,shading=shading,cmap=cmap)
if inverty:
plt.gca().invert_yaxis()
if invertx:
plt.gca().invert_xaxis()
return im
if projection:
if len(x.shape)==1:
x,y = np.meshgrid(x,y)
x = wrap2d(x)
x[:,-1] = x[:,0]+360.0
y = wrap2d(y)
variable=wrap2d(variable)
m=_xBasemap(projection=projection,**kwargs)
im=m.pcolormesh(x,y,variable,cmap=cmap,shading=shading,norm=normalization,latlon=True)
return m,im
im=plt.pcolormesh(x,y,variable,cmap=cmap,shading=shading,norm=normalization,**kwargs)
if inverty:
plt.gca().invert_yaxis()
if invertx:
plt.gca().invert_xaxis()
return im
from matplotlib import pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
from numpy.random import multivariate_normal
data = np.vstack([
multivariate_normal([10, 10], [[3, 2], [2, 3]], size=100000),
multivariate_normal([30, 20], [[2, 3], [1, 3]], size=1000)
])
gammas = [0.8, 0.5, 0.3]
fig, axes = plt.subplots(nrows=2, ncols=2)
axes[0, 0].set_title('Linear normalization')
axes[0, 0].hist2d(data[:, 0], data[:, 1], bins=100)
for ax, gamma in zip(axes.flat[1:], gammas):
ax.set_title('Power law $(\gamma=%1.1f)$' % gamma)
ax.hist2d(data[:, 0], data[:, 1],
bins=100, norm=mcolors.PowerNorm(gamma))
fig.tight_layout()
plt.show()
lat.set_axislabel('Galactic Latitude (deg)', minpad=1., size=fsize)
lon.set_ticks(spacing=0.2 * u.deg, color='black', exclude_overlapping=True, size=5, width=1.1)
lat.set_ticks(spacing=0.2 * u.deg, color='black', exclude_overlapping=True, size=5, width=1.1)
lon.set_ticklabel(size=fsize)
lat.set_ticklabel(size=fsize)
lon.display_minor_ticks(True)
lat.display_minor_ticks(True)
lon.set_minor_frequency(4)
lat.set_minor_frequency(4)
lon.set_major_formatter('d.d')
lat.set_major_formatter('d.d')
minval = np.nanmin(data)
maxval = np.nanmax(data)
im = ax.imshow(data, interpolation='nearest', cmap='Blues_r', origin='lower', norm=colors.PowerNorm(gamma=1./4.0))
d = Dendrogram.load_from(dendrofile)
leaf_mask = np.zeros(data.shape)
count=0
for leaf in d.leaves:
foundleaf = (leaf.idx == catalog['index'].data)
if np.any(foundleaf):
arr = leaf.get_mask()
leaf_mask[(arr==True)] = table['index'].data[count]
count+=1
ax.contour(leaf_mask, transform=ax.get_transform(wcs), cmap='Reds', linewidths=0.25)
plt.savefig(figure_name, dpi=800, bbox_inches='tight')
from matplotlib import pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
from numpy.random import multivariate_normal
data = np.vstack([
multivariate_normal([10, 10], [[3, 2], [2, 3]], size=100000),
multivariate_normal([30, 20], [[2, 3], [1, 3]], size=1000)
])
gammas = [0.8, 0.5, 0.3]
xgrid = np.floor((len(gammas) + 1.) / 2)
ygrid = np.ceil((len(gammas) + 1.) / 2)
plt.subplot(xgrid, ygrid, 1)
plt.title('Linear normalization')
plt.hist2d(data[:, 0], data[:, 1], bins=100)
for i, gamma in enumerate(gammas):
plt.subplot(xgrid, ygrid, i + 2)
plt.title('Power law\n$(\gamma=%1.1f)$' % gamma)
plt.hist2d(data[:, 0], data[:, 1], bins=100, norm=mcolors.PowerNorm(gamma))
plt.tight_layout()
plt.show()
# Create a figure with 2 plot areas
fig, axes = plt.subplots(ncols=2, nrows=1, figsize=(21, 5))
# Everything sarts with a Scatterplot
axes[0].set_title('Scatterplot')
axes[0].plot(x, y, 'ko')
### 2D Histogram ###
nbins = 150 # number of bins, adjustable
gmma = 0.3 # Gamma, changes the normalization for datapnts in 2D Histogram
# Smaller values reveal the lighter tracks where less time was
# spent; see:
# https://matplotlib.org/gallery/scales/power_norm.html#sphx-glr-gallery-scales-power-norm-py
axes[1].set_title('2D Histogram')
plt.xlabel("Distance, Pixels")
counts, xedges, yedges, im = axes[1].hist2d(x,
y,
bins=nbins,
cmap=plt.cm.YlGnBu_r,
norm=mcolors.PowerNorm(gmma))
# hist2d gives multiple things; im needed for colorbar
cbar = plt.colorbar(im, ax=axes[1])
#cbar.mappable.set_clim(0,100) # comment this out to set cbar to auto range
# or chnage to alter the range of the colorbar
cbar.ax.set_yticklabels(['Never', '', '', '', 'Most Often'])
# Change labels above to alter labels on colorbar
### Save Figure ###
# Make sure to name it something identifyable
plt.savefig("Testing_2DHistogram.pdf")
#Coloring in final graph: Green = low, Red = high
cground = colors.LinearSegmentedColormap.from_list('my_colormap',
['green', 'yellow', 'red'],
256)
cwater = colors.LinearSegmentedColormap.from_list(
'my_colormap', [[0, 1, 1, 0], [0, 1, 1, 1], 'blue'])
# tell imshow about color areaMap so that only set colors are used
vectGroundFunc = np.vectorize(attrgetter('groundLevel'))
groundMap = plot.imshow(vectGroundFunc(areaMap), cmap=cground, origin='lower')
vectWaterFunc = np.vectorize(attrgetter('waterLevel'))
vectIncWaterFunc = np.vectorize(attrgetter('incomingWater'))
waterMap = plot.imshow(vectWaterFunc(areaMap),
cmap=cwater,
origin='lower',
norm=colors.PowerNorm(gamma=gammaLevel * 1.0,
vmax=colourBarvmax / 1000.0),
animated=True)
colourbar = fig.colorbar(waterMap, ax=ax, extend='max')
#show areaMap and update in loop
print("Starting simluation")
print("Total Water = " +
str(np.sum(vectWaterFunc(areaMap)) + np.sum(rainFall)))
def runSimulation(self):
for (x, y), movingWater in np.ndenumerate(areaMap):
if not (movingWater.visted):
if i != 0:
h, xedges, yedges, img = ax2.hist2d(x,
y,
bins=[bins, bins],
range=[[-xlim, xlim],
[-xlim, xlim]],
cmap=cmap,
density=True)
else:
h, xedges, yedges, img = ax2.hist2d(x,
y,
bins=[bins - 15, bins - 15],
range=[[-xlim, xlim],
[-xlim, xlim]],
cmap=cmap,
norm=mcolors.PowerNorm(0.6),
density=True)
# colorbar: uncomment this section for individual colorbar
# norm = colors.Normalize(vmin=np.min(h), vmax=np.max(h))
# cb = fig2.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap), ax = ax2)
# cb.set_label('Probability', fontsize = fontsize, rotation = -90, horizontalalignment = 'center', verticalalignment = 'bottom')
sfntmp = sfname[i]
np.savetxt(sfntmp + "x.txt", xedges)
np.savetxt(sfntmp + "y.txt", yedges)
np.savetxt(sfntmp + "h.txt", h)
# axes label
ax2.set_xlabel(r'Position($\mu$m)', fontsize=fontsize)
ax2.set_ylabel(r'Position($\mu$m)', fontsize=fontsize)
# tick location and tick label
xtick_temp = np.arange(0, xlim, step=6.25)
def beamvstime(configfile,
maindir,
params=['Ne'],
filetemplate='AltvTime',
suptitle='Alt vs Time'):
""" This will create a altitude time image for the data for ionocontainer files
that are in sphereical coordinates.
Inputs
Times - A list of times that will be plotted.
configfile - The INI file with the simulation parameters that will be useds.
maindir - The directory the images will be saved in.
params - List of Parameter names that will be ploted. These need to match
in the ionocontainer names.
filetemplate - The first part of a the file names.
suptitle - The supertitle for the plots.
"""
sns.set_style("whitegrid")
sns.set_context("notebook")
# rc('text', usetex=True)
(sensdict, simparams) = readconfigfile(configfile)
paramslower = [ip.lower() for ip in params]
Np = len(params)
maindir = Path(maindir)
inputfile = str(maindir.joinpath('Fitted', 'fitteddata.h5'))
Ionofit = IonoContainer.readh5(inputfile)
times = Ionofit.Time_Vector
Nt = len(times)
dataloc = Ionofit.Sphere_Coords
pnames = Ionofit.Param_Names
pnameslower = sp.array([ip.lower() for ip in pnames.flatten()])
p2fit = [
sp.argwhere(ip == pnameslower)[0][0] if ip in pnameslower else None
for ip in paramslower
]
angles = dataloc[:, 1:]
b = np.ascontiguousarray(angles).view(
np.dtype((np.void, angles.dtype.itemsize * angles.shape[1])))
_, idx, invidx = np.unique(b, return_index=True, return_inverse=True)
beamlist = angles[idx]
Nb = beamlist.shape[0]
newfig = True
imcount = 0
ifig = -1
for iparam in range(Np):
for ibeam in range(Nb):
if newfig:
(figmplf, axmat) = plt.subplots(3,
3,
figsize=(20, 15),
facecolor='w',
sharex=True,
sharey=True)
axvec = axmat.flatten()
newfig = False
ix = 0
ifig += 1
ax = axvec[ix]
curbeam = beamlist[ibeam]
curparm = paramslower[iparam]
if curparm == 'nepow':
curparm = 'ne'
indxkep = np.argwhere(invidx == ibeam)[:, 0]
rng_fit = dataloc[indxkep, 0]
rngargs = np.argsort(rng_fit)
rng_fit = rng_fit[rngargs]
alt_fit = rng_fit * sp.sin(curbeam[1] * sp.pi / 180.)
curfit = Ionofit.Param_List[indxkep, :, p2fit[iparam]]
curfit = curfit[rngargs]
Tmat, Amat = np.meshgrid(times[:, 0], alt_fit)
image = ax.pcolor(Tmat, Amat, curfit.real, cmap='viridis')
if curparm == 'ne':
image.set_norm(colors.LogNorm(vmin=1e9, vmax=5e12))
cbarstr = params[iparam] + ' m-3'
else:
image.set_norm(colors.PowerNorm(gamma=1., vmin=500, vmax=3e3))
cbarstr = params[iparam] + ' K'
if ix > 5:
ax.set_xlabel("Time in s")
if sp.mod(ix, 3) == 0:
ax.set_ylabel('Alt km')
ax.set_title('{0} vs Altitude, Az: {1}$^o$ El: {2}$^o$'.format(
params[iparam], *curbeam))
imcount = imcount + 1
ix += 1
if ix == 9 or ibeam + 1 == Nb:
cbar_ax = figmplf.add_axes([.91, .3, .06, .4])
cbar = plt.colorbar(image, cax=cbar_ax)
cbar.set_label(cbarstr)
figmplf.suptitle(suptitle, fontsize=20)
figmplf.tight_layout(rect=[0, .05, .9, .95])
fname = filetemplate + '_{0:0>3}.png'.format(ifig)
plt.savefig(fname)
plt.close(figmplf)
newfig = True
'color': '0.8'
}
cfont_titl = {
'fontname': 'Open Sans',
'fontweight': 'light',
'fontsize': int(14. * fontr),
'color': color_top
}
# Colormaps for fields:
pal_fld = cp.chose_colmap(cpal_fld)
if l_log_field:
norm_fld = colors.LogNorm(vmin=tmin, vmax=tmax, clip=False)
elif l_pow_field:
norm_fld = colors.PowerNorm(gamma=pow_field,
vmin=tmin,
vmax=tmax,
clip=False)
else:
norm_fld = colors.Normalize(vmin=tmin, vmax=tmax, clip=False)
if l_show_lsm or l_add_topo_land:
if l_add_topo_land:
xtopo = nmp.log10(xtopo + rof_log)
pal_lsm = cp.chose_colmap('gray_r')
#norm_lsm = colors.Normalize(vmin = nmp.log10(min(-100.+rof_dpt/3.,0.) + rof_log), vmax = nmp.log10(4000.+rof_dpt + rof_log), clip = False)
norm_lsm = colors.Normalize(vmin=nmp.log10(-100. + rof_log),
vmax=nmp.log10(4000. + rof_dpt + rof_log),
clip=False)
else:
pal_lsm = cp.chose_colmap('land_dark')
norm_lsm = colors.Normalize(vmin=0., vmax=1., clip=False)
def draw_figures(self, history, color_p_axis=False):
from matplotlib import colors
color = 'black'
fontsize = self.font_size
markersize = fontsize * 1.5
beachballsize_small = markersize * 0.5
beachball_type = self.beachball_type
problem = history.problem
sp = SectionPlot(config=self)
self._to_be_closed.append(sp)
fig = sp.fig
axes_en = sp.axes_xy
axes_dn = sp.axes_zy
axes_ed = sp.axes_xz
bounds = problem.get_combined_bounds()
models = history.get_sorted_primary_models()[::-1]
iorder = num.arange(history.nmodels)
for parname, set_label, set_lim in [
['east_shift', sp.set_xlabel, sp.set_xlim],
['north_shift', sp.set_ylabel, sp.set_ylim],
['depth', sp.set_zlabel, sp.set_zlim]]:
ipar = problem.name_to_index(parname)
par = problem.combined[ipar]
set_label(par.get_label())
xmin, xmax = fixlim(*par.scaled(bounds[ipar]))
set_lim(xmin, xmax)
if 'volume_change' in problem.parameter_names:
volumes = models[:, problem.name_to_index('volume_change')]
volume_max = volumes.max()
volume_min = volumes.min()
def scale_size(source):
if not hasattr(source, 'volume_change'):
return beachballsize_small
volume_change = source.volume_change
fac = (volume_change - volume_min) / (volume_max - volume_min)
return markersize * .25 + markersize * .5 * fac
for axes, xparname, yparname in [
(axes_en, 'east_shift', 'north_shift'),
(axes_dn, 'depth', 'north_shift'),
(axes_ed, 'east_shift', 'depth')]:
ixpar = problem.name_to_index(xparname)
iypar = problem.name_to_index(yparname)
xpar = problem.combined[ixpar]
ypar = problem.combined[iypar]
xmin, xmax = fixlim(*xpar.scaled(bounds[ixpar]))
ymin, ymax = fixlim(*ypar.scaled(bounds[iypar]))
try:
axes.set_facecolor(mpl_color('aluminium1'))
except AttributeError:
axes.patch.set_facecolor(mpl_color('aluminium1'))
rect = patches.Rectangle(
(xmin, ymin), xmax-xmin, ymax-ymin,
facecolor=mpl_color('white'),
edgecolor=mpl_color('aluminium2'))
axes.add_patch(rect)
# fxs = xpar.scaled(problem.extract(models, ixpar))
# fys = ypar.scaled(problem.extract(models, iypar))
# axes.set_xlim(*fixlim(num.min(fxs), num.max(fxs)))
# axes.set_ylim(*fixlim(num.min(fys), num.max(fys)))
cmap = cm.ScalarMappable(
norm=colors.PowerNorm(
gamma=self.normalisation_gamma,
vmin=iorder.min(),
vmax=iorder.max()),
cmap=plt.get_cmap('coolwarm'))
for ix, x in enumerate(models):
source = problem.get_source(x)
mt = source.pyrocko_moment_tensor(
store=problem.get_gf_store(problem.targets[0]),
target=problem.targets[0])
fx = problem.extract(x, ixpar)
fy = problem.extract(x, iypar)
sx, sy = xpar.scaled(fx), ypar.scaled(fy)
# TODO: Add rotation in cross-sections
color = cmap.to_rgba(iorder[ix])
alpha = (iorder[ix] - iorder.min()) / \
float(iorder.max() - iorder.min())
alpha = alpha**self.normalisation_gamma
try:
beachball.plot_beachball_mpl(
mt, axes,
beachball_type=beachball_type,
position=(sx, sy),
size=scale_size(source),
color_t=color,
color_p=color if color_p_axis else 'white',
alpha=alpha,
zorder=1,
linewidth=0.25)
except beachball.BeachballError as e:
logger.warn(str(e))
item = PlotItem(name='main')
return [[item, fig]]
try:
gama
except:
gama = 1.0
fig = plt.figure()
ax = plt.subplot('111', projection=wcs_cut)
x, y = wcs_cut.wcs_world2pix(testra, testdec, 1)
props = dict(facecolor='white', alpha=0.5, edgecolor='None')
plt.text(x, y, galaxy + ' ' + linelabel, fontsize=15, bbox=props)
ax.tick_params(labelsize=8, direction='in')
im = plt.imshow(mom0_cut,
norm=colors.PowerNorm(gamma=gama),
vmax=vmax,
vmin=vmin,
origin='lower',
cmap='gist_ncar_r')
plt.xlabel('J2000 Right Ascension')
plt.ylabel('J2000 Declination')
beamellipse_pix.plot(color='black')
cbar = plt.colorbar(im)
cbar.set_label('$Jy\ beam^{-1}\ km\ s^{-1} $', fontsize=15)
south_sky = read_ds9(regionDir + 'south_SFR.reg')[0]
south_pix = south_sky.to_pixel(wcs_cut)
south_pix.plot(color='black', linewidth=2.0)
# process them afterwards using the nan_to_num
with np.errstate(invalid='ignore'):
M = np.nan_to_num(N + 1 - np.log2(np.log(abs(Z))) + log_horizon)
dpi = 72
width = 10
height = 10 * yn / xn
fig = plt.figure(figsize=(width, height), dpi=dpi)
ax = fig.add_axes([0, 0, 1, 1], frameon=False, aspect=1)
# Shaded rendering
light = colors.LightSource(azdeg=315, altdeg=10)
M = light.shade(M,
cmap=plt.cm.hot,
vert_exag=1.5,
norm=colors.PowerNorm(0.3),
blend_mode='hsv')
ax.imshow(M, extent=[xmin, xmax, ymin, ymax], interpolation="bicubic")
ax.set_xticks([])
ax.set_yticks([])
# Some advertisement for matplotlib
year = time.strftime("%Y")
text = ("The Mandelbrot fractal set\n"
"Rendered with matplotlib %s, %s - https://matplotlib.org" %
(matplotlib.__version__, year))
ax.text(xmin + .025,
ymin + .025,
text,
color="white",
fontsize=12,
fig = plt.figure(figsize=(20,15))
ax2 = fig.add_subplot(421)
#ax2.set_title("Yield (t/ha)",fontsize=20)
map = Basemap(projection ='cyl', llcrnrlat=-65, urcrnrlat=90,llcrnrlon=-180, urcrnrlon=180, resolution='c')
#map.drawcoastlines()
x,y = map(lon2,lat2)
map.drawcoastlines()
map.drawcountries()
map.drawmapboundary()
#print iyield2
cs = map.pcolormesh(x,y,iyield1,cmap=plt.cm.jet,norm=colors.PowerNorm(gamma=1./2.),vmin=0,vmax=16)
#cbar = map.colorbar(cs,location='bottom',size="5%",pad="2%")
#cbar.ax.tick_params(labelsize=15)
plt.axis('off')
cmap = plt.cm.bwr
bounds=[-30,-25,-20,-15,-10,-5,0,20,40,60,80,100,120]
#bounds=[-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6]
norm = colors.BoundaryNorm(bounds, cmap.N)
#norm = colors.Normalize(vmin=-150, vmax=150)
#norm=colors.SymLogNorm(linthresh=2, linscale=1,vmin=-200,vmax=200)
ax2 = fig.add_subplot(422)
#ax2.set_title("CESM-ISAM Maize Yield (t/ha)",fontsize=20)
map = Basemap(projection ='cyl', llcrnrlat=-65, urcrnrlat=90,llcrnrlon=-180, urcrnrlon=180, resolution='c')
map.drawcoastlines()
# There should probably be a good reason for plotting the data using
# this type of transformation. Technical viewers are used to linear
# and logarithmic axes and data transformations. Power laws are less
# common, and viewers should explicitly be made aware that they have
# been used.
N = 100
X, Y = np.mgrid[0:3:complex(0, N), 0:2:complex(0, N)]
Z1 = (1 + np.sin(Y * 10.)) * X**2
fig, ax = plt.subplots(2, 1)
pcm = ax[0].pcolormesh(X,
Y,
Z1,
norm=colors.PowerNorm(gamma=0.5),
cmap='PuBu_r',
shading='auto')
fig.colorbar(pcm, ax=ax[0], extend='max')
pcm = ax[1].pcolormesh(X, Y, Z1, cmap='PuBu_r', shading='auto')
fig.colorbar(pcm, ax=ax[1], extend='max')
plt.show()
###############################################################################
# Discrete bounds
# ---------------
#
# Another normalization that comes with Matplotlib is `.colors.BoundaryNorm`.
# In addition to *vmin* and *vmax*, this takes as arguments boundaries between
# which data is to be mapped. The colors are then linearly distributed between
def plot_result(img_array, ret_img_array):
std = float(cp.std(ret_img_array))
gamma = [0.5]
v_max = [8 * std]
frac = ret_img_array.shape[0] / 128
thumbnail_shape = [int(each / frac) for each in ret_img_array.shape]
thumbnail = np.array(
Image.fromarray(ret_img_array).resize(thumbnail_shape,
Image.ANTIALIAS))
# first select proper vmax and gamma
fig = plt.figure()
ima = plt.axes((0.1, 0.20, 0.8, 0.7))
ima.set_title("Please select proper Vmax and Gamma for result")
ima.imshow(thumbnail,
cmap="gray",
norm=colors.PowerNorm(gamma=gamma[0]),
vmin=0,
vmax=v_max[0])
# plot slider
om1 = plt.axes((0.25, 0.05, 0.65, 0.03))
om2 = plt.axes((0.25, 0.10, 0.65, 0.03))
som1 = Slider(om1,
r"$max value$",
0,
16 * std,
valinit=v_max[0],
dragging=True) # generate the first slider
som2 = Slider(om2, r"$Gamma$", 0, 4.0, valinit=gamma[0],
dragging=True) # generate the second slider
# define update function for slides
def update(val):
s1 = som1.val
s2 = som2.val
v_max[0] = s1
gamma[0] = s2
ima.imshow(thumbnail,
cmap="gray",
norm=colors.PowerNorm(gamma=gamma[0]),
vmin=0,
vmax=v_max[0])
fig.canvas.draw_idle()
# bind update function to slides
som1.on_changed(update)
som2.on_changed(update)
plt.show()
del thumbnail
# then print the final compared images
fig, (ax1, ax2) = plt.subplots(1, 2)
# plot original image sequence
ax1.set_title("Original image sequence")
ims = []
for frame in img_array[:200]:
im = ax1.imshow(frame, cmap="gray", animated=True)
ims.append([im])
ani = animation.ArtistAnimation(fig,
ims,
interval=50,
blit=True,
repeat_delay=0)
# animation.ArtistAnimation(fig, ims, interval=50, blit=True, repeat_delay=0)
# plot result
ax2.imshow(ret_img_array,
cmap="gray",
norm=colors.PowerNorm(gamma=gamma[0]),
vmin=0,
vmax=v_max[0])
ax2.set_title("srrf image")
plt.show()
@image_comparison(['imshow_bignumbers_real.png'],
remove_text=True,
style='mpl20')
def test_imshow_bignumbers_real():
rcParams['image.interpolation'] = 'nearest'
# putting a big number in an array of integers shouldn't
# ruin the dynamic range of the resolved bits.
fig, ax = plt.subplots()
img = np.array([[2., 1., 1.e22], [4., 1., 3.]])
pc = ax.imshow(img)
pc.set_clim(0, 5)
@pytest.mark.parametrize("make_norm", [
colors.Normalize, colors.LogNorm, lambda: colors.SymLogNorm(1),
lambda: colors.PowerNorm(1)
])
def test_empty_imshow(make_norm):
fig, ax = plt.subplots()
with pytest.warns(UserWarning,
match="Attempting to set identical left == right"):
im = ax.imshow([[]], norm=make_norm())
im.set_extent([-5, 5, -5, 5])
fig.canvas.draw()
with pytest.raises(RuntimeError):
im.make_image(fig._cachedRenderer)
def test_imshow_float128():
fig, ax = plt.subplots()
def no_nightglow_uncertainty(self):
ind = np.squeeze(np.where(self.__features == 'no_nightglow'))
return self.__uncertainties[:, :, ind]
@property
def aurora_radiance(self):
ind = np.squeeze(np.where((self.__features == 'co_cameron_bands') |
(self.__features == 'co2p_uvd') |
(self.__features == 'o2972') |
(self.__features == 'co2p_fdb')))
return np.sum(self.__radiances[:, :, ind], axis=2)
@property
def aurora_uncertainty(self):
ind = np.squeeze(np.where((self.__features == 'co_cameron_bands') |
(self.__features == 'co2p_uvd') |
(self.__features == 'o2972') |
(self.__features == 'co2p_fdb')))
return np.sum(self.__uncertainties[:, :, ind], axis=2)
if __name__ == '__main__':
df = DataFilename(files[7])
l1b = L1bDataContents(df)
img = PipelineMLR(l1b).aurora_radiance
img = plt.imshow(img, norm=colors.PowerNorm(gamma=1 / 2, vmin=0, vmax=10))
plt.colorbar()
plt.show()
def plot_day(self):
print("Starting plot: 24h")
# set up figure
fig = plt.figure(figsize=(self.figwidth, 0.75 * self.figwidth))
gs = GridSpec(2, 1)
gs.update(left=0.1,
right=0.95,
top=0.9,
bottom=0.1,
hspace=0.05,
wspace=0.0)
ax_t = plt.subplot(gs[0, 0:])
ax_co = plt.subplot(gs[1, 0:], sharex=ax_t)
# plot 2D histograms over time as hexbin
ax_t.hexbin([
int(h) + int(m) / 60. + int(s) / 3600
for h, m, s in [x[11:19].split(':') for x in self.data['date']]
],
self.data['temp'],
gridsize=100,
cmap='Reds',
mincnt=1,
extent=(0, 24, self.templim[0], self.templim[1]),
norm=colors.PowerNorm(gamma=0.5))
ax_co.hexbin([
int(h) + int(m) / 60. + int(s) / 3600
for h, m, s in [x[11:19].split(':') for x in self.data['date']]
],
self.data['co2'],
gridsize=100,
cmap='Blues',
mincnt=1,
extent=(0, 24, self.co2lim[0], self.co2lim[1]),
norm=colors.PowerNorm(gamma=0.5))
# format figure, labels, ticks
ax_t.set_title("Last updated " +
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
fontsize=self.fontsize)
ax_t.grid(True)
ax_co.grid(True)
ax_t.xaxis.tick_top()
ax_t.xaxis.set_label_position('top')
ax_t.set_xlabel(r"Hour of the day", fontsize=self.fontsize)
ax_co.set_xlabel(r"Hour of the day", fontsize=self.fontsize)
ax_t.set_ylabel(r"temperature [$^\circ$C]", fontsize=self.fontsize)
ax_co.set_ylabel(r"CO2 concentration [ppm]", fontsize=self.fontsize)
ax_t.tick_params(axis='both', which='major', labelsize=self.fontsize)
ax_co.tick_params(axis='both', which='major', labelsize=self.fontsize)
ax_t.set_xscale('linear')
ax_t.set_yscale('linear')
ax_co.set_yscale('linear')
ax_t.set_xlim(-0.5, 24.5)
ax_t.set_ylim(self.templim)
ax_co.set_ylim(self.co2lim)
ax_t.xaxis.set_major_locator(MultipleLocator(1))
ax_t.yaxis.set_major_locator(MultipleLocator(2.5))
ax_co.yaxis.set_major_locator(MultipleLocator(500))
fig.savefig(os.path.join(self.plotdir, self.logname + '.24h.svg'),
bbox_inches='tight')
# store figure for later use
self.day_plot = fig
print("Finished plot: 24h")
facecolor='none',
linewidths=0.3))
ax.add_feature(
cfeature.NaturalEarthFeature(category='physical',
name='rivers_north_america',
scale='10m',
edgecolor='navy',
facecolor='none',
linewidths=0.3))
### plot salinity
mp = ax.pcolormesh(ds["lon_rho"][:, :],
ds["lat_rho"][:, :],
ds["salt"][ind, 29, :, :],
transform=ccrs.PlateCarree(),
norm=colors.PowerNorm(gamma=2),
alpha=1,
cmap=cmo.cm.haline,
vmax=38,
vmin=0)
### colorbar
cax = fig.add_axes([0.38, 0.25, 0.415, 0.025]) #colorbar axes
cb = fig.colorbar(mp, cax=cax, orientation='horizontal')
cb.ax.set_xticks(np.linspace(0, 35, 8))
cb.ax.set_xticklabels(["0", "", "10", "15", "20", "25", "30", "35"],
fontsize=7)
cb.ax.tick_params(labelsize=10,
length=0,
color='0.2',
labelcolor='0.2')
