def show_matplotlib_pre_loaded_figure_in_jupyter(fig: Figure): # Suppresses: `Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.` # https://stackoverflow.com/questions/49503869/attributeerror-while-trying-to-load-the-pickled-matplotlib-figure?noredirect=1&lq=1 dummy = plt.figure() new_manager = dummy.canvas.manager new_manager.canvas.figure = fig fig.set_canvas(new_manager.canvas)
def mathTex_to_QPixmap(mathTex, fs): ''' E/ mathTEx : The formula to be displayed on screen in LaTeX E/ fs : The desired font size S/ qpixmap : The image to be displayed in Qpixmap format ''' # Set up a mpl figure instance # fig = Figure() fig.patch.set_facecolor('none') fig.set_canvas(FigureCanvas(fig)) renderer = fig.canvas.get_renderer() # Plot the mathTex expression # ax = fig.add_axes([0, 0, 1, 1]) ax.axis('off') ax.patch.set_facecolor('none') t = ax.text(0, 0, mathTex, ha='left', va='bottom', fontsize=fs) # Fit figure size to text artist # fwidth, fheight = fig.get_size_inches() fig_bbox = fig.get_window_extent(renderer) text_bbox = t.get_window_extent(renderer) tight_fwidth = text_bbox.width * fwidth / fig_bbox.width tight_fheight = text_bbox.height * fheight / fig_bbox.height fig.set_size_inches(tight_fwidth, tight_fheight) # Convert mpl figure to QPixmap # buf, size = fig.canvas.print_to_buffer() qimage = QtGui.QImage.rgbSwapped(QtGui.QImage(buf, size[0], size[1], QtGui.QImage.Format_ARGB32)) qpixmap = QtGui.QPixmap(qimage) return qpixmap
def subplots(nrows=1, ncols=1, figsize=(12, 8), dpi=120, num=0, subplot_kw={}): """ Equivalent function of pyplot.subplots(). The difference is that this one is not interactive and is used with backend plotting only. Parameters ---------- nrows=1, ncols=1, figsize=(12,8), dpi=120 num : dummy variable for compatibility Returns ------- fig, axes """ fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) axes = np.ndarray((nrows, ncols), dtype=np.object) plt_nr = 1 for row in range(nrows): for col in range(ncols): axes[row, col] = fig.add_subplot(nrows, ncols, plt_nr, **subplot_kw) plt_nr += 1 return fig, axes
def residuals_at_max_likelihood(mcmc_set): # Get the maximum likelihood parameters try: (max_likelihood, max_likelihood_position) = mcmc_set.maximum_likelihood() except NoPositionsException as npe: return Result(None, None) # Get the residuals residuals = mcmc_set.chains[0].get_residuals(max_likelihood_position) # Make the residuals plot fig = Figure() ax = fig.gca() plot_filename = '%s_max_likelihood_residuals.png' % mcmc_set.name thumbnail_filename = '%s_max_likelihood_residuals_th.png' % mcmc_set.name ax.plot(residuals[0], residuals[1]) ax.set_title('Residuals at Maximum Likelihood') #ax.xlabel('Time') #ax.ylabel('Residual') canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) return ThumbnailResult(thumbnail_filename, plot_filename)
def acf_of_ml_residuals(mcmc_set): # Get the maximum likelihood parameters try: (max_likelihood, max_likelihood_position) = mcmc_set.maximum_likelihood() except NoPositionsException as npe: return Result(None, None) # Get the residuals residuals = mcmc_set.chains[0].get_residuals(max_likelihood_position) # Plot the autocorrelation function acf = np.correlate(residuals[1], residuals[1], mode='full') plot_filename = '%s_acf_of_ml_residuals.png' % mcmc_set.name thumbnail_filename = '%s_acf_of_ml_residuals_th.png' % mcmc_set.name fig = Figure() ax = fig.gca() ax.plot(acf) ax.set_title('Autocorrelation of Maximum Likelihood Residuals') canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) return ThumbnailResult(thumbnail_filename, plot_filename)
class ResponsePlotDialog(wx.Dialog): def __init__(self, data, title="LRA Response", parent=None): wx.Dialog.__init__(self, parent=parent, title=title) pnl = wx.Panel(self) pnl.SetBackgroundColour('white') [time, disp, t_f] = data # Plot self.figure = Figure() self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvas(pnl, -1, self.figure) self.axes.grid(alpha=0.5) self.figure.set_canvas(self.canvas) self.axes.clear() self.axes.set_ylabel("Displacement ($\mu$m)") self.axes.set_xlabel("Time (ms)") self.axes.set_title("LRA Response") self.axes.grid(alpha=0.5) self.axes.plot(time * 1e3, disp * 1e6) self.axes.axvspan(0, t_f * 1000, color='green', alpha=0.25) self.canvas.draw() sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(self.canvas, 0, wx.ALL, 10) sizer.Add(self.CreateStdDialogButtonSizer(wx.OK), 0, wx.ALIGN_RIGHT) # pnl.SetSizer(sizer) sizer.SetSizeHints(self) pnl.SetSizerAndFit(sizer) self.Center()
def sample_fits(mcmc_set): tspan = mcmc_set.chains[0].options.tspan fig = Figure() ax = fig.gca() plot_filename = '%s_sample_fits.png' % mcmc_set.name thumbnail_filename = '%s_sample_fits_th.png' % mcmc_set.name # Make sure we can call the method 'get_observable_timecourses' if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \ not hasattr(mcmc_set.chains[0], 'plot_data'): return Result('None', None) # Plot the original data mcmc_set.chains[0].plot_data(ax) # Plot a sampling of trajectories from the original parameter set try: for i in range(num_samples): position = mcmc_set.get_sample_position() timecourses = mcmc_set.chains[0].get_observable_timecourses( position=position) for obs_name, timecourse in timecourses.iteritems(): ax.plot(tspan, timecourse, color='g', alpha=0.1, label=obs_name) except NoPositionsException as npe: pass canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) return ThumbnailResult(thumbnail_filename, plot_filename)
def tBidBax_kd(mcmc_set): """ .. todo:: document the basis for this""" num_kds = 10000 # Get indices for the tBid/Bax binding constants estimate_params = mcmc = mcmc_set.chains[0].options.estimate_params tBid_iBax_kf_index = None tBid_iBax_kr_index = None for i, p in enumerate(estimate_params): if p.name == 'tBid_iBax_kf': tBid_iBax_kf_index = i elif p.name == 'tBid_iBax_kr': tBid_iBax_kr_index = i # If we couldn't find the parameters, return None for the result if tBid_iBax_kf_index is None or tBid_iBax_kr_index is None: return Result(None, None) # Sample the kr/kf ratio across the pooled chains kd_dist = np.zeros(num_kds) for i in range(num_kds): position = mcmc_set.get_sample_position() kd_dist[i] = ((10 ** position[tBid_iBax_kr_index]) / (10 ** position[tBid_iBax_kf_index])) # Calculate the mean and variance mean = kd_dist.mean() sd = kd_dist.std() # Plot the Kd distribution plot_filename = '%s_tBidiBax_kd_dist.png' % mcmc_set.name fig = Figure() ax = fig.gca() ax.hist(kd_dist) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) return MeanSdResult(mean, sd, plot_filename)
class ImpedancePlotDialog(wx.Dialog): def __init__(self, data, title="LRA Model", parent=None): wx.Dialog.__init__(self, parent=parent, title=title) pnl = wx.Panel(self) pnl.SetBackgroundColour('white') [freq, Ze] = data # Plot self.figure = Figure() self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvas(pnl, -1, self.figure) self.axes.grid(alpha=0.5) self.figure.set_canvas(self.canvas) self.axes.clear() self.axes.set_ylabel("Ze (Ohms)") self.axes.set_xlabel("Frequency (Hz)") self.axes.set_title("LRA Impedance Spectrum") self.axes.grid(alpha=0.5) self.axes.loglog(freq, abs(Ze)) self.canvas.draw() sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(self.canvas, 0, wx.ALL, 10) sizer.Add(self.CreateStdDialogButtonSizer(wx.OK), 0, wx.ALIGN_RIGHT) sizer.SetSizeHints(self) pnl.SetSizerAndFit(sizer) self.Center()
def plot_parameter_curve(mcmc_set, p_index, p_name): # Make sure we've already run the fits for this mcmc set! if mcmc_set.name not in two_exp_fits_dict.keys(): raise Exception('%s not found in two_exp_fits_dict!' % mcmc_set.name) # Make sure we've already run the fits for the data! if 'data' not in two_exp_fits_dict.keys(): fit_data(mcmc_set) # Get the parameter array p_arr = two_exp_fits_dict[mcmc_set.name][p_index] p_arr_data = two_exp_fits_dict['data'][p_index] data = mcmc_set.chains[0].data plot_filename = '%s_%s_curve.png' % (mcmc_set.name, p_name) thumbnail_filename = '%s_%s_curve_th.png' % (mcmc_set.name, p_name) # Plot of parameter fig = Figure() ax = fig.gca() ax.plot(data.columns, p_arr, 'b') ax.plot(data.columns, p_arr_data, marker='o', linestyle='', color='r') ax.set_ylabel('%s value' % p_name) ax.set_xlabel('[Bax] (nM)') ax.set_title('%s for %s' % (mcmc_set.name, p_name)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) return ThumbnailResult(thumbnail_filename, plot_filename)
def mathTex_to_QPixmap(mathTex, fs): # ---- set up a mpl figure instance ---- fig = Figure() fig.patch.set_facecolor('none') fig.set_canvas(FigureCanvasAgg(fig)) renderer = fig.canvas.get_renderer() # ---- plot the mathTex expression ---- ax = fig.add_axes([0, 0, 1, 1]) ax.axis('off') ax.patch.set_facecolor('none') t = ax.text(0, 0, mathTex, ha='left', va='bottom', fontsize=fs) # ---- fit figure size to text artist ---- fwidth, fheight = fig.get_size_inches() fig_bbox = fig.get_window_extent(renderer) text_bbox = t.get_window_extent(renderer) tight_fwidth = text_bbox.width * fwidth / fig_bbox.width tight_fheight = text_bbox.height * fheight / fig_bbox.height fig.set_size_inches(tight_fwidth, tight_fheight) # ---- convert mpl figure to QPixmap ---- buf, size = fig.canvas.print_to_buffer() qimage = QtGui.QImage.rgbSwapped( QtGui.QImage(buf, size[0], size[1], QtGui.QImage.Format_ARGB32)) qpixmap = QtGui.QPixmap(qimage) return qpixmap
def plot_raw_dataset_um( points_um, savedir='', title='images', grid=(3, 3), figsize=(8, 8), size=0.1, dpi=300, invert_yaxis=True, ): ''' Plot the mRNA spots for each gene. ''' print('Plotting mRNA spots of selected genes...') if not os.path.exists(savedir): os.makedirs(savedir) genes_per_plot = grid[0] * grid[1] num_plots, remain = divmod(len(points_um), genes_per_plot) if remain != 0: num_plots += 1 gene_list = list(points_um.keys()) gene_idx = 0 for plot_num in range(num_plots): fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) for gridpos in range(genes_per_plot): if gene_idx == len(points_um): break ax = fig.add_subplot(grid[0], grid[1], gridpos + 1) ax.scatter( points_um[gene_list[gene_idx]][:, 1], points_um[gene_list[gene_idx]][:, 0], s=size, ) ax.set_aspect('equal') ax.set_title(gene_list[gene_idx]) if invert_yaxis: ax.invert_yaxis() gene_idx += 1 fig.suptitle(title + f'\n {plot_num + 1} of {num_plots}') fig.tight_layout(rect=(0, 0, 1, .94)) savename = ( f'raw_image_{plot_num+1}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.png' ) fig.savefig(os.path.join(savedir, savename), dpi=dpi) canvas.close() fig.clear() plt.close()
def plot_noise_nc(fglob,chip,**kwargs): if type(fglob) is str: fnames = glob.glob(fglob) else: fnames = fglob try: plotall = kwargs.pop('plot_all') except KeyError: plotall = False fnames.sort() errors = {} for fname in fnames: try: nc = EasyNetCDF4(fname) hwg = nc.hw_state.group fdir,fbase = os.path.split(fname) fbase,ext = os.path.splitext(fbase) chipfname = chip.replace(' ','_') pdf = PdfPages('/home/data/plots/%s_%s.pdf' % (fbase,chipfname)) nms = [] for (k,((sname,swg),(tname,tsg))) in enumerate(zip(nc.sweeps.groups.items(),nc.timestreams.groups.items())): #fig = plot_noise(swg,tsg,hwg,chip,**kwargs) indexes = np.unique(swg.variables['index'][:]) for index in indexes: kwargs['index'] = index try: nm = NoiseMeasurement(swg,tsg,hwg,chip,k,**kwargs) except IndexError: print "failed to find index",index,"in",sname,tname continue if pdf is not None: if plotall or k == 0: fig = Figure(figsize=(16,8)) title = ('%s %s' % (sname,tname)) nm.plot(fig=fig,title=title) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) pdf.savefig(fig,bbox_inches='tight') else: pdf.close() pdf = None del nm.fr_fine del nm.pii_fine del nm.prr_fine nms.append(nm) print fname,nm.start_temp,"K" if pdf is not None: pdf.close() nc.group.close() fh = open(os.path.join('/home/data','noise_' +fbase+'.pkl'),'w') cPickle.dump(nms,fh,-1) fh.close() except Exception,e: raise errors[fname] = e
def scatterplot(points, metadata, lims=None, outpath='/dev/null', display=False): f = Figure(figsize=(300 / dpi, 300 / dpi), dpi=dpi) ax = f.gca() for p in points: if p.level is None: # overrides cmap color = marker_map[p.shape].color else: color = p.level ax.scatter(p.x, p.y, c=color, vmin=0, vmax=1, linewidth=0.5, marker=marker_map[p.shape].marker, s=100, cmap=cmap_bwr) if lims is None: all_data = sum(([p.x, p.y] for p in points), []) dmin = min(all_data) dmax = max(all_data) drange = dmax - dmin lims = dmin - drange * 0.1, dmax + drange * 0.1 ax.set_xlim(lims) ax.set_ylim(lims) ax.set_aspect('equal') ax.set_xlabel(build_label(metadata[0])) ax.set_ylabel(build_label(metadata[1])) for loc in 'top', 'right': ax.spines[loc].set_color('none') ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('left') f.subplots_adjust(left=0.2, bottom=0.15, right=1, top=1, wspace=0, hspace=0) plt.setp(f, 'facecolor', 'none') canvas = FigureCanvasAgg(f) f.set_canvas(canvas) # must always be called, even if outpath is '/dev/null', so that the # returned figure object yields consistent pixel coordinates canvas.print_png(outpath) if display: plt.show() return f
def show_figure(fig: Figure) -> None: """ create a dummy figure and use its manager to display "fig" (to be used when "fig" lacks one) """ if not fig.canvas: dummy = plt.figure() new_manager = dummy.canvas.manager new_manager.canvas.figure = fig fig.set_canvas(new_manager.canvas)
def get_graph_proc(self): print(f"GET request graph from {self.client_address}") fig = Figure(figsize=(16, 8), dpi=80, facecolor='w', edgecolor='k') dummy = plt.figure() new_manager = dummy.canvas.manager new_manager.canvas.figure = fig fig.set_canvas(new_manager.canvas) # subplots = fig.subplots(1, len(self.data_frames)) # fig, axs = fig.subplots(len(self.data_frames.keys())) #result = f"<html>\n" devices = data_frames.get for device_name in devices: #result += f"<center>{device_name}</center><br>" graphs = devices[device_name] dfl = len(graphs.keys()) if dfl == 0: ax = fig.subplots() ax.plot([0], [0]) elif dfl == 1: dfk = list(graphs.keys())[0] axs = fig.subplots() axs.plot(graphs[dfk]['times'], graphs[dfk]['values']) axs.set_title(dfk) else: f, axs = fig.subplots(dfl) for i, df in enumerate(graphs.keys()): axs[i].plot(graphs[df]['times'], graphs[df]['values']) axs[i].set_title(df) # for i, df in enumerate(self.data_frames): # #ax = fig.add_subplot(len(self.data_frames), 1, i) # ax = fig.add_subplot() # ax.plot(self.data_frames[df]['x'], self.data_frames[df]['y']) # ax.set_title(df) plt.close(fig) # Save it to a temporary buffer. buf = io.BytesIO() fig.savefig(buf, format="png") # with open("result.png", 'wb') as output: # fig.savefig(output, format="png") # Embed the result in the html output. data = base64.b64encode(buf.getbuffer()).decode("ascii") self._set_response() try: self.wfile.write( f"<html>\n<img src='data:image/png;base64,{data}'/>\n</html>". encode("ascii")) except Exception as e: print(e)
def live_traffic(): with get_conn() as conn: cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor) destination_history_query = """ SELECT * FROM traffic WHERE recorded_at >= now() - INTERVAL '10 minutes'; """ cur.execute(destination_history_query) times = cur.fetchall() fig = Figure(figsize=(30, 8), dpi=80, facecolor='w', edgecolor='k', tight_layout=True) ax = fig.add_subplot(111) begin_times = [row['recorded_at'] for row in times] upload = [row['upload'] for row in times] ax.plot_date(x=begin_times, y=upload, label='upload', linestyle='solid') download = [row['download'] for row in times] ax.plot_date(x=begin_times, y=download, label='download', linestyle='solid') ax.set_xlabel('Time') ax.set_ylabel('Bandwidth') ax.set_ylim(bottom=0) ax.xaxis_date() my_fmt = DateFormatter('%H:%M') ax.xaxis.set_major_formatter(my_fmt) ax.xaxis.set_major_locator(SecondLocator(interval=60)) ax.legend() ax.grid() png_output = io.BytesIO() fig.set_canvas(FigureCanvasAgg(fig)) fig.savefig(png_output, transparent=True, format='png') response = make_response(png_output.getvalue()) response.headers['content-type'] = 'image/png' return response
class MPLPlotContainer(QWidget): def __init__(self, tristan_data_plotter): super().__init__() self.tristan_data_plotter = tristan_data_plotter layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) self.figure = Figure() self.ax = self.figure.add_subplot(111) # self.figure, self.ax = plt.subplots( 1, 1 ) self.canvas = FigureCanvas(self.figure) self.figure.set_canvas(self.canvas) layout.addWidget(self.canvas) self.tristan_data_plotter.plotter.set_mpl_axes(self.ax) self.setLayout(layout) def update(self, timestep): # self.figure.clf() # print( 'called update' ) self.tristan_data_plotter.plot_timestep(timestep) # print( 'drawing' ) # print( self.ax.lines[0].get_xydata() ) self.canvas.draw() self.repaint() # self.SetSize((self.Size[0],self.figurecanvas.Size[1])) def get_canvas(self): return self.ax def delete(self): pass def clear(self): self.tristan_data_plotter.clear() def reset(self): self.tristan_data_plotter.reset()
def chart(self,column): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(figsize=(14,6)) canvas = FigureCanvas(fig) fig.set_canvas(canvas) ax = fig.add_subplot(111) series = self.transactions().set_index('Date')[column] series.plot(ax=ax) fig.autofmt_xdate() io = StringIO() fig.savefig(io, format='svg') return io.getvalue()
def increase_Bax_5x(mcmc_set): """ .. todo:: document the basis for this""" tspan = mcmc_set.chains[0].options.tspan fig = Figure() ax = fig.gca() plot_filename = '%s_Bax_5x.png' % mcmc_set.name thumbnail_filename = '%s_Bax_5x_th.png' % mcmc_set.name # Make sure we can call the method 'get_observable_timecourses' if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \ not hasattr(mcmc_set.chains[0], 'plot_data'): return Result('None', None) # Plot the original data mcmc_set.chains[0].plot_data(ax) # Plot a sampling of trajectories from the original parameter set for i in range(num_samples): position = mcmc_set.get_sample_position() timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position) for obs_name, timecourse in timecourses.iteritems(): ax.plot(tspan, timecourse, color='g', alpha=0.5, label=obs_name) # Now increase Bax 5-fold... model = mcmc_set.chains[0].options.model old_Bax_0 = model.parameters['Bax_0'].value model.parameters['Bax_0'].value = old_Bax_0 * 5 # ...and do the sampling again for i in range(num_samples): position = mcmc_set.get_sample_position() timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position) for obs_name, timecourse in timecourses.iteritems(): ax.plot(tspan, timecourse, color='r', alpha=0.5, label=obs_name) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) # Make sure to reset the Bax initial condition to its original value! model.parameters['Bax_0'].value = old_Bax_0 return ThumbnailResult(thumbnail_filename, plot_filename)
def marginals(mcmc_set): """Returns the vector of Gelman-Rubin convergence criterion values and a link to an HTML file containing plots of the traces of the walk for each parameter fitted.""" # Prepare html for page showing plots of parameter traces html_str = "<html><head><title>Marginal distributions for " \ "%s</title></head>\n" % mcmc_set.name html_str += "<body><p>Marginal distributions for for %s</p>\n" \ % mcmc_set.name img_str_list = [] # Make plots of parameter traces for i in range(mcmc_set.chains[0].num_estimate): param_name = mcmc_set.chains[0].options.estimate_params[i].name fig = Figure() ax = fig.gca() # Build a list of arrays containing positions for this parameter chains_for_param = [] for chain in mcmc_set.chains: # Don't try to plot marginals for a chain with no accepted steps! if len(chain.positions) > 0: chains_for_param.append(chain.positions[:, i]) # Plot the marginals ax.hist(chains_for_param, histtype='step', bins=25) ax.set_title("Parameter: %s" % param_name) plot_filename = '%s_marginal_%s.png' % (mcmc_set.name, param_name) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) img_str_list.append(plot_filename) # Make the html file html_str += '\n'.join([ '<a href="%s"><img src="%s" width=400 /></a>' % (i, i) for i in img_str_list ]) html_str += "</body></html>" html_filename = '%s_marginals.html' % mcmc_set.name with open(html_filename, 'w') as f: f.write(html_str) return Result(None, html_filename)
def change_tBid_concentration(mcmc_set, fold_change): tspan = mcmc_set.chains[0].options.tspan fig = Figure() ax = fig.gca() plot_filename = '%s_tBid_%.1fx.png' % (mcmc_set.name, fold_change) thumbnail_filename = '%s_tBid_%.1fx_th.png' % (mcmc_set.name, fold_change) # Make sure we can call the method 'get_observable_timecourses' if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \ not hasattr(mcmc_set.chains[0], 'plot_data'): return Result('None', None) # Plot the original data mcmc_set.chains[0].plot_data(ax) # Plot a sampling of trajectories from the original parameter set for i in range(num_samples): position = mcmc_set.get_sample_position() timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position) for obs_name, timecourse in timecourses.iteritems(): ax.plot(tspan, timecourse, color='g', alpha=0.5, label=obs_name) # Now change tBid x-fold... model = mcmc_set.chains[0].options.model old_tBid_0 = model.parameters['tBid_0'].value model.parameters['tBid_0'].value = old_tBid_0 * fold_change # ...and do the sampling again for i in range(num_samples): position = mcmc_set.get_sample_position() timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position) for obs_name, timecourse in timecourses.iteritems(): ax.plot(tspan, timecourse, color='r', alpha=0.5, label=obs_name) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) # Make sure to reset the tBid initial condition to its original value! model.parameters['tBid_0'].value = old_tBid_0 return ThumbnailResult(thumbnail_filename, plot_filename)
def fit_plotting_function(self, position): """Gets the observable timecourse and plots it against the data. Useful for visualizing model output by examining the fit of the model at the maximum likelihood or maximum a posteriori parameters, etc. Parameters ---------- position : numpy.array Vector of parameter values to use for simulation and plotting. Returns ------- matplotlib.figure.Figure Figure instance containing the plot of the data and the simulation at the given position. """ # Run the simulation at the given position timecourses = self.get_observable_timecourses(position) # Make the plot fig = Figure() ax = fig.gca() # Add the data to the plot self.plot_data(ax) # Add the simulations to the plot for obs_name, timecourse in timecourses.iteritems(): ax.plot(timecourse[0], timecourse[1], label=obs_name) # Label the plot ax.set_xlabel('Time') ax.set_ylabel('Concentration') fontP = FontProperties() fontP.set_size('small') box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) ax.legend(loc='upper left', prop=fontP, ncol=1, bbox_to_anchor=(1, 1), fancybox=True, shadow=True) #ax.legend(loc='upper center', prop=fontP, ncol=5, # bbox_to_anchor=(0.5, 1.1), fancybox=True, shadow=True) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) return fig
def iBax_monotonically_increasing(mcmc_set): """ .. todo:: document the basis for this""" tspan = mcmc_set.chains[0].options.tspan fig = Figure() ax = fig.gca() plot_filename = '%s_iBax_monotonic_increasing.png' % mcmc_set.name num_true = 0 for i in range(num_samples): x = mcmc_set.get_sample_simulation() ax.plot(tspan, x['iBax'], color='r', alpha=0.5) if monotonic_increasing(x['iBax']): num_true += 1 canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) return FuzzyBooleanResult(float(num_true) / float(num_samples), plot_filename, expectation=1.0)
def marginals(mcmc_set): """Returns the vector of Gelman-Rubin convergence criterion values and a link to an HTML file containing plots of the traces of the walk for each parameter fitted.""" # Prepare html for page showing plots of parameter traces html_str = "<html><head><title>Marginal distributions for " \ "%s</title></head>\n" % mcmc_set.name html_str += "<body><p>Marginal distributions for for %s</p>\n" \ % mcmc_set.name img_str_list = [] # Make plots of parameter traces for i in range(mcmc_set.chains[0].num_estimate): param_name = mcmc_set.chains[0].options.estimate_params[i].name fig = Figure() ax = fig.gca() # Build a list of arrays containing positions for this parameter chains_for_param = [] for chain in mcmc_set.chains: # Don't try to plot marginals for a chain with no accepted steps! if len(chain.positions) > 0: chains_for_param.append(chain.positions[:,i]) # Plot the marginals ax.hist(chains_for_param, histtype='step') ax.set_title("Parameter: %s" % param_name) plot_filename = '%s_marginal_%s.png' % (mcmc_set.name, param_name) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) img_str_list.append(plot_filename) # Make the html file html_str += '\n'.join([ '<a href="%s"><img src="%s" width=400 /></a>' % (i, i) for i in img_str_list]) html_str += "</body></html>" html_filename = '%s_marginals.html' % mcmc_set.name with open(html_filename, 'w') as f: f.write(html_str) return Result(None, html_filename)
def fit_plotting_function(self, position): """Gets the observable timecourse and plots it against the data.""" # Run the simulation at the given position timecourses = self.get_observable_timecourses(position) # Make the plot fig = Figure() ax = fig.gca() # Add the data to the plot self.plot_data(ax) # Add the simulations to the plot for obs_name, timecourse in timecourses.iteritems(): ax.plot(self.mcmc.options.tspan, timecourse, label=obs_name) # Label the plot ax.set_xlabel('Time') ax.set_ylabel('Concentration') fontP = FontProperties() fontP.set_size('small') ax.legend(loc='upper center', prop=fontP, ncol=5, bbox_to_anchor=(0.5, 1.1), fancybox=True, shadow=True) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) return fig
def two_exponential_fits(mcmc_set): # Use the first MCMC in the chain to get the data, etc. mcmc = mcmc_set.chains[0] # Run a simulation (max_lkl, max_lkl_position) = mcmc_set.maximum_likelihood() data = mcmc.get_observables_as_dataframe(max_lkl_position) bax_concs = np.array(data.columns, dtype='float') plot_filename = '%s_two_exp_fits.png' % (mcmc_set.name) thumbnail_filename = '%s_two_exp_fits_th.png' % (mcmc_set.name) fit = TwoExp() (k1_arr, fmax_arr, k2_arr) = fit.fit_from_dataframe(data) fig = Figure() for i, bax_conc in enumerate(bax_concs): ax = fig.gca() conc_data = data[bax_conc] time = conc_data[:, 'TIME'] y = conc_data[:, 'MEAN'] two_exp_fit = fit.fit_func(time, (k1_arr[i], fmax_arr[i], k2_arr[i])) # Plot original sim ax.plot(time, y, 'b') # Plot fitted func ax.plot(time, two_exp_fit, 'r') ax.set_title('Two-exponential fits for %s' % mcmc_set.name) ax.set_xlabel('Time') ax.set_ylabel('Dye release') #ax.legend(loc='lower right') canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(thumbnail_filename, dpi=10) two_exp_fits_dict[mcmc_set.name] = (fmax_arr, k1_arr, k2_arr) return ThumbnailResult(thumbnail_filename, plot_filename)
class CanvasPanel(wx.Panel): def __init__(self, parent): super().__init__(parent, size=(800, 480)) matplotlib.rc('axes', edgecolor='black', linewidth=1) self.figure = Figure() self._axes = self.figure.add_axes([0, 0, 1, 1]) self._axes.set(xlim=(0, 1), ylim=(0, 1)) self._scat = self._axes.scatter(x=[], y=[]) self._canvas = FigureCanvas(self, id=-1, figure=self.figure) self.figure.set_canvas(self._canvas) box_sizer = wx.BoxSizer(wx.VERTICAL) box_sizer.Add(self._canvas, proportion=1, flag=wx.EXPAND | wx.TOP, border=6) self.SetSizer(box_sizer) self.Fit() def draw_markers(self, marker_positions, marker_sizes, marker_colors): self._scat.set_offsets(marker_positions) self._scat.set_sizes(marker_sizes) self._scat.set_facecolors(marker_colors) def clear(self): self._scat.remove() self._scat = self._axes.scatter(x=[], y=[])
def latex_to_qtpixmap(str_, fontsize_=None): figure_ = Figure() figure_.set_canvas(FigureCanvasAgg(figure_)) figure_.patch.set_facecolor("none") ax_ = figure_.add_axes([0, 0, 1, 1]) ax_.axis('off') text_ = ax_.text(0, 0, str_, ha='left', va='bottom', fontsize=fontsize_) f_w_, f_h_ = figure_.get_size_inches() bbox_f_ = figure_.get_window_extent(figure_.canvas.get_renderer()) bbox_t_ = text_.get_window_extent(figure_.canvas.get_renderer()) figure_.set_size_inches((bbox_t_.width / bbox_f_.width) * f_w_, (bbox_t_.height / bbox_f_.height) * f_h_) buf, size = figure_.canvas.print_to_buffer() return QtGui.QImage.rgbSwapped( QtGui.QImage(buf, *size, QtGui.QImage.Format_ARGB32))
def sample_fits(mcmc_set): fig = Figure() ax = fig.gca() plot_filename = '%s_sample_fits.png' % mcmc_set.name thumbnail_filename = '%s_sample_fits_th.png' % mcmc_set.name # Make sure we can call the method 'get_observable_timecourses' if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \ not hasattr(mcmc_set.chains[0], 'plot_data'): return Result('None', None) # Plot the original data mcmc_set.chains[0].plot_data(ax) # Plot a sampling of trajectories from the original parameter set try: for i in range(num_samples): position = mcmc_set.get_sample_position() timecourses = mcmc_set.chains[0].get_observable_timecourses( position=position) for obs_name, timecourse in timecourses.iteritems(): ax.plot(timecourse[0], timecourse[1], color='g', alpha=0.1, label=obs_name) except NoPositionsException as npe: pass canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) fig.savefig(plot_filename.replace('.png', '.pdf')) fig.savefig(thumbnail_filename, dpi=10) return ThumbnailResult(thumbnail_filename, plot_filename)
def plot_noise_nc(fglob,**kwargs): """ Create noise measurements from all noise sweeps in a netcdf file, make plots, and pickle the noise measurements fglob : string or list filename glob. Can be either a filename, which can contain * or ? wildcards, or a list of files plot_all : bool (default False) if True, plot all sweeps, otherwise just plot the first one for each resonator **kwargs are passed to the noise measurement class """ if type(fglob) is str: fnames = glob.glob(fglob) else: fnames = fglob plotall = kwargs.pop('plot_all',False) fnames.sort() errors = {} pdf = None for fname in fnames: try: fdir,fbase = os.path.split(fname) fbase,ext = os.path.splitext(fbase) rnc = readoutnc.ReadoutNetCDF(fname) nms = [] for (k,((sname,swg),(tname,tsg))) in enumerate(zip(rnc.sweeps_dict.items(),rnc.timestreams_dict.items())): #fig = plot_noise(swg,tsg,hwg,chip,**kwargs) indexes = np.unique(swg.index) for index in indexes: try: nm = SweepNoiseMeasurement(fname,sweep_group_index=k,timestream_group_index=k, resonator_index=index,**kwargs) except IndexError: print "failed to find index",index,"in",sname,tname continue if plotall or k == 0: try: if pdf is None: chipfname = nm.chip_name.replace(' ','_').replace(',','') pdfname = os.path.join(BASE_DATA_DIR,'plots/%s_%s.pdf') % (fbase,chipfname) pdf = PdfPages(pdfname) try: os.chmod(pdfname,0666) except OSError: print "could not change permissions of",pdfname fig = Figure(figsize=(16,8)) title = ('%s %s' % (sname,tname)) nm.plot(fig=fig,title=title) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) pdf.savefig(fig,bbox_inches='tight') except Exception: print "failed to plot",k,index,sname,tname,fname # else: # if pdf is not None: # pdf.close() # pdf = None nm._fractional_fluctuation_timeseries = None nms.append(nm) print fname,nm.start_temp,"K" if pdf is not None: pdf.close() pdf = None rnc.close() pklname = os.path.join(BASE_DATA_DIR,'noise_sweeps_' +fbase+'.pkl') fh = open(pklname,'w') cPickle.dump(nms,fh,-1) fh.close() try: os.chmod(pklname,0666) except OSError: print "could not change permissions of", pklname except KeyboardInterrupt: raise except Exception,e: # raise errors[fname] = e
def chromosome_plotter(): def onclick(event): global Chr, plotted i = 0 for y in ax_y: if event.ydata > (y - 0.1) and event.ydata < (y + 0.3): Chr = chromosomes[i] print("The chromosome is :" + str(chromosomes[i])) i += 1 global chromosomes, vcf root = tk.Tk() root.title("Variation Visualizer (CHROMOSOME VIEWER)") root.state('zoomed') df = allel.vcf_to_dataframe(vcf, fields=['CHROM', 'POS', 'REF', 'ALT'], alt_number=1) chromosome_vcf = df.CHROM fig = Figure(figsize=(10, 20)) ax = fig.subplots() ax.set_ylim(0, 50) ax.set_xlim(1, 200) canvas = FigureCanvasTkAgg(fig, root) fig.set_canvas(canvas=canvas) ax_y = [] ax_labels = [] p = 0 m = 48 v = 47.5 for chr in chromosomes: print(chr) chromosome = '{}.{}'.format(chr, 'fa') with open(chromosome) as fasta_file: # Will close handle cleanly lengths = [] for record in SeqIO.parse( fasta_file, "fasta" ): # (generator)...in this case it is not a multi fasta file lengths.append(record.seq) seq = str(record.seq) print("Initial length :" + str(len(seq))) length = int(len(seq) / 2000000) print("LEngth is : " + str(length)) start = 0 p = 0 for i in range(start, length): ax.broken_barh([(p, 1)], (m, 0.2), facecolors='#1a1a00') p += 1 i = 0 index = [] counter = 0 for chrm in chromosome_vcf: if chrm == chr: counter += 1 index.append(i) i += 1 ax.annotate(str(counter) + " variations", (p + 2, m), fontsize=6) for j in index: pos = df.POS[j] pos = int(pos / 2000000) ax.broken_barh([(pos, 1)], (v, 1), facecolors='#b30000') ax_y.append(m + 0.1) ax_labels.append(chr) m -= 2 v -= 2 plotted = True ax.set_yticks(ax_y) ax.set_yticklabels(ax_labels, fontsize=12) fig.canvas.mpl_connect('button_press_event', onclick) canvas.draw() canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True) root.mainloop()
def convergence_criterion(mcmc_set): """Returns the vector of Gelman-Rubin convergence criterion values and a link to an HTML file containing plots of the traces of the walk for each parameter fitted.""" # Prepare html for page showing plots of parameter traces html_str = "<html><head><title>Parameter traces for %s</title></head>\n" \ % mcmc_set.name html_str += "<body><p>Parameter traces for %s</p>\n" \ % mcmc_set.name img_str_list = [] # Useful variables num_estimate = mcmc_set.chains[0].num_estimate fontP = FontProperties() fontP.set_size('small') legend_kwargs = { 'prop': fontP, 'ncol': 1, 'bbox_to_anchor': (1, 1), 'fancybox': True, 'shadow': True } # Make plot of posterior fig = Figure() ax = fig.gca() for i, chain in enumerate(mcmc_set.chains): color = cm.jet(i / float(num_estimate - 1)) label = 's%d' % chain.options.seed if chain.pruned: line = ax.plot(chain.thinned_steps, chain.posteriors, color=color, label=label) else: line = ax.plot(chain.posteriors, color=color, label=label) ax.set_title("Posterior traces") ax.legend(loc='upper left', **legend_kwargs) posterior_plot_filename = '%s_posterior_trace.png' % mcmc_set.name canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(posterior_plot_filename) # Make plots of parameter traces for i in range(num_estimate): param_name = mcmc_set.chains[0].options.estimate_params[i].name fig = Figure() ax = fig.gca() for j, chain in enumerate(mcmc_set.chains): color = cm.jet(j / float(num_estimate - 1)) label = 's%d' % chain.options.seed if chain.pruned: line = ax.plot(chain.thinned_steps, chain.positions[:, i], color=color, label=label) else: line = ax.plot(chain.positions[:, i], color=color, label=label) ax.set_title("Parameter: %s" % param_name) ax.legend(loc='upper left', **legend_kwargs) plot_filename = '%s_trace_%s.png' % (mcmc_set.name, param_name) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) img_str_list.append(plot_filename) # Make the html file html_str += '<a href="%s"><img src="%s" width=400 /></a>' % \ (posterior_plot_filename, posterior_plot_filename) html_str += '\n'.join([ '<a href="%s"><img src="%s" width=400 /></a>' % (i, i) for i in img_str_list ]) html_str += "</body></html>" html_filename = '%s_convergence.html' % mcmc_set.name with open(html_filename, 'w') as f: f.write(html_str) return FloatListResult(convergence.convergence_criterion(mcmc_set), html_filename)
class realTimeVisualisation(gtk.Window): def __init__(self,networkVariables): ''' ''' super(realTimeVisualisation,self).__init__() self.set_size_request(640,690) self.set_position(gtk.WIN_POS_CENTER) self.connect("destroy", gtk.main_quit) self.fig = Figure(figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(640,690) vbox = gtk.VBox(False,1) alignIm = gtk.Alignment(0, 1 , 1, 0) alignIm.add(self.canvas) vbox.pack_start(alignIm) self.add(vbox) self.initNetworkVariables(networkVariables) self.createGraph() updateTime = 1 #len(self.quantitiesToPlot) ## if this time is to fast, it will show nothing gobject.timeout_add(updateTime,self.updateGraph) self.show_all() def initNetworkVariables(self,networkVariables): ''' ''' self.dt = 0.01 self.filename = '../.realtime.viz' self.quantitiesToPlot = ['Pressure','Flow'] self.initialValues = [0,0,0,0,0] try: self.dt = networkVariables['dt'] self.filename = networkVariables['filename'] self.quantitiesToPlot = networkVariables['quantitiesToPlot'] self.initialValues = networkVariables['initialValues'] except: pass def updateGraph(self): ''' ''' try: with open(''.join([cur,'/',self.filename]),'r') as dataFile: for dataLine in dataFile: dataString = dataLine break os.remove(''.join([cur,'/',self.filename])) except: pass dataDict = {} try: dataDict = eval(dataString) except: try: if dataString == 'STOP': return False except: pass pass try: for quantity in self.quantitiesToPlot: newValue = dataDict[quantity] ## update y values yvals = self.lines[quantity].get_ydata() yvalsn = np.append(yvals,newValue) self.lines[quantity].set_ydata(yvalsn) ## update x values timeOld = self.lines[quantity].get_xdata() time = np.append(timeOld,[timeOld[-1]+self.dt]) self.lines[quantity].set_xdata(time) ## adjust limits self.adjustAxis(self.axis[quantity],time,yvalsn) # update view() self.canvas.figure = self.fig self.fig.set_canvas(self.canvas) self.canvas.queue_resize() except: pass return True def adjustAxis(self,axis,xVals,yVals): ''' ''' mmF = 0.1 #get values for y yMaxVals = np.max(yVals) yMinVals = np.min(yVals) yMinAx,yMaxAx = axis.get_ylim() #check and correct if necessary if yMaxVals > yMaxAx-mmF*abs(yMaxAx): yMaxAx = yMaxVals+mmF*abs(yMaxVals) if yMinVals < yMinAx+mmF*abs(yMinAx): yMinAx = yMinVals-mmF*abs(yMinVals) #apply y values axis.set_ylim([yMinAx,yMaxAx]) #get values for x xMinVals = np.min(xVals) xMaxVals = np.max(xVals) xMinAx,xMaxAx = axis.get_xlim() #check and correct if necessary if xMaxVals > xMaxAx-mmF*abs(xMaxAx): xMaxAx = xMaxVals+mmF*abs(xMaxVals) if xMinVals < xMinAx+mmF*abs(xMinAx): xMinAx = xMinVals-mmF*abs(xMinVals) #apply y values axis.set_xlim([xMinAx,xMaxAx]) def createGraph(self): ''' ''' numberOfQuantities = len(self.quantitiesToPlot) self.fig.subplots_adjust(hspace = 0.4) self.fig.subplots_adjust(right = 0.85) self.fig.subplots_adjust(top = 0.98) self.fig.subplots_adjust(bottom = 0.2) self.fig.subplots_adjust(hspace = 0.5) self.fig.set_figwidth(8.27) self.fig.set_figheight((11.69/3)*numberOfQuantities) self.lines = {} self.axis = {} i = 0 colors = ['b','r','m','g','k'] for quantity in self.quantitiesToPlot: self.axis[quantity] = self.fig.add_subplot(numberOfQuantities,1,i+1, ylabel=quantity, xlabel='Time', ylim = [self.initialValues[i],self.initialValues[i]-0.001], xlim = [0,0.0001]) self.lines[quantity] = self.axis[quantity].plot(0,self.initialValues[i],color=colors[i] ,linestyle = '-',label=quantity, linewidth = 1.)[0] i = i+1 # update view() self.canvas.figure = self.fig self.fig.set_canvas(self.canvas) self.canvas.queue_resize()
def make_plot_3d(grid, grid_name, x, y, all_z, t, grid_t_idx, grid_x_idx, grid_z_idx, n_cols = 6, outpath='', filename_prefix='LMA',do_save=True, image_type='pdf', colormap='cubehelix' , grid_range=None): n_frames = t.shape[0] # n_cols = 6 n_rows = int(ceil( float(n_frames) / n_cols )) if type(colormap) == type(''): colormap = get_cmap(colormap) grey_color = (0.5,)*3 frame_color = (0.2,)*3 density_maxes = [] total_counts = [] all_t = [] xedge = centers_to_edges(x) x_range = xedge.max() - xedge.min() yedge = centers_to_edges(y) y_range = yedge.max() - yedge.min() dx = (xedge[1]-xedge[0]) # count_scale_factor = dx # / 1000.0 # max_count_baseline = 450 * count_scale_factor #/ 10.0 min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0]) if (max_count == 0) | (max_count == 1 ): max_count = min_count+1 default_vmin = -0.2 if np.log10(max_count) <= default_vmin: vmin_count = np.log10(max_count) + default_vmin else: vmin_count = default_vmin # If the range of values for the colorbar is manually specified, # overwrite what we did above if grid_range is not None: vmin_count = grid_range[0] max_count = grid_range[1] # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None) fig = Figure(figsize=(w,h)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols) p.label_edges(True) pad = 0.0 # for time labels in each frame for ax in p.multiples.flat: ax.set_axis_bgcolor('white') ax.spines['top'].set_edgecolor(frame_color) ax.spines['bottom'].set_edgecolor(frame_color) ax.spines['left'].set_edgecolor(frame_color) ax.spines['right'].set_edgecolor(frame_color) # ax.yaxis.set_major_formatter(kilo_formatter) # ax.xaxis.set_major_formatter(kilo_formatter) base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S") time_delta = timedelta(0,float(t[0]),0) start_time = base_date + time_delta for zi in range(len(all_z)): indexer = [slice(None),]*len(grid.shape) frame_start_times = [] altitude = all_z[zi] for i in range(n_frames): p.multiples.flat[i].clear() # reset (clear) the axes frame_start = base_date + timedelta(0,float(t[i]),0) frame_start_times.append(frame_start) indexer[grid_t_idx] = i indexer[grid_z_idx] = zi density = grid[indexer] density = np.ma.masked_where(density<=0.0, density) # mask grids 0 grids to reveal background color # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge, np.log10(density.transpose()), vmin=vmin_count, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') x_lab = xedge[0]-pad+x_range*.015 y_lab = yedge[0]-pad+y_range*.015 text_label = p.multiples.flat[i].text(x_lab, y_lab, label_string, color=grey_color, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print(label_string, x_lab, y_lab, grid_name, density.max(), density.sum()) color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') view_x = (xedge.min(), xedge.max()) view_y = (yedge.min(), yedge.max()) print('making multiples') p.multiples.flat[0].axis(view_x+view_y) filename = '%s-%s_%s_%05.2fkm_%04.1fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, altitude, time_delta.seconds, image_type) filename = os.path.join(outpath, filename) if do_save: fig.savefig(filename, dpi=150) print('done ', zi) return fig, p, frame_start_times, filename print(' ... done with loop')
def plotALot( img_array, gene_index_dict, # list of genes to plot reordered_genes=None, savedir="", title="images", grid=(3, 6), # grid to plot for each figure figsize=(16, 9), dpi=300, ): """ plot a lot of images from a list of genes """ genes_per_plot = grid[0] * grid[1] num_plots, remainder = divmod(len(gene_index_dict), (genes_per_plot)) # add an extra plot if # number of genes is not perfectly divisible by number of plots if remainder != 0: num_plots += 1 if reordered_genes is None: reordered_genes = [ None, ] * len(gene_index_dict) for gene in gene_index_dict: reordered_genes[gene_index_dict[gene]["index"]] = gene # set up index for number of genes already plotted # ------------------------------------------------ array_idx = 0 for plot_num in range(num_plots): # set up figure canvas # -------------------- fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) for gridpos in range(genes_per_plot): # check if we have reached end of gene list # ----------------------------------------- if array_idx == len(gene_index_dict): break # create temporary axes reference # ------------------------------- ax = fig.add_subplot(grid[0], grid[1], gridpos + 1) # plot the current gene (array_idx) # --------------------- gene = reordered_genes[array_idx] ax.imshow(img_array[gene_index_dict[gene]["index"], ...], cmap="hot") ax.set_title(gene) ax.grid(False) # increment gene index # -------------------- array_idx += 1 fig.suptitle(title + f" ({plot_num + 1} of {num_plots})") fig.tight_layout(rect=(0, 0, 1, .94)) # save the plot # time_now = datetime.datetime.now().strftime("%Y%m%d_%H%M") savename = (f"{title.replace(' ','_')}" f"_{plot_num + 1}of{num_plots}.png") if not os.path.exists(savedir): os.mkdir(savedir) fig.savefig(os.path.join(savedir, savename), dpi=dpi) canvas.close() fig.clear()
def plot(self, parname, **kwargs): '''\ keywords: errorbar - shows errorbars in fit, true by default legend - shows legend, true by default other kywords are passed to Figure.add_axes() Most important ones: xscale, yscale - [‘linear’ | ‘log’ | ‘symlog’] xlim, ylim - length 2 sequence of floats - to determine plot bounds''' showerr = kwargs.pop('errorbar', True) showleg = kwargs.pop('legend', True) figure = Figure(figsize=[6, 4.5]) rect = (rcParams['figure.subplot.left'], rcParams['figure.subplot.bottom'], rcParams['figure.subplot.right'] - rcParams['figure.subplot.left'], rcParams['figure.subplot.top'] - rcParams['figure.subplot.bottom']) figure.suptitle(parname) main_plot = figure.add_axes(rect, **kwargs) main_plot.set_xlabel(pretty_str_units(pq.Quantity(self.xcol[0]).units)) main_plot.set_ylabel(parname) x = [] redx = [] yelx = [] y = [] redy = [] yely = [] ex = None ey = [] if parname == 'chisqr': getval = lambda fit, pname: fit.chisqr geterr = lambda fit, pname: 0 else: getval = lambda fit, pname: fit.params[pname].value geterr = lambda fit, pname: fit.params[parname].stderr for i, fit in enumerate(self.results_list): try: xypair = (np.float64(self.xcol[i]), getval(fit, parname), geterr(fit, parname)) except KeyError: continue if fit.success is False: yelx.append(xypair[0]) yely.append(xypair[1]) elif not hasattr(fit, 'covar'): redx.append(xypair[0]) redy.append(xypair[1]) elif fit.covar is None: redx.append(xypair[0]) redy.append(xypair[1]) else: x.append(xypair[0]) y.append(xypair[1]) ey.append(xypair[2]) if not showerr: ey = None main_plot.errorbar( x, y, ey, ex, fmt='.', color='blue', ecolor='orange', label="good fit", ) main_plot.errorbar( redx, redy, None, None, fmt='.', color='red', ecolor='orange', label="overparametrized", ) main_plot.errorbar( yelx, yely, None, None, fmt='.', color='yellow', ecolor='orange', label="not succeeded", ) if showleg: main_plot.legend(fancybox=True) figure.set_canvas(FigureCanvasAgg(figure)) if test_ipython(): #print ('ipython') import tempfile tmpimg = tempfile.NamedTemporaryFile(suffix='.png', delete=True) figure.savefig(tmpimg.name, format='png') from IPython.display import Image, display display(Image(filename=tmpimg.name)) else: #print (' no ipython') figure.savefig(parname + '.svg')
import numpy as np from matplotlib.figure import Figure from matplotlib.backends.backend_agg import new_figure_manager def f(t): return np.exp(-t) * np.cos(2 * np.pi * t) def graph(fig): t1 = np.arange(0.0, 5.0, 0.1) t2 = np.arange(0.0, 5.0, 0.02) ax = fig.add_subplot(1, 1, 1) ax.plot(t1, f(t1), 'bo', t2, f(t2), 'k') fig = Figure() graph(fig) manager = new_figure_manager(1, dpi=72) manager.canvas.figure = fig fig.set_canvas(manager.canvas) fig.savefig("dist/no-pyplot.png")
class CanvasWidget(FigureCanvas): """Widget to draw plots on. This class keep track of all the axes in a dictionary. The key for an axis is its index number in sequence of creation. next_id: The key for the next axis. current_id: Key for current axis (anu plotting will happen on this). """ updateSignal = pyqtSignal() def __init__(self, model, graph, index, *args, **kwargs): self.model = model self.graph = graph self.index = index # QColor(243, 239, 238, 255) self.figure = Figure(facecolor = '#F3EFEE')#figsize=(1,1)) FigureCanvas.__init__(self, self.figure, *args, **kwargs) self.figure.set_canvas(self) # self.set_xlabel('Time (s)') # self.set_ylabel('Concentration (mM)') if len(args) > 0 and isinstance(args[0], QtGui.QWidget): self.reparent(args[0]) elif (kwargs is not None) and ('parent' in kwargs): self.reparent(kwargs['parent']) #self.setAcceptDrops(True) # self.setMaximumSize(100, 100) FigureCanvas.updateGeometry(self) self.axes = {} self.next_id = 0 self.current_id = -1 tabList = [] self.addTabletoPlot = '' self.setAcceptDrops(True) self.gridMode = False def dragEnterEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def dragMoveEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def eventFilter(self, source, event): if (event.type() == QtCore.QEvent.Drop): pass def dropEvent(self, event): """Insert an element of the specified class in drop location""" if not event.mimeData().hasFormat('text/plain'): return # print " active window ", self.isActiveWindow() # print "Mouse : ", self.mouse # pos = self.mapFromGlobal(QCursor.pos()) # print "Mouse Position : ", pos modelRoot, element = event.mimeData().data if isinstance (element,moose.PoolBase): tablePath = moose.utils.create_table_path(self.model, self.graph, element, "Conc") table = moose.utils.create_table(tablePath, element, "Conc","Table2") # moose.connect(table, 'requestOut', element, 'getConc') self.updateSignal.emit() elif isinstance(element, moose.CompartmentBase): tablePath = moose.utils.create_table_path(self.model, self.graph, element, "Vm") table = moose.utils.create_table(tablePath, element, "Vm","Table") self.updateSignal.emit() else: QtGui.QMessageBox.question(self, 'Message',"This element's properties cannot be plotted.", QtGui.QMessageBox.Ok) def addSubplot(self, rows, cols): """Add a subplot to figure and set it as current axes.""" assert(self.next_id <= rows * cols) axes = self.figure.add_subplot(rows, cols, self.next_id+1) axes.set_xlabel("Time (s)") axes.set_ylabel("Concentration (mM)") axes.set_xlim(left=0.0) axes.set_ylim(bottom=0.0) self.axes[self.next_id] = axes axes.set_title("Graph " + str(self.index + 1)) self.current_id = self.next_id self.next_id += 1 labelList = [] axes.legend(loc='upper center') return axes def plot(self, *args, **kwargs): #self.callAxesFn('legend',loc='lower center',bbox_to_anchor=(0.5, -0.03),fancybox=True, shadow=True, ncol=3) return self.callAxesFn('plot', *args, **kwargs) def callAxesFn(self, fname, *args, **kwargs): """Call any arbitrary function of current axes object.""" if self.current_id < 0: self.addSubplot(1,1) fn = eval('self.axes[self.current_id].%s' % (fname)) return fn(*args, **kwargs) def resize_event(self, event): print("Resize event called ", event) def toggleGrid(self): self.gridMode = not self.gridMode for key in self.axes: self.axes[key].grid(self.gridMode) self.draw() def setXLimit(self, minX, maxX): for key in self.axes: self.axes[key].set_xlim([minX, maxX]) self.draw()
class CanvasWidget(FigureCanvas): """Widget to draw plots on. This class keep track of all the axes in a dictionary. The key for an axis is its index number in sequence of creation. next_id: The key for the next axis. current_id: Key for current axis (anu plotting will happen on this). """ updateSignal = pyqtSignal() def __init__(self, model, graph, index, *args, **kwargs): self.model = model self.graph = graph self.index = index # QColor(243, 239, 238, 255) self.figure = Figure(facecolor='#F3EFEE') #figsize=(1,1)) FigureCanvas.__init__(self, self.figure, *args, **kwargs) self.figure.set_canvas(self) # self.set_xlabel('Time (s)') # self.set_ylabel('Concentration (mM)') if len(args) > 0 and isinstance(args[0], QtGui.QWidget): self.reparent(args[0]) elif (kwargs is not None) and ('parent' in kwargs): self.reparent(kwargs['parent']) #self.setAcceptDrops(True) # self.setMaximumSize(100, 100) FigureCanvas.updateGeometry(self) self.axes = {} self.next_id = 0 self.current_id = -1 tabList = [] self.addTabletoPlot = '' self.setAcceptDrops(True) self.gridMode = False def dragEnterEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def dragMoveEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def eventFilter(self, source, event): if (event.type() == QtCore.QEvent.Drop): pass def dropEvent(self, event): """Insert an element of the specified class in drop location""" if not event.mimeData().hasFormat('text/plain'): return # print " active window ", self.isActiveWindow() # print "Mouse : ", self.mouse # pos = self.mapFromGlobal(QCursor.pos()) # print "Mouse Position : ", pos modelRoot, element = event.mimeData().data if isinstance(element, moose.PoolBase): tablePath = moose.utils.create_table_path(self.model, self.graph, element, "Conc") table = moose.utils.create_table(tablePath, element, "Conc", "Table2") # moose.connect(table, 'requestOut', element, 'getConc') self.updateSignal.emit() elif isinstance(element, moose.CompartmentBase): tablePath = moose.utils.create_table_path(self.model, self.graph, element, "Vm") table = moose.utils.create_table(tablePath, element, "Vm", "Table") self.updateSignal.emit() else: QtGui.QMessageBox.question( self, 'Message', "This element's properties cannot be plotted.", QtGui.QMessageBox.Ok) def addSubplot(self, rows, cols): """Add a subplot to figure and set it as current axes.""" assert (self.next_id <= rows * cols) axes = self.figure.add_subplot(rows, cols, self.next_id + 1) axes.set_xlabel("Time (s)") axes.set_ylabel("Concentration (mM)") axes.set_xlim(left=0.0) axes.set_ylim(bottom=0.0) self.axes[self.next_id] = axes axes.set_title("Graph " + str(self.index + 1)) self.current_id = self.next_id self.next_id += 1 labelList = [] axes.legend(loc='upper center') return axes def plot(self, *args, **kwargs): #self.callAxesFn('legend',loc='lower center',bbox_to_anchor=(0.5, -0.03),fancybox=True, shadow=True, ncol=3) return self.callAxesFn('plot', *args, **kwargs) def callAxesFn(self, fname, *args, **kwargs): """Call any arbitrary function of current axes object.""" if self.current_id < 0: self.addSubplot(1, 1) fn = eval('self.axes[self.current_id].%s' % (fname)) return fn(*args, **kwargs) def resize_event(self, event): print("Resize event called ", event) def toggleGrid(self): self.gridMode = not self.gridMode for key in self.axes: self.axes[key].grid(self.gridMode) self.draw() def setXLimit(self, minX, maxX): for key in self.axes: self.axes[key].set_xlim([minX, maxX]) self.draw()
class ApplicationWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.column_names = ["Column A", "Column B", "Column C"] # Central widget self._main = QWidget() self.setCentralWidget(self._main) # Main menu bar self.menu = self.menuBar() self.menu_file = self.menu.addMenu("File") exit = QAction("Exit", self, triggered=qApp.quit) self.menu_file.addAction(exit) self.menu_about = self.menu.addMenu("&About") about = QAction("About Qt", self, shortcut=QKeySequence(QKeySequence.HelpContents), triggered=qApp.aboutQt) self.menu_about.addAction(about) # Figure (Left) self.fig = Figure(figsize=(5, 3)) self.canvas = FigureCanvas(self.fig) # Sliders (Left) self.slider_azim = QSlider(minimum=0, maximum=360, orientation=Qt.Horizontal) self.slider_elev = QSlider(minimum=0, maximum=360, orientation=Qt.Horizontal) self.slider_azim_layout = QHBoxLayout() self.slider_azim_layout.addWidget(QLabel("{}".format(self.slider_azim.minimum()))) self.slider_azim_layout.addWidget(self.slider_azim) self.slider_azim_layout.addWidget(QLabel("{}".format(self.slider_azim.maximum()))) self.slider_elev_layout = QHBoxLayout() self.slider_elev_layout.addWidget(QLabel("{}".format(self.slider_elev.minimum()))) self.slider_elev_layout.addWidget(self.slider_elev) self.slider_elev_layout.addWidget(QLabel("{}".format(self.slider_elev.maximum()))) # Table (Right) self.table = QTableWidget() header = self.table.horizontalHeader() header.setSectionResizeMode(QHeaderView.Stretch) # ComboBox (Right) self.combo = QComboBox() self.combo.addItems(["Wired", "Surface", "Triangular Surface", "Sphere"]) # Right layout rlayout = QVBoxLayout() rlayout.setContentsMargins(1, 1, 1, 1) rlayout.addWidget(QLabel("Plot type:")) rlayout.addWidget(self.combo) rlayout.addWidget(self.table) # Left layout llayout = QVBoxLayout() rlayout.setContentsMargins(1, 1, 1, 1) llayout.addWidget(self.canvas, 88) llayout.addWidget(QLabel("Azimuth:"), 1) llayout.addLayout(self.slider_azim_layout, 5) llayout.addWidget(QLabel("Elevation:"), 1) llayout.addLayout(self.slider_elev_layout, 5) # Main layout layout = QHBoxLayout(self._main) layout.addLayout(llayout, 70) layout.addLayout(rlayout, 30) # Signal and Slots connections self.combo.currentTextChanged.connect(self.combo_option) self.slider_azim.valueChanged.connect(self.rotate_azim) self.slider_elev.valueChanged.connect(self.rotate_elev) # Initial setup self.plot_wire() self._ax.view_init(30, 30) self.slider_azim.setValue(30) self.slider_elev.setValue(30) self.fig.canvas.mpl_connect("button_release_event", self.on_click) # Matplotlib slot method def on_click(self, event): azim, elev = self._ax.azim, self._ax.elev self.slider_azim.setValue(azim + 180) self.slider_elev.setValue(elev + 180) # Utils methods def set_table_data(self, X, Y, Z): for i in range(len(X)): self.table.setItem(i, 0, QTableWidgetItem("{:.2f}".format(X[i]))) self.table.setItem(i, 1, QTableWidgetItem("{:.2f}".format(Y[i]))) self.table.setItem(i, 2, QTableWidgetItem("{:.2f}".format(Z[i]))) def set_canvas_table_configuration(self, row_count, data): self.fig.set_canvas(self.canvas) self._ax = self.canvas.figure.add_subplot(projection="3d") self._ax.set_xlabel(self.column_names[0]) self._ax.set_ylabel(self.column_names[1]) self._ax.set_zlabel(self.column_names[2]) self.table.setRowCount(row_count) self.table.setColumnCount(3) self.table.setHorizontalHeaderLabels(self.column_names) self.set_table_data(data[0], data[1], data[2]) # Plot methods def plot_wire(self): # Data self.X, self.Y, self.Z = axes3d.get_test_data(0.03) self.set_canvas_table_configuration(len(self.X[0]), (self.X[0], self.Y[0], self.Z[0])) self._ax.plot_wireframe(self.X, self.Y, self.Z, rstride=10, cstride=10, cmap="viridis") self.canvas.draw() def plot_surface(self): # Data self.X, self.Y = np.meshgrid(np.linspace(-6, 6, 30), np.linspace(-6, 6, 30)) self.Z = np.sin(np.sqrt(self.X ** 2 + self.Y ** 2)) self.set_canvas_table_configuration(len(self.X[0]), (self.X[0], self.Y[0], self.Z[0])) self._ax.plot_surface(self.X, self.Y, self.Z, rstride=1, cstride=1, cmap="viridis", edgecolor="none") self.canvas.draw() def plot_triangular_surface(self): # Data radii = np.linspace(0.125, 1.0, 8) angles = np.linspace(0, 2 * np.pi, 36, endpoint=False)[..., np.newaxis] self.X = np.append(0, (radii * np.cos(angles)).flatten()) self.Y = np.append(0, (radii * np.sin(angles)).flatten()) self.Z = np.sin(-self.X * self.Y) self.set_canvas_table_configuration(len(self.X), (self.X, self.Y, self.Z)) self._ax.plot_trisurf(self.X, self.Y, self.Z, linewidth=0.2, antialiased=True) self.canvas.draw() def plot_sphere(self): # Data u = np.linspace(0, 2 * np.pi, 100) v = np.linspace(0, np.pi, 100) self.X = 10 * np.outer(np.cos(u), np.sin(v)) self.Y = 10 * np.outer(np.sin(u), np.sin(v)) self.Z = 9 * np.outer(np.ones(np.size(u)), np.cos(v)) self.set_canvas_table_configuration(len(self.X), (self.X[0], self.Y[0], self.Z[0])) self._ax.plot_surface(self.X, self.Y, self.Z) self.canvas.draw() # Slots @Slot() def combo_option(self, text): if text == "Wired": self.plot_wire() elif text == "Surface": self.plot_surface() elif text == "Triangular Surface": self.plot_triangular_surface() elif text == "Sphere": self.plot_sphere() @Slot() def rotate_azim(self, value): self._ax.view_init(self._ax.elev, value) self.fig.set_canvas(self.canvas) self.canvas.draw() @Slot() def rotate_elev(self, value): self._ax.view_init(value, self._ax.azim) self.fig.set_canvas(self.canvas) self.canvas.draw()
def convergence_criterion(mcmc_set): """Returns the vector of Gelman-Rubin convergence criterion values and a link to an HTML file containing plots of the traces of the walk for each parameter fitted.""" # Prepare html for page showing plots of parameter traces html_str = "<html><head><title>Parameter traces for %s</title></head>\n" \ % mcmc_set.name html_str += "<body><p>Parameter traces for %s</p>\n" \ % mcmc_set.name img_str_list = [] # Useful variables num_estimate = mcmc_set.chains[0].num_estimate fontP = FontProperties() fontP.set_size('small') legend_kwargs = {'prop':fontP, 'ncol':1, 'bbox_to_anchor':(1, 1), 'fancybox': True, 'shadow': True} # Make plot of posterior fig = Figure() ax = fig.gca() for i, chain in enumerate(mcmc_set.chains): color = cm.jet(i/float(num_estimate - 1)) label = 's%d' % chain.options.seed if chain.pruned: line = ax.plot(chain.thinned_accept_steps, chain.posteriors, color=color, label=label) else: line = ax.plot(chain.posteriors, color=color, label=label) ax.set_title("Posterior traces") ax.legend(loc='upper left', **legend_kwargs) posterior_plot_filename = '%s_posterior_trace.png' % mcmc_set.name canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(posterior_plot_filename) # Make plots of parameter traces for i in range(num_estimate): param_name = mcmc_set.chains[0].options.estimate_params[i].name fig = Figure() ax = fig.gca() for j, chain in enumerate(mcmc_set.chains): color = cm.jet(j/float(num_estimate - 1)) label = 's%d' % chain.options.seed if chain.pruned: line = ax.plot(chain.thinned_accept_steps, chain.positions[:,i], color=color, label=label) else: line = ax.plot(chain.positions[:, i], color=color, label=label) ax.set_title("Parameter: %s" % param_name) ax.legend(loc='upper left', **legend_kwargs) plot_filename = '%s_trace_%s.png' % (mcmc_set.name, param_name) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) fig.savefig(plot_filename) img_str_list.append(plot_filename) # Make the html file html_str += '<a href="%s"><img src="%s" width=400 /></a>' % \ (posterior_plot_filename, posterior_plot_filename) html_str += '\n'.join([ '<a href="%s"><img src="%s" width=400 /></a>' % (i, i) for i in img_str_list]) html_str += "</body></html>" html_filename = '%s_convergence.html' % mcmc_set.name with open(html_filename, 'w') as f: f.write(html_str) return FloatListResult(convergence.convergence_criterion(mcmc_set), html_filename)
def make_plot_3d(grid, grid_name, x, y, all_z, t, grid_t_idx, grid_x_idx, grid_z_idx, n_cols = 6, outpath='', filename_prefix='LMA',do_save=True, image_type='pdf', colormap='cubehelix' , grid_range=None): n_frames = t.shape[0] # n_cols = 6 n_rows = int(ceil( float(n_frames) / n_cols )) if type(colormap) == type(''): colormap = get_cmap(colormap) grey_color = (0.5,)*3 frame_color = (0.2,)*3 density_maxes = [] total_counts = [] all_t = [] xedge = centers_to_edges(x) x_range = xedge.max() - xedge.min() yedge = centers_to_edges(y) y_range = yedge.max() - yedge.min() dx = (xedge[1]-xedge[0]) # count_scale_factor = dx # / 1000.0 # max_count_baseline = 450 * count_scale_factor #/ 10.0 min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0]) if (max_count == 0) | (max_count == 1 ): max_count = min_count+1 default_vmin = -0.2 if np.log10(max_count) <= default_vmin: vmin_count = np.log10(max_count) + default_vmin else: vmin_count = default_vmin # If the range of values for the colorbar is manually specified, # overwrite what we did above if grid_range is not None: vmin_count = grid_range[0] max_count = grid_range[1] # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None) fig = Figure(figsize=(w,h)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols) p.label_edges(True) pad = 0.0 # for time labels in each frame for ax in p.multiples.flat: if int(matplotlib.__version__[0]) <= 1: ax.set_axis_bgcolor('white') else: ax.set_facecolor('white') ax.spines['top'].set_edgecolor(frame_color) ax.spines['bottom'].set_edgecolor(frame_color) ax.spines['left'].set_edgecolor(frame_color) ax.spines['right'].set_edgecolor(frame_color) # ax.yaxis.set_major_formatter(kilo_formatter) # ax.xaxis.set_major_formatter(kilo_formatter) base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S") time_delta = timedelta(0,float(t[0]),0) start_time = base_date + time_delta for zi in range(len(all_z)): indexer = [slice(None),]*len(grid.shape) frame_start_times = [] altitude = all_z[zi] for i in range(n_frames): p.multiples.flat[i].clear() # reset (clear) the axes frame_start = base_date + timedelta(0,float(t[i]),0) frame_start_times.append(frame_start) indexer[grid_t_idx] = i indexer[grid_z_idx] = zi density = grid[indexer] density = np.ma.masked_where(density<=0.0, density) # mask grids 0 grids to reveal background color # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge, np.log10(density.transpose()), vmin=vmin_count, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') x_lab = xedge[0]-pad+x_range*.015 y_lab = yedge[0]-pad+y_range*.015 text_label = p.multiples.flat[i].text(x_lab, y_lab, label_string, color=grey_color, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print(label_string, x_lab, y_lab, grid_name, density.max(), density.sum()) color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') view_x = (xedge.min(), xedge.max()) view_y = (yedge.min(), yedge.max()) print('making multiples') p.multiples.flat[0].axis(view_x+view_y) filename = '%s-%s_%s_%05.2fkm_%04.1fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, altitude, time_delta.seconds, image_type) filename = os.path.join(outpath, filename) if do_save: fig.savefig(filename, dpi=150) print('done ', zi) return fig, p, frame_start_times, filename print(' ... done with loop')
def make_plot(filename, grid_name, x_name='x', y_name='y', t_name='time', n_cols=6, outpath='', filename_prefix='LMA', do_save=True, image_type='pdf', colormap='gist_earth'): """ colormap: a string giving the name of a matplotlib built-in colormap, or a matplotlib.colors.Colormap instance """ f = nc.NetCDFFile(filename) data = f.variables # dictionary of variable names to nc_var objects dims = f.dimensions # dictionary of dimension names to sizes x = data[x_name] y = data[y_name] t = data[t_name] grid = data[grid_name] assert len(x.shape) == 1 assert len(y.shape) == 1 assert len(t.shape) == 1 grid_dims = grid.dimensions # tuple of dimension names name_to_idx = dict((k, i) for i, k in enumerate(grid_dims)) grid_t_idx = name_to_idx[t.dimensions[0]] grid_x_idx = name_to_idx[x.dimensions[0]] grid_y_idx = name_to_idx[y.dimensions[0]] n_frames = t.shape[0] # n_cols = 6 n_rows = int(ceil(float(n_frames) / n_cols)) if type(colormap) == type(''): colormap = get_cmap(colormap) grey_color = (0.5, ) * 3 frame_color = (0.2, ) * 3 density_maxes = [] total_counts = [] all_t = [] xedge = centers_to_edges(x) x_range = xedge.max() - xedge.min() yedge = centers_to_edges(y) y_range = yedge.max() - yedge.min() dx = (xedge[1] - xedge[0]) # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None) # count_scale_factor = dx # / 1000.0 # max_count_baseline = 450 * count_scale_factor #/ 10.0 min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0]) if (max_count == 0) | (max_count == 1): max_count = min_count + 1 f.close() default_vmin = -0.2 if np.log10(max_count) <= default_vmin: vmin_count = np.log10(max_count) + default_vmin else: vmin_count = default_vmin fig = Figure(figsize=(w, h)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols) p.label_edges(True) pad = 0.0 # for time labels in each frame for ax in p.multiples.flat: ax.set_axis_bgcolor('black') ax.spines['top'].set_edgecolor(frame_color) ax.spines['bottom'].set_edgecolor(frame_color) ax.spines['left'].set_edgecolor(frame_color) ax.spines['right'].set_edgecolor(frame_color) # ax.yaxis.set_major_formatter(kilo_formatter) # ax.xaxis.set_major_formatter(kilo_formatter) base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S") time_delta = timedelta(0, float(t[0]), 0) start_time = base_date + time_delta indexer = [ slice(None), ] * len(grid.shape) frame_start_times = [] for i in range(n_frames): frame_start = base_date + timedelta(0, float(t[i]), 0) frame_start_times.append(frame_start) indexer[grid_t_idx] = i density = grid[indexer] # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge, yedge, np.log10( density.transpose()), vmin=vmin_count, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') text_label = p.multiples.flat[i].text(xedge[0] - pad + x_range * .015, yedge[0] - pad + y_range * .015, label_string, color=grey_color, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print label_string, x.shape, density.max(), density.sum() color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') view_x = (xedge.min(), xedge.max()) view_y = (yedge.min(), yedge.max()) print 'making multiples', p.multiples.flat[0].axis(view_x + view_y) filename = '%s-%s_%s_%05.2fkm_%05.1fs.%s' % ( filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, time_delta.seconds, image_type) filename = os.path.join(outpath, filename) if do_save: fig.savefig(filename, dpi=150) return fig, p, frame_start_times, filename print ' ... done'
class CanvasWidget(FigureCanvas): """Widget to draw plots on. This class keep track of all the axes in a dictionary. The key for an axis is its index number in sequence of creation. next_id: The key for the next axis. current_id: Key for current axis (anu plotting will happen on this). """ def __init__(self, *args, **kwargs): self.figure = Figure() FigureCanvas.__init__(self, self.figure, *args, **kwargs) self.figure.set_canvas(self) if len(args) > 0 and isinstance(args[0], QtGui.QWidget): self.reparent(args[0]) elif (kwargs is not None) and ('parent' in kwargs): self.reparent(kwargs['parent']) #self.setAcceptDrops(True) FigureCanvas.updateGeometry(self) self.axes = {} self.next_id = 0 self.current_id = -1 tabList = [] self.addTabletoPlot = '' self.setAcceptDrops(True) def dragEnterEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def dragMoveEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def eventFilter(self, source, event): if (event.type() == QtCore.QEvent.Drop): pass def dropEvent(self, event): """Insert an element of the specified class in drop location""" if not event.mimeData().hasFormat('text/plain'): return # print " active window ", self.isActiveWindow() # print "Mouse : ", self.mouse # pos = self.mapFromGlobal(QCursor.pos()) # print "Mouse Position : ", pos self.modelRoot, self.element = event.mimeData().data if isinstance (self.element,moose.PoolBase): moose.utils.create(self.modelRoot,self.element,"Conc") else: QtGui.QMessageBox.question(self, 'Message',"This field is not plottable", QtGui.QMessageBox.Ok) def addSubplot(self, rows, cols): """Add a subplot to figure and set it as current axes.""" assert(self.next_id <= rows * cols) axes = self.figure.add_subplot(rows, cols, self.next_id+1) self.axes[self.next_id] = axes axes.set_title(chr(self.next_id + ord('A'))) self.current_id = self.next_id self.next_id += 1 labelList = [] axes.legend(loc='upper center') return axes def plot(self, *args, **kwargs): #self.callAxesFn('legend',loc='lower center',bbox_to_anchor=(0.5, -0.03),fancybox=True, shadow=True, ncol=3) return self.callAxesFn('plot', *args, **kwargs) def callAxesFn(self, fname, *args, **kwargs): """Call any arbitrary function of current axes object.""" if self.current_id < 0: self.addSubplot(1,1) fn = eval('self.axes[self.current_id].%s' % (fname)) return fn(*args, **kwargs)
class SquidGui(QtGui.QMainWindow): defaults = {} defaults.update(SquidAxon.defaults) defaults.update(ClampCircuit.defaults) defaults.update({ 'runtime': 50.0, 'simdt': 0.01, 'plotdt': 0.1, 'vclamp.holdingV': 0.0, 'vclamp.holdingT': 10.0, 'vclamp.prepulseV': 0.0, 'vclamp.prepulseT': 0.0, 'vclamp.clampV': 50.0, 'vclamp.clampT': 20.0, 'iclamp.baseI': 0.0, 'iclamp.firstI': 0.1, 'iclamp.firstT': 40.0, 'iclamp.firstD': 5.0, 'iclamp.secondI': 0.0, 'iclamp.secondT': 0.0, 'iclamp.secondD': 0.0 }) def __init__(self, *args): QtGui.QMainWindow.__init__(self, *args) self.squid_setup = SquidSetup() self._plotdt = SquidGui.defaults['plotdt'] self._plot_dict = defaultdict(list) self.setWindowTitle('Squid Axon simulation') self.setDockNestingEnabled(True) self._createRunControl() self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock) self._runControlDock.setFeatures( QtGui.QDockWidget.AllDockWidgetFeatures) self._createChannelControl() self._channelCtrlBox.setWindowTitle('Channel properties') self._channelControlDock.setFeatures( QtGui.QDockWidget.AllDockWidgetFeatures) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._channelControlDock) self._createElectronicsControl() self._electronicsDock.setFeatures( QtGui.QDockWidget.AllDockWidgetFeatures) self._electronicsDock.setWindowTitle('Electronics') self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock) self._createPlotWidget() self.setCentralWidget(self._plotWidget) self._createStatePlotWidget() self._createHelpMessage() self._helpWindow.setVisible(False) self._statePlotWidget.setWindowFlags(QtCore.Qt.Window) self._statePlotWidget.setWindowTitle('State plot') self._initActions() self._createRunToolBar() self._createPlotToolBar() def _createPlotWidget(self): self._plotWidget = QtGui.QWidget() self._plotFigure = Figure() self._plotCanvas = FigureCanvas(self._plotFigure) self._plotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._plotCanvas.updateGeometry() self._plotCanvas.setParent(self._plotWidget) self._plotCanvas.mpl_connect('scroll_event', self._onScroll) self._plotFigure.set_canvas(self._plotCanvas) # Vm and command voltage go in the same subplot self._vm_axes = self._plotFigure.add_subplot( 2, 2, 1, title='Membrane potential') self._vm_axes.set_ylim(-20.0, 120.0) # Channel conductances go to the same subplot self._g_axes = self._plotFigure.add_subplot( 2, 2, 2, title='Channel conductance') self._g_axes.set_ylim(0.0, 0.5) # Injection current for Vclamp/Iclamp go to the same subplot self._im_axes = self._plotFigure.add_subplot(2, 2, 3, title='Injection current') self._im_axes.set_ylim(-0.5, 0.5) # Channel currents go to the same subplot self._i_axes = self._plotFigure.add_subplot(2, 2, 4, title='Channel current') self._i_axes.set_ylim(-10, 10) for axis in self._plotFigure.axes: axis.set_autoscale_on(False) layout = QtGui.QVBoxLayout() layout.addWidget(self._plotCanvas) self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget) layout.addWidget(self._plotNavigator) self._plotWidget.setLayout(layout) def _createStatePlotWidget(self): self._statePlotWidget = QtGui.QWidget() self._statePlotFigure = Figure() self._statePlotCanvas = FigureCanvas(self._statePlotFigure) self._statePlotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._statePlotCanvas.updateGeometry() self._statePlotCanvas.setParent(self._statePlotWidget) self._statePlotFigure.set_canvas(self._statePlotCanvas) self._statePlotFigure.subplots_adjust(hspace=0.5) self._statePlotAxes = self._statePlotFigure.add_subplot( 2, 1, 1, title='State plot') self._state_plot, = self._statePlotAxes.plot([], [], label='state') self._activationParamAxes = self._statePlotFigure.add_subplot( 2, 1, 2, title='H-H activation parameters vs time') self._activationParamAxes.set_xlabel('Time (ms)') #for axis in self._plotFigure.axes: # axis.autoscale(False) self._stateplot_xvar_label = QtGui.QLabel('Variable on X-axis') self._stateplot_xvar_combo = QtGui.QComboBox() self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h']) self._stateplot_xvar_combo.setCurrentIndex(0) self._stateplot_xvar_combo.setEditable(False) self.connect(self._stateplot_xvar_combo, QtCore.SIGNAL('currentIndexChanged(const QString&)'), self._statePlotXSlot) self._stateplot_yvar_label = QtGui.QLabel('Variable on Y-axis') self._stateplot_yvar_combo = QtGui.QComboBox() self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h']) self._stateplot_yvar_combo.setCurrentIndex(2) self._stateplot_yvar_combo.setEditable(False) self.connect(self._stateplot_yvar_combo, QtCore.SIGNAL('currentIndexChanged(const QString&)'), self._statePlotYSlot) self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas, self._statePlotWidget) frame = QtGui.QFrame() frame.setFrameStyle(QtGui.QFrame.StyledPanel + QtGui.QFrame.Raised) layout = QtGui.QHBoxLayout() layout.addWidget(self._stateplot_xvar_label) layout.addWidget(self._stateplot_xvar_combo) layout.addWidget(self._stateplot_yvar_label) layout.addWidget(self._stateplot_yvar_combo) frame.setLayout(layout) self._closeStatePlotAction = QtGui.QAction('Close', self) self.connect(self._closeStatePlotAction, QtCore.SIGNAL('triggered()'), self._statePlotWidget.close) self._closeStatePlotButton = QtGui.QToolButton() self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction) layout = QtGui.QVBoxLayout() layout.addWidget(frame) layout.addWidget(self._statePlotCanvas) layout.addWidget(self._statePlotNavigator) layout.addWidget(self._closeStatePlotButton) self._statePlotWidget.setLayout(layout) # Setting the close event so that when the help window is # closed the ``State plot`` button becomes unchecked self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked( False) def _createRunControl(self): self._runControlBox = QtGui.QGroupBox(self) self._runControlBox.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred) self._runTimeLabel = QtGui.QLabel("Run time (ms)", self._runControlBox) self._simTimeStepLabel = QtGui.QLabel("Simulation time step (ms)", self._runControlBox) self._runTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['runtime']), self._runControlBox) set_default_line_edit_size(self._runTimeEdit) self._simTimeStepEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['simdt']), self._runControlBox) set_default_line_edit_size(self._simTimeStepEdit) layout = QtGui.QGridLayout() layout.addWidget(self._runTimeLabel, 0, 0) layout.addWidget(self._runTimeEdit, 0, 1) layout.addWidget(self._simTimeStepLabel, 1, 0) layout.addWidget(self._simTimeStepEdit, 1, 1) layout.setColumnStretch(2, 1.0) layout.setRowStretch(2, 1.0) self._runControlBox.setLayout(layout) self._runControlDock = QtGui.QDockWidget('Simulation', self) self._runControlDock.setWidget(self._runControlBox) def _createChannelControl(self): self._channelControlDock = QtGui.QDockWidget('Channels', self) self._channelCtrlBox = QtGui.QGroupBox(self) self._naConductanceToggle = QtGui.QCheckBox('Block Na+ channel', self._channelCtrlBox) self._naConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_NaChan)) self._kConductanceToggle = QtGui.QCheckBox('Block K+ channel', self._channelCtrlBox) self._kConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_KChan)) self._kOutLabel = QtGui.QLabel('[K+]out (mM)', self._channelCtrlBox) self._kOutEdit = QtGui.QLineEdit( '%g' % (self.squid_setup.squid_axon.K_out), self._channelCtrlBox) self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._kOutEdit) self._naOutLabel = QtGui.QLabel('[Na+]out (mM)', self._channelCtrlBox) self._naOutEdit = QtGui.QLineEdit( '%g' % (self.squid_setup.squid_axon.Na_out), self._channelCtrlBox) self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._naOutEdit) self._kInLabel = QtGui.QLabel('[K+]in (mM)', self._channelCtrlBox) self._kInEdit = QtGui.QLabel('%g' % (self.squid_setup.squid_axon.K_in), self._channelCtrlBox) self._kInEdit.setToolTip(tooltip_Nernst) self._naInLabel = QtGui.QLabel('[Na+]in (mM)', self._channelCtrlBox) self._naInEdit = QtGui.QLabel( '%g' % (self.squid_setup.squid_axon.Na_in), self._channelCtrlBox) self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._temperatureLabel = QtGui.QLabel('Temperature (C)', self._channelCtrlBox) self._temperatureEdit = QtGui.QLineEdit( '%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN), self._channelCtrlBox) self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._temperatureEdit) for child in self._channelCtrlBox.children(): if isinstance(child, QtGui.QLineEdit): set_default_line_edit_size(child) layout = QtGui.QGridLayout(self._channelCtrlBox) layout.addWidget(self._naConductanceToggle, 0, 0) layout.addWidget(self._kConductanceToggle, 1, 0) layout.addWidget(self._naOutLabel, 2, 0) layout.addWidget(self._naOutEdit, 2, 1) layout.addWidget(self._naInLabel, 3, 0) layout.addWidget(self._naInEdit, 3, 1) layout.addWidget(self._kOutLabel, 4, 0) layout.addWidget(self._kOutEdit, 4, 1) layout.addWidget(self._kInLabel, 5, 0) layout.addWidget(self._kInEdit, 5, 1) layout.addWidget(self._temperatureLabel, 6, 0) layout.addWidget(self._temperatureEdit, 6, 1) layout.setRowStretch(7, 1.0) self._channelCtrlBox.setLayout(layout) self._channelControlDock.setWidget(self._channelCtrlBox) return self._channelCtrlBox def __get_stateplot_data(self, name): data = [] if name == 'V': data = self.squid_setup.vm_table.vector elif name == 'm': data = self.squid_setup.m_table.vector elif name == 'h': data = self.squid_setup.h_table.vector elif name == 'n': data = self.squid_setup.n_table.vector else: raise ValueError('Unrecognized selection: %s' % (name)) return numpy.asarray(data) def _statePlotYSlot(self, selectedItem): ydata = self.__get_stateplot_data(str(selectedItem)) self._state_plot.set_ydata(ydata) self._statePlotAxes.set_ylabel(selectedItem) if str(selectedItem) == 'V': self._statePlotAxes.set_ylim(-20, 120) else: self._statePlotAxes.set_ylim(0, 1) self._statePlotCanvas.draw() def _statePlotXSlot(self, selectedItem): xdata = self.__get_stateplot_data(str(selectedItem)) self._state_plot.set_xdata(xdata) self._statePlotAxes.set_xlabel(selectedItem) if str(selectedItem) == 'V': self._statePlotAxes.set_xlim(-20, 120) else: self._statePlotAxes.set_xlim(0, 1) self._statePlotCanvas.draw() def _createElectronicsControl(self): """Creates a tabbed widget of voltage clamp and current clamp controls""" self._electronicsTab = QtGui.QTabWidget(self) self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp') self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp') self._electronicsDock = QtGui.QDockWidget(self) self._electronicsDock.setWidget(self._electronicsTab) def _getVClampCtrlBox(self): vClampPanel = QtGui.QGroupBox(self) self._vClampCtrlBox = vClampPanel self._holdingVLabel = QtGui.QLabel("Holding Voltage (mV)", vClampPanel) self._holdingVEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel) self._holdingTimeLabel = QtGui.QLabel("Holding Time (ms)", vClampPanel) self._holdingTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel) self._prePulseVLabel = QtGui.QLabel("Pre-pulse Voltage (mV)", vClampPanel) self._prePulseVEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel) self._prePulseTimeLabel = QtGui.QLabel("Pre-pulse Time (ms)", vClampPanel) self._prePulseTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel) self._clampVLabel = QtGui.QLabel("Clamp Voltage (mV)", vClampPanel) self._clampVEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel) self._clampTimeLabel = QtGui.QLabel("Clamp Time (ms)", vClampPanel) self._clampTimeEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel) for child in vClampPanel.children(): if isinstance(child, QtGui.QLineEdit): set_default_line_edit_size(child) layout = QtGui.QGridLayout(vClampPanel) layout.addWidget(self._holdingVLabel, 0, 0) layout.addWidget(self._holdingVEdit, 0, 1) layout.addWidget(self._holdingTimeLabel, 1, 0) layout.addWidget(self._holdingTimeEdit, 1, 1) layout.addWidget(self._prePulseVLabel, 2, 0) layout.addWidget(self._prePulseVEdit, 2, 1) layout.addWidget(self._prePulseTimeLabel, 3, 0) layout.addWidget(self._prePulseTimeEdit, 3, 1) layout.addWidget(self._clampVLabel, 4, 0) layout.addWidget(self._clampVEdit, 4, 1) layout.addWidget(self._clampTimeLabel, 5, 0) layout.addWidget(self._clampTimeEdit, 5, 1) layout.setRowStretch(6, 1.0) vClampPanel.setLayout(layout) return self._vClampCtrlBox def _getIClampCtrlBox(self): iClampPanel = QtGui.QGroupBox(self) self._iClampCtrlBox = iClampPanel self._baseCurrentLabel = QtGui.QLabel("Base Current Level (uA)", iClampPanel) self._baseCurrentEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.baseI']), iClampPanel) self._firstPulseLabel = QtGui.QLabel("First Pulse Current (uA)", iClampPanel) self._firstPulseEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel) self._firstDelayLabel = QtGui.QLabel("First Onset Delay (ms)", iClampPanel) self._firstDelayEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.firstD']), iClampPanel) self._firstPulseWidthLabel = QtGui.QLabel("First Pulse Width (ms)", iClampPanel) self._firstPulseWidthEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel) self._secondPulseLabel = QtGui.QLabel("Second Pulse Current (uA)", iClampPanel) self._secondPulseEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel) self._secondDelayLabel = QtGui.QLabel("Second Onset Delay (ms)", iClampPanel) self._secondDelayEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.secondD']), iClampPanel) self._secondPulseWidthLabel = QtGui.QLabel("Second Pulse Width (ms)", iClampPanel) self._secondPulseWidthEdit = QtGui.QLineEdit( '%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel) self._pulseMode = QtGui.QComboBox(iClampPanel) self._pulseMode.addItem("Single Pulse") self._pulseMode.addItem("Pulse Train") for child in iClampPanel.children(): if isinstance(child, QtGui.QLineEdit): set_default_line_edit_size(child) layout = QtGui.QGridLayout(iClampPanel) layout.addWidget(self._baseCurrentLabel, 0, 0) layout.addWidget(self._baseCurrentEdit, 0, 1) layout.addWidget(self._firstPulseLabel, 1, 0) layout.addWidget(self._firstPulseEdit, 1, 1) layout.addWidget(self._firstDelayLabel, 2, 0) layout.addWidget(self._firstDelayEdit, 2, 1) layout.addWidget(self._firstPulseWidthLabel, 3, 0) layout.addWidget(self._firstPulseWidthEdit, 3, 1) layout.addWidget(self._secondPulseLabel, 4, 0) layout.addWidget(self._secondPulseEdit, 4, 1) layout.addWidget(self._secondDelayLabel, 5, 0) layout.addWidget(self._secondDelayEdit, 5, 1) layout.addWidget(self._secondPulseWidthLabel, 6, 0) layout.addWidget(self._secondPulseWidthEdit, 6, 1) layout.addWidget(self._pulseMode, 7, 0, 1, 2) layout.setRowStretch(8, 1.0) # layout.setSizeConstraint(QtGui.QLayout.SetFixedSize) iClampPanel.setLayout(layout) return self._iClampCtrlBox def _overlayPlots(self, overlay): if not overlay: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): title = axis.get_title() axis.clear() axis.set_title(title) suffix = '' else: suffix = '_%d' % (len(self._plot_dict['vm'])) self._vm_axes.set_xlim(0.0, self._runtime) self._g_axes.set_xlim(0.0, self._runtime) self._im_axes.set_xlim(0.0, self._runtime) self._i_axes.set_xlim(0.0, self._runtime) self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s' % (suffix)) self._plot_dict['vm'].append(self._vm_plot) self._command_plot, = self._vm_axes.plot([], [], label='command%s' % (suffix)) self._plot_dict['command'].append(self._command_plot) # Channel conductances go to the same subplot self._gna_plot, = self._g_axes.plot([], [], label='Na%s' % (suffix)) self._plot_dict['gna'].append(self._gna_plot) self._gk_plot, = self._g_axes.plot([], [], label='K%s' % (suffix)) self._plot_dict['gk'].append(self._gk_plot) # Injection current for Vclamp/Iclamp go to the same subplot self._iclamp_plot, = self._im_axes.plot([], [], label='Iclamp%s' % (suffix)) self._vclamp_plot, = self._im_axes.plot([], [], label='Vclamp%s' % (suffix)) self._plot_dict['iclamp'].append(self._iclamp_plot) self._plot_dict['vclamp'].append(self._vclamp_plot) # Channel currents go to the same subplot self._ina_plot, = self._i_axes.plot([], [], label='Na%s' % (suffix)) self._plot_dict['ina'].append(self._ina_plot) self._ik_plot, = self._i_axes.plot([], [], label='K%s' % (suffix)) self._plot_dict['ik'].append(self._ik_plot) # self._i_axes.legend() # State plots self._state_plot, = self._statePlotAxes.plot([], [], label='state%s' % (suffix)) self._plot_dict['state'].append(self._state_plot) self._m_plot, = self._activationParamAxes.plot([], [], label='m%s' % (suffix)) self._h_plot, = self._activationParamAxes.plot([], [], label='h%s' % (suffix)) self._n_plot, = self._activationParamAxes.plot([], [], label='n%s' % (suffix)) self._plot_dict['m'].append(self._m_plot) self._plot_dict['h'].append(self._h_plot) self._plot_dict['n'].append(self._n_plot) if self._showLegendAction.isChecked(): for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend() def _updateAllPlots(self): self._updatePlots() self._updateStatePlot() def _updatePlots(self): if len(self.squid_setup.vm_table.vector) <= 0: return vm = numpy.asarray(self.squid_setup.vm_table.vector) cmd = numpy.asarray(self.squid_setup.cmd_table.vector) ik = numpy.asarray(self.squid_setup.ik_table.vector) ina = numpy.asarray(self.squid_setup.ina_table.vector) iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector) vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector) gk = numpy.asarray(self.squid_setup.gk_table.vector) gna = numpy.asarray(self.squid_setup.gna_table.vector) time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm)) self._vm_plot.set_data(time_series, vm) time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd)) self._command_plot.set_data(time_series, cmd) time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik)) self._ik_plot.set_data(time_series, ik) time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina)) self._ina_plot.set_data(time_series, ina) time_series = numpy.linspace(0, self._plotdt * len(iclamp), len(iclamp)) self._iclamp_plot.set_data(time_series, iclamp) time_series = numpy.linspace(0, self._plotdt * len(vclamp), len(vclamp)) self._vclamp_plot.set_data(time_series, vclamp) time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk)) self._gk_plot.set_data(time_series, gk) time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna)) self._gna_plot.set_data(time_series, gna) if self._autoscaleAction.isChecked(): for axis in self._plotFigure.axes: axis.relim() axis.set_autoscale_on(True) else: self._vm_axes.set_ylim(-20.0, 120.0) self._g_axes.set_ylim(0.0, 0.5) self._im_axes.set_ylim(-0.5, 0.5) self._i_axes.set_ylim(-10, 10) self._vm_axes.set_xlim(0.0, time_series[-1]) self._g_axes.set_xlim(0.0, time_series[-1]) self._im_axes.set_xlim(0.0, time_series[-1]) self._i_axes.set_xlim(0.0, time_series[-1]) self._plotCanvas.draw() def _updateStatePlot(self): if len(self.squid_setup.vm_table.vector) <= 0: return sx = str(self._stateplot_xvar_combo.currentText()) sy = str(self._stateplot_yvar_combo.currentText()) xdata = self.__get_stateplot_data(sx) ydata = self.__get_stateplot_data(sy) minlen = min(len(xdata), len(ydata)) self._state_plot.set_data(xdata[:minlen], ydata[:minlen]) self._statePlotAxes.set_xlabel(sx) self._statePlotAxes.set_ylabel(sy) if sx == 'V': self._statePlotAxes.set_xlim(-20, 120) else: self._statePlotAxes.set_xlim(0, 1) if sy == 'V': self._statePlotAxes.set_ylim(-20, 120) else: self._statePlotAxes.set_ylim(0, 1) self._activationParamAxes.set_xlim(0, self._runtime) m = self.__get_stateplot_data('m') n = self.__get_stateplot_data('n') h = self.__get_stateplot_data('h') time_series = numpy.linspace(0, self._plotdt * len(m), len(m)) self._m_plot.set_data(time_series, m) time_series = numpy.linspace(0, self._plotdt * len(h), len(h)) self._h_plot.set_data(time_series, h) time_series = numpy.linspace(0, self._plotdt * len(n), len(n)) self._n_plot.set_data(time_series, n) if self._autoscaleAction.isChecked(): for axis in self._statePlotFigure.axes: axis.relim() axis.set_autoscale_on(True) self._statePlotCanvas.draw() def _runSlot(self): if moose.isRunning(): print 'Stopping simulation in progress ...' moose.stop() self._runtime = float(str(self._runTimeEdit.text())) self._overlayPlots(self._overlayAction.isChecked()) self._simdt = float(str(self._simTimeStepEdit.text())) clampMode = None singlePulse = True if self._electronicsTab.currentWidget() == self._vClampCtrlBox: clampMode = 'vclamp' baseLevel = float(str(self._holdingVEdit.text())) firstDelay = float(str(self._holdingTimeEdit.text())) firstWidth = float(str(self._prePulseTimeEdit.text())) firstLevel = float(str(self._prePulseVEdit.text())) secondDelay = firstWidth secondWidth = float(str(self._clampTimeEdit.text())) secondLevel = float(str(self._clampVEdit.text())) self._im_axes.set_ylim(-10.0, 10.0) else: clampMode = 'iclamp' baseLevel = float(str(self._baseCurrentEdit.text())) firstDelay = float(str(self._firstDelayEdit.text())) firstWidth = float(str(self._firstPulseWidthEdit.text())) firstLevel = float(str(self._firstPulseEdit.text())) secondDelay = float(str(self._secondDelayEdit.text())) secondLevel = float(str(self._secondPulseEdit.text())) secondWidth = float(str(self._secondPulseWidthEdit.text())) singlePulse = (self._pulseMode.currentIndex() == 0) self._im_axes.set_ylim(-0.4, 0.4) self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel, firstDelay=firstDelay, firstWidth=firstWidth, firstLevel=firstLevel, secondDelay=secondDelay, secondWidth=secondWidth, secondLevel=secondLevel, singlePulse=singlePulse) if self._kConductanceToggle.isChecked(): self.squid_setup.squid_axon.specific_gK = 0.0 else: self.squid_setup.squid_axon.specific_gK = SquidAxon.defaults[ 'specific_gK'] if self._naConductanceToggle.isChecked(): self.squid_setup.squid_axon.specific_gNa = 0.0 else: self.squid_setup.squid_axon.specific_gNa = SquidAxon.defaults[ 'specific_gNa'] self.squid_setup.squid_axon.celsius = float( str(self._temperatureEdit.text())) self.squid_setup.squid_axon.K_out = float(str(self._kOutEdit.text())) self.squid_setup.squid_axon.Na_out = float(str(self._naOutEdit.text())) self.squid_setup.squid_axon.updateEk() self.squid_setup.schedule(self._simdt, self._plotdt, clampMode) # The following line is for use with Qthread self.squid_setup.run(self._runtime) self._updateAllPlots() def _toggleDocking(self, on): self._channelControlDock.setFloating(on) self._electronicsDock.setFloating(on) self._runControlDock.setFloating(on) def _restoreDocks(self): self._channelControlDock.setVisible(True) self._electronicsDock.setVisible(True) self._runControlDock.setVisible(True) def _initActions(self): self._runAction = QtGui.QAction(self.tr('Run'), self) self._runAction.setShortcut(self.tr('F5')) self._runAction.setToolTip('Run simulation (F5)') self.connect(self._runAction, QtCore.SIGNAL('triggered()'), self._runSlot) self._resetToDefaultsAction = QtGui.QAction( self.tr('Restore defaults'), self) self._resetToDefaultsAction.setToolTip( 'Reset all settings to their default values') self.connect(self._resetToDefaultsAction, QtCore.SIGNAL('triggered()'), self._useDefaults) self._showLegendAction = QtGui.QAction(self.tr('Display legend'), self) self._showLegendAction.setCheckable(True) self.connect(self._showLegendAction, QtCore.SIGNAL('toggled(bool)'), self._showLegend) self._showStatePlotAction = QtGui.QAction(self.tr('State plot'), self) self._showStatePlotAction.setCheckable(True) self._showStatePlotAction.setChecked(False) self.connect(self._showStatePlotAction, QtCore.SIGNAL('toggled(bool)'), self._statePlotWidget.setVisible) self._autoscaleAction = QtGui.QAction(self.tr('Auto-scale plots'), self) self._autoscaleAction.setCheckable(True) self._autoscaleAction.setChecked(False) self.connect(self._autoscaleAction, QtCore.SIGNAL('toggled(bool)'), self._autoscale) self._overlayAction = QtGui.QAction('Overlay plots', self) self._overlayAction.setCheckable(True) self._overlayAction.setChecked(False) self._dockAction = QtGui.QAction('Undock all', self) self._dockAction.setCheckable(True) self._dockAction.setChecked(False) self.connect(self._dockAction, QtCore.SIGNAL('toggled(bool)'), self._toggleDocking) self._restoreDocksAction = QtGui.QAction('Show all', self) self.connect(self._restoreDocksAction, QtCore.SIGNAL('triggered()'), self._restoreDocks) self._quitAction = QtGui.QAction(self.tr('&Quit'), self) self._quitAction.setShortcut(self.tr('Ctrl+Q')) self.connect(self._quitAction, QtCore.SIGNAL('triggered()'), QtGui.qApp.closeAllWindows) def _createRunToolBar(self): self._simToolBar = self.addToolBar(self.tr('Simulation control')) self._simToolBar.addAction(self._quitAction) self._simToolBar.addAction(self._runAction) self._simToolBar.addAction(self._resetToDefaultsAction) self._simToolBar.addAction(self._dockAction) self._simToolBar.addAction(self._restoreDocksAction) def _createPlotToolBar(self): self._plotToolBar = self.addToolBar(self.tr('Plotting control')) self._plotToolBar.addAction(self._showLegendAction) self._plotToolBar.addAction(self._autoscaleAction) self._plotToolBar.addAction(self._overlayAction) self._plotToolBar.addAction(self._showStatePlotAction) self._plotToolBar.addAction(self._helpAction) self._plotToolBar.addAction(self._helpBiophysicsAction) def _showLegend(self, on): if on: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend().set_visible(True) else: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend().set_visible(False) self._plotCanvas.draw() self._statePlotCanvas.draw() def _autoscale(self, on): if on: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.relim() axis.set_autoscale_on(True) else: for axis in self._plotFigure.axes: axis.set_autoscale_on(False) self._vm_axes.set_ylim(-20.0, 120.0) self._g_axes.set_ylim(0.0, 0.5) self._im_axes.set_ylim(-0.5, 0.5) self._i_axes.set_ylim(-10, 10) self._plotCanvas.draw() self._statePlotCanvas.draw() def _useDefaults(self): self._runTimeEdit.setText('%g' % (self.defaults['runtime'])) self._simTimeStepEdit.setText('%g' % (self.defaults['simdt'])) self._overlayAction.setChecked(False) self._naConductanceToggle.setChecked(False) self._kConductanceToggle.setChecked(False) self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out'])) self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out'])) self._temperatureEdit.setText( '%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN)) self._holdingVEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingV'])) self._holdingTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingT'])) self._prePulseVEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseV'])) self._prePulseTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseT'])) self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV'])) self._clampTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.clampT'])) self._baseCurrentEdit.setText('%g' % (SquidGui.defaults['iclamp.baseI'])) self._firstPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.firstI'])) self._firstDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.firstD'])) self._firstPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.firstT'])) self._secondPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.secondI'])) self._secondDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.secondD'])) self._secondPulseWidthEdit.setText( '%g' % (SquidGui.defaults['iclamp.secondT'])) self._pulseMode.setCurrentIndex(0) def _onScroll(self, event): if event.inaxes is None: return axes = event.inaxes zoom = 0.0 if event.button == 'up': zoom = -1.0 elif event.button == 'down': zoom = 1.0 if zoom != 0.0: self._plotNavigator.push_current() axes.get_xaxis().zoom(zoom) axes.get_yaxis().zoom(zoom) self._plotCanvas.draw() def closeEvent(self, event): QtGui.qApp.closeAllWindows() def _showBioPhysicsHelp(self): print '11111' self._createHelpMessage() self._helpMessageText.setText( '<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' % (tooltip_Nernst, tooltip_Erest, tooltip_KChan, tooltip_NaChan, tooltip_Im)) self._helpWindow.setVisible(True) def _showRunningHelp(self): self._createHelpMessage() self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL)) self._helpWindow.setVisible(True) def _createHelpMessage(self): if hasattr(self, '_helpWindow'): return self._helpWindow = QtGui.QWidget() self._helpWindow.setWindowFlags(QtCore.Qt.Window) layout = QtGui.QVBoxLayout() self._helpWindow.setLayout(layout) self._helpMessageArea = QtGui.QScrollArea() self._helpMessageText = QtGui.QTextBrowser() self._helpMessageText.setOpenExternalLinks(True) self._helpMessageArea.setWidget(self._helpMessageText) layout.addWidget(self._helpMessageText) self._squidGuiPath = os.path.dirname(os.path.abspath(__file__)) self._helpBaseURL = os.path.join(self._squidGuiPath, 'help.html') self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL)) self._helpMessageText.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._helpMessageArea.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self._helpMessageText.setMinimumSize(800, 600) self._closeHelpAction = QtGui.QAction('Close', self) self.connect(self._closeHelpAction, QtCore.SIGNAL('triggered()'), self._helpWindow.close) # Setting the close event so that the ``Help`` button is # unchecked when the help window is closed self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked( False) self._helpTOCAction = QtGui.QAction('Help running demo', self) self.connect(self._helpTOCAction, QtCore.SIGNAL('triggered()'), self._jumpToHelpTOC) # This panel is for putting two buttons using horizontal # layout panel = QtGui.QFrame() panel.setFrameStyle(QtGui.QFrame.StyledPanel + QtGui.QFrame.Raised) layout.addWidget(panel) layout = QtGui.QHBoxLayout() panel.setLayout(layout) self._helpAction = QtGui.QAction('Help running', self) self.connect(self._helpAction, QtCore.SIGNAL('triggered()'), self._showRunningHelp) self._helpBiophysicsAction = QtGui.QAction('Help biophysics', self) self.connect(self._helpBiophysicsAction, QtCore.SIGNAL('triggered()'), self._showBioPhysicsHelp) self._helpTOCButton = QtGui.QToolButton() self._helpTOCButton.setDefaultAction(self._helpTOCAction) self._helpBiophysicsButton = QtGui.QToolButton() self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction) layout.addWidget(self._helpTOCButton) layout.addWidget(self._helpBiophysicsButton) self._closeHelpButton = QtGui.QToolButton() self._closeHelpButton.setDefaultAction(self._closeHelpAction) layout.addWidget(self._closeHelpButton) def _jumpToHelpTOC(self): self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
def make_plot(filename, grid_name, x_name='x', y_name='y', t_name='time', n_cols=6, outpath='', filename_prefix='LMA', do_save=True, image_type='pdf', colormap='gist_earth'): """ colormap: a string giving the name of a matplotlib built-in colormap, or a matplotlib.colors.Colormap instance """ f = nc.NetCDFFile(filename) data = f.variables # dictionary of variable names to nc_var objects dims = f.dimensions # dictionary of dimension names to sizes x = data[x_name] y = data[y_name] t = data[t_name] grid = data[grid_name] assert len(x.shape) == 1 assert len(y.shape) == 1 assert len(t.shape) == 1 grid_dims = grid.dimensions # tuple of dimension names name_to_idx = dict((k, i) for i, k in enumerate(grid_dims)) grid_t_idx = name_to_idx[t.dimensions[0]] grid_x_idx = name_to_idx[x.dimensions[0]] grid_y_idx = name_to_idx[y.dimensions[0]] n_frames = t.shape[0] # n_cols = 6 n_rows = int(ceil( float(n_frames) / n_cols )) if type(colormap) == type(''): colormap = get_cmap(colormap) grey_color = (0.5,)*3 frame_color = (0.2,)*3 density_maxes = [] total_counts = [] all_t = [] xedge = centers_to_edges(x) x_range = xedge.max() - xedge.min() yedge = centers_to_edges(y) y_range = yedge.max() - yedge.min() dx = (xedge[1]-xedge[0]) # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None) # count_scale_factor = dx # / 1000.0 # max_count_baseline = 450 * count_scale_factor #/ 10.0 min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0]) if (max_count == 0) | (max_count == 1 ): max_count = min_count+1 f.close() default_vmin = -0.2 if np.log10(max_count) <= default_vmin: vmin_count = np.log10(max_count) + default_vmin else: vmin_count = default_vmin fig = Figure(figsize=(w,h)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols) p.label_edges(True) pad = 0.0 # for time labels in each frame for ax in p.multiples.flat: ax.set_axis_bgcolor('black') ax.spines['top'].set_edgecolor(frame_color) ax.spines['bottom'].set_edgecolor(frame_color) ax.spines['left'].set_edgecolor(frame_color) ax.spines['right'].set_edgecolor(frame_color) # ax.yaxis.set_major_formatter(kilo_formatter) # ax.xaxis.set_major_formatter(kilo_formatter) base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S") time_delta = timedelta(0,float(t[0]),0) start_time = base_date + time_delta indexer = [slice(None),]*len(grid.shape) frame_start_times = [] for i in range(n_frames): frame_start = base_date + timedelta(0,float(t[i]),0) frame_start_times.append(frame_start) indexer[grid_t_idx] = i density = grid[indexer] # density,edges = np.histogramdd((x,y), bins=(xedge,yedge)) density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge, np.log10(density.transpose()), vmin=vmin_count, vmax=np.log10(max_count), cmap=colormap) label_string = frame_start.strftime('%H%M:%S') text_label = p.multiples.flat[i].text(xedge[0]-pad+x_range*.015, yedge[0]-pad+y_range*.015, label_string, color=grey_color, size=6) density_plot.set_rasterized(True) density_maxes.append(density.max()) total_counts.append(density.sum()) all_t.append(frame_start) print label_string, x.shape, density.max(), density.sum() color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap, norm=density_plot.norm, orientation='horizontal') # color_scale.set_label('count per pixel') color_scale.set_label('log10(count per pixel)') view_x = (xedge.min(), xedge.max()) view_y = (yedge.min(), yedge.max()) print 'making multiples', p.multiples.flat[0].axis(view_x+view_y) filename = '%s-%s_%s_%05.2fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, time_delta.seconds, image_type) filename = os.path.join(outpath, filename) if do_save: fig.savefig(filename, dpi=150) return fig, p, frame_start_times, filename print ' ... done'
class myApp(wx.Frame): def __init__(self, title="Haptic Waveform Designer v1.3"): wx.Frame.__init__(self, None, title=title, size=(1000, 750)) self.freq = 1 self.amp = 1 self.statusBar = self.CreateStatusBar(style=wx.BORDER_NONE) #self.t = [] #self.x = [] #self.wavRate = 44100 #self.samWidth = 3 #self.whichPlot = "builder" self.theUI() self.currentFile = "" self.statusBar.SetStatusText("working on new file") self.waveSegment = [] self.loadedInfo = 0 #pub.sendMessage("test", data = 0) def theUI(self): # define main panel mainPanel = wx.Panel(self) mainPanel.SetBackgroundColour("#ffffff") # All the statics font = wx.Font(36, family=wx.FONTFAMILY_SWISS, style=0, weight=90, underline=False, faceName="", encoding=wx.FONTENCODING_DEFAULT) # menubar menuBar = wx.MenuBar() fileMenu = wx.Menu() aboutMenu = wx.Menu() openFileMenu = fileMenu.Append(wx.ID_ANY, "&Load Waveform") saveFileMenu = fileMenu.Append(wx.ID_ANY, "&Save Waveform") exportFileMenu = fileMenu.Append(wx.ID_ANY, "&Export as .wav") aboutSubMenu = aboutMenu.Append(wx.ID_ANY, "&About") menuBar.Append(fileMenu, "&File") menuBar.Append(aboutMenu, "&About") self.SetMenuBar(menuBar) self.Bind(wx.EVT_MENU, self.onOpen, openFileMenu) self.Bind(wx.EVT_MENU, self.onSaveAs, saveFileMenu) self.Bind(wx.EVT_MENU, self.onExportAs, exportFileMenu) self.Bind(wx.EVT_MENU, self.About, aboutSubMenu) # Plot self.figure = Figure() self.axes = self.figure.add_subplot(111) self.axes.set_ylabel("Voltage") self.axes.set_xlabel("Time (ms)") self.axes.set_title("Waveform") self.canvas = FigureCanvas(mainPanel, -1, self.figure) self.axes.grid(alpha=0.5) self.whichPlot = "builder" #register for waveform plot updates pub.subscribe(self.update_plot, 'update_waveform_data') pub.subscribe(self.getWaveSegment, "waveSegmentData") wvfm_panel = waveform_panel.waveform_builder(mainPanel) lra_pnl = lra_panel.lra_panel(mainPanel) # declare sizers mainSizer = wx.BoxSizer(wx.VERTICAL) top_sizer = wx.BoxSizer(wx.HORIZONTAL) top_sizer.Add(self.canvas, 1, wx.EXPAND) top_sizer.Add(lra_pnl, 0, wx.TOP | wx.RIGHT, 60) mainSizer.Add(top_sizer, 1, wx.EXPAND) mainSizer.Add(wvfm_panel, 0, wx.ALL | wx.EXPAND, 10) # Put sizer to the main panel mainPanel.SetSizerAndFit(mainSizer) self.Center() def getWaveSegment(self, data): self.waveSegment = data def getLRACoeff(self, data): self.LRACoeff = data #update waveform plot with new data def update_plot(self, data): [time, values, low, high] = data self.figure.set_canvas(self.canvas) self.axes.clear() self.axes.set_ylabel("Voltage") self.axes.set_xlabel("Time (ms)") self.axes.set_title("Waveform") self.axes.grid(alpha=0.5) self.axes.plot(time, values) self.axes.axvspan(low, high, color='red', alpha=0.25) self.canvas.draw() self.dataToExport = values # Must update this def updateStatus(self): self.statusBar.SetStatusText("file loaded! Using info from {}".format( self.currentFile)) # Displays About Dialog def About(self, evt): text = """ A project for ME-396P @ UT Austin. Built by Knights of Ni!: Rahmat Ashari Colin Campell Peter Wang """ dlg = wx.MessageDialog(self, text, "Haptic Waveform Designer", wx.OK) dlg.ShowModal() dlg.Destroy() #export current waveform as .wav file def onExportAs(self, event): with wx.FileDialog(self, "Save .wav file", wildcard="WAV files (*.wav)|*.wav", style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog: # the user changed their mind if fileDialog.ShowModal() == wx.ID_CANCEL: return # save the current contents in the file pathname = fileDialog.GetPath() try: wavWrite(str(pathname), 44100, self.dataToExport) # in 1 data every 1 milisecond except IOError: wx.LogError( "Cannot export current data in file {}.".format(pathname)) #save current waveform segments as file (JSON) def onSaveAs(self, event): with wx.FileDialog(self, "Save workflow", wildcard="Waveform files (*.wvfm)|*.wvfm", style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog: # the user changed their mind if fileDialog.ShowModal() == wx.ID_CANCEL: return # save the current contents in the file pathname = fileDialog.GetPath() fileToSave = self.waveSegment try: with open(pathname, "w") as file: json.dump(fileToSave, file, indent=4, sort_keys=False) except IOError: wx.LogError( "Cannot save current data in file {}.".format(pathname)) #load waveform file (JSON) def onOpen(self, event): with wx.FileDialog(self, "Open workflow", wildcard="Waveform files (*.wvfm)|*.wvfm", style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) as fileDialog: if fileDialog.ShowModal() == wx.ID_CANCEL: return pathname = fileDialog.GetPath() try: self.currentFile = pathname with open(pathname, 'r') as file: self.loadedInfo = json.load(file) pub.sendMessage("sendLoadData", data=self.loadedInfo) self.updateStatus() except IOError: wx.LogError("something went wrong lol")
class PlotWidget(custom_result.ResultWidget): __gsignals__ = { 'button-press-event': 'override', 'button-release-event': 'override', 'expose-event': 'override', 'size-allocate': 'override', 'unrealize': 'override' } def __init__(self, result): custom_result.ResultWidget.__init__(self) figsize=(DEFAULT_FIGURE_WIDTH, DEFAULT_FIGURE_HEIGHT) self.figure = Figure(facecolor='white', figsize=figsize) self.canvas = _PlotResultCanvas(self.figure) self.axes = self.figure.add_subplot(111) self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE) self.cached_contents = None self.sidebar_width = -1 def do_expose_event(self, event): cr = self.window.cairo_create() if not self.cached_contents: self.cached_contents = cr.get_target().create_similar(cairo.CONTENT_COLOR, self.allocation.width, self.allocation.height) renderer = RendererCairo(self.figure.dpi) renderer.set_width_height(self.allocation.width, self.allocation.height) renderer.set_ctx_from_surface(self.cached_contents) self.figure.draw(renderer) # event.region is not bound: http://bugzilla.gnome.org/show_bug.cgi?id=487158 # gdk_context = gtk.gdk.CairoContext(renderer.ctx) # gdk_context.region(event.region) # gdk_context.clip() cr.set_source_surface(self.cached_contents, 0, 0) cr.paint() def do_size_allocate(self, allocation): if allocation.width != self.allocation.width or allocation.height != self.allocation.height: self.cached_contents = None gtk.DrawingArea.do_size_allocate(self, allocation) def do_unrealize(self): gtk.DrawingArea.do_unrealize(self) self.cached_contents = None def do_button_press_event(self, event): if event.button == 3: custom_result.show_menu(self, event, save_callback=self.__save) return True else: return True def do_button_release_event(self, event): return True def do_realize(self): gtk.DrawingArea.do_realize(self) cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR) self.window.set_cursor(cursor) def do_size_request(self, requisition): try: # matplotlib < 0.98 requisition.width = self.figure.bbox.width() requisition.height = self.figure.bbox.height() except TypeError: # matplotlib >= 0.98 requisition.width = self.figure.bbox.width requisition.height = self.figure.bbox.height def recompute_figure_size(self): width = (self.sidebar_width / self.figure.dpi) height = width / DEFAULT_ASPECT_RATIO self.figure.set_figwidth(width) self.figure.set_figheight(height) self.queue_resize() def sync_dpi(self, dpi): self.figure.set_dpi(dpi) if self.sidebar_width >= 0: self.recompute_figure_size() def set_sidebar_width(self, width): if self.sidebar_width == width: return self.sidebar_width = width if self.sidebar_width >= 0: self.recompute_figure_size() def sync_style(self, style): self.cached_contents = None matplotlib.rcParams['font.size'] = self.parent.style.font_desc.get_size() / pango.SCALE def __save(self, filename): # The save/restore here was added to matplotlib's after 0.90. We duplicate # it for compatibility with older versions. (The code would need modification # for 0.98 and newer, which is the reason for the particular version in the # check) version = [int(x) for x in matplotlib.__version__.split('.')] need_save = version[:2] < [0, 98] if need_save: orig_dpi = self.figure.dpi.get() orig_facecolor = self.figure.get_facecolor() orig_edgecolor = self.figure.get_edgecolor() try: self.canvas.print_figure(filename) finally: if need_save: self.figure.dpi.set(orig_dpi) self.figure.set_facecolor(orig_facecolor) self.figure.set_edgecolor(orig_edgecolor) self.figure.set_canvas(self.canvas)
class ModelView(wx.Panel): title = 'Profile' default_size = (600,400) def __init__( self, *args, **kw): wx.Panel.__init__(self, *args, **kw) # Fig self.fig = Figure( figsize = (1,1), dpi = 75, facecolor = 'white', edgecolor = 'white', ) # Canvas self.canvas = FigureCanvas(self, -1, self.fig) self.fig.set_canvas(self.canvas) # Axes self.axes = self.fig.add_axes( Subplot(self.fig, 111)) self.axes.set_autoscale_on(False) self.theta_axes = self.axes.twinx() self.theta_axes.set_autoscale_on(False) # Show toolbar or not? self.toolbar = NavigationToolbar2WxAgg( self.canvas ) self.toolbar.Show(True) # Create a figure manager to manage things self.figmgr = FigureManager( self.canvas, 1, self ) # Panel layout self.profile_selector_label = wx.StaticText(self, label="Sample") self.profile_selector = wx.Choice(self) self.profile_selector.Hide() self.profile_selector_label.Hide() self.Bind(wx.EVT_CHOICE, self.OnProfileSelect) self.sizer = wx.BoxSizer( wx.VERTICAL ) self.sizer.Add( self.canvas,1, border=2, flag= wx.LEFT|wx.TOP|wx.GROW) self.tbsizer = wx.BoxSizer(wx.HORIZONTAL) self.tbsizer.Add(self.toolbar,0,wx.ALIGN_CENTER_VERTICAL) self.tbsizer.AddSpacer(20) self.tbsizer.Add(self.profile_selector_label, 0, wx.ALIGN_CENTER_VERTICAL) self.tbsizer.AddSpacer(5) self.tbsizer.Add(self.profile_selector, 0, wx.ALIGN_CENTER_VERTICAL) self.sizer.Add(self.tbsizer) self.SetSizer( self.sizer) self.sizer.Fit(self) # Status bar frame = self.GetTopLevelParent() self.statusbar = frame.GetStatusBar() if self.statusbar is None: self.statusbar = frame.CreateStatusBar() status_update = lambda msg: self.statusbar.SetStatusText(msg) # Set the profile interactor self.profile = ProfileInteractor(self.axes,self.theta_axes, status_update=status_update) # Add context menu and keyboard support to canvas self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnContextMenu) #self.canvas.Bind(wx.EVT_LEFT_DOWN, lambda evt: self.canvas.SetFocus()) self.model = None self._need_set_model = self._need_redraw = False self.Bind(wx.EVT_SHOW, self.OnShow) def OnContextMenu(self,event): """ Forward the context menu invocation to profile, if profile exists. """ sx,sy = event.GetX(), event.GetY() #transform = self.axes.transData #data_x,data_y = pixel_to_data(transform, sx, self.fig.bbox.height-sy) popup = wx.Menu() item = popup.Append(wx.ID_ANY,'&Grid on/off', 'Toggle grid lines') wx.EVT_MENU(self, item.GetId(), lambda _: (self.axes.grid(),self.fig.canvas.draw_idle())) item = popup.Append(wx.ID_ANY,'&Rescale', 'Show entire profile') wx.EVT_MENU(self, item.GetId(), lambda _: (self.profile.reset_limits(),self.profile.draw_idle())) self.PopupMenu(popup, (sx,sy)) return False def OnProfileSelect(self, event): self.set_profile(*self.profiles[event.GetInt()]) # ==== Model view interface === def OnShow(self, event): if not event.Show: return #print "showing profile" if self._need_set_model: #print "-set model" self.set_model(self.model) elif self._need_redraw: #print "-redraw" self.profile.redraw() event.Skip() def get_state(self): return self.model def set_state(self, state): self.set_model(state) def set_model(self, model): self.model = model if not self.IsShown(): self._need_set_model = True else: self._need_set_model = self._need_redraw = False self._set_model() def update_model(self, model): #print "profile update model" if self.model != model: return if not IS_MAC and not self.IsShown(): self._need_set_model = True else: self._need_set_model = self._need_redraw = False self._set_model() def update_parameters(self, model): #print "profile update parameters" if self.model != model: return if not IS_MAC and not self.IsShown(): self._need_redraw = True else: self._need_redraw = False self.profile.redraw() # ============================================= def _set_model(self): """Initialize model by profile.""" self.profiles = [] def add_profiles(name, exp, idx): if isinstance(exp,MixedExperiment): for i,p in enumerate(exp.parts): self.profiles.append( (name+chr(ord("a")+i), p, idx) ) else: self.profiles.append( (name, exp, idx) ) if isinstance(self.model,MultiFitProblem): for i,p in enumerate(self.model.models): if hasattr(p.fitness,"reflectivity"): name = p.fitness.name if not name: name = "M%d"%(i+1) add_profiles(name, p.fitness, i) else: add_profiles("", self.model.fitness, -1) self.profile_selector.Clear() if len(self.profiles) > 1: self.profile_selector.AppendItems([k for k,_,_ in self.profiles]) self.profile_selector_label.Show() self.profile_selector.Show() self.profile_selector.SetSelection(0) else: self.profile_selector_label.Hide() self.profile_selector.Hide() self.set_profile(*self.profiles[0]) # update the figure self.profile.redraw(reset_limits=True) def set_profile(self, name, experiment, idx): # Turn the model into a user interface # It is the responsibility of the party that is indicating # that a redraw is necessary to clear the precalculated # parts of the view; otherwise the theory function calculator # is going to be triggered twice. This happens inside profile # before the profile is calculated. Note that the profile # panel will receive its own signal, which will cause the # profile interactor to draw itself again. We hope this isn't # too much of a problem. def signal_update(): """Notify other views that the model has changed""" signal.update_parameters(model=self.model) def force_recalc(): self.model.model_update() if isinstance(self.model,MultiFitProblem): self.model.set_active_model(idx) self.profile.set_experiment(experiment, force_recalc=force_recalc, signal_update=signal_update) def onPrinterSetup(self,event=None): self.canvas.Printer_Setup(event=event) def onPrinterPreview(self,event=None): self.canvas.Printer_Preview(event=event) def onPrint(self,event=None): self.canvas.Printer_Print(event=event) def OnSaveFigureMenu(self, evt ): """ Save the current figure as an image file """ dlg = wx.FileDialog(self, message="Save Figure As ...", defaultDir=os.getcwd(), defaultFile="", wildcard="PNG files (*.png)|*.png|BMP files (*.bmp)|*.bmp|All files (*.*)|*.*", style=wx.SAVE ) _val = dlg.ShowModal() if _val == wx.ID_CANCEL: return #Do nothing if _val == wx.ID_OK: outfile = dlg.GetPath() dlg.Destroy() # Save self.fig.savefig( outfile ) def GetToolBar(self): """ backend_wx call this function. KEEP it """ return None def OnPanelFrameClose(self, evt): """ On Close this Frame """ self.Destroy() evt.Skip() def OnCopyFigureMenu(self, evt ): """ Copy the current figure """ CopyImage(self.canvas) def CanShowContextMenu(self): return True def quit_on_error(self): numpy.seterr(all='raise') ProfileInteractor._debug = True BaseInteractor._debug = True
class ModelView(wx.Panel): title = 'Profile' default_size = (600, 400) def __init__(self, *args, **kw): wx.Panel.__init__(self, *args, **kw) # Fig self.fig = Figure( figsize=(1, 1), dpi=75, facecolor='white', edgecolor='white', ) # Canvas self.canvas = FigureCanvas(self, -1, self.fig) self.fig.set_canvas(self.canvas) # Axes self.axes = self.fig.add_axes(Subplot(self.fig, 111)) self.axes.set_autoscale_on(False) self.theta_axes = self.axes.twinx() self.theta_axes.set_autoscale_on(False) # Show toolbar or not? self.toolbar = NavigationToolbar2WxAgg(self.canvas) self.toolbar.Show(True) # Create a figure manager to manage things self.figmgr = FigureManager(self.canvas, 1, self) # Panel layout self.profile_selector_label = wx.StaticText(self, label="Sample") self.profile_selector = wx.Choice(self) self.profile_selector.Hide() self.profile_selector_label.Hide() self.Bind(wx.EVT_CHOICE, self.OnProfileSelect) self.sizer = wx.BoxSizer(wx.VERTICAL) self.sizer.Add(self.canvas, 1, border=2, flag=wx.LEFT | wx.TOP | wx.GROW) self.tbsizer = wx.BoxSizer(wx.HORIZONTAL) self.tbsizer.Add(self.toolbar, 0, wx.ALIGN_CENTER_VERTICAL) self.tbsizer.AddSpacer(20) self.tbsizer.Add(self.profile_selector_label, 0, wx.ALIGN_CENTER_VERTICAL) self.tbsizer.AddSpacer(5) self.tbsizer.Add(self.profile_selector, 0, wx.ALIGN_CENTER_VERTICAL) self.sizer.Add(self.tbsizer) self.SetSizer(self.sizer) self.sizer.Fit(self) # Status bar frame = self.GetTopLevelParent() self.statusbar = frame.GetStatusBar() if self.statusbar is None: self.statusbar = frame.CreateStatusBar() status_update = lambda msg: self.statusbar.SetStatusText(msg) # Set the profile interactor self.profile = ProfileInteractor(self.axes, self.theta_axes, status_update=status_update) # Add context menu and keyboard support to canvas self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnContextMenu) #self.canvas.Bind(wx.EVT_LEFT_DOWN, lambda evt: self.canvas.SetFocus()) self.model = None self._need_interactors = self._need_redraw = False self.Bind(wx.EVT_SHOW, self.OnShow) def OnContextMenu(self, event): """ Forward the context menu invocation to profile, if profile exists. """ sx, sy = event.GetX(), event.GetY() #transform = self.axes.transData #data_x,data_y = pixel_to_data(transform, sx, self.fig.bbox.height-sy) popup = wx.Menu() item = popup.Append(wx.ID_ANY, '&Grid on/off', 'Toggle grid lines') wx.EVT_MENU(self, item.GetId(), lambda _: (self.axes.grid(), self.fig.canvas.draw_idle())) item = popup.Append(wx.ID_ANY, '&Rescale', 'Show entire profile') wx.EVT_MENU( self, item.GetId(), lambda _: (self.profile.reset_limits(), self.profile.draw_idle())) self.PopupMenu(popup, (sx, sy)) return False def OnProfileSelect(self, event): self._set_profile(*self.profiles[event.GetInt()]) # ==== Model view interface === def OnShow(self, event): if not event.Show: return #print "showing profile" if self._need_redraw: self.redraw(reset_interactors=False, reset_limits=True) #event.Skip() def get_state(self): return self.model def set_state(self, state): self.set_model(state) def set_model(self, model): # print ">>>>>>> refl1d profile set model" self.model = model self.redraw(reset_interactors=True, reset_limits=True) def update_model(self, model): # print ">>>>>>> refl1d profile update model" if self.model == model: self.redraw(reset_interactors=False, reset_limits=True) def update_parameters(self, model): # print ">>>>>>> refl1d profile update parameters" if self.model == model: self.redraw(reset_interactors=False, reset_limits=False) def redraw(self, reset_interactors=False, reset_limits=False): if reset_interactors: self._need_interactors = True if not self.IsShown(): self._need_redraw = True return if self._need_interactors: self._create_interactors() self._set_profile(*self.profiles[0]) self._need_interactors = False self.profile.redraw(reset_limits=reset_limits) # ============================================= def _create_interactors(self): self.profiles = [] def add_profiles(name, exp, idx): if isinstance(exp, MixedExperiment): for i, p in enumerate(exp.parts): self.profiles.append((name + chr(ord("a") + i), p, idx)) else: self.profiles.append((name, exp, idx)) if isinstance(self.model, MultiFitProblem): for i, p in enumerate(self.model.models): if hasattr(p.fitness, "reflectivity"): name = p.fitness.name if not name: name = "M%d" % (i + 1) add_profiles(name, p.fitness, i) else: add_profiles("", self.model.fitness, -1) self.profile_selector.Clear() if len(self.profiles) > 1: self.profile_selector.AppendItems([k for k, _, _ in self.profiles]) self.profile_selector_label.Show() self.profile_selector.Show() self.profile_selector.SetSelection(0) else: self.profile_selector_label.Hide() self.profile_selector.Hide() def _set_profile(self, name, experiment, idx): # Turn the model into a user interface # It is the responsibility of the party that is indicating # that a redraw is necessary to clear the precalculated # parts of the view; otherwise the theory function calculator # is going to be triggered twice. This happens inside profile # before the profile is calculated. Note that the profile # panel will receive its own signal, which will cause the # profile interactor to draw itself again. We hope this isn't # too much of a problem. def signal_update(): """Notify other views that the model has changed""" signal.update_parameters(model=self.model) def force_recalc(): self.model.model_update() if isinstance(self.model, MultiFitProblem): self.model.set_active_model(idx) self.profile.set_experiment(experiment, force_recalc=force_recalc, signal_update=signal_update) def onPrinterSetup(self, event=None): self.canvas.Printer_Setup(event=event) def onPrinterPreview(self, event=None): self.canvas.Printer_Preview(event=event) def onPrint(self, event=None): self.canvas.Printer_Print(event=event) def OnSaveFigureMenu(self, evt): """ Save the current figure as an image file """ dlg = wx.FileDialog( self, message="Save Figure As ...", defaultDir=os.getcwd(), defaultFile="", wildcard= "PNG files (*.png)|*.png|BMP files (*.bmp)|*.bmp|All files (*.*)|*.*", style=wx.SAVE) _val = dlg.ShowModal() if _val == wx.ID_CANCEL: return #Do nothing if _val == wx.ID_OK: outfile = dlg.GetPath() dlg.Destroy() # Save self.fig.savefig(outfile) def GetToolBar(self): """ backend_wx call this function. KEEP it """ return None def OnPanelFrameClose(self, evt): """ On Close this Frame """ self.Destroy() evt.Skip() def OnCopyFigureMenu(self, evt): """ Copy the current figure """ CopyImage(self.canvas) def CanShowContextMenu(self): return True def quit_on_error(self): numpy.seterr(all='raise') ProfileInteractor._debug = True BaseInteractor._debug = True
class SquidGui( QMainWindow ): defaults = {} defaults.update(SquidAxon.defaults) defaults.update(ClampCircuit.defaults) defaults.update({'runtime': 50.0, 'simdt': 0.01, 'plotdt': 0.1, 'vclamp.holdingV': 0.0, 'vclamp.holdingT': 10.0, 'vclamp.prepulseV': 0.0, 'vclamp.prepulseT': 0.0, 'vclamp.clampV': 50.0, 'vclamp.clampT': 20.0, 'iclamp.baseI': 0.0, 'iclamp.firstI': 0.1, 'iclamp.firstT': 40.0, 'iclamp.firstD': 5.0, 'iclamp.secondI': 0.0, 'iclamp.secondT': 0.0, 'iclamp.secondD': 0.0 }) def __init__(self, *args): QMainWindow.__init__(self, *args) self.squid_setup = SquidSetup() self._plotdt = SquidGui.defaults['plotdt'] self._plot_dict = defaultdict(list) self.setWindowTitle('Squid Axon simulation') self.setDockNestingEnabled(True) self._createRunControl() self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock) self._runControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures) self._createChannelControl() self._channelCtrlBox.setWindowTitle('Channel properties') self._channelControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._channelControlDock) self._createElectronicsControl() self._electronicsDock.setFeatures(QDockWidget.AllDockWidgetFeatures) self._electronicsDock.setWindowTitle('Electronics') self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock) self._createPlotWidget() self.setCentralWidget(self._plotWidget) self._createStatePlotWidget() self._createHelpMessage() self._helpWindow.setVisible(False) self._statePlotWidget.setWindowFlags(QtCore.Qt.Window) self._statePlotWidget.setWindowTitle('State plot') self._initActions() self._createRunToolBar() self._createPlotToolBar() def getFloatInput(self, widget, name): try: return float(str(widget.text())) except ValueError: QMessageBox.critical(self, 'Invalid input', 'Please enter a valid number for {}'.format(name)) raise def _createPlotWidget(self): self._plotWidget = QWidget() self._plotFigure = Figure() self._plotCanvas = FigureCanvas(self._plotFigure) self._plotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._plotCanvas.updateGeometry() self._plotCanvas.setParent(self._plotWidget) self._plotCanvas.mpl_connect('scroll_event', self._onScroll) self._plotFigure.set_canvas(self._plotCanvas) # Vm and command voltage go in the same subplot self._vm_axes = self._plotFigure.add_subplot(2,2,1, title='Membrane potential') self._vm_axes.set_ylim(-20.0, 120.0) # Channel conductances go to the same subplot self._g_axes = self._plotFigure.add_subplot(2,2,2, title='Channel conductance') self._g_axes.set_ylim(0.0, 0.5) # Injection current for Vclamp/Iclamp go to the same subplot self._im_axes = self._plotFigure.add_subplot(2,2,3, title='Injection current') self._im_axes.set_ylim(-0.5, 0.5) # Channel currents go to the same subplot self._i_axes = self._plotFigure.add_subplot(2,2,4, title='Channel current') self._i_axes.set_ylim(-10, 10) for axis in self._plotFigure.axes: axis.set_autoscale_on(False) layout = QVBoxLayout() layout.addWidget(self._plotCanvas) self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget) layout.addWidget(self._plotNavigator) self._plotWidget.setLayout(layout) def _createStatePlotWidget(self): self._statePlotWidget = QWidget() self._statePlotFigure = Figure() self._statePlotCanvas = FigureCanvas(self._statePlotFigure) self._statePlotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._statePlotCanvas.updateGeometry() self._statePlotCanvas.setParent(self._statePlotWidget) self._statePlotFigure.set_canvas(self._statePlotCanvas) self._statePlotFigure.subplots_adjust(hspace=0.5) self._statePlotAxes = self._statePlotFigure.add_subplot(2,1,1, title='State plot') self._state_plot, = self._statePlotAxes.plot([], [], label='state') self._activationParamAxes = self._statePlotFigure.add_subplot(2,1,2, title='H-H activation parameters vs time') self._activationParamAxes.set_xlabel('Time (ms)') #for axis in self._plotFigure.axes: # axis.autoscale(False) self._stateplot_xvar_label = QLabel('Variable on X-axis') self._stateplot_xvar_combo = QComboBox() self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h']) self._stateplot_xvar_combo.setCurrentText('V') self._stateplot_xvar_combo.setEditable(False) self._stateplot_xvar_combo.currentIndexChanged[str].connect( self._statePlotXSlot ) self._stateplot_yvar_label = QLabel('Variable on Y-axis') self._stateplot_yvar_combo = QComboBox() self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h']) self._stateplot_yvar_combo.setCurrentIndex(2) self._stateplot_yvar_combo.setEditable(False) self._stateplot_yvar_combo.currentIndexChanged[str].connect(self._statePlotYSlot) self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas, self._statePlotWidget) frame = QFrame() frame.setFrameStyle(QFrame.StyledPanel + QFrame.Raised) layout = QHBoxLayout() layout.addWidget(self._stateplot_xvar_label) layout.addWidget(self._stateplot_xvar_combo) layout.addWidget(self._stateplot_yvar_label) layout.addWidget(self._stateplot_yvar_combo) frame.setLayout(layout) self._closeStatePlotAction = QAction('Close', self) self._closeStatePlotAction.triggered.connect(self._statePlotWidget.close) self._closeStatePlotButton = QToolButton() self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction) layout = QVBoxLayout() layout.addWidget(frame) layout.addWidget(self._statePlotCanvas) layout.addWidget(self._statePlotNavigator) layout.addWidget(self._closeStatePlotButton) self._statePlotWidget.setLayout(layout) # Setting the close event so that when the help window is # closed the ``State plot`` button becomes unchecked self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(False) def _createRunControl(self): self._runControlBox = QGroupBox(self) self._runControlBox.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self._runTimeLabel = QLabel("Run time (ms)", self._runControlBox) self._simTimeStepLabel = QLabel("Simulation time step (ms)", self._runControlBox) self._runTimeEdit = QLineEdit('%g' % (SquidGui.defaults['runtime']), self._runControlBox) set_default_line_edit_size(self._runTimeEdit) self._simTimeStepEdit = QLineEdit('%g' % (SquidGui.defaults['simdt']), self._runControlBox) set_default_line_edit_size(self._simTimeStepEdit) layout = QGridLayout() layout.addWidget(self._runTimeLabel, 0, 0) layout.addWidget(self._runTimeEdit, 0, 1) layout.addWidget(self._simTimeStepLabel, 1, 0) layout.addWidget(self._simTimeStepEdit, 1, 1) layout.setColumnStretch(2, 1.0) layout.setRowStretch(2, 1.0) self._runControlBox.setLayout(layout) self._runControlDock = QDockWidget('Simulation', self) self._runControlDock.setWidget(self._runControlBox) def _createChannelControl(self): self._channelControlDock = QDockWidget('Channels', self) self._channelCtrlBox = QGroupBox(self) self._naConductanceToggle = QCheckBox('Block Na+ channel', self._channelCtrlBox) self._naConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_NaChan)) self._kConductanceToggle = QCheckBox('Block K+ channel', self._channelCtrlBox) self._kConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_KChan)) self._kOutLabel = QLabel('[K+]out (mM)', self._channelCtrlBox) self._kOutEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.K_out), self._channelCtrlBox) self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._kOutEdit) self._naOutLabel = QLabel('[Na+]out (mM)', self._channelCtrlBox) self._naOutEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.Na_out), self._channelCtrlBox) self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._naOutEdit) self._kInLabel = QLabel('[K+]in (mM)', self._channelCtrlBox) self._kInEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.K_in), self._channelCtrlBox) self._kInEdit.setToolTip(tooltip_Nernst) self._naInLabel = QLabel('[Na+]in (mM)', self._channelCtrlBox) self._naInEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.Na_in), self._channelCtrlBox) self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) self._temperatureLabel = QLabel('Temperature (C)', self._channelCtrlBox) self._temperatureEdit = QLineEdit('%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN), self._channelCtrlBox) self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst)) set_default_line_edit_size(self._temperatureEdit) for child in self._channelCtrlBox.children(): if isinstance(child, QLineEdit): set_default_line_edit_size(child) layout = QGridLayout(self._channelCtrlBox) layout.addWidget(self._naConductanceToggle, 0, 0) layout.addWidget(self._kConductanceToggle, 1, 0) layout.addWidget(self._naOutLabel, 2, 0) layout.addWidget(self._naOutEdit, 2, 1) layout.addWidget(self._naInLabel, 3, 0) layout.addWidget(self._naInEdit, 3, 1) layout.addWidget(self._kOutLabel, 4, 0) layout.addWidget(self._kOutEdit, 4, 1) layout.addWidget(self._kInLabel, 5, 0) layout.addWidget(self._kInEdit, 5, 1) layout.addWidget(self._temperatureLabel, 6, 0) layout.addWidget(self._temperatureEdit, 6, 1) layout.setRowStretch(7, 1.0) self._channelCtrlBox.setLayout(layout) self._channelControlDock.setWidget(self._channelCtrlBox) return self._channelCtrlBox def __get_stateplot_data(self, name): data = [] if name == 'V': data = self.squid_setup.vm_table.vector elif name == 'm': data = self.squid_setup.m_table.vector elif name == 'h': data = self.squid_setup.h_table.vector elif name == 'n': data = self.squid_setup.n_table.vector else: raise ValueError('Unrecognized selection: %s' % name ) return numpy.asarray(data) def _statePlotYSlot(self, selectedItem): ydata = self.__get_stateplot_data(str(selectedItem)) self._state_plot.set_ydata(ydata) self._statePlotAxes.set_ylabel(selectedItem) if str(selectedItem) == 'V': self._statePlotAxes.set_ylim(-20, 120) else: self._statePlotAxes.set_ylim(0, 1) self._statePlotCanvas.draw() def _statePlotXSlot(self, selectedItem): xdata = self.__get_stateplot_data(str(selectedItem)) self._state_plot.set_xdata(xdata) self._statePlotAxes.set_xlabel(selectedItem) if str(selectedItem) == 'V': self._statePlotAxes.set_xlim(-20, 120) else: self._statePlotAxes.set_xlim(0, 1) self._statePlotCanvas.draw() def _createElectronicsControl(self): """Creates a tabbed widget of voltage clamp and current clamp controls""" self._electronicsTab = QTabWidget(self) self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp') self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp') self._electronicsDock = QDockWidget(self) self._electronicsDock.setWidget(self._electronicsTab) def _getVClampCtrlBox(self): vClampPanel = QGroupBox(self) self._vClampCtrlBox = vClampPanel self._holdingVLabel = QLabel("Holding Voltage (mV)", vClampPanel) self._holdingVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel) self._holdingTimeLabel = QLabel("Holding Time (ms)", vClampPanel) self._holdingTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel) self._prePulseVLabel = QLabel("Pre-pulse Voltage (mV)", vClampPanel) self._prePulseVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel) self._prePulseTimeLabel = QLabel("Pre-pulse Time (ms)", vClampPanel) self._prePulseTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel) self._clampVLabel = QLabel("Clamp Voltage (mV)", vClampPanel) self._clampVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel) self._clampTimeLabel = QLabel("Clamp Time (ms)", vClampPanel) self._clampTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel) for child in vClampPanel.children(): if isinstance(child, QLineEdit): set_default_line_edit_size(child) layout = QGridLayout(vClampPanel) layout.addWidget(self._holdingVLabel, 0, 0) layout.addWidget(self._holdingVEdit, 0, 1) layout.addWidget(self._holdingTimeLabel, 1, 0) layout.addWidget(self._holdingTimeEdit, 1, 1) layout.addWidget(self._prePulseVLabel, 2, 0) layout.addWidget(self._prePulseVEdit, 2, 1) layout.addWidget(self._prePulseTimeLabel,3,0) layout.addWidget(self._prePulseTimeEdit, 3, 1) layout.addWidget(self._clampVLabel, 4, 0) layout.addWidget(self._clampVEdit, 4, 1) layout.addWidget(self._clampTimeLabel, 5, 0) layout.addWidget(self._clampTimeEdit, 5, 1) layout.setRowStretch(6, 1.0) vClampPanel.setLayout(layout) return self._vClampCtrlBox def _getIClampCtrlBox(self): iClampPanel = QGroupBox(self) self._iClampCtrlBox = iClampPanel self._baseCurrentLabel = QLabel("Base Current Level (uA)",iClampPanel) self._baseCurrentEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.baseI']),iClampPanel) self._firstPulseLabel = QLabel("First Pulse Current (uA)", iClampPanel) self._firstPulseEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel) self._firstDelayLabel = QLabel("First Onset Delay (ms)", iClampPanel) self._firstDelayEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstD']),iClampPanel) self._firstPulseWidthLabel = QLabel("First Pulse Width (ms)", iClampPanel) self._firstPulseWidthEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel) self._secondPulseLabel = QLabel("Second Pulse Current (uA)", iClampPanel) self._secondPulseEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel) self._secondDelayLabel = QLabel("Second Onset Delay (ms)", iClampPanel) self._secondDelayEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondD']),iClampPanel) self._secondPulseWidthLabel = QLabel("Second Pulse Width (ms)", iClampPanel) self._secondPulseWidthEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel) self._pulseMode = QComboBox(iClampPanel) self._pulseMode.addItem("Single Pulse") self._pulseMode.addItem("Pulse Train") for child in iClampPanel.children(): if isinstance(child, QLineEdit): set_default_line_edit_size(child) layout = QGridLayout(iClampPanel) layout.addWidget(self._baseCurrentLabel, 0, 0) layout.addWidget(self._baseCurrentEdit, 0, 1) layout.addWidget(self._firstPulseLabel, 1, 0) layout.addWidget(self._firstPulseEdit, 1, 1) layout.addWidget(self._firstDelayLabel, 2, 0) layout.addWidget(self._firstDelayEdit, 2, 1) layout.addWidget(self._firstPulseWidthLabel, 3, 0) layout.addWidget(self._firstPulseWidthEdit, 3, 1) layout.addWidget(self._secondPulseLabel, 4, 0) layout.addWidget(self._secondPulseEdit, 4, 1) layout.addWidget(self._secondDelayLabel, 5, 0) layout.addWidget(self._secondDelayEdit, 5, 1) layout.addWidget(self._secondPulseWidthLabel, 6, 0) layout.addWidget(self._secondPulseWidthEdit, 6, 1) layout.addWidget(self._pulseMode, 7, 0, 1, 2) layout.setRowStretch(8, 1.0) # layout.setSizeConstraint(QLayout.SetFixedSize) iClampPanel.setLayout(layout) return self._iClampCtrlBox def _overlayPlots(self, overlay): if not overlay: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): title = axis.get_title() axis.clear() axis.set_title(title) suffix = '' else: suffix = '_%d' % (len(self._plot_dict['vm'])) self._vm_axes.set_xlim(0.0, self._runtime) self._g_axes.set_xlim(0.0, self._runtime) self._im_axes.set_xlim(0.0, self._runtime) self._i_axes.set_xlim(0.0, self._runtime) self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s'%(suffix)) self._plot_dict['vm'].append(self._vm_plot) self._command_plot, = self._vm_axes.plot([], [], label='command%s'%(suffix)) self._plot_dict['command'].append(self._command_plot) # Channel conductances go to the same subplot self._gna_plot, = self._g_axes.plot([], [], label='Na%s'%(suffix)) self._plot_dict['gna'].append(self._gna_plot) self._gk_plot, = self._g_axes.plot([], [], label='K%s'%(suffix)) self._plot_dict['gk'].append(self._gk_plot) # Injection current for Vclamp/Iclamp go to the same subplot self._iclamp_plot, = self._im_axes.plot([], [], label='Iclamp%s'%(suffix)) self._vclamp_plot, = self._im_axes.plot([], [], label='Vclamp%s'%(suffix)) self._plot_dict['iclamp'].append(self._iclamp_plot) self._plot_dict['vclamp'].append(self._vclamp_plot) # Channel currents go to the same subplot self._ina_plot, = self._i_axes.plot([], [], label='Na%s'%(suffix)) self._plot_dict['ina'].append(self._ina_plot) self._ik_plot, = self._i_axes.plot([], [], label='K%s'%(suffix)) self._plot_dict['ik'].append(self._ik_plot) # self._i_axes.legend() # State plots self._state_plot, = self._statePlotAxes.plot([], [], label='state%s'%(suffix)) self._plot_dict['state'].append(self._state_plot) self._m_plot, = self._activationParamAxes.plot([],[], label='m%s'%(suffix)) self._h_plot, = self._activationParamAxes.plot([], [], label='h%s'%(suffix)) self._n_plot, = self._activationParamAxes.plot([], [], label='n%s'%(suffix)) self._plot_dict['m'].append(self._m_plot) self._plot_dict['h'].append(self._h_plot) self._plot_dict['n'].append(self._n_plot) if self._showLegendAction.isChecked(): for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend() def _updateAllPlots(self): self._updatePlots() self._updateStatePlot() def _updatePlots(self): if len(self.squid_setup.vm_table.vector) <= 0: return vm = numpy.asarray(self.squid_setup.vm_table.vector) cmd = numpy.asarray(self.squid_setup.cmd_table.vector) ik = numpy.asarray(self.squid_setup.ik_table.vector) ina = numpy.asarray(self.squid_setup.ina_table.vector) iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector) vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector) gk = numpy.asarray(self.squid_setup.gk_table.vector) gna = numpy.asarray(self.squid_setup.gna_table.vector) time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm)) self._vm_plot.set_data(time_series, vm) time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd)) self._command_plot.set_data(time_series, cmd) time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik)) self._ik_plot.set_data(time_series, ik) time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina)) self._ina_plot.set_data(time_series, ina) time_series = numpy.linspace(0, self._plotdt * len(iclamp), len(iclamp)) self._iclamp_plot.set_data(time_series, iclamp) time_series = numpy.linspace(0, self._plotdt * len(vclamp), len(vclamp)) self._vclamp_plot.set_data(time_series, vclamp) time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk)) self._gk_plot.set_data(time_series, gk) time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna)) self._gna_plot.set_data(time_series, gna) # self._vm_axes.margins(y=0.1) # self._g_axes.margin(y=0.1) # self._im_axes.margins(y=0.1) # self._i_axes.margins(y=0.1) if self._autoscaleAction.isChecked(): for axis in self._plotFigure.axes: axis.relim() axis.margins(0.1, 0.1) axis.autoscale_view(tight=True) else: self._vm_axes.set_ylim(-20.0, 120.0) self._g_axes.set_ylim(0.0, 0.5) self._im_axes.set_ylim(-0.5, 0.5) self._i_axes.set_ylim(-10, 10) self._vm_axes.set_xlim(0.0, time_series[-1]) self._g_axes.set_xlim(0.0, time_series[-1]) self._im_axes.set_xlim(0.0, time_series[-1]) self._i_axes.set_xlim(0.0, time_series[-1]) self._plotCanvas.draw() def _updateStatePlot(self): if len(self.squid_setup.vm_table.vector) <= 0: return sx = str(self._stateplot_xvar_combo.currentText()) sy = str(self._stateplot_yvar_combo.currentText()) xdata = self.__get_stateplot_data(sx) ydata = self.__get_stateplot_data(sy) minlen = min(len(xdata), len(ydata)) self._state_plot.set_data(xdata[:minlen], ydata[:minlen]) self._statePlotAxes.set_xlabel(sx) self._statePlotAxes.set_ylabel(sy) if sx == 'V': self._statePlotAxes.set_xlim(-20, 120) else: self._statePlotAxes.set_xlim(0, 1) if sy == 'V': self._statePlotAxes.set_ylim(-20, 120) else: self._statePlotAxes.set_ylim(0, 1) self._activationParamAxes.set_xlim(0, self._runtime) m = self.__get_stateplot_data('m') n = self.__get_stateplot_data('n') h = self.__get_stateplot_data('h') time_series = numpy.linspace(0, self._plotdt*len(m), len(m)) self._m_plot.set_data(time_series, m) time_series = numpy.linspace(0, self._plotdt*len(h), len(h)) self._h_plot.set_data(time_series, h) time_series = numpy.linspace(0, self._plotdt*len(n), len(n)) self._n_plot.set_data(time_series, n) if self._autoscaleAction.isChecked(): for axis in self._statePlotFigure.axes: axis.relim() axis.set_autoscale_on(True) axis.autoscale_view(True) self._statePlotCanvas.draw() def _runSlot(self): if moose.isRunning(): print('Stopping simulation in progress ...') moose.stop() self._runtime = self.getFloatInput(self._runTimeEdit, self._runTimeLabel.text()) self._overlayPlots(self._overlayAction.isChecked()) self._simdt = self.getFloatInput(self._simTimeStepEdit, self._simTimeStepLabel.text()) clampMode = None singlePulse = True if self._electronicsTab.currentWidget() == self._vClampCtrlBox: clampMode = 'vclamp' baseLevel = self.getFloatInput(self._holdingVEdit, self._holdingVLabel.text()) firstDelay = self.getFloatInput(self._holdingTimeEdit, self._holdingTimeLabel.text()) firstWidth = self.getFloatInput(self._prePulseTimeEdit, self._prePulseTimeLabel.text()) firstLevel = self.getFloatInput(self._prePulseVEdit, self._prePulseVLabel.text()) secondDelay = firstWidth secondWidth = self.getFloatInput(self._clampTimeEdit, self._clampTimeLabel.text()) secondLevel = self.getFloatInput(self._clampVEdit, self._clampVLabel.text()) if not self._autoscaleAction.isChecked(): self._im_axes.set_ylim(-10.0, 10.0) else: clampMode = 'iclamp' baseLevel = self.getFloatInput(self._baseCurrentEdit, self._baseCurrentLabel.text()) firstDelay = self.getFloatInput(self._firstDelayEdit, self._firstDelayLabel.text()) firstWidth = self.getFloatInput(self._firstPulseWidthEdit, self._firstPulseWidthLabel.text()) firstLevel = self.getFloatInput(self._firstPulseEdit, self._firstPulseLabel.text()) secondDelay = self.getFloatInput(self._secondDelayEdit, self._secondDelayLabel.text()) secondLevel = self.getFloatInput(self._secondPulseEdit, self._secondPulseLabel.text()) secondWidth = self.getFloatInput(self._secondPulseWidthEdit, self._secondPulseWidthLabel.text()) singlePulse = (self._pulseMode.currentIndex() == 0) if not self._autoscaleAction.isChecked(): self._im_axes.set_ylim(-0.4, 0.4) self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel, firstDelay=firstDelay, firstWidth=firstWidth, firstLevel=firstLevel, secondDelay=secondDelay, secondWidth=secondWidth, secondLevel=secondLevel, singlePulse=singlePulse) if self._kConductanceToggle.isChecked(): self.squid_setup.squid_axon.specific_gK = 0.0 else: self.squid_setup.squid_axon.specific_gK = SquidAxon.defaults['specific_gK'] if self._naConductanceToggle.isChecked(): self.squid_setup.squid_axon.specific_gNa = 0.0 else: self.squid_setup.squid_axon.specific_gNa = SquidAxon.defaults['specific_gNa'] self.squid_setup.squid_axon.celsius = self.getFloatInput(self._temperatureEdit, self._temperatureLabel.text()) self.squid_setup.squid_axon.K_out = self.getFloatInput(self._kOutEdit, self._kOutLabel.text()) self.squid_setup.squid_axon.Na_out = self.getFloatInput(self._naOutEdit, self._naOutLabel.text()) self.squid_setup.squid_axon.K_in = self.getFloatInput(self._kInEdit, self._kInLabel.text()) self.squid_setup.squid_axon.Na_in = self.getFloatInput(self._naInEdit, self._naInLabel.text()) self.squid_setup.squid_axon.updateEk() self.squid_setup.schedule(self._simdt, self._plotdt, clampMode) # The following line is for use with Qthread self.squid_setup.run(self._runtime) self._updateAllPlots() def _toggleDocking(self, on): self._channelControlDock.setFloating(on) self._electronicsDock.setFloating(on) self._runControlDock.setFloating(on) def _restoreDocks(self): self._channelControlDock.setVisible(True) self._electronicsDock.setVisible(True) self._runControlDock.setVisible(True) def _initActions(self): self._runAction = QAction(self.tr('Run'), self) self._runAction.setShortcut(self.tr('F5')) self._runAction.setToolTip('Run simulation (F5)') self._runAction.triggered.connect( self._runSlot) self._resetToDefaultsAction = QAction(self.tr('Restore defaults'), self) self._resetToDefaultsAction.setToolTip('Reset all settings to their default values') self._resetToDefaultsAction.triggered.connect( self._useDefaults) self._showLegendAction = QAction(self.tr('Display legend'), self) self._showLegendAction.setCheckable(True) self._showLegendAction.toggled.connect(self._showLegend) self._showStatePlotAction = QAction(self.tr('State plot'), self) self._showStatePlotAction.setCheckable(True) self._showStatePlotAction.setChecked(False) self._showStatePlotAction.toggled.connect(self._statePlotWidget.setVisible) self._autoscaleAction = QAction(self.tr('Auto-scale plots'), self) self._autoscaleAction.setCheckable(True) self._autoscaleAction.setChecked(False) self._autoscaleAction.toggled.connect(self._autoscale) self._overlayAction = QAction('Overlay plots', self) self._overlayAction.setCheckable(True) self._overlayAction.setChecked(False) self._dockAction = QAction('Undock all', self) self._dockAction.setCheckable(True) self._dockAction.setChecked(False) # self._dockAction.toggle.connect( self._toggleDocking) self._restoreDocksAction = QAction('Show all', self) self._restoreDocksAction.triggered.connect( self._restoreDocks) self._quitAction = QAction(self.tr('&Quit'), self) self._quitAction.setShortcut(self.tr('Ctrl+Q')) self._quitAction.triggered.connect(qApp.closeAllWindows) def _createRunToolBar(self): self._simToolBar = self.addToolBar(self.tr('Simulation control')) self._simToolBar.addAction(self._quitAction) self._simToolBar.addAction(self._runAction) self._simToolBar.addAction(self._resetToDefaultsAction) self._simToolBar.addAction(self._dockAction) self._simToolBar.addAction(self._restoreDocksAction) def _createPlotToolBar(self): self._plotToolBar = self.addToolBar(self.tr('Plotting control')) self._plotToolBar.addAction(self._showLegendAction) self._plotToolBar.addAction(self._autoscaleAction) self._plotToolBar.addAction(self._overlayAction) self._plotToolBar.addAction(self._showStatePlotAction) self._plotToolBar.addAction(self._helpAction) self._plotToolBar.addAction(self._helpBiophysicsAction) def _showLegend(self, on): if on: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend().set_visible(True) else: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.legend().set_visible(False) self._plotCanvas.draw() self._statePlotCanvas.draw() def _autoscale(self, on): if on: for axis in (self._plotFigure.axes + self._statePlotFigure.axes): axis.relim() axis.set_autoscale_on(True) axis.autoscale_view(True) else: for axis in self._plotFigure.axes: axis.set_autoscale_on(False) self._vm_axes.set_ylim(-20.0, 120.0) self._g_axes.set_ylim(0.0, 0.5) self._im_axes.set_ylim(-0.5, 0.5) self._i_axes.set_ylim(-10, 10) self._plotCanvas.draw() self._statePlotCanvas.draw() def _useDefaults(self): self._runTimeEdit.setText('%g' % (self.defaults['runtime'])) self._simTimeStepEdit.setText('%g' % (self.defaults['simdt'])) self._overlayAction.setChecked(False) self._naConductanceToggle.setChecked(False) self._kConductanceToggle.setChecked(False) self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out'])) self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out'])) self._kInEdit.setText('%g' % (SquidGui.defaults['K_in'])) self._naInEdit.setText('%g' % (SquidGui.defaults['Na_in'])) self._temperatureEdit.setText('%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN)) self._holdingVEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingV'])) self._holdingTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingT'])) self._prePulseVEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseV'])) self._prePulseTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseT'])) self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV'])) self._clampTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.clampT'])) self._baseCurrentEdit.setText('%g' % (SquidGui.defaults['iclamp.baseI'])) self._firstPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.firstI'])) self._firstDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.firstD'])) self._firstPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.firstT'])) self._secondPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.secondI'])) self._secondDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.secondD'])) self._secondPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.secondT'])) self._pulseMode.setCurrentIndex(0) def _onScroll(self, event): if event.inaxes is None: return axes = event.inaxes zoom = 0.0 if event.button == 'up': zoom = -1.0 elif event.button == 'down': zoom = 1.0 if zoom != 0.0: self._plotNavigator.push_current() axes.get_xaxis().zoom(zoom) axes.get_yaxis().zoom(zoom) self._plotCanvas.draw() def closeEvent(self, event): qApp.closeAllWindows() def _showBioPhysicsHelp(self): self._createHelpMessage() self._helpMessageText.setText('<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' % (tooltip_Nernst, tooltip_Erest, tooltip_KChan, tooltip_NaChan, tooltip_Im)) self._helpWindow.setVisible(True) def _showRunningHelp(self): self._createHelpMessage() self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL)) self._helpWindow.setVisible(True) def _createHelpMessage(self): if hasattr(self, '_helpWindow'): return self._helpWindow = QWidget() self._helpWindow.setWindowFlags(QtCore.Qt.Window) layout = QVBoxLayout() self._helpWindow.setLayout(layout) self._helpMessageArea = QScrollArea() self._helpMessageText = QTextBrowser() self._helpMessageText.setOpenExternalLinks(True) self._helpMessageArea.setWidget(self._helpMessageText) layout.addWidget(self._helpMessageText) self._squidGuiPath = os.path.dirname(os.path.abspath(__file__)) self._helpBaseURL = os.path.join(self._squidGuiPath,'help.html') self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL)) self._helpMessageText.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._helpMessageArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._helpMessageText.setMinimumSize(800, 600) self._closeHelpAction = QAction('Close', self) self._closeHelpAction.triggered.connect(self._helpWindow.close) # Setting the close event so that the ``Help`` button is # unchecked when the help window is closed self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked(False) self._helpTOCAction = QAction('Help running demo', self) self._helpTOCAction.triggered.connect( self._jumpToHelpTOC) # This panel is for putting two buttons using horizontal # layout panel = QFrame() panel.setFrameStyle(QFrame.StyledPanel + QFrame.Raised) layout.addWidget(panel) layout = QHBoxLayout() panel.setLayout(layout) self._helpAction = QAction('Help running', self) self._helpAction.triggered.connect(self._showRunningHelp) self._helpBiophysicsAction = QAction('Help biophysics', self) self._helpBiophysicsAction.triggered.connect(self._showBioPhysicsHelp) self._helpTOCButton = QToolButton() self._helpTOCButton.setDefaultAction(self._helpTOCAction) self._helpBiophysicsButton = QToolButton() self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction) layout.addWidget(self._helpTOCButton) layout.addWidget(self._helpBiophysicsButton) self._closeHelpButton = QToolButton() self._closeHelpButton.setDefaultAction(self._closeHelpAction) layout.addWidget(self._closeHelpButton) def _jumpToHelpTOC(self): self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
def plotALot( self, gene_list, # list of genes to plot savedir="", title="images", grid=(4, 8), # grid to plot for each figure figsize=(16, 9), dpi=300, ): """ plot a lot of intensity maps from a list of genes """ genes_per_plot = grid[0] * grid[1] num_plots, remainder = divmod(len(gene_list), (genes_per_plot)) # add an extra plot if # number of genes is not perfectly divisible by number of plots if remainder != 0: num_plots += 1 for img_num in range(len(self.img_arrays)): # set up index for number of genes already plotted # ------------------------------------------------ reordered_idx = 0 for plot_num in range(num_plots): # set up figure canvas # -------------------- fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) for gridpos in range(genes_per_plot): # check if we have reached end of gene list # ----------------------------------------- if reordered_idx == len(gene_list) - 1: break # create temporary axes reference # ------------------------------- ax = fig.add_subplot(grid[0], grid[1], gridpos + 1) # plot the current gene # --------------------- array_idx = self.gene_index_dict[gene_list[reordered_idx]] ax.imshow(self.img_arrays[img_num][array_idx, ...], cmap="hot") ax.set_title(gene_list[reordered_idx]) # increment gene index # -------------------- reordered_idx += 1 fig.suptitle(title + f"\n{self.hdf5_file_list[img_num]}" f"\n({plot_num + 1} of {num_plots})") fig.tight_layout(rect=(0, 0, 1, .94)) # save the plot # ------------- savename = ( f"image_{img_num + 1}_{title.replace(' ','_')}" f"_{plot_num + 1}of{num_plots}_{self.time_str}.png") if not os.path.exists(savedir): os.mkdir(savedir) fig.savefig(os.path.join(savedir, savename), dpi=dpi) # close the canvas # ---------------- canvas.close() fig.clear()
from matplotlib.figure import Figure from matplotlib.backends.backend_svg import new_figure_manager def graph(fig): t1 = [1, 2, 3, 4, 5] ax = fig.add_subplot(1, 1, 1) ax.plot(t1, t1, 'bo') fig = Figure() graph(fig) manager = new_figure_manager(1, dpi=72) manager.canvas.figure = fig fig.set_canvas(manager.canvas) fig.savefig("dist/a.svg")
def show_fit_at_position(mcmc_set, fit_value, position, fit_name): """Create the result page showing the fit quality at the given position. Parameters ---------- mcmc_set : MCMCSet object The set of MCMC chains fit_value : float The quality of fit at the given position. position : numpy.array Array of (log10-transformed) parameter values at the given position. fit_name : string A shorthand name for the fit position, e.g., "max_likelihood". Should conform to rules of Python variable naming (no spaces, doesn't start with a number, etc.). Returns ------- A result object containing the fit value and the link to the accompanying HTML plot page, if any. """ # If the MCMC object does not have a fit_plotting_function defined # (for example, if it is a base MCMC object), then don't create a # plot for visualization. if not hasattr(mcmc_set.chains[0], 'fit_plotting_function'): return Result(fit_value, None) # Prepare html for page showing plots at position html_str = "<html><head><title>Simulation of %s " \ "with %s parameter values</title></head>\n" \ % (mcmc_set.name, fit_name) html_str += "<body><p>Simulation of %s with %s " \ "parameter values</p>\n" % (mcmc_set.name, fit_name) # Show the plot vs. the data at the position fig = mcmc_set.chains[0].fit_plotting_function(position=position) img_filename = '%s_%s_plot.png' % (mcmc_set.name, fit_name) fig.savefig(img_filename) html_str += '<p><img src="%s" /></p>' % img_filename # Show the plot of all observables at the position chain0 = mcmc_set.chains[0] tspan = chain0.options.tspan observables = chain0.options.model.observables x = chain0.simulate(position=position, observables=True) fig = Figure() ax = fig.gca() lines = [] for o in observables: line = ax.plot(tspan, x[o.name]) lines += line ax.set_title("Observables at %s" % fit_name) fig.legend(lines, [o.name for o in observables], 'lower right') canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) img_filename = '%s_%s_species.png' % (mcmc_set.name, fit_name) fig.savefig(img_filename) html_str += '<p><img src="%s" /></p>' % img_filename # Print the parameter values for the position as a dict that can be # used to override the initial values html_str += '<pre>%s_params = {\n' % fit_name for i, p in enumerate(chain0.options.estimate_params): html_str += "\t'%s': %.17g,\n" % \ (p.name, 10 ** position[i]) html_str += '}</pre>' html_str += '</body></html>' # Create the html file html_filename = '%s_%s_plot.html' % (mcmc_set.name, fit_name) with open(html_filename, 'w') as f: f.write(html_str) return Result(fit_value, html_filename)
command=getit) w.pack(side=tk.BOTTOM) # .............................setting up matplotlib figure and plot................................ fig = Figure(figsize=(10, 5)) fig1 = Figure(figsize=(10, 1)) ax = fig.subplots() ax1 = fig1.subplots() canvas = FigureCanvasTkAgg(fig, root) canvas1 = FigureCanvasTkAgg(fig1, root) fig.set_canvas(canvas=canvas) fig1.set_canvas(canvas=canvas1) button1 = tk.Button(root, text="<-- LEFT", command=go_left) button1.configure(width=10, activebackground="#bfbfbf", relief=tk.FLAT) button1.pack(side=tk.LEFT) button2 = tk.Button(root, text="RIGHT-->", command=go_right) button2.configure(width=10, activebackground="#bfbfbf", relief=tk.FLAT) button2.pack(side=tk.RIGHT) # ...................................Hover ......................................... annot = ax.annotate("", xy=(0, 0), xytext=(20, 20),
def plot_net_set(pkl_glob,expname): if type(pkl_glob) is str: pklnames = glob.glob(pkl_glob) else: pklnames = pkl_glob pklnames.sort() nms = load_net_pkl(pklnames[0]) nres = len(set([nm.index for nm in nms])) ntemps = len(pklnames) chipfname = nms[0].chip.replace(' ','_') exppdf = PdfPages('/home/data/plots/net_%s_%s.pdf' % (expname,chipfname)) fig = plt.figure() ax = fig.add_subplot(111) colors = plt.cm.spectral(np.linspace(0.1,0.9,ntemps+1)) respdfs = {} resfigs = {} resfigs2 = {} resfigs3 = {} nets = np.zeros((ntemps,nres)) temps = np.zeros((ntemps,)) spectra = defaultdict(list) tidx = 0 for pklname in pklnames: nms = load_net_pkl(pklname) for idx in range(nres): if not respdfs.has_key(idx): respdfs[idx] = PdfPages('/home/data/plots/net_%s_%s_%02d.pdf' % (expname,chipfname,idx)) rset = [nm for nm in nms if nm.index == idx] fig = Figure(figsize=(16,8)) K_per_Hz,dt,df,ukrs = plot_net_sweep(rset,fig=fig) fig.suptitle('%s\n%02d - %f MHz' % (pklname,idx,rset[0].f0)) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) try: respdfs[idx].savefig(fig,bbox_inches='tight') except: raise print "Error with index",idx,pklname nm0 = rset[0] temps[tidx] = nm0.ts_temp nets[tidx,idx] = ukrs if not resfigs.has_key(idx): resfigs[idx] = Figure(figsize=(16,8)) resfigs[idx].add_subplot(111) resfigs2[idx] = Figure(figsize=(16,8)) resfigs2[idx].add_subplot(111) resfigs3[idx] = Figure(figsize=(16,8)) resfigs3[idx].add_subplot(111) ax = resfigs[idx].axes[0] if np.isfinite(K_per_Hz) and abs(K_per_Hz) > 0: ax.semilogx(nm0.pca_fr,np.sqrt(nm0.pca_evals[1,:])*1e6*nm0.f0*abs(K_per_Hz)*1e6/np.sqrt(2),label=('%.3f K' % nm0.ts_temp),color=colors[tidx]) ax.set_ylim(0,100) ax.grid(True) spectra[idx].append((nm0.pca_fr,np.sqrt(nm0.pca_evals[1,:])*1e6*nm0.f0*abs(K_per_Hz)*1e6/np.sqrt(2))) ax = resfigs2[idx].axes[0] ax.plot(nms[idx].frm,20*np.log10(abs(nms[idx].s21m+nms[idx].s0)),color=plt.cm.spectral(nms[idx].ts_temp/10.0)) ax.plot(nms[idx].fr,20*np.log10(abs(nms[idx].s21)),'.',color=plt.cm.spectral(nms[idx].ts_temp/10.0)) ax = resfigs3[idx].axes[0] ax.semilogx(nm0.pca_fr,np.sqrt(nm0.pca_evals[1,:])*1e6*nm0.f0,label=('%.3f K' % nm0.ts_temp),color=colors[tidx]) ax.set_ylim(0,0.5) ax.grid(True) tidx += 1 for idx,fig in resfigs.items(): ax = fig.axes[0] ax.legend(loc='lower left', prop=dict(size='x-small')) canvas = FigureCanvasAgg(fig) fig.set_canvas(canvas) respdfs[idx].savefig(fig,bbox_inches='tight') canvas = FigureCanvasAgg(resfigs2[idx]) resfigs2[idx].set_canvas(canvas) respdfs[idx].savefig(resfigs2[idx],bbox_inches='tight') canvas = FigureCanvasAgg(resfigs3[idx]) resfigs3[idx].set_canvas(canvas) respdfs[idx].savefig(resfigs3[idx],bbox_inches='tight') respdfs[idx].close() return temps,nets,spectra