def set_defaults(self): fontsize = {} for key, val in self.configdict.items(): if 'font' in key: fontsize[key] = val else: setattr(self, key, val) self.zoom_lims = [] self.added_texts = [] self.scatter_xdata = None self.scatter_ydata = None self.scatter_mask = None self.margins = None self.mpl_legend = None self.axes_traces = {} # preload some traces self.traces = [] self.reset_lines() f0 = FontProperties() self.labelfont = f0.copy() self.titlefont = f0.copy() self.legendfont = f0.copy() self.legendfont.set_size(fontsize['legendfont']) self.labelfont.set_size(fontsize['labelfont']) self.titlefont.set_size(fontsize['titlefont']) self.set_theme()
def plot_image(image,title): print title maxi = np.amax(image) med = np.median(image) fig = plt.figure(figsize=(10,10)) font0 = FontProperties() font = font0.copy() font.set_weight('bold') ax = fig.add_subplot(1,1,1) ax.tick_params(axis='x', labelsize=25) ax.tick_params(axis='y', labelsize=25) # image = filters.gaussian_filter(Q_image[149:549,149:549],1) img1 = ax.imshow(np.log10(np.abs(image)), origin='lower', vmin = np.log10(np.abs(med)), vmax = np.log10(np.abs(maxi))) fig.colorbar(img1, ax=ax) ax.get_xaxis().set_ticks([]) ax.get_yaxis().set_ticks([]) plt.savefig(title + 'log10.png', dpi = 600) plt.close() fig = plt.figure(figsize=(10,10)) font0 = FontProperties() font = font0.copy() font.set_weight('bold') ax = fig.add_subplot(1,1,1) ax.tick_params(axis='x', labelsize=25) ax.tick_params(axis='y', labelsize=25) # image = filters.gaussian_filter(Q_image[149:549,149:549],1) img1 = ax.imshow(np.abs(image), origin='lower', vmin = np.abs(med), vmax = np.abs(maxi)) fig.colorbar(img1, ax=ax) ax.get_xaxis().set_ticks([]) ax.get_yaxis().set_ticks([]) plt.savefig(title + '.png', dpi = 600) plt.close()
def create_results_figure(model_names, method_names, values, filename): results_table = np.array(values).transpose() n_models = results_table.shape[0] n_methods = results_table.shape[1] index = np.arange(n_methods) cmap = plt.get_cmap('tab20') x = np.linspace(0.0, 1.0, 100) font0 = FontProperties() font0.set_weight('medium') font0.set_size('medium') font1 = font0.copy() font1.set_size('x-large') font2 = font0.copy() font2.set_size('xx-large') dpi = 70 step = (1.0 / n_models) * 0.9 xmax = 100000.0 plt.figure(figsize=(1000 / dpi, 2500 / dpi), dpi=dpi) for i in range(n_models): color = cmap(i / n_models) ax = plt.barh(index - 0.35 + i * step, results_table[i], step, alpha=1.0, color=color, label=model_names[i]) rects = ax.patches for j in range(len(rects)): rect = rects[j] read_time = results_table[i][j] if read_time == 0: label = 'N/A' else: label = ' %-7.2f' % (results_table[i][j]) w = min(rect.get_width(), xmax - 1500) h = rect.get_y() + rect.get_height() * 0.45 if w == 0: w = 0.32 plt.ylabel('Library', fontproperties=font1) plt.xlabel('Time (log ms)', fontproperties=font1) plt.legend(bbox_to_anchor=(1.1, 1.0)) plt.xscale('log') plt.xlim(0.3, xmax) plt.yticks(np.arange(n_methods), method_names) plt.tight_layout() # plt.show() plt.savefig(filename, dpi=dpi)
def set_defaults(self): self.zoom_x = 0 self.zoom_y = 0 self.zoom_init = (0, 1) self.zoom_lims = [] self.viewpad = 2.5 self.title = ' ' self.xscale = 'linear' self.yscale = 'linear' self.xlabel = ' ' self.ylabel = ' ' self.y2label = ' ' self.added_texts = [] self.plot_type = 'lineplot' self.scatter_size = 30 self.scatter_normalcolor = 'blue' self.scatter_normaledge = 'blue' self.scatter_selectcolor = 'red' self.scatter_selectedge = 'red' self.scatter_xdata = None self.scatter_ydata = None self.scatter_mask = None self.margins = None self.auto_margins = True self.legend_loc = 'best' self.legend_onaxis = 'on plot' self.mpl_legend = None self.show_grid = True self.draggable_legend = False self.hidewith_legend = True self.show_legend = False self.show_legend_frame = False self.axes_style = 'box' f0 = FontProperties() self.labelfont = f0.copy() self.titlefont = f0.copy() self.legendfont = f0.copy() self.legendfont.set_size(7) self.labelfont.set_size(9) self.titlefont.set_size(10) self.color_themes = ColorThemes self.color_theme = 'light' self.set_color_theme(self.color_theme) # preload some traces self.ntrace = 0 self.lines = [None]*200 self.traces = [] self.reset_trace_properties()
def set_defaults(self): self.zoom_x = 0 self.zoom_y = 0 self.zoom_init = (0, 1) self.zoom_lims = [] self.viewpad = 2.5 self.title = ' ' self.xscale = 'linear' self.yscale = 'linear' self.xlabel = ' ' self.ylabel = ' ' self.y2label = ' ' self.added_texts = [] self.plot_type = 'lineplot' self.scatter_size = 30 self.scatter_normalcolor = 'blue' self.scatter_normaledge = 'blue' self.scatter_selectcolor = 'red' self.scatter_selectedge = 'red' self.scatter_xdata = None self.scatter_ydata = None self.scatter_mask = None self.margins = None self.auto_margins = True self.legend_loc = 'best' self.legend_onaxis = 'on plot' self.mpl_legend = None self.show_grid = True self.draggable_legend = False self.hidewith_legend = True self.show_legend = False self.show_legend_frame = False self.axes_style = 'box' f0 = FontProperties() self.labelfont = f0.copy() self.titlefont = f0.copy() self.legendfont = f0.copy() self.legendfont.set_size(7) self.labelfont.set_size(9) self.titlefont.set_size(10) self.color_themes = ColorThemes self.color_theme = 'light' self.set_color_theme(self.color_theme) # preload some traces self.ntrace = 0 self.lines = [None] * 200 self.traces = [] self.reset_trace_properties()
def createFont(family=None, style=None, variant=None, weight=None, stretch=None, size=None, fontFilePathName=None): """Returns a Font Object for text in Matplotlib.""" #### Copy Global Font Properties #### if fontFilePathName: try: font0 = FontProperties(fname=fontFilePathName) except: font0 = FontProperties() else: font0 = FontProperties() font = font0.copy() #### Adjust Based on Arguments #### if family != None: font.set_family(family) if style != None: font.set_style(style) if variant != None: font.set_variant(variant) if weight != None: font.set_weight(weight) if stretch != None: font.set_stretch(stretch) if size != None: font.set_size(size) return font
def CalibrationENC(calibration_filename): # Read data fron the calibration curve dataset C, e_C, noise_rms, d_noise_rms, fall_time, d_fall_time, amplitude, d_amplitude = LoadCalibrationFile(calibration_filename) noise_rms = noise_rms / 1000. # convert form \muV to mV d_noise_rms = d_noise_rms / 1000. ENC = (noise_rms/amplitude) * (C * 20.0) * pow(10,-15) / (1.602 * pow(10,-19) ) #pF * mV = 10^-12 * 10^-3 = 10^-15 C / 10^-19 C = 10^4 electrons d_ENC = np.zeros([len(ENC)]) for i in range(len(ENC)): d_ENC[i] = sqrt( d_noise_rms[i]*d_noise_rms[i]*(C[i] * 20.0/amplitude[i])*(C[i] * 20.0/amplitude[i]) + d_amplitude[i]*d_amplitude[i]*((noise_rms[i]/(amplitude[i]*amplitude[i])) * (C[i] * 20.0))*((noise_rms[i]/(amplitude[i]*amplitude[i])) * (C[i] * 20.0)) ) d_ENC = d_ENC * pow(10,-15) / (1.602 * pow(10,-19) ) # conversted to # of electrons calib_curve = TGraphErrors(len(ENC), array('d', C[:-1].tolist()), array('d', ENC.tolist()), array('d', e_C.tolist()), array('d', d_ENC) ) # Construct the fit with a 1st and 2nd order polynomial fit_curve = TF1('fit_curve','[1]*x + [0]',0.,110.) fit_curve2 = TF1('fit_curve2','[0]*x*x + [1]*x + [2]',0.,110.) # Fit the calibration curve calib_curve.Fit(fit_curve,'R') calib_curve.Fit(fit_curve2, 'R') lin_par0 = fit_curve.GetParameter(0) lin_e_par0 = fit_curve.GetParError(0) lin_par1 = fit_curve.GetParameter(1) lin_e_par1 = fit_curve.GetParError(1) xx = np.linspace(0., 105, 1000) yy = [fit_curve.Eval(x) for x in xx] yy2 = [fit_curve2.Eval(x) for x in xx] par = [lin_par0, lin_par1] l = 'fit pol1 $p_0$: {:.3g} $p_1$: {:.3g}'.format(*par) # Plot the calibration curve with matplotlib font0 = FontProperties() font = font0.copy() font.set_style('italic') font.set_weight('bold') font.set_size('x-large') fig, ax = plt.subplots() ax.set_xlabel('C [pF]') ax.set_ylabel('ENC [# of electrons]') ax.errorbar(C, ENC, d_ENC, marker='o', color='k', linestyle='None', label='Data') ax.plot(xx, yy, color='r', label=l) ax.plot(xx, yy2, color='g', label='fit pol2') ax.text(0.05,0.65, 'Group 1', verticalalignment='bottom', horizontalalignment='left', fontproperties=font, transform=ax.transAxes) ax.legend(loc='upper left', numpoints=1) plt.grid() #plt.show() fig.savefig('../graphics/calibrationENC_diode.pdf') plt.close(fig) plt.clf() return lin_par0, lin_e_par0, lin_par1, lin_e_par1
def draw_output_element(out_name, out_value, ax): # Add output value x, y = np.array([[out_value, out_value], [0, 0.24]]) line = lines.Line2D(x, y, lw=2., color='#F2F2F2') line.set_clip_on(False) ax.add_line(line) font0 = FontProperties() font = font0.copy() font.set_weight('bold') text_out_val = plt.text(out_value, 0.25, '{0:.2f}'.format(out_value), fontproperties=font, fontsize=14, horizontalalignment='center') text_out_val.set_bbox(dict(facecolor='white', edgecolor='white')) text_out_val = plt.text(out_value, 0.33, out_name, fontsize=12, alpha=0.5, horizontalalignment='center') text_out_val.set_bbox(dict(facecolor='white', edgecolor='white'))
def createFont(family = None, style = None, variant = None, weight = None, stretch = None, size = None, fontFilePathName = None): """Returns a Font Object for text in Matplotlib.""" #### Copy Global Font Properties #### if fontFilePathName: try: font0 = FontProperties(fname = fontFilePathName) except: font0 = FontProperties() else: font0 = FontProperties() font = font0.copy() #### Adjust Based on Arguments #### if family != None: font.set_family(family) if style != None: font.set_style(style) if variant != None: font.set_variant(variant) if weight != None: font.set_weight(weight) if stretch != None: font.set_stretch(stretch) if size != None: font.set_size(size) return font
def __init__(self,Model_suite,**input_parameters): self.working_directory = '.' self.station_listfile = None self.station_xyfile = None self.Model_suite = Model_suite self.modeltype = 'model' self.fig_width = 1. self.ax_width = 0.03 self.ax_height = 0.8 self.ax_bottom = 0.1 self.plot_spacing = 0.02 self.ylim = [6,0] self.title_type = 'single' self.titles = {'minmax':'Minimum and maximum resistivity, $\Omega m$', 'aniso':'Anisotropy in resistivity',# (maximum/minimum resistivity) 'strike':'Strike angle of minimum resistivity'}#, $^\circ$ self.xlim = {'minmax':[0.1,1000], 'aniso':[0,20], 'strike':[0,180]} self.fonttype = 'serif' self.label_fontsize = 8 self.title_fontsize = 12 for key in input_parameters.keys(): setattr(self,key,input_parameters[key]) font0 = FontProperties() font = font0.copy() font.set_family(self.fonttype) self.font = font self.working_directory = os.path.abspath(self.working_directory)
def drawtable(data, rows, columns, title, folder='Table', rowname='',fmt='{:.2f}'): nrows = len(rows) ncols = len(columns) fig, ax = plt.subplots(figsize=(ncols+2,nrows+2)) ax.set_axis_off() rowlc='#F0F0F0' collc='#F0F0F0' cellc='#FFFFFF' ecol='#0000FF' font1 = FontProperties() font1.set_size('9') fontl = font1.copy() fontl.set_weight('bold') tb = Table(ax)#, bbox=[0.10,0.10,0.90,0.90]) tb.auto_set_font_size(False) #tb.set_fontsize(100.0) width, height = 0.95/(ncols+1), 0.95/(nrows+1) for i in range(nrows): tb.add_cell(i,-1, width*2, height, text=rows[i][:20], loc='right',edgecolor=ecol, facecolor=rowlc,fontproperties=fontl) # Column Labels for j in range(ncols): tb.add_cell(-1, j, width, height/1.5, text=columns[j][:10], loc='center', edgecolor=ecol, facecolor=collc,fontproperties=fontl) tb.add_cell(-1,-1, width*2, height/1.5, text=rowname[:10], loc='right',edgecolor=ecol, facecolor=rowlc,fontproperties=fontl) # Add cells for i in range(len(data)): for j in range(len(data[i])): val = data[i][j] tb.add_cell(i,j,width, height, text=fmt.format(val), loc='center', edgecolor=ecol, facecolor=cellc, fontproperties=font1) # Row Labels ax.add_table(tb) plt.savefig(folder+'/'+title+'.pdf') #plt.show() #sys.exit(0) plt.close()
def gcm_heatmaps(gcms, ginfo, out_file, title_tag, colormap='RdYlBu_r'): with PdfPages(out_file) as pdf: font0 = FontProperties() font0.set_name('sans-serif') font0.set_size(12) font1 = font0.copy() font1.set_size(14) font2 = font0.copy() font2.set_size(16) for i, GCM in enumerate(gcms): title = "%s (|cor|> %.3f, %d nodes, %d edges)" % \ (title_tag, ginfo.loc[i, 'AbsCor'], ginfo.loc[i, 'NumNodes'], ginfo.loc[i, 'NumEdges']) fig = plt.figure(1, figsize=(8, 8)) ax = fig.add_subplot(111) im = ax.matshow(GCM, aspect='equal', cmap=matplotlib.cm.get_cmap(colormap), vmin=-1.0, vmax=1.0) ax.set_title(title, fontproperties=font2) labels = list(map(str, GCM_ORDER)) xticks = np.arange(len(labels)) yticks = np.arange(len(labels)) ax.set_xticks(xticks) ax.set_yticks(yticks) ax.set_xticklabels(labels, fontproperties=font1) ax.set_yticklabels(labels, fontproperties=font1) plt.setp(list(ax.spines.values()), lw=0.5, color="#666666") plt.setp(ax.get_xticklabels(), fontproperties=font1) plt.setp(ax.get_yticklabels(), fontproperties=font1) plt.setp(ax.xaxis.get_ticklines(), markersize=3) plt.setp(ax.yaxis.get_ticklines(), markersize=3) plt.setp(ax.xaxis.get_ticklines(minor=True), markersize=1) plt.setp(ax.yaxis.get_ticklines(minor=True), markersize=1) ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('right') pdf.savefig() plt.close()
def set_defaults(self): self.zoom_x = 0 self.zoom_y = 0 self.zoom_init = (0, 1) self.title = ' ' self.xlabel = ' ' self.ylabel = ' ' self.y2label = ' ' self.plot_type = 'lineplot' self.cursor_mode = 'zoom' self.scatter_size = 6 self.scatter_normalcolor = 'blue' self.scatter_normaledge = 'blue' self.scatter_selectcolor = 'red' self.scatter_selectedge = 'red' self.scatter_data = None self.scatter_coll = None self.scatter_mask = None self.legend_loc = 'upper right' self.legend_onaxis = 'on plot' self.mpl_legend = None self.show_grid = True self.show_legend = False self.show_legend_frame = False # self.trace_color_callback = trace_color_callback f0 = FontProperties() self.labelfont = f0.copy() self.titlefont = f0.copy() self.labelfont.set_size(9) self.titlefont.set_size(10) self.textcolor = '#000000' self.grid_color = '#E5E5E5' # preload some traces self.ntrace = 0 self.lines = [None]*30 self.traces = [] self._init_trace( 0, 'blue', 'solid') self._init_trace( 1, 'red', 'solid') self._init_trace( 2, 'black', 'solid') self._init_trace( 3, 'magenta', 'solid') self._init_trace( 4, 'green3', 'solid') self._init_trace( 5, 'maroon', 'solid') self._init_trace( 6, 'blue', 'dashed') self._init_trace( 7, 'red', 'dashed') self._init_trace( 8, 'black', 'dashed') self._init_trace( 9, 'magenta', 'dashed') self._init_trace(10, 'green3', 'dashed') self._init_trace(11, 'maroon', 'dashed') self._init_trace(12, 'blue', 'dotted') self._init_trace(13, 'red', 'dotted') self._init_trace(14, 'black', 'dotted') self._init_trace(15, 'magenta', 'dotted') self._init_trace(16, 'green3', 'dotted') self._init_trace(17, 'maroon', 'dotted') self._init_trace(18, 'blue', 'solid', marker='+') self._init_trace(19, 'red', 'solid', marker='+') self._init_trace(20, 'black', 'solid', marker='o')
def plot_ref_genome(ref_placements,cycle,total_length,segSeqD,imputed_status,label_segs,onco_set=set()): font0 = FontProperties() rot_sp = global_rot/360.*total_length for ind,refObj in ref_placements.iteritems(): seg_coord_tup = segSeqD[cycle[ind][0]] # print(refObj.to_string()) start_angle, end_angle = start_end_angle(refObj.abs_end_pos,refObj.abs_start_pos,total_length) # print start_angle,end_angle #makes the reference genome wedges patches.append(mpatches.Wedge((0,0), outer_bar, end_angle, start_angle, width=bar_width)) chrom = segSeqD[cycle[ind][0]][0] f_color_v.append(chromosome_colors[chrom]) e_color_v.append('grey') lw_v.append(0.2) #makes the ticks on the reference genome wedges if cycle[ind][1] == "+": # posns = zip(range(seg_coord_tup[1],seg_coord_tup[2]+1),np.arange(refObj.abs_end_pos,refObj.abs_start_pos,-1)) posns = zip(range(seg_coord_tup[1],seg_coord_tup[2]+1),np.arange(refObj.abs_start_pos,refObj.abs_end_pos)) else: # posns = zip(np.arange(seg_coord_tup[2],seg_coord_tup[1]-1,-1),np.arange(refObj.abs_end_pos,refObj.abs_start_pos,-1)) posns = zip(np.arange(seg_coord_tup[2],seg_coord_tup[1]-1,-1),np.arange(refObj.abs_start_pos,refObj.abs_end_pos)) tick_freq = max(30000,30000*int(np.floor(total_length/1000000))) if refObj.abs_end_pos-refObj.abs_start_pos < 30000: tick_freq = 10000 for j in posns: if j[0] % tick_freq == 0: text_angle = j[1]/total_length*360 x,y = pol2cart(outer_bar,(text_angle/360*2*np.pi)) x_t,y_t = pol2cart(outer_bar + 0.2,(text_angle/360*2*np.pi)) ax.plot([x,x_t],[y,y_t],color='grey',linewidth=1) text_angle,ha = vu.correct_text_angle(text_angle) txt = " " + str(int(round((j[0])/10000))) if ha == "left" else str(int(round((j[0])/10000))) + " " ax.text(x_t,y_t,txt,color='grey',rotation=text_angle, ha=ha,va="center",fontsize=9,rotation_mode='anchor') gene_tree = vu.parse_genes(seg_coord_tup[0],args.ref) relGenes = vu.rel_genes(gene_tree,seg_coord_tup,copy.copy(onco_set)) #plot the gene track plot_gene_track(refObj.abs_start_pos,relGenes,seg_coord_tup,total_length,cycle[ind][1]) #label the segments by number in cycle mid_sp = (refObj.abs_end_pos + refObj.abs_start_pos)/2 text_angle = mid_sp/total_length*360. x,y = pol2cart((outer_bar-2*bar_width),(text_angle/360.*2.*np.pi)) font = font0.copy() if imputed_status[ind]: font.set_style('italic') # font.set_weight('bold') text_angle,ha = vu.correct_text_angle(text_angle) if label_segs: ax.text(x,y,cycle[ind][0]+cycle[ind][1],color='grey',rotation=text_angle, ha=ha,fontsize=5,fontproperties=font,rotation_mode='anchor')
def __init__(self): self.axes = None self.canvas = None self.fig = None self.zoom_x = 0 self.zoom_y = 0 self.zoom_init = (0,1) self.title = ' ' self.xlabel = ' ' self.ylabel = ' ' self.styles = StyleMap.keys() self.symbols = MarkerMap.keys() self.legend_locs = ['upper right' , 'upper left', 'upper center', 'lower right', 'lower left', 'lower center', 'center left', 'center right', 'right', 'center'] self.legend_onaxis_choices = ['on plot', 'off plot'] self.legend_loc = 'upper right' self.legend_onaxis = 'on plot' self.mpl_legend = None self.show_grid = True self.show_legend = False self.show_legend_frame = True f0 = FontProperties() self.labelfont = f0.copy() self.titlefont = f0.copy() self.labelfont.set_size(12) self.titlefont.set_size(14) self.grid_color = '#E0E0E0' # preload some traces # color style linewidth marker markersize self.ntrace = 0 self.lines = [None]*30 self.traces = [] self._init_trace(20,None, 'black' ,'dotted',2,'o', 8) self._init_trace( 0,None, 'blue', 'solid', 2,None,8) self._init_trace( 1,None, 'red', 'solid', 2,None,8) self._init_trace( 2,None, 'black', 'solid', 2,None,8) self._init_trace( 3,None, 'magenta', 'solid', 2,None,8) self._init_trace( 4,None, 'darkgreen','solid', 2,None,8) self._init_trace( 5,None, 'maroon' ,'solid', 2,None,8) self._init_trace( 6,None, 'blue', 'dashed',2,None,8) self._init_trace( 7,None, 'red', 'dashed',2,None,8) self._init_trace( 8,None, 'black', 'dashed',2,None,8) self._init_trace( 9,None, 'magenta', 'dashed',2,None,8) self._init_trace(10,None, 'darkgreen','dashed',2,None,8) self._init_trace(11,None, 'maroon' ,'dashed',2,None,8) self._init_trace(12,None, 'blue', 'dotted',2,None,8) self._init_trace(13,None, 'red', 'dotted',2,None,8) self._init_trace(14,None, 'black', 'dotted',2,None,8) self._init_trace(15,None, 'magenta', 'dotted',2,None,8) self._init_trace(16,None, 'darkgreen','dotted',2,None,8) self._init_trace(17,None, 'maroon' ,'dotted',2,None,8) self._init_trace(18,None, 'blue' ,'solid',1,'+',8) self._init_trace(19,None, 'red' ,'solid',1,'+',8)
def get_font(self): font_properties = FontProperties() font = font_properties.copy() font.set_size(str(self.font_point.GetValue())) font.set_name(str(self.font_family.GetValue())) font.set_slant(str(self.font_style.GetValue())) font.set_weight(str(self.font_weight.GetValue())) return font
def __init__(self,aniso_depth_file,**input_parameters): self.levels = None self.n_levels = 10 self.escale = 0.001 self.anisotropy_threshold = [1.,100] self.cmap = 'jet_r' self.scaleby = 'resmin' self.anisotropy_display_factor = 0.75 self.xlim = None self.ylim = None self.plot_cbar=True self.cbar_ax = [0.8,0.1,0.08,0.8] self.imethod = 'linear' self.scalebar = True self.aniso_depth_file = aniso_depth_file self.aniso_depth_file_dict = dict(header_rows=1, scale='km') self.xyzfiles = None self.xyzfiles_dict = dict(header_rows=1, scale='km') self.xyzfile_titles = None self.additional_xy_data = {} self.plot_text = {} self.set_titles = True self.subplot_layout = 'vertical' self.wspace = 0.02 self.hspace = 0.15 self.fonttype = 'serif' self.figsize=(8,5) for key in input_parameters.keys(): if hasattr(self,str.lower(key)): setattr(self,key,input_parameters[key]) self.read_aniso_depth_data() if self.xyzfiles is not None: if type(self.xyzfiles) == str: self.xyzfiles = [self.xyzfiles] if self.xyzfile_titles is None: titles = [] for f in self.xyzfiles: titles.append(op.basename(f)) self.xyzfile_titles = titles else: if type(self.xyzfile_titles) == str: self.xyzfile_titles = [self.xyzfile_titles] while len(self.xyzfile_titles) < len(self.xyzfiles): self.xyzfile_titles.append('') font0 = FontProperties() font = font0.copy() font.set_family(self.fonttype) self.font = font
def CalibrationRiseTime(calibration_filename): # Read data fron the calibration curve dataset C, e_C, noise_rms, d_noise_rms, fall_time, d_fall_time, amplitude, d_amplitude = LoadCalibrationFile(calibration_filename) gStyle.SetOptStat(1111) # Construct the curve calib_curve = TGraphErrors(len(C), array('d',C.tolist()), array('d', fall_time.tolist()), array('d', e_C.tolist()), array('d',d_fall_time.tolist()) ) # Construct the fit with a 2nd order polynomial fit_curve = TF1('fit_curve','[0]*x*x + [1]*x + [2]',0.,110.) fit_curve.SetParameter(0, 0.0) fit_curve.SetParameter(1, 0.0) fit_curve.SetParameter(2, 0.0) fit_curve.SetLineColor(2) # FIt the calibration curve calib_curve.Fit(fit_curve,'R') # Extract the results fron the fit par0 = fit_curve.GetParameter(0) e_par0 = fit_curve.GetParError(0) par1 = fit_curve.GetParameter(1) e_par1 = fit_curve.GetParError(1) par2 = fit_curve.GetParameter(2) e_par2 = fit_curve.GetParError(2) xx = np.linspace(0., 105, 1000) yy = [fit_curve.Eval(x) for x in xx] par = [par2, par1, par0] l = 'fit pol2 $p_0$: {:.3g} $p_1$: {:.3g} $p_2$: {:.2f}'.format(*par) # Plot the calibration curve with matplotlib font0 = FontProperties() font = font0.copy() font.set_style('italic') font.set_weight('bold') font.set_size('x-large') fig, ax = plt.subplots() ax.set_xlabel('C [pF]') ax.set_xlim(0.0, 120) ax.set_ylabel('Rise time [ns]') ax.errorbar(C, fall_time, d_fall_time, marker='o', color='k', linestyle='None', label='Data') ax.plot(xx, yy, label=l, color='r') #plt.set_title('Diode calibration curve') ax.text(0.05,0.65, 'Group 1', verticalalignment='bottom', horizontalalignment='left', fontproperties=font, transform=ax.transAxes) ax.legend(loc='upper left', numpoints=1) plt.grid() #plt.show() fig.savefig('../graphics/calibration_diode.pdf') plt.close(fig) plt.clf() return par0, e_par0, par1, e_par1, par2, e_par2
def plot_histo( ydata , fileout , color ): ## Define figure enviroment fig = plt.figure(1) rect = fig.patch rect.set_facecolor('white') axescolor = '#f6f6f6' ax = plt.subplot(111,axisbg=axescolor) ## Font setting font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = font1.copy() font.set_family('serif') rc('text',usetex=True) ## Enable grid gridLineWidth = 0.2 ax.yaxis.grid(True, linewidth=gridLineWidth, linestyle='-', color='0.05') ## Marker setup colors = [ 'blue' , 'red' , 'blue','red','green','black','brown','orange','black','violet'] markers = ['^','s','o','d','1','v'] ## Ticks xdensity=100 fig.autofmt_xdate(bottom=0.18) plt.xticks(fontsize=16) plt.yticks(fontsize=16) locs,xlabels = plt.xticks() #locs = np.arange(xinf,xsup,xdensity) #plt.xticks(locs, map(lambda x: "%d" % x, locs)) locs,ylabels = plt.yticks() #plt.yticks(locs, map(lambda x: "%e" % x, locs)) ## Set title and axis labeling plt.xlabel(r'\textbf{Grey value}', fontsize=18,position=(0.5,-0.2)) plt.ylabel( r'\textbf{Counts}' , fontsize=18,position=(0.5,0.5)) plt.suptitle(r'\textbf{HISTOGRAM}', fontsize=16, fontweight='bold', position=(0.53,0.95)) ## Plot histogram n, bins, patches = plt.hist( ydata , 256 , facecolor=color, edgecolor='none' , alpha=1.0 ) ## Save plot and show it #plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' ) plt.savefig( fileout , facecolor=fig.get_facecolor() , #edgecolor='black' , format='eps', dpi=1000) plt.show()
def __init__(self, Model_suite, **input_parameters): self.Model_suite = Model_suite self.working_directory = Model_suite.working_directory self.parameters = [['minmax'], ['aniso', 'strike']] self.titles = { 'minmax': 'Minimum and maximum resistivity, $\Omega m$', 'aniso': 'Anisotropy in resistivity', # (maximum/minimum resistivity) 'strike': 'Strike angle of minimum resistivity' } #, $^\circ$ self.xlim = { 'minmax': [0.1, 1000], 'aniso': [0, 20], 'strike': [0, 180] } self.ylim = [6, 0] self.modelno = Model_suite.modelno self.modeltype = 'model' self.rotation_angle = 0. self.station_listfile = None self.station_xyfile = None self.figsize = (6, 6) self.plot_spacing = 0.1 self.title_type = 'single' self.fonttype = 'sans-serif' self.label_fontsize = 8 self.title_fontsize = 12 self.linedict = dict(style='-', width=1, colour=[['0.5', 'k']] * 2) self.horizon_list = None self.horizon_zscale = 'km' self.horizon_linedict = dict(style=['-'] * 6, width=[2] * 6, colour=['c', 'y', 'b', 'r', 'g', 'm']) self.subplot_dict = dict(wspace=0.1, bottom=0.25, hspace=0.4) # store inputs in the object to pass through to Plot_model object self.input_parameters = input_parameters # set attributes from keyword arguments for key in input_parameters.keys(): if hasattr(self, key): setattr(self, key, input_parameters[key]) self.input_parameters[key] = input_parameters[key] font0 = FontProperties() font = font0.copy() font.set_family(self.fonttype) self.font = font self.working_directory = os.path.abspath(self.working_directory)
def __init__(self, aniso_depth_file, **input_parameters): self.levels = None self.n_levels = 10 self.escale = 0.001 self.anisotropy_threshold = [1., 100] self.cmap = 'jet_r' self.scaleby = 'resmin' self.anisotropy_display_factor = 0.75 self.xlim = None self.ylim = None self.plot_cbar = True self.cbar_ax = [0.8, 0.1, 0.08, 0.8] self.imethod = 'linear' self.scalebar = True self.aniso_depth_file = aniso_depth_file self.aniso_depth_file_dict = dict(header_rows=1, scale='km') self.xyzfiles = None self.xyzfiles_dict = dict(header_rows=1, scale='km') self.xyzfile_titles = None self.additional_xy_data = {} self.plot_text = {} self.set_titles = True self.subplot_layout = 'vertical' self.wspace = 0.02 self.hspace = 0.15 self.fonttype = 'serif' self.figsize = (8, 5) for key in input_parameters.keys(): if hasattr(self, str.lower(key)): setattr(self, key, input_parameters[key]) self.read_aniso_depth_data() if self.xyzfiles is not None: if isinstance(self.xyzfiles, str): self.xyzfiles = [self.xyzfiles] if self.xyzfile_titles is None: titles = [] for f in self.xyzfiles: titles.append(op.basename(f)) self.xyzfile_titles = titles else: if isinstance(self.xyzfile_titles, str): self.xyzfile_titles = [self.xyzfile_titles] while len(self.xyzfile_titles) < len(self.xyzfiles): self.xyzfile_titles.append('') font0 = FontProperties() font = font0.copy() font.set_family(self.fonttype) self.font = font
def whoswho(X, y, image_file): # Train the whole entire data set !! md_pca, Xtrain_proj = pca_X(X, n_comp = 50) md_clf = svm_train(Xtrain_proj, y) # Load in test photo (whoswho.JPG) and crop them whoswho = image_file orig_im = image.imread(whoswho) images, faces = crop_images(orig_im) # goes through cropped images and called pca_svm_pred and for each prediction # it will print out the prediction made and add to the preds list. preds = [] for i in range(len(images)): preds.append(pca_svm_pred(images[i], md_pca, md_clf)) print("PCA+SVM predition for person", i, ":", names_dict.get(preds[i][0])) n_row = 1 n_col = 3 # this will plot each cropped image with a title of what the prediction was for i in range (n_row * n_col): plt.subplot(n_row, n_col, i+1) plt.imshow(images[i], cmap = plt.cm.gray) plt.title("Person" + str(i) + ": " + names_dict.get(preds[i][0])) plt.axis('off') # Create figure and show original image fig = plt.figure(figsize = (8, 8)) ax = plt.subplot(111) ax.imshow(orig_im) plt.grid('off') plt.axis('off') # Set font font0 = FontProperties() font = font0.copy() font.set_style('italic') font.set_weight('bold') font.set_size('large') # This will put text (predictions) on the current plt image. j = 0 for (x, y, w, h) in faces: plt.text(x + 100, y, names_dict.get(preds[j][0]), color='pink', \ size = 12, fontproperties = font) j+=1 plt.show() return images
def __init__(self,Model_suite,**input_parameters): self.Model_suite = Model_suite self.working_directory = Model_suite.working_directory self.parameters = [['minmax'],['aniso','strike']] self.titles = {'minmax':'Minimum and maximum resistivity, $\Omega m$', 'aniso':'Anisotropy in resistivity',# (maximum/minimum resistivity) 'strike':'Strike angle of minimum resistivity'}#, $^\circ$ self.xlim = {'minmax':[0.1,1000], 'aniso':[0,20], 'strike':[0,180]} self.ylim = [6,0] self.modelno = Model_suite.modelno self.modeltype = 'model' self.rotation_angle = 0. self.station_listfile = None self.station_xyfile = None self.figsize = (6,6) self.plot_spacing = 0.1 self.title_type = 'single' self.fonttype = 'sans-serif' self.label_fontsize = 8 self.title_fontsize = 12 self.linedict = dict(style='-',width=1, colour=[['0.5','k']]*2) self.horizon_list = None self.horizon_zscale = 'km' self.horizon_linedict = dict(style=['-']*6,width=[2]*6, colour=['c','y','b','r','g','m']) self.subplot_dict = dict(wspace=0.1,bottom=0.25,hspace=0.4) # store inputs in the object to pass through to Plot_model object self.input_parameters = input_parameters # set attributes from keyword arguments for key in input_parameters.keys(): if hasattr(self,key): setattr(self,key,input_parameters[key]) self.input_parameters[key] = input_parameters[key] font0 = FontProperties() font = font0.copy() font.set_family(self.fonttype) self.font = font self.working_directory = os.path.abspath(self.working_directory)
def boldAnnot(ax, x, y, txt, ha='left', va='top', size=12): font0 = FontProperties() boldFont = font0.copy() boldFont.set_weight('bold') boldFont.set_size(size) ax.text(x, y, txt, transform=ax.transAxes, ha=ha, va=va, fontsize=size, fontproperties=boldFont)
def naslov(ttitle, x_label, y_label): ax = plt.subplot(111) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() plt.grid(linestyle=':', linewidth=0.95, color='seagreen') from matplotlib.font_manager import FontProperties font0 = FontProperties() font = font0.copy() font.set_style('italic') font.set_size('x-large') font.set_family('serif') plt.title(ttitle, fontsize='14') plt.xlabel(x_label, fontsize='14') plt.ylabel(y_label, fontsize='14') plt.legend()
def plot_function( curves , n , args ): ## Common plot settings if n == 1: y = curves.copy() if n == 2: y = curves[0] yfit = curves[1] npix = len( y ) y = y.astype( myfloat ) x = np.arange(npix).astype(myfloat) fig = plt.figure(1) rect = fig.patch rect.set_facecolor('white') axescolor = '#f6f6f6' ax = plt.subplot(111,axisbg=axescolor) font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = font1.copy() font.set_family('serif') rc('text',usetex=True) gridLineWidth = 0.2 ax.yaxis.grid(True, linewidth=gridLineWidth, linestyle='-', color='0.05') fig.autofmt_xdate(bottom=0.18) plt.xticks(fontsize=16) plt.yticks(fontsize=16) plt.xlabel(r'\textbf{Pixel index}', fontsize=18,position=(0.5,-0.2)) plt.ylabel( r'\textbf{Grey value}' , fontsize=18,position=(0.5,0.5)) if n == 1: plt.suptitle(r'\textbf{Input line profile}', fontsize=16, fontweight='bold', position=(0.53,0.95)) plt.plot( x , y , linewidth=4 , color='b' ) elif n == 2: plt.suptitle(r'\textbf{Line profile fitted with ERF}', fontsize=16, fontweight='bold', position=(0.53,0.95)) plt.plot( x , y , 'o' , markersize=6 , color='b' ) plt.hold( True ) plt.plot( x , yfit , linewidth=4 , color='r' ) if n == 2 and args.saveplots is not None: fileout = args.saveplots #plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' ) plt.savefig( fileout , facecolor=fig.get_facecolor() , #edgecolor='black' , format='eps', dpi=1000) if args.plot is True: plt.show()
def cal(cfg, science, bias_image, darks, flats): al_science = deepcopy(science) filts = _gather_filters(science) for filt in filts: if filt in flats: files = [x for x in al_science if filt in x] files.sort() for i, f in enumerate(files): header, data = list(map(lambda x: x[0], nkrpy_read(f))) exptime = header['EXPTIME'] if header['EXPTIME'] \ else header['EXPOSURE'] if darks is not None: dark_image = scale_dark(files=darks, fin_exposure=exptime) if bias_image is not None: data -= bias_image if dark_image is not None: data -= dark_image data /= flats[filt] dest = os.path.join(os.getcwd(), cfg.destination) _t = "_".join(f.split("_")[0:2]).split("/")[-1] _temp = f'{dest}/{_t}_{i}.fits' if cfg.createfits: while not nkrpy_write(f'{_temp}', header=header, data=data): continue if cfg.createplot: os.chdir(os.path.join(cfg._cwd, cfg.destination)) fig = plt.figure(figsize=(10, 10)) font0 = FontProperties() font = font0.copy() font.set_weight('bold') ax = fig.add_subplot(1, 1, 1) ax.tick_params(axis='x', labelsize=25) ax.tick_params(axis='y', labelsize=25) ax.get_xaxis().set_ticks([]) ax.get_yaxis().set_ticks([]) plot_image(data, _temp.split('/')[-1], fig, ax, color=False) os.chdir(cfg._cwd) pass
def plot_function( curves , n , args ): ## Common plot settings if n == 1: y = curves.copy() if n == 2: y = curves[0] yfit = curves[1] npix = len( y ) y = y.astype( myfloat ) x = np.arange(npix).astype(myfloat) fig = plt.figure(1) rect = fig.patch rect.set_facecolor('white') axescolor = '#f6f6f6' ax = plt.subplot(111,axisbg=axescolor) font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = font1.copy() font.set_family('serif') rc('text',usetex=True) gridLineWidth = 0.2 ax.yaxis.grid(True, linewidth=gridLineWidth, linestyle='-', color='0.05') fig.autofmt_xdate(bottom=0.18) plt.xticks(fontsize=12) plt.yticks(fontsize=12) plt.xlabel('Pixel index', fontsize=12,position=(0.5,-0.2)) plt.ylabel( 'Grey value' , fontsize=12,position=(0.5,0.5)) if n == 1: plt.title('Input line profile', fontsize=12, fontweight='bold') plt.plot( x , y , linewidth=2 , color='b' ) elif n == 2: plt.title('Line profile fitted with ERF', fontsize=12, fontweight='bold') plt.plot( x , y , linewidth=2 , color='blue' , label='Line profile' ) plt.hold( True ) plt.plot( x , yfit , linewidth=3 , color='r' , label='Erf fit function' ) plt.legend(loc='upper right', shadow=True) if n == 2 and args.saveplots is not None: fileout = args.saveplots plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' , format='eps', dpi=1000) if args.plot is True: plt.show()
def computeMDS(inputFile): new_reader = pd.read_excel(inputFile, index_col=0) size = new_reader.shape for j in range(size[1]): for i in range(size[0]): new_reader.iloc[i,j]=new_reader.iloc[j,i] if (i==j): new_reader.iloc[i,j]= 0.00 adist = np.array(new_reader) amax = np.amax(adist) adist /= amax cities1 = [r.encode('utf-8') for r in list(new_reader.index)] mds = manifold.MDS(n_components=2, dissimilarity="precomputed", random_state=6) results = mds.fit(adist) coords = results.embedding_ plt.subplots_adjust(bottom = 0.1) plt.scatter( coords[:, 0], coords[:, 1], marker = 'o' ) font0 = FontProperties() font = font0.copy() ## Change the size of the font ## Sizes: ['xx-small', 'x-small', 'small', 'medium', 'large','x-large', 'xx-large'] font.set_size('xx-large') for label, x, y in zip(cities1, coords[:, 0], coords[:, 1]): plt.annotate( label, xy = (x, y), xytext = (-20, 20), fontproperties=font, textcoords = 'offset points', ha = 'right', va = 'bottom', bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 0.5), arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0')) plt.savefig('MDS.png') print ('MDS plot can be found at MDS.png')
def __init__(self, axes=None, fig=None, canvas=None): self.axes = axes self.fig = fig self.canvas = canvas self.cmap = colormap.gray self.cmap_reverse = False self.interp = 'nearest' self.title = 'map' self.log_scale = False self.cmap_lo = 0 self.cmap_hi = self.cmap_range = 100 # self.zoombrush = wx.Brush('#141430', wx.SOLID) self.zoombrush = wx.Brush('#040410', wx.SOLID) self.zoompen = wx.Pen('#101090', 3, wx.SOLID) f0 = FontProperties() self.titlefont = f0.copy() self.titlefont.set_size(14)
def add_text(self): """ Text in the plot """ if not self.is_number: return self.clear() try: self.figure.delaxes(self.figure.axes[0]) self.subplot = self.figure.add_subplot(111) self.figure.delaxes(self.figure.axes[1]) except: pass self.subplot.set_xticks([]) self.subplot.set_yticks([]) label = self.content FONT = FontProperties() xpos, ypos = (0.4, 0.5) font = FONT.copy() font.set_size(14) self.textList = [] self.subplot.set_xlim((0, 1)) self.subplot.set_ylim((0, 1)) try: if self.content != '?': float(label) except: self.subplot.set_frame_on(False) try: # mpl >= 1.1.0 self.figure.tight_layout() except: self.figure.subplots_adjust(left=0.1, bottom=0.1) if len(label) > 0 and xpos > 0 and ypos > 0: new_text = self.subplot.text(str(xpos), str(ypos), str(label), fontproperties=font) self.textList.append(new_text)
def plot_location_map(self): """ plot location map of all stations with profile shown on map. """ if self.Model_suite.station_xyfile is None: print "can't get locations, no x y file" return if not hasattr(self, 'profile_origin'): self.get_profile_origin() font0 = FontProperties() font = font0.copy() font.set_family('serif') xy_all = np.genfromtxt( self.Model_suite.station_xyfile, invalid_raise=False)[ :, 1:] plt.plot(xy_all[:, 0], xy_all[:, 1], '.', c='0.5') m, c = self.profile x0, y0 = self.profile_origin if m > 1: y1 = max(self.Model_suite.y) x1 = (y1 - c) / m else: x1 = max(self.Model_suite.x) y1 = m * x1 + c plt.plot([x0, x1], [y0, y1], 'k') plt.plot(self.Model_suite.x, self.Model_suite.y, 'k.') ax = plt.gca() for label in ax.get_yticklabels(): label.set_fontproperties(font) for label in ax.get_xticklabels(): label.set_fontproperties(font)
def onEditLabels(self, event): """ Edit legend label """ try: selected_plot = self.plots[self.graph.selected_plottable] except: selected_plot = self.plots[self.data2D.id] label = selected_plot.label dial = TextDialog(None, -1, 'Change Label', label) if dial.ShowModal() == wx.ID_OK: try: FONT = FontProperties() newlabel = dial.getText() font = FONT.copy() font.set_size(dial.getSize()) font.set_family(dial.getFamily()) font.set_style(dial.getStyle()) font.set_weight(dial.getWeight()) colour = dial.getColor() if len(newlabel) > 0: # update Label selected_plot.label = newlabel self.graph.title(newlabel) self.title_label = selected_plot.label self.title_font = font self.title_color = colour ## render the graph self.subplot.set_title(label=self.title_label, fontproperties=self.title_font, color=self.title_color) self._is_changed_legend_label = True self.subplot.figure.canvas.draw_idle() except: msg = "Add Text: Error. Check your property values..." logger.error(msg) if self.parent is not None: wx.PostEvent(self.parent, StatusEvent(status=msg)) dial.Destroy()
def __init__(self, Model_suite, **input_parameters): self.working_directory = '.' self.station_listfile = None self.station_xyfile = None self.Model_suite = Model_suite self.modeltype = 'model' self.fig_width = 1. self.ax_width = 0.03 self.ax_height = 0.8 self.ax_bottom = 0.1 self.plot_spacing = 0.02 self.ylim = [6, 0] self.title_type = 'single' self.titles = { 'minmax': 'Minimum and maximum resistivity, $\Omega m$', 'aniso': 'Anisotropy in resistivity', # (maximum/minimum resistivity) 'strike': 'Strike angle of minimum resistivity' } #, $^\circ$ self.xlim = { 'minmax': [0.1, 1000], 'aniso': [0, 20], 'strike': [0, 180] } self.fonttype = 'serif' self.label_fontsize = 8 self.title_fontsize = 12 for key in input_parameters.keys(): setattr(self, key, input_parameters[key]) font0 = FontProperties() font = font0.copy() font.set_family(self.fonttype) self.font = font self.working_directory = os.path.abspath(self.working_directory)
def plot_location_map(self): """ plot location map of all stations with profile shown on map. """ if self.Model_suite.station_xyfile is None: print "can't get locations, no x y file" return if not hasattr(self,'profile_origin'): self.get_profile_origin() font0 = FontProperties() font = font0.copy() font.set_family('serif') xy_all = np.genfromtxt(self.Model_suite.station_xyfile,invalid_raise=False)[:,1:] plt.plot(xy_all[:,0],xy_all[:,1],'.',c='0.5') m,c = self.profile x0,y0 = self.profile_origin if m > 1: y1 = max(self.Model_suite.y) x1 = (y1-c)/m else: x1 = max(self.Model_suite.x) y1 = m*x1 + c plt.plot([x0,x1],[y0,y1],'k') plt.plot(self.Model_suite.x,self.Model_suite.y,'k.') ax=plt.gca() for label in ax.get_yticklabels(): label.set_fontproperties(font) for label in ax.get_xticklabels(): label.set_fontproperties(font)
def set_font_label(ax, ylabel, xlabel, title): font0 = FontProperties() font = font0.copy() font.set_family('arial') font.set_size(8) for label in ax.get_xticklabels(): label.set_fontproperties(font) for label in ax.get_yticklabels(): label.set_fontproperties(font) font.set_size(9) ax.set_ylabel(ylabel, fontproperties=font) ax.set_xlabel(xlabel, fontproperties=font, labelpad = 2) font.set_size(title[1]) t = ax.set_title("\n".join(wrap(title[0], width = 26)), fontproperties=font) t.set_y(1.05) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.yaxis.set_ticks_position('left') ax.xaxis.set_ticks_position('bottom') ax.tick_params('both', direction = 'in', length=5, width=1, which='major') ax.locator_params(axis = 'X', nbins = 2)
def plot_info( xdata , ydata , fileout ): ## Define figure enviroment fig = plt.figure(1) rect = fig.patch rect.set_facecolor('white') axescolor = '#f6f6f6' ax = plt.subplot(111,axisbg=axescolor) ## Font setting font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = font1.copy() font.set_family('serif') rc('text',usetex=True) ## Enable grid gridLineWidth = 0.2 ax.yaxis.grid(True, linewidth=gridLineWidth, linestyle='-', color='0.05') ## Marker setup colors = [ 'red' , 'blue' , 'green','blue','black','brown','orange','black','violet'] markers = ['^','s','o','d','1','v'] ## Get xrange and yrange minx = np.min(xdata) maxx = np.max(xdata) miny = np.min(ydata) maxy = np.max(ydata) xinf = minx xsup = maxx yinf = miny ysup = maxy plt.xlim([xinf-0.5,xsup+0.5]) plt.ylim([yinf-0.1,ysup+0.1]) ## Ticks xdensity=40 fig.autofmt_xdate(bottom=0.18) plt.xticks(fontsize=16) plt.yticks(fontsize=16) locs,xlabels = plt.xticks() locs = np.arange(xinf,xsup,xdensity) plt.xticks(locs, map(lambda x: "%d" % x, locs)) ## Set title and axis labeling plt.xlabel(r'\textbf{Pixel position}', fontsize=20,position=(0.5,-0.2)) plt.ylabel( r'\textbf{Pixel value}' , fontsize=20,position=(0.5,0.5)) ## Plot each group data in the same final plot style = 'lines' labels = [ 'SPS' , 'ADMP-E' , 'ADMP-V' , 'ADMP-D' ] for i in range( ydata.shape[0] ): x = xdata y = ydata[i,:] if style == 'points': plt.plot( x , y , markers[i] , markersize=9, color=colors[i] , label=labels[i] ) elif style == 'lines': if i < 0: plt.plot( x , y , color=colors[i] , linestyle='--' , linewidth=4.0 , label=labels[i] ) else: plt.plot( x , y , color=colors[i] , linestyle='-' , linewidth=4.0 , label=labels[i] ) plt.hold( True ) plt.plot( x , yaux , color='blue' , linestyle='-' , linewidth=4.0 , label='PHANTOM' ) ## Add legend plt.legend( loc='upper center', bbox_to_anchor=(0.5, 1.1), ncol=4, fancybox=True, shadow=True ) ## Save plot and show it #plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' ) plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' , format='eps', dpi=1000) plt.show()
def __init__(self, chan, host, fold=19277, nmax=100,NORM=True,sequence=False): self.UPDATE = True self.color = True self.CMAP = ['jet','seismic','Greys','plasma'] self.COLORS = ['b','g','r'] self.channel = chan self.t = time.time() self.NORM = NORM self.shear = 0. self.sequence = sequence self.vmin = -125 self.vmax = 125 self.HORIZ_VAL = 0.05 self.fold = fold self.NMAX = nmax ### To set the first name that has to be recorded ### try: L = C.getoutput('ls Image_*_DSA'+self.channel[0]+' | sort -n').splitlines() temp = array([eval(L[i].split('_')[1]) for i in range(len(L))]) self.flag_save = max(temp) + 1 except: # nothing in the folder already self.flag_save = 1 for i in range(len(self.channel)): exec("self.remove_len1%d = 0" %i) exec("self.remove_len2%d = 1" %i) ### Establish the communication with the scope ### try: self.sock = vxi.Instrument(host) self.sock.write(':WAVeform:TYPE RAW') self.sock.write(':WAVEFORM:BYTEORDER LSBFirst') self.sock.write(':TIMEBASE:MODE MAIN') self.sock.write(':WAVEFORM:SOURCE ' + self.channel[0]) self.sock.write(':WAVEFORM:FORMAT BYTE') except: print "\nWrong IP, Listening port or bad connection => Check cables first\n" sys.exit() ### Verify all channell provided are active ### for i in range(len(self.channel)): if self.query(':'+self.channel[i]+':DISP?')!='1\n': print "\nChannel "+self.channel[i]+' is not active...\n' sys.exit() ################################################################## ################## Start creating the figure ##################### self.fig = figure(figsize=(16,7)) ### trigger the scope for the first time ### self.single() self.load_data() if not(self.NMAX): self.NMAX = int(len(self.data0)/self.fold) self.update_tabs() self.Y0 = 0 if len(self.channel)==1: self.declare_axis_1channel() elif len(self.channel)==2: self.declare_axis_2channel() elif len(self.channel)==3: self.declare_axis_3channel() for i in range(len(self.channel)): if not self.NORM: exec("self.im%d = self.ax%d.imshow(self.folded_data%d, interpolation='nearest', aspect='auto',origin='lower', vmin=self.vmin, vmax=self.vmax)" %(i,i,i)) else: exec("self.im%d = self.ax%d.imshow(self.folded_data%d, interpolation='nearest', aspect='auto',origin='lower', vmin=self.folded_data%d.min(), vmax=self.folded_data%d.max())" %(i,i,i,i,i)) for i in range(len(self.channel)): exec("self.cursor%d = Cursor(self.ax%d, useblit=True, color='red', linewidth=2)" %(i,i)) self.axhh = axes([0.02,0.25,0.12,0.62]) for i in range(len(self.channel)): exec("self.hline%d, = self.axh%d.plot(self.folded_data%d[self.Y0,:])" %(i,i,i)) exec("self.axh%d.set_xlim(0,len(self.folded_data%d[0,:]))" %(i,i)) exec("self.hhline%d, = self.axhh.plot(self.folded_data%d.mean(1),arange(self.NMAX),self.COLORS[i])" %(i,i)) self.axhh.set_ylim(0,self.NMAX-1) if not self.NORM: for i in range(len(self.channel)): exec("self.axh%d.set_ylim(self.vmin, self.vmax)" %i) self.axhh.set_xlim(self.vmin, self.vmax) else: for i in range(len(self.channel)): exec("self.axh%d.set_ylim(self.folded_data%d.min(), self.folded_data%d.max())" %(i,i,i)) if len(self.channel)==1: LIM_MIN = self.folded_data0.mean(1).min() LIM_MAX = self.folded_data0.mean(1).max() elif len(self.channel)==2: LIM_MIN = min(self.folded_data0.mean(1).min(),self.folded_data1.mean(1).min()) LIM_MAX = max(self.folded_data0.mean(1).max(),self.folded_data1.mean(1).max()) elif len(self.channel)==3: LIM_MIN = min(self.folded_data0.mean(1).min(),self.folded_data1.mean(1).min(),self.folded_data2.mean(1).min()) LIM_MAX = max(self.folded_data0.mean(1).max(),self.folded_data1.mean(1).max(),self.folded_data2.mean(1).max()) self.axhh.set_xlim(LIM_MIN-1,LIM_MAX+1) # create 'remove_len1' slider for i in range(len(self.channel)): exec("self.remove_len1%d_slider = Slider(self.remove_len1%d_sliderax,'beg',0.,self.fold,self.remove_len1%d,'%s')" %(i,i,i,'%d')) exec("self.remove_len1%d_slider.on_changed(self.update_tab)" %i) # create 'remove_len2' slider for i in range(len(self.channel)): exec("self.remove_len2%d_slider = Slider(self.remove_len2%d_sliderax,'end',1.,self.fold,self.remove_len2%d,'%s')" %(i,i,i,'%d')) exec("self.remove_len2%d_slider.on_changed(self.update_tab)" %i) # create 'shear' slider self.shear_sliderax = axes([0.175,0.96,0.775,0.02]) self.shear_slider = Slider(self.shear_sliderax,'Shear',-0.5,0.5,self.shear,'%1.2f') self.shear_slider.on_changed(self.update_shear) #if self.sequence: VERT_VAL = -6 font0 = FontProperties() font1 = font0.copy() font1.set_weight('bold') mpl.pyplot.text(-0.71,7+VERT_VAL,'Sequence mode:',fontsize=18,fontproperties=font1) mpl.pyplot.text(-0.71,3+VERT_VAL,'"b" to toggle it then:\n "y" to save\n "n" to next',fontsize=18) mpl.pyplot.text(-0.71,-32+VERT_VAL,'Useful keys:',fontsize=18,fontproperties=font1) mpl.pyplot.text(-0.71,-40+VERT_VAL,'"c" to change colormap\n "v" to change vertical\n /colorscale\n " " to pause\n "S" to save trace\n and picture\n "q" to exit',fontsize=18) #mpl.pyplot.text(-0.5,-27+VERT_VAL,'Sequence mode:',fontsize=18,fontproperties=font1) #mpl.pyplot.text(-0.37,-29.5+VERT_VAL,'"b" to toggle it then:\n "y" to save\n "n" to next',fontsize=18) #mpl.pyplot.text(0.15,-27+VERT_VAL,'Useful keys:',fontsize=18,fontproperties=font1) #mpl.pyplot.text(0.25,-31.5+VERT_VAL,'"c" to change colormap\n "v" to change vertical/colorscale\n " " to pause\n "S" to save trace and picture\n "q" to exit',fontsize=18) cid = self.fig.canvas.mpl_connect('motion_notify_event', self.mousemove) cid2 = self.fig.canvas.mpl_connect('key_press_event', self.keypress) self.axe_toggledisplay = self.fig.add_axes([0.,0.,1.0,0.02]) self.plot_circle(0,0,2,fc='#00FF7F') mpl.pyplot.axis('off') gobject.idle_add(self.update_plot) show()
import matplotlib.colors as mcolors import matplotlib as mpl from matplotlib.font_manager import FontProperties font = {'family' : 'normal', 'weight' : 'bold'} #matplotlib.rc('font',**{'family':'Times', 'sans-serif':['Times']}) #matplotlib.rc('text', usetex = True) #matplotlib.rc('font', **font) plt.rcParams["font.family"] = "arial" font0 = FontProperties() font = font0.copy() weight = "bold" font.set_weight(weight) #Color_list = [(0.306, 0.431+0.1, 0.545+0.3), (0.839+0.025, 0.60+0.05, 0.20), (0.839+0.16, 0.363, 0.35)] Color_list = [(0.651, 0.325, 0.529), (0.839+0.025, 0.60+0.05, 0.20), (0.839+0.16, 0.363, 0.35)] # Determine slope and intercept from Fitting-coral-cover.r # Data for GBR from source1: De'ath et al. 2012 source1Col = "#006024"#(0.173, 0.375, 0.187) GBR_Year_source1 = array([1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012]) GBR_Cover_source1 = array([27.6392, 22.7458, 26.3999, 20.5105, 19.6836, 21.1800, 23.0085, 23.4262, 22.1840, 23.1825, 25.7579, 23.1051, 20.8673, 25.4344, 24.2754, 23.0333, 20.6293,17.9764,17.4814, 21.7995, 16.3249,20.4771,15.5005, 18.5738,
def transitVisibilityPlot(allData, markTransit=False, plotLegend=True, showMoonDist=True, print2file=False): """ Plot the visibility of transits. This function can conveniently be used with the output of the transitTimes function. Parameters ---------- allData : dictionary Essentially the output of `transitTimes`. A dictionary mapping consecutive numbers (one per transit) to another dictionary providing the following keys: ============ ==================================================== Key Description ------------ ---------------------------------------------------- Planet name Name of the planet Transit jd (Only if `markTransit is True) Array giving JD of start, mid-time, and end of transit. Obs jd Array specifying the HJD of the start, center and end of the observation. Obs cal Equivalent to 'Obs jd', but in the form of the calendar date. In particular, for each date, a list containing [Year, month, day, fractional hours] is given. Obs coord East longitude [deg], latitude [deg], and altitude [m] of the observatory. Star ra Right ascension of the star [deg]. Star dec Declination of the star [deg]. ============ ==================================================== .. note:: To use the list created by transitTimes, the LONGITUDE and LATITUDE of the observatory location must have been specified. markTransit : boolean, optional If True (default is False), the in-transit times will be clearly indicated in the plot. Note that this would not be the case otherwise, which is particularly important if extra off-transit time before and after the transit has been requested. showMoonDist : boolean, optional If True (default), the Moon distance will be shown. print2file : boolean, optional If True, the plot will be dumped to a png-file named: "transitVis-"[planetName].png. The default is False. """ from PyAstronomy.pyasl import _ic if not _ic.check["matplotlib"]: raise(PE.PyARequiredImport("matplotlib is not installed.", \ where="transitVisibilityPlot", \ solution="Install matplotlib (http://matplotlib.org/)")) import matplotlib import matplotlib.pylab as plt from mpl_toolkits.axes_grid1 import host_subplot from matplotlib.ticker import MultipleLocator from matplotlib.font_manager import FontProperties from matplotlib import rcParams rcParams['xtick.major.pad'] = 12 if len(allData.keys()) == 0: raise(PE.PyAValError("Input dictionary is empty", \ where="transitVisibilityPlot", \ solution=["Use `transitTimes` to generate input dictionary", "Did you forget to supply observer's location?", \ "If you used `transitTime`, you might need to change the call argument (e.g., times)"])) # Check whether all relevant data have been specified reqK = ["Obs jd", "Obs coord", "Star ra", "Star dec", "Obs cal", "Planet name"] if markTransit: reqK.append("Transit jd") missingK = [] for k in reqK: if not k in allData[1].keys(): missingK.append(k) if len(missingK) > 0: raise(PE.PyAValError("The following keys are missing in the input dictionary: " + ', '.join(missingK), \ where="transitVisibilityPlot", \ solution="Did you specify observer's location in `transitTimes`?")) fig = plt.figure(figsize=(15,10)) fig.subplots_adjust(left=0.07, right=0.8, bottom=0.15, top=0.88) ax = host_subplot(111) font0 = FontProperties() font1 = font0.copy() font0.set_family('sans-serif') font0.set_weight('light') font1.set_family('sans-serif') font1.set_weight('medium') for n in allData.keys(): # JD array jdbinsize = 1.0/24./10. jds = np.arange(allData[n]["Obs jd"][0], allData[n]["Obs jd"][2], jdbinsize) # Get JD floating point jdsub = jds - np.floor(jds[0]) # Get alt/az of object altaz = eq2hor.eq2hor(jds, np.ones(jds.size)*allData[n]["Star ra"], np.ones(jds.size)*allData[n]["Star dec"], \ lon=allData[n]["Obs coord"][0], lat=allData[n]["Obs coord"][1], \ alt=allData[n]["Obs coord"][2]) # Get alt/az of Sun sunpos_altaz = eq2hor.eq2hor(jds, np.ones(jds.size)*allData[n]["Sun ra"], np.ones(jds.size)*allData[n]["Sun dec"], \ lon=allData[n]["Obs coord"][0], lat=allData[n]["Obs coord"][1], \ alt=allData[n]["Obs coord"][2]) # Define plot label plabel = "[%02d] %02d.%02d.%4d" % (n, allData[n]["Obs cal"][0][2], \ allData[n]["Obs cal"][0][1], allData[n]["Obs cal"][0][0]) # Find periods of: day, twilight, and night day = np.where( sunpos_altaz[0] >= 0. )[0] twi = np.where( np.logical_and(sunpos_altaz[0] > -18., sunpos_altaz[0] < 0.) )[0] night = np.where( sunpos_altaz[0] <= -18. )[0] if (len(day) == 0) and (len(twi) == 0) and (len(night) == 0): print print "transitVisibilityPlot - no points to draw for date %2d.%2d.%4d" \ % (allData[n]["Obs cal"][0][2], allData[n]["Obs cal"][0][1], allData[n]["Obs cal"][0][0]) print "Skip transit and continue with next" print continue mpos = moonpos(jds) mpha = moonphase(jds) mpos_altaz = eq2hor.eq2hor(jds, mpos[0], mpos[1], lon=allData[n]["Obs coord"][0], \ lat=allData[n]["Obs coord"][1], alt=allData[n]["Obs coord"][2]) moonind = np.where( mpos_altaz[0] > 0. )[0] if showMoonDist: mdist = getAngDist(mpos[0], mpos[1], np.ones(jds.size)*allData[n]["Star ra"], \ np.ones(jds.size)*allData[n]["Star dec"]) bindist = int((2.0/24.)/jdbinsize) firstbin = np.random.randint(0,bindist) for mp in range(0, int(len(jds)/bindist)): bind = firstbin+float(mp)*bindist ax.text(jdsub[bind], altaz[0][bind]-1., str(int(mdist[bind]))+r"$^\circ$", ha="center", va="top", \ fontsize=8, stretch='ultra-condensed', fontproperties=font0, alpha=1.) if markTransit: # Mark points within transit. These may differ from that pertaining to the # observation if an extra offset was given to provide off-transit time. transit_only_ind = np.where( np.logical_and(jds >= allData[n]["Transit jd"][0], \ jds <= allData[n]["Transit jd"][2]) )[0] ax.plot( jdsub[transit_only_ind], altaz[0][transit_only_ind], 'g', linewidth=6, alpha=.3) if len(twi) > 1: # There are points in twilight linebreak = np.where( (jdsub[twi][1:]-jdsub[twi][:-1]) > 2.0*jdbinsize)[0] if len(linebreak) > 0: plotrjd = np.insert(jdsub[twi], linebreak+1, np.nan) plotdat = np.insert(altaz[0][twi], linebreak+1, np.nan) ax.plot( plotrjd, plotdat, "-", color='#BEBEBE', linewidth=1.5) else: ax.plot( jdsub[twi], altaz[0][twi], "-", color='#BEBEBE', linewidth=1.5) ax.plot( jdsub[night], altaz[0][night], 'k', linewidth=1.5, label=plabel) ax.plot( jdsub[day], altaz[0][day], color='#FDB813', linewidth=1.5) altmax = np.argmax(altaz[0]) ax.text( jdsub[altmax], altaz[0][altmax], str(n), color="b", fontsize=14, \ fontproperties=font1, va="bottom", ha="center") if n == 29: ax.text( 1.1, 1.0-float(n)*0.04, "too many transits", ha="left", va="top", transform=ax.transAxes, \ fontsize=10, fontproperties=font0, color="r") else: ax.text( 1.1, 1.0-float(n)*0.04, plabel, ha="left", va="top", transform=ax.transAxes, \ fontsize=12, fontproperties=font0, color="b") ax.text( 1.1, 1.03, "Start of observation", ha="left", va="top", transform=ax.transAxes, \ fontsize=12, fontproperties=font0, color="b") ax.text( 1.1, 1.0, "[No.] Date", ha="left", va="top", transform=ax.transAxes, \ fontsize=12, fontproperties=font0, color="b") axrange = ax.get_xlim() ax.set_xlabel("UT [hours]") if axrange[1]-axrange[0] <= 1.0: jdhours = np.arange(0,3,1.0/24.) utchours = (np.arange(0,72,dtype=int)+12)%24 else: jdhours = np.arange(0,3,1.0/12.) utchours = (np.arange(0,72, 2, dtype=int)+12)%24 ax.set_xticks(jdhours) ax.set_xlim(axrange) ax.set_xticklabels(utchours, fontsize=18) # Make ax2 responsible for "top" axis and "right" axis ax2 = ax.twin() # Set upper x ticks ax2.set_xticks(jdhours) ax2.set_xticklabels(utchours, fontsize=18) ax2.set_xlabel("UT [hours]") # Horizon angle for airmass airmass_ang = np.arange(5.,90.,5.) geo_airmass = airmass.airmassPP(90.-airmass_ang) ax2.set_yticks(airmass_ang) airmassformat = [] for t in range(geo_airmass.size): airmassformat.append("%2.2f" % geo_airmass[t]) ax2.set_yticklabels(airmassformat, rotation=90) ax2.set_ylabel("Relative airmass", labelpad=32) ax2.tick_params(axis="y", pad=10, labelsize=10) plt.text(1.015,-0.04, "Plane-parallel", transform=ax.transAxes, ha='left', \ va='top', fontsize=10, rotation=90) ax22 = ax.twin() ax22.set_xticklabels([]) ax22.set_frame_on(True) ax22.patch.set_visible(False) ax22.yaxis.set_ticks_position('right') ax22.yaxis.set_label_position('right') ax22.spines['right'].set_position(('outward', 25)) ax22.spines['right'].set_color('k') ax22.spines['right'].set_visible(True) airmass2 = np.array(map(lambda ang: airmass.airmassSpherical(90. - ang, allData[n]["Obs coord"][2]), \ airmass_ang)) ax22.set_yticks(airmass_ang) airmassformat = [] for t in range(airmass2.size): airmassformat.append("%2.2f" % airmass2[t]) ax22.set_yticklabels(airmassformat, rotation=90) ax22.tick_params(axis="y", pad=10, labelsize=10) plt.text(1.045,-0.04, "Spherical+Alt", transform=ax.transAxes, ha='left', va='top', \ fontsize=10, rotation=90) ax3 = ax.twiny() ax3.set_frame_on(True) ax3.patch.set_visible(False) ax3.xaxis.set_ticks_position('bottom') ax3.xaxis.set_label_position('bottom') ax3.spines['bottom'].set_position(('outward', 50)) ax3.spines['bottom'].set_color('k') ax3.spines['bottom'].set_visible(True) ltime, ldiff = localtime.localTime(utchours, np.repeat(allData[n]["Obs coord"][0], len(utchours))) jdltime = jdhours - ldiff/24. ax3.set_xticks(jdltime) ax3.set_xticklabels(utchours) ax3.set_xlim([axrange[0],axrange[1]]) ax3.set_xlabel("Local time [hours]") ax.yaxis.set_major_locator(MultipleLocator(15)) ax.yaxis.set_minor_locator(MultipleLocator(5)) yticks = ax.get_yticks() ytickformat = [] for t in range(yticks.size): ytickformat.append(str(int(yticks[t]))+r"$^\circ$") ax.set_yticklabels(ytickformat, fontsize=20) ax.set_ylabel("Altitude", fontsize=18) yticksminor = ax.get_yticks(minor=True) ymind = np.where( yticksminor % 15. != 0. )[0] yticksminor = yticksminor[ymind] ax.set_yticks(yticksminor, minor=True) m_ytickformat = [] for t in range(yticksminor.size): m_ytickformat.append(str(int(yticksminor[t]))+r"$^\circ$") ax.set_yticklabels(m_ytickformat, minor=True) ax.yaxis.grid(color='gray', linestyle='dashed') ax.yaxis.grid(color='gray', which="minor", linestyle='dotted') ax2.xaxis.grid(color='gray', linestyle='dotted') plt.text(0.5,0.95,"Transit visibility of "+allData[n]["Planet name"], \ transform=fig.transFigure, ha='center', va='bottom', fontsize=20) if plotLegend: line1 = matplotlib.lines.Line2D((0,0),(1,1), color='#FDB813', linestyle="-", linewidth=2) line2 = matplotlib.lines.Line2D((0,0),(1,1), color='#BEBEBE', linestyle="-", linewidth=2) line3 = matplotlib.lines.Line2D((0,0),(1,1), color='k', linestyle="-", linewidth=2) line4 = matplotlib.lines.Line2D((0,0),(1,1), color='g', linestyle="-", linewidth=6, alpha=.3) if markTransit: lgd2 = plt.legend((line1,line2,line3, line4),("day","twilight","night","transit",), \ bbox_to_anchor=(0.88, 0.15), loc=2, borderaxespad=0.,prop={'size':12}, fancybox=True) else: lgd2 = plt.legend((line1,line2,line3),("day","twilight","night",), \ bbox_to_anchor=(0.88, 0.13), loc=2, borderaxespad=0.,prop={'size':12}, fancybox=True) lgd2.get_frame().set_alpha(.5) targetco = r"Target coordinates: (%8.4f$^\circ$, %8.4f$^\circ$)" % \ (allData[n]["Star ra"], allData[n]["Star dec"]) obsco = "Obs coord.: (%8.4f$^\circ$, %8.4f$^\circ$, %4d m)" % \ (allData[n]["Obs coord"][0], allData[n]["Obs coord"][1], allData[n]["Obs coord"][2]) plt.text(0.01,0.97, targetco, transform=fig.transFigure, ha='left', va='center', fontsize=10) plt.text(0.01,0.95, obsco, transform=fig.transFigure, ha='left', va='center', fontsize=10) if print2file: outfile = "transVis-"+allData[n]["Planet name"].replace(" ", "")+".png" plt.savefig(outfile, format="png", dpi=300) else: plt.show()
## ## first subgrid ## ############################################## # EKG Axis ax_ekg = plt.subplot(gs00[0, 0]) ekg_img = mpimg.imread('/home/jurek/git_repos/doctorate/Doktorat/graph/ekg.png') ax_ekg.imshow(ekg_img) #, aspect='auto') #, origin='lower') ax_ekg.set_axis_off() ax_ekg.set_frame_on(False) ax_ekg.autoscale_view(tight=True) alignment = {'horizontalalignment':'left', 'verticalalignment':'center'} text_fontsize = 20 font_1 = font_0.copy() font_1.set_size(text_fontsize) font_1.set_weight('bold') ax_ekg.text(0.1, 0.1, u"EKG", fontproperties=font_1, **alignment) #################################### ax_arrow_left = plt.subplot(gs00[0, 1]) ax_arrow_left.set_axis_off() ax_arrow_left.set_frame_on(False) arrow_left = mpatches.Arrow(0.0, 0.5, 0.9, 0.0, width=0.25, color="black", lw=4) #, label="Dane z EKG") arrow_left.set_fill(False) ax_arrow_left.add_patch(arrow_left) #empty plot create_empty_plot(gs00[0,2])
def plot_multiple_roc(rocList, title='', labels=None, include_baseline=True, equal_aspect=True, lengend_inside=True, file_name=None): """ Plots multiple ROC curves on the same chart. Parameters: rocList: the list of ROCData objects title: The tile of the chart labels: The labels of each ROC curve include_baseline: if it's True include the random baseline equal_aspect: keep equal aspect for all roc curves """ from matplotlib.font_manager import FontProperties font0 = FontProperties() cust_font = font0.copy() cust_font.set_family('arial') cust_font.set_size(12) pylab.clf() pylab.ylim((0,1)) pylab.xlim((0,1)) pylab.xticks(pylab.arange(0,1.1,.1)) pylab.yticks(pylab.arange(0,1.1,.1)) pylab.grid(True) if equal_aspect: cax = pylab.gca() cax.set_aspect('equal') pylab.tick_params(axis='both', which='major', labelsize=10) pylab.tick_params(axis='both', which='minor', labelsize=10) pylab.xlabel('False Positive Rate', fontproperties=cust_font) # 1 - True Negative Rate pylab.ylabel('True Positive Rate (Recall)', fontproperties=cust_font) # Sensitivity pylab.title(title) if not labels: labels = [ '' for x in rocList] _remove_duplicate_styles(rocList) for ix, r in enumerate(rocList): pylab.plot([x[0] for x in r.derived_points], [y[1] for y in r.derived_points], r.linestyle, linewidth=1, label=labels[ix] + ', AUC: %.2f' % r.auc()) if include_baseline: pylab.plot([0.0,1.0], [0.0, 1.0], 'k-', label= 'Random Guess') # pylab.annotate('Line of Perfect Classification', xy=(0, 1), xytext=(.1, .9), # arrowprops=dict(facecolor='black', shrink=0.05)) # pylab.annotate('Line of No-discrimination', xy=(0.55, 0.55), xytext=(.58, .5), # arrowprops=dict(facecolor='black', shrink=0.05)) if labels: if lengend_inside: # to place inside the plot pylab.legend(loc='lower right', prop={'size':12, 'family':'arial'}) else: # to place right outside pylab.legend(bbox_to_anchor=(1.02, 1), loc=2, borderaxespad=0., prop={'size':9, 'family':'arial'}) if file_name: pylab.savefig(file_name, dpi=700, bbox_inches='tight', pad_inches=0.1) else: pylab.show()
import matplotlib.pyplot as plt # My phone's internal storage usage by file type file_types_and_usage = ( ('image | jpeg', 1483), ('video | mp4', 678), ('audio | mpeg', 642), ('audio | ogg', 405), ('application | octet-stream', 103), ('other', 247), ) # Prepare fonts font1 = FontProperties() font1.set_family('Source Han Sans TW') font2 = font1.copy() font2.set_size('small') # Prepare subplots fig1, ax1 = plt.subplots() # Draw pie chart _, texts, autotexts = ax1.pie( # sizes [ftu[1] for ftu in file_types_and_usage], labels=[ftu[0] for ftu in file_types_and_usage], autopct='%1.f%%', pctdistance=0.7, startangle=90 ) # Set equal aspect ratio to ensure that pie is drawn as a circle
def __init__(self, chan, host, fold=19277, nmax=100,NORM=True,sequence=False): self.UPDATE = True self.color = True self.channel = chan self.t = time.time() self.NORM = NORM self.NMAX = nmax self.fold = fold self.shear = 0. self.sequence = sequence self.vmin = -125 self.vmax = 125 ### To set the first name that has to be recorded ### try: L = C.getoutput('ls Image_*_DSA'+self.channel+' | sort -n').splitlines() temp = array([eval(L[i].split('_')[1]) for i in range(len(L))]) self.flag_save = max(temp) + 1 except: # nothing in the folder already self.flag_save = 1 self.remove_len1 = 0 #6500 # 0 previously self.remove_len2 = 1 #12300 # 1 previously try: self.sock = vxi.Instrument(host) self.sock.write(':WAVeform:TYPE RAW') self.sock.write(':WAVEFORM:BYTEORDER LSBFirst') self.sock.write(':TIMEBASE:MODE MAIN') self.sock.write(':WAVEFORM:SOURCE ' + chan) self.sock.write(':WAVEFORM:FORMAT BYTE') except: print "\nWrong IP, Listening port or bad connection => Check cables first\n" sys.exit() if self.query(':'+self.channel+':DISP?')!='1\n': print "\nChannel "+chan[-1]+' is not active...\n' sys.exit() self.fig = figure(figsize=(16,7)) ### trigger the scope for the first time ### self.single() self.load_data() self.update_tabs() self.Y0 = 0 self.ax = axes([0.1,0.4,0.8,0.47]) if not self.NORM: self.im = self.ax.imshow(self.folded_data, interpolation='nearest', aspect='auto', origin='lower', vmin=self.vmin, vmax=self.vmax) else: self.im = self.ax.imshow(self.folded_data, interpolation='nearest', aspect='auto', origin='lower', vmin=self.folded_data.min(), vmax=self.folded_data.max()) self.cursor = Cursor(self.ax, useblit=True, color='red', linewidth=2) self.axh = axes([0.1,0.05,0.8,0.2]) self.hline, = self.axh.plot(self.folded_data[self.Y0,:]) self.axh.set_xlim(0,len(self.folded_data[0,:])) if not self.NORM: self.axh.set_ylim(self.vmin, self.vmax) else: self.axh.set_ylim(self.folded_data.min(), self.folded_data.max()) # create 'remove_len1' slider self.remove_len1_sliderax = axes([0.1,0.96,0.8,0.02]) self.remove_len1_slider = Slider(self.remove_len1_sliderax,'beg',0.,self.fold,self.remove_len1,'%d') self.remove_len1_slider.on_changed(self.update_tab) # create 'remove_len2' slider self.remove_len2_sliderax = axes([0.1,0.92,0.8,0.02]) self.remove_len2_slider = Slider(self.remove_len2_sliderax,'end',1.,self.fold,self.remove_len2,'%d') self.remove_len2_slider.on_changed(self.update_tab) # create 'shear' slider self.shear_sliderax = axes([0.1,0.88,0.8,0.02]) self.shear_slider = Slider(self.shear_sliderax,'Shear',-1,1,self.shear,'%1.2f') self.shear_slider.on_changed(self.update_shear) #if self.sequence: font0 = FontProperties() font1 = font0.copy() font1.set_weight('bold') mpl.pyplot.text(-1.1,-27,'Sequence mode:',fontsize=18,fontproperties=font1) mpl.pyplot.text(-0.75,-30,'"b" to toggle it then:\n "y" to save\n "n" to next',fontsize=18) mpl.pyplot.text(0.25,-27,'Useful keys:',fontsize=18,fontproperties=font1) mpl.pyplot.text(0.5,-31,'"v" to change vertical/colorscale\n " " to pause\n "S" to save trace and picture\n "q" to exit',fontsize=18) cid = self.fig.canvas.mpl_connect('motion_notify_event', self.mousemove) cid2 = self.fig.canvas.mpl_connect('key_press_event', self.keypress) self.axe_toggledisplay = self.fig.add_axes([0.43,0.27,0.14,0.1]) self.plot_circle(0,0,2,fc='#00FF7F') mpl.pyplot.axis('off') gobject.idle_add(self.update_plot) show()
def bubblePrices(city): irrelevantAttributes = [ "City", "Monthly Pass", "Volkswagen Golf", "Toyota Corolla", "Basic Utilities", "Internet", "Fitness Club", "Tennis Court Rent", "Preschool Month", "Primary School Year", "Rent 1 Bedroom Center", "Rent 1 Bedroom Outside Center", "Rent 3 Bedrooms Center", "Rent 3 Bedrooms Outside Center", "Price m2 Center", "Price m2 Outside Center", "Average Monthly Salary After Tax", "Mortgage Interest Rate" ] fyrirspurn = "SELECT * FROM Prices where City = " + '"' + beforeComma( city) + '"' print(fyrirspurn) query = cur.execute(fyrirspurn) cols = [column[0] for column in query.description] results = pd.DataFrame.from_records(data=query.fetchall(), columns=cols) results.drop(columns=irrelevantAttributes, inplace=True) print(results.columns.values) values = list(results.loc[0, :])[0:] names = [] j = 0 for i in cols: if i not in irrelevantAttributes: names.append(i) j = j + 1 fig, ax = plt.subplots(subplot_kw=dict(axisbg='#EEEEEE'), figsize=(9, 7)) fyrirspurn = "SELECT * FROM Prices where city = " + '"' + beforeComma( city) + '"' print(fyrirspurn) query = cur.execute(fyrirspurn) cols = [column[0] for column in query.description] results = pd.DataFrame.from_records(data=query.fetchall(), columns=cols) results.drop(columns=irrelevantAttributes, inplace=True) values = list(results.loc[0, :])[0:] names = [] j = 0 for i in cols: if i not in irrelevantAttributes: names.append(i) j = j + 1 fig, ax = plt.subplots(subplot_kw=dict(axisbg='#EEEEEE'), figsize=(9, 7)) N = len(values) col = np.random.rand(N) print(col) end = math.ceil(math.sqrt(N)) # þurfum að gera samsvörun step = end / N x = np.arange(0, end, step) hnitx = [] for i in range(3, end + 2): for j in range(end): if (len(hnitx) == N): break hnitx.append(i) hnity = [] for i in range(N): hnity.append(i % end) #plt.figure(figsize=(9,9)) hnitx = [x + random.random() / 4 for x in hnitx] hnity = [y + random.random() / 4 for y in hnity] mynd = ax.scatter(hnitx, hnity, c=col, alpha=0.5, s=[x * 20 for x in values]) plt.xlim((0.8, end + 2)) plt.xticks([], []) plt.yticks([], []) fig.patch.set_visible(False) ax.axis('off') font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = { 'family': 'serif', 'color': 'darkred', 'weight': 'normal', 'size': 13, } for label, x, y in zip(names, hnitx, hnity): r = random.random() * 2 plt.text(x + 0.22, y + 0.25, label, ha='right', va='bottom', fontdict=font) plt.plot([x + 0.22, x], [y + 0.25, y], 'k-', linewidth=0.5) # þarf að sjá font = { 'family': 'serif', 'color': 'black', 'weight': 'normal', 'size': 18, } ax.set_title("Bubble chart of prices of goods in " + city + " (area = €)", fontdict=font) # vantar að staðfesta að röðin sé eins? tooltip = mpld3.plugins.PointLabelTooltip( mynd, labels=[str(x) + "€" for x in values]) mpld3.plugins.connect(fig, tooltip) mpld3.show()
width = 14000000 height = 10000000 #m = Basemap(width=width,height=height,\ # resolution='c',projection='aeqd',\ # lat_0=lat_0,lon_0=lon_0) #m = Basemap(resolution='c',projection='aeqd',lat_0=lat_0,lon_0=lon_0) #m = Basemap(width=width,height=height,\ # resolution='c',projection='aea',\ # lat_0=lat_0,lon_0=lon_0) m = Basemap(resolution='c', projection='mbtfpq', lon_0=lon_0) #m = Basemap(resolution='c',projection='moll',lon_0=lon_0) #m = Basemap(resolution='c',projection='ortho',lon_0=lon_0,lat_0=lat_0) #m = Basemap(resolution='c',projection='cyl',llcrnrlat=llcrnrlat,llcrnrlon=llcrnrlon,urcrnrlat=urcrnrlat,urcrnrlon=urcrnrlon) p = FontProperties() font1 = p.copy() font1.set_size('small') # draw coasts and fill continents. m.drawcoastlines(linewidth=0.5) m.fillcontinents() m.drawparallels(arange(-80, 81, 10), labels=[1, 1, 0, 0], fontproperties=font1, labelstyle="+/-") m.drawmeridians(arange(-180, 180, 20), labels=[0, 0, 0, 1], fontproperties=font1, labelstyle="+/-") #m.bluemarble() m.drawmapboundary()
def drawing(ax, proj, CFIELD): # ========================== ''' Draw a 2D vector plot. Option of vectors or stream function''' __version__ = "1.0" __author__ = "Quim Ballabrerera" __date__ = "June 2017" import numpy as np import cartopy #EG Remember that CFIELD.VEL.PLOT.MESSAGE may serve to collect # messages fnt0 = FontProperties() font = fnt0.copy() font.set_size('x-large') if CFIELD.PLOT.DRAWING_MODE.get() == 2: # -------------------------------------------- STREAMFUNCTION CFIELD.PLOT.MESSAGE += "Plot STREAMFUNCTION" + str(CFIELD.PLOT.MESSAGE) if isinstance(proj, cartopy.crs.PlateCarree): #EG this call to quiver with zorder negative is needed to proceed #EG with the streamplot. Need further analysis. Cartopy 0.17 #EG Matplotlib 3.1.1 #ax.quiver(CFIELD.U.xx, CFIELD.U.yy, CFIELD.U.data, CFIELD.V.data, \ # transform=proj,zorder=-1) ax.streamplot(CFIELD.U.xx, CFIELD.U.yy, \ CFIELD.U.data, CFIELD.V.data, \ color=CFIELD.PLOT.STREAM_COLOR.get(), \ linewidth=CFIELD.PLOT.STREAM_WIDTH.get(), \ density=CFIELD.PLOT.STREAM_DENSITY.get(), \ zorder=CFIELD.PLOT.ZORDER.get(), \ transform=proj) else: CFIELD.PLOT.MESSAGE += 'VECTORPLOT: WARNING: Streamplot only works with Cylindircal Projection' #print('VECTORPLOT: WARNING: Streamplot only works with Cylindircal Projection') else: # Check if reprocessing data is required: if CFIELD.reprocess == False: if CFIELD.PLOT.GRID_MODE.get() != CFIELD.GRID_MODE_0: CFIELD.reprocess = True if CFIELD.PLOT.CURRENT_DX.get() != CFIELD.CURRENT_DX_0: CFIELD.reprocess = True if CFIELD.PLOT.CURRENT_DY.get() != CFIELD.CURRENT_DY_0: CFIELD.reprocess = True if CFIELD.PLOT.CURRENT_NX.get() != CFIELD.CURRENT_NX_0: CFIELD.reprocess = True if CFIELD.PLOT.CURRENT_NY.get() != CFIELD.CURRENT_NY_0: CFIELD.reprocess = True if CFIELD.reprocess: CFIELD.PLOT.MESSAGE += 'VECTORPLOT: processing data\n' CFIELD.reprocess = False CFIELD.GRID_MODE_0 = CFIELD.PLOT.GRID_MODE.get() CFIELD.CURRENT_DX_0 = CFIELD.PLOT.CURRENT_DX.get() CFIELD.CURRENT_DY_0 = CFIELD.PLOT.CURRENT_DY.get() CFIELD.CURRENT_NX_0 = CFIELD.PLOT.CURRENT_NX.get() CFIELD.CURRENT_NY_0 = CFIELD.PLOT.CURRENT_NY.get() if CFIELD.PLOT.GRID_MODE.get() == 0: CFIELD.PLOT.MESSAGE += "EG VECTORS: original or decimated grid" #print("EG VECTORS: original or decimated grid") dx = CFIELD.PLOT.CURRENT_DX.get() dy = CFIELD.PLOT.CURRENT_DY.get() CFIELD.xplt, CFIELD.yplt = CFIELD.U.xx[::dy, :: dx], CFIELD.U.yy[:: dy, :: dx] # Grid stored in U CFIELD.uplt, CFIELD.vplt = CFIELD.U.data[::dy, :: dx], CFIELD.V.data[:: dy, :: dx] else: CFIELD.PLOT.MESSAGE += "EG VECTORS: fixed grid" #print("EG VECTORS: fixed grid") #EG The method "linear" in interpol.griddata is mandatory. Other #EG choices provides strange behaviour lonmin, lonmax, latmin, latmax = ax.get_extent() CFIELD.xplt = np.linspace(lonmin, lonmax, CFIELD.PLOT.CURRENT_NX.get()) CFIELD.yplt = np.linspace(latmin, latmax, CFIELD.PLOT.CURRENT_NY.get()) n_lon, n_lat = np.meshgrid(CFIELD.xplt, CFIELD.yplt) CFIELD.uplt = interpol.griddata((CFIELD.U.xx.flatten(),CFIELD.U.yy.flatten()), \ CFIELD.U.data.flatten(),(n_lon,n_lat), method='linear') CFIELD.vplt = interpol.griddata((CFIELD.U.xx.flatten(),CFIELD.U.yy.flatten()), \ CFIELD.V.data.flatten(),(n_lon,n_lat), method='linear') CFIELD.speed = np.sqrt(CFIELD.uplt**2 + CFIELD.vplt**2) CFIELD.reprocess = False if CFIELD.PLOT.DRAWING_MODE.get() == 0: # -------------------------------------------- VECTORS CFIELD.PLOT.MESSAGE += "EG VECTORPLOT: Arrows" #print("EG VECTORPLOT: Arrows") if CFIELD.PLOT.COLOR_BY_SPEED.get(): quiver = ax.quiver(CFIELD.xplt,CFIELD.yplt,CFIELD.uplt,CFIELD.vplt, \ CFIELD.speed, \ transform=proj, \ color=CFIELD.PLOT.CURRENT_COLOR.get(), \ width=CFIELD.PLOT.CURRENT_WIDTH.get(), \ headwidth=CFIELD.PLOT.CURRENT_HEADWIDTH.get(), \ headlength=CFIELD.PLOT.CURRENT_HEADLENGTH.get(), \ scale=CFIELD.PLOT.CURRENT_SCALE.get(), \ minlength=0, \ alpha=CFIELD.PLOT.ALPHA.get(), \ zorder=CFIELD.PLOT.ZORDER.get()) else: quiver = ax.quiver(CFIELD.xplt,CFIELD.yplt,CFIELD.uplt,CFIELD.vplt, \ transform=proj, \ color=CFIELD.PLOT.CURRENT_COLOR.get(), \ width=CFIELD.PLOT.CURRENT_WIDTH.get(), \ headwidth=CFIELD.PLOT.CURRENT_HEADWIDTH.get(), \ headlength=CFIELD.PLOT.CURRENT_HEADLENGTH.get(), \ scale=CFIELD.PLOT.CURRENT_SCALE.get(), \ minlength=0, \ alpha=CFIELD.PLOT.ALPHA.get(), \ zorder=CFIELD.PLOT.ZORDER.get()) if CFIELD.PLOT.KEY_SHOW.get(): CFIELD.PLOT.KEY_OBJ = ax.quiverkey( quiver, CFIELD.PLOT.KEY_X.get(), CFIELD.PLOT.KEY_Y.get(), CFIELD.PLOT.KEY_VALUE.get(), CFIELD.PLOT.KEY_LABEL.get(), labelpos=CFIELD.PLOT.KEY_POS.get(), coordinates='figure', transform=proj, labelcolor=CFIELD.PLOT.KEY_COLOR.get(), fontproperties={'size': CFIELD.PLOT.KEY_SIZE.get()}) elif CFIELD.PLOT.DRAWING_MODE.get() == 1: # -------------------------------------------- BARBS CFIELD.PLOT.MESSAGE += "EG VECTORPLOT: BARBS" #print("EG VECTORPLOT: BARBS") # Barb plot assumes knots knots = CFIELD.PLOT.BARB_SCALE.get() barb_increments = { 'half': CFIELD.PLOT.BARB_HALF.get(), 'full': CFIELD.PLOT.BARB_FULL.get(), 'flag': CFIELD.PLOT.BARB_FLAG.get() } sizes = { 'spacing': CFIELD.PLOT.BARB_SPACING.get(), 'height': CFIELD.PLOT.BARB_HEIGHT.get(), 'width': CFIELD.PLOT.BARB_WIDTH.get(), 'emptybarb': CFIELD.PLOT.BARB_EMPTYBARB.get() } if CFIELD.PLOT.COLOR_BY_SPEED.get(): speedk = knots * speed barbs = ax.barbs(CFIELD.xplt, CFIELD.yplt, knots * CFIELD.uplt, knots * CFIELD.vplt, speedk, pivot=CFIELD.PLOT.BARB_PIVOT.get(), length=CFIELD.PLOT.BARB_LENGTH.get(), linewidth=CFIELD.PLOT.BARB_LINEWIDTH.get(), barb_increments=barb_increments, sizes=sizes, transform=proj, alpha=CFIELD.PLOT.ALPHA.get(), zorder=CFIELD.PLOT.ZORDER.get()) else: barbs = ax.barbs(CFIELD.xplt, CFIELD.yplt, knots * CFIELD.uplt, knots * CFIELD.vplt, pivot=CFIELD.PLOT.BARB_PIVOT.get(), length=CFIELD.PLOT.BARB_LENGTH.get(), barbcolor=CFIELD.PLOT.BARB_BARBCOLOR.get(), flagcolor=CFIELD.PLOT.BARB_FLAGCOLOR.get(), linewidth=CFIELD.PLOT.BARB_LINEWIDTH.get(), barb_increments=barb_increments, sizes=sizes, transform=proj, alpha=CFIELD.PLOT.ALPHA.get(), zorder=CFIELD.PLOT.ZORDER.get())
if args.name_mappings is not None: name_mappings = json.loads(args.name_mappings) fig, ax, rects, means, sigs = \ graph.draw_from_data_frame(fs.expand_path_to_filelist(args.data), args.output, args.plot_type, args.filter, args.secondary_filter, args.attempt_auto_mapping, name_mappings, args) font0 = FontProperties() if args.plot_type == "bar": for i in range(len(rects)): for j in range(len(rects[i])): height = rects[i][j].get_height() if means[i][j] < 0: height = -height font = font0.copy() if sigs[i][j]: font.set_weight('bold') ax.text(rects[i][j].get_x()+rects[i][j].get_width()/2., 1.03*height, "%.1f"%means[i][j], ha='center', va='center', fontproperties=font) highest = [0] * len(means) for i in range(len(means)): for j in range(len(means[i])): if means[i][j] > means[i][highest[i]]: highest[i] = j for j in range(len(means[0])): for i in range(len(means)): # if sigs[i][j] and highest[i] == j:
from matplotlib import patches from matplotlib.font_manager import FontProperties font24 = FontProperties() font24.set_family('sans-serif') font24.set_name('Helvetica') font24.set_size(24) font18 = font24.copy() font18.set_size(18) font36 = font24.copy() font36.set_size(36) outage0 = [] out_withd0 = [] with open("out_age.csv",'r') as filename1: for l in filename1: outage0.append(l.strip('\n').split(',')) with open("out_withd.csv",'r') as filename2: for l in filename2: out_withd0.append(l.strip('\n').split(',')) outage1 = array([(int(x),float(y),int(z)) for x,y,z in outage0[1:]]) out_withd1 = array([(int(x),float(y),int(z)) for x,y,z in out_withd0[2:]]) N = len(outage1) xx = outage1[:,0]
""" import numpy as np import matplotlib.pyplot as plt import pandas as pd import os import glob import calendar from GPP_smooth_func import * from matplotlib.font_manager import FontProperties plt.rcParams["font.family"] = "Arial" font0 = FontProperties() font0 = FontProperties() font_sub_title = font0.copy() font_sub_title.set_size('12') font_sub_title.set_weight('bold') font_label = font0.copy() font_label.set_size('11') font_label.set_weight('bold') font_tick = font0.copy() font_tick.set_size('10') def cm2inch(*tupl): inch = 2.54 if isinstance(tupl[0], tuple): return tuple(i / inch for i in tupl[0])
def plot_data( x , data_nnfbp , data_standard , fom , zslice , path_common ): ## Define figure enviroment fig = plt.figure( 1 , figsize=( 12 , 8 ) , dpi=100 ) rect = fig.patch rect.set_facecolor('white') axescolor = '#f6f6f6' ax = plt.subplot( 111 , axisbg=axescolor ) ## Font setting font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = font1.copy() font.set_family('serif') rc('text',usetex=True) ## Enable grid gridLineWidth = 0.2 ax.yaxis.grid(True, linewidth=gridLineWidth, linestyle='-', color='0.05') ## Marker setup colorArray = ['blue','red'] markerArray = ['^','s','o','d'] ## Get title if fom == 'snr1': title = 'SNR analysis on ROI 1 of slice n. ' elif fom == 'snr2': title = 'SNR analysis on ROI 2 of slice n. ' elif fom == 'cnr': title = 'CNR analysis on ROI 1-2 of slice n. ' elif fom == 'ssim': title = 'SSIM analysis on ROI of slice n. ' elif fom == 'nmi': title = 'NMI analysis on ROI of slice n. ' title += zslice ## Get xlabel and ylabel xlabel = 'Total scan time ( s )' if fom == 'snr1': ylabel = 'SNR' elif fom == 'snr2': ylabel = 'SNR' elif fom == 'cnr': ylabel = 'CNR' elif fom == 'ssim': ylabel = 'SSIM' elif fom == 'nmi': ylabel = 'NMI' ## Tick setting fig.autofmt_xdate(bottom=0.18) plt.xticks(fontsize=16) plt.yticks(fontsize=16) ax.set_xticks( np.linspace(0.6, 1.2, 4) ) ## Set title and axis labeling plt.text(0.5, 1.06,title,horizontalalignment='center',fontsize=22,transform = ax.transAxes) plt.xlabel(xlabel, fontsize=22,position=(0.5,-0.2)) plt.ylabel(ylabel, fontsize=22,position=(0.5,0.5)) ## Labels labels = [ '1.0 ms' , '1.5 ms' , '2.0 ms' , '4.0 ms' ] ## Plot nalg = 2 nset = 4 plt.xlim([ 0.55 , 1.25 ]) for i in range( nalg ): for j in range( nset ): if i == 0: y = data_nnfbp[j,:] label_aux = 'NNFBP' else: y = data_standard[j,:] label_aux = 'FBP' plt.plot( x , y , markerArray[j] , markersize=10.5, color=colorArray[i] , label= label_aux + ' - ' + labels[j] ) plt.hold(True) ## Add legend ax.set_position( [ 0.2 , 0.10 , 0.5 , 0.8 ] ) ax.legend( loc='center left', bbox_to_anchor=(1, 0.5) ) ## Save plot and show it fileout = path_common + fom + '_analysis_slice' + zslice + '.png' plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' ) plt.show()
def bubbleIndices(cost, city): if (cost): fyrirspurn = "SELECT * FROM CostOfLivingIndex where city = " + '"' + city + '"' else: fyrirspurn = "SELECT * FROM QualityOfLifeIndex where city = " + '"' + city + '"' irrelevantAttributes = ["City", "Rank", "index"] ### allt fyrir neðan er sama og í Prices dæminu print(fyrirspurn) query = cur.execute(fyrirspurn) cols = [column[0] for column in query.description] results = pd.DataFrame.from_records(data=query.fetchall(), columns=cols) results.drop(columns=irrelevantAttributes, inplace=True) values = list(results.loc[0, :])[0:] names = [] j = 0 for i in cols: if i not in irrelevantAttributes: names.append(i) j = j + 1 print(len(values)) print(len(names)) fig, ax = plt.subplots(subplot_kw=dict(axisbg='#EEEEEE'), figsize=(9, 7)) N = len(values) #col = np.arange(0.1,0.99,0.98/N) col = np.random.random_integers(0, N - 1) print(col) #print(len(col)) colors = [ 'yellow', 'red', 'green', 'blue', 'black', 'purple', 'brown', 'pink' ] end = math.ceil(math.sqrt(N)) # þurfum að gera samsvörun step = end / N x = np.arange(0, end, step) hnitx = [] for i in range(1, end + 1): for j in range(end): if (len(hnitx) == N): break hnitx.append(i) hnity = [] for i in range(N): hnity.append(i % end) #plt.figure(figsize=(9,9)) # hnitx = [x + random.random()/4 for x in hnitx] # hnity = [y + random.random()/4 for y in hnity] print(hnitx) print(hnity) mynd = ax.scatter(hnitx, hnity, c=colors, alpha=0.5, s=[x * 20 for x in values]) plt.xlim((0, end)) plt.ylim((-1, end)) plt.xticks([], []) plt.yticks([], []) fig.patch.set_visible(False) ax.axis('off') font0 = FontProperties() font1 = font0.copy() font1.set_size('large') fonts = [] for i in range(N): fonts.append({ 'family': 'serif', 'color': colors[i], 'weight': 'normal', 'size': 10, }) j = 0 for label, x, y in zip(names, hnitx, hnity): plt.text(x + 0.22, y + 0.25, label, ha='right', va='bottom', fontdict=fonts[j]) j = j + 1 #plt.plot([x+0.22,x], [y+0.25,y], 'k-', linewidth = 0.5) # þarf að sjá font = { 'family': 'serif', 'color': 'black', 'weight': 'normal', 'size': 18, } ax.set_title("Bubble chart of prices of goods in " + city + " (area = €)", fontdict=font) # vantar að staðfesta að röðin sé eins? tooltip = mpld3.plugins.PointLabelTooltip(mynd, labels=values) mpld3.plugins.connect(fig, tooltip) mpld3.show()
def plot_data( data , dim , fom , path , n_files , ylim ): ## Define figure enviroment fig = plt.figure( 1 , figsize=( 12 , 8 ) , dpi=100 ) rect = fig.patch rect.set_facecolor('white') axescolor = '#f6f6f6' ax = plt.subplot( 111 , axisbg=axescolor ) ## Font setting font0 = FontProperties() font1 = font0.copy() font1.set_size('large') font = font1.copy() font.set_family('serif') rc('text',usetex=True) ## Enable grid gridLineWidth = 0.2 ax.yaxis.grid(True, linewidth=gridLineWidth, linestyle='-', color='0.05') ## Marker setup colorArray = [ 'blue' , 'red' , 'green' , 'cyan' , 'magenta' , 'yellow' , 'black' , 'red' , 'green' ] markerArray = [ 'o' , 'v' , '^' , '<' , '>' , 's' , 'p' , '*' , 'h' , 'H' , '+' , 'D' , 'd' , '|' , '_' , u'o' , u'v', u'^' , u'<' , u'>' , u'1' , u'2' , u'3' , u'4' , u'8' , u's' , u'p' , u'*' ] ## Get title if dim == 0: title = 'Shepp-Logan 256 X 256 pixels' str_dim = 'pix0256' elif dim == 1: title = 'Shepp-Logan 512 X 512 pixels' str_dim = 'pix0512' elif dim == 2: title = 'Shepp-Logan 1024 X 1024 pixels' str_dim = 'pix1024' elif dim == 3: title = 'Shepp-Logan 2048 X 2048 pixels' str_dim = 'pix2048' ## Get xlabel and ylabel xlabel = 'Forward projectors' if fom == 'psnr': ylabel = 'PSNR' elif fom == 'ssim': ylabel = 'SSIM' elif fom == 'nmi': ylabel = 'NMI' ## Tick setting fig.autofmt_xdate(bottom=0.18) plt.xticks(fontsize=16) plt.yticks(fontsize=16) ## Set title and axis labeling plt.text(0.5, 1.02,title,horizontalalignment='center',fontsize=22,transform = ax.transAxes) plt.xlabel(xlabel, fontsize=22,position=(0.5,-0.2)) plt.ylabel(ylabel, fontsize=22,position=(0.5,0.5)) ## Label x = np.arange( 1 , 7 , 1 ) x_ticks = [ ' ' , 'NUFFT' , 'GRID-KB' , 'GRID-PSWF' , 'RT-BSPLINES' , 'RT-LIN' , 'RT-NN' ] ## Plot if ylim is not None: plt.ylim([ ylim[0] , ylim[1] ]) #ax.set_xticks( x_ticks ) ax.set_xticklabels( x_ticks ) plt.xlim([ 0 , 7 ]) for i in range( n_files ): y = data[i] plt.plot( x[i] , y , markerArray[i] , markersize=12, color=colorArray[i] ) plt.hold(True) ## Add legend ax.set_position( [ 0.2 , 0.12 , 0.5 , 0.8 ] ) ax.legend( loc='center left', bbox_to_anchor=(1, 0.5) ) ## Save plot and show it fileout = path + fom + '_analysis_' + str_dim + '.png' plt.savefig( fileout , facecolor=fig.get_facecolor() , edgecolor='black' ) plt.show()
width = 14000000 height = 10000000 # m = Basemap(width=width,height=height,\ # resolution='c',projection='aeqd',\ # lat_0=lat_0,lon_0=lon_0) # m = Basemap(resolution='c',projection='aeqd',lat_0=lat_0,lon_0=lon_0) # m = Basemap(width=width,height=height,\ # resolution='c',projection='aea',\ # lat_0=lat_0,lon_0=lon_0) m = Basemap(resolution="c", projection="mbtfpq", lon_0=lon_0) # m = Basemap(resolution='c',projection='moll',lon_0=lon_0) # m = Basemap(resolution='c',projection='ortho',lon_0=lon_0,lat_0=lat_0) # m = Basemap(resolution='c',projection='cyl',llcrnrlat=llcrnrlat,llcrnrlon=llcrnrlon,urcrnrlat=urcrnrlat,urcrnrlon=urcrnrlon) p = FontProperties() font1 = p.copy() font1.set_size("small") # draw coasts and fill continents. m.drawcoastlines(linewidth=0.5) # m.fillcontinents() m.drawparallels(arange(-80, 81, 10), labels=[1, 1, 0, 0], fontproperties=font1, labelstyle="+/-") m.drawmeridians(arange(-180, 180, 20), labels=[0, 0, 0, 1], fontproperties=font1, labelstyle="+/-") m.drawmapboundary() m.bluemarble() m.drawmapboundary() if arg1 < saa_switch_time: # Use the previous definitions # SAA 02
def drawing(fig,ax,m,CFIELD): # ====================================== ''' Draw a 2D vector plot. Option of vectors or stream function''' __version__ = "1.0" __author__ = "Quim Ballabrerera" __date__ = "June 2017" import numpy as np fnt0 = FontProperties() font = fnt0.copy() font.set_size('x-large') if CFIELD.VEL.PLOT.DRAWING_MODE.get() == 0: # -------------------------------------------- VECTORS if CFIELD.VEL.PLOT.GRID_MODE.get() == 0: dx = CFIELD.VEL.PLOT.CURRENT_DX.get() dy = CFIELD.VEL.PLOT.CURRENT_DY.get() uplt,vplt,xplt,yplt = m.rotate_vector(CFIELD.VEL.u[::dy,::dx], \ CFIELD.VEL.v[::dy,::dx], \ CFIELD.lon[::dx], \ CFIELD.lat[::dy], \ returnxy=True) else: uplt,vplt,xplt,yplt = m.transform_vector(CFIELD.VEL.u, \ CFIELD.VEL.v, \ CFIELD.lon, \ CFIELD.lat, \ CFIELD.VEL.PLOT.CURRENT_NX.get(), \ CFIELD.VEL.PLOT.CURRENT_NY.get(), \ returnxy=True, \ masked=True) if CFIELD.VEL.PLOT.COLOR_BY_SPEED.get(): speed = np.sqrt(uplt**2+vplt**2) quiver = m.quiver(xplt,yplt,uplt,vplt,speed, \ color=CFIELD.VEL.PLOT.CURRENT_COLOR.get(), \ width=CFIELD.VEL.PLOT.CURRENT_WIDTH.get(), \ headwidth=CFIELD.VEL.PLOT.CURRENT_HEADWIDTH.get(), \ headlength=CFIELD.VEL.PLOT.CURRENT_HEADLENGTH.get(), \ scale=CFIELD.VEL.PLOT.CURRENT_SCALE.get(), alpha=CFIELD.VEL.PLOT.CURRENT_ALPHA.get(), zorder=CFIELD.VEL.PLOT.CURRENT_ZORDER.get(), ) else: quiver = m.quiver(xplt,yplt,uplt,vplt, \ color=CFIELD.VEL.PLOT.CURRENT_COLOR.get(), \ width=CFIELD.VEL.PLOT.CURRENT_WIDTH.get(), \ headwidth=CFIELD.VEL.PLOT.CURRENT_HEADWIDTH.get(), \ headlength=CFIELD.VEL.PLOT.CURRENT_HEADLENGTH.get(), \ scale=CFIELD.VEL.PLOT.CURRENT_SCALE.get(), alpha=CFIELD.VEL.PLOT.CURRENT_ALPHA.get(), zorder=CFIELD.VEL.PLOT.CURRENT_ZORDER.get(), ) if CFIELD.VEL.PLOT.KEY_SHOW.get(): CFIELD.VEL.PLOT.KEY_OBJ = ax.quiverkey(quiver, CFIELD.VEL.PLOT.KEY_X.get(), CFIELD.VEL.PLOT.KEY_Y.get(), CFIELD.VEL.PLOT.KEY_VALUE.get(), CFIELD.VEL.PLOT.KEY_LABEL.get(), labelpos=CFIELD.VEL.PLOT.KEY_POS.get(), coordinates='figure', labelcolor=CFIELD.VEL.PLOT.KEY_COLOR.get(), fontproperties={'size': CFIELD.VEL.PLOT.KEY_SIZE.get()}, ) elif CFIELD.VEL.PLOT.DRAWING_MODE.get() == 1: # -------------------------------------------- BARBS # Barb plot assumes knots knots = CFIELD.VEL.PLOT.BARB_SCALE.get() barb_increments = {'half': CFIELD.VEL.PLOT.BARB_HALF.get(), 'full': CFIELD.VEL.PLOT.BARB_FULL.get(), 'flag': CFIELD.VEL.PLOT.BARB_FLAG.get()} sizes = {'spacing': CFIELD.VEL.PLOT.BARB_SPACING.get(), 'height': CFIELD.VEL.PLOT.BARB_HEIGHT.get(), 'width': CFIELD.VEL.PLOT.BARB_WIDTH.get(), 'emptybarb': CFIELD.VEL.PLOT.BARB_EMPTYBARB.get()} if CFIELD.VEL.PLOT.GRID_MODE.get() == 0: dx = CFIELD.VEL.PLOT.CURRENT_DX.get() dy = CFIELD.VEL.PLOT.CURRENT_DY.get() uplt,vplt,xplt,yplt = m.rotate_vector(CFIELD.VEL.u[::dy,::dx], \ CFIELD.VEL.v[::dy,::dx], \ CFIELD.lon[::dx], \ CFIELD.lat[::dy], \ returnxy=True) else: uplt,vplt,xplt,yplt = m.transform_vector(CFIELD.VEL.u, \ CFIELD.VEL.v, \ CFIELD.lon, \ CFIELD.lat, \ CFIELD.VEL.PLOT.CURRENT_NX.get(), \ CFIELD.VEL.PLOT.CURRENT_NY.get(), \ returnxy=True, \ masked=True) if CFIELD.VEL.PLOT.COLOR_BY_SPEED.get(): speed = knots*np.sqrt(uplt**2+vplt**2) barbs = m.barbs(xplt,yplt,knots*uplt,knots*vplt,speed, pivot=CFIELD.VEL.PLOT.BARB_PIVOT.get(), length=CFIELD.VEL.PLOT.BARB_LENGTH.get(), linewidth=CFIELD.VEL.PLOT.BARB_LINEWIDTH.get(), barb_increments=barb_increments, sizes=sizes, alpha=CFIELD.VEL.PLOT.BARB_ALPHA.get(), zorder=CFIELD.VEL.PLOT.BARB_ZORDER.get(), ) else: barbs = m.barbs(xplt,yplt,knots*uplt,knots*vplt, pivot=CFIELD.VEL.PLOT.BARB_PIVOT.get(), length=CFIELD.VEL.PLOT.BARB_LENGTH.get(), barbcolor=CFIELD.VEL.PLOT.BARB_BARBCOLOR.get(), flagcolor=CFIELD.VEL.PLOT.BARB_FLAGCOLOR.get(), barb_increments=barb_increments, sizes=sizes, linewidth=CFIELD.VEL.PLOT.BARB_LINEWIDTH.get(), alpha=CFIELD.VEL.PLOT.BARB_ALPHA.get(), zorder=CFIELD.VEL.PLOT.BARB_ZORDER.get(), ) elif CFIELD.VEL.PLOT.DRAWING_MODE.get() == 2: # -------------------------------------------- STREAMFUNCTION if m.projparams['proj'] == 'cyl': # ------------------- ax.streamplot(CFIELD.xx, CFIELD.yy, CFIELD.VEL.u, CFIELD.VEL.v, \ color=CFIELD.VEL.PLOT.STREAM_COLOR.get(), \ linewidth=CFIELD.VEL.PLOT.STREAM_WIDTH.get(), \ zorder=CFIELD.VEL.PLOT.STREAM_ZORDER.get(), \ density=CFIELD.VEL.PLOT.STREAM_DENSITY.get()) else: print('WARNING: Streamplot only works with Cylindircal Projection')
See :doc:`fonts_demo_kw` to achieve the same effect using kwargs. """ from matplotlib.font_manager import FontProperties import matplotlib.pyplot as plt plt.subplot(111, facecolor='w') font0 = FontProperties() alignment = {'horizontalalignment': 'center', 'verticalalignment': 'baseline'} # Show family options families = ['serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'] font1 = font0.copy() font1.set_size('large') t = plt.text(-0.8, 0.9, 'family', fontproperties=font1, **alignment) yp = [0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2] for k, family in enumerate(families): font = font0.copy() font.set_family(family) t = plt.text(-0.8, yp[k], family, fontproperties=font, **alignment) # Show style options
def plot_ref_genome(start_points,lens,cycle,total_length_with_spacing,segSeqD,imputed_status,label_segs=True): font0 = FontProperties() seg_posns = [] global_start = total_length_with_spacing*(global_rot/360.0) for ind,sp in enumerate(start_points): start_point = int(global_start - sp) seg_coord_tup = segSeqD[cycle[ind][0]] start_angle, end_angle, _ = start_end_angle(start_point,start_point - lens[ind],total_length_with_spacing) #makes the reference genome wedges patches.append(mpatches.Wedge((0,0), outer_bar, end_angle, start_angle, width=bar_width)) chrom = segSeqD[cycle[ind][0]][0] f_color_v.append(chromosome_colors[chrom]) e_color_v.append('grey') lw_v.append(0.2) #makes the ticks on the reference genome wedges if cycle[ind][1] == "+": posns = zip(range(seg_coord_tup[1],seg_coord_tup[2]+1),np.arange(start_point,start_point-lens[ind]-1,-1)) else: posns = zip(np.arange(seg_coord_tup[2],seg_coord_tup[1]-1,-1),np.arange(start_point,start_point-lens[ind]-1,-1)) tick_freq = max(10000,10000*int(np.floor(total_length_with_spacing/1000000))) for j in posns: if j[0] % tick_freq == 0: text_angle = j[1]/total_length_with_spacing*360 x,y = pol2cart(outer_bar,(text_angle/360*2*np.pi)) x_t,y_t = pol2cart(outer_bar + 0.2,(text_angle/360*2*np.pi)) ax.plot([x,x_t],[y,y_t],color='grey',linewidth=0.2) if (abs(text_angle) > 90 and abs(text_angle) < 360): text_angle-=180 ha = "right" txt = str(int(round((j[0])/10000))) + " " else: ha = "left" txt = " " + str(int(round((j[0])/10000))) ax.text(x_t,y_t,txt,color='grey',rotation=text_angle, ha=ha,fontsize=4,rotation_mode='anchor') gene_tree = parse_genes(seg_coord_tup[0]) relGenes = rel_genes(gene_tree,seg_coord_tup) #plot the gene track plot_gene_track(start_point,relGenes,seg_coord_tup,total_length_with_spacing,cycle[ind][1]) #label the segments by number in cycle mid_sp = start_point - lens[ind]/2 text_angle = mid_sp/total_length*360. x,y = pol2cart(outer_bar-0.9,(text_angle/360.*2.*np.pi)) font = font0.copy() if imputed_status[ind]: font.set_style('italic') font.set_weight('bold') if (abs(text_angle) > 90 and abs(text_angle) < 360): text_angle-=180 ha = "left" else: ha = "right" if label_segs: ax.text(x,y,cycle[ind][0]+cycle[ind][1],color='grey',rotation=text_angle, ha=ha,fontsize=5,fontproperties=font,rotation_mode='anchor')