def __init__(self, master): global fileName global daqInterval self.master = master master.title('MEC Power Supply Monitoring') master.geometry('1000x850+200+200') # ------------------------------------------------------------------------ # Displaying the filename # ------------------------------------------------------------------------ # Graphical definition of label self.filenameVariable = Tkinter.StringVar() #variable to call label self.filenameLabel = Tkinter.Label(master, textvariable=self.filenameVariable, anchor="w", fg="black") self.filenameVariable.set( u"Datalogging file:") # default value in display self.filenameLabel.pack() self.filenameLabel.place(x=10, y=0, width=100, height=25) self.filenamedisplayVariable = Tkinter.StringVar( ) # variable to call label global vsetfileName vsetfileName = self.filenamedisplayVariable self.filenamedisplayLabel = Tkinter.Label( master, textvariable=self.filenamedisplayVariable, anchor="center", fg="black", bg="ivory") self.filenamedisplayVariable.set(fileName) #default value in display self.filenamedisplayLabel.pack() self.filenamedisplayLabel.place(x=110, y=0, width=100, height=25) # ------------------------------------------------------------------------ # BUTTONS Definitions # ------------------------------------------------------------------------ # Graphic definition of SETTINGS button self.settingsButton = Tkinter.Button( master, text="SETTINGS", command=self.Settings, anchor="center", fg="black") # Button uses the settings function self.settingsButton.pack() self.settingsButton.place(x=85, y=100, width=80, height=25) # Graphic definition of START button self.startButton = Tkinter.Button( master, text="START", command=self.Start, anchor="center", fg="black") # Button uses the Start function self.startButton.pack() self.startButton.place(x=85, y=125, width=80, height=25) # Graphical definition of STOP button self.stopButton = Tkinter.Button( master, text="STOP", command=self.Stop) # Button uses the Stop function self.stopButton.pack() self.stopButton.place(x=85, y=150, width=80, height=25) # ------------------------------------------------------------------------ # Displaying PS1 status (ON/OFF) on master # ------------------------------------------------------------------------ # Graphical definition of PS1 ON/OFF label self.onoffPS1Variable = Tkinter.StringVar() # variable to call label if runPS1 == 'False': self.onoffPS1Variable.set(u"PS1: OFF") else: self.onoffPS1Variable.set(u"PS1: ON") self.onoffPS1Label = Tkinter.Label(master, textvariable=self.onoffPS1Variable, anchor="center", fg="black") self.onoffPS1Label.pack() self.onoffPS1Label.place(x=10, y=75, width=80, height=25) # ------------------------------------------------------------------------ # Displaying PS1 voltage # ------------------------------------------------------------------------ # Graphical definition of label self.ps1voltageVariable = Tkinter.StringVar() #variable to call label self.ps1voltageLabel = Tkinter.Label( master, textvariable=self.ps1voltageVariable, anchor="w", fg="black") self.ps1voltageVariable.set( u"PS1 Voltage:") # default value in display self.ps1voltageLabel.pack() self.ps1voltageLabel.place(x=10, y=25, width=80, height=25) self.ps1VdisplayVariable = Tkinter.StringVar( ) # variable to call label global vsetPS1 vsetPS1 = self.ps1VdisplayVariable self.ps1VdisplayLabel = Tkinter.Label( master, textvariable=self.ps1VdisplayVariable, anchor="e", fg="black", bg="ivory") self.ps1VdisplayVariable.set( str(ps1Voltage)) #default value in display self.ps1VdisplayLabel.pack() self.ps1VdisplayLabel.place(x=90, y=25, width=30, height=25) # ------------------------------------------------------------------------ # Displaying PS1 current # ------------------------------------------------------------------------ # Graphical definition of label self.ps1currentVariable = Tkinter.StringVar() #variable to call label self.ps1currentLabel = Tkinter.Label( master, textvariable=self.ps1currentVariable, anchor="w", fg="black") self.ps1currentVariable.set( u"PS1 Current:") # default value in display self.ps1currentLabel.pack() self.ps1currentLabel.place(x=10, y=50, width=80, height=25) self.ps1IdisplayVariable = Tkinter.StringVar( ) # variable to call label global isetPS1 time.sleep(1) isetPS1 = self.ps1IdisplayVariable self.ps1IdisplayLabel = Tkinter.Label( master, textvariable=self.ps1IdisplayVariable, anchor="e", fg="black", bg="ivory") self.ps1IdisplayVariable.set( str(ps1currentActual)) #default value in display self.ps1IdisplayLabel.pack() self.ps1IdisplayLabel.place(x=90, y=50, width=30, height=25) # ------------------------------------------------------------------------ # Displaying PS2 status (ON/OFF) on master # ------------------------------------------------------------------------ # Graphical definition of PS2 ON/OFF label self.onoffPS2Variable = Tkinter.StringVar() # variable to call label self.onoffPS2Label = Tkinter.Label(master, textvariable=self.onoffPS2Variable, anchor="center", fg="black") if runPS2 == 'False': self.onoffPS2Variable.set(u"PS2: OFF") else: self.onoffPS2Variable.set(u"PS2: ON") self.onoffPS2Label.pack() self.onoffPS2Label.place(x=135, y=75, width=80, height=25) # ------------------------------------------------------------------------ # Displaying PS2 voltage # ------------------------------------------------------------------------ # Graphical definition of label self.ps2voltageVariable = Tkinter.StringVar() #variable to call label self.ps2voltageLabel = Tkinter.Label( master, textvariable=self.ps2voltageVariable, anchor="w", fg="black") self.ps2voltageVariable.set( u"PS2 Voltage:") # default value in display self.ps2voltageLabel.pack() self.ps2voltageLabel.place(x=135, y=25, width=80, height=25) self.ps2displayVariable = Tkinter.StringVar() # variable to call label global vsetPS2 vsetPS2 = self.ps2displayVariable self.ps2displayLabel = Tkinter.Label( master, textvariable=self.ps2displayVariable, anchor="e", fg="black", bg="ivory") self.ps2displayVariable.set(str(ps2Voltage)) #default value in display self.ps2displayLabel.pack() self.ps2displayLabel.place(x=215, y=25, width=30, height=25) # ------------------------------------------------------------------------ # Displaying PS2 current # ------------------------------------------------------------------------ # Graphical definition of label self.ps2currentVariable = Tkinter.StringVar() #variable to call label self.ps2currentLabel = Tkinter.Label( master, textvariable=self.ps2currentVariable, anchor="w", fg="black") self.ps2currentVariable.set( u"PS2 Current:") # default value in display self.ps2currentLabel.pack() self.ps2currentLabel.place(x=135, y=50, width=80, height=25) self.ps2IdisplayVariable = Tkinter.StringVar( ) # variable to call label global isetPS2 time.sleep(1) isetPS2 = self.ps2IdisplayVariable self.ps2IdisplayLabel = Tkinter.Label( master, textvariable=self.ps2IdisplayVariable, anchor="e", fg="black", bg="ivory") self.ps2IdisplayVariable.set( str(ps2currentActual)) #default value in display self.ps2IdisplayLabel.pack() self.ps2IdisplayLabel.place(x=215, y=50, width=30, height=25) # ------------------------------------------------------------------------ # Displaying last data acquisition # ------------------------------------------------------------------------ # Graphical definition of label self.lastdAcqVariable = Tkinter.StringVar() #variable to call label self.lastdAcqLabel = Tkinter.Label(master, textvariable=self.lastdAcqVariable, anchor="w", fg="black") self.lastdAcqVariable.set(u"Last datalog:") # default value in display self.lastdAcqLabel.pack() self.lastdAcqLabel.place(x=0, y=185, width=80, height=25) self.lastdAcqdisplayVariable = Tkinter.StringVar( ) # variable to call label global lastdAcq time.sleep(1) lastdAcq = self.lastdAcqdisplayVariable self.lastdAcqdisplayLabel = Tkinter.Label( master, textvariable=self.lastdAcqdisplayVariable, anchor="w", fg="black", bg="ivory") self.lastdAcqdisplayVariable.set(str(' ')) #default value in display self.lastdAcqdisplayLabel.pack() self.lastdAcqdisplayLabel.place(x=80, y=185, width=160, height=25) # ------------------------------------------------------------------------ # Displaying Timer # ------------------------------------------------------------------------ # Graphical definition of label self.timerVariable = Tkinter.StringVar() #variable to call label self.timerLabel = Tkinter.Label(master, textvariable=self.timerVariable, anchor="w", fg="black") self.timerVariable.set( u"Time before next datalog:") # default value in display self.timerLabel.pack() self.timerLabel.place(x=0, y=210, width=150, height=25) self.timerdisplayVariable = Tkinter.StringVar( ) # variable to call label global timer time.sleep(1) timer = self.timerdisplayVariable self.timerdisplayLabel = Tkinter.Label( master, textvariable=self.timerdisplayVariable, anchor="e", fg="black", bg="ivory") self.timerdisplayVariable.set(str(' ')) #default value in display self.timerdisplayLabel.pack() self.timerdisplayLabel.place(x=190, y=210, width=50, height=25) # ------------------------------------------------------------------------ # Displaying Graphic trends for PSx currents # ------------------------------------------------------------------------ self.graph1display = Tkinter.StringVar() #variable to call label self.graph2display = Tkinter.StringVar() #variable to call label global graph1display global graph2display graph1display = self.graph1display graph2display = self.graph2display graph1displaylabel = Tkinter.Label( master, textvariable=self.graph1display, anchor="center", fg="white", bg="black" ) #putting a label behind the labels. Labels display text graph2displaylabel = Tkinter.Label( master, textvariable=self.graph2display, anchor="center", fg="white", bg="black" ) #putting a label behind the labels. Labels display text self.graph1display.set(u"PS1 Current") #default value in display self.graph2display.set(u"PS1 Current") #default value in display graph1displaylabel.pack() graph2displaylabel.pack() # graph1displaylabel.grid(column=0,row=7,columnspan=3,sticky='NESW') #label position graph1displaylabel.place(x=0, y=300) graph2displaylabel.place(x=400, y=300) global f1 global f2 global var1 global var2 f1 = Figure(figsize=(4, 4), dpi=100) f2 = Figure(figsize=(4, 4), dpi=100) var1 = f1.add_subplot(111) var2 = f2.add_subplot(111) var1.set_title('PS1 Current') var2.set_title('PS2 Current') var1.set_xlabel('t [h]') var2.set_xlabel('t [h]') var1.set_ylabel('I [mA]') var2.set_ylabel('I [mA]') var1.set_xlim((0, 24)) var2.set_xlim((0, 24)) var1.set_ylim((0, 500)) var2.set_ylim((0, 500)) var1.plot([], []) var2.plot([], []) canvas1 = FigureCanvasTkAgg(f1, master) canvas2 = FigureCanvasTkAgg(f2, master) canvas1.show() canvas2.show() # canvas.get_tk_widget().grid(column=0,row=7,columnspan=3,sticky='NESW') #graph position canvas1.get_tk_widget().place(x=0, y=250) #graph position canvas2.get_tk_widget().place(x=400, y=250) #graph position toolbar1frame = Frame(master) #New frame to bypass the pack limitation toolbar2frame = Frame(master) #New frame to bypass the pack limitation # toolbar1frame.grid(column=0,row=12,columnspan=4,sticky='NESW') toolbar1frame.place(x=0, y=700) toolbar2frame.place(x=400, y=700) toolbar1 = NavigationToolbar2TkAgg(canvas1, toolbar1frame) toolbar2 = NavigationToolbar2TkAgg(canvas2, toolbar2frame) toolbar1.update() toolbar2.update() master.grid_columnconfigure( 0, weight=1) #configure column 0 to resize with a weight of 1 master.resizable( True, False ) #a constraints allowing resizeable along horizontally(column) #(true) and not vertically(rows)--false) master.update() master.geometry( master.geometry()) #prevents the window from resizing all the time
fig, ax = plt.subplots() ax.grid(True) ax.set_title("ADRC") ax.set_xlabel("Time") ax.set_ylabel("Temperature/PWM") ax.axis([0, 1000, 0, MaxYaxisValue]) line1 = ax.plot(xAchse, yAchse, "-r", label="Temperature") #line2=ax.plot(xAchse,yAchse, "-b", label="Watt") line3 = ax.plot(xAchse, yAchse, "-y", label="PWM") legend(loc='upper left') canvas = FigureCanvasTkAgg(fig, master=windows) canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1) toolbar = NavigationToolbar2TkAgg(canvas, windows) toolbar.update() canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1) CPUTemperature = [] TemperatureData = [] WattDatas = [] PWMDatas = [] response = {} Start = True UpdateFlag = False mutex = threading.Lock()
def createPlot(self, specMat, param_str, paramValues): s = len(self.U) spectra = [] plot = Figure(figsize=(5, 4), dpi=100, facecolor='whitesmoke', edgecolor=None) spectrumplot = plot.add_subplot(211) spectrumplot.set_title('$\mathrm{Spectrum}$') for A in specMat: spectrum = [] for i in range(len(self.MU)): for j in range(len(A[0][i])): spectrum.append(A[0][i][j]) spectra.append(spectrum) spectrumplot.set_xlabel('$\mathrm{Re }\lambda$') spectrumplot.set_ylabel('$\mathrm{Im }\lambda$') efcnplot = plot.add_subplot(212) efcnplot.set_xlabel('$x$') efcnplot.set_ylabel('$y(x)$') lastind = 0 xs = real(spectra[0]) ys = imag(spectra[0]) def efcnchange(ax): print 'called' #Get the range for the new area xstart, ystart, xdelta, ydelta = ax.viewLim.bounds xend = xstart + xdelta yend = ystart + ydelta x = arange(xstart, xend, .01) self.plotEigenfunction(efcnplot, plot, specMat[0], x) # Connect for changing the view limits # retain a reference to avoid garbage collection efcnplot.autoscale(enable=True, axis='both', tight=True) cid = efcnplot.callbacks.connect('xlim_changed', efcnchange) #efcnplot.callbacks.connect('ylim_changed', efcnchange) plotWindow = FigureCanvasTkAgg(plot, master=self) self.plotSpectrum(specMat, 0, spectrumplot, efcnplot, plotWindow) plotWindow.show() toolbar = NavigationToolbar2TkAgg(plotWindow, self) toolbar.pack(side=TOP, padx=10, pady=10) plotWindow.get_tk_widget().pack(side=LEFT, fill=BOTH, expand=True, padx=10, pady=10) return [spectrumplot, plot, efcnplot, plotWindow]
def __init__(self, parent): self.parent = parent self.FFTwin = Tk.Toplevel(self.parent.tks) self.FFTwin.title("UV space") menubar = Tk.Menu(self.FFTwin) menubar.add_command(label="Quit", command=self.quit) self.FFTwin.config(menu=menubar) self.figUV1 = pl.figure(figsize=(10, 4)) self.UVPSF = self.figUV1.add_subplot(131, aspect='equal') self.UVOBS = self.figUV1.add_subplot(132, sharex=self.UVPSF, sharey=self.UVPSF, aspect='equal') pl.setp(self.UVOBS.get_yticklabels(), visible=False) self.UVSOURCE = self.figUV1.add_subplot(133, sharex=self.UVPSF, sharey=self.UVPSF, aspect='equal') pl.setp(self.UVSOURCE.get_yticklabels(), visible=False) self.figUV1.subplots_adjust(left=0.1, right=0.98, top=0.90, bottom=0.15, wspace=0.02, hspace=0.15) self.UVfmt = '%.2e Jy' self.PSFfmt = '%.2e' self.PSFText = self.UVPSF.text(0.05, 0.87, self.PSFfmt % (0.0), transform=self.UVPSF.transAxes, bbox=dict(facecolor='white', alpha=0.7)) self.UVSOURCEText = self.UVSOURCE.text( 0.05, 0.87, self.UVfmt % (0.0), transform=self.UVSOURCE.transAxes, bbox=dict(facecolor='white', alpha=0.7)) self.UVOBSText = self.UVOBS.text(0.05, 0.87, self.UVfmt % (0.0), transform=self.UVOBS.transAxes, bbox=dict(facecolor='white', alpha=0.7)) self.frames = {} self.frames['FigUV'] = Tk.Frame(self.FFTwin) self.frames['BFr'] = Tk.Frame(self.FFTwin) self.canvasUV1 = FigureCanvasTkAgg(self.figUV1, master=self.frames['FigUV']) self.canvasUV1.show() self.frames['FigUV'].pack(side=Tk.TOP) self.frames['BFr'].pack(side=Tk.TOP) self.buttons = {} self.buttons['reload'] = Tk.Button(self.frames['BFr'], text="Reload", command=self._FFTRead) self.buttons['reload'].pack() self.canvasUV1.mpl_connect('pick_event', self._onUVPick) self.canvasUV1.get_tk_widget().pack(side=Tk.LEFT) toolbar_frame = Tk.Frame(self.FFTwin) __toolbar = NavigationToolbar2TkAgg(self.canvasUV1, toolbar_frame) toolbar_frame.pack(side=Tk.LEFT) self._FFTRead()
def run_app(): # ######### # create and initialise the window # ######### root = Tk() root2 = Tk() initialise_window(root, 'Transit simulator', [], [root, root2], False) initialise_window(root2, 'Transit simulator', [root2], [], False) # get variables from log and set as tk variables those to be modified catalogue = plc.oec_catalogue() planet_search = StringVar(value='HD 209458 b') planet = StringVar(value='HD 209458 b') metallicity = DoubleVar(value=0.0) temperature = DoubleVar(value=0.0) logg = DoubleVar(value=0.0) phot_filter = IntVar(value=7) period = DoubleVar(value=0.0) rp_over_rs = DoubleVar(value=0.0) sma_over_rs = DoubleVar(value=0.0) inclination = DoubleVar(value=0.0) eccentricity = DoubleVar(value=0.0) periastron = DoubleVar(value=0.0) ascending_node = DoubleVar(value=0.0) # set progress variables, useful for updating the window update_planet = BooleanVar(root, value=True) update_planet_list = BooleanVar(root, value=True) open_root2 = BooleanVar(root, value=False) # create the plot in the additional window figure = matplotlib.figure.Figure() figure.patch.set_facecolor('white') ax1 = figure.add_subplot(122) ax2 = figure.add_subplot(221) ax3 = figure.add_subplot(223) canvas = FigureCanvasTkAgg(figure, root2) canvas.get_tk_widget().pack() NavigationToolbar2TkAgg(canvas, root2) # create widgets metallicity_label = Label(root, text='Stellar metallicity (dex)') metallicity_entry = Scale(root, from_=-5, to=1, resolution=0.5, variable=metallicity, orient=HORIZONTAL) metallicity_entry.set(metallicity.get()) temperature_label = Label(root, text='Stellar temperature (K)') temperature_entry = Scale(root, from_=3500, to=7000, resolution=250, variable=temperature, orient=HORIZONTAL) logg_label = Label(root, text='Stellar surface gravity (cm/s^2, log)') logg_entry = Scale(root, from_=0.0, to=5.0, resolution=0.5, variable=logg, orient=HORIZONTAL) available_filters = ['U', 'B', 'V', 'R', 'I', 'J', 'H', 'K'] phot_filter_label = Label(root, text='Filter') phot_filter_label_2 = Label(root, text=available_filters[phot_filter.get()]) phot_filter_entry = Scale(root, from_=0, to=len(available_filters) - 1, resolution=1, variable=phot_filter, showvalue=False, orient=HORIZONTAL) period_label = Label(root, text='Period (days)') period_entry = Entry(root, textvariable=period, validate='key') period_entry['validatecommand'] = ( period_entry.register(test_float_positive_input), '%P', '%d') rp_over_rs_label = Label(root, text='Rp/Rs') rp_over_rs_entry = Scale(root, from_=0, to=0.15, resolution=0.005, variable=rp_over_rs, orient=HORIZONTAL) sma_over_rs_label = Label(root, text='a/Rs') sma_over_rs_entry = Scale(root, from_=1, to=20, resolution=0.1, variable=sma_over_rs, orient=HORIZONTAL) inclination_label = Label(root, text='Inclination (deg)') inclination_entry = Scale(root, from_=70, to=90, resolution=0.1, variable=inclination, orient=HORIZONTAL) eccentricity_label = Label(root, text='Eccentricity') eccentricity_entry = Scale(root, from_=0, to=1, resolution=0.01, variable=eccentricity, orient=HORIZONTAL) periastron_label = Label(root, text='Periastron (deg)') periastron_entry = Scale(root, from_=0, to=360, resolution=1, variable=periastron, orient=HORIZONTAL) ascending_node_label = Label(root, text='Ascending node (deg)') ascending_node_entry = Scale(root, from_=0, to=360, resolution=1, variable=ascending_node, orient=HORIZONTAL) planet_label = Label(root, text=' Planet ') planet_search_entry = Entry(root, textvariable=planet_search) combostyle = ttk.Style() combostyle.theme_create('combostyle', parent='alt', settings={ 'TCombobox': { 'configure': { 'selectbackground': 'white', 'fieldbackground': 'white', 'background': 'white' } } }) combostyle.theme_use('combostyle') planet_entry = ttk.Combobox(root, textvariable=planet, state='readonly') search_planet_button = Button(root, text='SEARCH') plot_button = Button(root, text='PLOT') exit_transit_simulator_button = Button(root, text='EXIT') # define the function that updates the window def update_window(*event): if not event: pass if update_planet_list.get(): if isinstance(catalogue.searchPlanet(planet_search.get()), list): test_sample = [] for test_planet in catalogue.searchPlanet(planet_search.get()): if test_planet.isTransiting: test_sample.append(test_planet) planet_entry['values'] = tuple( [ppp.name for ppp in test_sample]) elif catalogue.searchPlanet(planet_search.get()): planet_entry['values'] = tuple( [catalogue.searchPlanet(planet_search.get()).name]) else: planet_entry['values'] = tuple([]) if len(planet_entry['values']) == 1: planet.set(planet_entry['values'][0]) update_planet.set(True) else: planet.set('Choose Planet') update_planet_list.set(False) if update_planet.get(): parameters = plc.find_oec_parameters(planet.get(), catalogue=catalogue) logg.set(parameters[1]) temperature.set(parameters[2]) metallicity.set(parameters[3]) rp_over_rs.set(parameters[4]) period.set(parameters[6]) sma_over_rs.set(parameters[7]) eccentricity.set(parameters[8]) inclination.set(parameters[9]) periastron.set(parameters[10]) ascending_node.set(0.0) update_planet.set(False) phot_filter_label_2.configure( text=available_filters[phot_filter.get()]) planet_entry.selection_clear() plot_transit = True for input_entry in [ phot_filter_entry, metallicity_entry, temperature_entry, logg_entry, period_entry, rp_over_rs_entry, sma_over_rs_entry, inclination_entry, eccentricity_entry, periastron_entry ]: if len(str(input_entry.get())) == 0: plot_transit = False if plot_transit: if period.get() == 0 or rp_over_rs.get() == 0 or sma_over_rs.get( ) == 0: plot_transit = False if plot_transit: try: limb_darkening_coefficients = plc.clablimb( 'claret', logg.get(), temperature.get(), metallicity.get(), available_filters[phot_filter.get()]) time_array = np.arange(100 - period.get() / 4, 100 + period.get() / 4, 30. / 24. / 60. / 60.) position = plc.exoplanet_orbit(period.get(), sma_over_rs.get(), eccentricity.get(), inclination.get(), periastron.get(), 100, time_array) time_array = time_array[np.where((np.abs(position[1]) < 1.5) & (position[0] > 0))] position = plc.exoplanet_orbit(period.get(), sma_over_rs.get(), eccentricity.get(), inclination.get(), periastron.get(), 100, time_array, ww=ascending_node.get()) transit_light_curve = plc.transit('claret', limb_darkening_coefficients, rp_over_rs.get(), period.get(), sma_over_rs.get(), eccentricity.get(), inclination.get(), periastron.get(), 100, time_array) a1, a2, a3, a4 = limb_darkening_coefficients star_r = np.arange(0, 1, 0.01) star_m = np.sqrt(1 - star_r * star_r) star_i = (1.0 - a1 * (1.0 - star_m**0.5) - a2 * (1.0 - star_m) - a3 * (1.0 - star_m**1.5) - a4 * (1.0 - star_m**2)) cmap = matplotlib.cm.get_cmap('rainbow') color = cmap(1 - (temperature.get() - 3500) / (9000 - 3500)) ax2.cla() ax2.set_aspect('equal') ax2.tick_params(axis='both', which='both', bottom='off', left='off', top='off', right='off', labelbottom='off', labelleft='off') star_circle = matplotlib.patches.Circle((0, 0), 1, color=color, fc=color) planet_circle = matplotlib.patches.Circle( (position[1][len(position[1]) // 2], position[2][len(position[2]) // 2]), rp_over_rs.get(), color='k', fc='k') ax2.add_patch(star_circle) ax2.add_patch(planet_circle) ax2.plot(position[1], position[2], c='k') ax2.set_xlim(-1.5, 1.5) ax2.set_ylim(-1.5, 1.5) ax3.cla() ax3.set_aspect(3.0) ax3.set_yticks([0, 0.5, 1.0]) ax3.set_xticks([-1.0, 0, 1.0]) ax3.plot(star_r, star_i, c=color) ax3.plot(-star_r, star_i, c=color) ax3.set_xlim(-1.5, 1.5) ax3.set_ylim(0.1, 1.1) ax3.set_ylabel('I / I0') ax3.set_xlabel('r / Rs') ax1.cla() ax1.plot((time_array - 100) * 24.0 * 60.0, 1000 * transit_light_curve, c='k') ylim_1 = int(min(transit_light_curve) * 200) ax1.set_ylim(1000 * ylim_1 / 200.0, 1001) ax1.tick_params(left='off', right='on', labelleft='off', labelright='on') ax1.set_ylabel('F / F0 (ppt)') ax1.set_xlabel('t - T0 (min)') except IndexError: ax1.cla() ax2.cla() ax3.cla() canvas.draw() update_window() # define actions for the different buttons, including calls to the function that updates the window def choose_planet(entry): if not entry: return 0 update_planet.set(True) update_window() def search_planet(): update_planet_list.set(True) update_window() def plot(): open_root2.set(True) update_window() root2.deiconify() def exit_transit_simulator(): root.destroy() root2.destroy() # connect actions to widgets planet_entry.bind('<<ComboboxSelected>>', choose_planet) phot_filter_entry.bind("<ButtonRelease-1>", update_window) metallicity_entry.bind("<ButtonRelease-1>", update_window) temperature_entry.bind("<ButtonRelease-1>", update_window) logg_entry.bind("<ButtonRelease-1>", update_window) period_entry.bind(sequence='<KeyRelease>', func=update_window) rp_over_rs_entry.bind("<ButtonRelease-1>", update_window) sma_over_rs_entry.bind("<ButtonRelease-1>", update_window) inclination_entry.bind("<ButtonRelease-1>", update_window) eccentricity_entry.bind("<ButtonRelease-1>", update_window) periastron_entry.bind("<ButtonRelease-1>", update_window) ascending_node_entry.bind("<ButtonRelease-1>", update_window) search_planet_button['command'] = search_planet plot_button['command'] = plot exit_transit_simulator_button['command'] = exit_transit_simulator # setup window setup_window(root, [ [], [[phot_filter_label_2, 3]], [[phot_filter_label, 2], [phot_filter_entry, 3]], [[metallicity_label, 2], [metallicity_entry, 3]], [[temperature_label, 2], [temperature_entry, 3]], [[logg_label, 2], [logg_entry, 3]], [[planet_label, 1]], [[planet_search_entry, 1], [period_label, 2], [period_entry, 3]], [[search_planet_button, 1]], [[planet_entry, 1], [rp_over_rs_label, 2], [rp_over_rs_entry, 3]], [[sma_over_rs_label, 2], [sma_over_rs_entry, 3]], [[inclination_label, 2], [inclination_entry, 3]], [[plot_button, 1], [eccentricity_label, 2], [eccentricity_entry, 3]], [[exit_transit_simulator_button, 1], [periastron_label, 2], [periastron_entry, 3]], [[ascending_node_label, 2], [ascending_node_entry, 3]], [], ]) # finalise and show window finalise_window(root, 1) finalise_window(root2, 3) root.mainloop()
def serine(self): cn_min = [0, 0, 40] cn_max = [-45, 40, 10] bnh_min = [-45, 40, 10] bnh_max = [-50, 40, -50] cc1_min = [0, 0, 40] cc1_max = [45, -40, 10] bco_min = [45, -40, 10] bco_max = [60, -40, -50] ch1_min = [0, 0, 40] ch1_max = [-10, 10, 70] cc2_min = [0, 0, 40] cc2_max = [10, -10, 70] ch2_min = [10, -10, 70] ch2_max = [5, -5, 90] ch3_min = [10, -10, 70] ch3_max = [20, -20, 90] co2_min = [10, -10, 70] co2_max = [40, -40, 70] oh_min = [40, -40, 70] oh_max = [60, -50, 50] fig = Figure(figsize=(10, 6), dpi=100, facecolor='black') canvas = FigureCanvasTkAgg(fig, self) canvas.draw() ax = fig.add_subplot(111, projection="3d") ax.set_axis_bgcolor("black") cn = ax.plot([cn_max[0], cn_min[0]], [cn_max[1], cn_min[1]], [cn_max[2], cn_min[2]], linewidth=5, color=cn_color, marker='o', markerfacecolor='orange', markersize=12) bnh = ax.plot([bnh_max[0], bnh_min[0]], [bnh_max[1], bnh_min[1]], [bnh_max[2], bnh_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) ccl = ax.plot([cc1_max[0], cc1_min[0]], [cc1_max[1], cc1_min[1]], [cc1_max[2], cc1_min[2]], linewidth=5, color=cc_color, marker='o', markerfacecolor='orange', markersize=12) bco = ax.plot([bco_max[0], bco_min[0]], [bco_max[1], bco_min[1]], [bco_max[2], bco_min[2]], linewidth=5, color=co_color, marker='o', markerfacecolor='orange', markersize=12) ch1 = ax.plot([ch1_max[0], ch1_min[0]], [ch1_max[1], ch1_min[1]], [ch1_max[2], ch1_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) cc2 = ax.plot([cc2_max[0], cc2_min[0]], [cc2_max[1], cc2_min[1]], [cc2_max[2], cc2_min[2]], linewidth=5, color=cc_color, marker='o', markerfacecolor='orange', markersize=12) ch2 = ax.plot([ch2_max[0], ch2_min[0]], [ch2_max[1], ch2_min[1]], [ch2_max[2], ch2_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) ch3 = ax.plot([ch3_max[0], ch3_min[0]], [ch3_max[1], ch3_min[1]], [ch3_max[2], ch3_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) co2 = ax.plot([co2_max[0], co2_min[0]], [co2_max[1], co2_min[1]], [co2_max[2], co2_min[2]], linewidth=5, color=co_color, marker='o', markerfacecolor='orange', markersize=12) oh = ax.plot([oh_max[0], oh_min[0]], [oh_max[1], oh_min[1]], [oh_max[2], oh_min[2]], linewidth=5, color=oh_color, marker='o', markerfacecolor='orange', markersize=12) tch = plt.Rectangle((0, 0), 1, 1, fc=ch_color) toh = plt.Rectangle((0, 0), 1, 1, fc=oh_color) tcn = plt.Rectangle((0, 0), 1, 1, fc=cn_color) tcc = plt.Rectangle((0, 0), 1, 1, fc=cc_color) tbco = plt.Rectangle((0, 0), 1, 1, fc=co_color) tbnh = plt.Rectangle((0, 0), 1, 1, fc=nh_color) ax.legend([tch, tcn, tcc, tbco, tbnh, toh], ['ch', 'cn', 'cc', 'co', 'nh', 'oh']) ax.axis("off") toolbarFrame = Frame(self) toolbarFrame.grid(row=6, column=7) toolbar = NavigationToolbar2TkAgg(canvas, toolbarFrame) canvas.get_tk_widget().grid(row=4, column=7)
def __init__(self, parent, controller): tk.Frame.__init__(self, parent) self.configure(background='white') w, h = self.winfo_screenwidth(), self.winfo_screenheight() xunit = w / 1000 yunit = h / 1000 label = tk.Label(self, text="PID Controller\nand\nMonitering\n\nGROUP 5", font=LARGE_FONT, background='white') label.place(x=xunit * 20, y=yunit * 20) self.KpLabel = tk.Label(self, text="Kp:", background='white') self.KpLabel.place(x=xunit * 10, y=yunit * 325) self.KiLabel = tk.Label(self, text="Ki:", background='white') self.KiLabel.place(x=xunit * 10, y=yunit * 375) self.KdLabel = tk.Label(self, text="Kd:", background='white') self.KdLabel.place(x=xunit * 10, y=yunit * 425) self.Setpoint = tk.Label(self, text="Sp:", background='white') self.Setpoint.place(x=xunit * 10, y=yunit * 475) CurrentKp = tk.Label(self, text="Current Kp:", background='white') CurrentKp.place(x=xunit * 10, y=yunit * 625) self.CurrentKp = tk.Label(self, text=str(PID_datahouse.Kp), background='white') self.CurrentKp.place(x=xunit * 85, y=yunit * 625) CurrentKi = tk.Label(self, text="Current Ki:", background='white') CurrentKi.place(x=xunit * 10, y=yunit * 675) self.CurrentKi = tk.Label(self, text=str(PID_datahouse.Ki), background='white') self.CurrentKi.place(x=xunit * 85, y=yunit * 675) CurrentKd = tk.Label(self, text="Current Kd:", background='white') CurrentKd.place(x=xunit * 10, y=yunit * 725) self.CurrentKd = tk.Label(self, text=str(PID_datahouse.Kd), background='white') self.CurrentKd.place(x=xunit * 85, y=yunit * 725) CurrentSetpoint = tk.Label(self, text="Current Setpoint: ", background='white') CurrentSetpoint.place(x=xunit * 10, y=yunit * 775) self.CurrentSetpoint = tk.Label(self, text=str(PID_datahouse.Sp), background='white') self.CurrentSetpoint.place(x=xunit * 85, y=yunit * 775) self.KpEntry = ttk.Entry(self) self.KpEntry.place(x=xunit * 30, y=yunit * 325) self.KiEntry = ttk.Entry(self) self.KiEntry.place(x=xunit * 30, y=yunit * 375) self.KdEntry = ttk.Entry(self) self.KdEntry.place(x=xunit * 30, y=yunit * 425) self.SpEntry = ttk.Entry(self) self.SpEntry.place(x=xunit * 30, y=yunit * 475) button1 = ttk.Button(self, text='Connect', command=lambda: self.connectingFunc()) button1.place(x=xunit * 30, y=yunit * 200) button2 = ttk.Button(self, text='Disconnect', command=lambda: self.disconnectingFunc()) button2.place(x=xunit * 30, y=yunit * 250) button3 = ttk.Button(self, text='Update', command=lambda: self.updateFromEntry()) button3.place(x=xunit * 30, y=yunit * 525) button3 = ttk.Button(self, text='Quit', command=lambda: self.quitFunc(controller)) button3.place(x=xunit * 30, y=yunit * 875) self.ErrorValue = tk.Label(self, text="No Error", background='Green', width=15, anchor='w') self.ErrorValue.place(x=xunit * 100, y=yunit * 526) self.ErrorConnect = tk.Label(self, text="Not Connected", background='red', width=15, anchor='w') self.ErrorConnect.place(x=xunit * 100, y=yunit * 200) canvas = FigureCanvasTkAgg(PID_datahouse.graph, self) canvas.show() toolbar = NavigationToolbar2TkAgg(canvas, self) toolbar.update() canvas._tkcanvas.place(x=xunit * 250, y=00)
def Main(argv): line_number = 0 usage = "Usage: %prog FILENAME [options]" parser = OptionParser(usage=usage) parser.add_option("-s", "--start", action="store", type="int", dest="start", default=0, help="Start time of analysis in ms") parser.add_option("-e", "--end", action="store", type="int", dest="end", default=1000000000, help="End time of analysis in ms") parser.add_option("-c", "--core", action="store", type="int", dest="num_of_cores", default=0, help="Number of cores, default is 0, i.e. tool automatically tries to " \ "identify num of cores, can fail if 1 core stays in Idle") parser.add_option("", "--norun", action="store_false", dest="running_threads_plot", default=True, help="Disable graph displaying running threads") parser.add_option("", "--nocoreload", action="store_false", dest="load_per_core_plot", default=True, help="Disable graph displaying CPU load per core") parser.add_option("", "--noirq", action="store_false", dest="irq_plot", default=True, help="Disable graph displaying IRQs") parser.add_option( "-t", "--timeslice", action="store", type="int", dest="timeslice", default=150, help="Timeslice in ms for CPU load per core plot, default 150") parser.add_option("", "--tsref", action="store", type="str", dest="timestamp_file", default="", help="Use timestamp alignment file") parser.add_option("", "--mhz", action="store_true", dest="cpu_mhz", default=False, help="CPU load per core in MHz") (options, args) = parser.parse_args() if len(args) != 1: print "Usage: type python <program>.py -h" return filterMaster.timestamp_start_b = int(options.start) filterMaster.timestamp_end_b = int(options.end) if str(options.timestamp_file): if timestamp_ref_module: ref_ts.set_file(str(options.timestamp_file)) else: print "\'timestamp_ref\' module not found: \'--tsref\' discarded" filterMaster_ts.timestamp_start_b = int(options.start) filterMaster_ts.timestamp_end_b = int(options.end) filterMaster_ts.timeslice_ms = options.timeslice filterMaster_ts.num_of_cores = options.num_of_cores filterMaster_ts.mhz = options.cpu_mhz irqTrace.timestamp_start_b = int(options.start) irqTrace.timestamp_end_b = int(options.end) # CPU load detailed diagram ########################### file = open(args[0], 'r') string = file.readline() # search for regexp while (string): line_number += 1 filterMaster.filter_line(string, line_number) string = file.readline() file.close() # CPU load per core ################### if options.load_per_core_plot: file = open(args[0], 'r') line_number = 0 string = file.readline() # search num of cores if (filterMaster_ts.num_of_cores == 0): while (string): filterMaster_ts.filter_line_pre(string, line_number) string = file.readline() file.close() # search for regexp file = open(args[0], 'r') line_number = 0 string = file.readline() while (string): line_number += 1 filterMaster_ts.filter_line(string, line_number) string = file.readline() file.close() # IRQ diagram ############# if options.irq_plot: file = open(args[0], 'r') string = file.readline() # search for regexp while (string): line_number += 1 irqTrace.filter_line(string, line_number) string = file.readline() file.close() # Display ######### #Update label size for Y axis for all charts matplotlib.rc('ytick', labelsize=10) bottom_margin = 0.05 margin = 0.03 first_graph = None ############################################################# # Window 1: MPU Thread/IRQ execution # ############################################################# win1_num_plot = [] if options.running_threads_plot: win1_num_plot.append(2) if options.irq_plot: win1_num_plot.append(1) current_vert = 1 - margin current_plot = 0 if len(win1_num_plot) > 0: left_margin = 0.2 win1_vert_size = ((1 - bottom_margin - len(win1_num_plot) * margin) / sum(win1_num_plot)) fig1 = P.figure() if options.running_threads_plot: current_vert -= win1_vert_size * win1_num_plot[current_plot] gr = P.axes([ left_margin, current_vert, 1 - (margin + left_margin), win1_vert_size * win1_num_plot[current_plot] ]) current_vert -= margin current_plot += 1 if (first_graph == None): first_graph = gr filterMaster.draw() if options.irq_plot: current_vert -= win1_vert_size * win1_num_plot[current_plot] gr = P.axes([ left_margin, current_vert, 1 - (margin + left_margin), win1_vert_size * win1_num_plot[current_plot] ], sharex=first_graph) current_vert -= margin current_plot += 1 if (first_graph == None): first_graph = gr irqTrace.draw() P.xlabel('time (ms)') root1 = Tk.Tk() root1.title(string="MPU Thread/IRQ execution (" + args[0] + ")") canvas1 = FigureCanvasTkAgg(fig1, master=root1) canvas1.show() canvas1.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) toolbar1 = NavigationToolbar2TkAgg(canvas1, root1) toolbar1.update() canvas1._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) ############################################################# # Window 2: MPU load # ############################################################# win2_num_plot = [] cpu_label_margin = 0.05 if options.load_per_core_plot: win2_num_plot.append(1) current_vert = 1 - margin current_plot = 0 if len(win2_num_plot) > 0: left_margin = 0.2 win2_vert_size = ((1 - bottom_margin - len(win2_num_plot) * margin) / sum(win2_num_plot)) fig2 = P.figure() if options.load_per_core_plot: current_vert -= win2_vert_size * win2_num_plot[current_plot] gr = P.axes([ left_margin, current_vert, 1 - (margin + left_margin), (win2_vert_size - cpu_label_margin) * win2_num_plot[current_plot] ], sharex=first_graph) current_vert -= margin current_plot += 1 if (first_graph == None): first_graph = gr filterMaster_ts.draw() P.xlabel('time (ms)') if len(win1_num_plot) > 0: root2 = Tk.Toplevel(root1) else: root2 = Tk.Tk() root2.title(string="MPU load (" + args[0] + ")") canvas2 = FigureCanvasTkAgg(fig2, master=root2) canvas2.show() canvas2.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) toolbar2 = NavigationToolbar2TkAgg(canvas2, root2) toolbar2.update() canvas2._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) ############################################################# if len(win1_num_plot) > 0: root = root1 else: root = root2 def _quit(): root.quit() # stops mainloop root.destroy() # this is necessary on Windows to prevent # Fatal Python Error: PyEval_RestoreThread: NULL tstate root.protocol("WM_DELETE_WINDOW", _quit) root.mainloop()
def __init__(self): '''Create the user interface and initialize it ''' self.root = Tk() #self.root.geometry("+100+0") # Set window title from command-line argument, which is saved in self.subarray_name self.root.wm_title('Delay Widget') self.menu = Menu(self.root) filemenu = Menu(self.menu, tearoff=0) self.menu.add_cascade(label='File', menu=filemenu) filemenu.add_command(label='Open npz File...', command=self.Opennpz) filemenu.add_command(label='Save Delays to ACC', command=self.Save) filemenu.add_command(label='Save LoRX Delays to ACC', command=self.SaveLoRX) self.root.config(menu=self.menu) fmain = Frame(self.root) fmain.pack() line1 = Frame(fmain) line1.pack() Label(line1, text='Ant 14 Y-X Delay', font="Helvetica 14").pack(side=LEFT, expand=1) self.dla14var = StringVar() self.dla14 = Entry(line1, textvariable=self.dla14var, font="Helvetica 14", width=5) self.dla14var.set('0.0') self.dla14.bind("<Return>", self.fetch) self.dla14.pack(side=LEFT) dla14updown = Frame(line1) dla14updown.pack(side=LEFT) self.dla14upbtn = Button(dla14updown, text=u'\u25B2', command=self.up14dla, borderwidth=0, pady=0) self.dla14upbtn.pack(padx=1, pady=0) self.dla14dnbtn = Button(dla14updown, text=u'\u25BC', command=self.down14dla, borderwidth=0, pady=0) self.dla14dnbtn.pack(padx=1, pady=0) line2 = Frame(fmain) line2.pack() fleft = Frame(line2) fleft.pack(side=LEFT) leftant = Frame(fleft) leftant.pack(side=TOP) Label(leftant, text='Ant', font="Helvetica 14").pack(side=LEFT) self.antvar = StringVar() self.ant = Entry(leftant, textvariable=self.antvar, font="Helvetica 14", width=3) self.antvar.set('1') #self.ant.bind("<Return>", self.fetch) self.ant.pack(side=LEFT) #antbtns = Frame(leftant) #antbtns.pack() antupdown = Frame(leftant) antupdown.pack() self.antupbtn = Button(antupdown, text=u'\u25B2', command=self.up, borderwidth=0, pady=0) self.antupbtn.pack(padx=1, pady=0) self.antdnbtn = Button(antupdown, text=u'\u25BC', command=self.down, borderwidth=0, pady=0) self.antdnbtn.pack(padx=1, pady=0) leftdla = Frame(fleft) leftdla.pack() Label(leftdla, text='X Delay', font="Helvetica 14").pack(side=LEFT) self.delays = np.zeros(13, np.float) self.dlavar = StringVar() self.dla = Entry(leftdla, textvariable=self.dlavar, font="Helvetica 14", width=5) self.dlavar.set(str(self.delays[0])) self.dla.bind("<Return>", self.fetch) self.dla.pack(side=LEFT) #dlabtns = Frame(leftdla) dlaupdown = Frame(leftdla) dlaupdown.pack() self.dlaupbtn = Button(dlaupdown, text=u'\u25B2', command=self.updla, borderwidth=0, pady=0) self.dlaupbtn.pack(padx=1, pady=0) self.dladnbtn = Button(dlaupdown, text=u'\u25BC', command=self.downdla, borderwidth=0, pady=0) self.dladnbtn.pack(padx=1, pady=0) leftxydla = Frame(fleft) leftxydla.pack() Label(leftxydla, text='Y-X Delay', font="Helvetica 14").pack(side=LEFT) self.xydelays = np.zeros(13, np.float) self.xydlavar = StringVar() self.xydla = Entry(leftxydla, textvariable=self.xydlavar, font="Helvetica 14", width=5) self.xydlavar.set(str(self.xydelays[0])) self.xydla.bind("<Return>", self.fetch) self.xydla.pack(side=LEFT) #dlabtns = Frame(leftdla) xydlaupdown = Frame(leftxydla) xydlaupdown.pack() self.xydlaupbtn = Button(xydlaupdown, text=u'\u25B2', command=self.xyupdla, borderwidth=0, pady=0) self.xydlaupbtn.pack(padx=1, pady=0) self.xydladnbtn = Button(xydlaupdown, text=u'\u25BC', command=self.xydowndla, borderwidth=0, pady=0) self.xydladnbtn.pack(padx=1, pady=0) fright = Frame(line2) fright.pack() self.fig = plt.figure(1) self.ax = [] for i in range(4): self.ax.append(self.fig.add_subplot(220 + i + 1)) self.ax[i].grid() self.canvas = FigureCanvasTkAgg(self.fig, fright) self.canvas.show() self.canvas.get_tk_widget().pack(side=TOP, expand=1) toolbar1 = NavigationToolbar2TkAgg(self.canvas, fright) toolbar1.update() self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1) savebtn = Button(fmain, text='Show', command=self.show) savebtn.pack(side=LEFT, padx=3, pady=3) quitbtn = Button(fmain, text='Exit', command=self.root.quit) quitbtn.pack(side=LEFT, padx=3, pady=3) self.label1 = Label(fmain, text='', font='Courier 10') self.label1.pack() self.label2 = Label(fmain, text='', font='Courier 10') self.label2.pack() self.label3 = Label(fmain, text='', font='Courier 10') self.label3.pack() # Some test data to play with self.data_source = 'Simulation' self.fghz = np.array([3.4, 3.5, 3.6, 4.4, 4.6, 4.8]) self.pol = np.array([0, 2, 3, 1]) nf = len(self.fghz) taux = np.random.randn(13) tauy = taux + np.random.randn(13) * 0.1 taux14 = 0.3 tauy14 = -1.1 df = np.random.randn(13, 4, nf) * 0.1 self.ph = np.zeros((13, 4, nf), float) for k, fghz in enumerate(self.fghz): self.ph[:, 0, k] = 2 * np.pi * fghz * (taux14 - taux) + df[:, 0, k] # XX self.ph[:, 1, k] = 2 * np.pi * fghz * (tauy14 - tauy) + df[:, 1, k] # YY self.ph[:, 2, k] = 2 * np.pi * fghz * (tauy14 - taux) + df[:, 2, k] # XY self.ph[:, 3, k] = 2 * np.pi * fghz * (taux14 - tauy) + df[:, 3, k] # YX self.doplot(ant=1)
def __init__(self, root): self.images = [] self.axes = [] self.filename = '' self.sequenz = Daten() self.serialState = '' self.decstart = 0 self.decend = 1500 #GUI self.config = ConfigParser.RawConfigParser() self.configfile = 'LogikAnalyse.cfg' self.defaultDir = "Daten" try: self.loadConfig() except: print 'Kein Configfile gefunden, nehme Anfangswerte' #initial defaults self.pulseMin = 300 self.samples = 1500 self.comPortSelect = 'COM9' self.messTyp = 'pulse' self.root = root self.root.title('Logik Analyse') self.root.protocol("WM_DELETE_WINDOW", self.exit_) self.fig = matplotlib.figure.Figure() self.axes = self.fig.add_subplot(1, 1, 1) figframe = Tk.Frame(root) figframe.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) canvas = FigureCanvasTkAgg(self.fig, master=figframe) toolbar = NavigationToolbar2TkAgg(canvas, figframe) toolbar.pack(side=Tk.TOP, fill=Tk.BOTH) # expand=1) self.modify_toolbar() self.scaleY() self.add_menu() configframe = Tk.Frame(root) configframe.pack(side=Tk.BOTTOM, fill=Tk.BOTH, expand=1) self.samplesSpinboxVal = Tk.StringVar() self.samplesSpinboxVal.set(str(self.samples)) self.samplesSpinboxLabel = Tk.Label(configframe, text='Samples').pack(side=Tk.LEFT, anchor=Tk.E) self.samplesSpinbox = Tk.Spinbox(configframe, from_=500, to=5000, increment=500, width=5, textvariable=self.samplesSpinboxVal) self.samplesSpinbox.pack(side=Tk.LEFT) self.pulseMinSpinboxVal = Tk.StringVar() self.pulseMinSpinboxVal.set(str(self.pulseMin)) self.pulseMinSpinboxLabel = Tk.Label( configframe, text='pulseMin').pack(side=Tk.LEFT, anchor=Tk.E) self.pulseMinSpinbox = Tk.Spinbox(configframe, from_=100, to=500, increment=50, width=5, textvariable=self.pulseMinSpinboxVal) self.pulseMinSpinbox.pack(side=Tk.LEFT) self.comPortSpinboxVal = Tk.StringVar() self.comPortSpinboxVal.set(str(self.comPortSelect)) #print self.comPortSpinboxVal.get() self.comPorts = tuple(serial_ports()) self.comPortSpinboxLabel = Tk.Label(configframe, text='Port').pack(side=Tk.LEFT, anchor=Tk.E) self.comPortSpinbox = Tk.Spinbox(configframe, command=self.switchconnectSer(), values=self.comPorts, textvariable=self.comPortSpinboxVal, width=14) self.comPortSpinbox.pack(side=Tk.LEFT) self.messTypRadioVal = Tk.StringVar() self.messTypRadioVal.set(self.messTyp) self.messTypDtRadio = Tk.Radiobutton(configframe, text='dt', padx=0, variable=self.messTypRadioVal, value='dt') self.messTypDtRadio.pack(side=Tk.LEFT, anchor=Tk.W) self.messTypPulseRadio = Tk.Radiobutton(configframe, text='Pulse', padx=0, variable=self.messTypRadioVal, value='pulse') self.messTypPulseRadio.pack(side=Tk.LEFT, anchor=Tk.W) canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) self.root.bind('<Control-y>', lambda e: self.scaleY()) self.root.bind('<Control-m>', lambda e: self.aufnahme()) # implement the default mpl key bindings def on_key_event(event): #if (event.key=='y'): # self.scaleY() key_press_handler(event, canvas, toolbar) self.tmp_cid1 = canvas.mpl_connect('key_press_event', on_key_event) def on_button_event(event): self.scaleY() self.tmp_cid2 = canvas.mpl_connect('button_release_event', on_button_event)
def __init__(self, top=None): '''This class configures and populates the toplevel window. top is the toplevel containing window.''' self._bgcolor = '#d9d9d9' # X11 color: 'gray85' self._fgcolor = '#000000' # X11 color: 'black' self._compcolor = '#d9d9d9' # X11 color: 'gray85' self._ana1color = '#d9d9d9' # X11 color: 'gray85' self._ana2color = '#d9d9d9' # X11 color: 'gray85' self.style = ttk.Style() if sys.platform == "win32": self.style.theme_use('winnative') self.style.configure('.', background=self._bgcolor) self.style.configure('.', foreground=self._fgcolor) self.style.map('.', background=[('selected', self._compcolor), ('active', self._ana2color)]) #init options and load .config file self.config = options.defaultConfig() options.loadConfig(self.config) top.geometry("1026x675+477+155") top.title("Pygrid") top.configure(highlightcolor="black") self.TSizegrip1 = ttk.Sizegrip(top) self.TSizegrip1.place(anchor=SE, relx=1.0, rely=1.0) self.Frame1 = Frame(top) self.Frame1.place(relx=0.0, rely=0.06, relheight=0.94, relwidth=0.78) self.Frame1.configure(relief=GROOVE, borderwidth="2", width=805) self.figure = Figure(dpi=50) self.Canvas1 = FigureCanvasTkAgg(self.figure, master=self.Frame1) self.Canvas1.get_tk_widget().pack(side=TOP, fill="both", expand=1) self.ax = self.figure.add_axes([.05, .05, .80, .9]) self.ax.axis([ float(self.config['gen']['dlonmin']), float(self.config['gen']['dlonmax']), float(self.config['gen']['dlatmin']), float(self.config['gen']['dlatmax']) ]) self.cax = self.figure.add_axes([.05 + .8 + 0.025, .05, .025, .9]) self.cax.set_visible(False) self.toolbar = NavigationToolbar2TkAgg(self.Canvas1, self.Frame1) self.menubar = Menu(top, bg=self._bgcolor, fg=self._fgcolor) top.configure(menu=self.menubar) def add_cascade(r, m, t): r.add_cascade(menu=m, activebackground="#d9d9d9", activeforeground="#000000", background="#d9d9d9", foreground="#000000", label=t) def add_command(r, c, t): r.add_command(activebackground="#d8d8d8", activeforeground="#000000", background="#d9d9d9", command=c, foreground="#000000", label=t) self.file = Menu(top, tearoff=0) add_cascade(self.menubar, self.file, "File") add_command(self.file, pygrid_support.TODO, "New") self.file.add_separator(background="#d9d9d9") add_command(self.file, pygrid_support.TODO, "Exit") self.save = Menu(top, tearoff=0) add_cascade(self.menubar, self.save, "Save") add_command(self.save, pygrid_support.save_segfile, "Save segfile") add_command(self.save, pygrid_support.save_neifile, "Save neifile") add_command(self.save, pygrid_support.save_nodfile, "Save nodfile") add_command(self.save, pygrid_support.save_nod2polyfile, "Save nod2poly file") add_command(self.save, pygrid_support.save_llzfile, "Save llzfile") add_command(self.save, pygrid_support.save_markerfile, "Save markerfile") self.load = Menu(top, tearoff=0) add_cascade(self.menubar, self.load, "Load") add_command(self.load, pygrid_support.load_coastline, "Load coastline") add_command(self.load, pygrid_support.load_segfile, "Load segfile") add_command(self.load, pygrid_support.load_neifile, "Load neifile") add_command(self.load, pygrid_support.load_nodfile, "Load nodfile") add_command(self.load, pygrid_support.load_llzfile, "Load llzfile") add_command(self.load, pygrid_support.load_fvcomfile, "Load fvcom") add_command(self.load, pygrid_support.load_markerfile, "Load markerfile") self.options = Menu(top, tearoff=0) add_cascade(self.menubar, self.options, "Options") add_command(self.options, self.getGeneralOptionBox, "General Options") add_command(self.options, self.getCoastOptionBox, "Coastline Options") add_command(self.options, self.getSegOptionBox, "Seg Options") add_command(self.options, self.getNeiOptionBox, "Nei Options") add_command(self.options, self.getNodOptionBox, "Nod Options") add_command(self.options, self.getllzOptionBox, "llz Options") add_command(self.options, self.getFvcomOptionBox, "Fvcom Options") add_command(self.options, self.getMarkerOptionBox, "Marker Options") self.help = Menu(top, tearoff=0) add_cascade(self.menubar, self.help, "Help") add_command(self.help, pygrid_support.TODO, "About") ################################################################ # # Checkboxes # ################################################################ self.Frame3 = Frame(top) self.Frame3.place(relx=0.0, rely=0.0, relheight=0.07, relwidth=0.78) self.Frame3.configure(relief=GROOVE, borderwidth="2", width=805) self.types = [ 'coast', 'seg', 'nei', 'nod', 'llz', 'neic', 'fvcom', 'marker' ] self.CBVar = {} for typ in self.types: self.CBVar[typ] = IntVar() def cbutton(frm, x, y, h, w, t, c, v): cb = Checkbutton(frm) cb.place(relx=x, rely=y, relheight=h, relwidth=w) cb.configure(activebackground="#d9d9d9", justify=LEFT) cb.configure(text=t, command=c, variable=v) return cb cbutton(self.Frame3, 0.01, 0.04, 0.91, 0.15, '''Show coastline''', pygrid_support.toggle_coastline, self.CBVar['coast']) cbutton(self.Frame3, 0.16, 0.04, 0.91, 0.15, '''Show Segfile''', pygrid_support.toggle_segfile, self.CBVar['seg']) cbutton(self.Frame3, 0.31, 0.04, 0.91, 0.12, '''Show Neifile''', pygrid_support.toggle_neifile, self.CBVar['nei']) cbutton(self.Frame3, 0.43, 0.04, 0.91, 0.14, '''Show Nodfile''', pygrid_support.toggle_nodfile, self.CBVar['nod']) cbutton(self.Frame3, 0.57, 0.04, 0.91, 0.12, '''Show llzfile''', pygrid_support.toggle_llzfile, self.CBVar['llz']) cbutton(self.Frame3, 0.70, 0.04, 0.91, 0.15, '''Show nei color''', pygrid_support.toggle_neifilecolor, self.CBVar['neic']) self.NeiMenuVar = StringVar(root) self.NeiChoices = {'Depth', 'dhh', 'Sidelength'} self.NeiMenuVar.set('Depth') self.NeiMenu = OptionMenu(self.Frame3, self.NeiMenuVar, *self.NeiChoices) self.NeiMenu.place(relx=0.850, rely=0.04, relheight=0.91, relwidth=0.15) self.NeiMenuVar.trace('w', pygrid_support.change_neimenu) ######################################################################## # # Make notebook # ###################################################################### self.nb = ttk.Notebook(top) self.Frame2 = Frame(self.nb) self.Frame2.place(relx=0.78, rely=0.0, relheight=0.75, relwidth=0.22) self.Frame2.configure(relief=GROOVE, borderwidth="2", width=215) self.Frame5 = Frame(self.nb) self.Frame5.place(relx=0.78, rely=0.0, relheight=0.75, relwidth=0.22) self.Frame5.configure(relief=GROOVE, borderwidth="2", width=215) self.Frame6 = Frame(self.nb) self.Frame6.place(relx=0.78, rely=0.0, relheight=0.75, relwidth=0.22) self.Frame6.configure(relief=GROOVE, borderwidth="2", width=215) self.Frame7 = Frame(self.nb) self.Frame7.place(relx=0.78, rely=0.0, relheight=0.75, relwidth=0.22) self.Frame7.configure(relief=GROOVE, borderwidth="2", width=215) self.Frame8 = Frame(self.nb) self.Frame8.place(relx=0.78, rely=0.0, relheight=0.75, relwidth=0.22) self.Frame8.configure(relief=GROOVE, borderwidth="2", width=215) self.nb.add(self.Frame2, text='Nodes') self.nb.add(self.Frame5, text='Depth') self.nb.add(self.Frame6, text='Seg') self.nb.add(self.Frame7, text='FVCOM') self.nb.add(self.Frame8, text='Marker') self.nb.place(relx=0.78, rely=0, relheight=0.75, relwidth=0.22) rh = 0.055 rw = 0.85 rw2 = 0.4 rw4 = 0.2 sh = 0.06 ######################################################################## # functions for labels entrys etc that capture common elements ######################################################################## def label(frm, x, y, h, w, t): l = Label(frm) l.place(relx=x, rely=y, relheight=h, relwidth=w) l.configure(activebackground="#f9f9f9") l.configure(text=t) return l def entry(frm, x, y, h, w, t): e = Entry(frm) e.place(relx=x, rely=y, relheight=h, relwidth=w) e.configure(background="white") e.configure(font="TkFixedFont") e.configure(selectbackground="#c4c4c4") e.insert(0, t) return e def button(frm, x, y, h, w, t, c): b = Button(frm) b.place(relx=x, rely=y, relheight=h, relwidth=w) b.configure(activebackground="#d9d9d9") b.configure(text=t) b.configure(command=c) return b ######################################################################## # # Node Tab # ######################################################################## ry = 0.01 label(self.Frame2, 0.075, ry, rh, rw2, '''Set resolution''') self.Entry1 = entry(self.Frame2, 0.525, ry, rh, rw2, '') button(self.Frame2, 0.075, ry + sh * 1, rh, rw, '''Spray Area''', pygrid_support.spray_area) button(self.Frame2, 0.075, ry + sh * 2, rh, rw, '''Remove Area''', pygrid_support.remove_area) button(self.Frame2, 0.075, ry + sh * 3, rh, rw, '''Remove Area (llz)''', pygrid_support.remove_area_llz) button(self.Frame2, 0.075, ry + sh * 5, rh, rw, '''Remove nodes inside seg''', pygrid_support.remove_nodeseg_in) button(self.Frame2, 0.075, ry + sh * 6, rh, rw, '''Remove nodes outside seg''', pygrid_support.remove_nodeseg_out) button(self.Frame2, 0.075, ry + sh * 7, rh, rw, '''Extract nod from nei''', pygrid_support.extract_nod) button(self.Frame2, 0.075, ry + sh * 8, rh, rw, '''Extract seg from nei''', pygrid_support.extract_seg) button(self.Frame2, 0.075, ry + sh * 9, rh, rw, '''Extract llz from nei''', pygrid_support.extract_llz) ######################################################################## # # Depth tab # ######################################################################## ry = 0.01 label(self.Frame5, 0.1, ry, rh, .2, '''Min''') label(self.Frame5, 0.375, ry, rh, .2, '''Max''') label(self.Frame5, 0.66, ry, rh, .2, '''Mean''') ry += sh self.Labelsmin = label(self.Frame5, 0.1, ry, rh, .2, '''na''') self.Labelsmax = label(self.Frame5, 0.375, ry, rh, .2, '''na''') self.Labelsmean = label(self.Frame5, 0.66, ry, rh, .2, '''na''') button(self.Frame5, 0.075, ry + 0.05, rh, rw, '''Calc Stats''', pygrid_support.calc_stats) ry += 2 * sh label(self.Frame5, 0.5, ry, rh, rw2, '''Set depth''') button(self.Frame5, 0.075, ry + 0.05, rh, rw2, '''Set depth''', pygrid_support.set_depth) self.Entry3 = entry(self.Frame5, 0.525, ry + 0.05, rh, rw2, '') ry += 2 * sh label(self.Frame5, 0.5, ry, rh, rw2, '''Avg. depth''') button(self.Frame5, 0.075, ry + 0.05, rh, rw2, '''Avg. depth''', pygrid_support.avg_depth) self.Entry4 = entry(self.Frame5, 0.525, ry + 0.05, rh, rw2, '') ry += 2 * sh label(self.Frame5, .275, ry, rh, .3, '''Limit Min''') label(self.Frame5, .625, ry, rh, .3, '''Limit Max''') ry += sh label(self.Frame5, .05, ry, rh, .2, '''Depth''') self.Entryhmin = entry(self.Frame5, 0.275, ry, rh, rw2 * .75, '') self.Entryhmax = entry(self.Frame5, 0.625, ry, rh, rw2 * .75, '') ry += sh label(self.Frame5, .05, ry, rh, .2, '''dhh''') self.Entrydhhmin = entry(self.Frame5, 0.275, ry, rh, rw2 * .75, '') self.Entrydhhmax = entry(self.Frame5, 0.625, ry, rh, rw2 * .75, '') ry += sh button(self.Frame5, 0.075, ry, rh, rw, '''Smooth''', pygrid_support.smooth) ######################################################################## # # Seg Tab # ######################################################################## ry = 0.01 button(self.Frame6, 0.075, ry, rh, rw2, '''Select Seg''', pygrid_support.select_seg) self.Entry2 = entry(self.Frame6, 0.525, ry, rh, rw2, '') button(self.Frame6, 0.075, ry + sh * 1, rh, rw, '''Create Seg''', pygrid_support.create_seg) button(self.Frame6, 0.075, ry + sh * 2, rh, rw, '''Delete Seg''', pygrid_support.delete_seg) ######################################################################## # # FVCOM Tab # ######################################################################## ry = 0.01 cbutton(self.Frame7, 0.075, ry, rh, rw, '''Show FVCOM''', pygrid_support.toggle_fvcom, self.CBVar['fvcom']) label(self.Frame7, .075, ry + sh, rh, rw4, '''Times:''') self.timemin = label(self.Frame7, .275, ry + sh, rh, rw4, '''na''') self.timemax = label(self.Frame7, .5, ry + sh, rh, rw4, '''na''') self.etime = entry(self.Frame7, 0.75, ry + sh, rh, rw4, '0') label(self.Frame7, .075, ry + sh * 2, rh, rw4, '''Levels:''') self.lvlmin = label(self.Frame7, .275, ry + sh * 2, rh, rw4, '''na''') self.lvlmax = label(self.Frame7, .5, ry + sh * 2, rh, rw4, '''na''') self.elvl = entry(self.Frame7, 0.75, ry + sh * 2, rh, rw4, '0') self.FVCOMMenuVar = StringVar(root) self.FVCOMChoices = { 'speed_da', 'speed', 'dhh', 'sidelength', 'vorticity_da', 'vorticity', 'density' } self.FVCOMMenuVar.set('speed_da') self.FVCOMMenu = OptionMenu(self.Frame7, self.FVCOMMenuVar, *self.FVCOMChoices) self.FVCOMMenu.place(relx=0.075, rely=ry + sh * 3, relheight=rh, relwidth=rw) #self.FVCOMMenuVar.trace('w', pygrid_support.TODO)#change_fvcommenu) self.overmenu = entry(self.Frame7, 0.075, ry + sh * 4, rh, rw, '') self.fsb = Frame(self.Frame7) self.fsb.place(relx=rw + .01, rely=ry + sh * 5, relheight=.625, relwidth=0.1) self.sb = Scrollbar(self.fsb, orient="vertical") self.sb.pack(side=RIGHT, fill=Y) self.listbox = Listbox(self.Frame7) self.listbox.place(relx=0.01, rely=ry + sh * 5, relheight=.625, relwidth=rw) # attach listbox to scrollbar self.listbox.config(yscrollcommand=self.sb.set) self.sb.config(command=self.listbox.yview) button(self.Frame7, 0.075, ry + sh * 15.5, rh, rw, '''Plot FVCOM''', pygrid_support._plot_fvcomfile) ######################################################################## # # Markers Tab # ######################################################################## ry = 0.01 cbutton(self.Frame8, 0.075, ry, rh, rw, '''Show Markers''', pygrid_support.toggle_markerfile, self.CBVar['marker']) label(self.Frame8, .075, ry + sh, rh, rw2, '''Lon:''') self.mlon = entry(self.Frame8, 0.075, ry + sh * 2, rh, rw2, '') label(self.Frame8, .525, ry + sh, rh, rw2, '''Lat:''') self.mlat = entry(self.Frame8, 0.525, ry + sh * 2, rh, rw2, '') label(self.Frame8, .075, ry + sh * 3, rh, rw, '''Label:''') self.mlabel = entry(self.Frame8, 0.075, ry + sh * 4, rh, rw, '') button(self.Frame8, 0.075, ry + sh * 15.5, rh, rw, '''Add Marker''', pygrid_support._add_marker) ######################################################################## # # Selection controls # ######################################################################## self.FrameSelection = Frame(top) self.FrameSelection.place(relx=0.78, rely=0.75, relheight=.1, relwidth=0.22) self.FrameSelection.configure(relief=GROOVE, borderwidth="2", width=215) button(self.FrameSelection, 0.05, 0.075, 0.4, rw, '''Clear Selection''', pygrid_support.clear_selection) button(self.FrameSelection, 0.05, 0.525, 0.4, rw, '''Select Area''', pygrid_support.select_area) ######################################################################## # # Colorbar controls # ######################################################################## self.Frame4 = Frame(top) self.Frame4.place(relx=0.78, rely=0.85, relheight=.15, relwidth=0.22) self.Frame4.configure(relief=GROOVE, borderwidth="2", width=215) label(self.Frame4, 0.05, 0.03, 0.255, rw2, '''Max''') self.Entry41 = entry(self.Frame4, 0.525, 0.03, 0.255, rw2, '') label(self.Frame4, 0.05, 0.33, 0.255, rw2, '''Min''') self.Entry42 = entry(self.Frame4, 0.525, 0.33, 0.255, rw2, '') button(self.Frame4, 0.075, .66, 0.255, rw2, '''Redraw llz''', pygrid_support.redraw_llz) button(self.Frame4, 0.525, .66, 0.255, rw2, '''Redraw nei''', pygrid_support.redraw_nei)
def plot(self): # ------ # Start simulation Sim = SolarSystemSimulation() # ------ # Create new window to plot the simulation sim_window = tk.Toplevel() sim_window.title('SolarSystemSimulation') sim_window.focus_force() # Auto-focus on window # Add interrupt button killswitch = ttk.Button(sim_window, text="Close Simulation", command=sim_window.destroy) killswitch.pack() fig, ax, elapsedTime = self.setupPlot(Sim) # Check if HTO is plotted if gui.plotHohmann.get(): Sim, travelTime, transferDistanceAU = self.hohmannTransfer(Sim) # ------ # Add Information to Plot info = self.addInformation(ax) info['elapsedTime'].set_text('Elapsed Time: {:.2f} Earth years'.format( gui.duration.get())) if gui.plotHohmann.get(): info['originDestination'].set_text( '%s \u2192 %s' % (Sim.originPlanet, Sim.destinationPlanet)) info['transferTime'].set_text('Transfer Time: %.2f Earth Years' % travelTime) info['transferDistance'].set_text('Transfer Distance: %.1f AU' % transferDistanceAU) # ------ # Create plotting canvas canvas = FigureCanvasTkAgg(fig, sim_window) canvas.show() canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True) # Add matplotlib toolbar to the plot toolbar = NavigationToolbar2TkAgg(canvas, sim_window) toolbar.update() canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) # ------ # Simulate and plot # For each planet in simulation, calculate trajectories planetTrajectories = {} for key, planet in Sim.Planets.items(): planetTrajectories[key] = [planet.position] sphereOfInfluence = Sim.Planets[ Sim.destinationPlanet].sphereOfInfluence # in AU for i in range(Sim.steps): Sim.timeStep() for key, planet in Sim.Planets.items(): planetTrajectories[key].append(planet.position) # If orbit insertion is performed, check if spacecraft has arrived at planet if gui.plotHohmann.get(): if gui.orbitInsertion.get(): distanceToDestination = np.sqrt(( Sim.Planets['HTO'].position[0] - Sim.Planets[Sim.destinationPlanet].position[0] )**2 + ( Sim.Planets['HTO'].position[1] - Sim.Planets[Sim.destinationPlanet].position[1])**2) if distanceToDestination < sphereOfInfluence: Sim.Planets['HTO'].performOrbitInsertion(Sim) # Plot final trajectories for key, planet in Sim.Planets.items(): ax.plot(*zip(*planetTrajectories[key]), ls=planet.linestyle, c=planet.colour, lw=0.5) ax.plot(*planetTrajectories[key][-1], marker=planet.marker, c=planet.colour) # Add Sun sun, = ax.plot((0, 0), c='orange', marker='o', ls='') canvas.draw()
def __init__(self, parent): tk.Frame.__init__(self, parent) parent.deiconify() #Plot Widgets self.plot_frame = tk.LabelFrame(parent, text='Filter Data') self.plot_fig = Figure(figsize=(7, 5), dpi=100) self.plot_canvas = FigureCanvasTkAgg(self.plot_fig, master=self.plot_frame) self.plot_toolbar_frame = tk.Frame(self.plot_frame) self.plot_toolbar = NavigationToolbar2TkAgg(self.plot_canvas, self.plot_toolbar_frame) self.plot_toolbar.update() self.plot_frame.grid(row=0, column=0, columnspan=6, sticky=tk.N + tk.S) self.plot_toolbar_frame.grid(row=1, column=0, columnspan=6) self.plot_canvas.get_tk_widget().grid(row=0, column=0, columnspan=6) #Control Widgets self.control_frame = tk.LabelFrame(parent, text='Controls') self.control_frame.grid(row=1, column=0, columnspan=6, sticky=tk.N + tk.S + tk.E + tk.W) self.fs_entry = tk.Entry(self.control_frame) self.fs_entry.insert(0, '500') self.fs_label = tk.Label(self.control_frame, text='Sampling Frequency (kHz)') self.fs_label.grid(row=0, column=0, sticky=tk.E + tk.W) self.fs_entry.grid(row=0, column=1, sticky=tk.E + tk.W) self.fc_entry = tk.Entry(self.control_frame) self.fc_entry.insert(0, '95') self.fc_label = tk.Label(self.control_frame, text='Cutoff Frequency (kHz)') self.fc_label.grid(row=0, column=2, sticky=tk.E + tk.W) self.fc_entry.grid(row=0, column=3, sticky=tk.E + tk.W) self.poles = tk.IntVar(parent) self.poles.set(8) self.pole_option = tk.OptionMenu(self.control_frame, self.poles, 2, 4, 6, 8, 10) self.pole_label = tk.Label(self.control_frame, text='Poles') self.pole_label.grid(row=0, column=4, sticky=tk.E + tk.W) self.pole_option.grid(row=0, column=5, sticky=tk.E + tk.W) self.fit_button = tk.Button(self.control_frame, text='Fit Filter', command=self.update_filter) self.fit_button.grid(row=1, column=1, sticky=tk.E + tk.W) self.residuals = tk.IntVar() self.residuals.set(0) self.residuals_check = tk.Checkbutton(self.control_frame, text='Plot Residuals', variable=self.residuals) self.residuals_check.grid(row=1, column=2, sticky=tk.E + tk.W) #Feedback Widgets self.feedback_frame = tk.LabelFrame(parent, text='Fit Parameters') self.feedback_frame.grid(row=2, column=0, columnspan=6, sticky=tk.N + tk.S + tk.E + tk.W) self.fit_report = tk.StringVar() self.fit_report_label = tk.Label(self.feedback_frame, textvariable=self.fit_report) self.fit_report_label.grid(row=0, column=0, columnspan=6, sticky=tk.E + tk.W)
return (x1(s + 0.001, k, lmb) - x1(s, k, lmb)) / 0.001 def x2derr(s, k, lmb): return (x2(s + 0.001, k, lmb) - x2(s, k, lmb)) / 0.001 a2.plot(s, x2derr(s, k, lmb)) canvas = FigureCanvasTkAgg(f, master=rootframe) canvas.show() canvas.get_tk_widget().grid(row=1, column=0, columnspan=5, sticky='W') framen = Tk.Frame(rootframe) framen.grid(row=0, column=0, columnspan=5, sticky=Tk.W) toolbar = NavigationToolbar2TkAgg(canvas, framen) toolbar.update() def on_key_event(event): print('you pressed %s' % event.key) key_press_handler(event, canvas, toolbar) canvas.mpl_connect('key_press_event', on_key_event) def _quit(): root.quit() # stops mainloop root.destroy() # this is necessary on Windows to prevent # Fatal Python Error: PyEval_RestoreThread: NULL tstate
def add_graph_subplot(self): plot_dict = {} plot_dict['fig'] = pylab.figure(1) plot_dict['frame_main_plot'] = Tkinter.Frame(self.root) plot_dict['frame_graph_fig'] = Tkinter.Frame( plot_dict['frame_main_plot']) plot_dict['frame_graph_info'] = Tkinter.Frame( plot_dict['frame_main_plot']) plot_dict['frame_graph_control'] = Tkinter.Frame( plot_dict['frame_graph_info']) plot_dict['frame_graph_text'] = Tkinter.Frame( plot_dict['frame_graph_info']) plot_dict['canvas'] = FigureCanvasTkAgg( plot_dict['fig'], master=plot_dict['frame_graph_fig']) plot_dict['canvas'].show() # Add matlotlib toolbar plot_dict['button_quit'] = Tkinter.Button( master=plot_dict['frame_graph_control'], text='Quit', command=lambda: self._quit()) plot_dict['button_reset'] = Tkinter.Button( master=plot_dict['frame_graph_control'], text='Reset', command=lambda: self.reset()) # Add matlotlib toolbar plot_dict['wScale'] = Tkinter.Scale( master=plot_dict['frame_graph_control'], from_=10, to=5500, sliderlength=30, label="X", orient=Tkinter.HORIZONTAL) plot_dict['wScale'].set(100) # Add matlotlib toolbar plot_dict['wScale_udp_packet'] = Tkinter.Scale( master=plot_dict['frame_graph_control'], from_=1, to=50, sliderlength=30, label="UDP-kbps", orient=Tkinter.HORIZONTAL) plot_dict['wScale_udp_packet'].set(5) # Add matlotlib toolbar plot_dict['toolbar'] = NavigationToolbar2TkAgg( plot_dict['canvas'], plot_dict['frame_graph_info']) plot_dict['toolbar'].update() plot_dict['wScale'].pack(side=Tkinter.LEFT) plot_dict['wScale_udp_packet'].pack(side=Tkinter.LEFT) plot_dict['button_quit'].pack(side=Tkinter.RIGHT) plot_dict['button_reset'].pack(side=Tkinter.RIGHT) # Add matlotlib toolbar plot_dict['TextInfo'] = Tkinter.Text(plot_dict['frame_graph_text'], height=6) plot_dict['TextInfo_timeinfo'] = Tkinter.Text( plot_dict['frame_graph_text'], height=6) plot_dict['TextInfo_timeinfo'].pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['TextInfo'].pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['canvas'].get_tk_widget().pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['frame_graph_text'].pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['frame_graph_control'].pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['frame_graph_fig'].pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['frame_graph_info'].pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) plot_dict['frame_main_plot'].pack(side=Tkinter.LEFT, fill=Tkinter.BOTH, expand=1) #add subplot self.add_subplot(plot_dict['fig'], 0, 'ax_0_0', "udp-0", [0, 1000, 700, 5000]) self.add_subplot(plot_dict['fig'], 1, 'ax_1_0', "udp-1", [0, 1000, 700, 5000]) #self.add_subplot(plot_dict['fig'], 2, 'ax_2_0', "udp-2", [0,1000,700,5000]) #self.add_subplot(plot_dict['fig'], 3, 'ax_3_0', "udp-3", [0,1000,700,5000]) #self.add_subplot(plot_dict['fig'], 4, 'ax_4_0', "udp-4", [0,1000,700,5000]) xAchse = pylab.arange(0, 100, 1) yAchse = pylab.array([0] * 100) self.add_line('ax_0_0', 'udp', xAchse, yAchse, '-') return plot_dict
def view_chart(self, df, field_name): ''' f = Figure(figsize=(5,5), dpi=100) a = f.add_subplot(111) a.clear() a.plot(df) a.plot(df.index, df.iloc[: , 0:1] , "#00A3E0", label="Days") a.plot(df.index, df.iloc[: , 1:2] , "#183A54", label="Count") a.legend(bbox_to_anchor=(0, 1.02, 1, .102), loc=3, ncol=2, borderaxespad=0) a.set_title('Bar_chart ' + field_name) a.set_xlabel(field_name) ''' # df = df_Geraete_große.copy(deep=True) # fieldName = 'Geräte_große' fieldName = field_name # fig, ax = plt.subplots() fig = Figure(figsize=(5, 5), dpi=100) ax = fig.add_subplot(111) ax.clear() index = df.index ind = np.arange(len(df)) # the x locations for the groups bar_width = 0.45 # the width of the bars mean = df['F_t_Fail_time_days'] # mean = df.iloc[: , 0:1].values count = df['count'] # count = df.iloc[: , 1:2].values opacity = 0.4 error_config = {'ecolor': '0.3'} rects1 = ax.bar(ind, mean, bar_width, alpha=opacity, color='b', error_kw=error_config, label='Mean time to failure') rects2 = ax.bar(ind + bar_width, count, bar_width, alpha=opacity, color='r', error_kw=error_config, label='number of Equipment') # fig.set_figwidth(7) # set figure width # fig.set_figheight(5) # set figure height # add some text for lables, title and axes ticks ax.set_xlabel(fieldName) ax.set_ylabel('amount') ax.set_title('Mean time to first Failure by' + fieldName) ax.set_xticks(ind + bar_width / 2) # + bar_width / 2 ax.set_xticklabels( index, rotation=10) # rotation=x degree set rotation for ticks ax.legend() fig.tight_layout() def autolable(rects): for rect in rects: height = rect.get_height() ax.text(rect.get_x() + rect.get_width() / 2., 1.05 * height, '%d' % int(height), ha='center', va='bottom') autolable(rects1) autolable(rects2) # plt.show() # global canvas canvas = FigureCanvasTkAgg(fig, self) canvas.show() canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True) # global toolbar toolbar = NavigationToolbar2TkAgg(canvas, self) toolbar.update() canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) return canvas, toolbar
def layouts(self, histo_num): if histo_num>0 and histo_num < 7: columns=2 elif histo_num>=7 and histo_num<=9: columns=3 else: ERROR="Nie planuje." return ERROR histo_num=float(histo_num) histo_in_row=int(round(histo_num/columns)) rows=1+(histo_in_row*2) row_size=600/histo_in_row for r in range(rows): if r%2==0: self.win.rowconfigure(r, minsize=10) else: self.win.rowconfigure(r, minsize=row_size) self.win.columnconfigure(0,minsize=200) column_size=1000/columns for c in range(1,columns+1): self.win.columnconfigure(c,minsize =column_size) if histo_num>0 and histo_num <=9: histo_ID=0 if histo_num%2 == 0 and histo_num<7: tab=list(range(1,rows)) elif (histo_num%3==1 or histo_num%3==2) and histo_num>=7: tab=list(range(1,rows-2)) elif histo_num%2 != 0 and histo_num<7: tab=list(range(1,rows-2)) print("ROWS %d" %rows) for r in tab[0::2]: for c in range(1,columns+1): self.canvas[0][histo_ID].get_tk_widget().grid(row=r,column=c) histo_ID+=1 histo_ID=0 for r in tab[1::2]: for c in range(1,columns+1): self.TOOLBAR.append(NavigationToolbar2TkAgg(self.canvas[0][histo_ID],self.win)) self.TOOLBAR[histo_ID].grid(row=r,column=c) histo_ID+=1 if histo_num==1: self.canvas[0][histo_ID].get_tk_widget().grid(row=rows-2, column=1,columnspan=2,sticky=N+S+W+E) self.TOOLBAR.append(NavigationToolbar2TkAgg(self.canvas[0][histo_ID],self.win)) self.TOOLBAR[histo_ID].grid(row=rows-1,column=1,columnspan=2,sticky=N+S) if histo_num%2 != 0 and histo_num<7 and histo_num>1: self.canvas[0][histo_ID].get_tk_widget().grid(row=rows-2, column=1,columnspan=2,sticky=N+S) self.TOOLBAR.append(NavigationToolbar2TkAgg(self.canvas[0][histo_ID],self.win)) self.TOOLBAR[histo_ID].grid(row=rows-1,column=1,columnspan=2,sticky=N+S) elif histo_num%3==1 and histo_num>=7: self.canvas[0][histo_ID].grid(row=rows-2,column=2) self.TOOLBAR.append(NavigationToolbar2TkAgg(self.canvas[0][histo_ID],self.win)) self.TOOLBAR[histo_ID].grid(row=rows-1,columns=2) elif histo_num%3==2 and histo_num>=7: self.canvas[0][histo_ID].grid(row=rows-2,column=1,columnspan=2,sticky=W) self.TOOLBAR.append(NavigationToolbar2TkAgg(self.canvas[0][histo_ID],self.win)) self.TOOLBAR[histo_ID].grid(row=rows-1,columns=3,columnspan=2,sticky=W) self.canvas[0][histo_ID+1].grid(row=rows-2,column=2,columnspan=2,sticky=E) self.TOOLBAR.append(NavigationToolbar2TkAgg(self.canvas[0][histo_ID+1],self.win)) self.TOOLBAR[histo_ID+1].grid(row=rows-1,columns=2,columnspan=2,sticky=E) else: ERROR="Nie planuje." return ERROR
def __init__(self, master): self.master = master self.frameTOP = Frame(master) self.frameTOP.grid(row=0, column=0, columnspan=2) self.frameBOT = Frame(master) self.frameBOT.grid(row=1, column=0, columnspan=2) self.frameLEFT = Frame(master) self.frameLEFT.grid(row=2, column=0, padx=5) self.frameRIGHT = Frame(master) self.frameRIGHT.grid(row=2, column=1, padx=5) self.frameBOTBOT = Frame(master) self.frameBOTBOT.grid(row=3, column=0, columnspan=2) self.file_name = '' self.checkVar = IntVar() self.checkVarFilter = IntVar() self.checkVarPath1 = IntVar() self.checkVarPath2 = IntVar() self.checkVarCurs = IntVar() self.checkVarPos1 = IntVar() self.checkVarPos2 = IntVar() self.checkVarFor1 = IntVar() self.checkVarFor2 = IntVar() self.fig = plt.Figure() self.checkBoxFilter = Checkbutton(self.frameTOP, variable=self.checkVarFilter) self.checkBoxFilter.grid(row=0, column=0) self.labelFilter1 = Label(self.frameTOP, text='Filter (Size :').grid(row=0, column=1) self.filterEntry = Entry(self.frameTOP, width=4) self.filterEntry.grid(row=0, column=2) self.filterEntry.insert(0, '100') self.labelFilter2 = Label(self.frameTOP, text=')').grid(row=0, column=3) self.loadButton = Button(self.frameTOP, text="LOAD DATA", command=loadDataFromFile, state=DISABLED) self.loadButton.grid(row=0, column=4) self.plotButton = Button(self.frameTOP, text="PLOT", command=plot, state=DISABLED) self.plotButton.grid(row=0, column=5) self.plotChoicesButton = Button(self.frameTOP, text="PLOT CHOICES", command=plotChoices, state=DISABLED) self.plotChoicesButton.grid(row=0, column=6) # self.quitButton = Button(self.frameTOP, text = "QUIT", fg = 'red', command = master.destroy) # self.quitButton.pack(side = RIGHT) ################################################## self.checkBoxPath1 = Checkbutton(self.frameRIGHT, text='Path 1', variable=self.checkVarPath1) self.checkBoxPath1.grid(row=0, sticky=W) self.checkBoxPath1.select() self.checkBoxPath2 = Checkbutton(self.frameRIGHT, text='Path 2', variable=self.checkVarPath2) self.checkBoxPath2.grid(row=1, sticky=W) self.checkBoxPath2.select() self.checkBoxCurs = Checkbutton(self.frameRIGHT, text='Curs', variable=self.checkVarCurs) self.checkBoxCurs.grid(row=2, sticky=W) self.checkBoxCurs.select() self.checkBoxPos1 = Checkbutton(self.frameRIGHT, text='Pos 1', variable=self.checkVarPos1) self.checkBoxPos1.grid(row=3, sticky=W) self.checkBoxPos1.deselect() self.checkBoxPos2 = Checkbutton(self.frameRIGHT, text='Pos 2', variable=self.checkVarPos2) self.checkBoxPos2.grid(row=4, sticky=W) self.checkBoxPos2.deselect() self.checkBoxFor1 = Checkbutton(self.frameRIGHT, text='Force 1', variable=self.checkVarFor1) self.checkBoxFor1.grid(row=5, sticky=W) self.checkBoxFor1.select() self.checkBoxFor2 = Checkbutton(self.frameRIGHT, text='Force 2', variable=self.checkVarFor2) self.checkBoxFor2.grid(row=6, sticky=W) self.checkBoxFor2.select() ################################################### self.canvas = FigureCanvasTkAgg(self.fig, self.frameLEFT) self.canvas.show() self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1) self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.frameLEFT) self.toolbar.update() self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1, padx=5) ################################################### self.fileEntry = Entry(self.frameBOT, width='80') self.fileEntry.pack(side=LEFT) self.fileButton = Button(self.frameBOT, text='FILE', command=self.choosefile) self.fileButton.pack(side=RIGHT)
m.drawmeridians(np.linspace(m.llcrnrlon, m.urcrnrlon, meridianres), labels=[False, False, False, True]) m.drawstates() x = np.linspace(0, m.urcrnrx, dim[1]) y = np.linspace(0, m.urcrnry, dim[2]) xx, yy = np.meshgrid(x, y) quad = m.pcolormesh(xx, yy, np.transpose(np.squeeze(ftledata[timestep, :, :])), shading='gouraud', cmap='viridis') #quad = m.contourf(xx,yy, np.transpose(np.squeeze(ftledata[timestep,:,:])),shading='gouraud',cmap='viridis') cbar = fig.colorbar(quad, ax=ax, pad=0.01) ax.set_title('Time Step {0}'.format(timestep)) ridges = m.contour(xx, yy, np.transpose(np.squeeze(ftledata[timestep, :, :])), levels=[-1]) canvas = FigureCanvasTkAgg(fig, root) canvas.show() canvas.get_tk_widget().grid(row=1, column=3, rowspan=40) toolbar_frame = tk.Frame(root) toolbar_frame.grid(row=0, column=3, sticky="w") toolbar = NavigationToolbar2TkAgg(canvas, toolbar_frame) toolbar.update() #root.mainloop() tk.mainloop()
def arginine(self): ch_min = [0, 0, 40] ch_max = [-20, 30, 70] cc_min = [0, 0, 40] cc_max = [40, -20, 70] co_min = [45, -40, 10] co_max = [60, -40, -50] nh_min = [-45, 40, 10] nh_max = [-50, 40, -50] cn_min = [0, 0, 40] cn_max = [-45, 40, 10] cc1_min = [0, 0, 40] cc1_max = [45, -40, 10] c3_min = [40, -20, 70] c3_max = [80, -45, 60] c3h1_min = [80, -45, 60] c3h1_max = [70, -20, 40] c3h2_min = [80, -45, 60] c3h2_max = [100, -60, 40] c3c4_min = [80, -45, 60] c3c4_max = [125, -70, 100] c4h1_min = [125, -70, 100] c4h1_max = [145, -45, 80] c4h2_min = [125, -70, 100] c4h2_max = [155, -20, 120] c4n1_min = [125, -70, 100] c4n1_max = [175, -85, 80] c5n1_min = [175, -85, 80] c5n1_max = [280, -120, 130] c5n2_min = [280, -120, 130] c5n2_max = [310, -150, 100] c5n2h1_min = [310, -150, 100] c5n2h1_max = [350, -190, 130] c5n2h2_min = [310, -150, 100] c5n2h2_max = [270, -200, 70] c5n3_min = [280, -120, 130] c5n3_max = [250, -180, 160] c5n3h1_min = [250, -180, 160] c5n3h1_max = [300, -240, 200] c5n3h2_min = [250, -180, 160] c5n3h2_max = [200, -230, 130] c4n1h1_min = [175, -85, 80] c4n1h1_max = [185, -110, 40] c2h1_min = [40, -20, 70] c2h1_max = [50, -50, 100] c2h2_min = [40, -20, 70] c2h2_max = [25, 10, 100] fig = Figure(figsize=(10, 6), dpi=100, facecolor='black') canvas = FigureCanvasTkAgg(fig, self) canvas.draw() ax = fig.add_subplot(111, projection="3d") ax.set_axis_bgcolor("black") ch = ax.plot([ch_max[0], ch_min[0]], [ch_max[1], ch_min[1]], [ch_max[2], ch_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) cc = ax.plot([cc_max[0], cc_min[0]], [cc_max[1], cc_min[1]], [cc_max[2], cc_min[2]], linewidth=5, color=cc_color, marker='o', markerfacecolor='orange', markersize=12) co = ax.plot([co_max[0], co_min[0]], [co_max[1], co_min[1]], [co_max[2], co_min[2]], linewidth=5, color=co_color, marker='o', markerfacecolor='orange', markersize=12) nh = ax.plot([nh_max[0], nh_min[0]], [nh_max[1], nh_min[1]], [nh_max[2], nh_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) cn = ax.plot([cn_max[0], cn_min[0]], [cn_max[1], cn_min[1]], [cn_max[2], cn_min[2]], linewidth=5, color=cn_color, marker='o', markerfacecolor='orange', markersize=12) ccl = ax.plot([cc1_max[0], cc1_min[0]], [cc1_max[1], cc1_min[1]], [cc1_max[2], cc1_min[2]], linewidth=5, color=cc_color, marker='o', markerfacecolor='orange', markersize=12) c3 = ax.plot([c3_max[0], c3_min[0]], [c3_max[1], c3_min[1]], [c3_max[2], c3_min[2]], linewidth=5, color=cc_color, marker='o', markerfacecolor='orange', markersize=12) c3h1 = ax.plot([c3h1_max[0], c3h1_min[0]], [c3h1_max[1], c3h1_min[1]], [c3h1_max[2], c3h1_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) c3h2 = ax.plot([c3h2_max[0], c3h2_min[0]], [c3h2_max[1], c3h2_min[1]], [c3h2_max[2], c3h2_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) c3c4 = ax.plot([c3c4_max[0], c3c4_min[0]], [c3c4_max[1], c3c4_min[1]], [c3c4_max[2], c3c4_min[2]], linewidth=5, color=cc_color, marker='o', markerfacecolor='orange', markersize=12) c4h1 = ax.plot([c4h1_max[0], c4h1_min[0]], [c4h1_max[1], c4h1_min[1]], [c4h1_max[2], c4h1_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) c4h2 = ax.plot([c4h2_max[0], c4h2_min[0]], [c4h2_max[1], c4h2_min[1]], [c4h2_max[2], c4h2_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) c4n1 = ax.plot([c4n1_max[0], c4n1_min[0]], [c4n1_max[1], c4n1_min[1]], [c4n1_max[2], c4n1_min[2]], linewidth=5, color=cn_color, marker='o', markerfacecolor='orange', markersize=12) c5n1 = ax.plot([c5n1_max[0], c5n1_min[0]], [c5n1_max[1], c5n1_min[1]], [c5n1_max[2], c5n1_min[2]], linewidth=5, color=cn_color, marker='o', markerfacecolor='orange', markersize=12) c5n2 = ax.plot([c5n2_max[0], c5n2_min[0]], [c5n2_max[1], c5n2_min[1]], [c5n2_max[2], c5n2_min[2]], linewidth=5, color=cn_color, marker='o', markerfacecolor='orange', markersize=12) c5n2h1 = ax.plot([c5n2h1_max[0], c5n2h1_min[0]], [c5n2h1_max[1], c5n2h1_min[1]], [c5n2h1_max[2], c5n2h1_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) c5n2h2 = ax.plot([c5n2h2_max[0], c5n2h2_min[0]], [c5n2h2_max[1], c5n2h2_min[1]], [c5n2h2_max[2], c5n2h2_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) c5n3 = ax.plot([c5n3_max[0], c5n3_min[0]], [c5n3_max[1], c5n3_min[1]], [c5n3_max[2], c5n3_min[2]], linewidth=5, color=cn_color, marker='o', markerfacecolor='orange', markersize=12) c5n3h1 = ax.plot([c5n3h1_max[0], c5n3h1_min[0]], [c5n3h1_max[1], c5n3h1_min[1]], [c5n3h1_max[2], c5n3h1_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) c5n3h2 = ax.plot([c5n3h2_max[0], c5n3h2_min[0]], [c5n3h2_max[1], c5n3h2_min[1]], [c5n3h2_max[2], c5n3h2_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) c4n1h1 = ax.plot([c4n1h1_max[0], c4n1h1_min[0]], [c4n1h1_max[1], c4n1h1_min[1]], [c4n1h1_max[2], c4n1h1_min[2]], linewidth=5, color=nh_color, marker='o', markerfacecolor='orange', markersize=12) c2h1 = ax.plot([c2h1_max[0], c2h1_min[0]], [c2h1_max[1], c2h1_min[1]], [c2h1_max[2], c2h1_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) c2h2 = ax.plot([c2h2_max[0], c2h2_min[0]], [c2h2_max[1], c2h2_min[1]], [c2h2_max[2], c2h2_min[2]], linewidth=5, color=ch_color, marker='o', markerfacecolor='orange', markersize=12) tch = plt.Rectangle((0, 0), 1, 1, fc=ch_color) tch1 = plt.Rectangle((0, 0), 1, 1, fc=ch_color) tcn = plt.Rectangle((0, 0), 1, 1, fc=cn_color) tcc = plt.Rectangle((0, 0), 1, 1, fc=cc_color) tbco = plt.Rectangle((0, 0), 1, 1, fc=co_color) tbnh = plt.Rectangle((0, 0), 1, 1, fc=nh_color) ax.legend([tch, tcn, tcc, tbco, tbnh], ['ch', 'cn', 'cc', 'co', 'nh']) ax.axis("off") toolbarFrame = Frame(self) toolbarFrame.grid(row=6, column=7) toolbar = NavigationToolbar2TkAgg(canvas, toolbarFrame) canvas.get_tk_widget().grid(row=4, column=7)
def do_plot(self): if self.plate != int(self.e1.get()) or self.mjd != int(self.e2.get()): self.plate = int(self.e1.get()) self.mjd = int(self.e2.get()) self.fiber = int(self.e3.get()) self.znum = int(self.e5.get()) self.platepath = join(environ['BOSS_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, 'spPlate-%s-%s.fits' % (self.plate, self.mjd)) hdu = fits.open(self.platepath) self.specs = hdu[0].data self.wave = 10**(hdu[0].header['COEFF0'] + n.arange(hdu[0].header['NAXIS1']) * hdu[0].header['COEFF1']) self.models = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[2].data self.fiberid = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.FIBERID self.type1 = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.CLASS1 self.type2 = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.CLASS2 self.type3 = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.CLASS3 self.type4 = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.CLASS4 self.type5 = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.CLASS5 self.z = n.zeros((self.fiberid.shape[0],5)) self.z[:,0] = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.Z1 self.z[:,1] = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.Z2 self.z[:,2] = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.Z3 self.z[:,3] = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.Z4 self.z[:,4] = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.Z5 self.zwarning = fits.open(join(environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'], '%s' % self.plate, environ['RUN1D'], 'redmonster-%s-%s.fits' % (self.plate, self.mjd)))[1].data.ZWARNING else: self.fiber = int(self.e3.get()) f = Figure(figsize=(10,6), dpi=100) a = f.add_subplot(111) loc = n.where(self.fiberid == self.fiber)[0] if self.znum == 1: z = self.z[loc[0],0] thistype = self.type1[loc[0]] elif self.znum == 2: z = self.z[loc[0],1] thistype = self.type2[loc[0]] elif self.znum == 3: z = self.z[loc[0],2] thistype = self.type3[loc[0]] elif self.znum == 4: z = self.z[loc[0],3] thistype = self.type4[loc[0]] elif self.znum == 5: z = self.z[loc[0],4] thistype = self.type5[loc[0]] if self.var.get() == 0: if self.restframe.get() == 0: a.plot(self.wave, self.specs[self.fiber], color='black') elif self.restframe.get() == 1: a.plot(self.wave/(1+self.z[loc][0]), self.specs[self.fiber], color='black') elif self.var.get() == 1: smooth = self.e4.get() if smooth is '': if self.restframe.get() == 0: a.plot(self.wave, self.specs[self.fiber], color='black') elif self.restframe.get() == 1: a.plot(self.wave/(1+z), self.specs[self.fiber], color='black') else: if self.restframe.get() == 0: a.plot(self.wave, convolve(self.specs[self.fiber], Box1DKernel(int(smooth))), color='black') elif self.restframe.get() == 1: a.plot(self.wave/(1+z), convolve(self.specs[self.fiber], Box1DKernel(int(smooth))), color='black') # Overplot model if len(loc) is not 0: if self.restframe.get() == 0: #a.plot(self.wave, self.models[loc[0]], color='black') # This for when multiple models are in redmonster file a.plot(self.wave, self.models[loc[0],self.znum-1], color='cyan') if self.ablines.get() == 1: for i, line in enumerate(self.ablinelist): if ((line*(1+z) > self.wave[0]) & (line*(1+z) < self.wave[-1])): a.axvline(line*(1+z), color='blue', linestyle='--', label=self.ablinenames[i]) if self.emlines.get() == 1: for i, line in enumerate(self.emlinelist): if (line*(1+z) > self.wave[0]) & (line*(1+z) < \ self.wave[-1]): a.axvline(line*(1+z), color='red', linestyle='--', label=self.emlinenames[i]) if self.ablines.get() == 1 or self.emlines.get() == 1: a.legend(prop={'size':10}) elif self.restframe.get() == 1: a.plot(self.wave/(1+z), self.models[loc[0],self.znum-1], color='cyan') if self.ablines.get() == 1: for i, line in enumerate(self.ablinelist): if (line > self.wave[0]) & (line < self.wave[-1]): a.axvline(line, color='blue', linestyle='--', label=self.ablinenames[i]) if self.emlines.get() == 1: for i, line in enumerate(self.emlinelist): if (line > self.wave[0]) & (line < self.wave[-1]): a.axvline(line, color='red', linestyle='--', label=self.emlinenames[i]) if self.ablines.get() == 1 or self.emlines.get() == 1: a.legend(prop={'size':10}) a.set_title('Plate %s Fiber %s: z=%s class=%s zwarning=%s' % (self.plate, self.fiber, z, thistype, self.zwarning[loc[0]])) else: print('Fiber %s is not in redmonster-%s-%s.fits' % \ (self.fiber, self.plate, self.mjd)) a.set_title('Plate %s Fiber %s' % (self.plate, self.fiber)) if self.restframe.get() == 1: lower_data, upper_data = self.set_limits() a.axis([self.wave[0]/(1+z)-100,self.wave[-1]/(1+z)+100, lower_data,upper_data]) elif self.restframe.get() == 0: lower_data, upper_data = self.set_limits() a.axis([self.wave[0]-100,self.wave[-1]+100,lower_data,upper_data]) a.set_xlabel('Wavelength ($\AA$)') a.set_ylabel('Flux ($10^{-17} erg\ cm^2 s^{-1} \AA^{-1}$)') canvas = FigureCanvasTkAgg(f, master=self.root) canvas.get_tk_widget().grid(row=0, column=5, rowspan=20) toolbar_frame = Frame(self.root) toolbar_frame.grid(row=20,column=5) toolbar = NavigationToolbar2TkAgg( canvas, toolbar_frame ) canvas.show()
position=(0., 0.9), color='b') t3 = ax3.set_ylabel("", labelpad=-15, rotation="horizontal", position=(0., 0.9), color='b') t4 = Label(window, text=" isodoses :") t6 = Label(window, text="structures :") graph1 = FigureCanvasTkAgg(fig1, master=window) canvas1 = graph1.get_tk_widget() toolbar_frame = Frame(window) toolbar = NavigationToolbar2TkAgg(graph1, toolbar_frame) #toolbar = NavigationToolbar2Tk( graph1, toolbar_frame ) toolbar.pan() # default widget check1 = Checkbutton(window, command=show_isodose) check2 = Checkbutton(window, command=show_ROI) w1 = Scale(window, from_=0, to=dim_x - 1, orient=VERTICAL, command=w1move, showvalue=0) w2 = Scale(window, from_=0,
def __init__(self, parent, controller): self.controller = controller self.title = "Backtest" ttk.Frame.__init__(self, parent) # Left Pane left_frame = ttk.Frame(self, padding=20) left_frame.pack(side="left") label = ttk.Label(left_frame, text="Pre-trained Stock") label.pack(padx=10, anchor=tk.W) symbol_list = ttk.Combobox(left_frame, width=18, font=("Calibri", 12)) symbol_list.pack(padx=20, pady=(0, 35), anchor=tk.W) label = ttk.Label(left_frame, text="Start Date - ex: 2015-03-31") label.pack( padx=10, anchor=tk.W, ) start_entry = ttk.Entry(left_frame, width=20, font=("Calibri", 12)) start_entry.pack(padx=20, anchor=tk.W) label = ttk.Label(left_frame, text="End Date") label.pack( padx=10, anchor=tk.W, ) end_entry = ttk.Entry(left_frame, width=20, font=("Calibri", 12)) end_entry.pack(padx=20, pady=(0, 35), anchor=tk.W) label = ttk.Label(left_frame, text="Predictive Model") label.pack( padx=10, anchor=tk.W, ) models = self.controller.get_trained_models(symbol_list.get()) type_list = ttk.Combobox(left_frame, width=18, font=("Calibri", 12)) type_list.pack(padx=20, anchor=tk.W) run_btn = ttk.Button(left_frame, text="Run Backtesting", padding=(25, 10, 25, 10), command=lambda: run_backtest()) run_btn.pack(pady=50, padx=15, anchor=tk.W) # Right Pane right_frame = ttk.Frame(self, padding=20) right_frame.pack(side="right") figure = Figure(figsize=(12, 8), dpi=60, facecolor='white') canvas = FigureCanvasTkAgg(figure, right_frame) canvas.get_tk_widget().grid(row=0, column=1) toolbar = NavigationToolbar2TkAgg(canvas, right_frame) toolbar.grid(row=1, column=1, pady=20) def update_selections(event): trained_symbols = self.controller.get_trained_symbols() symbol_list['value'] = trained_symbols if trained_symbols: symbol_list.current(0) models = self.controller.get_trained_models(symbol_list.get()) type_list['value'] = models if trained_symbols: type_list.current(0) self.bind("<Visibility>", update_selections) def symbol_change_handler(event): trained_models = self.controller.get_trained_models( symbol_list.get()) type_list['value'] = trained_models if len(trained_models) == 0: type_list['value'] = ["No trained models found"] type_list.current(0) symbol_list.bind("<<ComboboxSelected>>", symbol_change_handler) def on_key_event(event): key_press_handler(event, canvas, toolbar) canvas.mpl_connect('key_press_event', on_key_event) def on_click(event): canvas._tkcanvas.focus_set() canvas.mpl_connect('button_press_event', on_click) def run_backtest(): # extract variables needed for execuation symbol = symbol_list.get() start_date = start_entry.get() end_date = end_entry.get() model = type_list.get() # run selected model backtest try: plot = self.controller.run_backtest(symbol, model, start_date, end_date) except ValidationError as input_error: print input_error.message figure.clear() plot_data(figure, plot) canvas.draw()
def __init__(self, odf, plotter): self.f = Figure() # Save reference to the model self.odf = odf # Save reference to the plotter self.plotter = plotter self.leftMask = None self.rightMask = None self.activeLine = None self.root = tk.Tk() self.root.wm_title("PyA Model Explorer") # Make the widgets expand/shrink as window size changes self.root.columnconfigure(0, weight=1) self.root.rowconfigure(0, weight=1) # Bind the mouse wheel if platform.system() == "Linux": self.root.bind("<Button-4>", self._mouseWheel) self.root.bind("<Button-5>", self._mouseWheel) elif platform.system() == "Darwin": self.root.bind("<MouseWheel>", self._onWheel) # for OS X # A frame containing the mpl plot self.plotFrame = tk.Frame() self.plotFrame.pack(fill=tk.BOTH, side=tk.LEFT, expand=True) self.canvas = FigureCanvasTkAgg(self.f, master=self.plotFrame) # A frame containing the box with selected points # and control buttons self.controlFrame = tk.Frame(self.root) self.controlFrame.pack(side=tk.RIGHT, expand=False, fill=tk.BOTH) self.selectedPar = tk.StringVar(self.controlFrame) # Get parameters of model ps = list(self.odf.parameters().keys()) # Set default modification properties # Saves these properties for all parameters self.modProps = {} for p in ps: self.modProps[p] = { "modus": "mul", "modValMul": 1.02, "modValAdd": 0.01 } # Frame containing all parameters self.parameterFrame = tk.Frame(self.controlFrame, height=2, bd=1, relief=tk.SUNKEN) # Dictionaries holding the specific information for each parameter self.singleParameterFrames = {} self.singleParameterEntry = {} self.singleParameterVar = {} # knows whether the parameter is free (value=True) or frozen (=False) self.singleParameterFree = {} # Closures around the functions adapting thaw/freeze def frozenChanged(k): def change(): if self.singleParameterFree[k].get() == True: self.odf.thaw(k) else: self.odf.freeze(k) self._updateDof() return change # define what happens when a value is set to the entered parameter (closures) def hitReturn(k): def change(*args): self.selectedPar.set(k) self.odf[k] = float(self.singleParameterVar[k].get()) self._parameterValueChanged() return change # defines what happens when a parameter's value is changed, but not set yet, i.e., not current (closures) def parameterValueChanged(k): def valueChanged(*args): pp, ll = str(self.singleParameterVar[k].get()).find("."), len( str(self.singleParameterVar[k].get())) if round(self.odf[k], ll - pp - 1) != round( self.singleParameterVar[k].get(), ll - pp - 1): self.singleParameterEntry[k].configure(bg="red") else: self.singleParameterEntry[k].configure(bg="white") return valueChanged # Create an entry for each parameter # Create a scrollable region # Check maximum number of characters for parameter names: maxParamLen = 0 for k in sorted(self.odf.parameters().keys()): if len(k) > maxParamLen: maxParamLen = len(k) # Create an entry for each parameter for k in sorted(self.odf.parameters().keys()): x = tk.Frame(self.parameterFrame, height=2, bd=2, relief=tk.SUNKEN, pady=2) self.singleParameterFrames[k] = x y0 = tk.Radiobutton(x, text=k, variable=self.selectedPar, value=k, width=maxParamLen + 1, indicatoron=0) y0.pack(side=tk.LEFT) #y1 = tk.StringVar() y1 = tk.DoubleVar() y1.set(self.odf[k]) y2 = tk.Entry(x, textvariable=y1, width=8) y2.bind('<Return>', hitReturn(k)) self.singleParameterVar[k] = y1 self.singleParameterVar[k].trace('w', parameterValueChanged(k)) self.singleParameterEntry[k] = y2 y2.pack(side=tk.LEFT) self.singleParameterFrames[k].pack() modModus = tk.StringVar() modModus.set(self.modProps[k]["modus"]) self.singleParameterFree[k] = tk.BooleanVar() self.singleParameterFree[k].set(k in self.odf.freeParamNames()) y3 = tk.Radiobutton(x, text="Thawed", value=True, variable=self.singleParameterFree[k], command=frozenChanged(k)) y4 = tk.Radiobutton(x, text="Frozen", value=False, variable=self.singleParameterFree[k], command=frozenChanged(k)) y3.pack(side=tk.RIGHT) y4.pack(side=tk.RIGHT) self.parameterFrame.pack(fill=tk.X, expand=False) # Set of the menu to select the current parameter self.selectedPar.set(ps[0]) # Chi2 frame: # , relief=tk.SUNKEN) self.chi2Frame = tk.Frame(self.controlFrame, borderwidth=10) self.chi2value = tk.DoubleVar() self.chi2value.set(self.plotter.chi2) self.dofValue = tk.IntVar() # self.dofValue.set(len(self.plotter.fitIdx)) # self.dofValue.set(100) self.dofValue.set( len(self.plotter.x) - len(self.odf.freeParameters()) - 1) self.chi2Label = tk.Label(self.chi2Frame, text="Chi2: ") self.dofLabel = tk.Label(self.chi2Frame, text="dof: ") self.chi2Entry = tk.Entry(self.chi2Frame, textvariable=self.chi2value, bd=2, width=10) self.dofEntry = tk.Entry(self.chi2Frame, textvariable=self.dofValue, bd=2, width=10) self.chi2Label.pack(side=tk.LEFT) self.chi2Entry.pack(side=tk.LEFT) self.dofLabel.pack(side=tk.LEFT) self.dofEntry.pack(side=tk.LEFT) self.chi2Frame.pack() # Frame to bundle mouse-wheel inputs self.mouseWheelFrame = tk.Frame(self.controlFrame, height=2, bd=3, relief=tk.SUNKEN) self.mwmLabel = tk.Label(self.mouseWheelFrame, text="Mouse wheel manipulation") self.mwmLabel.pack() # Modify by multiplication or addition (modModus) self.modModus = tk.StringVar() self.modModus.set("mul") # Entry field and radiobutton to specify factor to be used self.factorFrame = tk.Frame(self.mouseWheelFrame) self.modEntryTextMul = tk.StringVar() self.modEntryFactor = tk.Entry(self.factorFrame, textvariable=self.modEntryTextMul, width=6) self.modEntryFactor.pack(side=tk.LEFT) self.radioMultipli = tk.Radiobutton(self.factorFrame, text="Multiply", value="mul", variable=self.modModus) self.radioMultipli.pack(side=tk.LEFT) self.factorFrame.pack(fill=tk.BOTH) # Entry field and radiobutton to specify step (delta) to be used self.addFrame = tk.Frame(self.mouseWheelFrame) self.modEntryTextAdd = tk.StringVar() self.modEntryAdd = tk.Entry(self.addFrame, textvariable=self.modEntryTextAdd, width=6) self.modEntryAdd.pack(side=tk.LEFT) self.radioAdd = tk.Radiobutton(self.addFrame, text="Add", value="add", variable=self.modModus) self.radioAdd.pack(side=tk.LEFT) self.addFrame.pack(fill=tk.BOTH) # Set text fields for modification factor/step to default self.modEntryTextMul.set( self.modProps[self.selectedPar.get()]["modValMul"]) self.modEntryTextAdd.set( self.modProps[self.selectedPar.get()]["modValAdd"]) self.modEntryTextAdd.trace("w", self._modModeChangedAdd) self.modEntryTextMul.trace("w", self._modModeChangedMul) # Show the frame # self.mouseWheelFrame.grid(row=4, column=0, columnspan=3, pady=10) self.mouseWheelFrame.pack() # React to change in modify Modus self.modModus.trace('w', self._modModusChanged) # React to a change in the active parameter self.selectedPar.trace("w", self._activeParameterChanged) dummyLabel = tk.Label(self.controlFrame) dummyLabel.pack() # Fit button and fit ranges self.fitRangeFrame = tk.Frame(self.controlFrame, bd=3, relief=tk.SUNKEN) self.fit_lo = tk.DoubleVar() self.fit_hi = tk.DoubleVar() self.fit_lo.set(min(plotter.x)) self.fit_hi.set(max(plotter.x)) self.fitRangeLoLim = tk.Entry(self.fitRangeFrame, textvariable=self.fit_lo, width=9, bd=2) self.fitRangeHiLim = tk.Entry(self.fitRangeFrame, textvariable=self.fit_hi, width=9, bd=2) self.fitRangeLabel = tk.Label(self.fitRangeFrame, text="Fit range:") self.fitButton = tk.Button(self.fitRangeFrame, text="Fit", command=self._fitClicked) self.fitButton.pack(side=tk.BOTTOM, fill=tk.X) self.fitRangeLabel.pack(side=tk.LEFT, fill=tk.X) self.fitRangeHiLim.pack(side=tk.RIGHT) self.fitRangeLoLim.pack(side=tk.RIGHT) self.fitRangeFrame.pack(fill=tk.X) #self.fitRangeLoLim.bind('<Return>', self._fitRangeChanged()) self.fit_lo.trace("w", self._fitRangeChanged) self.fit_hi.trace("w", self._fitRangeChanged) self.numberClicked = 0 #self.modModus.trace('w', self._modModusChanged) #self.modModus.trace('w', self._modModusChanged) dummyLabel = tk.Label(self.controlFrame) dummyLabel.pack() # , relief=tk.SUNKEN) self.showFrame = tk.Frame(self.controlFrame, bd=3) self.showFrame.pack(side=tk.TOP) self.parSumButton = tk.Button(self.showFrame, text="Parameter summary", command=self._parameterSummaryClicked) self.parSumButton.pack(side=tk.LEFT) self.valSetButton = tk.Button(self.showFrame, text="Value set code", command=self._valueSetClicked) # self.valSetButton.grid(row=7, column=2) self.valSetButton.pack(side=tk.RIGHT) # a tk.DrawingArea # self.canvas.get_tk_widget().grid(column=0, columnspan=7, row=0, rowspan=10) self.canvas.get_tk_widget().pack() self.cid = self.f.canvas.mpl_connect('button_press_event', self._mouseButtonClicked) self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.plotFrame) self.toolbar.update() self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) def _quit(): # stops main loop self.root.quit() # this is necessary on Windows to prevent # Fatal Python Error: PyEval_RestoreThread: NULL tstate self.root.destroy() self.quitButton = tk.Button(master=self.controlFrame, text='Quit', command=_quit) self.quitButton.pack(side=tk.BOTTOM) # Plot the model for the first time self._parameterValueChanged() # Whether or not parameter summary exists self.root.parSumWin = None if platform.system() == "Darwin": self.root.bind("<MouseWheel>", self._onWheel) # for OS X
root.title("matplotlib in TK") #设置图形尺寸与质量 f = Figure(figsize=(5, 4), dpi=100) a = f.add_subplot(111) t = arange(0.0, 3, 0.01) s = sin(2*pi*t) #绘制图形 a.plot(t, s) #把绘制的图形显示到tkinter窗口上 canvas = FigureCanvasTkAgg(f, master=root) canvas.show() canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) #把matplotlib绘制图形的导航工具栏显示到tkinter窗口上 toolbar = NavigationToolbar2TkAgg(canvas, root) toolbar.update() canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) #定义并绑定键盘事件处理函数 def on_key_event(event): print('you pressed %s' % event.key) key_press_handler(event, canvas, toolbar) canvas.mpl_connect('key_press_event', on_key_event) #按钮单击事件处理函数 def _quit(): #结束事件主循环,并销毁应用程序窗口 root.quit() root.destroy() button = Tk.Button(master=root, text='Quit', command=_quit)
def createWidgets(self): """ Creates the widgets for this application """ " Top frame " self.firstF = Frame(self.mainframe, bd=2, relief=RIDGE) self.firstF.grid() " Frame for device " self.device1 = LabelFrame(self.mainframe, bd=2, relief=RIDGE) self.device1.grid(row=1, column=0) # , columnspan = 4) " Chiller feedback frame" self.chillerFeedback_LF = LabelFrame( self.mainframe, bd=2, relief=RIDGE, text='PUMP: Temp. feedback rep.rate') self.chillerFeedback_LF.grid(row=2, column=0) # , columnspan = 4) self.save_LF = LabelFrame(self.mainframe, bd=2, relief=RIDGE) self.save_LF.grid(row=4, column=0) " Create the variables for the application " self.stopLoop = IntVar() self.stopLoop.set(0) self.LastDataSaved = IntVar() self.LastDataSaved.set(0) self.devices_initialised = IntVar() self.devices_initialised.set(0) self.deviationVoltage_DG = DoubleVar() self.deviationVoltage_DG.set(0.05) # 'record wether the last temperature change was up or down' self.lastTemperatureChange = 'None' self.temperature_data = [] # last temperature data " Startbutton with 'gumbo'" self.startB = Button(self.firstF, text='gumbo', command=self.mainLoop) self.startB.pack(side=LEFT) " Checkbox for stopping " self.stopLoopCB = Checkbutton(self.firstF, text='halt', variable=self.stopLoop) self.stopLoopCB.pack(side=LEFT, padx=10) self.deleteDataB = Button(self.firstF, text='delete Data', command=self.deleteData) self.deleteDataB.pack(side=LEFT) self.testB = Button(self.firstF, text='re-read set temp', command=self.test) self.testB.pack(side=LEFT) self.deviationVoltage_DGE = Entry( self.firstF, textvariable=self.deviationVoltage_DG, bg='white', width=11) self.deviationVoltage_DGE.pack(side=LEFT) self.ShutdownAndQuitB = Button(self.firstF, text="Quit", command=self.Quit) self.ShutdownAndQuitB.pack(side=RIGHT) self.k = 1 # number_dataArrays = 1 # self.k = number_dataArrays = 1 # Don't know what it does, but # probably it should be one if there's only one monitoring self.dat = [] for a in range(self.k): self.dat.append([]) self.t = [] self.font_label = ('Helvetica', 20, 'bold') self.font_entry = ('Helvetica', 30, 'bold') self.sleep_time_per_meas = DoubleVar() self.sleep_time_per_meas.set(500) self.limit_plot_y_axis = IntVar() self.limit_plot_y_axis.set(0) self.y1lim = DoubleVar() self.y1lim.set(self.piezo_voltage_min) self.y2lim = DoubleVar() self.y2lim.set(self.piezo_voltage_max) self.sets_to_plot = IntVar() self.sets_to_plot.set(500) self.filename = StringVar() self.filename.set('temp.txt') Label(self.device1, text="sleep time [ms]").pack(side=LEFT) self.sleep_time_per_measE = Entry( self.device1, textvariable=self.sleep_time_per_meas, bg='white', width=5) self.sleep_time_per_measE.pack(side=LEFT) self.stopLoopCB = Checkbutton(self.device1, text='ylims', variable=self.limit_plot_y_axis) self.stopLoopCB.pack(side=LEFT, padx=10) self.y1E = Entry(self.device1, textvariable=self.y1lim, bg='white', width=5) self.y1E.pack(side=LEFT) self.y2E = Entry(self.device1, textvariable=self.y2lim, bg='white', width=5) self.y2E.pack(side=LEFT) Label(self.save_LF, text="sets to plot:").pack(side=LEFT) self.sets_to_plotE = Entry(self.save_LF, textvariable=self.sets_to_plot, bg='white', width=5) self.sets_to_plotE.pack(side=LEFT) self.saveB = Button(self.save_LF, text="save", command=self.save) self.saveB.pack(side=LEFT) self.filenameE = Entry(self.save_LF, textvariable=self.filename, bg='white', width=50) self.filenameE.pack(side=LEFT) ### self.chillerFeedback_LF self.T_set = IntVar() self.T_set.set(0) self.T_min = IntVar() self.T_min.set(self.tmin) self.T_max = IntVar() self.T_max.set(self.tmax) voltage_range = self.piezo_voltage_max - self.piezo_voltage_min self.Vpi_lim_low = DoubleVar() self.Vpi_lim_low.set(self.piezo_voltage_min + 0.2 * voltage_range) self.Vpi_lim_high = DoubleVar() self.Vpi_lim_high.set(self.piezo_voltage_max - 0.2 * voltage_range) self.T_delta_t = DoubleVar() self.T_delta_t.set(self.t_delta_t) self.T_feedback = IntVar() self.T_feedback.set(0) self.counter_T_feedback = 0. self.counter_T_feedback_reset_bool = 1 self.T_feedbackCB = Checkbutton(self.chillerFeedback_LF, text='lock', variable=self.T_feedback) self.T_feedbackCB.pack(side=LEFT, padx=10) Label(self.chillerFeedback_LF, text="T_set").pack(side=LEFT) self.T_setE = Entry(self.chillerFeedback_LF, textvariable=self.T_set, bg='white', width=5) self.T_setE.pack(side=LEFT) Label(self.chillerFeedback_LF, text="T_min").pack(side=LEFT) self.T_minE = Entry(self.chillerFeedback_LF, textvariable=self.T_min, bg='white', width=5) self.T_minE.pack(side=LEFT) Label(self.chillerFeedback_LF, text="T_max").pack(side=LEFT) self.T_maxE = Entry(self.chillerFeedback_LF, textvariable=self.T_max, bg='white', width=5) self.T_maxE.pack(side=LEFT) Label(self.chillerFeedback_LF, text="Vpi_lim_low").pack(side=LEFT) self.Vpi_lim_lowE = Entry(self.chillerFeedback_LF, textvariable=self.Vpi_lim_low, bg='white', width=5) self.Vpi_lim_lowE.pack(side=LEFT) Label(self.chillerFeedback_LF, text="Vpi_lim_high").pack(side=LEFT) self.Vpi_lim_highE = Entry(self.chillerFeedback_LF, textvariable=self.Vpi_lim_high, bg='white', width=5) self.Vpi_lim_highE.pack(side=LEFT) Label(self.chillerFeedback_LF, text="T_delta_t").pack(side=LEFT) self.T_delta_tE = Entry(self.chillerFeedback_LF, textvariable=self.T_delta_t, bg='white', width=5) self.T_delta_tE.pack(side=LEFT) ### for matplotlib self.fig = plt.figure(figsize=(5, 3)) self.canvas = FigureCanvasTkAgg(self.fig, master=root) self.toolbar = NavigationToolbar2TkAgg(self.canvas, root) self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1) #grid(row = 0, column = 2)# # get the tuples indicating the different background colors, used for a warning self.fig.set_facecolor('red') self.redbackground = self.fig.get_facecolor() self.fig.set_facecolor('white') self.whitebackground = self.fig.get_facecolor() self.ax = plt.subplot(211) self.raw_data_axis = plt.subplot(212) self.raw_data_axis.set_ylabel('Voltage') self.raw_data_axis.set_xlabel('Time') self.raw_data_axis.set_title('Bla') self.raw_data_axis.hold(False) self.ax.set_ylabel('signal [V]') self.ax.set_xlabel('t [s]') self.ax.plot([1, 4, 2]) self.ax2 = self.ax.twinx() self.canvas.draw()
def initialize(self): #These variables are set at the start to be used later on in the plotting. As long as they are 'in scope' and are set before you try to use them, it doesn't matter where you set them. Being in scope means being declared where you are using them. An example of being out of scope would be if you had a "main" function, and a separate "graph" function that is called inside main. If you declare a variable min_val inside the graph function, and try to use it in the main, it won't work because main can't see it. min_val = 0 max_val = 1024 #Prints a line to the terminal asking user to input the port number as 'COMx'. You can check the port number in device manager when the Arduino is plugged in #port = raw_input("Enter the port number (e.g. 'COM4'): \n") port = 'com6' #Creates a variable called 'ser' that we will use to communicate with the serial port. Gives it the port number, the baud rate and timeout (not sure what timeout does but it fixed that 0000s problem) self.ser = serial.Serial(port, 230400, timeout=1) #Some commented out stuff experimenting with weird data #ser = serial.Serial('COM4', 9600, timeout=1) self.ser.flush() #Sleep tells the programme to wait for x seconds. Useful in serial comms when you want to be sure something has happened time.sleep(3) #This is an empty array of data that will be populated later with the values from the serial port self.valList = [] self.startTime = time.time() frame = Frame(self) frame.pack(side="left", fill="both", expand=True) plotFrame = Frame(self) plotFrame.pack(side="right", fill="both", expand=True) #Left-hand-side self.l1 = Label(frame, text="Heading Text").grid(row=0, columnspan=2) self.l2 = Label(frame, text="Name").grid(row=1, sticky=W) self.l3 = Label(frame, text="Clicks (C)").grid(row=3, sticky=W) self.l4 = Label(frame, text="Clicks (R)").grid(row=5, sticky=W) self.l5 = Label(frame, text="Temp").grid(row=7, sticky=W) self.l6 = Label(frame, text="Notes").grid(row=9, sticky=W) self.e1 = Entry(frame, width=30) self.e2 = Entry(frame, width=30) self.e3 = Entry(frame, width=30) self.e4 = Entry(frame, width=30) self.e5 = Text(frame, width=23, height=5) self.e1.grid(row=2, column=0, sticky=W) self.e2.grid(row=4, column=0, sticky=W) self.e3.grid(row=6, column=0, sticky=W) self.e4.grid(row=8, column=0, sticky=W) self.e5.grid(row=10, column=0, sticky=W) self.btn_text = tk.StringVar() button = tk.Button(frame, textvariable=self.btn_text, fg="green", command=self.OnButtonClick) self.btn_text.set("Start") button.grid(row=11, column=0, stick=W) #button = tk.Button(self,text="Start",command=self.OnButtonClick).pack(side=tk.LEFT,anchor=W) #button = tk.Button(plotFrame,text="Start",command=self.OnButtonClick).grid(row=11, column=0) #Right hand side with Graph Label(plotFrame, text="Graph Stuff heading").pack() f = Figure(figsize=(6, 4), dpi=100) a = f.add_subplot(111) x = [] y = [] self.line1, = a.plot(x, y) self.canvas = FigureCanvasTkAgg(f, plotFrame) self.canvas.show() #a.plot([1,2,3,4,5,6,7,8],[5,6,1,3,8,9,3,5]) #canvas = FigureCanvasTkAgg(f, plotFrame) #canvas.show() self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.NONE, expand=False, anchor=W) self.update toolbar = NavigationToolbar2TkAgg(self.canvas, plotFrame).pack(side=tk.TOP) Label(plotFrame, text="Data One").pack(anchor=W) Label(plotFrame, text="Data Two").pack(anchor=W) Label(plotFrame, text="Data Three").pack(anchor=W)
def main(): # PLOTDIAGR = show PLOTRAWDISP = 0 PLOTDISPALL = 0 SAVEFILES = 0 if not os.path.isdir("TOMO_DISP"): os.makedirs("TOMO_DISP") db = connect() PER = get_config(db, "ftan_periods", plugin="Tomo") PER = np.array([float(pi) for pi in PER.split(',')]) fmin = float(get_config(db, "ftan_fmin", plugin="Tomo")) fmax = float(get_config(db, "ftan_fmax", plugin="Tomo")) vgmin = float(get_config(db, "ftan_vgmin", plugin="Tomo")) vgmax = float(get_config(db, "ftan_vgmax", plugin="Tomo")) bmin = float(get_config(db, "ftan_bmin", plugin="Tomo")) bmax = float(get_config(db, "ftan_bmax", plugin="Tomo")) diagramtype = get_config(db, "ftan_diagramtype", plugin="Tomo") nfreq = int(get_config(db, "ftan_nfreq", plugin="Tomo")) ampmin = float(get_config(db, "ftan_ampmin", plugin="Tomo")) global data data = pd.DataFrame() # nfreq = 100 db = connect() def load_dir(): folder = askdirectory(parent=root) files = sorted( glob.glob(os.path.join(os.path.realpath(folder), "*_MEAN.*"))) cb['values'] = files cb_val.set(files[0]) def save(): global data print(data.head()) filename = cb_val.get() filename = filename.replace("TOMO_SAC", "TOMO_DISP").replace( ".sac", ".csv").replace(".SAC", ".csv") if not os.path.isdir(os.path.split(filename)[0]): os.makedirs(os.path.split(filename)[0]) data.to_csv(filename) def process(e=None): filename = cb_val.get() NET1, STA1, NET2, STA2, crap = os.path.split(filename)[1].split('_') st = read(filename) dist = st[0].stats.sac.dist dt = st[0].stats.delta p = ccf.gca() p.cla() taxis = np.arange(st[0].stats.npts) * st[0].stats.delta vaxis = dist / taxis[1:] zone = np.where((vaxis >= float(_vgmin.get())) & (vaxis <= float(_vgmax.get())))[0] p.plot(taxis, st[0].data) p.plot(taxis[zone], st[0].data[zone], c='r') ccf.subplots_adjust(bottom=0.25) ccfcanvas.show() per, disper, seeds = pickgroupdispcurv(filename, _fmin.get(), _fmax.get(), _vgmin.get(), _vgmax.get(), _bmin.get(), _bmax.get(), diagramtype, nfreq, _ampmin.get(), dist) basename = "%s.%s_%s.%s_%s" % (NET1, STA1, NET2, STA2, crap) basename = basename.replace(".SAC", "") for _ in [ "write_amp.txt", "write_disp.txt", "write_FP.txt", "write_ph.txt", "write_TV.txt", ]: shutil.move(_, _.replace("write", basename)) U = np.loadtxt('%s_TV.txt' % basename) P = np.loadtxt('%s_FP.txt' % basename) xmin = min(P) xmax = max(P) ymin = min(U) ymax = max(U) amp = np.loadtxt('%s_amp.txt' % basename).T iu = np.where((disper >= ymin) & (disper <= ymax)) per = per[iu] disper = disper[iu] Per, Vitg = np.meshgrid(P, U) f.clf() p = f.gca() p.cla() if int(_normed.get()): for i in range(amp.shape[1]): amp[:, i] /= amp[:, i].max() c = p.contourf(Per, Vitg, amp, 35, cmap=cm_val.get()) f.colorbar(c) idxx = np.where(float(_minWL.get()) * per * disper < dist)[0] p.plot(per, disper, '-ok', lw=1.5) p.scatter(per[idxx], disper[idxx], marker='o', s=100, c="green", lw=1.5) p.scatter(seeds[:, 0], seeds[:, 1], s=10, marker='d', facecolor='w', edgecolor="k") global data data = pd.DataFrame(disper[idxx], index=per[idxx], columns=["Velocity"]) data.index.name = "Period" # TODO add axes labels depending on diagramtype p.set_xlabel("Period (s)", fontsize=12) p.set_ylabel('Velocity (km/s)', fontsize=12) p.set_xlim(xmin, xmax) p.set_ylim(ymin, ymax) p.set_title("%s.%s - %s.%s (%.2f km)" % (NET1, STA1, NET2, STA2, dist)) canvas.show() def previous_file(e=None): idx = cb['values'].index(cb.get()) if idx > 0: idx -= 1 cb.set(cb['values'][idx]) process() def next_file(e=None): idx = cb['values'].index(cb.get()) if idx < len(cb['values']): idx += 1 cb.set(cb['values'][idx]) process() #root root = Tk() root.title("MSNoise-TOMO: Time-Frequency & Dispersion Curve Picking Tool") # root.resizable(True, True) # menubar = Menu(root) # filemenu = Menu(menubar, tearoff=0) # filemenu.add_command(label="Open", command=openfile) # filemenu.add_separator() # filemenu.add_command(label="Exit", command=root.quit) # menubar.add_cascade(label="File", menu=filemenu) # root.config(menu=menubar) #mainframe gui_style = ttk.Style() gui_style.configure('My.TLabel', background='#ffffff') gui_style.configure('My.TButton', background='#ff0011') gui_style.configure('M2.TButton', background='#B7E2F0') gui_style.configure('My.TFrame', background='#ffffff') mainframe = ttk.Frame(root, padding="3 3 12 12", style='My.TFrame') mainframe.grid(column=0, row=0, sticky=(N, W, E, S)) mainframe.columnconfigure(0, weight=1) mainframe.rowconfigure(0, weight=1) _folder = StringVar(root, value=os.path.join(os.getcwd(), "TOMO_SAC")) ttk.Button(mainframe, text="Select Folder", command=load_dir, style='M2.TButton').grid(column=1, row=1, sticky=W) cb_val = StringVar() files = sorted( glob.glob(os.path.join(os.path.realpath(_folder.get()), "*_MEAN.*"))) cb = ttk.Combobox(mainframe, width=55, textvariable=cb_val, height=4) cb.grid(column=2, row=1, sticky=(W, E), columnspan=2) if len(files): cb['values'] = files cb_val.set(files[0]) else: cb_val.set("<-- SELECT A FOLDER BY CLICKING ON THE BUTTON") # PARAMS PANEL # myFont = Font(family="Helvetica", size=12) _vgmin = StringVar(root, value=vgmin) vgminSize = ttk.Entry(mainframe, width=7, textvariable=_vgmin) vgminSize.grid(column=2, row=2, sticky=(W, E)) tmp = ttk.Label(mainframe, text="Vg Min ", style='My.TLabel').grid(column=1, row=2, sticky=W) _vgmax = StringVar(root, value=vgmax) vgmaxSize = ttk.Entry(mainframe, width=7, textvariable=_vgmax) vgmaxSize.grid(column=2, row=3, sticky=(W, E)) ttk.Label(mainframe, text="Vg Max ", style='My.TLabel').grid(column=1, row=3, sticky=W) _minSNR = StringVar(root, value=0.0) minSNRSize = ttk.Entry(mainframe, width=7, textvariable=_minSNR) minSNRSize.grid(column=2, row=4, sticky=(W, E)) ttk.Label(mainframe, text="Min SNR ", style='My.TLabel').grid(column=1, row=4, sticky=W) _minWL = StringVar(root, value=1.0) minWLSize = ttk.Entry(mainframe, width=7, textvariable=_minWL) minWLSize.grid(column=2, row=5, sticky=(W, E)) ttk.Label(mainframe, text="Min Wavelength ", style='My.TLabel').grid(column=1, row=5, sticky=W) _fmin = StringVar(root, value=fmin) fminSize = ttk.Entry(mainframe, width=7, textvariable=_fmin) fminSize.grid(column=2, row=6, sticky=(W, E)) ttk.Label(mainframe, text="Min Frequency ", style='My.TLabel').grid(column=1, row=6, sticky=W) _fmax = StringVar(root, value=fmax) fmaxSize = ttk.Entry(mainframe, width=7, textvariable=_fmax) fmaxSize.grid(column=2, row=7, sticky=(W, E)) ttk.Label(mainframe, text="Max Frequency ", style='My.TLabel').grid(column=1, row=7, sticky=W) _diagType = StringVar(root, value="PV") diagTypeSize = ttk.Entry(mainframe, width=7, textvariable=_diagType) diagTypeSize.grid(column=2, row=8, sticky=(W, E)) ttk.Label(mainframe, text="Diagram (...) ", style='My.TLabel').grid(column=1, row=8, sticky=W) _bmin = StringVar(root, value=bmin) bminSize = ttk.Entry(mainframe, width=7, textvariable=_bmin) bminSize.grid(column=2, row=9, sticky=(W, E)) ttk.Label(mainframe, text="Bmin ", style='My.TLabel').grid(column=1, row=9, sticky=W) _bmax = StringVar(root, value=bmax) bminSize = ttk.Entry(mainframe, width=7, textvariable=_bmax) bminSize.grid(column=2, row=10, sticky=(W, E)) ttk.Label(mainframe, text="Bmax ", style='My.TLabel').grid(column=1, row=10, sticky=W) _ampmin = StringVar(root, value=ampmin) ampminSize = ttk.Entry(mainframe, width=7, textvariable=_ampmin) ampminSize.grid(column=2, row=11, sticky=(W, E)) ttk.Label(mainframe, text="Amp Min ", style='My.TLabel').grid(column=1, row=11, sticky=W) maps = sorted(m for m in plt.cm.datad) cm_val = StringVar() cm = ttk.Combobox(mainframe, width=7, textvariable=cm_val, height=4) cm.grid(column=2, row=12, sticky=(W, E)) ttk.Label(mainframe, text="Cmap ", style='My.TLabel').grid(column=1, row=12, sticky=W) cm['values'] = maps cm_val.set("hot_r") ccf = Figure(figsize=(5, 1), dpi=100) ccfcanvas = FigureCanvasTkAgg(ccf, master=mainframe) ccfcanvas.get_tk_widget().grid(row=2, column=3, rowspan=2) f = Figure(dpi=100) canvas = FigureCanvasTkAgg(f, master=mainframe) canvas.get_tk_widget().grid(row=4, column=3, rowspan=9) _normed = IntVar() chh = ttk.Checkbutton(mainframe, text="Normed", variable=_normed, \ onvalue=1, offvalue=0).grid(column=1, row=13, sticky=W) ttk.Button(mainframe, text="Compute", command=process, style='My.TButton').grid(column=2, row=13, sticky=W) ttk.Button(mainframe, text="Save", command=save, style='My.TButton').grid(column=2, row=14, sticky=W) toolbar = NavigationToolbar2TkAgg(canvas, mainframe) toolbar.update() toolbar.grid(column=3, row=14, columnspan=1, sticky=W) # canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=0) def onclick(event): print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' % (event.button, event.x, event.y, event.xdata, event.ydata)) cid = f.canvas.mpl_connect('button_press_event', onclick) for child in mainframe.winfo_children(): child.grid_configure(padx=0.5, pady=0.5) root.bind('<Return>', process) root.bind('<KP_Enter>', process) root.bind('<Control-Key-Left>', previous_file) root.bind('<Control-Key-Right>', next_file) icon = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'img', 'msnoise.gif') img = PhotoImage(file=icon) root.tk.call('wm', 'iconphoto', root._w, img) # print(os.path.isfile(icon)) # root.iconbitmap(icon) root.mainloop()
def __init__(self, parent, controller): tk.Frame.__init__(self, parent) self.configure(bg=PADDING_COLOR, highlightcolor=PADDING_COLOR, highlightbackground=PADDING_COLOR) self.canvas = FigureCanvasTkAgg(f, self) self.canvas.get_tk_widget().grid(row=0, column=0, sticky='nsew', padx=5, pady=4, ipadx=0, ipady=0) self.canvas.get_tk_widget().configure( bg=BACKGROUND_COLOR, highlightcolor=PADDING_COLOR, highlightbackground=PADDING_COLOR, relief=tk.SUNKEN, bd=1) self.grid_rowconfigure(0, weight=1) self.grid_columnconfigure(0, weight=1) frame2 = tk.Frame(self) frame2.grid(row=1, column=0, columnspan=1, sticky='WE', padx=7, pady=5) frame2.configure(bg=BACKGROUND_COLOR, highlightcolor=BACKGROUND_COLOR, highlightbackground=BACKGROUND_COLOR, relief=tk.SUNKEN, bd=1) # frame2.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=1) frame3 = tk.Frame(self) frame3.grid(row=0, column=2, rowspan=2, sticky='NS', padx=3, pady=4) frame3.configure(bg=PADDING_COLOR, highlightcolor=PADDING_COLOR, highlightbackground=PADDING_COLOR) buttonsFrame = tk.Frame(self, relief=tk.SUNKEN, bd=1) buttonsFrame.configure(bg=BACKGROUND_COLOR, highlightcolor=BACKGROUND_COLOR, highlightbackground=BACKGROUND_COLOR) buttonsFrame.grid(row=0, column=1, rowspan=2, sticky='NS', pady=5.2, padx=2) button1 = ttk.Button(buttonsFrame, text="Force Release", cursor='hand2', command=lambda: SendPacket('r')) button1.grid(row=0, column=0, padx=2, pady=2, sticky='nsew') button2 = ttk.Button(buttonsFrame, text="Capture", cursor='hand2', command=lambda: SendPacket('c')) button2.grid(row=0, column=1, padx=0, pady=2, sticky='nsew') button3 = ttk.Button(buttonsFrame, text="Picture", cursor='hand2', command=lambda: controller.show_frame(StartPage)) button3.grid(row=1, column=0, padx=2, pady=0, sticky='nsew') button4 = ttk.Button( buttonsFrame, text="Send State", cursor='hand2', command=lambda: SendPacket(self.sendentry.get() + '\n')) button4.grid(row=1, column=1, padx=0, pady=0, sticky='nsew') sendlabel = tk.Label(buttonsFrame, text="Send State", font=SMALL_FONT) sendlabel.grid(row=2, column=0, columnspan=2, sticky='NS', padx=5, pady=5) sendlabel.configure(bg=BACKGROUND_COLOR, fg=TEXT_COLOR, highlightcolor=BACKGROUND_COLOR, highlightbackground=BACKGROUND_COLOR) self.sendentry = ttk.Entry(buttonsFrame, width=7) self.sendentry.grid(row=3, column=0, columnspan=2, sticky='NS', padx=5, pady=5) rangelabel = tk.Label(buttonsFrame, text="Plot Range", font=SMALL_FONT) rangelabel.grid(row=4, column=0, columnspan=2, sticky='NS', padx=5, pady=5) rangelabel.configure(bg=BACKGROUND_COLOR, fg=TEXT_COLOR, highlightcolor=BACKGROUND_COLOR, highlightbackground=BACKGROUND_COLOR) self.rangeentry1 = ttk.Entry(buttonsFrame, width=5) self.rangeentry1.grid(row=5, column=0, columnspan=2, sticky='NS', padx=5, pady=5) rangebutton = ttk.Button(buttonsFrame, text="Update Range", cursor='hand2', command=self.GetSetPlotRange) rangebutton.grid(row=6, column=0, columnspan=2, sticky='NS', padx=5, pady=5) # -------------------------------------------------------------------------------------------------------------- mfFrame = tk.Frame(buttonsFrame) mfFrame.grid(row=7, column=0, columnspan=2, sticky='nsew', padx=5, pady=5) mfFrame.configure(bg=BACKGROUND_COLOR, highlightcolor=BACKGROUND_COLOR, highlightbackground=BACKGROUND_COLOR) mfscrollbar = ttk.Scrollbar(mfFrame) mfscrollbar.grid(row=0, column=2, sticky='NS') self.marklistbox = tk.Listbox(mfFrame, selectmode=tk.SINGLE, yscrollcommand=mfscrollbar.set) self.marklistbox.grid(row=0, column=0, columnspan=2, sticky='nsew') mfscrollbar.config(command=self.marklistbox.yview) markerlist = [ 'point', 'pixel', 'circle', 'triangledown', 'triangleup', 'triangleleft', 'triangleright', 'octagon', 'square', 'pentagon', 'star', 'hexagon1', 'hexagon2', 'plus', 'X', 'diamond', 'thindiamond', 'vline', 'hline', 'None' ] for marker in markerlist: self.marklistbox.insert(tk.END, marker) mkbutton = ttk.Button(mfFrame, text='Set Marker', cursor='hand2', command=lambda: self.GetSetMarkerSymbol()) mkbutton.grid(row=1, column=1, columnspan=1, sticky='NS', padx=5, pady=5) self.mksize = tk.Entry(mfFrame, width=5) self.mksize.grid(row=1, column=0, padx=5, pady=5) toolbar = NavigationToolbar2TkAgg(self.canvas, frame2) toolbar.update() toolbar.configure(bg=BACKGROUND_COLOR, highlightcolor=BACKGROUND_COLOR, highlightbackground=BACKGROUND_COLOR, padx=1)
def _pack_navigation(self, canvas, frame): toolbar = NavigationToolbar2TkAgg(canvas, frame) toolbar.update() canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)