def __init__(self, *args, **kwargs): """Identical to Slider.__init__, except for the "increment" kwarg. "increment" specifies the step size that the slider will be discritized to.""" self.inc = kwargs.pop('increment', 0.5) self.discrete_val = round(kwargs['valinit'] / self.inc) * self.inc Slider.__init__(self, *args, **kwargs)
def loadFile(self, filename): self.filename = filename sms_openSF(filename, self.sh) sr = self.sh.iSamplingRate print "maxbin before: ", self.maxFreq * (self.sizeSpec*2) / sr self.maxBin = sms_power2(self.maxFreq * (self.sizeSpec*2) / sr) self.peakParams.iSamplingRate = sr self.maxFreq = self.maxBin * sr / (self.sizeSpec*2) self.peakParams.fHighestFreq = self.maxFreq print "maxbin after: ", self.maxBin print "maxfreq after: ", self.maxFreq self.specEnv = zeros(self.maxBin) # set up time slider nSeconds = self.sh.nSamples / float(sr) axcolor = 'lightgoldenrodyellow' self.axtime = axes([0.2, 0.15, 0.65, 0.03], axisbg=axcolor) self.axorder = axes([0.2, 0.10, 0.65, 0.03], axisbg=axcolor) self.axlambda = axes([0.2, 0.05, 0.65, 0.03], axisbg=axcolor) self.stime = Slider(self.axtime, 'Time (seconds)', 0., nSeconds, valinit=0.05) self.stime.on_changed(self.updateFrame) self.sorder = Slider(self.axorder, 'Order (p)', 0., 100, valinit=20, valfmt='%d') self.sorder.on_changed(self.updateOrder) self.slambda = Slider(self.axlambda, 'lambda (power)', -10., -2, valinit=-5) self.slambda.on_changed(self.updateLambda)
def plot_spin_lattice(spin_array, observables): """ Shows the spin_array for all temperature values. """ T_range = observables.T_range fig = plt.figure(figsize=(4.5, 5)) ax = fig.add_subplot(111) plt.subplots_adjust(bottom=0.12, top=1) ax.set_title('$\\rm{\\bf Spin\,Lattice:}\;T= %.3f\,\\rm [K]$' % (T_range[-1]), fontsize=14, loc=('center')) im = ax.imshow(spin_array[:,:,-1], origin='lower', interpolation='none') slider_ax = plt.axes([0.2, 0.06, 0.6, 0.03], axisbg='#7F0000') spin_slider = Slider(slider_ax, '', 0, len(T_range)-1, len(T_range)-1, valfmt ='%u', facecolor='#00007F') def update(val): i = int(val) ax.set_title('$\\rm{\\bf Spin\,Lattice:}\;T= %.3f\,\\rm [K]$' % (T_range[i]), fontsize=14, loc=('center')) im.set_array(spin_array[:,:,i]) spin_slider.on_changed(update) plt.annotate('Temperature Slider', xy=(0.32,0.025), xycoords='figure fraction', fontsize=12) plt.show()
def showimages(img1, img2, pathtosave): def press(event): sys.stdout.flush() if event.key == 'escape': sys.exit(0) elif event.key == ' ': plt.savefig(os.path.join(pathtosave, 'overlay.pdf'), bbox_inches='tight') print 'saved' fig, ax = plt.subplots() fig.canvas.mpl_connect('key_press_event', press) plt.subplots_adjust(0.15, 0.1, 0.9, 0.98) im = ax.imshow(img1) axcolor = 'lightgoldenrodyellow' BAR_HEIGHT = 0.03 axalpha = plt.axes([0.2, 0.2 * BAR_HEIGHT, 0.7, BAR_HEIGHT], axisbg = axcolor) # axmax = plt.axes([0.2, BAR_HEIGHT + 0.4 * BAR_HEIGHT, 0.7, BAR_HEIGHT], axisbg = axcolor) salpha = Slider(axalpha, 'Alpha', 0.0, 1.0, valinit = 1.0) def update(event): curralpha = salpha.val ax.hold(False) ax.imshow(img1, alpha = curralpha) ax.hold(True) ax.imshow(img2, alpha = 1 - curralpha) plt.draw() return curralpha salpha.on_changed(update) plt.show()
def plotter(): ''' This process is supposed to handle the graphs. Not pretty at the moment... but then matplotlib never is. ''' signal.signal(signal.SIGINT, signal.SIG_IGN) # Ignore keyboard interrupt signal, parent process will handle. waterfall_size = 150 # This makes it about 75 seconds in theory. Drawing the graph sometimes takes a bit longer. fig = plt.figure(figsize=(20,15)) plt.subplots_adjust(left = 0.1, bottom = 0.25) ax = plt.subplot(1, 1, 1) line_lcp, = ax.plot([], [], 'bo', lw=1) line_rcp, = ax.plot([], [], 'ro', lw=1) ax.set_xlim(0,400) vav_data_lcp = collections.deque(maxlen = waterfall_size) vav_data_rcp = collections.deque(maxlen = waterfall_size) slider_ax = plt.axes([0.25, 0.1, 0.65, 0.03]) video_average_length_slider = Slider(slider_ax, 'VAv', 1, waterfall_size, valinit=video_average_length.value) def update(val): video_average_length.value = int(video_average_length_slider.val) fig.canvas.draw_idle() video_average_length_slider.on_changed(update) def init(): x = np.zeros(data_width) y = np.zeros(data_width) line_lcp.set_data(x,y) line_rcp.set_data(x,y) return line, def animate(*args): if script_run.value != 1: sys.exit() x = np.arange(0, 400, 400.0 / 1024.0) vav_data_lcp.appendleft(data_stream_1[:]) vav_data_rcp.appendleft(data_stream_2[:]) lcp = np.zeros(data_width) rcp = np.zeros(data_width) for i in range(video_average_length.value): if i < len(vav_data): lcp += np.array(vav_data_lcp[i]) rcp += np.array(vav_data_rcp[i]) lcp /= video_average_length.value rcp /= video_average_length.value graph_max = 0 if lcp.max() > rcp.max(): graph_max = lcp.max() else: graph_max = rcp.max() ax.set_ylim(0,graph_max + 1) line_lcp.set_data(x,lcp) line_rcp.set_data(x.rcp) return line, # Set the animation off to a start... anim = animation.FuncAnimation(fig, animate, init_func=init, blit=True, interval=500) plt.show() print 'plotter process finished.'
class SinSlider(): pi = 3.14159 def __init__(self, num): self.init_plot(num) self.init_slider(num) def init_plot(self, num): pylab.subplot(111) pylab.subplots_adjust(bottom = 0.25) pylab.axis([0.0, 2 * self.pi, -1.0, 1.0]) pylab.title("y = sin(num * x)") pylab.xlabel("x") pylab.ylabel("y") x, y = self.calc_xy(num) self.plot, = pylab.plot(x, y) # comma after 'self.plot' def init_slider(self, num): slider_axes = pylab.axes([0.1, 0.1, 0.8, 0.05]) # left, bottom, width, height self.slider = Slider(slider_axes, 'num', 0.0, 4.0, valinit = num) self.slider.on_changed(self.update) def update(self, num): _, new_y = self.calc_xy(num) self.plot.set_ydata(new_y) pylab.draw() def calc_xy(self, num): start = 0.0 stop = 2 * self.pi step = 0.01 x = pylab.arange(start, stop, step) y = pylab.sin(num * x) return x, y
def preparePlot(shapeModeler): global sliders, mainPlot, fig fig, ax = plt.subplots(); whiteSpace = 0.15 + numParams*0.05; plt.subplots_adjust( bottom=whiteSpace); plt.axis('equal'); #plot of initial shape params = np.zeros((numParams,1)); shape = shapeModeler.makeShape(params); shape = ShapeModeler.normaliseShape(shape); numPointsInShape = len(shape)/2; x_shape = shape[0:numPointsInShape]; y_shape = shape[numPointsInShape:]; mainPlot, = plt.plot(x_shape, -y_shape); plt.axis([-1, 1, -1, 1],autoscale_on=False, aspect='equal'); #add sliders to modify parameter values parameterVariances = shapeModeler.getParameterVariances(); sliders = [0]*numParams; for i in range(numParams): slider = Slider(plt.axes([0.25, 0.1+0.05*(numParams-i-1), 0.65, 0.03], axisbg=axcolor), 'Parameter '+str(i+1), -5*parameterVariances[i], 5*parameterVariances[i], valinit=0); slider.on_changed(update); sliders[i] = slider; resetax = plt.axes([0.8, 0.025, 0.1, 0.04]) button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975') button.on_clicked(reset) plt.show()
def mplot(func,x,**kwargs): num_params = len(kwargs) fig = plt.figure() main_ax = fig.add_subplot(111) fig.subplots_adjust(bottom=bottom_pad + (num_params+1)*per_slider) param_vals = dict((param_name,(lo+hi)/2) for param_name, (lo,hi) in kwargs.items()) y = func(x,**param_vals) l, = main_ax.plot(x,y) def update(*args): for param_name, slider in zip(param_vals,sliders): param_vals[param_name] = slider.val vals = func(x,**param_vals) l.set_ydata(vals) # using autoscale_view makes the axes shrink *and* grow #main_ax.relim() #main_ax.autoscale_view() # setting ylim this way only lets the axes grow ymin, ymax = main_ax.get_ylim() main_ax.set_ylim(min(vals.min(),ymin),max(ymax,vals.max())) fig.canvas.draw() sliders = [] for idx, (param_name, (lo,hi)) in enumerate(kwargs.items()): ax = fig.add_axes([0.25,bottom_pad+per_slider*idx,0.65,3/5*per_slider],axisbg=bgcolor) slider = Slider(ax, param_name, lo, hi, valinit=param_vals[param_name]) slider.on_changed(update) sliders.append(slider) plt.axes(main_ax)
def from_partial(plot_func,**kwargs): num_params = len(kwargs) fig = plt.figure() main_ax = fig.add_subplot(111) fig.subplots_adjust(bottom=bottom_pad + (num_params+1)*per_slider) param_vals = dict((param_name,(lo+hi)/2) for param_name, (lo,hi) in kwargs.items()) plot_func = partial(plot_func,main_ax) plot_func(param_vals) def update(*args): for param_name, slider in zip(param_vals,sliders): param_vals[param_name] = slider.val main_ax.cla() plot_func(param_vals) # using autoscale_view makes the axes shrink *and* grow main_ax.relim() main_ax.autoscale_view() fig.canvas.draw() sliders = [] for idx, (param_name, (lo,hi)) in enumerate(kwargs.items()): ax = fig.add_axes([0.25,bottom_pad+per_slider*idx,0.65,3/5*per_slider],axisbg=bgcolor) slider = Slider(ax, param_name, lo, hi, valinit=param_vals[param_name]) slider.on_changed(update) sliders.append(slider) plt.axes(main_ax)
class ChangingPlot(object): """ Gives a pyplot object with a slider that shows the complex roots of the truncated power series for the number of terms on the slider. """ def __init__(self,poly,NUMTERMS): self.sols,self.NUMTERMS = solLists(poly,NUMTERMS) self.windowBounds = minmax(self.sols) self.inc = 1.0 self.fig, self.ax = plt.subplots() self.sliderax = self.fig.add_axes([0.2, 0.02, 0.6, 0.03], axisbg='yellow') self.slider = Slider(self.sliderax, 'Value', 0, self.NUMTERMS-3, valinit=self.inc) self.slider.on_changed(self.update) self.slider.drawon = False self.dot, = self.ax.plot(self.sols[0][0],self.sols[0][1], 'bo') self.ax.axis(self.windowBounds) def update(self, value): value = int(value) self.dot.set_data(self.sols[value][0],self.sols[value][1]) self.slider.valtext.set_text('{}'.format(value)) self.fig.canvas.draw() def show(self): plt.show()
def param_gui(letter_name, shapeModeler): global sliders, mainPlot, fig, pca_params fig, ax = plt.subplots() whiteSpace = 0.15 + num_params*0.05 plt.subplots_adjust( bottom=whiteSpace) plt.axis('equal') #plot of initial shape params = np.zeros((num_params,1)) shape = shapeModeler.makeShape(params) shape = ShapeModeler.normaliseShape(shape) numPointsInShape = len(shape)/2 x_shape = shape[0:numPointsInShape] y_shape = shape[numPointsInShape:] mainPlot, = plt.plot(x_shape, -y_shape) plt.axis([-1, 1, -1, 1],autoscale_on=False, aspect='equal') plt.title(letter_name) #add sliders to modify parameter values parameterVariances = shapeModeler.getParameterVariances() sliders = [0]*num_params for i in range(num_params): slider = Slider(plt.axes([0.25, 0.1+0.05*(num_params-i-1), 0.65, 0.03], axisbg=axcolor), 'Parameter '+str(i+1), -5*parameterVariances[i], 5*parameterVariances[i], valinit=0) slider.on_changed(partial(update, shapeModeler)) sliders[i] = slider resetax = plt.axes([0.8, 0.025, 0.1, 0.04]) button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975') button.on_clicked(reset) plt.show() return pca_params
class slider(): def __init__(self,res): self.res=res def slider_bar(self,res): #setupthe slider axcolor = 'lightgoldenrodyellow' self.axtime = plt.axes([0.1, 0.05, 0.8, 0.03], axisbg=axcolor) self.stime = Slider(self.axtime, 'Timestep', 0, len(res.resobj.fils.fid.dimensions['Time']), valinit=0) def update(val,res): t = self.stime.val res.refresh_plot(t) self.stime.on_changed(update(self,res)) def foward_button(self,res): self.fwdax = plt.axes([0.1, 0.1, 0.1, 0.04]) self.fwdb = Button(self.fwdax, 'forward', color='lightgoldenrodyellow', hovercolor='0.975') self.fwdb.on_clicked(slider.update(res.resobj.timestep-1,res))
def iplot_spectrum_ds(ds, init = True, sigmarng = [0.05, 1.5], taurng = [0,4], **kwargs): """ Plots spectrum from TlacDatSet interactively using matplotlib. NOT FINISHED >> see tlac_web instead Keyword Arguments: ds -- TlacDatSet instance to plot init --- If true (default) plot will be initialized first sigmarng -- Range for intrinsic spectrum width. Measured in units of the actual sigma_i (default [0,1.5]) taurng -- Range for dust optical depth tau_d (default [0, 4]) **kwargs -- Will be passes to `tlac_analysis.plot_spectrum` """ if(not isinstance(ds, TlacDatSet)): raise ValueError("ds has to be a TlacDatSet instance") dat = ds['Lya','x'] sigmar = ds.header['emission', 'frequency_param' ] if(init): plot_init() plt.gcf().subplots_adjust(top = 0.95, bottom = 0.05) plot_spectrum(dat, np.ones(len(dat)), **kwargs) fig = plt.gcf() ax = fig.axes[0] line = ax.lines[-1] nbins = len(line.get_xdata()) bm = fig.subplotpars.bottom fig.subplots_adjust(bottom = bm + 0.04) axsigma = plt.axes([0.2, bm - 0.03, 0.65, 0.03]) ssigma = Slider(axsigma, r"$\sigma_i$", sigmarng[0] * sigmar, sigmarng[1] * sigmar, valinit=sigmar) def update(val): sigma = ssigma.val w = tlac_weights(ds, sigma, 0) x,y = plot_spectrum(dat, w, plot = False, **kwargs) line.set_xdata(x) line.set_ydata(y) ymax = ax.get_ylim()[1] if(np.max(y) > 1.1 * ymax): ax.set_ylim(ymax = 1.5 * ymax) elif(np.max(y) < 0.5 * ymax): ax.set_ylim(ymax = 0.5 * ymax) fig.canvas.draw_idle() ssigma.on_changed(update) # change current axis back plt.sca(ax) plt.show() # have to return ref to slider. otherwise unresponsive! return fig, ax, ssigma
def __init__(self, image, low, high): self.image_name = image self.low = low self.high = high self.filter = None self.output = None self.filter_type = None self.padRows = None self.padCols = None original_input = cv2.imread(image,0) rows, cols = original_input.shape if(rows < cols): original_input = cv2.transpose(original_input) self.transposed = True else: self.transposed = False rows, cols = original_input.shape optimalRows = cv2.getOptimalDFTSize(rows) optimalCols = cv2.getOptimalDFTSize(cols) self.padRows = optimalRows - rows self.padCols = optimalCols - cols self.input = np.zeros((optimalRows,optimalCols)) self.input[:rows,:cols] = original_input self.dftshift = get_dft_shift(self.input) plt.subplots_adjust(left=0, bottom=0.05, right=1, top=1, wspace=0, hspace=0) plt.subplot(131) plt.axis('off') plt.title('original image') plt.imshow(self.input, cmap = 'gray',interpolation='nearest') self.axslow = plt.axes([0.05, 0.01, 0.5, 0.02]) self.slow = Slider(self.axslow, 'low', 0.01, 1, valinit=self.low) self.slow.on_changed(self.updateLow) self.axhigh = plt.axes([0.05, 0.03, 0.5, 0.02]) self.shigh = Slider(self.axhigh, 'high', 0.01, 1, valinit=self.high) self.shigh.on_changed(self.updateHigh) self.slow.slidermax=self.shigh self.shigh.slidermin=self.slow self.axfilter = plt.axes([0.62, 0.01, 0.15, 0.04]) self.rfilter = RadioButtons(self.axfilter, ('Gaussian Filter', 'Ideal Filter')) self.rfilter.on_clicked(self.updateFilterType) self.filter_type = self.rfilter.value_selected self.axprocess = plt.axes([0.8, 0.01, 0.08, 0.04]) self.bprocess = Button(self.axprocess, 'Process') self.bprocess.on_clicked(self.process) self.axsave = plt.axes([0.88, 0.01, 0.08, 0.04]) self.bsave = Button(self.axsave, 'Save') self.bsave.on_clicked(self.save)
def plotInteractive( data ): ax = plt.subplot(111) plt.subplots_adjust(bottom=0.25) t = sorted(data.keys()) pl = plt.scatter([0],[0],s=10,linewidths=(0,0,0)) plt.axis([0, 2, 0, 2]) axTime = plt.axes([0.25, 0.1, 0.65, 0.03]) sTime = Slider(axTime, 'Time', min(t), max(t), valinit=min(t)) def updateTime(val): t0 = sTime.val dt = abs(np.array(t)-t0) t_in = t[dt.argmin()] px = getpx(data,t_in) pv = getpv(data,t_in) pl.set_offsets(px) pl.set_array(pv) plt.draw() updateTime(min(t)) sTime.on_changed(updateTime) plt.show(block=False)
def vis(gt,f,est=False,title=False): import matplotlib.pyplot as plt from matplotlib.widgets import Slider #, Button, RadioButtons from matplotlib.patches import Ellipse fig = plt.figure() if title : fig.suptitle(title, fontsize=14, fontweight='bold') ax = plt.subplot(111, aspect='equal') fig.subplots_adjust(left=0.25, bottom=0.25) ax.clear() axcolor = 'lightgoldenrodyellow' ax2 = fig.add_axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor) def update(val): val=int(val) ax.clear() loc=find_locs(f[val]) if est is not False: p=np.random.permutation(est[val].max()+1) p2=np.random.permutation(gt[val].max()+1) calc_distance_vis(loc,f[val],p[est[val]],3500,ax) ax.scatter(f[val][:,1],f[val][:,2], c=p2[gt[val]],vmin=0, vmax=gt[val].max(),s=100) update(0) slider = Slider(ax2, 'Frame', 0, gt.shape[0] - 1, valinit=0, valfmt='%i') slider.on_changed(update) plt.show()
def _create_controls(self): self._freq_ax = plt.axes([0.2, 0.19, 0.2, 0.03]) self._freq_slider = Slider(self._freq_ax, 'Frequency', 0, self.samplerate / 2.0, valinit = self.frequency) self._freq_slider.on_changed(self.set_signal_frequency) self._ampl_ax = plt.axes([0.2, 0.1, 0.2, 0.03]) self._ampl_slider = Slider(self._ampl_ax, 'Amplitude', -100, 0, valinit = dcv.lin2db(self.amplitude)) self._ampl_slider.on_changed(self.set_signal_amplitude) self._signaltype_ax = plt.axes([0.5, 0.05, 0.15, 0.20]) self._signaltype_radio = RadioButtons(self._signaltype_ax, ('Sine', 'Square', 'Sawtooth', 'Triangle', 'Noise', 'Constant')) self._signaltype_radio.on_clicked(self.set_signal_type) self._windowtype_ax = plt.axes([0.7, 0.05, 0.15, 0.20]) self._windowtype_radio = RadioButtons(self._windowtype_ax, ('Flat', 'Hanning', 'Hamming', 'Blackman')) self._windowtype_radio.on_clicked(self.set_window_type)
class ChangingPlot(object): def __init__(self): data = np.genfromtxt('AR.csv', dtype=None, delimiter=',', skip_header=1) [aa,bb]=data.shape self.bb=int(bb) self.freq=data[:,0] self.AR_sim=data[:,1] # change this for the stepsize self.inc = 1.0 self.fig, self.ax = plt.subplots() self.sliderax = self.fig.add_axes([0.2, 0.02, 0.6, 0.03], axisbg='yellow') self.slider = Slider(self.sliderax, 'Value', 0, self.bb, valinit=self.inc) self.slider.on_changed(self.update) self.slider.drawon = False self.dot, = self.ax.plot(self.freq, self.AR_sim) self.ax.axhline(y=3,linestyle='-.',color='b',linewidth=0.5) def update(self, value): value = int(value / self.inc) * self.inc data = np.genfromtxt('AR.csv', dtype=None, delimiter=',', skip_header=1) [aa,bb]=data.shape self.freq=data[:,0] self.AR_sim=data[:,[value]] self.dot.set_data([self.freq,self.AR_sim]) self.slider.valtext.set_text('{}'.format(value)) self.fig.canvas.draw() def show(self): plt.show()
def getBubbleChart(d): def generateX(): return np.repeat(np.arange(len(d.index.values)),len(d.index.values)) def generateY(): return np.tile(np.arange(len(d.index.values)),len(d.index.values)) fig, ax = plt.subplots() plt.subplots_adjust(left=0.25, bottom=0.25) l = plt.scatter(generateX(),generateY(),s=d*50) basic_sizes = l._sizes plt.xticks(np.arange(0, len(d), 1.0),d.index.values,ha='right', rotation=45) plt.yticks(np.arange(0, len(d), 1.0),d.index.values) plt.grid() axcolor = 'lightgoldenrodyellow' axsize = plt.axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor) ssize = Slider(axsize, 'Size', 1, 20, valinit=50) def update(val): new_coef = ssize.val/50 new_sizes = [x * new_coef for x in basic_sizes] l._sizes = new_sizes fig.canvas.draw_idle() ssize.on_changed(update) plt.show()
def plot_fits(self, X, X_pred, plot_preds = True): self.plot_preds = plot_preds import matplotlib self.colors = ['r', 'g', 'b'] more_colors = matplotlib.colors.cnames.keys() shuffle(more_colors) # print self.colors # print more_colors self.colors.extend(more_colors) self.trial_groups = self.split_trial_groups() self.X = X self.X_pred = X_pred # set-up the plot window self.fig, self.ax = plt.subplots(figsize=(12,8)) plt.subplots_adjust(bottom=0.25) # make sliders axcolor = 'lightgoldenrodyellow' self.axtrial = plt.axes([0.25, 0.05, 0.65, 0.03], axisbg=axcolor) self.axspot = plt.axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor) self.axclass = plt.axes([0.25, 0.15, 0.65, 0.03], axisbg=axcolor) # need to update to find the number of classes, trial_groups self.strial = Slider(self.axtrial, 'Trial', 0, self.n_trial_groups, valinit=0) self.sspot = Slider(self.axspot, 'Spot', 1, len(self.column_headers), valinit=1) self.sclass = Slider(self.axclass, 'Class', 0, len(self.groups), valinit=0) self.strial.on_changed(self.update_fits) self.sspot.on_changed(self.update_fits) self.sclass.on_changed(self.update_fits) self.plot_fit(spot=1, group=0, trial=0, averages=self.averages) plt.show()
def __init__(self, *args, **kwargs): """Identical to Slider.__init__, except for the "increment" kwarg. "increment" specifies the step size that the slider will be discritized to.""" self.inc = kwargs.pop("increment", 1.0) Slider.__init__(self, *args, **kwargs) self.dval = int(self.val + 0.5)
def cal_threshold(image, tr): ''' shows the before and after for thresholding, where the threshold can be set by a slider ''' assert image.ndim ==2, 'This is not a single-channel image! Use single-channel images' im = image.astype('uint8') #create the axes for the slider axcolor = 'teal' ax1 = plt.axes([.15,.2,.65,.03],axisbg=axcolor) #create the slider s1 = Slider(ax1, 'Threshold', 0, 255, valinit=tr) #actual thresholding: compare each pixel in the image to the threshold trim = im > tr plt.subplot(221),plt.imshow(im),plt.title('Original') plt.subplot(222),plt.imshow(trim),plt.title('After thresholding') def update(val): vtr = s1.val trim = im > vtr plt.subplot(222),plt.imshow(trim),plt.title('After thresholding') s1.on_changed(update) plt.show() #trim is a binary image - convert it to full colorscale by multiplying with #255 return trim*255, s1.val
def cube_show_slider(cube, axis=2, **kwargs): import matplotlib.pyplot as plt from matplotlib.widgets import Slider, Button, RadioButtons # check dim if not cube.ndim == 3: raise ValueError("cube should be an ndarray with ndim == 3") # generate figure fig = plt.figure() ax = plt.subplot(111) fig.subplots_adjust(left=0.25, bottom=0.25) # select first image s = [slice(0, 1) if i == axis else slice(None) for i in xrange(3)] im = cube[s].squeeze() # display image l = ax.imshow(im, **kwargs) axcolor = 'lightgoldenrodyellow' ax = fig.add_axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor) slider = Slider(ax, 'Axis %i index' % axis, 0, cube.shape[axis] - 1, valinit=0, valfmt='%i') def update(val): ind = int(slider.val) s = [slice(ind, ind + 1) if i == axis else slice(None) for i in xrange(3)] im = cube[s].squeeze() l.set_data(im, **kwargs) fig.canvas.draw() slider.on_changed(update) plt.show()
def create_sliders(self): for i, name in enumerate(self.names): dim = self.def_dim + i * self.del_dim axes = self.f.add_axes(dim, axisbg = self.axcolor) slider = Slider(axes, name, 0, 10, valinit=1) slider.on_changed(self.update) self.cont_of_slid[name] = (axes, slider)
def initUI(self): self.fig, self.ax = plt.subplots() self.fig.canvas.set_window_title('Numerik DGL 2 - Schattenprojektion') self.fig.suptitle('Vorwaertsproblem') plt.subplots_adjust(bottom=0.3) plt.axis([0, 200, -100, 100]) plt.axis('equal') axColor = 'lightgoldenrodyellow' # Slider - Phi axPhi = plt.axes([0.18, 0.2, 0.65, 0.03], axisbg=axColor) self.sliderPhi = Slider(axPhi, 'Phi', 0, 360, valinit=self.phi, valfmt='%1d') self.sliderPhi.on_changed(self.onUpdate) # Slider - Delta Phi axDeltaPhi = plt.axes([0.18, 0.15, 0.65, 0.03], axisbg=axColor) self.sliderDeltaPhi = Slider(axDeltaPhi, 'Delta Phi', 5, 360, valinit=self.delta_phi, valfmt='%1d') self.sliderDeltaPhi.on_changed(self.onUpdate) # Slider - Psi axPsi = plt.axes([0.18, 0.1, 0.65, 0.03], axisbg=axColor) self.sliderPsi = Slider(axPsi, 'Psi', 0, 180, valinit=self.psi, valfmt='%1d') self.sliderPsi.on_changed(self.onUpdate) # Button - Previous axPrev = plt.axes([0.18, 0.03, 0.1, 0.05]) self.buttonPrev = Button(axPrev, 'Previous') self.buttonPrev.on_clicked(self.onPrevious) # Button - Next axNext = plt.axes([0.29, 0.03, 0.1, 0.05]) self.buttonNext = Button(axNext, 'Next') self.buttonNext.on_clicked(self.onNext) # Button - Reset axReset = plt.axes([0.73, 0.03, 0.1, 0.05]) self.buttonReset = Button(axReset, 'Reset') self.buttonReset.on_clicked(self.onReset) self.onDraw()
class Explorer(object): """A simple interactive slicer that "pans" a series of 2D slices along a given axis of a 3D volume. Additional kwargs are passed to "imshow".""" def __init__(self, data, axis=2, **kwargs): self.data = data self.axis = axis self.start, self.stop = 0, data.shape[self.axis] - 1 kwargs['cmap'] = kwargs.get('cmap', 'gray_r') self.fig, self.ax = plt.subplots() self.im = self.ax.imshow(self[self.start], **kwargs) self.ax.axis('off') self.sliderax = self.fig.add_axes([0.2, 0.02, 0.6, 0.03]) self.slider = Slider(self.sliderax, 'Z-slice', self.start, self.stop, valinit=self.start, valfmt='%i') self.slider.on_changed(self.update) def __getitem__(self, i): slices = self.data.ndim * [slice(None)] slices[self.axis] = i return self.data[slices].swapaxes(0, 1) def update(self, val): dat = self[int(val)] self.im.set(data=dat, clim=[dat.min(), dat.max()]) self.fig.canvas.draw() def show(self): plt.show()
def init(): """ Set up the initial conditions """ # Sets up initial dimensions M.figure(figsize=(8,8)) density=N.loadtxt(os.path.join(sys.path[0], './densmesh.txt')) # Real Fourier transform of "density" density_k = N.fft.rfftn(density*1e3) # 1e3 to enhance contrast global psi psi = zeldovich(density_k) # Zel'dovich displacement field global scale global slider_scale scale = 1.0 slider_scale = 50.0 axcolor = 'lightgoldenrodyellow' axScale = plt.axes([0.15, 0.1, 0.7, 0.03], axisbg=axcolor) slider_scale = Slider(axScale, 'Scale', 0.0, 50.0, 1.0) slider_scale.on_changed(update) # Attempting to removed axes from the graph plt.axes([0.15, 0.15, 0.7, 0.7]) plt.xticks([]) plt.yticks([]) return density_k, psi
def run(self): for varname,range in self.ranges.iteritems(): if range is None: raise ValueError("no range specified for slider %s." % varname) def update(val): d = dict([(k, self.sliders[k].val) for k in self.sliders.keys()]) # pull members into current scope -> no self. in cutstring vars = self.vars weights = self.weights basemask = self.basemask # evaluate cutstring and combine with basemask mask = basemask & eval(self.cutstring % d) self.updatefunc(self, vars, weights, mask) self.sliderfig = p.figure(figsize=(3,len(self.ranges)*.4)) self.sliders = dict() space = .05 height = (1. - (len(self.ranges)+2)*space) / float(len(self.ranges)) for i,(varname,range) in enumerate(self.ranges.iteritems()): ax = p.axes([0.25, 1-float(i+1)*(space+height), 0.5, height]) slider = Slider(ax, varname, range[0],range[1], valinit=(range[1]-range[0])/2.) slider.on_changed(update) self.sliders[varname] = slider self.initfunc(self,self.vars,self.weights,self.basemask)
def interpolation(threshold, X_Smooth1, Smooth_Y_Coordinates): Smooth_X_npy = np.asarray(X_Coordinates) Smooth_Y_npy = np.asarray(Smooth_Y_Coordinates) f = interp1d(Smooth_X_npy, Smooth_Y_npy, kind = "cubic" ) temp = f(X_Coordinates) plt.close('all') fig, ax = plt.subplots(5) fig.suptitle("Neutron Imaging Curve Smoothing", fontsize="x-large") ax[0] = plt.subplot2grid((6,7), (0,0), rowspan=2, colspan=3) ax[0].plot(X_Coordinates, Y_Coordinates) ax[0].set_title('Original Plot') ax[1] = plt.subplot2grid((6,7), (3,0), rowspan=2, colspan=3) ax[1].plot(X_Coordinates, beta_list, 'r.-') ax[1].axhline(y=threshold, linewidth=1, color='k') ax[1].set_title('Peak Plot', ) ax[2] = plt.subplot2grid((6,7), (0,4), rowspan=2, colspan=3) ax[2].plot(X_Coordinates, Smooth_Y_Coordinates) ax[2].set_title('Smoothed graph') ax[3] = plt.subplot2grid((6,7), (3,4), rowspan=2, colspan=3) ax[3].plot(X_Coordinates, f(X_Coordinates)) ax[3].set_title('Interpolated') ax[4] = plt.subplot2grid((6,7), (5,0), colspan=7) ax[4].set_position([0.25, 0.1, 0.65, 0.03]) thres = Slider(ax[4], 'Threshold', 0.000, 0.005, valinit = threshold, valfmt='%1.5f') workbook = xlwt.Workbook(encoding='ascii') sheet = workbook.add_sheet("Sheet") sheet.write(0, 0, "(Raw-OB)/OB") sheet.write(0, 1, "wavelength (angs)") for i in range(len(X_Coordinates)): sheet.write(i+1, 0, X_Coordinates[i]) sheet.write(i+1, 1, temp[i]) workbook.save(outputfile) def update(val): threshold = thres.val print ("Threshold value: "), threshold smoothing_Plot(total_Span, threshold) fig.canvas.draw_idle() thres.on_changed(update) plt.show() fig2, ax2 = plt.subplots(2) ax2[0] = plt.subplot2grid((7,2), (0,0), rowspan=3, colspan=2) ax2[0].plot(X_Coordinates, Y_Coordinates) ax2[0].set_title('Original Plot') for i in X_Smooth1: plt.axvline(x = i, linewidth=1, color='k') ax2[1] = plt.subplot2grid((7,2), (4,0), rowspan=3, colspan=2) ax2[1].plot(X_Coordinates, f(X_Coordinates)) ax2[1].set_title('Interpolated') for i in X_Smooth1: plt.axvline(x = i, linewidth=1, color='k') plt.show()
def __init__(self, image, dragging=True, **kwargs): # init PointBrowser super(FindCenters,self).__init__(image,[[None,None]],**kwargs); self.axis.set_title('FitHexagonCenters: %s' % self.imginfo['desc']); self.fig.subplots_adjust(bottom=0.2); # space for sliders # add slider for neighborhood size self.nbhd_size = 5; # neighborhood size axNbhd = self.fig.add_axes([0.2, 0.05, 0.1, 0.04]); self.sNbhd = Slider(axNbhd,'neighbors ',2,20,valinit=self.nbhd_size,\ valfmt=' (%d)',dragging=dragging); self.sNbhd.on_changed(self.ChangeNeighborhood); # add slider for number of points self.num_points = 1e6; # number of local maxima to find axNum = self.fig.add_axes([0.45, 0.05, 0.3, 0.04]); self.sNum = Slider(axNum, 'points ',0,100,valinit=self.num_points,\ valfmt=' (%d)',dragging=dragging); self.sNum.on_changed(self.ChangeMaxPoints); # add buttons axRefine = self.fig.add_axes([0.85, 0.7, 0.1, 0.04]); self.bRefine = Button(axRefine,'Refine'); self.bRefine.on_clicked(self.RefineCenters); # initial calculation of local maximas self.ChangeNeighborhood(self.nbhd_size);
ax.set_title(filename + "; total frames: " + str(num_frames)) ax2 = fig.add_subplot(111) ax2.autoscale(True) ax3 = fig.add_subplot(111) ax3.autoscale(True) # plot first data set frame = 0 ln, = ax.plot(xdata[frame:frame_size], ydata[frame:frame_size]) ln2, = ax2.plot(xdata[frame:frame_size], samples2[frame:frame_size]) ln3, = ax3.plot(xdata[frame:frame_size], samples3[frame:frame_size], 'ro') axframe = plt.axes([0.25, 0.1, 0.65, 0.03]) sframe = Slider(axframe, 'Frame', 0, num_frames, valinit=0, valfmt='%d') def update(val): frame = numpy.floor(sframe.val) start, end = int(frame * frame_size), int((frame + 1) * frame_size) #print to_string(samples2[start:end]) print "FRAME", start, end ln.set_xdata(xdata[start:end]) ln.set_ydata(ydata[start:end]) ln2.set_xdata(xdata[start:end]) ln2.set_ydata(samples2[start:end]) ln3.set_xdata(xdata[start:end]) ln3.set_ydata(samples3[start:end]) ax.relim() ax.autoscale_view()
class Renderer: def __init__(self, file_name, hide, n, interval=100, hide_widgets=False): self.root = tkinter.Tk() if not file_name: file_name = askopenfilename(initialdir="output", title="Select param", filetypes=[ ("param files", "*.param")]) self.file_name = file_name X = pickle.load(open(file_name, 'rb')) self.plotter = Plotter(X, hide, n) self.interval = interval self.hide_widgets = hide_widgets def render(self): print(f'drawing with {self.plotter.n} circles') self.fig = Figure(figsize=(13, 13), dpi=100) self.ax = self.fig.subplots() self.root.wm_title(f"Render - {base_name(args.file_name, True)}") canvas = FigureCanvasTkAgg(self.fig, master=self.root) canvas.draw() canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1) if not self.hide_widgets: rax = self.fig.add_axes([0.05, 0.0, 0.1, 0.1]) rax.axis('off') self.check = CheckButtons(rax, ('hide',), (self.plotter.hide,)) self.check.on_clicked(lambda _: self.plotter.toggle_hide()) nax = self.fig.add_axes([0.2, 0.07, 0.7, 0.02]) self.nslider = Slider(nax, 'n', 2, self.plotter.frames, valinit=self.plotter.n, valstep=1) self.nslider.on_changed(self._update_n) fpsax = self.fig.add_axes([0.2, 0.03, 0.7, 0.02]) self.fpsslider = Slider(fpsax, 'fps', 1, 50, valinit=10, valstep=1) self.fpsslider.on_changed(self._update_fps) self._init_animation() if args.save: self.save(args.out) else: tkinter.mainloop() def _init_animation(self): self.animation = FuncAnimation(self.fig, self.plotter.render_frame, frames=range(self.plotter.frames), interval=self.interval, repeat_delay=1000, init_func=partial( self.plotter.init_frame, self.ax), repeat=True) def _update_fps(self, fps): self.animation.event_source.stop() self.interval = int(1000 / fps) self._init_animation() def _update_n(self, n): self.animation.event_source.stop() self.plotter = Plotter(self.plotter.X, self.plotter.hide, int(n)) self._init_animation() def save(self, out_fname): if not out_fname: out_fname = f'output/{base_name(self.file_name)}.mp4' print(f'saving to {out_fname}') self.animation.save( out_fname, writer=FFMpegWriter(fps=10, bitrate=1000))
#fig_manager = plot.get_current_fig_manager() #if hasattr(fig_manager, 'window'): # fig_manager.window.showMaximized() #creation de l' "Axes" et ajustement de sa position ax = fig.add_subplot(111) ax2 = ax.twinx() fig.subplots_adjust(left=0.1,right=0.6, bottom=0.25) # création des Sliders V_slider_ax = fig.add_axes([0.7, 0.25, 0.03, 0.65]) V_slider = VertSlider(V_slider_ax, "V0/E", -0.8, 2, valinit=0) w_slider_ax = fig.add_axes([0.1, 0.1, 0.5, 0.03]) w_slider = Slider(w_slider_ax, 'width', 0.1, 5.0, valinit=w) zoom_slider_ax = fig.add_axes([0.1, 0.05, 0.5, 0.03]) zoom_slider = Slider(zoom_slider_ax, 'zoom', 0.1, 2.0, valinit=zoom) prec_slider_ax = fig.add_axes([0.8, 0.25, 0.03, 0.65]) prec_slider = VertSlider(prec_slider_ax, "precision", 1, 500, valinit=precision) #configuration des events handlers V_slider.on_changed(sliders_on_changed) w_slider.on_changed(sliders_on_changed) zoom_slider.on_changed(sliders_on_changed) prec_slider.on_changed(sliders_on_changed) # création du Bouton reset reset_button_ax = fig.add_axes([0.7, 0.1, 0.1, 0.04]) reset_button = Button(reset_button_ax, 'Reset', color = axisColor, hovercolor='0.975')
class VideoViewer(object): """ A matplotlib-based video viewer. Parameters ---------- video : list-like, iterator A list of a tuple of 2D arrays or a generator of a tuple of 2D arrays. If an iterator is provided, you must set 'n' as well. n: int Length of the video. When this is set it displays only first 'n' frames of the video. id : int, optional For multi-frame data specifies camera index. title : str, optional Plot title. """ def __init__(self, video, n=None, id=0, title=""): if n is None: try: n = len(video) except TypeError: raise Exception("You must specify nframes!") self.id = id self.index = 0 self.video = video self.fig, self.ax = plt.subplots() self.ax.set_title(title) plt.subplots_adjust(bottom=0.25) frame = next(iter(video)) #take first frame frame = self._prepare_image(frame) self.img = self.ax.imshow(frame) self.axframe = plt.axes([0.25, 0.1, 0.65, 0.03]) self.sframe = Slider(self.axframe, 'Frame', 0, n - 1, valinit=0, valstep=1, valfmt='%i') def update(val): i = int(self.sframe.val) try: frame = self.video[i] #assume list-like object self.index = i except TypeError: #assume generator frame = None if i > self.index: for frame in self.video: self.index += 1 if self.index >= i: break if frame is not None: frame = self._prepare_image(frame) self.img.set_data(frame) self.fig.canvas.draw_idle() self.sframe.on_changed(update) def _prepare_image(self, im): if isinstance(im, tuple) or isinstance(im, list): return im[self.id] else: return im def show(self): """Shows video.""" plt.show()
fig, ax = plt.subplots() plt.subplots_adjust(left=0.25, bottom=0.25) t = np.arange(0.0, 1.0, 0.001) a0 = 5 f0 = 3 delta_f = 5.0 s = a0 * np.sin(2 * np.pi * f0 * t) l, = plt.plot(t, s, lw=2) plt.axis([0, 1, -10, 10]) axcolor = 'lightgoldenrodyellow' axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor) axamp = plt.axes([0.25, 0.15, 0.65, 0.03], facecolor=axcolor) sfreq = Slider(axfreq, 'Freq', 0.1, 30.0, valinit=f0, valstep=delta_f) samp = Slider(axamp, 'Amp', 0.1, 10.0, valinit=a0) def update(val): amp = samp.val freq = sfreq.val l.set_ydata(amp*np.sin(2*np.pi*freq*t)) fig.canvas.draw_idle() sfreq.on_changed(update) samp.on_changed(update) resetax = plt.axes([0.8, 0.025, 0.1, 0.04]) button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
ax.xaxis.set_ticks_position('bottom') xMiddleLine = ax.axvline(xInitial, color="orange") # Text boxes # Function axbox = plt.axes([0.125, 0.05, 0.8, 0.0400]) #left bottom width height text_box = TextBox(axbox, 'Function', initial=initial_function) # X Lower axbox2 = plt.axes([0.180, 0.13, 0.2, 0.0400]) xMiddleBox = TextBox(axbox2, 'Initial X guess', initial=str(xInitial)) # Slider # Iteration count axbox4 = plt.axes([0.125, 0.21, 0.3, 0.0400]) iterSlider = Slider(axbox4, 'Iteration', 0, 10, valinit=initial_iteration - 1, valstep=1) # Update iteration def updateIteration(val): # Get values from the slider iteration = iterSlider.val # Remove existing xMiddle ax.lines[-1].remove() # Get updated xMiddle xMiddle = newRaph(float(xMiddleBox.text), iteration) # Set the xMiddle xMiddleLine = ax.axvline((xMiddle), color="Orange") plt.draw()
class DoS(): """ Definition of the density of state class """ def __init__(self, bandarrays=None, energies=None, evals=None, units='eV', label='1', sigma=0.2, npts=2500, fermi_level=None, norm=1.0, sdos=None, e_min=None, e_max=None): """ Extract a quantity which is associated to the DoS, that can be plotted """ import numpy as np self.ens = [] self.labels = [] self.ef = None # self.norms=[] self.npts = npts if e_min is not None: self.e_min = e_min else: self.e_min = 1.e100 if e_max is not None: self.e_max = e_max else: self.e_max = -1.e100 if bandarrays is not None: self.append_from_bandarray(bandarrays, label) if evals is not None: self.append_from_dict(evals, label) if energies is not None: self.append( np.array([energies]), label=label, units=units, norm=(np.array([norm]) if isinstance(norm, float) else norm)) self.sigma = sigma self.fermi_level(fermi_level, units=units) if sdos is not None: self._embed_sdos(sdos) def _embed_sdos(self, sdos): self.sdos = [] for i, xdos in enumerate(sdos): self.sdos.append({'coord': xdos['coord']}) jdos = 0 for subspin in xdos['dos']: if len(subspin[0]) == 0: continue d = {'doslist': subspin} try: self.ens[jdos]['sdos'].append(d) except KeyError: self.ens[jdos]['sdos'] = [d] jdos += 1 def append_from_bandarray(self, bandarrays, label): """ Add a new band array to the previous DoS. Important for kpoints DOS """ import numpy as np for jspin in range(2): kptlists, lbl = _bandarray_to_data(jspin, bandarrays) self.append(np.array(kptlists[0]), label=label + lbl, units='AU', norm=np.array(kptlists[1])) def append_from_dict(self, evals, label): import numpy as np "Get the energies from the different flavours given by the dict" evs = [[], []] ef = None for ev in evals: occ = self.get_ev(ev, ['e_occ', 'e_occupied']) if occ: ef = max(occ) vrt = self.get_ev(ev, ['e_vrt', 'e_virt']) eigen = False if occ: eigen = occ if vrt: eigen = vrt if not eigen: eigen = self.get_ev(ev) if not occ and not vrt and eigen: ef = max(eigen) if not eigen: continue for i, e in enumerate(eigen): if e: evs[i].append(e) for i, energs in enumerate(evs): if len(energs) == 0: continue self.append(np.array(energs), label=label, units='AU', norm=1.0 - 2.0 * i) if ef: self.fermi_level(ef, units='AU') def get_ev(self, ev, keys=None): "Get the correct list of the energies for this eigenvalue" res = False if keys is None: ener = ev.get('e') spin = ev.get('s') if ener and spin == 1: res = [ener] elif ener and spin == -1: res = [None, ener] else: for k in keys: if k in ev: res = ev[k] if not isinstance(res, list): res = [res] break return res def append(self, energies, label=None, units='eV', norm=1.0): if not isinstance(norm, float) and len(norm) == 0: return dos = self.conversion_factor(units) * energies self.ens.append({'dos': DiracSuperposition(dos, wgts=norm)}) lbl = label if label is not None else str(len(self.labels) + 1) self.labels.append(lbl) # self.norms.append(norm) self.range = self._set_range() def conversion_factor(self, units): if units == 'AU': fac = AU_eV elif units == 'eV': fac = 1.0 else: raise ValueError('Unrecognized units (' + units + ')') return fac def fermi_level(self, fermi_level, units='eV'): if fermi_level is not None: self.ef = fermi_level * self.conversion_factor(units) def _set_range(self, npts=None, e_min=None, e_max=None): import numpy as np if npts is None: npts = self.npts if e_min is None: e_min = self.e_min if e_max is None: e_max = self.e_max for dos in self.ens: mn, mx = dos['dos'].xlim e_min = min(e_min, mn) e_max = max(e_max, mx) return np.arange(e_min, e_max, (e_max - e_min) / npts) def curve(self, dos, norm, sigma=None): import numpy as np if sigma is None: sigma = self.sigma nrm = np.sqrt(2.0 * np.pi) * sigma / norm dos_g = [] for e_i in self.range: if len(dos.shape) == 2: nkpt = dos.shape[0] value = 0.0 for ikpt in range(nkpt): value += np.sum( np.exp(-(e_i - dos[ikpt, :])**2 / (2.0 * sigma**2)) / nrm[ikpt]) else: value = np.sum( np.exp(-(e_i - dos[:])**2 / (2.0 * sigma**2)) / nrm) # Append data corresponding to each energy grid dos_g.append(value) return np.array(dos_g) def dump(self, sigma=None): "For Gnuplot" if sigma is None: sigma = self.sigma # data=[self.curve(dos,norm=self.norms[i],sigma=sigma) # for i,dos in enumerate(self.ens)] data = [ dos['dos'].curve(self.range, sigma=sigma)[1] for dos in self.ens ] for i, e in enumerate(self.range): safe_print(e, ' '.join(map(str, [d[i] for d in data]))) def plot(self, sigma=None, legend=True, xlmin=None, xlmax=None, ylmin=None, ylmax=None, width=6.4, height=4.8): import matplotlib.pyplot as plt from matplotlib.widgets import Slider # , Button, RadioButtons if sigma is None: sigma = self.sigma self.fig, self.ax1 = plt.subplots(figsize=(width, height)) self.plotl = [] for i, dos in enumerate(self.ens): # self.plotl.append(self.ax1.plot(self.range,self.curve(dos,norm=self.norms[i],sigma=sigma),label=self.labels[i])) self.plotl.append( self.ax1.plot(*dos['dos'].curve(self.range, sigma=sigma), label=self.labels[i])) if xlmax is not None: plt.xlim(xmax=xlmax) if xlmin is not None: plt.xlim(xmin=xlmin) if ylmax is not None: plt.ylim(ymax=ylmax) if ylmin is not None: plt.ylim(ymin=ylmin) plt.xlabel('Energy [eV]', fontsize=18) plt.ylabel('DoS', fontsize=18) if self.ef is not None: plt.axvline(self.ef, color='k', linestyle='--') # self.ax1.annotate('Fermi level', xy=(self.ef,2), # xytext=(self.ef, 10), # arrowprops=dict(facecolor='white', shrink=0.05), # ) if len(self.labels) > 1 and legend: plt.legend(loc='best') axcolor = 'lightgoldenrodyellow' try: axsigma = plt.axes([0.2, 0.93, 0.65, 0.03], facecolor=axcolor) except AttributeError: axsigma = plt.axes([0.2, 0.93, 0.65, 0.03], axisbg=axcolor) self.ssig = Slider(axsigma, 'Smearing', 0.0, 0.4, valinit=sigma) self.ssig.on_changed(self.update) if hasattr(self, 'sdos') and self.sdos: self._set_sdos_selector() self._set_sdos() plt.show() def _set_sdos_selector(self): import matplotlib.pyplot as plt from matplotlib.widgets import RadioButtons self.sdos_selector = RadioButtons(plt.axes( [0.93, 0.05, 0.04, 0.11], axisbg='lightgoldenrodyellow'), ('x', 'y', 'z'), active=1) self.isdos = 1 self.sdos_selector.on_clicked(self._update_sdos) def _set_sdos(self): import numpy xs = self.sdos[self.isdos]['coord'] self._set_sdos_sliders(numpy.min(xs), numpy.max(xs)) self._update_sdos(0.0) # fake value as it is unused def _sdos_curve(self, sdos, vmin, vmax): import numpy xs = self.sdos[self.isdos]['coord'] imin = numpy.argmin(numpy.abs(xs - vmin)) imax = numpy.argmin(numpy.abs(xs - vmax)) doslist = sdos[self.isdos]['doslist'] # norms=self.sdos[self.isdos]['norms'][ispin] tocurve = [0.0 for i in doslist[imin]] for d in doslist[imin:imax + 1]: tocurve = [t + dd for t, dd in zip(tocurve, d)] # tocurve=numpy.sum([ d[ispin] for d in doslist[imin:imax+1]],axis=0) return tocurve # float(len(xs))/float(imax+1-imin)*tocurve,norms def _update_sdos(self, val): isdos = self.isdos if val == 'x': isdos = 0 elif val == 'y': isdos = 1 elif val == 'z': isdos = 2 if isdos != self.isdos: self.isdos = isdos self._set_sdos() vmin, vmax = (s.val for s in self.ssdos) if vmax < vmin: self.ssdos[1].set_val(vmin) vmax = vmin if vmin > vmax: self.ssdos[0].set_val(vmax) vmin = vmax # now plot the sdos curve associated to the given value sig = self.ssig.val curves = [] for dos in self.ens: if 'sdos' not in dos: continue renorms = self._sdos_curve(dos['sdos'], vmin, vmax) curve = dos['dos'].curve(self.range, sigma=sig, wgts=renorms) curves.append(curve) if hasattr(self, '_sdos_plots'): for pl, curve in zip(self._sdos_plots, curves): pl[0].set_ydata(curve[1]) else: self._sdos_plots = [] for c in curves: self._sdos_plots.append(self.ax1.plot(*c, label='sdos')) self.ax1.relim() self.ax1.autoscale_view() self.fig.canvas.draw_idle() def _set_sdos_sliders(self, cmin, cmax): import matplotlib.pyplot as plt from futile.Figures import VertSlider if hasattr(self, 'ssdos'): self.ssdos[0].ax.clear() self.ssdos[0].__init__(self.ssdos[0].ax, 'SDos', cmin, cmax, valinit=cmin) self.ssdos[1].ax.clear() self.ssdos[1].__init__(self.ssdos[1].ax, '', cmin, cmax, valinit=cmax) else: axcolor = 'red' axmin = plt.axes([0.93, 0.2, 0.02, 0.65], axisbg=axcolor) axmax = plt.axes([0.95, 0.2, 0.02, 0.65], axisbg=axcolor) self.ssdos = [ VertSlider(axmin, 'SDos', cmin, cmax, valinit=cmin), VertSlider(axmax, '', cmin, cmax, valinit=cmax) ] self.ssdos[0].valtext.set_ha('right') self.ssdos[1].valtext.set_ha('left') self.ssdos[0].on_changed(self._update_sdos) self.ssdos[1].on_changed(self._update_sdos) def update(self, val): sig = self.ssig.val for i, dos in enumerate(self.ens): self.plotl[i][0].set_ydata(dos['dos'].curve(self.range, sigma=sig)[1]) # self.plotl[i][0].set_ydata(self.curve(dos,norm=self.norms[i],sigma=sig)) self.ax1.relim() self.ax1.autoscale_view() self.fig.canvas.draw_idle()
def GUI(self): # ,makefigs=True): print('I am here') mpl.rcParams['toolbar'] = 'None' self.Nphf = self.Npix / 2 self.robfac = 0.0 self.figSPEC = pl.figure(figsize=(20, 16)) # self.gs1 = self.figSPEC.add_gridspec(nrows=4, ncols=3, left=0.05, right=0.48, # wspace=0.05) if self.tks is None: self.canvas = self.figSPEC.canvas else: self.canvas = FigureCanvasTkAgg(self.figSPEC, master=self.tks) self.canvas.show() menubar = Tk.Menu(self.tks) menubar.add_command(label="Help", command=self._getHelp) menubar.add_command(label="Quit", command=self.quit) self.tks.config(menu=menubar) self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) self.specPlot = self.figSPEC.add_subplot(221) self.freqPlot = self.figSPEC.add_subplot(222) self.timePlot = self.figSPEC.add_subplot(223) # self.eventprofilePlot = self.figSPEC.add_subplot(224) self.specPlot.set_position([0.1, 0.45, 0.45, 0.45]) self.freqPlot.set_position([0.58, 0.45, 0.125, 0.45]) self.timePlot.set_position([0.1, 0.28, 0.45, 0.15]) # self.dirtyPlot = self.figUV.add_subplot(236,aspect='equal') #self.spherePlot = pl.axes([0.53,0.82,0.12,0.12],projection='3d',aspect='equal') u = np.linspace(0, 2 * np.pi, 100) v = np.linspace(0, np.pi, 100) x = 10 * np.outer(np.cos(u), np.sin(v)) y = 10 * np.outer(np.sin(u), np.sin(v)) z = 10 * np.outer(np.ones(np.size(u)), np.cos(v)) #self.spherePlotPlot = self.spherePlot.plot_surface(x, y, z, rstride=4, cstride=4, color=(0.8,0.8,1.0)) #self.spherePlot._axis3don = False #self.spherePlot.patch.set_alpha(0.8) #beta = np.zeros(100) #self.arrayPath = [np.zeros(self.nH), np.zeros(self.nH), np.zeros(self.nH)] #self.sphereArray = self.spherePlot.plot([],[],[],'y',linewidth=3) #self.spherePlot.set_xlim3d((-6,6)) #self.spherePlot.set_ylim3d((-6,6)) #self.spherePlot.set_zlim3d((-6,6)) #self.spherePlot.patch.set_alpha(0.8) #self.spherePlot.elev = 45. self.canvas.mpl_connect('button_press_event', self.on_press) #self.figSPEC.subplots_adjust(left=0.01,right=0.99,top=0.95,bottom=0.071,hspace=0.15) #self.canvas.mpl_connect('mouse_event', self.mouse_move) #self.canvas.mpl_connect('motion_notify_event', self._onAntennaDrag) #self.canvas.mpl_connect('button_release_event',self._onRelease) #self.canvas.mpl_connect('button_press_event',self._onPress) #self.canvas.mpl_connect('key_press_event', self._onKeyPress) self.pickAnt = False self.fmtH = r'$\phi = $ %3.1f$^\circ$ $\delta = $ %3.1f$^\circ$' "\n" r'H = %3.1fh / %3.1fh' self.fmtBas = r'Bas %i $-$ %i at H = %4.2fh' self.fmtVis = r'Amp: %.1e Jy. Phase: %5.1f deg.' self.fmtA = 'N = %i' self.fmtA2 = ' Picked Ant. #%i' self.fmtA3 = '\n%6.1fm | %6.1fm' self.wax = {} self.widget = {} self.wax['freq'] = pl.axes([0.075, 0.15, 0.1, 0.04]) self.wax['freq_min'] = pl.axes([0.4, 0.15, 0.1, 0.04]) self.wax['freq_max'] = pl.axes([0.6, 0.15, 0.1, 0.04]) self.wax['smooth'] = pl.axes([0.045, 0.25, 0.1, 0.04]) self.wax['open'] = pl.axes([0.002, 0.90, 0.075, 0.04]) self.wax['plot'] = pl.axes([0.003, 0.8, 0.075, 0.04]) self.wax['reduce'] = pl.axes([0.07, 0.1, 0.25, 0.04]) self.widget['freq'] = Slider(self.wax['freq'], r'frequency', self.st_freq, self.stp_freq, valinit=80.0) self.widget['freq_min'] = Slider(self.wax['freq_min'], r'frequency_min', self.st_freq, self.stp_freq, valinit=45.0) self.widget['freq_max'] = Slider(self.wax['freq_max'], r'frequency_max', self.st_freq, self.stp_freq, valinit=155.0) self.widget['smooth'] = Slider(self.wax['smooth'], r'smooth', valmin=1, valmax=101, valinit=51.0) self.widget['open'] = Button(self.wax['open'], r' Open File') self.widget['plot'] = Button(self.wax['plot'], r' plot') self.widget['reduce'] = Button(self.wax['reduce'], r'Reduce data') self.widget['freq'].on_changed(self.onFreq) self.widget['freq_min'].on_changed(self.onFreq_min_axis_change) self.widget['freq_max'].on_changed(self.onFreq_max_axis_change) self.widget['smooth'].on_changed(self.onSmooth) # self.widget['loadfile'].on_clicked(self.loadFile) self.widget['open'].on_clicked(self.loadFile) self.widget['plot'].on_clicked(self.onPlot) self._prepareSpec_data() self.canvas.draw()
def draw(os, rays=None, hold_on=False, do_not_draw_surfaces=[], do_not_draw_raybundles=[], interactive=False, show_box=True, label=None, linewidth=1.0, export_type="pdf", export=None, **kwargs): """ Convenience function for drawing optical system and list of raybundles Use figsize=(..,..) to control aspect ratio for export. :param os - OpticalSystem :param rb - list of raybundles """ if export is not None: interactive = False if label is None: label = str(uuid.uuid4()) axis_color = "lightgoldenrodyellow" dpi = kwargs.pop("dpi", None) figsize = kwargs.pop("figsize", None) fig = plt.figure(1, dpi=dpi, figsize=figsize) if not show_box: ax = plt.Axes(fig, [0., 0., 1., 1.], label=label) ax.set_axis_off() fig.add_axes(ax) else: ax = fig.add_subplot(1, 1, 1, label=label) if interactive: fig.subplots_adjust(left=0.25, bottom=0.25) xz_angle_slider_size = [0.25, 0.15, 0.65, 0.03] up_angle_slider_size = [0.25, 0.10, 0.65, 0.03] if StrictVersion(matplotlib.__version__) < StrictVersion("2.0.0"): xz_angle_slider_ax = fig.add_axes(xz_angle_slider_size, axisbg=axis_color) up_angle_slider_ax = fig.add_axes(up_angle_slider_size, axisbg=axis_color) else: xz_angle_slider_ax = fig.add_axes(xz_angle_slider_size, facecolor=axis_color) up_angle_slider_ax = fig.add_axes(up_angle_slider_size, facecolor=axis_color) xz_angle_slider = Slider(xz_angle_slider_ax, "XZ angle", 0.0, 360.0, valinit=0.0, valfmt="%0.0f") up_angle_slider = Slider(up_angle_slider_ax, "UP angle", 0.0, 360.0, valinit=0.0, valfmt="%0.0f") ax.axis("equal") if StrictVersion(matplotlib.__version__) < StrictVersion("2.0.0"): ax.set_axis_bgcolor("white") else: ax.set_facecolor("white") def draw_rays(ax, rays, do_not_draw_raybundles=[], **kwargs): if rays is not None: if isinstance(rays, list): for rpl in rays: ray_color = tuple(np.random.random(3)) if isinstance(rpl, list): for rp in rpl: ray_color = tuple(np.random.random(3)) rp.draw2d( ax, color=ray_color, do_not_draw_raybundles=do_not_draw_raybundles, **kwargs) elif isinstance(rpl, tuple): (rl, ray_color) = rpl if isinstance(rl, list): # draw(s, [([rp1, ..], color1), (....)]) for r in rl: r.draw2d(ax, color=ray_color, **kwargs) else: # draw(s, [(rp1, color1), (....)]) rl.draw2d(ax, color=ray_color, **kwargs) else: rpl.draw2d( ax, color=ray_color, do_not_draw_raybundles=do_not_draw_raybundles, **kwargs) elif isinstance(rays, RayPath): # draw(s, raypath) ray_color = tuple(np.random.random(3)) rays.draw2d(ax, color=ray_color, do_not_draw_raybundles=do_not_draw_raybundles, **kwargs) elif isinstance(rays, RayBundle): # draw(s, raybundle) ray_color = tuple(np.random.random(3)) rays.draw2d(ax, color=ray_color, **kwargs) elif isinstance(rays, tuple): (rl, ray_color) = rays if isinstance(rl, list): # draw(s, ([raypath1, ...], color)) for r in rl: r.draw2d(ax, color=ray_color, **kwargs) else: # draw(s, (raypath, color)) rl.draw2d(ax, color=ray_color, do_not_draw_raybundles=do_not_draw_raybundles, **kwargs) def sliders_on_changed(val): ax.clear() round_val_xz = np.round(xz_angle_slider.val) round_val_up = np.round(up_angle_slider.val) phi = round_val_xz * degree theta = round_val_up * degree # new_ex = np.array([np.cos(phi), # 0, # np.sin(phi)]) # new_up = np.array([-np.sin(theta), # np.cos(theta), # 0.]) new_ex = np.array([ np.cos(phi) * np.cos(theta), np.sin(theta), np.sin(phi) * np.cos(theta) ]) new_up = np.array([ -np.cos(phi) * np.sin(theta), np.cos(theta), -np.sin(phi) * np.sin(theta) ]) inyzplane = np.abs(round_val_xz) < numerical_tolerance\ and np.abs(round_val_up) < numerical_tolerance os.draw2d(ax, color="grey", inyzplane=inyzplane, plane_normal=new_ex, up=new_up, **kwargs) draw_rays(ax, rays, plane_normal=new_ex, up=new_up, **kwargs) if interactive: xz_angle_slider.on_changed(sliders_on_changed) up_angle_slider.on_changed(sliders_on_changed) draw_rays(ax, rays, linewidth=linewidth, do_not_draw_raybundles=do_not_draw_raybundles, **kwargs) os.draw2d(ax, color="grey", linewidth=linewidth, do_not_draw_surfaces=do_not_draw_surfaces, **kwargs) if export is not None: # ax.autoscale(enable=True, axis='both', tight=True) fig.savefig(export, format=export_type, bbox_inches='tight', pad_inches=0) if not hold_on: plt.show()
def _add_teach_panel(self, robot): fig = self.fig # Add text to the plots def text_trans(text): # pragma: no cover T = robot.fkine() t = np.round(T.t, 3) r = np.round(T.rpy(), 3) text[0].set_text("x: {0}".format(t[0])) text[1].set_text("y: {0}".format(t[1])) text[2].set_text("yaw: {0}".format(r[2])) # Update the self state in mpl and the text def update(val, text, robot): # pragma: no cover for i in range(robot.n): robot.q[i] = self.sjoint[i].val * np.pi/180 text_trans(text) # Step the environment self.step(0) fig.subplots_adjust(left=0.38) text = [] x1 = 0.04 x2 = 0.22 yh = 0.04 ym = 0.5 - (robot.n * yh) / 2 + 0.17/2 self.axjoint = [] self.sjoint = [] qlim = np.copy(robot.qlim) * 180/np.pi if np.all(qlim == 0): # pragma nocover qlim[0, :] = -180 qlim[1, :] = 180 # Set the pose text T = robot.fkine() t = np.round(T.t, 3) r = np.round(T.rpy(), 3) fig.text( 0.02, 1 - ym + 0.25, "End-effector Pose", fontsize=9, weight="bold", color="#4f4f4f") text.append(fig.text( 0.03, 1 - ym + 0.20, "x: {0}".format(t[0]), fontsize=9, color="#2b2b2b")) text.append(fig.text( 0.03, 1 - ym + 0.16, "y: {0}".format(t[1]), fontsize=9, color="#2b2b2b")) text.append(fig.text( 0.15, 1 - ym + 0.20, "yaw: {0}".format(r[0]), fontsize=9, color="#2b2b2b")) fig.text( 0.02, 1 - ym + 0.06, "Joint angles", fontsize=9, weight="bold", color="#4f4f4f") for i in range(robot.n): ymin = (1 - ym) - i * yh self.axjoint.append( fig.add_axes([x1, ymin, x2, 0.03], facecolor='#dbdbdb')) self.sjoint.append( Slider( self.axjoint[i], 'q' + str(i), qlim[0, i], qlim[1, i], robot.q[i] * 180/np.pi)) self.sjoint[i].on_changed(lambda x: update(x, text, robot))
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 6)) fig.subplots_adjust(bottom=0.25) ax.set_xlabel('Time', fontsize=14) ax.set_ylabel('', fontsize=14) ax.set_title('Michaelis Menten', fontsize=14) l1, l2, l3, l4 = ax.plot(time, res) l1.set_label('$dS$') l2.set_label('$dE$') l3.set_label('$dES$') l4.set_label('$dP$') ax.margins(x=0) axcolor = 'lightgoldenrodyellow' axkf = plt.axes([.25, .02, .65, .03], facecolor=axcolor) axkb = plt.axes([.25, .07, .65, .03], facecolor=axcolor) axki = plt.axes([.25, .12, .65, .03], facecolor=axcolor) skf = Slider(axkf, r'$k_f$', 0., 10., valinit=kf, valstep=.1) skb = Slider(axkb, r'$k_b$', 0., 10., valinit=kb, valstep=.1) ski = Slider(axki, r'Kirr', 0., 10., valinit=Kirr, valstep=.1) skf.on_changed(update) skb.on_changed(update) ski.on_changed(update) ax.legend(loc='best', fontsize=14) plt.show()
g1.set_xlabel("temps (s)") ls,=g1.plot(t,resolution(0,1)[1],"r-",label="Amplitude du système") lf,=g1.plot(t,sin(w_forcage*t),"g-",label="Force excitatrice") legend() show() ''' ajuster la pulsation de l'excitateur par ui avec un curseur ''' subplots_adjust(bottom=0.3)#réduit g1 pour laisser palce au slider rect=f.add_axes([0.1,0.12,0.8,0.03])#emplacement du curseur slider=Slider(rect,r"$\frac{\omega_{forçage}}{\omega _0}$",0.01,2,1)#paramètres du curseur slider.label.set_size(30) rect2=f.add_axes([0.1,0.05,0.8,0.03])#emplacement du curseur slider2=Slider(rect2,r"$\Gamma$",0.01,2,1)#paramètres du curseur slider2.label.set_size(30) def maj(_):#met à jour l1 avec les valeurs du curseur global w_forcage global gamma w_forcage=slider.val gamma=slider2.val ls.set_ydata(resolution(0,1)[1]) lf.set_ydata(sin(w_forcage*t)) slider.on_changed(maj) slider2.on_changed(maj)
class NormalizedWormPlottable(animation.TimedAnimation): """ A class that renders matplotlib plots of worm measurement and feature data. This follows the [animated subplots example] (http://matplotlib.org/1.3.0/examples/animation/subplots.html) in inheriting from TimedAnimation rather than using PyLab-shell-type calls to construct the animation. """ def __init__(self, normalized_worm, motion_mode=None, interactive=False, interpolate_nan_frames=False): """ Initialize the animation of the worm's attributes. Parameters --------------------------------------- normalized_worm: NormalizedWorm the NormalizedWorm object to be plotted. motion_mode: 1-dimensional numpy array (optional) The motion mode of the worm over time. Must have length = normalized_worm.num_frames interactive: boolean (optional) if interactive is set to False, then: suppress the drawing of the figure, until an explicit plt.show() is called. this allows NormalizedWormPlottable to be instantiated without just automatically being displayed. Instead, the user must call NormalizedWormPlottable.show() to have plt.show() be called. interpolate_nan_frames: interpolate the flickering nan frames Note: this is currently not implemented Notes --------------------------------------- To initialize the animation, we must do six things: 1. set up the data to be used from the normalized_worm 2. create the figure 3. create subplots in the figure, assigning them Axis handles 4. create Artist objects for all objects in the subplots 5. assign the Artist objects to the correct Axis handle 6. call the base class __init__ """ # A NormalizedWormPlottable instance can be instantiated to be # interactive, or by default it is set to NOT interactive, which # means that NormalizedWormPlottable.show() must be called to get # it to display. plt.interactive(interactive) self._paused = False # 1. set up the data to be used self.nw = normalized_worm self.motion_mode = motion_mode self.motion_mode_options = {-1: 'backward', 0: 'paused', 1: 'forward'} self.motion_mode_colours = { -1: 'b', # blue 0: 'r', # red 1: 'g' } # green # 2. create the figure fig = plt.figure(figsize=(5, 5)) # We have blit=True, so the animation only redraws the elements that # have changed. This means that if the window is resized, everything # other than the plot area will be black. To fix this, here we have # matplotlib explicitly redraw everything if a resizing event occurs. # DEBUG: this actually doesn't appear to work. def refresh_plot(event): print("refresh_plot called") # We must reset this or else repetitive expanding and contracting # of the window will cause the view to zoom in on the subplots self.set_axes_extents() fig.canvas.draw() self.refresh_connection_id = fig.canvas.mpl_connect( 'resize_event', refresh_plot) fig.suptitle('C. elegans attributes', fontsize=20) # 3. Add the subplots self.ax1 = plt.subplot2grid((3, 3), (0, 0), rowspan=2, colspan=2) self.ax1.set_title('Position') self.ax1.plot(self.nw.skeleton[0, 0, :], self.nw.skeleton[0, 1, :]) self.ax1.set_xlabel('x') self.ax1.set_ylabel('y') #ax1.set_aspect(aspect='equal', adjustable='datalim') # ax1.set_autoscale_on() self.annotation1a = \ self.ax1.annotate("(motion mode data not available)", xy=(-10, 10), xycoords='axes points', horizontalalignment='right', verticalalignment='top', fontsize=10) self.annotation1b = \ self.ax1.annotate("bottom right (points)", xy=(-10, 10), xycoords='axes points', horizontalalignment='right', verticalalignment='bottom', fontsize=10) # WIDGETS # [left,botton,width,height] as a proportion of # figure width and height frame_slider_axes = fig.add_axes([0.2, 0.02, 0.33, 0.02], axisbg='lightgoldenrodyellow') self.frame_slider = Slider(frame_slider_axes, label='Frame#', valmin=1, valmax=self.nw.num_frames, valinit=1, valfmt=u'%d') def frame_slider_update(val): print("Slider value: %d" % round(val, 0)) self.frame_seq = self.new_frame_seq(int(round(val, 0))) fig.canvas.draw() self.frame_slider.on_changed(frame_slider_update) button_axes = fig.add_axes([0.8, 0.025, 0.1, 0.04]) #ax4 = plt.subplot2grid((3, 3), (2, 2)) button = Button(button_axes, 'Pause', color='lightgoldenrodyellow', hovercolor='0.975') def pause(event): if not self._paused: self._stop() else: self.event_source = fig.canvas.new_timer() self.event_source.interval = self._interval self._start() # Toggle the paused state self._paused = 1 - self._paused button.on_clicked(pause) self.ax2 = plt.subplot2grid((3, 3), (0, 2)) self.ax2.set_title('Morphology') self.ax2.set_aspect(aspect='equal', adjustable='datalim') self.annotation2 = self.ax2.annotate( "Worm head", xy=(0, 0), xycoords='data', xytext=(10, 10), textcoords='data', arrowprops=dict(arrowstyle="fancy", connectionstyle="arc3,rad=.2")) self.ax3 = plt.subplot2grid((3, 3), (1, 2)) self.ax3.set_title('Orientation-free') # DON'T USE set_xbound, it changes dynmically self.ax3.set_aspect(aspect='equal', adjustable='datalim') # Length and Area over time self.ax4a = plt.subplot2grid((3, 3), (2, 0), rowspan=1, colspan=2) self.ax4a.plot(self.nw.length, 'o-') self.ax4a.set_title('Length and Area over time') self.ax4a.set_ylabel('Microns') self.ax4b = self.ax4a.twinx() self.ax4b.plot(self.nw.area, 'xr-') self.ax4b.set_ylabel('Microns ^ 2') # Widths and Angles self.ax5a = plt.subplot2grid((3, 3), (2, 2)) self.ax5a.set_title('Widths and Angles') self.ax5a.set_xlabel('Skeleton point') self.widths = Line2D([], []) self.ax5a.set_ylabel('Microns') self.ax5b = self.ax5a.twinx() self.angles = Line2D([], []) self.ax5b.set_ylabel('Degrees') # 4. create Artist objects self.time_marker = Line2D([], []) self.line1W = Line2D([], [], color='green', linestyle='point marker', marker='o', markersize=5) self.line1W_head = Line2D([], [], color='red', linestyle='point marker', marker='o', markersize=7) self.line1C = Line2D([], [], color='yellow', linestyle='point marker', marker='o', markersize=5) self.patch1E = Ellipse(xy=(0, 0), width=1000, height=500, angle=0, alpha=0.3) self.line2W = Line2D([], [], color='black', marker='o', markersize=5) self.line2W_head = Line2D([], [], color='red', linestyle='point marker', marker='o', markersize=7) self.line2C = Line2D([], [], color='blue') self.line2C2 = Line2D([], [], color='orange') self.line3W = Line2D([], [], color='black', marker='o', markersize=5) self.line3W_head = Line2D([], [], color='red', linestyle='point marker', marker='o', markersize=7) self.artists_with_data = [ self.line1W, self.line1W_head, self.line1C, self.line2W, self.line2W_head, self.line2C, self.line2C2, self.line3W, self.line3W_head, self.widths, self.angles, self.time_marker ] # This list is a superset of self.artists_with_data self.artists_to_be_drawn = ([ self.patch1E, self.annotation1a, self.annotation1b, self.annotation2 ] + self.artists_with_data) self.set_axes_extents() # 5. assign Artist objects to the relevant subplot self.ax1.add_line(self.line1W) self.ax1.add_line(self.line1W_head) self.ax1.add_line(self.line1C) self.ax1.add_artist(self.patch1E) self.ax2.add_line(self.line2W) self.ax2.add_line(self.line2W_head) self.ax2.add_line(self.line2C) self.ax2.add_line(self.line2C2) self.ax3.add_line(self.line3W) self.ax3.add_line(self.line3W_head) self.ax4a.add_line(self.time_marker) self.ax5a.add_line(self.widths) self.ax5b.add_line(self.angles) # So labels don't overlap: #plt.tight_layout() # 6. call the base class __init__ # TimedAnimation draws a new frame every *interval* milliseconds. # so this is how we convert from FPS to interval: interval = 1000 / self.nw.video_info.fps return animation.TimedAnimation.__init__(self, fig, interval=interval, blit=True) def set_axes_extents(self): # DON'T USE set_xbound; it changes dynamically self.ax1.set_xlim(self.nw.position_limits(0)) self.ax1.set_ylim(self.nw.position_limits(1)) self.ax2.set_xlim((-500, 500)) self.ax2.set_ylim((-500, 500)) self.ax3.set_xlim((-800, 800)) self.ax3.set_ylim((-500, 500)) self.ax4a.set_xlim((0, self.nw.num_frames)) self.ax5a.set_xlim((0, 49)) self.ax5a.set_ylim((0, np.nanmax(self.nw.widths))) self.ax5b.set_ylim( (np.nanmin(self.nw.angles), np.nanmax(self.nw.angles))) def set_frame_data(self, frame_index): self._current_frame = frame_index i = frame_index if self._paused: return self.line1W.set_data(self.nw.skeleton[:, 0, i], self.nw.skeleton[:, 1, i]) self.line1W_head.set_data(self.nw.skeleton[0, 0, i], self.nw.skeleton[0, 1, i]) self.line1C.set_data(self.nw.ventral_contour[:, 0, i], self.nw.ventral_contour[:, 1, i]) self.patch1E.center = (self.nw.centre[:, i]) # skeleton centre self.patch1E.angle = self.nw.angle[i] # orientation # Set the values of our annotation text in the main subplot: if self.motion_mode is not None: if np.isnan(self.motion_mode[i]): self.patch1E.set_facecolor('w') self.annotation1a.set_text("Motion mode: {}".format('NaN')) else: # Set the colour of the ellipse surrounding the worm to a # colour corresponding to the current motion mode of the worm self.patch1E.set_facecolor( self.motion_mode_colours[self.motion_mode[i]]) # Annotate the current motion mode of the worm in text self.annotation1a.set_text("Motion mode: {}".format( self.motion_mode_options[self.motion_mode[i]])) self.annotation1b.set_text("Frame {} of {}".format(i, self.num_frames)) self.line2W.set_data(self.nw.centred_skeleton[:, 0, i], self.nw.centred_skeleton[:, 1, i]) self.line2W_head.set_data(self.nw.centred_skeleton[0, 0, i], self.nw.centred_skeleton[0, 1, i]) self.line2C.set_data(self.nw.centred_skeleton[:, 0, i] + \ (self.nw.ventral_contour[:, 0, i] - self.nw.skeleton[:, 0, i]), self.nw.centred_skeleton[:, 1, i] + \ (self.nw.ventral_contour[:, 1, i] - self.nw.skeleton[:, 1, i])) self.line2C2.set_data( self.nw.centred_skeleton[:, 0, i] + (self.nw.dorsal_contour[:, 0, i] - self.nw.skeleton[:, 0, i]), self.nw.centred_skeleton[:, 1, i] + (self.nw.dorsal_contour[:, 1, i] - self.nw.skeleton[:, 1, i])) self.annotation2.xy = (self.nw.centred_skeleton[0, 0, i], self.nw.centred_skeleton[0, 1, i]) self.line3W.set_data(self.nw.orientation_free_skeleton[:, 0, i], self.nw.orientation_free_skeleton[:, 1, i]) self.line3W_head.set_data(self.nw.orientation_free_skeleton[0, 0, i], self.nw.orientation_free_skeleton[0, 1, i]) self.widths.set_data(np.arange(49), self.nw.widths[:, i]) self.angles.set_data(np.arange(49), self.nw.angles[:, i]) # Draw a vertical line to mark the passage of time self.time_marker.set_data([i, i], [0, 10000]) @property def num_frames(self): """ Return the total number of frames in the animation """ return self.nw.num_frames def show(self): """ Draw the figure in a window on the screen """ plt.show() def _draw_frame(self, frame_index): """ Called sequentially for each frame of the animation. Thus we must set our plot to look like it should for the given frame. Parameters --------------------------------------- frame_index: int An integer between 0 and the number of frames, giving the current frame. """ # Make the canvas elements visible now # (We made them invisible in _init_draw() so that the first # frame of the animation wouldn't remain stuck on the canvas) for l in self.artists_to_be_drawn: l.set_visible(True) self.set_frame_data(frame_index) self._drawn_artists = self.artists_to_be_drawn def new_frame_seq(self, start_frame=0): """ Returns an iterator that iterates over the frames in the animation Parameters --------------- start_frame: int Start the sequence at this frame then loop back around to start_frame-1. """ s = start_frame n = self.num_frames return iter(np.mod(np.arange(s, s + n), n)) def _init_draw(self): """ Called when first drawing the animation. It is an abstract method in Animation, to be implemented here for the first time. """ for l in self.artists_with_data: l.set_data([], []) # Keep the drawing elements invisible for the first frame to avoid # the first frame remaining on the canvas for l in self.artists_to_be_drawn: l.set_visible(False) def save(self, filename, file_title='C. elegans movement video', file_comment='C. elegans movement video from Schafer lab'): """ Save the animation as an mp4. Parameters --------------------------------------- filename: string The name of the file to be saved as an mp4. file_title: string (optional) A title to be embedded in the file's saved metadata. file_comment: string (optional) A comment to be embedded in the file's saved metadata. Notes --------------------------------------- Requires ffmpeg or mencoder to be installed. To install ffmpeg on Windows, see: http://www.wikihow.com/Install-FFmpeg-on-Windows The code specifies extra_args=['-vcodec', 'libx264'], to ensure that the x264 codec is used, so that the video can be embedded in html5. You may need to adjust this for your system. For more information, see: http://matplotlib.sourceforge.net/api/animation_api.html """ fps = self.nw.video_info.fps FFMpegWriter = animation.writers['ffmpeg'] metadata = dict(title=file_title, artist='matplotlib', comment=file_comment) writer = FFMpegWriter(fps=fps, metadata=metadata) animation.TimedAnimation.save(self, filename, writer=writer, fps=fps, extra_args=['-vcodec', 'libx264'])
# plotting code snippet taken from # https://stackoverflow.com/questions/31001713/plotting-the-data-with-scrollable-x-time-horizontal-axis-on-linux fig, ax = plt.subplots(figsize=(12, 5)) plt.subplots_adjust(bottom=0.25, left=0.1) t = np.arange(0.0, length / 10, 0.1) l1, = plt.plot(t, xs, color='blue', label="xs") l2, = plt.plot(t, ys, color='green', label="ys") l3, = plt.plot(t, zs, color='red', label="zs") plt.legend(loc="lower left") plt.xlabel("Time (sec)") plt.ylabel("Acceleration (cm/s^2)") plt.grid() plt.axis([0, 5, -3000, 3000]) axcolor = 'lightgoldenrodyellow' axpos = plt.axes([0.2, 0.1, 0.65, 0.03], facecolor=axcolor) spos = Slider(axpos, 'Second', 0.1, float((length / 10) - 5)) def update(val): pos = spos.val ax.axis([pos, pos + 5, -3000, 3000]) fig.canvas.draw_idle() spos.on_changed(update) plt.show()
l.append(0) v.append(0) l[k] = ax.plot(omega/(2*np.pi), var_plot, '-') #, label='Mismatch phase = {}°'.format(phase_mm[k] * 180 / np.pi) # plt.legend() v[k] = ax.plot(omega/(2*np.pi), var_plot_vac, '--', color='black', linewidth=1) if sliders: axcolor = 'lightgoldenrodyellow' axangle = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor) axdetuning = plt.axes([0.25, 0.15, 0.65, 0.03], facecolor=axcolor) axtransmission = plt.axes([0.25, 0.2, 0.65, 0.03], facecolor=axcolor) axfreqmin = plt.axes([0.25, 0.25, 0.1, 0.05], facecolor=axcolor) axfreqmax = plt.axes([0.6, 0.25, 0.1, 0.05], facecolor=axcolor) sangle = Slider(axangle, 'Homodyne angle (°)', 0, 180, valinit=angle_init, valstep=angle_step) sdetuning = Slider(axdetuning, 'Detuning (MHz)', detuning_min, detuning_max, valinit=detuning_init, valstep=detuning_step) stransmission = Slider(axtransmission, 'Input mirror transmission', transmission_min, transmission_max, valinit=transmission_init, valstep=transmission_step) sfreqmin = TextBox(axfreqmin, 'Min frequency (MHz)', initial=str(freq_min * 1e-6), color='.95', hovercolor='1') sfreqmax = TextBox(axfreqmax, 'Max frequency (MHz)', initial=str(freq_max * 1e-6), color='.95', hovercolor='1') def update(val): angle = np.pi * sangle.val /180 detuning = 2 * np.pi * sdetuning.val * 1e6 transmission = stransmission.val omega_min = 2 * np.pi * float(sfreqmin.text) * 1e6 #s-1 omega_max = 2 * np.pi * float(sfreqmax.text) * 1e6 #s-1 <- range of sideband frequencies observed # nb_freq = 1000 # <- freq resolution omega = np.linspace(omega_min, omega_max, nb_freq) for k in range(len(phase_mm)): var_plot = np.zeros(nb_freq)
def __init__(self, normalized_worm, motion_mode=None, interactive=False, interpolate_nan_frames=False): """ Initialize the animation of the worm's attributes. Parameters --------------------------------------- normalized_worm: NormalizedWorm the NormalizedWorm object to be plotted. motion_mode: 1-dimensional numpy array (optional) The motion mode of the worm over time. Must have length = normalized_worm.num_frames interactive: boolean (optional) if interactive is set to False, then: suppress the drawing of the figure, until an explicit plt.show() is called. this allows NormalizedWormPlottable to be instantiated without just automatically being displayed. Instead, the user must call NormalizedWormPlottable.show() to have plt.show() be called. interpolate_nan_frames: interpolate the flickering nan frames Note: this is currently not implemented Notes --------------------------------------- To initialize the animation, we must do six things: 1. set up the data to be used from the normalized_worm 2. create the figure 3. create subplots in the figure, assigning them Axis handles 4. create Artist objects for all objects in the subplots 5. assign the Artist objects to the correct Axis handle 6. call the base class __init__ """ # A NormalizedWormPlottable instance can be instantiated to be # interactive, or by default it is set to NOT interactive, which # means that NormalizedWormPlottable.show() must be called to get # it to display. plt.interactive(interactive) self._paused = False # 1. set up the data to be used self.nw = normalized_worm self.motion_mode = motion_mode self.motion_mode_options = {-1: 'backward', 0: 'paused', 1: 'forward'} self.motion_mode_colours = { -1: 'b', # blue 0: 'r', # red 1: 'g' } # green # 2. create the figure fig = plt.figure(figsize=(5, 5)) # We have blit=True, so the animation only redraws the elements that # have changed. This means that if the window is resized, everything # other than the plot area will be black. To fix this, here we have # matplotlib explicitly redraw everything if a resizing event occurs. # DEBUG: this actually doesn't appear to work. def refresh_plot(event): print("refresh_plot called") # We must reset this or else repetitive expanding and contracting # of the window will cause the view to zoom in on the subplots self.set_axes_extents() fig.canvas.draw() self.refresh_connection_id = fig.canvas.mpl_connect( 'resize_event', refresh_plot) fig.suptitle('C. elegans attributes', fontsize=20) # 3. Add the subplots self.ax1 = plt.subplot2grid((3, 3), (0, 0), rowspan=2, colspan=2) self.ax1.set_title('Position') self.ax1.plot(self.nw.skeleton[0, 0, :], self.nw.skeleton[0, 1, :]) self.ax1.set_xlabel('x') self.ax1.set_ylabel('y') #ax1.set_aspect(aspect='equal', adjustable='datalim') # ax1.set_autoscale_on() self.annotation1a = \ self.ax1.annotate("(motion mode data not available)", xy=(-10, 10), xycoords='axes points', horizontalalignment='right', verticalalignment='top', fontsize=10) self.annotation1b = \ self.ax1.annotate("bottom right (points)", xy=(-10, 10), xycoords='axes points', horizontalalignment='right', verticalalignment='bottom', fontsize=10) # WIDGETS # [left,botton,width,height] as a proportion of # figure width and height frame_slider_axes = fig.add_axes([0.2, 0.02, 0.33, 0.02], axisbg='lightgoldenrodyellow') self.frame_slider = Slider(frame_slider_axes, label='Frame#', valmin=1, valmax=self.nw.num_frames, valinit=1, valfmt=u'%d') def frame_slider_update(val): print("Slider value: %d" % round(val, 0)) self.frame_seq = self.new_frame_seq(int(round(val, 0))) fig.canvas.draw() self.frame_slider.on_changed(frame_slider_update) button_axes = fig.add_axes([0.8, 0.025, 0.1, 0.04]) #ax4 = plt.subplot2grid((3, 3), (2, 2)) button = Button(button_axes, 'Pause', color='lightgoldenrodyellow', hovercolor='0.975') def pause(event): if not self._paused: self._stop() else: self.event_source = fig.canvas.new_timer() self.event_source.interval = self._interval self._start() # Toggle the paused state self._paused = 1 - self._paused button.on_clicked(pause) self.ax2 = plt.subplot2grid((3, 3), (0, 2)) self.ax2.set_title('Morphology') self.ax2.set_aspect(aspect='equal', adjustable='datalim') self.annotation2 = self.ax2.annotate( "Worm head", xy=(0, 0), xycoords='data', xytext=(10, 10), textcoords='data', arrowprops=dict(arrowstyle="fancy", connectionstyle="arc3,rad=.2")) self.ax3 = plt.subplot2grid((3, 3), (1, 2)) self.ax3.set_title('Orientation-free') # DON'T USE set_xbound, it changes dynmically self.ax3.set_aspect(aspect='equal', adjustable='datalim') # Length and Area over time self.ax4a = plt.subplot2grid((3, 3), (2, 0), rowspan=1, colspan=2) self.ax4a.plot(self.nw.length, 'o-') self.ax4a.set_title('Length and Area over time') self.ax4a.set_ylabel('Microns') self.ax4b = self.ax4a.twinx() self.ax4b.plot(self.nw.area, 'xr-') self.ax4b.set_ylabel('Microns ^ 2') # Widths and Angles self.ax5a = plt.subplot2grid((3, 3), (2, 2)) self.ax5a.set_title('Widths and Angles') self.ax5a.set_xlabel('Skeleton point') self.widths = Line2D([], []) self.ax5a.set_ylabel('Microns') self.ax5b = self.ax5a.twinx() self.angles = Line2D([], []) self.ax5b.set_ylabel('Degrees') # 4. create Artist objects self.time_marker = Line2D([], []) self.line1W = Line2D([], [], color='green', linestyle='point marker', marker='o', markersize=5) self.line1W_head = Line2D([], [], color='red', linestyle='point marker', marker='o', markersize=7) self.line1C = Line2D([], [], color='yellow', linestyle='point marker', marker='o', markersize=5) self.patch1E = Ellipse(xy=(0, 0), width=1000, height=500, angle=0, alpha=0.3) self.line2W = Line2D([], [], color='black', marker='o', markersize=5) self.line2W_head = Line2D([], [], color='red', linestyle='point marker', marker='o', markersize=7) self.line2C = Line2D([], [], color='blue') self.line2C2 = Line2D([], [], color='orange') self.line3W = Line2D([], [], color='black', marker='o', markersize=5) self.line3W_head = Line2D([], [], color='red', linestyle='point marker', marker='o', markersize=7) self.artists_with_data = [ self.line1W, self.line1W_head, self.line1C, self.line2W, self.line2W_head, self.line2C, self.line2C2, self.line3W, self.line3W_head, self.widths, self.angles, self.time_marker ] # This list is a superset of self.artists_with_data self.artists_to_be_drawn = ([ self.patch1E, self.annotation1a, self.annotation1b, self.annotation2 ] + self.artists_with_data) self.set_axes_extents() # 5. assign Artist objects to the relevant subplot self.ax1.add_line(self.line1W) self.ax1.add_line(self.line1W_head) self.ax1.add_line(self.line1C) self.ax1.add_artist(self.patch1E) self.ax2.add_line(self.line2W) self.ax2.add_line(self.line2W_head) self.ax2.add_line(self.line2C) self.ax2.add_line(self.line2C2) self.ax3.add_line(self.line3W) self.ax3.add_line(self.line3W_head) self.ax4a.add_line(self.time_marker) self.ax5a.add_line(self.widths) self.ax5b.add_line(self.angles) # So labels don't overlap: #plt.tight_layout() # 6. call the base class __init__ # TimedAnimation draws a new frame every *interval* milliseconds. # so this is how we convert from FPS to interval: interval = 1000 / self.nw.video_info.fps return animation.TimedAnimation.__init__(self, fig, interval=interval, blit=True)
ax1.set_ylim(-0.1, 1) ax.set_xlabel('Time') ax.set_ylabel('Synaptic Paramter') axcolor = 'lightgoldenrodyellow' axsInject = plt.axes([0.6, 0.7, 0.35, 0.04], facecolor=axcolor) axsg_AM_E = plt.axes([0.6, 0.65, 0.35, 0.04], facecolor=axcolor) axsg_AM_I = plt.axes([0.6, 0.6, 0.35, 0.04], facecolor=axcolor) axsg_GABA_E = plt.axes([0.6, 0.55, 0.35, 0.04], facecolor=axcolor) axsg_GABA_I = plt.axes([0.6, 0.50, 0.35, 0.04], facecolor=axcolor) axstau_G = plt.axes([0.6, 0.45, 0.35, 0.04], facecolor=axcolor) axstau_A = plt.axes([0.6, 0.40, 0.35, 0.04], facecolor=axcolor) axh = plt.axes([-1, -1, 1, 1]) # Make sliders that control parameters sInj = Slider(axsInject, r'Current', 0, 2, valinit=0.14, color='maroon') sg_AM_E = Slider(axsg_AM_E, r'AM E', 0, 10.0, valinit=1.8, color='midnightblue') sg_AM_I = Slider(axsg_AM_I, r'AM I', 0.0, 10.0, valinit=1, color='midnightblue') sg_GABA_E = Slider(axsg_GABA_E, r'GABA E', 0.0,
# Add the first image ax.imshow(img) ax.set_xticks([]) ax.set_yticks([]) ax.set_title("Original Image") # add the first image again (since initially there should be no filtering) ax2.imshow(img) ax2.set_xticks([]) ax2.set_yticks([]) ax2.set_title("Blurred Image") # Add a slider for our blurring Kernel # Define an axes area and draw a slider in it kernel_slider_ax = fig.add_axes([0.25, 0.15, 0.65, 0.03]) kernel_slider = Slider(kernel_slider_ax, 'Kernel Size', 1, 10) # When the slider changes, we replace the original image (ax2 version) with the blurred image def sliders_on_changed(val): # Have to cast the slider value as an int to properly calculate the kernel ax2.imshow(blurred_image((int)(kernel_slider.val))) fig.canvas.draw_idle() kernel_slider.on_changed(sliders_on_changed) # Add a button for resetting the parameters reset_button_ax = fig.add_axes([0.8, 0.025, 0.1, 0.04]) reset_button = Button(reset_button_ax, 'Reset', hovercolor='0.975')
def main(argv=None): if argv is None: argv = sys.argv if len(argv) != 2: print("usage: %s SIMNAME" % os.path.basename(sys.argv[0])) return 2 # process arguments simname = argv[1] tslice = 0 # read elapsed hour/datetime key file dts, hrs = pltutils.timekeys(simname) nts = len(dts) datetimes = [] for dt in dts: datetimes.append(datetime.strftime(dt, "%Y-%m-%d %H:%M:%S")) # read data files # cair z, acair = pltutils.get1Dvar(simname, "met", "cair") cair = acair[:, tslice] # h2o z, ah2o = pltutils.get1Dvar(simname, "met", "h2o") h2o = ah2o[:, tslice] # kv z, akv = pltutils.get1Dvar(simname, "met", "kv") kv = akv[:, tslice] # pmb z, apmb = pltutils.get1Dvar(simname, "met", "pmb") pmb = apmb[:, tslice] # ppfd z, appfd = pltutils.get1Dvar(simname, "met", "ppfd") ppfd = appfd[:, tslice] # qh z, aqh = pltutils.get1Dvar(simname, "met", "qh") qh = aqh[:, tslice] # rh z, arh = pltutils.get1Dvar(simname, "met", "rh") rh = arh[:, tslice] # tk z, atk = pltutils.get1Dvar(simname, "met", "tk") tk = atk[:, tslice] # ubar z, aubar = pltutils.get1Dvar(simname, "met", "ubar") ubar = aubar[:, tslice] # create the plots fig = plt.figure(figsize=(12, 12)) # air density (molec/cm3) ax1 = fig.add_subplot(2, 4, 1) pcair, = ax1.plot(cair, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="c$_{air}$") pltutils.setstdfmts(ax1, tlmaj, tlmin, tlbsize, tlbpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.85, 0.05)) # plt.xlim(xmax=1.0, xmin=0.0) plt.ylim(ymax=43.0, ymin=0.0) # water density (molecules/cm3) ax2 = fig.add_subplot(2, 4, 2) ph2o, = ax2.plot(h2o, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="H$_2$O") pltutils.setstdfmts(ax2, tlmaj, tlmin, tlbsize, tlbpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.55, 0.05)) # plt.xlim(xmax=1200.0, xmin=-100.0) plt.ylim(ymax=43.0, ymin=0.0) # eddy diffusivity (cm2/s) ax3 = fig.add_subplot(2, 4, 3) pkv, = ax3.plot(kv, z, color=colors[4], linestyle="-", marker="None", linewidth=lnwdth, label="K$_{v}$") pltutils.setstdfmts(ax3, tlmaj, tlmin, tlbsize, tlbpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.95, 0.05)) plt.ylim(ymax=43.0, ymin=0.0) # air pressure (mb) ax4 = fig.add_subplot(2, 4, 4) ppmb, = ax4.plot(pmb, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="p$_{air}$") pltutils.setstdfmts(ax4, tlmaj, tlmin, tlbsize, tlbpad) # plt.xlabel("$\mu$mol m$^{-2}$ s$^{-1}$", fontsize=xfsize, labelpad=xtpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.95, 0.05)) # plt.xlim(xmax=20., xmin=-1.) plt.ylim(ymax=43.0, ymin=0.0) # ppfd ax5 = fig.add_subplot(2, 4, 5) pppfd, = ax5.plot(ppfd, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="PPFD") pltutils.setstdfmts(ax5, tlmaj, tlmin, tlbsize, tlbpad) # plt.xlabel("W/m$^2$", fontsize=xfsize, labelpad=xtpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.65, 0.05)) # plt.xlim(xmax=1200.0, xmin=-100.0) plt.ylim(ymax=43.0, ymin=0.0) # qh ax6 = fig.add_subplot(2, 4, 6) pqh, = ax6.plot(qh, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="q$_h$") pltutils.setstdfmts(ax6, tlmaj, tlmin, tlbsize, tlbpad) # plt.xlabel("W/m$^2$", fontsize=xfsize, labelpad=xtpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.65, 0.05)) # plt.xlim(xmax=1200.0, xmin=-100.0) plt.ylim(ymax=43.0, ymin=0.0) # rh ax7 = fig.add_subplot(2, 4, 7) prh, = ax7.plot(rh, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="RH") pltutils.setstdfmts(ax7, tlmaj, tlmin, tlbsize, tlbpad) # plt.xlabel("W/m$^2$", fontsize=xfsize, labelpad=xtpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.65, 0.05)) # plt.xlim(xmax=500.0, xmin=-20.0) plt.ylim(ymax=43.0, ymin=0.0) # ubar ax8 = fig.add_subplot(2, 4, 8) pubar, = ax8.plot(ubar, z, color=colors[3], linestyle="-", marker="None", linewidth=lnwdth, label="u$_{mean}$") # xmin, xmax = ax8.get_xlim() # plt.xticks(np.arange(xmin, xmax+1, 1000.)) pltutils.setstdfmts(ax8, tlmaj, tlmin, tlbsize, tlbpad) # plt.xlabel("s m$^{-1}$", fontsize=xfsize, labelpad=xtpad) plt.legend(loc=4, fontsize=lfsize, bbox_to_anchor=(0.95, 0.05)) # plt.xlim(xmax=2000., xmin=-100.) plt.ylim(ymax=43.0, ymin=0.0) psupttle = plt.suptitle(simname + " - " + datetimes[tslice], fontsize=tfsize, y=tyloc) # make room for the slider plt.subplots_adjust(bottom=0.15) # make a slider to control the time slice slidercolor = "cyan" axtime = plt.axes([0.25, 0.03, 0.55, 0.02], facecolor=slidercolor) time_slider = Slider(ax=axtime, label="Time", valmin=0, valmax=nts - 1, valstep=1, valinit=0) # update function for the slider def update(val): tslice = int(time_slider.val) psupttle.set_text(simname + " - " + datetimes[tslice]) xmax = np.amax(acair[:, tslice]) xmin = np.amin(acair[:, tslice]) pcair.set_xdata(acair[:, tslice]) ax1.set_xlim(xmax=xmax * 1.1, xmin=xmin * 0.95) xmax = np.amax(ah2o[:, tslice]) xmin = np.amin(ah2o[:, tslice]) ph2o.set_xdata(ah2o[:, tslice]) ax2.set_xlim(xmax=xmax * 1.1, xmin=xmin * 0.95) xmax = np.amax(akv[:, tslice]) pkv.set_xdata(akv[:, tslice]) ax3.set_xlim(xmax=xmax * 1.1, xmin=-20.0) xmax = np.amax(apmb[:, tslice]) xmin = np.amin(apmb[:, tslice]) ppmb.set_xdata(apmb[:, tslice]) ax4.set_xlim(xmax=xmax * 1.1, xmin=xmin * 0.95) xmax = np.amax(appfd[:, tslice]) xmin = np.amin(appfd[:, tslice]) pppfd.set_xdata(appfd[:, tslice]) ax5.set_xlim(xmax=2500., xmin=-20.0) xmax = np.amax(aqh[:, tslice]) xmin = np.amin(aqh[:, tslice]) pqh.set_xdata(aqh[:, tslice]) ax6.set_xlim(xmax=xmax * 1.1, xmin=xmin * 0.95) xmax = np.amax(arh[:, tslice]) xmin = np.amin(arh[:, tslice]) prh.set_xdata(arh[:, tslice]) ax7.set_xlim(xmax=100., xmin=0.0) xmax = np.amax(aubar[:, tslice]) xmin = np.amin(aubar[:, tslice]) pubar.set_xdata(aubar[:, tslice]) ax8.set_xlim(xmax=xmax * 1.1, xmin=0.0) fig.canvas.draw_idle() # register the update function with the slider time_slider.on_changed(update) # allow slider to be moved by "left" and "right" arrow keys def onarrow(event): if event.key == "left": if (time_slider.val == 0): val = 0 else: val = time_slider.val - 1 time_slider.set_val(val) elif event.key == "right": if (time_slider.val == (nts - 1)): val = nts - 1 else: val = time_slider.val + 1 time_slider.set_val(val) else: pass # bind key event to the arrow key handler kid = fig.canvas.mpl_connect("key_press_event", onarrow) plt.show() return 0
def __init__(self, name): self.name = name self.data = None self.xspace = None self.fit = None self.peak = {} self.bounds = { 'Background': [-np.inf, np.inf], } self.current_peak = None self.background = 0 self.fig = plt.figure("Curvefit", figsize=(8, 8)) self.mainAx = self.fig.add_axes([0.1, 0.3, 0.7, 0.6]) #self.mainAx.plot(data[0], data[1], ".") ##button axes##### self.buttonAx = {} self.button = {} self.buttonState = { 'Add': False, 'Gauss': False, 'Lorentz': False, } self.buttonAx['Add'] = plt.axes([0.83, 0.82, 0.1, 0.075]) self.button['Add'] = Button(self.buttonAx['Add'], 'Add', color='grey') self.button['Add'].on_clicked(self.add_clicked) self.buttonAx['Gauss'] = plt.axes([0.83, 0.72, 0.1, 0.075]) self.button['Gauss'] = Button(self.buttonAx['Gauss'], 'Gauss', color='grey') self.button['Gauss'].on_clicked(self.gauss_clicked) self.buttonAx['Lorentz'] = plt.axes([0.83, 0.62, 0.1, 0.075]) self.button['Lorentz'] = Button(self.buttonAx['Lorentz'], 'Lorentz', color='grey') self.button['Lorentz'].on_clicked(self.lorentz_clicked) ### # self.buttonAx['AmpBound'] = plt.axes([0.65, 0.2, 0.065, 0.03]) # self.button['AmpBound'] = Button(self.buttonAx['AmpBound'] ,'Bound', color='grey') # # self.buttonAx['MeanBound'] = plt.axes([0.65, 0.15, 0.065, 0.03]) # self.button['MeanBound'] = Button(self.buttonAx['MeanBound'] ,'Bound', color='grey') # self.buttonAx['StdBound+'] = plt.axes([0.65, 0.10, 0.04, 0.03]) # self.button['StdBound+'] = Button(self.buttonAx['StdBound+'] ,'+', color='grey') # self.button['StdBound+'].on_clicked(self.std_up_bound_clicked) # self.buttonAx['StdBound-'] = plt.axes([0.60, 0.10, 0.04, 0.03]) # self.button['StdBound-'] = Button(self.buttonAx['StdBound-'] ,'-', color='grey') # self.button['StdBound-'].on_clicked(self.std_low_bound_clicked) # self.buttonAx['BgBound+'] = plt.axes([0.65, 0.05, 0.04, 0.03]) # self.button['BgBound+'] = Button(self.buttonAx['BgBound+'], '+', color ='grey') # self.button['BgBound+'].on_clicked(self.bg_up_bound_clicked) # self.buttonAx['BgBound-'] = plt.axes([0.60, 0.05, 0.04, 0.03]) # self.button['BgBound-'] = Button(self.buttonAx['BgBound-'], '-', color ='grey') # self.button['BgBound-'].on_clicked(self.bg_low_bound_clicked) # ### # self.buttonAx['Peak-'] = plt.axes([0.83, 0.5, 0.035, 0.03]) self.button['Peak-'] = Button(self.buttonAx['Peak-'], '<', color='grey') self.button['Peak-'].on_clicked(self.toggle_peaks_left) self.peak_number_ax = plt.axes([0.85, 0.54, 0.06, 0.03]) self.peak_number_ax.set_axis_off() self.buttonAx['Peak+'] = plt.axes([0.895, 0.5, 0.035, 0.03]) self.button['Peak+'] = Button(self.buttonAx['Peak+'], '>', color='grey') self.button['Peak+'].on_clicked(self.toggle_peaks_right) self.buttonAx['Save'] = plt.axes([0.83, 0.32, 0.1, 0.075]) self.button['Save'] = Button(self.buttonAx['Save'], "Save", color='grey') self.button['Save'].on_clicked(self.save_fit) ##sliders##### self.sliderAx = {} self.slider = {} self.sliderVals = {'Amp': 0.5, 'Mean': 0.5, 'Std': 0.5} self.sliderAx['Amp'] = plt.axes([0.15, 0.2, 0.25, 0.03]) self.slider['Amp'] = Slider(self.sliderAx['Amp'], "Amp", 0, 1, valinit=0.5, color='grey') self.slider['Amp'].on_changed(self.amp_slider_changed) self.sliderAx['Mean'] = plt.axes([0.15, 0.15, 0.25, 0.03]) self.slider['Mean'] = Slider(self.sliderAx['Mean'], "Mean", 0, 1, valinit=0.5, color='grey') self.sliderAx['Std'] = plt.axes([0.15, 0.10, 0.25, 0.03]) self.slider['Std'] = Slider(self.sliderAx['Std'], "Std", 0, 4, valinit=2, color='grey') self.slider['Std'].on_changed(self.std_slider_changed) self.sliderAx['Bg'] = plt.axes([0.15, 0.05, 0.25, 0.03]) self.slider['Bg'] = Slider(self.sliderAx['Bg'], "Bg", 0, 1, valinit=0.5, color='grey') self.slider['Bg'].on_changed(self.bg_slider_changed) #TEXT BOX self.textboxAx = {} self.textbox = {} self.textboxAx['Bg'] = plt.axes([0.5, 0.05, 0.06, 0.03]) self.textbox['Bg'] = TextBox(self.textboxAx['Bg'], "", "0") self.textbox['Bg'].on_submit(self.bg_submit) self.textboxAx['Std'] = plt.axes([0.5, 0.10, 0.06, 0.03]) self.textbox['Std'] = TextBox(self.textboxAx['Std'], "", "0") self.textbox['Std'].on_submit(self.std_submit) self.textboxAx['Mean'] = plt.axes([0.5, 0.15, 0.06, 0.03]) self.textbox['Mean'] = TextBox(self.textboxAx['Mean'], "", "0") self.textbox['Mean'].on_submit(self.mean_submit) self.textboxAx['Amp'] = plt.axes([0.5, 0.2, 0.06, 0.03]) self.textbox['Amp'] = TextBox(self.textboxAx['Amp'], "", "0") self.textbox['Amp'].on_submit(self.amp_submit) self.clickid = self.fig.canvas.mpl_connect('button_press_event', self.mainAx_click) #### self.datapoints = None
plt.draw # redraw the plot #button_declaration axButton = plt.axes([0.92, 0.6, 0.06, 0.06]) #xloc,yloc,width,heights btn = Button(axButton, ' ADD ') #button on click callback function btn.on_clicked(setValue) #Sliders declaration axSlider1 = plt.axes([0.1, 0.20, 0.55, 0.02]) #xloc,yloc,width,height slider1 = Slider(ax=axSlider1, label='Tox', valmin=1 * 10**(-9), valmax=5 * 10**(-9), valinit=tox, valfmt='tox is ' + '%1.11f' + ' in m', color="green") axSlider2 = plt.axes([0.1, 0.15, 0.55, 0.02]) #xloc,yloc,width,height slider2 = Slider(axSlider2, 'NA', valmin=1, valmax=20, valinit=NA / (10**23), valfmt='NA is ' + '%1.2f' + ' in 10**23 m^-3') axSlider3 = plt.axes([0.1, 0.10, 0.55, 0.02]) #xloc,yloc,width,height slider3 = Slider(axSlider3, 'Phi_m',
edges = camimg edges = cv2.Canny(edges, 50, 100) fig, ax = plt.subplots() plt.subplots_adjust(bottom=0.25) plt.subplot(1, 2, 1), plt.imshow(camimg, cmap='gray') plt.title('Original'), plt.xticks([]), plt.yticks([]) plt.subplot(1, 2, 2) edge_plot = plt.imshow(edges, cmap='gray') plt.title('Edges'), plt.xticks([]), plt.yticks([]) axcolor = 'lightgoldenrodyellow' axupper = plt.axes([0.15, 0.15, 0.7, 0.03], axisbg=axcolor) upper = Slider(axupper, 'Upper', 0, 255, valinit=100) axlower = plt.axes([0.15, 0.1, 0.7, 0.03], axisbg=axcolor) lower = Slider(axlower, 'Lower', 0, 255, valinit=50) def update(val): global edges edges = camimg edges = cv2.Canny(edges, lower.val, upper.val) """ contours = measure.find_contours(edges, 0.5) contours.sort(key=lambda x: -len(x)) final = [] for cont in contours[:ncont]:
vcirc_tot = np.sqrt(vcirc_bulge**2 + vcirc_disk**2 + vcirc_halo**2) plot4_disk, = ax4.plot(mymdar.r, vcirc_disk, label='disk') plot4_halo, = ax4.plot(mymdar.r, vcirc_halo, label='halo') plot4_bulge, = ax4.plot(mymdar.r, vcirc_bulge, label='bulge') plot4_tot, = ax4.plot(mymdar.r, vcirc_tot, label='total') ax4.set_xlim(0, 40) ax4.set_ylim(0, 300) #a.plot_galaxy(ax=ax3) #mymdar.plot_vcirc(ax=ax4) #ax4.legend(loc='upper left', ncol=2, frameon=False) s_Mgal = Slider(ax_Mgal, 'Mbar', 3, 15.0, valinit=np.log10(Mgal)) s_Rh = Slider(ax_Rh, 'R50', 0.01, 15.0, valinit=Rh) s_m200 = Slider(ax_m200, 'M200', 10, 14, valinit=np.log10(M200)) s_fmbulge = Slider(ax_fmbulge, 'Bul_frac', 0.01, 1.0, valinit=f_mbulge) s_fabulge = Slider(ax_fabulge, 'Bul_size', 0.01, 3.0, valinit=f_abulge) data_behroozi = np.loadtxt('m200-mstr.txt') ax1.plot(np.log10(data_behroozi[:, 0]), np.log10(data_behroozi[:, 1] * data_behroozi[:, 0]), ls='--') galaxy_mstr_mhalo, = ax1.plot(np.log10(mymdar.M200), np.log10(mymdar.Mgal), 'o') mass_concentration = np.loadtxt('mass_concentration.txt') get_concentration = interp1d(
print 'flip map left and right' if inps.flip_ud: ax_v.invert_yaxis() print 'flip map up and down' # Colorbar cbar = fig_v.colorbar(img, orientation='vertical') cbar.set_label('Displacement [%s]' % inps.disp_unit) # Axes 2 - Time Slider ax_time = fig_v.add_axes([0.125, 0.1, 0.6, 0.07], axisbg='lightgoldenrodyellow', yticks=[]) tslider = Slider(ax_time, 'Years', tims[0], tims[-1], valinit=tims[inps.epoch_num]) tslider.ax.bar(tims, np.ones(len(tims)), facecolor='black', width=0.01, ecolor=None) tslider.ax.set_xticks( np.round(np.linspace(tims[0], tims[-1], num=5) * 100) / 100) def time_slider_update(val): '''Update Displacement Map using Slider''' global fig_v, ax_v, img, mask, inps, tims timein = tslider.val idx_nearest = np.argmin(np.abs(np.array(tims) - timein))
ax1.set_xlim(0, 1) ax1.set_ylim(0, 100) axcolor = 'lightgoldenrodyellow' axs_I = plt.axes([0.7, 0.85, 0.2, 0.03], axisbg=axcolor) axs_A = plt.axes([0.7, 0.5, 0.2, 0.03], axisbg=axcolor) axs_R = plt.axes([0.7, 0.6, 0.2, 0.03], axisbg=axcolor) axs_C = plt.axes([0.7, 0.55, 0.2, 0.03], axisbg=axcolor) axs_vl = plt.axes([0.7, 0.65, 0.2, 0.03], axisbg=axcolor) axs_vth = plt.axes([0.7, 0.8, 0.2, 0.03], axisbg=axcolor) axs_vres = plt.axes([0.7, 0.75, 0.2, 0.03], axisbg=axcolor) axs_tref = plt.axes([0.7, 0.7, 0.2, 0.03], axisbg=axcolor) # Make sliders that control parameters s_I = Slider(axs_I, r'$I \, [nA]$', 0, 1.0, valinit=0.5, color='maroon') s_A = Slider(axs_A, r'$A \, [mm^2\!]$', 0.01, 0.2, valinit=0.05, color='midnightblue') s_R = Slider(axs_R, r'$r \, [M\Omega\ mm^2\!]$', 0.1, 10.0, valinit=2, color='midnightblue') s_C = Slider(axs_C, r'$c \, [nF/mm^2\!]$', 1.,
def ishow(self): """ interactive show of trajectories Examples -------- .. plot:: :include-source: >>> from pylayers.mobility.trajectory import * >>> T=Trajectories() >>> T.loadh5() >>> T.ishow() """ fig, ax = plt.subplots() fig.subplots_adjust(bottom=0.2, left=0.3) t = np.arange(0, len(self[0].index), self[0].ts) L = Layout(self.Lfilename) fig, ax = L.showG('s', fig=fig, ax=ax) valinit = 0 lines = [] labels = [] colors = "bgrcmykw" for iT, T in enumerate(self): if T.typ == 'ag': lines.extend( ax.plot(T['x'][0:valinit], T['y'][0:valinit], 'o', color=colors[iT], visible=True)) labels.append(T.name + ':' + T.ID) else: lines.extend( ax.plot(T['x'][0], T['y'][0], '^', ms=12, color=colors[iT], visible=True)) labels.append(T.name + ':' + T.ID) t = self[0].time() # init boolean value for visible in checkbutton blabels = [True] * len(labels) ######## # slider ######## slider_ax = plt.axes([0.1, 0.1, 0.8, 0.02]) slider = Slider(slider_ax, "time", self[0].tmin, self[0].tmax, valinit=valinit, color='#AAAAAA') def update(val): if val >= 1: pval = np.where(val > t)[0] ax.set_title(str( self[0].index[pval[-1]].time())[:11].ljust(12), loc='left') for iT, T in enumerate(self): if T.typ == 'ag': lines[iT].set_xdata(T['x'][pval]) lines[iT].set_ydata(T['y'][pval]) fig.canvas.draw() slider.on_changed(update) ######## # choose ######## rax = plt.axes([0.02, 0.5, 0.3, 0.2], aspect='equal') # check (ax.object, name of the object , bool value for the obsject) check = CheckButtons(rax, labels, tuple(blabels)) def func(label): i = labels.index(label) lines[i].set_visible(not lines[i].get_visible()) fig.canvas.draw() check.on_clicked(func) fig.canvas.draw() plt.show(fig)
"""cuantas veces presentamos el estimulo y cuantas veces el sujeto responde al estimulo""" ensayos = 60 estimulo = numpy.linspace(0, ensayos, ensayos) valor_ud = numpy.zeros(len(estimulo)) #len dice longitud """parametros de la ley de weber""" k = 1 c = [k] * ensayos #constante de Weber repitela cuantas veces ensayos haya S0 = 10 #umbral debajo del cual el estimulo es percibido """plots""" fig, ax = plt.subplots(2) plt.subplots_adjust(left=0.15, bottom=0.25) ax_k = plt.axes([0.15, 0.1, 0.65, 0.03], axisbg='lightgoldenrodyellow') slider_k = Slider(ax_k, 'k', .5, 1.5, valinit=k) for i in range(len(estimulo)): if estimulo[i] <= S0: valor_ud[i] = 0 else: valor_ud[i] = S0 + k * estimulo[i - S0] def update(var): k = slider_k.val c = [k] * ensayos for i in range(len(estimulo)): if estimulo[i] <= S0: valor_ud[i] = 0 else:
########################################################################################################## fig, ax = plt.subplots() plt.subplots_adjust(left=0.25, bottom=0.25) f0 = 1 delta_f = 1 g = nx.random_k_out_graph(n=f0, k=2, alpha=0.5) axcolor = 'lightgray' axfreq = plt.axes([0.25, 0.06, 0.65, 0.03], facecolor=axcolor) sfreq = Slider(axfreq, 'noise', 1, 20, valinit=f0, valstep=delta_f, valfmt='%0.0f') active_nodes = [] non_active_nodes = [] for i in range(number_of_clusters): Net.nodes[control_nodes[i]] = 1 for i in range(len(Net.nodes)): if Net.nodes[i] == 1: active_nodes.append(i) else: non_active_nodes.append(i)
fig = plt.figure() ax = fig.add_subplot(111, projection='3d') for i in range(xlin.shape[0]): ax.plot(xlin[i], ylin[i], zlin[i]) s = np.zeros(v.shape[0]) c = np.zeros(v.shape[0]) val = 1 s = np.absolute(v[:, val - 1]) s = s * 300 c = np.where(v[:, val - 1] > 0, 0, 1) Stateplot = ax.scatter(xyz[:, 0], xyz[:, 1], xyz[:, 2], zdir='z', s=s) Stateplot.set_cmap("bwr") plt.subplots_adjust(bottom=0.25) axcolor = 'lightgoldenrodyellow' axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor) state = Slider(axfreq, 'State', 1, v.shape[0], valinit=1, valstep=1) def update(val): val = state.val val = int(val) s = np.absolute(v[:, val - 1]) s = s * 300 print(s) c = np.where(v[:, val - 1] > 0, 0, 1) print(c) Stateplot._sizes = s Stateplot.set_array(c) fig.canvas.draw_idle()
def main(): fig, ax = plt.subplots() plt.subplots_adjust(left=0.12, bottom=0.4,top=0.8) phasesample = np.linspace(0,1,101) l, = ax.plot(phasesample,phasesample, lw=2) ax.set_ylabel("rel. flux (%)") ax.set_xlabel("phase") ax.set_ylim(-10,10) ax.margins(x=0) topax = ax.twiny() topax.set_xticks([0,0.25,0.5,0.75,1]) topax.set_xticklabels(['farthest','toward','nearest','away','farthest']) axcolor = 'lightgoldenrodyellow' axteff = plt.axes([0.25, 0.05, 0.6, 0.03], facecolor=axcolor) axlogg = plt.axes([0.25, 0.1, 0.6, 0.03], facecolor=axcolor) axporb = plt.axes([0.25, 0.15, 0.6, 0.03], facecolor=axcolor) axk = plt.axes([0.25, 0.2, 0.6, 0.03], facecolor=axcolor) axinc = plt.axes([0.25, 0.25, 0.6, 0.03], facecolor=axcolor) steff = Slider(axteff, 'Teff (K)', 8300, 30000, valinit=10000, valfmt=u'%1.0f') #valstep=50, slogg = Slider(axlogg, 'log(g) (cgs)', 4, 7.4, valinit=5.5, valfmt=u'%1.1f') #valstep = 0.1, sporb = Slider(axporb, 'P_orb (hours)', 0.25, 24, valinit=2 ) #valstep = 0.05 sk = Slider(axk, 'K (km/s)', 20, 620, valinit=200, valfmt=u'%1.0f') #valstep = 10, sinc = Slider(axinc, 'inc (deg)', 1, 90, valinit=45, valfmt=u'%1.0f') #valstep = 1, def update(val): df = calc(teff=steff.val,logg=slogg.val,porb=sporb.val,k=sk.val,inc=sinc.val) l.set_ydata(-df["EV (%)"][0]*np.cos(phasesample*4*np.pi) + df["DB (%)"][0]*np.sin(phasesample*2*np.pi)) for i in range(len(df.values[0])): mpl_table._cells[(1, i)]._text.set_text('%.4f' % df.values[0][i]) fig.canvas.draw_idle() df = calc(teff=steff.val,logg=slogg.val,porb=sporb.val,k=sk.val,inc=sinc.val) axvals = plt.axes([0.12, 0.88, 0.78, 0.1], facecolor=axcolor) font_size=8 bbox=[0, 0, 1, 1] axvals.axis('off') mpl_table = axvals.table(cellText = [['%.4f' % j for j in i] for i in df.values], bbox=bbox, colLabels=df.columns) mpl_table.auto_set_font_size(False) mpl_table.set_fontsize(font_size) update(1) steff.on_changed(update) slogg.on_changed(update) sporb.on_changed(update) sk.on_changed(update) sinc.on_changed(update) plt.show()