class RotatePanel(CtxSubPanel): name = 'RotatePanel' def __init__(self, parent): CtxSubPanel.__init__(self, parent) self.angle = DoubleVar(self.mw.root) self.angle.set(0) label = TLabel(self.panel, image='context_R') label.pack(side=LEFT) self.entry_width = TSpinbox(self.panel, var=0, vartype=1, textvariable=self.angle, min=-360, max=360, step=1, width=6, command=self.applyRotate) tooltips.AddDescription(self.entry_width, _('Rotation angle')) self.entry_width.pack(side=LEFT, padx=5) b = TButton(self.panel, command=self.rotLeft, style='Toolbutton', image='context_rotate_ccw') tooltips.AddDescription(b, _(u'Rotate -90°')) b.pack(side=LEFT) b = TButton(self.panel, command=self.rot180, style='Toolbutton', image='context_rotate') tooltips.AddDescription(b, _(u'Rotate 180°')) b.pack(side=LEFT) b = TButton(self.panel, command=self.rotRight, style='Toolbutton', image='context_rotate_cw') tooltips.AddDescription(b, _(u'Rotate 90°')) b.pack(side=LEFT) def rot180(self): self.rotation(180) def rotLeft(self): self.rotation(90) def rotRight(self): self.rotation(-90) def applyRotate(self, *arg): self.rotation(self.angle.get()) def rotation(self, angle): if angle < 0: if angle < -360: angle += int(angle / 360) * 360 angle += 360 self.doc.RotateSelected(angle)
class RotatePanel(CtxSubPanel): name='RotatePanel' def __init__(self, parent): CtxSubPanel.__init__(self, parent) self.angle=DoubleVar(self.mw.root) self.angle.set(0) label = TLabel(self.panel, image='context_R') label.pack(side = LEFT) self.entry_width = TSpinbox(self.panel, var=0, vartype=1, textvariable = self.angle, min = -360, max = 360, step = 1, width = 6, command = self.applyRotate) tooltips.AddDescription(self.entry_width, _('Rotation angle')) self.entry_width.pack(side = LEFT, padx=5) b = TButton(self.panel, command=self.rotLeft, style='Toolbutton', image='context_rotate_ccw') tooltips.AddDescription(b, _(u'Rotate -90°')) b.pack(side = LEFT) b = TButton(self.panel, command=self.rot180, style='Toolbutton', image='context_rotate') tooltips.AddDescription(b, _(u'Rotate 180°')) b.pack(side = LEFT) b = TButton(self.panel, command=self.rotRight, style='Toolbutton', image='context_rotate_cw') tooltips.AddDescription(b, _(u'Rotate 90°')) b.pack(side = LEFT) def rot180(self): self.rotation(180) def rotLeft(self): self.rotation(90) def rotRight(self): self.rotation(-90) def applyRotate(self, *arg): self.rotation(self.angle.get()) def rotation(self, angle): if angle<0: if angle<-360: angle+=int(angle/360)*360 angle+=360 self.doc.RotateSelected(angle)
class TrainingError(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent training_error_laber = Label(self, text = 'Training Error: ') training_error_laber.pack(side = 'left') error_options = [round(0.1 + i*0.1, 2) for i in range(25)] self.selected_error = DoubleVar(self, value = DEFAULT_TRAINING_ERROR) option_menu = OptionMenu(self, self.selected_error, *error_options, command = self._on_error_selection) option_menu.pack(side = 'right') def get(self): return self.selected_error.get() def reset(self): self.selected_error.set(DEFAULT_TRAINING_ERROR) def _on_error_selection(self, selected_error): print "Selected training error: ", selected_error
def set_tk_var(): global method method = StringVar() method.set(read_config("Config", "Method", "str")) global server server = StringVar() server.set(read_config("Config", "Server", "str")) global shelltype shelltype = StringVar() shelltype.set(read_config("Config", "ShellType", "str")) global parameter parameter = StringVar() parameter.set(read_config("Config", "Parameter", "str")) global thread_num thread_num = IntVar() thread_num.set(read_config("Config", "ThreadNumber", "int")) global req_delay req_delay = DoubleVar() req_delay.set(read_config("Config", "RequestDelay", "float")) global time_out time_out = DoubleVar() time_out.set(read_config("Config", "RequestTimeout", "float")) global random_ua random_ua = BooleanVar() random_ua.set(read_config("Config", "RandomUserAgent", "boolean")) global con_close con_close = BooleanVar() con_close.set(read_config("Config", "ConnectionClose", "boolean")) global keep_alive keep_alive = BooleanVar() keep_alive.set(read_config("Config", "KeepAlive0", "boolean")) global custom_hdr custom_hdr = BooleanVar() custom_hdr.set(read_config("Config", "CustomRequestHeader", "boolean")) global custom_hdr_data custom_hdr_data = StringVar() custom_hdr_data.set(read_config("Config", "CustomRequestHeaderData", "str"))
class TrainingError(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent training_error_laber = Label(self, text='Training Error: ') training_error_laber.pack(side='left') error_options = [round(0.1 + i * 0.1, 2) for i in range(25)] self.selected_error = DoubleVar(self, value=DEFAULT_TRAINING_ERROR) option_menu = OptionMenu(self, self.selected_error, *error_options, command=self._on_error_selection) option_menu.pack(side='right') def get(self): return self.selected_error.get() def reset(self): self.selected_error.set(DEFAULT_TRAINING_ERROR) def _on_error_selection(self, selected_error): print "Selected training error: ", selected_error
class SystemProperties: """Gets the flow and contaminant properties.""" def __init__(self, master, system): """Constructor method. Defines the parameters to be obtained in this window.""" self.master = master self.system = system self.fonttype = system.fonttype self.version = system.version self.superfont = get_superfont(self.fonttype) #superscript font self.tframe = Frame(master.tframe) self.frame = Frame(master.frame) self.bframe = Frame(master.bframe) self.advs = ['None', 'Steady flow', 'Period oscillation'] self.bios = ['None', 'Uniform', 'Depth-dependent'] self.cons = ['None', 'Consolidation'] self.adv = StringVar(value=self.advs[0]) #tidal flag self.bio = StringVar(value=self.bios[0]) #bioturbation flag self.con = StringVar(value=self.cons[0]) #consolidation flag self.hbio = DoubleVar(value=10.) #bioturbation depth self.sigma = DoubleVar(value=10.) #bioturbation depth self.Dbiop = DoubleVar(value=1.) #particle bioturbation coeff self.Dbiopw = DoubleVar(value=100.) #pore water bioturbation coeff self.Vdar = DoubleVar(value=0.) #Darcy velocity self.Vtidal = DoubleVar(value=0.) #Tidal velocity self.ptidal = DoubleVar(value=0.0014) #Tidal frequency self.hcon = DoubleVar(value=0) #total consolidation self.t90 = DoubleVar(value=1.) #time to 90% consolidation self.top = None #flag for existence of toplevel if system.layers[0].number == 0: self.toplayer_h = system.layers[1].h else: self.toplayer_h = system.layers[0].h self.lengthunit = system.lengthunit self.timeunit = system.timeunit self.diffunit = system.diffunit self.diffunits = system.diffunits try: self.adv.set(system.adv) self.bio.set(system.bio) self.con.set(system.con) self.Vdar.set(system.Vdar) self.hbio.set(system.hbio) self.sigma.set(system.sigma) self.Dbiop.set(system.Dbiop) self.Dbiopw.set(system.Dbiopw) self.Vtidal.set(system.Vtidal) self.ptidal.set(system.ptidal) self.hcon.set(system.hcon) self.t90.set(system.t90) except: pass def make_widgets(self): """Make the widgets for the window.""" self.bgcolor = self.frame.cget('bg') self.instructions = Label( self.frame, text= ' Please provide the information of the following system properties: ' ) self.blank1 = Label(self.frame, width=30) self.blank2 = Label(self.frame, width=20) self.blank3 = Label(self.frame, width=15) self.blank4 = Label(self.frame, width=20) self.headings1 = Label(self.frame, text='Parameter') self.headings2 = Label(self.frame, text='Value') self.headings3 = Label(self.frame, text='Units') self.advlabel = Label(self.frame, text='Upwelling groundwater flow') self.advwidget = OptionMenu(self.frame, self.adv, *self.advs, command=self.updatesystem) self.Vdarlabel = Label(self.frame, text='Darcy velocity:') self.Vtidallabel = Label(self.frame, text='Oscillation maximum velocity:') self.ptidallabel = Label(self.frame, text='Oscillation period:') self.Vdarwidget = Entry(self.frame, width=10, textvariable=self.Vdar, justify='center') self.Vtidalwidget = Entry(self.frame, width=10, textvariable=self.Vtidal, justify='center') self.ptidalwidget = Entry(self.frame, width=10, textvariable=self.ptidal, justify='center') self.Vdarunits = Label(self.frame, text=self.lengthunit + '/' + self.timeunit) self.Vtidalunits = Label(self.frame, text=self.lengthunit + '/' + self.timeunit) self.ptidalunits = Label(self.frame, text=self.timeunit) self.biolabel = Label(self.frame, text='Modeling bioturbation') self.biowidget = OptionMenu(self.frame, self.bio, *self.bios, command=self.updatesystem) self.hbiolabel = Label(self.frame, text='Bioturbation depth:') self.sigmalabel = Label(self.frame, text='Gaussian model coefficient:') self.Dbioplabel = Label(self.frame, text='Particle biodiffusion coefficient:') self.Dbiopwlabel = Label(self.frame, text='Pore water biodiffusion coefficient:') self.hbiowidget = Entry(self.frame, width=10, textvariable=self.hbio, justify='center') self.sigmawidget = Entry(self.frame, width=10, textvariable=self.sigma, justify='center') self.Dbiopwidget = Entry(self.frame, width=10, textvariable=self.Dbiop, justify='center') self.Dbiopwwidget = Entry(self.frame, width=10, textvariable=self.Dbiopw, justify='center') self.hbiounits = Label(self.frame, text=self.lengthunit) self.Dbiopunits = Label(self.frame, text=self.diffunits[1]) self.Dbiopwunits = Label(self.frame, text=self.diffunits[1]) self.conlabel = Label(self.frame, text='Modeling consolidation') self.conwidget = OptionMenu(self.frame, self.con, *self.cons, command=self.updatesystem) self.hconlabel = Label(self.frame, text='Maximum consolidation depth:') self.t90label = Label(self.frame, text='Time to 90% consolidation:') self.hconwidget = Entry(self.frame, width=10, textvariable=self.hcon, justify='center') self.t90widget = Entry(self.frame, width=10, textvariable=self.t90, justify='center') self.hconunits = Label(self.frame, text=self.lengthunit) self.t90units = Label(self.frame, text=self.timeunit) self.advwidget.config(width=20) self.biowidget.config(width=20) self.conwidget.config(width=20) #self.okbutton = Button(self.frame, text = 'OK', command = self.OK, width = 20) #show the widgets on the grid self.instructions.grid(row=0, column=0, columnspan=3, padx=6, sticky='W') self.blank1.grid(row=1, column=0) self.blank2.grid(row=1, column=1) self.blank3.grid(row=1, column=2) self.row = 3 self.focusbutton = None self.updatesystem() def updatesystem(self, event=None): try: self.advlabel.grid_forget() self.advwidget.grid_forget() self.Vdarlabel.grid_forget() self.Vdarwidget.grid_forget() self.Vdarunits.grid_forget() self.Vtidallabel.grid_forget() self.Vtidalwidget.grid_forget() self.Vtidalunits.grid_forget() self.ptidallabel.grid_forget() self.ptidalwidget.grid_forget() self.ptidalunits.grid_forget() self.biolabel.grid_forget() self.biowidget.grid_forget() self.sigmalabel.grid_forget() self.sigmawidget.grid_forget() self.hbiolabel.grid_forget() self.hbiowidget.grid_forget() self.hbiounits.grid_forget() self.Dbioplabel.grid_forget() self.Dbiopwidget.grid_forget() self.Dbiopunits.grid_forget() self.Dbiopwlabel.grid_forget() self.Dbiopwwidget.grid_forget() self.Dbiopwunits.grid_forget() self.conlabel.grid_forget() self.conwidget.grid_forget() self.hconlabel.grid_forget() self.hconwidget.grid_forget() self.hconunits.grid_forget() self.t90label.grid_forget() self.t90widget.grid_forget() self.t90units.grid_forget() except: pass row = self.row self.advlabel.grid(row=row, column=0, sticky='E', padx=4) self.advwidget.grid(row=row, column=1, sticky='W', padx=4, columnspan=2) row = row + 1 if self.adv.get() == self.advs[1] or self.adv.get() == self.advs[2]: self.Vdarlabel.grid(row=row, column=0, sticky='E', padx=4) self.Vdarwidget.grid(row=row, column=1, pady=1) self.Vdarunits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 if self.adv.get() == self.advs[2]: self.Vtidallabel.grid(row=row, column=0, sticky='E', padx=4) self.Vtidalwidget.grid(row=row, column=1, pady=1) self.Vtidalunits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 self.ptidallabel.grid(row=row, column=0, sticky='E', padx=4) self.ptidalwidget.grid(row=row, column=1, pady=1) self.ptidalunits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 self.biolabel.grid(row=row, column=0, sticky='E', padx=4) self.biowidget.grid(row=row, column=1, sticky='W', padx=4, columnspan=2) row = row + 1 if self.bio.get() == self.bios[1]: self.hbiolabel.grid(row=row, column=0, sticky='E', padx=4) self.hbiowidget.grid(row=row, column=1, pady=1) self.hbiounits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 if self.bio.get() == self.bios[2]: self.sigmalabel.grid(row=row, column=0, sticky='E', padx=4) self.sigmawidget.grid(row=row, column=1, pady=1) self.hbiounits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 if self.bio.get() == self.bios[1] or self.bio.get() == self.bios[2]: self.Dbioplabel.grid(row=row, column=0, sticky='E', padx=4) self.Dbiopwidget.grid(row=row, column=1, pady=1) self.Dbiopunits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 self.Dbiopwlabel.grid(row=row, column=0, sticky='E', padx=4) self.Dbiopwwidget.grid(row=row, column=1, pady=1) self.Dbiopwunits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 self.conlabel.grid(row=row, column=0, sticky='E', padx=4) self.conwidget.grid(row=row, column=1, sticky='W', padx=4, columnspan=2) row = row + 1 if self.con.get() == self.cons[1]: self.hconlabel.grid(row=row, column=0, sticky='E', padx=4) self.hconwidget.grid(row=row, column=1, pady=1) self.hconunits.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 self.t90label.grid(row=row, column=0, sticky='E', padx=4) self.t90widget.grid(row=row, column=1, pady=1) self.t90units.grid(row=row, column=2, sticky='W', padx=4) row = row + 1 self.blank4.grid(row=row) row = row + 1 self.focusbutton = None self.master.geometry() def error_check(self, event=None): """Finish and move on. Checks that the number chemicals are less than the total number of chemicals in database.""" error = 0 #if self.bio.get() == self.bios[1] and self.hbio.get() > self.toplayer_h: error = 1 return error def warning(self): tkmb.showerror( title=self.version, message='The bioturbation ' + 'depth (%.1f cm) ' % self.hbio.get() + 'cannot exceed the ' + 'thickness of the top layer (%.1f). ' % self.toplayer_h + 'Automatically increasing ' + 'the thickness of the top layer to the bioturbation ' + 'depth.') self.hbio.set(self.toplayer_h) self.focusbutton = None self.master.tk.lift()
class DPSinterface: """ DSPinterface is a Tk graphical interface to drive a DPS power supplier. """ def __init__(self, root): """ Create a DSP interface instance. :param root: is the Tk() interface where the DPS will be drawedstring with the prot name i.e. /dev/ttyUSB0 or COM5 for Windows :returns: a new instance of DPS graphical interface """ self.root = root root.title("DPS power supplier interface") root.protocol("WM_DELETE_WINDOW", self.wnwcmdclose) self.dps = None self.poller = None self.waver = None self.strtme = time() self.dpsfwave = None self.maxoutv = 5 self.maxoutc = 5 menubar = Menu(root) filemenu = Menu(menubar, tearoff=0) filemenu.add_command(label="Exit", command=self.wnwcmdclose) menubar.add_cascade(label="File", menu=filemenu) scopemenu = Menu(menubar, tearoff=0) scopemenu.add_command(label="Load sampled points...", command=self.mnucmdloadsmppts) scopemenu.add_command(label="Save sampled points as...", command=self.mnucmdsavesmppts) menubar.add_cascade(label="Scope", menu=scopemenu) wavemenu = Menu(menubar, tearoff=0) wavemenu.add_command(label="New wave", command=self.mnucmdnewwve) wavemenu.add_command(label="Load wave...", command=self.mnucmdloadwve) wavemenu.add_command(label="Edit wave...", command=self.mnucmdedtwve) wavemenu.add_command(label="Save wave as...", command=self.mnucmdsavewve) menubar.add_cascade(label="Wave", menu=wavemenu) memmenu = Menu(menubar, tearoff=0) memmenu.add_command(label="Edit memories...", command=self.mnucmdedtmem) menubar.add_cascade(label="Memory", menu=memmenu) helpmenu = Menu(menubar, tearoff=0) helpmenu.add_command(label="Help...", command=self.mnucmdhelp) helpmenu.add_command(label="About...", command=self.mnucmdabout) menubar.add_cascade(label="Help", menu=helpmenu) root.config(menu=menubar) row = 0 col = 0 rowspan = 1 colspan = 1 insertlabelrow(root, row, col, ("Serial: ", None, "Addr,Baud: "), E) col += colspan self.svardpsport = StringVar() self.svardpsport.set('/dev/ttyUSB0') self.entryserport = Entry(root, textvariable=self.svardpsport, width=ENTRYWIDTH, justify='right') self.entryserport.grid(row=row, column=col, sticky=W) col += colspan col += colspan self.svardpsaddbrt = StringVar() self.svardpsaddbrt.set('1, 9600') self.entrydpsadd = Entry(root, textvariable=self.svardpsaddbrt, width=ENTRYWIDTH, justify='right') self.entrydpsadd.grid(row=row, column=col, sticky=W) col += colspan colspan = 2 self.ivarconctd = IntVar() self.ivarconctd.set(0) Checkbutton(root, variable=self.ivarconctd, text='Connect', command=self.butcmdconnect).grid(row=row, column=col, columnspan=colspan, sticky=E + W) row += rowspan col = 0 colspan = 1 Separator(root, orient='horizontal').grid(row=row, columnspan=8, sticky=E + W, pady=8) row += rowspan rowspan = 1 colspan = 2 col = 0 self.ivarbrghtnes = IntVar() s = Scale(root, label='Brightness', variable=self.ivarbrghtnes, from_=0, to=5, resolution=1, orient="horizontal") s.bind("<ButtonRelease-1>", self.sclbndbrghtnss) s.grid(row=row, column=col, columnspan=colspan, sticky=E + W) col += colspan colspan = 1 Label(root, text="Model: ").grid(row=row, column=col, sticky=E) col += colspan self.ivarmodel = IntVar() Entry(root, textvariable=self.ivarmodel, state="readonly", width=ENTRYWIDTH, justify='right').grid(row=row, column=col, sticky=W) col += colspan colspan = 2 self.ivarsetmem = IntVar() s = Scale(root, label='Mem Recall', variable=self.ivarsetmem, from_=1, to=9, resolution=1, orient="horizontal") s.bind("<ButtonRelease-1>", self.sclbndmemory) s.grid(row=row, column=col, columnspan=colspan, sticky=E + W) row += rowspan colspan = 1 col = 0 insertlabelrow( root, row, col, (("Vinp [V]: ", VCOL), None, "Out Mode: ", None, "Protection: "), E) self.dvarvinp = DoubleVar() self.svarwrmde = StringVar() self.setworkmode(0) self.svarprot = StringVar() self.setprotection(0) insertentryrow( root, row, col, (None, self.dvarvinp, None, self.svarwrmde, None, self.svarprot), 'right', W, 'readonly') colspan = 1 row += rowspan col = 0 insertlabelrow(root, row, col, (("Vmax [V]: ", VCOL), None, ("Cmax [A]: ", CCOL), None, ("Pmax [W]: ", PCOL)), E) self.dvarvmaxm0 = DoubleVar() self.dvarcmaxm0 = DoubleVar() self.dvarpmaxm0 = DoubleVar() entries = insertentryrow(root, row, col, (None, self.dvarvmaxm0, None, self.dvarcmaxm0, None, self.dvarpmaxm0), 'right', W) for e, f in zip(entries, (self.entbndvmax, self.entbndcmax, self.entbndpmax)): e.bind('<FocusOut>', f) e.bind('<Return>', f) row += rowspan col = 0 insertlabelrow(root, row, col, (("Vout [V]: ", VCOL), None, ("Cout [A]: ", CCOL), None, ("Pout [W]: ", PCOL)), E) self.dvarvout = DoubleVar() self.dvarcout = DoubleVar() self.dvarpout = DoubleVar() insertentryrow( root, row, col, (None, self.dvarvout, None, self.dvarcout, None, self.dvarpout), 'right', W, 'readonly') row += rowspan col = 0 self.scope = Scope(root, [], row, col) row += 9 col = 4 Label(root, text="Rte[s/Sa]: ").grid(row=row, column=col, sticky=E) col += colspan self.dvarsecsmp = DoubleVar() self.dvarsecsmp.set(self.scope.sampletime()) e = Entry(root, textvariable=self.dvarsecsmp, width=ENTRYWIDTH, justify='right').grid(row=row, column=col, sticky=W) row += rowspan col = 0 colspan = 2 self.ivaracquire = IntVar() self.ivaracquire.set(0) Checkbutton(root, variable=self.ivaracquire, text='Run Acquisition', command=self.butcmdacquire).grid(row=row, column=col, columnspan=2, sticky=E + W) col += colspan self.ivarkeylock = IntVar() self.ivarkeylock.set(0) Checkbutton(root, variable=self.ivarkeylock, text="Key Lock", command=self.butcmdkeylock).grid(row=row, column=col, sticky=E + W, columnspan=colspan) col += colspan self.ivaroutenab = IntVar() self.ivaroutenab.set(0) Checkbutton(root, variable=self.ivaroutenab, text="Output Enable", command=self.butcmdoutenable).grid(row=row, column=col, sticky=E + W, columnspan=colspan) row += rowspan col = 0 rowspan = 1 colspan = 3 self.dvarvscale = DoubleVar() self.voltscale = Scale(root, label='Vset [V]', foreground=VCOL, variable=self.dvarvscale, from_=0, to=self.maxoutv, resolution=1, orient="horizontal") #, label='Vset[V]' self.voltscale.bind("<ButtonRelease-1>", self.sclbndvolt) self.voltscale.grid(row=row, column=col, columnspan=colspan, sticky=E + W) col += colspan self.dvarcscale = DoubleVar() self.curntscale = Scale(root, label='Cset[A]', foreground=CCOL, variable=self.dvarcscale, from_=0, to=self.maxoutc, resolution=1, orient="horizontal") #,label='Cset[A]' self.curntscale.bind("<ButtonRelease-1>", self.sclbndcrnt) self.curntscale.grid(row=row, column=col, columnspan=colspan, sticky=E + W) row += rowspan col = 0 self.dvarvscalef = DoubleVar() sc = Scale(root, foreground=VCOL, variable=self.dvarvscalef, from_=0, to=0.99, resolution=0.01, orient="horizontal") sc.bind("<ButtonRelease-1>", self.sclbndvolt) sc.grid(row=row, column=col, columnspan=colspan, sticky=E + W) col += colspan self.dvarcscalef = DoubleVar() sc = Scale(root, foreground=CCOL, variable=self.dvarcscalef, from_=0, to=0.99, resolution=0.01, orient="horizontal") sc.bind("<ButtonRelease-1>", self.sclbndcrnt) sc.grid(row=row, column=col, columnspan=colspan, sticky=E + W) row += rowspan col = 0 colspan = 1 Separator(root, orient='horizontal').grid(row=row, columnspan=6, sticky=E + W, pady=8) row += rowspan colspan = 1 col = 0 Label(root, text="Waveform: ").grid(row=row, column=col, sticky=E) col += colspan colspan = 2 self.svarwave = StringVar() Entry(root, textvariable=self.svarwave, width=ENTRYWIDTH, justify='right', state='readonly').grid(row=row, column=col, columnspan=colspan, sticky=E + W) col += colspan colspan = 1 self.ivarplaywv = IntVar() self.ivarplaywv.set(0) Checkbutton(root, variable=self.ivarplaywv, text='Play', command=self.butcmdplaywave).grid(row=row, column=col, sticky=E + W) col += colspan self.ivarpausewv = IntVar() self.ivarpausewv.set(0) Checkbutton(root, variable=self.ivarpausewv, text='Pause', command=self.butcmdpausewave).grid(row=row, column=col, sticky=E + W) col += colspan self.ivarloopwv = IntVar() self.ivarloopwv.set(0) Checkbutton(root, variable=self.ivarloopwv, text='Loop').grid(row=row, column=col, sticky=E + W) self.scope.update() self.scope.redraw() def sclbndvolt(self, event): """ Voltage scale bind command to set the voltage on the DSP. :param event: the event describing what changed """ if self.isconnected(): self.dps.set(['vset'], [self.getvscale()]) def sclbndcrnt(self, event): """ Current scale bind command to set the current on the DSP. :param event: the event describing what changed """ if self.isconnected(): self.dps.set(['cset'], [self.getcscale()]) def sclbndmemory(self, event): """ Memory-set bind command to set the memory on the DSP. :param event: the event describing what changed """ if self.isconnected(): m = self.ivarsetmem.get() self.dps.set(['mset'], [m]) self.updatefields(True) def sclbndbrghtnss(self, event): """ Brightness bind command to set the brightness on the DSP. :param event: the event describing what changed """ if self.isconnected(): b = self.ivarbrghtnes.get() self.dps.set(['brght'], [b]) def mnucmdnewwve(self): """ New wave menu command to initialize a new wave. """ self.dpsfwave = Dpsfile() self.svarwave.set('unnamed') def mnucmdloadwve(self): """ Load wave menu command to load a wave file. """ fname = tkFileDialog.askopenfilename(initialdir=".", title="Select wave file to load", filetypes=(("dps files", "*.dps"), ("all files", "*.*"))) if fname: self.svarwave.set(os.path.basename(fname)) self.dpsfwave = Dpsfile() self.dpsfwave.load(fname) def mnucmdedtwve(self): """ Edit wave menu command to open the edit wave window. """ if self.dpsfwave is not None: Wveinterface(self.root, self.dpsfwave.getpoints()) else: tkMessageBox.showinfo('No wave loaded', 'Load or create a new wave file to modify') def mnucmdsavewve(self): """ Save wave menu command to save the current wave in memory. """ if self.dpsfwave is not None: fname = tkFileDialog.asksaveasfilename( initialdir=".", title="Select wave file to save", filetypes=(("dps files", "*.dps"), ("all files", "*.*"))) if fname: self.dpsfwave.save(fname) self.svarwave.set(os.path.basename(fname)) else: tkMessageBox.showinfo('No wave in memory', 'Load or create a wave file to modify') def mnucmdloadsmppts(self): """ Load sampled points menu command to load in the graphical view sampled before. """ fname = tkFileDialog.askopenfilename(initialdir=".", title="Select data file to load", filetypes=(("dps files", "*.dps"), ("all files", "*.*"))) if fname: self.scope.load(fname) def mnucmdsavesmppts(self): """ Save sampled points menu command to save the last points sampled showed in the graphical view. """ fname = tkFileDialog.asksaveasfilename( initialdir=".", title="Select data file to save", filetypes=(("dps files", "*.dps"), ("all files", "*.*"))) if fname: self.scope.save(fname) def mnucmdedtmem(self): """ Memory menu command to edit the values of preset memories on DSP. """ if self.isconnected(): Meminterface(self.root, self.dps, self.updatefields) def mnucmdabout(self): """ About menu command to show the window with program information. """ Txtinterface( self.root, 'About', """DPS interface is designed by Simone Pernice That project was born as a textual driver to interface any DPS device. After the driver I made also a graphical interface to manage DPS devices. This project was born because I was not able to find any Linux application to manage DPS devices via USB. For question email to me: [email protected] Version {} relesed on {} First release on 3rd February 2019 Turin Italy DPS interface is under licence {} If you like this program please make a donation with PayPal to [email protected]""" .format(__version__, __date__, __license__)) def mnucmdhelp(self): """ Help menu command to show basic help on usage. """ Txtinterface( self.root, 'Help', """This is an interface to remote controll a power supplier of DPS series. The white fields can be edited, the gray are read only. To connect to DPS power supplier first link it to the PC through an USB cable. The data required to connect is on the first row of the graphical interface. Write the serial address on the first field (COMxx for Windows or /dev/ttyUSBx for Linux). Address and baudrate do not require update because they are the default for DPS power supplier. Turn on DPS with up key pressed to change those values. Press 'Connect' check button and if the device is present it is linked. Press again the same check button to disconnect the DPS. Once the link to DPS is in place all the data on the interface are updated and on the DPS the keylock is set. The second block of graphical interface contains all data about DPS. The brightness set which can be changed through the scale regulation. The model number. The memory from which recall the preset parameters. The input voltage, the output mode cv (constant voltage) or cc (constant current). The protection mode: none (no protection triggered), ovp (over voltage protection), ocp (over current protection), opp (over power protection). The maximum voltage, current and power to provide before triggering the self protection. The next row contains output voltage, current and power in textual form. A time diagram of the DPS output voltage, current and power is avaiable. It is possible to play with the mouse on that screen: - wheel press to fit in the screen all the enabled drawings - wheel to zoom in time - shift+wheel to zoom on Y for the highlighted curves - ctrl+wheel to change the enabled curves - left button drag to move the highlighted curve The same mouse functions are available in the fields below the diagram: - voltage per division, current per division and watt per division - zero position for voltage, current and power - check button to view voltage, current and power - time: second per divisions and zero position for time The sample time is used for the acquisition. DPS is quite slot, the minimum read time is around 1 second. The suggested rate is to have a sample for displayed pixel. The next buttons are: - Run acquisition: starts a thread that read the DPS status, update the interface fields as well as the time diagram. The acquisition points can be saved and loaded to be showed lated with menu commands on DPS scope load/save. They can be also edited through the wave edit window and played. - Key lock: set or reset the DPS key lock. It should be on in order to have faster communication. If key lock is on less fields of DPS are read since user can change them only through the PC interface. - Output enable to enable the DPS output Eventually there are the voltage and current scale. Thery are split in two: - the first is for coarse (1 unit/step) adjustment the unit of voltage/current - the second is for fine (0.01 unit/step) adjustament of voltage/current On the last block of interface there is a waveform field showing the wave loaded. Wave is a set of required output voltage and current at give timings. It is possible play and pause it through the respective commands of the interface. If loop is set when the wave play is completed it restarts. The acquisition may slow the wave player, use low acquisition sample time to avoid delays.""") def butcmdconnect(self): """ Connect check button command to connect to the DSP. It reads: serial port address, DPS address and serial speed from other interface fields. If it is capable to link to the DPS: - the maximum voltage and current are read and scale maximums set accordingly - the DPS current data are read and set accordingly in the interface - the localDPS interface is locked so that the user cannot change them but has to go through the graphical interface if the DPS is locked the polling is faster because less data needs to be read from DPS - the input fields are disabled """ if self.ivarconctd.get(): try: flds = self.svardpsaddbrt.get().split(',') if len(flds) > 0: ch = int(flds[0]) else: ch = 1 if len(flds) > 1: br = int(flds[1]) else: br = 9600 self.dps = DPSdriver(self.svardpsport.get(), ch, br) except Exception as e: tkMessageBox.showerror('Error', 'Cannot connect: ' + str(e)) self.ivarconctd.set(0) self.dps = None return m = self.dps.get(['model']) m = m[0] self.ivarmodel.set(m) to = m / 100 self.voltscale.config(to=to) self.maxoutv = to to = m % 100 self.curntscale.config(to=to) self.maxoutv = to self.scope.resetpoints() self.ivarkeylock.set(1) self.butcmdkeylock() self.updatefields(True) self.entryserport.config(state='readonly') self.entrydpsadd.config(state='readonly') else: # Stop polling self.ivaracquire.set(0) if self.poller: self.poller.wake() time.sleep(1.) # Wait to be sure the thread exits # Stop waveform generation self.ivarplaywv.set(0) if self.waver: self.waver.wake() time.sleep(1.) # Wait to be sure the thread exits self.dps = None self.entryserport.config(state=NORMAL) self.entrydpsadd.config(state=NORMAL) def butcmdacquire(self): """ Acquire check button command to manage the acquisition thread to read the DSP data. If the button is not selected the thread is lunched. If the button is selected the thread is stopped. """ if self.ivaracquire.get(): if not self.isconnected(): self.ivaracquire.set(0) return self.scope.resetpoints() self.strtme = time() self.poller = Poller(self.ivaracquire, self.dvarsecsmp, self.updatefields) else: self.poller.wake() def butcmdkeylock(self): """ Key lock button command to enable or disable the key lock on DPS remote interface. """ if self.isconnected(): self.dps.set(['lock'], [self.ivarkeylock.get()]) else: self.ivarkeylock.set(0) def butcmdoutenable(self): """ DPS output button command to enable or disable the DPS output power. """ if self.isconnected(): self.dps.set(['onoff'], [self.ivaroutenab.get()]) else: self.ivaroutenab.set(0) def butcmdplaywave(self): """ Wave generator check button command to manage the wave generation thread to make a waveform on the DSP. If the button is not selected the thread is lunched. If the button is selected the thread is stopped. """ if self.ivarplaywv.get(): if not self.isconnected(): self.ivarplaywv.set(0) return if not self.dpsfwave: tkMessageBox.showinfo('No wave in memory', 'Load or create a wave file to modify') self.ivarplaywv.set(0) return if not self.ivaroutenab.get(): self.ivaroutenab.set(1) self.butcmdoutenable() self.waver = Waver(self.setvcdps, self.ivarplaywv, self.ivarpausewv, self.ivarloopwv, self.dpsfwave.getpoints()) else: self.waver.wake() def butcmdpausewave(self): """ Wave generator pause check button command to temporary pause the wave generations. """ self.waver.wake() def wnwcmdclose(self): """ DPS main window close. Before exiting the supplier is disconnected the external supplier. """ if self.ivarconctd.get(): self.ivarconctd.set(0) self.butcmdconnect() self.root.destroy() def entbndvmax(self, event): """ Maximum voltage entry bind to set the protection maximum ouput voltage of the DSP. :param event: the event describing what changed """ if self.isconnected(): if self.dvarvmaxm0.get() > self.maxoutv * PROTEXCEED: self.dvarvmaxm0.set(self.maxoutv * PROTEXCEED) elif self.dvarvmaxm0.get() < 0.: self.dvarvmaxm0.set(0.) self.dps.set(['m0ovp'], [self.dvarvmaxm0.get()]) def entbndcmax(self, event): """ Maximum current entry bind to set the protection maximum output curret of the DSP. :param event: the event describing what changed """ if self.isconnected(): if self.dvarcmaxm0.get() > self.maxoutc * PROTEXCEED: self.dvarcmaxm0.set(self.maxoutc * PROTEXCEED) elif self.dvarcmaxm0.get() < 0.: self.dvarcmaxm0.set(0.) self.dps.set(['m0ocp'], [self.dvarcmaxm0.get()]) def entbndpmax(self, event): """ Maximum power entry bind to set the protection maximum output power of the DSP. :param event: the event describing what changed """ if self.isconnected(): if self.dvarpmaxm0.get( ) > self.maxoutv * self.maxoutc * PROTEXCEED * PROTEXCEED: self.dvarpmaxm0.set(self.maxoutv * self.maxoutc * PROTEXCEED * PROTEXCEED) elif self.dvarpmaxm0.get() < 0.: self.dvarcmaxm0.set(0.) self.dps.set(['m0opp'], [self.dvarpmaxm0.get()]) def setvcdps(self, v, c): """ Set the DPS output voltage and current moving their scales accordingly. :param v: the required voltage, if negative it is not changed :param c: the required current, if negative it is not changed """ if v >= 0: if c >= 0: self.setvscale(v) self.setcscale(c) self.dps.set(['vset', 'cset'], [v, c]) else: self.setvscale(v) self.dps.set(['vset'], [v]) elif c >= 0: self.setcscale(c) self.dps.set(['cset'], [c]) def isconnected(self): """ Check if the DPS is connected, if not display a message. :returns: True if connected, False if not """ if self.dps is None: tkMessageBox.showinfo('Not connected', 'Enstablish a connection before') return False return True def setvscale(self, v): """ Set the voltage scale, nothing is changed on the DPS. :param v: the voltage to set """ if v > self.maxoutv: v = self.maxoutv elif v < 0: v = 0 self.dvarvscale.set(int(v)) self.dvarvscalef.set(round(v - int(v), 2)) def getvscale(self): """ Get the voltage scale set value. :returns: the voltage set """ return self.dvarvscale.get() + self.dvarvscalef.get() def setcscale(self, c): """ Set the current scale, nothing is changed on the DPS. :param c: the current to set """ if c > self.maxoutc: c = self.maxoutc elif c < 0: c = 0 self.dvarcscale.set(int(c)) self.dvarcscalef.set(round(c - int(c), 2)) def getcscale(self): """ Get the current scale set value. :returns: the current set """ return self.dvarcscale.get() + self.dvarcscalef.get() def updatefields(self, forcereadall=False): """ Reads data stored in DPS and updates the interface fields accordingly. In order to be as fast as possible, if keylock is enabled, reads only the fields that can change without uses access. If keylock is disabled all the fields are read because user may have changed something from the interface. :param forcereadall: if True read and update all the DPS fields regardless of the keylock status :returns: the point read. A point is made by (time, voltage, current, power) """ if not forcereadall and self.ivarkeylock.get( ): # If user keep locked fewer data are read, otherwise all data = self.dps.get( ['vout', 'cout', 'pout', 'vinp', 'lock', 'prot', 'cvcc']) self.dvarvout.set(data[0]) self.dvarcout.set(data[1]) self.dvarpout.set(data[2]) self.dvarvinp.set(data[3]) self.ivarkeylock.set(data[4]) self.setprotection(data[5]) self.setworkmode(data[6]) vcp = data[0:3] else: # All data is read data = self.dps.get([ 'vset', 'cset', 'vout', 'cout', 'pout', 'vinp', 'lock', 'prot', 'cvcc', 'onoff', 'brght', 'mset', 'm0ovp', 'm0ocp', 'm0opp' ]) self.setvscale(data[0]) self.setcscale(data[1]) self.dvarvout.set(data[2]) self.dvarcout.set(data[3]) self.dvarpout.set(data[4]) self.dvarvinp.set(data[5]) self.ivarkeylock.set(data[6]) self.setprotection(data[7]) self.setworkmode(data[8]) self.ivaroutenab.set(data[9]) self.ivarbrghtnes.set(data[10]) self.ivarsetmem.set(data[11]) self.dvarvmaxm0.set(data[12]) self.dvarcmaxm0.set(data[13]) self.dvarpmaxm0.set(data[14]) vcp = data[2:5] vcp.insert(TPOS, time() - self.strtme) self.scope.addpoint(vcp) return vcp def setprotection(self, p): """ Set the protection field with an user readable string explaining the DPS protection status. :param p: the protection statu returned by the DPS """ self.svarprot.set({0: 'none', 1: 'ovp', 2: 'ocp', 3: 'opp'}[p]) def setworkmode(self, wm): """ Set the workmode field with an user readable string explaining the DPS work mode. :param wm: the working mode returned by the DPS """ self.svarwrmde.set({0: 'cv', 1: 'cc'}[wm])
class plotter(Frame): def __init__(self,mainframe): # Initiate t a blank figure self.figure_created=False # A bool to represent if the figure was created or not self.mainframe=mainframe # Asign a variable ofr the aminframe self.fig=Figure() # This is a dummy figure that will be overwrited but it will grant the space for the real one self.canvas=FigureCanvasTkAgg(self.fig,master=mainframe) # The canvas where all the plots will be made self.canvas.show() self.canvas.get_tk_widget().grid(column=5,row=0,rowspan=12,columnspan=4) # Create the widget that will mange the pots # Create the number of columns and rows ttk.Label(mainframe,text="Set number of columns ").grid(column=0,row=0) self.total_columns=IntVar() # The variable that will store the number of total columns self.total_columns.set(1) # We give it an initial value # Combobox with the Possible values for the total number of columns in the main figure self.box_total_columns=ttk.Combobox(mainframe,textvariable=self.total_columns,state="readonly",width=3) self.box_total_columns['values']=range(1,10) self.box_total_columns.grid(column=1,row=0) ttk.Label(mainframe,text=" Set number of rows ").grid(column=2,row=0) # The same taht with the columns but with the rows self.total_rows=IntVar() self.total_rows.set(1) self.box_total_rows=ttk.Combobox(mainframe,textvariable=self.total_rows,state="readonly",width=3) self.box_total_rows['values']=range(1,10) self.box_total_rows.grid(column=3,row=0) # Create the figure with the subplots ttk.Button(mainframe,command=self.init_program,text="Create").grid(column=4,row=0) # This button will initiate all the features # The next lines will allow to change between the subplots ttk.Label(mainframe,text="Select Column ").grid(column=0,row=1) self.current_column=IntVar() # The variable storing the current Column # The next lines will setup the combobox for making this change self.box_current_column=ttk.Combobox(mainframe,textvariable=self.current_column,state="readonly",width=3) self.box_current_column["values"]=["--"] self.box_current_column.grid(column=1,row=1) ttk.Label(mainframe,text=" Select Row ").grid(column=2,row=1) self.current_row=IntVar() # The variable storing th current row self.box_current_row=ttk.Combobox(mainframe,textvariable=self.current_row,state="readonly",width=3) self.box_current_row["values"]=["--"] self.box_current_row.grid(column=3,row=1) self.box_current_row.bind("<<ComboboxSelected>>",self.change_subplot) # Now we make that when you choose one column or a row self.box_current_column.bind("<<ComboboxSelected>>",self.change_subplot) # the prgram will auto load the presets for that subplot # Open File ttk.Button(mainframe,text="Open file",command=self.open_file).grid(column=0,row=3) self.filename=StringVar() # Variable to store the path to the data file self.entry_filename=ttk.Entry(mainframe,textvar=self.filename,width=30).grid(column=1,row=3,columnspan=3,sticky=E) # Options for the plot # The label for the legend self.label=StringVar() # Variable storing the label ttk.Label(mainframe,text="Label").grid(column=0,row=4) ttk.Entry(mainframe,textvar=self.label,width=30).grid(column=1,row=4,columnspan=3,sticky=E) # Entry to enter the label # Select The column where the data is stored in the file self.column_x=IntVar() # This variable stores the column where the x data is in the file (0 is the first one) self.column_x.set(0) # Give the variable an initial value self.column_y=IntVar() # This variable stores the column where the y data is in the file (0 is the first one) self.column_y.set(1) # Give the variable an initial value ttk.Label(text="Column for x data").grid(column=0,row=5) ttk.Entry(textvar=self.column_x,width=3).grid(column=1,row=5) ttk.Label(text="Column for y data").grid(column=2,row=5) ttk.Entry(textvar=self.column_y,width=3).grid(column=3,row=5) # Combobox for selecting the maker self.marker=StringVar() # Variable storing the marker configuration self.marker.set("None") # The preset value for the marker (no marker on the points) ttk.Label(mainframe,text="Marker").grid(column=0,row=6) combo_marker=ttk.Combobox(mainframe,textvariable=self.marker,state="readonly",width=5) combo_marker["values"]=["None",".",",","o","+","*",'x',"custom"] # Since there is quite a lot of markers i only preload the combo_marker.grid(column=1,row=6) # esentials, but with the option custom it's posible to use wichever matplotlib supports self.marker_custom=StringVar() # Variable storing the marker type ttk.Entry(mainframe,textvar=self.marker_custom,width=5).grid(column=3,row=6,sticky=E) # Entry for the option of the custom ttk.Button(mainframe,text="Custom Marker",command=self.set_custom_marker).grid(column=2,row=6) # Button to aply the custom config # Combobox for the line Style self.linestyle=StringVar() # Variable storing the linestyle configuration self.linestyle.set("-") # Preset value for the linestyle (solid line) ttk.Label(mainframe,text="Line Style").grid(column=0,row=7) combo_linestyle=ttk.Combobox(mainframe,textvariable=self.linestyle,state="readonly",width=5) combo_linestyle["values"]=["None","-","--","-.",":"] # Those are all the posible options for the linestyle combo_linestyle.grid(column=1,row=7) # Change the color, this is a test version for a quick need ttk.Label(mainframe,text="Color").grid(column=2,row=7) self.color=StringVar() ttk.Entry(textvar=self.color,width=5).grid(column=3,row=7) # Change the axis labels ttk.Label(mainframe,text="X axis Label").grid(column=0,row=8,columnspan=2) ttk.Label(mainframe,text="Y axis Label").grid(column=2,row=8,columnspan=2) self.x_label=StringVar() # Variable storing the label for the x axis self.y_label=StringVar() # Variable storing the label for the y axis ttk.Entry(mainframe,textvar=self.x_label).grid(column=0,row=9,columnspan=2) ttk.Entry(mainframe,textvar=self.y_label).grid(column=2,row=9,columnspan=2) ttk.Button(mainframe,text="Update Labels",command=self.update_labels).grid(column=4,row=8) # This button aplies the labels in the axis # Limits for the x and y axes # Label with information ttk.Label(text="Minimun Value of the axis").grid(column=0,row=10,columnspan=2) ttk.Label(text="Minimun Value of the axis").grid(column=2,row=10,columnspan=2) self.xmin=DoubleVar() # Variable with the value of the minimun x self.xmax=DoubleVar() # Variable with the value of the maximun x self.ymin=DoubleVar() # Variable with the value of the minimun y self.ymax=DoubleVar() # Variable with the value of the maximun y ttk.Entry(mainframe,textvar=self.xmin).grid(column=0,row=11,columnspan=2) # Entry for the minimal value ttk.Entry(mainframe,textvar=self.xmax).grid(column=2,row=11,columnspan=2) # Entry for the maximun value ttk.Button(mainframe,text="x axis",command=self.change_x_axe).grid(column=4,row=11) # Update x axe ttk.Entry(mainframe,textvar=self.ymin).grid(column=0,row=12,columnspan=2) # The same for the y axis ttk.Entry(mainframe,textvar=self.ymax).grid(column=2,row=12,columnspan=2) ttk.Button(mainframe,text="y axis",command=self.change_y_axe).grid(column=4,row=12) # Make the plot ttk.Button(mainframe,text="Plot",command=self.make_plot).grid(column=0,row=13) # Save the figure ttk.Button(mainframe,text="Save",command=self.save_plot).grid(column=1,row=13) # Options of subplots # Reset one of the subplots ttk.Button(mainframe,text="Reset Subplot",command=self.reset_subplot).grid(column=4,row=1) # Export a configuration file of the plots, this will allow to redo the figure ttk.Button(mainframe,text="Export",command=self.export_logfile).grid(column=2,row=13) # Import a configuration file of the plots, this will allow to redo a previous exported figure using the logfile ttk.Button(mainframe,text="import",command=self.read_logfile).grid(column=3,row=13) # Join the x axis ttk.Button(mainframe,text="join x axes",command=self.fix_x_ticks).grid(column=5,row=12) ttk.Button(mainframe,text="join y axes",command=self.fix_y_ticks).grid(column=6,row=12) ttk.Button(mainframe,text="join x and y axes",command=self.fix_x_and_y_ticks).grid(column=7,row=12) def init_program(self,*args): # This functions set all the presets for the program to work self.create_subplots() # First we create the subplots required by self.total_rows/columns self.current_column.set(1) # We set the focus on the self.current_row.set(1) # (1,1) subplot (remember that we start to count in 1 ,not 0. self.change_subplot() # Aply the changes in the focus of the subplot def create_subplots(self,*args): self.sharex=True self.sharey=False # This function will create the subplot axes, and the needed variables self.fig=Figure() # This will replace the figure in the main routine (its necesary to change the size of the figure without closing # the program self.canvas=FigureCanvasTkAgg(self.fig,master=self.mainframe) # We have to redefine the canvas self.canvas.show() self.canvas.get_tk_widget().grid(column=5,row=0,rowspan=12,columnspan=4) self.axes=[[]] # This variable will store the axes of each subplots. Th axe os a subplot is what allow to make the plot in that subplot # self.fig.subplots_adjust(hspace=0.001) self.file_index=[[]] # This will save wich data files were plotted in each subplot, its necessary in order to write the logfile self.label_index=[[]] # This variable store the labels for making the logfile self.marker_index=[[]] # This one store the marker for each data set self.linestyle_index=[[]] # This one stores line style self.color_index=[[]] # This one stores the color self.xcolumn_index=[[]] # This one store the column of the file used as x data self.xlabel_index=[[]] # This will save the labels used for the x axis self.ycolumn_index=[[]] # This one store the column of the file used as y data self.ylabel_index=[[]] # This will save the labels used for the y axis self.xlimit_index=[[]] self.ylimit_index=[[]] # Now we will append an axe inside self.axes for each subplot, it will be stored so it is accesible with [row][column] # We need to append also a list for each subplot in the other variables for j in range(self.total_columns.get()): # First we make a lopp throw the first row self.axes[0].append(self.fig.add_subplot(self.total_rows.get(),self.total_columns.get(),j+1)) # Append an axe subplot in each column self.file_index[0].append([]) # Append a list for each column self.label_index[0].append([]) self.marker_index[0].append([]) self.linestyle_index[0].append([]) self.color_index[0].append([]) self.xcolumn_index[0].append([]) self.ycolumn_index[0].append([]) self.xlabel_index[0].append("") # Append a blank string for each column self.ylabel_index[0].append("") # Append a blank string for each column self.xlimit_index[0].append(["",""]) self.ylimit_index[0].append(["",""]) if (self.total_rows.get()-1)!=0: # If we have more than one row we repeat the previous steps for each row for i in range(1,self.total_rows.get()): self.axes.append([]) # We need to append a list for each row here self.file_index.append([]) # also in this one self.label_index.append([]) # And this one self.marker_index.append([]) # and this one self.linestyle_index.append([]) # and this one self.xcolumn_index.append([]) self.ycolumn_index.append([]) self.color_index.append([]) self.xlabel_index.append([]) self.ylabel_index.append([]) self.xlimit_index.append([]) self.ylimit_index.append([]) for j in range(self.total_columns.get()): # The next steps are the same than in the previous loop self.axes[i].append(self.fig.add_subplot(self.total_rows.get(),self.total_columns.get(),1+j+self.total_columns.get()*i)) self.file_index[i].append([]) self.label_index[i].append([]) self.marker_index[i].append([]) self.linestyle_index[i].append([]) self.color_index[i].append([]) self.xlabel_index[i].append("") self.xcolumn_index[i].append([]) self.ycolumn_index[i].append([]) self.ylabel_index[i].append("") self.xlimit_index[i].append(["",""]) self.ylimit_index[i].append(["",""]) self.fig.tight_layout() # We let maplotlib to optimize the space around the subplots # for i in range(self.total_rows.get()-1): # self.axes[0][0].xaxis.set_visible(False) self.canvas.draw() # We draw the changes, now the main figure is divided in the subplots self.box_current_column["values"]=range(1,self.total_columns.get()+1) # Update the possible values in the combobox self.box_current_row["values"]=range(1,self.total_rows.get()+1) # of the columns and rows to make the change posiible self.figure_created=True # We save that we have created a figure with subplots def stick_x_axis(self,*args): # This function will create the subplot axes, and the needed variables self.fig=Figure() # This will replace the figure in the main routine (its necesary to change the size of the figure without closing # the program self.canvas=FigureCanvasTkAgg(self.fig,master=self.mainframe) # We have to redefine the canvas self.canvas.show() self.canvas.get_tk_widget().grid(column=5,row=0,rowspan=12) self.axes=[[]] # This variable will store the axes of each subplots. Th axe os a subplot is what allow to make the plot in that subplot self.file_index=[[]] # This will save wich data files were plotted in each subplot, its necessary in order to write the logfile self.label_index=[[]] # This variable store the labels for making the logfile self.marker_index=[[]] # This one store the marker for each data set self.linestyle_index=[[]] # This one stores line style self.color_index=[[]] self.xcolumn_index=[[]] self.ycolumn_index=[[]] self.xlabel_index=[[]] # This will save the labels used for the x axis self.ylabel_index=[[]] # This will save the labels used for the y axis self.xlimit_index=[[]] self.ylimit_index=[[]] # Now we will append an axe inside self.axes for each subplot, it will be stored so it is accesible with [row][column] # We need to append also a list for each subplot in the other variables for j in range(self.total_columns.get()): # First we make a lopp throw the first row self.axes[0].append(self.fig.add_subplot(self.total_rows.get(),self.total_columns.get(),j+1)) # Append an axe subplot in each column self.file_index[0].append([]) # Append a list for each column self.label_index[0].append([]) self.marker_index[0].append([]) self.linestyle_index[0].append([]) self.color_index[0].append([]) self.xcolumn_index[0].append([]) self.ycolumn_index[0].append([]) self.xlabel_index[0].append("") # Append a blank string for each column self.ylabel_index[0].append("") # Append a blank string for each column self.xlimit_index[0].append(["",""]) self.ylimit_index[0].append(["",""]) if (self.total_rows.get()-1)!=0: # If we have more than one row we repeat the previous steps for each row for i in range(1,self.total_rows.get()): self.axes.append([]) # We need to append a list for each row here self.file_index.append([]) # also in this one self.label_index.append([]) # And this one self.marker_index.append([]) # and this one self.linestyle_index.append([]) # and this one self.color_index.append([]) self.xcolumn_index.append([]) self.ycolumn_index.append([]) self.xlabel_index.append([]) self.ylabel_index.append([]) self.xlimit_index.append([]) self.ylimit_index.append([]) for j in range(self.total_columns.get()): # The next steps are the same than in the previous loop self.axes[i].append(self.fig.add_subplot(self.total_rows.get(),self.total_columns.get(),1+j+self.total_columns.get()*i)) self.file_index[i].append([]) self.label_index[i].append([]) self.marker_index[i].append([]) self.linestyle_index[i].append([]) self.color_index[i].append([]) self.xcolumn_index[i].append([]) self.ycolumn_index[i].append([]) self.xlabel_index[i].append("") self.ylabel_index[i].append("") self.xlimit_index[i].append(["",""]) self.ylimit_index[i].append(["",""]) self.fig.tight_layout() # We let maplotlib to optimize the space around the subplots self.canvas.draw() # We draw the changes, now the main figure is divided in the subplots self.box_current_column["values"]=range(1,self.total_columns.get()+1) # Update the possible values in the combobox self.box_current_row["values"]=range(1,self.total_rows.get()+1) # of the columns and rows to make the change posiible self.figure_created=True # We save that we have created a figure with subplots def fix_x_ticks(self,*args): # First set for the maximun of each column and set all the graphs to it for j in range(self.total_columns.get()): max=self.axes[0][j].xaxis.get_majorticklocs()[-1] min=self.axes[0][j].xaxis.get_majorticklocs()[0] for i in range(1,self.total_rows.get()): if (self.axes[i][j].xaxis.get_majorticklocs()[-1]>max): max=self.axes[i][j].xaxis.get_majorticklocs()[-1] if self.axes[i][j].xaxis.get_majorticklocs()[0]<min: min=self.axes[i][j].xaxis.get_majorticklocs()[0] for u in range(self.total_rows.get()): self.axes[i][j].set_xlim([min,max]) for i in range(self.total_rows.get()-1): for j in range(self.total_columns.get()): # self.axes[i][j].xaxis.set_visible(False) self.axes[i][j].set_xticklabels('') self.axes[i+1][j].get_shared_x_axes().join(self.axes[0][j],self.axes[i+1][j]) for j in range(self.total_columns.get()): label=(self.axes[0][j].yaxis.get_majorticklocs()) self.axes[0][j].set_yticklabels(label) for i in range(1,self.total_rows.get()): for j in range(self.total_columns.get()): label=(self.axes[i][j].yaxis.get_majorticklocs()) label=label[0:-1] self.axes[i][j].set_yticklabels(label) self.fig.tight_layout() self.fig.subplots_adjust(hspace=0.001) self.canvas.draw() def fix_y_ticks(self,*args): # First search for the maximun and minimun of y in each row: for i in range(self.total_rows.get()): max=self.axes[i][0].yaxis.get_majorticklocs()[-1] min=self.axes[i][0].yaxis.get_majorticklocs()[0] for j in range(1,self.total_columns.get()): if (self.axes[i][j].yaxis.get_majorticklocs()[-1]>max): max=self.axes[i][j].yaxis.get_majorticklocs()[-1] if self.axes[i][j].yaxis.get_majorticklocs()[0]<min: min=self.axes[i][j].yaxis.get_majorticklocs()[0] for j in range(self.total_columns.get()): self.axes[i][j].set_ylim([min,max]) for i in range(self.total_rows.get()): for j in range(self.total_columns.get()-1): # self.axes[i][j].xaxis.set_visible(False) self.axes[i][j+1].get_shared_y_axes().join(self.axes[i][0],self.axes[i][j+1]) self.axes[i][j+1].set_yticklabels('') self.axes[i][j+1].get_shared_y_axes().join(self.axes[i][0],self.axes[i][j+1]) for i in range(self.total_rows.get()): label=(self.axes[i][-1].xaxis.get_majorticklocs()) self.axes[i][0].set_xticklabels(label) for i in range(self.total_rows.get()): for j in range(self.total_columns.get()-1): label=(self.axes[i][j].xaxis.get_majorticklocs()) label=label[0:-1] self.axes[i][j].set_xticklabels(label) self.fig.tight_layout() self.fig.subplots_adjust(wspace=0.001) self.canvas.draw() def fix_x_and_y_ticks(self,*args): # First set for the maximun of each column and set all the graphs to it for j in range(self.total_columns.get()): max=self.axes[0][j].xaxis.get_majorticklocs()[-1] min=self.axes[0][j].xaxis.get_majorticklocs()[0] for i in range(1,self.total_rows.get()): if (self.axes[i][j].xaxis.get_majorticklocs()[-1]>max): max=self.axes[i][j].xaxis.get_majorticklocs()[-1] if self.axes[i][j].xaxis.get_majorticklocs()[0]<min: min=self.axes[i][j].xaxis.get_majorticklocs()[0] for u in range(self.total_rows.get()): self.axes[i][j].set_xlim([min,max]) for i in range(self.total_rows.get()-1): for j in range(self.total_columns.get()): # self.axes[i][j].xaxis.set_visible(False) self.axes[i][j].set_xticklabels('') self.axes[i+1][j].get_shared_x_axes().join(self.axes[0][j],self.axes[i+1][j]) for j in range(self.total_columns.get()): label=(self.axes[0][j].yaxis.get_majorticklocs()) self.axes[0][j].set_yticklabels(label) for i in range(1,self.total_rows.get()): for j in range(self.total_columns.get()): label=(self.axes[i][j].yaxis.get_majorticklocs()) label=label[0:-1] self.axes[i][j].set_yticklabels(label) # First search for the maximun and minimun of y in each row: for i in range(self.total_rows.get()): max=self.axes[i][0].yaxis.get_majorticklocs()[-1] min=self.axes[i][0].yaxis.get_majorticklocs()[0] for j in range(1,self.total_columns.get()): if (self.axes[i][j].yaxis.get_majorticklocs()[-1]>max): max=self.axes[i][j].yaxis.get_majorticklocs()[-1] if self.axes[i][j].xaxis.get_majorticklocs()[0]<min: min=self.axes[i][j].yaxis.get_majorticklocs()[0] for j in range(self.total_columns.get()): self.axes[i][j].set_ylim([min,max]) for i in range(self.total_rows.get()): for j in range(self.total_columns.get()-1): # self.axes[i][j].xaxis.set_visible(False) self.axes[i][j+1].get_shared_y_axes().join(self.axes[i][0],self.axes[i][j+1]) self.axes[i][j+1].set_yticklabels('') for i in range(self.total_rows.get()): label=(self.axes[i][-1].xaxis.get_majorticklocs()) self.axes[i][0].set_xticklabels(label) for i in range(self.total_rows.get()): for j in range(self.total_columns.get()-1): label=(self.axes[i][j].xaxis.get_majorticklocs()) label=label[0:-1] self.axes[i][j].set_xticklabels(label) for i in range(self.total_rows.get()-1): for j in range(self.total_columns.get()): self.axes[i][j].set_xticklabels('') self.fig.tight_layout() self.fig.subplots_adjust(hspace=0.001) self.fig.subplots_adjust(wspace=0.001) self.canvas.draw() def change_subplot(self,*args): # This function will set the focus on the proper subplot self.current_axe=self.axes[self.current_row.get()-1][self.current_column.get()-1] # We marke as the current axe the one we have chosen self.label.set("") # Reset the values of the labels self.x_label.set(self.xlabel_index[self.current_row.get()-1][self.current_column.get()-1]) # This set the correct x label self.y_label.set(self.ylabel_index[self.current_row.get()-1][self.current_column.get()-1]) # This set the correct ylabel self.column_x.set(0) # Give the variable an initial value self.column_y.set(1) # Give the variable an initial value def save_plot(self,*args): # This function save the figure into a file self.fig.savefig(tkFileDialog.asksaveasfilename(filetypes=(('Portable Document Format','*.pdf'), # Theese are the preset file types ('Portable Network Graphics','*.png'), # Its possible to insert more ('All files','*.*')))) def update_labels(self,*args): # This will change the x and y labels of a subplot to a new value self.current_axe.set_xlabel(self.x_label.get()) # This set the value ox the x label to the one inserted in the entry for that purpouse self.current_axe.set_ylabel(self.y_label.get()) # This do the same for the y axe self.xlabel_index[self.current_row.get()-1][self.current_column.get()-1]=self.x_label.get() # This two senteces save the new values self.ylabel_index[self.current_row.get()-1][self.current_column.get()-1]=self.y_label.get() # of the labels for making the logfile self.fig.tight_layout() # We let matplotlib to arrage the spaces between subplots self.canvas.draw() # Update the canvas def reset_subplot(self,*args): # This will reset the current subplot self.current_axe.clear() # This erase all the information of the subplot self.linestyle_index[self.current_row.get()-1][self.current_column.get()-1]=[] # Empty the values of the log variables self.marker_index[self.current_row.get()-1][self.current_column.get()-1]=[] self.label_index[self.current_row.get()-1][self.current_column.get()-1]=[] self.file_index[self.current_row.get()-1][self.current_column.get()-1]=[] self.canvas.draw() # Update the changes on the canvas def set_custom_marker(self,*args): # This function allows as to refine a custom marker self.marker.set(self.marker_custom.get()) # This will update the value of the marker variable to the one we have entered def open_file(self,*args): # This will open a window for choosing the file where to read the data self.filename.set(tkFileDialog.askopenfilename()) # This stores in the variable of the data file the path to the file self.label.set("") # Set the label to a blank value def make_plot(self,*args): # This will make the plot in the current selected subplot self.file_index[self.current_row.get()-1][self.current_column.get()-1].append(self.filename.get()) # Update the log variable self.label_index[self.current_row.get()-1][self.current_column.get()-1].append(self.label.get()) # With the information of the self.marker_index[self.current_row.get()-1][self.current_column.get()-1].append(self.marker.get()) # new plot self.linestyle_index[self.current_row.get()-1][self.current_column.get()-1].append(self.linestyle.get()) self.color_index[self.current_row.get()-1][self.current_column.get()-1].append(self.color.get()) self.xcolumn_index[self.current_row.get()-1][self.current_column.get()-1].append(self.column_x.get()) self.ycolumn_index[self.current_row.get()-1][self.current_column.get()-1].append(self.column_y.get()) f=open(self.filename.get(),'r') # Open the file in read mode x=[] # This variable will store the data for the x axis y=[] # This will store the data of the y axis for l in f: # We goe throw the lines of the file try: # We try to add a couple of values to the x and y, this fill only succed if both are numbers x.append(float(l.split()[self.column_x.get()])) # We read the data from the column we have previously selected y.append(float(l.split()[self.column_y.get()])) # For both x and y axes except: # I should insert here only to except some kind of errors, this maybe will be changed in a future, I have to see pass # which are the errors that I should allow (the ones of trying to convert string to float) if self.color.get()!='': # We plot the data with the color self.current_axe.plot(x,y,marker=self.marker.get(),linestyle=self.linestyle.get(),label=self.label.get(),color=self.color.get()) else: self.current_axe.plot(x,y,marker=self.marker.get(),linestyle=self.linestyle.get(),label=self.label.get()) self.current_axe.legend(loc="best",prop={'size':10}) # current settings, and place a legend. The legend will search for the best location # The location of the legend may be customizable in the future self.fig.tight_layout() self.canvas.draw() f.close() # We close the file def export_logfile(self,*args): # This will export what we have done to make our graphics, so it will be easy to redo or continue our work # from that point. filename=(tkFileDialog.asksaveasfilename()) # This will open a window to ask for a location to save the file f=open(filename,'w+') # We open the file # The first line of the log will be the size of the subplots (how many rows and column) f.write("Total Rows "+str(self.total_rows.get())+" Total Columns "+str(self.total_columns.get())+"\n") # Now the loop in the rows and the columns for i in range(self.total_rows.get()): for j in range(self.total_columns.get()): # Insert 1 black lines to improve readablity f.write("\n") # For each row and column, we write its "coordinates" (row and column) f.write('row= ') f.write(str(i+1)) f.write(' column= ') f.write(str(j+1)) f.write('\n') # We write the value of the labels of the axis f.write("\txlabel "+self.xlabel_index[i][j]+"\n") f.write("\tylabel "+self.ylabel_index[i][j]+"\n") f.write("\txlimits "+str(self.xlimit_index[i][j][0])+" "+str(self.xlimit_index[i][j][1])+"\n") f.write("\tylimits "+str(self.ylimit_index[i][j][0])+" "+str(self.ylimit_index[i][j][1])+"\n") # Now we loop in the files we have plotted for k in range(len(self.file_index[i][j])): # We frite file 1,2,3... before each configuration of a data ser, this number doesn't have any use at all, but maybe # in the future will, and it helps to struturize the logfile f.write('\n\tfile ') f.write(str(k+1)) f.write('\n') # Wtite a line with the marker, the program is case sensitive f.write('\t\tMarker '+self.marker_index[i][j][k]+'\n') # Another with the linestyle f.write('\t\tLinestyle '+self.linestyle_index[i][j][k]+'\n') f.write('\t\tColor '+self.color_index[i][j][k]+'\n') # The label of the file f.write('\t\tLabel '+self.label_index[i][j][k]+'\n') # the columns with the data to plot f.write('\t\tXcolumn '+str(self.xcolumn_index[i][j][k])+'\n') f.write('\t\tYcolumn '+str(self.ycolumn_index[i][j][k])+'\n') # The path to the file f.write('\t\tData '+self.file_index[i][j][k]+'\n') def read_logfile(self,*args): # This function will get the path to the logfile we want to import filename=(tkFileDialog.askopenfilename()) # This will open a window to select the path self.load_logfile(filename) # We call the function that will actually load the logfile def load_logfile(self,filename): # This function will load the logfile # This function takes more arguments than the ones of the class. This was done in order to simplify # The load of the logfile directly from terminal f=open(filename,'r') # Open the logfile for l in f: # Loop throw the lines looking for some key words that will load the configuration # All the words are case sensitive, so if you want to make yourself the logfile you must notice that l=l.strip() if l.startswith("Total Row"): # This should be the first config line of the logfile total_rows=int(l.split()[2]) # Read the total number of rows total_columns=int(l.split()[5]) # And columns if (total_rows>self.total_rows.get() or total_columns>self.total_columns.get() or (not self.figure_created)): # This will be executed if the subplots were not created or if the subplots created are not big enought. # If the created subplots can fit the newones they will add to the current ones self.total_rows.set(total_rows) # We set the total number of rows and columns self.total_columns.set(total_columns) # to the value of the logfile self.create_subplots() # Execute the function that create the subplots elif l.startswith("row"): # This line is the one with the information of wich subplot are we editing self.current_row.set(int(l.split()[1])) # We set the variables to that value self.current_column.set(int(l.split()[3])) self.change_subplot() # And change the subplot to that set elif l.startswith("xlabel"): # This line is the one with the label o the x axis xlabel="" if len(l.split())>2: # If the label is more than 1 word we add all the words within a separation of 1 space for palabra in l.split()[1:-1]: xlabel+=palabra+" " xlabel+=l.split()[-1] # And the las word whiout a separation elif len(l.split())==2: # If it's only one word wen just xlabel=l.split()[1] # set the correct value self.x_label.set(xlabel) self.update_labels() # Run the function to make the change elif l.startswith("ylabel"): # The same with the y axis ylabel="" if len(l.split())>2: for palabra in l.split()[1:-1]: ylabel+=palabra+" " ylabel+=l.split()[-1] elif len(l.split())==2: ylabel=l.split()[1] self.y_label.set(ylabel) self.update_labels() elif l.startswith("xlimit"): if len(l.split())==3: self.xmin.set(float(l.split()[1])) self.xmax.set(float(l.split()[2])) self.change_x_axe() elif l.startswith("ylimit"): # The same with the y axis if len(l.split())==3: self.ymin.set(float(l.split()[1])) self.ymax.set(float(l.split()[2])) self.change_y_axe() elif l.startswith("Marker"): # This line have the marker self.marker.set(l.split()[1]) # Set the marker to the correct value # If this line is not finded the value of this variable will be the last one used or, if it wasn't used before, the # preset value, this aplies also to the linestyle elif l.startswith("Linestyle"): # This line have the linestyle wanted self.linestyle.set(l.split()[1]) # set the variable to it's proper value elif l.startswith("Color"): if len(l.split())==2: self.color.set(l.split()[1]) else: self.color.set("") elif l.startswith("Xcolumn"): self.column_x.set(int(l.split()[1])) elif l.startswith("Ycolumn"): self.column_y.set(int(l.split()[1])) elif l.startswith("Label"): # This lane have the value of the label label="" if len(l.split())>2: # We make the same trick than for reading the x and y labels for palabra in l.split()[1:-1]: label=label+palabra+" " label=label+l.split()[-1] elif len(l.split())==2: label=l.split()[1] self.label.set(label) # Update the calue of the label variable elif l.startswith("Data"): # This line have the path to the file with the data, it can be absolute or relative path # In oreder to avoid errors is better to use absolute paths (the ones the program writes with the export logfile) filename2="" if len(l.split())>2: # We make the same trick than with the labels for palabra in l.split()[1:-1]: filename2=filename2+palabra+" " filename2=filename2+l.split()[-1] elif len(l.split())==2: filename2=l.split()[1] self.filename.set(filename2) # Update the variable with the path to the data file self.make_plot() # We make the plot f.close() # Finally we close the file # This functions will allow to choose the range of the x and y axe def change_x_axe(self,*args): self.current_axe.set_xlim([self.xmin.get(),self.xmax.get()]) # This line set the axes to the value entered self.xlimit_index[self.current_row.get()-1][self.current_column.get()-1]=[self.xmin.get(),self.xmax.get()] self.fig.tight_layout() # This fit all the changes self.canvas.draw() # This draws the new figure def change_y_axe(self,*args): self.current_axe.set_ylim([self.ymin.get(),self.ymax.get()]) self.ylimit_index[self.current_row.get()-1][self.current_column.get()-1]=[self.ymin.get(),self.ymax.get()] self.fig.tight_layout() self.canvas.draw()
hnu_grid = table_key_dict["{0}_{1}".format("hnugrid", selected_ID.get())] mgr_grid = table_key_dict["{0}_{1}".format("ramg", selected_ID.get())] mgp_grid = table_key_dict["{0}_{1}".format("pmg", selected_ID.get())] mgs_grid = table_key_dict["{0}_{1}".format("rsmg", selected_ID.get())] mgrt_grid = table_key_dict["{0}_{1}".format("rtmg", selected_ID.get())] # get log average rho and T for initial plot avg_rho = exp(0.5 * (log(max(rho_grid)) + log(min(rho_grid)))) avg_rho = round(avg_rho, -int(floor(log10(avg_rho)) - 1)) avg_T = exp(0.5 * (log(max(T_grid)) + log(min(T_grid)))) avg_T = round(avg_T, -int(floor(log10(avg_T)) - 1)) # setup and initialize Tk values that can be tied to entry fields # set temperature and density to log average value target_rho = DoubleVar() target_rho.set(avg_rho) target_T = DoubleVar() target_T.set(avg_T) op_type = IntVar() op_type.set(1) # get interpolated opacity data for this temperature and density # first check to see if the data is valid (non-zero) mgr_valid = ip_reader.check_valid_data(mgr_grid) mgp_valid = ip_reader.check_valid_data(mgp_grid) mgs_valid = ip_reader.check_valid_data(mgs_grid) mgrt_valid = ip_reader.check_valid_data(mgrt_grid) name = selected_ID.get() print("-------------------- BEGIN DATA PRINT FOR {0} ---------------------".format(name)) print("Group structure for {0} groups:".format(len(hnu_grid) - 1))
class RotatePanel(PluginPanel): name = "Rotate" title = _("Rotate") def init(self, master): PluginPanel.init(self, master) root = self.mw.root self.var_angle = DoubleVar(root) self.var_angle.set(0) self.var_width_number = DoubleVar(root) self.var_height_number = DoubleVar(root) self.var_width_base = DoubleVar(root) self.var_height_base = DoubleVar(root) self.cnt_x_absolute = None self.cnt_y_absolute = None var_width_unit = StringVar(root) var_height_unit = StringVar(root) unit = config.preferences.default_unit self.var_width = LengthVar(10, unit, self.var_width_number, var_width_unit) self.var_height = LengthVar(10, unit, self.var_height_number, var_height_unit) jump = config.preferences.default_unit_jump self.var_width.set(0) self.var_height.set(0) self.var_width_base.set(0) self.var_height_base.set(0) self.var_position = StringVar(root) self.var_position.set(ABSOLUTE) self.var_basepoint = StringVar(root) self.var_basepoint.set("C") # --------------------------------------------------------- top = TFrame(self.panel, style="FlatFrame") top.pack(side=TOP, fill=BOTH) # --------------------------------------------------------- angle_frame = TFrame(top, style="FlatFrame", borderwidth=3) angle_frame.pack(side=TOP, fill=BOTH) label = TLabel(angle_frame, style="FlatLabel", text=" " + _("Angle:") + " ") label.pack(side=LEFT, padx=5) self.entry_angle = TSpinbox( angle_frame, var=0, vartype=1, textvariable=self.var_angle, min=-360, max=360, step=5, width=6, command=self.apply_rotate, ) self.entry_angle.pack(side=LEFT, anchor=E) label = TLabel(angle_frame, style="FlatLabel", text=_("deg")) label.pack(side=LEFT, padx=5) # --------------------------------------------------------- label = TLabel(top, style="FlatLabel", text=_("Center:")) label.pack(side=TOP, fill=BOTH, padx=5) # --------------------------------------------------------- # Horisontal size_frameH = TFrame(top, style="FlatFrame", borderwidth=3) size_frameH.pack(side=TOP, fill=BOTH) label = TLabel(size_frameH, style="FlatLabel", image="center_h") label.pack(side=LEFT, padx=5) self.entry_width = TSpinbox( size_frameH, var=0, vartype=1, textvariable=self.var_width_number, min=-50000, max=50000, step=jump, width=10, command=self.apply_rotate, ) self.entry_width.pack(side=LEFT) self.labelwunit = TLabel(size_frameH, style="FlatLabel", text=self.var_width.unit) self.labelwunit.pack(side=LEFT, padx=5) # --------------------------------------------------------- # Vertical size_frameV = TFrame(top, style="FlatFrame", borderwidth=3) size_frameV.pack(side=TOP, fill=BOTH) label = TLabel(size_frameV, style="FlatLabel", image="center_v") label.pack(side=LEFT, padx=5) self.entry_height = TSpinbox( size_frameV, var=0, vartype=1, textvariable=self.var_height_number, min=-50000, max=50000, step=jump, width=10, command=self.apply_rotate, ) self.entry_height.pack(side=LEFT) self.labelhunit = TLabel(size_frameV, style="FlatLabel", text=self.var_height.unit) self.labelhunit.pack(side=LEFT, padx=5) # --------------------------------------------------------- # position chek self.position_check = TCheckbutton( top, text=_("Absolute Center"), variable=self.var_position, onvalue=ABSOLUTE, offvalue=RELATIVE, command=self.position, ) self.position_check.pack(side=TOP, anchor=W, padx=5, pady=5) # --------------------------------------------------------- # Basepoint check label = TLabel(top, style="FlatLabel", text=_("Basepoint:")) label.pack(side=TOP, fill=BOTH, padx=5) basepoint_frame = TLabelframe(top, labelwidget=label, style="Labelframe", borderwidth=4) basepoint_frame.pack(side=TOP, fill=X, padx=5, pady=2) self.Basepoint = BasePointSelector(basepoint_frame, anchor=self.var_basepoint, command=self.apply_basepoint) self.Basepoint.pack(side=LEFT, fill=BOTH, padx=5) label = TLabel(basepoint_frame, style="FlatLabel", image="coordinate_deg") label.pack(side=LEFT, fill=BOTH, padx=10) self.position_check.pack(side=TOP, anchor=W, padx=5, pady=5) # --------------------------------------------------------- # Button frame button_frame = TFrame(top, style="FlatFrame", borderwidth=5) button_frame.pack(side=BOTTOM, fill=BOTH) self.update_buttons = [] self.button = UpdatedButton(top, text=_("Apply"), command=self.apply_rotate) self.button.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X, pady=3) self.button_copy = UpdatedButton(top, text=_("Apply to Copy"), command=self.apply_to_copy) self.button_copy.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X) self.init_from_doc() self.subscribe_receivers() ############################################################################### def subscribe_receivers(self): self.document.Subscribe(SELECTION, self.Update) self.document.Subscribe(EDITED, self.update_var) config.preferences.Subscribe(CHANGED, self.update_pref) def unsubscribe_receivers(self): self.document.Unsubscribe(SELECTION, self.Update) self.document.Unsubscribe(EDITED, self.update_var) config.preferences.Unsubscribe(CHANGED, self.update_pref) def init_from_doc(self, *arg): self.Update() def Update(self, *arg): if self.is_selection(): self.entry_angle.set_state(NORMAL) self.entry_width.set_state(NORMAL) self.entry_height.set_state(NORMAL) self.position_check["state"] = NORMAL self.button["state"] = NORMAL self.button_copy["state"] = NORMAL self.TestBasepoint() else: self.entry_angle.set_state(DISABLED) self.entry_width.set_state(DISABLED) self.entry_height.set_state(DISABLED) self.position_check["state"] = DISABLED self.button["state"] = DISABLED self.button_copy["state"] = DISABLED self.update_pref() def apply_basepoint(self): self.update_var() def position(self): self.update_var() def RotateSelected(self, angle, cnt=None): text = _("Rotation") if self.document.selection: self.document.begin_transaction(text) try: try: if cnt is None: cnt = self.document.selection.coord_rect.center() angle = angle * degrees trafo = Rotation(angle, cnt) self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def RotateAndCopy(self, angle, cnt=None): text = _("Rotation&Copy") if self.document.selection: self.document.begin_transaction(text) try: try: if cnt is None: cnt = self.document.selection.coord_rect.center() angle = angle * degrees trafo = Rotation(angle, cnt) self.document.ApplyToDuplicate() self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def apply_rotate(self, *arg): if self.button["state"] == DISABLED: return try: var_x = self.var_width.get() var_y = self.var_height.get() var_a = self.var_angle.get() except: return if var_a < 0: if var_a < -360: var_a += int(var_a / 360) * 360 var_a += 360 if self.var_basepoint.get() != "USER": self.cnt_x_absolute, self.cnt_y_absolute = self.coordinates(ABSOLUTE) self.var_basepoint.set("USER") if self.var_width_base != var_x or self.var_height_base != var_y: if self.var_position.get() == ABSOLUTE: self.cnt_x_absolute = var_x self.cnt_y_absolute = var_y else: x, y = self.coordinates(ABSOLUTE, "C") self.cnt_x_absolute = var_x + x self.cnt_y_absolute = var_y + y self.var_basepoint.set("USER") if arg and arg[0] == "Duplicate": self.RotateAndCopy(var_a, Point(self.cnt_x_absolute, self.cnt_y_absolute)) else: self.RotateSelected(var_a, Point(self.cnt_x_absolute, self.cnt_y_absolute)) def apply_to_copy(self): self.apply_rotate("Duplicate") def coordinates(self, position, anchor=None): br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom if position == RELATIVE: left, bottom = -hor_sel / 2.0, -ver_sel / 2.0 else: left, bottom = br.left, br.bottom cnt_x, cnt_y = self.Basepoint.get_basepoint(hor_sel, ver_sel, left, bottom, anchor) return cnt_x, cnt_y def TestBasepoint(self): if self.cnt_x_absolute is None: return base = ["C", "NW", "N", "NE", "W", "E", "SW", "S", "SE"] for b in xrange(len(base)): cnt_x, cnt_y = self.coordinates(ABSOLUTE, base[b]) if round(cnt_x, 2) == round(self.cnt_x_absolute, 2) and round(cnt_y, 2) == round(self.cnt_y_absolute, 2): self.var_basepoint.set(base[b]) return self.var_basepoint.set("USER") def update_pref(self, *arg): self.labelwunit["text"] = config.preferences.default_unit self.labelhunit["text"] = config.preferences.default_unit self.entry_width.step = config.preferences.default_unit_jump self.entry_height.step = config.preferences.default_unit_jump self.update_var() def update_var(self, *arg): if len(self.document.selection.GetInfo()): self.var_width.unit = config.preferences.default_unit self.var_height.unit = config.preferences.default_unit if self.var_basepoint.get() == "USER": if self.var_position.get() == ABSOLUTE: self.var_width.set(self.cnt_x_absolute) self.var_height.set(self.cnt_y_absolute) else: x, y = self.coordinates(ABSOLUTE, "C") self.var_width.set(self.cnt_x_absolute - x) self.var_height.set(self.cnt_y_absolute - y) else: x, y = self.coordinates(self.var_position.get()) self.var_width.set(x) self.var_height.set(y) self.var_width_base = self.var_width.get() self.var_height_base = self.var_height.get() def is_selection(self): return len(self.document.selection) > 0
class GeoGUI: def __init__(self, master): self.master = master master.title("GeoGUI") self.w= "W:" self.inputw=0 self.e= "E:" self.inpute=0 self.s= "S:" self.inputs=0 self.n= "N:" self.inputn=0 self.r= "Resolution:" self.inputr=0 self.lele= "Lower Elevation Limits:" self.inputlele=-40000 self.hele= "Higher Elevation Limits:" self.inputhele=40000 self.step= "Step size:" self.inputstep=.1 self.w_label_text = StringVar() self.w_label = Label(master, textvariable=self.w_label_text) self.w_label_text.set(self.w) self.e_label_text = StringVar() self.e_label = Label(master, textvariable=self.e_label_text) self.e_label_text.set(self.e) self.n_label_text = StringVar() self.n_label = Label(master, textvariable=self.n_label_text) self.n_label_text.set(self.n) self.s_label_text = StringVar() self.s_label = Label(master, textvariable=self.s_label_text) self.s_label_text.set(self.s) self.r_label_text = DoubleVar() self.r_label = Label(master, textvariable=self.r_label_text) self.r_label_text.set(self.r) self.lele_label_text = DoubleVar() self.lele_label = Label(master, textvariable=self.lele_label_text) self.lele_label_text.set(self.lele) self.hele_label_text = DoubleVar() self.hele_label = Label(master, textvariable=self.hele_label_text) self.hele_label_text.set(self.hele) self.step_label_text = DoubleVar() self.step_label = Label(master, textvariable=self.step_label_text) self.step_label_text.set(self.step) self.label = Label(master, text="W:") self.label = Label(master, text="E:") self.label = Label(master, text="N:") self.label = Label(master, text="S:") self.label = Label(master, text="Resolution:") self.label = Label(master, text="Lower Elevation Limits:") self.label = Label(master, text="Higher Elevation Limits:") self.label = Label(master, text="Step size:") wvcmd = master.register(self.wvalidate) evcmd = master.register(self.evalidate) svcmd = master.register(self.svalidate) nvcmd = master.register(self.nvalidate) rvcmd = master.register(self.rvalidate) lelevcmd = master.register(self.lelevalidate) helevcmd = master.register(self.helevalidate) stepvcmd = master.register(self.stepvalidate) # we have to wrap the command self.entryw = Entry(master, validate="key", validatecommand=(wvcmd, '%s')) self.entrye = Entry(master, validate="key", validatecommand=(evcmd, '%s')) self.entrys = Entry(master, validate="key", validatecommand=(svcmd, '%s')) self.entryn = Entry(master, validate="key", validatecommand=(nvcmd, '%s')) self.entryr = Entry(master, validate="key", validatecommand=(rvcmd, '%P')) self.entrylele = Entry(master, validate="key", validatecommand=(lelevcmd, '%P')) self.entryhele = Entry(master, validate="key", validatecommand=(helevcmd, '%P')) self.entrystep = Entry(master, validate="key", validatecommand=(stepvcmd, '%P')) self.w_label.pack() self.entryw.pack() self.e_label.pack() self.entrye.pack() self.s_label.pack() self.entrys.pack() self.n_label.pack() self.entryn.pack() self.r_label.pack() self.entryr.pack() self.lele_label.pack() self.entrylele.pack() self.hele_label.pack() self.entryhele.pack() self.step_label.pack() self.entrystep.pack() self.run_button = Button(master, text="Run", command=self.run) self.run_button.pack() self.close_button = Button(master, text="Close", command=master.quit) self.close_button.pack() def evalidate(self, new_text): if not new_text: # the field is being cleared self.inpute = 0 return True try: self.inpute = float(new_text) print(self.inpute) return True except ValueError: if new_text[0] == "-": self.inpute=-1 return True return False def wvalidate(self, new_text): if not new_text: # the field is being cleared self.inputw = 0 return True try: self.inputw = float(new_text) print(self.inputw) return True except ValueError: if new_text[0] == "-": self.inputw=-1 return True return False def nvalidate(self, new_text): if not new_text: # the field is being cleared self.inputn = 0 return True try: self.inputn = float(new_text) print(self.inputn) return True except ValueError: if new_text[0] == "-": self.inputn=-1 return True return False def svalidate(self, new_text): if not new_text: # the field is being cleared self.inputs = 0 return True try: self.inputs = float(new_text) print(self.inputs) return True except ValueError: if new_text[0] == "-": self.inputs=-1 return True return False def rvalidate(self, new_text): if not new_text: # the field is being cleared self.inputr = 0 return True try: self.inputr = int(new_text) return True except ValueError: return False def lelevalidate(self, new_text): if not new_text: # the field is being cleared return True try: self.inputlele = float(new_text) return True except ValueError: return False def helevalidate(self, new_text): if not new_text: # the field is being cleared return True try: self.inputhele = float(new_text) return True except ValueError: return False def stepvalidate(self, new_text): if not new_text: # the field is being cleared return True try: self.inputstep = float(new_text) return True except ValueError: return False def run(self): locations=[] tstamp= str(datetime.datetime.now()) foutname= os.path.join(os.path.expanduser("~"),"Documents",tstamp+".ascii") fout = open(foutname, 'w') w=self.inputw s= self.inputs while s <= self.inputn: while w <= self.inpute+.1: locations.append((w,s)) w+=self.inputstep getElevation(locations,self.inputr,self.inputlele,self.inputhele,fout) s+=self.inputstep w=self.inputw #print(self.inputs) locations=[] fout.close()
class ChemicalEditor: """Gets the contaminant properties.""" def __init__(self, master, system, chemical, chemicals, database, editflag): """Constructor method. Defines the parameters to be obtained in this window.""" self.master = master self.fonttype = system.fonttype self.version = system.version self.superfont = get_superfont(self.fonttype) #superscript font self.frame = Frame(master.frame) self.tframe = Frame(master.tframe) self.bframe = Frame(master.bframe) self.system = system self.database = database self.top = None #flag for existence of toplevel# self.tkfont = tkFont.Font(font=system.fonttype) self.soluableflag = chemical.soluable self.editflag = editflag self.cancelflag = 0 self.chemicals = chemicals self.diffunit = system.diffunit self.diffunits = system.diffunits if self.soluableflag == 1: self.database = database self.chemical = chemical self.name = StringVar(value='') self.formula = StringVar(value='') self.MW = DoubleVar(value=0) self.temp = DoubleVar(value=0) self.Dw = DoubleVar(value=0) self.Ref = StringVar(value='') self.Koc = DoubleVar(value=0) self.Kdoc = DoubleVar(value=0) self.Kf = DoubleVar(value=0) self.N = DoubleVar(value=0) if editflag == 1: #Detemine whether the chemical is added or edited self.name.set(self.chemical.name) self.formula.set(self.chemical.formula) self.MW.set(self.chemical.MW) self.temp.set(self.chemical.temp) self.Dw.set(self.chemical.Dw) self.Koc.set(self.chemical.Koc) self.Kdoc.set(self.chemical.Kdoc) self.Ref.set(self.chemical.Ref) self.Kf.set(self.chemical.Kf) self.N.set(self.chemical.N) else: self.name = StringVar(value=' ') self.formula = StringVar(value=' ') self.MW = DoubleVar(value=100) self.temp = DoubleVar(value=0) self.Dw = DoubleVar(value=0) self.Koc = DoubleVar(value=0) self.Kdoc = DoubleVar(value=0) self.Kf = DoubleVar(value=0) self.N = DoubleVar(value=0) if editflag == 1: #Detemine whether the chemical is added or edited self.name.set(chemical.name) def make_widgets(self): """Make the widgets for the window.""" self.bgcolor = self.frame.cget('bg') self.instructions = Label( self.tframe, text= ' Please provide the following chemical properties: ' ) self.blankcolumn = Label(self.frame, text=' ', width=2) self.namecolumn = Label(self.frame, text=' ', width=20) self.MWcolumn = Label(self.frame, text=' ', width=12) self.tempcolumn = Label(self.frame, text=' ', width=10) self.Dwcolumn = Label(self.frame, text=' ', width=18) self.Koccolumn = Label(self.frame, text=' ', width=18) self.Kdoccolumn = Label(self.frame, text=' ', width=18) self.Refcolumn = Label(self.frame, text=' ', width=20) self.Rightcolumn = Label(self.frame, text=' ', width=2) self.namelabel = Label(self.frame, text='Chemical name') self.MWlabel = Label(self.frame, text='Molecular\n weight') self.templabel = Label(self.frame, text='Temperature') self.Dwlabel = Label(self.frame, text='Molecular diffusivity\n in water') self.Koclabel = Label(self.frame, text='Organic carbon\n partition coefficient') self.Kdoclabel = Label( self.frame, text='Dissolved organic carbon\n partition coefficient') self.Reflabel = Label(self.frame, text='Reference') self.tempunits = Label(self.frame, text=unichr(176) + 'C') self.Dwunits = Label(self.frame, text=self.diffunit) self.Kocunits = Label(self.frame, text='log(L/kg)') self.Kdocunits = Label(self.frame, text='log(L/kg)') self.importbutton = Button(self.frame, text='From Database', width=20, command=self.importchemical) self.okbutton = Button(self.frame, text='OK', width=20, command=self.OK) self.cancelbutton = Button(self.frame, text='Cancel', width=20, command=self.Cancel) self.blank1 = Label(self.frame, text=' ') self.blank2 = Label(self.frame, text=' ') #show the widgets on the grid self.instructions.grid(row=0, column=0, columnspan=6, padx=8, sticky='W') self.blankcolumn.grid(row=1, column=0, sticky='WE', padx=1, pady=1) self.namecolumn.grid(row=1, column=1, sticky='WE', padx=1, pady=1) self.MWcolumn.grid(row=1, column=2, sticky='WE', padx=1, pady=1) self.tempcolumn.grid(row=1, column=3, sticky='WE', padx=1, pady=1) self.Dwcolumn.grid(row=1, column=4, sticky='WE', padx=1, pady=1) self.Koccolumn.grid(row=1, column=5, sticky='WE', padx=1, pady=1) self.Kdoccolumn.grid(row=1, column=6, sticky='WE', padx=1, pady=1) self.Refcolumn.grid(row=1, column=7, sticky='WE', padx=1, pady=1) self.Rightcolumn.grid(row=1, column=8, sticky='WE', padx=1, pady=1) self.namelabel.grid(row=2, column=1, sticky='WE', padx=1, pady=1) self.MWlabel.grid(row=2, column=2, sticky='WE', padx=1, pady=1) self.templabel.grid(row=2, column=3, sticky='WE', padx=1, pady=1) self.Dwlabel.grid(row=2, column=4, sticky='WE', padx=1, pady=1) self.Koclabel.grid(row=2, column=5, sticky='WE', padx=1, pady=1) self.Kdoclabel.grid(row=2, column=6, sticky='WE', padx=1, pady=1) self.Reflabel.grid(row=2, column=7, sticky='WE', padx=1, pady=1) self.tempunits.grid(row=3, column=3, sticky='WE', padx=1, pady=1) self.Dwunits.grid(row=3, column=4, sticky='WE', padx=1, pady=1) self.Kocunits.grid(row=3, column=5, sticky='WE', padx=1, pady=1) self.Kdocunits.grid(row=3, column=6, sticky='WE', padx=1, pady=1) if self.soluableflag == 1: if self.editflag == 0: self.namewidget = Entry(self.frame, width=18, justify='center', textvariable=self.name) self.tempwidget = Entry(self.frame, width=10, justify='center', textvariable=self.temp) else: self.namewidget = Label(self.frame, width=18, justify='center', textvariable=self.name) self.tempwidget = Label(self.frame, width=10, justify='center', textvariable=self.temp) self.Dwwidget = Entry(self.frame, width=16, justify='center', textvariable=self.Dw) self.MWwidget = Entry(self.frame, width=10, justify='center', textvariable=self.MW) self.Kocwidget = Entry(self.frame, width=16, justify='center', textvariable=self.Koc) self.Kdocwidget = Entry(self.frame, width=16, justify='center', textvariable=self.Kdoc) self.Refwidget = Entry(self.frame, width=18, justify='center', textvariable=self.Ref) self.namewidget.grid(row=4, column=1, padx=2, pady=1) self.MWwidget.grid(row=4, column=2, padx=2, pady=1) self.tempwidget.grid(row=4, column=3, padx=2, pady=1) self.Dwwidget.grid(row=4, column=4, padx=2, pady=1) self.Kocwidget.grid(row=4, column=5, padx=2, pady=1) self.Kdocwidget.grid(row=4, column=6, padx=2, pady=1) self.Refwidget.grid(row=4, column=7, padx=2, pady=1) else: self.namewidget = Entry(self.frame, width=18, justify='center', textvariable=self.name) self.Dwwidget = Label(self.frame, width=16, justify='center', text='Not applicable') self.Kocwidget = Label(self.frame, width=16, justify='center', text='Not applicable') self.Kdocwidget = Label(self.frame, width=16, justify='center', text='Not applicable') self.namewidget.grid(row=4, column=1, padx=2, pady=1) self.Dwwidget.grid(row=4, column=3, padx=2, pady=1) self.Kocwidget.grid(row=4, column=4, padx=2, pady=1) self.Kdocwidget.grid(row=4, column=5, padx=2, pady=1) self.blank1.grid(row=5) if self.editflag == 0: self.importbutton.grid(row=6, columnspan=11) self.okbutton.grid(row=7, columnspan=11) self.cancelbutton.grid(row=8, columnspan=11) self.blank2.grid(row=9) self.okbutton.bind('<Return>', self.OK) self.focusbutton = self.okbutton if int((self.tkfont.measure(self.Ref.get()) + 10) * 1.1424219345 / 8) + 1 > 18: self.Refwidget.config( width=int((self.tkfont.measure(self.Ref.get()) + 10) * 1.1424219345 / 8) + 3) if int((self.tkfont.measure(self.name.get()) + 10) * 1.1424219345 / 8) + 1 > 18: self.namewidget.config( width=int((self.tkfont.measure(self.name.get()) + 10) * 1.1424219345 / 8) + 3) self.master.geometry() self.master.center() def importchemical(self): if self.top is None: self.top = CapSimWindow(master=self.master, buttons=2) self.top.make_window( ChemicalImporter(self.top, self.system, self.database)) self.top.tk.mainloop() if self.top.window.cancelflag == 0: self.updatechemical(self.top.window) if self.top is not None: self.top.destroy() self.top = None elif self.top is not None: tkmb.showerror( title=self.system.version, message= 'Please close the existing parameter input window first.') self.top.tk.focus() def updatechemical(self, window): self.name.set(window.name.get()) self.formula.set(window.formula.get()) self.MW.set(window.MW.get()) self.temp.set(window.temp.get()) self.Koc.set(window.Koc.get()) self.Kdoc.set(window.Kdoc.get()) self.Ref.set(window.Ref.get()) self.Kf.set(window.Kf.get()) self.N.set(window.N.get()) if self.diffunit == self.diffunits[0]: self.Dw.set(window.Dw.get()) elif self.diffunit == self.diffunits[1]: Dw = window.Dw.get() * 86400 * 365 if Dw > 1: self.Dw.set(round(Dw, 2)) else: i = 2 while Dw / 100 < 0.1**i: i = i + 1 self.Dw.set(round(Dw, i)) self.frame.update() if int((self.tkfont.measure(self.Ref.get()) + 10) * 1.1424219345 / 8) + 1 > 20: self.Refwidget.config( width=int((self.tkfont.measure(self.Ref.get()) + 10) * 1.1424219345 / 8) + 3) if int((self.tkfont.measure(self.name.get()) + 10) * 1.1424219345 / 8) + 1 > 20: self.namewidget.config( width=int((self.tkfont.measure(self.name.get()) + 10) * 1.1424219345 / 8) + 3) self.master.geometry() self.master.center() def OK(self, event=None): """Finish and move on. Checks that the number chemicals are less than the total number of chemicals in database.""" if self.editflag == 0: check = [(chemical.name == self.name.get()) for chemical in self.chemicals[0:-1]] else: check = [0] if self.master.window.top is not None: self.master.open_toplevel() elif sum(check) >= 1: self.chemicals_error() elif self.name.get() == '' or self.name.get().count(' ') == len( self.name.get()): self.name_error() elif self.Dw.get() == 0: self.Dw_error() else: self.master.tk.quit() def chemicals_error(self): tkmb.showerror(title=self.version, message='This chemical has already been selected!') self.focusbutton = self.okbutton self.master.tk.lift() def name_error(self): tkmb.showerror(title=self.version, message='Please input the name for the chemical!') self.focusbutton = self.okbutton self.master.tk.lift() def Dw_error(self): tkmb.showerror( title=self.version, message= 'The diffusivity of the chemical can not be zero, please correct!') self.focusbutton = self.okbutton self.master.tk.lift() def Cancel(self): try: self.name.set(self.chemical.name) self.MW.set(self.chemical.MW.get()) self.formula.set(self.chemical.formula.get()) self.temp.set(self.chemical.temp.get()) self.Dw.set(self.chemical.Dw.get()) self.Koc.set(self.chemical.Koc.get()) self.Kdoc.set(self.chemical.Kdoc.get()) self.Ref.set(self.chemical.Ref.get()) self.Kf.set(self.chemical.Kf.get()) self.N.set(self.chemical.N.get()) except: self.cancelflag = 1 if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit()
class Controller(Observer): def __init__(self,parent,view,lissajou,subjectSig,subjects): self.cursorFrame = Frame(parent) self.selectionFrame = Frame(self.cursorFrame) self.view = view self.lissajou = lissajou self.subjects = subjects self.subjectSig=subjectSig self.amp=IntVar() self.scale_amp=Scale(self.cursorFrame,variable=self.amp, label="Amplitude", orient="horizontal",length=250,from_=0,to=10, sliderlength=50,tickinterval=1,showvalue=0, command=self.update) self.freq=IntVar() self.scale_freq=Scale(self.cursorFrame,variable=self.freq, label="Frequence", orient="horizontal",length=250,from_=0,to=10, sliderlength=50,tickinterval=0,showvalue=0, command=self.update) self.offset=DoubleVar() self.scale_offset=Scale(self.cursorFrame,variable=self.offset, label="Offset", orient="horizontal",length=250,from_=-10.0,to=10.0, sliderlength=50,tickinterval=5,showvalue=0, command=self.update) self.phase=IntVar() self.scale_phase=Scale(self.cursorFrame,variable=self.phase, label="Phase", orient="horizontal",length=250,from_=-90,to=90, sliderlength=10,tickinterval=45,showvalue=0, command=self.update) self.voltVar = DoubleVar() self.voltVar.set(1) self.button1 = Radiobutton(self.selectionFrame, text="1V", variable=self.voltVar, value=1.0*5.0,command =lambda:self.update(None)) self.button1.select() self.button2 = Radiobutton(self.selectionFrame, text="2V", variable=self.voltVar, value=2.0*5.0, command =lambda:self.update(None)) self.button5 = Radiobutton(self.selectionFrame, text="5V", variable=self.voltVar, value=5.0*5.0, command =lambda:self.update(None)) self.isOffsetVar= IntVar() self.isOffset = Checkbutton(self.selectionFrame,text = "Offset",variable = self.isOffsetVar, command =lambda:self.update(None)) def update(self,event): self.update_amplitude(event) self.update_offset(event) self.update_frequency(event) self.update_phase(event) self.view.update() if self.lissajou!=None: self.lissajou.update() def update_amplitude(self,event): print("update_amplitude(self,event)",self.amp.get()) self.subjectSig.set_magnitude(self.amp.get()/self.voltVar.get()) self.subjects.generate_XYCurve() def update_frequency(self,event): print("update_frequency(self,event)",self.freq.get()) self.subjectSig.set_frequency(self.freq.get()) self.subjects.generate_XYCurve() def update_phase(self,event): print("update_phase(self,event)",self.phase.get()) self.subjectSig.set_phase(self.phase.get()) self.subjects.generate_XYCurve() def update_offset(self,event): if self.isOffsetVar.get(): print("update_offset(self,event)",self.isOffsetVar.get()) self.subjectSig.set_offset(self.offset.get()/self.voltVar.get()) self.subjects.generate_XYCurve() else: self.subjectSig.set_offset(0.0) self.subjects.generate_XYCurve() def setLissajou(self,lissajou): self.lissajou = lissajou def packing(self) : self.selectionFrame.pack(side='top') self.button1.pack(side='left') self.button2.pack(side='left') self.button5.pack(side='left') self.isOffset.pack(side='left') self.cursorFrame.pack(side='left',expand=1, fill='both') self.scale_amp.pack() self.scale_freq.pack() self.scale_offset.pack() self.scale_phase.pack()
class take_data: ''' ''' def __init__(self, pype, toplevel=False, filename=False, num_sequences=10, run_tag=''): ''' ''' self.pype = pype self.toplevel = toplevel self.keep_runningVar = BooleanVar(value=True) self.extend_runVar = BooleanVar(value=False) self.run_typeVar = StringVar(value="/tmp/") self.run_tagVar = StringVar(value=run_tag) self.num_sequencesVar = IntVar(value=num_sequences) self.sequence_spacingVar = DoubleVar(value=0) self.len_sequenceVar = DoubleVar() self.stateVar = StringVar(value='done') self.conf_filename = StringVar(value='') self.params = {} self.runthread = multiprocessing.Process() self._GetParamFuncs() if toplevel: self._BuildGui() def _BuildGui(self): ''' Setup all of the buttons and user entries ''' # Data Location row = 0 Label(self.toplevel, text='-'*20+'Data Location'+'-'*20).grid(row=row, columnspan=3, column=0) row += 1 Label(self.toplevel, text='/data').grid(row=row, column=0, sticky='E') run_type_options = ["/tmp/", "/commissioning/", "/runs/"] OptionMenu(self.toplevel, self.run_typeVar, *run_type_options).grid( row=row, column=1, sticky='EW') Entry(self.toplevel, textvariable=self.run_tagVar).grid(row=row, column=2) Checkbutton(self.toplevel, text="Extend if Exists", variable=self.extend_runVar).grid(row=row, column=3) row += 1 Label(self.toplevel, text="(raid location)").grid(row=row, column=0, sticky='E') Label(self.toplevel, text="(run type)").grid(row=row, column=1) Label(self.toplevel, text="(run tag)").grid(row=row, column=2) row += 1 # Acquisition Cycle Details Label(self.toplevel, text='-'*20+'Acquisition Cycles'+'-'*20).grid(row=row, columnspan=3, column=0) row += 1 Label(self.toplevel, text='Number of Sequences').grid(row=row, column=0) Entry(self.toplevel, textvariable=self.num_sequencesVar).grid(row=row, column=1) row += 1 Label(self.toplevel, text='Delay Between').grid(row=row, column=0) Entry(self.toplevel, textvariable=self.sequence_spacingVar).grid(row=row, column=1) Label(self.toplevel, text='[s]').grid(row=row, column=2, sticky='W') row += 1 builtins_list = ['default_run', 'noise_analysis_run'] self.conf_filename.set(builtins_list[0]) Button(self.toplevel, text='Load Builtin Run Def', command=self._GetParamFuncs).grid(row=row, column=0) OptionMenu(self.toplevel, self.conf_filename, *builtins_list).grid( row=row, column=1) self.conf_filename.set(builtins_list[0]) row += 1 Label(self.toplevel, text='Load Custom Run Def').grid(row=row, column=0) Button(self.toplevel, text="find file", command=self._ParamFuncFile ).grid(row=row, column=1) row += 1 # Mantis Settings Label(self.toplevel, text='-'*20+'Mantis Settings'+'-'*20).grid(row=row, columnspan=3, column=0) row += 1 Label(self.toplevel, text='(Empty fields use default values)').grid(row=row, columnspan=3, column=0) row += 1 Label(self.toplevel, text='Digitization Time').grid(row=row, column=0) Entry(self.toplevel, textvariable=self.len_sequenceVar).grid(row=row, column=1) Label(self.toplevel, text='[ms]').grid(row=row, column=2, sticky='W') row += 1 Button(self.toplevel, text="Start Run", command=self.DoRun ).grid(row=row, column=0) Button(self.toplevel, text="ABORT", command=self._Abort, bg='red' ).grid(row=row, column=1) Label(self.toplevel, textvariable=self.stateVar).grid(row=row, column=2) def _ParamFuncFile(self): ''' ''' self.conf_filename.set(askopenfilename()) if self.conf_filename.get(): self._GetParamFuncs() def _Abort(self): ''' ''' self.keep_runningVar.set(False) if self.runthread.is_alive(): print('terminating child process') self.runthread.terminate() else: print('no current thread') self.stateVar.set('aborted') def _IsRunning(self): ''' ''' print(self.runthread.is_alive()) def _GetParamFuncs(self): ''' ''' fname = self.conf_filename.get() if not fname or fname == 'default_run': if not 'run_params' in sys.modules: from . import default_run as run_params else: reload(run_params) elif fname == 'noise_analysis_run': from . import noise_analysis_run as run_params else: imp.load_source('run_params', fname) import run_params self.DefaultParams = run_params.DefaultParams self.SequenceParams = run_params.SequenceParams self.FilenamePrefix = run_params.FilenamePrefix self.Mantis_kwargs = run_params.Mantis_kwargs() if 'duration' in self.Mantis_kwargs: self.len_sequenceVar.set(self.Mantis_kwargs['duration']) def DoRun(self): ''' Execute the run ''' self.keep_runningVar.set(True) self.stateVar.set('normal') if self.runthread.is_alive(): print('there is already live process, abort first or let it finish') else: self.runthread = multiprocessing.Process(target=self.__DoRun) self.runthread.start() def __DoRun(self): ''' the run called by DoRun in a subprocess ''' self.params['run_tag'] = self.run_tagVar.get() self.params['num_sequences'] = self.num_sequencesVar.get() print('setting defaults') self._SetParams(self.DefaultParams()) for sequence_num in range(self.params['num_sequences']): print('--> starting sequence {0}/{1}'.format(sequence_num, self.params['num_sequences'] - 1)) if not self.keep_runningVar.get(): print('Aborting!') break self._DoSequence(sequence_num) print('--> sequence {0}/{1} complete.'.format(sequence_num, self.params['num_sequences'] - 1)) sleep(self.sequence_spacingVar.get()) print('-> run (tag: {0}) complete.'.format(self.params['run_tag'])) self.stateVar.set('run complete') def _SetParams(self, params_list): ''' ''' for channel_name, value in params_list: setattempt = self.pype.Set(channel_name, value) setattempt.Wait() if setattempt.Waiting(): raise NoResponseError('setting ' + str(channel_name)) print(channel_name, '->', value) def _DoSequence(self, sequence_number): ''' Do one sequence within the run ''' mantis_kwargs = self.Mantis_kwargs.copy() run_doc = self.pype.NewDump(uuid4().hex, self.params['run_tag'], new_run=((not sequence_number) and not self.extend_runVar.get())) self._SetParams(self.SequenceParams(sequence_number)) for channel in self.pype.ListWithProperty('dump'): run_doc[channel] = self.pype.Get(channel) run_doc[channel].Update() run_doc[channel].Wait() run_doc._UpdateTo() outfilename = '/data/{:s}_{:05d}_{:05d}.egg'.format( self.FilenamePrefix(sequence_number), run_doc['run_number'], run_doc['sequence_number']) print('outputting '+outfilename) run_descrip = ast.literal_eval(mantis_kwargs['description']) for (chan, val) in self.SequenceParams(sequence_number): run_descrip[chan] = val run_descrip['run_tag'] = self.params['run_tag'] run_doc['sequence_tag'] = dumps(run_descrip) mantis_kwargs.update({'output': outfilename, 'description': dumps(run_descrip), 'duration': self.len_sequenceVar.get()}) run = self.pype.RunMantis(**mantis_kwargs) print('mantis run starting') run.Wait() run_doc['mantis'] = run run_doc._UpdateTo()
class FourBarGUI(object): """ GUI to model a 4-bar mechanism. """ def __init__(self, wdw, r, c): """ Determines layout of the canvas, number of rows and colums is r and c. """ wdw.title('a 4-bar mechanism') self.fbr = FourBar() self.rows = r self.cols = c self.ox = c/3 self.oy = 3*r/4 # print "A =" , (self.ox, self.oy) self.togo = False # the canvas and start, stop, and clear buttons self.c = Canvas(wdw, width=self.cols, height=self.rows, bg='green') self.c.grid(row=1, column=2, columnspan=2) self.startbut = Button(wdw, text='start', command = self.start) self.startbut.grid(row=3, column=2, sticky=W+E) self.stopbut = Button(wdw, text='stop', command = self.stop) self.stopbut.grid(row=3, column=3, sticky=W+E) self.clearbut = Button(wdw, text='clear', command = self.clear) self.clearbut.grid(row=3, column=4, columnspan=3, sticky=W+E) # the length of the crank self.crank_lbl = Label(wdw, text='crank', justify=LEFT) self.crank_lbl.grid(row=0, column=0) self.crank_bar = IntVar() self.L = Scale(wdw, orient='vertical', from_=0, to=self.rows/2, \ tickinterval=20, resolution=1, length=self.rows, \ variable=self.crank_bar, command=self.draw_mechanism) self.L.set(self.fbr.crank) self.L.grid(row=1, column=0) # the angle that drives the crank self.angle_lbl = Label(wdw, text='angle', justify=LEFT) self.angle_lbl.grid(row=0, column=1) self.angle = DoubleVar() self.t = Scale(wdw, orient='vertical', from_=0, to=6.30, \ tickinterval=0.30, resolution=0.01, length=self.rows, \ variable=self.angle, command=self.draw_mechanism) self.t.grid(row=1, column=1) self.angle.set(self.fbr.angle) # the bar at the right self.right_bar_lbl = Label(wdw, text='right bar', justify=LEFT) self.right_bar_lbl.grid(row=0, column=4) self.right_bar = IntVar() self.r = Scale(wdw, orient='vertical', from_=0, to=self.rows/2, \ tickinterval=20, resolution=1, length=self.rows, \ variable=self.right_bar, command=self.draw_mechanism) self.r.grid(row=1, column=4) self.right_bar.set(self.fbr.right) # the top bar attached to the crank self.top_bar_lbl = Label(wdw, text='top bar', justify=LEFT) self.top_bar_lbl.grid(row=0, column=5) self.r_top_bar = IntVar() self.R = Scale(wdw, orient='vertical', from_=0, to=self.rows/2, \ tickinterval=20, resolution=1, length=self.rows, \ variable=self.r_top_bar, command=self.draw_mechanism) self.R.grid(row=1, column=5) self.r_top_bar.set(self.fbr.top) # the scale for the coupler bar self.coupler_bar_lbl = Label(wdw, text='coupler', justify=LEFT) self.coupler_bar_lbl.grid(row=0, column=6) self.coupler_bar = IntVar() self.cpl = Scale(wdw, orient='vertical', from_=0, to=self.rows/2, \ tickinterval=20, resolution=1, length=self.rows, \ variable=self.coupler_bar, command=self.draw_mechanism) self.cpl.grid(row=1, column=6) self.coupler_bar.set(self.fbr.coupler) # the horizontal bottom bar self.flat_lbl = Label(wdw, text='right joint', justify=RIGHT) self.flat_lbl.grid(row=2, column=1) self.flat = IntVar() self.f = Scale(wdw, orient='horizontal', from_=0, to=self.rows/2, \ tickinterval=50, resolution=1, length=self.cols, \ variable=self.flat, command=self.draw_mechanism) self.f.grid(row=2, column=2, columnspan=2) self.flat.set(self.fbr.flat) # coordinates of the coupler point appear on top self.ex = Entry(wdw) # for x value self.ex.grid(row=0, column=2) self.ex.insert(INSERT, "x = ") self.ey = Entry(wdw) # for y value self.ey.grid(row=0, column=3) self.ey.insert(INSERT,"y = ") # check button for drawing of coupler curve self.curve = IntVar() self.cb = Checkbutton(wdw, text='coupler', \ variable=self.curve, onvalue=1, offvalue=0) self.curve.set(1) self.cb.grid(row=3, column=0) # draw the mechanism on canvas self.draw_mechanism(0) def update_values(self): """ Takes all values of the scales and updates the data attributes of self.fbr. """ self.fbr.flat = self.flat.get() self.fbr.crank = self.crank_bar.get() self.fbr.top = self.r_top_bar.get() self.fbr.right = self.right_bar.get() self.fbr.coupler = self.coupler_bar.get() self.fbr.angle = self.angle.get() #self.fbr.print_joints() def draw_coupler_point(self, p): """ Draws coupler point with coordinates in p if the curve checkbox is on. Note that the previous values for the coordinates of the coupler point are stored in the entry fields. """ if self.curve.get() == 1: px = self.ox + p[0] py = self.oy - p[1] eqx = self.ex.get() Lx = eqx.split('=') if Lx[1] == ' ': qx = 0.0 else: qx = float(Lx[1]) eqy = self.ey.get() Ly = eqy.split('=') if Ly[1] == ' ': qy = 0.0 else: qy = float(Ly[1]) if (qx != 0.0) and (qy != 0.0): qx = self.ox + qx qy = self.oy - qy self.c.create_line(qx, qy, px, py, width=1) def fill_entries(self, p): """ Fills the entry fields with the coordinates of the coupler point in p. """ sx = 'x = %f' % p[0] sy = 'y = %f' % p[1] self.ex.delete(0, END) self.ex.insert(INSERT, sx) self.ey.delete(0, END) self.ey.insert(INSERT, sy) def draw_link(self, p, q, s): """ Draws the link from point with coordinates in p to the point with coordinates in q, using s as tag. """ self.c.delete(s) px = self.ox + p[0] py = self.oy - p[1] qx = self.ox + q[0] qy = self.oy - q[1] self.c.create_line(px, py, qx, qy, width=2, tags=s) def draw_mechanism(self, v): """ Fills the canvas with the current model of the planar 4-bar mechanism. Because this command is called by the sliders, the argument v is needed but not used. """ self.update_values() L = self.fbr.joints() for i in range(0, len(L)): p = L[i] px = self.ox + p[0] py = self.oy - p[1] sj = 'joint%d' % i self.c.delete(sj) self.c.create_oval(px-6, py-6, px+6, py+6, width=1, \ outline='black', fill='red', tags=sj) self.draw_link(L[0], L[2], 'link0') self.draw_link(L[1], L[3], 'link1') self.draw_link(L[2], L[3], 'link2') self.draw_link(L[2], L[4], 'link3') self.draw_coupler_point(L[4]) self.fill_entries(L[4]) def start(self): """ Starts the animation, adding 0.01 to angle. """ self.togo = True while self.togo: theta = self.angle.get() theta = theta + 0.01 if theta > 6.28: theta = 0 self.angle.set(theta) self.draw_mechanism(0) self.c.update() def stop(self): """ Stops the animation. """ self.togo = False def clear(self): """ Clears the canvas. """ self.c.delete(ALL)
class _App: ######################################################################### # GUI setup ######################################################################### def __menu(self, master): menubar = Menu(master) def file_menu(): menu = Menu(menubar, tearoff=0) menu.add_command(label="Open ctxt / cbin", command=self.open_file) # menu.add_command(label="Append ctxt", command=self.append_file) menu.add_separator() menu.add_command(label="Exit", command=self.save_settings_and_quit) return menu menubar.add_cascade(label="File", menu=file_menu()) def view_menu(): menu = Menu(menubar, tearoff=0) menu.add_checkbutton(label="Auto-render", variable=self.render_auto) # menu.add_command(label="Filter threads", command=None) return menu menubar.add_cascade(label="View", menu=view_menu()) def analyse_menu(): # def timechart(): # _TimeChart(master, self.output.get("0.0", END)) menu = Menu(menubar, tearoff=0) # menu.add_command(label="Time Chart", command=timechart) return menu # menubar.add_cascade(label="Analyse", menu=analyse_menu()) def help_menu(): def show_about(): t = Toplevel(master) t.title("About") t.transient(master) t.resizable(False, False) Label(t, image=self.img_logo).grid(column=0, row=0, sticky=(E, W)) Label(t, text="Context %s" % VERSION, anchor=CENTER).grid(column=0, row=1, sticky=(E, W)) Label(t, text="(c) 2011-2014 Shish", anchor=CENTER).grid(column=0, row=2, sticky=(E, W)) Button(t, text="Close", command=t.destroy).grid(column=0, row=3, sticky=(E,)) win_center(t) def show_docs(): t = Toplevel(master) t.title("Context Documentation") t.transient(master) scroll = Scrollbar(t, orient=VERTICAL) tx = Text( t, wrap=WORD, yscrollcommand=scroll.set, ) scroll['command'] = tx.yview scroll.pack(side=RIGHT, fill=Y, expand=1) tx.pack(fill=BOTH, expand=1) tx.insert("0.0", b64decode(data.README).replace("\r", "")) tx.configure(state="disabled") tx.focus_set() win_center(t) def show_license(): t = Toplevel(master) t.title("Context Licenses") t.transient(master) scroll = Scrollbar(t, orient=VERTICAL) tx = Text( t, wrap=WORD, yscrollcommand=scroll.set, ) scroll['command'] = tx.yview scroll.pack(side=RIGHT, fill=Y, expand=1) tx.pack(fill=BOTH, expand=1) tx.insert("0.0", b64decode(data.LICENSE).replace("\r", "")) tx.configure(state="disabled") tx.focus_set() win_center(t) menu = Menu(menubar, tearoff=0) menu.add_command(label="About", command=show_about) menu.add_command(label="Documentation", command=show_docs) menu.add_command(label="License", command=show_license) return menu menubar.add_cascade(label="Help", menu=help_menu()) return menubar def __control_box(self, master): f = None def _la(t): Label(f, text=t).pack(side="left") def _sp(fr, t, i, v, w=10): Spinbox(f, from_=fr, to=t, increment=i, textvariable=v, width=w).pack(side="left") f = Frame(master) _la(" Start ") _sp(0, int(time.time()), 10, self.render_start, 15) _la(" Seconds ") _sp(MIN_SEC, MAX_SEC, 1, self.render_len, 3) _la(" Pixels per second ") _sp(MIN_PPS, MAX_PPS, 100, self.scale, 5) _la(" Cutoff (ms) ") _sp(0, 1000, 1, self.render_cutoff, 3) _la(" Coalesce (ms) ") _sp(0, 1000, 1, self.coalesce_threshold, 3) Button(f, text="Render", command=self.update).pack(side=LEFT, fill=Y) # padding=0 f.pack() return f def __bookmarks(self, master): panel = Frame(master) panel.grid_rowconfigure(0, weight=1) bookmarks = Frame(panel) bookmarks.grid_columnconfigure(0, weight=1) bookmarks.grid_rowconfigure(0, weight=1) li = Listbox(bookmarks, width=40) li.grid(column=0, row=0, sticky=(N, E, S, W)) self.bookmarks_list = li sb = Scrollbar(bookmarks, orient=VERTICAL, command=li.yview) sb.grid(column=1, row=0, sticky=(N, S)) li.config(yscrollcommand=sb.set) def _lbox_selected(*args): selected_idx = int(li.curselection()[0]) self.render_start.set(self.bookmarks_values[selected_idx]) self.canvas.xview_moveto(0) if not self.render_auto.get(): self.update() li.bind('<Double-Button-1>', _lbox_selected) bookmarks.grid(column=0, row=0, sticky=(N, E, S, W)) buttons = Frame(panel) Button(buttons, image=self.img_start, command=self.start_event).pack(side="left") Button(buttons, image=self.img_prev, command=self.prev_event).pack(side="left") Button(buttons, image=self.img_end, command=self.end_event).pack(side="right") Button(buttons, image=self.img_next, command=self.next_event).pack(side="right") buttons.grid(column=0, row=1, sticky=(E, W)) return panel def __canvas(self, master): f = Frame(master) f.grid_columnconfigure(0, weight=1) f.grid_rowconfigure(0, weight=1) h = Scrollbar(f, orient=HORIZONTAL) v = Scrollbar(f, orient=VERTICAL) canvas = Canvas( f, background="white", xscrollcommand=h.set, yscrollcommand=v.set, ) h['command'] = canvas.xview v['command'] = canvas.yview canvas.bind("<4>", lambda e: self.scale_view(e, 1.0 * 1.1)) canvas.bind("<5>", lambda e: self.scale_view(e, 1.0 / 1.1)) # in windows, mouse wheel events always go to the root window o_O self.master.bind("<MouseWheel>", lambda e: self.scale_view( e, ((1.0 * 1.1) if e.delta > 0 else (1.0 / 1.1)) )) # Drag based movement # def _sm(e): # self.st = self.render_start.get() # self.sx = e.x # self.sy = e.y # def _cm(e): # self.render_start.set(self.st + float(self.sx - e.x)/self.scale.get()) # self.render() # self.canvas.bind("<1>", _sm) # self.canvas.bind("<B1-Motion>", _cm) canvas.grid(column=0, row=0, sticky=(N, W, E, S)) v.grid(column=1, row=0, sticky=(N, S)) h.grid(column=0, row=1, sticky=(W, E)) self.canvas = canvas return f def __scrubber(self, master): sc = Canvas( master, width=800, height=SCRUBBER_HEIGHT, background="white", ) def sc_goto(e): width_fraction = float(e.x) / sc.winfo_width() ev_s = self.get_earliest_bookmark_after(0) ev_e = self.get_latest_bookmark_before(sys.maxint) ev_l = ev_e - ev_s self.render_start.set(ev_s + ev_l * width_fraction - float(self.render_len.get()) / 2) if not self.render_auto.get(): self.update() self.canvas.xview_moveto(0.5) sc.bind("<1>", sc_goto) def resize(event): if self.c: self.render_scrubber_activity() self.render_scrubber_arrow() # sc.coords(line, 0, 0, event.width, event.height) sc.bind("<Configure>", resize) return sc def __init__(self, master, database_file): self.master = master self.bookmarks_values = [] self.bookmarks_list = None self.canvas = None self.scrubber = None # render is called before init finished? self.char_w = -1 self.soft_scale = 1.0 self.window_ready = False self.data = [] self.sc_activity = None self.original_texts = {} self.tooltips = {} self.event_idx_offset = 0 self._last_log_dir = os.path.expanduser("~/") self.c = None # database connection try: os.makedirs(os.path.expanduser(os.path.join("~", ".config"))) except OSError: pass self.config_file = os.path.expanduser(os.path.join("~", ".config", "context.cfg")) self.threads = [] self.render_start = DoubleVar(master, 0) self.render_len = IntVar(master, 10) self.render_cutoff = IntVar(master, 1) self.coalesce_threshold = IntVar(master, 1) self.render_auto = IntVar(master, 1) self.scale = IntVar(master, 1000) self.load_settings() master.protocol("WM_DELETE_WINDOW", self.save_settings_and_quit) self.render_start.trace_variable("w", lambda *x: conditional(self.render_auto, self.update)) self.render_len.trace_variable("w", lambda *x: conditional(self.render_auto, self.update)) self.render_cutoff.trace_variable("w", lambda *x: conditional(self.render_auto, self.render)) self.coalesce_threshold.trace_variable("w", lambda *x: conditional(self.render_auto, self.update)) self.scale.trace_variable("w", lambda *x: conditional(self.render_auto, self.render)) self.img_start = PhotoImage(data=data.start) self.img_prev = PhotoImage(data=data.prev) self.img_next = PhotoImage(data=data.next) self.img_end = PhotoImage(data=data.end) self.img_logo = PhotoImage(data=data.context_name) menu = self.__menu(master) controls_panel = self.__control_box(master) bookmarks_panel = self.__bookmarks(master) canvas_panel = self.__canvas(master) scrubber = self.__scrubber(master) status = Label(master, text="") if have_ttk: grip = Sizegrip(master) else: grip = Label(master, text="") master.grid_columnconfigure(1, weight=1) master.grid_rowconfigure(1, weight=1) master.config(menu=menu) controls_panel.grid(column=0, row=0, sticky=(W, E), columnspan=2) bookmarks_panel.grid(column=0, row=1, sticky=(N, W, E, S)) canvas_panel.grid(column=1, row=1, sticky=(N, E, S, W)) scrubber.grid(column=0, row=2, sticky=(W, E), columnspan=2) status.grid(column=0, row=3, sticky=(W, E), columnspan=2) grip.grid(column=1, row=3, sticky=(S, E)) self.scrubber = scrubber self.status = status self.master.update() self.window_ready = True if database_file: self.load_file(database_file) def set_status(self, text): if text: print(text) self.status.config(text=text) self.master.update() ######################################################################### # Open file ######################################################################### def open_file(self): filename = askopenfilename( filetypes=[ ("All Supported Types", "*.ctxt *.cbin"), ("Context Text", "*.ctxt"), ("Context Binary", "*.cbin") ], initialdir=self._last_log_dir ) if filename: try: self.load_file(filename) except Exception as e: self.set_status("Error loading file: %s" % str(e)) def load_file(self, given_file): if not os.path.exists(given_file): showerror("Error", "Context dump file '%s' does not exist" % given_file) return self._last_log_dir = os.path.dirname(given_file) path, _ext = os.path.splitext(given_file) log_file = path + ".ctxt" database_file = path + ".cbin" # if the user picked a log file, compile it (unless an # up-to-date version already exists) if given_file == log_file: needs_recompile = False if not os.path.exists(database_file): needs_recompile = True self.set_status("Compiled log not found, compiling") elif os.stat(log_file).st_mtime > os.stat(database_file).st_mtime: needs_recompile = True self.set_status("Compiled log is out of date, recompiling") elif not version_check(database_file): needs_recompile = True self.set_status("Compiled log is from an old version of context, recompiling") if needs_recompile: compiler = subprocess.Popen(["context-compiler", log_file], stdout=subprocess.PIPE) while True: line = compiler.stdout.readline() if line: self.set_status(line.strip()) else: break self.c = sqlite3.connect(database_file) self.data = [] # don't load the bulk of the data yet self.load_bookmarks(self.c) self.load_summary(self.c) self.load_threads(self.c) self.master.title(NAME + ": " + database_file) # render grid + scrubber self.render() self.event_idx_offset = self.get_earliest_bookmark_after(0) self.render_start.set(self.event_idx_offset) def load_bookmarks(self, conn): self.bookmarks_values = [] self.bookmarks_list.delete(0, END) for ts, tx, et in conn.execute(""" SELECT start_time, start_text, end_text FROM events WHERE start_type = 'BMARK' ORDER BY start_time """): tss = datetime.datetime.fromtimestamp(ts).strftime("%Y/%m/%d %H:%M:%S") # .%f self.bookmarks_values.append(ts) self.bookmarks_list.insert(END, "%s: %s" % (tss, tx or et)) def load_threads(self, conn): # fast because the data is split off into a tiny table self.threads = [ "-".join([str(c) for c in r]) for r in conn.execute("SELECT node, process, thread FROM threads ORDER BY id") ] def load_summary(self, conn): self.sc_activity = [row[0] for row in conn.execute("SELECT events FROM summary ORDER BY id")] ######################################################################### # Settings ######################################################################### def load_settings(self): try: cp = ConfigParser.SafeConfigParser() cp.readfp(file(self.config_file)) if cp.has_section("gui"): if cp.has_option("gui", "render_len"): self.render_len.set(cp.getint("gui", "render_len")) if cp.has_option("gui", "scale"): self.scale.set(cp.getint("gui", "scale")) if cp.has_option("gui", "render_cutoff"): self.render_cutoff.set(cp.getint("gui", "render_cutoff")) if cp.has_option("gui", "coalesce_threshold"): self.coalesce_threshold.set(cp.getint("gui", "coalesce_threshold")) if cp.has_option("gui", "render_auto"): self.render_auto.set(cp.getint("gui", "render_auto")) if cp.has_option("gui", "last_log_dir"): self._last_log_dir = cp.get("gui", "last_log_dir") except Exception as e: print("Error loading settings from %s:\n %s" % (self.config_file, e)) def save_settings(self): try: cp = ConfigParser.SafeConfigParser() cp.add_section("gui") cp.set("gui", "render_len", str(self.render_len.get())) cp.set("gui", "scale", str(self.scale.get())) cp.set("gui", "render_cutoff", str(self.render_cutoff.get())) cp.set("gui", "coalesce_threshold", str(self.coalesce_threshold.get())) cp.set("gui", "render_auto", str(self.render_auto.get())) cp.set("gui", "last_log_dir", self._last_log_dir) cp.write(file(self.config_file, "w")) except Exception as e: print("Error writing settings to %s:\n %s" % (self.config_file, e)) def save_settings_and_quit(self): self.save_settings() self.master.destroy() self.master.quit() ######################################################################### # Navigation ######################################################################### def get_earliest_bookmark_after(self, start_hint=0): return list(self.c.execute( "SELECT min(start_time) FROM events WHERE start_time > ? AND start_type = 'BMARK'", [start_hint, ] ))[0][0] def get_latest_bookmark_before(self, end_hint=0): return list(self.c.execute( "SELECT max(start_time) FROM events WHERE start_time < ? AND start_type = 'BMARK'", [end_hint, ] ))[0][0] def end_event(self): next_ts = self.get_latest_bookmark_before(sys.maxint) if next_ts: self.render_start.set(next_ts) self.canvas.xview_moveto(0) def next_event(self): next_ts = self.get_earliest_bookmark_after(self.render_start.get()) if next_ts: self.render_start.set(next_ts) self.canvas.xview_moveto(0) def prev_event(self): prev_ts = self.get_latest_bookmark_before(self.render_start.get()) if prev_ts: self.render_start.set(prev_ts) self.canvas.xview_moveto(0) def start_event(self): next_ts = self.get_earliest_bookmark_after(0) if next_ts: self.render_start.set(next_ts) self.canvas.xview_moveto(0) ######################################################################### # Rendering ######################################################################### def scale_view(self, e=None, n=1.0): # get the old pos if e: _xv = self.canvas.xview() left_edge = _xv[0] width = _xv[1] - _xv[0] width_fraction = float(e.x) / self.canvas.winfo_width() x_pos = left_edge + width * width_fraction # scale if n != 1: self.soft_scale *= n self.canvas.scale("event", 0, 0, n, 1) self.canvas.scale("lock", 0, 0, n, 1) for t in self.canvas.find_withtag("time_label"): val = self.canvas.itemcget(t, 'text')[2:] self.canvas.itemconfigure(t, text=" +%.4f" % (float(val) / n)) for t in self.canvas.find_withtag("event_tip"): self.canvas.itemconfigure(t, width=float(self.canvas.itemcget(t, 'width')) * n) # this seems slow? sure something similar was faster... for t in self.canvas.find_withtag("event_label"): self.canvas.itemconfigure(t, width=float(self.canvas.itemcget(t, 'width')) * n) # this seems slow? sure something similar was faster... w = int(self.canvas.itemcget(t, 'width')) tx = self.truncate_text(" " + self.original_texts[t], w) self.canvas.itemconfigure(t, text=tx) # this seems slow? sure something similar was faster... self.canvas.delete("grid") self.render_base() self.canvas.configure(scrollregion=shrink(self.canvas.bbox("grid"), 2)) # scroll the canvas so that the mouse still points to the same place if e: _xv = self.canvas.xview() new_width = _xv[1] - _xv[0] self.canvas.xview_moveto(x_pos - new_width * width_fraction) def truncate_text(self, text, w): return text.split("\n")[0][:w / self.char_w] def update(self): self.update_events() self.render() def update_events(self): """ Data settings changed, get new data and re-render """ if not self.window_ready: # update() is called a couple of times during init() return try: s = self.render_start.get() e = self.render_start.get() + self.render_len.get() threshold = float(self.coalesce_threshold.get()) / 1000.0 except ValueError: return try: self.n = 0 self.data = [] # free memory # thread_level_starts = [[], ] * len(self.threads) # this bug is subtle and hilarious thread_level_ends = [[] for _ in self.threads] def progress(*args): try: self.n += 1 self.set_status("Loading... (%dk opcodes)" % (self.n * 10)) return 0 except Exception as e: return 1 # non-zero = cancel query self.c.set_progress_handler(progress, 10000) try: for row in self.c.execute( """ SELECT * FROM events WHERE id IN (SELECT id FROM events_index WHERE end_time > ? AND start_time < ?) AND (end_time - start_time) * 1000 >= ? ORDER BY start_time ASC, end_time DESC """, (s - self.event_idx_offset, e - self.event_idx_offset, self.render_cutoff.get()) ): event = Event(row) thread_idx = event.thread_id if event.start_type == "START": prev_event_at_level = None while thread_level_ends[thread_idx] and thread_level_ends[thread_idx][-1].end_time <= event.start_time: prev_event_at_level = thread_level_ends[thread_idx].pop() event.depth = len(thread_level_ends[thread_idx]) if ( threshold and prev_event_at_level and prev_event_at_level.can_merge(event, threshold) ): prev_event_at_level.merge(event) thread_level_ends[thread_idx].append(prev_event_at_level) else: thread_level_ends[thread_idx].append(event) self.data.append(event) else: self.data.append(event) except sqlite3.OperationalError: pass self.c.set_progress_handler(None, 0) finally: self.set_status("") def render(self): """ Render settings changed, re-render with existing data """ if not self.window_ready: return if not MIN_PPS < self.scale.get() < MAX_PPS: return self.soft_scale = 1.0 self.render_clear() self.render_scrubber_activity() self.render_scrubber_arrow() self.render_base() self.render_data() def render_clear(self): """ clear the canvas and any cached variables """ self.canvas.delete(ALL) self.original_texts = {} self.tooltips = {} self.canvas.configure(scrollregion=( 0, 0, self.render_len.get() * self.scale.get(), len(self.threads) * (MAX_DEPTH * BLOCK_HEIGHT) + HEADER_HEIGHT )) if self.char_w == -1: t = self.canvas.create_text(0, 0, font="TkFixedFont", text="_", anchor=NW) bb = self.canvas.bbox(t) # [2]-[0]=10, but trying by hand, 8px looks better on win7 # 7px looks right on linux, not sure what [2]-[0] is there, # hopefully 9px, so "-2" always helps? self.char_w = bb[2] - bb[0] - 2 self.canvas.delete(t) def render_scrubber_activity(self, length=None): sc = self.scrubber if not sc: return if self.sc_activity is not None: sc.delete("activity") activity_peak = max(self.sc_activity) if activity_peak == 0: return for n in range(0, length or len(self.sc_activity)): col = gen_colour(self.sc_activity[n], activity_peak) sc.create_rectangle( int(float(n) / len(self.sc_activity) * sc.winfo_width()), 1, int(float(n + 1) / len(self.sc_activity) * sc.winfo_width()), SCRUBBER_HEIGHT, fill=col, outline=col, tags="activity", ) def render_scrubber_arrow(self): sc = self.scrubber if not self.window_ready: return if not sc: return # events start / end / length ev_s = self.get_earliest_bookmark_after(0) ev_e = self.get_latest_bookmark_before(sys.maxint) ev_l = ev_e - ev_s if ev_l == 0: # only one bookmark return # view start / end / length vi_s = self.render_start.get() vi_e = self.render_start.get() + self.render_len.get() # vi_l = vi_e - vi_s # scrubber width sc_w = sc.winfo_width() sc.delete("arrow") # arrow start_abs = vi_s start_rel = start_abs - ev_s start_fraction = start_rel / ev_l start_scaled = start_fraction * sc_w start = start_scaled end_abs = vi_e end_rel = end_abs - ev_s end_fraction = end_rel / ev_l end_scaled = end_fraction * sc_w end = end_scaled # left edge sc.create_line( start, 1, start, SCRUBBER_HEIGHT, fill="#000", tags="arrow", ) sc.create_line( start, SCRUBBER_HEIGHT/2, start + 5, 15, fill="#000", tags="arrow", ) sc.create_line( start, SCRUBBER_HEIGHT/2, start + 5, 5, fill="#000", tags="arrow", ) # right edge sc.create_line( end, 1, end, SCRUBBER_HEIGHT, fill="#000", tags="arrow", ) sc.create_line( end, SCRUBBER_HEIGHT/2, end - 5, 15, fill="#000", tags="arrow", ) sc.create_line( end, SCRUBBER_HEIGHT/2, end - 5, 5, fill="#000", tags="arrow", ) # join sc.create_line( start, SCRUBBER_HEIGHT/2, end, SCRUBBER_HEIGHT/2, fill="#000", tags="arrow", ) def render_base(self): """ Render grid lines and markers """ _rl = self.render_len.get() _sc = self.scale.get() * self.soft_scale rs_px = int(_rl * _sc) rl_px = int(_rl * _sc) for n in range(rs_px, rs_px + rl_px, 100): label = " +%.4f" % (float(n) / _sc - _rl) self.canvas.create_line(n - rs_px, 0, n - rs_px, HEADER_HEIGHT + len(self.threads) * MAX_DEPTH * BLOCK_HEIGHT, fill="#CCC", tags="grid") self.canvas.create_text(n - rs_px, 5, text=label, anchor=NW, tags="time_label grid") for n in range(0, len(self.threads)): self.canvas.create_line(0, HEADER_HEIGHT + MAX_DEPTH * BLOCK_HEIGHT * n, rl_px, HEADER_HEIGHT + MAX_DEPTH * BLOCK_HEIGHT * n, tags="grid") self.canvas.create_text(0, HEADER_HEIGHT + MAX_DEPTH * BLOCK_HEIGHT * (n + 1) - 5, text=" " + self.threads[n], anchor=SW, tags="grid") self.canvas.tag_lower("grid") def render_data(self): """ add the event rectangles """ if not self.window_ready: # update() is called a couple of times during init() return _rs = self.render_start.get() _rc = self.render_cutoff.get() _sc = self.scale.get() event_count = len(self.data) - 1 shown = 0 for n, event in enumerate(self.data): if n % 1000 == 0 or n == event_count: self.set_status("Rendered %d events (%d%%)" % (n, float(n) * 100 / event_count)) self.master.update() thread_idx = event.thread_id if event.start_type == "START": if (event.end_time - event.start_time) * 1000 < _rc: continue if event.depth >= MAX_DEPTH: continue shown += 1 if shown == 500 and VERSION.endswith("-demo"): showerror("Demo Limit", "The evaluation build is limited to showing 500 events at a time, so rendering has stopped") break self.show_event( event, _rs, _sc, thread_idx, ) elif event.start_type == "BMARK": # note that when loading data, we currently filter for # "start_type=START" for a massive indexed speed boost # so there are no bookmarks. We may want to load bookmarks # into a separate array? pass # render bookmark elif event.start_type == "LOCKW" or event.start_type == "LOCKA": self.show_lock( event, _rs, _sc, thread_idx, ) self.set_status("") def show_event(self, event, offset_time, scale_factor, thread): function = event.start_location ok = event.end_type == "ENDOK" start_px = int((event.start_time - offset_time) * scale_factor) length_px = int(event.length * scale_factor) tip = "%dms @%dms: %s\n%s" % ( (event.end_time - event.start_time) * 1000, (event.start_time - offset_time) * 1000, function, event.text ) fill = "#CFC" if ok else "#FCC" outl = "#484" if ok else "#844" r = self.canvas.create_rectangle( start_px, HEADER_HEIGHT + thread * MAX_DEPTH * BLOCK_HEIGHT + event.depth * BLOCK_HEIGHT, start_px + length_px, HEADER_HEIGHT + thread * MAX_DEPTH * BLOCK_HEIGHT + event.depth * BLOCK_HEIGHT + BLOCK_HEIGHT, fill=fill, outline=outl, tags="event", ) t = self.canvas.create_text( start_px, HEADER_HEIGHT + thread * MAX_DEPTH * BLOCK_HEIGHT + event.depth * BLOCK_HEIGHT + 3, text=self.truncate_text(" " + event.text, length_px), tags="event event_label", anchor=NW, width=length_px, font="TkFixedFont", state="disabled", ) self.canvas.tag_raise(r) self.canvas.tag_raise(t) self.canvas.tag_bind(r, "<1>", lambda e: self._focus(r)) self.original_texts[t] = event.text self.tooltips[r] = tip self.canvas.tag_bind(r, "<Enter>", lambda e: self._ttip_show(r)) self.canvas.tag_bind(r, "<Leave>", lambda e: self._ttip_hide()) def show_lock(self, event, offset_time, scale_factor, thread): start_px = int((event.start_time - offset_time) * scale_factor) length_px = int(event.length * scale_factor) fill = "#FDD" if event.start_type == "LOCKW" else "#DDF" r = self.canvas.create_rectangle( start_px, HEADER_HEIGHT + thread * MAX_DEPTH * BLOCK_HEIGHT, start_px + length_px, HEADER_HEIGHT + (thread + 1) * MAX_DEPTH * BLOCK_HEIGHT, fill=fill, outline=fill, tags="lock", ) t = self.canvas.create_text( start_px + length_px, HEADER_HEIGHT + (thread + 1) * MAX_DEPTH * BLOCK_HEIGHT, text=self.truncate_text(event.text, length_px), tags="lock lock_label", anchor=SE, width=length_px, font="TkFixedFont", state="disabled", fill="#888", ) self.canvas.tag_lower(t) self.canvas.tag_lower(r) def _focus(self, r): # scale the canvas so that the (selected item width + padding == screen width) view_w = self.canvas.winfo_width() rect_w = max(self.canvas.bbox(r)[2] - self.canvas.bbox(r)[0] + HEADER_HEIGHT, 10) self.scale_view(n=float(view_w) / rect_w) # move the view so that the selected (item x1 = left edge of screen + padding) canvas_w = self.canvas.bbox("grid")[2] rect_x = self.canvas.bbox(r)[0] - 5 self.canvas.xview_moveto(float(rect_x) / canvas_w) def _ttip_show(self, r): tip = self.tooltips[r] x0, y0, x1, y1 = self.canvas.bbox(r) if x0 < 0: x1 = x1 - x0 x0 = x0 - x0 t2 = self.canvas.create_text( x0 + 4, y0 + BLOCK_HEIGHT + 4, text=tip.strip(), width=400, tags="tooltip", anchor=NW, justify="left", state="disabled", ) x0, y0, x1, y1 = self.canvas.bbox(t2) r2 = self.canvas.create_rectangle( x0 - 2, y0 - 1, x1 + 2, y1 + 2, state="disabled", fill="#FFA", outline="#AA8", tags="tooltip" ) self.canvas.tag_raise(t2) def _ttip_hide(self): self.canvas.delete("tooltip")
def gui(): from Tkinter import Tk, Label, Entry,Button, Scale, Checkbutton,W,HORIZONTAL, Frame, StringVar, IntVar, DoubleVar, Radiobutton, BooleanVar, E global root root = Tk() root.wm_title("Compute R_complete") line = 0 global insFile, hklFile, nHKL, nParams, nHKLLabel, fracFree, status, nParamsLabel, nCPU, rCompleteLabel, cycles, lsType, cleanup,nFree, nRunsLabel, mergeCheck, compileMap insFile = StringVar() hklFile = StringVar() nHKL = IntVar() nParams = IntVar() nFree = IntVar() fracFree = DoubleVar() fracFree.set(5.0) nCPU = IntVar() nCPU.set(maxCPU) cycles = IntVar() cycles.set(10) lsType = IntVar() lsType.set(1) cleanup = BooleanVar() cleanup.set(True) mergeCheck = BooleanVar() mergeCheck.set(True) compileMap = BooleanVar() compileMap.set(True) Label(root, text='Instruction File:').grid(row=line, column=0, sticky=E) Entry(root, textvariable=insFile).grid(row=line, column=1) Button(root, text='Browse', command=browseINS).grid(row=line, column=2) line += 1 Label(root, text='Reflection File:').grid(row=line, column=0, sticky=E) Entry(root, textvariable=hklFile).grid(row=line, column=1) Button(root, text='Browse', command=browseHKL).grid(row=line, column=2) line += 1 Checkbutton(root, var=mergeCheck, text='Merge Reflections').grid(row=line, column=1, sticky=W) line += 1 Button(root, text='Load', command=load).grid(row=line, columnspan=3) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='# of reflections:').grid(row=line, sticky=E) nHKLLabel = Label(root, text='???') nHKLLabel.grid(row=line, column=1, sticky=W) line += 1 Label(root, text='# of atoms:').grid(row=line, sticky=E) nParamsLabel = Label(root, text='???') nParamsLabel.grid(row=line, column=1, sticky=W) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='Select Parameters').grid(row=line, column=1) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='# of free reflections:').grid(row=line, sticky=E) nFreeEntry = Entry(root, width=5, textvariable=nFree) nFreeEntry.grid(row=line, column=1, sticky=W) nFreeEntry.bind('<Return>', setScale) nRunsLabel = Label(root, text='# runs') nRunsLabel.grid(row=line, column=2) line += 1 Label(root, text='% of free reflections:').grid(row=line, column=0, sticky=E) w = Scale(root, from_=0.1, to=10.0, resolution=0.1, orient=HORIZONTAL, length=200, var=fracFree, command=percentScale) w.grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Label(root, text='stable <-------------------------------> fast').grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Frame(root, height=10).grid(row=line) line += 1 Label(root, text='Refinement cycles:').grid(row=line, column=0, sticky=E) ls = Scale(root, from_=0, to=50, resolution=1, orient=HORIZONTAL, length=200, var=cycles) ls.grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Label(root, text='fast <--------------------> less model bias').grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Frame(root, height=10).grid(row=line) line += 1 Label(root, text='# of CPUs:').grid(row=line, column=0, sticky=E) ww = Scale(root, from_=1, to=maxCPU, orient=HORIZONTAL, length=200, var=nCPU) ww.grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Label(root, text='Refinement Type:').grid(row=line, column=0, sticky=E) Radiobutton(root, text='CGLS', var=lsType, value=1).grid(row=line, column=1, sticky=W) Radiobutton(root, text='L.S.', var=lsType, value=2).grid(row=line, column=2, sticky=W) line += 1 Frame(root, height=10).grid(row=line) line += 1 Label(root, text='Compile map:').grid(row=line, column=0, sticky=E) Checkbutton(root, var=compileMap).grid(row=line, column=1, sticky=W) line += 1 Label(root, text='Cleanup:').grid(row=line, column=0, sticky=E) Checkbutton(root, var=cleanup).grid(row=line, column=1, sticky=W) line += 1 Button(root, text='RUN', command=run, width=25).grid(row=line, columnspan=3) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='R_complete:').grid(row=line, column=0, sticky=E) rCompleteLabel = Label(root, text='???') rCompleteLabel.grid(row=line, column=1, sticky=W) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='Status:').grid(row=line, column=0, sticky=E) status = Label(root, text='Idle... Please load files.') status.grid(row=line, column=1, columnspan=2, sticky=W) global IDLE IDLE = True root.mainloop()
def set(self, value): DoubleVar.set(self, round(value, self.precision))
class GradientPatternFrame(PatternFrame): def __init__(self, master=None, **kw): apply(PatternFrame.__init__, (self, master), kw) gradient = CreateSimpleGradient(StandardColors.white, StandardColors.black) frame = Frame(self) frame.pack(side = TOP, fill = X) self.var_gradient_type = IntVar(self) for value, bitmap in [(0, 'linear'), (1, 'conical'), (2, 'radial')]: bitmap = getattr(pixmaps, 'gradient_' + bitmap) button = make_button(frame, bitmap = bitmap, value = value, variable = self.var_gradient_type, command = self.choose_type) button.pack(side = LEFT, fill = X, expand = 1) frame = Frame(self) frame.pack(side = TOP, expand = 1, fill = X) self.colors = [None, None] self.colors[0] = ColorButton(frame, height = 1, color = gradient.StartColor(), command = self.set_color, args = 0) self.colors[0].pack(side = LEFT, fill = X, expand = 1) self.colors[1] = ColorButton(frame, height = 1, color = gradient.EndColor(), command = self.set_color, args = 1) self.colors[1].pack(side = LEFT, fill = X, expand = 1) self.var_border = DoubleVar(self) self.var_border.set(0.0) frame = Frame(self) frame.pack(side = TOP, fill = X, expand = 1) label = Label(frame, text = _("Border")) label.pack(side = LEFT, expand = 1, anchor = E) entry = MyEntry(frame, textvariable = self.var_border, width = 4, justify = RIGHT, command = self.set_border) entry.pack(side = LEFT, expand = 1, fill = X) scroll = MiniScroller(frame, variable = self.var_border, min = 0.0, max = 100.0, step = 1.0, command = self.set_border) scroll.pack(side = LEFT, fill = Y) button = UpdatedButton(self, text = _("Edit Gradient"), command = self.edit_gradient) button.pack(side = TOP, fill = X) pattern = LinearGradient(gradient) self.SetPattern(pattern) def set_color(self, idx): self.gradient = self.gradient.Duplicate() self.gradient.SetStartColor(self.__get_color(0)) self.gradient.SetEndColor(self.__get_color(1)) self.pattern = self.pattern.Duplicate() self.pattern.SetGradient(self.gradient) self.issue(CHANGED) def __get_color(self, idx): return self.colors[idx].Color() def choose_type(self): type = gradient_types[self.var_gradient_type.get()] self.pattern = type(duplicate = self.pattern) self.issue(CHANGED) def set_border(self, *rest): border = self.var_border.get() / 100.0 if hasattr(self.pattern, 'SetBorder'): self.pattern = self.pattern.Duplicate() self.pattern.SetBorder(border) self.issue(CHANGED) def SetPattern(self, pattern): PatternFrame.SetPattern(self, pattern) self.gradient = gradient = pattern.Gradient().Duplicate() self.var_gradient_type.set(gradient_types.index(pattern.__class__)) self.colors[0].SetColor(gradient.StartColor()) self.colors[1].SetColor(gradient.EndColor()) if hasattr(pattern, 'Border'): self.var_border.set(pattern.Border() * 100.0) def Center(self): if self.pattern.__class__ == LinearGradient: return (0.5, 0.5) return tuple(self.pattern.Center()) def SetCenter(self, center): if self.pattern.__class__ == LinearGradient: return p = apply(Point, center) self.pattern = self.pattern.Duplicate() self.pattern.SetCenter(p) self.issue(CHANGED) def SetDirection(self, dir): if self.pattern.__class__ == RadialGradient: return dir = apply(Point, dir) self.pattern = self.pattern.Duplicate() self.pattern.SetDirection(dir) self.issue(CHANGED) def EditModes(self): if self.pattern.__class__ == LinearGradient: return (0, 1) elif self.pattern.__class__ == RadialGradient: return (1, 0) else: return (1, 1) def edit_gradient(self): gradient = gradientedit.EditGradient(self, self.gradient) if gradient is not None: pattern = self.pattern.Duplicate() pattern.SetGradient(gradient) self.SetPattern(pattern) self.issue(CHANGED)
filename_button = Button(root, text=names[0], command = lambda : filename_value.set(askopenfilename())) filename_entry = Entry(root, textvariable=filename_value, justify='left') nA_label = Label(root, text=names[1]) nA_value = IntVar(); nA_value.set(nA_default) nA_entry = Entry(root, textvariable=nA_value) nB_label = Label(root, text=names[2]) nB_value = IntVar(); nB_value.set(nB_default) nB_entry = Entry(root, textvariable=nB_value) nobinning_label = Label(root, text='DO NOT USE BINNING') nobinning_value = IntVar(); nobinning_value.set(1) nobinning_check = Checkbutton(root, variable=nobinning_value, onvalue=1, offvalue=0, command=check_binning) p_label = Label(root, text=names[3]) p_value = IntVar(); p_value.set(p_default) p_entry = Entry(root, textvariable=p_value) fbL_label = Label(root, text=names[4]) fbL_value = DoubleVar(); fbL_value.set(fbL_default) fbL_entry = Entry(root, textvariable=fbL_value) fbH_label = Label(root, text=names[5]) fbH_value = DoubleVar(); fbH_value.set(fbH_default) fbH_entry = Entry(root, textvariable=fbH_value) binchoice_label = Label(root, text=names[6]) binchoice_frame = Frame(root) binchoice_value = StringVar() equal = Radiobutton(binchoice_frame,text='equal',variable=binchoice_value,value='equal',command=check_binchoice) equal.select() adaptive = Radiobutton(binchoice_frame,text='adaptive',variable=binchoice_value,value='adaptive',command=check_binchoice) equal.grid(row=0,column=0) adaptive.grid(row=0,column=1) binchoice_frame.grid() fitType_label = Label(root, text=names[7]) fitType_frame = Frame(root)
class ExportParasClass: def __init__(self, frame=None, config=None, postpro=None): self.frame = frame self.initialise_textvariables() self.generate_entryfields(config) #self.change_entry_state(NORMAL) def initialise_textvariables(self): self.tool_dia = DoubleVar() self.tool_dia.set(0.0) self.start_rad = DoubleVar() self.start_rad.set(0.0) self.axis3_retract = DoubleVar() self.axis3_retract.set(0.0) self.axis3_safe_margin = DoubleVar() self.axis3_safe_margin.set(0.0) self.axis3_slice_depth = DoubleVar() self.axis3_slice_depth.set(0.0) self.axis3_mill_depth = DoubleVar() self.axis3_mill_depth.set(0.0) self.F_G1_Depth = DoubleVar() self.F_G1_Depth.set(0.0) self.F_G1_Plane = DoubleVar() self.F_G1_Plane.set(0.0) def generate_entryfields(self, config): self.entries = [] f1 = Frame(self.frame, relief=GROOVE, bd=2) f1.grid(row=1, column=0, padx=2, pady=2, sticky=N + W + E) f2 = Frame(self.frame, relief=GROOVE, bd=2) f2.grid(row=2, column=0, padx=2, pady=2, sticky=N + W + E) f3 = Frame(self.frame, relief=GROOVE, bd=2) f3.grid(row=3, column=0, padx=2, pady=2, sticky=N + W + E) f1.columnconfigure(0, weight=1) f2.columnconfigure(0, weight=1) f3.columnconfigure(0, weight=1) Label(f1, text=_("Tool diameter [mm]:"))\ .grid(row=0, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f1, width=7, textvariable=self.tool_dia, state=DISABLED)) self.entries[-1].grid(row=0, column=1, sticky=N + E) Label(f1, text=_("Start radius (for tool comp.) [mm]:"))\ .grid(row=1, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f1, width=7, textvariable=self.start_rad, state=DISABLED)) self.entries[-1].grid(row=1, column=1, sticky=N + E) Label(f2, text=(_("%s safety margin [mm]:") % config.ax3_letter))\ .grid(row=1, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f2, width=7, textvariable=self.axis3_safe_margin, state=DISABLED)) self.entries[-1].grid(row=1, column=1, sticky=N + E) Label(f2, text=(_("%s infeed depth [mm]:") % config.ax3_letter))\ .grid(row=2, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f2, width=7, textvariable=self.axis3_slice_depth, state=DISABLED)) self.entries[-1].grid(row=2, column=1, sticky=N + E) Label(f2, text=(_("%s mill depth [mm]:") % config.ax3_letter))\ .grid(row=3, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f2, width=7, textvariable=self.axis3_mill_depth, state=DISABLED)) self.entries[-1].grid(row=3, column=1, sticky=N + E) Label(f3, text=(_("G1 feed %s-direction [mm/min]:") % config.ax3_letter))\ .grid(row=1, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f3, width=7, textvariable=self.F_G1_Depth, state=DISABLED)) self.entries[-1].grid(row=1, column=1, sticky=N + E) Label(f3, text=(_("G1 feed %s%s-direction [mm/min]:") % (config.ax1_letter, config.ax2_letter)))\ .grid(row=2, column=0, sticky=N + W, padx=4) self.entries.append(Entry(f3, width=7, textvariable=self.F_G1_Plane, state=DISABLED)) self.entries[-1].grid(row=2, column=1, sticky=N + E) def change_entry_state(self, state=DISABLED): for entry in self.entries: entry.config(state=state) def ShowParas(self, LayerContent): print 'Kommt noch'
class Cockpit(ttkFrame): ''' Remote device GUI ''' #TODO: 20160415 DPM - Set these values from configuration file #--- config THROTTLE_BY_USER = True THROTTLE_RESOLUTION = 0.1 # Joystick enabled or not, if any JOYSTICK_ENABLED = True DEFAULT_DRONE_IP = "192.168.1.130" DEFAULT_DRONE_PORT = 2121 #--- end config KEY_ANG_SPEED = "ang-speed" KEY_ANGLES = "angles" KEY_ACCEL = "accel" PID_KEYS = ["P", "I", "D"] DIR_NONE = 0 DIR_VERTICAL = 1 DIR_HORIZONTAL = 2 def __init__(self, parent, isDummy = False, droneIp = DEFAULT_DRONE_IP, dronePort = DEFAULT_DRONE_PORT): ''' Constructor ''' ttkFrame.__init__(self, parent) self._target = [0.0] * 4 self._selectedPidConstats = "--" self._pidConstants = { Cockpit.KEY_ANG_SPEED:{ "X":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Y":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Z":{ "P": 0.0, "I": 0.0, "D": 0.0 } }, Cockpit.KEY_ANGLES: { "X":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Y":{ "P": 0.0, "I": 0.0, "D": 0.0 } }, Cockpit.KEY_ACCEL:{ "X":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Y":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Z":{ "P": 0.0, "I": 0.0, "D": 0.0 } } } self.parent = parent self.initUI() self._controlKeysLocked = False if not isDummy: self._link = INetLink(droneIp, dronePort) else: self._link = ConsoleLink() self._link.open() self._updateInfoThread = Thread(target=self._updateInfo) self._updateInfoThreadRunning = False self._readingState = False self._start() def initUI(self): self.parent.title("Drone control") self.style = Style() self.style.theme_use("default") self.pack(fill=BOTH, expand=1) self.parent.bind_all("<Key>", self._keyDown) self.parent.bind_all("<KeyRelease>", self._keyUp) if system() == "Linux": self.parent.bind_all("<Button-4>", self._onMouseWheelUp) self.parent.bind_all("<Button-5>", self._onMouseWheelDown) else: #case of Windows self.parent.bind_all("<MouseWheel>", self._onMouseWheel) #Commands commandsFrame = tkFrame(self) commandsFrame.grid(column=0, row=0, sticky="WE") self._started = IntVar() self._startedCB = Checkbutton(commandsFrame, text="On", variable=self._started, command=self._startedCBChanged) self._startedCB.pack(side=LEFT, padx=4) # self._integralsCB = Checkbutton(commandsFrame, text="Int.", variable=self._integralsEnabled, \ # command=self._integralsCBChanged, state=DISABLED) # self._integralsCB.pack(side=LEFT, padx=4) self._quitButton = Button(commandsFrame, text="Quit", command=self.exit) self._quitButton.pack(side=LEFT, padx=2, pady=2) # self._angleLbl = Label(commandsFrame, text="Angle") # self._angleLbl.pack(side=LEFT, padx=4) # # self._angleEntry = Entry(commandsFrame, state=DISABLED) # self._angleEntry.pack(side=LEFT) #Info infoFrame = tkFrame(self) infoFrame.grid(column=1, row=1, sticky="NE", padx=4) #Throttle Label(infoFrame, text="Throttle").grid(column=0, row=0, sticky="WE") self._throttleTexts = [StringVar(),StringVar(),StringVar(),StringVar()] Entry(infoFrame, textvariable=self._throttleTexts[3], state=DISABLED, width=5).grid(column=0, row=1) Entry(infoFrame, textvariable=self._throttleTexts[0], state=DISABLED, width=5).grid(column=1, row=1) Entry(infoFrame, textvariable=self._throttleTexts[2], state=DISABLED, width=5).grid(column=0, row=2) Entry(infoFrame, textvariable=self._throttleTexts[1], state=DISABLED, width=5).grid(column=1, row=2) #Angles Label(infoFrame, text="Angles").grid(column=0, row=3, sticky="WE") self._angleTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._angleTexts[index], state=DISABLED, width=5).grid(column=index, row=4) #Accels Label(infoFrame, text="Accels").grid(column=0, row=5, sticky="WE") self._accelTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._accelTexts[index], state=DISABLED, width=5).grid(column=index, row=6) #Speeds Label(infoFrame, text="Speeds").grid(column=0, row=7, sticky="WE") self._speedTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._speedTexts[index], state=DISABLED, width=5).grid(column=index, row=8) #Height Label(infoFrame, text="Height").grid(column=0, row=9, sticky="E") self._heightText = StringVar() Entry(infoFrame, textvariable=self._heightText, state=DISABLED, width=5).grid(column=1, row=9) #Loop rate Label(infoFrame, text="Loop @").grid(column=0, row=10, sticky="E") self._loopRateText = StringVar() Entry(infoFrame, textvariable=self._loopRateText, state=DISABLED, width=5).grid(column=1, row=10) Label(infoFrame, text="Hz").grid(column=2, row=10, sticky="W") #control controlFrame = tkFrame(self) controlFrame.grid(column=0, row=1, sticky="W") self._throttle = DoubleVar() if Cockpit.THROTTLE_BY_USER: self._thrustScale = Scale(controlFrame, orient=VERTICAL, from_=100.0, to=0.0, \ tickinterval=0, variable=self._throttle, resolution=Cockpit.THROTTLE_RESOLUTION, \ length=200, showvalue=1, \ state=DISABLED, command=self._onThrustScaleChanged) else: self._thrustScale = Scale(controlFrame, orient=VERTICAL, from_=100.0, to=-100.0, \ tickinterval=0, variable=self._throttle, \ length=200, showvalue=1, \ state=DISABLED, command=self._onThrustScaleChanged) self._thrustScale.bind("<Double-Button-1>", self._onThrustScaleDoubleButton1, "+") self._thrustScale.grid(column=0) self._shiftCanvas = Canvas(controlFrame, bg="white", height=400, width=400, \ relief=SUNKEN) self._shiftCanvas.bind("<Button-1>", self._onMouseButton1) #self._shiftCanvas.bind("<ButtonRelease-1>", self._onMouseButtonRelease1) self._shiftCanvas.bind("<B1-Motion>", self._onMouseButton1Motion) self._shiftCanvas.bind("<Double-Button-1>", self._onMouseDoubleButton1) self._shiftCanvas.bind("<Button-3>", self._onMouseButton3) #self._shiftCanvas.bind("<ButtonRelease-3>", self._onMouseButtonRelease3) self._shiftCanvas.bind("<B3-Motion>", self._onMouseButton3Motion) self._shiftCanvas.grid(row=0,column=1, padx=2, pady=2) self._shiftCanvas.create_oval(1, 1, 400, 400, outline="#ff0000") self._shiftCanvas.create_line(200, 2, 200, 400, fill="#ff0000") self._shiftCanvas.create_line(2, 200, 400, 200, fill="#ff0000") self._shiftMarker = self._shiftCanvas.create_oval(196, 196, 204, 204, outline="#0000ff", fill="#0000ff") self._yaw = DoubleVar() self._yawScale = Scale(controlFrame, orient=HORIZONTAL, from_=-100.0, to=100.0, \ tickinterval=0, variable=self._yaw, \ length=200, showvalue=1, \ command=self._onYawScaleChanged) self._yawScale.bind("<Double-Button-1>", self._onYawScaleDoubleButton1, "+") self._yawScale.grid(row=1, column=1) self._controlKeyActive = False #PID calibration pidCalibrationFrame = tkFrame(self) pidCalibrationFrame.grid(column=0, row=2, sticky="WE"); self._pidSelected = StringVar() self._pidSelected.set("--") self._pidListBox = OptionMenu(pidCalibrationFrame, self._pidSelected, "--", \ Cockpit.KEY_ANG_SPEED, Cockpit.KEY_ANGLES, Cockpit.KEY_ACCEL, \ command=self._onPidListBoxChanged) self._pidListBox.pack(side=LEFT, padx=2) self._pidListBox.config(width=10) self._axisSelected = StringVar() self._axisSelected.set("--") self._axisListBox = OptionMenu(pidCalibrationFrame, self._axisSelected, "--", "X", "Y", "Z", \ command=self._onAxisListBoxChanged) self._axisListBox.pack(side=LEFT, padx=2) self._axisListBox.config(state=DISABLED) Label(pidCalibrationFrame, text="P").pack(side=LEFT, padx=(14, 2)) self._pidPString = StringVar() self._pidPString.set("0.00") self._pidPSpinbox = Spinbox(pidCalibrationFrame, width=5, from_=0.0, to=10000.0, increment=0.01, state=DISABLED, \ textvariable=self._pidPString, command=self._onPidSpinboxChanged) self._pidPSpinbox.pack(side=LEFT, padx=2) Label(pidCalibrationFrame, text="I").pack(side=LEFT, padx=(14, 2)) self._pidIString = StringVar() self._pidIString.set("0.00") self._pidISpinbox = Spinbox(pidCalibrationFrame, width=5, from_=0.0, to=10000.0, increment=0.01, state=DISABLED, \ textvariable=self._pidIString, command=self._onPidSpinboxChanged) self._pidISpinbox.pack(side=LEFT, padx=2) Label(pidCalibrationFrame, text="D").pack(side=LEFT, padx=(14, 2)) self._pidDString = StringVar() self._pidDString.set("0.00") self._pidDSpinbox = Spinbox(pidCalibrationFrame, width=5, from_=0.0, to=10000.0, increment=0.01, state=DISABLED, \ textvariable=self._pidDString, command=self._onPidSpinboxChanged) self._pidDSpinbox.pack(side=LEFT, padx=2) #debug debugFrame = tkFrame(self) debugFrame.grid(column=0, row=3, sticky="WE") self._debugMsg = Message(debugFrame, anchor="nw", justify=LEFT, relief=SUNKEN, width=300) self._debugMsg.pack(fill=BOTH, expand=1) def _start(self): self._readDroneConfig() if Cockpit.JOYSTICK_ENABLED: self._joystickManager = JoystickManager.getInstance() self._joystickManager.start() joysticks = self._joystickManager.getJoysticks() if len(joysticks) != 0: self._joystick = joysticks[0] self._joystick.onAxisChanged += self._onJoystickAxisChanged self._joystick.onButtonPressed += self._onJoystickButtonPressed else: self._joystick = None def _onJoystickAxisChanged(self, sender, index): if self._started.get() and sender == self._joystick: axisValue = self._joystick.getAxisValue(index) if index == 0: self._yaw.set(axisValue) self._updateTarget() elif index == 1 and not Cockpit.THROTTLE_BY_USER: thrust = -axisValue self._throttle.set(thrust) self._updateTarget() elif index == 2 and Cockpit.THROTTLE_BY_USER: rowThrottle = (axisValue + 100.0)/2.0 if rowThrottle < 10.0: throttle = rowThrottle * 6.0 elif rowThrottle < 90.0: throttle = 60.0 + ((rowThrottle - 10.0) / 8.0) else: throttle = 70.0 + (rowThrottle - 90.0) * 3.0 self._throttle.set(throttle) self._sendThrottle() elif index == 3: x = 196 + axisValue * 2 lastCoords = self._shiftCanvas.coords(self._shiftMarker) coords = (x, lastCoords[1]) self._plotShiftCanvasMarker(coords) elif index == 4: y = 196 + axisValue * 2 lastCoords = self._shiftCanvas.coords(self._shiftMarker) coords = (lastCoords[0], y) self._plotShiftCanvasMarker(coords) def _onJoystickButtonPressed(self, sender, index): if sender == self._joystick and index == 7: if self._started.get() == 0: self._startedCB.select() else: self._startedCB.deselect() # Tkinter's widgets seem not to be calling the event-handler # when they are changed programmatically. Therefore, the # even-handler is called explicitly here. self._startedCBChanged() def exit(self): self._link.send({"key": "close", "data": None}) self._stopUpdateInfoThread() self._link.close() if Cockpit.JOYSTICK_ENABLED: self._joystickManager.stop() self.quit() def _updateTarget(self): markerCoords = self._shiftCanvas.coords(self._shiftMarker) coords = ((markerCoords[0] + markerCoords[2]) / 2, (markerCoords[1] + markerCoords[3]) / 2) self._target[0] = float(coords[1] - 200) / 2.0 # X-axis angle / X-axis acceleration self._target[1] = float(coords[0] - 200) / 2.0 # Y-axis angle / Y-axis acceleration #Remote control uses clockwise angle, but the drone's referece system uses counter-clockwise angle self._target[2] = -self._yaw.get() # Z-axis angular speed # Z-axis acceleration (thrust). Only when the motor throttle is not controlled by user directly if Cockpit.THROTTLE_BY_USER: self._target[3] = 0.0 else: self._target[3] = self._throttle.get() self._sendTarget() def _keyDown(self, event): if event.keysym == "Escape": self._throttle.set(0) self._started.set(0) self._thrustScale.config(state=DISABLED) self._stopUpdateInfoThread() self._sendIsStarted() elif event.keysym.startswith("Control"): self._controlKeyActive = True elif not self._controlKeysLocked and self._controlKeyActive: if event.keysym == "Up": self._thrustScaleUp() elif event.keysym == "Down": self._thrustScaleDown() elif event.keysym == "Left": self._yawLeft() elif event.keysym == "Right": self._yawRight() elif event.keysym == "space": self._yawReset() if not Cockpit.THROTTLE_BY_USER: self._thrustReset() elif not self._controlKeysLocked and not self._controlKeyActive: if event.keysym == "Up": self._moveShiftCanvasMarker((0,-5)) elif event.keysym == "Down": self._moveShiftCanvasMarker((0,5)) elif event.keysym == "Left": self._moveShiftCanvasMarker((-5,0)) elif event.keysym == "Right": self._moveShiftCanvasMarker((5,0)) elif event.keysym == "space": self._resetShiftCanvasMarker() def _keyUp(self, eventArgs): if eventArgs.keysym.startswith("Control"): self._controlKeyActive = False def _onMouseButton1(self, eventArgs): self._lastMouseCoords = (eventArgs.x, eventArgs.y) def _onMouseButtonRelease1(self, eventArgs): self._shiftCanvas.coords(self._shiftMarker, 196, 196, 204, 204) def _limitCoordsToSize(self, coords, size, width): maxSize = size-(width/2.0) minSize = -(width/2.0) if coords[0] > maxSize: x = maxSize elif coords[0] < minSize: x = minSize else: x = coords[0] if coords[1] > maxSize: y = maxSize elif coords[1] < minSize: y = minSize else: y = coords[1] return (x,y) def _plotShiftCanvasMarker(self, coords): coords = self._limitCoordsToSize(coords, 400, 8) self._shiftCanvas.coords(self._shiftMarker, coords[0], coords[1], coords[0] + 8, coords[1] + 8) self._updateTarget() def _moveShiftCanvasMarker(self, shift): lastCoords = self._shiftCanvas.coords(self._shiftMarker) newCoords = (lastCoords[0] + shift[0], lastCoords[1] + shift[1]) self._plotShiftCanvasMarker(newCoords) def _resetShiftCanvasMarker(self): self._shiftCanvas.coords(self._shiftMarker, 196, 196, 204, 204) self._updateTarget() def _onMouseButton1Motion(self, eventArgs): deltaCoords = (eventArgs.x - self._lastMouseCoords[0], eventArgs.y - self._lastMouseCoords[1]) self._moveShiftCanvasMarker(deltaCoords) self._lastMouseCoords = (eventArgs.x, eventArgs.y) def _onMouseDoubleButton1(self, eventArgs): self._resetShiftCanvasMarker() def _onMouseButton3(self, eventArgs): self._lastMouseCoords = (eventArgs.x, eventArgs.y) self._mouseDirection = Cockpit.DIR_NONE def _onMouseButtonRelease3(self, eventArgs): self._shiftCanvas.coords(self._shiftMarker, 196, 196, 204, 204) def _onMouseButton3Motion(self, eventArgs): deltaCoords = (eventArgs.x - self._lastMouseCoords[0], eventArgs.y - self._lastMouseCoords[1]) if self._mouseDirection == Cockpit.DIR_NONE: if abs(deltaCoords[0]) > abs(deltaCoords[1]): self._mouseDirection = Cockpit.DIR_HORIZONTAL else: self._mouseDirection = Cockpit.DIR_VERTICAL if self._mouseDirection == Cockpit.DIR_HORIZONTAL: deltaCoords = (deltaCoords[0], 0) else: deltaCoords = (0, deltaCoords[1]) self._moveShiftCanvasMarker(deltaCoords) self._lastMouseCoords = (eventArgs.x, eventArgs.y) def _thrustScaleUp(self): #TODO: 20160526 DPM: El valor de incremento de aceleración (1.0) puede ser muy alto if self._started.get(): newValue = self._thrustScale.get() \ + (Cockpit.THROTTLE_RESOLUTION if Cockpit.THROTTLE_BY_USER else 1.0) self._thrustScale.set(newValue) self._updateTarget() def _thrustScaleDown(self): #TODO: 20160526 DPM: El valor de decremento de aceleración (1.0) puede ser muy alto if self._started.get(): newValue = self._thrustScale.get() \ - (Cockpit.THROTTLE_RESOLUTION if Cockpit.THROTTLE_BY_USER else 1.0) self._thrustScale.set(newValue) self._updateTarget() def _thrustReset(self): if self._started.get(): self._thrustScale.set(0.0) self._updateTarget() def _onThrustScaleDoubleButton1(self, eventArgs): self._thrustReset() return "break" def _yawRight(self): newValue = self._yaw.get() + 1 self._yaw.set(newValue) self._updateTarget() def _yawLeft(self): newValue = self._yaw.get() - 1 self._yaw.set(newValue) self._updateTarget() def _yawReset(self): self._yaw.set(0) self._updateTarget() def _onMouseWheelUp(self, eventArgs): if not self._controlKeyActive: self._thrustScaleUp() else: self._yawRight() def _onMouseWheelDown(self, eventArgs): if not self._controlKeyActive: self._thrustScaleDown() else: self._yawLeft() def _onMouseWheel(self, eventArgs): factor = eventArgs.delta/(1200.0 if Cockpit.THROTTLE_BY_USER and not self._controlKeyActive else 120.0) if not self._controlKeyActive: if self._started.get(): newValue = self._thrustScale.get() + factor self._thrustScale.set(newValue) self._updateTarget() else: newValue = self._yaw.get() + factor self._yaw.set(newValue) self._updateTarget() def _onYawScaleChanged(self, eventArgs): self._updateTarget() def _onYawScaleDoubleButton1(self, eventArgs): self._yawReset() return "break" def _startedCBChanged(self): if not self._started.get(): self._throttle.set(0) self._thrustScale.config(state=DISABLED) #self._integralsCB.config(state=DISABLED) self._stopUpdateInfoThread() else: self._thrustScale.config(state="normal") #self._integralsCB.config(state="normal") self._startUpdateInfoThread() self._sendIsStarted() # def _integralsCBChanged(self): # # self._link.send({"key": "integrals", "data":self._integralsEnabled.get() != 0}) # def _onThrustScaleChanged(self, eventArgs): if Cockpit.THROTTLE_BY_USER: self._sendThrottle() else: self._updateTarget() def _sendThrottle(self): self._link.send({"key": "throttle", "data": self._throttle.get()}) def _sendTarget(self): self._link.send({"key": "target", "data": self._target}) def _sendIsStarted(self): isStarted = self._started.get() != 0 self._link.send({"key": "is-started", "data": isStarted}) def _sendPidCalibrationData(self): if self._pidSelected.get() != "--" and self._axisSelected.get() != "--": pidData = { "pid": self._pidSelected.get(), "axis": self._axisSelected.get(), "p": float(self._pidPSpinbox.get()), "i": float(self._pidISpinbox.get()), "d": float(self._pidDSpinbox.get())} self._link.send({"key": "pid-calibration", "data": pidData}) def _updatePidCalibrationData(self): pid = self._pidSelected.get() axis = self._axisSelected.get() if pid != "--" and axis != "--": self._pidConstants[pid][axis]["P"] = float(self._pidPSpinbox.get()) self._pidConstants[pid][axis]["I"] = float(self._pidISpinbox.get()) self._pidConstants[pid][axis]["D"] = float(self._pidDSpinbox.get()) def _readDroneConfig(self): self._link.send({"key": "read-drone-config", "data": None}, self._onDroneConfigRead) def _readDroneState(self): if not self._readingState: self._readingState = True self._link.send({"key": "read-drone-state", "data": None}, self._onDroneStateRead) def _readPidConfigItem(self, message, cockpitKey, axises, configKeys): for i in range(len(axises)): for j in range(len(Cockpit.PID_KEYS)): self._pidConstants[cockpitKey][axises[i]][Cockpit.PID_KEYS[j]] = message[configKeys[j]][i] def _onDroneConfigRead(self, message): #TODO Show current configuration within the GUI (at least relevant settings) if message: #Angle-speeds self._readPidConfigItem(message, Cockpit.KEY_ANG_SPEED, ["X", "Y", "Z"], \ [Configuration.PID_ANGLES_SPEED_KP, \ Configuration.PID_ANGLES_SPEED_KI, \ Configuration.PID_ANGLES_SPEED_KD]) #Angles self._readPidConfigItem(message, Cockpit.KEY_ANGLES, ["X", "Y"], \ [Configuration.PID_ANGLES_KP, \ Configuration.PID_ANGLES_KI, \ Configuration.PID_ANGLES_KD]) #Accels self._readPidConfigItem(message, Cockpit.KEY_ACCEL, ["X", "Y", "Z"], \ [Configuration.PID_ACCEL_KP, \ Configuration.PID_ACCEL_KI, \ Configuration.PID_ACCEL_KD]) def _onDroneStateRead(self, state): if state: for index in range(4): self._throttleTexts[index].set("{0:.3f}".format(state["_throttles"][index])) for index in range(3): self._accelTexts[index].set("{0:.3f}".format(state["_accels"][index])) self._angleTexts[index].set("{0:.3f}".format(state["_angles"][index])) currentPeriod = state["_currentPeriod"] if currentPeriod > 0.0: freq = 1.0/currentPeriod self._loopRateText.set("{0:.3f}".format(freq)) else: self._loopRateText.set("--") else: self._stopUpdateInfoThread() self._readingState = False def _onPidSpinboxChanged(self): self._updatePidCalibrationData() self._sendPidCalibrationData() def _onPidListBoxChanged(self, pid): self._axisSelected.set("--") self._pidPString.set("--") self._pidIString.set("--") self._pidDString.set("--") self._pidPSpinbox.config(state=DISABLED) self._pidISpinbox.config(state=DISABLED) self._pidDSpinbox.config(state=DISABLED) self._selectedPidConstats = pid if pid == "--": self._axisListBox.config(state=DISABLED) self._controlKeysLocked = False else: self._axisListBox.config(state="normal") self._controlKeysLocked = True def _onAxisListBoxChanged(self, axis): if axis == "--" or (self._selectedPidConstats == Cockpit.KEY_ANGLES and axis == "Z"): self._pidPString.set("--") self._pidIString.set("--") self._pidDString.set("--") self._pidPSpinbox.config(state=DISABLED) self._pidISpinbox.config(state=DISABLED) self._pidDSpinbox.config(state=DISABLED) self._controlKeysLocked = axis != "--" else: self._pidPString.set("{:.2f}".format(self._pidConstants[self._selectedPidConstats][axis]["P"])) self._pidIString.set("{:.2f}".format(self._pidConstants[self._selectedPidConstats][axis]["I"])) self._pidDString.set("{:.2f}".format(self._pidConstants[self._selectedPidConstats][axis]["D"])) self._pidPSpinbox.config(state="normal") self._pidISpinbox.config(state="normal") self._pidDSpinbox.config(state="normal") self._controlKeysLocked = True def _updateInfo(self): while self._updateInfoThreadRunning: self._readDroneState() time.sleep(1.0) def _startUpdateInfoThread(self): self._updateInfoThreadRunning = True if not self._updateInfoThread.isAlive(): self._updateInfoThread.start() def _stopUpdateInfoThread(self): self._updateInfoThreadRunning = False if self._updateInfoThread.isAlive(): self._updateInfoThread.join()
class Application(Frame): def __init__(self, master=None): Frame.__init__(self, master) self.DEFAULT_SECTION = 'DEFAULT' self.grid() self.createWidgets() def createWidgets(self): self.__config = ConfigParser.ConfigParser() self.__config.set(self.DEFAULT_SECTION, 'input', '~/input.jpg') self.__config.set(self.DEFAULT_SECTION, 'inverted', '0') self.__config.set(self.DEFAULT_SECTION, 'output', '~/output.svg') self.__config.set(self.DEFAULT_SECTION, 'preamble', 'G17 G21 G90 G64 P0.1 S4500 M3 M8') self.__config.set(self.DEFAULT_SECTION, 'size', '256') self.__config.set(self.DEFAULT_SECTION, 'scale', '1') self.__config.set(self.DEFAULT_SECTION, 'width', '152.4') self.__config.set(self.DEFAULT_SECTION, 'height', '101.6') self.__config.set(self.DEFAULT_SECTION, 'columns', '3') self.__config.set(self.DEFAULT_SECTION, 'rows', '2') self.__config.set(self.DEFAULT_SECTION, 'margin', '10.0') self.__config.set(self.DEFAULT_SECTION, 'thickness', '6.35') self.__config.set(self.DEFAULT_SECTION, 'tool_diameter', '3.175') self.__config.read(os.path.expanduser('~/.py-art.cfg')) self.EntryFrame = Frame(self,bd=5) self.EntryFrame.grid(row=0, column=1) i = 0 Label(self.EntryFrame, text='Engrave an image\n').grid(row=i, column=0, columnspan=2) i += 1 Label(self.EntryFrame, text='Input file').grid(row=i, column=0, sticky=E) self.InputVar = StringVar() self.InputVar.set(self.__config.get(self.DEFAULT_SECTION, 'input')) Entry(self.EntryFrame, textvariable=self.InputVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Size').grid(row=i, column=0, sticky=E) self.SizeVar = IntVar() self.SizeVar.set(self.__config.get(self.DEFAULT_SECTION, 'size')) Entry(self.EntryFrame, textvariable=self.SizeVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Scale').grid(row=i, column=0, sticky=E) self.ScaleVar = IntVar() self.ScaleVar.set(self.__config.get(self.DEFAULT_SECTION, 'scale')) Entry(self.EntryFrame, textvariable=self.ScaleVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Rows').grid(row=i, column=0, sticky=E) self.RowsVar = IntVar() self.RowsVar.set(self.__config.get(self.DEFAULT_SECTION, 'rows')) Entry(self.EntryFrame, textvariable=self.RowsVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Columns').grid(row=i, column=0, sticky=E) self.ColumnsVar = IntVar() self.ColumnsVar.set(self.__config.get(self.DEFAULT_SECTION, 'columns')) Entry(self.EntryFrame, textvariable=self.ColumnsVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Image effects').grid(row=i, column=0, sticky=E) self.InvertedVar = IntVar() self.InvertedVar.set(self.__config.getint(self.DEFAULT_SECTION, 'inverted')) Checkbutton(self.EntryFrame, text='Inverted', variable=self.InvertedVar).grid(row=i, column=1,sticky=W) if IN_AXIS: i += 1 Label(self.EntryFrame, text='Preamble').grid(row=i, column=0, sticky=E) self.PreambleVar = StringVar() self.PreambleVar.set(self.__config.get(self.DEFAULT_SECTION, 'preamble')) Entry(self.EntryFrame, textvariable=self.PreambleVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Width').grid(row=i, column=0, sticky=E) self.WidthVar = DoubleVar() self.WidthVar.set(self.__config.get(self.DEFAULT_SECTION, 'width')) Entry(self.EntryFrame, textvariable=self.WidthVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Height').grid(row=i, column=0, sticky=E) self.HeightVar = DoubleVar() self.HeightVar.set(self.__config.get(self.DEFAULT_SECTION, 'height')) Entry(self.EntryFrame, textvariable=self.HeightVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Margin').grid(row=i, column=0, sticky=E) self.MarginVar = DoubleVar() self.MarginVar.set(self.__config.get(self.DEFAULT_SECTION, 'margin')) Entry(self.EntryFrame, textvariable=self.MarginVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Tool diameter').grid(row=i, column=0, sticky=E) self.ToolDiameterVar = DoubleVar() self.ToolDiameterVar.set(self.__config.get(self.DEFAULT_SECTION, 'tool_diameter')) Entry(self.EntryFrame, textvariable=self.ToolDiameterVar ,width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Thickness').grid(row=i, column=0, sticky=E) self.ThicknessVar = DoubleVar() self.ThicknessVar.set(self.__config.get(self.DEFAULT_SECTION, 'thickness')) Entry(self.EntryFrame, textvariable=self.ThicknessVar ,width=50).grid(row=i, column=1) i += 1 Button(self.EntryFrame, text='Trace boundary in AXIS and Quit',command=self.WriteBoundaryTraceToAxis).grid(row=i, column=1, sticky=E) i += 1 Button(self.EntryFrame, text='Engrave in AXIS and Quit',command=self.WriteEngravingToAxis).grid(row=i, column=1, sticky=E) i += 1 Button(self.EntryFrame, text='Cut boundary in AXIS and Quit',command=self.WriteBoundaryCutToAxis).grid(row=i, column=1, sticky=E) else: i += 1 Label(self.EntryFrame, text='Output file').grid(row=i, column=0, sticky=E) self.OutputVar = StringVar() self.OutputVar.set(self.__config.get(self.DEFAULT_SECTION, 'output')) Entry(self.EntryFrame, textvariable=self.OutputVar ,width=50).grid(row=i, column=1) i += 1 Button(self.EntryFrame, text='Write to SVG and Quit', command=self.WriteToSvg).grid(row=i, column=1, sticky=E) def WriteConfig(self): with open(os.path.expanduser('~/.py-art.cfg'), 'wb') as configfile: self.__config.set(self.DEFAULT_SECTION, 'input', self.InputVar.get()) self.__config.set(self.DEFAULT_SECTION, 'inverted', self.InvertedVar.get()) self.__config.set(self.DEFAULT_SECTION, 'size', self.SizeVar.get()) self.__config.set(self.DEFAULT_SECTION, 'scale', self.ScaleVar.get()) self.__config.set(self.DEFAULT_SECTION, 'rows', self.RowsVar.get()) self.__config.set(self.DEFAULT_SECTION, 'columns', self.ColumnsVar.get()) if IN_AXIS: self.__config.set(self.DEFAULT_SECTION, 'height', self.ToolDiameterVar.get()) self.__config.set(self.DEFAULT_SECTION, 'margin', self.ToolDiameterVar.get()) self.__config.set(self.DEFAULT_SECTION, 'preamble', self.PreambleVar.get()) self.__config.set(self.DEFAULT_SECTION, 'tool_diameter', self.ToolDiameterVar.get()) self.__config.set(self.DEFAULT_SECTION, 'thickness', self.ThicknessVar.get()) self.__config.set(self.DEFAULT_SECTION, 'width', self.ToolDiameterVar.get()) else: self.__config.set(self.DEFAULT_SECTION, 'output', self.OutputVar.get()) self.__config.write(configfile) def DisplayAndQuit(self, display, size): image = Image.open(os.path.expanduser(self.InputVar.get())) rows = self.RowsVar.get() columns = self.ColumnsVar.get() curve = Curve(display, image) curve.scale = (self.ScaleVar.get(), self.ScaleVar.get()) curve.is_inverted = self.InvertedVar.get() curve.calculate_levels(5, 0, 0, columns * size, rows * size) self.display_nxm_with_border(rows, columns, size, display, curve) display.close() self.WriteConfig() self.quit() def WriteToSvg(self): size = int(self.SizeVar.get()) display = SvgDisplay( os.path.expanduser(self.OutputVar.get()), self.ColumnsVar.get()*size + 22, self.RowsVar.get()*size + 22) # display = TurtleDisplay() display.offset = (11,11) self.DisplayAndQuit(display, size) def WriteBoundaryMoves(self, display, cut_depth): width = self.WidthVar.get() height = self.HeightVar.get() tool_radius = self.ToolDiameterVar.get() / 2 corner_radius = 1.0 display.add_point((-tool_radius, -corner_radius)) print "g1 y%f z%f" % (-height + corner_radius, -cut_depth) print "g3 x%f y%f i%f" % ( corner_radius, -height - tool_radius, tool_radius + corner_radius) print "g1 x%f" % (width - corner_radius) print "g3 x%f y%f j%f" % ( width + tool_radius, -height + corner_radius, tool_radius + corner_radius) print "g1 y%f" % (-corner_radius) print "g3 x%f y%f i%f" % ( width - corner_radius, tool_radius, -tool_radius - corner_radius) print "g1 x%f" % (corner_radius) print "g3 x%f y%f j%f" % ( -tool_radius, -corner_radius, -tool_radius - corner_radius) def WriteBoundaryTraceToAxis(self): display = self.CreateGCodeDisplay() self.WriteBoundaryMoves(display, cut_depth=0) display.close_curve() display.close() self.WriteConfig() self.quit() def WriteBoundaryCutToAxis(self): display = self.CreateGCodeDisplay() tool_radius = self.ToolDiameterVar.get() / 2 thickness = self.ThicknessVar.get() zstart = 0.05 zstep = -tool_radius / 2 zstop = -thickness - 0.5 display.depth = -zstart for cut_depth in range(zstart, zstop, zstep): self.WriteBoundaryMoves(display, cut_depth) display.close_curve() display.close() self.WriteConfig() self.quit() def CreateGCodeDisplay(self): display = GCodeDisplay() display.preamble = self.PreambleVar.get() display.feed_rate = 1200 return display def WriteEngravingToAxis(self): display = self.CreateGCodeDisplay() width = self.WidthVar.get() height = self.HeightVar.get() margin = self.MarginVar.get() size = self.SizeVar.get() xscale = (width - 2*margin) / (3*size) yscale = (height - 2*margin) / (2*size) scale = min(xscale, yscale) xoff = width/2 + 1.5*size*scale yoff = -height/2 + size*scale display.scale = (-scale, -scale) display.offset = (xoff, yoff) self.DisplayAndQuit(display, size) def display_rectangle(self, size, display, curve): display.add_point((-1, -1)) display.add_point((-1, size)) display.add_point((size * 2, size)) display.add_point((size * 2, -1)) display.close_curve() curve.draw_cell((size - 1, 0), (size - 1, size - 1), -1) display.add_point((size, size - 1)) curve.draw_cell((size, size - 1), (size, 0), -1) display.add_point((size - 1, 0)) display.close_curve() def display_square(self, size, display, curve): display.add_point((-1, -1)) display.add_point((-1, size)) display.add_point((size, size)) display.add_point((size, -1)) display.close_curve() curve.draw_cell((size/2 - 1, 0), (size/2 - 1, size/2 - 1), -1) display.add_point((size/2 - 1, size/2)) curve.draw_cell((size/2 - 1, size/2), (size/2 - 1, size-1), -1) display.add_point((size/2, size - 1)) curve.draw_cell((size/2, size - 1), (size/2, size/2), -1) display.add_point((size/2, size/2 - 1)) curve.draw_cell((size/2, size/2 - 1), (size/2, 0), -1) display.add_point((size/2 - 1, 0)) display.close_curve() def display_nxm_with_border(self, n, m, size, display, curve): """ Draw the curve using n rows and m columns. n - the number of rows must be even. m - the number of columns. size - the size of each row and column. display - the place to draw the curve. curve - the curve to draw. """ display.add_point((-1, n/2*size)) display.add_point((-1, n*size)) display.add_point((m*size, n*size)) display.add_point((m*size, -1)) display.add_point((-1, -1)) display.add_point((-1, n/2*size - 1)) self.display_nxm(n, m, size, display, curve) def display_nxm(self, n, m, size, display, curve): for i in range(n/2 - 1): display.add_point((0, (n/2 - i)*size - 1)) curve.draw_cell((0, (n/2 - i)*size - 1), (0, (n/2 - i - 1)*size), -1) for i in range(m): display.add_point((i*size, size - 1)) curve.draw_cell((i*size, size - 1), ((i+1)*size - 1, size - 1), 1) for i in range(n/2 - 1): for j in range(m-2): display.add_point(((m-j)*size - 1, (2*i+1)*size)) curve.draw_cell( ((m-j)*size - 1, (2*i+1)*size), ((m-j-1)*size, (2*i+1)*size), 1) for j in range(2): display.add_point((2*size - 1, (2*i+j+1)*size)) curve.draw_cell( (2*size - 1, (2*i+j+1)*size), (2*size - 1, (2*i+j+2)*size - 1), -1) for j in range(m-2): display.add_point(((2+j)*size, (2*i+3)*size)) curve.draw_cell( ((2+j)*size, (2*i+3)*size - 1), ((3+j)*size-1, (2*i+3)*size - 1), 1) for i in range(m): display.add_point(((m-i)*size-1, (n-1)*size)) curve.draw_cell( ((m-i)*size-1, (n-1)*size), ((m-i-1)*size, (n-1)*size), 1) for i in range(n/2 - 1): display.add_point((0, (n - i - 1)*size - 1)) curve.draw_cell((0, (n - i - 1)*size - 1), (0, (n - i - 2)*size), -1) display.close_curve()
class Scope: """ Scope is class used to make a scope on grid layout with Tkinterface. """ def __init__(self, root, data, row0, col0, rowspan=10, colspan=6, showpower=True, horizontaljoin=False, buttoncallback=None): """ Create a scope interface. :param root: is the main window :param data: is the data to display (update if enabled) :param row0: is the beginning row as whitch the scope should be placed on the grid layout :param col0: is the beginning column as whitch the scope should be placed on the grid layout :param rowspan: is how many rows should be used to draw the whole scope :param colspan: is how many columns should be used to draw the whole scope :param showpower: is a boolean field used to show the power (not required in wave editor) :param horizontaljoin: if true the points are joined through horizontal segments then vertica (for waveditor) if it is false they are just joined as useful in the scope view :param buttoncallback: it is the function to provide if the user can manage the graphs changing point (for wave editor) :returns: a new instance of scope """ self.root = root row = row0 rowspan -= 4 #those lines are used for inputs self.scopetube = Scopetube(root, data, horizontaljoin, self.newratios, buttoncallback) self.scopetube.grid(row=row, column=col0, columnspan=colspan, rowspan=rowspan, sticky=E + W) row += rowspan rowspan = 1 colspan = 1 insertlabelrow(root, row, col0, (("Y [V/div]: ", VCOL), None, ("Y [A/div]: ", CCOL)), E) self.dvarvdiv = DoubleVar() self.dvarvdiv.set(1.) self.dvarcdiv = DoubleVar() self.dvarcdiv.set(1.) entries = insertentryrow(root, row, col0, (None, self.dvarvdiv, None, self.dvarcdiv), 'right', W) self.dvarpdiv = DoubleVar() self.dvarpdiv.set(1.) if showpower: insertlabelrow(root, row, col0, (None, None, None, None, ("Y [W/div]: ", PCOL)), E) entries += insertentryrow( root, row, col0, (None, None, None, None, None, self.dvarpdiv), 'right', W) row += rowspan insertlabelrow(root, row, col0, (("Y0 [V]: ", VCOL), None, ("Y0 [A]: ", CCOL)), E) self.dvarv0 = DoubleVar() self.dvarv0.set(0.) self.dvarc0 = DoubleVar() self.dvarc0.set(0.) entries += insertentryrow(root, row, col0, (None, self.dvarv0, None, self.dvarc0), 'right', W) self.dvarp0 = DoubleVar() self.dvarp0.set(0.) if showpower: insertlabelrow(root, row, col0, (None, None, None, None, ("Y0 [W]: ", PCOL)), E) entries += insertentryrow( root, row, col0, (None, None, None, None, None, self.dvarp0), 'right', W) row += rowspan rowspan = 1 colspan = 2 col = col0 self.ivarvena = IntVar() self.ivarvena.set(1) Checkbutton(root, variable=self.ivarvena, text='Voltage show', foreground=VCOL, command=self.entbndcmdbutscpupdt).grid(row=row, column=col, columnspan=colspan, sticky=E + W) col += colspan self.ivarcena = IntVar() self.ivarcena.set(1) Checkbutton(root, variable=self.ivarcena, text='Current show', foreground=CCOL, command=self.entbndcmdbutscpupdt).grid(row=row, column=col, columnspan=colspan, sticky=E + W) self.ivarpena = IntVar() self.ivarpena.set(0) if showpower: col += colspan self.ivarpena.set(1) Checkbutton(root, variable=self.ivarpena, text='Power show', foreground=PCOL, command=self.entbndcmdbutscpupdt).grid( row=row, column=col, columnspan=colspan, sticky=E + W) row += rowspan col = col0 insertlabelrow(root, row, col0, ("X [s/div]: ", None, "X0 [s]: "), E) self.dvartdiv = DoubleVar() self.dvartdiv.set(60.) self.dvart0 = DoubleVar() self.dvart0.set(0.) entries += insertentryrow(root, row, col0, (None, self.dvartdiv, None, self.dvart0), 'right', W) for e in entries: e.bind('<FocusOut>', self.entbndcmdbutscpupdt) e.bind('<Return>', self.entbndcmdbutscpupdt) self.varlist = (self.ivarvena, self.ivarcena, self.ivarpena, self.dvarvdiv, self.dvarcdiv, self.dvarpdiv, self.dvarv0, self.dvarc0, self.dvarp0, self.dvartdiv, self.dvart0) self.update() def entbndcmdbutscpupdt(self, *event): """ Updates scope view ratios when something changes on any of the setting. The change is detected by RETURN pressure or field change :param event: may the event that made the change (not used), added to be used as command/event call back """ self.scopetube.setratios([e.get() for e in self.varlist]) self.scopetube.redraw() def newratios(self, ratios): """ Updates scope ratios. Used by scopetube to update the ratios base on the mouse actions. :param ratios: is the list of ratios to update: v, c, p enables; v, c, p initial value; v, c, p divisions; t initial value and divisions. """ for var, val in zip(self.varlist, ratios): var.set(val) def update(self): """ Updates scope tube view based on the dimensions of the screen. """ self.scopetube.update() self.entbndcmdbutscpupdt(None) def resetpoints(self): """ Delete all the waveform points . """ self.scopetube.resetpoints() def addpoint(self, p): """ Add a new point to the waveform. """ self.scopetube.addpoint(p) def redraw(self): """ Redraw the scopetube. """ self.scopetube.redraw() def sampletime(self): """ Gets the scopetube suggested sample time. That is the sample time required to have a sample for every pixel. """ return self.scopetube.sampletime() def load(self, fname): """ Load a waveform saved before (uses CSV files) :param fname: the file name from which retrieve the waveform """ self.scopetube.load(fname) def save(self, fname): """ Save the waveform currently in memory (uses CSV files) :param fname: the file name in which save the waveform """ self.scopetube.save(fname)
def on_entermom(event): """shows an explanation if cursor placed over question mark""" infomom.place(relx=0.545, rely=0.675, anchor=NW) def on_leavemom(event): """hides explanation if cursor not placed over question mark""" infomom.place_forget() qmom.bind("<Enter>", on_entermom) qmom.bind("<Leave>", on_leavemom) #bind functions #Percentage of data to analize: percentg_val = DoubleVar() percentg_val.set(0) #Initialize a value #Define and show slider PercentgEntry = Scale(frame1, label="Percentage of data to analize:", bg="LightCyan2", from_=0, to=100, orient=HORIZONTAL, length=300, resolution=0.5, variable=percentg_val) PercentgEntry.grid(row=17, column=0, columnspan=2, sticky=W) #Button to open root browser latestThread = None #analysis thread
class Application(Frame): def __init__(self, master=None): Frame.__init__(self, master) self.DEFAULT_SECTION = 'DEFAULT' self.grid() self.createWidgets() def createWidgets(self): self.__config = ConfigParser.ConfigParser() self.__config.set(self.DEFAULT_SECTION, 'input', '~/input.jpg') self.__config.set(self.DEFAULT_SECTION, 'inverted', '0') self.__config.set(self.DEFAULT_SECTION, 'output', '~/output.svg') self.__config.set(self.DEFAULT_SECTION, 'preamble', 'G17 G21 G90 G64 P0.1 S4500 M3 M8') self.__config.set(self.DEFAULT_SECTION, 'size', '256') self.__config.set(self.DEFAULT_SECTION, 'scale', '1') self.__config.set(self.DEFAULT_SECTION, 'width', '152.4') self.__config.set(self.DEFAULT_SECTION, 'height', '101.6') self.__config.set(self.DEFAULT_SECTION, 'columns', '3') self.__config.set(self.DEFAULT_SECTION, 'rows', '2') self.__config.set(self.DEFAULT_SECTION, 'margin', '10.0') self.__config.set(self.DEFAULT_SECTION, 'thickness', '6.35') self.__config.set(self.DEFAULT_SECTION, 'tool_diameter', '3.175') self.__config.read(os.path.expanduser('~/.py-art.cfg')) self.EntryFrame = Frame(self, bd=5) self.EntryFrame.grid(row=0, column=1) i = 0 Label(self.EntryFrame, text='Engrave an image\n').grid(row=i, column=0, columnspan=2) i += 1 Label(self.EntryFrame, text='Input file').grid(row=i, column=0, sticky=E) self.InputVar = StringVar() self.InputVar.set(self.__config.get(self.DEFAULT_SECTION, 'input')) Entry(self.EntryFrame, textvariable=self.InputVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Size').grid(row=i, column=0, sticky=E) self.SizeVar = IntVar() self.SizeVar.set(self.__config.get(self.DEFAULT_SECTION, 'size')) Entry(self.EntryFrame, textvariable=self.SizeVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Scale').grid(row=i, column=0, sticky=E) self.ScaleVar = IntVar() self.ScaleVar.set(self.__config.get(self.DEFAULT_SECTION, 'scale')) Entry(self.EntryFrame, textvariable=self.ScaleVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Rows').grid(row=i, column=0, sticky=E) self.RowsVar = IntVar() self.RowsVar.set(self.__config.get(self.DEFAULT_SECTION, 'rows')) Entry(self.EntryFrame, textvariable=self.RowsVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Columns').grid(row=i, column=0, sticky=E) self.ColumnsVar = IntVar() self.ColumnsVar.set(self.__config.get(self.DEFAULT_SECTION, 'columns')) Entry(self.EntryFrame, textvariable=self.ColumnsVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Image effects').grid(row=i, column=0, sticky=E) self.InvertedVar = IntVar() self.InvertedVar.set( self.__config.getint(self.DEFAULT_SECTION, 'inverted')) Checkbutton(self.EntryFrame, text='Inverted', variable=self.InvertedVar).grid(row=i, column=1, sticky=W) if IN_AXIS: i += 1 Label(self.EntryFrame, text='Preamble').grid(row=i, column=0, sticky=E) self.PreambleVar = StringVar() self.PreambleVar.set( self.__config.get(self.DEFAULT_SECTION, 'preamble')) Entry(self.EntryFrame, textvariable=self.PreambleVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Width').grid(row=i, column=0, sticky=E) self.WidthVar = DoubleVar() self.WidthVar.set(self.__config.get(self.DEFAULT_SECTION, 'width')) Entry(self.EntryFrame, textvariable=self.WidthVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Height').grid(row=i, column=0, sticky=E) self.HeightVar = DoubleVar() self.HeightVar.set( self.__config.get(self.DEFAULT_SECTION, 'height')) Entry(self.EntryFrame, textvariable=self.HeightVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Margin').grid(row=i, column=0, sticky=E) self.MarginVar = DoubleVar() self.MarginVar.set( self.__config.get(self.DEFAULT_SECTION, 'margin')) Entry(self.EntryFrame, textvariable=self.MarginVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Tool diameter').grid(row=i, column=0, sticky=E) self.ToolDiameterVar = DoubleVar() self.ToolDiameterVar.set( self.__config.get(self.DEFAULT_SECTION, 'tool_diameter')) Entry(self.EntryFrame, textvariable=self.ToolDiameterVar, width=50).grid(row=i, column=1) i += 1 Label(self.EntryFrame, text='Thickness').grid(row=i, column=0, sticky=E) self.ThicknessVar = DoubleVar() self.ThicknessVar.set( self.__config.get(self.DEFAULT_SECTION, 'thickness')) Entry(self.EntryFrame, textvariable=self.ThicknessVar, width=50).grid(row=i, column=1) i += 1 Button(self.EntryFrame, text='Trace boundary in AXIS and Quit', command=self.WriteBoundaryTraceToAxis).grid(row=i, column=1, sticky=E) i += 1 Button(self.EntryFrame, text='Engrave in AXIS and Quit', command=self.WriteEngravingToAxis).grid(row=i, column=1, sticky=E) i += 1 Button(self.EntryFrame, text='Cut boundary in AXIS and Quit', command=self.WriteBoundaryCutToAxis).grid(row=i, column=1, sticky=E) else: i += 1 Label(self.EntryFrame, text='Output file').grid(row=i, column=0, sticky=E) self.OutputVar = StringVar() self.OutputVar.set( self.__config.get(self.DEFAULT_SECTION, 'output')) Entry(self.EntryFrame, textvariable=self.OutputVar, width=50).grid(row=i, column=1) i += 1 Button(self.EntryFrame, text='Write to SVG and Quit', command=self.WriteToSvg).grid(row=i, column=1, sticky=E) def WriteConfig(self): with open(os.path.expanduser('~/.py-art.cfg'), 'wb') as configfile: self.__config.set(self.DEFAULT_SECTION, 'input', self.InputVar.get()) self.__config.set(self.DEFAULT_SECTION, 'inverted', self.InvertedVar.get()) self.__config.set(self.DEFAULT_SECTION, 'size', self.SizeVar.get()) self.__config.set(self.DEFAULT_SECTION, 'scale', self.ScaleVar.get()) self.__config.set(self.DEFAULT_SECTION, 'rows', self.RowsVar.get()) self.__config.set(self.DEFAULT_SECTION, 'columns', self.ColumnsVar.get()) if IN_AXIS: self.__config.set(self.DEFAULT_SECTION, 'height', self.ToolDiameterVar.get()) self.__config.set(self.DEFAULT_SECTION, 'margin', self.ToolDiameterVar.get()) self.__config.set(self.DEFAULT_SECTION, 'preamble', self.PreambleVar.get()) self.__config.set(self.DEFAULT_SECTION, 'tool_diameter', self.ToolDiameterVar.get()) self.__config.set(self.DEFAULT_SECTION, 'thickness', self.ThicknessVar.get()) self.__config.set(self.DEFAULT_SECTION, 'width', self.ToolDiameterVar.get()) else: self.__config.set(self.DEFAULT_SECTION, 'output', self.OutputVar.get()) self.__config.write(configfile) def DisplayAndQuit(self, display, size): image = Image.open(os.path.expanduser(self.InputVar.get())) rows = self.RowsVar.get() columns = self.ColumnsVar.get() curve = Curve(display, image) curve.scale = (self.ScaleVar.get(), self.ScaleVar.get()) curve.is_inverted = self.InvertedVar.get() curve.calculate_levels(5, 0, 0, columns * size, rows * size) self.display_nxm_with_border(rows, columns, size, display, curve) display.close() self.WriteConfig() self.quit() def WriteToSvg(self): size = int(self.SizeVar.get()) display = SvgDisplay(os.path.expanduser(self.OutputVar.get()), self.ColumnsVar.get() * size + 22, self.RowsVar.get() * size + 22) # display = TurtleDisplay() display.offset = (11, 11) self.DisplayAndQuit(display, size) def WriteBoundaryMoves(self, display, cut_depth): width = self.WidthVar.get() height = self.HeightVar.get() tool_radius = self.ToolDiameterVar.get() / 2 corner_radius = 1.0 display.add_point((-tool_radius, -corner_radius)) print "g1 y%f z%f" % (-height + corner_radius, -cut_depth) print "g3 x%f y%f i%f" % (corner_radius, -height - tool_radius, tool_radius + corner_radius) print "g1 x%f" % (width - corner_radius) print "g3 x%f y%f j%f" % (width + tool_radius, -height + corner_radius, tool_radius + corner_radius) print "g1 y%f" % (-corner_radius) print "g3 x%f y%f i%f" % (width - corner_radius, tool_radius, -tool_radius - corner_radius) print "g1 x%f" % (corner_radius) print "g3 x%f y%f j%f" % (-tool_radius, -corner_radius, -tool_radius - corner_radius) def WriteBoundaryTraceToAxis(self): display = self.CreateGCodeDisplay() self.WriteBoundaryMoves(display, cut_depth=0) display.close_curve() display.close() self.WriteConfig() self.quit() def WriteBoundaryCutToAxis(self): display = self.CreateGCodeDisplay() tool_radius = self.ToolDiameterVar.get() / 2 thickness = self.ThicknessVar.get() zstart = 0.05 zstep = -tool_radius / 2 zstop = -thickness - 0.5 display.depth = -zstart for cut_depth in range(zstart, zstop, zstep): self.WriteBoundaryMoves(display, cut_depth) display.close_curve() display.close() self.WriteConfig() self.quit() def CreateGCodeDisplay(self): display = GCodeDisplay() display.preamble = self.PreambleVar.get() display.feed_rate = 1200 return display def WriteEngravingToAxis(self): display = self.CreateGCodeDisplay() width = self.WidthVar.get() height = self.HeightVar.get() margin = self.MarginVar.get() size = self.SizeVar.get() xscale = (width - 2 * margin) / (3 * size) yscale = (height - 2 * margin) / (2 * size) scale = min(xscale, yscale) xoff = width / 2 + 1.5 * size * scale yoff = -height / 2 + size * scale display.scale = (-scale, -scale) display.offset = (xoff, yoff) self.DisplayAndQuit(display, size) def display_rectangle(self, size, display, curve): display.add_point((-1, -1)) display.add_point((-1, size)) display.add_point((size * 2, size)) display.add_point((size * 2, -1)) display.close_curve() curve.draw_cell((size - 1, 0), (size - 1, size - 1), -1) display.add_point((size, size - 1)) curve.draw_cell((size, size - 1), (size, 0), -1) display.add_point((size - 1, 0)) display.close_curve() def display_square(self, size, display, curve): display.add_point((-1, -1)) display.add_point((-1, size)) display.add_point((size, size)) display.add_point((size, -1)) display.close_curve() curve.draw_cell((size / 2 - 1, 0), (size / 2 - 1, size / 2 - 1), -1) display.add_point((size / 2 - 1, size / 2)) curve.draw_cell((size / 2 - 1, size / 2), (size / 2 - 1, size - 1), -1) display.add_point((size / 2, size - 1)) curve.draw_cell((size / 2, size - 1), (size / 2, size / 2), -1) display.add_point((size / 2, size / 2 - 1)) curve.draw_cell((size / 2, size / 2 - 1), (size / 2, 0), -1) display.add_point((size / 2 - 1, 0)) display.close_curve() def display_nxm_with_border(self, n, m, size, display, curve): """ Draw the curve using n rows and m columns. n - the number of rows must be even. m - the number of columns. size - the size of each row and column. display - the place to draw the curve. curve - the curve to draw. """ display.add_point((-1, n / 2 * size)) display.add_point((-1, n * size)) display.add_point((m * size, n * size)) display.add_point((m * size, -1)) display.add_point((-1, -1)) display.add_point((-1, n / 2 * size - 1)) self.display_nxm(n, m, size, display, curve) def display_nxm(self, n, m, size, display, curve): for i in range(n / 2 - 1): display.add_point((0, (n / 2 - i) * size - 1)) curve.draw_cell((0, (n / 2 - i) * size - 1), (0, (n / 2 - i - 1) * size), -1) for i in range(m): display.add_point((i * size, size - 1)) curve.draw_cell((i * size, size - 1), ((i + 1) * size - 1, size - 1), 1) for i in range(n / 2 - 1): for j in range(m - 2): display.add_point(((m - j) * size - 1, (2 * i + 1) * size)) curve.draw_cell(((m - j) * size - 1, (2 * i + 1) * size), ((m - j - 1) * size, (2 * i + 1) * size), 1) for j in range(2): display.add_point((2 * size - 1, (2 * i + j + 1) * size)) curve.draw_cell((2 * size - 1, (2 * i + j + 1) * size), (2 * size - 1, (2 * i + j + 2) * size - 1), -1) for j in range(m - 2): display.add_point(((2 + j) * size, (2 * i + 3) * size)) curve.draw_cell(((2 + j) * size, (2 * i + 3) * size - 1), ((3 + j) * size - 1, (2 * i + 3) * size - 1), 1) for i in range(m): display.add_point(((m - i) * size - 1, (n - 1) * size)) curve.draw_cell(((m - i) * size - 1, (n - 1) * size), ((m - i - 1) * size, (n - 1) * size), 1) for i in range(n / 2 - 1): display.add_point((0, (n - i - 1) * size - 1)) curve.draw_cell((0, (n - i - 1) * size - 1), (0, (n - i - 2) * size), -1) display.close_curve()
def cs_Dblentry(root, r, c, value, entry_conf={}, grid_conf={}): entrydbl = DoubleVar() entrydbl.set(float(value)) entry = Entry(root, textvariable=entrydbl, **entry_conf) entry.grid(row=r, column=c, **grid_conf) return entry
class CoefficientEditor: """Gets the chemical reaction information for each layer.""" def __init__(self, master, system, coefficient, coefficients, editflag): """Constructor method. Makes the GUI using the list of "Layer" objects "layers." """ # Read the Tkinter information self.master = master self.version = system.version self.fonttype = system.fonttype self.formulatype = system.formulatype self.superfont = get_superfont(self.fonttype) self.subfont = get_superfont(self.formulatype) self.tframe = Frame(master.tframe) self.frame = Frame(master.frame) self.bframe = Frame(master.bframe) self.bgcolor = self.frame.cget('bg') self.top = None self.concunit = system.concunit self.timeunit = system.timeunit self.concunits = system.concunits # Convert mass concentration units to corresponding molar concentration units if self.concunit == system.concunits[0]: self.concunit = system.concunits[3] if self.concunit == system.concunits[1]: self.concunit = system.concunits[4] if self.concunit == system.concunits[2]: self.concunit = system.concunits[5] # Read the system information self.coefficient = coefficient self.coefficients = coefficients self.layers = system.layers self.editflag = editflag if self.editflag == 0: self.layer_full_list = [] self.reaction_full_list = [] for layer in system.layers: self.layer_full_list.append(layer.name) for reaction in system.reactions: self.reaction_full_list.append(reaction.name) self.layer_list = [] self.reaction_list = [] for layer in system.layers: coef_check = 0 for reaction in system.reactions: if coefficients[layer.name][reaction.name].lam == 0: coef_check = 1 if coef_check == 1: self.layer_list.append(layer.name) self.reaction_list.append([]) for reaction in system.reactions: if coefficients[layer.name][reaction.name].lam == 0: self.reaction_list[-1].append(reaction.name) self.layer = StringVar(value=self.layer_list[0]) self.reaction = StringVar(value=self.reaction_list[0][0]) self.equation = StringVar(value='') else: self.layer = coefficient.layer.name self.reaction = coefficient.reaction.name self.equation = coefficient.reaction.equation self.reactants = coefficient.reaction.reactants self.lam = DoubleVar(value=coefficient.lam) self.cancelflag = 0 def make_widgets(self): self.instructions = Label( self.frame, text= 'Please input the following information for the added kinetic process: ' ) self.blankcolumn = Label(self.frame, text=' ', width=2) self.layercolumn = Label(self.frame, text=' ', width=15) self.namecolumn = Label(self.frame, text=' ', width=15) self.equationcolumn = Label(self.frame, text=' ', width=20) self.ratecolumn = Label(self.frame, text=' ', width=10) self.coef1column = Label(self.frame, text=' ', width=10) self.unit1column = Label(self.frame, text=' ', width=3) self.endcolumn = Label(self.frame, text=' ', width=2) self.layerlabel = Label(self.frame, text='Layer') self.namelabel = Label(self.frame, text='Reaction') self.equationlabel = Label(self.frame, text='Chemical equation') self.ratelabel = Label(self.frame, text='Rate equation') self.lamcoeflabel = Label(self.frame, text='Coefficient ' + u'\u03BB') self.blank1 = Label(self.frame, text=' ') self.instructions.grid(row=0, column=0, padx=8, sticky='W', columnspan=11) self.blankcolumn.grid(row=1, column=0, padx=2, sticky='WE') self.layercolumn.grid(row=1, column=1, padx=2, sticky='WE') self.namecolumn.grid(row=1, column=2, padx=2, sticky='WE') self.equationcolumn.grid(row=1, column=3, padx=2, sticky='WE') self.ratecolumn.grid(row=1, column=4, padx=2, sticky='WE') self.coef1column.grid(row=1, column=5, padx=2, sticky='WE') self.unit1column.grid(row=1, column=6, padx=2, sticky='WE') self.endcolumn.grid(row=1, column=7, padx=2, sticky='WE') self.layerlabel.grid(row=2, column=1, padx=2, sticky='WE') self.namelabel.grid(row=2, column=2, padx=2, sticky='WE') self.equationlabel.grid(row=2, column=3, padx=2, sticky='WE') self.ratelabel.grid(row=2, column=4, padx=2, sticky='WE') self.blank1.grid(row=3, column=0, padx=2, sticky='WE', columnspan=11) if self.editflag == 1: self.layerwidget = Label(self.frame, text=self.layer) self.namewidget = Label(self.frame, text=self.reaction) self.equationwidget = Label(self.frame, text=self.equation, font=self.formulatype) self.layerwidget.grid(row=4, column=1, padx=2) self.namewidget.grid(row=4, column=2, padx=2) self.equationwidget.grid(row=4, column=3, padx=10) if self.coefficient.reaction.model == 'User-defined' or self.coefficient.reaction.model == 'Fundamental': unitindex = 0 tkfont = tkFont.Font(font=self.formulatype) tksubfont = tkFont.Font(font=self.subfont) tksuperfont = tkFont.Font(font=self.superfont) # Measure the width of rate and lambda expression rate_len = tkfont.measure(u'r = \u03BB') rate_len = rate_len + tksubfont.measure( str(self.coefficient.reaction.number) + ',') if self.coefficient.layer.number == 0: rate_len = rate_len + tksubfont.measure('D') else: rate_len = rate_len + tksubfont.measure( str(self.coefficient.layer.number)) for reactant in self.coefficient.reaction.reactants: if reactant.index <> 0: rate_len = rate_len + tkfont.measure('C') rate_len = rate_len + tksubfont.measure( reactant.formula) if reactant.index == int(reactant.index): index = int(reactant.index) else: index = reactant.index if index <> 1.: rate_len = rate_len + tksuperfont.measure( str(index) + ' ') unitindex = unitindex + reactant.index print(unitindex) lam_len = tkfont.measure('') if unitindex == int(unitindex): unitindex = int(unitindex) print(unitindex) if (unitindex - 1) != 0: if (unitindex - 1) != -1: lam_len = lam_len + tkfont.measure('(' + self.concunit + ')') lam_len = lam_len + tksuperfont.measure( str(-(unitindex - 1))) else: lam_len = lam_len + tkfont.measure(self.concunit + ' ') lam_len = lam_len + tkfont.measure(self.timeunit) lam_len = lam_len + tksuperfont.measure('-1') self.ratewidget = Text(self.frame, width=int(rate_len * 1.1424219345 / 8) + 1, height=1, font=self.formulatype) self.ratewidget.insert('end', u'r') self.ratewidget.insert('end', ' = ') self.ratewidget.insert('end', u'\u03BB') self.ratewidget.insert( 'end', str(self.coefficient.reaction.number) + ',', 'sub') if self.coefficient.layer.number == 0: self.ratewidget.insert('end', 'D', 'sub') else: self.ratewidget.insert('end', str(self.coefficient.layer.number), 'sub') for reactant in self.coefficient.reaction.reactants: if reactant.index <> 0: self.ratewidget.insert('end', 'C') self.ratewidget.insert('end', reactant.formula, 'sub') if reactant.index == int(reactant.index): index = int(reactant.index) else: index = reactant.index if index <> 1.: self.ratewidget.insert('end', str(index) + ' ', 'super') self.ratewidget.tag_config('sub', offset=-4, font=self.subfont) self.ratewidget.tag_config('super', offset=5, font=self.superfont) self.ratewidget.tag_config('right', justify='right') self.ratewidget.config(state='disabled', background=self.bgcolor, borderwidth=0, spacing3=3) self.lamcoefwidget = Entry(self.frame, textvariable=self.lam, justify='center', width=8) self.lamunitlabel = Text( self.frame, width=int(lam_len * 1.1424219345 / 8) + 1, height=1, font=self.formulatype) if (unitindex - 1) != 0: if (unitindex - 1) != -1: self.lamunitlabel.insert('end', '(' + self.concunit + ')') self.lamunitlabel.insert('end', str(-(unitindex - 1)), 'super') else: self.lamunitlabel.insert('end', self.concunit + ' ') self.lamunitlabel.insert('end', self.timeunit) self.lamunitlabel.insert('end', '-1', 'super') self.lamunitlabel.tag_config('sub', offset=-4, font=self.subfont) self.lamunitlabel.tag_config('super', offset=5, font=self.superfont) self.lamunitlabel.tag_config('right', justify='right') self.lamunitlabel.config(state='disabled', background=self.bgcolor, borderwidth=0, spacing3=3) self.lamcoeflabel.grid(row=2, column=5, padx=2, sticky='WE', columnspan=4) self.ratewidget.grid(row=4, column=4, padx=5) self.lamcoefwidget.grid(row=4, column=5, padx=2, sticky='E') self.lamunitlabel.grid(row=4, column=6, padx=2, sticky='W') else: self.layerwidget = OptionMenu(self.frame, self.layer, *self.layer_list, command=self.click_layer) self.layerwidget.grid(row=4, column=1, padx=2, sticky='WE') self.click_layer() self.okbutton = Button(self.frame, text='OK', width=20, command=self.OK) self.cancelbutton = Button(self.frame, text='Cancel', width=20, command=self.Cancel) self.blank2 = Label(self.frame, text=' ') self.blank3 = Label(self.frame, text=' ') self.blank4 = Label(self.frame, text=' ') self.focusbutton = None self.blank3.grid(row=5) self.okbutton.grid(row=6, columnspan=11) self.cancelbutton.grid(row=7, columnspan=11) self.blank4.grid(row=8) self.okbutton.bind('<Return>', self.OK) self.focusbutton = self.okbutton def click_layer(self, event=None): try: self.namewidget.grid_forget() except: pass self.reaction.set(self.reaction_list[self.layer_list.index( self.layer.get())][0]) self.namewidget = OptionMenu(self.frame, self.reaction, *self.reaction_list[self.layer_list.index( self.layer.get())], command=self.click_reaction) self.namewidget.grid(row=4, column=2, padx=2, sticky='WE') self.click_reaction() def click_reaction(self, event=None): try: self.equationwidget.grid_forget() self.ratewidget.grid_forget() except: pass try: self.lamcoeflabel.grid_forget() self.lamcoefwidget.grid_forget() self.lamunitlabel.grid_forget() except: pass coefficient = self.coefficients[self.layer.get()][self.reaction.get()] self.lam.set(coefficient.lam) self.equation = coefficient.reaction.equation self.equationwidget = Label(self.frame, text=self.equation, font=self.formulatype) self.equationwidget.grid(row=4, column=3, padx=5) if coefficient.reaction.model == 'User-defined' or coefficient.reaction.model == 'Fundamental': unitindex = 0 tkfont = tkFont.Font(font=self.formulatype) tksubfont = tkFont.Font(font=self.subfont) tksuperfont = tkFont.Font(font=self.superfont) # Measure the width of rate and lambda expression rate_len = tkfont.measure(u'r = \u03BB') rate_len = rate_len + tksubfont.measure( str(coefficient.reaction.number) + ',') if coefficient.layer.number == 0: rate_len = rate_len + tksubfont.measure('D') else: rate_len = rate_len + tksubfont.measure( str(coefficient.layer.number)) for reactant in coefficient.reaction.reactants: if reactant.index <> 0: rate_len = rate_len + tkfont.measure('C') rate_len = rate_len + tksubfont.measure(reactant.formula) if reactant.index == int(reactant.index): index = int(reactant.index) else: index = reactant.index if index <> 1.: rate_len = rate_len + tksuperfont.measure( str(index) + ' ') unitindex = unitindex + reactant.index lam_len = tkfont.measure('') if unitindex == int(unitindex): unitindex = int(unitindex) if (unitindex - 1) != 0: if (unitindex - 1) != 1: lam_len = lam_len + tkfont.measure('(' + self.concunit + ')') lam_len = lam_len + tksuperfont.measure( str(-(unitindex - 1))) else: lam_len = lam_len + tkfont.measure(self.concunit) lam_len = lam_len + tkfont.measure(self.timeunit) lam_len = lam_len + tksuperfont.measure('-1') self.ratewidget = Text(self.frame, width=int(rate_len * 1.1424219345 / 8) + 1, height=1, font=self.formulatype) self.ratewidget.insert('end', u'r = \u03BB') self.ratewidget.insert('end', str(coefficient.reaction.number) + ',', 'sub') if coefficient.layer.number == 0: self.ratewidget.insert('end', 'D', 'sub') else: self.ratewidget.insert('end', str(coefficient.layer.number), 'sub') for reactant in coefficient.reaction.reactants: if reactant.index <> 0: self.ratewidget.insert('end', 'C') self.ratewidget.insert('end', reactant.formula, 'sub') if reactant.index == int(reactant.index): index = int(reactant.index) else: index = reactant.index if index <> 1.: self.ratewidget.insert('end', str(index) + ' ', 'super') self.ratewidget.tag_config('sub', offset=-4, font=self.subfont) self.ratewidget.tag_config('super', offset=5, font=self.superfont) self.ratewidget.tag_config('right', justify='right') self.ratewidget.config(state='disabled', background=self.bgcolor, borderwidth=0, spacing3=3) self.lamcoefwidget = Entry(self.frame, textvariable=self.lam, justify='center', width=8) self.lamunitlabel = Text(self.frame, width=int(lam_len * 1.1424219345 / 8) + 1, height=1, font=self.formulatype) if unitindex == int(unitindex): unitindex = int(unitindex) if (unitindex - 1) != 0: if (unitindex - 1) != 1: self.lamunitlabel.insert('end', '(' + self.concunit + ')') self.lamunitlabel.insert('end', str(-(unitindex - 1)), 'super') else: self.lamunitlabel.insert('end', self.concunit) self.lamunitlabel.insert('end', self.timeunit) self.lamunitlabel.insert('end', '-1', 'super') self.lamunitlabel.tag_config('sub', offset=-4, font=self.subfont) self.lamunitlabel.tag_config('super', offset=5, font=self.superfont) self.lamunitlabel.tag_config('right', justify='right') self.lamunitlabel.config(state='disabled', background=self.bgcolor, borderwidth=0, spacing3=3) self.lamcoeflabel.grid(row=2, column=5, padx=2, sticky='WE', columnspan=4) self.ratewidget.grid(row=4, column=4, padx=5) self.lamcoefwidget.grid(row=4, column=5, padx=2, sticky='E') self.lamunitlabel.grid(row=4, column=6, padx=2, sticky='W') self.frame.update() self.focusbutton = None self.master.geometry() self.master.center() def OK(self, event=None): """Finish and move on. Checks that the number chemicals are less than the total number of chemicals in database.""" if self.editflag == 0: self.layerindex = self.layer_full_list.index(self.layer.get()) self.reactionnumber = self.reaction_full_list.index( self.reaction.get()) + 1 if self.master.window.top is not None: self.master.open_toplevel() elif self.lam == 0: self.coefficient_error() else: self.master.tk.quit() def coefficient_error(self): tkmb.showerror( title=self.version, message='At least one chemical has been replicated in the reaction!' ) self.focusbutton = self.okbutton self.master.tk.lift() def Cancel(self): try: self.reactants = self.reaction.reactants self.products = self.reaction.products except: self.cancelflag = 1 if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit()
def cs_dbl(value): dvar = DoubleVar() dvar.set(float(value)) return dvar
class Cockpit(ttkFrame): ''' Remote controller GUI ''' KEY_ANG_SPEED = "ang-speed" KEY_ANGLES = "angles" KEY_ACCEL = "accel" PID_KEYS = ["P", "I", "D"] DEFAULT_DRONE_IP = "192.168.1.130" DEFAULT_DRONE_PORT = 2121 DIR_NONE = 0 DIR_VERTICAL = 1 DIR_HORIZONTAL = 2 MAX_ACCEL = 10.0 #TODO angles. Replace by m/s² MAX_ACCEL_Z = 0.1 #m/s² MAX_ANGLE_SPEED = 50.0 #º/s def __init__(self, parent, isDummy = False, droneIp = DEFAULT_DRONE_IP, dronePort = DEFAULT_DRONE_PORT): ''' Constructor ''' ttkFrame.__init__(self, parent) self._started = IntVar() self._integralsEnabled = IntVar() self._target = [0.0] * 4 self._selectedPidConstats = "--" self._pidConstants = { Cockpit.KEY_ANG_SPEED:{ "X":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Y":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Z":{ "P": 0.0, "I": 0.0, "D": 0.0 } }, Cockpit.KEY_ANGLES: { "X":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Y":{ "P": 0.0, "I": 0.0, "D": 0.0 } }, Cockpit.KEY_ACCEL:{ "X":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Y":{ "P": 0.0, "I": 0.0, "D": 0.0 }, "Z":{ "P": 0.0, "I": 0.0, "D": 0.0 } } } self.parent = parent self.initUI() self._controlKeysLocked = False if not isDummy: self._link = INetLink(droneIp, dronePort) else: self._link = ConsoleLink() self._link.open() self._updateInfoThread = Thread(target=self._updateInfo) self._updateInfoThreadRunning = False self._readingState = False self._start() def initUI(self): self.parent.title("Drone control") self.style = Style() self.style.theme_use("default") self.pack(fill=BOTH, expand=1) self.parent.bind_all("<Key>", self._keyDown) self.parent.bind_all("<KeyRelease>", self._keyUp) if system() == "Linux": self.parent.bind_all("<Button-4>", self._onMouseWheelUp) self.parent.bind_all("<Button-5>", self._onMouseWheelDown) else: #case of Windows self.parent.bind_all("<MouseWheel>", self._onMouseWheel) #Commands commandsFrame = tkFrame(self) commandsFrame.grid(column=0, row=0, sticky="WE") self._startedCB = Checkbutton(commandsFrame, text="On", variable=self._started, command=self._startedCBChanged) self._startedCB.pack(side=LEFT, padx=4) self._integralsCB = Checkbutton(commandsFrame, text="Int.", variable=self._integralsEnabled, \ command=self._integralsCBChanged, state=DISABLED) self._integralsCB.pack(side=LEFT, padx=4) self._quitButton = Button(commandsFrame, text="Quit", command=self.exit) self._quitButton.pack(side=LEFT, padx=2, pady=2) # self._angleLbl = Label(commandsFrame, text="Angle") # self._angleLbl.pack(side=LEFT, padx=4) # # self._angleEntry = Entry(commandsFrame, state=DISABLED) # self._angleEntry.pack(side=LEFT) #Info infoFrame = tkFrame(self) infoFrame.grid(column=1, row=1, sticky="E", padx=4) #Throttle Label(infoFrame, text="Throttle").grid(column=0, row=0, sticky="WE") self._throttleTexts = [StringVar(),StringVar(),StringVar(),StringVar()] Entry(infoFrame, textvariable=self._throttleTexts[3], state=DISABLED, width=5).grid(column=0, row=1) Entry(infoFrame, textvariable=self._throttleTexts[0], state=DISABLED, width=5).grid(column=1, row=1) Entry(infoFrame, textvariable=self._throttleTexts[2], state=DISABLED, width=5).grid(column=0, row=2) Entry(infoFrame, textvariable=self._throttleTexts[1], state=DISABLED, width=5).grid(column=1, row=2) #Angles Label(infoFrame, text="Angles").grid(column=0, row=3, sticky="WE") self._angleTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._angleTexts[index], state=DISABLED, width=5).grid(column=index, row=4) #Accels Label(infoFrame, text="Accels").grid(column=0, row=5, sticky="WE") self._accelTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._accelTexts[index], state=DISABLED, width=5).grid(column=index, row=6) #Speeds Label(infoFrame, text="Speeds").grid(column=0, row=7, sticky="WE") self._speedTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._speedTexts[index], state=DISABLED, width=5).grid(column=index, row=8) #Height Label(infoFrame, text="Height").grid(column=0, row=9, sticky="W") self._heightText = StringVar() Entry(infoFrame, state=DISABLED, width=5).grid(column=1, row=9) #control controlFrame = tkFrame(self) controlFrame.grid(column=0, row=1, sticky="W") self._throttle = DoubleVar() self._thrustScale = Scale(controlFrame, orient=VERTICAL, from_=100.0, to=-100.0, \ tickinterval=0, variable=self._throttle, \ length=200, showvalue=1, \ state=DISABLED, command=self._onThrustScaleChanged) self._thrustScale.bind("<Double-Button-1>", self._onThrustScaleDoubleButton1, "+") self._thrustScale.grid(column=0) self._shiftCanvas = Canvas(controlFrame, bg="white", height=400, width=400, \ relief=SUNKEN) self._shiftCanvas.bind("<Button-1>", self._onMouseButton1) #self._shiftCanvas.bind("<ButtonRelease-1>", self._onMouseButtonRelease1) self._shiftCanvas.bind("<B1-Motion>", self._onMouseButton1Motion) self._shiftCanvas.bind("<Double-Button-1>", self._onMouseDoubleButton1) self._shiftCanvas.bind("<Button-3>", self._onMouseButton3) #self._shiftCanvas.bind("<ButtonRelease-3>", self._onMouseButtonRelease3) self._shiftCanvas.bind("<B3-Motion>", self._onMouseButton3Motion) self._shiftCanvas.grid(row=0,column=1, padx=2, pady=2) self._shiftCanvas.create_oval(2, 2, 400, 400, outline="#ff0000") self._shiftCanvas.create_line(201, 2, 201, 400, fill="#ff0000") self._shiftCanvas.create_line(2, 201, 400, 201, fill="#ff0000") self._shiftMarker = self._shiftCanvas.create_oval(197, 197, 205, 205, outline="#0000ff", fill="#0000ff") self._yaw = DoubleVar() self._yawScale = Scale(controlFrame, orient=HORIZONTAL, from_=-100.0, to=100.0, \ tickinterval=0, variable=self._yaw, \ length=200, showvalue=1, \ command=self._onYawScaleChanged) self._yawScale.bind("<Double-Button-1>", self._onYawScaleDoubleButton1, "+") self._yawScale.grid(row=1, column=1) self._controlKeyActive = False #PID calibration pidCalibrationFrame = tkFrame(self) pidCalibrationFrame.grid(column=0, row=2, sticky="WE"); self._pidSelected = StringVar() self._pidSelected.set("--") self._pidListBox = OptionMenu(pidCalibrationFrame, self._pidSelected, "--", \ Cockpit.KEY_ANG_SPEED, Cockpit.KEY_ANGLES, Cockpit.KEY_ACCEL, \ command=self._onPidListBoxChanged) self._pidListBox.pack(side=LEFT, padx=2) self._pidListBox.config(width=10) self._axisSelected = StringVar() self._axisSelected.set("--") self._axisListBox = OptionMenu(pidCalibrationFrame, self._axisSelected, "--", "X", "Y", "Z", \ command=self._onAxisListBoxChanged) self._axisListBox.pack(side=LEFT, padx=2) self._axisListBox.config(state=DISABLED) Label(pidCalibrationFrame, text="P").pack(side=LEFT, padx=(14, 2)) self._pidPString = StringVar() self._pidPString.set("0.00") self._pidPSpinbox = Spinbox(pidCalibrationFrame, width=5, from_=0.0, to=100.0, increment=0.01, state=DISABLED, \ textvariable=self._pidPString, command=self._onPidSpinboxChanged) self._pidPSpinbox.pack(side=LEFT, padx=2) Label(pidCalibrationFrame, text="I").pack(side=LEFT, padx=(14, 2)) self._pidIString = StringVar() self._pidIString.set("0.00") self._pidISpinbox = Spinbox(pidCalibrationFrame, width=5, from_=0.0, to=100.0, increment=0.01, state=DISABLED, \ textvariable=self._pidIString, command=self._onPidSpinboxChanged) self._pidISpinbox.pack(side=LEFT, padx=2) Label(pidCalibrationFrame, text="D").pack(side=LEFT, padx=(14, 2)) self._pidDString = StringVar() self._pidDString.set("0.00") self._pidDSpinbox = Spinbox(pidCalibrationFrame, width=5, from_=0.0, to=100.0, increment=0.01, state=DISABLED, \ textvariable=self._pidDString, command=self._onPidSpinboxChanged) self._pidDSpinbox.pack(side=LEFT, padx=2) #debug debugFrame = tkFrame(self) debugFrame.grid(column=0, row=3, sticky="WE") self._debugMsg = Message(debugFrame, anchor="nw", justify=LEFT, relief=SUNKEN, width=300) self._debugMsg.pack(fill=BOTH, expand=1) def _start(self): self._readDroneConfig() def exit(self): self._link.send({"key": "close", "data": None}) self._stopUpdateInfoThread() self._link.close() self.quit() def _updateTarget(self): markerCoords = self._shiftCanvas.coords(self._shiftMarker) coords = ((markerCoords[0] + markerCoords[2]) / 2, (markerCoords[1] + markerCoords[3]) / 2) self._target[1] = float(coords[0] - 201) * Cockpit.MAX_ACCEL / 200.0 self._target[0] = float(coords[1] - 201) * Cockpit.MAX_ACCEL / 200.0 #Remote control uses clockwise angle, but the drone's referece system uses counter-clockwise angle self._target[2] = -self._yaw.get() * Cockpit.MAX_ANGLE_SPEED / 100.0 self._target[3] = self._throttle.get() * Cockpit.MAX_ACCEL_Z / 100.0 self._sendTarget() def _keyDown(self, event): if event.keysym == "Escape": self._throttle.set(0) self._started.set(0) self._thrustScale.config(state=DISABLED) self._stopUpdateInfoThread() self._sendIsStarted() elif event.keysym.startswith("Control"): self._controlKeyActive = True elif not self._controlKeysLocked and self._controlKeyActive: if event.keysym == "Up": self._thrustScaleUp() elif event.keysym == "Down": self._thrustScaleDown() elif event.keysym == "Left": self._yawLeft() elif event.keysym == "Right": self._yawRight() elif event.keysym == "space": self._yawReset() self._thrustReset() elif not self._controlKeysLocked and not self._controlKeyActive: if event.keysym == "Up": self._moveShiftCanvasMarker((0,-5)) elif event.keysym == "Down": self._moveShiftCanvasMarker((0,5)) elif event.keysym == "Left": self._moveShiftCanvasMarker((-5,0)) elif event.keysym == "Right": self._moveShiftCanvasMarker((5,0)) elif event.keysym == "space": self._resetShiftCanvasMarker() def _keyUp(self, eventArgs): if eventArgs.keysym.startswith("Control"): self._controlKeyActive = False def _onMouseButton1(self, eventArgs): self._lastMouseCoords = (eventArgs.x, eventArgs.y) def _onMouseButtonRelease1(self, eventArgs): self._shiftCanvas.coords(self._shiftMarker, 197, 197, 205, 205) def _limitCoordsToSize(self, coords, size): if coords[0] > size: x = size elif coords[0] < 0: x = 0 else: x = coords[0] if coords[1] > size: y = size elif coords[1] < 0: y = 0 else: y = coords[1] return (x,y) def _moveShiftCanvasMarker(self, shift): lastCoords = self._shiftCanvas.coords(self._shiftMarker) newCoords = (lastCoords[0] + shift[0], lastCoords[1] + shift[1]) newCoords = self._limitCoordsToSize(newCoords, 400) self._shiftCanvas.coords(self._shiftMarker, newCoords[0], newCoords[1], newCoords[0] + 8, newCoords[1] + 8) self._updateTarget() def _resetShiftCanvasMarker(self): self._shiftCanvas.coords(self._shiftMarker, 197, 197, 205, 205) self._updateTarget() def _onMouseButton1Motion(self, eventArgs): deltaCoords = (eventArgs.x - self._lastMouseCoords[0], eventArgs.y - self._lastMouseCoords[1]) self._moveShiftCanvasMarker(deltaCoords) self._lastMouseCoords = (eventArgs.x, eventArgs.y) def _onMouseDoubleButton1(self, eventArgs): self._resetShiftCanvasMarker() def _onMouseButton3(self, eventArgs): self._lastMouseCoords = (eventArgs.x, eventArgs.y) self._mouseDirection = Cockpit.DIR_NONE def _onMouseButtonRelease3(self, eventArgs): self._shiftCanvas.coords(self._shiftMarker, 197, 197, 205, 205) def _onMouseButton3Motion(self, eventArgs): deltaCoords = (eventArgs.x - self._lastMouseCoords[0], eventArgs.y - self._lastMouseCoords[1]) if self._mouseDirection == Cockpit.DIR_NONE: if abs(deltaCoords[0]) > abs(deltaCoords[1]): self._mouseDirection = Cockpit.DIR_HORIZONTAL else: self._mouseDirection = Cockpit.DIR_VERTICAL if self._mouseDirection == Cockpit.DIR_HORIZONTAL: deltaCoords = (deltaCoords[0], 0) else: deltaCoords = (0, deltaCoords[1]) self._moveShiftCanvasMarker(deltaCoords) self._lastMouseCoords = (eventArgs.x, eventArgs.y) def _thrustScaleUp(self): if self._started.get(): newValue = self._thrustScale.get() + 1 self._thrustScale.set(newValue) self._updateTarget() def _thrustScaleDown(self): if self._started.get(): newValue = self._thrustScale.get() - 1 self._thrustScale.set(newValue) self._updateTarget() def _thrustReset(self): if self._started.get(): self._thrustScale.set(0.0) self._updateTarget() def _onThrustScaleDoubleButton1(self, eventArgs): self._thrustReset() return "break" def _yawRight(self): newValue = self._yaw.get() + 1 self._yaw.set(newValue) self._updateTarget() def _yawLeft(self): newValue = self._yaw.get() - 1 self._yaw.set(newValue) self._updateTarget() def _yawReset(self): self._yaw.set(0) self._updateTarget() def _onMouseWheelUp(self, eventArgs): if not self._controlKeyActive: self._thrustScaleUp() else: self._yawRight() def _onMouseWheelDown(self, eventArgs): if not self._controlKeyActive: self._thrustScaleDown() else: self._yawLeft() def _onMouseWheel(self, eventArgs): factor = int(eventArgs.delta/120) if not self._controlKeyActive: if self._started.get(): newValue = self._thrustScale.get() + factor self._thrustScale.set(newValue) self._updateTarget() else: newValue = self._yaw.get() + factor self._yaw.set(newValue) self._updateTarget() def _onYawScaleChanged(self, eventArgs): self._updateTarget() def _onYawScaleDoubleButton1(self, eventArgs): self._yawReset() return "break" def _startedCBChanged(self): if not self._started.get(): self._throttle.set(0) self._thrustScale.config(state=DISABLED) self._integralsCB.config(state=DISABLED) self._stopUpdateInfoThread() else: self._thrustScale.config(state="normal") self._integralsCB.config(state="normal") self._startUpdateInfoThread() self._sendIsStarted() def _integralsCBChanged(self): self._link.send({"key": "integrals", "data":self._integralsEnabled.get() != 0}) def _onThrustScaleChanged(self, eventArgs): self._updateTarget() def _sendTarget(self): self._link.send({"key": "target", "data": self._target}) def _sendIsStarted(self): isStarted = self._started.get() != 0 self._link.send({"key": "is-started", "data": isStarted}) def _sendPidCalibrationData(self): if self._pidSelected.get() != "--" and self._axisSelected.get() != "--": pidData = { "pid": self._pidSelected.get(), "axis": self._axisSelected.get(), "p": float(self._pidPSpinbox.get()), "i": float(self._pidISpinbox.get()), "d": float(self._pidDSpinbox.get())} self._link.send({"key": "pid-calibration", "data": pidData}) def _updatePidCalibrationData(self): pid = self._pidSelected.get() axis = self._axisSelected.get() if pid != "--" and axis != "--": self._pidConstants[pid][axis]["P"] = float(self._pidPSpinbox.get()) self._pidConstants[pid][axis]["I"] = float(self._pidISpinbox.get()) self._pidConstants[pid][axis]["D"] = float(self._pidDSpinbox.get()) def _readDroneConfig(self): self._link.send({"key": "read-drone-config", "data": None}, self._onDroneConfigRead) def _readDroneState(self): if not self._readingState: self._readingState = True self._link.send({"key": "read-drone-state", "data": None}, self._onDroneStateRead) def _readPidConfigItem(self, message, cockpitKey, axises, configKeys): for i in range(len(axises)): for j in range(len(Cockpit.PID_KEYS)): self._pidConstants[cockpitKey][axises[i]][Cockpit.PID_KEYS[j]] = message[configKeys[j]][i] def _onDroneConfigRead(self, message): #TODO Show current configuration within the GUI (at least relevant settings) if message: #Angle-speeds self._readPidConfigItem(message, Cockpit.KEY_ANG_SPEED, ["X", "Y", "Z"], \ [Configuration.PID_ANGLES_SPEED_KP, \ Configuration.PID_ANGLES_SPEED_KI, \ Configuration.PID_ANGLES_SPEED_KD]) #Angles self._readPidConfigItem(message, Cockpit.KEY_ANGLES, ["X", "Y"], \ [Configuration.PID_ANGLES_KP, \ Configuration.PID_ANGLES_KI, \ Configuration.PID_ANGLES_KD]) #Accels self._readPidConfigItem(message, Cockpit.KEY_ACCEL, ["X", "Y", "Z"], \ [Configuration.PID_ACCEL_KP, \ Configuration.PID_ACCEL_KI, \ Configuration.PID_ACCEL_KD]) def _onDroneStateRead(self, state): if state: for index in range(4): self._throttleTexts[index].set("{0:.3f}".format(state["_throttles"][index])) for index in range(3): self._accelTexts[index].set("{0:.3f}".format(state["_accels"][index])) self._angleTexts[index].set("{0:.3f}".format(state["_angles"][index])) else: self._stopUpdateInfoThread() self._readingState = False def _onPidSpinboxChanged(self): self._updatePidCalibrationData() self._sendPidCalibrationData() def _onPidListBoxChanged(self, pid): self._axisSelected.set("--") self._pidPString.set("--") self._pidIString.set("--") self._pidDString.set("--") self._pidPSpinbox.config(state=DISABLED) self._pidISpinbox.config(state=DISABLED) self._pidDSpinbox.config(state=DISABLED) self._selectedPidConstats = pid if pid == "--": self._axisListBox.config(state=DISABLED) self._controlKeysLocked = False else: self._axisListBox.config(state="normal") self._controlKeysLocked = True def _onAxisListBoxChanged(self, axis): if axis == "--" or (self._selectedPidConstats == Cockpit.KEY_ANGLES and axis == "Z"): self._pidPString.set("--") self._pidIString.set("--") self._pidDString.set("--") self._pidPSpinbox.config(state=DISABLED) self._pidISpinbox.config(state=DISABLED) self._pidDSpinbox.config(state=DISABLED) self._controlKeysLocked = axis != "--" else: self._pidPString.set("{:.2f}".format(self._pidConstants[self._selectedPidConstats][axis]["P"])) self._pidIString.set("{:.2f}".format(self._pidConstants[self._selectedPidConstats][axis]["I"])) self._pidDString.set("{:.2f}".format(self._pidConstants[self._selectedPidConstats][axis]["D"])) self._pidPSpinbox.config(state="normal") self._pidISpinbox.config(state="normal") self._pidDSpinbox.config(state="normal") self._controlKeysLocked = True def _updateInfo(self): while self._updateInfoThreadRunning: self._readDroneState() time.sleep(1.0) def _startUpdateInfoThread(self): self._updateInfoThreadRunning = True if not self._updateInfoThread.isAlive(): self._updateInfoThread.start() def _stopUpdateInfoThread(self): self._updateInfoThreadRunning = False if self._updateInfoThread.isAlive(): self._updateInfoThread.join()
class FakeDeviceApp(Frame): MIN_X = 0 MAX_X = 50 MIN_Y = 0 MAX_Y = 100 MIN_Z = 0 MAX_Z = 200 def __init__(self, parent): Frame.__init__(self, parent, background='white') self.parent = parent self.init_ui() def init_ui(self): self.parent.title('Fake Device') self.style = Style() self.style.theme_use('default') self.pack(fill=BOTH, expand=1) x_scale = Scale(self, from_=self.MIN_X, to=self.MAX_X, command=self.on_scale_x) x_scale.place(x=0, y=0) y_scale = Scale(self, from_=self.MIN_Y, to=self.MAX_Y, command=self.on_scale_y) y_scale.place(x=0, y=20) z_scale = Scale(self, from_=self.MIN_Z, to=self.MAX_Z, command=self.on_scale_z) z_scale.place(x=0, y=40) angle_scale = Scale(self, from_=0, to=math.pi/2, command=self.on_scale_angle) angle_scale.place(x=0, y=80) self.x_var = IntVar() self.x_label = Label(self, text=0, textvariable=self.x_var) self.x_label.place(x=100, y=0) self.y_var = IntVar() self.y_label = Label(self, text=0, textvariable=self.y_var) self.y_label.place(x=100, y=20) self.z_var = IntVar() self.z_label = Label(self, text=0, textvariable=self.z_var) self.z_label.place(x=100, y=40) self.angle_var = DoubleVar() self.angle_label = Label(self, text=0, textvariable=self.angle_var) self.angle_label.place(x=100, y=80) self.button = Button(self, text='test', command=self.on_button) self.button.place(x=0, y=100) def on_button(self): print('hello') def on_scale_angle(self, val): v = float(val) self.angle_var.set(v) self.update() def on_scale_x(self, val): v = int(float(val)) self.x_var.set(v) self.update() def on_scale_y(self, val): v = int(float(val)) self.y_var.set(v) self.update() def on_scale_z(self, val): v = int(float(val)) self.z_var.set(v) self.update() def update(self): x = self.x_var.get() y = self.y_var.get() z = self.z_var.get() angle = self.angle_var.get() sensor = events.sensor_storage sensor.reset() if not (x == 0 and y == 0 and z == 0): index_pos = [x, y, z] sensor.index_finger_pos = index_pos sensor.cmd_angle = angle
class ConfigClass: def __init__(self,textbox,FOLDER,APPNAME): self.folder=os.path.join(FOLDER,'config') self.appname=APPNAME # Das Standard App Verzeichniss fuer das Betriebssystem abfragen self.make_settings_folder() # eine ConfigParser Instanz oeffnen und evt. vorhandenes Config File Laden self.parser = ConfigParser.ConfigParser() self.cfg_file_name=self.appname+'_config.cfg' self.parser.read(os.path.join(self.folder,self.cfg_file_name)) # Falls kein Config File vorhanden ist oder File leer ist neue File anlegen und neu laden if len(self.parser.sections())==0: self.make_new_Config_file() self.parser.read(os.path.join(self.folder,self.cfg_file_name)) textbox.prt((_('\nNo config file found generated new on at: %s') \ %os.path.join(self.folder,self.cfg_file_name))) else: textbox.prt((_('\nLoading config file:%s') \ %os.path.join(self.folder,self.cfg_file_name))) #Tkinter Variablen erstellen zur späteren Verwendung in den Eingabefeldern self.get_all_vars() #DEBUG INFORMATIONEN #Übergeben des geladenen Debug Level textbox.set_debuglevel(DEBUG=self.debug) textbox.prt(_('\nDebug Level: %i') %(self.debug),1) textbox.prt(str(self),1) def make_settings_folder(self): # create settings folder if necessary try: os.mkdir(self.folder) except OSError: pass def make_new_Config_file(self): #Generelle Einstellungen für Export self.parser.add_section('General') self.parser.set('General', 'write_to_stdout', 0) self.parser.add_section('Paths') self.parser.set('Paths', 'load_path', 'C:\Users\Christian Kohloeffel\Documents\DXF2GCODE\trunk\dxf') self.parser.set('Paths', 'save_path', 'C:\Users\Christian Kohloeffel\Documents') self.parser.add_section('Import Parameters') self.parser.set('Import Parameters', 'point_tolerance', 0.01) self.parser.set('Import Parameters', 'fitting_tolerance', 0.01) self.parser.set('Import Parameters', 'spline_check',1) self.parser.add_section('Tool Parameters') self.parser.set('Tool Parameters', 'diameter', 0.1) self.parser.set('Tool Parameters', 'start_radius', 0.05) self.parser.add_section('Plane Coordinates') self.parser.set('Plane Coordinates', 'axis1_start_end', 0) self.parser.set('Plane Coordinates', 'axis2_start_end', 0) self.parser.add_section('Depth Coordinates') self.parser.set('Depth Coordinates', 'axis3_retract', 1) self.parser.set('Depth Coordinates', 'axis3_safe_margin', 1.0) self.parser.set('Depth Coordinates', 'axis3_mill_depth', -1.0) self.parser.set('Depth Coordinates', 'axis3_slice_depth', -1.0) self.parser.add_section('Feed Rates') self.parser.set('Feed Rates', 'f_g1_depth', 300) self.parser.set('Feed Rates', 'f_g1_plane', 5000) self.parser.add_section('Axis letters') self.parser.set('Axis letters', 'ax1_letter', 'X') self.parser.set('Axis letters', 'ax2_letter', 'Y') self.parser.set('Axis letters', 'ax3_letter', 'Z') self.parser.add_section('Route Optimisation') self.parser.set('Route Optimisation', 'Begin art','heurestic') self.parser.set('Route Optimisation', 'Max. population', 20) self.parser.set('Route Optimisation', 'Max. iterations', 300) self.parser.set('Route Optimisation', 'Mutation Rate', 0.95) self.parser.add_section('Filters') self.parser.set('Filters', 'pstoedit_cmd','C:\Program Files (x86)\pstoedit\pstoedit') self.parser.set('Filters', 'pstoedit_opt', ['-f','dxf','-mm']) self.parser.add_section('Debug') self.parser.set('Debug', 'global_debug_level', 0) open_file = open(os.path.join(self.folder,self.cfg_file_name), "w") self.parser.write(open_file) open_file.close() def get_all_vars(self): #try: self.write_to_stdout=int(self.parser.get('General', 'write_to_stdout')) self.tool_dia=DoubleVar() self.tool_dia.set(float(self.parser.get('Tool Parameters','diameter'))) self.start_rad=DoubleVar() self.start_rad.set(float(self.parser.get('Tool Parameters','start_radius'))) self.axis1_st_en=DoubleVar() self.axis1_st_en.set(float(self.parser.get('Plane Coordinates','axis1_start_end'))) self.axis2_st_en=DoubleVar() self.axis2_st_en.set(float(self.parser.get('Plane Coordinates','axis2_start_end'))) self.axis3_retract=DoubleVar() self.axis3_retract.set(float(self.parser.get('Depth Coordinates','axis3_retract'))) self.axis3_safe_margin=DoubleVar() self.axis3_safe_margin.set(float(self.parser.get('Depth Coordinates','axis3_safe_margin'))) self.axis3_slice_depth=DoubleVar() self.axis3_slice_depth.set(float(self.parser.get('Depth Coordinates','axis3_slice_depth'))) self.axis3_mill_depth=DoubleVar() self.axis3_mill_depth.set(float(self.parser.get('Depth Coordinates','axis3_mill_depth'))) self.F_G1_Depth=DoubleVar() self.F_G1_Depth.set(float(self.parser.get('Feed Rates','f_g1_depth'))) self.F_G1_Plane=DoubleVar() self.F_G1_Plane.set(float(self.parser.get('Feed Rates','f_g1_plane'))) self.points_tolerance=DoubleVar() self.points_tolerance.set(float(self.parser.get('Import Parameters','point_tolerance'))) self.fitting_tolerance=DoubleVar() self.fitting_tolerance.set(float(self.parser.get('Import Parameters','fitting_tolerance'))) self.spline_check=int(self.parser.get('Import Parameters', 'spline_check') ) #Zuweisen der Werte fuer die TSP Optimierung self.begin_art=self.parser.get('Route Optimisation', 'Begin art') self.max_population=int((int(self.parser.get('Route Optimisation', 'Max. population'))/4)*4) self.max_iterations=int(self.parser.get('Route Optimisation', 'Max. iterations')) self.mutate_rate=float(self.parser.get('Route Optimisation', 'Mutation Rate', 0.95)) #Zuweisen der Axis Letters self.ax1_letter=self.parser.get('Axis letters', 'ax1_letter') self.ax2_letter=self.parser.get('Axis letters', 'ax2_letter') self.ax3_letter=self.parser.get('Axis letters', 'ax3_letter') #Holen der restlichen Variablen #Verzeichnisse self.load_path=self.parser.get('Paths','load_path') self.save_path=self.parser.get('Paths','save_path') #Holen der Commandos fuer pstoedit self.pstoedit_cmd=self.parser.get('Filters','pstoedit_cmd') self.pstoedit_opt=self.parser.get('Filters','pstoedit_opt') #Setzen des Globalen Debug Levels self.debug=int(self.parser.get('Debug', 'global_debug_level')) # except: # showerror(_("Error during reading config file"), _("Please delete or correct\n %s")\ # %(os.path.join(self.folder,self.cfg_file_name))) # raise Exception, _("Problem during import from INI File") # def __str__(self): str='' for section in self.parser.sections(): str= str +"\nSection: "+section for option in self.parser.options(section): str= str+ "\n -> %s=%s" % (option, self.parser.get(section, option)) return str
class MovePanel(PluginPanel): name='Move' title = _("Move") def init(self, master): PluginPanel.init(self, master) root=self.mw.root self.var_width_number=DoubleVar(root) self.var_height_number=DoubleVar(root) self.var_width_base=DoubleVar(root) self.var_height_base=DoubleVar(root) var_width_unit = StringVar(root) var_height_unit = StringVar(root) unit = config.preferences.default_unit self.var_width = LengthVar(10, unit, self.var_width_number, var_width_unit) self.var_height = LengthVar(10, unit,self.var_height_number,var_height_unit) jump=config.preferences.default_unit_jump self.var_width.set(0) self.var_height.set(0) self.var_width_base.set(0) self.var_height_base.set(0) self.var_position = StringVar(root) self.var_position.set(ABSOLUTE) self.var_basepoint = StringVar(root) self.var_basepoint.set('C') #--------------------------------------------------------- top = TFrame(self.panel, style='FlatFrame') top.pack(side = TOP, fill=BOTH) #--------------------------------------------------------- # Horisontal size size_frameH = TFrame(top, style='FlatFrame', borderwidth=3) size_frameH.pack(side = TOP, fill = BOTH) label = TLabel(size_frameH, style='FlatLabel', image='move_h') label.pack(side = LEFT, padx=5) self.entry_width = TSpinbox(size_frameH, var=0, vartype=1, textvariable = self.var_width_number, min = -50000, max = 50000, step = jump, width = 10, command=self.apply_move) self.entry_width.pack(side = LEFT) self.labelwunit = TLabel(size_frameH, style='FlatLabel', text = self.var_width.unit) self.labelwunit.pack(side = LEFT, padx=5) #--------------------------------------------------------- # Vertical size_frameV = TFrame(top, style='FlatFrame', borderwidth=3) size_frameV.pack(side = TOP, fill = BOTH) label = TLabel(size_frameV, style='FlatLabel', image='move_v') label.pack(side = LEFT, padx=5) self.entry_height = TSpinbox(size_frameV, var=0, vartype=1, textvariable = self.var_height_number, min = -50000, max = 50000, step = jump, width = 10, command=self.apply_move) self.entry_height.pack(side = LEFT) self.labelhunit = TLabel(size_frameV, style='FlatLabel', text = self.var_height.unit) self.labelhunit.pack(side = LEFT, padx=5) #--------------------------------------------------------- # position chek self.position_check = TCheckbutton(top, text = _("Absolute Coordinates"), variable = self.var_position, onvalue=ABSOLUTE, offvalue=RELATIVE, command = self.position) self.position_check.pack(side = TOP, anchor=W, padx=5,pady=5) #--------------------------------------------------------- # Basepoint check label = TLabel(top, style='FlatLabel', text = _("Basepoint:")) label.pack(side = TOP, fill = BOTH, padx=5) basepoint_frame=TLabelframe(top, labelwidget=label, style='Labelframe', borderwidth=4) basepoint_frame.pack(side = TOP, fill=X, padx=5, pady=2) self.Basepoint = BasePointSelector(basepoint_frame, anchor=self.var_basepoint, command = self.apply_basepoint) self.Basepoint.pack(side = LEFT, fill = BOTH, padx=5) label = TLabel(basepoint_frame, style='FlatLabel', image = 'coordinate_sys') label.pack(side = LEFT, fill = BOTH, padx=10) #--------------------------------------------------------- # Button frame button_frame = TFrame(top, style='FlatFrame', borderwidth=5) button_frame.pack(side = BOTTOM, fill = BOTH) self.update_buttons = [] self.button = UpdatedButton(top, text = _("Apply"), command = self.apply_move) self.button.pack(in_ = button_frame, side = BOTTOM, expand = 1, fill = X, pady=3) self.button_copy = UpdatedButton(top, text = _("Apply to Copy"), command = self.apply_to_copy) self.button_copy.pack(in_ = button_frame, side = BOTTOM, expand = 1, fill = X) self.init_from_doc() self.subscribe_receivers() ############################################################################### def subscribe_receivers(self): self.document.Subscribe(SELECTION, self.Update) self.document.Subscribe(EDITED, self.update_var) config.preferences.Subscribe(CHANGED, self.update_pref) def unsubscribe_receivers(self): self.document.Unsubscribe(SELECTION, self.Update) self.document.Unsubscribe(EDITED, self.update_var) config.preferences.Unsubscribe(CHANGED, self.update_pref) def init_from_doc(self, *arg): self.Update() def Update(self, *arg): if self.is_selection(): self.entry_width.set_state(NORMAL) self.entry_height.set_state(NORMAL) self.position_check['state']=NORMAL self.button['state']=NORMAL self.button_copy['state']=NORMAL else: self.entry_width.set_state(DISABLED) self.entry_height.set_state(DISABLED) self.position_check['state']=DISABLED self.button['state']=DISABLED self.button_copy['state']=DISABLED self.update_pref() def apply_basepoint(self): self.Update() def position(self): if self.var_position.get()==ABSOLUTE and self.var_basepoint.get()=='USER': self.var_basepoint.set('C') self.update_var() def apply_move(self, *arg): if self.button["state"]==DISABLED: return try: var_x=self.var_width.get() var_y=self.var_height.get() except: return x, y = self.coordinates(self.var_position.get()) if self.var_position.get()==RELATIVE: if self.var_width_base != self.var_width.get() or self.var_height_base != self.var_height.get(): self.var_basepoint.set('USER') x,y = var_x, var_y else: x,y = var_x-x, var_y-y if arg and arg[0] == 'Duplicate': self.document.MoveAndCopy(x, y, Point(0,0)) else: self.document.MoveSelected(x, y) def apply_to_copy(self): self.apply_move('Duplicate') def coordinates(self, position): br=self.document.selection.coord_rect hor_sel=br.right - br.left ver_sel=br.top - br.bottom if position == RELATIVE: left, bottom = -hor_sel/2, -ver_sel/2 else: left, bottom = br.left, br.bottom cnt_x,cnt_y=self.Basepoint.get_basepoint(hor_sel,ver_sel,left,bottom) if position == RELATIVE and cnt_x!=None: return cnt_x*2, cnt_y*2 else: return cnt_x, cnt_y def update_pref(self, *arg): self.labelwunit['text']=config.preferences.default_unit self.labelhunit['text']=config.preferences.default_unit self.entry_width.step=config.preferences.default_unit_jump self.entry_height.step=config.preferences.default_unit_jump self.update_var() def update_var(self, *arg): if len(self.document.selection.GetInfo()): if self.var_basepoint.get() == 'USER': x=self.var_width.get() y=self.var_height.get() self.var_width.unit=config.preferences.default_unit self.var_height.unit=config.preferences.default_unit self.var_width.set(x) self.var_height.set(y) else: self.var_width.unit=config.preferences.default_unit self.var_height.unit=config.preferences.default_unit x, y = self.coordinates(self.var_position.get()) self.var_width.set(x) self.var_height.set(y) self.var_width_base=self.var_width.get() self.var_height_base=self.var_height.get() def is_selection(self): return (len(self.document.selection) > 0)
class FontPanel(StylePropertyPanel): title = _("Fonts") def __init__(self, master, main_window, doc): self.family_to_fonts = font.make_family_to_fonts() self.families = self.family_to_fonts.keys() self.families.sort() StylePropertyPanel.__init__(self, master, main_window, doc, name='fontdlg') self.family_list.SetList(self.families) index = self.families.index(self.font_family) self.family_list.select_set(index) self.family_list.yview(index) def build_dlg(self): top = self.top buttons = self.create_std_buttons(top) buttons.grid(row=3, column=4, columnspan=2, sticky="news") self.sample = FontPreview(top) self.sample.grid(column=0, row=3, columnspan=4, sticky="news") # XXX: the background color of the sample text should be # configurable label = Label(top, text=_("Font Family:"), anchor=W) label.grid(column=0, row=0, columnspan=2, sticky="ew") sb_vert = Scrollbar(top, takefocus=0) sb_vert.grid(column=1, row=1, rowspan=2, sticky="news") family_list = UpdatedListbox(top, name='families', height=8) family_list.grid(column=0, row=1, rowspan=2, sticky="news") family_list.Subscribe(SELECTION, self.family_selected) sb_vert['command'] = (family_list, 'yview') family_list['yscrollcommand'] = (sb_vert, 'set') self.family_list = family_list label = Label(top, text=_("Font Style:"), anchor=W) label.grid(column=2, row=0, sticky="ew") sb_vert = Scrollbar(top, takefocus=0) sb_vert.grid(column=3, row=1, rowspan=2, sticky="news") self.font_attr_list = UpdatedListbox(top, name='weights', height=4, width=15) self.font_attr_list.grid(column=2, row=1, rowspan=2, sticky="news") self.font_attr_list.Subscribe(SELECTION, self.attr_selected) sb_vert['command'] = (self.font_attr_list, 'yview') self.font_attr_list['yscrollcommand'] = (sb_vert, 'set') label = Label(top, text=_("Size:"), anchor=W) label.grid(column=4, row=0, columnspan=2, sticky="ew") frame = Frame(top) frame.grid(column=4, row=1, columnspan=2, sticky='ew') self.var_size = DoubleVar(top) scroll = MiniScroller(frame, variable=self.var_size, min=0.0, max=None, step=1) scroll.pack(side=RIGHT, fill=Y) self.size_entry = MyEntry(frame, textvariable=self.var_size, width=4, command=self.apply_size, justify=RIGHT) self.size_entry.pack(side=LEFT, expand=1, fill=BOTH) sb_vert = Scrollbar(top, takefocus=0) sb_vert.grid(column=5, row=2, sticky="news") self.size_list = UpdatedListbox(top, name='sizes', width=4, height=5) self.size_list.grid(column=4, row=2, sticky="news") self.size_list.Subscribe(SELECTION, self.size_selected) self.size_list.SetList(std_sizes) sb_vert['command'] = (self.size_list, 'yview') self.size_list['yscrollcommand'] = (sb_vert, 'set') top.columnconfigure(0, weight=1000) top.columnconfigure(4, weight=1) top.rowconfigure(2, weight=1) def init_from_doc(self): object = self.document.CurrentObject() if object is not None and object.is_Text: self.update_from_object_cb(object) else: default = font.GetFont(config.preferences.default_font) self.font_family = default.family self.font_attr = default.font_attrs self.update_from_family() self.update_size(properties.default_text_style.font_size) def Update(self): self.update_from_object_cb(self.document.CurrentObject()) def update_from_object_cb(self, obj): if obj is not None and obj.is_Text: font = obj.Font() self.font_family = font.family self.font_attr = font.font_attrs self.update_size(obj.FontSize()) self.update_from_family() def do_apply(self): name = self.current_font_ps() if not name: if __debug__: pdebug(None, 'FontPanel.do_apply: no ps name!') return kw = { 'font': font.GetFont(name), 'font_size': self.var_size.get(), # set if_type_present to one to make sure that font # properties are only set on objects that can have font # properties. This is not ideal, but it works and needed # only simple changes to base.py 'if_type_present': 1 } self.set_properties(_("Set Font `%s'") % name, 'font', kw) def update_from_family(self, set_view=1): index = self.families.index(self.font_family) self.family_list.Select(index, set_view) fonts = self.family_to_fonts[self.font_family] attrs = [] for name in fonts: attrs.append(font.fontmap[name][1]) attrs.sort() self.set_font_attrs(attrs) self.update_sample() def update_size(self, size): self.var_size.set(size) if size in std_sizes: self.size_list.Select(list(std_sizes).index(size), 1) else: self.size_list.SelectNone() def update_sample(self): self.sample.SetFont(self.current_font_ps()) def set_font_attrs(self, attrs): self.font_attrs = attrs self.font_attr_list.SetList(attrs) self.font_attr = get_from_list(self.font_attr, attrs) self.font_attr_list.Select(attrs.index(self.font_attr), 1) def current_font_xlfd(self): fonts = self.family_to_fonts[self.font_family] for name in fonts: family, attrs, xlfd_start, encoding = font.fontmap[name] if attrs == self.font_attr: return font.xlfd_template % (xlfd_start, 24, encoding) return '' def current_font_ps(self): fonts = self.family_to_fonts[self.font_family] for name in fonts: family, attrs, xlfd_start, encoding = font.fontmap[name] if attrs == self.font_attr: return name return '' def family_selected(self): sel = self.family_list.curselection() if sel: index = sel[0] self.font_family = self.families[index] self.update_from_family(set_view=0) def attr_selected(self): sel = self.font_attr_list.curselection() if sel: index = sel[0] self.font_attr = self.font_attrs[index] self.update_sample() def size_selected(self): sel = self.size_list.curselection() if sel: self.var_size.set(self.size_list.get(sel[0])) def apply_size(self, *args): if self.can_apply(): size = self.var_size.get() self.document.CallObjectMethod(text.CommonText, _("Set Font Size %.1f") % size, 'SetFontSize', size) def save_prefs(self): StylePropertyPanel.save_prefs(self) config.preferences.sample_text = self.sample.Text()
class FontPanel(StylePropertyPanel): title = _("Fonts") def __init__(self, master, main_window, doc): self.family_to_fonts = font.make_family_to_fonts() self.families = self.family_to_fonts.keys() self.families.sort() StylePropertyPanel.__init__(self, master, main_window, doc, name = 'fontdlg') self.family_list.SetList(self.families) index = self.families.index(self.font_family) self.family_list.select_set(index) self.family_list.yview(index) def build_dlg(self): top = self.top buttons = self.create_std_buttons(top) buttons.grid(row = 3, column = 4, columnspan = 2, sticky = "news") self.sample_text = StringVar(top) self.sample_text.set(config.preferences.sample_text) self.sample = Entry(top, textvariable = self.sample_text, relief = FLAT, bg = top['bg'], width = len(config.preferences.sample_text)) self.sample.grid(column = 0, row = 3, columnspan = 4, sticky = "news") # XXX: the background color of the sample text should be # configurable label = Label(top, text = _("Font Family:"), anchor = W) label.grid(column = 0, row = 0, columnspan = 2, sticky = "ew") sb_vert = Scrollbar(top, takefocus = 0) sb_vert.grid(column = 1, row = 1, rowspan = 2, sticky = "news") family_list = UpdatedListbox(top, name = 'families', height = 8) family_list.grid(column = 0, row = 1, rowspan = 2, sticky = "news") family_list.Subscribe(SELECTION, self.family_selected) sb_vert['command'] = (family_list, 'yview') family_list['yscrollcommand'] = (sb_vert, 'set') self.family_list = family_list label = Label(top, text = _("Font Style:"), anchor = W) label.grid(column = 2, row = 0, sticky = "ew") sb_vert = Scrollbar(top, takefocus = 0) sb_vert.grid(column = 3, row = 1, rowspan = 2, sticky = "news") self.font_attr_list = UpdatedListbox(top, name = 'weights', height = 4, width = 15) self.font_attr_list.grid(column = 2, row = 1, rowspan = 2, sticky = "news") self.font_attr_list.Subscribe(SELECTION, self.attr_selected) sb_vert['command'] = (self.font_attr_list, 'yview') self.font_attr_list['yscrollcommand'] = (sb_vert, 'set') label = Label(top, text = _("Size:"), anchor = W) label.grid(column = 4, row = 0, columnspan = 2, sticky = "ew") frame = Frame(top) frame.grid(column = 4, row = 1, columnspan = 2, sticky = 'ew') self.var_size = DoubleVar(top) scroll = MiniScroller(frame, variable = self.var_size, min = 0.0, max = None, step = 1) scroll.pack(side = RIGHT, fill = Y) self.size_entry = MyEntry(frame, textvariable = self.var_size, width = 4, command = self.apply_size, justify = RIGHT) self.size_entry.pack(side = LEFT, expand = 1, fill = BOTH) sb_vert = Scrollbar(top, takefocus = 0) sb_vert.grid(column = 5, row = 2, sticky = "news") self.size_list = UpdatedListbox(top, name = 'sizes', width = 4, height = 5) self.size_list.grid(column = 4, row = 2, sticky = "news") self.size_list.Subscribe(SELECTION, self.size_selected) self.size_list.SetList(std_sizes) sb_vert['command'] = (self.size_list, 'yview') self.size_list['yscrollcommand'] = (sb_vert, 'set') top.columnconfigure(0, weight = 1000) top.columnconfigure(4, weight = 1) top.rowconfigure(2, weight = 1) def init_from_doc(self): object = self.document.CurrentObject() if object is not None and object.is_Text: self.update_from_object_cb(object) else: default = font.GetFont(config.preferences.default_font) self.font_family = default.family self.font_attr = default.font_attrs self.update_from_family() self.update_size(properties.default_text_style.font_size) def Update(self): self.update_from_object_cb(self.document.CurrentObject()) def update_from_object_cb(self, obj): if obj is not None and obj.is_Text: font = obj.Font() self.font_family = font.family self.font_attr = font.font_attrs self.update_size(obj.FontSize()) self.update_from_family() def do_apply(self): name = self.current_font_ps() if not name: if __debug__: pdebug(None, 'FontPanel.do_apply: no ps name!') return kw = {'font': font.GetFont(name), 'font_size': self.var_size.get(), # set if_type_present to one to make sure that font # properties are only set on objects that can have font # properties. This is not ideal, but it works and needed # only simple changes to base.py 'if_type_present': 1} self.set_properties(_("Set Font `%s'") % name, 'font', kw) def update_from_family(self, set_view = 1): index = self.families.index(self.font_family) self.family_list.Select(index, set_view) fonts = self.family_to_fonts[self.font_family] attrs = [] for name in fonts: attrs.append(font.fontmap[name][1]) attrs.sort() self.set_font_attrs(attrs) self.update_sample() def update_size(self, size): self.var_size.set(size) if size in std_sizes: self.size_list.Select(list(std_sizes).index(size), 1) else: self.size_list.SelectNone() def update_sample(self): xlfd = self.current_font_xlfd() if not xlfd: xlfd = 'fixed' self.sample['font'] = xlfd def set_font_attrs(self, attrs): self.font_attrs = attrs self.font_attr_list.SetList(attrs) self.font_attr = get_from_list(self.font_attr, attrs) self.font_attr_list.Select(attrs.index(self.font_attr), 1) def current_font_xlfd(self): fonts = self.family_to_fonts[self.font_family] for name in fonts: family, attrs, xlfd_start, encoding = font.fontmap[name] if attrs == self.font_attr: return font.xlfd_template % (xlfd_start, 24, encoding) return '' def current_font_ps(self): fonts = self.family_to_fonts[self.font_family] for name in fonts: family, attrs, xlfd_start, encoding = font.fontmap[name] if attrs == self.font_attr: return name return '' def family_selected(self): sel = self.family_list.curselection() if sel: index = string.atoi(sel[0]) self.font_family = self.families[index] self.update_from_family(set_view = 0) def attr_selected(self): sel = self.font_attr_list.curselection() if sel: index = string.atoi(sel[0]) self.font_attr = self.font_attrs[index] self.update_sample() def size_selected(self): sel = self.size_list.curselection() if sel: self.var_size.set(self.size_list.get(sel[0])) def apply_size(self, *args): if self.can_apply(): size = self.var_size.get() self.document.CallObjectMethod(text.CommonText, _("Set Font Size %.1f") % size, 'SetFontSize', size) def save_prefs(self): StylePropertyPanel.save_prefs(self) config.preferences.sample_text = self.sample_text.get()
class wm_seg: """ Simple GUI application If the application inside a container, automatic updates are removed. The application uses two frames (tabs): - training - testing """ def __init__(self, master, container): self.master = master master.title("nicMSlesions") # running on a container self.container = container # gui attributes self.path = os.getcwd() self.default_config = None self.user_config = None self.current_folder = os.getcwd() self.list_train_pretrained_nets = [] self.list_test_nets = [] self.version = __version__ if self.container is False: # version_number self.commit_version = subprocess.check_output( ['git', 'rev-parse', 'HEAD']) # queue and thread parameters. All processes are embedded # inside threads to avoid freezing the application self.train_task = None self.test_task = None self.test_queue = Queue.Queue() self.train_queue = Queue.Queue() # -------------------------------------------------- # parameters. Mostly from the config/*.cfg files # -------------------------------------------------- # data parameters self.param_training_folder = StringVar() self.param_test_folder = StringVar() self.param_FLAIR_tag = StringVar() self.param_T1_tag = StringVar() self.param_MOD3_tag = StringVar() self.param_MOD4_tag = StringVar() self.param_mask_tag = StringVar() self.param_model_tag = StringVar() self.param_register_modalities = BooleanVar() self.param_skull_stripping = BooleanVar() self.param_denoise = BooleanVar() self.param_denoise_iter = IntVar() self.param_save_tmp = BooleanVar() self.param_debug = BooleanVar() # train parameters self.param_net_folder = os.path.join(self.current_folder, 'nets') self.param_use_pretrained_model = BooleanVar() self.param_pretrained_model = StringVar() self.param_inference_model = StringVar() self.param_num_layers = IntVar() self.param_net_name = StringVar() self.param_net_name.set('None') self.param_balanced_dataset = StringVar() self.param_fract_negatives = DoubleVar() # model parameters self.param_pretrained = None self.param_min_th = DoubleVar() self.param_patch_size = IntVar() self.param_weight_paths = StringVar() self.param_load_weights = BooleanVar() self.param_train_split = DoubleVar() self.param_max_epochs = IntVar() self.param_patience = IntVar() self.param_batch_size = IntVar() self.param_net_verbose = IntVar() self.param_t_bin = DoubleVar() self.param_l_min = IntVar() self.param_min_error = DoubleVar() self.param_mode = BooleanVar() self.param_gpu_number = IntVar() # load the default configuration from the conf file self.load_default_configuration() # self frame (tabbed notebook) self.note = Notebook(self.master) self.note.pack() os.system('cls' if platform.system() == 'Windows' else 'clear') print "##################################################" print "# ------------ #" print "# nicMSlesions #" print "# ------------ #" print "# MS WM lesion segmentation #" print "# #" print "# ------------------------------- #" print "# (c) Sergi Valverde 2018 #" print "# Neuroimage Computing Group #" print "# ------------------------------- #" print "##################################################\n" print "Please select options for training or inference in the menu..." # -------------------------------------------------- # training tab # -------------------------------------------------- self.train_frame = Frame() self.note.add(self.train_frame, text="Training") self.test_frame = Frame() self.note.add(self.test_frame, text="Inference") # label frames cl_s = 5 self.tr_frame = LabelFrame(self.train_frame, text="Training images:") self.tr_frame.grid(row=0, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) self.model_frame = LabelFrame(self.train_frame, text="CNN model:") self.model_frame.grid(row=5, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) # training options self.inFolderLbl = Label(self.tr_frame, text="Training folder:") self.inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2) self.inFolderTxt = Entry(self.tr_frame) self.inFolderTxt.grid(row=0, column=1, columnspan=5, sticky="W", pady=3) self.inFileBtn = Button(self.tr_frame, text="Browse ...", command=self.load_training_path) self.inFileBtn.grid(row=0, column=5, columnspan=1, sticky='W', padx=5, pady=1) self.optionsBtn = Button(self.tr_frame, text="Other options", command=self.parameter_window) self.optionsBtn.grid(row=0, column=10, columnspan=1, sticky="W", padx=(100, 1), pady=1) # setting input modalities: FLAIR + T1 are mandatory # Mod 3 / 4 are optional self.flairTagLbl = Label(self.tr_frame, text="FLAIR tag:") self.flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2) self.flairTxt = Entry(self.tr_frame, textvariable=self.param_FLAIR_tag) self.flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1) self.t1TagLbl = Label(self.tr_frame, text="T1 tag:") self.t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2) self.t1Txt = Entry(self.tr_frame, textvariable=self.param_T1_tag) self.t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1) self.mod3TagLbl = Label(self.tr_frame, text="mod 3 tag:") self.mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2) self.mod3Txt = Entry(self.tr_frame, textvariable=self.param_MOD3_tag) self.mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1) self.mod4TagLbl = Label(self.tr_frame, text="mod 4 tag:") self.mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2) self.mod4Txt = Entry(self.tr_frame, textvariable=self.param_MOD4_tag) self.mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1) self.maskTagLbl = Label(self.tr_frame, text="MASK tag:") self.maskTagLbl.grid(row=5, column=0, sticky='E', padx=5, pady=2) self.maskTxt = Entry(self.tr_frame, textvariable=self.param_mask_tag) self.maskTxt.grid(row=5, column=1, columnspan=1, sticky="W", pady=1) # model options self.modelTagLbl = Label(self.model_frame, text="Model name:") self.modelTagLbl.grid(row=6, column=0, sticky='E', padx=5, pady=2) self.modelTxt = Entry(self.model_frame, textvariable=self.param_net_name) self.modelTxt.grid(row=6, column=1, columnspan=1, sticky="W", pady=1) self.checkPretrain = Checkbutton(self.model_frame, text="use pretrained", var=self.param_use_pretrained_model) self.checkPretrain.grid(row=6, column=3, padx=5, pady=5) self.update_pretrained_nets() self.pretrainTxt = OptionMenu(self.model_frame, self.param_pretrained_model, *self.list_train_pretrained_nets) self.pretrainTxt.grid(row=6, column=5, sticky='E', padx=5, pady=5) # START button links self.trainingBtn = Button(self.train_frame, state='disabled', text="Start training", command=self.train_net) self.trainingBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1) # -------------------------------------------------- # inference tab # -------------------------------------------------- self.tt_frame = LabelFrame(self.test_frame, text="Inference images:") self.tt_frame.grid(row=0, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) self.test_model_frame = LabelFrame(self.test_frame, text="CNN model:") self.test_model_frame.grid(row=5, columnspan=cl_s, sticky='WE', padx=5, pady=5, ipadx=5, ipady=5) # testing options self.test_inFolderLbl = Label(self.tt_frame, text="Testing folder:") self.test_inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2) self.test_inFolderTxt = Entry(self.tt_frame) self.test_inFolderTxt.grid(row=0, column=1, columnspan=5, sticky="W", pady=3) self.test_inFileBtn = Button(self.tt_frame, text="Browse ...", command=self.load_testing_path) self.test_inFileBtn.grid(row=0, column=5, columnspan=1, sticky='W', padx=5, pady=1) self.test_optionsBtn = Button(self.tt_frame, text="Other options", command=self.parameter_window) self.test_optionsBtn.grid(row=0, column=10, columnspan=1, sticky="W", padx=(100, 1), pady=1) self.test_flairTagLbl = Label(self.tt_frame, text="FLAIR tag:") self.test_flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2) self.test_flairTxt = Entry(self.tt_frame, textvariable=self.param_FLAIR_tag) self.test_flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1) self.test_t1TagLbl = Label(self.tt_frame, text="T1 tag:") self.test_t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2) self.test_t1Txt = Entry(self.tt_frame, textvariable=self.param_T1_tag) self.test_t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1) self.test_mod3TagLbl = Label(self.tt_frame, text="mod 3 tag:") self.test_mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2) self.test_mod3Txt = Entry(self.tt_frame, textvariable=self.param_MOD3_tag) self.test_mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1) self.test_mod4TagLbl = Label(self.tt_frame, text="mod 4 tag:") self.test_mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2) self.test_mod4Txt = Entry(self.tt_frame, textvariable=self.param_MOD4_tag) self.test_mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1) self.test_pretrainTxt = OptionMenu(self.test_model_frame, self.param_inference_model, *self.list_test_nets) self.param_inference_model.set('None') self.test_pretrainTxt.grid(row=5, column=0, sticky='E', padx=5, pady=5) # START button links cto docker task self.inferenceBtn = Button(self.test_frame, state='disabled', text="Start inference", command=self.infer_segmentation) self.inferenceBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1) # train / test ABOUT button self.train_aboutBtn = Button(self.train_frame, text="about", command=self.about_window) self.train_aboutBtn.grid(row=7, column=4, sticky='E', padx=(1, 1), pady=1) self.test_aboutBtn = Button(self.test_frame, text="about", command=self.about_window) self.test_aboutBtn.grid(row=7, column=4, sticky='E', padx=(1, 1), pady=1) # Processing state self.process_indicator = StringVar() self.process_indicator.set(' ') self.label_indicator = Label(master, textvariable=self.process_indicator) self.label_indicator.pack(side="left") # Closing processing events is implemented via # a master protocol self.master.protocol("WM_DELETE_WINDOW", self.close_event) def parameter_window(self): """ Setting other parameters using an emerging window CNN parameters, CUDA device, post-processing.... """ t = Toplevel(self.master) t.wm_title("Other parameters") # data parameters t_data = LabelFrame(t, text="data options:") t_data.grid(row=0, sticky="WE") checkPretrain = Checkbutton(t_data, text="Register modalities", var=self.param_register_modalities) checkPretrain.grid(row=0, sticky='W') checkSkull = Checkbutton(t_data, text="Skull-strip modalities", var=self.param_skull_stripping) checkSkull.grid(row=1, sticky="W") checkDenoise = Checkbutton(t_data, text="Denoise masks", var=self.param_denoise) checkDenoise.grid(row=2, sticky="W") denoise_iter_label = Label(t_data, text=" Denoise iter: ") denoise_iter_label.grid(row=3, sticky="W") denoise_iter_entry = Entry(t_data, textvariable=self.param_denoise_iter) denoise_iter_entry.grid(row=3, column=1, sticky="E") check_tmp = Checkbutton(t_data, text="Save tmp files", var=self.param_save_tmp) check_tmp.grid(row=4, sticky="W") checkdebug = Checkbutton(t_data, text="Debug mode", var=self.param_debug) checkdebug.grid(row=5, sticky="W") # model parameters t_model = LabelFrame(t, text="Model:") t_model.grid(row=5, sticky="EW") maxepochs_label = Label(t_model, text="Max epochs: ") maxepochs_label.grid(row=6, sticky="W") maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs) maxepochs_entry.grid(row=6, column=1, sticky="E") trainsplit_label = Label(t_model, text="Validation %: ") trainsplit_label.grid(row=7, sticky="W") trainsplit_entry = Entry(t_model, textvariable=self.param_train_split) trainsplit_entry.grid(row=7, column=1, sticky="E") batchsize_label = Label(t_model, text="Test batch size:") batchsize_label.grid(row=8, sticky="W") batchsize_entry = Entry(t_model, textvariable=self.param_batch_size) batchsize_entry.grid(row=8, column=1, sticky="E") mode_label = Label(t_model, text="Verbosity:") mode_label.grid(row=9, sticky="W") mode_entry = Entry(t_model, textvariable=self.param_net_verbose) mode_entry.grid(row=9, column=1, sticky="E") #gpu_mode = Checkbutton(t_model, # text="GPU:", # var=self.param_mode) #gpu_mode.grid(row=10, sticky="W") gpu_number = Label(t_model, text="GPU number:") gpu_number.grid(row=10, sticky="W") gpu_entry = Entry(t_model, textvariable=self.param_gpu_number) gpu_entry.grid(row=10, column=1, sticky="W") # training parameters tr_model = LabelFrame(t, text="Training:") tr_model.grid(row=12, sticky="EW") balanced_label = Label(tr_model, text="Balanced dataset: ") balanced_label.grid(row=13, sticky="W") balanced_entry = Entry(tr_model, textvariable=self.param_balanced_dataset) balanced_entry.grid(row=13, column=1, sticky="E") fraction_label = Label(tr_model, text="Fraction negative/positives: ") fraction_label.grid(row=14, sticky="W") fraction_entry = Entry(tr_model, textvariable=self.param_fract_negatives) fraction_entry.grid(row=14, column=1, sticky="E") # postprocessing parameters t_post = LabelFrame(t, text="Post-processing: ") t_post.grid(row=15, sticky="EW") t_bin_label = Label(t_post, text="Out probability th: ") t_bin_label.grid(row=16, sticky="W") t_bin_entry = Entry(t_post, textvariable=self.param_t_bin) t_bin_entry.grid(row=16, column=1, sticky="E") l_min_label = Label(t_post, text="Min out region size: ") l_min_label.grid(row=17, sticky="W") l_min_entry = Entry(t_post, textvariable=self.param_l_min) l_min_entry.grid(row=17, column=1, sticky="E") vol_min_label = Label(t_post, text="Min vol error (ml): ") vol_min_label.grid(row=18, sticky="W") vol_min_entry = Entry(t_post, textvariable=self.param_min_error) vol_min_entry.grid(row=18, column=1, sticky="E") def load_default_configuration(self): """ load the default configuration from /config/default.cfg This method assign each of the configuration parameters to class attributes """ default_config = ConfigParser.SafeConfigParser() default_config.read(os.path.join(self.path, 'config', 'default.cfg')) # dastaset parameters self.param_training_folder.set( default_config.get('database', 'train_folder')) self.param_test_folder.set( default_config.get('database', 'inference_folder')) self.param_FLAIR_tag.set(default_config.get('database', 'flair_tags')) self.param_T1_tag.set(default_config.get('database', 't1_tags')) self.param_MOD3_tag.set(default_config.get('database', 'mod3_tags')) self.param_MOD4_tag.set(default_config.get('database', 'mod4_tags')) self.param_mask_tag.set(default_config.get('database', 'roi_tags')) self.param_register_modalities.set( default_config.get('database', 'register_modalities')) self.param_denoise.set(default_config.get('database', 'denoise')) self.param_denoise_iter.set( default_config.getint('database', 'denoise_iter')) self.param_skull_stripping.set( default_config.get('database', 'skull_stripping')) self.param_save_tmp.set(default_config.get('database', 'save_tmp')) self.param_debug.set(default_config.get('database', 'debug')) # train parameters self.param_use_pretrained_model.set( default_config.get('train', 'full_train')) self.param_pretrained_model.set( default_config.get('train', 'pretrained_model')) self.param_inference_model.set(" ") self.param_balanced_dataset.set( default_config.get('train', 'balanced_training')) self.param_fract_negatives.set( default_config.getfloat('train', 'fraction_negatives')) # model parameters self.param_net_folder = os.path.join(self.current_folder, 'nets') self.param_net_name.set(default_config.get('model', 'name')) self.param_train_split.set( default_config.getfloat('model', 'train_split')) self.param_max_epochs.set(default_config.getint('model', 'max_epochs')) self.param_patience.set(default_config.getint('model', 'patience')) self.param_batch_size.set(default_config.getint('model', 'batch_size')) self.param_net_verbose.set(default_config.get('model', 'net_verbose')) self.param_gpu_number.set(default_config.getint('model', 'gpu_number')) # self.param_mode.set(default_config.get('model', 'gpu_mode')) # post-processing self.param_l_min.set(default_config.getint('postprocessing', 'l_min')) self.param_t_bin.set(default_config.getfloat('postprocessing', 't_bin')) self.param_min_error.set( default_config.getfloat('postprocessing', 'min_error')) def write_user_configuration(self): """ write the configuration into config/configuration.cfg """ user_config = ConfigParser.RawConfigParser() # dataset parameters user_config.add_section('database') user_config.set('database', 'train_folder', self.param_training_folder.get()) user_config.set('database', 'inference_folder', self.param_test_folder.get()) user_config.set('database', 'flair_tags', self.param_FLAIR_tag.get()) user_config.set('database', 't1_tags', self.param_T1_tag.get()) user_config.set('database', 'mod3_tags', self.param_MOD3_tag.get()) user_config.set('database', 'mod4_tags', self.param_MOD4_tag.get()) user_config.set('database', 'roi_tags', self.param_mask_tag.get()) user_config.set('database', 'register_modalities', self.param_register_modalities.get()) user_config.set('database', 'denoise', self.param_denoise.get()) user_config.set('database', 'denoise_iter', self.param_denoise_iter.get()) user_config.set('database', 'skull_stripping', self.param_skull_stripping.get()) user_config.set('database', 'save_tmp', self.param_save_tmp.get()) user_config.set('database', 'debug', self.param_debug.get()) # train parameters user_config.add_section('train') user_config.set('train', 'full_train', not (self.param_use_pretrained_model.get())) user_config.set('train', 'pretrained_model', self.param_pretrained_model.get()) user_config.set('train', 'balanced_training', self.param_balanced_dataset.get()) user_config.set('train', 'fraction_negatives', self.param_fract_negatives.get()) # model parameters user_config.add_section('model') user_config.set('model', 'name', self.param_net_name.get()) user_config.set('model', 'pretrained', self.param_pretrained) user_config.set('model', 'train_split', self.param_train_split.get()) user_config.set('model', 'max_epochs', self.param_max_epochs.get()) user_config.set('model', 'patience', self.param_patience.get()) user_config.set('model', 'batch_size', self.param_batch_size.get()) user_config.set('model', 'net_verbose', self.param_net_verbose.get()) # user_config.set('model', 'gpu_mode', self.param_mode.get()) user_config.set('model', 'gpu_number', self.param_gpu_number.get()) # postprocessing parameters user_config.add_section('postprocessing') user_config.set('postprocessing', 't_bin', self.param_t_bin.get()) user_config.set('postprocessing', 'l_min', self.param_l_min.get()) user_config.set('postprocessing', 'min_error', self.param_min_error.get()) # Writing our configuration file to 'example.cfg' with open(os.path.join(self.path, 'config', 'configuration.cfg'), 'wb') as configfile: user_config.write(configfile) def load_training_path(self): """ Select training path from disk and write it. If the app is run inside a container, link the iniitaldir with /data """ initialdir = '/data' if self.container else os.getcwd() fname = askdirectory(initialdir=initialdir) if fname: try: self.param_training_folder.set(fname) self.inFolderTxt.delete(0, END) self.inFolderTxt.insert(0, self.param_training_folder.get()) self.trainingBtn['state'] = 'normal' except: pass def load_testing_path(self): """ Selecet the inference path from disk and write it If the app is run inside a container, link the iniitaldir with /data """ initialdir = '/data' if self.container else os.getcwd() fname = askdirectory(initialdir=initialdir) if fname: try: self.param_test_folder.set(fname) self.test_inFolderTxt.delete(0, END) self.test_inFolderTxt.insert(0, self.param_test_folder.get()) self.inferenceBtn['state'] = 'normal' except: pass def update_pretrained_nets(self): """ get a list of the different net configuration present in the system. Each model configuration is represented by a folder containing the network weights for each of the networks. The baseline net config is always included by default """ folders = os.listdir(self.param_net_folder) self.list_train_pretrained_nets = folders self.list_test_nets = folders def write_to_console(self, txt): """ to doc: important method """ self.command_out.insert(END, str(txt)) def write_to_test_console(self, txt): """ to doc: important method """ self.test_command_out.insert(END, str(txt)) def infer_segmentation(self): """ Method implementing the inference process: - Check network selection - write the configuration to disk - Run the process on a new thread """ if self.param_inference_model.get() == 'None': print "ERROR: Please, select a network model before starting...\n" return if self.test_task is None: self.inferenceBtn.config(state='disabled') self.param_net_name.set(self.param_inference_model.get()) self.param_use_pretrained_model.set(False) self.write_user_configuration() print "\n-----------------------" print "Running configuration:" print "-----------------------" print "Inference model:", self.param_model_tag.get() print "Inference folder:", self.param_test_folder.get(), "\n" print "Method info:" print "------------" self.test_task = ThreadedTask(self.write_to_test_console, self.test_queue, mode='testing') self.test_task.start() self.master.after(100, self.process_container_queue) def train_net(self): """ Method implementing the training process: - write the configuration to disk - Run the process on a new thread """ if self.param_net_name.get() == 'None': print "ERROR: Please, define network name before starting...\n" return self.trainingBtn['state'] = 'disable' if self.train_task is None: self.trainingBtn.update() self.write_user_configuration() print "\n-----------------------" print "Running configuration:" print "-----------------------" print "Train model:", self.param_net_name.get() print "Training folder:", self.param_training_folder.get(), "\n" print "Method info:" print "------------" self.train_task = ThreadedTask(self.write_to_console, self.test_queue, mode='training') self.train_task.start() self.master.after(100, self.process_container_queue) def check_update(self): """ check update version and propose to download it if differnt So far, a rudimentary mode is used to check the last version. """ # I have to discard possible local changes :( print "---------------------------------------" print "Updating software" print "current version:", self.commit_version remote_commit = subprocess.check_output(['git', 'stash']) remote_commit = subprocess.check_output(['git', 'fetch']) remote_commit = subprocess.check_output( ['git', 'rev-parse', 'origin/master']) if remote_commit != self.commit_version: proc = subprocess.check_output(['git', 'pull', 'origin', 'master']) self.check_link.config(text="Updated") self.commit_version = remote_commit print "updated version:", self.commit_version else: print "This software is already in the latest version" print "---------------------------------------" def about_window(self): """ Window showing information about the software and version number, including auto-update. If the application is run from a container, then auto-update is disabled """ def callback(event): """ open webbrowser when clicking links """ webbrowser.open_new(event.widget.cget("text")) # main window t = Toplevel(self.master, width=500, height=500) t.wm_title("About") # NIC logo + name title = Label(t, text="nicMSlesions v" + self.version + "\n" "Multiple Sclerosis White Matter Lesion Segmentation") title.grid(row=2, column=1, padx=20, pady=10) img = ImageTk.PhotoImage(Image.open('./logonic.png')) imglabel = Label(t, image=img) imglabel.image = img imglabel.grid(row=1, column=1, padx=10, pady=10) group_name = Label(t, text="Copyright Sergi Valverde (2018-) \n " + "NeuroImage Computing Group") group_name.grid(row=3, column=1) group_link = Label(t, text=r"http://atc.udg.edu/nic", fg="blue", cursor="hand2") group_link.grid(row=4, column=1) group_link.bind("<Button-1>", callback) license_content = "Licensed under the BSD 2-Clause license. \n" + \ "A copy of the license is present in the root directory." license_label = Label(t, text=license_content) license_label.grid(row=5, column=1, padx=20, pady=20) # if self.container is False: # # check version and updates # version_number = Label(t, text="commit: " + self.commit_version) # version_number.grid(row=6, column=1, padx=20, pady=(1, 1)) # # self.check_link = Button(t, # text="Check for updates", # command=self.check_update) # self.check_link.grid(row=7, column=1) def process_container_queue(self): """ Process the threading queue. When the threaded processes are finished, buttons are reset and a message is shown in the app. """ self.process_indicator.set('Running... please wait') try: msg = self.test_queue.get(0) self.process_indicator.set('Done. See log for more details.') self.inferenceBtn['state'] = 'normal' self.trainingBtn['state'] = 'normal' except Queue.Empty: self.master.after(100, self.process_container_queue) def close_event(self): """ Stop the thread processes using OS related calls. """ if self.train_task is not None: self.train_task.stop_process() if self.test_task is not None: self.test_task.stop_process() os.system('cls' if platform.system == "Windows" else 'clear') root.destroy()
class RotatePanel(PluginPanel): name = 'Rotate' title = _("Rotate") def init(self, master): PluginPanel.init(self, master) root = self.mw.root self.var_angle = DoubleVar(root) self.var_angle.set(0) self.var_width_number = DoubleVar(root) self.var_height_number = DoubleVar(root) self.var_width_base = DoubleVar(root) self.var_height_base = DoubleVar(root) self.cnt_x_absolute = None self.cnt_y_absolute = None var_width_unit = StringVar(root) var_height_unit = StringVar(root) unit = config.preferences.default_unit self.var_width = LengthVar(10, unit, self.var_width_number, var_width_unit) self.var_height = LengthVar(10, unit, self.var_height_number, var_height_unit) jump = config.preferences.default_unit_jump self.var_width.set(0) self.var_height.set(0) self.var_width_base.set(0) self.var_height_base.set(0) self.var_position = StringVar(root) self.var_position.set(ABSOLUTE) self.var_basepoint = StringVar(root) self.var_basepoint.set('C') #--------------------------------------------------------- top = TFrame(self.panel, style='FlatFrame') top.pack(side=TOP, fill=BOTH) #--------------------------------------------------------- angle_frame = TFrame(top, style='FlatFrame', borderwidth=3) angle_frame.pack(side=TOP, fill=BOTH) label = TLabel(angle_frame, style='FlatLabel', text=" " + _("Angle:") + " ") label.pack(side=LEFT, padx=5) self.entry_angle = TSpinbox(angle_frame, var=0, vartype=1, textvariable=self.var_angle, min=-360, max=360, step=5, width=6, command=self.apply_rotate) self.entry_angle.pack(side=LEFT, anchor=E) label = TLabel(angle_frame, style='FlatLabel', text=_("deg")) label.pack(side=LEFT, padx=5) #--------------------------------------------------------- label = TLabel(top, style='FlatLabel', text=_("Center:")) label.pack(side=TOP, fill=BOTH, padx=5) #--------------------------------------------------------- # Horisontal size_frameH = TFrame(top, style='FlatFrame', borderwidth=3) size_frameH.pack(side=TOP, fill=BOTH) label = TLabel(size_frameH, style='FlatLabel', image='center_h') label.pack(side=LEFT, padx=5) self.entry_width = TSpinbox(size_frameH, var=0, vartype=1, textvariable=self.var_width_number, min=-50000, max=50000, step=jump, width=10, command=self.apply_rotate) self.entry_width.pack(side=LEFT) self.labelwunit = TLabel(size_frameH, style='FlatLabel', text=self.var_width.unit) self.labelwunit.pack(side=LEFT, padx=5) #--------------------------------------------------------- # Vertical size_frameV = TFrame(top, style='FlatFrame', borderwidth=3) size_frameV.pack(side=TOP, fill=BOTH) label = TLabel(size_frameV, style='FlatLabel', image='center_v') label.pack(side=LEFT, padx=5) self.entry_height = TSpinbox(size_frameV, var=0, vartype=1, textvariable=self.var_height_number, min=-50000, max=50000, step=jump, width=10, command=self.apply_rotate) self.entry_height.pack(side=LEFT) self.labelhunit = TLabel(size_frameV, style='FlatLabel', text=self.var_height.unit) self.labelhunit.pack(side=LEFT, padx=5) #--------------------------------------------------------- # position chek self.position_check = TCheckbutton(top, text=_("Absolute Center"), variable=self.var_position, onvalue=ABSOLUTE, offvalue=RELATIVE, command=self.position) self.position_check.pack(side=TOP, anchor=W, padx=5, pady=5) #--------------------------------------------------------- # Basepoint check label = TLabel(top, style='FlatLabel', text=_("Basepoint:")) label.pack(side=TOP, fill=BOTH, padx=5) basepoint_frame = TLabelframe(top, labelwidget=label, style='Labelframe', borderwidth=4) basepoint_frame.pack(side=TOP, fill=X, padx=5, pady=2) self.Basepoint = BasePointSelector(basepoint_frame, anchor=self.var_basepoint, command=self.apply_basepoint) self.Basepoint.pack(side=LEFT, fill=BOTH, padx=5) label = TLabel(basepoint_frame, style='FlatLabel', image='coordinate_deg') label.pack(side=LEFT, fill=BOTH, padx=10) self.position_check.pack(side=TOP, anchor=W, padx=5, pady=5) #--------------------------------------------------------- # Button frame button_frame = TFrame(top, style='FlatFrame', borderwidth=5) button_frame.pack(side=BOTTOM, fill=BOTH) self.update_buttons = [] self.button = UpdatedButton(top, text=_("Apply"), command=self.apply_rotate) self.button.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X, pady=3) self.button_copy = UpdatedButton(top, text=_("Apply to Copy"), command=self.apply_to_copy) self.button_copy.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X) self.init_from_doc() self.subscribe_receivers() ############################################################################### def subscribe_receivers(self): self.document.Subscribe(SELECTION, self.Update) self.document.Subscribe(EDITED, self.update_var) config.preferences.Subscribe(CHANGED, self.update_pref) def unsubscribe_receivers(self): self.document.Unsubscribe(SELECTION, self.Update) self.document.Unsubscribe(EDITED, self.update_var) config.preferences.Unsubscribe(CHANGED, self.update_pref) def init_from_doc(self, *arg): self.Update() def Update(self, *arg): if self.is_selection(): self.entry_angle.set_state(NORMAL) self.entry_width.set_state(NORMAL) self.entry_height.set_state(NORMAL) self.position_check['state'] = NORMAL self.button['state'] = NORMAL self.button_copy['state'] = NORMAL self.TestBasepoint() else: self.entry_angle.set_state(DISABLED) self.entry_width.set_state(DISABLED) self.entry_height.set_state(DISABLED) self.position_check['state'] = DISABLED self.button['state'] = DISABLED self.button_copy['state'] = DISABLED self.update_pref() def apply_basepoint(self): self.update_var() def position(self): self.update_var() def RotateSelected(self, angle, cnt=None): text = _("Rotation") if self.document.selection: self.document.begin_transaction(text) try: try: if cnt is None: cnt = self.document.selection.coord_rect.center() angle = angle * degrees trafo = Rotation(angle, cnt) self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def RotateAndCopy(self, angle, cnt=None): text = _("Rotation&Copy") if self.document.selection: self.document.begin_transaction(text) try: try: if cnt is None: cnt = self.document.selection.coord_rect.center() angle = angle * degrees trafo = Rotation(angle, cnt) self.document.ApplyToDuplicate() self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def apply_rotate(self, *arg): if self.button["state"] == DISABLED: return try: var_x = self.var_width.get() var_y = self.var_height.get() var_a = self.var_angle.get() except: return if var_a < 0: if var_a < -360: var_a += int(var_a / 360) * 360 var_a += 360 if self.var_basepoint.get() != 'USER': self.cnt_x_absolute, self.cnt_y_absolute = self.coordinates( ABSOLUTE) self.var_basepoint.set('USER') if self.var_width_base != var_x or self.var_height_base != var_y: if self.var_position.get() == ABSOLUTE: self.cnt_x_absolute = var_x self.cnt_y_absolute = var_y else: x, y = self.coordinates(ABSOLUTE, 'C') self.cnt_x_absolute = var_x + x self.cnt_y_absolute = var_y + y self.var_basepoint.set('USER') if arg and arg[0] == 'Duplicate': self.RotateAndCopy(var_a, Point(self.cnt_x_absolute, self.cnt_y_absolute)) else: self.RotateSelected( var_a, Point(self.cnt_x_absolute, self.cnt_y_absolute)) def apply_to_copy(self): self.apply_rotate('Duplicate') def coordinates(self, position, anchor=None): br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom if position == RELATIVE: left, bottom = -hor_sel / 2.0, -ver_sel / 2.0 else: left, bottom = br.left, br.bottom cnt_x, cnt_y = self.Basepoint.get_basepoint(hor_sel, ver_sel, left, bottom, anchor) return cnt_x, cnt_y def TestBasepoint(self): if self.cnt_x_absolute is None: return base = ['C', 'NW', 'N', 'NE', 'W', 'E', 'SW', 'S', 'SE'] for b in xrange(len(base)): cnt_x, cnt_y = self.coordinates(ABSOLUTE, base[b]) if round(cnt_x,2) == round(self.cnt_x_absolute,2) and \ round(cnt_y,2) == round(self.cnt_y_absolute,2): self.var_basepoint.set(base[b]) return self.var_basepoint.set('USER') def update_pref(self, *arg): self.labelwunit['text'] = config.preferences.default_unit self.labelhunit['text'] = config.preferences.default_unit self.entry_width.step = config.preferences.default_unit_jump self.entry_height.step = config.preferences.default_unit_jump self.update_var() def update_var(self, *arg): if len(self.document.selection.GetInfo()): self.var_width.unit = config.preferences.default_unit self.var_height.unit = config.preferences.default_unit if self.var_basepoint.get() == 'USER': if self.var_position.get() == ABSOLUTE: self.var_width.set(self.cnt_x_absolute) self.var_height.set(self.cnt_y_absolute) else: x, y = self.coordinates(ABSOLUTE, 'C') self.var_width.set(self.cnt_x_absolute - x) self.var_height.set(self.cnt_y_absolute - y) else: x, y = self.coordinates(self.var_position.get()) self.var_width.set(x) self.var_height.set(y) self.var_width_base = self.var_width.get() self.var_height_base = self.var_height.get() def is_selection(self): return (len(self.document.selection) > 0)
class Example(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.initUI() self.centerUI(w=560,h=235) def initUI(self): self.parent.title("DBLR for Dummies") self.pack(fill=BOTH, expand=True) #self.columnconfigure(0, weight=1) #self.rowconfigure(0, weight=1) # weight attibute is used to make them growable self.meas = IntVar() self.point = IntVar() self.base_path = StringVar() self.coef = DoubleVar() self.noise = DoubleVar() self.n_sigma = DoubleVar() self.thr1 = DoubleVar() self.thr2 = DoubleVar() self.thr3 = DoubleVar() self.graph_sw = BooleanVar() #Image factor=0.65 search = Image.open("NEXT_official_logo.jpg") width_org, height_org = search.size search_temp = search.resize((int(width_org*factor), int(height_org*factor)), Image.ANTIALIAS) search_aux = ImageTk.PhotoImage(search_temp) label1 = Label(self, image=search_aux) label1.image = search_aux label1.grid(row=0, column=4, columnspan=2, rowspan=3, padx=5) #self.base_path.set("F:/DATOS_DAC/2052/pmt_0_trace_evt_") self.base_path.set("Argon.h5.z") e1 = Entry(self, textvariable=self.base_path, width=40) e1.grid(row=0,column=1, sticky=W, columnspan=3, pady=5, padx=5) e1_label = Label(self, text="Path & Name") e1_label.grid(row=0,column=0, columnspan=1, sticky=E, pady=5, padx=5) self.point.set("0") sb1 = Spinbox(self, from_=0, to=100, width=4, textvariable=self.point) sb1.grid(row=2,column=1, sticky=W, pady=5, padx=5) sb1_label = Label(self, text="PMT") sb1_label.grid(row=2,column=0, padx=5, sticky=E) self.meas.set("0") sb1 = Spinbox(self, from_=0, to=100, width=4, textvariable=self.meas) sb1.grid(row=2,column=3, sticky=W, pady=5, padx=5) sb1_label = Label(self, text="Event") sb1_label.grid(row=2,column=2, padx=5, sticky=E) #Check buttons # cb1 = Checkbutton(self, text="New Graph", variable=self.graph_sw) # cb1.select() # cb1.grid(row=2,column=2, sticky=W) #PARAMETERS Integration_label = Label(self, text="PARAMETERS", font = "Verdana 12 bold") Integration_label.grid(row=3,column=1, padx=5, columnspan = 2, pady=10, sticky=E) self.coef.set("1.65E-3") e2 = Entry(self, width=12, textvariable=self.coef) e2.grid(row=4,column=1, sticky=W, pady=5, padx=5) e2_label = Label(self, text="DBLR Coef") e2_label.grid(row=4,column=0, sticky=E, pady=5, padx=5) self.noise.set("0.75") e3 = Entry(self, width=12, textvariable=self.noise) e3.grid(row=4,column=3, sticky=W, pady=5, padx=5) e3_label = Label(self, text="Noise (LSB)") e3_label.grid(row=4,column=2, sticky=E, pady=5, padx=5) self.n_sigma.set("4") e4 = Entry(self, width=12, textvariable=self.n_sigma) e4.grid(row=4,column=5, sticky=W, pady=5, padx=5) e4_label = Label(self, text="Noise Threshold") e4_label.grid(row=4,column=4, sticky=E, pady=5, padx=5) self.thr1.set("0") e5 = Entry(self, width=12, textvariable=self.thr1) e5.grid(row=5,column=1, sticky=W, pady=5, padx=5) e5_label = Label(self, text="Threshold 1") e5_label.grid(row=5,column=0, sticky=E, pady=5, padx=5) self.thr2.set("0") e6 = Entry(self, width=12, textvariable=self.thr2) e6.grid(row=5,column=3, sticky=W, pady=5, padx=5) e6_label = Label(self, text="Threshold 2") e6_label.grid(row=5,column=2, sticky=E, pady=5, padx=5) self.thr3.set("0") e7 = Entry(self, width=12, textvariable=self.thr3) e7.grid(row=5,column=5, sticky=W, pady=5, padx=5) e7_label = Label(self, text="Threshold 3") e7_label.grid(row=5,column=4, sticky=E, pady=5, padx=5) # Main buttons obtn = Button(self, text="GO!!", command=self.DBLR_f) obtn.grid(row=6, column=4, sticky=E, pady=10) cbtn = Button(self, text="Quit", command=self.quit) cbtn.grid(row=6, column=5, sticky=E, pady=10) hbtn = Button(self, text="Help", command=self.help_f) hbtn.grid(row=6, column=0, sticky=W, pady=10) def help_f(self): top = Toplevel() top.title("HELP") msg = Message(top, width= 500, text="Noise Threshold (NT) - Noise Based Main Threshold \ (Sigmas)\n Threshold 1 - Main Threshold (LSBs) \n Threshold 2 - End of Pulse Error \n \ Threshold 3 - End of Tail Error \n When Thr1 = Thr3 = 0 their values are defined as: \n \ (THR1 = NT (LSBs) / THR3 = NT*NOISE_ADC / 5)") msg.pack() button = Button(top, text="Close", command=top.destroy) button.pack() def DBLR_f(self): global a #if (self.graph_sw.get()==True): b=a a=a+1 #else: # b=0 aux=self.base_path.get() # path=''.join([aux,str(self.meas.get()),'.txt']) # g=pd.read_csv(path) f=read_panel_hdf5(aux, self.point.get(), self.meas.get()) f=4096-f recons,energia = DB.BLR( signal_daq=f.flatten().astype(float), coef=self.coef.get(), n_sigma=self.n_sigma.get(), NOISE_ADC=self.noise.get(), thr1=self.thr1.get(), thr2=self.thr2.get(), thr3=self.thr3.get(), plot=False) plt.figure(a) plt.plot(recons) plt.figtext(0.2,0.75, ('ENERGY = %0.2f ' % (energia))) plt.show() def centerUI(self,w,h): sw = self.parent.winfo_screenwidth() sh = self.parent.winfo_screenheight() x = (sw-w)/2 y = (sh-h)/2 self.parent.geometry('%dx%d+%d+%d' % (w,h,x,y))
class ChemicalDeleter: def __init__(self, master, system, chemical): """Constructor method. Defines the parameters to be obtained in this window.""" self.master = master self.fonttype = system.fonttype self.version = system.version self.superfont = get_superfont(self.fonttype) #superscript font self.frame = Frame(master.frame) self.tframe = Frame(master.tframe) self.bframe = Frame(master.bframe) self.top = None #flag for existence of toplevel# self.soluableflag = chemical.soluable self.name = StringVar(value=chemical.name) self.MW = DoubleVar(value=chemical.MW) self.formula = StringVar(value=chemical.formula) self.temp = DoubleVar(value=chemical.temp) self.Dw = DoubleVar(value=chemical.Dw) self.Koc = DoubleVar(value=chemical.Koc) self.Kdoc = DoubleVar(value=chemical.Kdoc) self.Ref = StringVar(value=chemical.Ref) self.Kf = DoubleVar(value=chemical.Kf) self.N = DoubleVar(value=chemical.N) self.chemical = chemical self.cancelflag = 0 def make_widgets(self): self.bgcolor = self.frame.cget('bg') self.instructions = Label( self.frame, text= ' Are you sure to delete the following chemical? ' ) self.namelabel = Label(self.frame, text='Chemical name') self.MWlabel = Label(self.frame, text='Molecular\n weight') self.templabel = Label(self.frame, text='Temperature') self.Dwlabel = Label(self.frame, text='Molecular diffusivity\n in water') self.Koclabel = Label(self.frame, text='Organic carbon\n partition coefficient') self.Kdoclabel = Label( self.frame, text='Dissolved organic carbon\n partition coefficient') self.Reflabel = Label(self.frame, text='Reference') self.tempunits = Label(self.frame, text=unichr(176) + 'C') self.Dwunits = Label(self.frame, text=u'cm\u00B2/s') self.Kocunits = Label(self.frame, text='log(L/kg)') self.Kdocunits = Label(self.frame, text='log(L/kg)') self.namewidget = Label(self.frame, width=20, justify='center', textvariable=self.name) if self.soluableflag == 1: self.tempwidget = Label(self.frame, width=10, justify='center', textvariable=self.temp) self.MWwidget = Label(self.frame, width=16, justify='center', textvariable=self.MW) self.Dwwidget = Label(self.frame, width=16, justify='center', textvariable=self.Dw) self.Kocwidget = Label(self.frame, width=16, justify='center', textvariable=self.Koc) self.Kdocwidget = Label(self.frame, width=16, justify='center', textvariable=self.Kdoc) self.Refwidget = Label(self.frame, width=16, justify='center', textvariable=self.Ref) else: self.tempwidget = Label(self.frame, width=10, justify='center', text=' ') self.Dwwidget = Label(self.frame, width=16, justify='center', text='Not applicable') self.Kocwidget = Label(self.frame, width=16, justify='center', text='Not applicable') self.Kdocwidget = Label(self.frame, width=16, justify='center', text='Not applicable') self.insoluablestate = Label(self.frame, width=16, justify='center', text='Not applicable') #show the widgets on the grid self.blankcolumn = Label(self.frame, text=' ', width=2) self.namecolumn = Label(self.frame, text=' ', width=20) self.MWcolumn = Label(self.frame, text=' ', width=18) self.tempcolumn = Label(self.frame, text=' ', width=10) self.Dwcolumn = Label(self.frame, text=' ', width=18) self.Koccolumn = Label(self.frame, text=' ', width=18) self.Kdoccolumn = Label(self.frame, text=' ', width=18) self.Refcolumn = Label(self.frame, text=' ', width=18) self.deletebutton = Button(self.frame, text='Delete', width=20, command=self.Delete) self.cancelbutton = Button(self.frame, text='Cancel', width=20, command=self.Cancel) self.blank1 = Label(self.frame, text=' ') self.blank2 = Label(self.frame, text=' ') self.instructions.grid(row=0, column=0, columnspan=6, padx=8, sticky='W') self.blankcolumn.grid(row=1, column=0, sticky='WE', padx=1, pady=1) self.namecolumn.grid(row=1, column=1, sticky='WE', padx=1, pady=1) self.MWcolumn.grid(row=1, column=2, sticky='WE', padx=1, pady=1) self.tempcolumn.grid(row=1, column=3, sticky='WE', padx=1, pady=1) self.Dwcolumn.grid(row=1, column=4, sticky='WE', padx=1, pady=1) self.Koccolumn.grid(row=1, column=5, sticky='WE', padx=1, pady=1) self.Kdoccolumn.grid(row=1, column=6, sticky='WE', padx=1, pady=1) self.Refcolumn.grid(row=1, column=7, sticky='WE', padx=1, pady=1) self.namelabel.grid(row=2, column=1, sticky='WE', padx=4, pady=1) self.MWlabel.grid(row=2, column=2, sticky='WE', padx=1, pady=1) self.templabel.grid(row=2, column=3, sticky='WE', padx=1, pady=1) self.Dwlabel.grid(row=2, column=4, sticky='WE', padx=1, pady=1) self.Koclabel.grid(row=2, column=5, sticky='WE', padx=1, pady=1) self.Kdoclabel.grid(row=2, column=6, sticky='WE', padx=1, pady=1) self.Reflabel.grid(row=2, column=7, sticky='WE', padx=1, pady=1) self.tempunits.grid(row=3, column=3, sticky='WE', padx=1, pady=1) self.Dwunits.grid(row=3, column=4, sticky='WE', padx=1, pady=1) self.Kocunits.grid(row=3, column=5, sticky='WE', padx=1, pady=1) self.Kdocunits.grid(row=3, column=6, sticky='WE', padx=1, pady=1) self.namewidget.grid(row=4, column=1, padx=2, pady=1, sticky='WE') self.MWwidget.grid(row=4, column=2, padx=2, pady=1, sticky='WE') self.tempwidget.grid(row=4, column=3, padx=2, pady=1, sticky='WE') self.Dwwidget.grid(row=4, column=4, padx=2, pady=1) self.Kocwidget.grid(row=4, column=5, padx=2, pady=1) self.Kdocwidget.grid(row=4, column=6, padx=2, pady=1) self.Refwidget.grid(row=4, column=7, padx=2, pady=1) self.blank1.grid(row=5) self.deletebutton.grid(row=6, columnspan=11) self.cancelbutton.grid(row=7, columnspan=11) self.blank2.grid(row=8) self.deletebutton.bind('<Return>', self.Delete) self.focusbutton = self.deletebutton def Delete(self, event=None): """Finish and move on. Checks that the number chemicals are less than the total number of chemicals in database.""" if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit() def Cancel(self): try: self.name.set(self.chemical.name) self.temp.set(self.chemical.temp) self.MW.set(self.chemical.MW) self.formula.set(self.chemical.formula) self.Dw.set(self.chemical.Dw) self.Koc.set(self.chemical.Koc) self.Kdoc.set(self.chemical.Kdoc) self.Ref.set(self.chemical.Ref) self.Kf.set(self.chemical.Kf) self.N.set(self.chemical.N) except: self.cancelflag = 1 if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit()
class Example(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.initUI() self.centerUI(w=450,h=340) def initUI(self): self.parent.title("LINEARITY TEST FOR PMT BASES") self.pack(fill=BOTH, expand=True) self.columnconfigure(0, weight=1) #self.rowconfigure(0, weight=1) # weight attibute is used to make them growable # self.graph_cb = BooleanVar() self.init_point = IntVar() self.base_path = StringVar() self.end_point = IntVar() self.step = IntVar() self.n_meas = IntVar() self.inc_point = IntVar() self.coef = DoubleVar() self.noise = DoubleVar() self.thr_sigma = DoubleVar() self.SPE_DAQ = DoubleVar() search = Image.open("next_logo.jpg") search_temp = search.resize((170, 200), Image.ANTIALIAS) search_aux = ImageTk.PhotoImage(search_temp) label1 = Label(self, image=search_aux) label1.image = search_aux label1.grid(row=0, column=0, columnspan=10, rowspan=10, sticky=E+W+S+N) #Text Box self.base_path.set("F:/DATOS_DAC/2052/pmt_0_trace_evt_") e1 = Entry(self, textvariable=self.base_path, width=40) e1.grid(row=1,column=2, sticky=W, columnspan=5, pady=5) e1_label = Label(self, text="DataSet path (including name file)") e1_label.grid(row=0,column=2,sticky=W, columnspan=5, pady=5) #Spin Boxes self.n_meas.set("20") sb1 = Spinbox(self, from_=1, to=1000, width=6, textvariable=self.n_meas) sb1.grid(row=3,column=3, sticky=W) sb1_label = Label(self, text="Measurements") sb1_label.grid(row=2,column=3, padx=0, sticky=W) self.step.set("10") sb2 = Spinbox(self, from_=10, to=200, width=6, textvariable=self.step) sb2.grid(row=3,column=4, sticky=W) sb2_label = Label(self, text="Pulse Width Step") sb2_label.grid(row=2,column=4, padx=0, sticky=W) # INTEGRATION LIMITS Integration_label = Label(self, text="INTEGRATION LIMITS", font = "Verdana 12 bold") Integration_label.grid(row=4,column=3, padx=5, columnspan = 3, pady=10) self.init_point.set("30") sb3 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.init_point) sb3.grid(row=7,column=3, sticky=W) sb3_label = Label(self, text="Start (usec)") sb3_label.grid(row=6,column=3, padx=0, sticky=W) self.end_point.set("160") sb4 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.end_point) sb4.grid(row=7,column=4, sticky=W) sb4_label = Label(self, text="End (usec)") sb4_label.grid(row=6,column=4, padx=0, sticky=W) # PARAMETERS Integration_label = Label(self, text="PARAMETERS", font = "Verdana 12 bold") Integration_label.grid(row=8,column=3, padx=5, columnspan = 3, pady=10) self.inc_point.set("3") sb5 = Spinbox(self, from_=1, to=100, width=6, textvariable=self.inc_point) sb5.grid(row=11,column=3, sticky=W) sb5_label = Label(self, text="First point") sb5_label.grid(row=10,column=3, padx=0, sticky=W) self.coef.set("1.636E-3") e6 = Entry(self, width=10, textvariable=self.coef) e6.grid(row=11,column=4, sticky=W) e6_label = Label(self, text="DBLR Coef") e6_label.grid(row=10,column=4, sticky=W) self.noise.set("0.75") e7 = Entry(self, width=10, textvariable=self.noise) e7.grid(row=11,column=5, sticky=W) e7_label = Label(self, text="Noise (LSB)") e7_label.grid(row=10,column=5, sticky=W) self.thr_sigma.set("40") e8 = Entry(self, width=10, textvariable=self.thr_sigma) e8.grid(row=13,column=3, sticky=W) e8_label = Label(self, text="Threshold") e8_label.grid(row=12,column=3, sticky=W) self.SPE_DAQ.set("20.5") e9 = Entry(self, width=10, textvariable=self.SPE_DAQ) e9.grid(row=13,column=4, sticky=W) e9_label = Label(self, text="SPE (LSB)") e9_label.grid(row=12,column=4, sticky=W) # #Check buttons # cb1 = Checkbutton(self, text="MultiGraph Output", variable=self.graph_cb ) # cb1.select() # cb1.grid(row=7,column=6, sticky=W) # Main buttons obtn = Button(self, text="GO!!", command=self.linearity_f) obtn.grid(row=14, column=4, sticky=E, pady=10) cbtn = Button(self, text="Quit", command=self.quit) cbtn.grid(row=14, column=5, sticky=E, pady=10) hbtn = Button(self, text="Help") hbtn.grid(row=14, column=0, sticky=W, pady=10) def linearity_f(self): # global a # # if (self.graph_cb.get()==True): # b=a # a=a+1 # else: # b=0 linearity.linearity_test(base_path=self.base_path.get(), init_point=self.init_point.get(), end_point=self.end_point.get(), step=self.step.get(), n_meas=self.n_meas.get(), inc_point=self.inc_point.get(), coef=self.coef.get(), noise=self.noise.get(), thr_sigma=self.thr_sigma.get(), SPE_DAQ=self.SPE_DAQ.get(), graph_sw=0 ) def centerUI(self,w,h): sw = self.parent.winfo_screenwidth() sh = self.parent.winfo_screenheight() x = (sw-w)/2 y = (sh-h)/2 self.parent.geometry('%dx%d+%d+%d' % (w,h,x,y))
class SolidDatabaseEditor: """Gets the contaminant properties.""" def __init__(self, master, system, solid, solid_database, editflag): """Constructor method. Defines the parameters to be obtained in this window.""" self.master = master self.fonttype = system.fonttype self.version = system.version self.superfont = get_superfont(self.fonttype) #superscript font self.tframe = Frame(master.tframe) self.frame = Frame(master.frame) self.bframe = Frame(master.bframe) self.top = None #flag for existence of toplevel# self.solid = solid self.solid_database = solid_database self.torts = ['Millington & Quirk', 'Boudreau', 'None'] self.sorps = [ 'Linear--Kd specified', 'Linear--Kocfoc', 'Freundlich', 'Langmuir' ] self.name = StringVar( value='Solid ' + str(solid_database[-1].number)) #stores the chemical name self.e = DoubleVar(value=0.5) #stores the porosity self.rho = DoubleVar(value=1.0) #stores the bulk density self.foc = DoubleVar(value=0.01) #stores the organic carbon fraction self.tort = StringVar( value=self.torts[0]) #stores the default tortuosity correction self.sorp = StringVar( value=self.sorps[0]) #stores the default sorption correction self.Ref = StringVar(value='') #stores the density self.editflag = editflag self.cancelflag = 0 if editflag == 1: #Detemine whether the chemical is added or edited self.name.set(solid.name) self.e.set(solid.e) self.rho.set(solid.rho) self.foc.set(solid.foc) self.tort.set(solid.tort) self.sorp.set(solid.sorp) self.Ref.set(solid.Ref) def make_widgets(self): """Make the widgets for the window.""" self.bgcolor = self.frame.cget('bg') self.instructions = Label( self.frame, text= ' Please provide the following properties for the solid/mixture: ' ) self.blankcolumn = Label(self.frame, text=' ', width=1) self.namecolumn = Label(self.frame, text=' ', width=18) self.ecolumn = Label(self.frame, text=' ', width=10) self.rhocolumn = Label(self.frame, text=' ', width=10) self.foccolumn = Label(self.frame, text=' ', width=10) self.tortcolumn = Label(self.frame, text=' ', width=18) self.sorpcolumn = Label(self.frame, text=' ', width=20) self.refcolumn = Label(self.frame, text=' ', width=18) self.endcolumn = Label(self.frame, text=' ', width=2) self.namelabel = Label(self.frame, text='Material') self.elabel = Label(self.frame, text='Porosity') self.rholabel = Label(self.frame, text='Bulk density') self.foclabel = Label(self.frame, text='Organic carbon fraction') self.tortlabel = Label(self.frame, text='Tortruosity correction') self.sorplabel = Label(self.frame, text='Sorption isotherms') self.reflabel = Label(self.frame, text='Reference') self.rhounitlabel = Label(self.frame, text=u'g/cm\u00B3') self.namewidget = Entry(self.frame, width=16, justify='center', textvariable=self.name) self.ewidget = Entry(self.frame, width=8, justify='center', textvariable=self.e) self.rhowidget = Entry(self.frame, width=8, justify='center', textvariable=self.rho) self.focwidget = Entry(self.frame, width=8, justify='center', textvariable=self.foc) self.tortwidget = OptionMenu(self.frame, self.tort, *self.torts) self.sorpwidget = OptionMenu(self.frame, self.sorp, *self.sorps) self.refwidget = Entry(self.frame, width=15, justify='center', textvariable=self.Ref) self.okbutton = Button(self.frame, text='OK', width=20, command=self.OK) self.cancelbutton = Button(self.frame, text='Cancel', width=20, command=self.Cancel) self.blank1 = Label(self.frame, text=' ') self.blank2 = Label(self.frame, text=' ') #show the widgets on the grid self.instructions.grid(row=0, column=0, columnspan=7, padx=8, sticky='W') self.blankcolumn.grid(row=1, column=0, sticky='WE', padx=1, pady=1) self.namecolumn.grid(row=1, column=1, sticky='WE', padx=1, pady=1) self.ecolumn.grid(row=1, column=2, sticky='WE', padx=1, pady=1) self.rhocolumn.grid(row=1, column=3, sticky='WE', padx=1, pady=1) self.foccolumn.grid(row=1, column=4, sticky='WE', padx=1, pady=1) self.tortcolumn.grid(row=1, column=5, sticky='WE', padx=1, pady=1) self.sorpcolumn.grid(row=1, column=6, sticky='WE', padx=1, pady=1) self.refcolumn.grid(row=1, column=7, sticky='WE', padx=1, pady=1) self.endcolumn.grid(row=1, column=8, sticky='WE', padx=1, pady=1) self.namelabel.grid(row=2, column=1, sticky='WE', padx=1, pady=1) self.elabel.grid(row=2, column=2, sticky='WE', padx=1, pady=1) self.rholabel.grid(row=2, column=3, sticky='WE', padx=1, pady=1) self.foclabel.grid(row=2, column=4, sticky='WE', padx=1, pady=1) self.tortlabel.grid(row=2, column=5, sticky='WE', padx=1, pady=1) self.sorplabel.grid(row=2, column=6, sticky='WE', padx=1, pady=1) self.reflabel.grid(row=2, column=7, sticky='WE', padx=1, pady=1) self.rhounitlabel.grid(row=3, column=3, sticky='WE', padx=1, pady=1) self.namewidget.grid(row=4, column=1, padx=1, pady=1) self.ewidget.grid(row=4, column=2, padx=1, pady=1) self.rhowidget.grid(row=4, column=3, padx=1, pady=1) self.focwidget.grid(row=4, column=4, padx=1, pady=1) self.tortwidget.grid(row=4, column=5, padx=1, pady=1, sticky='WE') self.sorpwidget.grid(row=4, column=6, padx=1, pady=1, sticky='WE') self.refwidget.grid(row=4, column=7, padx=1, pady=1) self.blank1.grid(row=5) self.okbutton.grid(row=6, columnspan=11) self.cancelbutton.grid(row=7, columnspan=11) self.blank2.grid(row=8) self.okbutton.bind('<Return>', self.OK) self.focusbutton = self.okbutton def OK(self, event=None): """Finish and move on. Checks that the number chemicals are less than the total number of chemicals in database.""" if self.editflag == 0: check = [(solid.name == self.name.get()) for solid in self.solid_database[0:-1]] if self.editflag == 1: check = [(solid.name == self.name.get() and self.solid.name != self.name.get()) for solid in self.solid_database[0:-1]] if self.master.window.top is not None: self.master.open_toplevel() elif self.e.get() > 1 or self.e.get() < 0: tkmb.showinfo( self.version, 'The porosity of a solid can not be larger than 1 or smaller than 0' ) self.e.set(0.5) elif self.rho.get() < 0: tkmb.showinfo(self.version, 'The bulk density of a solid can not be negative') self.e.set(1.0) elif self.foc.get() > 1 or self.foc.get() < 0: tkmb.showinfo( self.version, 'The organic carbon fraction of a solid can not be larger than 1 or smaller than 0' ) self.e.set(1.0) elif sum(check) >= 1 or self.name.get() == '': self.solids_error() else: self.master.tk.quit() def solids_error(self): tkmb.showerror( title=self.version, message= 'This solid material has already been added to the database!') self.focusbutton = self.okbutton self.master.tk.lift() def Cancel(self): try: self.name.set(self.solid.name) self.e.set(self.solid.e) self.rho.set(self.solid.rho) self.foc.set(self.solid.foc) self.tort.set(self.solid.tort) self.sorp.set(self.solid.sorp) self.Ref.set(self.solid.Ref) except: self.cancelflag = 1 if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit()
class ChemicalImporter: def __init__(self, master, system, database): """The constructor method.""" self.version = system.version self.fonttype = system.fonttype self.sfont = get_superfont(self.fonttype) self.master = master self.frame = Frame(master.frame) self.tframe = Frame(master.tframe) self.bframe = Frame(master.bframe) self.tkfont = tkFont.Font(font=system.fonttype) self.chemicals_list = database.keys() self.chemicals_list.sort() self.name = StringVar() self.formula = StringVar() self.MW = DoubleVar() self.temp = DoubleVar(value=0) self.Dw = DoubleVar(value=0) self.Ref = StringVar(value=0) self.Koc = DoubleVar(value=0) self.Kdoc = DoubleVar(value=0) self.Kf = DoubleVar(value=0) self.N = DoubleVar(value=0) self.importedchemicals = {} for name in self.chemicals_list: self.importedchemicals[name] = ChemicalData(name) self.importedchemicals[name].read_database(database[name]) self.name_width = 10 self.ref_width = 10 for chemical_name in self.chemicals_list: if (self.tkfont.measure(chemical_name) + 10) > self.name_width: self.name_width = self.tkfont.measure(chemical_name) + 10 for temp in self.importedchemicals[chemical_name].temps: if (self.tkfont.measure( self.importedchemicals[chemical_name].Ref[temp]) + 10) > self.name_width: self.name_width = self.tkfont.measure( self.importedchemicals[chemical_name].Ref[temp]) + 10 if self.name_width < 150: self.name_width = 150 if self.ref_width < 150: self.ref_width = 150 self.cancelflag = 0 self.sname = StringVar(self.frame, value='') def make_widgets(self): self.instructions = Label( self.tframe, text='Please select the chemical you would like to add ') self.leftcolumn = Label(self.tframe, text=' ', width=2) self.checkcolumn = Label(self.tframe, text=' ', width=5) self.orinamecolumn = Label( self.tframe, text=' ', width=int(self.name_width * 1.1424219345 / 8) + 1) self.tempcolumn = Label(self.tframe, text=' ', width=15) self.ref1column = Label( self.tframe, text=' ', width=int(self.ref_width * 1.1424219345 / 8 / 2) + 1) self.ref2column = Label( self.tframe, text=' ', width=int(self.ref_width * 1.1424219345 / 8 / 2) + 1) self.rightcolumn = Label(self.tframe, text=' ', width=2) self.search_label = Label(self.tframe, text='Search:') self.search_entry = Entry(self.tframe, textvariable=self.sname) self.namelabel = Label(self.tframe, text='Name') self.templabel = Label(self.tframe, text='Temperature') self.reflabel = Label(self.tframe, text='Reference') self.botleftcolumn = Label(self.frame, text=' ', width=2) self.botcheckcolumn = Label(self.frame, text=' ', width=5) self.botorinamecolumn = Label( self.frame, text=' ', width=int(self.name_width * 1.1424219345 / 8) + 1) self.bottempcolumn = Label(self.frame, text=' ', width=15) self.botref1column = Label( self.frame, text=' ', width=int(self.ref_width * 1.1424219345 / 8 / 2) + 1) self.botref2column = Label( self.frame, text=' ', width=int(self.ref_width * 1.1424219345 / 8 / 2) + 1) self.botrightcolumn = Label(self.frame, text=' ', width=2) self.importbutton = Button(self.bframe, text='Import', command=self.OK, width=20) self.cancelbutton = Button(self.bframe, text='Cancel', command=self.cancel, width=20) self.blank1 = Label(self.tframe, text=' ') self.blank2 = Label(self.frame, text=' ') self.blank3 = Label(self.bframe, text=' ') self.blank4 = Label(self.bframe, text=' ') #show the widgets on the grid (top to bottom and left to right) self.instructions.grid(row=0, columnspan=5, sticky='W', padx=8) self.leftcolumn.grid(row=1, column=0, sticky='WE') self.checkcolumn.grid(row=1, column=1, sticky='WE') self.orinamecolumn.grid(row=1, column=2, sticky='WE') self.tempcolumn.grid(row=1, column=3, sticky='WE') self.ref1column.grid(row=1, column=4, sticky='WE') self.ref2column.grid(row=1, column=5, sticky='WE') self.rightcolumn.grid(row=1, column=6, sticky='WE') self.search_label.grid(row=2, column=1, sticky='E', padx=4) self.search_entry.grid(row=2, column=2, columnspan=4, sticky='WE', padx=4) self.blank1.grid(row=3) self.namelabel.grid(row=4, column=2, sticky='WE') self.templabel.grid(row=4, column=3, sticky='WE') self.reflabel.grid(row=4, column=4, columnspan=2, sticky='WE') self.botleftcolumn.grid(row=1, column=0, sticky='WE') self.botcheckcolumn.grid(row=1, column=1, sticky='WE') self.botorinamecolumn.grid(row=1, column=2, sticky='WE') self.bottempcolumn.grid(row=1, column=3, sticky='WE') self.botref1column.grid(row=1, column=4, sticky='WE') self.botref2column.grid(row=1, column=5, sticky='WE') self.botrightcolumn.grid(row=1, column=6, sticky='WE') self.searchname() self.sname.trace('w', self.searchname) def searchname(self, event=None, *args): row = 2 for name in self.chemicals_list: try: self.importedchemicals[name].remove_selectchemicalwidgets() except: pass if self.sname.get() == '': for name in self.chemicals_list: self.importedchemicals[name].selectchemicalwidgets( self.frame, row=row, master=self.master, namewidth=int(self.name_width * 1.1424219345 / 8) + 1, refwidth=int(self.ref_width * 1.1424219345 / 8) + 1) row = row + 1 else: for name in self.chemicals_list: if name.lower()[:len(self.sname.get())].count( self.sname.get().lower()) >= 1: self.importedchemicals[name].selectchemicalwidgets( self.frame, row=row, master=self.master, namewidth=int(self.name_width * 1.1424219345 / 8) + 1, refwidth=int(self.ref_width * 1.1424219345 / 8) + 1) row = row + 1 else: self.importedchemicals[name].check = IntVar( value=self.importedchemicals[name].check) self.blank2.grid(row=row) row = 2 self.blank3.grid(row=row) row = row + 1 self.importbutton.grid(row=row, column=0, columnspan=5, pady=1) row = row + 1 self.cancelbutton.grid(row=row, column=0, columnspan=5, pady=1) row = row + 1 self.blank4.grid(row=row) self.cancelbutton.bind('<Return>', self.cancel) self.focusbutton = self.cancelbutton def selectchemicaldata(self, name): for othername in self.chemicals_list: if othername <> name: try: self.importedchemicals[othername].check.set(0) except: pass def cancelname(self, event=None): self.sname.set('') self.searchname() def OK(self, event=None): for name in self.chemicals_list: if self.importedchemicals[name].check.get() == 1: self.name.set(name) self.formula.set(self.importedchemicals[name].formula) self.MW.set(self.importedchemicals[name].MW) self.temp.set(self.importedchemicals[name].temp.get()) self.Dw.set(self.importedchemicals[name].Dw[self.temp.get()]) self.Ref.set(self.importedchemicals[name].Ref[self.temp.get()]) self.Koc.set(self.importedchemicals[name].Koc[self.temp.get()]) self.Kdoc.set( self.importedchemicals[name].Kdoc[self.temp.get()]) self.Kf.set(self.importedchemicals[name].Kf[self.temp.get()]) self.N.set(self.importedchemicals[name].N[self.temp.get()]) for name in self.chemicals_list: try: self.importedchemicals[name].remove_selectchemicalwidgets() except: pass self.frame.quit() def cancel(self, event=None): self.cancelflag = 1 self.frame.quit()
class NumberEntry(BaseWiget): def __init__(self, parent, def_dict=None, tracker_path=None, to_game_callback=None, **kw): BaseWiget.__init__(self,parent, def_dict=def_dict, tracker_path=tracker_path, to_game_callback=to_game_callback, **kw) self.old_value = 0 outType = def_dict.get("outType", float) if outType == int: integer = True elif outType == float: integer = False else: raise TypeError("outType = %s"%repr(outType)) minVal = def_dict.get("minVal", 0) maxVal = def_dict.get("maxVal", 100) step = 1 if integer: self.var = IntVar() else: self.var = DoubleVar() step = 1.0 if (maxVal-minVal) < 5: step = 0.01 if "step" in def_dict: step = def_dict["step"] self.entry = Control(self, label=self.caption, integer=integer, variable=self.var, min=minVal, max=maxVal, step = step, options='entry.width 20 label.width 1 label.anchor w entry.anchor w') if not integer: number_zero = len(str(step).split(".")[1]) foramter = "%.{0}f".format(number_zero) def foo(num): num = float(num) if num>maxVal:num = maxVal if num<minVal:num = minVal return foramter%num self.entry['validatecmd'] = foo self.entry.grid(row=1, column=1) self.var.trace("w", self._onChangeVariable) self.old_value = self.getValue() self.onEndSetupContent() #------------- интерфейс -------------# def setValue(self, value): if self.old_value == value: return self.old_value = value self.var.set(value) def getValue(self): return self.var.get() def getDictValue(self): raise NotImplementedError def forceSave(self): """принудительное сохранение""" self._onEndInput() #------------- внутренние методы -------------# def _onEndInput(self): value = self.getValue() if self.old_value != value: self.onValueChangeEndByUser(self.old_value, value) self.old_value = value def _onChangeVariable(self, *event): value = self.getValue() if self.old_value == value: return self._onEndInput()
class CreateStarDlg(SKModal): title = _("Create Star") def __init__(self, master, **kw): # This constructor is here just for illustration purposes; it's # not really needed here, as it simply passes all parameters on # to the base class' constructor. # # The parameter master is the window this dialog belongs to. It # should normally be the top-level application window. apply(SKModal.__init__, (self, master), kw) def build_dlg(self): # The SKModal constructor automatically calls this method to # create the widgets in the dialog. # # self.top is the top-level window of the dialog. All widgets of # the dialog must contained in it. top = self.top # The rest is normal Tkinter code. self.var_corners = IntVar(top) self.var_corners.set(5) label = Label(top, text = _("Corners"), anchor = 'e') label.grid(column = 0, row = 0, sticky = 'ew') entry = Entry(top, textvariable = self.var_corners, width = 15) entry.grid(column = 1, row = 0, sticky = 'ew') self.var_steps = IntVar(top) self.var_steps.set(2) label = Label(top, text = _("Steps"), anchor = 'e') label.grid(column = 0, row = 1, sticky = 'ew') entry = Entry(top, textvariable = self.var_steps, width = 15) entry.grid(column = 1, row = 1, sticky = 'ew') self.var_radius = DoubleVar(top) self.var_radius.set(100) label = Label(top, text = _("Radius"), anchor = 'e') label.grid(column = 0, row = 2, sticky = 'ew') entry = Entry(top, textvariable = self.var_radius, width = 15) entry.grid(column = 1, row = 2, sticky = 'ew') but_frame = Frame(top) but_frame.grid(column = 0, row = 3, columnspan = 2) button = Button(but_frame, text = _("OK"), command = self.ok) button.pack(side = 'left', expand = 1) # The self.cancel method is provided by the base class and # cancels the dialog. button = Button(but_frame, text = _("Cancel"), command = self.cancel) button.pack(side = 'right', expand = 1) def ok(self, *args): # This method is bound to the OK-button. Its purpose is to # collect the values of the various edit fields and pass them as # one parameter to the close_dlg method. # # close_dlg() saves its parameter and closes the dialog. corners = self.var_corners.get() steps = self.var_steps.get() radius = self.var_radius.get() self.close_dlg((corners, steps, radius))
class SkewPanel(PluginPanel): name = "Skew" title = _("Skew") def init(self, master): PluginPanel.init(self, master) self.width_priority = 1 root = self.mw.root self.var_angleX = DoubleVar(root) self.var_angleY = DoubleVar(root) jump = 5 self.var_angleX.set(0) self.var_angleY.set(0) self.var_proportional = IntVar(root) self.var_proportional.set(0) self.var_basepoint = StringVar(root) self.var_basepoint.set("C") # --------------------------------------------------------- top = TFrame(self.panel, style="FlatFrame") top.pack(side=TOP, fill=BOTH) # --------------------------------------------------------- # Horisontal size_frameH = TFrame(top, style="FlatFrame", borderwidth=3) size_frameH.pack(side=TOP, fill=BOTH) label = TLabel(size_frameH, style="FlatLabel", image="skew_h") label.pack(side=LEFT, padx=5) self.entry_angleX = TSpinbox( size_frameH, var=0, vartype=1, textvariable=self.var_angleX, min=-75, max=75, step=jump, width=10, command=self.apply_skew, ) self.entry_angleX.pack(side=LEFT) self.labelwunit = TLabel(size_frameH, style="FlatLabel", text=_("deg")) self.labelwunit.pack(side=LEFT, padx=5) # --------------------------------------------------------- # Vertical size_frameV = TFrame(top, style="FlatFrame", borderwidth=3) size_frameV.pack(side=TOP, fill=BOTH) label = TLabel(size_frameV, style="FlatLabel", image="skew_v") label.pack(side=LEFT, padx=5) self.entry_angleY = TSpinbox( size_frameV, var=0, vartype=1, textvariable=self.var_angleY, min=-75, max=75, step=jump, width=10, command=self.apply_skew, ) self.entry_angleY.pack(side=LEFT) self.labelhunit = TLabel(size_frameV, style="FlatLabel", text=_("deg")) self.labelhunit.pack(side=LEFT, padx=5) # --------------------------------------------------------- # Basepoint check label = TLabel(top, style="FlatLabel", text=_("Basepoint:")) label.pack(side=TOP, fill=BOTH, padx=5) basepoint_frame = TLabelframe(top, labelwidget=label, style="Labelframe", borderwidth=4) basepoint_frame.pack(side=TOP, fill=X, padx=5, pady=2) self.Basepoint = BasePointSelector(basepoint_frame, anchor=self.var_basepoint) self.Basepoint.pack(side=LEFT, fill=BOTH, padx=5) label = TLabel(basepoint_frame, style="FlatLabel", image="coordinate_deg") label.pack(side=LEFT, fill=BOTH, padx=10) # --------------------------------------------------------- # Button frame button_frame = TFrame(top, style="FlatFrame", borderwidth=5) button_frame.pack(side=BOTTOM, fill=BOTH) self.update_buttons = [] self.button = UpdatedButton(top, text=_("Apply"), command=self.apply_skew) self.button.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X, pady=3) self.button_copy = UpdatedButton(top, text=_("Apply to Copy"), command=self.apply_to_copy) self.button_copy.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X) self.init_from_doc() self.subscribe_receivers() ############################################################################### def subscribe_receivers(self): self.document.Subscribe(SELECTION, self.Update) def unsubscribe_receivers(self): self.document.Unsubscribe(SELECTION, self.Update) def init_from_doc(self): self.Update() def Update(self, *arg): if self.is_selection(): self.entry_angleX.set_state(NORMAL) self.entry_angleY.set_state(NORMAL) self.button["state"] = NORMAL self.button_copy["state"] = NORMAL else: self.entry_angleX.set_state(DISABLED) self.entry_angleY.set_state(DISABLED) self.button["state"] = DISABLED self.button_copy["state"] = DISABLED def SkewSelected(self, axisX=0, axisY=0): if self.document.selection: self.document.begin_transaction() try: try: br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom cnt_x, cnt_y = self.Basepoint.get_basepoint(hor_sel, ver_sel, br.left, br.bottom) text = _("Skew") ax, ay = tan(axisX), tan(axisY) sx = 1.0 sy = 1.0 - (ax * ay) tx = cnt_x * ax ty = cnt_y * ax * ay - cnt_y * ay # Move the selection in the coordinates x0 y0 trafo = Trafo(1, 0, 0, 1, -cnt_x, -cnt_y) # Skew and Scaling trafo = Trafo(sx, ay, -ax, sy, 0, 0)(trafo) # Move the selection in the coordinates basepoint trafo = Trafo(1, 0, 0, 1, cnt_x, cnt_y)(trafo) self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def apply_skew(self, *arg): if self.button["state"] == DISABLED: return try: angleX = self.var_angleX.get() * degrees angleY = self.var_angleY.get() * degrees self.SkewSelected(angleX, angleY) except: return def apply_to_copy(self): if self.button["state"] == DISABLED: return self.document.begin_transaction(_("Skew&Copy")) try: try: self.document.ApplyToDuplicate() self.apply_skew() except: self.document.abort_transaction() finally: self.document.end_transaction() def is_selection(self): return len(self.document.selection) > 0
class SolidDatabaseDeleter: def __init__(self, master, system, solid): """Constructor method. Defines the parameters to be obtained in this window.""" self.master = master self.fonttype = system.fonttype self.version = system.version self.superfont = get_superfont(self.fonttype) #superscript font self.tframe = Frame(master.tframe) self.frame = Frame(master.frame) self.bframe = Frame(master.bframe) self.top = None #flag for existence of toplevel# self.name = StringVar(value=solid.name) #stores the chemical name self.e = DoubleVar(value=solid.e) #stores the porosity self.rho = DoubleVar(value=solid.rho) #stores the bulk density self.foc = DoubleVar( value=solid.foc) #stores the organic carbon fraction self.tort = StringVar( value=solid.tort) #stores the default tortuosity correction self.sorp = StringVar( value=solid.sorp) #stores the default sorption correction self.Ref = StringVar( value=solid.Ref) #stores the default sorption correction self.cancelflag = 0 def make_widgets(self): self.bgcolor = self.frame.cget('bg') self.instructions = Label( self.frame, text= ' Are you sure to delete the following solid from database? ' ) self.namelabel = Label(self.frame, text='Material') self.elabel = Label(self.frame, text='Porosity') self.rholabel = Label(self.frame, text='Bulk density\n (kg/L') self.foclabel = Label(self.frame, text='Organic carbon\n fraction') self.tortlabel = Label(self.frame, text='Tortruosity correction') self.sorplabel = Label(self.frame, text='Sorption isotherms') self.Reflabel = Label(self.frame, text='Reference') self.rhounitlabel = Label(self.frame, text=u'g/cm\u00B3') self.namewidget = Label(self.frame, width=16, justify='center', textvariable=self.name) self.ewidget = Label(self.frame, width=8, justify='center', textvariable=self.e) self.rhowidget = Label(self.frame, width=8, justify='center', textvariable=self.rho) self.focwidget = Label(self.frame, width=8, justify='center', textvariable=self.foc) self.tortwidget = Label(self.frame, width=16, justify='center', textvariable=self.tort) self.sorpwidget = Label(self.frame, width=16, justify='center', textvariable=self.sorp) self.Refwidget = Label(self.frame, width=10, justify='center', textvariable=self.Ref) self.blankcolumn = Label(self.frame, text=' ', width=1) self.namecolumn = Label(self.frame, text=' ', width=18) self.ecolumn = Label(self.frame, text=' ', width=10) self.rhocolumn = Label(self.frame, text=' ', width=10) self.foccolumn = Label(self.frame, text=' ', width=10) self.tortcolumn = Label(self.frame, text=' ', width=18) self.sorpcolumn = Label(self.frame, text=' ', width=18) self.Refcolumn = Label(self.frame, text=' ', width=18) self.endcolumn = Label(self.frame, text=' ', width=2) self.deletebutton = Button(self.frame, text='Delete', width=20, command=self.Delete) self.cancelbutton = Button(self.frame, text='Cancel', width=20, command=self.Cancel) self.blank1 = Label(self.frame, text=' ') self.blank2 = Label(self.frame, text=' ') #show the widgets on the grid self.instructions.grid(row=0, column=0, columnspan=6, padx=8, sticky='W') self.blankcolumn.grid(row=1, column=0, sticky='WE', padx=1, pady=1) self.namecolumn.grid(row=1, column=1, sticky='WE', padx=1, pady=1) self.ecolumn.grid(row=1, column=2, sticky='WE', padx=1, pady=1) self.rhocolumn.grid(row=1, column=3, sticky='WE', padx=1, pady=1) self.foccolumn.grid(row=1, column=4, sticky='WE', padx=1, pady=1) self.tortcolumn.grid(row=1, column=5, sticky='WE', padx=1, pady=1) self.sorpcolumn.grid(row=1, column=6, sticky='WE', padx=1, pady=1) self.Refcolumn.grid(row=1, column=7, sticky='WE', padx=1, pady=1) self.endcolumn.grid(row=1, column=8, sticky='WE', padx=1, pady=1) self.namelabel.grid(row=2, column=1, sticky='WE', padx=1, pady=1) self.elabel.grid(row=2, column=2, sticky='WE', padx=1, pady=1) self.rholabel.grid(row=2, column=3, sticky='WE', padx=1, pady=1) self.foclabel.grid(row=2, column=4, sticky='WE', padx=1, pady=1) self.tortlabel.grid(row=2, column=5, sticky='WE', padx=1, pady=1) self.sorplabel.grid(row=2, column=6, sticky='WE', padx=1, pady=1) self.Reflabel.grid(row=2, column=7, sticky='WE', padx=1, pady=1) self.rhounitlabel.grid(row=3, column=3, sticky='WE', padx=1, pady=1) self.namewidget.grid(row=4, column=1, padx=1, pady=1, sticky='WE') self.ewidget.grid(row=4, column=2, padx=1, pady=1) self.rhowidget.grid(row=4, column=3, padx=1, pady=1) self.focwidget.grid(row=4, column=4, padx=1, pady=1) self.tortwidget.grid(row=4, column=5, padx=1, pady=1) self.sorpwidget.grid(row=4, column=6, padx=1, pady=1) self.Refwidget.grid(row=4, column=7, padx=1, pady=1) self.blank1.grid(row=5) self.deletebutton.grid(row=6, columnspan=11) self.cancelbutton.grid(row=7, columnspan=11) self.blank2.grid(row=8) self.deletebutton.bind('<Return>', self.Delete) self.focusbutton = self.deletebutton def Delete(self, event=None): """Finish and move on. Checks that the number chemicals are less than the total number of chemicals in database.""" if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit() def Cancel(self): try: self.name.set(self.solid.name) self.e.set(self.solid.e) self.rho.set(self.solid.rho) self.foc.set(self.solid.foc) self.tort.set(self.solid.tort) self.sorp.set(self.solid.sorp) self.Ref.set(self.solid.Ref) except: self.cancelflag = 1 if self.master.window.top is not None: self.master.open_toplevel() else: self.master.tk.quit()
class SkewPanel(PluginPanel): name = 'Skew' title = _("Skew") def init(self, master): PluginPanel.init(self, master) self.width_priority = 1 root = self.mw.root self.var_angleX = DoubleVar(root) self.var_angleY = DoubleVar(root) jump = 5 self.var_angleX.set(0) self.var_angleY.set(0) self.var_proportional = IntVar(root) self.var_proportional.set(0) self.var_basepoint = StringVar(root) self.var_basepoint.set('C') #--------------------------------------------------------- top = TFrame(self.panel, style='FlatFrame') top.pack(side=TOP, fill=BOTH) #--------------------------------------------------------- # Horisontal size_frameH = TFrame(top, style='FlatFrame', borderwidth=3) size_frameH.pack(side=TOP, fill=BOTH) label = TLabel(size_frameH, style='FlatLabel', image='skew_h') label.pack(side=LEFT, padx=5) self.entry_angleX = TSpinbox(size_frameH, var=0, vartype=1, textvariable=self.var_angleX, min=-75, max=75, step=jump, width=10, command=self.apply_skew) self.entry_angleX.pack(side=LEFT) self.labelwunit = TLabel(size_frameH, style='FlatLabel', text=_("deg")) self.labelwunit.pack(side=LEFT, padx=5) #--------------------------------------------------------- # Vertical size_frameV = TFrame(top, style='FlatFrame', borderwidth=3) size_frameV.pack(side=TOP, fill=BOTH) label = TLabel(size_frameV, style='FlatLabel', image='skew_v') label.pack(side=LEFT, padx=5) self.entry_angleY = TSpinbox(size_frameV, var=0, vartype=1, textvariable=self.var_angleY, min=-75, max=75, step=jump, width=10, command=self.apply_skew) self.entry_angleY.pack(side=LEFT) self.labelhunit = TLabel(size_frameV, style='FlatLabel', text=_("deg")) self.labelhunit.pack(side=LEFT, padx=5) #--------------------------------------------------------- # Basepoint check label = TLabel(top, style='FlatLabel', text=_("Basepoint:")) label.pack(side=TOP, fill=BOTH, padx=5) basepoint_frame = TLabelframe(top, labelwidget=label, style='Labelframe', borderwidth=4) basepoint_frame.pack(side=TOP, fill=X, padx=5, pady=2) self.Basepoint = BasePointSelector(basepoint_frame, anchor=self.var_basepoint) self.Basepoint.pack(side=LEFT, fill=BOTH, padx=5) label = TLabel(basepoint_frame, style='FlatLabel', image='coordinate_deg') label.pack(side=LEFT, fill=BOTH, padx=10) #--------------------------------------------------------- # Button frame button_frame = TFrame(top, style='FlatFrame', borderwidth=5) button_frame.pack(side=BOTTOM, fill=BOTH) self.update_buttons = [] self.button = UpdatedButton(top, text=_("Apply"), command=self.apply_skew) self.button.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X, pady=3) self.button_copy = UpdatedButton(top, text=_("Apply to Copy"), command=self.apply_to_copy) self.button_copy.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X) self.init_from_doc() self.subscribe_receivers() ############################################################################### def subscribe_receivers(self): self.document.Subscribe(SELECTION, self.Update) def unsubscribe_receivers(self): self.document.Unsubscribe(SELECTION, self.Update) def init_from_doc(self): self.Update() def Update(self, *arg): if self.is_selection(): self.entry_angleX.set_state(NORMAL) self.entry_angleY.set_state(NORMAL) self.button['state'] = NORMAL self.button_copy['state'] = NORMAL else: self.entry_angleX.set_state(DISABLED) self.entry_angleY.set_state(DISABLED) self.button['state'] = DISABLED self.button_copy['state'] = DISABLED def SkewSelected(self, axisX=0, axisY=0): if self.document.selection: self.document.begin_transaction() try: try: br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom cnt_x, cnt_y = self.Basepoint.get_basepoint( hor_sel, ver_sel, br.left, br.bottom) text = _("Skew") ax, ay = tan(axisX), tan(axisY) sx = 1.0 sy = 1.0 - (ax * ay) tx = cnt_x * ax ty = cnt_y * ax * ay - cnt_y * ay # Move the selection in the coordinates x0 y0 trafo = Trafo(1, 0, 0, 1, -cnt_x, -cnt_y) # Skew and Scaling trafo = Trafo(sx, ay, -ax, sy, 0, 0)(trafo) # Move the selection in the coordinates basepoint trafo = Trafo(1, 0, 0, 1, cnt_x, cnt_y)(trafo) self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def apply_skew(self, *arg): if self.button["state"] == DISABLED: return try: angleX = self.var_angleX.get() * degrees angleY = self.var_angleY.get() * degrees self.SkewSelected(angleX, angleY) except: return def apply_to_copy(self): if self.button["state"] == DISABLED: return self.document.begin_transaction(_("Skew&Copy")) try: try: self.document.ApplyToDuplicate() self.apply_skew() except: self.document.abort_transaction() finally: self.document.end_transaction() def is_selection(self): return (len(self.document.selection) > 0)
class ConfigClass: def __init__(self,textbox,FOLDER,APPNAME): self.folder=os.path.join(FOLDER,'config') self.appname=APPNAME # Das Standard App Verzeichniss fuer das Betriebssystem abfragen self.make_settings_folder() # eine ConfigParser Instanz oeffnen und evt. vorhandenes Config File Laden self.parser = ConfigParser.ConfigParser() self.cfg_file_name=self.appname+'_config.cfg' self.parser.read(os.path.join(self.folder,self.cfg_file_name)) # Falls kein Config File vorhanden ist oder File leer ist neue File anlegen und neu laden if len(self.parser.sections())==0: self.make_new_Config_file() self.parser.read(os.path.join(self.folder,self.cfg_file_name)) textbox.prt((_('\nNo config file found generated new on at: %s') \ %os.path.join(self.folder,self.cfg_file_name))) else: textbox.prt((_('\nLoading config file:%s') \ %os.path.join(self.folder,self.cfg_file_name))) #Tkinter Variablen erstellen zur späteren Verwendung in den Eingabefeldern self.get_all_vars() #DEBUG INFORMATIONEN #Übergeben des geladenen Debug Level textbox.set_debuglevel(DEBUG=self.debug) textbox.prt(_('\nDebug Level: %i') %(self.debug),1) textbox.prt(str(self),1) def make_settings_folder(self): # create settings folder if necessary try: os.mkdir(self.folder) except OSError: pass def make_new_Config_file(self): #Generelle Einstellungen für Export self.parser.add_section('General') self.parser.set('General', 'write_to_stdout', 0) self.parser.add_section('Paths') self.parser.set('Paths', 'load_path', 'C:\Users\Christian Kohloeffel\Documents\DXF2GCODE\trunk\dxf') self.parser.set('Paths', 'save_path', 'C:\Users\Christian Kohloeffel\Documents') self.parser.add_section('Import Parameters') self.parser.set('Import Parameters', 'point_tolerance', 0.01) self.parser.set('Import Parameters', 'fitting_tolerance', 0.01) self.parser.set('Import Parameters', 'spline_check',1) self.parser.add_section('Tool Parameters') self.parser.set('Tool Parameters', 'diameter', 2.0) self.parser.set('Tool Parameters', 'start_radius', 0.2) self.parser.add_section('Plane Coordinates') self.parser.set('Plane Coordinates', 'axis1_start_end', 0) self.parser.set('Plane Coordinates', 'axis2_start_end', 0) self.parser.add_section('Depth Coordinates') self.parser.set('Depth Coordinates', 'axis3_retract', 15) self.parser.set('Depth Coordinates', 'axis3_safe_margin', 3.0) self.parser.set('Depth Coordinates', 'axis3_mill_depth', -3.0) self.parser.set('Depth Coordinates', 'axis3_slice_depth', -1.5) self.parser.add_section('Feed Rates') self.parser.set('Feed Rates', 'f_g1_depth', 150) self.parser.set('Feed Rates', 'f_g1_plane', 400) self.parser.add_section('Axis letters') self.parser.set('Axis letters', 'ax1_letter', 'X') self.parser.set('Axis letters', 'ax2_letter', 'Y') self.parser.set('Axis letters', 'ax3_letter', 'Z') self.parser.add_section('Route Optimisation') self.parser.set('Route Optimisation', 'Begin art','heurestic') self.parser.set('Route Optimisation', 'Max. population', 20) self.parser.set('Route Optimisation', 'Max. iterations', 300) self.parser.set('Route Optimisation', 'Mutation Rate', 0.95) self.parser.add_section('Filters') self.parser.set('Filters', 'pstoedit_cmd','C:\Program Files (x86)\pstoedit\pstoedit') self.parser.set('Filters', 'pstoedit_opt', ['-f','dxf','-mm']) self.parser.add_section('Debug') self.parser.set('Debug', 'global_debug_level', 0) open_file = open(os.path.join(self.folder,self.cfg_file_name), "w") self.parser.write(open_file) open_file.close() def get_all_vars(self): #try: self.write_to_stdout=int(self.parser.get('General', 'write_to_stdout')) self.tool_dia=DoubleVar() self.tool_dia.set(float(self.parser.get('Tool Parameters','diameter'))) self.start_rad=DoubleVar() self.start_rad.set(float(self.parser.get('Tool Parameters','start_radius'))) self.axis1_st_en=DoubleVar() self.axis1_st_en.set(float(self.parser.get('Plane Coordinates','axis1_start_end'))) self.axis2_st_en=DoubleVar() self.axis2_st_en.set(float(self.parser.get('Plane Coordinates','axis2_start_end'))) self.axis3_retract=DoubleVar() self.axis3_retract.set(float(self.parser.get('Depth Coordinates','axis3_retract'))) self.axis3_safe_margin=DoubleVar() self.axis3_safe_margin.set(float(self.parser.get('Depth Coordinates','axis3_safe_margin'))) self.axis3_slice_depth=DoubleVar() self.axis3_slice_depth.set(float(self.parser.get('Depth Coordinates','axis3_slice_depth'))) self.axis3_mill_depth=DoubleVar() self.axis3_mill_depth.set(float(self.parser.get('Depth Coordinates','axis3_mill_depth'))) self.F_G1_Depth=DoubleVar() self.F_G1_Depth.set(float(self.parser.get('Feed Rates','f_g1_depth'))) self.F_G1_Plane=DoubleVar() self.F_G1_Plane.set(float(self.parser.get('Feed Rates','f_g1_plane'))) self.points_tolerance=DoubleVar() self.points_tolerance.set(float(self.parser.get('Import Parameters','point_tolerance'))) self.fitting_tolerance=DoubleVar() self.fitting_tolerance.set(float(self.parser.get('Import Parameters','fitting_tolerance'))) self.spline_check=int(self.parser.get('Import Parameters', 'spline_check') ) #Zuweisen der Werte fuer die TSP Optimierung self.begin_art=self.parser.get('Route Optimisation', 'Begin art') self.max_population=int((int(self.parser.get('Route Optimisation', 'Max. population'))/4)*4) self.max_iterations=int(self.parser.get('Route Optimisation', 'Max. iterations')) self.mutate_rate=float(self.parser.get('Route Optimisation', 'Mutation Rate', 0.95)) #Zuweisen der Axis Letters self.ax1_letter=self.parser.get('Axis letters', 'ax1_letter') self.ax2_letter=self.parser.get('Axis letters', 'ax2_letter') self.ax3_letter=self.parser.get('Axis letters', 'ax3_letter') #Holen der restlichen Variablen #Verzeichnisse self.load_path=self.parser.get('Paths','load_path') self.save_path=self.parser.get('Paths','save_path') #Holen der Commandos fuer pstoedit self.pstoedit_cmd=self.parser.get('Filters','pstoedit_cmd') self.pstoedit_opt=self.parser.get('Filters','pstoedit_opt') #Setzen des Globalen Debug Levels self.debug=int(self.parser.get('Debug', 'global_debug_level')) # except: # showerror(_("Error during reading config file"), _("Please delete or correct\n %s")\ # %(os.path.join(self.folder,self.cfg_file_name))) # raise Exception, _("Problem during import from INI File") # def __str__(self): str='' for section in self.parser.sections(): str= str +"\nSection: "+section for option in self.parser.options(section): str= str+ "\n -> %s=%s" % (option, self.parser.get(section, option)) return str
class ScalePanel(PluginPanel): name = 'ScaleAndMirror' title = _("Scale and Mirror") def init(self, master): PluginPanel.init(self, master) self.width_priority = 1 root = self.mw.root self.var_width = DoubleVar(root) self.var_height = DoubleVar(root) unit = '%' jump = 5 self.var_proportional = IntVar(root) self.var_proportional.set(0) self.var_basepoint = StringVar(root) self.var_basepoint.set('C') #--------------------------------------------------------- top = TFrame(self.panel, style='FlatFrame') top.pack(side=TOP, fill=BOTH) #--------------------------------------------------------- # Horisontal size size_frameH = TFrame(top, style='FlatFrame', borderwidth=3) size_frameH.pack(side=TOP, fill=BOTH) label = TLabel(size_frameH, style='FlatLabel', image='size_h') label.pack(side=LEFT, padx=5) self.entry_width = TSpinbox(size_frameH, var=100, vartype=1, textvariable=self.var_width, min=-30000, max=30000, step=jump, width=6, command=self.apply_scale) self.entry_width.pack(side=LEFT) self.entry_width.down_button.bind('<ButtonRelease>', self.entry_width_chang) self.entry_width.down_button.bind('<KeyRelease>', self.entry_width_chang) self.entry_width.up_button.bind('<ButtonRelease>', self.entry_width_chang) self.entry_width.up_button.bind('<KeyRelease>', self.entry_width_chang) self.entry_width.entry.bind('<ButtonRelease>', self.entry_width_chang) self.entry_width.entry.bind('<KeyRelease>', self.entry_width_chang) self.entry_width.entry.bind('<FocusOut>', self.entry_width_chang) self.entry_width.entry.bind('<FocusIn>', self.entry_width_FocusIn) self.labelwunit = TLabel(size_frameH, style='FlatLabel', text=unit) self.labelwunit.pack(side=LEFT, padx=5) self.hflip = BooleanVar(root) self.hflip.set(0) button = TCheckbutton(size_frameH, image="pstrip_hflip", style='ToolBarCheckButton', variable=self.hflip, command=None) button.pack(side=LEFT) #--------------------------------------------------------- # Vertical size_frameV = TFrame(top, style='FlatFrame', borderwidth=3) size_frameV.pack(side=TOP, fill=BOTH) label = TLabel(size_frameV, style='FlatLabel', image='size_v') label.pack(side=LEFT, padx=5) self.entry_height = TSpinbox(size_frameV, var=100, vartype=1, textvariable=self.var_height, min=-30000, max=30000, step=jump, width=6, command=self.apply_scale) self.entry_height.pack(side=LEFT) self.entry_height.down_button.bind('<ButtonRelease>', self.entry_height_chang) self.entry_height.down_button.bind('<KeyRelease>', self.entry_height_chang) self.entry_height.up_button.bind('<ButtonRelease>', self.entry_height_chang) self.entry_height.up_button.bind('<KeyRelease>', self.entry_height_chang) self.entry_height.entry.bind('<ButtonRelease>', self.entry_height_chang) self.entry_height.entry.bind('<KeyRelease>', self.entry_height_chang) self.entry_height.entry.bind('<FocusOut>', self.entry_height_chang) self.entry_height.entry.bind('<FocusIn>', self.entry_height_FocusIn) self.labelhunit = TLabel(size_frameV, style='FlatLabel', text=unit) self.labelhunit.pack(side=LEFT, padx=5) self.vflip = BooleanVar(root) self.vflip.set(0) button = TCheckbutton(size_frameV, image="pstrip_vflip", style='ToolBarCheckButton', variable=self.vflip, command=None) button.pack(side=LEFT) #--------------------------------------------------------- # Proportional chek self.proportional_check = TCheckbutton(top, text=_("Proportional"), variable=self.var_proportional, command=self.proportional) self.proportional_check.pack(side=TOP, anchor=W, padx=5, pady=5) #--------------------------------------------------------- # Basepoint check label = TLabel(top, style='FlatLabel', text=_("Basepoint:")) label.pack(side=TOP, fill=BOTH, padx=5) basepoint_frame = TLabelframe(top, labelwidget=label, style='Labelframe', borderwidth=4) basepoint_frame.pack(side=TOP, fill=X, padx=5, pady=2) self.Basepoint = BasePointSelector(basepoint_frame, anchor=self.var_basepoint) self.Basepoint.pack(side=LEFT, fill=BOTH, padx=5) label = TLabel(basepoint_frame, style='FlatLabel', image='coordinate_sys') label.pack(side=LEFT, fill=BOTH, padx=10) #--------------------------------------------------------- # Button frame button_frame = TFrame(top, style='FlatFrame', borderwidth=5) button_frame.pack(side=BOTTOM, fill=BOTH) self.update_buttons = [] self.button = UpdatedButton(top, text=_("Apply"), command=self.apply_scale) self.button.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X, pady=3) self.button_copy = UpdatedButton(top, text=_("Apply to Copy"), command=self.apply_to_copy) self.button_copy.pack(in_=button_frame, side=BOTTOM, expand=1, fill=X) self.init_from_doc() self.subscribe_receivers() ############################################################################### def subscribe_receivers(self): self.document.Subscribe(SELECTION, self.Update) def unsubscribe_receivers(self): self.document.Unsubscribe(SELECTION, self.Update) def init_from_doc(self, *arg): self.Update() def Update(self, *arg): if self.is_selection(): self.entry_width.set_state(NORMAL) self.entry_height.set_state(NORMAL) self.proportional_check['state'] = NORMAL self.button['state'] = NORMAL self.button_copy['state'] = NORMAL else: self.entry_width.set_state(DISABLED) self.entry_height.set_state(DISABLED) self.proportional_check['state'] = DISABLED self.button['state'] = DISABLED self.button_copy['state'] = DISABLED def entry_width_FocusIn(self, *arg): self.width_priority = 1 def entry_height_FocusIn(self, *arg): self.width_priority = 0 def ScaleSelected(self, h, v, cnt_x=None, cnt_y=None): text = _("Scale") if self.document.selection: self.document.begin_transaction(text) try: try: br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom if cnt_x is None: cnt_x = hor_sel / 2 + br.left if cnt_y is None: cnt_y = ver_sel / 2 + br.bottom trafo = Trafo(h, 0, 0, v, cnt_x - cnt_x * h, cnt_y - cnt_y * v) self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def ScaleAndCopy(self, h, v, cnt_x=None, cnt_y=None): text = _("Scale&Copy") if self.document.selection: self.document.begin_transaction(text) try: try: br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom if cnt_x is None: cnt_x = hor_sel / 2 + br.left if cnt_y is None: cnt_y = ver_sel / 2 + br.bottom trafo = Trafo(h, 0, 0, v, cnt_x - cnt_x * h, cnt_y - cnt_y * v) self.document.ApplyToDuplicate() self.document.TransformSelected(trafo, text) except: self.document.abort_transaction() finally: self.document.end_transaction() def entry_height_chang(self, *arg): if self.var_proportional.get(): self.var_width.set(self.var_height.get()) def entry_width_chang(self, *arg): if self.var_proportional.get(): self.var_height.set(self.var_width.get()) def proportional(self): if self.width_priority: self.entry_width_chang() else: self.entry_height_chang() def apply_scale(self, *arg): if self.button["state"] == DISABLED: return self.proportional() width = self.var_width.get() height = self.var_height.get() br = self.document.selection.coord_rect hor_sel = br.right - br.left ver_sel = br.top - br.bottom cnt_x, cnt_y = self.Basepoint.get_basepoint(hor_sel, ver_sel, br.left, br.bottom) h = width / 100 if h == 0: h = 1 if self.hflip.get(): h = -1 * h v = height / 100 if v == 0: v = 1 if self.vflip.get(): v = -1 * v if arg and arg[0] == 'Duplicate': self.ScaleAndCopy(h, v, cnt_x, cnt_y) else: self.ScaleSelected(h, v, cnt_x, cnt_y) def apply_to_copy(self): self.apply_scale('Duplicate') def is_selection(self): return (len(self.document.selection) > 0)
class GUI: def _run(self): self.saveBtn.config(state=DISABLED) self.progressTxt.config(state=NORMAL) self.progressTxt.delete('1.0', END) self.progressTxt.update() self.progressTxt.config(state=DISABLED) inputId = self.txEntry.get() item = map(int, self.dbLbox.curselection()) db = self.dbids[item[0]] self.runBtn.config(state=DISABLED) self.inputId, self.inputName, self.hprobes = main(inputId, db, debug=self.debug, txt=self.progressTxt) self.runBtn.config(state=NORMAL) if self.hprobes is not None: self.saveBtn.config(state=NORMAL) def _quitGUI(self): #rpath = self.progressTxt.get('8.0','end-1c') #if rpath.startswith('Your results'): # tkMessageBox.showinfo("Quit", self.progressTxt.get('8.0','end-1c')) self.master.destroy() def _save(self): hps = filter_probes(self.hprobes, self.spec.get(), self.mingc.get(), self.multiexon.get(), self.mintm.get(), self.maxtm.get(), self.mindimer.get(), self.minfold.get(), self.maxduplex.get()) result_csv = write_probesCSV(self.inputId, self.inputName, hps, self.progressTxt) result_fna = write_probesFNA(self.inputId, self.inputName, hps, self.progressTxt) tkMessageBox.showinfo('Result file', 'Details on ' + str(len(hps)) + \ ' hybridization probe(s) were exported to ' + \ result_csv + "\n\n" + \ 'Sequences of '+ str(len(hps)) + \ ' hybridization probe(s) were exported to ' + \ result_fna) def __init__(self, master, dbnames, dbids, debug, version): self.dbids = dbids self.debug = debug self.master = master master.title('Plish Probe Designer') self.logoImg = PhotoImage(file=get_script_path() + '/img/plishLogo.gif') self.logoLbl = Label(master, image=self.logoImg) self.logoLbl.grid(row=0, columnspan=3) self.logoLbl.img = self.logoImg self.dbLbl = Label(master, text='Database') self.dbLbl.grid(row=1, sticky=W + N) self.dbLbox = Listbox(master, width=63, height=4) self.dbLbox.configure(exportselection=False) for i in range(len(dbnames)): self.dbLbox.insert(i, dbnames[i]) self.dbLbox.select_set(0) self.dbLbox.grid(row=1, column=1, columnspan=2, sticky=N) self.txLbl = Label(master, text='Transcript ID') self.txLbl.grid(row=2, sticky=W + N) self.txEntry = Entry(master, width=39) self.txEntry.grid(row=2, column=1, sticky=W + N) self.runBtn = Button(master, text='Run', command=self._run, width=15) self.runBtn.grid(row=2, column=2) self.progressLbl = Label(master, text='Progress') self.progressLbl.grid(row=4, sticky=W + N) self.progressTxt = Text(bg="#263238", fg="#ffffff", state=DISABLED, width=51, height=16) self.progressTxt.grid(row=4, column=1) self.saveBtn = Button(master, text='Save', command=self._save, state=DISABLED, width=15) self.saveBtn.grid(row=5, column=2, sticky=N) self.quitBtn = Button(master, text='Quit', command=self._quitGUI, width=15) self.quitBtn.grid(row=6, column=2, sticky=N) self.aboutLF = LabelFrame(master, text='About', width=300) self.aboutLF.grid(row=5, column=0, rowspan=2, columnspan=2, sticky=N + W) self.versionLbl = Label(self.aboutLF, text='PLISH Probe Designer, Version ' + version + '\n' + \ '(c) Heller lab, Stanford University School of Medicine\n' + \ ' Daniel C. Ellwanger <*****@*****.**> ', justify=LEFT) self.versionLbl.grid(row=0, column=0, sticky=N) # Filter self.filterLF = LabelFrame(master, text='Filter') self.filterLF.grid(row=4, column=2, rowspan=2, sticky=N + W) self.mingc = DoubleVar() self.mingc.set(_defaultGC) self.mingcLbl = Label(self.filterLF, text='Min. GC') self.mingcLbl.grid(row=0, column=0, sticky=N + W) self.mingcEntry = Entry(self.filterLF, width=5, text=self.mingc) self.mingcEntry.grid(row=0, column=1, sticky=N + W) self.mingcLbl2 = Label(self.filterLF, text='%') self.mingcLbl2.grid(row=0, column=2, sticky=N + W) self.spec = StringVar(master) self.spec.set("isoform") self.specLbl = Label(self.filterLF, text='Specificity') self.specLbl.grid(row=1, column=0, sticky=N + W) self.specOm = OptionMenu(self.filterLF, self.spec, "isoform", "gene", "none") self.specOm.grid(row=1, column=1, sticky=N + W, columnspan=2) self.mintm = DoubleVar() self.mintm.set(_defaultMinTm) self.mintmLbl = Label(self.filterLF, text='Min. Tm') self.mintmLbl.grid(row=2, column=0, sticky=N + W) self.mintmEntry = Entry(self.filterLF, width=5, text=self.mintm) self.mintmEntry.grid(row=2, column=1, sticky=N + W) self.mintmLbl2 = Label(self.filterLF, text=u'\N{DEGREE SIGN}' + 'C') self.mintmLbl2.grid(row=2, column=2, sticky=N + W) self.maxtm = DoubleVar() self.maxtm.set(_defaultMaxTm) self.maxtmLbl = Label(self.filterLF, text='Max. Tm') self.maxtmLbl.grid(row=3, column=0, sticky=N + W) self.maxtmEntry = Entry(self.filterLF, width=5, text=self.maxtm) self.maxtmEntry.grid(row=3, column=1, sticky=N + W) self.maxtmLbl2 = Label(self.filterLF, text=u'\N{DEGREE SIGN}' + 'C') self.maxtmLbl2.grid(row=3, column=2, sticky=N + W) self.minfold = DoubleVar() self.minfold.set(_defaultMinFold) self.minfoldLbl = Label(self.filterLF, text='Min. Fold') self.minfoldLbl.grid(row=4, column=0, sticky=N + W) self.minfoldEntry = Entry(self.filterLF, width=5, text=self.minfold) self.minfoldEntry.grid(row=4, column=1, sticky=N + W) self.minfoldLbl2 = Label(self.filterLF, text='kcal/mol') self.minfoldLbl2.grid(row=4, column=2, sticky=N + W) self.mindimer = DoubleVar() self.mindimer.set(_defaultMinDimer) self.mindimerLbl = Label(self.filterLF, text='Min. Dimer') self.mindimerLbl.grid(row=5, column=0, sticky=N + W) self.mindimerEntry = Entry(self.filterLF, width=5, text=self.mindimer) self.mindimerEntry.grid(row=5, column=1, sticky=N + W) self.mindimerLbl2 = Label(self.filterLF, text='kcal/mol') self.mindimerLbl2.grid(row=5, column=2, sticky=N + W) self.maxduplex = DoubleVar() self.maxduplex.set(_defaultMaxDuplex) self.maxduplexLbl = Label(self.filterLF, text='Max. Duplex') self.maxduplexLbl.grid(row=6, column=0, sticky=N + W) self.maxduplexEntry = Entry(self.filterLF, width=5, text=self.maxduplex) self.maxduplexEntry.grid(row=6, column=1, sticky=N + W) self.maxduplexLbl2 = Label(self.filterLF, text='kcal/mol') self.maxduplexLbl2.grid(row=6, column=2, sticky=N + W) self.multiexon = BooleanVar() self.multiexon.set(_defaultMultiExon) self.multiexonCb = Checkbutton(self.filterLF, text='Multi-exon', variable=self.multiexon, onvalue=True, offvalue=False) self.multiexonCb.grid(row=7, column=0, sticky=N + W)
class gui(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.initUI() self.centerUI(w=600, h=250) def initUI(self): self.parent.title("FIND BLR COEFFICIENT VALUE") self.pack(fill=BOTH, expand=True) self.columnconfigure(0, weight=1) # self.rowconfigure(0, weight=1) # weight attibute is used to make them growable ###### GUI Control Variables ###### self.LIMIT_L = IntVar() self.LIMIT_H = IntVar() self.PULSE_R = IntVar() self.PULSE_L = IntVar() self.pulse_height = DoubleVar() self.hdf5_file = StringVar() self.PMT = IntVar() self.EVENT = IntVar() self.amplitude_range = DoubleVar() self.delta = DoubleVar() self.noise_sigma = DoubleVar() self.coeff = DoubleVar() #self.DRAW = BooleanVar() search = Image.open("next_logo.jpg") search_temp = search.resize((170, 200), Image.ANTIALIAS) search_aux = ImageTk.PhotoImage(search_temp) label1 = Label(self, image=search_aux) label1.image = search_aux label1.grid(row=0, column=0, columnspan=10, rowspan=10, sticky=E + W + S + N) self.hdf5_file.set("2052.h5.z") e1 = Entry(self, textvariable=self.hdf5_file, width=30) e1.grid(row=1, column=1, sticky=W, columnspan=5, pady=5) e1_label = Label(self, text="HDF5 file") e1_label.grid(row=0, column=1, sticky=W, columnspan=5, pady=5) self.PMT.set("0") sb1 = Spinbox(self, from_=0, to=12, width=3, textvariable=self.PMT) sb1.grid(row=3, column=2, sticky=W) sb1_label = Label(self, text="PMT") sb1_label.grid(row=2, column=2, padx=0, sticky=W) self.EVENT.set("0") sb1 = Spinbox(self, from_=0, to=1000, width=5, textvariable=self.EVENT) sb1.grid(row=3, column=3, sticky=W) sb1_label = Label(self, text="EVENT") sb1_label.grid(row=2, column=3, padx=0, sticky=W) self.LIMIT_L.set("19000") sb1 = Spinbox(self, from_=0, to=100000, width=5, textvariable=self.LIMIT_L) sb1.grid(row=5, column=2, sticky=W) sb1_label = Label(self, text="ROI Start ") sb1_label.grid(row=4, column=2, padx=0, sticky=W) self.LIMIT_H.set("22500") sb1 = Spinbox(self, from_=0, to=100000, width=5, textvariable=self.LIMIT_H) sb1.grid(row=5, column=3, sticky=W) sb1_label = Label(self, text="ROI End ") sb1_label.grid(row=4, column=3, padx=0, sticky=W) self.PULSE_R.set("20142") sb1 = Spinbox(self, from_=0, to=100000, width=8, textvariable=self.PULSE_R) sb1.grid(row=5, column=4, sticky=E) sb1_label = Label(self, text=" Pulse Rise") sb1_label.grid(row=4, column=4, padx=0, sticky=E) self.PULSE_L.set("1200") sb1 = Spinbox(self, from_=0, to=5000, width=8, textvariable=self.PULSE_L) sb1.grid(row=5, column=5, sticky=E) sb1_label = Label(self, text=" Pulse Length") sb1_label.grid(row=4, column=5, padx=0, sticky=E) sb1_label = Label(self, text=" ") sb1_label.grid(row=2, column=7, padx=0, sticky=W) sb1_label = Label(self, text=" ") sb1_label.grid(row=6, column=7, padx=0, sticky=W) self.pulse_height.set("545.5") sb1 = Entry(self, width=8, textvariable=self.pulse_height) sb1.grid(row=7, column=3, sticky=E) sb1_label = Label(self, text=" Amplitude") sb1_label.grid(row=6, column=3, padx=0, sticky=E) self.amplitude_range.set("2") sb1 = Entry(self, width=8, textvariable=self.amplitude_range) sb1.grid(row=7, column=4, sticky=E) sb1_label = Label(self, text=" Loop Range") sb1_label.grid(row=6, column=4, padx=0, sticky=E) self.delta.set("0.1") sb1 = Entry(self, width=8, textvariable=self.delta) sb1.grid(row=7, column=5, sticky=E) sb1_label = Label(self, text=" Loop Delta") sb1_label.grid(row=6, column=5, padx=0, sticky=E) self.noise_sigma.set("4") sb1 = Entry(self, width=3, textvariable=self.noise_sigma) sb1.grid(row=5, column=6, sticky=E) sb1_label = Label(self, text=" Noise Threshold") sb1_label.grid(row=4, column=6, padx=0, sticky=E) sb_coeff_label = Label(self, text="Coefficient ") sb_coeff_label.grid(row=0, column=6, padx=0, sticky=E) self.sb_coeff = Label(self) self.sb_coeff.grid(row=1, column=6, padx=0, sticky=E) # MAIN BUTTONS obtn = Button(self, text="GO!!", command=self.find_C) obtn.grid(row=14, column=4, sticky=E, pady=10) cbtn = Button(self, text="Quit", command=self.quit) cbtn.grid(row=14, column=5, sticky=E, pady=10) hbtn = Button(self, text="Help", command=self.help_f) hbtn.grid(row=14, column=0, sticky=W, pady=10) def help_f(self): top = Toplevel() top.title("HELP") msg = Message(top, width=500, text="COEFF Calibration Procedure: \n \ Input Start Point and Length of the pulse \n \ Input an initial guess of the pulse amplitude \n \ Use a ROI with at least 1000 samples of baseline \n \ and 1000 samples after pulse end \n \ Adjust loop range and step until a graph error \n \ with a minimum is observed \n \ Refine the search to increase precision") msg.pack() button = Button(top, text="Close", command=top.destroy) button.pack() def find_C(self): draw = False LIMIT_L = self.LIMIT_L.get() #19000 LIMIT_H = self.LIMIT_H.get() #22500 PULSE_R = self.PULSE_R.get() #20142 PULSE_L = self.PULSE_L.get() #1200 pulse_height = self.pulse_height.get() #545 hdf5_file = self.hdf5_file.get() #'2052.h5.z' PMT = self.PMT.get() event = self.EVENT.get() amplitude_range = self.amplitude_range.get() #2 delta = self.delta.get() #0.1 noise_sigma = self.noise_sigma.get() #4 coeff_aux = fc.find_coeff(LIMIT_L, LIMIT_H, PULSE_R, PULSE_L, pulse_height, hdf5_file, PMT, event, amplitude_range, delta, noise_sigma, draw) plt.show() self.sb_coeff.configure(text=str(coeff_aux)) def centerUI(self, w, h): sw = self.parent.winfo_screenwidth() sh = self.parent.winfo_screenheight() x = (sw - w) / 2 y = (sh - h) / 2 self.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))
def gui(): from Tkinter import Tk, Label, Entry, Button, Scale, Checkbutton, W, HORIZONTAL, Frame, StringVar, IntVar, DoubleVar, Radiobutton, BooleanVar, E global root root = Tk() root.wm_title("Compute R_complete") line = 0 global insFile, hklFile, nHKL, nParams, nHKLLabel, fracFree, status, nParamsLabel, nCPU, rCompleteLabel, cycles, lsType, cleanup, nFree, nRunsLabel, mergeCheck, compileMap insFile = StringVar() hklFile = StringVar() nHKL = IntVar() nParams = IntVar() nFree = IntVar() fracFree = DoubleVar() fracFree.set(5.0) nCPU = IntVar() nCPU.set(maxCPU) cycles = IntVar() cycles.set(10) lsType = IntVar() lsType.set(1) cleanup = BooleanVar() cleanup.set(True) mergeCheck = BooleanVar() mergeCheck.set(True) compileMap = BooleanVar() compileMap.set(True) Label(root, text='Instruction File:').grid(row=line, column=0, sticky=E) Entry(root, textvariable=insFile).grid(row=line, column=1) Button(root, text='Browse', command=browseINS).grid(row=line, column=2) line += 1 Label(root, text='Reflection File:').grid(row=line, column=0, sticky=E) Entry(root, textvariable=hklFile).grid(row=line, column=1) Button(root, text='Browse', command=browseHKL).grid(row=line, column=2) line += 1 Checkbutton(root, var=mergeCheck, text='Merge Reflections').grid(row=line, column=1, sticky=W) line += 1 Button(root, text='Load', command=load).grid(row=line, columnspan=3) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='# of reflections:').grid(row=line, sticky=E) nHKLLabel = Label(root, text='???') nHKLLabel.grid(row=line, column=1, sticky=W) line += 1 Label(root, text='# of atoms:').grid(row=line, sticky=E) nParamsLabel = Label(root, text='???') nParamsLabel.grid(row=line, column=1, sticky=W) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='Select Parameters').grid(row=line, column=1) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='# of free reflections:').grid(row=line, sticky=E) nFreeEntry = Entry(root, width=5, textvariable=nFree) nFreeEntry.grid(row=line, column=1, sticky=W) nFreeEntry.bind('<Return>', setScale) nRunsLabel = Label(root, text='# runs') nRunsLabel.grid(row=line, column=2) line += 1 Label(root, text='% of free reflections:').grid(row=line, column=0, sticky=E) w = Scale(root, from_=0.1, to=10.0, resolution=0.1, orient=HORIZONTAL, length=200, var=fracFree, command=percentScale) w.grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Label(root, text='stable <-------------------------------> fast').grid( row=line, column=1, columnspan=2, sticky=W) line += 1 Frame(root, height=10).grid(row=line) line += 1 Label(root, text='Refinement cycles:').grid(row=line, column=0, sticky=E) ls = Scale(root, from_=0, to=50, resolution=1, orient=HORIZONTAL, length=200, var=cycles) ls.grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Label(root, text='fast <--------------------> less model bias').grid( row=line, column=1, columnspan=2, sticky=W) line += 1 Frame(root, height=10).grid(row=line) line += 1 Label(root, text='# of CPUs:').grid(row=line, column=0, sticky=E) ww = Scale(root, from_=1, to=maxCPU, orient=HORIZONTAL, length=200, var=nCPU) ww.grid(row=line, column=1, columnspan=2, sticky=W) line += 1 Label(root, text='Refinement Type:').grid(row=line, column=0, sticky=E) Radiobutton(root, text='CGLS', var=lsType, value=1).grid(row=line, column=1, sticky=W) Radiobutton(root, text='L.S.', var=lsType, value=2).grid(row=line, column=2, sticky=W) line += 1 Frame(root, height=10).grid(row=line) line += 1 Label(root, text='Compile map:').grid(row=line, column=0, sticky=E) Checkbutton(root, var=compileMap).grid(row=line, column=1, sticky=W) line += 1 Label(root, text='Cleanup:').grid(row=line, column=0, sticky=E) Checkbutton(root, var=cleanup).grid(row=line, column=1, sticky=W) line += 1 Button(root, text='RUN', command=run, width=25).grid(row=line, columnspan=3) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='R_complete:').grid(row=line, column=0, sticky=E) rCompleteLabel = Label(root, text='???') rCompleteLabel.grid(row=line, column=1, sticky=W) line += 1 Frame(root, height=20).grid(row=line) line += 1 Label(root, text='Status:').grid(row=line, column=0, sticky=E) status = Label(root, text='Idle... Please load files.') status.grid(row=line, column=1, columnspan=2, sticky=W) global IDLE IDLE = True root.mainloop()
class CMYKDigitizer(TFrame): def __init__(self, parent, callback, **kw): self.callback = callback TFrame.__init__(self, parent, style='FlatFrame', **kw) self.C_value = DoubleVar(0) self.M_value = DoubleVar(0) self.Y_value = DoubleVar(0) self.K_value = DoubleVar(0) self.A_value = DoubleVar(0) b = TLabel(self, style='HLine') b.pack(side=BOTTOM, fill=X) frame = TFrame(self, borderwidth=0, style='FlatFrame') frame.pack(side=BOTTOM) label = TLabel(frame, text=_("Opacity: ")) label.pack(side=LEFT) self.A_spin = TSpinbox(frame, min=0, max=255, step=1, vartype=0, width=7, textvariable=self.A_value, command=self.cmyk_component_changed) self.A_spin.pack(side=RIGHT) b = TLabel(self, style='HLine') b.pack(side=BOTTOM, fill=X) cmyk_frame = TFrame(self, borderwidth=2, style='FlatFrame') cmyk_frame.pack(side=LEFT, padx=10) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="C: ") label.pack(side=LEFT) self.C_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.C_value, command=self.cmyk_component_changed) self.C_spin.pack(side=RIGHT) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="M: ") label.pack(side=LEFT) self.M_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.M_value, command=self.cmyk_component_changed) self.M_spin.pack(side=RIGHT) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="Y: ") label.pack(side=LEFT) self.Y_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.Y_value, command=self.cmyk_component_changed) self.Y_spin.pack(side=RIGHT) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="K: ") label.pack(side=LEFT) self.K_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.K_value, command=self.cmyk_component_changed) self.K_spin.pack(side=RIGHT) rgb_frame = TFrame(self, borderwidth=2, style='FlatFrame') rgb_frame.pack(side=LEFT) self.RGB_label = TLabel(rgb_frame, text='R:\nG:\nB:', justify=LEFT) self.RGB_label.pack(side=LEFT) def set_color(self, color): self.color = color c, m, y, k = color.getCMYK() self.C_value.set(round(c * 100, 2)) self.M_value.set(round(m * 100, 2)) self.Y_value.set(round(y * 100, 2)) self.K_value.set(round(k * 100, 2)) self.A_value.set(int(round(color.alpha * 100))) r, g, b = color.getRGB() text = 'R: %d\nG: %d\nB: %d' % (round(r * 255, 2), round( g * 255, 2), round(b * 255, 2)) int_color = (round(r * 255), round(g * 255), round(b * 255)) text += '\n\n#%02X%02X%02X' % int_color self.RGB_label['text'] = text def cmyk_component_changed(self, *arg): c = self.C_value.get() / 100.0 m = self.M_value.get() / 100.0 y = self.Y_value.get() / 100.0 k = self.K_value.get() / 100.0 a = self.A_value.get() / 100.0 self.callback(CreateCMYKAColor(c, m, y, k, a))
class gui(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.initUI() self.centerUI(w=600,h=250) def initUI(self): self.parent.title("FIND BLR COEFFICIENT VALUE") self.pack(fill=BOTH, expand=True) self.columnconfigure(0, weight=1) # self.rowconfigure(0, weight=1) # weight attibute is used to make them growable ###### GUI Control Variables ###### self.LIMIT_L = IntVar() self.LIMIT_H = IntVar() self.PULSE_R = IntVar() self.PULSE_L = IntVar() self.pulse_height = DoubleVar() self.hdf5_file = StringVar() self.PMT = IntVar() self.EVENT = IntVar() self.amplitude_range = DoubleVar() self.delta = DoubleVar() self.noise_sigma = DoubleVar() self.coeff = DoubleVar() #self.DRAW = BooleanVar() search = Image.open("next_logo.jpg") search_temp = search.resize((170, 200), Image.ANTIALIAS) search_aux = ImageTk.PhotoImage(search_temp) label1 = Label(self, image=search_aux) label1.image = search_aux label1.grid(row=0, column=0, columnspan=10, rowspan=10, sticky=E+W+S+N) self.hdf5_file.set("2052.h5.z") e1 = Entry(self, textvariable=self.hdf5_file, width=30) e1.grid(row=1,column=1, sticky=W, columnspan=5, pady=5) e1_label = Label(self, text="HDF5 file") e1_label.grid(row=0,column=1,sticky=W, columnspan=5, pady=5) self.PMT.set("0") sb1 = Spinbox(self, from_=0, to=12, width=3, textvariable=self.PMT) sb1.grid(row=3,column=2, sticky=W) sb1_label = Label(self, text="PMT") sb1_label.grid(row=2,column=2, padx=0, sticky=W) self.EVENT.set("0") sb1 = Spinbox(self, from_=0, to=1000, width=5, textvariable=self.EVENT) sb1.grid(row=3,column=3, sticky=W) sb1_label = Label(self, text="EVENT") sb1_label.grid(row=2,column=3, padx=0, sticky=W) self.LIMIT_L.set("19000") sb1 = Spinbox(self, from_=0, to=100000, width=5, textvariable=self.LIMIT_L) sb1.grid(row=5,column=2, sticky=W) sb1_label = Label(self, text="ROI Start ") sb1_label.grid(row=4,column=2, padx=0, sticky=W) self.LIMIT_H.set("22500") sb1 = Spinbox(self, from_=0, to=100000, width=5, textvariable=self.LIMIT_H) sb1.grid(row=5,column=3, sticky=W) sb1_label = Label(self, text="ROI End ") sb1_label.grid(row=4,column=3, padx=0, sticky=W) self.PULSE_R.set("20142") sb1 = Spinbox(self, from_=0, to=100000, width=8, textvariable=self.PULSE_R) sb1.grid(row=5,column=4, sticky=E) sb1_label = Label(self, text=" Pulse Rise") sb1_label.grid(row=4,column=4, padx=0, sticky=E) self.PULSE_L.set("1200") sb1 = Spinbox(self, from_=0, to=5000, width=8, textvariable=self.PULSE_L) sb1.grid(row=5,column=5, sticky=E) sb1_label = Label(self, text=" Pulse Length") sb1_label.grid(row=4,column=5, padx=0, sticky=E) sb1_label = Label(self, text=" ") sb1_label.grid(row=2,column=7, padx=0, sticky=W) sb1_label = Label(self, text=" ") sb1_label.grid(row=6,column=7, padx=0, sticky=W) self.pulse_height.set("545.5") sb1 = Entry(self, width=8, textvariable=self.pulse_height) sb1.grid(row=7,column=3, sticky=E) sb1_label = Label(self, text=" Amplitude") sb1_label.grid(row=6,column=3, padx=0, sticky=E) self.amplitude_range.set("2") sb1 = Entry(self, width=8, textvariable=self.amplitude_range) sb1.grid(row=7,column=4, sticky=E) sb1_label = Label(self, text=" Loop Range") sb1_label.grid(row=6,column=4, padx=0, sticky=E) self.delta.set("0.1") sb1 = Entry(self, width=8, textvariable=self.delta) sb1.grid(row=7,column=5, sticky=E) sb1_label = Label(self, text=" Loop Delta") sb1_label.grid(row=6,column=5, padx=0, sticky=E) self.noise_sigma.set("4") sb1 = Entry(self, width=3, textvariable=self.noise_sigma) sb1.grid(row=5,column=6, sticky=E) sb1_label = Label(self, text=" Noise Threshold") sb1_label.grid(row=4,column=6, padx=0, sticky=E) sb_coeff_label = Label(self, text= "Coefficient ") sb_coeff_label.grid(row=0,column=6, padx=0, sticky=E) self.sb_coeff = Label(self) self.sb_coeff.grid(row=1,column=6, padx=0, sticky=E) # MAIN BUTTONS obtn = Button(self, text="GO!!", command=self.find_C) obtn.grid(row=14, column=4, sticky=E, pady=10) cbtn = Button(self, text="Quit", command=self.quit) cbtn.grid(row=14, column=5, sticky=E, pady=10) hbtn = Button(self, text="Help", command=self.help_f) hbtn.grid(row=14, column=0, sticky=W, pady=10) def help_f(self): top = Toplevel() top.title("HELP") msg = Message(top, width= 500, text="COEFF Calibration Procedure: \n \ Input Start Point and Length of the pulse \n \ Input an initial guess of the pulse amplitude \n \ Use a ROI with at least 1000 samples of baseline \n \ and 1000 samples after pulse end \n \ Adjust loop range and step until a graph error \n \ with a minimum is observed \n \ Refine the search to increase precision") msg.pack() button = Button(top, text="Close", command=top.destroy) button.pack() def find_C(self): draw = False LIMIT_L = self.LIMIT_L.get() #19000 LIMIT_H = self.LIMIT_H.get() #22500 PULSE_R = self.PULSE_R.get() #20142 PULSE_L = self.PULSE_L.get() #1200 pulse_height = self.pulse_height.get() #545 hdf5_file = self.hdf5_file.get() #'2052.h5.z' PMT = self.PMT.get() event = self.EVENT.get() amplitude_range = self.amplitude_range.get() #2 delta = self.delta.get() #0.1 noise_sigma = self.noise_sigma.get() #4 coeff_aux = fc.find_coeff(LIMIT_L, LIMIT_H, PULSE_R, PULSE_L, pulse_height, hdf5_file, PMT, event, amplitude_range, delta, noise_sigma, draw) plt.show() self.sb_coeff.configure(text=str(coeff_aux)) def centerUI(self,w,h): sw = self.parent.winfo_screenwidth() sh = self.parent.winfo_screenheight() x = (sw-w)/2 y = (sh-h)/2 self.parent.geometry('%dx%d+%d+%d' % (w,h,x,y))
class CMYKDigitizer(TFrame): def __init__(self, parent, callback, **kw): self.callback = callback TFrame.__init__(self, parent, style='FlatFrame', **kw) self.C_value = DoubleVar(0) self.M_value = DoubleVar(0) self.Y_value = DoubleVar(0) self.K_value = DoubleVar(0) self.A_value = DoubleVar(0) b = TLabel(self, style='HLine') b.pack(side=BOTTOM, fill=X) frame = TFrame(self, borderwidth=0, style='FlatFrame') frame.pack(side=BOTTOM) label = TLabel(frame, text=_("Opacity: ")) label.pack(side=LEFT) self.A_spin = TSpinbox(frame, min=0, max=255, step=1, vartype=0, width=7, textvariable=self.A_value, command=self.cmyk_component_changed) self.A_spin.pack(side=RIGHT) b = TLabel(self, style='HLine') b.pack(side=BOTTOM, fill=X) cmyk_frame = TFrame(self, borderwidth=2, style='FlatFrame') cmyk_frame.pack(side=LEFT, padx=10) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="C: ") label.pack(side=LEFT) self.C_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.C_value, command=self.cmyk_component_changed) self.C_spin.pack(side=RIGHT) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="M: ") label.pack(side=LEFT) self.M_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.M_value, command=self.cmyk_component_changed) self.M_spin.pack(side=RIGHT) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="Y: ") label.pack(side=LEFT) self.Y_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.Y_value, command=self.cmyk_component_changed) self.Y_spin.pack(side=RIGHT) frame = TFrame(cmyk_frame, borderwidth=2, style='FlatFrame') frame.pack(side=TOP) label = TLabel(frame, text="K: ") label.pack(side=LEFT) self.K_spin = TSpinbox(frame, min=0, max=100, step=1, vartype=1, width=7, textvariable=self.K_value, command=self.cmyk_component_changed) self.K_spin.pack(side=RIGHT) rgb_frame = TFrame(self, borderwidth=2, style='FlatFrame') rgb_frame.pack(side=LEFT) self.RGB_label = TLabel(rgb_frame, text='R:\nG:\nB:', justify=LEFT) self.RGB_label.pack(side=LEFT) def set_color(self, color): self.color = color c, m, y, k = color.getCMYK() self.C_value.set(round(c * 100, 2)) self.M_value.set(round(m * 100, 2)) self.Y_value.set(round(y * 100, 2)) self.K_value.set(round(k * 100, 2)) self.A_value.set(int(round(color.alpha * 100))) r, g, b = color.getRGB() text = 'R: %d\nG: %d\nB: %d' % (round(r * 255, 2), round(g * 255, 2), round(b * 255, 2)) int_color = (round(r * 255), round(g * 255), round(b * 255)) text += '\n\n#%02X%02X%02X' % int_color self.RGB_label['text'] = text def cmyk_component_changed(self, *arg): c = self.C_value.get() / 100.0 m = self.M_value.get() / 100.0 y = self.Y_value.get() / 100.0 k = self.K_value.get() / 100.0 a = self.A_value.get() / 100.0 self.callback(CreateCMYKAColor(c, m, y, k, a))
class TopoConsole(tk.AppWindow,tk.TkParameterized): """ Main window for the Tk-based GUI. """ def _getmenubar(self): return self.master.menubar menubar = property(_getmenubar) def __getitem__(self,menu_name): """Allow dictionary-style access to the menu bar.""" return self.menubar[menu_name] def __init__(self, root,exit_on_quit=True, **params): tk.AppWindow.__init__(self,root,status=True) tk.TkParameterized.__init__(self,root,**params) # Instead of displaying tracebacks on the commandline, try to display # them on the originating window. # CEBALERT: on destroy(), ought to revert this Tkinter.Misc._report_exception=_tkinter_report_exception self.exit_on_quit = exit_on_quit self.auto_refresh_panels = [] self._init_widgets() self.title(topo.sim.name) # If -g passed *before* scripts on commandline, this is useless. # So topo.misc.commandline sets the title as its last action (if -g) # catch click on the 'x': offers choice to quit or not self.protocol("WM_DELETE_WINDOW",self.quit_topographica) ########## ### Make cascade menus open automatically on linux when the mouse ### is over the menu title. ### [Tkinter-discuss] Cascade menu issue ### http://mail.python.org/pipermail/tkinter-discuss/2006-August/000864.html if topo.tkgui.system_platform is 'linux': activate_cascade = """\ if {[%W cget -type] != {menubar} && [%W type active] == {cascade}} { %W postcascade active } """ self.bind_class("Menu", "<<MenuSelect>>", activate_cascade) ########## # Install warning and message handling from param.parameterized import Parameterized self.__orig_P_warning = Parameterized.warning #self.__orig_P_message = Parameterized.message type.__setattr__(Parameterized,'warning',self.gui_warning) #type.__setattr__(Parameterized,'message',self.gui_message) def gui_warning(self,msg,*args,**kw): stat = self.__get_status_bar() stat.warn(msg%args) self.__orig_P_warning(self,msg,*args,**kw) def gui_message(self,msg,*args,**kw): stat = self.__get_status_bar() stat.message(msg%args) self.__orig_P_message(self,*args) def title(self,t=None): newtitle = "Topographica" if t: newtitle+=": %s" % t tk.AppWindow.title(self,newtitle) def _init_widgets(self): ## CEBALERT: now we can have multiple operations at the same time, ## status bar could be improved to show all tasks? # CEBALERT self.messageBar = self.status self.some_area = DockManager(self) self.some_area.pack(fill="both", expand=1) ### Balloon, for pop-up help self.balloon = tk.Balloon(self.content) ### Top-level (native) menu bar #self.menubar = tk.ControllableMenu(self.content) self.configure(menu=self.menubar) #self.menu_balloon = Balloon(topo.tkgui.root) # no menubar in tile yet # http://news.hping.org/comp.lang.tcl.archive/4679.html self.__simulation_menu() self.__create_plots_menu() self.refresh_plots_menu() self.__help_menu() ### Running the simulation run_frame = Frame(self.content) run_frame.pack(side='top',fill='x',padx=4,pady=8) self.run_frame = run_frame Label(run_frame,text='Run for: ').pack(side=LEFT) self.run_for_var=DoubleVar() self.run_for_var.set(1.0) run_for = tk.TaggedSlider(run_frame, variable=self.run_for_var, tag_width=11, slider_length=150, bounds=(0,20000)) self.balloon.bind(run_for,"Duration to run the simulation, e.g. 0.0500, 1.0, or 20000.") run_for.pack(side=LEFT,fill='x',expand=YES) run_for.tag.bind("<Return>",self.run_simulation) # When return is pressed, the TaggedSlider updates itself...but we also want to run # the simulation in this case. run_frame.optional_action=self.run_simulation go_button = Button(run_frame,text="Go", command=self.run_simulation) go_button.pack(side=LEFT) self.balloon.bind(go_button,"Run the simulation for the specified duration.") self.step_button = Button(run_frame,text="Step",command=self.run_step) self.balloon.bind(self.step_button,"Run the simulation through the time at which the next events are processed.") self.step_button.pack(side=LEFT) self.sizeright() def __simulation_menu(self): """Add the simulation menu options to the menubar.""" simulation_menu = ControllableMenu(self.menubar,tearoff=0) self.menubar.add_cascade(label='Simulation',menu=simulation_menu) simulation_menu.add_command(label='Run script',command=self.run_script) simulation_menu.add_command(label='Save script',command=self.save_script_repr) simulation_menu.add_command(label='Load snapshot',command=self.load_snapshot) simulation_menu.add_command(label='Save snapshot',command=self.save_snapshot) #simulation_menu.add_command(label='Reset',command=self.reset_network) simulation_menu.add_command(label='Test Pattern',command=self.open_test_pattern) simulation_menu.add_command(label='Model Editor',command=self.open_model_editor) simulation_menu.add_command(label='Quit',command=self.quit_topographica) def open_test_pattern(self): return open_plotgroup_panel(TestPattern) def __create_plots_menu(self): """ Add the plot menu to the menubar, with Basic plots on the menu itself and others in cascades by category (the plots come from plotgroup_templates). """ plots_menu = ControllableMenu(self.menubar,tearoff=0) self.menubar.add_cascade(label='Plots',menu=plots_menu) # CEBALERT: should split other menus in same way as plots (create/refresh) def refresh_plots_menu(self): plots_menu = self['Plots'] plots_menu.delete(0,'end') # create menu entries, and get list of categories entries=OrderedDict() # keep the order of plotgroup_templates (which is also KL) categories = [] for label,plotgroup in plotgroups.items(): entries[label] = PlotsMenuEntry(plotgroup) categories.append(plotgroup.category) categories = sorted(set(categories)) # The Basic category items appear on the menu itself. assert 'Basic' in categories, "'Basic' is the category for the standard Plots menu entries." for label,entry in entries.items(): if entry.plotgroup.category=='Basic': plots_menu.add_command(label=label,command=entry.__call__) categories.remove('Basic') plots_menu.add_separator() # Add the other categories to the menu as cascades, and the plots of each category to # their cascades. for category in categories: category_menu = ControllableMenu(plots_menu,tearoff=0) plots_menu.add_cascade(label=category,menu=category_menu) # could probably search more efficiently than this for label,entry in entries.items(): if entry.plotgroup.category==category: category_menu.add_command(label=label,command=entry.__call__) plots_menu.add_separator() plots_menu.add_command(label="Help",command=(lambda x=plotting_help_locations: self.open_location(x))) def __help_menu(self): """Add the help menu options.""" help_menu = ControllableMenu(self.menubar,tearoff=0,name='help') self.menubar.add_cascade(label='Help',menu=help_menu) help_menu.add_command(label='About',command=self.new_about_window) help_menu.add_command(label="User Manual", command=(lambda x=user_manual_locations: self.open_location(x))) help_menu.add_command(label="Tutorials", command=(lambda x=tutorials_locations: self.open_location(x))) help_menu.add_command(label="Examples", command=self.run_example_script) help_menu.add_command(label="Reference Manual", command=(lambda x=reference_manual_locations: self.open_location(x))) help_menu.add_command(label="Topographica.org", command=(lambda x=topo_www_locations: self.open_location(x))) help_menu.add_command(label="Python documentation", command=(lambda x=python_doc_locations: self.open_location(x))) def quit_topographica(self,check=True,exit_status=0): """Quit topographica.""" if not check or (check and tk.askyesno("Quit Topographica","Really quit?")): self.destroy() # matplotlib's tk backend starts its own Tk instances; we # need to close these ourselves (at least to avoid error # message about 'unusual termination' in Windows). try: # not that there should be an error, but just in case... import matplotlib._pylab_helpers for figman in matplotlib._pylab_helpers.Gcf.get_all_fig_managers(): figman.destroy() except: pass self.message("Quit selected%s" % ("; exiting" if self.exit_on_quit else "")) # Workaround for obscure problem on some UNIX systems # as of 4/2007, probably including Fedora Core 5. # On these systems, if Topographica is started from a # bash prompt and then quit from the Tkinter GUI (as # opposed to using Ctrl-D in the terminal), the # terminal would suppress echoing of all future user # input. stty sane restores the terminal to sanity, # but it is not clear why this is necessary. # For more info: # http://groups.google.com/group/comp.lang.python/browse_thread/thread/68d0f33c8eb2e02d if topo.tkgui.system_platform=="linux" and os.getenv('EMACS')!='t': try: os.system("stty sane") except: pass # CEBALERT: re. above. Shouldn't we be able to store the # output of "stty --save" before starting the gui, then # ensure that when the gui exits (however badly it # happens) run "stty saved_settings"? # CEBALERT: there was no call to self.master.destroy() if self.exit_on_quit: sys.exit(exit_status) def run_script(self): """ Dialog to run a user-selected script The script is exec'd in __main__.__dict__ (i.e. as if it were specified on the commandline.) """ script = askopenfilename(initialdir=normalize_path(),filetypes=SCRIPT_FILETYPES) if script in ('',(),None): # (representing the various ways no script was selected in the dialog) self.messageBar.response('Run canceled') else: execfile(script,__main__.__dict__) self.messageBar.response('Ran ' + script) sim_name_from_filename(script) self.title(topo.sim.name) # CEBALERT: duplicates most of run_script() def run_example_script(self): script = askopenfilename(initialdir=topo.misc.genexamples.find_examples(), filetypes=SCRIPT_FILETYPES) if script in ('',(),None): # (representing the various ways no script was selected in the dialog) self.messageBar.response('No example opened') else: execfile(script,__main__.__dict__) self.messageBar.response('Ran ' + script) sim_name_from_filename(script) self.title(topo.sim.name) def save_script_repr(self): script_name = asksaveasfilename(filetypes=SCRIPT_FILETYPES, initialdir=normalize_path(), initialfile=topo.sim.basename()+"_script_repr.ty") if script_name: topo.command.save_script_repr(script_name) self.messageBar.response('Script saved to ' + script_name) def load_snapshot(self): """ Dialog to load a user-selected snapshot (see topo.command.load_snapshot() ). """ snapshot_name = askopenfilename(initialdir=normalize_path(),filetypes=SAVED_FILETYPES) if snapshot_name in ('',(),None): self.messageBar.response('No snapshot loaded.') else: self.messageBar.dynamicinfo('Loading snapshot (may take some time)...') self.update_idletasks() topo.command.load_snapshot(snapshot_name) self.messageBar.response('Loaded snapshot ' + snapshot_name) self.title(topo.sim.name) self.auto_refresh() def save_snapshot(self): """ Dialog to save a snapshot (see topo.command.save_snapshot() ). Adds the file extension .typ if not already present. """ snapshot_name = asksaveasfilename(filetypes=SAVED_FILETYPES, initialdir=normalize_path(), initialfile=topo.sim.basename()+".typ") if snapshot_name in ('',(),None): self.messageBar.response('No snapshot saved.') else: if not snapshot_name.endswith('.typ'): snapshot_name = snapshot_name + SAVED_FILE_EXTENSION self.messageBar.dynamicinfo('Saving snapshot (may take some time)...') self.update_idletasks() topo.command.save_snapshot(snapshot_name) self.messageBar.response('Snapshot saved to ' + snapshot_name) def auto_refresh(self, update=True): """ Refresh all windows in auto_refresh_panels. Panels can add and remove themselves to the list; those in the list will have their refresh() method called whenever this console's autorefresh() is called. """ for win in self.auto_refresh_panels: win.refresh(update) self.set_step_button_state() self.update_idletasks() ### CEBERRORALERT: why doesn't updatecommand("display=True") for an ### orientation preference map measurement work with the ### hierarchical example? I guess this is the reason I thought the ### updating never worked properly (or I really did break it ### recently - or I'm confused)... def refresh_activity_windows(self): """ Update any windows with a plotgroup_key ending in 'Activity'. Used primarily for debugging long scripts that present a lot of activity patterns. """ for win in self.auto_refresh_panels: if re.match('.*Activity$',win.plotgroup.name): win.refresh() self.update_idletasks() def open_model_editor(self): """Start the Model editor.""" return ModelEditor(self) def new_about_window(self): win = tk.AppWindow(self) win.withdraw() win.title("About Topographica") text = Label(win,text=topo.about(display=False),justify=LEFT) text.pack(side=LEFT) win.deiconify() #self.messageBar.message('state', 'OK') def open_location(self, locations): """ Try to open one of the specified locations in a new window of the default browser. See webbrowser module for more information. locations should be a tuple. """ # CB: could have been a list. This is only here because if locations is set # to a string, it will loop over the characters of the string. assert isinstance(locations,tuple),"locations must be a tuple." for location in locations: try: existing_location = resolve_path(location) webbrowser.open(existing_location,new=2,autoraise=True) self.messageBar.response('Opened local file '+existing_location+' in browser.') return ### except: pass for location in locations: if location.startswith('http'): try: webbrowser.open(location,new=2,autoraise=True) self.messageBar.response('Opened remote location '+location+' in browser.') return ### except: pass self.messageBar.response("Could not open any of %s in a browser."%locations) # CEBALERT: need to take care of removing old messages automatically? # (Otherwise callers might always have to pass 'ok'.) def status_message(self,m): self.messageBar.response(m) def run_simulation(self,event=None): # event=None allows use as callback """ Run the simulation for the duration specified in the 'run for' taggedslider. """ fduration = self.run_for_var.get() self.open_progress_window(timer=topo.sim.timer) topo.sim.run_and_time(fduration) self.auto_refresh() # CEBERRORALERT: Step button does strange things at time==0. # E.g. for lissom_oo_or, nothing appears to happen. For # hierarchical, runs to time==10. def run_step(self): if not topo.sim.events: # JP: step button should be disabled if there are no events, # but just in case... return # JPALERT: This should really use .run_and_time() but it doesn't support # run(until=...) topo.sim.run(until=topo.sim.events[0].time) self.auto_refresh() def set_step_button_state(self): if topo.sim.events: self.step_button.config(state=NORMAL) else: self.step_button.config(state=DISABLED) def __get_status_bar(self,i=2): # Hack to find appropriate status bar: Go back through frames # until a widget with a status bar is found, and return it. try: while True: f = sys._getframe(i) if hasattr(f,'f_locals'): if 'self' in f.f_locals: o = f.f_locals['self'] # (temporary hack til ScrolledFrame cleaned up) if o.__class__.__name__!='ScrolledFrame': if hasattr(o,'messageBar'): return o.messageBar elif hasattr(o,'status'): return o.status i+=1 except: pass #print "GUI INTERNAL WARNING: failed to determine window on which to display message." return self.messageBar def open_progress_window(self,timer,title=None): """ Provide a convenient link to progress bars. """ stat = self.__get_status_bar() return stat.open_progress_window(timer=timer,sim=topo.sim)
class Tool_Path_Generator: def __init__(self, top=None): '''This class configures and populates the toplevel window. top is the toplevel containing window.''' _bgcolor = '#e6e6e6' # X11 color: 'gray85' _fgcolor = '#000000' # X11 color: 'black' font11 = "-size 15 -weight normal -slant roman " \ "-underline 0 -overstrike 0" self.axial_length = DoubleVar() self.printbed_diameter = DoubleVar() self.final_diameter = DoubleVar() self.filament_width_og = DoubleVar() self.helix_angle = DoubleVar() self.smear_factor = DoubleVar() self.flow_rate = DoubleVar() self.uv_offset = DoubleVar() self.use_strong_pattern = BooleanVar() self.axial_length.set(200.0) self.printbed_diameter.set(10.0) self.final_diameter.set(15.0) self.filament_width_og.set(0.41) self.helix_angle.set(45.0) self.smear_factor.set(100.0) self.flow_rate.set(0.0015) self.uv_offset.set(32.5) self.use_strong_pattern.set(True) top.geometry("700x550") top.title("SkelePrint Tool Path Generator") top.configure(background="#e6e6e6") top.configure(highlightbackground="#e6e6e6") top.configure(highlightcolor="black") self.Label7 = Label(top) self.Label7.grid(row=0, column=0, sticky=W) self.Label7.configure(background="#e6e6e6") self.Label7.configure(font=font11) self.Label7.configure(foreground="#000000") self.Label7.configure(text='''SkelePrint Tool Path Generator''') self.Labelframe1 = LabelFrame(top) self.Labelframe1.grid(row=1, column=0, sticky=N+S) self.Labelframe1.configure(relief=GROOVE) self.Labelframe1.configure(foreground="black") self.Labelframe1.configure(text='''Dimensions''') self.Labelframe1.configure(background="#e6e6e6") self.Labelframe1.configure(highlightbackground="#e6e6e6") self.Labelframe1.configure(highlightcolor="black") self.axial_length_entry = Entry(self.Labelframe1) self.axial_length_entry.grid(row=0, column=1) self.axial_length_entry.configure(background="white") self.axial_length_entry.configure(font="TkFixedFont") self.axial_length_entry.configure(foreground="#000000") self.axial_length_entry.configure(highlightbackground="#e6e6e6") self.axial_length_entry.configure(highlightcolor="black") self.axial_length_entry.configure(insertbackground="black") self.axial_length_entry.configure(selectbackground="#c4c4c4") self.axial_length_entry.configure(selectforeground="black") self.axial_length_entry.configure(textvariable=self.axial_length) self.Label1 = Label(self.Labelframe1) self.Label1.grid(row=0, column=0, sticky=E) self.Label1.configure(activebackground="#e6e6e6") self.Label1.configure(activeforeground="black") self.Label1.configure(background="#e6e6e6") self.Label1.configure(foreground="#000000") self.Label1.configure(highlightbackground="#e6e6e6") self.Label1.configure(highlightcolor="black") self.Label1.configure(text='''Axial Length''') self.Label2 = Label(self.Labelframe1) self.Label2.grid(row=0, column=2, sticky=W) self.Label2.configure(activebackground="#e6e6e6") self.Label2.configure(activeforeground="black") self.Label2.configure(background="#e6e6e6") self.Label2.configure(disabledforeground="#e6e6e6") self.Label2.configure(foreground="#000000") self.Label2.configure(highlightbackground="#e6e6e6") self.Label2.configure(highlightcolor="black") self.Label2.configure(text='''mm''') self.Label3 = Label(self.Labelframe1) self.Label3.grid(row=1, column=0, sticky=E) self.Label3.configure(activebackground="#e6e6e6") self.Label3.configure(activeforeground="black") self.Label3.configure(background="#e6e6e6") self.Label3.configure(foreground="#000000") self.Label3.configure(highlightbackground="#e6e6e6") self.Label3.configure(highlightcolor="black") self.Label3.configure(text='''Printbed Diameter''') self.Entry2 = Entry(self.Labelframe1) self.Entry2.grid(row=1, column=1) self.Entry2.configure(background="white") self.Entry2.configure(font="TkFixedFont") self.Entry2.configure(foreground="#000000") self.Entry2.configure(highlightbackground="#e6e6e6") self.Entry2.configure(highlightcolor="black") self.Entry2.configure(insertbackground="black") self.Entry2.configure(selectbackground="#c4c4c4") self.Entry2.configure(selectforeground="black") self.Entry2.configure(textvariable=self.printbed_diameter) self.Label4 = Label(self.Labelframe1) self.Label4.grid(row=1, column=2, sticky=W) self.Label4.configure(activebackground="#e6e6e6") self.Label4.configure(activeforeground="black") self.Label4.configure(background="#e6e6e6") self.Label4.configure(foreground="#000000") self.Label4.configure(highlightbackground="#e6e6e6") self.Label4.configure(highlightcolor="black") self.Label4.configure(text='''mm''') self.Label5 = Label(self.Labelframe1) self.Label5.grid(row=2, column=0, sticky=E) self.Label5.configure(activebackground="#e6e6e6") self.Label5.configure(activeforeground="black") self.Label5.configure(background="#e6e6e6") self.Label5.configure(foreground="#000000") self.Label5.configure(highlightbackground="#e6e6e6") self.Label5.configure(highlightcolor="black") self.Label5.configure(text='''Final Print Diameter''') self.final_diameter_entry = Entry(self.Labelframe1) self.final_diameter_entry.grid(row=2, column=1) self.final_diameter_entry.configure(background="white") self.final_diameter_entry.configure(font="TkFixedFont") self.final_diameter_entry.configure(foreground="#000000") self.final_diameter_entry.configure(highlightbackground="#e6e6e6") self.final_diameter_entry.configure(highlightcolor="black") self.final_diameter_entry.configure(insertbackground="black") self.final_diameter_entry.configure(selectbackground="#c4c4c4") self.final_diameter_entry.configure(selectforeground="black") self.final_diameter_entry.configure(textvariable=self.final_diameter) self.Label6 = Label(self.Labelframe1) self.Label6.grid(row=2, column=2, sticky=W) self.Label6.configure(activebackground="#e6e6e6") self.Label6.configure(activeforeground="black") self.Label6.configure(background="#e6e6e6") self.Label6.configure(foreground="#000000") self.Label6.configure(highlightbackground="#e6e6e6") self.Label6.configure(highlightcolor="black") self.Label6.configure(text='''mm''') self.Entry4 = Entry(self.Labelframe1) self.Entry4.grid(row=3, column=1) self.Entry4.configure(background="white") self.Entry4.configure(font="TkFixedFont") self.Entry4.configure(foreground="#000000") self.Entry4.configure(highlightbackground="#e6e6e6") self.Entry4.configure(highlightcolor="black") self.Entry4.configure(insertbackground="black") self.Entry4.configure(selectbackground="#c4c4c4") self.Entry4.configure(selectforeground="black") self.Entry4.configure(textvariable=self.filament_width_og) self.Label7 = Label(self.Labelframe1) self.Label7.grid(row=3, column=2, sticky=W) self.Label7.configure(activebackground="#e6e6e6") self.Label7.configure(activeforeground="black") self.Label7.configure(background="#e6e6e6") self.Label7.configure(foreground="#000000") self.Label7.configure(highlightbackground="#e6e6e6") self.Label7.configure(highlightcolor="black") self.Label7.configure(text='''mm''') self.Label8 = Label(self.Labelframe1) self.Label8.grid(row=3, column=0, sticky=E) self.Label8.configure(activebackground="#e6e6e6") self.Label8.configure(activeforeground="black") self.Label8.configure(background="#e6e6e6") self.Label8.configure(foreground="#000000") self.Label8.configure(highlightbackground="#e6e6e6") self.Label8.configure(highlightcolor="black") self.Label8.configure(text='''Filament Width''') self.tip = Label(self.Labelframe1, width=300, height=300) __location__ = os.path.realpath( os.path.join(os.getcwd(), os.path.dirname(__file__))) img = Image.open(os.path.join(__location__, 'dimensions.png')) one = ImageTk.PhotoImage(img) self.tip = Label(self.Labelframe1, image=one) self.tip.image = one self.tip.configure(background="#e6e6e6") self.tip.grid(row=4, columnspan=3) self.Labelframe2 = LabelFrame(top) self.Labelframe2.grid(row=1, column=1, sticky=N+S) self.Labelframe2.configure(relief=GROOVE) self.Labelframe2.configure(foreground="black") self.Labelframe2.configure(text='''Print Properties''') self.Labelframe2.configure(background="#e6e6e6") self.Labelframe2.configure(highlightbackground="#e6e6e6") self.Labelframe2.configure(highlightcolor="black") self.Label9 = Label(self.Labelframe2) self.Label9.grid(row=0, column=0, sticky=E) self.Label9.configure(activebackground="#e6e6e6") self.Label9.configure(activeforeground="black") self.Label9.configure(background="#e6e6e6") self.Label9.configure(foreground="#000000") self.Label9.configure(highlightbackground="#e6e6e6") self.Label9.configure(highlightcolor="black") self.Label9.configure(text='''Helix Angle''') self.Entry5 = Entry(self.Labelframe2) self.Entry5.grid(row=0, column=1) self.Entry5.configure(background="white") self.Entry5.configure(font="TkFixedFont") self.Entry5.configure(foreground="#000000") self.Entry5.configure(highlightbackground="#e6e6e6") self.Entry5.configure(highlightcolor="black") self.Entry5.configure(insertbackground="black") self.Entry5.configure(selectbackground="#c4c4c4") self.Entry5.configure(selectforeground="black") self.Entry5.configure(textvariable=self.helix_angle) self.Label10 = Label(self.Labelframe2) self.Label10.grid(row=0, column=2, sticky=W) self.Label10.configure(activebackground="#e6e6e6") self.Label10.configure(activeforeground="black") self.Label10.configure(background="#e6e6e6") self.Label10.configure(foreground="#000000") self.Label10.configure(highlightbackground="#e6e6e6") self.Label10.configure(highlightcolor="black") self.Label10.configure(text='''degrees [0 - 90]''') self.strong_targeter_button = Radiobutton(self.Labelframe2) self.strong_targeter_button.grid(row=1, column=0, sticky=E) self.strong_targeter_button.configure(variable=self.use_strong_pattern) self.strong_targeter_button.configure(value=True) self.strong_targeter_button.configure(activebackground="#e6e6e6") self.strong_targeter_button.configure(activeforeground="black") self.strong_targeter_button.configure(background="#e6e6e6") self.strong_targeter_button.configure(foreground="#000000") self.strong_targeter_button.configure(highlightbackground="#e6e6e6") self.strong_targeter_button.configure(highlightcolor="black") self.strong_targeter_label = Label(self.Labelframe2) self.strong_targeter_label.grid(row=1, column=1, sticky=W) self.strong_targeter_label.configure(activebackground="#e6e6e6") self.strong_targeter_label.configure(activeforeground="black") self.strong_targeter_label.configure(background="#e6e6e6") self.strong_targeter_label.configure(foreground="#000000") self.strong_targeter_label.configure(highlightbackground="#e6e6e6") self.strong_targeter_label.configure(highlightcolor="black") self.strong_targeter_label.configure(text="Strong angle pattern") self.default_targeter_button = Radiobutton(self.Labelframe2) self.default_targeter_button.grid(row=2, column=0, sticky=E) self.default_targeter_button.configure(activebackground="#e6e6e6") self.default_targeter_button.configure(activeforeground="black") self.default_targeter_button.configure(background="#e6e6e6") self.default_targeter_button.configure(foreground="#000000") self.default_targeter_button.configure(highlightbackground="#e6e6e6") self.default_targeter_button.configure(highlightcolor="black") self.default_targeter_button.configure( variable=self.use_strong_pattern) self.default_targeter_button.configure(value=False) self.default_targeter_label = Label(self.Labelframe2) self.default_targeter_label.grid(row=2, column=1, sticky=W) self.default_targeter_label.configure(activebackground="#e6e6e6") self.default_targeter_label.configure(activeforeground="black") self.default_targeter_label.configure(background="#e6e6e6") self.default_targeter_label.configure(foreground="#000000") self.default_targeter_label.configure(highlightbackground="#e6e6e6") self.default_targeter_label.configure(highlightcolor="black") self.default_targeter_label.configure(text="Default angle pattern") self.Scale1 = Scale(self.Labelframe2) self.Scale1.grid(row=5, column=1, columnspan=2, sticky=S+W) self.Scale1.configure(activebackground="#e6e6e6") self.Scale1.configure(background="#e6e6e6") self.Scale1.configure(font="TkTextFont") self.Scale1.configure(foreground="#000000") self.Scale1.configure(from_="5.0") self.Scale1.configure(highlightbackground="#d9d9d9") self.Scale1.configure(highlightcolor="black") self.Scale1.configure(length="150") self.Scale1.configure(orient="horizontal") self.Scale1.configure(resolution="5.0") self.Scale1.configure(troughcolor="#d9d9d9") self.Scale1.configure(variable=self.smear_factor) self.Label8 = Label(self.Labelframe2) self.Label8.grid(row=3, column=0, sticky=E) self.Label8.configure(background="#e6e6e6") self.Label8.configure(foreground="#000000") self.Label8.configure(text='''Flow rate''') self.Entry6 = Entry(self.Labelframe2) self.Entry6.grid(row=3, column=1) self.Entry6.configure(background="white") self.Entry6.configure(font="TkFixedFont") self.Entry6.configure(foreground="#000000") self.Entry6.configure(highlightbackground="#e6e6e6") self.Entry6.configure(highlightcolor="black") self.Entry6.configure(insertbackground="black") self.Entry6.configure(selectbackground="#c4c4c4") self.Entry6.configure(selectforeground="black") self.Entry6.configure(textvariable=self.flow_rate) self.Label12 = Label(self.Labelframe2) self.Label12.grid(row=3, column=2, sticky=W) self.Label12.configure(activebackground="#e6e6e6") self.Label12.configure(activeforeground="black") self.Label12.configure(background="#e6e6e6") self.Label12.configure(foreground="#000000") self.Label12.configure(highlightbackground="#d9d9d9") self.Label12.configure(highlightcolor="black") self.Label12.configure(text='''cm^3 / s''') self.uv_label = Label(self.Labelframe2) self.uv_label.grid(row=4, column=0, sticky=E) self.uv_label.configure(activebackground="#e6e6e6") self.uv_label.configure(activeforeground="black") self.uv_label.configure(background="#e6e6e6") self.uv_label.configure(foreground="#000000") self.uv_label.configure(highlightbackground="#d9d9d9") self.uv_label.configure(highlightcolor="black") self.uv_label.configure(text="UV Distance") self.uv_entry = Entry(self.Labelframe2) self.uv_entry.grid(row=4, column=1) self.uv_entry.configure(background="white") self.uv_entry.configure(font="TkFixedFont") self.uv_entry.configure(foreground="#000000") self.uv_entry.configure(highlightbackground="#e6e6e6") self.uv_entry.configure(highlightcolor="black") self.uv_entry.configure(insertbackground="black") self.uv_entry.configure(selectbackground="#c4c4c4") self.uv_entry.configure(selectforeground="black") self.uv_entry.configure(textvariable=self.uv_offset) self.uv_label_2 = Label(self.Labelframe2) self.uv_label_2.grid(row=4, column=2, sticky=W) self.uv_label_2.configure(activebackground="#e6e6e6") self.uv_label_2.configure(activeforeground="black") self.uv_label_2.configure(background="#e6e6e6") self.uv_label_2.configure(foreground="#000000") self.uv_label_2.configure(highlightbackground="#d9d9d9") self.uv_label_2.configure(highlightcolor="black") self.uv_label_2.configure(text='''mm''') self.Label11 = Label(self.Labelframe2) self.Label11.grid(row=5, column=0, sticky=S+E) self.Label11.configure(activebackground="#e6e6e6") self.Label11.configure(activeforeground="black") self.Label11.configure(background="#e6e6e6") self.Label11.configure(foreground="#000000") self.Label11.configure(highlightbackground="#d9d9d9") self.Label11.configure(highlightcolor="black") self.Label11.configure(text='''Layer Height %''') self.Label13 = Label(self.Labelframe2) self.Label13.grid(row=6, columnspan=3) self.Label13.configure(activebackground="#f9f9f9") self.Label13.configure(activeforeground="black") self.Label13.configure(background="#e6e6e6") self.Label13.configure(foreground="#000000") self.Label13.configure(highlightbackground="#d9d9d9") self.Label13.configure(highlightcolor="black") self.Label13.configure(text='''caution: layer height % is experimental default = 100% (ie. layer height = filament width)''') self.Message1 = Message(self.Labelframe2) self.Message1.grid(row=8, columnspan=3) self.Message1.configure(anchor=N) self.Message1.configure(background="#e6e6e6") self.Message1.configure(foreground="#000000") self.Message1.configure(highlightbackground="#e6e6e6") self.Message1.configure(highlightcolor="black") self.Message1.configure(text='''Helix Angle Conditions: If the angle is > 90, it will be set to 90 degrees If angle is < 0, it will be set to 0 degrees If angle = 0, the layer will consist of a single helix printed as close \ together as possible If angle = 90, the layer will consist of many straight lines''') self.tip2 = Label(self.Labelframe2, width=300, height=91) img2 = Image.open(os.path.join(__location__, 'theta.jpg')) two = ImageTk.PhotoImage(img2) self.tip2 = Label(self.Labelframe2, image=two) self.tip2.image = two self.tip2.configure(background="#e6e6e6") self.tip2.grid(row=7, columnspan=3) self.Label8 = Label(top) self.Label8.grid(row=5, columnspan=2) self.Label8.configure(background="#e6e6e6") self.Label8.configure(foreground="#000000") self.Label8.configure(text='''G Code file will be saved on your Desktop under: "gcode/timestamp_skeleprint_gcode.gcode"''') self.Button1 = Button(top) self.Button1.grid(row=2, columnspan=2) self.Button1.configure(activebackground="#e6e6e6") self.Button1.configure(activeforeground="#e6e6e6") self.Button1.configure(background="#e6e6e6") self.Button1.configure(command=lambda: tpg_gui_support.tpg( self.axial_length.get(), self.filament_width_og.get(), self.printbed_diameter.get(), self.final_diameter.get(), self.helix_angle.get(), self.smear_factor.get(), self.flow_rate.get(), self.uv_offset.get(), self.use_strong_pattern.get())) self.Button1.configure(foreground="#000000") self.Button1.configure(highlightbackground="#e6e6e6") self.Button1.configure(highlightcolor="black") self.Button1.configure(relief=RAISED) self.Button1.configure(text='''Generate G Code''') self.menubar = Menu(top, font="TkMenuFont", bg=_bgcolor, fg=_fgcolor) top.configure(menu=self.menubar)