def show_images(imagedata_list, save_as=None, fontsize=12): ncols = 3 if len(imagedata_list) <= 3: ncols = len(imagedata_list) nrows = 1 else: nrows = int(np.ceil(len(imagedata_list) / 3)) # f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 10)) f, axes = plt.subplots(nrows, ncols, squeeze=False) f.tight_layout() f.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.) # f.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0., hspace=-0.5) if nrows == 1: plt.setp(axes, xticks=np.arange(0, 1280, 250)) axes = np.reshape(axes, -1) for imagedata, ax in zip(imagedata_list, axes): (img, title, cmap) = imagedata if cmap is not None: ax.imshow(img, cmap=cmap) else: ax.imshow(img) ax.set_title(title, fontsize=fontsize) extra_axes_count = len(axes) - len(imagedata_list) for i in range(extra_axes_count): plt.delaxes(axes[len(imagedata_list) + i]) if save_as is not None: plt.savefig(save_as, bbox_inches='tight', dpi=300) plt.show()
def plot_cut_in_bin(RE_ranked, RE_data_dict, path_out): #Set number of plots Num_plots=len(RE_ranked) #Plot distribution of restriction fragments length if Num_plots%4==0: fig1, plots=plt.subplots(Num_plots//4,4,figsize=(15,15), dpi=100) else: fig1, plots=plt.subplots((Num_plots//4)+1,4,figsize=(15,15), dpi=100) i=0 iter_plot=plots.reshape(-1) while i<Num_plots: RE_name=RE_ranked[i][0] catnum=RE_data_dict[RE_name][2] iter_plot[i].hist(catnum, edgecolor='black', color='#ff862f', linewidth=1) iter_plot[i].set_title(RE_name, size=22) iter_plot[i].set_xlabel('Number of cuts', size=18) iter_plot[i].set_ylabel('Number of bins', size=18) iter_plot[i].tick_params(axis='both', labelsize=14) print('mean '+str(int(np.mean(catnum)))+' cuts\nmedian '+str(int(np.median(catnum)))+' cuts') iter_plot[i].annotate('mean '+str(int(np.mean(catnum)))+' cuts\nmedian '+str(int(np.median(catnum)))+' cuts', xytext=(0.4, 0.8), textcoords='axes fraction', xy=(0, 0), size=16.5) i+=1 #Remove empty subplots for elem in iter_plot[Num_plots:]: plt.delaxes(elem) plt.tight_layout() plt.savefig(path_out+"E_coli_re_analysis_cut_in_bin.png", figsize=(15,10), dpi=400) plt.close() return
def plotMoni(self, ax, number): """ defines the monitors that should be plotted. """ if number==1: #plot driver activity moni=self.m.totalTreeMoni if len(moni)>0: ax.plot(moni.tseries(),moni.yseries(), drawstyle='steps-post') ax.axis([-0.1, self.now(), -0.1, (max(moni.yseries())+1)]) ax.grid(True) ax.set_xlabel('time(s)') ax.set_ylabel('trees picked up') elif number==2: #plot trees planted moni=self.m.distMoni if len(moni)>0: ax.plot(moni.tseries(),moni.yseries(), drawstyle='steps-post') ax.axis([-0.1, self.now(), -0.1, (max(moni.yseries())+1)]) ax.grid(True) ax.set_xlabel('time(s)') ax.set_ylabel('dist. traveled (m)') elif number==3: #create a new axis.. plt.delaxes(ax) ax=self.p.fig.add_subplot(326, aspect='equal', axisbg='#A2CD5A') lim=self.m.pos[0]-15, self.m.pos[0]+15, self.m.pos[1]-15, self.m.pos[1]+15 self.p.update_world(ax,lim) return ax
def generate_sex_pic(self, sex_data): """ 生成性别数据图片 因为plt在子线程中执行会出现自动弹出弹框并阻塞主线程的行为,plt行为均放在主线程中 :param sex_data: :return: """ # 绘制「性别分布」柱状图 # 'steelblue' bar_figure = plt.bar(range(3), sex_data, align='center', color=self.bar_color, alpha=0.8) # 添加轴标签 plt.ylabel(u'Number') # 添加标题 plt.title(u'Male/Female in your Wechat', fontsize=self.title_font_size) # 添加刻度标签 plt.xticks(range(3), [u'Male', u'Female', u'UnKnown']) # 设置Y轴的刻度范围 # 0, male; 1, female; 2, unknown max_num = max(sex_data[0], max(sex_data[1], sex_data[2])) plt.ylim([0, max_num * 1.1]) # 为每个条形图添加数值标签 for x, y in enumerate(sex_data): plt.text(x, y + len(str(y)), y, ha='center') # 保存图片 plt.savefig(ALS.result_path + '/2.png') # todo 如果不调用此处的关闭,就会导致生成最后一个图像出现折叠、缩小的混乱 #bar_figure.remove() plt.clf() plt.delaxes()
def boxplots(self, column, for_test=True, for_target=True): n_subplots = 2 if for_test: n_subplots += 1 if for_target: n_subplots += 1 f, ax = plt.subplots(1, n_subplots, figsize=(4 * (n_subplots + 1), 4), sharey=True) train = self._data.loc[self._train, [column]] b1 = sb.boxplot(data=train, y=column, orient='v', ax=ax[0]) ax[0].set(title='train') if for_test: test = self._data.loc[self._test, [column]] b2 = sb.boxplot(data=test, y=column, orient='v', ax=ax[1]) ax[1].set(title='test') if for_target: if for_test: i = 2 else: i = 1 train = self._data.loc[self._train, [column]].join( self._target.to_frame('TARGET')) b3 = sb.boxplot(data=train, y=column, x='TARGET', orient='v', ax=ax[i]) ax[i].set(title='train') plt.delaxes(ax[-1]) plt.show()
def distplots(self, column, for_test=True, for_target=True): if for_target: n_subplots = 3 else: n_subplots = 2 f, ax = plt.subplots(1, n_subplots, figsize=(n_subplots * 6, 4), sharex=True, sharey=True) d1 = sb.distplot(self._data.loc[self._train, column], hist=False, label='train', ax=ax[0]) if for_test: d2 = sb.distplot(self._data.loc[self._test, column], hist=False, label='test', ax=ax[0]) plt.legend() if for_target: d3 = sb.distplot( self._data.loc[self._target[self._target.eq(0)].index, column], hist=False, label='target=0', ax=ax[1]) d4 = sb.distplot( self._data.loc[self._target[self._target.eq(1)].index, column], hist=False, label='target=1', ax=ax[1]) plt.legend() plt.delaxes(ax[-1]) plt.show()
def scatter_plot(data, show=False): data = data[:, 1:] # Get rid of id colors = ["red"] * 50 + ["green"] * 50 + ["blue"] * 50 # the data is ordered so this is ok fig, axs = plt.subplots(4, 4) # we have 4 features, so the scatter matrix is 4x4 # legend legend_elements = [Line2D([0], [0], marker='o', color='w', label='Iris-setosa', markerfacecolor='r', markersize=5), Line2D([0], [0], marker='o', color='w', label='Iris-versicolor', markerfacecolor='g', markersize=5), Line2D([0], [0], marker='o', color='w', label='Iris-virginica', markerfacecolor='b', markersize=5), ] fig.legend(handles=legend_elements, loc='upper left') # title plt.suptitle("Scatter Plot Matrix") # filling each cell in the matrix for i in range(4): for j in range(4): if i == j: plt.delaxes(axs[i, j]) continue ax = axs[i, j] # get the current axis # hide tick and tick label of the big axes ax.tick_params(direction="in", labelcolor='none', top=False, bottom=False, left=False, right=False, pad=0.0) x = data[:, i].reshape((150, )) # plot only the relevant feature y = data[:, j].reshape((150, )) # plot only the relevant feature ax.scatter(x, y, s=1, color=colors) ax.set_xlabel(get_label(i), labelpad=-8, fontsize= 10) # xlabel ax.set_ylabel(get_label(j), labelpad=-5, fontsize=10) # ylabel if show: plt.show()
def all_params_plotted(): fig, axs = plt.subplots(4, 2, figsize=(11, 11)) fig.subplots_adjust(hspace=0.3, top=0.95, bottom=0.05, left=0.1, right=0.95) plt.axes(axs[0, 0]) vary_parameter(500.0, 3000.0, TEMP, show_fig=False) #plt.sca(axs[0,1]) #vary_parameter(4.0,8.0, DENS, show_fig=False) plt.delaxes(axs[0, 1]) plt.axes(axs[1, 0]) vary_parameter(50, 200, FLUX, show_fig=False) plt.axes(axs[1, 1]) vary_parameter(0.01, 0.1, ATMO, show_fig=False) plt.axes(axs[2, 0]) vary_parameter(0.1, 0.4, EFFI, show_fig=False) plt.axes(axs[2, 1]) vary_parameter(0.1, 10, PRES, show_fig=False) plt.axes(axs[3, 0]) vary_parameter(2500, R_H2, GASC, show_fig=False) plt.axes(axs[3, 1]) vary_parameter(50, 200, TIME, show_fig=False) plt.show()
def generate_data(choice='linear'): global X, Y, N if choice == 'linear': N = np.random.randint(50, 150) std = (np.random.randint(6, 10)) * 0.1 X, Y = make_blobs(n_samples=N, centers=2, random_state=0, cluster_std=0.60) elif choice == 'circle': N = np.random.randint(100, 200) factor = (np.random.randint(1, 6)) * 0.1 X, Y = make_circles(n_samples=N, factor=factor, noise=0.1) plt.delaxes() plt.scatter(X[:, 0], X[:, 1], c=Y, cmap='winter', s=100, edgecolors='black') plt.xlabel("Feature1") plt.ylabel("Feature2") plt.title("DATA POINTS") gendat = BytesIO() plt.savefig(gendat, format='png') # figfile.seek(0) # Rewind to the beginning of the file gendat_img = base64.b64encode(gendat.getbuffer()).decode('ascii') return gendat_img
def reset(self, colors=None): if self.ax is not None: plt.delaxes(self.ax) self.ax = self.fig.add_subplot(111, aspect="equal") self.polygons = {} for key in self.env.sim.bodies.keys(): if colors is not None and key in colors.keys(): self.env.sim.bodies[key].color = colors[key] self.polygons[key] = Polygon( [[0, 0]], ec=self.env.sim.bodies[key].color + [1], fc=self.env.sim.bodies[key].color + [1], closed=True, ) self.ax.add_artist(self.polygons[key]) self.ax.set_xlim(self.xlim) self.ax.set_ylim(self.ylim) if not self.offline: self.fig.show() else: self.ts = 0
def visualize(model, filename): values = model.all_params() cols = OrderedDict() for key, value in values.items(): if isinstance(value, np.ndarray): # TODO group by prefix, showing W and b side by side cols.setdefault(key[:-2] + key[-1] if len(key) > 1 and key[-2] in "bW" else key, []).append((key, value)) _, axes = plt.subplots(2, len(cols), figsize=(5*len(cols), 10)) # TODO https://stackoverflow.com/a/13784887/223267 plt.tight_layout() for j, col in enumerate(tqdm(cols.values(), unit="param", desc=filename)): for i in range(2): axis = axes[i, j] if len(values) > 1 else axes if len(col) <= i: plt.delaxes(axis) else: plt.sca(axis) key, value = col[i] plt.colorbar(plt.pcolormesh(smooth(value))) for pattern, repl in REPLACEMENTS: # TODO map 0123->ifoc key = re.sub(pattern, repl, key) plt.title(key) for axis in (plt.gca().xaxis, plt.gca().yaxis): axis.set_major_locator(MaxNLocator(integer=True)) output_file = filename + ".png" plt.savefig(output_file) plt.clf() print("Saved '%s'." % output_file)
def separate(self, adjust: np.ndarray, layout: np.ndarray, xlabel: str): """ plt.subplots(nrows=1, ncols=ncols, figsize=(9.1, 2.1), constrained_layout=False) :param adjust: :param layout: :param xlabel: :return: """ # The number of curves nlines = self.predictions.line.shape[1] # Proceed fig, handle = plt.subplots(nrows=math.ceil(nlines / 2), ncols=2) fig.subplots_adjust(hspace=adjust[0], wspace=adjust[1]) fig.tight_layout(h_pad=layout[0], w_pad=layout[1]) for i in range(nlines): self.get_separate(handle=handle[i // 2, i % 2], index=i, xlabel=xlabel) # Delete the final/empty subplot if (nlines // 2) > 0: plt.delaxes(handle[nlines // 2, nlines % 2]) return fig, handle
def __call__(self): fig, ax = plt.subplots(3, 3) # map and path map_plot = ax[0][0].imshow(self.map_with_path, cmap='Greys', interpolation='nearest') map_plot.axes.get_xaxis().set_visible(False) map_plot.axes.get_yaxis().set_visible(False) ax[0][0].set_title("Map and A* path") # closest wall distance dists = self.metrics.get("closestDist") dist_plot = ax[0][1].imshow(dists, cmap='RdYlGn', interpolation='nearest') dist_plot.axes.get_xaxis().set_visible(False) dist_plot.axes.get_yaxis().set_visible(False) ax[0][1].set_title("Distance to \nclosest obstacle") dist_cbar = fig.colorbar(dist_plot, ax=ax[0][1], orientation='horizontal') dist_cbar.ax.tick_params(labelsize='xx-small') # characteristic dimension cdr = self.metrics.get("char_dimension") cdr_plot = ax[0][2].imshow(cdr, cmap='binary', interpolation='nearest') cdr_plot.axes.get_xaxis().set_visible(False) cdr_plot.axes.get_yaxis().set_visible(False) ax[0][2].set_title("Char dimension") cdr_cbar = fig.colorbar(cdr_plot, ax=ax[0][2], orientation='horizontal') cdr_cbar.ax.tick_params(labelsize='xx-small') # average visibility avgVis = self.metrics.get("avgVis") avgVis_plot = ax[1][0].imshow(avgVis, cmap='RdYlGn', interpolation='nearest') avgVis_plot.axes.get_xaxis().set_visible(False) avgVis_plot.axes.get_yaxis().set_visible(False) ax[1][0].set_title("Average visibility") avgVis_cbar = fig.colorbar(avgVis_plot, ax=ax[1][0], orientation='horizontal') avgVis_cbar.ax.tick_params(labelsize='xx-small') # dispersion dispersion = self.metrics.get("dispersion") disp_plot = ax[1][1].imshow(dispersion, cmap='RdYlGn', interpolation='nearest') disp_plot.axes.get_xaxis().set_visible(False) disp_plot.axes.get_yaxis().set_visible(False) ax[1][1].set_title("%d-square radius dispersion" % self.dispersion_radius) disp_cbar = fig.colorbar(disp_plot, ax=ax[1][1], orientation='horizontal') disp_cbar.ax.tick_params(labelsize='xx-small') # jackal's navigable map, low-res jmap_plot = ax[2][0].imshow(self.jackal_map_with_path, cmap='Greys', interpolation='nearest') jmap_plot.axes.get_xaxis().set_visible(False) jmap_plot.axes.get_yaxis().set_visible(False) ax[2][0].set_title("Jackal navigable map") plt.delaxes(ax[1][2]) plt.axis('off') plt.show()
def smaller_axes(ax1): # Replace existing axes with one only 90% width and 75% height, # allowing more room for ticks and titles ax_pos = ax1.get_position().get_points() ax_width = ax_pos[1,0] - ax_pos[0,0] ax_height = ax_pos[1,1] - ax_pos[0,1] pp.delaxes(ax1) ax2 = pp.axes([ax_pos[0,0] + .10 * ax_width, ax_pos[0,1] + .20 * ax_height, .90 * ax_width, .75 * ax_height]) return ax2
def remove(self, name): for i in range(len(self.axes)): if (name == self.functions_name[i]): print("found number 3") del self.functions_name[i] del self.functions[i] pyplot.delaxes(self.axes[i]) self.axes = self.axes[self.axes != self.axes[i]] self.draw()
def plot_form_factors(ge2_vals, gm2_vals, q2, save_path=None): """ Plots the distributions of proton form factors for a given Q^2 side-by-side, based on Monte Carlo simulations Args: ge2_vals (list) - The values of the electric form factor squared gm2_vals (list) - The values of the magnetic form factor squared Returns: (tuple) - (float) - The uncertainty/standard deviation of the electric form factor measurements (float) - The uncertainty/standard deviation of the magnetic form factor measurements """ plt.delaxes() plt.figure(figsize=(24,10)) ax1 = plt.subplot(121) mu1, sigma1 = stats.norm.fit(ge2_vals) n, bins, patches = plt.hist(ge2_vals, bins=50, normed=1, facecolor='red', linewidth=3, histtype="stepfilled") y = mlab.normpdf(bins, mu1, sigma1) plt.plot(bins, y, "-", color="black", linewidth=4) plt.axvspan(mu1-sigma1, mu1+sigma1, color="white", alpha=0.5) plt.xticks(fontsize=20, rotation=30) plt.yticks(fontsize=20) ax2 = plt.subplot(122) mu2, sigma2 = stats.norm.fit(gm2_vals) n, bins, patches = plt.hist(gm2_vals, bins=50, normed=1, facecolor='blue', linewidth=3, histtype="stepfilled") y = mlab.normpdf(bins, mu2, sigma2) plt.plot(bins, y, "-", color="black", linewidth=4) plt.axvspan(mu2-sigma2, mu2+sigma2, color="white", alpha=0.5) plt.xticks(fontsize=20, rotation=30) plt.yticks(fontsize=20) ax1.set_xlabel(r'$G_E^2$', fontsize=30, labelpad=20) ax1.set_ylabel(r'Frequency', fontsize=30, labelpad=20) ax1.annotate('$Q^2 = %.3f$ \n $\mu = %f$ \n $\sigma = %f$' % (q2, mu1, sigma1), xy=(mu1, 0), xycoords='data', xytext=(0.6, 0.7), textcoords="axes fraction", verticalalignment='bottom', horizontalalignment='left', fontsize=30) ax1.text(0.5, 1.05, 'a', transform=ax1.transAxes, size=40, weight='bold') ax2.set_xlabel(r'$G_M^2$', fontsize=30, labelpad=20) ax2.set_ylabel(r'Frequency', fontsize=30, labelpad=20) ax2.annotate('$Q^2 = %.3f$ \n $\mu = %f$ \n $\sigma = %f$' % (q2, mu2, sigma2), xy=(mu2, 0), xycoords='data', xytext=(0.65, 0.7), textcoords="axes fraction", verticalalignment='bottom', horizontalalignment='left', fontsize=30) ax2.text(0.5, 1.05, 'b', transform=ax2.transAxes, size=40, weight='bold') plt.subplots_adjust(bottom=0.15) if not save_path: plt.show() else: plt.savefig(save_path+"/ff_q2_"+str(q2)+".png", bbox_inches="tight") return sigma1, sigma2
def tetrahedron_array_st(): """ Make figure of tetrahedra along different combinations of singular vectors colored by scottrade classification """ # Load Fits filename = 'saves/8_factor_matrices.pkl.gz' E, W, C, SSE, varexpl = local_load(filename) # Calculate Singular Vectors A = np.dot(E, W) u, s, vt = svd(A.T, full_matrices=0) vtE = np.asarray(np.dot(vt, E)) # Define colors and labels cols = [ '#FFF000', '#FDBF6F', '#A6CEE3', '#33A02C', '#FB9A99', '#B2DF8A', '#E31A1C', '#6A3D9A', '#FF7F00', '#543005', '#CAB2D6', '#000000', '#1F78B4', '#8C510A' ] numcos = [58, 61, 41, 42, 107, 53, 40, 93, 6, 57, 55, 31, 46, 15] sulis = [[v] * k for k, v in zip(numcos, cols)] csuarray = np.array([item for sublist in sulis for item in sublist]) # Plot figure fig, axs = plt.subplots(8, 8, figsize=(20, 20)) for ((j, i), ax) in np.ndenumerate(axs): if i < j: xs, ys = u[:, i].T * s[i], u[:, j].T * s[j] ax.scatter(xs, ys, s=5, color=csuarray) ax.scatter(vtE[i, :], vtE[j, :], s=10, color='k') ax.set_axis_off() xy = zip(vtE[i, :], vtE[j, :]) for p in itertools.combinations(xy, 2): ax.plot([p[0][0], p[1][0]], [p[0][1], p[1][1]], ls='--', color='#D9D9D9') else: plt.delaxes(ax) plt.subplots_adjust(hspace=0.05, wspace=0.05) plt.savefig('figures/tetrahedron_array_st.png', bbox_inches='tight', pad_inches=0) plt.close() return
def reorg_fig(self, nplots): """Reorganise the views to show nplots""" if CmdBase.mode == CmdMode.GUI: self.parent_application.sp_nviews.blockSignals(True) self.parent_application.sp_nviews.setValue(nplots) self.parent_application.sp_nviews.blockSignals(False) self.plotselecttabWidget.blockSignals(True) nplot_old = self.nplots self.nplots = nplots gs = self.organizeplots(self.pot, self.nplots, self.ncols) # hide tabs if only one figure self.plotselecttabWidget.setVisible(nplots > 1) for i in range(nplots): self.axarr[i].set_position(gs[i].get_position(self.figure)) self.axarr[i].set_subplotspec(gs[i]) for tab in self.hidden_tab: tab_id = tab[0] widget = tab[1] tab_text = tab[2] self.plotselecttabWidget.insertTab(tab_id, widget, tab_text) self.hidden_tab = [] for i in range(nplots, len(self.axarr)): self.axarr[i].set_visible(False) tab_id = i + 1 widget = self.plotselecttabWidget.widget(nplots + 1) tab_text = self.plotselecttabWidget.tabText(nplots + 1) self.hidden_tab.append([tab_id, widget, tab_text]) self.plotselecttabWidget.removeTab(nplots + 1) self.set_bbox() for i in range(self.nplots): self.axarr[i].set_position(self.bbox[i]) # add new axes to plt for i in range(nplot_old, self.nplots): try: plt.subplot(self.axarr[i]) except: pass # remove axes from plt for i in range(self.nplots, nplot_old): try: plt.delaxes(self.axarr[i]) except: pass for ds in self.parent_application.datasets.values(): ds.nplots = nplots self.parent_application.update_all_ds_plots() self.handle_plottabChanged(0) # switch to all plot tab self.plotselecttabWidget.blockSignals(False)
def barplots(self, column, for_test=True, for_target=True, nan_as_cat=True): if for_test: n_subplots = 3 else: n_subplots = 2 f, ax = plt.subplots(1, n_subplots, figsize=(n_subplots * 6, 4)) data = self._data.loc[self._train, column].value_counts( normalize=True, dropna=nan_as_cat).sort_index() pos = np.arange(data.shape[0]) if for_target: dt = [] for t in [0, 1]: idx = self._target[self._target.eq(t)].index sh = self._data.loc[self._train, column].shape[0] temp = self._data.loc[idx, column].value_counts( dropna=nan_as_cat) / sh dt.append( pd.merge(data.to_frame('total'), temp.to_frame(str(t)), left_index=True, right_index=True, how='left')[str(t)].fillna(0)) b1 = ax[0].bar(pos, dt[0].values, alpha=0.5) b2 = ax[0].bar(pos, dt[1].values, bottom=dt[0].values, alpha=0.5) ax[0].legend([b1, b2], ['target=0', 'target=1']) else: b1 = ax[0].bar(pos, data.values, alpha=0.5) ax[0].set(title=column + ' train') ax[0].set_xticks(pos) ax[0].set_xticklabels(list(data.index), rotation=90) if for_test: data = pd.merge(data.to_frame('train'), self._data.loc[self._test, column].value_counts( normalize=True, dropna=nan_as_cat).to_frame('test'), left_index=True, right_index=True, how='outer').fillna(0).sort_index(axis=0) pos = np.arange(data.shape[0]) b1 = ax[1].bar(pos, data.train.values, alpha=0.5) b2 = ax[1].bar(pos, data.test.values, alpha=0.5) ax[1].set(title=column + ' test') ax[1].set_xticks(pos) ax[1].set_xticklabels(list(data.index), rotation=90) ax[1].legend([b1, b2], ['train', 'test']) plt.delaxes(ax[-1]) plt.show()
def main(infile="waves.out", outfile="out.mp4", startpic="start.png"): """Visualize shallow water simulation results. Args: infile: Name of input file generated by simulator outfile: Desired output file (mp4 or gif) startpic: Name of picture generated at first frame """ u = np.fromfile(infile, dtype=np.dtype('f4')) nx = int(u[0]) ny = int(u[1]) x = range(0, nx) y = range(0, ny) u = u[2:] nframe = len(u) // (nx * ny) stride = nx // 20 u = np.reshape(u, (nframe, nx, ny)) X, Y = np.meshgrid(x, y) fig = plt.figure(figsize=(10, 10)) #print("In Plotting: nx = %d, ny = %d" % (nx,ny)) #print(u); def plot_frame(i, stride=5): ax = fig.add_subplot(111, projection='3d') ax.set_zlim(0, 2) Z = u[i, :, :] ax.plot_surface(X, Y, Z, rstride=stride, cstride=stride) return ax if startpic: ax = plot_frame(0) plt.savefig(startpic) plt.delaxes(ax) metadata = dict(title='Wave animation', artist='Matplotlib') if outfile[-4:] == ".mp4": Writer = manimation.writers['ffmpeg'] writer = Writer( fps=15, metadata=metadata, extra_args=["-r", "30", "-c:v", "libx264", "-pix_fmt", "yuv420p"]) elif outfile[-4:] == ".gif": Writer = manimation.writers['imagemagick'] writer = Writer(fps=15, metadata=metadata) with writer.saving(fig, outfile, nframe): for i in range(nframe): ax = plot_frame(i) writer.grab_frame() plt.delaxes(ax)
def figPause(fig): global gInPause buttonAxes = plt.axes([0.9, 0.9, 0.1, 0.05]) button = Button(buttonAxes, '>>') button.on_clicked(onclick) gInPause = True print('Program paused in figure window...') while gInPause: plt.pause(0.1) plt.draw() button.disconnect_events() plt.delaxes(buttonAxes) plt.draw()
def figPause(fig): global gInPause buttonAxes = plt.axes([0.9, 0.9, 0.1, 0.05]) button = Button(buttonAxes, '>>') button.on_clicked(onclick) gInPause = True print('Program paused in figure window...') while gInPause: plt.pause(0.0001) plt.draw() button.disconnect_events() plt.delaxes(buttonAxes) plt.draw()
def mk_2d_sequence_gif(x_seq, y_seq, filename='make_2d_sequence_gif.gif', plot_kwargs={}, edit_funs={}, writeGif_kwargs={}, savefig_kwargs={}, **kwargs): # handling defaults plot_kwargs = dict({'color':'b', 'marker':'o', 'linestyle':'-', 'linewidth':0.2}, **plot_kwargs) savefig_kwargs = dict({'dpi':200}, **savefig_kwargs) writeGif_kwargs = dict({'size':(600,600), 'duration':0.2}, **writeGif_kwargs) # handling edit_funs if hasattr(edit_funs, '__call__'): edit_fun = edit_funs else: # defining an edit function from the edit_funs dict def edit_fun(): # this function assumes keys of edit_funs are plt attributes, and tries to call the values on them for k, v in edit_funs.iteritems(): if hasattr(plt, edit_funs[k]): f = plt.__getattribute__(k) try: f(**v) except: try: f(*v) except: f(v) else: v() tmp_dir = tempfile.mkdtemp('mk_2d_sequence_gif') # get the axis limits if 'xylims' in kwargs.keys(): ax = kwargs['xylims'] else: # plot the full sequences to get the axis limits from it plt.plot(x_seq, y_seq, **plot_kwargs) edit_fun() ax = plt.axis() # create files that will be absorbed by the gif for i in range(1,len(x_seq)+1): plt.delaxes() plt.plot(x_seq[:i], y_seq[:i], **plot_kwargs) plt.axis(ax) edit_fun() plt.savefig(os.path.join(tmp_dir, 'mk_2d_sequence_gif%02.0f'%i), **savefig_kwargs) # create the gif size = writeGif_kwargs['size'] del writeGif_kwargs['size'] file_names = sorted(fnmatch.filter(os.listdir(tmp_dir), 'mk_2d_sequence_gif*')) images = [Image.open(os.path.join(tmp_dir,fn)) for fn in file_names] for im in images: im.thumbnail(size, Image.ANTIALIAS) writeGif(filename=filename, images=images, **writeGif_kwargs)
def create_figure(n,plot=False,figsize=False,vertical=False): if n==1: if not plot or plot=='pie': fig, (ax1) = plt.subplots(1,1,figsize=(8,8)) ax=[ax1] elif plot=='line' or plot=='stacked': fig, (ax1) = plt.subplots(1,1,figsize=(10,4)) ax=[ax1] elif n==2: if vertical: if figsize: fig, (ax1,ax2) = plt.subplots(2,1,figsize=figsize) ax=[ax1,ax2] else: fig, (ax1,ax2) = plt.subplots(2,1,figsize=(5,10)) ax=[ax1,ax2] else: fig, (ax1,ax2) = plt.subplots(1,2,figsize=(10,5)) ax=[ax1,ax2] elif n==3: if figsize: if vertical: fig, (ax1,ax2,ax3) = plt.subplots(3,1,figsize=figsize) else: fig, (ax1,ax2,ax3) = plt.subplots(1,3,figsize=figsize) else: fig, (ax1,ax2,ax3) = plt.subplots(1,3,figsize=(9,3,)) ax=[ax1,ax2,ax3] else: if vertical==True: nrows=n ncols=1 else: nrows,ncols=plot_layout(n) if figsize: fx,fy=figsize else: fx,fy=get_figsize(nrows,ncols) fig, axes = plt.subplots(nrows,ncols,figsize=(fx,fy)) ax=[] for a in axes: if vertical==True: ax.append(a) else: for b in a: ax.append(b) if len(ax) != n: plt.delaxes(ax[-1]) return fig, ax
def main(infile="dam_break.out", outfile="out-local.mp4", startpic="start.png"): """Visualize shallow water simulation results. Args: infile: Name of input file generated by simulator outfile: Desired output file (mp4 or gif) startpic: Name of picture generated at first frame """ u = np.fromfile(infile, dtype=np.dtype('f4')) nx = int(u[0]) ny = int(u[1]) x = range(0,nx) y = range(0,ny) u = u[2:] nframe = len(u) // (nx*ny) stride = nx // 20 u = np.reshape(u, (nframe,nx,ny)) X, Y = np.meshgrid(x,y) fig = plt.figure(figsize=(10,10)) def plot_frame(i, stride=5): ax = fig.add_subplot(111, projection='3d') ax.set_zlim(0, 2) Z = u[i,:,:]; ax.plot_surface(X, Y, Z, rstride=stride, cstride=stride) return ax if startpic: ax = plot_frame(0) plt.savefig(startpic) plt.delaxes(ax) metadata = dict(title='Wave animation', artist='Matplotlib') if outfile[-4:] == ".mp4": Writer = manimation.writers['ffmpeg'] writer = Writer(fps=15, metadata=metadata, extra_args=["-r", "30", "-c:v", "libx264", "-pix_fmt", "yuv420p"]) elif outfile[-4:] == ".gif": Writer = manimation.writers['imagemagick'] writer = Writer(fps=15, metadata=metadata) with writer.saving(fig, outfile, nframe): for i in range(nframe): ax = plot_frame(i) writer.grab_frame() plt.delaxes(ax)
def tetrahedron_array(): """ Make figure of tetrahedra along different combinations of singular vectors colored by sector association """ # Load Fits filename = 'saves/8_factor_matrices.pkl.gz' E, W, C, SSE, varexpl = local_load(filename) # Calculate Singular Vectors A = np.dot(E, W) u, s, vt = svd(A.T, full_matrices=0) vtE = np.asarray(np.dot(vt, E)) # Define colors and assign to data points csu = np.array([ '#984EA3', '#E41A1C', '#A65628', '#F781BF', '#4DAF4A', '#377EB8', '#FF7F00', '#FFF000' ]) csuarray = csu[np.argmax(W, 0)] # Plot fig, axs = plt.subplots(8, 8, figsize=(20, 20)) for ((j, i), ax) in np.ndenumerate(axs): if i < j: xs, ys = u[:, i].T * s[i], u[:, j].T * s[j] ax.scatter(xs, ys, s=5, color=csuarray) ax.scatter(vtE[i, :], vtE[j, :], s=10, color='k') ax.set_axis_off() xy = zip(vtE[i, :], vtE[j, :]) for p in itertools.combinations(xy, 2): ax.plot([p[0][0], p[1][0]], [p[0][1], p[1][1]], ls='--', color='#D9D9D9') else: plt.delaxes(ax) plt.subplots_adjust(hspace=0.05, wspace=0.05) plt.savefig('figures/tetrahedron_array.png', bbox_inches='tight', pad_inches=0) plt.close() return
def histogram(data): fig, axs = plt.subplots(3, 5, figsize=(24, 12)) i = 0 j = 0 bestStd = None for row in data: if all(isinstance(x, float) for x in data[row]): stdScore = std(data[row].dropna()) if bestStd == None or bestStd > stdScore: bestStd = stdScore bestRow = row Gryffindor = getHouse(data, row, 'Gryffindor') Slytherin = getHouse(data, row, 'Slytherin') Ravenclaw = getHouse(data, row, 'Ravenclaw') Hufflepuff = getHouse(data, row, 'Hufflepuff') if len(Gryffindor) > 0 and len(Slytherin) > 0 and len( Ravenclaw) > 0 and len(Hufflepuff) > 0: axs[i][j].set_title(str(row)) axs[i][j].hist(np.hstack(Gryffindor), histtype='bar', alpha=0.3, label='Gryffindor') axs[i][j].hist(np.hstack(Slytherin), histtype='bar', alpha=0.3, label='Slytherin') axs[i][j].hist(np.hstack(Ravenclaw), histtype='bar', alpha=0.3, label='Ravenclaw') axs[i][j].hist(np.hstack(Hufflepuff), histtype='bar', alpha=0.3, label='Hufflepuff') axs[i][j].legend(prop={'size': 6}) j += 1 if j > 4: i += 1 j = 0 if i < 3 and j < 4: plt.delaxes(axs[2][3]) plt.delaxes(axs[2][4]) print( str(bestRow) + " has the most homogeneous distribution of scores between the four houses" ) plt.show()
def generateTaxSubplots(search_rank): for ax_ind1, ax_ind2, bcs, name in zip(subplot_coordinates_list_columns, subplot_coordinates_list_rows, ncbiblast_barcodes, name_list): applyTaxPlotStyle(ax_ind1, ax_ind2, bcs, search_rank, name) if len(list(ntblasthit_reads_filtered_barcodes['barcode_arrangement'].unique())) != 0: plt.delaxes(ax[subplot_coordinates_list_columns[-1], subplot_coordinates_list_rows[-1]]) plt.suptitle('Reads Hitting NCBI Database - % By ' + str(search_rank).title() + ' By Sample', fontsize='x-large', y=1.02, fontweight="bold") plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=1.4, hspace=0.4) plt.tight_layout() plt.savefig('/home/yiheng/analysis/WGS/figures/' + 'figure3_%s_%s.png' % (column_name, search_rank), bbox_inches='tight') plt.show()
def pieplots(self, column, for_test=True, for_target=True, nan_as_cat=True): n_subplots = 2 subtitles = [column + '_train'] data = [ self._data.loc[self._train, column].value_counts(normalize=True, dropna=nan_as_cat).values ] labels = [ self._data.loc[self._train, column].value_counts(normalize=True, dropna=nan_as_cat).index ] if for_test: n_subplots += 1 subtitles.append(column + '_test') data.append(self._data.loc[self._test, column].value_counts( normalize=True, dropna=nan_as_cat).values) labels.append(self._data.loc[self._test, column].value_counts( normalize=True, dropna=nan_as_cat).index) if for_target: for t in [0, 1]: n_subplots += 1 subtitles.append(column + ' target=' + str(t)) idx = self._target[self._target.eq(t)].index data.append(self._data.loc[idx, column].value_counts( normalize=True, dropna=nan_as_cat).values) labels.append(self._data.loc[idx, column].value_counts( normalize=True, dropna=nan_as_cat).index) f, ax = plt.subplots( 1, n_subplots, figsize=(n_subplots * 4 + sum([for_test, for_target, for_target]), 4)) for i in range(n_subplots - 1): ax[i].pie(x=data[i], labels=labels[i], explode=[0.1] * len(labels[i]), autopct='%1.2f%%') ax[i].set(title=subtitles[i]) plt.delaxes(ax[-1]) plt.show()
def plot_1dscans(filenames, plot_file=None, cols=3, width=14, l_col='log_likelihood'): """ plots the scan for all filenames as a grid """ rows = np.ceil(len(filenames) / cols).astype(int) _, axes = plt.subplots(rows, cols, figsize=(width, 0.7 * width / cols * rows)) # fig = plt.figure() for i, ax in enumerate(axes.ravel()): if i < len(filenames): scan, parameter = read_1dscan(filenames[i], l_col) param_range = scan.to_numpy()[:, 0] ll = scan.to_numpy()[:, 1] ax.plot(param_range, ll, label='scan') params_config = read_params_config(filenames[i]) init = get_params_config(params_config, parameter)["init"].values[0] init_idx = np.searchsorted(param_range, init) ax.axvline(x=init, label='init', ls='--', color='tab:orange') ax.axhline(y=ll[init_idx], ls='--', color='tab:orange') x_scan_max, y_scan_max = param_range[np.nanargmax(ll)], np.nanmax( ll) ax.axvline(x=x_scan_max, label='ll max', ls='--', color='tab:green') ax.axhline(y=y_scan_max, ls='--', color='tab:green') ax.set_xlabel(parameter) ax.set_ylabel('log likelihood') ax.ticklabel_format(style='sci', scilimits=(0, 1), useOffset=False) ax.legend() else: plt.delaxes(ax) plt.tight_layout() if plot_file != None: plt.savefig(plot_file + '_1dscans.pdf') plt.show()
def handle_plottabChanged(self, index): self.parent_application.current_viewtab = index if index == 0: # multiplots view_name = self.parent_application.multiviews[0].name if CmdBase.mode == CmdMode.GUI: ind = self.parent_application.viewComboBox.findText( view_name, Qt.MatchExactly) self.parent_application.viewComboBox.blockSignals(True) self.parent_application.viewComboBox.setCurrentIndex( ind) # set the view combobox according to current view self.parent_application.viewComboBox.blockSignals(False) for i in range(self.nplots): self.axarr[i].set_position(self.bbox[i]) self.axarr[i].set_visible(True) try: plt.subplot(self.axarr[i]) except: pass else: # single plot max-size tab_to_maxi = index - 1 # in 0 1 2 view_name = self.parent_application.multiviews[tab_to_maxi].name if CmdBase.mode == CmdMode.GUI: ind = self.parent_application.viewComboBox.findText(view_name) self.parent_application.viewComboBox.blockSignals(True) self.parent_application.viewComboBox.setCurrentIndex( ind) # set the view combobox according to current view self.parent_application.viewComboBox.blockSignals(False) for i in range(self.nplots): if i == tab_to_maxi: # hide other plots self.axarr[i].set_visible(True) self.axarr[i].set_position(self.bboxmax) try: plt.subplot(self.axarr[i]) except: pass else: self.axarr[i].set_visible(False) try: plt.delaxes(self.axarr[i]) except: pass self.parent_application.update_datacursor_artists() self.canvas.draw() self.parent_application.set_view_tools(view_name)
def plot_noisy_param_run(filenames, params_config, skip=0, cols=3, width=14): """ needs list of final files """ no_params = len(params_config) rows = np.ceil(no_params / cols).astype(int) _, axes = plt.subplots(rows, cols, figsize=(width, 0.7 * width / cols * rows)) ax = axes.ravel() for i, k in enumerate(params_config.items()): n = 0 for minimization_final_file in filenames: if os.path.isfile(minimization_final_file): parameters_settings = read_params_config( minimization_final_file) final = get_params_config(parameters_settings, k[0])["final"].values[0] init = get_params_config(parameters_settings, k[0])["init"].values[0] err_bar = float( pd.read_csv(minimization_final_file, skiprows=14)[k[0]].iloc[2]) ax[i].errorbar(n, final, yerr=err_bar, color='tab:blue', fmt='o', ms=3, label="deviation prediction") # ax[i].scatter(n, final, color="tab:blue") ax[i].scatter(n, init, color="tab:orange") else: print(minimization_final_file, "not found!") n += 1 # ax[i].ticklabel_format(style='sci', scilimits=(0,1), useOffset=False) ax[i].set_ylabel(k[0]) ax[i].set_xlabel("run") for i in range(len(params_config), len(ax)): plt.delaxes(ax[i]) plt.tight_layout() plt.show()
def plotHistWithoutOutliers(df, fig=(12, 8), thresh=0.25, imputestrategy="median", outliertreat="remove"): """this function does not change the dataframe permanently""" df = df.select_dtypes("number") col = 4 row = int(len(df.columns) / col) + 1 _, axes = plt.subplots(row, col, figsize=fig) delete = row * col - len(df.columns) for d in range(delete): plt.delaxes(axes[row - 1, col - d - 1]) plt.suptitle("Histograms without outliers") r = 0 c = 0 fc = 0 for f in sorted(df.columns): Q1 = df[f].fillna(df[f].agg(imputestrategy)).quantile(thresh) Q3 = df[f].fillna(df[f].agg(imputestrategy)).quantile(1 - thresh) IQR = Q3 - Q1 t1 = (Q3 + 1.5 * IQR) t2 = (Q1 - 1.5 * IQR) cond = ((df[f] > t1) | (df[f] < t2)) r = int(fc / 4) c = fc % 4 if outliertreat == "remove": df[~cond][f].hist(ax=axes[r, c]) elif outliertreat == "cap": s = df[f].copy() s.where(s > t2, t2, inplace=True) s.where(s < t1, t1, inplace=True) s.hist(ax=axes[r, c]) else: print("wrong value for outliertreat") raise #axes[r,c].set_xticklabels(axes[r,c].get_xticklabels(), rotation=r,ha='right') axes[r, c].set_title(f) plt.tight_layout(rect=[0, 0.03, 1, 0.95]) fc = fc + 1
def show(self, outfn='1dexample'): # Compute stats about the solution. self.hist() fig, axes = plt.subplots(2, 2, gridspec_kw={ 'width_ratios': [1, 3], 'height_ratios': [1, 3] }) plt.delaxes(axes[0, 0]) # Objective function. dom = np.linspace(0, 1, 1000) axes[1, 1].plot(dom, self.energy(dom), pt.pc['db'], lw=0.5) # Statistics of solution. axes[0, 1].hist(self.states, bins=np.linspace(0, 1, 30)) axes[0, 1].set_xlim(axes[1, 1].get_xlim()) axes[0, 1].set_yticks(pt.thin_ticks(axes[0, 1].get_yticks())) axes[1, 0].hist(self.ens, orientation='horizontal') print(axes[1, 0].get_xlim(), axes[1, 0].get_ylim()) #axes[1,0].set_yticks(np.linspace(0,1,5)) #axes[1,1].set_yticks(np.linspace(0,1,5)) #axes[1,0].set_xticks(np.linspace(0,100,3,dtype=int)) axes[1, 0].set_xticks(pt.thin_ticks(axes[1, 0].get_xticks())) pt.fix_lims(axes[1, 1]) axes[0, 1].set_xlim(axes[1, 1].get_xlim()) axes[1, 0].set_ylim(axes[1, 1].get_ylim()) fig.set_size_inches(4, 3) # Labeling. axes[1, 1].set_xlabel('Domain') axes[0, 1].set_ylabel('Histogram') axes[1, 0].set_xlabel('Histogram') axes[1, 0].set_ylabel('Objective') fig.tight_layout() sns.despine() fig.savefig(outfn + '.pdf') fig.savefig(outfn + '.eps')
def basemap_temperature(data_comp,met): lat_ts=90.0 ; lat_0=90.0 ; lon_0=-45.0 ; sgn=1 width=7000000. ; height=7000000.0 ; vmin = 32 ; vmax = 36 ; ind = 0 if met == 5: mm = 0 elif met == 200: mm = 16 elif met == 400: mm = 21 else: print "error: wrong depth level" fig, axes = plt.subplots(2,3) for data in data_comp: m = Basemap(ax=axes.flat[ind],width=width,height=height,resolution='h',\ projection='stere',lat_ts=lat_ts,lat_0=lat_0,lon_0=lon_0) # the continents will be drawn on top. #m.drawmapboundary(fill_color='white') # fill continents, set lake color same as ocean color. #m.fillcontinents(color='grey',lake_color='navy') m.drawlsmask(land_color='grey',ocean_color='white',lakes=True) x,y=m(data_comp[data].lon,data_comp[data].lat) datam = data_comp[data].S[mm,:,:] sitm = np.ma.masked_where(np.isnan(datam),datam) CS=m.pcolormesh(x,y,sitm,cmap=cmocean.cm.salt,vmin=vmin,vmax=vmax) m.drawparallels(np.arange(-80.,81.,15.)) m.drawmeridians(np.arange(-180.,181.,30.)) #m.drawcoastlines() axes.flat[ind].set_title('Sal at '+str(met)+'m - '+data_comp[data].title) ind += 1 cbar_ax = fig.add_axes([1.9, 0.3, 0.045, 1.4]) cbar = plt.colorbar(CS, cax=cbar_ax,) cbar.ax.set_ylabel(r'$psu$') plt.delaxes(axes.flat[-1]) fig.subplots_adjust(right=1.7,top=1.8)
def plot_changes_dept(df_pre_merged, df_post_merged, col_names, ctrl_terms, department_list): ''' Plot changes by department ''' n_cols = 2 n_rows = math.ceil(len(department_list) / n_cols) #print('number of rows', n_rows) if n_rows == 2: fig, axs = plt.subplots(n_rows, n_cols, figsize=(7.5, 7.5)) elif n_rows == 3: fig, axs = plt.subplots(n_rows, n_cols, figsize=(7.5, 9.5)) for i, department_name in enumerate(department_list): df = get_changes(df_pre_merged, df_post_merged, 'id', col_names, 'ttal', ctrl_terms, department_name, pctg=False) #df.to_csv('images/fig5_{}.csv'.format(re.sub(r"[^a-zA-Z0-9]+", '', department_name))) plt.subplot(n_rows, n_cols, i + 1) plt.xlabel("Terms", fontsize=9, fontfamily='Arial') plt.ylabel("Change", fontsize=9, fontfamily='Arial') plt.title(department_name, fontsize=10, fontfamily='Arial') plt.grid(which='major', axis='x') plt.xticks(rotation='vertical', fontsize=8, fontfamily='Arial') plt.yticks(fontsize=8, fontfamily='Arial') plt.gca().spines['right'].set_color('none') plt.gca().spines['top'].set_color('none') plt.bar(df['term'], df['change'], color="#d9b80d") if len(department_list) % 2 != 0: plt.delaxes(axs[n_cols - 1, n_rows - 1]) plt.tight_layout() plt.show() #plt.savefig(save_name) '''
def savePlot(self, source, hold): for i, data in enumerate(source): try: self.figure += 1 except AttributeError: self.figure = 1 plt.figure(self.figure) if(hold == None): plt.plot(data) else: if(isinstance(hold, list)): plt.axis([hold[i][0], hold[i][-1], -1.0, 1.0]) print(i, data, hold[i][0], hold[i][-1]) #plt.ylim(-1.0, 1.0) plt.plot(hold[i], data) else: plt.axis([hold[0], hold[-1], -1.0, 1.0]) plt.plot(hold, data) plt.savefig('image/' + str(i) + '.png', dpi=72) plt.delaxes()
def main(infile="waves.out", startpic="start", frame="0"): """Visualize shallow water simulation results. Args: infile: Name of input file generated by simulator outfile: Desired output file (mp4 or gif) startpic: Name of picture generated at first frame """ u = np.fromfile(infile, dtype=np.dtype('f4')) nx = int(u[0]) ny = int(u[1]) x = range(0,nx) y = range(0,ny) u = u[2:] fn = int(frame) nframe = len(u) // (nx*ny) stride = nx // 20 u = np.reshape(u, (nframe,nx,ny)) X, Y = np.meshgrid(x,y) fig = plt.figure(figsize=(10,10)) def plot_frame(i, stride=5): ax = fig.add_subplot(111, projection='3d') ax.set_zlim(0, 2) Z = u[i,:,:]; ax.plot_surface(X, Y, Z, rstride=stride, cstride=stride) return ax for imgn in range(fn): ax = plot_frame(int(imgn)) plt.savefig(startpic + str(imgn) + ".png") plt.delaxes(ax) """
def plot_ltt(var, **kwargs): """Plot the daily min, max, and mean of a parameter, filtering for known bad data as listed in filter_times.py. :var: MSID or derived parameter name (string) Optional inputs: :savefig: Save and close figure (default is True) :saveas: Name to save figure as (default is <MSID>.png) :samefig: Use current figure (default is False) :start: Start time (default is after OAC on 1999:250) :stop: Stop time (default is None) :stat: Statistic type ('5min' or 'daily', default is 'daily') :filter: User-defined Start and End times to filter out due to bad data. If none are supplied, it will default to any listed in filter_times.py. In addition, LTTplot will always filter known NSM and SSM events as listed in filter_times.py (bad_all). :plot_stds: Plot standard deviations (default is True) :plot_mins: Plot minimum values (default is True) :plot_means: Plot mean values (default is True) :plot_maxes: Plot maximum values (default is True) :plot_limits: Plot database yellow caution and red warning limits (default is True) :yellow: User-defined yellow caution limit lines (default is none) :min_mark: User-defined marker for minimum values (default is 'b:') :max_mark: User-defined marker for maximum values (default is 'g:') :mean_mark: User-defined marker for mean values (default is 'k+') :red: User-defined red warning limit lines (default is none) :subplot: Subplot information in [rows, columns, subplot number] (default is [1, 1, 1]) :fig_width: Figure width (default is 8). Helpful if x-axis is crowded. Irrelevant if samefig=True. :fig_height: Figure height (default varies by number of subplots: 6 for 1 row of subplots, 9 for 2 rows, otherwise 12). Irrelevant if samefig=True. :ylim: User-defined y-limits (default is none) :legend: Display legend (default is False) :cust_title: Custom title (default is MSID and description) :cust_unit: Custom unit to be displayed on y-axis label, typically for use with custom_mult or derived parameters (default is none) :custom_mult: Custom multiplier, typically for use with custom unit (default is none) e.g. LTTplot('Dist_SatEarth') LTTplot('pline05t', ylim=[30,170], savefig=False) LTTplot('pr1tv01t', limit_lines=False, yellow=150, red=240) LTTplot('pr2tv01t', limit_lines=False, yellow=[40,150], red=[37,240]) LTTplot('plaed3gt', filter=['2011:299:00:00:00 2011:300:00:00:00']) LTTplot('pcm01t', subplot=[4,1,1], savefig=False) LTTplot('aogbias1', cust_unit='ARCSEC/SEC', cust_mult=3600*180/pi, subplot=311) LTTplot('aosares1', start='2003:001', stop='2003:100', fig_width=10, fig_height=6) LTTplot('dp_css1_npm_sun', plot_means=False, plot_maxes=False, plot_stds=False, min_mark='rd', legend=True) """ var = var.lower() start = kwargs.pop('start', '1999:250') stop = kwargs.pop('stop', None) stat = kwargs.pop('stat', 'daily') # Collect data and filter for bad points data = fetch.Msid(var, start, stop, stat=stat) data.filter_bad_times(table=getattr(bad, 'bad_all')) if kwargs.has_key('filter'): data.filter_bad_times(table=kwargs.pop('filter')) elif hasattr(bad, 'bad_' + var): data.filter_bad_times(table=getattr(bad, 'bad_' + var)) # Define subplots and figure size # Figure size will vary depending on the number of subplots. If # plotting standard deviations, ax1 will only be used to reference # default axes size. ax1 will be deleted and data will be plotted on ax2. sub = kwargs.pop('subplot', 111) # Convert subplot input to list form if provided by user as integer if np.isscalar(sub): sub = [int(str(sub)[0]), int(str(sub)[1]), int(str(sub)[2])] # Create a new figure unless using existing figure if not kwargs.pop('samefig', False): if kwargs.has_key('fig_height'): fig_height = kwargs.pop('fig_height') elif sub[0] == 1: fig_height = 6 elif sub[0] == 2: fig_height = 6 else: fig_height = 12 fig_width = kwargs.pop('fig_width', 8) pp.figure(figsize=(fig_width, fig_height)) ax1 = pp.subplot(sub[0], sub[1], sub[2]) ax1.ticklabel_format(useOffset=False) if kwargs.get('plot_stds', True): ax_pos = ax1.get_position().get_points() ax_width = ax_pos[1,0] - ax_pos[0,0] ax_height = ax_pos[1,1] - ax_pos[0,1] pp.delaxes(ax1) ax2 = pp.axes([ax_pos[0,0], ax_pos[0,1] + .20 * ax_height, ax_width, .75 * ax_height]) ax2.ticklabel_format(useOffset=False) # Plot data mult = kwargs.pop('cust_mult', 1) lim = kwargs.pop('limit_lines', True) if kwargs.pop('plot_maxes', True): plot_cxctime(data.times, data.maxes * mult, kwargs.pop('max_mark', 'g.'), markersize=3, label=(stat + ' maxes')) if kwargs.pop('plot_mins', True): plot_cxctime(data.times, data.mins * mult, kwargs.pop('min_mark', 'b.'), markersize=3, label=(stat + ' mins')) if kwargs.pop('plot_means', True): plot_cxctime(data.times, data.means * mult, kwargs.pop('mean_mark', 'k.'), markersize=3, label=(stat + ' means')) # Adjust x-axis x_ax = Time.DateTime(pp.xlim(), format='plotdate').mjd dur = np.diff(x_ax) x_ax_new = [x_ax[0], x_ax[1] + .1*dur[0]] pp.xlim(Time.DateTime(x_ax_new, format='mjd').plotdate) # Plot limits if kwargs.pop('plot_limits', True): # Check if single limit set exists in TDB if (hasattr(data, 'tdb') and (data.tdb.Tlmt is not None)): pp.plot(pp.xlim(), np.array([data.tdb.Tlmt[4] * mult, data.tdb.Tlmt[4] * mult]), 'r') pp.plot(pp.xlim(), np.array([data.tdb.Tlmt[2] * mult, data.tdb.Tlmt[2] * mult]), 'y') pp.plot(pp.xlim(), np.array([data.tdb.Tlmt[3] * mult, data.tdb.Tlmt[3] * mult]), 'y') pp.plot(pp.xlim(), np.array([data.tdb.Tlmt[5] * mult, data.tdb.Tlmt[5] * mult]), 'r') if ~kwargs.has_key('ylim'): pp.ylim(np.array([data.tdb.Tlmt[4] - 10.0, data.tdb.Tlmt[5] + 10.0])) # Add title if kwargs.has_key('cust_title'): title = kwargs.pop('cust_title') elif hasattr(data, 'tdb'): title = data.tdb.technical_name + ' - ' + data.msid.upper() else: title=data.msid.upper() pp.title(title) # Account for custom y-labels if kwargs.has_key('cust_unit'): pp.ylabel(kwargs.pop('cust_unit')) else: pp.ylabel(data.unit) pp.grid() # Plot custom limit lines if kwargs.has_key('ylim'): pp.ylim(kwargs.pop('ylim')) if kwargs.has_key('yellow'): y = np.array([kwargs.pop('yellow')]) for i in range(len(y)): pp.plot(pp.xlim(), np.array([y[i], y[i]]), 'y') if kwargs.has_key('red'): r = np.array([kwargs.pop('red')]) for i in range(len(r)): pp.plot(pp.xlim(), np.array([r[i], r[i]]), 'r') # Add legend if kwargs.pop('legend', False): pp.legend(loc='best') # Plot standard deviations on ax3 if kwargs.get('plot_stds', True): ax2.set_xticklabels([]) ax3 = pp.axes([ax_pos[0,0], ax_pos[0,1] + .05 * ax_height, ax_width, .15 * ax_height]) plot_cxctime(data.times, data.stds * mult, color='k', label=(stat + ' stdev')) ax3.yaxis.set_major_locator(ticker.MaxNLocator(2)) y_ticks = pp.yticks() y_lim = pp.ylim() pp.xlim(Time.DateTime(x_ax_new, format='mjd').plotdate) # prevent overlap between y-axis and stdev y-axis if (y_lim[1] - y_ticks[0][-1]) / y_lim[-1] < .70: pp.yticks(y_ticks[0][:-1]) # Ensure xticks aren't rotated ax = pp.gca() pp.setp(ax.get_xticklabels(), 'rotation', 0) # Save and close figure s = kwargs.pop('savefig', True) if s == True: figname = kwargs.pop('saveas', data.msid.lower() + '.png') pp.savefig(figname) pp.close()
def fig_lfp_decomposition(fig, axes, params, transient=200, X=['L23E', 'L6E'], show_xlabels=True): # ana_params.set_PLOS_2column_fig_style(ratio=0.5) # fig, axes = plt.subplots(1,5) # fig.subplots_adjust(left=0.06, right=0.96, wspace=0.4, hspace=0.2) if analysis_params.bw: # linestyles = ['-', '-', '--', '--', '-.', '-.', ':', ':'] linestyles = ['-', '-', '-', '-', '-', '-', '-', '-'] markerstyles = ['s', 's', 'v', 'v', 'o', 'o', '^', '^'] else: if plt.matplotlib.__version__ == '1.5.x': linestyles = ['-', ':']*(len(params.Y) / 2) print('CSD variance semi log plots may fail with matplotlib.__version__ {}'.format(plt.matplotlib.__version__)) else: linestyles = ['-', (0, (1,1))]*(len(params.Y) / 2) #cercor version # markerstyles = ['s', 's', 'v', 'v', 'o', 'o', '^', '^'] markerstyles = [None]*len(params.Y) linewidths = [1.25 for i in range(len(linestyles))] plt.delaxes(axes[0]) #population plot axes[0] = fig.add_subplot(261) axes[0].xaxis.set_ticks([]) axes[0].yaxis.set_ticks([]) axes[0].set_frame_on(False) plot_population(axes[0], params, aspect='tight', isometricangle=np.pi/32, plot_somas = False, plot_morphos = True, num_unitsE = 1, num_unitsI=1, clip_dendrites=False, main_pops=True, rasterized=False) phlp.annotate_subplot(axes[0], ncols=5, nrows=1, letter='A') axes[0].set_aspect('auto') axes[0].set_ylim(-1550, 50) axis = axes[0].axis() phlp.remove_axis_junk(axes[1]) plot_signal_sum(axes[1], params, fname=os.path.join(params.populations_path, X[0] + '_population_LFP.h5'), unit='mV', T=[800,1000], ylim=[axis[2], axis[3]], rasterized=False) # CSD background colorplot im = plot_signal_sum_colorplot(axes[1], params, os.path.join(params.populations_path, X[0] + '_population_CSD.h5'), unit=r'$\mu$Amm$^{-3}$', T=[800,1000], colorbar=False, ylim=[axis[2], axis[3]], fancy=False, cmap=plt.get_cmap('gray', 21) if analysis_params.bw else plt.get_cmap('bwr_r', 21), rasterized=False) cb = phlp.colorbar(fig, axes[1], im, width=0.05, height=0.5, hoffset=-0.05, voffset=0.5) cb.set_label('($\mu$Amm$^{-3}$)', labelpad=0.) axes[1].set_ylim(-1550, 50) axes[1].set_title('LFP and CSD ({})'.format(X[0]), va='baseline') phlp.annotate_subplot(axes[1], ncols=3, nrows=1, letter='B') #quickfix on first axes axes[0].set_ylim(-1550, 50) if show_xlabels: axes[1].set_xlabel(r'$t$ (ms)',labelpad=0.) else: axes[1].set_xlabel('') phlp.remove_axis_junk(axes[2]) plot_signal_sum(axes[2], params, fname=os.path.join(params.populations_path, X[1] + '_population_LFP.h5'), ylabels=False, unit='mV', T=[800,1000], ylim=[axis[2], axis[3]], rasterized=False) # CSD background colorplot im = plot_signal_sum_colorplot(axes[2], params, os.path.join(params.populations_path, X[1] + '_population_CSD.h5'), unit=r'$\mu$Amm$^{-3}$', T=[800,1000], ylabels=False, colorbar=False, ylim=[axis[2], axis[3]], fancy=False, cmap=plt.get_cmap('gray', 21) if analysis_params.bw else plt.get_cmap('bwr_r', 21), rasterized=False) cb = phlp.colorbar(fig, axes[2], im, width=0.05, height=0.5, hoffset=-0.05, voffset=0.5) cb.set_label('($\mu$Amm$^{-3}$)', labelpad=0.) axes[2].set_ylim(-1550, 50) axes[2].set_title('LFP and CSD ({})'.format(X[1]), va='baseline') phlp.annotate_subplot(axes[2], ncols=1, nrows=1, letter='C') if show_xlabels: axes[2].set_xlabel(r'$t$ (ms)',labelpad=0.) else: axes[2].set_xlabel('') plotPowers(axes[3], params, params.Y, 'CSD', linestyles=linestyles, transient=transient, markerstyles=markerstyles, linewidths=linewidths) axes[3].axis(axes[3].axis('tight')) axes[3].set_ylim(-1550, 50) axes[3].set_yticks(-np.arange(16)*100) if show_xlabels: axes[3].set_xlabel(r'$\sigma^2$ ($(\mu$Amm$^{-3})^2$)', va='center') axes[3].set_title('CSD variance', va='baseline') axes[3].set_xlim(left=1E-7) phlp.remove_axis_junk(axes[3]) phlp.annotate_subplot(axes[3], ncols=1, nrows=1, letter='D') plotPowers(axes[4], params, params.Y, 'LFP', linestyles=linestyles, transient=transient, markerstyles=markerstyles, linewidths=linewidths) axes[4].axis(axes[4].axis('tight')) axes[4].set_ylim(-1550, 50) axes[4].set_yticks(-np.arange(16)*100) if show_xlabels: axes[4].set_xlabel(r'$\sigma^2$ (mV$^2$)', va='center') axes[4].set_title('LFP variance', va='baseline') axes[4].legend(bbox_to_anchor=(1.37, 1.0), frameon=False) axes[4].set_xlim(left=1E-7) phlp.remove_axis_junk(axes[4]) phlp.annotate_subplot(axes[4], ncols=1, nrows=1, letter='E') return fig
m = 0 s_max = 2 s_min = 0.2 x = np.linspace(m -3*s_max, m + 3*s_max, 1000) s_values = np.linspace(s_max, s_min, 30) # f is max for x=m; smaller s gives larger max value max_f = f(m, m, s_min) # Make a first plot mpl.ion() fig = mpl.figure() # Show the movie, and make hardcopies of frames simulatenously counter = 0 for s in s_values: mpl.delaxes() # delete plot, replot everything for this s ax = fig.gca() ax.axis([x[0], x[-1], -0.1, max_f]) y = f(x, m, s) ax.plot(x, y) ax.set_xlabel('x') ax.set_ylabel('f') ax.legend(['s=%4.2f' % s]) mpl.draw() fig.savefig('tmp_%04d.png' % counter) counter += 1 raw_input('Type Return key: ')
def pcol( x, y, data, projection=None, vmin=None, vmax=None, **kwargs): """function h=pcol(x,y,v) function h=pcol(x,y,v, projection = mp ) plots 2D scalar fields v on the MITgcm cubed sphere grid with pcolormesh. x,y are really 'xg', and 'yg', that is, they should be the coordinates of the points one half grid cell to the left and bottom, that is vorticity points for tracers, etc. The optional flag 'sphere' results in a 3D visualization on the sphere without any specific projection. Good for debugging. If present, 'projection' (a basemap instance) is used to transform coordinates. Unfortunatly, cylindrical and conic maps are limited to the [-180 180] range. projection = 'sphere' results in a 3D visualization on the sphere without any specific projection. Good for debugging. Example script to use pcol.py: from mpl_toolkits.basemap import Basemap import MITgcmutils as mit import matplotlib.pyplot as plt from sq import sq x=mit.rdmds('XG'); y=mit.rdmds('YG'); e=mit.rdmds('Eta',np.Inf) fig = plt.figure(); mp = Basemap(projection='moll',lon_0 = 0., resolution = 'l', area_thresh = 1000.) plt.clf() h = mit.cs.pcol(x,y,sq(e), projection = mp) mp.fillcontinents(color = 'grey') mp.drawmapboundary() mp.drawmeridians(np.arange(0, 360, 30)) mp.drawparallels(np.arange(-90, 90, 30)) plt.show() """ # pcol first divides the 2D cs-field(6*n,n) into six faces. Then for # each face, an extra row and colum is added from the neighboring faces in # order to fool pcolor into drawing the entire field and not just # (n-1,m-1) data points. There are two corner points that have no explicit # coordinates so that they have to be found by # interpolation/averaging. Then each face is divided into 4 tiles, # assuming cs-geometry, and each tile is plotted individually in # order to avoid problems due to ambigous longitude values (the jump # between -180 and 180, or 360 and 0 degrees). As long as the poles # are at the centers of the north and south faces and the first tile is # symmetric about its center this should work. # get the figure handle fig=plt.gcf() mapit = 0 if projection!=None: mp = projection if mp=='sphere': mapit=-1 else: mapit = 1 # convert to [-180 180[ representation x = np.where(x>180,x-360.,x) ny,nx = data.shape # determine range for color range cax = [data.min(),data.max()] if cax[1]-cax[0]==0: cax = [cax[0]-1,cax[1]+1] if vmin!=None: cax[0]=vmin if vmax!=None: cax[1]=vmax if mapit == -1: # set up 3D plot if len(fig.axes)>0: # if present, remove and replace the last axis of fig geom=fig.axes[-1].get_geometry() plt.delaxes(fig.axes[-1]) else: # otherwise use full figure geom = ((1,1,1)) ax = fig.add_subplot(geom[0],geom[1],geom[2],projection = '3d', axisbg='None') # define color range tmp = data - data.min() N = tmp/tmp.max() # use this colormap colmap = cm.jet colmap.set_bad('w',1.0) mycolmap = colmap(N) #cm.jet(N) ph=np.array([]) jc=x.shape[0]/2 xxf=np.empty((jc+1,jc+1,4)) yyf=xxf ffld=np.empty((jc,jc,4)) xff=[] yff=[] fldf=[] for k in range(0,6): ix = np.arange(0,ny) + k*ny xff.append(x[0:ny,ix]) yff.append(y[0:ny,ix]) fldf.append(data[0:ny,ix]) # find the missing corners by interpolation (one in the North Atlantic) xfodd = (xff[0][-1,0]+xff[2][-1,0]+xff[4][-1,0])/3. yfodd = (yff[0][-1,0]+yff[2][-1,0]+yff[4][-1,0])/3. # and one south of Australia xfeven= (xff[1][0,-1]+xff[3][0,-1]+xff[5][0,-1])/3. yfeven= (yff[1][0,-1]+yff[3][0,-1]+yff[5][0,-1])/3. # loop over tiles for k in range(0,6): kodd = 2*(k/2) kodd2 = kodd if kodd==4: kodd2=kodd-6 keven = 2*(k/2) keven2 = keven if keven==4: keven2=keven-6 fld = fldf[k] if np.mod(k+1,2): xf = np.vstack( [ np.column_stack( [xff[k],xff[1+kodd][:,0]] ), np.flipud(np.append(xff[2+kodd2][:,0],xfodd))] ) yf = np.vstack( [ np.column_stack( [yff[k],yff[1+kodd][:,0]] ), np.flipud(np.append(yff[2+kodd2][:,0],yfodd))] ) else: xf = np.column_stack( [np.vstack( [xff[k],xff[2+keven2][0,:]] ), np.flipud(np.append(xff[3+keven2][0,:], xfeven))] ) yf = np.column_stack( [np.vstack( [yff[k],yff[2+keven2][0,:]] ), np.flipud(np.append(yff[3+keven2][0,:], yfeven))] ) if mapit==-1: ix = np.arange(0,ny) + k*ny # no projection at all (projection argument is 'sphere'), # just convert to cartesian coordinates and plot a 3D sphere deg2rad=np.pi/180. xcart,ycart,zcart = sph2cart( xf*deg2rad, yf*deg2rad ) ax.plot_surface(xcart,ycart,zcart,rstride=1,cstride=1, facecolors=mycolmap[0:ny,ix], linewidth=2,shade=False) ph = np.append(ph, ax) else: # divide all faces into 4 because potential problems arise at # the centers for kf in range(0,4): if kf==0: i0,i1,j0,j1 = 0, jc+1, 0, jc+1 elif kf==1: i0,i1,j0,j1 = 0, jc+1,jc,2*jc+1 elif kf==2: i0,i1,j0,j1 = jc,2*jc+1, 0, jc+1 elif kf==3: i0,i1,j0,j1 = jc,2*jc+1,jc,2*jc+1 xx = xf[i0:i1,j0:j1] yy = yf[i0:i1,j0:j1] ff = fld[i0:i1-1,j0:j1-1] if np.median(xx) < 0: xx = np.where(xx>=180,xx-360.,xx) else: xx = np.where(xx<=-180,xx+360.,xx) # if provided use projection if mapit==1: xx,yy = mp(xx,yy) # now finally plot 4x6 tiles ph = np.append(ph, plt.pcolormesh(xx, yy, ff, vmin=cax[0], vmax=cax[1], **kwargs)) if mapit == -1: ax.axis('image') ax.set_axis_off() # ax.set_visible=False # add a reasonable colormap m = cm.ScalarMappable(cmap=colmap) m.set_array(data) plt.colorbar(m) elif mapit == 0: ax = fig.axes[-1] ax.axis('image') plt.grid('on') return ph
def poincarePlot(xyvalues1, xyvalues2, box, max, projections=(0,0)): """ Scatter plot with projection histograms IN: xyvalues = tuple (float,float) box = text max = tuple (float,float) projections = tuple (bool,bool) """ from matplotlib.ticker import NullFormatter x1, y1 = xyvalues1 # sample 1 x2, y2 = xyvalues2 # sample2 ax = plt.subplot() if projections == (0,0): # the scatter plot ax.scatter(x1,y1,s=1) if xyvalues2 != (0,0): ax.scatter(x2,y2,s=1,c='r') # set tick label size ax.tick_params(labelsize='xx-small') # place a text box in upper left in axes coords props = dict(boxstyle='round', facecolor='wheat', alpha=0.5) # these are matplotlib.patch.Patch properties ax.text(0.05, 0.95, box, transform=ax.transAxes, fontsize=10, verticalalignment='top', bbox=props) (xmax,ymax) = max plt.xlim([-xmax,xmax]) plt.ylim([-ymax,ymax]) plt.autoscale(enable=False,axis='both') return elif projections != (0,0): nullfmt = NullFormatter() # no labels plt.delaxes(ax) # definitions for the axes left, width = 0.1, 0.65 bottom, height = 0.1, 0.65 bottom_h = bottom + height + 0.02 left_h = left + width + 0.02 rect_scatter = [left, bottom, width, height] rect_histx = [left, bottom_h, width, 0.2] rect_histy = [left_h, bottom, 0.2, height] # the scatter plot axScatter = plt.axes(rect_scatter) axScatter.scatter(x1, y1, s=1) if xyvalues2 != (0,0): axScatter.scatter(x2, y2, s=1, c='r') # set tick label size axScatter.tick_params(labelsize='xx-small') # place a text box in upper left in axes coords props = dict(boxstyle='round', facecolor='wheat', alpha=0.5) # these are matplotlib.patch.Patch properties axScatter.text(0.05, 0.95, box, transform=axScatter.transAxes, fontsize=10, verticalalignment='top', bbox=props) (prx,pry) = projections (xmax,ymax) = max if prx == 1: # x projection axHistx = plt.axes(rect_histx) # no labels axHistx.xaxis.set_major_formatter(nullfmt) axHistx.yaxis.set_major_formatter(nullfmt) # now determine nice limits by hand: binwidthx = xmax/100. limx = (int(xmax/binwidthx) + 1) * binwidthx axScatter.set_xlim((-limx, limx)) binsx = NP.arange(-limx, limx + binwidthx, binwidthx) axHistx.hist(x1, bins=binsx, color='black') # axHistx.set_xlim(axScatter.get_xlim()) if pry == 1: # y projection axHisty = plt.axes(rect_histy) # no labels axHisty.xaxis.set_major_formatter(nullfmt) axHisty.yaxis.set_major_formatter(nullfmt) # now determine nice limits by hand: binwidthy = ymax/100. limy = (int(ymax/binwidthy) + 1) * binwidthy axScatter.set_ylim((-limy, limy)) binsy = NP.arange(-limy, limy + binwidthy, binwidthy) axHisty.hist(y1, bins=binsy, orientation='horizontal', color='black') # axHisty.set_ylim(axScatter.get_ylim()) return
ax.set_xlim(0.0, 2.5) ax.set_ylim(0.0, 2.5) ax.set_zlim(0.0, 3.0) data = np.loadtxt("./particles_"+times[i], skiprows=1) locations[:,0] = data[:,0] locations[:,1] = data[:,1] locations[:,2] = data[:,2] #velocities[:,0] = data[:,3] #velocities[:,1] = data[:,4] #velocities[:,2] = data[:,5] X = data[:,0] Y = data[:,1] Z = data[:,2] ax.scatter(X, Z, Y, s=10*10) return ax metadata = dict(title='SPH', artist='Matplotlib') Writer = manimation.writers['ffmpeg'] writer = Writer(fps=15, metadata=metadata, extra_args=["-r", "30", "-c:v", "libx264", "-pix_fmt", "yuv420p"]) with writer.saving(fig, "movie.mp4", f): for i in range(f): print "frame ",i," written. ",float(i)/float(f)*100.0,"% done. \n", ax = plot_frame(i) writer.grab_frame() plt.delaxes(ax)
def __init__(self, prevHandler, savefile, source_name='time_freq', extent='default'): PlotTimeFreqDataHandler.__init__(self, prevHandler, source_name, extent) plt.savefig(savefile, dpi=72) plt.delaxes()
def _initialize(self): # Count number of plots to create: num_plots = 0 for config in self._config.itervalues(): num_plots += len(config) # Set default grid of plot positions: if not self._rows*self._cols == num_plots: self._cols = int(np.ceil(np.sqrt(num_plots))) self._rows = int(np.ceil(num_plots/float(self._cols))) self.f, self.axarr = plt.subplots(self._rows, self._cols, figsize=self._figsize) # Remove unused subplots: for i in xrange(num_plots, self._rows*self._cols): plt.delaxes(self.axarr[np.unravel_index(i, (self._rows, self._cols))]) cnt = 0 self.handles = [] self.types = [] keywds = ['handle', 'ydata', 'fmt', 'type', 'ids', 'shape'] if not isinstance(self.axarr, np.ndarray): self.axarr = np.asarray([self.axarr]) for LPU, configs in self._config.iteritems(): for plt_id, config in enumerate(configs): ind = np.unravel_index(cnt, self.axarr.shape) cnt+=1 # Some plot types require specific numbers of # neuron ID arrays: if 'type' in config: if config['type'] == 'quiver': assert len(config['ids'])==2 config['type'] = 0 elif config['type'] == 'hsv': assert len(config['ids'])==2 config['type'] = 1 elif config['type'] == 'image': assert len(config['ids'])==1 config['type'] = 2 elif config['type'] == 'waveform': config['type'] = 3 elif config['type'] == 'raster': config['type'] = 4 elif config['type'] == 'rate': config['type'] = 5 else: raise ValueError('Plot type not supported') else: if str(LPU).startswith('input') or not self._graph[LPU][str(config['ids'][0])]['spiking']: config['type'] = 2 else: config['type'] = 4 if config['type'] < 3: if not 'shape' in config: # XXX This can cause problems when the number # of neurons is not equal to # np.prod(config['shape']) num_neurons = len(config['ids'][0]) config['shape'] = [int(np.ceil(np.sqrt(num_neurons)))] config['shape'].append(int(np.ceil(num_neurons/float(config['shape'][0])))) if config['type'] == 0: config['handle'] = self.axarr[ind].quiver(\ np.reshape(self._data[LPU][config['ids'][0],0],config['shape']),\ np.reshape(self._data[LPU][config['ids'][1],0],config['shape'])) elif config['type'] == 1: X = np.reshape(self._data[LPU][config['ids'][0],0],config['shape']) Y = np.reshape(self._data[LPU][config['ids'][1],0],config['shape']) V = (X**2 + Y**2)**0.5 H = (np.arctan2(X,Y)+np.pi)/(2*np.pi) S = np.ones_like(V) HSV = np.dstack((H,S,V)) RGB = hsv_to_rgb(HSV) config['handle'] = self.axarr[ind].imshow(RGB) elif config['type'] == 2: if 'trans' in config: if config['trans'] is True: to_transpose = True else: to_transpose = False else: to_transpose = False config['trans'] = False if to_transpose: temp = self.axarr[ind].imshow(np.transpose(np.reshape(\ self._data[LPU][config['ids'][0],0], config['shape']))) else: temp = self.axarr[ind].imshow(np.reshape(\ self._data[LPU][config['ids'][0],0], config['shape'])) temp.set_clim(self._imlim) temp.set_cmap(plt.cm.gist_gray) config['handle'] = temp elif config['type'] == 3: fmt = config['fmt'] if 'fmt' in config else '' self.axarr[ind].set_xlim(self._xlim) self.axarr[ind].set_ylim(self._ylim) if len(config['ids'][0])==1: config['handle'] = self.axarr[ind].plot([0], \ [self._data[LPU][config['ids'][0][0],0]], fmt)[0] config['ydata'] = [self._data[LPU][config['ids'][0][0],0]] else: config['handle'] = self.axarr[ind].plot(self._data[LPU][config['ids'][0],0])[0] elif config['type'] == 4: config['handle'] = self.axarr[ind] config['handle'].vlines(0, 0, 0.01) config['handle'].set_ylim([.5, len(config['ids'][0]) + .5]) config['handle'].set_ylabel('Neurons', fontsize=self._fontsize-1, weight='bold') config['handle'].set_xlabel('Time (s)',fontsize=self._fontsize-1, weight='bold') config['handle'].set_xlim([0,len(self._data[LPU][config['ids'][0][0],:])*self._dt]) config['handle'].axes.set_yticks([]) config['handle'].axes.set_xticks([]) for key in config.iterkeys(): if key not in keywds: try: self._set_wrapper(self.axarr[ind],key, config[key]) except: pass try: self._set_wrapper(config['handle'],key, config[key]) except: pass if config['type']<3: config['handle'].axes.set_xticks([]) config['handle'].axes.set_yticks([]) if self.suptitle is not None: self.f.suptitle(self._title, fontsize=self._fontsize+1, x=0.5,y=0.03, weight='bold') plt.tight_layout() if self.out_filename: self.writer = FFMpegFileWriter(fps=self.fps, codec=self.codec) # Use the output file to determine the name of the temporary frame # files so that two concurrently run visualizations don't clobber # each other's frames: self.writer.setup(self.f, self.out_filename, dpi=80, frame_prefix=os.path.splitext(self.out_filename)[0]+'_') self.writer.frame_format = 'png' self.writer.grab_frame() else: self.f.show()
def _onKeyRelease(self, event): """ Fired on all key releases. It essentially is a simple state manager with the key being routed to different places depending on the current application state. """ key = event.key # Default mode is no mode. if self._current_app_mode is None: # Enter help mode. if key == KEYMAP["show help"]: self._current_app_mode = "help" self._axes_to_restore = plt.gcf().axes self.help_axis = plt.gcf().add_axes((0, 0, 1, 1)) self.help_axis.text( 0.5, 0.8, HELP_TEXT, transform=self.help_axis.transAxes, verticalalignment="center", horizontalalignment="center") self.help_axis.set_xticks([]) self.help_axis.set_yticks([]) self._deactivate_multicursor() plt.draw() # Enter weight selection mode. elif key == KEYMAP["set weight"]: self._current_app_mode = "weight_selection" self._current_weight = "" self._update_current_weight("", editing=True) # Navigation elif key == KEYMAP["next station"]: self.next() elif key == KEYMAP["previous station"]: self.prev() elif key == KEYMAP["reset station"]: self.reset() return # Weight selection mode. elif self._current_app_mode == "weight_selection": weight_keys = "0123456789." # Keep typing the new weight. if key in weight_keys: self._current_weight += key self._update_current_weight(self._current_weight, editing=True) # Set the new weight. If that fails, reset it. In any case, leave # the weight selection mode. else: self._current_app_mode = None try: weight = float(self._current_weight) except: self._update_current_weight(self.weight) return self._update_current_weight(weight) # Help selection mode. Any keypress while in it will exit it. elif self._current_app_mode == "help": plt.delaxes(self.help_axis) del self.help_axis for ax in self._axes_to_restore: plt.gcf().add_axes(ax) del self._axes_to_restore plt.tight_layout() self._activate_multicursor() plt.draw() self._current_app_mode = None return
def plot(self, show_best=True, show_mean=True, latexify=False, font_family="serif", scale='linear', summarize=True, print_pareto=False): """ Visualize the progress of an optimization. Args: show_best (bool): Point out the best point on legend and on plot. If more than one best point (i.e., multiple equal maxima), show them all. If multiobjective, shows best for each objective, and prints the best value and x for each objective. show_mean (bool): Show the mean and standard deviation for the guesses as the computations are carried out. latexify (bool): Use LaTeX for formatting. font_family (str): The font family to use for rendering. Choose from 'serif', 'sans-serif', 'fantasy', 'monospace', or 'cursive'. scale (str): Whether to scale the plot's y axis according to log ('log') or 'linear' scale. summarize (bool): If True, stdouts summary from .summarize. print_pareto (bool): If True, display all Pareto-optimal objective values. Returns: A matplotlib plot object handle """ if not self.is_configured: raise NotConfiguredError("Use MissionControl.configure to configure" "your optimization collection before " "plotting!") maximize = self.config["maximize"] fxstr = "$f(x)$" if latexify else "f(x)" opt = max if maximize else min objs = self.c.find_one({'index': {'$exists': 1}})['y'] n_objs = len(objs) if isinstance(objs, (list, tuple)) else 1 dt = datetime.datetime.now() dtdata = [dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second] timestr = "{}-{}-{} {}:{}.{}".format(*dtdata) t0 = time.time() if latexify: plt.rc('text', usetex=True) else: plt.rc('text', usetex=False) plt.rc('font', family=font_family, size=9) n_cols = 3 if n_objs < n_cols: _, ax_arr = plt.subplots(n_objs, squeeze=False) else: _, ax_arr = plt.subplots(n_cols, int(math.ceil(n_objs / n_cols)), squeeze=False) docset = self.c.find({'index': {'$exists': 1}}) docs = [None] * docset.count() for i, doc in enumerate(docset): docs[i] = {'y': doc['y'], 'index': doc['index'], 'x': doc['x']} if n_objs > 1: all_y = np.asarray([doc['y'] for doc in docs]) pareto_set = all_y[pareto(all_y, maximize=maximize)].tolist() pareto_graph = [(i + 1, doc['y']) for i, doc in enumerate(docs) if doc['y'] in pareto_set] pareto_i = [i[0] for i in pareto_graph] print("Optimization Analysis:") print("Number of objectives: {}".format(n_objs)) for obj in range(n_objs): ax = ax_arr[obj % n_cols, int(math.floor(obj / n_cols))] i = [] fx = [] best = [] mean = [] std = [] n = self.c.find().count() - 2 for doc in docs: fx.append(doc['y'] if n_objs == 1 else doc['y'][obj]) i.append(doc['index']) best.append(opt(fx)) mean.append(np.mean(fx)) std.append(np.std(fx)) if time.time() - t0 > 60: self.logger.warn( "Gathering data from the db is taking a while. Ensure" "the latency to your db is low and the bandwidth" "is as high as possible!") mean = np.asarray(mean) std = np.asarray(std) ax.scatter(i, fx, color='blue', label=fxstr, s=10) ax.plot(i, best, color='orange', label="best {} value found so far" "".format(fxstr)) if show_mean: ax.plot(i, mean, color='grey', label="mean {} value (with std " "dev.)".format(fxstr)) ax.fill_between(i, mean + std, mean - std, color='grey', alpha=0.3) ax.set_xlabel("{} evaluation".format(fxstr)) ax.set_ylabel("{} value".format(fxstr)) best_val = opt(best) if show_best: if latexify: best_label = "Best value: $f(x) = {}$" \ "".format(latex_float(best_val)) else: best_label = "Best value: f(x) = {:.2E}".format(best_val) best = self.c.find({'y': best_val}) if n_objs == 1: print("\tNumber of optima: {}".format(best.count())) else: print("\tNumber of optima for objective {}: {}" "".format(obj + 1, best.count())) for b in best: bl = None if n_objs > 1 else best_label ax.scatter([b['index']], [best_val], color='darkgreen', s=50, linewidth=3, label=bl, facecolors='none', edgecolors='darkgreen') artext = "$x = $ [" if latexify else "x = [" for i, xi in enumerate(b['x']): if i > 0: artext += ". \mbox{~~~~~}" if latexify else " " if type(xi) in dtypes.floats: if latexify: artext += "${}$,\n".format(latex_float(xi)) else: artext += "{:.2E},\n".format(xi) else: artext += str(xi) + ",\n" artext = artext[:-2] + "]" objstr = "objective {}".format( obj + 1) if n_objs > 1 else "" if maximize: print("\t\tmax(f(x)) {} is {} at x = {}" "".format(objstr, best_val, b['x'])) else: print("\t\tmin(f(x)) {} is {} at x = {}" "".format(objstr, best_val, b['x'])) ax.annotate(artext, xy=(b['index'] + 0.5, best_val), xytext=(b['index'] + float(n) / 12.0, best_val), arrowprops=dict(color='green'), color='darkgreen', bbox=dict(facecolor='white', alpha=1.0)) else: best_label = "" if n_objs > 1: pareto_fx = [i[1][obj] for i in pareto_graph] ax.scatter(pareto_i, pareto_fx, color='red', label="Pareto optimal", s=20) if n_objs > 1: ax.set_title("Objective {}: {}".format(obj + 1, best_label)) ax.set_yscale(scale) plt.gcf().set_size_inches(10, 10) if summarize: print(self.summarize()) if print_pareto and n_objs > 1: print("Pareto Frontier: {} points, ranked by hypervolume".format( len(pareto_set))) pareto_y = [doc['y'] for doc in docs if doc['y'] in pareto_set] pareto_x = [doc['x'] for doc in docs if doc['y'] in pareto_set] # Order y by hypervolume hypervolumes = [np.prod(y) for y in pareto_y] pareto_y_ordered = [y for _, y in sorted(zip(hypervolumes, pareto_y), reverse=True)] pareto_x_ordered = [x for _, x in sorted(zip(hypervolumes, pareto_x), reverse=True)] hypervolumes_ordered = sorted(hypervolumes, reverse=True) for i, _ in enumerate(pareto_set): print("f(x) = {} @ x = {} with hypervolume {}".format( pareto_y_ordered[i], pareto_x_ordered[i], hypervolumes_ordered[i])) if n_objs % n_cols != 0 and n_objs > n_cols: for i in range(n_objs % n_cols, n_cols): plt.delaxes(ax_arr[i, -1]) plt.legend() # plt.tight_layout(pad=0.01, w_pad=0.01, h_pad=0.01) plt.subplots_adjust(wspace=0.3, hspace=0.5) plt.suptitle("Rocketsled optimization results for {} - " "{}".format(self.c.name, timestr), y=0.99) return plt
def boxPlot(x_axis = 'initialFreq', dataPath = '/home/muddcs15/research/work/hemiplasy/results/', prob1 = '0.001', prob2 = '0.01', prob3 = '0.05', prob4 = '0.1', prob5 = '0.5', spectree = '/home/muddcs15/research/work/hemiplasy/data/config/fungi.stree', output = 'save'): """ A function that will output boxplots of probability of hemiplasy and probability of hemiplasy over duploss vs. initial allele frequency x_axis can be: 'initialFreq' 'pairs' 'dupLocation' output can be: 'save' or 'print' """ if x_axis == 'initialFreq': events = open('/home/muddcs15/research/work/hemiplasy/results/hemiplasy-loss.error.txt', 'r') for line in events: famid, locus, spcs, gns, snode, lca = line.rstrip().split('\t') # define number of plots to be outputed fig, axes = plt.subplots(nrows=1, ncols=2) # identify the files for each of the different initial frequencies probs1 = os.path.join(dataPath, 'probabilities-' + prob1 + '.txt') probs2 = os.path.join(dataPath, 'probabilities-' + prob2 + '.txt') probs3 = os.path.join(dataPath, 'probabilities-' + prob3 + '.txt') probs4 = os.path.join(dataPath, 'probabilities-' + prob4 + '.txt') probs5 = os.path.join(dataPath, 'probabilities-' + prob5 + '.txt') probsList = [probs1, probs2, probs3, probs4, probs5] totalPerList = [] # probability of hemiplasy compared to duploss totalAList = [] # probability of hemiplasy ocurring h = 0 # probability that ocurred by hemiplasy d = 0 # probability that ocurred by duploss # open each probability file for probFilename in probsList: hList = [] # list of probability of hemiplasy perList = [] # list of percentage with prob hemiplasy > prob duploss aveList = [] # list of average probability of hemiplasy per fam id # look at each famid for that initial frequency probFile = open(probFilename, "r") for line in probFile: sepProbs = line.split() fam = sepProbs.pop(0) famid = fam[6:] # get the probability of duploss and hemiplasy for each trial in each famid for pair in sepProbs: duploss, hemiplasy = map(float, pair.split(',')) hList.append(hemiplasy) # check whether hemiplasy is more likely or duploss if hemiplasy > duploss: h += 1 else: d += 1 # calculate the percent that likely ocurred by hemiplasy percent = float(h)/float(h+d) # get the average probability of hemiplasy for each famid ave = stats.mean(hList) # append percent by hemiplasy to perList and average for the famid to aveList perList.append(percent) aveList.append(ave) # append the lists through each famid to the large lists for each list of values totalPerList.append(perList) totalAList.append(aveList) # close file probFile.close() # define the first plot and its labels axes[0].boxplot(totalAList) axes[0].set_title('Probability of Hemiplasy') axes[0].set_xticklabels(['0.001','0.01','0.05','0.1','0.5'],minor=False) axes[0].set_xlabel('Initial Frequency') axes[0].set_ylabel('Probability') # define the second plot and its labels axes[1].boxplot(totalPerList) axes[1].set_title('Probability of Hemiplasy vs. DupLoss') axes[1].set_xticklabels(['0.001','0.01','0.05','0.1','0.5'],minor=False) axes[1].set_xlabel('Initial Frequency') axes[1].set_ylabel('Probability') # save the plots if that is desired if output == 'save': fig = plt.gcf() fig.set_size_inches(10, 8) fig.savefig(dataPath+'figures/freq.png') # print the plots if that is desired elif output == 'print': plt.show() elif x_axis == 'pairs': stree = treelib.read_tree(spectree) # species tree species = stree.leaf_names() species1 = [] species2 = [] for node in stree: if len(node.leaves()) == 2: species1.append(node.children[0].name) species2.append(node.children[1].name) # identify the files for each of the different initial frequencies probs1 = os.path.join(dataPath, 'probabilities-' + prob1 + '.txt') probs2 = os.path.join(dataPath, 'probabilities-' + prob2 + '.txt') probs3 = os.path.join(dataPath, 'probabilities-' + prob3 + '.txt') probs4 = os.path.join(dataPath, 'probabilities-' + prob4 + '.txt') probsList = [probs1, probs2, probs3, probs4] totalPerList = [] # probability of hemiplasy compared to duploss totalAList = [] # probability of hemiplasy ocurring totalPairs = [] h = 0 # probability that ocurred by hemiplasy d = 0 # probability that ocurred by duploss pair1 = [] pair2 = [] pair3 = [] pair4 = [] pair5 = [] # open each probability file for probFilename in probsList: events = open('/home/muddcs15/research/work/hemiplasy/results/hemiplasy-loss.txt', 'r') hList = [] # list of probability of hemiplasy perList = [] # list of percentage with prob hemiplasy > prob duploss aveList = [] # list of average probability of hemiplasy per fam id countTrue = 0 # look at each famid for that initial frequency probFile = open(probFilename, "r") for line in probFile: sepProbs = line.split() fam = sepProbs.pop(0) famid = fam[6:] # get the probability of duploss and hemiplasy for each trial in each famid for pair in sepProbs: duploss, hemiplasy = map(float, pair.split(',')) hList.append(hemiplasy) # check whether hemiplasy is more likely or duploss if hemiplasy > duploss: h += 1 else: d += 1 # calculate the percent that likely ocurred by hemiplasy percent = float(h)/float(h+d) # get the average probability of hemiplasy for each famid ave = stats.mean(hList) # append percent by hemiplasy to perList and average for the famid to aveList perList.append(percent) aveList.append(ave) # get the number pair between which the hemiplasy could have occurred for line in events: ev_famid, locus, spcs, gns, snode, lca = line.rstrip().split('\t') if famid == ev_famid: countTrue += 1 for sp1, sp2 in zip(species1, species2): if (sp1 in spcs and sp2 not in spcs): spec_check = sp1 specPos = species1.index(sp1) elif (sp2 in spcs and sp1 not in spcs): spec_check = sp2 specPos = species2.index(sp2) break # add the hemiplasy probability to the list of the pair in which it potentially occurred if specPos == 0: pair1.append(ave) if specPos == 1: pair2.append(ave) if specPos == 2: pair3.append(ave) if specPos == 3: pair4.append(ave) if specPos == 4: pair5.append(ave) events.close() # close file probFile.close() # append the list of probabilities of hemiplasy for each pair as a separate list to the totalPairs list, creating a list of lists totalPairs.append(pair1) totalPairs.append(pair2) totalPairs.append(pair3) totalPairs.append(pair4) totalPairs.append(pair5) # define the plot's inputs plt.boxplot(totalPairs) plt.title('Hemiplasy by Pairs') plt.xlabel('Pair') plt.ylabel('Probability') # save the plots if that is desired if output == 'save': fig = plt.gcf() fig.set_size_inches(10, 8) fig.savefig(dataPath+'figures/pairs.png') # print the plots if that is desired elif output == 'print': plt.show() elif x_axis == 'dupLocation': stree = treelib.read_tree(spectree) # species tree species = stree.leaf_names() species1 = [] species2 = [] for node in stree: if len(node.leaves()) == 2: species1.append(node.children[0].name) species2.append(node.children[1].name) # define number of plots to be outputed fig, axes = plt.subplots(nrows=2, ncols=3) # identify the files for each of the different initial frequencies probs1 = os.path.join(dataPath, 'probabilities-' + prob1 + '.txt') probs2 = os.path.join(dataPath, 'probabilities-' + prob2 + '.txt') probs3 = os.path.join(dataPath, 'probabilities-' + prob3 + '.txt') probs4 = os.path.join(dataPath, 'probabilities-' + prob4 + '.txt') probsList = [probs1, probs2, probs3, probs4] totalPerList = [] # probability of hemiplasy compared to duploss totalAList = [] # probability of hemiplasy ocurring totalPairs = [] h = 0 # probability that ocurred by hemiplasy d = 0 # probability that ocurred by duploss pair1 = [] pair2 = [] pair3 = [] pair4 = [] pair5 = [] pairList = [pair1, pair2, pair3, pair4, pair5] totalFList = [] totalPDList =[] # open each probability file for probFilename in probsList: events = open('/home/muddcs15/research/work/hemiplasy/results/hemiplasy-loss.txt', 'r') hList = [] # list of probability of hemiplasy perList = [] # list of percentage with prob hemiplasy > prob duploss aveList = [] # list of average probability of hemiplasy per fam id famList = [] PDList = [] # look at each famid for that initial frequency probFile = open(probFilename, "r") for line in probFile: sepProbs = line.split() fam = sepProbs.pop(0) famid = fam[6:] famList.append(famid) # get the probability of duploss and hemiplasy for each trial in each famid for pair in sepProbs: duploss, hemiplasy = map(float, pair.split(',')) hList.append(hemiplasy) # check whether hemiplasy is more likely or duploss if hemiplasy > duploss: h += 1 else: d += 1 # calculate the percent that likely ocurred by hemiplasy percent = float(h)/float(h+d) # get the average probability of hemiplasy for each famid ave = stats.mean(hList) # append percent by hemiplasy to perList and average for the famid to aveList perList.append(percent) aveList.append(ave) # get the number pair between which the hemiplasy could have occurred for line in events: ev_famid, locus, spcs, gns, dup, lca = line.rstrip().split('\t') if famid == ev_famid: for sp1, sp2 in zip(species1, species2): if (sp1 in spcs and sp2 not in spcs): spec_check = sp1 specPos = species1.index(sp1) elif (sp2 in spcs and sp1 not in spcs): spec_check = sp2 specPos = species2.index(sp2) break PDList.append((specPos, dup)) # add the duplication location and the hemiplasy probability to the list of the pair it was determined to have occurred in famNum = 0 for pos, dpl in PDList: if pos == 0: pair1.append((int(dpl), aveList[famNum])) if pos == 1: pair2.append((int(dpl), aveList[famNum])) if pos == 2: pair3.append((int(dpl), aveList[famNum])) if pos == 3: pair4.append((int(dpl), aveList[famNum])) if pos == 4: pair5.append((int(dpl), aveList[famNum])) famNum += 1 events.close() # append the lists through each famid to the large lists for each list of values totalPerList.append(perList) totalAList.append(aveList) totalFList.append(famList) totalPDList.append(PDList) # close file probFile.close() # create a dictionary with the lists of each pair finalPair = collections.defaultdict(list) # go through each pair list and get the duplication pairCount = 0 for pairNum in pairList: pairCount += 1 dup = collections.defaultdict(list) # get the probability pertaining to each duplication location and the pair, and append it to the dictionary for (dupLoc, prob) in pairNum: dup[dupLoc].append(prob) # add each pair as a separate list of lists to the finalPair list finalPair[pairCount].extend([dup[dupLoc] for dupLoc in xrange(1,14)]) # define the first plot and its labels axes[0,0].boxplot(finalPair[1]) axes[0,0].set_title('Pair1') axes[0,0].set_xlabel('Duplication Location') axes[0,0].set_ylabel('Probability') axes[0,0].set_ylim(0,0.25) # define the second plot and its labels axes[0,1].boxplot(finalPair[2]) axes[0,1].set_title('Pair2') axes[0,1].set_xlabel('Duplication Location') axes[0,1].set_ylabel('Probability') axes[0,1].set_ylim(0,0.25) # define the third plot and its labels axes[0,2].boxplot(finalPair[3]) axes[0,2].set_title('Pair3') axes[0,2].set_xlabel('Duplication Location') axes[0,2].set_ylabel('Probability') axes[0,2].set_ylim(0,0.25) # define the fourth plot and its labels axes[1,0].boxplot(finalPair[4]) axes[1,0].set_title('Pair4') axes[1,0].set_xlabel('Duplication Location') axes[1,0].set_ylabel('Probability') axes[1,0].set_ylim(0,0.25) # define the fifth plot and its labels axes[1,1].boxplot(finalPair[5]) axes[1,1].set_title('Pair5') axes[1,1].set_xlabel('Duplication Location') axes[1,1].set_ylabel('Probability') axes[1,1].set_ylim(0,0.25) plt.delaxes(axes[1,2]) # save the plots if that is desired if output == 'save': fig = plt.gcf() fig.set_size_inches(15, 10) fig.savefig(dataPath+'figures/dupLoc.png') # print the plots if that is desired elif output == 'print': plt.show()
def _initialize(self): # Count number of plots to create: num_plots = 0 for config in self._config.itervalues(): num_plots += len(config) # Set default grid of plot positions: if not self._rows*self._cols == num_plots: self._cols = int(np.ceil(np.sqrt(num_plots))) self._rows = int(np.ceil(num_plots/float(self._cols))) self.f, self.axarr = plt.subplots(self._rows, self._cols, figsize=self._figsize) # Remove unused subplots: for i in xrange(num_plots, self._rows*self._cols): plt.delaxes(self.axarr[np.unravel_index(i, (self._rows, self._cols))]) cnt = 0 self.handles = [] self.types = [] keywds = ['handle', 'ydata', 'fmt', 'type', 'ids', 'shape', 'norm'] # TODO: Irregular grid in U will make the plot better U, V = np.mgrid[0:np.pi/2:complex(0, 60), 0:2*np.pi:complex(0, 60)] X = np.cos(V)*np.sin(U) Y = np.sin(V)*np.sin(U) Z = np.cos(U) self._dome_pos_flat = (X.flatten(), Y.flatten(), Z.flatten()) self._dome_pos = (X, Y, Z) self._dome_arr_shape = X.shape if not isinstance(self.axarr, np.ndarray): self.axarr = np.asarray([self.axarr]) for LPU, configs in self._config.iteritems(): for plt_id, config in enumerate(configs): ind = np.unravel_index(cnt, self.axarr.shape) cnt+=1 # Some plot types require specific numbers of # neuron ID arrays: if 'type' in config: if config['type'] == 'quiver': assert len(config['ids'])==2 config['type'] = 0 elif config['type'] == 'hsv': assert len(config['ids'])==2 config['type'] = 1 elif config['type'] == 'image': assert len(config['ids'])==1 config['type'] = 2 elif config['type'] == 'waveform': config['type'] = 3 elif config['type'] == 'raster': config['type'] = 4 elif config['type'] == 'rate': config['type'] = 5 elif config['type'] == 'dome': config['type'] = 6 else: raise ValueError('Plot type not supported') else: if str(LPU).startswith('input') and not self._graph[LPU].node[str(config['ids'][0][0])]['spiking']: config['type'] = 2 else: config['type'] = 4 if config['type'] < 3: if not 'shape' in config: # XXX This can cause problems when the number # of neurons is not equal to # np.prod(config['shape']) num_neurons = len(config['ids'][0]) config['shape'] = [int(np.ceil(np.sqrt(num_neurons)))] config['shape'].append(int(np.ceil(num_neurons/float(config['shape'][0])))) if config['type'] == 0: config['handle'] = self.axarr[ind].quiver(\ np.reshape(self._data[LPU][config['ids'][0],0],config['shape']),\ np.reshape(self._data[LPU][config['ids'][1],0],config['shape'])) elif config['type'] == 1: X = np.reshape(self._data[LPU][config['ids'][0],0],config['shape']) Y = np.reshape(self._data[LPU][config['ids'][1],0],config['shape']) V = (X**2 + Y**2)**0.5 H = (np.arctan2(X,Y)+np.pi)/(2*np.pi) S = np.ones_like(V) HSV = np.dstack((H,S,V)) RGB = hsv_to_rgb(HSV) config['handle'] = self.axarr[ind].imshow(RGB) elif config['type'] == 2: if 'trans' in config: if config['trans'] is True: to_transpose = True else: to_transpose = False else: to_transpose = False config['trans'] = False if to_transpose: temp = self.axarr[ind].imshow(np.transpose(np.reshape(\ self._data[LPU][config['ids'][0],0], config['shape']))) else: temp = self.axarr[ind].imshow(np.reshape(\ self._data[LPU][config['ids'][0],0], config['shape'])) temp.set_clim(self._imlim) temp.set_cmap(plt.cm.gist_gray) config['handle'] = temp elif config['type'] == 3: fmt = config['fmt'] if 'fmt' in config else '' self.axarr[ind].set_xlim(self._xlim) self.axarr[ind].set_ylim(self._ylim) if len(config['ids'][0])==1: config['handle'] = self.axarr[ind].plot([0], \ [self._data[LPU][config['ids'][0][0],0]], fmt)[0] config['ydata'] = [self._data[LPU][config['ids'][0][0],0]] else: config['handle'] = self.axarr[ind].plot(self._data[LPU][config['ids'][0],0])[0] elif config['type'] == 4: config['handle'] = self.axarr[ind] config['handle'].vlines(0, 0, 0.01) config['handle'].set_ylim([.5, len(config['ids'][0]) + .5]) config['handle'].set_ylabel('Neurons', fontsize=self._fontsize-1, weight='bold') config['handle'].set_xlabel('Time (s)',fontsize=self._fontsize-1, weight='bold') min_id = min(self._id_to_data_idx[LPU].keys()) min_idx = self._id_to_data_idx[LPU][min_id] config['handle'].set_xlim([0,len(self._data[LPU][min_idx,:])*self._dt]) config['handle'].axes.set_yticks([]) config['handle'].axes.set_xticks([]) elif config['type'] == 6: self.axarr[ind].axes.set_yticks([]) self.axarr[ind].axes.set_xticks([]) self.axarr[ind] = self.f.add_subplot(self._rows, self._cols, cnt, projection='3d') config['handle' ] = self.axarr[ind] config['handle'].axes.set_yticks([]) config['handle'].axes.set_xticks([]) config['handle'].xaxis.set_ticks([]) config['handle'].yaxis.set_ticks([]) config['handle'].zaxis.set_ticks([]) if 'norm' not in config.keys(): config['norm'] = Normalize(vmin=-70, vmax=0, clip=True) elif config['norm'] == 'auto': if self._data[LPU].shape[1] > 100: config['norm'] = Normalize(vmin = np.min(self._data[LPU][config['ids'][0],100:]), vmax = np.max(self._data[LPU][config['ids'][0],100:]), clip = True) else: config['norm'] = Normalize(vmin = np.min(self._data[LPU][config['ids'][0],:]), vmax = np.max(self._data[LPU][config['ids'][0],:]), clip = True) node_dict = self._graph[LPU].node if str(LPU).startswith('input'): latpositions = np.asarray([ node_dict[str(nid)]['lat'] \ for nid in range(len(node_dict)) \ if node_dict[str(nid)]['extern'] ]) longpositions = np.asarray([ node_dict[str(nid)]['long'] \ for nid in range(len(node_dict)) \ if node_dict[str(nid)]['extern'] ]) else: latpositions = np.asarray([ node_dict[str(nid)]['lat'] for nid in config['ids'][0] ]) longpositions = np.asarray([ node_dict[str(nid)]['long'] for nid in config['ids'][0] ]) xx = np.cos(longpositions) * np.sin(latpositions) yy = np.sin(longpositions) * np.sin(latpositions) zz = np.cos(latpositions) config['positions'] = (xx, yy, zz) colors = griddata(config['positions'], self._data[LPU][config['ids'][0],0], self._dome_pos_flat, 'nearest').reshape(self._dome_arr_shape) colors = config['norm'](colors).data colors = np.tile(np.reshape(colors, [self._dome_arr_shape[0],self._dome_arr_shape[1],1]) ,[1,1,4]) colors[:,:,3] = 1.0 config['handle'].plot_surface(self._dome_pos[0], self._dome_pos[1], self._dome_pos[2], rstride=1, cstride=1, facecolors=colors, antialiased=False, shade=False) for key in config.iterkeys(): if key not in keywds: try: self._set_wrapper(self.axarr[ind],key, config[key]) except: pass try: self._set_wrapper(config['handle'],key, config[key]) except: pass if config['type']<3: config['handle'].axes.set_xticks([]) config['handle'].axes.set_yticks([]) if self.suptitle is not None: self.f.suptitle(self._title, fontsize=self._fontsize+1, x=0.5,y=0.03, weight='bold') plt.tight_layout() if self.out_filename: if self.FFMpeg is None: if which(matplotlib.rcParams['animation.ffmpeg_path']): self.writer = FFMpegFileWriter(fps=self.fps, codec=self.codec) elif which(matplotlib.rcParams['animation.avconv_path']): self.writer = AVConvFileWriter(fps=self.fps, codec=self.codec) else: raise RuntimeError('cannot find ffmpeg or avconv') elif self.FFMpeg: if which(matplotlib.rcParams['animation.ffmpeg_path']): self.writer = FFMpegFileWriter(fps=self.fps, codec=self.codec) else: raise RuntimeError('cannot find ffmpeg') else: if which(matplotlib.rcParams['animation.avconv_path']): self.writer = AVConvFileWriter(fps=self.fps, codec=self.codec) else: raise RuntimeError('cannot find avconv') # Use the output file to determine the name of the temporary frame # files so that two concurrently run visualizations don't clobber # each other's frames: self.writer.setup(self.f, self.out_filename, dpi=80, frame_prefix=os.path.splitext(self.out_filename)[0]+'_') self.writer.frame_format = 'png' self.writer.grab_frame() else: self.f.show()
filteredDataGyro = [value] angle = value angleData = [] for i in range(18000000): value = gyro.getAccelX() * 90.0 accel = value data.append(value) filteredData.append(0.9 * filteredData[-1] + 0.1 * value) value = gyro.getGyroY() * -1.0 dataGyro.append(value) filteredDataGyro.append(0.9 * filteredDataGyro[-1] + 0.1 * value) angle = (0.9) * (angle + value * 0.01) + (0.1 * filteredData[-1]) angleData.append(angle) if not i % 80: plt.delaxes() #plt.plot(data, color="black") plt.plot(filteredData, color="red") #plt.plot(dataGyro, color="black") #plt.plot(filteredDataGyro, color="cyan") #plt.plot(angleData, color="green") plt.draw() print str(angle) else: time.sleep(0.01) if plt.waitforbuttonpress(0.01) != None: quit()