def plot_ext_laws(self):
wave = np.arange(900, 20000)
f0 = np.ones(wave.shape[0])
for law in ['calz', 'ccm', 'allen', 'prevot', 'seaton', 'fitz']:
getattr(self, law)(wave, f0, 1.)
self.wild(wave)
fig = plt.figure()
gs = GridSpec(1,1)
gs.update(left=0.12, right=0.95, top=0.95, bottom=0.12)
ax = fig.add_subplot(gs[0])
ax.semilogx(wave, self.calz_klam, 'c', lw=1.5, label='Calzetti')
# ax.semilogx(wave, self.ccm_klam, 'k', label='Cardelli')
ax.semilogx(wave, self.allen_klam, 'r', lw=1.5, label='Allen')
ax.semilogx(wave, self.prevot_klam, 'g', lw=1.5, label='Prevot')
ax.semilogx(wave, self.seaton_klam, 'm', lw=1.5, label='Seaton')
ax.semilogx(wave, self.fitz_klam, 'b', lw=1.5, label='Fitzpatrick')
ax.legend(frameon=False)
for axis in ['top', 'bottom', 'left', 'right']:
ax.spines[axis].set_linewidth(1.5)
ax.set_ylabel(r'$k(\lambda)$', fontsize=20)
ax.set_xlabel(r'$\lambda [\AA]$', fontsize=20)
ax.set_xlim(9e2, 2.5e4)
ax.set_ylim(0, 20)
plt.savefig('extlaw.pdf')
def initialize_figure(start_hour, stop_hour):
f = plt.figure(figsize=(17, 21))
font_1 = font_0.copy()
font_1.set_size('20')
font_1.set_weight('bold')
plt.suptitle(u"Schemat wyznaczania HRA dla pojedynczego 24-godzinnego nagrania odstępów RR.",
fontproperties=font_1, y=0.995, fontsize=25)
empty_ratio = 0.2
height_ratios = [
0.5, #1 24-tachogram
0.3, #2 plot 24h -> 2h pass
0.9, #3 2-hour tachogram
empty_ratio, #4 empty
0.45, #5 5-min window arrow plot
#empty_ratio, #6
0.9, #7 2-hour windowed tachogram
empty_ratio, #8 empty plot
0.55, #9 calculate descriptors arrow plot
empty_ratio, #10 empty plot
0.9, #11 2-hour windowed tachogram with asymmetry signs
2.0 #12 schema for binomial test
]
num_rows = len(height_ratios)
num_cols = 1
row_number = 0
gs1 = GridSpec(num_rows, num_cols, height_ratios=height_ratios) #[3, 0.3, 3, 0.5, 4])
gs1.update(left=0.04, right=0.99, wspace=0.1, hspace=0.0, bottom=0.04, top=0.98)
return f, gs1
def plot_pie_bouttypes(bca, new_filename):
print('Plotting pie chart of bout type percentages...')
hab = bca.iloc[0, :]
trials = bca.iloc[1::2, :].sum(axis=0)
breaks = bca.iloc[2::2, :].sum(axis=0)
dfs = [hab, trials, breaks]
condition = ['Baseline', 'Trials', 'Intertrial Intervals']
fig = plt.figure(figsize=(15, 10))
cmp = JoaoColormap()
gs = GridSpec(2, 3) # 2 rows, 3 columns
for i in np.arange(3):
ax = plt.subplot2grid((2, 3), (0, i))
dfs[i].plot(kind='pie',
colors=[colour_dict.get(x, 'white') for x in dfs[i].index],
ax=ax,
autopct=my_autopct,
pctdistance=1.1,
labels=None)
# ax.axis('equal')
# ax.set_title(condition[i], fontsize=18)
ax.set(ylabel='', title=condition[i], aspect='equal')
ax4 = plt.subplot2grid((2, 3), (1, 0), colspan=3)
cat_sym_unique = np.arange(13) # np.unique(cat_sym_tmp)
for i in np.arange(13):
tmp_str = ordered_bouts[i]
ax4.scatter(i, 0.9, color=cmp(idx[i] - 1), s=200)
ax4.text(i - 0.12, 0.8, tmp_str)
ax4.set_ylim([0, 1])
ax4.axis('off')
gs.update(wspace=0.2, hspace=0.02)
plt.tight_layout()
fig.savefig(new_filename, bbox_inches='tight', format='tiff')
plt.close('all')
def main():
matplotlib.rc('font', size=12)
fig = plt.figure(figsize=(16,9))
gs = GridSpec(2, 1, height_ratios=[20, 1])#, 20])
gs.update(hspace=0., wspace=0.)
ax1 = plt.subplot(gs[0])
label_ax = plt.subplot(gs[1])
[ax.set_xlim(0, 599) for ax in (ax1, label_ax)]
ax1.set_ylim(0, 350)
# New way
regiondict = dict(zip(range(1,600), ['MA']*(133-1) + ['CA']*(364-133) + ['p2']*(378-364) + ['NC']*(433-378) + ['p1']*(449-433) + ['p6']*(501-449) + ['PR']*(600-501)))
N_lines = 50
muts = get_muts('gag-gag') + get_muts('gag-pr')
muts = [mut for mut in muts if regiondict[mut[1]] != regiondict[mut[0]]]
muts.sort(key=lambda x: x[-1], reverse=True)
min_mi = muts[N_lines-1][2]
counter = 0
for mut in muts[:N_lines]:
r1, r2 = regiondict[mut[0]], regiondict[mut[1]]
c = 'r' if r2 == 'PR' else 'b'
ax1.add_patch(make_circ(*mut, ec=c))
counter += 1
print counter
r = range(1)
proxy1 = plt.Line2D(r, r, color='b', markerfacecolor='none', lw=3)
proxy2 = plt.Line2D(r, r, color='r', markerfacecolor='none', lw=3)
ax1.legend((proxy1, proxy2), ('Gag-Gag', 'Gag-PR'))
# Add x-axis boxes
locs = [(132, 'MA'), (363, 'CA'), (377, 'p2'), (432, 'NC'), (448, 'p1'), (500, 'p6'),
(599, 'PR')]
x_start = 0
colors = ('#AAAAAA', '#EEEEEE')
for i, (junc, name) in enumerate(locs):
color = colors[i%2]
width = junc - x_start
rect = patches.Rectangle((x_start, 0), width, 1, color=color)
label_ax.add_patch(rect)
label_ax.text(x_start + width/2., 1/2., name, ha='center', va='center')
x_start = junc
label_ax.set_xlim(0, 599)
label_ax.set_xticks([1]+range(50, 650, 50))
label_ax.set_xticklabels([1]+range(50, 500, 50)+[1]+range(50, 150, 50))
[plt.setp(ax.get_xticklabels(), visible=False) for ax in (ax1, )]
[plt.setp(ax.get_yticklabels(), visible=False) for ax in (ax1, label_ax)]
[ax.tick_params(top=False, left=False, right=False, bottom=False) for ax in (ax1, label_ax)]
ax1.tick_params(bottom=True)
ax1.set_xticks(np.arange(0, 599, 10))
label_ax.set_xlabel('Sequence position')
plt.show()
def make_grid(nrows,
ncols,
left=0.05,
right=0.9,
bottom=0.05,
top=0.95,
hspace=0.2,
wspace=0.2):
gs = GridSpec(nrows, ncols)
gs.update(left=left,
right=right,
hspace=hspace,
wspace=wspace,
bottom=bottom,
top=top)
ax = []
if nrows > 1:
for i in range(nrows):
ax_row = []
for j in range(ncols):
ax_row.append(plt.subplot(gs[i, j]))
ax.append(ax_row)
else:
for j in range(ncols):
ax.append(plt.subplot(gs[j]))
return [ax, gs]
def __draw_images(datagen, x, result_images):
import os, glob, shutil
import matplotlib.pyplot as plt
import cv2
from matplotlib.gridspec import GridSpec
# 出力先ディレクトリを作成
temp_dir = "temp"
os.mkdir(temp_dir)
# generatorから9個の画像を生成
# xは1サンプルのみなのでbatch_sizeは1で固定
x = __bgr2rgb(x)
g = datagen.flow(x,
batch_size=32,
save_to_dir=temp_dir,
save_prefix='img',
save_format='jpg')
for i in range(9):
batch = g.next()
# 生成した画像を3x3で描画
images = glob.glob(os.path.join(temp_dir, "*.jpg"))
fig = plt.figure()
gs = GridSpec(3, 3)
gs.update(wspace=0.1, hspace=0.1)
for i in range(9):
img = cv2.imread(images[i])
plt.subplot(gs[i])
plt.imshow(img, aspect='auto')
plt.axis("off")
plt.savefig(result_images)
# 出力先ディレクトリを削除
shutil.rmtree(temp_dir)
def plot(self, outfile, wspace=None, hspace=None, figsize=8):
grid_cols, grid_rows = self.compute_grid_size()
fig_w, fig_h = figsize * grid_cols, figsize * grid_rows
fig = plt.figure(figsize=(fig_w, fig_h))
gs = GridSpec(grid_rows, grid_cols)
if wspace is not None:
gs.update(wspace=wspace)
elif hspace is not None:
gs.update(hspace=hspace)
for j, metric_name in enumerate(sorted(self.to_plot)):
metric = self.to_plot[metric_name]
current_cell = gs[j // grid_cols, j % grid_cols]
if metric['data_type'] == 'lines':
self.plot_lines(current_cell, metric_name, metric)
elif metric['data_type'] == 'scatter':
self.plot_scatter(current_cell, metric_name, metric)
elif metric['data_type'] == 'image-grid':
self.plot_image_grid(current_cell, metric_name, metric)
elif metric['data_type'] == 'image':
self.plot_image(current_cell, metric_name, metric)
elif metric['data_type'] == 'hist':
self.plot_hist(current_cell, metric_name, metric)
plt.savefig(outfile, dpi=200, bbox_inches='tight')
plt.close(fig)
def test():
def make_ticklabels_invisible(fig):
for i, ax in enumerate(fig.axes):
ax.text(0.5, 0.5, "ax%d" % (i + 1), va="center", ha="center")
for tl in ax.get_xticklabels() + ax.get_yticklabels():
tl.set_visible(False)
# gridspec with subplotpars set.
f = plt.figure()
plt.suptitle("GridSpec w/ different subplotpars")
gs1 = GridSpec(3, 3)
gs1.update(left=0.05, right=0.48, wspace=0.05)
plt.subplot(gs1[:-1, :])
plt.subplot(gs1[-1, :-1])
plt.subplot(gs1[-1, -1])
gs2 = GridSpec(3, 3)
gs2.update(left=0.55, right=0.98, hspace=0.05)
plt.subplot(gs2[:, :-1])
plt.subplot(gs2[:-1, -1])
plt.subplot(gs2[-1, -1])
make_ticklabels_invisible(f)
def plot_fd(fd_file, title='FD plot', mean_fd_dist=None, figsize=(11.7, 8.3)):
fd_power = _calc_fd(fd_file)
fig = plt.Figure(figsize=figsize)
FigureCanvas(fig)
if mean_fd_dist:
grid = GridSpec(2, 4)
else:
grid = GridSpec(1, 2, width_ratios=[3, 1])
grid.update(hspace=1.0, right=0.95, left=0.1, bottom=0.2)
ax = fig.add_subplot(grid[0, :-1])
ax.plot(fd_power)
ax.set_xlim((0, len(fd_power)))
ax.set_ylabel("Frame Displacement [mm]")
ax.set_xlabel("Frame number")
ylim = ax.get_ylim()
ax = fig.add_subplot(grid[0, -1])
sns.distplot(fd_power, vertical=True, ax=ax)
ax.set_ylim(ylim)
if mean_fd_dist:
ax = fig.add_subplot(grid[1, :])
sns.distplot(mean_fd_dist, ax=ax)
ax.set_xlabel("Mean Frame Displacement (over all subjects) [mm]")
mean_fd = fd_power.mean()
label = r'$\overline{\text{FD}}$ = %g' % mean_fd
plot_vline(mean_fd, label, ax=ax)
fig.suptitle(title)
return fig
def make_posemap(img, pose, video_num, img_size, f_num, gauss_size):
posemap = pose_map(pose, img_size, gauss_size)
posemap = np.uint8(255 * posemap)
posemap = cv2.applyColorMap(posemap, cv2.COLORMAP_JET)
posemap = cv2.cvtColor(posemap, cv2.COLOR_BGR2RGB)
posemap = posemap / 255
s_img = posemap * 1.0 + img
fig = plt.figure(figsize=(16, 10))
gs = GridSpec(4, 5, left=0.13, right=0.9)
gs.update(wspace=-0.01)
gs_1 = GridSpecFromSubplotSpec(nrows=4, ncols=3, subplot_spec=gs[0:4, 0:3])
fig.add_subplot(gs_1[:, :])
delete_line()
plt.imshow(s_img)
gs_2 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[0:2, 3:5])
fig.add_subplot(gs_2[:, :])
delete_line()
plt.imshow(img)
gs_3 = GridSpecFromSubplotSpec(nrows=2, ncols=2, subplot_spec=gs[2:4, 3:5])
fig.add_subplot(gs_3[:, :])
delete_line()
plt.imshow(posemap, cmap='jet')
plt.clim(0, 1)
plt.colorbar()
SAVE_PATH = "../../../demo/images/posemap"
if not os.path.exists(os.path.join(SAVE_PATH, "posemap_" + video_num)):
os.makedirs(os.path.join(SAVE_PATH, "posemap_" + video_num))
plt.savefig(
os.path.join(SAVE_PATH, "posemap_" + video_num,
str(f_num).zfill(5) + ".png"))
plt.close()
def plot_residuals(x,
y1,
y2,
y1err=None,
title='Plot',
y1label='y1',
xlabel='x',
y2label='y2'):
f = plt.figure()
plt.suptitle(title)
gs1 = GridSpec(2, 2, width_ratios=[1, 2], height_ratios=[4, 1])
gs1.update(wspace=0.5)
ax1 = plt.subplot(gs1[:-1, :])
ax2 = plt.subplot(gs1[-1, :])
ax1.grid()
ax1.errorbar(x, y1, yerr=y1err, ecolor='g')
ax1.set_xticklabels([])
ax1.set_ylabel(y1label)
ax1.set_xlim(x.min(), x.max())
ax2.grid()
ax2.plot(x, y2, color='green')
plt.yticks(
np.array([
round(y2.min(), 3),
round((y2.min() + y2.max()) / 2., 3),
round(y2.max(), 3)
]))
ax2.set_xlabel(xlabel)
ax2.set_ylabel(y2label)
ax2.set_xlim(x.min(), x.max())
plt.close()
return f
def plot_fd(fd_file, fd_radius, mean_fd_dist=None, figsize=DINA4_LANDSCAPE):
fd_power = _calc_fd(fd_file, fd_radius)
fig = plt.Figure(figsize=figsize)
FigureCanvas(fig)
if mean_fd_dist:
grid = GridSpec(2, 4)
else:
grid = GridSpec(1, 2, width_ratios=[3, 1])
grid.update(hspace=1.0, right=0.95, left=0.1, bottom=0.2)
ax = fig.add_subplot(grid[0, :-1])
ax.plot(fd_power)
ax.set_xlim((0, len(fd_power)))
ax.set_ylabel("Frame Displacement [mm]")
ax.set_xlabel("Frame number")
ylim = ax.get_ylim()
ax = fig.add_subplot(grid[0, -1])
sns.distplot(fd_power, vertical=True, ax=ax)
ax.set_ylim(ylim)
if mean_fd_dist:
ax = fig.add_subplot(grid[1, :])
sns.distplot(mean_fd_dist, ax=ax)
ax.set_xlabel("Mean Frame Displacement (over all subjects) [mm]")
mean_fd = fd_power.mean()
label = r"$\overline{{\text{{FD}}}}$ = {0:g}".format(mean_fd)
plot_vline(mean_fd, label, ax=ax)
return fig
def wirikan(self): #Graficos principales
fig = plt.figure(figsize=(20,15))
gs1 = GridSpec(7, 1)
gs1.update(left=0.05, right=0.95, wspace=0.5, hspace=0.3, top=0.98, bottom=0.08)
ax1 = plt.subplot(gs1[0:2,:])
ax1.grid()
ax1.set_ylabel('Roll',fontsize=8)
ax1.xaxis.set_tick_params(labelsize=7)
ax1.yaxis.set_tick_params(labelsize=7)
ax2 = plt.subplot(gs1[2:4,:])
ax2.grid()
ax2.set_ylabel('Pitch',fontsize=8)
ax2.xaxis.set_tick_params(labelsize=7)
ax2.yaxis.set_tick_params(labelsize=7)
ax3 = plt.subplot(gs1[4:6,:])
ax3.grid()
ax3.set_ylabel('Yaw',fontsize=8)
ax3.xaxis.set_tick_params(labelsize=7)
ax3.yaxis.set_tick_params(labelsize=7)
ax4 = plt.subplot(gs1[6,:])
ax4.grid()
ax4.set_ylabel('Mark',fontsize=8)
ax4.xaxis.set_tick_params(labelsize=7)
ax4.yaxis.set_tick_params(labelsize=7)
return fig
def fig_ambient(fig_size=(2, 2),
ncol=2,
nrow=2,
left=0.15,
right=0.95,
top=0.95,
hspace=0,
bottom=0.15,
wspace=0):
fig = plt.figure(figsize=fig_size)
gs2 = GridSpec(nrow, ncol)
gs2.update(left=left,
right=right,
top=top,
hspace=hspace,
bottom=bottom,
wspace=wspace)
nplots = ncol * nrow
axes = []
for k in range(nplots):
ax = plt.subplot(gs2[k])
#AXIS(ax)
axes.append(ax)
return axes
def create_fig(self):
nrow = 1
ncol = 2
ngrid = 2
magical_factor = 15
wspace = 0
hspace = 0
font_size = 15
self.fig = plt.figure(figsize=(
nrow * magical_factor,
(ncol + 1) * ngrid,
))
gs1 = GridSpec(
nrow,
(ncol + 1) * ngrid,
)
gs1.update(
wspace=wspace,
hspace=hspace,
)
self.axs = {}
n = 0
for i, j in product(range(nrow),
[i for i in range(ncol * ngrid)][::ngrid]):
self.axs[n] = plt.subplot(gs1[i, j:j + ngrid])
n += 1
def figure2():
fig = plt.figure(figsize=(10, 6))
gs = GridSpec(6, 1)
gs.update(left=0.1, right=0.95)
ax1 = plt.subplot(gs[:2])
ax2 = plt.subplot(gs[2])
ax3 = plt.subplot(gs[3:5])
ax4 = plt.subplot(gs[5])
ax = [ax1, ax2, ax3, ax4]
start_time = time()
I_sm1 = b2.TimedArray([0, 2, 0, 5, 0, 10, 0]*b2.pA, dt=100*b2.ms)
par_sim['I_sm'] = I_sm1
state_monitor = simulate_Thl_cell_fig2(par, par_sim)
plot_data(state_monitor, ax[0])
plot_current(state_monitor, ax[1])
I_sm2 = b2.TimedArray([0, 0, -0.5, 0, 0, -1, 0, 0]*b2.pA, dt=100*b2.ms)
par_sim['I_sm'] = I_sm2
par['i_ext'] = 0.0
state_monitor = simulate_Thl_cell_fig2(par, par_sim)
print("Done in {}".format(time() - start_time))
plot_data(state_monitor, ax[2])
plot_current(state_monitor, ax[3], xlabel="Time [ms]")
[ax[i].set_xticks([]) for i in range(3)]
[ax[i].set_xlim([0, 1000]) for i in range(4)]
plt.savefig(join("data", "figure2.png"))
plt.show()
def refocus(img,k_2D, dz, alpha, delta=0, plotme=False):
k_0 = 2 * np.pi / 780e-9
fft_img = np.fft.fftshift(np.fft.fft2(img-img.mean()))
fft_img_refocused = U(k_2D, dz, alpha, delta) * fft_img
img_refocused = np.fft.ifft2(fft_img*0+fft_img_refocused)
# mod = (img_refocused * np.conjugate(img_refocused)).real
mod = np.abs(img_refocused) / (2 * k_0)
if plotme:
xc = 321
yc = 218
radius = 20
mod_crop = mod = mod[yc-2*radius:yc+2*radius, xc-2*radius:xc+2*radius]
plt.figure(0, figsize=(10, 3))
gs = GridSpec(1, 2)
gs.update(left=0.1, right=0.95, bottom=0.1, top=0.96,
wspace=0.2, hspace=0.1)
plt.subplot(gs[0])
plt.imshow(np.abs(fft_img_refocused)**2, vmax=7e3)
plt.colorbar()
plt.subplot(gs[1])
plt.imshow((mod_crop)+img.mean())
plt.colorbar()
plt.show()
return mod
def plot_2(plotdata, filename, title, use_offset=False):
f = mpl.figure.Figure(figsize=(11, 8.5))
canvas = FigureCanvasPdf(f)
f.suptitle(title)
gs = GridSpec(len(plotdata), 1)
gs.update(left=0.05, right=0.94, wspace=0.05)
i = 0
offset = 0
for newdata, refdata, invert, series_no in plotdata:
ax1 = f.add_subplot(gs[i, :])
ax2 = ax1.twinx()
data = newdata.match.rate().data
ax2.plot(data[0], data[1], color='#e0b040', linewidth=2.0,
linestyle='-', marker='+', markeredgewidth=2.0)
ax2max = ax2.get_ylim()[1]
ax2.set_ylim([0, ax2max * 2])
ax1.set_ylabel(newdata.series1[series_no].get_name())
data = newdata.series1[series_no].data
if use_offset:
offset = -newdata.series1[series_no].std()*2
if invert:
offset = -offset
ax1.plot(refdata.data[0], refdata.data[1]+offset, linewidth=2.0,
color='#9090ff')
ax1.plot(data[0], data[1], color='black', linewidth=0.75)
ax1.set_zorder(ax2.get_zorder()+1) # put ax in front of ax2
ax1.patch.set_visible(False) # hide the 'canvas'
if invert:
ax1.invert_yaxis()
i = i + 1
canvas.print_figure(filename)
def make_plot(seriess, filename, title=None, invert=False):
f = mpl.figure.Figure(figsize=(11, 8.5))
canvas = FigureCanvasPdf(f)
if title:
f.suptitle(title)
gs = GridSpec(len(seriess), 1)
gs.update(left=0.05, right=0.94, wspace=0.05)
for i in range(0, len(seriess)):
s = seriess[i]
if isinstance(s, (list, tuple)):
ax1 = f.add_subplot(gs[i, :])
ax2 = ax1.twinx()
ax2.plot(s[1].data[0],
s[1].data[1],
color='#aaaaaa',
linewidth=5.0)
ax1.set_ylabel(s[0].get_name())
ax1.plot(s[0].data[0], s[0].data[1], color='black')
ax1.set_zorder(ax2.get_zorder() + 1) # put ax in front of ax2
ax1.patch.set_visible(False) # hide the 'canvas'
if invert:
ax1.invert_yaxis()
ax2.invert_yaxis()
else:
ax = f.add_subplot(gs[i, :])
ax.set_ylabel(s.get_name())
ax.plot(s.data[0], s.data[1], color='black')
if invert:
ax.invert_yaxis()
canvas.print_figure(filename)
def nbo_vs_year(self):
"""
Plot percent of structures, with different NBO per 1000 atoms levels,
from "good" pdb structures (all PDB files with a single model, no unknown
atom types and good CRYST1 records) VS. year
Second sub plot: the total of "good" structures deposited VS. year
"""
plt.close('all')
# figure parameters
# plt.ion() # enables interactive mode
max_y = 105
fontsize = 20
fig = plt.figure(figsize=(8,10))
gs = GridSpec(2,1,height_ratios=[2,1])
# first subplot
ax1 = plt.subplot(gs[0,0])
ax2 = plt.subplot(gs[1,0])
lines = []
line_type = ['.:','.-','.--']
n = len(line_type)
for i,pd in enumerate(self.plot_data_list):
lt = line_type[i%n]
l, = ax1.plot(pd.years,pd.percent,lt)
lines.append(l)
ax1.set_ylabel('Percent of PDB structures',fontsize=fontsize)
ax1.text(min(self.years)+0.5,max_y-4,'a.',fontsize=fontsize)
ax1.tick_params(axis='both',labelsize=fontsize - 2)
ax1.axes.get_xaxis().set_visible(False)
ax1.set_yticks([5,10,40,70,100])
ax1.set_ylim([0,max_y])
ax1.set_xlim([self.start_year,self.end_year])
# legend
labels = ['NBO per 1000 atom > {}']*len(self.nbo_per_1000_atoms)
labels = [x.format(y) for x,y in zip(labels,self.nbo_per_1000_atoms)]
if self.sym:
legend_pos = [0.96,0.70]
else:
legend_pos = [0.54,0.30]
ax1.legend(
lines,labels,
bbox_to_anchor=legend_pos,
loc=1,borderaxespad=0.0)
# Second subplot
ax2.plot(self.years,self.n_total,'.:g')
ax2.set_xlim([self.start_year,self.end_year])
ax2.set_xlabel('Year',fontsize=fontsize)
ax2.set_ylabel('Number of structures',fontsize=fontsize)
ax2.text(min(self.years)+0.5,max(self.n_total)-5,'b.',fontsize=fontsize)
ax2.tick_params(axis='both',labelsize=fontsize - 2)
ax2.set_xticks([self.start_year,1990,2000,self.end_year])
ax2.set_yscale('log')
ax2.set_yticks([10,100,1000])
#
gs.tight_layout(fig)
gs.update(hspace=0)
s = 'all'*(not self.sym) + 'sym'*self.sym
fig_name = 'nbo_vs_year_{}.png'.format(s)
plt.savefig(fig_name)
fig.show()
def plot_fd(fd_file, fd_radius, mean_fd_dist=None, figsize=DINA4_LANDSCAPE):
fd_power = _calc_fd(fd_file, fd_radius)
fig = plt.Figure(figsize=figsize)
FigureCanvas(fig)
if mean_fd_dist:
grid = GridSpec(2, 4)
else:
grid = GridSpec(1, 2, width_ratios=[3, 1])
grid.update(hspace=1.0, right=0.95, left=0.1, bottom=0.2)
ax = fig.add_subplot(grid[0, :-1])
ax.plot(fd_power)
ax.set_xlim((0, len(fd_power)))
ax.set_ylabel("Frame Displacement [mm]")
ax.set_xlabel("Frame number")
ylim = ax.get_ylim()
ax = fig.add_subplot(grid[0, -1])
sns.distplot(fd_power, vertical=True, ax=ax)
ax.set_ylim(ylim)
if mean_fd_dist:
ax = fig.add_subplot(grid[1, :])
sns.distplot(mean_fd_dist, ax=ax)
ax.set_xlabel("Mean Frame Displacement (over all subjects) [mm]")
mean_fd = fd_power.mean()
label = r'$\overline{{\text{{FD}}}}$ = {0:g}'.format(mean_fd)
plot_vline(mean_fd, label, ax=ax)
return fig
def view_random_images(self,
class_names='any',
n_each=1,
subset='train',
cmap='auto'):
self.__check_test_subset(subset)
subset_labels = self.__getattribute__(f'{subset}_labels')
subset_images = self.__getattribute__(f'{subset}_images')
if cmap == 'auto':
subset_dim = len(subset_images[0, :].shape)
if (subset_dim == 2) or (subset_dim == 3
and subset_images.shape[-1] == 1):
cmap = plt.cm.binary
else:
cmap = None
if class_names is 'any':
class_names = [np.random.choice(self.class_names)]
elif class_names is 'all':
class_names = self.class_names
n_classes = len(class_names)
fig = plt.figure(figsize=(n_classes * 2, n_each * 2))
gs = GridSpec(n_each, n_classes)
gs.update(wspace=0.15, hspace=0.05)
# Get class labels
class_labels = [self.nm2lab[nm] for nm in class_names]
# Get label indices for each class
label_df = pd.DataFrame(subset_labels)
label_indices = label_df.groupby([0]).indices
# Now sample from chosen class_labels
sample_labels = {
k: np.random.choice(label_indices[k], n_each)
for k in class_labels
}
for i, (cls_lab, indices) in enumerate(sample_labels.items()):
for j, idx in enumerate(indices):
ax = plt.subplot(gs[j, i])
ax.set_xticklabels([])
ax.set_yticklabels([])
cls_nm = self.lab2nm[cls_lab]
img = subset_images[idx]
ax.imshow(img, cmap=cmap)
ax.set_axis_off()
ax.set_aspect('auto')
if j == 0:
ax.set_title(cls_nm, fontdict=dict(weight='bold'))
return np.reshape(fig.axes, (n_each, len(class_labels)))
def plot_band(ax, nax, xticks_ax, xticklabels_ax, xmin_ax, xmax_ax, ymin, ymax,
data_merged_ax):
width_ratios = []
used_colors = []
for xmin, xmax in zip(xmin_ax, xmax_ax):
width_ratios.append(xmax - xmin)
gs = GridSpec(nrows=1, ncols=nax, width_ratios=width_ratios)
gs.update(wspace=0.1)
for iax in range(nax):
for i in range(len(data_merged_ax[iax])):
if len(data_merged_ax[iax][i]) > 0:
ax.plot(data_merged_ax[iax][i][0:, 0],
data_merged_ax[iax][i][0:, 1],
linestyle=lsty[i],
color=color[i])
used_colors.append(color[i])
for j in range(2, len(data_merged_ax[iax][i][0][0:])):
ax.plot(data_merged_ax[iax][i][0:, 0],
data_merged_ax[iax][i][0:, j],
linestyle=lsty[i],
color=color[i])
# # ax_0 = plt.subplot(gs[0,:])
# # ax_0.set_axis_off()
# cmp = mpl.colors.ListedColormap(used_colors)
# norm = mpl.colors.BoundaryNorm(boundaries=bn, ncolors=cmp.N)
# #fig.subplots_adjust(top=0.9)
#
# p0 = ax.get_position().get_points().flatten()
# # l, b, w = [0.15, 0.92, 0.7]
# # cax = fig.add_axes([0.15, 0.9, 0.2, 0.05])
# # cax = fig.add_axes([p0[0], 1, p0[2]-p0[0], 0.05])
# # cb_ax = mpl_toolkits.axes_grid1.inset_locator.inset_axes(ax, loc=3)
# cb =fig.colorbar(mappable=mpl.cm.ScalarMappable(norm=norm, cmap=cmp), use_gridspec=False,
# ax=ax, orientation='horizontal',shrink=1, fraction=0.1, pad=0.1)
if iax == 0:
if options.unitname.lower() == "mev":
ax.set_ylabel("Frequency (meV)", labelpad=10)
elif options.unitname.lower() == "thz":
ax.set_ylabel("Frequency (THz)", labelpad=10, fontsize=12)
else:
ax.set_ylabel("Frequency (cm${}^{-1}$)", labelpad=10)
else:
ax.set_yticklabels([])
ax.set_yticks([])
plt.axis([xmin_ax[iax], xmax_ax[iax], ymin, ymax])
ax.set_xticks(xticks_ax[iax])
ax.set_xticklabels(xticklabels_ax[iax])
ax.xaxis.grid(True, linestyle='-')
ax.tick_params(axis='y', direction='in', labelsize=12)
# ax.minorticks_on()
ax.tick_params(axis='both', direction='in', right=True, top=True)
def gen_metrics_grid():
grids = {}
g = GridSpec(2, 2, width_ratios=[1.8, 1], height_ratios=[1, 1])
grids['inst'] = g[0, 0:2]
grids['avg'] = g[1, 0]
grids['scatter'] = g[1, 1]
g.update(top=0.93, bottom=0.2, right=0.88, hspace=0.4, wspace=0.8)
return grids
def save_grid_images(images, file_name="grid_images.png"):
gs = GridSpec(3, 3)
gs.update(wspace=0.1, hspace=0.1)
for idx, image in enumerate(images):
plt.subplot(gs[idx])
plt.imshow(image[0], cmap='gray')
plt.axis('off')
plt.savefig(file_name)
def show_retrieval_indexing(images_retrieval, small_distances, k,
path_database, feature_extraction_method, distance,
folder_classes):
acc = accuracy(small_distances, folder_classes, k)
fig, ax = plt.subplots(len(images_retrieval),
k + 1,
sharex=True,
sharey=True)
gs1 = GridSpec(len(images_retrieval), k + 1)
gs1.update(wspace=0.025, hspace=0.5) # set the spacing between axes.
if len(images_retrieval) > 1:
cont = 0
for cont2, i in enumerate(images_retrieval):
ax[cont2, 0].imshow(i, cmap='gray', interpolation='none')
ax[cont2, 0].set_adjustable('box-forced')
ax[cont2, 0].set_yticks([])
ax[cont2, 0].set_xticks([])
ax[cont2, 0].set_ylabel(acc[cont2], fontsize=6)
cont += 1
#for each retrieval image returns the k nearer images
for j in range(k):
ax[cont2, j + 1].imshow(imread(small_distances[cont2][j]),
cmap='gray',
interpolation='none')
ax[cont2, j + 1].set_adjustable('box-forced')
ax[cont2, j + 1].set_yticks([])
ax[cont2, j + 1].set_xticks([])
shortName = small_distances[cont2][j]
shortName = shortName.split('/')[-1]
shortName = shortName[0:6]
ax[cont2, j + 1].set_title(shortName, fontsize=8)
cont += 1
else:
ax[0].imshow(images_retrieval[0], cmap='gray', interpolation='none')
ax[0].set_adjustable('box-forced')
ax[0].set_yticks([])
ax[0].set_xticks([])
ax[0].set_ylabel('Input ', fontsize=8)
#for each retrieval image returns the k nearer images
for j in range(k):
ax[j + 1].imshow(imread(small_distances[0][j]),
cmap='gray',
interpolation='none')
ax[j + 1].set_adjustable('box-forced')
ax[j + 1].set_yticks([])
ax[j + 1].set_xticks([])
shortName = fname_database[int(small_distances[0, j])]
shortName = shortName.split('/')[-1]
shortName = shortName[0:6]
ax[j + 1].set_title(shortName, fontsize=8)
fig.savefig(
path_database + "results/result" + "_" + feature_extraction_method +
"_" + distance + "_" + str(k) +
"_sorting.png") # save the figure to file # save the figure to file
plt.show()
def lsplom(X, ax_ref=None, title='', names=None):
assert type(X) == list
if ax_ref is None:
ax_ref = X
if names is None:
names = ['Ch.{}'.format(i) for i in range(len(X))]
def fix_axes(fig, ax_ref):
min = np.min([x.min() for x in ax_ref])
max = np.max([x.max() for x in ax_ref])
for i, ax in enumerate(fig.axes):
# ax.text(0, 0, "ax%d" % (i+1), va="center", ha="center")
ax.set_xlim([min, max])
ax.set_ylim([min, max])
# Hide the right and top spines
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.spines['bottom'].set_visible(False)
# Only show ticks on the left and bottom spines
ax.yaxis.set_ticks_position('left')
ax.xaxis.set_ticks_position('bottom')
for tl in ax.get_xticklabels() + ax.get_yticklabels():
# tl.set_visible(False)
pass
N = len(X)
f = plt.figure()
plt.suptitle(title, fontsize=18)
for n, x in enumerate(X):
features = x.shape[1]
gs = GridSpec(features, features)
gs.update(left=n / N + 0.05, right=(n + 1) / N, wspace=0.05)
for i, j in itertools.product(range(features), range(features)):
plt.subplot(gs[i, j])
if i > j:
plt.plot(x[:, j], x[:, i], '.')
if False:
plt.plot(x[0:2, j], x[0:2, i], 'r-', markersize=2)
plt.plot(x[1:3, j], x[1:3, i], 'g-', markersize=2)
plt.plot(x[2:4, j], x[2:4, i], 'k-', markersize=2)
# zero axis
plt.axhline(y=0, ls="--", c=".3")
plt.axvline(x=0, ls="--", c=".3")
elif i == j:
if i == 0:
plt.title(names[n], fontsize=22)
plt.text(0,
0,
'd.' + str(i),
horizontalalignment='center',
verticalalignment='center',
fontsize=18)
plt.axis('off')
else:
plt.axis('off')
fix_axes(f, ax_ref)
def display_tcks_with_mrview(self,
tcks,
backgrounds,
padding=1,
img_size=5,
offset=None):
"""
Displays dMRI tractography streamlines using MRtrix's mrview to
display and screenshot to file the streamlines. Then reload,
crop and combine the different slice orientations into
a single panel.
Parameters
----------
save_path : str | None
The path of the file to save the image at. If None the
images are displayed instead
size : Tuple(2)[int]
The size of the combined figure to plot
offset : Tuple(3)[int]
An array of integers with with to offset the slices displayed
"""
n_rows = len(tcks)
# Create figure in which to aggregate the plots
gs = GridSpec(n_rows, 3)
gs.update(wspace=0.0, hspace=0.0)
fig = plt.figure(figsize=(3 * img_size, n_rows * img_size))
# Create temp dir to store screen captures
tmpdir = tempfile.mkdtemp()
for i, (tck, bg) in enumerate(zip(tcks, backgrounds)):
# Call mrview to display the tracks, capture them to
# file and then reload the image into a matplotlib
# grid
options = ['-tractography.load', tck.path, '-noannotations']
if offset is not None:
array = bg.get_array()
centre = self.image_centre(array, offset)
options.extend(['-voxel', '{},{},{}'.format(*centre)])
# Set options to remove cursor, capture hte image and exit
options.extend(['-lock', 'yes', '-capture.grab', '-exit'])
imgs = []
for i in range(3):
sp.call('{} {} -plane {} {}'.format(self.mrview_path, bg.path,
2 - i, ' '.join(options)),
cwd=tmpdir,
shell=(self.mrview_path == 'mrview'))
img = matplotlib.image.imread(
op.join(tmpdir, 'screenshot0000.png'))
imgs.append(self.crop(img, border=padding))
padded_size = max(chain(*(a.shape for a in imgs)))
for i, img in enumerate(imgs):
img = self.pad_to_size(img, (padded_size, padded_size))
axis = fig.add_subplot(gs[i])
axis.get_xaxis().set_visible(False)
axis.get_yaxis().set_visible(False)
plt.imshow(img)
plt.tight_layout(0.0)
def generateTimeseriesPSCSnapViews(self,
out_dir,
nCols,
nRows,
title='',
basename='psc_img',
psc_min_max=PSC_MIN_MAX):
"""
Create a list (size Nt = N timepoints) of figures. Each figure contains the PSC volume corresponding to the
timepoint represented as Nk slices in a matrix-shape
:return:
"""
lf = []
for t in range(self.Nt):
out_graph_vol_fn = opj(
out_dir, '_'.join([basename, str(t).zfill(4)]) + '.png')
if not ope(out_graph_vol_fn):
# Create a figure
fig = plt.figure(figsize=(nCols, nRows))
gs = GridSpec(nRows, nCols)
gs.update(wspace=0.0,
hspace=0.0) # set the spacing between axes.
for i in range(nRows):
for j in range(nCols):
z = i * nCols + j
if z <= self.Nt:
im = self.f_psc_img[:, :, z, t].T
ax = plt.subplot(gs[i, j])
ims = ax.imshow(im,
vmin=-psc_min_max,
vmax=psc_min_max,
cmap='seismic')
ax.set_xticks([])
ax.set_yticks([])
ax.axis('off')
# for tissueName, bin_map, tcol in zip(TISSUE_NAMES, [self.gm_bin,self.wm_bin,self.csf_bin], TISSUE_COLORS):
# cmap1 = colors.LinearSegmentedColormap.from_list('my_cmap', [COL_TRANSP, tcol], 256)
# mask = bin_map[:,:,z].T
# ax.imshow(mask, cmap=cmap1, interpolation='none', alpha=.5)
plt.suptitle(title + ' vol {0}/{1}'.format(t + 1, self.Nt))
# Try to add colorbar at the bottom
fig.subplots_adjust(right=0.9)
cbar_ax = fig.add_axes([0.9, 0.25, 0.01,
0.5]) #left bottom width height
cbar = fig.colorbar(ims,
ticks=[-psc_min_max, 0, psc_min_max],
cax=cbar_ax)
cbar.ax.set_yticklabels([
'-{0}%'.format(psc_min_max), '0',
'+{0}%'.format(psc_min_max)
]) # vertically oriented colorbar
#cbar.set_label('Signal')
# Save
plt.savefig(out_graph_vol_fn)
lf.append(out_graph_vol_fn)
plt.close()
return lf
def firstPlot(self):
"""Set grid and axes position in the grid. Plot charts."""
gs = GridSpec(2, 2)
gs.update(wspace=0.25, hspace=0.5)
self.canvas.axes1 = self.canvas.figure.add_subplot(gs[0, 0])
self.canvas.axes2 = self.canvas.figure.add_subplot(gs[0, 1])
self.canvas.axes3 = self.canvas.figure.add_subplot(gs[1, :])
self.plotCharts()
plt.tight_layout()
def init_figure():
h = plt.figure(figsize=(8, 10))
gs = GridSpec(1, 3)
gs.update(wspace=0.25)
axr = plt.subplot(gs[0, 0:-1])
axr.grid(color='gray', linestyle='--', linewidth=0.4, axis='x')
axb = plt.subplot(gs[0, -1])
axb.grid(color='gray', linestyle='--', linewidth=0.4, axis='x')
return h, axr, axb
def make_figure(self, type):
self.fig.clf()
if type == 'gd':
pass
elif type == 'mc':
gs = GridSpec(1, 1)
gs.update(hspace=0.7, wspace=0.8)
self.splts = [self.fig.add_subplot(gs[int(i/3), int(i%3)]) for i in range(1*1)] # grid nxn
else:
pass
def gen_simple_grid():
""" Set a simple grid that only has instantaneous and filtered plots
without metrics calculation
"""
grids = {}
g = GridSpec(2, 1, height_ratios=[1, 1])
grids['inst'] = g[0, 0]
grids['avg'] = g[1, 0]
g.update(top=0.93, bottom=0.13, right=0.88, hspace=0.4, wspace=0.8)
return grids
def graph():
plt.switch_backend('TkAgg') #default on my system
print(('Backend: {}'.format(plt.get_backend())))
f = plt.figure(num=str(index) + '.' + prueba, figsize=(20, 15))
mng = plt._pylab_helpers.Gcf.figs.get(f.number, None)
mng = plt.get_current_fig_manager()
mng.resize(*mng.window.maxsize())
plt.title(str(index) + '.' + prueba)
gs1 = GridSpec(7, 1)
gs1.update(left=0.05, right=0.95, wspace=0.5, hspace=0.3, bottom=0.08)
ax1 = plt.subplot(gs1[0, :])
ax1.grid()
ax1.set_ylabel('Roll', fontsize=8)
L1 = ax1.plot(datos['time'], datos['roll'])
ax2 = plt.subplot(gs1[1, :])
ax2.grid()
ax2.set_ylabel('Pitch', fontsize=8)
L2 = ax2.plot(datos['time'], datos['pitch'])
ax3 = plt.subplot(gs1[2, :])
ax3.grid()
ax3.set_ylabel('Yaw', fontsize=8)
L3 = ax3.plot(datos['time'], datos['yaw'])
ax4 = plt.subplot(gs1[3, :])
ax4.grid()
ax4.set_ylabel('X', fontsize=8)
L4 = ax4.plot(datos['time'], datos['X'])
ax5 = plt.subplot(gs1[4, :])
ax5.grid()
ax5.set_ylabel('Y', fontsize=8)
L5 = ax5.plot(datos['time'], datos['Y'])
ax6 = plt.subplot(gs1[5, :])
ax6.grid()
ax6.set_ylabel('Y', fontsize=8)
L6 = ax6.plot(datos['time'], datos['Z'])
ax7 = plt.subplot(gs1[6, :])
ax7.grid()
ax7.set_ylabel('LED_TIME', fontsize=8)
L7 = ax7.plot(datos['time'], datos['ledblue'])
L8 = ax7.plot(datos['time'], datos['ledred'])
date = datetime.datetime.now()
name = (str(index) + '_' + prueba + str(date.day) + '-' + str(date.month) +
'-' + str(date.year) + '_' + str(date.hour) + ':' +
str(date.minute) + ':' + str(date.second) + '.png')
plt.savefig(name, bbox_inches='tight')
plt.show()
def plot_standard(corr="acorr"):
os.chdir(tables_dir)
ref = np.loadtxt("stars_lick_val_{0}.txt".format(corr)).T
obs = np.loadtxt("stars_lick_obs_{0}.txt".format(corr)).T
bands = np.loadtxt("bands_matching_standards.txt", usecols=(0), dtype=str).tolist()
bands2, units, error = np.loadtxt("bands.txt", usecols=(0,9,10), dtype=str).T
idx = [list(bands2).index(x) for x in bands]
idx2 = np.array([list(bands).index(x) for x in bands2])
error = error[idx]
units = units[idx]
units = [x.replace("Ang", "\AA") for x in units]
fig = plt.figure(1, figsize=(20,12))
gs = GridSpec(5,5)
gs.update(left=0.03, right=0.988, top=0.98, bottom=0.06, wspace=0.2,
hspace=0.4)
offsets, errs = [], []
for i in range(25):
ax = plt.subplot(gs[i])
plt.locator_params(axis="y", nbins=6)
plt.locator_params(axis="x", nbins=6)
ax.minorticks_on()
# ax.plot(obs[i], ref[i] - obs[i], "ok")
ax.axhline(y=0, ls="--", c="k")
diff = ref[i] - obs[i]
diff, c1, c2 = sigmaclip(diff[np.isfinite(diff)], 2.5, 2.5)
ax.hist(diff, bins=8, color="0.7", histtype='stepfilled')
ylim = plt.ylim()
xlim = plt.xlim()
xlim = np.max(np.abs(xlim))
ax.set_ylim(0, ylim[1] + 2)
ax.set_xlim(-xlim, xlim)
mean = np.nanmean(diff)
N = len(diff)
err = np.nanstd(diff) / np.sqrt(N)
lab = "${0:.2f}\pm{1:.2f}$".format(mean, err)
ax.axvline(x=mean, ls="-", c="r", label=lab)
ax.axvline(x=0, ls="--", c="k")
# ax.axhline(y=float(error[i]))
# ax.axhline(y=-float(error[i]))
# ax.set_xlabel("{0} ({1})".format(bands[i].replace("_", " "), units[i]))
ax.legend(loc=1,prop={'size':12})
ax.set_xlabel("$\Delta$ {0} ({1})".format(bands[i].replace("_", " "),
units[i]))
ax.set_ylabel("Frequency")
offsets.append(mean)
errs.append(err)
offsets = np.array(offsets)[idx2]
errs = np.array(errs)[idx2]
output = os.path.join(home, "plots/lick_stars_{0}.png".format(corr))
plt.savefig(output)
with open(os.path.join(tables_dir, "lick_offsets.txt"), "w") as f:
f.write("# Index Additive Correction\n")
np.savetxt(f, np.column_stack((np.array(bands)[idx2],offsets, errs)),
fmt="%s")
def _saveDataPlots(dataObjects):
for dataObject in dataObjects:
figure = plt.figure()
gs = GridSpec(2, 1, height_ratios=[3, 1])
gs.update(hspace=0.7)
dataObject.generatePlot(
[figure.add_subplot(gs[0]),
figure.add_subplot(gs[1])])
figure.savefig('temp/' + dataObject.texName + '.pdf')
figure.clear()
def kplot(curcode,startdatetime,show_log,title="none",ymarks=[]):
df='%Y-%m-%d %H:%M:%S'
dt=datetime.strptime(startdatetime,df)
# fig,ax = plt.subplots(nrows=3,ncols=1, figsize=(12,5),facecolor='#D3D3D3')
fig = plt.figure(figsize=(12,5),facecolor='#D3D3D3')
fig.suptitle(title)
gs1 = GridSpec(8, 8)
gs1.update(left=0.05, right=0.95, wspace=0.05)
ax1 = plt.subplot(gs1[0:5, :])
ax2 = plt.subplot(gs1[6:8, 0:3])
ax3 = plt.subplot(gs1[6:8, 4:8])
#day
ax2.set_title("days")
days_range=30
table=curcode+"_1day"
kdatas=kdb.query(table,(dt-timedelta(days=days_range)).strftime(df),(dt+timedelta(days=days_range)).strftime(df))
while len(kdatas) < 60:
days_range +=5
kdatas=kdb.query(table,(dt-timedelta(days=days_range)).strftime(df),(dt+timedelta(days=days_range)).strftime(df))
kaxplot(ax2,dt.replace(hour=0,minute=0,second=0),'%m-%d',kdatas,ymarks)
#hour
ax1.set_title("hours")
hours_range=60
table=curcode+"_1hour"
kdatas=kdb.query(table,(dt-timedelta(hours=hours_range)).strftime(df),(dt+timedelta(hours=hours_range)).strftime(df))
while len(kdatas) < 120:
hours_range +=10
kdatas=kdb.query(table,(dt-timedelta(hours=hours_range)).strftime(df),(dt+timedelta(hours=hours_range)).strftime(df))
kaxplot(ax1,dt.replace(minute=0,second=0),'%Y-%m-%d %H',kdatas,ymarks)
#min
ax3.set_title("minutes")
mins_range=50
table=curcode+"_1min"
kdatas=kdb.query(table,(dt-timedelta(minutes=mins_range)).strftime(df),(dt+timedelta(minutes=mins_range)).strftime(df))
while len(kdatas) < 100:
mins_range +=10
kdatas=kdb.query(table,(dt-timedelta(minutes=mins_range)).strftime(df),(dt+timedelta(minutes=mins_range)).strftime(df))
kaxplot(ax3,dt.replace(second=0),'%H:%M',kdatas,ymarks)
#show or log
if show_log == "show" :
plt.show()
else:
if not os.path.exists(show_log):
os.makedirs(show_log)
plt.savefig(show_log+startdatetime.replace(":","%")+".png")
plt.close('all')
def plot_series(data, order='co', fig=None, subplot_spec=None):
'''
Parameters
----------
data : ndarray
shape (26=ntask, nbin)
order : string, optional
one of 'co' or 'oc', for center-out or out-center data order
determines mapping of data to polygons
defaults to center-out
fig : matplotlib Figure instance
an existing figure to use, optional
subplotspec : matplotlib SubplotSpec instance, optional
an existing subplotspec to use, i.e. subset of a gridspec
'''
if not ((np.rank(data) == 2) & (data.shape[0] == 26)):
raise ValueError('data has wrong shape; should be (26, nbin),'
'actually is %s' % (str(data.shape)))
if order == 'co':
mapping = get_targ_co_dir_mapping()
elif order == 'oc':
mapping = get_targ_oc_dir_mapping()
else:
raise ValueError('`order` not recognized')
if (fig != None) & (not isinstance(fig, Figure)):
raise ValueError('`fig` must be an instance of Figure')
if (fig == None):
fig = plt.figure()
if (subplot_spec != None):
if not isinstance(subplot_spec, SubplotSpec):
raise ValueError('subplot_spec must be instance of '
'SubplotSpec')
ntask, nbin = data.shape
clim = (np.nanmin(data), np.nanmax(data))
if subplot_spec == None:
gs = GridSpec(nbin + 1,1, height_ratios=[1,] * nbin + [0.5,])
gs.update(left=0.02, right=0.98, top=0.98, bottom=0.05)
else:
gs = GridSpecFromSubplotSpec(\
nbin + 1,1, subplot_spec=subplot_spec, \
height_ratios=[1,] * nbin + [0.5,])
for i in xrange(nbin):
ax = fig.add_subplot(gs[i], projection='split_lambert')
plot_gem(data[:,i], order=order, ax=ax, clim=clim)
cbax = fig.add_subplot(gs[-1], aspect=.25)
cb = plt.colorbar(ax.collections[0], cbax, orientation='horizontal')
clim = cb.get_clim()
cb.set_ticks(clim)
cb.set_ticklabels(['%0.1f' % x for x in clim])
return fig
def plot(self, *args, **kwargs):
g_idx = self.myc['g_idx']
neuron_idx = self.myc['neuron_idx']
l, b, r, t = self.myc['bbox_rect']
fig = self._get_final_fig(self.myc['fig_size'])
gs = GridSpec(2, 2)
gs.update(left=l, right=r, bottom=b, top=t, hspace=0)
# E-->I outgoing
ax = fig.add_subplot(gs[0, 0])
self.plotOutgoing(g_idx, "E", neuron_idx, ax=ax, xlabel='', ylabel='',
use_title=False)
ax.set_xticks([])
# I-->E input
ax = fig.add_subplot(gs[0, 1])
self.plotIncoming(g_idx, "E", neuron_idx, ax=ax, ylabel='', xlabel='',
use_title=False)
ax.set_xticks([])
ax.set_yticks([])
# I-->E outgoing
ax = fig.add_subplot(gs[1, 0])
self.plotOutgoing(g_idx, "I", neuron_idx, ax=ax, use_title=False,
xlabel='', ylabel='')
# E-->I input
ax = fig.add_subplot(gs[1, 1])
self.plotIncoming(g_idx, "I", neuron_idx, ax=ax, xlabel='', ylabel='',
use_title=False)
ax.set_yticks([])
fname = self.get_fname("/connections_pcolor_grid.pdf")
plt.savefig(fname, dpi=300, transparent=True)
plt.close()
# Add an extra colorbar
fig = self._get_final_fig(self.myc['cbar_fig_size'])
ax_cbar = fig.add_axes([0.05, 0.80, 0.8, 0.15])
cbar = mpl.colorbar.ColorbarBase(ax_cbar, cmap=mpl.cm.jet,
norm=mpl.colors.Normalize(vmin=0,
vmax=1),
ticks=[0, 1],
orientation='horizontal')
ax_cbar.xaxis.set_ticklabels(['0', '$g_{E/I}$'])
fname_cbar = self.get_fname("/connections_pcolor_grid_colorbar.pdf")
plt.savefig(fname_cbar, dpi=300, transparent=True)
plt.close()
def __init__(self, window):
"""Initialize spectrogram canvas graphs."""
# Initialize variables to default values.
self.window = window
self.samples = 100 # Number of samples to store
self.fftSize = 256 # Initial FFT size just to render something in the charts
self.sampleRate = 0
self.binFreq = 0
self.binCount = self.fftSize/2
self.graphUpdateHz = 10 # Update rate of the animation
self.coloredBin = None
self.magnitudes = np.zeros((self.samples, self.binCount))
# Tell numpy to ignore errors like taking the log of 0
np.seterr(all='ignore')
# Set up figure to hold plots
self.figure = Figure(figsize=(1024,768), dpi=72, facecolor=(1,1,1), edgecolor=(0,0,0))
# Set up 2x1 grid to hold initial plots
gs = GridSpec(2, 1, height_ratios=[1,2], width_ratios=[1])
gs.update(left=0.075, right=0.925, bottom=0.05, top=0.95, wspace=0.05)
# Set up frequency histogram bar plot
self.histAx = self.figure.add_subplot(gs[0])
self.histAx.set_title('Frequency Histogram')
self.histAx.set_ylabel('Intensity (decibels)')
self.histAx.set_xlabel('Frequency Bin (hz)')
self.histAx.set_xticks([])
self.histPlot = self.histAx.bar(np.arange(self.binCount), np.zeros(self.binCount), width=1.0, linewidth=0.0, facecolor='blue')
# Set up spectrogram waterfall plot
self.spectAx = self.figure.add_subplot(gs[1])
self.spectAx.set_title('Spectrogram')
self.spectAx.set_ylabel('Sample Age (seconds)')
self.spectAx.set_xlabel('Frequency Bin (hz)')
self.spectAx.set_xticks([])
self.spectPlot = self.spectAx.imshow(self.magnitudes, aspect='auto', cmap=get_cmap('jet'))
# Add formatter to translate position to age in seconds
self.spectAx.yaxis.set_major_formatter(FuncFormatter(lambda x, pos: '%d' % (x*(1.0/self.graphUpdateHz))))
# Set up spectrogram color bar
#cbAx = self.figure.add_subplot(gs[3])
#self.figure.colorbar(self.spectPlot, cax=cbAx, use_gridspec=True, format=FuncFormatter(lambda x, pos: '%d' % (x*100.0)))
#cbAx.set_ylabel('Intensity (decibels)')
# Initialize canvas
super(SpectrogramCanvas, self).__init__(self.figure)
# Hook up mouse and animation events
self.mpl_connect('motion_notify_event', self._mouseMove)
self.ani = FuncAnimation(self.figure, self._update, interval=1000.0/self.graphUpdateHz, blit=False)
def test_lector():
os.chdir(os.path.join(home, "MILES"))
bands = os.path.join(tables_dir, "bands.txt")
filename = "lector_tmputH9bu.list_LINE"
stars = np.loadtxt(filename, usecols=(0,),
dtype=str)
ref = np.loadtxt(filename,
usecols=(2,3,4,5,6,7,8,9,14,15,16,17,18,24,25,26,
27,28,29,30,31,32,33,34,35))
obs = []
from lick import Lick
for i, star in enumerate(stars):
print star + ".fits"
spec = pf.getdata(star + ".fits")
h = pf.getheader(star + ".fits")
w = h["CRVAL1"] + h["CDELT1"] * \
(np.arange(h["NAXIS1"]) + 1 - h["CRPIX1"])
lick, tmp = lector.lector(w, spec, np.ones_like(w), bands,
interp_kind="linear")
ll = Lick(w, spec, np.loadtxt(bands, usecols=(2,3,4,5,6,7,)))
obs.append(ll.classic)
obs = np.array(obs)
fig = plt.figure(1, figsize=(20,12))
gs = GridSpec(5,5)
gs.update(left=0.08, right=0.98, top=0.98, bottom=0.06, wspace=0.25,
hspace=0.4)
obs = obs.T
ref = ref.T
names = np.loadtxt(bands, usecols=(0,), dtype=str)
units = np.loadtxt(bands, usecols=(9,), dtype=str).tolist()
# units = [x.replace("Ang", "\AA") for x in units]
for i in range(25):
ax = plt.subplot(gs[i])
plt.locator_params(axis="x", nbins=6)
ax.minorticks_on()
ax.plot(obs[i], (obs[i] - ref[i]) / ref[i], "o", color="0.5")
ax.axhline(y=0, ls="--", c="k")
lab = "median $= {0:.3f}$".format(
np.nanmedian(obs[i] - ref[i])).replace("-0.00", "0.00")
ax.axhline(y=np.nanmedian(obs[i] - ref[i]), ls="--", c="r", label=lab)
ax.set_xlabel("{0} ({1})".format(names[i].replace("_", " "), units[i]))
ax.legend(loc=1,prop={'size':15})
ax.set_ylim(-0.01, 0.01)
fig.text(0.02, 0.5, 'I$_{{\\rm pylector}}$ - I$_{{\\rm lector}}$', va='center',
rotation='vertical', size=40)
output = os.path.join(home, "plots/test_lector.png")
plt.show()
plt.savefig(output)
def make_split(ratio, gap=0.12):
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.ticker import MaxNLocator
cax = plt.gca()
box = cax.get_position()
xmin, ymin = box.xmin, box.ymin
xmax, ymax = box.xmax, box.ymax
gs = GridSpec(2, 1, height_ratios=[ratio, 1 - ratio], left=xmin, right=xmax, bottom=ymin, top=ymax)
gs.update(hspace=gap)
ax = plt.subplot(gs[0])
plt.setp(ax.get_xticklabels(), visible=False)
bx = plt.subplot(gs[1], sharex=ax)
return ax, bx
def test_blank_subplots():
fig = plt.figure()
gs = GridSpec(4, 6)
ax1 = fig.add_subplot(gs[0,1])
ax1.plot(D['x1'], D['y1'])
fig.add_subplot(gs[1,1])
fig.add_subplot(gs[2:,1])
fig.add_subplot(gs[0,2:])
fig.add_subplot(gs[1:3, 2:4])
fig.add_subplot(gs[3, 2:5])
fig.add_subplot(gs[1:3,4:])
fig.add_subplot(gs[3,5])
gs.update(hspace=.6, wspace=.6)
renderer = run_fig(fig)
equivalent, msg = compare_dict(renderer.layout, BLANK_SUBPLOTS['layout'])
assert equivalent, msg
def plot_confound(tseries,
figsize,
name,
units=None,
series_tr=None,
normalize=False):
"""
A helper function to plot :abbr:`fMRI (functional MRI)` confounds.
"""
import matplotlib
matplotlib.use(config.get('execution', 'matplotlib_backend'))
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.backends.backend_pdf import FigureCanvasPdf as FigureCanvas
import seaborn as sns
fig = plt.Figure(figsize=figsize)
FigureCanvas(fig)
grid = GridSpec(1, 2, width_ratios=[3, 1], wspace=0.025)
grid.update(hspace=1.0, right=0.95, left=0.1, bottom=0.2)
ax = fig.add_subplot(grid[0, :-1])
if normalize and series_tr is not None:
tseries /= series_tr
ax.plot(tseries)
ax.set_xlim((0, len(tseries)))
ylabel = name
if units is not None:
ylabel += (' speed [{}/s]' if normalize else ' [{}]').format(units)
ax.set_ylabel(ylabel)
xlabel = 'Frame #'
if series_tr is not None:
xlabel = 'Frame # ({} sec TR)'.format(series_tr)
ax.set_xlabel(xlabel)
ylim = ax.get_ylim()
ax = fig.add_subplot(grid[0, -1])
sns.distplot(tseries, vertical=True, ax=ax)
ax.set_xlabel('Frames')
ax.set_ylim(ylim)
ax.set_yticklabels([])
return fig
def myShow(X, Y, Z, xs = None, xs2 = None, xlabel = None, xlabel2=None, xdot=None, ydot=None, title = None):
gs = GridSpec(1, 1)
gs.update(top = 0.95, bottom = 0.02,left=0.02, right=0.98, hspace=0.2,wspace=0.05)
ax = plt.subplot(gs[0, 0])
m = 30
V = np.array(range(10))**2 * np.sqrt(Z.max() - Z.min()) / np.float(m - 1) + Z.min()
ax.contourf(X, Y, Z, V, alpha=.75, cmap=cm.RdBu)
C = ax.contour(X, Y, Z, V, colors='black', linewidth=.3, alpha=0.5)
# put the axes in the centre
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
# put white boxes around the labels
for label in ax.get_xticklabels() + ax.get_yticklabels():
label.set_fontsize(10)
label.set_bbox(dict(facecolor='white', edgecolor='None', alpha=0.35 ))
if xdot != None and ydot != None :
ax.plot([xdot,xdot],[ydot,ydot], marker='o', color='black')
if xs != None:
x = []
y = []
for xx,yy in xs:
x.append(xx)
y.append(yy)
ax.plot(x, y, label=xlabel)
if xs2 != None:
x = []
y = []
for xx,yy in xs2:
x.append(xx)
y.append(yy)
ax.plot(x, y, label=xlabel2)
if xlabel != None:
ax.legend(loc='upper left')
if title !=None:
ax.set_title(title, fontsize=18, position=(0.5, 1.01))
fig = plt.gcf()
fig.set_size_inches(10, 5)
def gridspec_demo():
"""If you need even more flexibility with subplots (for example, a 2x2
figure with only 3 subplots, where one subplot spans two rows), use
GridSpec. We won't go into a lot of details here, but it will allow you to
create plots like the one produced by this function.
For more details and documentation, see:
http://matplotlib.sourceforge.net/users/gridspec.html
"""
# Import GridSpec
from matplotlib.gridspec import GridSpec
# Create a new figure
fig = plt.figure()
# First grid specification -- a 3x3 plot with only three subplots
gs1 = GridSpec(3, 3)
gs1.update(left=0.05, right=0.48, wspace=0.05)
ax1 = plt.subplot(gs1[:-1, :])
ax2 = plt.subplot(gs1[-1, :-1])
ax3 = plt.subplot(gs1[-1, -1])
# A different grid specification on the same figure. This essentially
# expands the figure to be 6x3 by explicitly setting the location of the
# GridSpec (with gs2.update).
gs2 = GridSpec(3, 3)
gs2.update(left=0.55, right=0.98, hspace=0.05)
ax4 = plt.subplot(gs2[:, :-1])
ax5 = plt.subplot(gs2[:-1, -1])
ax6 = plt.subplot(gs2[-1, -1])
# Remove tick labels and print the name of the axes for each set of axes
for i, ax in enumerate(fig.axes):
ax.text(0.5, 0.5, "ax%d" % (i+1), va="center", ha="center")
for tl in ax.get_xticklabels() + ax.get_yticklabels():
tl.set_visible(False)
# Set overall plot title
plt.suptitle("GridSpec w/ different subplotpars", fontsize=titlesize)
def _plotStats(self, df, strategyName):
"""
绘制账户盈亏统计图
"""
def _dateFormatter(x, pos):
if not (0 <= int(x) < df.shape[0]):
return None
return df.index[int(x)].strftime("%y-%m-%d")
# create grid spec
gs = GridSpec(4, 1)
gs.update(hspace=0)
# subplot for PnL
axPnl = plt.subplot(gs[:-1, :])
axPnl.grid(True)
axPnl.set_title('{}: 盈亏(%)'.format(strategyName))
# set x ticks
x = [x for x in range(df.shape[0])]
xspace = max((len(x)+9)//10, 1)
axPnl.xaxis.set_major_locator(FixedLocator(x[:-xspace-1: xspace] + x[-1:]))
axPnl.xaxis.set_major_formatter(FuncFormatter(_dateFormatter))
# plot pnl
for name in df.columns:
if name not in ['持仓资金(%)', '持仓股票数']:
axPnl.plot(x, df[name].values, label=name)
axPnl.legend(loc='upper left', frameon=False)
# subplot for position
axPos = plt.subplot(gs[-1, :], sharex=axPnl)
axPos.grid(True)
axPos.bar(x, df['持仓资金(%)'].values, label='持仓资金(%)')
axPos.plot(x, df['持仓资金(%)'].values.cumsum()/np.array(list(range(1, df.shape[0] + 1))), label='平均持仓资金(%)', color='g')
axPos.plot(x, df['持仓股票数'].values, label='持仓股票数', color='r')
axPos.legend(loc='upper left', frameon=False)
def plot_both_directions(data, co, fig=None):
'''
Parameters
----------
data : ndarray
shape (52=ntask, nbin)
co : ndarray
shape (52,), dtype bool, array of which tasks are center-out
fig : matplotlib Figure instance
an existing figure to use, optional
'''
if not ((np.rank(data) == 2) & (data.shape[0] == 52)):
raise ValueError('data has wrong shape; should be (52, nbin),'
'actually is %s' % (str(data.shape)))
if (fig != None) & (not isinstance(fig, Figure)):
raise ValueError('`fig` must be an instance of Figure')
if (fig == None):
fig = plt.figure()
gs = GridSpec(1,2)
gs.update(left=0.02, right=0.98, top=0.98, bottom=0.05, hspace=0.02)
plot_series(data[co], order='co', fig=fig, subplot_spec=gs[0])
plot_series(data[~co], order='oc', fig=fig, subplot_spec=gs[1])
def plot_ebands_with_doses(self, ebands_kpath, doses, ylims=None, **kwargs):
"""
Plot band structure and doses
Args:
ebands_kpath:
doses:
ylims: Set the data limits for the x-axis in eV. Accept tuple e.g. ``(left, right)``
or scalar e.g. ``left``. If left (right) is None, default values are used
Return: |matplotlib-Figure|
"""
# Build grid plot.
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
fig = plt.figure()
ncols = 3
width_ratios = [2, 0.2, 0.2]
gspec = GridSpec(1, ncols, width_ratios=width_ratios)
gspec.update(wspace=0.05)
ax_ebands = plt.subplot(gspec[0])
ax_doses = []
for i in range(2):
ax = plt.subplot(gspec[i + 1], sharey=ax_ebands)
ax_doses.append(ax)
ax.grid(True)
set_axlims(ax, ylims, "y")
# Plot electron bands.
ebands_kpath.plot(ax=ax_ebands, ylims=ylims, show=False)
# Plot DOSes.
#doses.edos.plot
#vdos.edos.plot
#ax.set_ylabel("")
return fig
def test_blank_subplots():
fig = plt.figure()
gs = GridSpec(4, 6)
ax1 = fig.add_subplot(gs[0, 1])
ax1.plot(D['x1'], D['y1'])
fig.add_subplot(gs[1, 1])
fig.add_subplot(gs[2:, 1])
fig.add_subplot(gs[0, 2:])
fig.add_subplot(gs[1:3, 2:4])
fig.add_subplot(gs[3, 2:5])
fig.add_subplot(gs[1:3, 4:])
fig.add_subplot(gs[3, 5])
gs.update(hspace=.6, wspace=.6)
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, BLANK_SUBPLOTS['data'][data_no],
ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
BLANK_SUBPLOTS['layout'])
assert equivalent, msg
def initialize_figure(start_hour, stop_hour):
# f = plt.figure(figsize=(70, 20))
# f = plt.figure(figsize=(40, 15))
# proc = 10 / 100.0
# f = plt.figure(figsize=(40-40*proc, 15-15*proc))
f = plt.figure(figsize=(26, 15))
font_1 = font_0.copy()
font_1.set_size('20')
font_1.set_weight('bold')
plt.suptitle(u"Dynamika zmian asymetrii rytmu serca w wykresach mini-Poincaré w 24-godzinnym nagraniu",
fontproperties=font_1, y=0.995, fontsize=25)
empty_ratio = 0.2
height_ratios = [empty_ratio,
3-2.5*empty_ratio, # 1 24-tachogram
1.5*empty_ratio,
0.8, # 2 arrows
#0.1, # label for poincare windows
0.1, # label for poincare windows
#3, # 3 poincare plot windows
2.5, # 3 poincare plot windows
0.001, # empty plot
0.499, # data row
]
num_rows = len(height_ratios)
num_cols = len(png_files)
width_ratios = [1] * num_cols
row_number = 0
gs1 = GridSpec(num_rows, num_cols, height_ratios=height_ratios, width_ratios=width_ratios)
gs1.update(left=0.04, right=0.99, wspace=0.0, hspace=0.0, bottom=0.04, top=0.98)
return f, gs1
def plot_energy():
'''
x axis: buffer manager
y axis: disk status
'''
active_l = []
idle_l = []
standby_l = []
spinup_l = []
spindown_l = []
x_ticks = []
for sr in sort_sim_results(_sim_results.values()):
x_ticks.append(sr.get_x_tick_label())
ene_val = sr.energy.get_energy_value_list()
active_l.append(float(ene_val[0]))
idle_l.append(float(ene_val[1]))
standby_l.append(float(ene_val[2]))
spinup_l.append(float(ene_val[3]))
spindown_l.append(float(ene_val[4]))
width = 0.50
ind = np.arange(len(x_ticks))
ind = ind + 0.5 - width / 2
bottoms = np.array([0 for i in range(len(x_ticks))])
# clear figure
plt.clf()
# setting layout
gs = GridSpec(1,1)
gs.update(left=0.15, right=0.80)
ax = plt.subplot(gs[:])
p_active = plt.bar(ind, active_l, width, color='r', label='active', axes=ax)
bottoms = bottoms + active_l
p_idle = plt.bar(ind, idle_l, width, color='g', bottom=bottoms, label='idle', axes=ax)
bottoms = bottoms + idle_l
p_standby = plt.bar(ind, standby_l, width, color='b', bottom=bottoms, label='standby', axes=ax)
bottoms = bottoms + standby_l
p_spindown = plt.bar(ind, spindown_l, width, color='c', bottom=bottoms, label='spindown', axes=ax)
bottoms = bottoms + spindown_l
p_spinup = plt.bar(ind, spinup_l, width, color='m', bottom=bottoms, label='spinup', axes=ax)
# labels setting
plt.ylabel('Energy Consumption [joule]', size=14)
plt.yticks(size=16)
plt.xticks(ind + width / 2, x_ticks)
# title setting
plt.title('Replevel=%s, CMA=%s, CMF=%s\n%s'
% (_sim_results.values()[0].replicalevel,
_sim_results.values()[0].memoryassignor,
_sim_results.values()[0].memoryfactory,
_sim_results.values()[0].get_workload_param_text()
),
size=16
)
# legend setting
plt.legend(
(p_spinup[0], p_spindown[0], p_standby[0], p_idle[0], p_active[0]),
('spinup', 'spindown', 'standby', 'idle', 'active'),
bbox_to_anchor=(1, 1),
borderaxespad=0.0,
loc='upper left',
)
# set x ticks to the scientific notation
plt.gca().ticklabel_format(style="sci", scilimits=(0,0), axis="y", size=16)
# plt.show()
save_figure(plt, 'energy', _output_dir)
def drawBumpExamples(dataSpace, spaceRect, iterList, gsCoords, types, **kw):
'''Draw a grid-like plot of bump attractor (network activity) examples.
.. todo::
code duplication
'''
# kw processing
trialNum = kw.pop('trialNum', 0)
exIdx = kw.pop('exIdx', (0, 0))
xlabel = kw.pop('xlabel', True)
ylabel = kw.pop('ylabel', True)
xlabelPos = kw.pop('xlabelPos', -0.2)
ylabelPos = kw.pop('ylabelPos', -0.2)
xlabel2 = kw.pop('xlabel2', True)
ylabel2 = kw.pop('ylabel2', True)
xlabel2Pos = kw.pop('xlabel2os', -0.6)
ylabel2Pos = kw.pop('ylabel2os', -0.6)
fontSize = kw.pop('fontSize', 'medium')
fig = kw.pop('fig', plt.gcf())
# + plotBump() kwargs
kw['rasterized'] = kw.pop('rasterized', True)
kw['vmin'] = kw.get('vmin', 0)
left = spaceRect[0]
bottom = spaceRect[1]
right = spaceRect[2]
top = spaceRect[3]
exRow, exCol = exIdx
bumps, wi, we = aggr.aggregateType(dataSpace, iterList, types, trialNum+1,
ignoreNaNs=False, normalizeTicks=False)
scaleBar = None
exRows = top - bottom + 1
exCols = right - left + 1
gs = GridSpec(exRows, exCols)
gsLeft = gsCoords[0]
gsBottom = gsCoords[1]
gsRight = gsCoords[2]
gsTop = gsCoords[3]
gs.update(left=gsLeft, bottom=gsBottom, right=gsRight, top=gsTop)
ax = None
for r in range(bottom, top+1):
for c in range(left, right+1):
print(r, c)
bump = bumps[r][c][trialNum]
if (not isinstance(bump, np.ndarray)):
continue
gsRow = top - r
gsCol = c - left
ax = fig.add_subplot(gs[gsRow, gsCol])
plotBump(ax, bump, **kw)
if (ylabel and gsCol == 0):
label = "{0:.2f}".format(we[r][c])
ax.text(ylabelPos, 0.5, label, rotation=90,
transform=ax.transAxes, va='center', ha='right',
fontsize=fontSize)
if (xlabel and gsRow == exRows - 1):
label = "{0:.2f}".format(wi[r][c])
ax.text(0.5, xlabelPos, label, transform=ax.transAxes,
va='top', ha='center', fontsize=fontSize)
# Second Y label
if (ylabel2 and r-bottom == 0 and c-left == 0):
trans = transforms.blended_transform_factory(ax.transAxes,
plt.gcf().transFigure)
weTxt_y = gsBottom + (gsTop - gsBottom)/2.0
ax.text(ylabel2Pos, weTxt_y, ylabelText, transform=trans,
va='center', ha='right', rotation=90,
fontsize=fontSize)
# Second X label
if (xlabel2 and r - bottom == 0):
trans = transforms.blended_transform_factory(plt.gcf().transFigure,
ax.transAxes)
wiTxt_x = gsLeft + (gsRight - gsLeft)/2.0
ax.text(wiTxt_x, xlabel2Pos, xlabelText, transform=trans, va='top',
ha='center', fontsize=fontSize)
return gs
def specboxdblwide(Data, Labels):
"""
Plot several Raman spectra in individual boxes for comparison.
The bottom box has an attached box for an additional spectral window.
"""
from matplotlib.gridspec import GridSpec
# _, ColorScheme = colordef(Labels)
ColorScheme = ['DarkOrange', 'CornflowerBlue', 'OliveDrab']
xx = Data[:,0].reshape((Data.shape[0],1))
yy = Data[:,1:]
nPlots = len(Labels)
SpecPerPlot = int(yy.shape[1]/nPlots)
# Data for final double-wide spectrum
DataEnd = np.loadtxt('AuNPCHIR.csv', delimiter=',', skiprows=1)
Labels.append('CHIR-090')
xEnd = DataEnd[:,0].reshape((DataEnd.shape[0],1))
yEnd = DataEnd[:,1:]
plt.rc('font', family = 'Arial', size='14')
# Setup grid for all plots and create plots except for last box and plot
fig = plt.figure(figsize=(7,9))
gs = GridSpec(nPlots+1,5)
gs.update(left=0.10, right=0.95, top=0.99, bottom=0.08, hspace=0, wspace=0)
for i in range(nPlots):
ax = plt.subplot(gs[i,:-1])
for j in range(SpecPerPlot):
ax.plot(xx,yy[:,SpecPerPlot*i+j],c=ColorScheme[j])
ax.set_yticks(np.arange(0.2, 1.2, 0.2))
ax.set_yticklabels([1],visible=False)
ax.set_xticklabels([1],visible=False)
ax.set_title(Labels[i],ha='left',x=0.05,y=0.8)
ax.set_ylim(0,1.1)
# Last box has double-wide plot
axEndLeft = plt.subplot(gs[-1,:-1])
axEndRight = plt.subplot(gs[-1,-1])
for j in range(SpecPerPlot):
axEndLeft.plot(xEnd,yEnd[:,j],c=ColorScheme[j])
axEndRight.plot(xEnd,yEnd[:,j]*4,c=ColorScheme[j])
axEndLeft.set_xlim(200,2000)
axEndLeft.set_yticklabels([1],visible=False)
axEndLeft.set_title(Labels[-1],ha='left',x=0.05,y=0.8)
axEndLeft.set_xlabel(r'Wavenumber ($\mathregular{cm}^{-1}$)')
axEndLeft.set_ylim(0,1.1)
axEndRight.set_xlim(2000,2400)
axEndRight.set_xticks([2000,2200,2400])
axEndRight.set_yticklabels([1],visible=False)
axEndRight.set_title('(4x)',ha='right',x=0.85,y=0.8)
axEndRight.set_ylim(0,1.1)
fig.text(0.05,0.5,'Normalized Intensity (a.u.)',rotation=90,ha='center',va='center')
plt.show()
from matplotlib.gridspec import GridSpec
def make_ticklabels_invisible(fig):
for i, ax in enumerate(fig.axes):
ax.text(0.5, 0.5, "ax%d" % (i+1), va="center", ha="center")
ax.tick_params(labelbottom=False, labelleft=False)
# demo 3 : gridspec with subplotpars set.
fig = plt.figure()
fig.suptitle("GridSpec w/ different subplotpars")
gs1 = GridSpec(3, 3)
gs1.update(left=0.05, right=0.48, wspace=0.05)
ax1 = plt.subplot(gs1[:-1, :])
ax2 = plt.subplot(gs1[-1, :-1])
ax3 = plt.subplot(gs1[-1, -1])
gs2 = GridSpec(3, 3)
gs2.update(left=0.55, right=0.98, hspace=0.05)
ax4 = plt.subplot(gs2[:, :-1])
ax5 = plt.subplot(gs2[:-1, -1])
ax6 = plt.subplot(gs2[-1, -1])
make_ticklabels_invisible(fig)
plt.show()
def main(fname, lines=False, model=False, telluric=False, sun=False,
rv=False, rv1=False, rv2=False, ccf='none', ftype='1D',
fitsext='0', order='77'):
"""Plot a fits file with extensive options
:fname: Input spectra
:lines: Absorption lines
:model: Model spectrum
:telluric: Telluric spectrum
:sun: Solar spectrum
:rv: RV of input spectrum
:rv1: RV of Solar/model spectrum
:rv2: RV of telluric spectrum
:ccf: Calculate CCF (sun, model, telluric, both)
:ftype: Type of fits file (1D, CRIRES, GIANO)
:fitsext: Slecet fits extention to use (0,1,2,3,4)
:returns: RV if CCF have been calculated
"""
print('\n-----------------------------------')
path = os.path.expanduser('~/.plotfits/')
pathsun = os.path.join(path, 'solarspectrum_01.fits')
pathtel = os.path.join(path, 'telluric_NIR.fits')
pathwave = os.path.join(path, 'WAVE_PHOENIX-ACES-AGSS-COND-2011.fits')
pathGIANO = os.path.join(path, 'wavelength_GIANO.dat')
if os.path.isdir(path):
if sun and (not os.path.isfile(pathsun)):
print('Downloading solar spectrum...')
_download_spec(pathsun)
if telluric and (not os.path.isfile(pathtel)):
print('Downloading telluric spectrum...')
_download_spec(pathtel)
if model and (not os.path.isfile(pathwave)):
print('Downloading wavelength vector for model...')
url = 'ftp://phoenix.astro.physik.uni-goettingen.de/HiResFITS//WAVE_PHOENIX-ACES-AGSS-COND-2011.fits'
urllib.urlretrieve(url, pathwave)
else:
os.mkdir(path)
print('%s Created' % path)
print('Downloading solar spectrum...')
_download_spec(pathsun)
print('Downloading telluric spectrum...')
_download_spec(pathtel)
fitsext = int(fitsext)
order = int(order)
if ftype == '1D':
I = fits.getdata(fname, fitsext)
hdr = fits.getheader(fname, fitsext)
w = get_wavelength(hdr)
elif ftype == 'CRIRES':
d = fits.getdata(fname, fitsext)
hdr = fits.getheader(fname, fitsext)
try:
I = d['Extracted_OPT'] # Gasgano reduction
except:
I = d['Extracted_DRACS'] # Dracs reduction
w = d['Wavelength']*10
elif ftype == 'GIANO':
d = fits.getdata(fname)
I = d[order - 32] # 32 is the first order
wd = np.loadtxt(pathGIANO)
w1, w2 = wd[wd[:, 0] == order][0][1:]
w = np.linspace(w1, w2, len(I))
I /= np.median(I)
# Normalization (use first 50 points below 1.2 as constant continuum)
maxes = I[(I < 1.2)].argsort()[-50:][::-1]
I /= np.median(I[maxes])
dw = 10 # Some extra coverage for RV shifts
if rv:
I, w = dopplerShift(wvl=w, flux=I, v=rv, fill_value=0.95)
w0, w1 = w[0] - dw, w[-1] + dw
if sun and not model:
I_sun = fits.getdata(pathsun)
hdr = fits.getheader(pathsun)
w_sun = get_wavelength(hdr)
i = (w_sun > w0) & (w_sun < w1)
w_sun = w_sun[i]
I_sun = I_sun[i]
if len(w_sun) > 0:
I_sun /= np.median(I_sun)
if ccf in ['sun', 'both'] and rv1:
print('Warning: RV set for Sun. Calculate RV with CCF')
if rv1 and ccf not in ['sun', 'both']:
I_sun, w_sun = dopplerShift(wvl=w_sun, flux=I_sun, v=rv1, fill_value=0.95)
else:
print('Warning: Solar spectrum not available in wavelength range.')
sun = False
elif sun and model:
print('Warning: Both solar spectrum and a model spectrum are selected. Using model spectrum.')
sun = False
if model:
I_mod = fits.getdata(model)
hdr = fits.getheader(model)
if 'WAVE' in hdr.keys():
w_mod = fits.getdata(pathwave)
else:
w_mod = get_wavelength(hdr)
nre = nrefrac(w_mod) # Correction for vacuum to air (ground based)
w_mod = w_mod / (1 + 1e-6 * nre)
i = (w_mod > w0) & (w_mod < w1)
w_mod = w_mod[i]
I_mod = I_mod[i]
if len(w_mod) > 0:
# https://phoenix.ens-lyon.fr/Grids/FORMAT
# I_mod = 10 ** (I_mod-8.0)
I_mod /= np.median(I_mod)
# Normalization (use first 50 points below 1.2 as continuum)
maxes = I_mod[(I_mod < 1.2)].argsort()[-50:][::-1]
I_mod /= np.median(I_mod[maxes])
if ccf in ['model', 'both'] and rv1:
print('Warning: RV set for model. Calculate RV with CCF')
if rv1 and ccf not in ['model', 'both']:
I_mod, w_mod = dopplerShift(wvl=w_mod, flux=I_mod, v=rv1, fill_value=0.95)
else:
print('Warning: Model spectrum not available in wavelength range.')
model = False
if telluric:
I_tel = fits.getdata(pathtel)
hdr = fits.getheader(pathtel)
w_tel = get_wavelength(hdr)
i = (w_tel > w0) & (w_tel < w1)
w_tel = w_tel[i]
I_tel = I_tel[i]
if len(w_tel) > 0:
I_tel /= np.median(I_tel)
if ccf in ['telluric', 'both'] and rv2:
print('Warning: RV set for telluric, Calculate RV with CCF')
if rv2 and ccf not in ['telluric', 'both']:
I_tel, w_tel = dopplerShift(wvl=w_tel, flux=I_tel, v=rv2, fill_value=0.95)
else:
print('Warning: Telluric spectrum not available in wavelength range.')
telluric = False
rvs = {}
if ccf != 'none':
if ccf in ['sun', 'both'] and sun:
# remove tellurics from the Solar spectrum
if telluric and sun:
print('Correcting solar spectrum for tellurics...')
I_sun = I_sun / I_tel
print('Calculating CCF for the Sun...')
rv1, r_sun, c_sun, x_sun, y_sun = ccf_astro((w, -I + 1), (w_sun, -I_sun + 1))
if rv1 != 0:
print('Shifting solar spectrum...')
I_sun, w_sun = dopplerShift(w_sun, I_sun, v=rv1, fill_value=0.95)
rvs['sun'] = rv1
print('DONE')
if ccf in ['model', 'both'] and model:
print('Calculating CCF for the model...')
rv1, r_mod, c_mod, x_mod, y_mod = ccf_astro((w, -I + 1), (w_mod, -I_mod + 1))
if rv1 != 0:
print('Shifting model spectrum...')
I_mod, w_mod = dopplerShift(w_mod, I_mod, v=rv1, fill_value=0.95)
rvs['model'] = rv1
print('DONE')
if ccf in ['telluric', 'both'] and telluric:
print('Calculating CCF for the model...')
rv2, r_tel, c_tel, x_tel, y_tel = ccf_astro((w, -I + 1), (w_tel, -I_tel + 1))
if rv2 != 0:
print('Shifting telluric spectrum...')
I_tel, w_tel = dopplerShift(w_tel, I_tel, v=rv2, fill_value=0.95)
rvs['telluric'] = rv2
print('DONE')
if len(rvs) == 0:
ccf = 'none'
if ccf != 'none':
from matplotlib.gridspec import GridSpec
fig = plt.figure(figsize=(16, 5))
gs = GridSpec(1, 5)
if len(rvs) == 1:
gs.update(wspace=0.25, hspace=0.35, left=0.05, right=0.99)
ax1 = plt.subplot(gs[:, 0:-1])
ax2 = plt.subplot(gs[:, -1])
ax2.set_yticklabels([])
elif len(rvs) == 2:
gs.update(wspace=0.25, hspace=0.35, left=0.01, right=0.99)
ax1 = plt.subplot(gs[:, 1:4])
ax2 = plt.subplot(gs[:, 0])
ax3 = plt.subplot(gs[:, -1])
ax2.set_yticklabels([])
ax3.set_yticklabels([])
else:
fig = plt.figure(figsize=(16, 5))
ax1 = fig.add_subplot(111)
# Start in pan mode with these two lines
manager = plt.get_current_fig_manager()
manager.toolbar.pan()
# Use nice numbers on x axis (y axis is normalized)...
x_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
ax1.xaxis.set_major_formatter(x_formatter)
if sun and not model:
ax1.plot(w_sun, I_sun, '-g', lw=2, alpha=0.6, label='Sun')
if telluric:
ax1.plot(w_tel, I_tel, '-r', lw=2, alpha=0.5, label='Telluric')
if model:
ax1.plot(w_mod, I_mod, '-g', lw=2, alpha=0.5, label='Model')
ax1.plot(w, I, '-k', lw=2, label='Star')
# Add crosshair
xlim = ax1.get_xlim()
cursor = Cursor(ax1)
plt.connect('motion_notify_event', cursor.mouse_move)
ax1.set_xlim(xlim)
if lines:
y0, y1 = ax1.get_ylim()
if rv1:
shift = (1.0 + rv1 / 299792.458)
for line in lines:
ax1.vlines(line*shift, y0, y1, linewidth=2, color='m', alpha=0.5)
ax1.text(line*shift-0.7, 1.2, str(line), rotation=90)
else:
for line in lines:
ax1.vlines(line, y0, y1, linewidth=2, color='m', alpha=0.5)
ax1.text(line-0.7, 1.2, str(line), rotation=90)
ax1.set_xlabel('Wavelength')
ax1.set_ylabel('"Normalized" flux')
if len(rvs) == 1:
if 'sun' in rvs.keys():
ax2.plot(r_sun, c_sun, '-k', lw=2)
ax2.plot(x_sun, y_sun, '--r', lw=2)
ax2.set_title('CCF (sun)')
if 'model' in rvs.keys():
ax2.plot(r_mod, c_mod, '-k', lw=2)
ax2.plot(x_mod, y_mod, '--r', lw=2)
ax2.set_title('CCF (mod)')
if 'telluric' in rvs.keys():
ax2.plot(r_tel, c_tel, '-k', lw=2)
ax2.plot(x_tel, y_tel, '--r', lw=2)
ax2.set_title('CCF (tel)')
ax2.set_xlabel('RV [km/s]')
elif len(rvs) == 2:
if 'sun' in rvs.keys():
ax2.plot(r_sun, c_sun, '-k', lw=2)
ax2.plot(x_sun, y_sun, '--r', lw=2)
ax2.set_title('CCF (sun)')
if 'model' in rvs.keys():
ax2.plot(r_mod, c_mod, '-k', lw=2)
ax2.plot(x_mod, y_mod, '--r', lw=2)
ax2.set_title('CCF (mod)')
ax3.plot(r_tel, c_tel, '-k', lw=2)
ax3.plot(x_tel, y_tel, '--r', lw=2)
ax3.set_title('CCF (tel)')
ax2.set_xlabel('RV [km/s]')
ax3.set_xlabel('RV [km/s]')
if rv:
ax1.set_title('%s\nRV correction: %s km/s' % (fname, rv))
elif rv1 and rv2:
ax1.set_title('%s\nSun/model: %s km/s, telluric: %s km/s' % (fname, rv1, rv2))
elif rv1 and not rv2:
ax1.set_title('%s\nSun/model: %s km/s' % (fname, rv1))
elif not rv1 and rv2:
ax1.set_title('%s\nTelluric: %s km/s' % (fname, rv2))
elif ccf == 'model':
ax1.set_title('%s\nModel(CCF): %s km/s' % (fname, rv1))
elif ccf == 'sun':
ax1.set_title('%s\nSun(CCF): %s km/s' % (fname, rv1))
elif ccf == 'telluric':
ax1.set_title('%s\nTelluric(CCF): %s km/s' % (fname, rv2))
elif ccf == 'both':
ax1.set_title('%s\nSun/model(CCF): %s km/s, telluric(CCF): %s km/s' % (fname, rv1, rv2))
else:
ax1.set_title(fname)
if sun or telluric or model:
ax1.legend(loc=3, frameon=False)
plt.show()
return rvs
class Figure:
def __init__(self,nxpix=1280):
"""Generate a 3D stereoscopic view of ~15k WISE sources. Color
clusters of objects differently.
Parameters:
-----------
nxpix : int
Number of pixels of the output (PNG) file. An aspect ratio
of 16:9 is assumed.
"""
self.dpi = 100
self.aspect = 16./9.
self.ux = nxpix/float(self.dpi)
self.uy = self.ux/self.aspect
# Load data (WISE colors)
print "Loading data..."
with N.load('data.npz') as datafile:
self.x, self.y, self.z = datafile['x'], datafile['y'], datafile['z']
print "Number of objects: %d" % self.x.size
print "Done."
def make_stereoscopic_3d_scatter(self,azimuth=-18,saveformat='png'):
"""Generate two panels, 5 degrees apart in azimuth. Cross eyes for
stereoscopic view.
Parameters:
-----------
azimuth : {float,int}
The azimuth angle (in degrees) at which the camera views
the scene.
saveformat : str
Generate an output file, with the supplied azimuth in the
file name. Must be either 'png' (recommended, default) or
'pdf' (will be rather slow to save).
Returns:
--------
Nothing, but saves an output file.
"""
assert (saveformat in ('png','pdf')), "saveformat must be 'png' (recommended) or 'pdf' (will be very slow to save)."
filename = '3D_color_stereoscopic_az%07.2f.%s' % (azimuth,saveformat)
print "Generating plot %s" % filename
self.setup_figure(figsize=(self.ux,self.uy)) # width, height
# left panel (=right eye)
ax1 = p.subplot(self.gs3D[0],projection='3d',aspect='equal',axisbg='w')
plot_scatter_3D(self.fig,ax1,1,self.x,self.y,self.z,self.uy,azimuth=azimuth)
# right panel (=left eye)
ax2 = p.subplot(self.gs3D[1],projection='3d',aspect='equal',axisbg='w')
plot_scatter_3D(self.fig,ax2,2,self.x,self.y,self.z,self.uy,azimuth=azimuth-5)
if saveformat == 'png':
p.savefig(filename,dpi=100)
else:
p.savefig(filename)
p.close()
def make_movie_frames(self,azstart=1,azstop=10,azstep=1):
"""Helper function to generate frames (for a video) with varying
azimuth angle.
Parameters:
-----------
azstart, azstop, azstep : float-ables
The azimuth angles of first frame, last frame
(approximate), and of the step size. All in degrees. All
can be negative (determines direction of scene rotation)
"""
try:
azstart = float(azstart)
azstop = float(azstop)
azstep = float(azstep)
except ValueError:
raise Exception, "azstart, azstop, azstep must be convertible to a floating point number."
if azstop < azstart:
azstep = -N.abs(azstep)
allaz = N.arange(azstart,azstop,azstep)
for j,az in enumerate(allaz):
print "Generating frame file %d of %d" % (j+1,len(allaz))
self.make_stereoscopic_3d_scatter(azimuth=az)
def setup_figure(self,figsize):
"""Set up the figure and rc params."""
self.fontsize = 2*self.uy
p.rcParams['axes.labelsize'] = self.fontsize
p.rcParams['font.size'] = self.fontsize
p.rcParams['legend.fontsize'] = self.fontsize-2
p.rcParams['xtick.labelsize'] = self.fontsize
p.rcParams['ytick.labelsize'] = self.fontsize
self.fig = p.figure(figsize=figsize) # width, height 300dpi
self.fig.suptitle('Clustering of astronomical objects in WISE 3D color space\n(cross your eyes for stereoscopic view)',color='k',fontsize=self.fontsize+2)
# this will hold the 3D scatter plot
self.gs3D = GridSpec(1,2)
self.gs3D.update(left=0.02,right=0.98,bottom=0.,top=1.,wspace=0.05,hspace=0.)
for line in srf08Distancetxt:
srfDistance_.append(line)
srf08Distancetxt.close()
plt.figure(1)
plt.subplots_adjust(hspace = .4)
tl = 0
th = 30
if int (sys.argv[1]) < 2 :
plt.suptitle("Sensors response for " + sys.argv[1] + " meter, " + sys.argv[2], fontsize = 15)
else:
plt.suptitle("Sensors response for " + sys.argv[1] + " meters, " + sys.argv[2], fontsize = 15)
#srf08
gs1 = GridSpec(3, 3)
gs1.update(left=0.03, right=0.98, wspace=0)
pir = plt.subplot(gs1[1,:])
pir.plot(pirTime_, pirData_, 'r')
plt.axis([tl,th,0,1.1])
plt.ylabel('Motion status')
plt.title('PIR sensor')
srf08 = plt.subplot(gs1[:1, :])
srf08.plot(srf08Time_, srf08Data_, 'g')
plt.axis([tl,th,0,1.1])
plt.ylabel('Motion status')
plt.title('Ultrasonic SRF08 sensor')
xband = plt.subplot(gs1[-1, :])
xband.plot(xBandTime_, xBandData_, 'b')
#Setting the table with minimum scatter
rawdata, err_rawdata = data_min_scatter[str(0)].values,data_min_scatter[str(1)].values
# ********************************************************************************************************************
# ********************************************************************************************************************
print 'Make a beautifull plot from flux results: \n'
for i in range(len(data_min_scatter.columns)-2):
if (i % 2 == 0) and (i != int(data_min_scatter.columns[-1])-2):
refstar = data_min_scatter[str(i+2)].values
err_refstar = data_min_scatter[str(i+3)].values
rawflux = rawdata/refstar
eflux = rawflux*np.sqrt((err_rawdata/rawdata)**2 + (err_refstar/refstar)**2)
f = plt.figure()
plt.suptitle('Minimum scatter of the flux \n @'+files_csv[id_min]+'\ncolumns = '+str(i+3)+' Reference Star/ '+str(i+4)+' Err_flux',fontsize=12)
gs1 = GridSpec(2, 2, width_ratios=[1,2],height_ratios=[4,1])
gs1.update(wspace=0.5)
ax1 = plt.subplot(gs1[:-1, :])
ax2 = plt.subplot(gs1[-1, :])
ax1.grid()
ax1.errorbar(hjd,rawflux,yerr=eflux,ecolor='g')
ax1.set_xticklabels([])
ax1.set_ylabel('Relative Flux')
ax2.grid()
ax2.plot(hjd,airmass,color='green')
plt.yticks(np.array([airmass.min(), (airmass.min()+airmass.max())/2., airmass.max()]))
ax2.set_xlabel('JD')
ax2.set_ylabel('airmass')
plt.savefig(save_path+'/rawflux_StarColumn_'+str(i+3)+'.png')
os.chdir(original_path)
print 'Total duration = ',abs(exotred.time.time()-start_time)/60.,' minutes'