def _add_count(self, frame, index, name, default, option) : self.function[-1] = lambda v : [option]*int(v) self.variables[-1] = StringVar() self.variables[-1].set(default) label = Label(frame, text=name) label.grid(row=index, column=0, sticky='W', padx=10) field = Spinbox(frame, from_=0, to=100, textvariable=self.variables[-1]) field.grid(row=index, column=1, sticky='WE')
class LabeledSpin(Frame): def __init__(self, **kwargs): master = None if 'master' not in kwargs else kwargs['master'] title = '' if 'title' not in kwargs else kwargs['title'] Frame.__init__(self, master) self.val = IntVar() self.lbl = Label(text=title) self.lbl.grid(row=0, column=0, sticky=W, in_=self) self.Spin = Spinbox(textvariable=self.val) self.Spin.grid(row=0, column=1, sticky=W, in_=self)
def initUI(self): # Main Window self.parent.title("gBot") self.style = Style() self.style.theme_use("default") self.pack(fill=BOTH, expand=1) # Debug Window Toplevel1 = Toplevel(self) Toplevel1.title("gBot Debug Console") self.pack(fill=BOTH, expand=1) TL_T1 = Text(Toplevel1, width=50) TL_T1.pack() Toplevel1.state("withdrawn") Toplevel1.protocol('WM_DELETE_WINDOW', lambda:Toplevel1.state("withdrawn")) Toplevel1.attributes("-topmost", True) # Username Input L1 = Label(self, text="G+ User Name") L1.grid(row=0, column=0, sticky=E, ipady=1) E1 = Entry(self, width=30) E1.grid(row=0, column=1, ipady=1, sticky=E) # Password Input L2 = Label(self, text="G+ Password") L2.grid(row=1, column=0, sticky=E, ipady=1) E2 = Entry(self, width=30) E2.grid(row=1, column=1, ipady=1, sticky=E) # Output Path Input L3 = Label(self, text="Output Path") L3.grid(row=2, column=0, sticky=E, pady=1) E3 = Entry(self, width=30) E3.grid(row=2, column=1, ipady=1, sticky=E) E3.insert(0, "%s\links.txt" % (os.getcwd())) # Num Posts L4 = Label(self, text="# Of Posts") L4.grid(row=3, column=0, sticky=E, pady=1) S1 = Spinbox(self, from_=1, to=9999999, width=28) S1.grid(row=3, column=1, ipady=1, sticky=E) # Post Input T1 = Text(self, width=30) T1.grid(row=5, columnspan=2, sticky=W+E, pady=1) # Start button B1 = Button(self, text="Start Posting", command=lambda:self.doPosting(B1,TL_T1,E1.get(),E2.get(),T1.get(1.0,END),E3.get(),S1.get())) B1.grid(row=6,columnspan=2, sticky=W+E) # Debug button B2 = Button(self, text="Debug log", command=lambda:Toplevel1.state("normal")) B2.grid(row=7, columnspan=2, sticky=W+E) self.addDebug(TL_T1,"Started successfully")
class YearSelector(): def __init__(self, parent=None, text='Year:', min_value=1950, max_value=2100, **kwargs): # NOTE: This class used to be a subclass of Frame, but it did not grid properly #Frame.__init__(self, parent) self.label = Label(parent, text=text) self.year = StringVar() self.year_selector = Spinbox(parent, from_=min_value, to=max_value, textvariable=self.year, command=self.on_change, width=5) self.set_args() def set_args(self, **kwargs): self.check_other_func = kwargs['check_other_func'] if 'check_other_func' in kwargs else None def get_value(self): value = int(self.year.get()) return value def set_value(self, value): self.year.set(value) def set_grid(self, row=0, padx=0, pady=0): #self.grid(row=row) self.label.grid(row=row, column=0, sticky='e') self.year_selector.grid(row=row, column=1, padx=padx, pady=pady, sticky='w') def on_change(self): if self.check_other_func != None: value = int(self.year.get()) new_value = self.check_other_func(value) if value != new_value: self.set_value(new_value) else: pass def get_less_than(self, compare_value): value = int(self.year.get()) compare_value = int(compare_value) if value <= compare_value: return value return compare_value def get_greater_than(self, compare_value): value = int(self.year.get()) compare_value = int(compare_value) if value >= compare_value: return value return compare_value
class RelyGUI(object): """ GUI for driving storage reliability simulations """ # # enumerated values for menus and spin boxes # disk_type = None diskTypes = [ # menu of disk drive types "Enterprise", "Consumer", "Real" ] disk_nre = None nre_rates = [ # list of likely NRE rates ... correspond to above "1.0E-19", "1.0E-18", "1.0E-17", "1.0E-16", "1.0E-15", "1.0E-14", "1.0E-13" ] # default FIT rates for various classes of drives fit_map = { 'Enterprise': "826", 'Consumer': "1320", 'Real': "7800" } # default NRE rates for various classes of drives nre_map = { 'Enterprise': "1.0E-16", 'Consumer': "1.0E-15", 'Real': "1.0E-14" } raid_type = None raidTypes = [ # menu of RAID types "RAID-0", "RAID-1", "RAID-5", "RAID-6" ] raid_vols = None # default volume counts for various RAID configurations vol_map = { 'RAID-0': 1, 'RAID-1': 2, 'RAID-5': 3, 'RAID-6': 6, } nre_model = None nreTypes = [ # ways of modeling NREs "ignore", "error", "fail", "error+fail/2" ] raid_rplc = None replace_times = [ # list of likely drive replacement times (hours) 0, 1, 2, 4, 6, 8, 10, 12, 18, 24 ] rados_down = None markout_times = [ # list of likely OSD mark-down times (minutes) 0, 1, 2, 3, 4, 5, 10, 15, 20, 30, 45, 60 ] raid_speed = None rados_speed = None rebuild_speeds = [ # list of likely rebuild speeds (MB/s) 1, 2, 5, 10, 15, 20, 25, 40, 50, 60, 80, 100, 120, 140, 160 ] remote_latency = None async_latencies = [ # list of likely asynchronous replication latencies 0, 1, 5, 10, 30, 60, 300, 600, 900, 1800, 3600, 2 * 3600, 6 * 3600, 12 * 3600, 18 * 3600, 24 * 3600 ] rados_fullness = None fullness = [ # list of likely volume fullness percentages 50, 75, 80, 85, 90, 95, 100 ] site_num = None site_count = [ # list of likely remote site numbers 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] remote_speed = None remote_speeds = [ # list of likely remote recovery speeds (MB/s) 1, 2, 5, 10, 20, 25, 40, 50, 60, 80, 100, 150, 200, 300, 400, 500, 600, 800, 1000 ] remote_fail = None site_destroy = [ # force majeure event frequency 10, 100, 1000, 10000, 100000, "never" ] remote_rplc = None site_recover = [ # number of days to recover a destroyed facility 1, 2, 4, 8, 12, 16, 20, 30, 40, 50, 60, 80, 100, 150, 200, 250, 300, 365, "never" ] verbosities = [ # display verbosity "all", "parameters", "headings", "data only" ] verbosity = None period = None disk_size = None rados_pgs = None rados_cpys = None stripe_length = None # these we generate dynamically obj_size = None object_sizes = [] min_obj_size = 1 * 1024 * 1024 max_obj_size = 1 * 1024 * 1024 * 1024 * 1024 step_obj_size = 4 # GUI widget field widths ROWS = 20 BORDER = 5 short_wid = 2 med_wid = 4 long_wid = 6 short_fmt = "%2d" med_fmt = "%4d" long_fmt = "%6d" # references to the input widget fields (I know ...) def do_disk(self): """ calculate disk reliability """ self.getCfgInfo() self.doit(self.cfg, "disk") def do_raid(self): """ calculate raid reliability """ self.getCfgInfo() self.doit(self.cfg, "raid") def do_rados(self): """ calculate RADOS reliability """ self.getCfgInfo() self.doit(self.cfg, "rados") def do_sites(self): """ calculate Multi-Site RADOS reliability """ self.getCfgInfo() self.doit(self.cfg, "multi") def diskchoice(self, value): """ change default FIT and NRE rates to match disk selection """ self.disk_nre.delete(0, END) self.disk_nre.insert(0, self.nre_map[value]) self.disk_fit.delete(0, END) self.disk_fit.insert(0, self.fit_map[value]) self.disk_fit2.delete(0, END) self.disk_fit2.insert(0, self.fit_map[value]) def raidchoice(self, value): """ change default # of volumes to match RAID levels """ self.raid_vols.delete(0, END) self.raid_vols.insert(0, self.vol_map[value]) def __init__(self, cfg, doit): """ create the GUI panel widgets cfg -- parameter values (input and output) doit -- method to call to run simulations """ # gather the basic parameters self.cfg = cfg self.doit = doit self.root = Tk() self.root.title('Data Reliability Model') t = Frame(self.root, bd=2 * self.BORDER) # w.iconbitmap(default='inktank.ico') # ? windows only ? # left stack (DISK) f = Frame(t, bd=self.BORDER, relief=RIDGE) r = 1 Label(f, text="Disk Type").grid(row=r) self.disk_type = StringVar(f) self.disk_type.set(self.diskTypes[0]) OptionMenu(f, self.disk_type, *self.diskTypes, command=self.diskchoice).grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 Label(f, text="Size (GiB)").grid(row=r) self.disk_size = Entry(f, width=self.long_wid) self.disk_size.delete(0, END) self.disk_size.insert(0, self.long_fmt % (cfg.disk_size / GiB)) self.disk_size.grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 Label(f, text="Primary FITs").grid(row=r) self.disk_fit = Entry(f, width=self.long_wid) self.disk_fit.grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 Label(f, text="Secondary FITs").grid(row=r) self.disk_fit2 = Entry(f, width=self.long_wid) self.disk_fit2.grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 Label(f, text="NRE rate").grid(row=r) self.disk_nre = Spinbox(f, width=self.long_wid, values=self.nre_rates) self.disk_nre.grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 while r < self.ROWS: Label(f).grid(row=r) r += 1 Button(f, text="RELIABILITY", command=self.do_disk).grid(row=r) f.grid(column=1, row=1) self.diskchoice(self.diskTypes[0]) # set default disk type # second stack (RAID) f = Frame(t, bd=self.BORDER, relief=RIDGE) r = 1 Label(f, text="RAID Type").grid(row=r) self.raid_type = StringVar(f) self.raid_type.set("RAID-1") OptionMenu(f, self.raid_type, *self.raidTypes, command=self.raidchoice).grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 Label(f, text="Replace (hours)").grid(row=r) self.raid_rplc = Spinbox(f, width=self.short_wid, values=self.replace_times) self.raid_rplc.grid(row=r + 1) self.raid_rplc.delete(0, END) self.raid_rplc.insert(0, "%d" % cfg.raid_replace) Label(f).grid(row=r + 2) r += 3 Label(f, text="Rebuild (MiB/s)").grid(row=r) self.raid_speed = Spinbox(f, width=self.med_wid, values=self.rebuild_speeds) self.raid_speed.grid(row=r + 1) self.raid_speed.delete(0, END) self.raid_speed.insert(0, "%d" % (cfg.raid_recover / MiB)) Label(f).grid(row=r + 2) r += 3 Label(f, text="Volumes").grid(row=r) self.raid_vols = Spinbox(f, from_=1, to=10, width=self.short_wid) self.raid_vols.grid(row=r + 1) Label(f).grid(row=r + 2) self.raidchoice("RAID-1") # set default number of volumes r += 3 while r < self.ROWS: Label(f).grid(row=r) r += 1 Button(f, text="RELIABILITY", command=self.do_raid).grid(row=r) f.grid(column=2, row=1) # third stack (RADOS) f = Frame(t, bd=self.BORDER, relief=RIDGE) r = 1 Label(f, text="RADOS copies").grid(row=r) self.rados_cpys = Spinbox(f, values=(1, 2, 3, 4, 5, 6), width=self.short_wid) self.rados_cpys.grid(row=r + 1) self.rados_cpys.delete(0, END) self.rados_cpys.insert(0, "%d" % cfg.rados_copies) Label(f).grid(row=r + 2) r += 3 Label(f, text="Mark-out (min)").grid(row=r) self.rados_down = Spinbox(f, values=self.markout_times, width=self.short_wid) self.rados_down.grid(row=r + 1) self.rados_down.delete(0, END) self.rados_down.insert(0, "%d" % (cfg.rados_markout * 60)) Label(f).grid(row=r + 2) r += 3 Label(f, text="Recovery (MiB/s)").grid(row=r) self.rados_speed = Spinbox(f, width=self.med_wid, values=self.rebuild_speeds) self.rados_speed.grid(row=r + 1) self.rados_speed.delete(0, END) self.rados_speed.insert(0, "%d" % (cfg.rados_recover / MiB)) Label(f).grid(row=r + 2) r += 3 Label(f, text="Space Usage (%)").grid(row=r) self.rados_fullness = Spinbox(f, values=self.fullness, width=self.med_wid) self.rados_fullness.grid(row=r + 1) self.rados_fullness.delete(0, END) self.rados_fullness.insert(0, "%d" % (cfg.rados_fullness * 100)) Label(f).grid(row=r + 2) r += 3 Label(f, text="Declustering (pg)").grid(row=r) self.rados_pgs = Entry(f, width=self.med_wid) self.rados_pgs.delete(0, END) self.rados_pgs.insert(0, self.med_fmt % cfg.rados_decluster) self.rados_pgs.grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 Label(f, text="Stripe Length").grid(row=r) self.stripe_length = Entry(f, width=self.med_wid) self.stripe_length.delete(0, END) self.stripe_length.insert(0, self.med_fmt % cfg.stripe_length) self.stripe_length.grid(row=r + 1) Label(f).grid(row=r + 2) r += 3 while r < self.ROWS: Label(f).grid(row=r) r += 1 Button(f, text="RELIABILITY", command=self.do_rados).grid(row=r) f.grid(column=3, row=1) # fourth stack (remote site) r = 1 f = Frame(t, bd=self.BORDER, relief=RIDGE) Label(f, text="RADOS Sites").grid(row=r) self.site_num = Spinbox(f, values=self.site_count, width=self.short_wid) self.site_num.grid(row=r + 1) self.site_num.delete(0, END) self.site_num.insert(0, "%d" % cfg.remote_sites) Label(f).grid(row=r + 2) r += 3 Label(f, text="Rep Latency (s)").grid(row=r) self.remote_latency = Spinbox(f, values=self.async_latencies, width=self.long_wid) self.remote_latency.grid(row=r + 1) self.remote_latency.delete(0, END) self.remote_latency.insert(0, "%d" % (cfg.remote_latency * 60 * 60)) Label(f).grid(row=r + 2) r += 3 Label(f, text="Recovery (MiB/s)").grid(row=r) self.remote_speed = Spinbox(f, values=self.remote_speeds, width=self.med_wid) self.remote_speed.grid(row=r + 1) self.remote_speed.delete(0, END) self.remote_speed.insert(0, "%d" % (cfg.remote_recover / MiB)) Label(f).grid(row=r + 2) r += 3 Label(f, text="Disaster (years)").grid(row=r) self.remote_fail = Spinbox(f, values=self.site_destroy, width=self.long_wid) self.remote_fail.grid(row=r + 1) self.remote_fail.delete(0, END) self.remote_fail.insert(0, "1000") # FIX - get this from cfg ... but translate from FITS Label(f).grid(column=2, row=r + 2) r += 3 Label(f, text="Site Recover (days)").grid(row=r) self.remote_avail = Spinbox(f, values=self.site_recover, width=self.long_wid) self.remote_avail.grid(row=r + 1) self.remote_avail.delete(0, END) self.remote_avail.insert(0, "30") # FIX - get this from cfg ... but translate from FITS Label(f).grid(row=r + 2) r += 3 while r < self.ROWS: Label(f).grid(row=r) r += 1 Button(f, text="RELIABILITY", command=self.do_sites).grid(row=r) f.grid(column=4, row=1) # and the control panel r = 2 c = 1 Label(t).grid(column=c, row=r) Label(t, text="NRE model").grid(column=c, row=r + 1) self.nre_model = StringVar(t) self.nre_model.set(self.cfg.nre_model) OptionMenu(t, self.nre_model, *self.nreTypes).grid(column=c, row=r + 2) c = 2 Label(t).grid(column=c, row=r) Label(t, text="Period (years)").grid(column=c, row=r + 1) self.period = Spinbox(t, from_=1, to=10, width=self.short_wid) self.period.grid(column=c, row=r + 2) c = 3 Label(t).grid(column=c, row=r) Label(t, text="Object size").grid(column=c, row=r + 1) # generate object sizes dynamically from parameters os = self.min_obj_size while os <= self.max_obj_size: if os < MB: s = "%dKB" % (os / KB) elif os < GB: s = "%dMB" % (os / MB) elif os < TB: s = "%dGB" % (os / GB) else: s = "%dTB" % (os / TB) self.object_sizes.append(s) os *= self.step_obj_size self.obj_size = Spinbox(t, values=self.object_sizes, width=self.long_wid) self.obj_size.grid(column=c, row=r + 2) self.obj_size.delete(0, END) self.obj_size.insert(0, self.object_sizes[0]) c = 4 Label(t).grid(column=c, row=r) Label(t, text="Verbosity").grid(column=c, row=r + 1) self.verbosity = StringVar(t) self.verbosity.set(cfg.verbose) OptionMenu(t, self.verbosity, *self.verbosities).grid(column=c, row=r + 2) # and then finalize everything t.grid() def getCfgInfo(self): """ scrape configuration information out of the widgets """ self.cfg.period = 365.25 * 24 * int(self.period.get()) self.cfg.disk_type = self.disk_type.get() self.cfg.disk_size = int(self.disk_size.get()) * GiB self.cfg.disk_nre = float(self.disk_nre.get()) self.cfg.disk_fit = int(self.disk_fit.get()) self.cfg.disk_fit2 = int(self.disk_fit2.get()) self.cfg.raid_vols = int(self.raid_vols.get()) self.cfg.raid_type = self.raid_type.get() self.cfg.raid_replace = int(self.raid_rplc.get()) self.cfg.raid_recover = int(self.raid_speed.get()) * MiB self.cfg.nre_model = self.nre_model.get() self.cfg.rados_copies = int(self.rados_cpys.get()) self.cfg.rados_markout = float(self.rados_down.get()) / 60 self.cfg.rados_recover = int(self.rados_speed.get()) * MiB self.cfg.rados_decluster = int(self.rados_pgs.get()) self.cfg.stripe_length = int(self.stripe_length.get()) self.cfg.rados_fullness = float(self.rados_fullness.get()) / 100 self.cfg.remote_latency = float(self.remote_latency.get()) / (60 * 60) self.cfg.remote_sites = int(self.site_num.get()) self.cfg.remote_recover = int(self.remote_speed.get()) * MiB self.cfg.verbose = self.verbosity.get() # these parameters can also have the value "never" v = self.remote_fail.get() self.cfg.majeure = 0 if v == "never" else \ 1000000000 / (float(self.remote_fail.get()) * 365.25 * 24) v = self.remote_avail.get() self.cfg.site_recover = 0 if v == "never" else \ float(self.remote_avail.get()) * 24 # a more complex process for the dynamically generated lists self.cfg.obj_size = self.min_obj_size i = 0 while i < len(self.object_sizes) and \ self.cfg.obj_size < self.max_obj_size: if self.obj_size.get() == self.object_sizes[i]: break self.cfg.obj_size *= self.step_obj_size i += 1 # sanity checking on arguments with limits if self.cfg.stripe_length < 1: self.cfg.stripe_length = 1 if self.cfg.stripe_length > self.cfg.rados_decluster: print("\nIGNORING stripe width (%d) > decluster (%d)\n" % (self.cfg.stripe_length, self.cfg.rados_decluster)) self.cfg.stripe_length = self.cfg.rados_decluster def mainloop(self): self.root.mainloop()
class JobParameters(Toplevel): def __init__(self, parent=None, **kwargs): Toplevel.__init__(self, parent) self.title('Job Parameters') self.parent = parent self.main_frame = Frame(self) self.input_directory_gui = DirectorySelector(self.main_frame, 'Input Directory:') self.output_directory_gui = DirectorySelector(self.main_frame, 'Output Directory:', get_default=lambda: self.input_directory_gui.get_directory() + '/output/') self.input_directory_gui.set_notify(self.notify) self.beginning_year = kwargs['beginning_year'] if 'beginning_year' in kwargs else 1950 self.ending_year = kwargs['ending_year'] if 'ending_year' in kwargs else 2100 self.beginning_year_selector = YearSelector(self.main_frame, text="Beginning Year:", min_value=self.beginning_year, max_value=self.ending_year) self.ending_year_selector = YearSelector(self.main_frame, text="Ending Year:", min_value=self.beginning_year, max_value=self.ending_year) self.one_decade_range_var = IntVar() self.one_decade_range = Checkbutton(self.main_frame, text='Calculate 10 Year Range', variable=self.one_decade_range_var, command=self.on_change) self.two_decade_range_var = IntVar() self.two_decade_range = Checkbutton(self.main_frame, text='Calculate 20 Year Range', variable=self.two_decade_range_var, command=self.on_change) self.custom_range_var = IntVar() self.custom_range = Checkbutton(self.main_frame, text='Calculate Custom Year Range', variable=self.custom_range_var, command=self.on_change) self.custom_range_val = StringVar() self.custom_range_input = Spinbox(self.main_frame, from_=30, to=100, textvariable=self.custom_range_val, command=self.on_change, width=5) # Initialize widget values self.beginning_year_selector.set_value(self.beginning_year) self.beginning_year_selector.set_args(check_other_func=self.ending_year_selector.get_less_than) self.ending_year_selector.set_value(self.ending_year) self.ending_year_selector.set_args(check_other_func=self.beginning_year_selector.get_greater_than) self.one_decade_range_var.set(1) self.two_decade_range_var.set(1) self.custom_range_var.set(0) self.custom_range_input.config(state=Tkinter.DISABLED) self.button_frame = Frame(self.main_frame) self.ok_button = Button(self.button_frame, text='OK', command=self.on_submit) self.cancel_button = Button(self.button_frame, text='Cancel', command=self.on_close) self.job_id = kwargs['job_id'] if 'job_id' in kwargs else None self.entry = kwargs['entry'] if 'entry' in kwargs else None self.grab_set() self.resizable(width=False, height=False) def notify(self): self.output_directory_gui.notify() self.lift() def set_grid(self): # Layout child widgets self.main_frame.grid() self.input_directory_gui.set_grid(row=0, padx=6) self.output_directory_gui.set_grid(row=1, padx=6) self.beginning_year_selector.set_grid(row=2, padx=6) self.ending_year_selector.set_grid(row=3, padx=6) self.one_decade_range.grid(row=4, column=1, sticky='w', padx=6) self.two_decade_range.grid(row=5, column=1, sticky='w', padx=6) self.custom_range.grid(row=6, column=1, sticky='w', padx=6) self.custom_range_input.grid(row=6, column=2, sticky='w', padx=6) self.button_frame.grid(row=7, columnspan=3, sticky='nsew') self.ok_button.pack(side=Tkinter.RIGHT) self.cancel_button.pack(side=Tkinter.RIGHT) #self.ok_button.grid(row=7, column=1, pady=2) #self.cancel_button.grid(row=7, column=2, pady=2) def on_change(self): is_custom_range_checked = self.custom_range_var.get() == 1 if is_custom_range_checked: self.custom_range_input.config(state=Tkinter.NORMAL) else: self.custom_range_input.config(state=Tkinter.DISABLED) def on_submit(self): if self.input_directory_gui.get_directory() == '' or self.output_directory_gui.get_directory() == '': self.on_close() return # The job parameters are extracted from the GUI here and passed to the processing thread to run the requisite job. job = dict() job['job_id'] = self.job_id job['delimiter'] = '.' job['individual_files'] = False job['input_directory'] = self.input_directory_gui.get_directory() job['output_directory'] = self.output_directory_gui.get_directory() job['start'] = self.beginning_year_selector.get_value() job['end'] = self.ending_year_selector.get_value() job['calculate_one_decade'] = self.one_decade_range_var.get() == 1 job['calculate_two_decade'] = self.two_decade_range_var.get() == 1 job['calculate_custom_range'] = self.custom_range_var.get() == 1 job['custom_range'] = int(self.custom_range_val.get()) job['log'] = True if self.entry != None: self.entry.add_job(job) self.on_close() def on_close(self): if self.parent != None: self.parent.focus_set() self.withdraw() self.destroy() def on_focus(self): self.focus_force()
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)
class MoveControl(LabelFrame): def __init__(self, root, prtr, settings, log, *arg): fn = os.path.join(settings.cmdFolder, "images", "control_xyz.png") self.image = Image.open(fn) self.photo = ImageTk.PhotoImage(self.image) LabelFrame.__init__(self, root, *arg, text="Movement") self.app = root self.hilite = None self.hilitemask = None self.settings = settings self.printer = prtr self.log = log l = Label(self, text="mm/min") l.grid(row=1, column=2) l = Label(self, text="X/Y Feed Rate:") l.grid(row=2, column=1, sticky=E) self.xyfeed = Spinbox(self, width=10, justify=RIGHT, from_=0, to=MAXFEED) self.xyfeed.grid(row=2, column=2) self.xyfeed.delete(0, END) self.xyfeed.insert(0, settings.xyfeed) self.xyfeed.bind("<FocusOut>", self.valxyFeed) self.xyfeed.bind("<Leave>", self.valxyFeed) l = Label(self, text="Z Feed Rate:") l.grid(row=3, column=1, sticky=E) self.zfeed = Spinbox(self, width=10, justify=RIGHT, from_=0, to=MAXFEED) self.zfeed.grid(row=3, column=2) self.zfeed.delete(0, END) self.zfeed.insert(0, settings.zfeed) self.zfeed.bind("<FocusOut>", self.valzFeed) self.zfeed.bind("<Leave>", self.valzFeed) self.canvas = Canvas(self, width=self.image.size[0], height=self.image.size[1], *arg) self.canvas.create_image((0, 0), image=self.photo, anchor=N+W) self.canvas.grid(row=4, column=1, columnspan=2) for m in imageMasks: self.canvas.create_oval((m[0][0]-mask_rad, m[0][1]-mask_rad, m[0][0]+mask_rad, m[0][1]+mask_rad), outline="#FF0000", width=4, tags=m[1], state=HIDDEN) self.canvas.bind("<Button-1>", self.OnLeftDown) self.canvas.bind("<Motion>", self.OnMotion) self.canvas.bind("<Enter>", self.OnEnter) self.canvas.bind("<Leave>", self.OnLeave) self.bAllOff = Button(self, text="Release Motors", command=self.allMotorsOff) self.bAllOff.grid(row=5, column=1, columnspan=2) def valxyFeed(self, *arg): x = self.validFeed(self.xyfeed.get(), 'XY') if x == None: self.xyfeed.delete(0, END) self.xyfeed.insert(0, "%d" % self.settings.xyfeed) return True if self.settings.xyfeed != x: self.settings.xyfeed = x self.settings.setModified() return True def valzFeed(self, *arg): x = self.validFeed(self.zfeed.get(), 'Z') if x == None: self.zfeed.delete(0, END) self.zfeed.insert(0, "%d" % self.settings.zfeed) return True if self.settings.zfeed != x: self.settings.zfeed = x self.settings.setModified() return True def validFeed(self, fv, axis): try: x = int(fv) except: self.log.logMsg("Value for %s feed rate not a valid integer" % axis) return None if x <=0 or x >MAXFEED: self.log.logMsg("Value for %s feed rate out of range(0-5000)" % axis) return None return x def allMotorsOff(self): if self.app.printerAvailable(cmd="M84"): self.printer.send_now("M84") def OnMotion(self, e): for i in range(len(imageGeometry)): if boundBy((e.x, e.y), imageGeometry[i][0]): self.setHilite(i) return if self.hilite != None: self.clearHilite() def OnEnter(self, e): self.clearHilite() def OnLeave(self, e): self.clearHilite() def setHilite(self, i): if i != self.hilite: self.canvas.delete("HILITE") self.canvas.create_rectangle(imageGeometry[i][0], outline="#C85E5D", width=3, fill="gray", stipple="gray50", tags="HILITE") self.hilite = i if self.hilitemask: self.canvas.itemconfig(self.hilitemask, state=HIDDEN) if imageGeometry[i][2]: self.hilitemask = imageGeometry[i][2] self.canvas.itemconfig(self.hilitemask, state=NORMAL) def clearHilite(self): self.canvas.delete("HILITE") self.hilite = None self.hilitemask = None for m in imageMasks: self.canvas.itemconfig(m[1], state=HIDDEN) def OnLeftDown(self, e): if self.app.printerAvailable(cmd="G1"): for g in imageGeometry: if boundBy((e.x, e.y), g[0]): if "G1" in g[1]: if "X" in g[1]: feed = self.settings.xyfeed elif "Y" in g[1]: feed = self.settings.xyfeed elif "Z" in g[1]: feed = self.settings.zfeed else: feed = 100 self.printer.send_now("G91") self.printer.send_now(g[1] + " F" + str(feed)) self.printer.send_now("G90") else: self.printer.send_now(g[1]) break
class pump_ui(object): def __init__(self): master = Tk() master.style = ttk.Style() master.style.theme_use("default") master.config(bg=background_colour) master.resizable( 0, 0 ) # Disable resizing the UI to prevent having to make widget placing dynamic master.winfo_toplevel().title(frame_title) master.iconbitmap("bitcoin.ico") # Create pumper assistant to store data on the current BTC and alt holdings. self.pumper = pumper() self.create_title(master) self.create_api_info(master, previous_row=0) self.create_auto_sell(master, previous_row=3) self.create_stop_loss(master, previous_row=4) self.create_order_type(master, previous_row=6) self.create_fee_type(master, previous_row=7) self.create_btc_balance_picker(master, previous_row=8) self.create_alt_ticker(master, previous_row=10) self.create_pump_and_sell_buttons(master, previous_row=11) self.create_current_profit(master, previous_row=12) self.create_output_box(master, rightmost_column=1) # Can hardcode API key and Secret #self.api_key_entry.delete(0,END) #self.api_key_entry.insert(0,"KEY") #self.api_key_entry.config(state=DISABLED) #self.api_secret_entry.delete(0, END) #self.api_secret_entry.insert(0, "SECRET") #self.api_secret_entry.config(state=DISABLED) # Display the UI, this can only be called once per program. # Nothing in the main Python script will be run after creating the UI because of this. master.mainloop() def create_title(self, master, previous_row=-1, previous_column=-1): empty = Label(master, text=frame_title) empty.grid(row=previous_row + 1, column=previous_column + 2, columnspan=1) empty.config(bg=background_colour, fg=label_font_colour) def create_api_info(self, master, previous_row=-1, previous_column=-1): api_key_lbl = Label(master, text="API Key:") api_key_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) api_key_lbl.config(bg=background_colour, fg=label_font_colour) self.api_key_entry = Entry(master, highlightthickness=0, bd=0, width=21, show="*") self.api_key_entry.config(borderwidth=2, relief=default_relief) self.api_key_entry.grid(row=previous_row + 1, column=previous_column + 2) api_secret_lbl = Label(master, text="API Secret:") api_secret_lbl.grid(row=previous_row + 2, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) api_secret_lbl.config(bg=background_colour, fg=label_font_colour) self.api_secret_entry = Entry(master, highlightthickness=0, bd=0, width=21, show="*") self.api_secret_entry.config(borderwidth=2, relief=default_relief) self.api_secret_entry.grid(row=previous_row + 2, column=previous_column + 2) self.api_connect_btn = Button(master, text="Connect To Binance", command=self.on_connect_api) self.api_connect_btn.grid(row=previous_row + 3, column=previous_column + 2, columnspan=1, sticky=W + E, padx=10, pady=(0, 3)) self.api_connect_btn.config(highlightbackground=background_colour) def create_auto_sell(self, master, previous_row=-1, previous_column=-1): auto_sell_lbl = Label(master, text="Auto Sell (%):") auto_sell_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) auto_sell_lbl.config(bg=background_colour, fg=label_font_colour) self.auto_sell_spinbox = Spinbox(master, from_=1.0, to=300.0, increment=1.0, highlightbackground=background_colour) self.auto_sell_spinbox.config(borderwidth=2, relief=default_relief) self.auto_sell_spinbox.grid(row=previous_row + 1, column=previous_column + 2) self.auto_sell_spinbox.delete(0, "end") self.auto_sell_spinbox.insert(0, 50) def create_stop_loss(self, master, previous_row=-1, previous_column=-1): stop_loss_lbl = Label(master, text="Stop Loss (%):") stop_loss_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0)) stop_loss_lbl.config(bg=background_colour, fg=label_font_colour) self.stop_loss_spinbox = Spinbox(master, from_=-100.0, to=-10.0, increment=1.0, highlightbackground=background_colour) self.stop_loss_spinbox.config(borderwidth=2, relief=default_relief) self.stop_loss_spinbox.grid(row=previous_row + 1, column=previous_column + 2) self.stop_loss_spinbox.delete(0, "end") self.stop_loss_spinbox.insert(0, -10) def create_btc_balance_picker(self, master, previous_row=-1, previous_column=-1): self.btc_balance_str = StringVar() btc_balance_lbl = Label(master, textvar=self.btc_balance_str) btc_balance_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=2, sticky=W + E, padx=(3, 0)) btc_balance_lbl.config(bg=background_colour, fg=label_font_colour) self.set_available_btc_balance(Decimal(0)) btc_to_use_label = Label(master, text="BTC to spend:", bg=background_colour, fg=label_font_colour) btc_to_use_label.grid(row=previous_row + 2, column=previous_column + 1, sticky=E, padx=(3, 0)) self.btc_to_use_spinbox = Spinbox( master, from_=minimum_trade, to=minimum_trade, increment=btc_to_use_increment, highlightbackground=background_colour) self.btc_to_use_spinbox.config(borderwidth=2, relief=default_relief) self.btc_to_use_spinbox.grid(row=previous_row + 2, column=previous_column + 2) def create_order_type(self, master, previous_row=-1, previous_column=-1): order_type_lbl = Label(master, text="Entry Type:") order_type_lbl.grid(row=previous_row + 1, column=previous_column + 1, sticky=E, padx=(3, 0)) order_type_lbl.config(bg=background_colour, fg=label_font_colour) self.is_entry_market = True def change_order_type(*args): self.is_entry_market = (self.order_type.get() == "Market Buy \/") self.order_type = StringVar() self.order_type.trace( "w", change_order_type ) # Reduces how much work is done when the pump starts choices = {"Market Buy \/", "Limit Buy \/"} self.entry_type_option_menu = OptionMenu(master, self.order_type, *choices) self.entry_type_option_menu.grid(row=previous_row + 1, column=previous_column + 2, sticky=W + E, padx=8) self.entry_type_option_menu.config(highlightthickness=0) self.entry_type_option_menu.configure(indicatoron=0) self.order_type.set("Market Buy \/") def create_fee_type(self, master, previous_row=-1, previous_column=-1): fee_type_lbl = Label(master, text="Fee Type:") fee_type_lbl.grid(row=previous_row + 1, column=previous_column + 1, sticky=E, padx=(3, 0)) fee_type_lbl.config(bg=background_colour, fg=label_font_colour) self.is_using_bnb = True def change_fee_type(*args): self.is_using_bnb = ( self.order_type.get() == "Binance Coin (BNB) \/") self.fee_type = StringVar() self.fee_type.trace( "w", change_fee_type ) # Reduces how much work is done when the pump starts choices = {"Binance Coin (BNB) \/", "0.1% Of All Trades \/"} self.fee_type_option_menu = OptionMenu(master, self.fee_type, *choices) self.fee_type_option_menu.grid(row=previous_row + 1, column=previous_column + 2, sticky=W + E, padx=8) self.fee_type_option_menu.config(highlightthickness=0) self.fee_type_option_menu.configure(indicatoron=0) self.fee_type.set("Binance Coin (BNB) \/") def create_pump_and_sell_buttons(self, master, previous_row=-1, previous_column=-1): # Manual sell button can only be activated after initiating a pump. self.manual_sell_btn = Button(master, text="Sell", state=DISABLED, command=self.on_manual_sell) self.manual_sell_btn.grid(row=previous_row + 1, column=previous_column + 1, sticky=W + E, padx=(3, 0)) self.manual_sell_btn.config(highlightbackground=background_colour) self.pump_btn = Button(master, text="Pump", command=self.on_pump) self.pump_btn.grid(row=previous_row + 1, column=previous_column + 2, sticky=W + E, padx=8) self.pump_btn.config(highlightbackground=background_colour, state=DISABLED) def create_alt_ticker(self, master, previous_row=-1, previous_column=-1): ticker_lbl = Label(master, text="Ticker To Pump:") ticker_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=1, sticky=E, padx=(3, 0), pady=(0, 8)) ticker_lbl.config(bg=background_colour, fg=label_font_colour) self.ticker_entry = Entry(master, highlightthickness=0, bd=0, width=21) self.ticker_entry.config(borderwidth=2, relief=default_relief) self.ticker_entry.grid(row=previous_row + 1, column=previous_column + 2, pady=8) self.ticker_entry.bind('<Return>', self.on_pump_shortcut) def create_current_profit(self, master, previous_row=-1, previous_column=-1): self.current_profit_str = StringVar() current_profit_lbl = Label(master, textvar=self.current_profit_str) current_profit_lbl.grid(row=previous_row + 1, column=previous_column + 1, columnspan=2, sticky=W + E, padx=3, pady=(0, 3)) current_profit_lbl.config(bg=background_colour, fg=label_font_colour) self.current_profit_str.set("Current Profit: 0%") def create_output_box(self, master, rightmost_column): self.pump_output = StringVar() console_lbl = Label(master, textvar=self.pump_output, borderwidth=2, relief=default_relief, anchor=N) console_lbl.grid(row=0, column=rightmost_column + 1, columnspan=1, rowspan=14, padx=(10, 0), pady=0) console_lbl.config(width=50, height=22, bg="black", font=Font(family="Courier", size=9), fg="white") self.lines = 0 def disable_pre_pump_options(self): # Change the buttons that can be clicked to prevent the user # from trying to pump multiple coins with one bot. self.manual_sell_btn.config(state=NORMAL) self.pump_btn.config(state=DISABLED) self.btc_to_use_spinbox.config(state=DISABLED) self.ticker_entry.config(state=DISABLED) self.auto_sell_spinbox.config(state=DISABLED) self.stop_loss_spinbox.config(state=DISABLED) self.api_key_entry.config( state=DISABLED) # Comment out if hardcoding key self.api_secret_entry.config( state=DISABLED) # Comment out if hardcoding secret self.api_connect_btn.config(state=DISABLED) self.entry_type_option_menu.config(state=DISABLED) self.fee_type_option_menu.config(state=DISABLED) def enable_pump_options(self): # Change the buttons that can be clicked to prevent the user # from trying to pump multiple coins with one bot. self.manual_sell_btn.config(state=DISABLED) self.pump_btn.config(state=NORMAL) self.btc_to_use_spinbox.config(state=NORMAL) self.ticker_entry.config(state=NORMAL) self.auto_sell_spinbox.config(state=NORMAL) self.stop_loss_spinbox.config(state=NORMAL) self.api_key_entry.config( state=NORMAL) # Comment out if hardcoding key self.api_secret_entry.config( state=NORMAL) # Comment out if hardcoding secret self.api_connect_btn.config(state=NORMAL) self.entry_type_option_menu.config(state=NORMAL) self.fee_type_option_menu.config(state=NORMAL) def set_available_btc_balance(self, btc_balance): self.pumper.btc_balance = btc_balance self.btc_balance_str.set("Available Balance: " + readable_btc_balance(btc_balance)) def set_current_profit(self, current_profit): self.current_profit_str.set( "Current Profit: " + '{0:.3f}'.format(round(current_profit * Decimal(100), 3)) + "%") def write_to_console(self, line): self.lines += 1 if self.lines > max_lines_in_console: i = self.pump_output.get().index('\n') self.pump_output.set(self.pump_output.get()[i + 1:] + "\n" + line) elif self.lines == 1: self.pump_output.set(line) else: self.pump_output.set(self.pump_output.get() + "\n" + line) #### Button Behaviour #### def on_pump(self): try: api = self.api btc_to_use = Decimal(self.btc_to_use_spinbox.get()) except InvalidOperation: # The BTC to spend box is empty. self.write_to_console("Stop!") self.write_to_console("BTC to spend cannot be empty.") return except AttributeError: # There is no API object. self.write_to_console( "You need to connect to Binance before pumping.") return if btc_to_use >= minimum_trade: if btc_to_use <= self.pumper.btc_balance: target_profit_percentage = Decimal( float(self.auto_sell_spinbox.get()) / 100.0) # Validate auto-sell and stop loss if target_profit_percentage <= Decimal(0): self.write_to_console("Auto sell has to be positive.") return if Decimal(self.stop_loss_spinbox.get()) >= Decimal(0): self.write_to_console("Stop loss has to be negative.") return ticker = self.ticker_entry.get().upper() # Empty strings are False in Python if ticker: full_ticker = api.full_ticker_for(ticker) try: alt = self.api.get_ticker(symbol=full_ticker) except BinanceAPIException, e: logging.debug(str(e)) self.write_to_console("Invalid ticker.") return alt_value = Decimal(alt["askPrice"]) # Used in console output decimal_points = minimum_decimals_in_quantity.get( full_ticker, 0) self.pumper.decimal_points_in_alt = decimal_points self.pumper.set_up(btc_to_use, target_profit_percentage, alt_value, ticker) if self.is_entry_market: self.pumper.alt_holdings = api.market_buy( self.pumper.btc_to_use, full_ticker, self.is_using_bnb) self.write_to_console( "Bought " + readable_alt_balance( decimal_points, pumper=self.pumper) + " with " + readable_btc_balance(btc_to_use) + ".") else: highest_bid = Decimal(alt["bidPrice"]) if alt_value - highest_bid <= Decimal(0.00000001): to_bid = highest_bid else: # Bid between the highest bid and the lowest ask for the best odds of being filled. to_bid = (alt_value - highest_bid) / 2 + highest_bid to_bid = Decimal( floor(to_bid * Decimal(100000000.0)) ) / Decimal(100000000.0) self.pumper.starting_alt_value = to_bid expected = api.limit_buy( btc_to_alt(btc_to_use, alt_value), pumper, full_ticker, to_bid, self.is_using_bnb) self.write_to_console("Buying " + readable_alt_balance( decimal_points, alt_amount=expected, ticker=ticker ) + " for " + readable_btc_balance(btc_to_use) + ".") self.write_to_console( "This is a limit order, it may not get filled.") self.disable_pre_pump_options() self.set_stop_loss() self.start_monitoring_orderbook(full_ticker) else: # The user is trying to trade with more than they actually have. self.write_to_console("You did not enter a ticker.") else: # The user is trying to trade with more than they actually have. self.write_to_console("Stop!") self.write_to_console( "You are trying to spend more BTC than you have.") else:
def initUI(self): self.parent.title("FIND SPE 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 self.graph_cb = BooleanVar() self.bins = IntVar() self.path = StringVar() self.n_files = IntVar() self.start_s = IntVar() self.end_s = IntVar() self.guess = IntVar() search = Image.open("next_logo.jpg") search_temp = search.resize((160, 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) #Number of Files and Bins. Spin Box self.n_files.set("2000") sb1 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.n_files) sb1.grid(row=1,column=4, sticky=W) sb1_label = Label(self, text="Files") sb1_label.grid(row=1,column=3, padx=5, sticky=E) self.bins.set("50") sb2 = Spinbox(self, from_=10, to=200, width=6, textvariable=self.bins) sb2.grid(row=1,column=6, sticky=W) sb2_label = Label(self, text="Hist. Bins") sb2_label.grid(row=1,column=5, padx=5, sticky=E) # INTEGRATION LIMITS Integration_label = Label(self, text="INTEGRATION", font = "Verdana 12 bold") Integration_label.grid(row=3,column=4, padx=5, columnspan = 2) self.start_s.set("1732") sb3 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.start_s) sb3.grid(row=4,column=4, sticky=W) sb3_label = Label(self, text="StartPoint") sb3_label.grid(row=4,column=3, padx=5, sticky=E) self.end_s.set("1752") sb4 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.end_s) sb4.grid(row=4,column=6, sticky=W) sb4_label = Label(self, text="EndPoint") sb4_label.grid(row=4,column=5, padx=5, sticky=E) sb4_label = Label(self, text="") sb4_label.grid(row=4,column=7, padx=5, sticky=E) # FITTING PARAMETERS Integration_label = Label(self, text="FITTING", font = "Verdana 12 bold") Integration_label.grid(row=6,column=4, padx=5, columnspan = 2) self.guess.set("-20") sb5 = Spinbox(self, from_=-50, to=-1, width=6, textvariable=self.guess) sb5.grid(row=7,column=4, sticky=W) sb5_label = Label(self, text="SPE guess") sb5_label.grid(row=7,column=5, padx=5, sticky=W) #Check buttons cb1 = Checkbutton(self, text="MultiGraph Output", variable=self.graph_cb ) cb1.select() cb1.grid(row=7,column=6, sticky=W) #Text Box #self.path.set("F:/DATOS_DAC/spe_1230/2046/pmt_0_trace_evt_") self.path.set("spe_1230_2046.h5.z") e1 = Entry(self, textvariable=self.path, width=45) e1.grid(row=10,column=3, sticky=W, columnspan=10, padx=10, pady=5) e1_label = Label(self, text="DataSet path (including name file)") e1_label.grid(row=9,column=3,sticky=W, columnspan=10, padx=10) # Main buttons obtn = Button(self, text="GO!!", command=self.SPE_f) obtn.grid(row=14, column=5, sticky=E, pady=5) cbtn = Button(self, text="Quit", command=self.quit) cbtn.grid(row=14, column=6, sticky=E, pady=5) hbtn = Button(self, text="Help") hbtn.grid(row=14, column=0, sticky=W, pady=5)
class TkPictureFrame(Frame): def __init__(self, x, y, master=None): Frame.__init__(self, master) self.photo = None self.resolution = (x, y) #The center of the Canvas is 0, 0. Find the center so #we can draw the image properly. self.center = ( x/2, y/2) #Setup the canvas self.picture = Canvas(self, width=x, height=y) #Place the canvas in the Grid. self.picture.grid(row=0,column=0,columnspan=2) #Camera check button control. self.checkButton = Checkbutton(self, text='Camera?',\ command=self.toggleCamera) #Place it on the grid. self.checkButton.grid(row=1,column=0) #Spinbox to set FPS self.fpsSpin = Spinbox(self, text="FPS", from_=2, to=30,\ command=self.fpsSpinCallback) self.fpsSpin.grid(row=1, column=1) #Set framerate self.fpsSpinCallback() #To determine if the camera is running self.capturing = False def fpsSpinCallback(self): self.fps = int(self.fpsSpin.get()) def changePic(self, photo): #Make a reference to the old photo for removal self.oldphoto = self.photo #Setup the new photo self.photo = photo #Draw the new photo over the old photo self.picture.create_image(self.center,image=self.photo) #Remove the old photo self.picture.delete(self.oldphoto) #Enable the checkbox self.checkButton.config(state="normal") def timedDisable(self, widget): #Disable a widget for 2 seconds. widget.config(state="disabled") time.sleep(2) widget.config(state="normal") def threadTimeDisable(self, widget): #Run the timed disable in a thread to avoid lockups. thread.start_new_thread(self.timedDisable, (widget,)) def startCamera(self): #Disable the checkbox and fps spinner. self.checkButton.config(state="disabled") self.fpsSpin.config(state="disabled") #Start the camera thread.start_new_thread(self.setupCamera, self.resolution) self.capturing = True def stopCamera(self): #Disable the checkbox for a duration. self.threadTimeDisable(self.checkButton) #Enable the spinner. self.fpsSpin.config(state="normal") #Clear the canvas. self.capturing = False self.picture.delete("all") def toggleCamera(self): if self.capturing: self.stopCamera() else: self.startCamera() def setupCamera(self, x, y): with picamera.PiCamera() as camera: camera.resolution = (x, y) camera.framerate = self.fps stream = io.BytesIO() for each in camera.capture_continuous(stream, format='jpeg'): # Truncate the stream to the current position (in case # prior iterations output a longer image) each.truncate() #Rewind the stream each.seek(0) #Open the image stream image = Image.open(each) photo = ImageTk.PhotoImage(image) #Break out of the loop if not capturing if not self.capturing: break #Update the canvas self.changePic(photo) #Reset playback to the beginning for the next image. each.seek(0)
# Spinbox callback def _spin(): value = spin.get() #print(value) #scr.insert(tk.INSERT, value + '\n') def _spin2(): value = spin2.get() #print(value) #scr.insert(tk.INSERT, value + '\n') # Adding 2 Spinbox widget using a set of values spin = Spinbox(monty, from_=10, to=25, width=5, bd=8, command=_spin) spin.grid(column=0, row=2) spin2 = Spinbox(monty, values=('Python3入门', 'C语言', 'C++', 'Java', 'OpenCV'), width=13, bd=3, command=_spin2) spin2.grid(column=1, row=2, sticky='W') # Using a scrolled Text control #scrolW = 30; scrolH = 5 #scr = scrolledtext.ScrolledText(monty, width=scrolW, height=scrolH, wrap=tk.WORD) #scr.grid(column=0, row=3, sticky='WE', columnspan=3) # Add Tooltip createToolTip(spin, '这是一个Spinbox.')
bookChosen.config(state='readonly') #设为只读模式 # Spinbox callback def _spin(): value = spin.get() #print(value) #scr.insert(tk.INSERT, value + '\n') def _spin2(): value = spin2.get() #print(value) #scr.insert(tk.INSERT, value + '\n') # Adding 2 Spinbox widget using a set of values spin = Spinbox(monty, from_=10,to=25, width=5, bd=8, command=_spin) spin.grid(column=0, row=2) spin2 = Spinbox(monty, values=('Python3入门', 'C语言','C++', 'Java', 'OpenCV'), width=13, bd=3, command=_spin2) spin2.grid(column=1, row=2,sticky='W') # Using a scrolled Text control #scrolW = 30; scrolH = 5 #scr = scrolledtext.ScrolledText(monty, width=scrolW, height=scrolH, wrap=tk.WORD) #scr.grid(column=0, row=3, sticky='WE', columnspan=3) # Add Tooltip createToolTip(spin, '这是一个Spinbox.') createToolTip(spin2, '这是一个Spinbox.') createToolTip(action, '这是一个Button.') createToolTip(nameEntered,'这是一个Entry.') createToolTip(bookChosen, '这是一个Combobox.')
class SpineRegGui(Frame): def __init__(self, parent, param_filename=None): Frame.__init__(self, parent) self.title = 'SpineDTI' self.log = os.path.join(os.path.abspath('.'), 'log') self.parent = parent self.parameter_values = {} self.param = parameter.Parameter() self.initUI() self.init_variable() self.update_param_from_text() if param_filename is not None: self.read_param(param_filename) def init_variable(self): #self.txt_multiband.insert(0, '2') self.reset_entry(self.spin_multiband, 2) #self.txt_nitr.insert(0, '3') self.reset_entry(self.spin_nitr, 3) self.chk_nosearch.invoke() self.reset_entry(self.txt_b0_threshold, 90) self.reset_entry(self.txt_high_b_threshold, 400) dirname = os.path.dirname(os.path.realpath(__file__)) self.reset_entry(self.txt_topup_config, os.path.join(dirname, 'b02b0_ON_1_3mm.cnf')) self.reset_entry(self.txt_reg_config, os.path.join(dirname, 'xytrans.sch')) self.reset_entry(self.txt_topup_app, 'topup_2d') self.reset_entry(self.txt_eddy_app, 'eddy') if self.txt_working.get() == '': self.reset_entry(self.txt_working, os.path.abspath('.'), force=True) def update_parameter(self): if self.parameter_values.has_key('subject'): self.reset_entry(self.txt_subject, self.parameter_values['subject']) if self.parameter_values.has_key('dwi'): self.reset_entry(self.txt_dwi, self.parameter_values['dwi']) self.reset_entry( self.txt_bval, filename_wo_ext(self.parameter_values['dwi']) + '.bval') self.reset_entry( self.txt_bvec, filename_wo_ext(self.parameter_values['dwi']) + '.bvec') if self.parameter_values.has_key('b0'): self.reset_entry(self.txt_b0, self.parameter_values['b0']) if self.parameter_values.has_key('working'): self.reset_entry(self.txt_working, self.parameter_values['working'], force=True) def reset_entry(self, entry, text, force=False): entry.delete(0, len(entry.get())) dirname = self.txt_working.get() len_dirname = len(dirname) # print dirname, text if (not force) and type(text) == type( '') and len_dirname > 1 and dirname == text[:len_dirname]: entry.insert(0, text[len_dirname:].strip(os.path.sep)) else: entry.insert(0, text) def filenameDialog_text(self, text): fl = tkFileDialog.askopenfilename() if fl != '': self.reset_entry(text, fl) def dirnameDialog_text(self, text): fl = tkFileDialog.askdirectory(initialdir=text.get()) if fl != '': self.reset_entry(text, fl) def prefix(self): if self.txt_subject.get() == '': return '' else: return self.txt_subject.get() + '_' def update_param_from_text(self): self.param.subject = self.txt_subject.get() self.param.working_dir = self.txt_working.get() self.param.fn_bval = self.txt_bval.get() self.param.fn_bvec = self.txt_bvec.get() self.param.b0_threshold = self.txt_b0_threshold.get() #self.param.b0_threshold = self.txt_b0_threshold.get() #FIXME self.param.topup_app = self.txt_topup_app.get() self.param.topup_config = self.txt_topup_config.get() self.param.eddy_app = self.txt_eddy_app.get() self.param.fn_b0 = self.txt_b0.get() self.param.fn_b0_mask = self.txt_b0mask.get() self.param.fn_dwi = self.txt_dwi.get() self.param.fn_dwi_mask = self.txt_dwi_mask.get() self.param.fn_dwi_eddy_out = self.txt_output_eddy.get() self.param.multiband = self.spin_multiband.get() self.param.niter = self.spin_nitr.get() self.param.nosearch = self.nosearch.get() self.param.noresample = self.noresample.get() self.param.schedule = self.txt_reg_config.get() self.param.fn_dwi_eddy = self.txt_dwi_eddy.get() self.param.fn_reg_mask = self.txt_reg_mask.get() self.param.fn_reg_outlier = self.txt_reg_outlier.get() self.param.fn_reg_slices = self.txt_reg_slices.get() self.param.fn_reg_out = self.txt_output_reg.get() self.param.fn_dti = self.txt_dti.get() self.param.fn_dwi_dti = self.txt_dwi_dti.get() self.param.fn_dwi_dti_mask = self.txt_md_mask.get() self.param.fn_dwi_dti_outlier = self.txt_dti_outlier.get() self.param.fn_dti_value = self.txt_dti_value.get() self.param.fn_dti_value_roi = self.txt_dti_roi.get() self.param.fn_dti_value_out = self.txt_output_dti_value.get() self.param.set_variable_types() def update_text_from_param(self): self.reset_entry(self.txt_subject, self.param.subject) self.reset_entry(self.txt_working, self.param.working_dir, force=True) self.reset_entry(self.txt_bval, self.param.fn_bval) self.reset_entry(self.txt_bvec, self.param.fn_bvec) self.reset_entry(self.txt_b0_threshold, self.param.b0_threshold) self.reset_entry(self.txt_topup_app, self.param.topup_app) self.reset_entry(self.txt_topup_config, self.param.topup_config) self.reset_entry(self.txt_eddy_app, self.param.eddy_app) self.reset_entry(self.txt_b0, self.param.fn_b0) self.reset_entry(self.txt_b0mask, self.param.fn_b0_mask) self.reset_entry(self.txt_dwi, self.param.fn_dwi) self.reset_entry(self.txt_dwi_mask, self.param.fn_dwi_mask) self.reset_entry(self.txt_output_eddy, self.param.fn_dwi_eddy_out) self.reset_entry(self.spin_multiband, self.param.multiband) self.reset_entry(self.spin_nitr, self.param.niter) self.nosearch.set(self.param.nosearch) self.noresample.set(self.param.noresample) self.reset_entry(self.txt_reg_config, self.param.schedule) self.reset_entry(self.txt_dwi_eddy, self.param.fn_dwi_eddy) self.reset_entry(self.txt_reg_mask, self.param.fn_reg_mask) self.reset_entry(self.txt_reg_outlier, self.param.fn_reg_outlier) self.reset_entry(self.txt_reg_slices, self.param.fn_reg_slices) self.reset_entry(self.txt_output_reg, self.param.fn_reg_out) self.reset_entry(self.txt_dwi_dti, self.param.fn_dwi_dti) self.reset_entry(self.txt_dti, self.param.fn_dti) self.reset_entry(self.txt_md_mask, self.param.fn_dwi_dti_mask) self.reset_entry(self.txt_dti_outlier, self.param.fn_dwi_dti_outlier) self.reset_entry(self.txt_dti_value, self.param.fn_dti_value) self.reset_entry(self.txt_dti_roi, self.param.fn_dti_value_roi) self.reset_entry(self.txt_output_dti_value, self.param.fn_dti_value_out) def read_param(self, filename=None): if filename is None or not os.path.isfile(filename): fn = tkFileDialog.askopenfilename() else: fn = filename if os.path.isfile(fn): print 'Reading %s' % fn self.param.read(fn) self.update_text_from_param() self.reset_entry(self.txt_param, fn) else: sys.stderr.write('File not exist: %s\n' % fn) def save_param(self): self.update_param_from_text() if self.txt_param.get() != '': if os.path.dirname(self.txt_param.get()) == '': filename = tkFileDialog.asksaveasfilename( initialdir=self.txt_working.get(), initialfile=os.path.basename(self.txt_param.get())) else: filename = tkFileDialog.asksaveasfilename( initialdir=os.path.dirname(self.txt_param.get()), initialfile=os.path.basename(self.txt_param.get())) else: filename = tkFileDialog.asksaveasfilename( initialdir=self.txt_working.get()) if filename != '': self.param.save(filename) self.reset_entry(self.txt_param, filename) def initUI(self): self.parent.title(self.title) self.nosearch = BooleanVar(self) self.noresample = BooleanVar(self) i = 0 #frame_top = Frame(self) #frame_top.grid(row=i, column=0, columnspan=6, sticky=EW) #Label(frame_top, text='topframe').grid(row=0, column=0, sticky=EW) #Label(frame_top, text='topframe').grid(row=0, column=1, sticky=EW) #Label(frame_top, text='topframe').grid(row=1, column=0, sticky=EW) #Label(frame_top, text='topframe').grid(row=1, column=1, sticky=EW) #Entry(frame_top, text='topframe').grid(row=0, column=0, sticky=EW) #Entry(frame_top, text='topframe').grid(row=0, column=1, sticky=EW) #Entry(frame_top, text='topframe').grid(row=1, column=0, sticky=EW) #Entry(frame_top, text='topframe').grid(row=1, column=1, sticky=EW) #frame_top.grid_columnconfigure(0, weight=1) #frame_top.grid_columnconfigure(1, weight=1) dddWidth = 4 labelWidth = 10 i += 1 Label(self, text='Working dir', width=labelWidth).grid(row=i, column=0) self.txt_working = Entry(self) self.txt_working.grid(row=i, column=1, sticky=EW) btn_working = Button( self, text='...', width=dddWidth, command=lambda: self.dirnameDialog_text(self.txt_working)) btn_working.grid(row=i, column=2, sticky=W) i += 1 Label(self, text='Parameters', width=labelWidth).grid(row=i, column=0) self.txt_param = Entry(self) self.txt_param.grid(row=i, column=1, sticky=EW) btn_param_read = Button(self, text='Read', command=self.read_param) btn_param_read.grid(row=i, column=2) btn_param_save = Button(self, text='Save', command=self.save_param) btn_param_save.grid(row=i, column=3) i += 1 frm_prepa = Frame(self) ii = 0 Label(frm_prepa, text='Subject', width=labelWidth).grid(row=ii, column=0) self.txt_subject = Entry(frm_prepa) self.txt_subject.grid(row=ii, column=1, sticky=EW) btn_prepa = Button(frm_prepa, text='Prepare DWIs', command=self.run_prepare) btn_prepa.grid(row=ii, column=3) #btn_update = Button(frm_prepa, text='Update filenames', command=self.update_parameter); btn_update.grid(row=ii, column=4) btn_update = Button(frm_prepa, text='Update filenames', command=self.update_text_from_param) btn_update.grid(row=ii, column=4) ii += 1 Label(frm_prepa, text='bval', width=labelWidth).grid(row=ii, column=0) self.txt_bval = Entry(frm_prepa) self.txt_bval.grid(row=ii, column=1, sticky=EW) btn_bval = Button( frm_prepa, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_bval)) btn_bval.grid(row=ii, column=2, sticky=W) Label(frm_prepa, text='b0 threshold').grid(row=ii, column=3, sticky=E) self.txt_b0_threshold = Entry(frm_prepa, width=10) self.txt_b0_threshold.grid(row=ii, column=4) ii += 1 Label(frm_prepa, text='bvec', width=labelWidth).grid(row=ii, column=0) self.txt_bvec = Entry(frm_prepa) self.txt_bvec.grid(row=ii, column=1, sticky=EW) btn_bvec = Button( frm_prepa, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_bvec)) btn_bvec.grid(row=ii, column=2, sticky=W) Label(frm_prepa, text='high b threshold').grid(row=ii, column=3, sticky=E) self.txt_high_b_threshold = Entry(frm_prepa, width=10) self.txt_high_b_threshold.grid(row=ii, column=4) frm_prepa.grid_columnconfigure(1, weight=1) frm_prepa.grid(row=i, rowspan=ii + 1, column=0, columnspan=6, sticky=NSEW) ii += 1 i += ii # TOPUP/EDDY or Rigid registration i += 1 Label(self, text=' TOPUP/EDDY or Rigid registration').grid(row=i, column=0, columnspan=2, sticky=W) i += 1 frm_eddy = Frame(self) width = 10 ii = 0 jj = 0 Label(frm_eddy, text='TOPUP', width=width, justify=RIGHT, anchor=E).grid(row=ii, column=jj, sticky=E) jj += 1 self.txt_topup_app = Entry(frm_eddy, width=width) self.txt_topup_app.grid(row=ii, column=jj) jj += 1 Label(frm_eddy, text='Configure', width=width, justify=RIGHT, anchor=E).grid(row=ii, column=jj, sticky=E) jj += 1 self.txt_topup_config = Entry(frm_eddy) self.txt_topup_config.grid(row=ii, column=jj, sticky=EW) jj += 1 btn_topup_config = Button( frm_eddy, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_topup_config)) btn_topup_config.grid(row=ii, column=jj, sticky=W) jj += 1 Label(frm_eddy, text='EDDY', width=width, justify=RIGHT, anchor=E).grid(row=ii, column=jj, sticky=E) jj += 1 self.txt_eddy_app = Entry(frm_eddy, width=width) self.txt_eddy_app.grid(row=ii, column=jj) frm_eddy.grid(row=i, rowspan=ii + 1, column=0, columnspan=6, sticky=NSEW) frm_eddy.grid_columnconfigure(3, weight=1) i += ii i += 1 Label(self, text='B0', width=labelWidth).grid(row=i, column=0) self.txt_b0 = Entry(self) self.txt_b0.grid(row=i, column=1, sticky=EW) btn_b0 = Button(self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_b0)) btn_b0.grid(row=i, column=2, sticky=W) btn_topup = Button(self, text='TOPUP', command=self.run_topup) btn_topup.grid(row=i, column=4, rowspan=2, sticky=NS) btn_rigid = Button(self, text='Rigid\nReg', command=self.run_eddy) btn_rigid.grid(row=i, column=5, rowspan=4, sticky=NS) i += 1 Label(self, text='B0 mask', width=labelWidth).grid(row=i, column=0) self.txt_b0mask = Entry(self) self.txt_b0mask.grid(row=i, column=1, sticky=EW) btn_b0mask = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_b0mask)) btn_b0mask.grid(row=i, column=2, sticky=W) btn_b0mask_make = Button( self, text='Make', command=lambda: self.make_mask( self.txt_b0.get(), mask4d=True, rtn=self.txt_b0mask)) btn_b0mask_make.grid(row=i, column=3) i += 1 Label(self, text='DWI', width=labelWidth).grid(row=i, column=0) self.txt_dwi = Entry(self) self.txt_dwi.grid(row=i, column=1, sticky=EW) btn_dwi_eddy = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dwi)) btn_dwi_eddy.grid(row=i, column=2, sticky=W) btn_eddy = Button(self, text='EDDY', command=self.run_eddy) btn_eddy.grid(row=i, column=4, rowspan=2, sticky=NS) i += 1 Label(self, text='DWI mask', width=labelWidth).grid(row=i, column=0) self.txt_dwi_mask = Entry(self) self.txt_dwi_mask.grid(row=i, column=1, sticky=EW) btn_dwi_mask = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dwi_mask)) btn_dwi_mask.grid(row=i, column=2, sticky=W) btn_dwi_mask_make = Button( self, text='Make', command=lambda: self.make_mask(self.txt_dwi.get(), rtn=self.txt_dwi_mask)) btn_dwi_mask_make.grid(row=i, column=3) i += 1 Label(self, text='Output', width=labelWidth).grid(row=i, column=0) self.txt_output_eddy = Entry(self) self.txt_output_eddy.grid(row=i, column=1, sticky=EW) btn_output_eddy = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_output_eddy)) btn_output_eddy.grid(row=i, column=2, sticky=W) btn_output_eddy_auto = Button(self, text='Auto', command=self.gen_eddy_outputname) btn_output_eddy_auto.grid(row=i, column=3) # 2D registration i += 1 Label(self, text=' 2D registration (X-Y translation)').grid(row=i, column=0, columnspan=2, sticky=W) i += 1 frm_param = Frame(self) width = 12 width_half = 6 ii = 0 jj = 0 Label(frm_param, text='Multi band', width=width, justify=RIGHT, anchor=E).grid(row=ii, column=jj, sticky=E) #jj += 1; self.txt_multiband = Entry(frm_param, width=width_half); self.txt_multiband.grid(row=ii, column=jj) jj += 1 self.spin_multiband = Spinbox(frm_param, from_=0, to=1000, increment=1, width=width_half) self.spin_multiband.grid(row=ii, column=jj) jj += 1 Label(frm_param, text='#iteration', width=width, justify=RIGHT, anchor=E).grid(row=ii, column=jj, sticky=E) #jj += 1; self.txt_nitr = Entry(frm_param, width=width_half); self.txt_nitr.grid(row=ii, column=jj) jj += 1 self.spin_nitr = Spinbox(frm_param, from_=0, to=1000, increment=1, width=width_half) self.spin_nitr.grid(row=ii, column=jj) jj += 1 Label(frm_param, text='', width=width, justify=RIGHT, anchor=E).grid(row=ii, column=jj, sticky=E) jj += 1 self.chk_nosearch = Checkbutton(frm_param, text='nosearch', variable=self.nosearch, width=width) self.chk_nosearch.grid(row=ii, column=jj) jj += 1 self.chk_noresample = Checkbutton(frm_param, text='noresample', variable=self.noresample, width=width) self.chk_noresample.grid(row=ii, column=jj) ii += 1 jj = 0 Label(frm_param, text='Schedule').grid(row=ii, column=jj, sticky=E) jj += 1 self.txt_reg_config = Entry(frm_param) self.txt_reg_config.grid(row=ii, column=jj, sticky=EW, columnspan=4) jj += 4 btn_reg_config = Button( frm_param, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_reg_config)) btn_reg_config.grid(row=ii, column=jj, sticky=W) frm_param.grid_columnconfigure(4, weight=1) frm_param.grid(row=i, rowspan=ii + 1, column=0, columnspan=6, sticky=NSEW) i += ii i += 1 Label(self, text='DWI', width=labelWidth).grid(row=i, column=0) self.txt_dwi_eddy = Entry(self) self.txt_dwi_eddy.grid(row=i, column=1, sticky=EW) btn_dwi_eddy = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dwi_eddy)) btn_dwi_eddy.grid(row=i, column=2, sticky=W) btn_dwi_eddy_copy = Button( self, text='Copy', command=lambda: self.reset_entry(self.txt_dwi_eddy, self.txt_output_eddy.get())) btn_dwi_eddy_copy.grid(row=i, column=3) btn_dwi_eddy = Button(self, text='Save\nParam', command=self.save_reg_param) btn_dwi_eddy.grid(row=i, column=4, rowspan=2, sticky=NSEW) btn_dwi_eddy = Button(self, text='XY-Reg', command=self.run_xy_reg) btn_dwi_eddy.grid(row=i, column=5, rowspan=2, sticky=NSEW) i += 1 Label(self, text='Mask', width=labelWidth).grid(row=i, column=0) self.txt_reg_mask = Entry(self) self.txt_reg_mask.grid(row=i, column=1, sticky=EW) btn_reg_mask = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_reg_mask)) btn_reg_mask.grid(row=i, column=2, sticky=W) btn_reg_mask_make = Button( self, text='Make', command=lambda: self.make_mask(self.txt_dwi_eddy.get(), rtn=self.txt_reg_mask)) btn_reg_mask_make.grid(row=i, column=3) i += 1 Label(self, text='Slices', width=labelWidth).grid(row=i, column=0) self.txt_reg_slices = Entry(self) self.txt_reg_slices.grid(row=i, column=1, sticky=EW) i += 1 Label(self, text='Outlier', width=labelWidth).grid(row=i, column=0) self.txt_reg_outlier = Entry(self) self.txt_reg_outlier.grid(row=i, column=1, sticky=EW) btn_reg_outlier = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_reg_outlier)) btn_reg_outlier.grid(row=i, column=2, sticky=W) btn_reg_outlier_calculate = Button(self, text='Calculate', command=self.run_xy_reg_outlier) btn_reg_outlier_calculate.grid(row=i, column=3) btn_reg_apply = Button(self, text='Applywarp', command=self.run_applywarp) btn_reg_apply.grid(row=i, column=4, columnspan=2, sticky=EW) i += 1 Label(self, text='Output', width=labelWidth).grid(row=i, column=0) self.txt_output_reg = Entry(self) self.txt_output_reg.grid(row=i, column=1, sticky=EW) btn_output_reg = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_output_reg)) btn_output_reg.grid(row=i, column=2, sticky=W) btn_output_reg_auto = Button(self, text='Auto', command=self.gen_reg_outputname) btn_output_reg_auto.grid(row=i, column=3) # DTI i += 1 Label(self, text=' DTI map with outlier rejection').grid(row=i, column=0, columnspan=2, sticky=W) i += 1 Label(self, text='DWI_reg', width=labelWidth).grid(row=i, column=0) self.txt_dwi_dti = Entry(self) self.txt_dwi_dti.grid(row=i, column=1, sticky=EW) btn_dwi_dti = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dwi_dti)) btn_dwi_dti.grid(row=i, column=2, sticky=W) btn_dwi_dti_copy = Button( self, text='Copy', command=lambda: self.reset_entry(self.txt_dwi_dti, self.txt_output_reg.get())) btn_dwi_dti_copy.grid(row=i, column=3) btn_dti_maps = Button(self, text='Generate DTI maps', command=self.run_generate_dti_maps) btn_dti_maps.grid(row=i, column=4, columnspan=2, sticky=EW) i += 1 Label(self, text='DTI', width=labelWidth).grid(row=i, column=0) self.txt_dti = Entry(self) self.txt_dti.grid(row=i, column=1, sticky=EW) btn_dti = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dti)) btn_dti.grid(row=i, column=2, sticky=W) btn_dti_auto = Button(self, text='Auto', command=self.gen_dti_name) btn_dti_auto.grid(row=i, column=3) btn_dti_outlier_calc = Button(self, text='Calculate Outlier', command=self.run_dti_outlier) btn_dti_outlier_calc.grid(row=i, column=4, columnspan=2, rowspan=2, sticky=NSEW) i += 1 Label(self, text='Mask', width=labelWidth).grid(row=i, column=0) self.txt_md_mask = Entry(self) self.txt_md_mask.grid(row=i, column=1, sticky=EW) btn_md_mask = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_md_mask)) btn_md_mask.grid(row=i, column=2, sticky=W) btn_md_mask_make = Button(self, text='Make', command=self.run_md_mask) btn_md_mask_make.grid(row=i, column=3) i += 1 Label(self, text='Outlier', width=labelWidth).grid(row=i, column=0) self.txt_dti_outlier = Entry(self) self.txt_dti_outlier.grid(row=i, column=1, sticky=EW) btn_dti_outlier = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dti_outlier)) btn_dti_outlier.grid(row=i, column=2, sticky=W) btn_dti_maps_itr = Button( self, text='Generate DTI maps', command=lambda: self.run_generate_dti_maps(outlier=True)) btn_dti_maps_itr.grid(row=i, column=4, columnspan=2, sticky=EW) #i += 1 #Label(self, text='DWI' , width=labelWidth).grid(row=i, column=0) #self.txt_dwi_dti_itr = Entry(self); self.txt_dwi_dti_itr.grid(row=i, column=1, sticky=EW) #btn_dwi_dti_itr = Button(self, text='...', width=dddWidth, command=lambda:self.filenameDialog_text(self.txt_dwi_dti_itr)) #btn_dwi_dti_itr.grid(row=i, column=2, sticky=W) #i += 1; Label(self, text='Output' , width=labelWidth).grid(row=i, column=0) #self.txt_output_dti = Entry(self); self.txt_output_dti.grid(row=i, column=1, sticky=EW) #btn_output_dti = Button(self, text='...', width=dddWidth, command=lambda:self.filenameDialog_text(self.txt_output_dti)) #btn_output_dti.grid(row=i, column=2, sticky=W) #btn_output_dti_auto = Button(self, text='Auto', command=self.gen_dti_outputname); btn_output_dti_auto.grid(row=i, column=3) # DTI Values i += 1 Label(self, text=' DTI values').grid(row=i, column=0, columnspan=2, sticky=W) i += 1 Label(self, text='DTI', width=labelWidth).grid(row=i, column=0) self.txt_dti_value = Entry(self) self.txt_dti_value.grid(row=i, column=1, sticky=EW) btn_dti_value = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dti_value)) btn_dti_value.grid(row=i, column=2, sticky=W) btn_dwi_dti_value_copy = Button( self, text='Copy', command=lambda: self.reset_entry(self.txt_dti_value, self.txt_dti.get())) btn_dwi_dti_value_copy.grid(row=i, column=3) btn_dti_value_get = Button(self, text='Get DTI\nValues', command=self.run_get_dti_values) btn_dti_value_get.grid(row=i, column=4, rowspan=2, columnspan=2, sticky=NSEW) i += 1 Label(self, text='ROI', width=labelWidth).grid(row=i, column=0) self.txt_dti_roi = Entry(self) self.txt_dti_roi.grid(row=i, column=1, sticky=EW) btn_dti_roi = Button( self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text(self.txt_dti_roi)) btn_dti_roi.grid(row=i, column=2, sticky=W) btn_dti_roi = Button(self, text='Make') btn_dti_roi.grid(row=i, column=3) i += 1 Label(self, text='Output', width=labelWidth).grid(row=i, column=0) self.txt_output_dti_value = Entry(self) self.txt_output_dti_value.grid(row=i, column=1, sticky=EW) btn_output_dti_value = Button(self, text='...', width=dddWidth, command=lambda: self.filenameDialog_text( self.txt_output_dti_value)) btn_output_dti_value.grid(row=i, column=2, sticky=W) btn_output_dti_value_auto = Button( self, text='Auto', command=self.gen_dti_value_outputname) btn_output_dti_value_auto.grid(row=i, column=3) self.grid_columnconfigure(1, weight=1) ni = i + 1 for i in range(ni): self.grid_rowconfigure(i, weight=1, minsize=20) self.pack(fill=BOTH, expand=True) def initUI_1(self): self.parent.title("Review") self.pack(fill=BOTH, expand=True) frame1 = Frame(self) frame1.pack(fill=X) lbl1 = Label(frame1, text="Title", width=6) lbl1.pack(side=LEFT, padx=5, pady=5) entry1 = Entry(frame1) entry1.pack(fill=X, padx=5, expand=True) frame2 = Frame(self) frame2.pack(fill=X) #frame2.pack(fill=BOTH, expand=True) lbl2 = Label(frame2, text="Author", width=6) lbl2.pack(side=LEFT, padx=5, pady=5) entry2 = Entry(frame2) entry2.pack(fill=X, padx=5, expand=True) frame3 = Frame(self) frame3.pack(fill=BOTH, expand=True) lbl3 = Label(frame3, text="Review", width=6) lbl3.pack(side=LEFT, anchor=N, padx=5, pady=5) txt = Entry(frame3) txt.pack(fill=BOTH, pady=5, padx=5, expand=True) def onOpen(self): ftypes = [('Python files', '*.py'), ('All files', '*')] dlg = tkFileDialog.Open(self, filetypes=ftypes) fl = dlg.show() if fl != '': #text = self.readFile(fl) print fl def gen_eddy_outputname(self): fn = self.txt_output_eddy.get() if fn == '' or '_rigid.nii.gz' in fn: fn = filename_wo_ext(self.txt_dwi.get()) + '_eddy_unwarped.nii.gz' else: fn = filename_wo_ext(self.txt_dwi.get()) + '_rigid.nii.gz' self.reset_entry(self.txt_output_eddy, fn) def gen_reg_outputname(self): fn = filename_wo_ext(self.txt_dwi_eddy.get()) + '_xenc.nii.gz' self.reset_entry(self.txt_output_reg, fn) #def gen_dti_outputname(self): # fn = filename_wo_ext(self.txt_output_reg.get()) + '_dti.nii.gz' # self.reset_entry(self.txt_output_dti, fn) def gen_dti_name(self): self.reset_entry(self.txt_dti, filename_wo_ext(self.txt_dwi_dti.get()) + '_dti') def gen_dti_value_outputname(self): fn = filename_wo_ext(self.txt_dti_value.get()) + '.csv' self.reset_entry(self.txt_output_dti_value, fn) def check_dependency(self, dependency): dirname = self.txt_working.get() for entry in dependency: if not os.path.isfile(os.path.join(dirname, entry.get())): sys.stderr.write('File not exist: %s\n' % entry.get()) return False return True def run_prepare(self): #prep = Tk() #app = prepare_dwi_gui.PrepareDWI(prep, subject=self.txt_subject.get(), output_dir=self.txt_working.get(), return_value=self.parameter_values, make_param=False) #prep.mainloop() self.prep_window = Toplevel(self.parent) self.prep_app = prepare_dwi_gui.PrepareDWI( self.prep_window, subject=self.txt_subject.get(), output_dir=self.txt_working.get(), return_value=self.parameter_values, obj_return_value=self, make_param=False) #app.mainloop() #self.update_parameter() #tkMessageBox.showinfo(self.title, 'Done: DWI preparation') def make_mask(self, filename=None, mask4d=False, rtn=None): import gui_mask root = Tk() #current_pwd = os.path.abspath(os.path.curdir()) working = self.txt_working.get() #os.chdir(working) if filename is None or filename == '': app = gui_mask.CreateMask(root, filename=None, dirname=working, mask4d=mask4d, obj_return_value=rtn) else: app = gui_mask.CreateMask(root, filename=os.path.join(working, filename), dirname=working, mask4d=mask4d, obj_return_value=rtn) root.mainloop() #os.chdir(current_pwd) #tkMessageBox.showinfo(self.title, 'Done: Making mask') def run_topup(self): dependency = [ self.txt_b0, self.txt_b0mask, ] if not self.check_dependency(dependency): return working = self.txt_working.get() fn_b0 = os.path.join(working, self.txt_b0.get()) fn_b0mask = os.path.join(working, self.txt_b0mask.get()) fn_b0masked = filename_wo_ext(fn_b0) + '_masked.nii.gz' fn_out = os.path.join(working, self.prefix() + 'topup') run_command('fslmaths %s -mas %s %s' % (fn_b0, fn_b0mask, fn_b0masked)) topup_command = [self.txt_topup_app.get()] if self.txt_topup_config.get() != '': topup_command.append('--config=%s' % self.txt_topup_config.get()) topup_command.append('--datain=%s' % (os.path.join(working, self.prefix() + 'acqparams.txt'))) topup_command.append('--imain=%s' % fn_b0masked) topup_command.append('--out=%s' % fn_out) topup_command.append('--iout=%s_warped' % fn_out) topup_command.append('--fout=%s_field' % fn_out) topup_command.append('--logout=%s_log' % fn_out) topup_command.append('1> %s_topup_log.out' % self.txt_subject.get()) cmd = ' '.join(topup_command) append_text(self.log, cmd, 'run_topup') run_command(cmd) print 'Done: TOPUP' tkMessageBox.showinfo(self.title, 'Done: TOPUP') def run_eddy(self): dependency = [ self.txt_dwi, self.txt_dwi_mask, ] if not self.check_dependency(dependency): return working = self.txt_working.get() eddy_command = [self.txt_eddy_app.get()] eddy_command.append('--flm=quadratic') eddy_command.append('--acqp=%s' % (os.path.join(working, self.prefix() + 'acqparams.txt'))) eddy_command.append('--bvals=%s' % (os.path.join(working, self.txt_bval.get()))) eddy_command.append('--bvecs=%s' % (os.path.join(working, self.txt_bvec.get()))) eddy_command.append('--imain=%s' % (os.path.join(working, self.txt_dwi.get()))) eddy_command.append('--index=%s' % (os.path.join(working, self.prefix() + 'index.txt'))) eddy_command.append('--mask=%s' % (os.path.join(working, self.txt_dwi_mask.get()))) eddy_command.append('--topup=%s' % (os.path.join(working, self.prefix() + 'topup'))) eddy_command.append('1> %s_eddy_log.out' % self.txt_subject.get()) if self.txt_output_eddy.get() == '': self.gen_eddy_outputname() eddy_command.append( '--out=%s' % (os.path.join(working, self.txt_output_eddy.get()))) cmd = ' '.join(eddy_command) append_text(self.log, cmd, 'run_eddy') run_command(cmd) print 'Done: Eddy' self.reset_entry(self.txt_dwi_eddy, self.txt_output_eddy.get()) tkMessageBox.showinfo(self.title, 'Done: EDDY') def run_rigid_reg(self): dependency = [ self.txt_b0, self.txt_dwi_mask, ] if not self.check_dependency(dependency): return tkMessageBox.showinfo(self.title, 'Non implemented yet') #tkMessageBox.showinfo(self.title, 'Done: Rigid registration') def save_reg_param(self): dependency = [ self.txt_dwi_eddy, self.txt_reg_mask, ] if not self.check_dependency(dependency): return filename = tkFileDialog.asksaveasfilename( initialdir=self.txt_working.get(), initialfile='reg_2d.params') if filename == '': return self.update_param_from_text() param_2d = parameter.Parameter_reg2d(param_object=self.param) param_2d.save_param(filename) def run_xy_reg(self): dependency = [self.txt_dwi_eddy, self.txt_reg_mask] if not self.check_dependency(dependency): return self.update_param_from_text() param_2d = parameter.Parameter_reg2d(param_object=self.param) spine_reg.set_print_cmd( os.path.join(self.txt_working.get(), self.prefix() + 'xy_reg_cmd')) cmd = '\n'.join( [str(vars(param_2d)), 'spine_reg.run_registration(param_2d)']) append_text(self.log, cmd, 'run_xy_reg') sub_slices = self.txt_reg_slices.get() if sub_slices != '': try: slices = [ value.strip() for value in sub_slices.strip().split(',') ] slices = [int(value) for value in slices if value != ''] sub_slices = slices except: sub_slices = None else: sub_slices = None fn_out = spine_reg.run_registration(param_2d, sub_slices=sub_slices) self.reset_entry(self.txt_dwi_dti, fn_out) os.chdir(self.txt_working.get()) print 'Done: XY-Reg' tkMessageBox.showinfo(self.title, 'Done: XY-registration') def run_applywarp(self): dependency = [ self.txt_dwi_eddy, self.txt_reg_mask, ] if not self.check_dependency(dependency): return param_2d = parameter.Parameter_reg2d(param_object=self.param) spine_reg.set_print_cmd( os.path.join(self.txt_working.get(), self.prefix() + 'xy_reg_cmd')) fn_out = spine_reg.run_applywarp(param_2d) self.reset_entry(self.txt_dwi_dti, fn_out) print 'Done: Applywarp' tkMessageBox.showinfo(self.title, 'Done: Applywarp') def run_xy_reg_outlier(self, param_2d=None): dependency = [self.txt_dwi_eddy, self.txt_reg_mask, self.txt_bval] #if not self.check_dependency(dependency): # return self.update_param_from_text() if param_2d is None: param_2d = parameter.Parameter_reg2d(param_object=self.param) spine_reg.generate_xy_trans(param_2d) os.chdir(self.txt_working.get()) print 'Done: XY-Reg outlier calculation' def run_generate_dti_maps(self, outlier=False): cmd = 'generate_dti_maps(%s)' % (', '.join([ self.txt_dwi_dti.get(), 'bval_bvec=None', 'bval=%s' % os.path.join(self.txt_working.get(), self.txt_bval.get()), 'bvec=%s' % os.path.join(self.txt_working.get(), self.txt_bvec.get()), 'prefix=%s' % self.prefix(), 'outlier=%s' % outlier ])) append_text(self.log, cmd, 'run_generate_dti_maps') fn_out = generate_dti_maps(self.txt_dwi_dti.get(), bval_bvec=None, bval=os.path.join(self.txt_working.get(), self.txt_bval.get()), bvec=os.path.join(self.txt_working.get(), self.txt_bvec.get()), prefix=self.prefix(), outlier=outlier) print 'Done: Generate DTI maps' self.reset_entry(self.txt_dti_value, fn_out) tkMessageBox.showinfo(self.title, 'Done: Generating DTI maps') def run_md_mask(self): if not os.path.isfile( os.path.join(self.txt_working.get(), self.txt_dwi_dti.get())): sys.stderr.write('File not exist: %s\n' % self.txt_dwi_dti.get()) return working = self.txt_working.get() if os.path.isfile(os.path.join(working, self.txt_dti_value.get())): fn_md = filename_wo_ext(self.txt_dti_value.get()) + '_MD.nii.gz' else: fn_md = filename_wo_ext(self.txt_dwi_dti.get()) + '_dti_MD.nii.gz' fn_mask = create_md_mask(os.path.join(working, fn_md), fn_out=None, thr_min=0.1, thr_max=1.1) print 'Done: Making MD mask' self.reset_entry(self.txt_md_mask, os.path.basename(fn_mask)) #tkMessageBox.showinfo(self.title, 'Done: MD mask') def run_dti_outlier(self): import outlier_4dfp_gui root = Tk() working = self.txt_working.get() filename = os.path.join( working, filename_wo_ext(self.txt_dwi_dti.get()) + '_res.nii.gz') filename_roi = os.path.join(working, self.txt_md_mask.get()) filename_csv = os.path.join(working, self.txt_dti_outlier.get()) if filename_csv == '': filename_csv = filename_wo_ext(filename) + '.csv' print filename, filename_roi, filename_csv app = outlier_4dfp_gui.Outlier4dfp( root, filename=filename, filename_roi=filename_roi, filename_csv=filename_csv, dirname=working, obj_return_value=self.txt_dti_outlier) root.mainloop() #tkMessageBox.showinfo(self.title, 'Done: Making mask') def run_get_dti_values(self): filenames = [ '%s_%s' % (self.txt_dti_value.get(), tmp) for tmp in ['MD', 'FA', 'RD', 'RA', 'Eig1', 'Eig2', 'Eig3'] ] filename_roi = self.txt_dti_roi.get() filename_csv = self.txt_output_dti_value.get() if filename_csv == '': self.gen_dti_value_outputname() filename_csv = self.txt_output_dti_value.get() value_matrix = calculate_voxel_values(filenames, filename_roi, filename_csv=filename_csv) print 'Done: Getting DTI values'
class MacroEdit(Toplevel): def __init__(self, root, prtr, settings, log, fn, text, *arg): Toplevel.__init__(self, root, *arg) self.title("Macro Editor") self.fn = fn self.app = root self.settings = settings self.printer = prtr self.log = log self.macroList = self.settings.getMacroList() self.macroEntry = None if fn == None: title = "New macro" self.macroTitle = None self.newMacro = True else: self.newMacro = False self.macroTitle = title = os.path.basename(fn) for m in self.macroList: if self.macroTitle == m[MNAME]: self.macroEntry = m break self.f = LabelFrame(self, text=title) self.entry = Text(self.f, width=80, height=24, relief=RIDGE, bd=2) self.entry.grid(row=1, column=1) self.f.grid(row=1, column=1, columnspan=6) self.bSave = Button(self, text="Save", width=20, command=self.doSave) self.bSave.grid(row=2, column=1) self.bExit = Button(self, text="Exit", width=20, command=self.doExit) self.bExit.grid(row=2, column=2) self.cbvAddButton = IntVar() self.cbAddButton = Checkbutton(self, text="Add Button", variable=self.cbvAddButton, command=self.doAddButton) self.cbAddButton.grid(row=2, column=3) self.buttonText = Entry(self, width=12) self.buttonText.grid(row=2, column=4) l = Label(self, text="Column:", justify=RIGHT) l.grid(row=2, column=5, sticky=E) self.spCol = Spinbox(self, values=[1,2,3], width=12, justify=RIGHT) self.spCol.grid(row=2, column=6) l = Label(self, text="Row:", justify=RIGHT) l.grid(row=3, column=5, sticky=E) self.spRow = Spinbox(self, values=[1,2,3,4,5,6,7,8,9,10], width=12, justify=RIGHT) self.spRow.grid(row=3, column=6) if self.macroEntry != None: self.cbvAddButton.set(1) self.spRow.delete(0, END) self.spRow.insert(0, self.macroEntry[MROW]) self.spCol.delete(0, END) self.spCol.insert(0, self.macroEntry[MCOL]) self.buttonText.delete(0, END) self.buttonText.insert(0, self.macroEntry[MTEXT]) self.initialButtonInfo = [1, self.macroEntry[MCOL], self.macroEntry[MROW], self.macroEntry[MTEXT]] else: self.cbvAddButton.set(0) self.spRow.delete(0, END) self.spRow.insert(0, 1) self.spCol.delete(0, END) self.spCol.insert(0, 1) self.buttonText.delete(0, END) self.initialButtonInfo = [0, 1, 1, ""] self.doAddButton() self.startText = text self.entry.delete("1.0", END) self.entry.insert(END, self.startText) self.entry.edit_modified(False) self.grab_set() self.app.wait_window(self) def doAddButton(self): if self.cbvAddButton.get() == 1: self.buttonText.config(state=NORMAL) self.spRow.config(state=NORMAL) self.spCol.config(state=NORMAL) else: self.buttonText.config(state=DISABLED) self.spRow.config(state=DISABLED) self.spCol.config(state=DISABLED) def buttonInfoChanged(self): if self.cbvAddButton.get() != self.initialButtonInfo[0]: return True if self.initialButtonInfo[1] != int(self.spCol.get()): return True if self.initialButtonInfo[2] != int(self.spRow.get()): return True return self.initialButtonInfo[3] != self.buttonText.get() def doSave(self): if self.cbvAddButton.get() == 1 and self.buttonInfoChanged(): c = int(self.spCol.get()) r = int(self.spRow.get()) for m in self.macroList: if c == m[MCOL] and r == m[MROW]: if self.newMacro or self.macroTitle != m[MNAME]: showerror("Duplicate Location", "That position is already in use by another macro", parent=self) return buttonInfo = [c, r, self.buttonText.get()] else: buttonInfo = None if self.entry.edit_modified() or self.buttonInfoChanged(): l = self.entry.get("1.0", END).rstrip() if self.app.macroEditSave(self.fn, l, buttonInfo, self): self.entry.edit_modified(False) self.initialButtonInfo[0] = self.cbvAddButton.get() self.initialButtonInfo[1] = int(self.spCol.get()) self.initialButtonInfo[2] = int(self.spRow.get()) self.initialButtonInfo[3] = self.buttonText.get() def doExit(self): if self.entry.edit_modified() or self.buttonInfoChanged(): if not tkMessageBox.askyesno("Exit?", "Are you sure you want to exit and lose changes?", parent=self): return self.app.macroEditExit(self.fn) self.destroy()
def createWidgets(self): '''Create and align widgets''' top = self.winfo_toplevel() top.rowconfigure(0, weight=1) top.columnconfigure(0, weight=1) self.rowconfigure(0, weight=1) self.columnconfigure(0, weight=1) self.passwordout = StringVar() self.passwordout.set('- No password generated -') self.isnew = IntVar() ttitle = Label(self, text=versionStr, font=self.getFont(4)) wisnew = Checkbutton(self, height=2, font=self.getFont(), text=('This is a new password, that I have not ' 'used before'), variable=self.isnew, command=self.toggleCheck) tlabel = Label(self, text='Label', font=self.getFont(2)) tpasswordin1 = Label(self, text='Password', font=self.getFont(2)) tpasswordin2 = Label(self, text='Password (again)', font=self.getFont(2)) tlength = Label(self, text='Length', font=self.getFont(2)) talgorithm = Label(self, text='Algorithm', font=self.getFont(2)) tsequence = Label(self, text='Sequence #', font=self.getFont(2)) self.label = ttk.Combobox(self, width=27, font=self.getFont(), postcommand=self.filterLabels) self.passwordin1 = Entry(self, width=27, font=self.getFont(), show="*") self.passwordin2 = Entry(self, width=27, font=self.getFont(), show="*", state=DISABLED) length = Spinbox(self, width=3, font=self.getFont, from_=9, to=171, textvariable=self.lengthVar) self.algorithm = ttk.Combobox(self, width=27, font=self.getFont(), values=algos.algorithms) sequence = Spinbox(self, width=3, font=self.getFont, from_=1, to=sys.maxint, textvariable=self.sequenceVar) genbutton = Button(self, text="Generate password", font=self.getFont(), command=self.validateAndShow, default="active") clrbutton = Button(self, text="Clear fields", font=self.getFont(), command=self.clearIO) self.result = Entry(self, font=self.getFont(4), textvariable=self.passwordout, state="readonly", fg="black", readonlybackground="gray") # Keybindings self.passwordin1.bind('<Return>', lambda e: genbutton.invoke()) self.passwordin2.bind('<Return>', lambda e: genbutton.invoke()) length.bind('<Return>', lambda e: genbutton.invoke()) self.algorithm.bind('<Return>', lambda e: genbutton.invoke()) sequence.bind('<Return>', lambda e: genbutton.invoke()) self.master.bind('<Control-q>', lambda e: self.quit()) self.master.bind('<Escape>', lambda e: self.reset()) self.label.bind('<<ComboboxSelected>>', self.labelSelected) self.label.bind('<FocusOut>', self.labelFocusOut) # Layout widgets in a grid ttitle.grid(row=0, column=0, sticky=N + S + E + W, columnspan=2) wisnew.grid(row=1, column=0, sticky=N + S + E + W, columnspan=2) tlabel.grid(row=2, column=0, sticky=N + S + W) self.label.grid(row=2, column=1, sticky=N + S + E + W) tpasswordin1.grid(row=3, column=0, sticky=N + S + W) self.passwordin1.grid(row=3, column=1, sticky=N + S + E + W) tpasswordin2.grid(row=4, column=0, sticky=N + S + W) self.passwordin2.grid(row=4, column=1, sticky=N + S + E + W) tlength.grid(row=5, column=0, sticky=N + S + W) length.grid(row=5, column=1, sticky=N + S + E + W) talgorithm.grid(row=6, column=0, sticky=N + S + W) self.algorithm.grid(row=6, column=1, sticky=N + S + E + W) tsequence.grid(row=7, column=0, sticky=N + S + W) sequence.grid(row=7, column=1, sticky=N + S + E + W) clrbutton.grid(row=8, column=0, sticky=N + S + E + W, columnspan=2) genbutton.grid(row=9, column=0, sticky=N + S + E + W, columnspan=2) self.result.grid(row=10, column=0, sticky=N + S + E + W, columnspan=2) # Initial values self.algorithm.set(self.settings.algorithm) # Initially, set focus on self.label self.label.focus_set()
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)
class Interface(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.controller = Controller(TKRenderer()) self.initUI() def initUI(self): self.parent.title("Kinect Human Finder") self.style = Style() self.style.theme_use("default") self.pack(fill=BOTH, expand=1) self.columnconfigure(1, weight=1, minsize=100, pad=10) self.rowconfigure(1, weight=1, minsize=100, pad=10) self.initHistoryFrame() self.initImageFrame() self.initMenuFrame() def initHistoryFrame(self): self.historyFrame = Frame(self, height=100, width=200, borderwidth=2) self.backButton = Button(self.historyFrame, text="Back", command=lambda: self.showImage(self.controller.goBack())) self.backButton.pack(side=LEFT, padx=5, pady=5) self.nextButton = Button(self.historyFrame, text="Next", command=lambda: self.showImage(self.controller.goNext())) self.nextButton.pack(side=LEFT, padx=5, pady=5) self.openButton = Button(self.historyFrame, text="Open", command=self.openFile) self.openButton.pack(side=LEFT, padx=(490,0), ipadx = 10, pady=5) self.historyFrame.grid(row=0, column=0, columnspan=2, sticky=W) def initImageFrame(self): self.imageFrame = Frame(self, borderwidth=2) if not os.path.exists(WELCOME_IMAGE_PATH): print "Welcome image not found at:" + WELCOME_IMAGE_PATH else: if not os.path.exists(SECOND_WELCOME_IMAGE_PATH): print "Second welcome image not found at:" + SECOND_WELCOME_IMAGE_PATH else: self.showImage(self.controller.loadImage(WELCOME_IMAGE_PATH)) self.showImage(self.controller.loadImage(SECOND_WELCOME_IMAGE_PATH)) def initMenuFrame(self): self.menuFrame = Frame(self, width=400) self.menuFrame.grid(row=1, column=1, sticky=N + E + S + W) self.menuFrame.columnconfigure(0, weight=0, minsize=100, pad=10) binaryText = Label(self.menuFrame, text="Mapa binarna") preprocessingText = Label(self.menuFrame, text="Preprocessing") cogText = Label(self.menuFrame, text="Środek ciężkości") snakeText = Label(self.menuFrame, text="Metoda aktywnych konturów") # Parameters self.binarySpinFrame = self.createBinarySpinBoxes() self.binarySpinFrame.grid(row=1, column=0, padx=36, pady=(5,15), stick=N + W) self.preprocessFrame = self.createPreprocessBoxes() self.preprocessFrame.grid(row=3, column=0, padx=36, pady=(0,15), stick=N + W) self.cogSpinFrame = self.createCogSpinBoxes() self.cogSpinFrame.grid(row=5, column=0, padx=36, pady=(0,15), stick=N + W) self.snakeSpinFrame = self.createSnakeSpinBoxes() self.snakeSpinFrame.grid(row=7, column=0, padx=36, pady=(0,15), stick=N + W) binaryText.grid(row=0, padx=15, stick=N + W) preprocessingText.grid(row=2, padx=15, stick=N + W) cogText.grid(row=4, padx=15, stick=N + W) snakeText.grid(row=6, padx=15, stick=N + W) # Buttons self.binaryButton = Button(self.menuFrame, text="Generuj mapą binarną", command=lambda: self.showImage(self.controller.generateBinaryMotionBitmap( int(self.binaryThreshold.get()) ))) self.preprocessButton = Button(self.menuFrame, text="Preprocessing", command=lambda: self.showImage(self.controller.getPreprocessedBitmap( int(self.binaryThreshold.get()), int(self.erosion.get()), int(self.densityCoefficient.get()) ))) self.massCenterButton = Button(self.menuFrame, text="Pokaż centrum masy", command=lambda: self.showImage(self.controller.getBitmapWithMassCenter( int(self.binaryThreshold.get()), int(self.erosion.get()), int(self.densityCoefficient.get()), int(self.distanceFromCenterCoefficient.get()) ))) self.snakeButton = Button(self.menuFrame, text="Wyznacz kontur", command=lambda: self.showImage(self.controller.getTheSnake( int(self.binaryThreshold.get()), int(self.erosion.get()), int(self.densityCoefficient.get()), int(self.distanceFromCenterCoefficient.get()), int(self.snakeValue1.get()), int(self.snakeValue2.get()), int(self.snakeValue3.get()) ))) self.binaryButton.grid(row=8, column=0, padx=15, pady=(20,0), stick=N + W) self.preprocessButton.grid(row=9, column=0, padx=15, pady=(20,0), stick=N + W) self.massCenterButton.grid(row=10, column=0, padx=15, pady=(20,0), stick=N + W) self.snakeButton.grid(row=11, column=0, padx=15, pady=(20,0), stick=N + W) def createBinarySpinBoxes(self): frame = Frame(self.menuFrame, width=300) from_ = 0 to = 255 vcmd = (self.register(self.validateSpinBox),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') label1 = Label(frame, text="THRESHOLD (0,255)") self.binaryThreshold = StringVar(value="40") self.binarySpinBox = Spinbox(frame, textvariable=self.binaryThreshold, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label1.grid(row=0, column=0, padx=(0,10), stick=N+W) self.binarySpinBox.grid(row=0, column=1, stick=N+W) return frame def createPreprocessBoxes(self): frame = Frame(self.menuFrame, width=300) from_ = 0 to = 100 vcmd = (self.register(self.validateSpinBox),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') label1 = Label(frame, text="Erozja - ilosc przebiegow") self.erosion = StringVar(value="2") self.erosionSpinBox = Spinbox(frame, textvariable=self.erosion, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label1.grid(row=0, column=0, padx=(0,10), stick=N+W) self.erosionSpinBox.grid(row=0, column=1, stick=N+W) return frame def createCogSpinBoxes(self): frame = Frame(self.menuFrame, width=300) from_ = 0 to = 100 vcmd = (self.register(self.validateSpinBox),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') label1 = Label(frame, text="Wsp. kary za rzadkość") self.densityCoefficient = StringVar(value="10") self.cogSpinBox = Spinbox(frame, textvariable=self.densityCoefficient, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label2 = Label(frame, text="Wsp. kary za odległość") self.distanceFromCenterCoefficient = StringVar(value="60") self.cogSpinBox2 = Spinbox(frame, textvariable=self.distanceFromCenterCoefficient, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label1.grid(row=0, column=0, padx=(0,10), stick=N+W) label2.grid(row=1, column=0, padx=(0,10), stick=N+W) self.cogSpinBox.grid(row=0, column=1, stick=N+W) self.cogSpinBox2.grid(row=1, column=1, stick=N+W) return frame def createSnakeSpinBoxes(self): frame = Frame(self.menuFrame, width=300) from_ = 0 to = 255 vcmd = (self.register(self.validateSpinBox),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') label1 = Label(frame, text="Parametr 1") self.snakeValue1 = StringVar() self.snakeSpinBox = Spinbox(frame, textvariable=self.snakeValue1, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label2 = Label(frame, text="Parametr 2") self.snakeValue2 = StringVar() self.snakeSpinBox2 = Spinbox(frame, textvariable=self.snakeValue2, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label3 = Label(frame, text="Parametr 3") self.snakeValue3 = StringVar() self.snakeSpinBox3 = Spinbox(frame, textvariable=self.snakeValue3, width=4, from_=from_, to=to, validate="key", validatecommand=vcmd) label1.grid(row=0, column=0, padx=(0,10), stick=N+W) label2.grid(row=1, column=0, padx=(0,10), stick=N+W) label3.grid(row=2, column=0, padx=(0,10), stick=N+W) self.snakeSpinBox.grid(row=0, column=1, stick=N+W) self.snakeSpinBox2.grid(row=1, column=1, stick=N+W) self.snakeSpinBox3.grid(row=2, column=1, stick=N+W) return frame def validateSpinBox(self, action, index, value_if_allowed, prior_value, text, validation_type, trigger_type, widget_name): if text in '0123456789': try: if value_if_allowed == "": return True value = int(value_if_allowed) if 0 <= value < 256: return True else: return False except ValueError: return False except: print "Unexpected error:", sys.exc_info()[0] else: return False def showImage(self, img): if img is not None: label = Label(self, image=img) label.image = img # keep a reference! without it the image will be garbaged label.grid(row=1, column=0, sticky=N + W) def openFile(self): fileHandler = tkFileDialog.askopenfile(parent=self, mode='rb', title='Choose the first image') self.controller.clearCache() if fileHandler is not None: self.showImage(self.controller.loadImage(fileHandler)) fileHandler2 = tkFileDialog.askopenfile(parent=self, mode='rb', title='Choose the second image') if fileHandler2 is not None: self.showImage(self.controller.loadImage(fileHandler2)) def setSize(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 Application(Frame): MAXWORDLEN = 20 DEFAULTWORDLEN = 3 MANDATORY1stCHAR=0 def __init__(self, master=None): Frame.__init__(self, master, padx=3, pady=3) self.dictionaryfile = None self.menubar = Menu() self.__createWidgets() self.menubar.add_cascade(label='File', menu=self.__File) self.menubar.add_cascade(label='Options', menu=self.__Options) self.menubar.add_command(label='About', command=self.__about) self.__params.grid(row=0, column=0, sticky=W) self.__res_pane = Frame() self.__res_pane.grid(row=2, column=0, sticky=E + W) self.__status = Label(anchor=W, relief=SUNKEN) self.__status.grid(row=3, column=0, sticky=E + W) self.osDictFile() self.matchobj = None if self.dictionaryfile is None: self.status('No dictionary defined!') master.config(menu=self.menubar) def __createWidgets(self): self.__params = Frame(padx=5, pady=5) Label(text='Letters: ', anchor=E).grid(row=0, column=0, sticky=E, in_=self.__params) self.__char_entry = Entry(width=10) self.__chk1st = Checkbutton(variable=self.MANDATORY1stCHAR, command=self.__CB) Label(text='First letter appears in every result ', anchor=W).grid( row=0, column=4, sticky=E, in_=self.__params) self.__char_entry.grid(row=0, column=1, columnspan=2, sticky=W, in_=self.__params) self.__chk1st.grid(row=0, column=3, sticky=W, in_=self.__params) Label(text='Minimum length of result words: ', anchor=E).grid( row=1, column=0, sticky=E, in_=self.__params) self.__word_length_ctrl = Spinbox(from_=1, to=Application.MAXWORDLEN, width=2) self.__word_length_ctrl.delete(0, END) self.__word_length_ctrl.insert(0, Application. DEFAULTWORDLEN) self.__word_length_ctrl.grid(row=1, column=1, in_=self.__params, sticky=W) self.__go_button = Button(text='Go', command=self.__findWords) self.__go_button.grid(row=1, column=2, sticky=E, in_=self.__params) self.__Options = Menu() self.__Options.add_command(label='Choose dictionary', command=self.__choosedict) self.__File = Menu() self.__File.add_command(label='Export as ODT (Open document text)', command=self.__export) self.__char_entry.focus_set() self.__char_entry.bind("<Return>", self.__keyPressEnter) def __CB(self): self.MANDATORY1stCHAR = not self.MANDATORY1stCHAR def __choosedict(self): try: self.dictionaryfile = tkFileDialog.askopenfile(mode='r').name self.status('') except AttributeError: pass def osDictFile(self): if 'linux' in sys.platform: self.dictionaryfile = '/usr/share/dict/words' def __about(self): AboutDialog(self) def status(self, text): self.__status.config(text=text) self.__status.update_idletasks() def __findWords(self): self.__res_pane.grid_forget() chars = self.__char_entry.get() minlen = int(self.__word_length_ctrl.get()) if len(chars) < minlen: tkMessageBox.showerror(title='Not enough letters', message='''Not enough letters given\n You must give at least as many letters as the minimum required word length''') return res = self.__getres(minlen, chars) self.__res_pane = ResultPane(res) self.__res_pane.grid(row=2, column=0, sticky=E + W) def __getres(self, minlen, chars): firstpass = True while True: try: self.matchobj = None if firstpass and self.dictionaryfile is None: self.matchobj = Match(minlen=minlen, chars=chars, statushandler=self.status, mand1st=self.MANDATORY1stCHAR) firstpass = False else: self.matchobj = Match(minlen=minlen, chars=chars, dict=self.dictionaryfile, statushandler=self.status, mand1st=self.MANDATORY1stCHAR) res = self.matchobj.wordMatch() return res except IOError: ans = tkMessageBox.askyesno(title='No Dictionary', message='''No dictionary file was found, would you like to choose a dictionary file? (No) aborts the application''') if ans: self.__choosedict() else: sys.exit() def __keyPressEnter(self, event): self.__findWords() def __export(self): options= {} options['defaultextension'] = '.odt' options['filetypes'] = [('all files', '.*'), ('Open Document Text', '.odt')] options['initialdir'] = expanduser('~') options['initialfile'] = self.__char_entry.get() f = asksaveasfilename(**options) outfile = Doc(self.matchobj) outfile.write(unicode(f, "utf-8"))
class SettingWindow(Toplevel): def __init__(self, master, max_num_features, num_frames, mser_image): Toplevel.__init__(self, master) self.protocol('WM_DELETE_WINDOW', self.withdraw) self.notebook = ttk.Notebook(self) frame_feats = ttk.Frame(self.notebook) frame_forest = ttk.Frame(self.notebook) frame_mser = ttk.Frame(self.notebook) frame_other = ttk.Frame(self.notebook) self.notebook.add(frame_feats, text="Features ") self.notebook.add(frame_forest, text=" Forest ") self.notebook.add(frame_mser, text=" MSER ") self.notebook.add(frame_other, text=" Other ") self.max_num_feats = max_num_features self.selection = None self.mser_image = mser_image rand_row = random.randint(1, 512-200) rand_col = random.randint(1, 512-110) self.mser_area = mser_image[rand_row:rand_row+180, rand_col:rand_col+100] # read images from icons folder self.hf0_img = PhotoImage(file="./icons/hf0.gif") self.hf1_img = PhotoImage(file="./icons/hf1.gif") self.hf2_img = PhotoImage(file="./icons/hf2.gif") self.hf3_img = PhotoImage(file="./icons/hf3.gif") self.hf4_img = PhotoImage(file="./icons/hf4.gif") self.hf5_img = PhotoImage(file="./icons/hf5.gif") self.features_vars = list() for i in range(max_num_features): self.features_vars.append(IntVar()) Label(frame_feats, text="Patch size (" + u"\N{GREEK SMALL LETTER PI}" + "):").grid(row=0, column=0, pady=5) self.patch_size_spinbox = Spinbox(frame_feats, from_=3, to=30, width=3) self.patch_size_spinbox.delete(0, END) self.patch_size_spinbox.insert(END, 10) self.patch_size_spinbox.grid(row=0, column=1, padx=5) f1 = ttk.Labelframe(frame_feats, text='Mean filter') f1.grid(row=1, columnspan=2) Label(f1, text=u"\N{GREEK SMALL LETTER PI}").grid(row=0, column=0) Checkbutton(f1, text="R", variable=self.features_vars[0]).grid(row=0, column=1) Checkbutton(f1, text="G", variable=self.features_vars[1]).grid(row=0, column=2) Checkbutton(f1, text="B", variable=self.features_vars[2]).grid(row=0, column=3) Label(f1, text=u"\N{GREEK SMALL LETTER PI}" + "/2").grid(row=1, column=0) Checkbutton(f1, text="R", variable=self.features_vars[3]).grid(row=1, column=1) Checkbutton(f1, text="G", variable=self.features_vars[4]).grid(row=1, column=2) Checkbutton(f1, text="B", variable=self.features_vars[5]).grid(row=1, column=3) f2 = ttk.Labelframe(frame_feats, text="Gaussian filter") f2.grid(row=2, columnspan=2) Label(f2, text=str(1.0)).grid(row=0, column=0) Checkbutton(f2, text="R", variable=self.features_vars[6]).grid(row=0, column=1) Checkbutton(f2, text="G", variable=self.features_vars[7]).grid(row=0, column=2) Checkbutton(f2, text="B", variable=self.features_vars[8]).grid(row=0, column=3) Label(f2, text=str(3.5)).grid(row=1, column=0) Checkbutton(f2, text="R", variable=self.features_vars[9]).grid(row=1, column=1) Checkbutton(f2, text="G", variable=self.features_vars[10]).grid(row=1, column=2) Checkbutton(f2, text="B", variable=self.features_vars[11]).grid(row=1, column=3) f3 = ttk.Labelframe(frame_feats, text="Laplacian of gaussian") f3.grid(row=3, columnspan=2) Label(f3, text=str(2.0)).grid(row=0, column=0) Checkbutton(f3, text="R", variable=self.features_vars[12]).grid(row=0, column=1) Checkbutton(f3, text="G", variable=self.features_vars[13]).grid(row=0, column=2) Checkbutton(f3, text="B", variable=self.features_vars[14]).grid(row=0, column=3) Label(f3, text=str(3.5)).grid(row=1, column=0) Checkbutton(f3, text="R", variable=self.features_vars[15]).grid(row=1, column=1) Checkbutton(f3, text="G", variable=self.features_vars[16]).grid(row=1, column=2) Checkbutton(f3, text="B", variable=self.features_vars[17]).grid(row=1, column=3) f4 = ttk.Labelframe(frame_feats, text="Haar-like features") f4.grid(row=1, rowspan=2, column=3, padx=5) Checkbutton(f4, image=self.hf0_img, variable=self.features_vars[18]).grid(row=0, column=0) Checkbutton(f4, image=self.hf1_img, variable=self.features_vars[19]).grid(row=0, column=1) Checkbutton(f4, image=self.hf2_img, variable=self.features_vars[20]).grid(row=1, column=0) Checkbutton(f4, image=self.hf3_img, variable=self.features_vars[21]).grid(row=1, column=1) Checkbutton(f4, image=self.hf4_img, variable=self.features_vars[22]).grid(row=2, column=0) Checkbutton(f4, image=self.hf5_img, variable=self.features_vars[23]).grid(row=2, column=1) buttons_paned_window = PanedWindow(frame_feats, orient=VERTICAL) buttons_paned_window.grid(row=3, column=3) self.select_all_button = Button(buttons_paned_window, text="Select all", command=self._select_all) buttons_paned_window.add(self.select_all_button) self.clear_selection_button = Button(buttons_paned_window, text="Clear selection", command=self._clear_selection) buttons_paned_window.add(self.clear_selection_button) # default values for j in [0, 1, 3, 6, 7, 9, 15, 21, 23]: self.features_vars[j].set(1) # FOREST FRAMES # number of trees f5 = ttk.Labelframe(frame_forest, text="Number of trees") f5.grid(row=0, columnspan=2, pady=5, padx=5) Label(f5, text="N").grid(row=1, column=0) self.num_trees_scale = Scale(f5, from_=5, to=500, resolution=5, orient=HORIZONTAL) self.num_trees_scale.set(300) self.num_trees_scale.grid(row=0, column=1, rowspan=2) # depth single tree f6 = ttk.Labelframe(frame_forest, text="Depth single tree") f6.grid(row=1, columnspan=2, pady=5, padx=5) Label(f6, text="d").grid(row=1, column=0) self.depth_tree_scale = Scale(f6, from_=2, to=20, orient=HORIZONTAL) self.depth_tree_scale.set(3) self.depth_tree_scale.grid(row=0, column=1, rowspan=2) # percentage number of features f7 = ttk.Labelframe(frame_forest, text="% subset of features") f7.grid(row=2, columnspan=2, pady=5, padx=5) Label(f7, text="m").grid(row=1, column=0) self.percentage_feats_scale = Scale(f7, from_=0.0, to=1, resolution=0.05, orient=HORIZONTAL) self.percentage_feats_scale.set(0.5) self.percentage_feats_scale.grid(row=0, column=1, rowspan=2) # mser frame # delta f8 = ttk.Labelframe(frame_mser, text="Delta") f8.grid(row=0, columnspan=2, pady=5, padx=5) Label(f8, text=u"\N{GREEK SMALL LETTER DELTA}").grid(row=1, column=0) self.delta_scale = Scale(f8, from_=1, to=10, resolution=1, orient=HORIZONTAL) self.delta_scale.set(2) self.delta_scale.grid(row=0, column=1, rowspan=2) # min area f9 = ttk.Labelframe(frame_mser, text="Minimum area") f9.grid(row=1, columnspan=2, pady=5, padx=5) Label(f9, text="m").grid(row=1, column=0) self.min_area_scale = Scale(f9, from_=2, to=200, orient=HORIZONTAL) self.min_area_scale.set(10) self.min_area_scale.grid(row=0, column=1, rowspan=2) # percentage number of features f10 = ttk.Labelframe(frame_mser, text="Maximum area") f10.grid(row=2, columnspan=2, pady=5, padx=5) Label(f10, text="M").grid(row=1, column=0) self.max_area_scale = Scale(f10, from_=50, to=1000, resolution=5, orient=HORIZONTAL) self.max_area_scale.set(350) self.max_area_scale.grid(row=0, column=1, rowspan=2) # mser image f11 = ttk.Labelframe(frame_mser) f11.grid(row=0, rowspan=3, column=2, padx=5) self.mser_img_array = Image.fromarray(self.mser_area, "RGB") self.mser_img = ImageTk.PhotoImage(self.mser_img_array) img_label = Label(f11, image=self.mser_img) img_label.grid(row=0, column=0) buttons_p_w_mser = PanedWindow(f11, orient=HORIZONTAL) try_button = Button(f11, text="Try", command=self.try_mser) buttons_p_w_mser.add(try_button) change_button = Button(f11, text="New img", command=self.change_mser) buttons_p_w_mser.add(change_button) buttons_p_w_mser.grid(row=1, column=0) # other frame f12 = ttk.Labelframe(frame_other, text="Refinement") f12.grid(row=0, columnspan=2, pady=5, padx=5) Label(f12, text=u"\N{GREEK CAPITAL LETTER PHI}_l").grid(row=1, column=0) self.low_thresh_scale = Scale(f12, from_=0, to=1, resolution=0.05, orient=HORIZONTAL, length=90) self.low_thresh_scale.set(0.45) self.low_thresh_scale.grid(row=0, column=1, rowspan=2) Label(f12, text=u"\N{GREEK CAPITAL LETTER PHI}_h").grid(row=3, column=0) self.high_thresh_scale = Scale(f12, from_=0, to=1, resolution=0.05, orient=HORIZONTAL, length=90) self.high_thresh_scale.set(0.65) self.high_thresh_scale.grid(row=2, column=1, rowspan=2) f13 = ttk.Labelframe(frame_other, text="Dots distance") f13.grid(row=1, columnspan=2, pady=5, padx=5) Label(f13, text=u" \N{GREEK SMALL LETTER SIGMA}").grid(row=1, column=0) self.dots_distance_scale = Scale(f13, from_=1, to=20, resolution=1, orient=HORIZONTAL, length=90) self.dots_distance_scale.set(6) self.dots_distance_scale.grid(row=0, column=1, rowspan=2) f14 = ttk.Labelframe(frame_other, text="Tracks") f14.grid(row=0, column=3, pady=5, padx=5) Label(f14, text="N").grid(row=1, column=0) self.num_frames_tracks_spinbox = Spinbox(f14, from_=2, to=num_frames, width=10) self.num_frames_tracks_spinbox.delete(0, END) self.num_frames_tracks_spinbox.insert(END, num_frames) self.num_frames_tracks_spinbox.grid(row=0, column=1, rowspan=2) Label(f14, text=u"\N{GREEK SMALL LETTER TAU}").grid(row=3, column=0) self.gaps_scale = Scale(f14, from_=1, to=10, resolution=1, orient=HORIZONTAL, length=90) self.gaps_scale.set(2) self.gaps_scale.grid(row=2, column=1, rowspan=2) self.notebook.pack(padx=1, pady=1) save_button = Button(self, text=" Save and Close window ", command=self.withdraw) save_button.pack(pady=2) def _select_all(self): for i, var in enumerate(self.features_vars): var.set(1) def _clear_selection(self): for i, var in enumerate(self.features_vars): var.set(0) def change_mser(self): rand_row = random.randint(1, 512-200) rand_col = random.randint(1, 512-110) self.mser_area = self.mser_image[rand_row:rand_row+180, rand_col:rand_col+100] self.update_mser_image(self.mser_area) def try_mser(self): delta = self.delta_scale.get() min_area = self.min_area_scale.get() max_area = self.max_area_scale.get() image = self.mser_area red_c = image[:,:,0] red_c = cv2.equalizeHist(red_c) det_img = image.copy() mser = cv2.MSER(delta, _min_area=min_area, _max_area=max_area) regions = mser.detect(red_c) cp = list() new_c = np.zeros(self.mser_area.shape, dtype=np.uint8) for r in regions: for point in r: cp.append(point) det_img[point[1], point[0], 0] = 0 det_img[point[1], point[0], 1] = 0 det_img[point[1], point[0], 2] = 204 #new_c[point[1], point[0]] = 255 self.update_mser_image(det_img) def update_mser_image(self, new_image): self.mser_img_array = Image.fromarray(new_image) self.mser_img.paste(self.mser_img_array) def get_patch_size(self): patch_size = self.patch_size_spinbox.get() return int(patch_size) def get_num_frames_tracks(self): num_frames_tracks = self.num_frames_tracks_spinbox.get() return int(num_frames_tracks) def get_mser_opts(self): return [self.delta_scale.get(), self.min_area_scale.get(), self.max_area_scale.get()] def get_forest_opts(self): return [self.num_trees_scale.get(), self.depth_tree_scale.get(), self.percentage_feats_scale.get()] def get_low_thresh(self): return self.low_thresh_scale.get() def get_high_thresh(self): return self.high_thresh_scale.get() def get_dots_distance(self): return int(self.dots_distance_scale.get()) def get_selection_mask(self): if self.selection is not None: return self.selection selection_mask = np.zeros((self.max_num_feats, ), dtype='bool') for i, var in enumerate(self.features_vars): selection_mask[i] = var.get() self.selection = selection_mask return selection_mask
class CreateMask(Frame): def __init__(self, parent, filename=None, dirname=None, mask4d=False, obj_return_value=None): Frame.__init__(self, parent) self.parent = parent self.obj_return_value = obj_return_value if dirname is None: self.dirname = '' else: self.dirname = dirname if filename is None or not os.path.isfile(filename): if dirname is not None: filename = tkFileDialog.askopenfilename(initialdir=dirname) else: filename = tkFileDialog.askopenfilename() if not os.path.isfile(filename): parent.destroy() return self.readImage(filename) _, _, filename_mask = create_mask.set_filenames(filename) self.filename_mask = filename_mask + '.nii.gz' if mask4d: if len(self.shape) > 3: self.mask_base = np.zeros(self.shape, dtype=np.int8) self.mask = self.mask_base[:, :, :, 0] self.mask4d = True else: self.mask = np.zeros(self.shape[:3], dtype=np.int8) self.mask4d = False self.volume = 0 self.initUI() self.modifyUI() self.drawSlice() def initUI(self): self.frame_bottom = Frame(self) self.frame_main = Frame(self) def modifyUI(self): frame_bottom = self.frame_bottom frame_main = self.frame_main self.sliceView = [ ImshowMplCanvas(frame_main) for k in range(self.shape[2]) ] self.sliceSpin = [ MySpinBox(frame_main, k) for k in range(self.shape[2]) ] #Layout self.parent.title('CreateMask') max_spin = 0 if self.mask4d: max_spin = self.shape[3] - 1 self.spin_volume = Spinbox(frame_bottom, from_=0, to=max_spin, increment=1, command=self.change_volume, width=8) self.reset_box(self.spin_volume, 0) buttonMask = Button(frame_bottom, text='B0 from Bval...', command=self.createBaseImage) buttonMaskCreate = Button(frame_bottom, text='Create', command=self.createMaskAll) buttonSave = Button(frame_bottom, text='Save', command=self.saveMask) self.drawmask = BooleanVar() buttonDrawMask = Checkbutton(frame_bottom, text='Draw Mask', variable=self.drawmask, command=self.drawSlice) num_col = 3 num_row = 6 for col in range(self.shape[2] / num_row): for k in range(num_row): ind = col * num_row + k if ind >= self.shape[2]: break self.sliceView[ind].get_tk_widget().grid(row=k, column=col * num_col, sticky=NSEW) self.sliceSpin[ind].grid(row=k, column=col * num_col + 1) self.frame_main.grid_columnconfigure(col * num_col, weight=1) for k in range(num_row): self.frame_main.grid_rowconfigure(k, weight=1) self.spin_volume.grid(row=0, column=0) buttonMask.grid(row=0, column=1) buttonMaskCreate.grid(row=0, column=2) buttonSave.grid(row=0, column=3) buttonDrawMask.grid(row=0, column=5) frame_bottom.pack(side=BOTTOM) frame_main.pack(fill=BOTH, expand=TRUE) self.pack(fill=BOTH, expand=True) def change_volume(self): if not self.mask4d: return self.volume = int(self.spin_volume.get()) self.data = self.data_base[:, :, :, self.volume] self.mask = self.mask_base[:, :, :, self.volume] self.drawSlice() def saveMask(self): print 'save mask to %s' % self.filename_mask if self.mask4d: img_out = nib.Nifti1Image(self.mask_base, self.img.get_affine(), self.img.get_header()) else: img_out = nib.Nifti1Image(self.mask, self.img.get_affine(), self.img.get_header()) nib.save(img_out, os.path.join(self.dirname, self.filename_mask)) if self.obj_return_value is not None: self.obj_return_value.delete(0, len(self.obj_return_value.get())) self.obj_return_value.insert(0, os.path.basename(self.filename_mask)) def readImage(self, filename): self.filename = filename self.img = nib.load(filename) self.shape = self.img.shape self.data_base = self.img.get_data() if len(self.data_base.shape) > 3: for f in range(self.data_base.shape[3]): for z in range(self.data_base.shape[2]): self.data_base[:, :, z, f] = ndimage.gaussian_filter( self.data_base[:, :, z, f], sigma=0.5) self.data = self.data_base[:, :, :, 0] else: for z in range(self.data_base.shape[2]): self.data_base[:, :, z] = ndimage.gaussian_filter( self.data_base[:, :, z], sigma=0.5) self.data = self.data_base def createBaseImage(self): bvalFilename = tkFileDialog.askopenfilename() if bvalFilename: b0frames = parameter.get_b0_from_bval(bvalFilename) print self.filename, b0frames filename, filename_fltd, filename_mask = create_mask.set_filenames( self.filename) create_mask.make_base_image(filename, filename_fltd + '.nii.gz', b0frames) self.filename_mask = filename_mask + '.nii.gz' self.readImage(filename_fltd + '.nii.gz') self.drawSlice() def setSpinBoxConnect(self): for k in range(self.shape[2]): #self.sliceSpin[k].valueChanged.connect(lambda: self.createMaskSlice(k)) #self.sliceSpin[k].configure(command=lambda:self.createMaskSlice(k, self.sliceSpin[k])) self.sliceSpin[k].configure(command=functools.partial( self.createMaskSlice, k, self.sliceSpin[k])) def drawSlice(self): for k in range(self.shape[2]): self.sliceView[k].drawData(self.data[:, :, k], self.mask[:, :, k], self.drawmask.get()) def reset_box(self, box, text): box.delete(0, len(box.get())) box.insert(0, text) def createMaskSlice(self, k, value=None): self.mask[:, :, k] = 0 if value is None: value_i = int(self.sliceSpin[k].get()) else: value_i = int(value.get()) #create_mask.mask_from_threshold(self.com_x[k], self.com_y[k], self.sliceSpin[k].value(), self.data, self.mask, k) create_mask.mask_from_threshold(self.com_x[k], self.com_y[k], value_i, self.data, self.mask, k) self.sliceView[k].drawData(self.data[:, :, k], self.mask[:, :, k], self.drawmask.get()) def createMaskAll(self): self.drawmask.set(True) hdr = self.img.get_header() zooms = hdr.get_zooms() shape = self.shape self.com_x, self.com_y, roi_x, roi_y = create_mask.calculate_com( self.data, zooms) for k in range(shape[2]): dat_subflt = self.data[roi_x[k][0]:roi_x[k][1], roi_y[k][0]:roi_y[k][1], k].flatten() #threshold = np.mean(dat_subflt) threshold = np.mean(dat_subflt) + np.std(dat_subflt) self.reset_box(self.sliceSpin[k], int(threshold)) self.createMaskSlice(k) #create_mask.mask_from_threshold(self.com_x[k], self.com_y[k], threshold, self.data, self.mask, k) #self.drawSlice() self.setSpinBoxConnect()
class PeakFinder: def __init__(self, master): self.master = master master.title(u"Weiterreißwiderstand") self.big_font = tkFont.Font(family='Helvetica', size=36, weight='bold') self.normal_font = tkFont.Font(family='Helvetica', size=20, weight='normal') self.X = None self.Y = None self.maxima = None self.maxima_x = None self.number_max = 0 self.number_max_string = StringVar() self.max_max = 0.0 self.max_max_string = StringVar() self.min_max = 0.0 self.min_max_string = StringVar() self.median = 0.0 self.median_string = StringVar() self.w_string = StringVar() self.distance_string = StringVar() self.method_string = StringVar() self.sample_file = '' self.project_file = '' self.w = 0.0 self.distance = 0.0 ######################################################################### ''' Optionen für Dateidialoge ''' self.file_opt = options = {} options['defaultextension'] = '.txt' options['filetypes'] = [('text files', '.txt')] options['initialfile'] = '' options['parent'] = master options['title'] = 'Messung importieren' self.file_opt2 = options = {} options['defaultextension'] = '.txt' options['filetypes'] = [('text files', '.txt')] options['initialfile'] = '' options['parent'] = master options['title'] = 'Neues Projekt erstellen.' self.file_opt3 = options = {} options['defaultextension'] = '.txt' options['filetypes'] = [('text files', '.txt')] options['initialfile'] = '' options['parent'] = master options['title'] = 'Vorhandenes Projekt öffnen.' ##################################################################################################### ''' GUI ''' ''' MenueLeiste ''' ############################################################################################### self.menubar = Menu(master) # create a pulldown menu, and add it to the menu bar self.filemenu = Menu(self.menubar, tearoff=0) self.filemenu.add_command(label="Neu", command=self.new_file, font = self.normal_font) self.filemenu.add_command(label=u"Öffnen...", command=self.open_file, font = self.normal_font) self.filemenu.add_separator() self.filemenu.add_command(label="Messung importieren", command=self.get_filepath, font = self.normal_font) self.filemenu.add_separator() self.filemenu.add_command(label="Beenden", command=root.quit, font = self.normal_font) self.menubar.add_cascade(label="Datei", menu=self.filemenu, font = self.normal_font) self.helpmenu = Menu(self.menubar, tearoff=0) self.helpmenu.add_command(label="Hilfe", command=self.help, font = self.normal_font) self.helpmenu.add_command(label=u"Über", command=self.info, font = self.normal_font) self.menubar.add_cascade(label="Hilfe", menu=self.helpmenu, font = self.normal_font) master.config(menu=self.menubar) ############################################################################################## ''' Parameter ''' self.option_label = ttk.Label(master, text = "Parameter", font = self.big_font) self.option_label.grid(row = 0, rowspan = 2, columnspan = 4, sticky=W) self.delta_x_label = ttk.Label(master, text = "Delta X", font = self.normal_font) self.delta_x_label.grid(row = 3, sticky=W) self.delta_x_spinbox = Spinbox(master, from_=10, to=500, increment = 10, font = self.normal_font, width = 4, command = self.plot) self.delta_x_spinbox.grid(row = 3, column = 1) self.delta_y_label = ttk.Label(master, text = "Delta Y", font = self.normal_font) self.delta_y_label.grid(row = 4, column = 0, sticky=W) self.delta_y_spinbox = Spinbox(master, from_=0, to=2, increment = 0.05, font = self.normal_font, width = 4, command = self.plot) self.delta_y_spinbox.grid(row = 4, column = 1) # self.plot_button = Button(master, text = "Plotten", font = self.normal_font, command = self.plot, width = 10) # self.plot_button.grid(row = 3, column = 2, columnspan = 1) self.sample_thickness_label = ttk.Label(master, text = "Probendicke [mm]", font = self.normal_font) self.sample_thickness_label.grid(row = 5, column = 0, sticky=W) self.sample_thickness_entry = ttk.Entry(master, font = self.normal_font, width = 5) self.sample_thickness_entry.grid(row = 5, column = 1) self.calculate_button = Button(master, text = "Berechnen", font = self.normal_font, command = self.calculate, width = 10) self.calculate_button.grid(row = 6, column = 1, columnspan = 1) ########################################################################################################## ''' Speichern ''' self.save_label = ttk.Label(master, text = "Auswertung Speichern", font = self.big_font) self.save_label.grid(row = 7, rowspan = 2, columnspan = 4, sticky=W) self.sample_name_label = ttk.Label(master, text = "Probenname", font = self.normal_font) self.sample_name_label.grid(row = 9, sticky=W) self.sample_name_entry = ttk.Entry(master, font = self.normal_font) self.sample_name_entry.grid(row = 9, column = 1, columnspan = 3) self.comment_label = ttk.Label(master, text = "Kommentar", font = self.normal_font) self.comment_label.grid(row = 10, sticky=W) self.comment_entry = ttk.Entry(master, font = self.normal_font) self.comment_entry.grid(row = 10, column = 1, columnspan = 3) self.save_button = Button(master, text = "Speichern", font = self.normal_font, command = self.save, width = 10) self.save_button.grid(row = 12, column = 1, columnspan = 2, sticky=W) ############################################################################################################## ''' Analyse ''' self.number_max_label = ttk.Label(master, text = "Anzahl Maxima:", font = self.normal_font) self.number_max_label.grid(row = 9, column = 6, sticky=W) self.number_max_int_label = ttk.Label(master, textvariable = self.number_max_string, font = self.normal_font) self.number_max_int_label.grid(row = 9, column = 7) self.max_max_label = ttk.Label(master, text = "Median [N]:", font = self.normal_font) self.max_max_label.grid(row = 10, column = 6, sticky=W) self.max_max_int_label = ttk.Label(master, textvariable = self.median_string, font = self.normal_font) self.max_max_int_label.grid(row = 10, column = 7) self.min_max_label = ttk.Label(master, text = u"Weiterreißwiderstand [N/mm]:", font = self.normal_font) self.min_max_label.grid(row = 11, column = 6, sticky=W) self.min_max_int_label = ttk.Label(master, textvariable = self.w_string, font = self.normal_font) self.min_max_int_label.grid(row = 11, column = 7) self.min_max_label = ttk.Label(master, text = u"Spannweite [mm]:", font = self.normal_font) self.min_max_label.grid(row = 12, column = 6, sticky=W) self.min_max_int_label = ttk.Label(master, textvariable = self.distance_string, font = self.normal_font) self.min_max_int_label.grid(row = 12, column = 7) self.method_label = ttk.Label(master, text="Methode:", font = self.normal_font) self.method_label.grid(row = 13, column = 6, sticky=W) self.method_method_label = ttk.Label(master, textvariable = self.method_string, font = self.normal_font) self.method_method_label.grid(row = 13, column = 7) ########################################################################################################## ''' Canvas ''' # Create a canvas self.w, self.h = 800, 500 self.canvas = Canvas(master, width=self.w, height=self.h) self.canvas.grid(row = 0, column = 5, columnspan = 5, rowspan = 9) ''' Funktionen ''' def plot(self): try: #Maxima finden self._max, self._min = self.peakdetect(self.Y, self.X, float(self.delta_x_spinbox.get()), float(self.delta_y_spinbox.get())) #Maxima in Array schreiben self.xm = [p[0] for p in self._max] self.ym = [p[1] for p in self._max] #Maxima verarbeiten self.maxima = self.ym self.maxima_x = self.xm self.number_max = len(self._max) self.number_max_string.set(str(self.number_max)) self.max_max = max(self.ym) self.max_max_string.set(str(self.max_max)) self.min_max = min(self.ym) self.min_max_string.set(str(self.min_max)) #Graph Plotten self.fig = plt.Figure(figsize=(8, 5), dpi=100) self.ax = self.fig.add_subplot(111) self.ax.plot(self.X, self.Y) self.ax.plot(self.xm, self.ym, 'ro', markersize = 10) #self.ax.axvline(x=10, ymin = 0, ymax = 1, linewidth = 2, color = 'g') self.ax.axis('auto') self.ax.set_xlabel('Weg [mm]') self.ax.set_ylabel('Kraft [N]') self.fig_photo = self.draw_figure(self.canvas, self.fig, loc=(0, 0)) #Methode Anzeigen if 1 < self.number_max <= 5 : self.method_string.set('Median') elif self.number_max < 2: self.method_string.set('Maximum') else: self.method_string.set('80% Median') except: tkMessageBox.showwarning('Fehler bei der Berechnung!', 'Bitte Eingaben prüfen.') def calculate(self): if self.sample_thickness_entry.get() == '': tkMessageBox.showwarning('Keine Probendicke eingetragen!', 'Bitte Probendicke zur Berechnung eintragen.') else: if self.number_max <= 5: self.median_calculation() else: self.percent_calculation() def percent_calculation(self): #Berechnung 80 Prozent von #Maxima n = int(round(self.number_max*0.8)) delta = self.number_max - n #Entfernen der ersten und zweiten 10 Prozent del self.maxima[0:int(round(delta/2))] del self.maxima[len(self.maxima)-int(round(delta-int(round(delta/2)))):len(self.maxima)] del self.maxima_x[0:int(round(delta/2))] del self.maxima_x[len(self.maxima_x)-int(round(delta-int(round(delta/2)))):len(self.maxima_x)] #Berechnung des Weiterreisswiderstands try: d = float(self.sample_thickness_entry.get()) #Auslesen der Probendicke self.median = np.median(self.maxima) #Berechnung des Medians self.w = self.median/d self.median_string.set(str(self.median)) self.w_string.set(str(self.w)) #Berechnung der Spannweite self.distance = self.maxima_x[len(self.maxima_x)-1]-self.maxima_x[0] self.distance_string.set(str(self.distance)) except: tkMessageBox.showwarning(u'Probendicke hat falsche Formatierung!', u'Bitte Probendicke in der Form Z.ZZ eingeben (Z=Zahl).') def median_calculation(self): #Berechnung des Weiterreisswiderstands try: d = float(self.sample_thickness_entry.get()) #Auslesen der Probendicke self.median = np.median(self.maxima) #Berechnung des Medians self.w = self.median/d self.median_string.set(str(self.median)) self.w_string.set(str(self.w)) #Berechnung der Spannweite self.distance = self.maxima_x[len(self.maxima_x)-1]-self.maxima_x[0] self.distance_string.set(str(self.distance)) except: tkMessageBox.showwarning(u'Probendicke hat falsche Formatierung!', u'Bitte Probendicke in der Form Z.ZZ eingeben (Z=Zahl).') def save(self): #Speichern der Auswertung im Projekt if self.project_file != '' and self.sample_name_entry.get() != '': maxima_string = '' for maximum in self.maxima: maxima_string += str(maximum)+'\t' print(maxima_string) self.project_file_write = open(self.project_file, 'a') self.project_file_write.write('\n'+self.sample_name_entry.get()+'\t'+str(self.number_max)+'\t'+str(self.median)+'\t'+self.sample_thickness_entry.get()+'\t'+str(self.w)+'\t'+str(self.distance)+'\t'+self.method_string.get()+'\t'+self.comment_entry.get()+'\t'+maxima_string) self.project_file_write.close() elif self.project_file == '': tkMessageBox.showwarning(u'Keine Datei zum Speichern geöffnet!', u'Bitte Datei zum Speichern öffnen oder neue Datei erstellen.') elif self.sample_name_entry.get() == '': tkMessageBox.showwarning(u'Keine Probenname eingetragen!', u'Bitte Probenname eintragen.') def new_file(self): #Neues Projekt erstellen self.project_file = tkFileDialog.asksaveasfilename(**self.file_opt2) self.project_file_write = open(self.project_file, 'a') self.project_file_write.write('Probenname\tNMax\tMedian\tProbendicke\tWeiterreisswiderstand\tSpannweite\tMethode\tKommentar\tMaxima(80%)') self.project_file_write.close() def open_file(self): #Bestehendes Projekt öffnen self.project_file = tkFileDialog.askopenfilename(**self.file_opt3) def get_filepath(self): #Dateipfad von Messung erfragen self.sample_file = tkFileDialog.askopenfilename(**self.file_opt) self.import_data(self.sample_file) def import_data(self, loadfile): #Messung importieren self.X, self.Y = np.loadtxt(loadfile, usecols = (1,0), unpack = True) self.plot() def help(self): #Hilfeseite zeigen top = Toplevel() top.title("Hilfe") label1 = ttk.Label(top, text = u"Projekt öffnen/erstellen", font=self.normal_font) label1.pack() msg1 = Message(top, text=u'Über Datei -> Neu muss zu Beginn eine .txt-Datei erstellt werden. In dieser werden die Ergebnisse der Auswertung gespeichert.\n\nAlternativ kann über Datei -> Öffnen... ein bereits existierendes Projekt mit den neuen Ergebnissen erweitert werden. \n\n') msg1.pack() label2 = ttk.Label(top, text = u"Messung importieren und auswerten", font=self.normal_font) label2.pack() msg2 = Message(top, text=u'Zunächst muss über Datei -> Messung importieren die gewünschte Messung importiert werden.\n\nAnschließend werden Delta X und Delta Y so eingestellt, dass nur die gewünschten Maxima (rote Punkte im Graphen) vom Algorithmus erkannt werden.\n\nZur Berechnung des Weiterreißwiderstandes wird die Probendicke benötigt. Diese muss im entsprechenden Fenster eingetragen werden (Trennung durch . nicht durch , Bsp: 1.75).\n\nÜber die Schaltfläche Berechnen werden die gewünschten Werte berechnet.\n\nNachdem der Probenname und optional ein Kommentar zur Messung in die entsprechenden Fenster eingetragen wurden, lässt sich die Auswertung im zuvor gewählten Projekt abspeichern.') msg2.pack() button = Button(top, text="Verbergen", command=top.destroy) button.pack() def info(self): #Infoseite zeigen top = Toplevel() top.title(u"Über dieses Programm...") msg = Message(top, text=u'Dieses Programm dient zur Auswertung von Messungen für die Bestimmung des Weiterreißwiderstands nach DIN ISO 6133:2004-05\n\nZur Detektion der Maxima dient ein Algorithmus aus MATLAB (http://billauer.co.il/peakdet.html) verwendet, welcher nach Python übersetzt wurden.\n\nDas Programm entscheidet je nach Anzahl der Maxima selbst, welche Vorgabe für die Auswertung zu verwenden ist.\n\n\n\nErstellt von Lukas Scheffler') msg.pack() button = Button(top, text="Verbergen", command=top.destroy) button.pack() def draw_figure(self, canvas, figure, loc=(0, 0)): ''' Draw a matplotlib figure onto a Tk canvas loc: location of top-left corner of figure on canvas in pixels. Inspired by matplotlib source: lib/matplotlib/backends/backend_tkagg.py ''' figure_canvas_agg = FigureCanvasAgg(figure) figure_canvas_agg.draw() figure_x, figure_y, figure_w, figure_h = figure.bbox.bounds figure_w, figure_h = int(figure_w), int(figure_h) photo = PhotoImage(master=canvas, width=figure_w, height=figure_h) # Position: convert from top-left anchor to center anchor canvas.create_image(loc[0] + figure_w/2, loc[1] + figure_h/2, image=photo) # Unfortunatly, there's no accessor for the pointer to the native renderer tkagg.blit(photo, figure_canvas_agg.get_renderer()._renderer, colormode=2) # Return a handle which contains a reference to the photo object # which must be kept live or else the picture disappears return photo def _datacheck_peakdetect(self, x_axis, y_axis): if x_axis is None: x_axis = range(len(y_axis)) if len(y_axis) != len(x_axis): raise (ValueError, 'Input vectors y_axis and x_axis must have same length') #needs to be a numpy array y_axis = np.array(y_axis) x_axis = np.array(x_axis) return x_axis, y_axis def peakdetect(self, y_axis, x_axis = None, lookahead = 300, delta=0): """ Converted from/based on a MATLAB script at: http://billauer.co.il/peakdet.html function for detecting local maximas and minmias in a signal. Discovers peaks by searching for values which are surrounded by lower or larger values for maximas and minimas respectively keyword arguments: y_axis -- A list containg the signal over which to find peaks x_axis -- (optional) A x-axis whose values correspond to the y_axis list and is used in the return to specify the postion of the peaks. If omitted an index of the y_axis is used. (default: None) lookahead -- (optional) distance to look ahead from a peak candidate to determine if it is the actual peak (default: 200) '(sample / period) / f' where '4 >= f >= 1.25' might be a good value delta -- (optional) this specifies a minimum difference between a peak and the following points, before a peak may be considered a peak. Useful to hinder the function from picking up false peaks towards to end of the signal. To work well delta should be set to delta >= RMSnoise * 5. (default: 0) delta function causes a 20% decrease in speed, when omitted Correctly used it can double the speed of the function return -- two lists [max_peaks, min_peaks] containing the positive and negative peaks respectively. Each cell of the lists contains a tupple of: (position, peak_value) to get the average peak value do: np.mean(max_peaks, 0)[1] on the results to unpack one of the lists into x, y coordinates do: x, y = zip(*tab) """ max_peaks = [] min_peaks = [] dump = [] #Used to pop the first hit which almost always is false # check input data x_axis, y_axis = self._datacheck_peakdetect(x_axis, y_axis) # store data length for later use length = len(y_axis) #perform some checks if lookahead < 1: raise ValueError, "Lookahead must be '1' or above in value" if not (np.isscalar(delta) and delta >= 0): raise ValueError, "delta must be a positive number" #maxima and minima candidates are temporarily stored in #mx and mn respectively mn, mx = np.Inf, -np.Inf #Only detect peak if there is 'lookahead' amount of points after it for index, (x, y) in enumerate(zip(x_axis[:-lookahead], y_axis[:-lookahead])): if y > mx: mx = y mxpos = x if y < mn: mn = y mnpos = x ####look for max#### if y < mx-delta and mx != np.Inf: #Maxima peak candidate found #look ahead in signal to ensure that this is a peak and not jitter if y_axis[index:index+lookahead].max() < mx: max_peaks.append([mxpos, mx]) dump.append(True) #set algorithm to only find minima now mx = np.Inf mn = np.Inf if index+lookahead >= length: #end is within lookahead no more peaks can be found break continue #else: #slows shit down this does # mx = ahead # mxpos = x_axis[np.where(y_axis[index:index+lookahead]==mx)] ####look for min#### if y > mn+delta and mn != -np.Inf: #Minima peak candidate found #look ahead in signal to ensure that this is a peak and not jitter if y_axis[index:index+lookahead].min() > mn: min_peaks.append([mnpos, mn]) dump.append(False) #set algorithm to only find maxima now mn = -np.Inf mx = -np.Inf if index+lookahead >= length: #end is within lookahead no more peaks can be found break #else: #slows shit down this does # mn = ahead # mnpos = x_axis[np.where(y_axis[index:index+lookahead]==mn)] #Remove the false hit on the first value of the y_axis try: if dump[0]: max_peaks.pop(0) else: min_peaks.pop(0) del dump except IndexError: #no peaks were found, should the function return empty lists? pass return [max_peaks, min_peaks]
class Temperatures(LabelFrame): def __init__(self, root, prtr, settings, log, *arg): LabelFrame.__init__(self, root, *arg, text="Temperatures") self.app = root self.printer = prtr self.settings = settings self.log = log l = Label(self, text="Extruder:", justify=LEFT) l.grid(row=1, column=1, sticky=W) self.statExt = Canvas(self, width=150, height=STAT_HEIGHT, bd=2, bg="white", relief=RIDGE) self.statExt.grid(row=1, column=2, columnspan=2) self.setStatus(self.statExt, UNKNOWN) self.bSetExt = Button(self, text="Set", width=4, command=self.doSetExt) self.bSetExt.grid(row=2, column=1, padx=2) self.spExtTemp = Spinbox(self, values=self.formatTemps(self.settings.extemps), width=12, justify=RIGHT) self.spExtTemp.grid(row=2, column=2) if self.settings.lastexttemp != None: self.spExtTemp.delete(0, END) self.spExtTemp.insert(0, self.settings.lastexttemp) self.spExtTemp.bind("<FocusOut>", self.valExtTemp) self.spExtTemp.bind("<Leave>", self.valExtTemp) self.bOffExt = Button(self, text="Off", width=4, command=self.doOffExt) self.bOffExt.grid(row=2, column=3, padx=2) self.frameExt = Frame(self) self.frameExt.grid(row=3, column=1, columnspan=3) self.legendExt = Canvas(self.frameExt, width=LEGEND_WIDTH, height=100, bd=2, bg="white", relief=RIDGE) self.legendExt.pack(side=LEFT, padx=0, pady=2) self.canvasExt = Canvas(self.frameExt, width=200, height=100, bd=2, bg="white", relief=RIDGE) self.canvasExt.pack(side=LEFT, padx=0, pady=2) self.drawExtAxes() self.extFan = IntVar() if self.settings.fanwithextruder: self.extFan.set(1) else: self.extFan.set(0) self.cb = Checkbutton(self, text="Fan on with extruder", variable=self.extFan, command=self.fanCheck) self.cb.grid(row=4, column=1, columnspan=3) self.forceExtTemp = IntVar() if self.settings.forceexttemp: self.forceExtTemp.set(1) else: self.forceExtTemp.set(0) self.forceExtTempCheck() self.bForceExt = Checkbutton(self, text="Force Ext Temp", variable=self.forceExtTemp, command=self.forceExtTempCheck) self.bForceExt.grid(row=5, column=1, columnspan=3) l = Label(self, text="Bed:", justify=LEFT) l.grid(row=6, column=1, sticky=W) self.statBed = Canvas(self, width=150, height=STAT_HEIGHT, bd=2, bg="white", relief=RIDGE) self.statBed.grid(row=6, column=2, columnspan=2) self.setStatus(self.statBed, UNKNOWN) self.bSetBed = Button(self, text="Set", width=4, command=self.doSetBed) self.bSetBed.grid(row=7, column=1, padx=2) self.spBedTemp = Spinbox(self, values=self.formatTemps(self.settings.bedtemps), width=12, justify=RIGHT) self.spBedTemp.grid(row=7, column=2) if self.settings.lastbedtemp != None: self.spBedTemp.delete(0, END) self.spBedTemp.insert(0, self.settings.lastbedtemp) self.spBedTemp.bind("<FocusOut>", self.valBedTemp) self.spBedTemp.bind("<Leave>", self.valBedTemp) self.bOffBed = Button(self, text="Off", width=4, command=self.doOffBed) self.bOffBed.grid(row=7, column=3, padx=2) self.frameBed = Frame(self) self.frameBed.grid(row=8, column=1, columnspan=3) self.legendBed = Canvas(self.frameBed, width=LEGEND_WIDTH, height=100, bd=2, bg="white", relief=RIDGE) self.legendBed.pack(side=LEFT, padx=0, pady=2) self.canvasBed = Canvas(self.frameBed, width=200, height=100, bd=2, bg="white", relief=RIDGE) self.canvasBed.pack(side=LEFT, padx=0, pady=2) self.drawBedAxes() self.dataBed = [] self.dataExt = [] self.forceBedTemp = IntVar() if self.settings.forcebedtemp: self.forceBedTemp.set(1) else: self.forceBedTemp.set(0) self.forceBedTempCheck() self.bForceBed = Checkbutton(self, text="Force Bed Temp", variable=self.forceBedTemp, command=self.forceBedTempCheck) self.bForceBed.grid(row=9, column=1, columnspan=3) self.monTemp = IntVar() self.monTemp.set(1) self.monCheck() self.cb = Checkbutton(self, text="Monitor temperatures", variable=self.monTemp, command=self.monCheck) self.cb.grid(row=10, column=1, columnspan=3) self.rptre = re.compile("ok *T:([0-9\.]+) *\/([0-9\.]+) *B:([0-9\.]+) *\/([0-9\.]+)") def fanCheck(self): self.settings.fanwithextruder = (self.extFan.get() == 1) self.settings.setModified() def forceBedTempCheck(self): if self.forceBedTemp.get() == 1: if not self.settings.forcebedtemp: self.settings.forcebedtemp = True self.settings.setModified() else: if self.settings.forcebedtemp: self.settings.forcebedtemp = False self.settings.setModified() def forceExtTempCheck(self): if self.forceExtTemp.get() == 1: if not self.settings.forceexttemp: self.settings.forceexttemp = True self.settings.setModified() else: if self.settings.forceexttemp: self.settings.forceexttemp = False self.settings.setModified() def monCheck(self): if self.monTemp.get() == 1: self.app.monitorTemp = True self.printer.tempcb = self.tempcb else: self.app.monitorTemp = False self.dataBed = [] self.canvasBed.delete("GRAPH") self.canvasBed.delete("TARGET") self.dataExt = [] self.canvasExt.delete("GRAPH") self.canvasExt.delete("TARGET") self.printer.tempcb = None self.setStatus(self.statExt, UNKNOWN) self.setStatus(self.statBed, UNKNOWN) def tempcb(self, l): m = self.rptre.search(l) t = m.groups() if len(t) != 4: return self.app.exttemp = float(t[0]) if self.settings.forceexttemp: tp = float(t[1]) if tp >= 0.05 and tp < self.app.exttarget: self.log.logMsg("Asserting hot end temperature of %.2f" % self.app.exttarget) self.printer.send_now("M104 S%s" % self.app.exttarget) else: self.app.exttarget = tp else: self.app.exttarget = float(t[1]) self.app.bedtemp = float(t[2]) if self.settings.forcebedtemp: tp = float(t[3]) if tp >= 0.05 and tp < self.app.bedtarget: self.log.logMsg("Asserting bed temperature of %.2f" % self.app.bedtarget) self.printer.send_now("M140 S%s" % self.app.bedtarget) else: self.app.bedtarget = tp else: self.app.bedtarget = float(t[3]) self.updateTempDisplay(float(t[2]), float(t[0])) def updateTempDisplay(self, tBed, tExt): self.addBedDatapoint(tBed) self.addExtDatapoint(tExt) if self.app.exttarget < 0.05: # unit is off if self.app.exttemp > 35: self.setStatus(self.statExt, COOLING) else: self.setStatus(self.statExt, COOL) else: # unit is on if self.app.exttarget - self.app.exttemp < 0.05: self.setStatus(self.statExt, HOT) else: self.setStatus(self.statExt, HEATING) if self.app.bedtarget < 0.05: # unit is off if self.app.bedtemp > 35: self.setStatus(self.statBed, COOLING) else: self.setStatus(self.statBed, COOL) else: # unit is on if self.app.bedtarget - self.app.bedtemp < 0.05: self.setStatus(self.statBed, HOT) else: self.setStatus(self.statBed, HEATING) def formatTemps(self, t): def cmptemp(a, b): ta = int(a.split()[0]) tb = int(b.split()[0]) return cmp(ta, tb) result = [x for x in t] return sorted(result, cmptemp) def doSetExt(self): if self.app.printerAvailable(cmd="M104"): if self.settings.fanwithextruder and self.app.FanSpeed != 255: if self.settings.forcefanspeed: self.logger.logMsg("Asserting fan speed of %d" % self.app.FanSpeed) else: self.app.toolbar.setFanSpeed(255) temp = self.spExtTemp.get().split(' ')[0] self.printer.send_now("M104 S%s" % temp) self.app.exttarget = float(temp) def valExtTemp(self, *arg): invalid = False try: choice = self.spExtTemp.get() x = int(choice.split(' ')[0]) except: self.log.logMsg("Value for Extruder temperature not a valid integer") invalid = True else: if x <=0 or x >MAXEXTTEMP: self.log.logMsg("Value for Extruder temperature out of range(0-%d" % MAXEXTTEMP) invalid = True if invalid: self.spExtTemp.delete(0, END) self.spExtTemp.insert(0, "%s" % self.formatTemps(self.settings.extemps)[0]) else: if choice not in self.settings.extemps: self.settings.extemps.append(choice) self.settings.setModified() self.spExtTemp.config(values=self.formatTemps(self.settings.extemps)) self.spExtTemp.delete(0, END) self.spExtTemp.insert(0, choice) if self.settings.lastexttemp != choice: self.settings.lastexttemp = choice self.settings.setModified() return True def doOffExt(self, *arg): if self.app.printerAvailable(cmd="M104"): if self.settings.fanwithextruder and self.app.FanSpeed != 0: if self.settings.forcefanspeed: self.logger.logMsg("Asserting fan speed of %d" % self.app.FanSpeed) else: self.app.toolbar.setFanSpeed(0) self.printer.send_now("M104 S0") def drawExtAxes(self): self.canvasExt.delete("AXES") for i in range(0, MAXEXTTEMP, 50): y = 100.0-(float(i)/MAXEXTTEMP*100.0) self.canvasExt.create_line(0, y, 200, y, fill="#C0C0C0", tags="AXES") self.legendExt.create_text(LEGEND_WIDTH, y+7, anchor=SE, tags="AXES", text="%3d" % i) def addExtDatapoint(self, t): c = (t/MAXEXTTEMP)*100.0 self.dataExt.append(c) while len(self.dataExt) >= MAXDATAPOINTS: del(self.dataExt[0]) self.canvasExt.delete("TARGET") self.canvasExt.delete("GRAPH") target = int((self.app.exttarget/MAXEXTTEMP)*100.0) if target != 0: self.canvasExt.create_line(0, 100-target, 200, 100-target, fill="blue", tags="TARGET") self.canvasExt.create_text(10, 100-target, anchor=SW, tags="TARGET", fill="blue", text="%3.3d" % int(self.app.exttarget)) start = MAXDATAPOINTS - len(self.dataExt) pTemp = 0 for i in range(start, MAXDATAPOINTS): if i != start: self.canvasExt.create_line(i*5, 100-pTemp, (i+1)*5, 100-self.dataExt[i-start], fill="red", tags="GRAPH") pTemp = self.dataExt[i-start] self.canvasExt.create_text(190, 100-c, anchor=SE, tags="GRAPH", fill="red", text="%3.3d" % int(t)) def setStatus(self, w, status): if status == UNKNOWN: c = "black" s = "??" elif status == HEATING: c = "orange" s = "heating" elif status == HOT: c = "red" s = "hot" elif status == COOLING: c = "blue" s = "cooling" elif status == COOL: c = "green" s = "cool" else: c = "black" s = "??" w.config(bg=c) w.delete(ALL) w.create_text(75, STAT_HEIGHT-5, text=s, fill="white") def doSetBed(self): if self.app.printerAvailable(cmd="M140"): temp = self.spBedTemp.get().split(' ')[0] self.printer.send_now("M140 S%s" % temp) self.app.bedtarget = float(temp) def valBedTemp(self, *arg): invalid = False try: choice = self.spBedTemp.get() x = int(choice.split(' ')[0]) except: self.log.logMsg("Value for Bed temperature not a valid integer") invalid = True else: if x <=0 or x >MAXEXTTEMP: self.log.logMsg("Value for Bed temperature out of range(0-%d" % MAXBEDTEMP) invalid = True if invalid: self.spBedTemp.delete(0, END) self.spBedTemp.insert(0, "%s" % self.formatTemps(self.settings.bedtemps)[0]) else: if choice not in self.settings.bedtemps: self.settings.bedtemps.append(choice) self.settings.setModified() self.spBedTemp.config(values=self.formatTemps(self.settings.bedtemps)) self.spBedTemp.delete(0, END) self.spBedTemp.insert(0, choice) if self.settings.lastbedtemp != choice: self.settings.lastbedtemp = choice self.settings.setModified() return True def doOffBed(self, *arg): if self.app.printerAvailable(cmd="M140"): self.printer.send_now("M140 S0") def addBedDatapoint(self, t): c = (t/MAXBEDTEMP)*100.0 self.dataBed.append(c) while len(self.dataBed) >= MAXDATAPOINTS: del(self.dataBed[0]) self.canvasBed.delete("TARGET") self.canvasBed.delete("GRAPH") target = int((self.app.bedtarget/MAXBEDTEMP)*100.0) if target != 0: self.canvasBed.create_line(0, 100-target, 200, 100-target, fill="blue", tags="TARGET") self.canvasBed.create_text(10, 100-target, anchor=SW, tags="TARGET", fill="blue", text="%3.3d" % int(self.app.bedtarget)) start = MAXDATAPOINTS - len(self.dataBed) pTemp = 0 for i in range(start, MAXDATAPOINTS): if i != start: self.canvasBed.create_line((i-1)*5, 100-pTemp, i*5, 100-self.dataBed[i-start], fill="red", tags="GRAPH") pTemp = self.dataBed[i-start] self.canvasBed.create_text(190, 100-c, anchor=SE, tags="GRAPH", fill="red", text="%3.3d" % int(t)) def drawBedAxes(self): self.canvasBed.delete("AXES") for i in range(0, MAXBEDTEMP, 50): y = 100.0-(float(i)/MAXBEDTEMP*100.0) self.canvasBed.create_line(0, y, 200, y, fill="#C0C0C0", tags="AXES") self.legendBed.create_text(LEGEND_WIDTH, y+7, anchor=SE, tags="AXES", text="%3d" % i)
class ConstraintsWindow: constr_types = ['Fix', 'Equality', 'Concentric'] def __init__(self, master=None): self.master = master self.nspheres = 0 master.title('Constraints') self.padWE = dict(padx='0.5mm', pady='0.5mm') self.frame = ttk.Frame(self.master) self.create_widgets() self.configure_widgets() self.frame.grid(row=0, column=0) # binds self.count.trace('w', self.change_count) self.master.bind('<Configure>', self.configure_widgets) self.master.protocol('WM_DELETE_WINDOW', self.hide_window) self.master.bind('<Destroy>', self.hide_window) def create_widgets(self): self.count = StringVar() self.count.set('0') self.lbCount = ttk.Label(self.frame, text='Number of constraints:') self.sbCount = Spinbox(self.frame, from_=0, to=1000, textvariable=self.count, width=10) self.lbType = ttk.Label(self.frame, text='Type') self.lbPrm1 = ttk.Label(self.frame, text='Parameter#1') self.lbPrm2 = ttk.Label(self.frame, text='Parameter#2') self.cbTypes = [] self.cbPrm1s = [] self.cbPrm2s = [] self.btOk = ttk.Button(self.frame, text='Ok', command=self.hide_window) self.btHelp = ttk.Button(self.frame, text='Help', command=self.show_help) def configure_widgets(self, event=None): self.lbCount.grid(row=0, column=0, columnspan=2, **self.padWE) self.sbCount.grid(row=0, column=2, columnspan=2, **self.padWE) self.lbType.grid(row=1, column=0, **self.padWE) self.lbPrm1.grid(row=1, column=1, **self.padWE) self.lbPrm2.grid(row=1, column=2, **self.padWE) n = int(self.count.get()) for i in xrange(n): self.cbTypes[i].grid(row=2 + i, column=0, **self.padWE) self.cbPrm1s[i].grid(row=2 + i, column=1, **self.padWE) self.cbPrm2s[i].grid(row=2 + i, column=2, **self.padWE) self.btOk.pack_forget() self.btOk.grid(row=3 + n, column=0, **self.padWE) self.btHelp.grid(row=3 + n, column=2, **self.padWE) def hide_window(self, event=None): if (event is not None) and (event.widget != self.master): return # skip events from destruction of widgets self.master.withdraw() def show_window(self, nspheres): assert nspheres >= 0 self.nspheres = nspheres print(' Number of spheres passed to Constrains window: %i' % nspheres) self.master.deiconify() def change_count(self, var, blank, mode): n = int(self.count.get()) while len(self.cbTypes) > n: self.cbTypes[-1].destroy() self.cbTypes.pop() self.cbPrm1s[-1].destroy() self.cbPrm1s.pop() self.cbPrm2s[-1].destroy() self.cbPrm2s.pop() while len(self.cbTypes) < n: i = len(self.cbTypes) self.cbTypes.append(ttk.Combobox(self.frame, width=10)) self.cbTypes[i].configure(values=self.constr_types) self.cbTypes[i].bind('<<ComboboxSelected>>', lambda event: self.select_type(event, i)) self.cbPrm1s.append(ttk.Combobox(self.frame, width=10)) self.cbPrm2s.append(ttk.Combobox(self.frame, width=10)) print(self.cbTypes) self.configure_widgets() def select_type(self, event, irow): stype = self.cbTypes[irow].get() prms = ['scale', 'bkg0', 'bkg1', 'bkg2'] for i in xrange(self.nspheres): prms.append('a%i' % i) prms.append('x%i' % i) prms.append('y%i' % i) prms.append('z%i' % i) if stype == 'Fix': self.cbPrm1s[irow].configure(values=prms) self.cbPrm2s[irow].configure(values=[]) elif stype == 'Equality': self.cbPrm1s[irow].configure(values=prms) self.cbPrm2s[irow].configure(values=prms) elif stype == 'Concentric': prms = ['s%i' % i for i in xrange(self.nspheres)] self.cbPrm1s[irow].configure(values=prms) self.cbPrm2s[irow].configure(values=prms) else: raise Exception('Unknonw Constraint: "%s"' % stype) self.cbPrm1s[irow].delete(0, 'end') self.cbPrm2s[irow].delete(0, 'end') def get_constraints_list(self): n = int(self.count.get()) result = [] for i in xrange(n): stype = self.cbTypes[i].get() if stype == 'Fix': p1 = self.cbPrm1s[i].get() print(' %sConstraint(%s)' % (stype, p1)) result.append(FixConstraint(p1)) elif stype == 'Equality': p1 = self.cbPrm1s[i].get() p2 = self.cbPrm2s[i].get() print(' %sConstraint(%s, %s)' % (stype, p1, p2)) result.append(EqualityConstraint(p1, p2)) elif stype == 'Concentric': i1 = int(self.cbPrm1s[i].get()[1:]) i2 = int(self.cbPrm2s[i].get()[1:]) print(' %sConstraint(%i, %i)' % (stype, i1, i2)) result.append(ConcentricConstraint(i1, i2)) else: raise Exception('Unknonw Constraint: "%s"' % stype) return result def show_help(self): tkMessageBox.showinfo( 'Constraints Help', '''Types of constraints *Fix* -- don't vary the parameter during fitting. Can be applied to any parameter. *Equality* -- keep the values of to parameters equal. Can be applied to any parameters pair. *Concentric* -- maintain the centers of two spheres at the same position. This position is still varied. Can be applied to spheres pair only. ''')
class PVapplicaton(Frame): """ classdocs """ def __init__(self, master=None): """ Constructor """ Frame.__init__(self, master, name='pvApplication', bg='black', padx=5, pady=5) # set black background, pad sides with 15 points, top/bottom 5 points # fill=BOTH fills in padding with background color # w/o fill=BOTH padding is default color # side=TOP is the default self.pack(fill=BOTH) master.resizable(False, False) # not resizable in x or y master.title(PVAPP_TXT) # set title bar of master (a.k.a. root) master.protocol("WM_DELETE_WINDOW", self._quit) # close window to quit self.validationConstants = self.readJSON('validationConstants') self.messagetext = self.readJSON('messagetext' + '.' + LANGUAGE) MAX_STRINGS = self.validationConstants["pvapplication"]["numStrs"] MAX_MODULES = self.validationConstants["pvapplication"]["numMods"] MAX_SUNS = self.validationConstants["pvapplication"]["sysEe"] CAPTION_FONT = nametofont('TkCaptionFont') # font for titles # PVsystem pvSys = self.pvSys = PVsystem() # variables numStrs = self.numStrs = IntVar(self, NUMBERSTRS, 'numStrs') numMods = self.numMods = IntVar(self, NUMBERMODS, 'numMods') numCells = self.numCells = IntVar(self, NUMBERCELLS, 'numCells') txtIsys = self.txtIsys = DoubleVar(self, name='txtIsys') txtVsys = self.txtVsys = DoubleVar(self, name='txtVsys') txtPsys = self.txtPsys = DoubleVar(self, name='txtPsys') txtImp = self.txtImp = StringVar(self, name='txtImp') txtVmp = self.txtVmp = StringVar(self, name='txtVmp') txtPmp = self.txtPmp = StringVar(self, name='txtPmp') txtIsc = self.txtIsc = StringVar(self, name='txtIsc') txtVoc = self.txtVoc = StringVar(self, name='txtVoc') txtFF = self.txtFF = StringVar(self, name='txtFF') txtEff = self.txtEff = StringVar(self, name='txtEff') sysEe = self.sysEe = DoubleVar(self, 1, name='sysEe') txtImp.set("{:7.3f}".format(self.pvSys.Imp)) # [A] txtVmp.set("{:7.3f}".format(self.pvSys.Vmp)) # [V] txtPmp.set("{:7.3f}".format(self.pvSys.Pmp / 1000)) # [kW] txtIsc.set("{:7.3f}".format(self.pvSys.Isc)) # [A] txtVoc.set("{:7.3f}".format(self.pvSys.Voc)) # [V] txtFF.set("{:7.3f}".format(self.pvSys.FF * 100)) # [%] txtEff.set("{:7.3f}".format(self.pvSys.eff * 100)) # [%] self.msgtext = StringVar(self, READY_MSG, 'msgtext') # must register vcmd and invcmd as Tcl functions vcmd = (self.register(self.validateWidget), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') invcmd = (self.register(self.invalidWidget), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') # SP logo # convert image to tk-compatible format (.gif, .pgm, or .ppm) self.SPlogo = ImageTk.PhotoImage(Image.open(SPLOGO)) # bg='black' fills extra space with black # anchor=W aligns photoimage on left side, NW is no different # padding is ignored by images, use borderwidth Label(self, image=self.SPlogo, borderwidth=5, bg='black', anchor=W).pack(fill=BOTH) # fill=BOTH expands the photoimage to fill parent frame # w/o fill=BOTH photoimage is centered in frame even with anchor=W # Intro text introText = 'PVmismatch calculates I-V and P-V curves as well as the' introText += ' max power point (MPP) for any sized system.\nSet the' introText += ' number of strings in the system, the number of modules' introText += ' per string and the number cells per module.' # anchor=W aligns message on left side, NW is no different # fg='white' sets text color to white, default is black, so it doesn't # show on black background # default aspect is 150%, about as wide as high, or set width>0 Message(self, text=introText, width=750, bg='black', fg='white', anchor=W).pack(fill=BOTH) # fill=BOTH expands the message to fill parent frame # w/o fill=BOTH message is centered in frame even with anchor=W # PVsystem frame pvSysFrame = self.pvSysFrame = Frame(master, name='pvSysFrame') # fill=BOTH keeps widgets in frame on left when window is resized pvSysFrame.pack(fill=BOTH) # PVsystem matplotlib figure canvas self.pvSysPlotFrame = Frame(pvSysFrame, name='pvSysPlotFrame') pvSysPlotFrame = self.pvSysPlotFrame pvSysPlotFrame.pack(side=RIGHT) pvSysPlot = self.pvSysPlot = pvSys.plotSys() self.pvSysFigCanvas = FigureCanvasTkAgg(pvSysPlot, master=pvSysPlotFrame, resize_callback=None) pvSysFigCanvas = self.pvSysFigCanvas pvSysFigCanvas.get_tk_widget()._name = 'pvSysFigCanvas' # IGNORE:W0212 pvSysFigCanvas.show() # NB: FigureCanvasTkAgg._tkcanvas is FigureCanvasTkAgg.get_tk_widget() pvSysFigCanvas.get_tk_widget().pack(fill=BOTH) pvSysToolbar = NavigationToolbar2TkAgg(pvSysFigCanvas, pvSysPlotFrame) pvSysToolbar.update() pvSysToolbar.pack(fill=BOTH) # PVsystem data frame pvSysDataFrame = self.pvSysDataFrame = Frame(pvSysFrame, name='pvSysDataFrame') pvSysDataFrame.pack(side=LEFT) _row = 0 Label(pvSysDataFrame, text='PVsystem', font=CAPTION_FONT).grid(row=_row, columnspan=3, sticky=W) # number of strings _row += 1 # row 1 Label(pvSysDataFrame, text='Number of Strings').grid(row=_row, columnspan=2, sticky=W) # use textVar to set number of strings from LOAD, RESET or default spinboxCnf = { 'name': 'numStrSpinbox', 'from_': 1, 'to': MAX_STRINGS, 'textvariable': numStrs, 'width': 5, 'validate': 'all', 'validatecommand': vcmd, 'invalidcommand': invcmd, 'command': self.updatePVsys } self.numStrSpinbox = Spinbox(pvSysDataFrame, cnf=spinboxCnf) self.numStrSpinbox.bind("<Return>", self.keyBinding) self.numStrSpinbox.grid(row=_row, column=2) # number of modules _row += 1 # row 2 Label(pvSysDataFrame, text='Number of Modules').grid(row=_row, columnspan=2, sticky=W) # number of modules spinbox spinboxCnf = { 'name': 'numModSpinbox', 'from_': 1, 'to': MAX_MODULES, 'textvariable': numMods, 'width': 5, 'validate': 'all', 'validatecommand': vcmd, 'invalidcommand': invcmd, 'command': self.updatePVsys } self.numModSpinbox = Spinbox(pvSysDataFrame, cnf=spinboxCnf) self.numModSpinbox.bind("<Return>", self.keyBinding) self.numModSpinbox.grid(row=_row, column=2) # number of cells _row += 1 # row 3 Label(pvSysDataFrame, text='Number of Cells').grid(row=_row, columnspan=2, sticky=W) # http://www.logilab.org/card/pylintfeatures#basic-checker # pylint: disable = W0142 self.numCellOption = OptionMenu(pvSysDataFrame, numCells, *MODSIZES, command=self.updatePVsys) # pylint: enable = W0142 self.numCellOption._name = 'numCellOption' # IGNORE:W0212 self.numCellOption.grid(row=_row, column=2) # Advanced Configuration button _row += 1 # row 14 buttonCnf = { 'name': 'advCnfButton', 'text': 'Advanced Configuration', 'command': self.startAdvCnf_tk } pvStrButton = self.pvStrButton = Button(pvSysDataFrame, buttonCnf) pvStrButton.grid(row=_row, columnspan=3, sticky=(E + W)) # slider to explore IV curves _row += 1 # row 4, 5 & 6 self.pvSysScale = Scale(pvSysDataFrame, orient=HORIZONTAL, label='I-V Curve', font=CAPTION_FONT, command=self.getIV, showvalue=False, from_=0, to=(pvSys.pvconst.npts - 1)) self.pvSysScale.grid(row=_row, columnspan=3, sticky=(E + W)) # Isys Label(pvSysDataFrame, text='Isys [A]').grid(row=(_row + 1)) self.pvIsys = Entry(pvSysDataFrame, textvariable=txtIsys, width=7) self.pvIsys.grid(row=(_row + 2)) # Vsys Label(pvSysDataFrame, text='Vsys [V]').grid(row=(_row + 1), column=1) self.pvVsys = Entry(pvSysDataFrame, textvariable=txtVsys, width=7) self.pvVsys.grid(row=(_row + 2), column=1) # Psys Label(pvSysDataFrame, text='Psys [kW]').grid(row=(_row + 1), column=2) self.pvPsys = Entry(pvSysDataFrame, textvariable=txtPsys, width=7) self.pvPsys.grid(row=(_row + 2), column=2) # Imp, Vmp & Pmp _row += 3 # row 7, 8, 9, 10, 11 & 12 Label(pvSysDataFrame, text='I-V Characteristics', font=CAPTION_FONT).grid(row=_row, columnspan=3, sticky=W) Label(pvSysDataFrame, text='Imp [A]').grid(row=(_row + 1)) Label(pvSysDataFrame, text='Vmp [V]').grid(row=(_row + 1), column=1) Label(pvSysDataFrame, text='Pmp [kW]').grid(row=(_row + 1), column=2) self.pvImp = Entry(pvSysDataFrame, textvariable=txtImp, width=7, state='readonly') self.pvImp.grid(row=(_row + 2)) self.pvVmp = Entry(pvSysDataFrame, textvariable=txtVmp, width=7, state='readonly') self.pvVmp.grid(row=(_row + 2), column=1) self.pvPmp = Entry(pvSysDataFrame, textvariable=txtPmp, width=7, state='readonly') self.pvPmp.grid(row=(_row + 2), column=2) # Isc, Voc & FF Label(pvSysDataFrame, text='Isc [A]').grid(row=(_row + 3)) Label(pvSysDataFrame, text='Voc [V]').grid(row=(_row + 3), column=1) Label(pvSysDataFrame, text='FF [%]').grid(row=(_row + 3), column=2) self.pvIsc = Entry(pvSysDataFrame, textvariable=txtIsc, width=7, state='readonly') self.pvIsc.grid(row=(_row + 4)) self.pvVoc = Entry(pvSysDataFrame, textvariable=txtVoc, width=7, state='readonly') self.pvVoc.grid(row=(_row + 4), column=1) self.pvFF = Entry(pvSysDataFrame, textvariable=txtFF, width=7, state='readonly') self.pvFF.grid(row=(_row + 4), column=2) Label(pvSysDataFrame, text='Efficiency [%]').grid(row=(_row + 5), columnspan=2) self.pvEff = Entry(pvSysDataFrame, textvariable=txtEff, width=7, state='readonly') self.pvEff.grid(row=(_row + 5), column=2) # set suns _row += 6 # row 13 Label(pvSysDataFrame, text='Irradiance [suns]', font=CAPTION_FONT).grid(row=_row, columnspan=2, sticky=W) # number of modules spinbox spinboxCnf = { 'name': 'sunSpinbox', 'from_': 0.2, 'to': MAX_SUNS, 'increment': 0.1, 'textvariable': sysEe, 'width': 5, 'validate': 'all', 'validatecommand': vcmd, 'invalidcommand': invcmd, 'command': self.updatePVsys } self.sunSpinbox = Spinbox(pvSysDataFrame, cnf=spinboxCnf) self.sunSpinbox.bind("<Return>", self.keyBinding) self.sunSpinbox.grid(row=_row, column=2) # PVstring button _row += 1 # row 14 buttonCnf = { 'name': 'pvStrButton', 'text': 'PVstring', 'command': self.startPVstring_tk } pvStrButton = self.pvStrButton = Button(pvSysDataFrame, buttonCnf) pvStrButton.grid(row=_row, columnspan=3, sticky=(E + W)) # toolbar toolbar = self.toolbarframe = Frame(master, name='toolbar') toolbar.pack(fill=BOTH) self.QUIT = Button(toolbar, text='Quit', command=self._quit) self.QUIT.pack(side=RIGHT) self.SAVE = Button(toolbar, text='Save', command=self._save) self.SAVE.pack(side=RIGHT) self.LOAD = Button(toolbar, text='Load', command=self._load) self.LOAD.pack(side=RIGHT) self.RESET = Button(toolbar, text='Reset', command=self._reset) self.RESET.pack(side=RIGHT) self.UPDATE = Button(toolbar, text='Update', command=self._update) self.UPDATE.pack(side=RIGHT) self.HELP = Button(toolbar, text='Help', command=self._help) self.HELP.pack(side=RIGHT) self.MESSAGE = Message(toolbar, textvariable=self.msgtext, width=500, fg='red') self.MESSAGE.pack(side=LEFT) # Validation substitutions # %d Type of action: 1 for insert, 0 for delete, or -1 for focus, forced or # textvariable validation. # %i Index of char string to be inserted/deleted, if any, otherwise -1. # %P The value of the spinbox should edition occur. If you are configuring # the spinbox widget to have a new textvariable, this will be the value # of that textvariable. # %s The current value of spinbox before edition. # %S The text string being inserted/deleted, if any. Otherwise it is an # empty string. # %v The type of validation currently set. # %V The type of validation that triggered the callback (key, focusin, # focusout, forced). # %W The name of the spinbox widget. # TODO: Fix these functions so that delete and overwrite work def validateWidget(self, *args): # W = Tkinter.W = 'w' is already used, so use W_ instead (d, i, P, s, S, v, V, W_) = args # @UnusedVariable # IGNORE:W0612 logging.debug( "OnValidate: d={}, i={}, P={}, s={}, S={}, v={}, V={}, W={}". format(*args)) if W_ == ".pvSysFrame.pvSysDataFrame.numStrSpinbox": valType = INTEGERS valTest = lambda val: int(val) # IGNORE:W0108 elif W_ == ".pvSysFrame.pvSysDataFrame.numModSpinbox": valType = INTEGERS valTest = lambda val: int(val) # IGNORE:W0108 elif W_ == ".pvSysFrame.pvSysDataFrame.sunSpinbox": valType = FLOATS valTest = lambda val: float(val) # IGNORE:W0108 else: return False w = self.nametowidget(W_) w.config(validate=v) if S in valType: try: valTest(P) except ValueError: return False return True else: return False def invalidWidget(self, *args): (d, i, P, s, S, v, V, W_) = args # @UnusedVariable # IGNORE:W0612 logging.debug( "OnInvalid: d={}, i={}, P={}, s={}, S={}, v={}, V={}, W={}".format( *args)) if W_ == ".pvSysFrame.pvSysDataFrame.numStrSpinbox": errText = 'Invalid number of strings!' elif W_ == ".pvSysFrame.pvSysDataFrame.numModSpinbox": errText = 'Invalid number of modules!' elif W_ == ".pvSysFrame.pvSysDataFrame.sunSpinbox": errText = 'Invalid irradiance!' else: errText = 'Unknown widget!' w = self.nametowidget(W_) w.config(validate=v) self.msgtext.set(errText) self.bell() def getIV(self, *args): logging.debug('args:\n\t%r', args) x = np.float64(float(args[0]) / self.pvSys.pvconst.npts / 2.) xp = np.concatenate( (self.pvSys.pvconst.negpts, self.pvSys.pvconst.pts), axis=0).flatten() Vsys = np.interp(x, xp, self.pvSys.Vsys) Isys = np.interp(x, xp, self.pvSys.Isys) Psys = Vsys * Isys / 1000 self.txtVsys.set("{:7.3f}".format(Vsys)) self.txtIsys.set("{:7.3f}".format(Isys)) self.txtPsys.set("{:7.3f}".format(Psys)) def startPVstring_tk(self): top = Toplevel() app = PVstring_tk(self, top) app.mainloop() # please destroy me or I'll continue to run in background top.destroy() def startAdvCnf_tk(self): """ open advnaced config window """ top = Toplevel(name='advCnfTop') app = AdvCnf_tk(self, top) app.mainloop() # please destroy me or I'll continue to run in background top.destroy() def keyBinding(self, event): logging.debug('event widget:\n\t%r', event.widget) logging.debug('event widget get:\n\t%r', event.widget.get()) self.updatePVsys() def updatePVsys(self, *args, **kwargs): logging.debug('args:\n\t%r', args) logging.debug('kwargs:\n\t%r', kwargs) if args and isinstance(args[0], PVsystem_cls): pvsys = args[0] for n, pvstr in enumerate(pvsys.pvstrs): for pvmod in pvstr.pvmods: pvmod.calcMod() pvstr.calcString() logging.debug('updating pvstring #%d: Pmp = %g[W]', n, pvstr.Pstring.max()) return PVAPP = "pvapplication" try: numStrs = self.numStrs.get() if not (0 < numStrs <= self.validationConstants[PVAPP]["numStrs"]): raise PVValidationError('numStrs', numStrs) numMods = self.numMods.get() if not (0 < numMods <= self.validationConstants[PVAPP]["numMods"]): raise PVValidationError('numMods', numMods) sysEe = self.sysEe.get() if not (0 < sysEe <= self.validationConstants[PVAPP]["sysEe"]): raise PVValidationError('sysEe', sysEe) except PVValidationError as err: logging.debug('err:\n\t%r', err) errtext = self.messagetext[PVAPP][err.argname] self.msgtext.set(errtext) self.bell() return numCells = self.numCells.get() self.msgtext.set(self.messagetext[PVAPP]["Ready"]) pvconst = self.pvSys.pvconst pvcell = PVcell(Ee=sysEe) if numCells == 24: numCells = STD24 elif numCells == 72: numCells = STD72 elif numCells == 96: numCells = STD96 elif numCells == 128: numCells = STD128 pvmods = PVmodule(cell_pos=numCells, pvcells=pvcell) self.pvSys = PVsystem(pvconst, numStrs, numberMods=numMods, pvmods=pvmods) self.updateIVstats() def updateIVstats(self): # reuse sysPlot figure and update pvSysFigCanvas self.pvSysPlot = self.pvSys.plotSys(self.pvSysPlot) self.pvSysFigCanvas.show() self.txtImp.set("{:7.3f}".format(self.pvSys.Imp)) # [A] self.txtVmp.set("{:7.3f}".format(self.pvSys.Vmp)) # [V] self.txtPmp.set("{:7.3f}".format(self.pvSys.Pmp / 1000)) # [kW] self.txtIsc.set("{:7.3f}".format(self.pvSys.Isc)) # [A] self.txtVoc.set("{:7.3f}".format(self.pvSys.Voc)) # [V] self.txtFF.set("{:7.3f}".format(self.pvSys.FF * 100)) # [%] self.txtEff.set("{:7.3f}".format(self.pvSys.eff * 100)) # [%] def _help(self): logging.debug('show docs in browser') webbrowser.open(DOCS) def _update(self): self.msgtext.set(READY_MSG) self.updatePVsys() def _reset(self): # number of strings integer variable self.numStrs.set(NUMBERSTRS) # default # number of modules integer variable self.numMods.set(NUMBERMODS) # default # number of cells integer variable self.numCells.set(NUMBERCELLS) # default value is 96 self.msgtext.set(READY_MSG) # TODO: need to reset advCnf too logging.debug('reset') def _load(self): logging.debug('load *.pv file') def _save(self): logging.debug('save *.pv file') def _quit(self): # this is necessary on Windows to prevent # Fatal Python Error: PyEval_RestoreThread: NULL tstate self.master.quit() # stops mainloop self.master.destroy() def readJSON(self, JSONfilename): if not JSONfilename.endswith('json'): JSONfilename += '.json' JSONfullpath = os.path.join(JSONDIR, JSONfilename) with open(JSONfullpath, 'r') as JSONfile: JSONObjects = json.load(JSONfile) logging.debug('JSON objects loaded from %s.', JSONfullpath) return JSONObjects
def main(): root = Tk() root.title("Day Calculator") Birthdate = Label(root, text="Birth Day").grid(row=0, column=0) Today = Label(root, text="Today").grid(row=0, column=2) monthLabel = Label(root, text="Month(MM)").grid(row=1, column=1) dayLabel = Label(root, text="Day(DD)").grid(row=2, column=1) yearLabel = Label(root, text="Year(YYYY)").grid(row=3, column=1) # want to make a switch thingy # is a spinbox, but still funky though. # the birth info birthMonth = Spinbox(root, from_=1, to=12, bd=5) birthDay = Spinbox(root, from_=1, to=31, bd=5) birthYear = Spinbox(root, from_=1900, to=3000, bd=5) birthMonth.delete(0, END) birthMonth.insert(10, 12) birthDay.delete(0, END) birthDay.insert(10, 5) birthYear.delete(0, END) birthYear.insert(10, 1994) # today info todayMonth = Spinbox(root, from_=1, to=12, bd=5) todayDay = Spinbox(root, from_=1, to=31, bd=5) todayYear = Spinbox(root, from_=1900, to=3000, bd=5) today = getTodayInfo() todayMonth.delete(0, END) todayMonth.insert(10, today[0]) todayDay.delete(0, END) todayDay.insert(10, today[1]) todayYear.delete(0, END) todayYear.insert(10, today[2]) # grid it! birthMonth.grid(row=1, column=0) birthDay.grid(row=2, column=0) birthYear.grid(row=3, column=0) todayMonth.grid(row=1, column=2) todayDay.grid(row=2, column=2) todayYear.grid(row=3, column=2) text = Entry(root, bd=5) text.insert(END, "Press Submit") text.grid(row=4, column=2) # functions def calculate(): text.delete(0, END) days = differenceManual( int(birthMonth.get()), int(birthDay.get()), int(birthYear.get()), int(todayMonth.get()), int(todayDay.get()), int(todayYear.get()) ) if days == -1: string = "Incorrect Date" else: string = str(days) + " Days Old!" text.insert(END, string) submit = Button(root, text="Submit", command=calculate) quit = Button(root, text='Quit', command=root.quit) submit.grid(row=4, column=1) quit.grid(row=4, column=0) # run!!! root.mainloop()
class UIFrame(Frame): ''' This class is responsible for creating configuring and laying out all controls on the main GUI window. It returns UIFrame object (based on Frame) representing the populated window for the application to interact with. ''' def __init__(self, parent): ''' Creates and returns a new UIFrame object. _Parameters_ parent (required) - The parent widget object under which this console is to be created. _Return_ UIFrame Object ''' Frame.__init__(self, parent) self.parent = parent #Main window frames self._optionsFrame = Frame(self.parent) self._runFrame = Frame(self.parent) self._consoleFrame = Frame(self.parent) #Member widget creation and configuration - widgets configured in their constructors self._lblLoopCount = Label(self._optionsFrame, text = "Loop Count") self.LoopSpinner = Spinbox(self._optionsFrame, from_ = 1, to = 5000, repeatdelay = 500, repeatinterval = 50) self._lblOptions = Label(self._optionsFrame, text="Options String") self.OptionsEntry = Entry(self._optionsFrame, exportselection = False) self.ClearButton = Button(self._runFrame, text="Clear") self.RunButton = Button(self._runFrame, text="Run!!!") self.Console = ConsoleFrame(self._consoleFrame) #Geometry control #First pack the main window frames self._optionsFrame.pack(fill = "x") self._runFrame.pack() self._consoleFrame.pack(fill = "both", expand = True, padx = 2, pady = 2) #This line is needed to allow the options column to have the correct width self._optionsFrame.columnconfigure(1, weight = 1) #widgets in options frame self._lblLoopCount.grid(row = 0, column = 0, sticky = "w", padx = 2, pady = 2) self.LoopSpinner.grid(row = 1, column = 0, sticky = "w", padx = 2, pady = 2) self._lblOptions.grid(row = 0, column = 1, sticky = "w", padx = 2, pady = 2) self.OptionsEntry.grid(row = 1, column = 1, sticky = "e"+"w", padx = 2, pady = 2) #widgets in run frame self.RunButton.pack(side = "left", padx = 2, pady = 2) self.ClearButton.pack(side = "left", padx = 2, pady = 2) #note - Console frame packed in constructor for console object #set minimum window size self.master.update_idletasks() self.master.minsize(self.master.winfo_width(), self.master.winfo_height())
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 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)
class SettingWindow(Toplevel): def __init__(self, master, max_num_features, num_frames, mser_image): Toplevel.__init__(self, master) self.protocol('WM_DELETE_WINDOW', self.withdraw) self.notebook = ttk.Notebook(self) frame_feats = ttk.Frame(self.notebook) frame_forest = ttk.Frame(self.notebook) frame_mser = ttk.Frame(self.notebook) frame_other = ttk.Frame(self.notebook) self.notebook.add(frame_feats, text="Features ") self.notebook.add(frame_forest, text=" Forest ") self.notebook.add(frame_mser, text=" MSER ") self.notebook.add(frame_other, text=" Other ") self.max_num_feats = max_num_features self.selection = None self.mser_image = mser_image rand_row = random.randint(1, 512 - 200) rand_col = random.randint(1, 512 - 110) self.mser_area = mser_image[rand_row:rand_row + 180, rand_col:rand_col + 100] # read images from icons folder self.hf0_img = PhotoImage(file="./icons/hf0.gif") self.hf1_img = PhotoImage(file="./icons/hf1.gif") self.hf2_img = PhotoImage(file="./icons/hf2.gif") self.hf3_img = PhotoImage(file="./icons/hf3.gif") self.hf4_img = PhotoImage(file="./icons/hf4.gif") self.hf5_img = PhotoImage(file="./icons/hf5.gif") self.features_vars = list() for i in range(max_num_features): self.features_vars.append(IntVar()) Label(frame_feats, text="Patch size (" + u"\N{GREEK SMALL LETTER PI}" + "):").grid( row=0, column=0, pady=5) self.patch_size_spinbox = Spinbox(frame_feats, from_=3, to=30, width=3) self.patch_size_spinbox.delete(0, END) self.patch_size_spinbox.insert(END, 10) self.patch_size_spinbox.grid(row=0, column=1, padx=5) f1 = ttk.Labelframe(frame_feats, text='Mean filter') f1.grid(row=1, columnspan=2) Label(f1, text=u"\N{GREEK SMALL LETTER PI}").grid(row=0, column=0) Checkbutton(f1, text="R", variable=self.features_vars[0]).grid(row=0, column=1) Checkbutton(f1, text="G", variable=self.features_vars[1]).grid(row=0, column=2) Checkbutton(f1, text="B", variable=self.features_vars[2]).grid(row=0, column=3) Label(f1, text=u"\N{GREEK SMALL LETTER PI}" + "/2").grid(row=1, column=0) Checkbutton(f1, text="R", variable=self.features_vars[3]).grid(row=1, column=1) Checkbutton(f1, text="G", variable=self.features_vars[4]).grid(row=1, column=2) Checkbutton(f1, text="B", variable=self.features_vars[5]).grid(row=1, column=3) f2 = ttk.Labelframe(frame_feats, text="Gaussian filter") f2.grid(row=2, columnspan=2) Label(f2, text=str(1.0)).grid(row=0, column=0) Checkbutton(f2, text="R", variable=self.features_vars[6]).grid(row=0, column=1) Checkbutton(f2, text="G", variable=self.features_vars[7]).grid(row=0, column=2) Checkbutton(f2, text="B", variable=self.features_vars[8]).grid(row=0, column=3) Label(f2, text=str(3.5)).grid(row=1, column=0) Checkbutton(f2, text="R", variable=self.features_vars[9]).grid(row=1, column=1) Checkbutton(f2, text="G", variable=self.features_vars[10]).grid(row=1, column=2) Checkbutton(f2, text="B", variable=self.features_vars[11]).grid(row=1, column=3) f3 = ttk.Labelframe(frame_feats, text="Laplacian of gaussian") f3.grid(row=3, columnspan=2) Label(f3, text=str(2.0)).grid(row=0, column=0) Checkbutton(f3, text="R", variable=self.features_vars[12]).grid(row=0, column=1) Checkbutton(f3, text="G", variable=self.features_vars[13]).grid(row=0, column=2) Checkbutton(f3, text="B", variable=self.features_vars[14]).grid(row=0, column=3) Label(f3, text=str(3.5)).grid(row=1, column=0) Checkbutton(f3, text="R", variable=self.features_vars[15]).grid(row=1, column=1) Checkbutton(f3, text="G", variable=self.features_vars[16]).grid(row=1, column=2) Checkbutton(f3, text="B", variable=self.features_vars[17]).grid(row=1, column=3) f4 = ttk.Labelframe(frame_feats, text="Haar-like features") f4.grid(row=1, rowspan=2, column=3, padx=5) Checkbutton(f4, image=self.hf0_img, variable=self.features_vars[18]).grid(row=0, column=0) Checkbutton(f4, image=self.hf1_img, variable=self.features_vars[19]).grid(row=0, column=1) Checkbutton(f4, image=self.hf2_img, variable=self.features_vars[20]).grid(row=1, column=0) Checkbutton(f4, image=self.hf3_img, variable=self.features_vars[21]).grid(row=1, column=1) Checkbutton(f4, image=self.hf4_img, variable=self.features_vars[22]).grid(row=2, column=0) Checkbutton(f4, image=self.hf5_img, variable=self.features_vars[23]).grid(row=2, column=1) buttons_paned_window = PanedWindow(frame_feats, orient=VERTICAL) buttons_paned_window.grid(row=3, column=3) self.select_all_button = Button(buttons_paned_window, text="Select all", command=self._select_all) buttons_paned_window.add(self.select_all_button) self.clear_selection_button = Button(buttons_paned_window, text="Clear selection", command=self._clear_selection) buttons_paned_window.add(self.clear_selection_button) # default values for j in [0, 1, 3, 6, 7, 9, 15, 21, 23]: self.features_vars[j].set(1) # FOREST FRAMES # number of trees f5 = ttk.Labelframe(frame_forest, text="Number of trees") f5.grid(row=0, columnspan=2, pady=5, padx=5) Label(f5, text="N").grid(row=1, column=0) self.num_trees_scale = Scale(f5, from_=5, to=500, resolution=5, orient=HORIZONTAL) self.num_trees_scale.set(300) self.num_trees_scale.grid(row=0, column=1, rowspan=2) # depth single tree f6 = ttk.Labelframe(frame_forest, text="Depth single tree") f6.grid(row=1, columnspan=2, pady=5, padx=5) Label(f6, text="d").grid(row=1, column=0) self.depth_tree_scale = Scale(f6, from_=2, to=20, orient=HORIZONTAL) self.depth_tree_scale.set(3) self.depth_tree_scale.grid(row=0, column=1, rowspan=2) # percentage number of features f7 = ttk.Labelframe(frame_forest, text="% subset of features") f7.grid(row=2, columnspan=2, pady=5, padx=5) Label(f7, text="m").grid(row=1, column=0) self.percentage_feats_scale = Scale(f7, from_=0.0, to=1, resolution=0.05, orient=HORIZONTAL) self.percentage_feats_scale.set(0.5) self.percentage_feats_scale.grid(row=0, column=1, rowspan=2) # mser frame # delta f8 = ttk.Labelframe(frame_mser, text="Delta") f8.grid(row=0, columnspan=2, pady=5, padx=5) Label(f8, text=u"\N{GREEK SMALL LETTER DELTA}").grid(row=1, column=0) self.delta_scale = Scale(f8, from_=1, to=10, resolution=1, orient=HORIZONTAL) self.delta_scale.set(2) self.delta_scale.grid(row=0, column=1, rowspan=2) # min area f9 = ttk.Labelframe(frame_mser, text="Minimum area") f9.grid(row=1, columnspan=2, pady=5, padx=5) Label(f9, text="m").grid(row=1, column=0) self.min_area_scale = Scale(f9, from_=2, to=200, orient=HORIZONTAL) self.min_area_scale.set(10) self.min_area_scale.grid(row=0, column=1, rowspan=2) # percentage number of features f10 = ttk.Labelframe(frame_mser, text="Maximum area") f10.grid(row=2, columnspan=2, pady=5, padx=5) Label(f10, text="M").grid(row=1, column=0) self.max_area_scale = Scale(f10, from_=50, to=1000, resolution=5, orient=HORIZONTAL) self.max_area_scale.set(350) self.max_area_scale.grid(row=0, column=1, rowspan=2) # mser image f11 = ttk.Labelframe(frame_mser) f11.grid(row=0, rowspan=3, column=2, padx=5) self.mser_img_array = Image.fromarray(self.mser_area, "RGB") self.mser_img = ImageTk.PhotoImage(self.mser_img_array) img_label = Label(f11, image=self.mser_img) img_label.grid(row=0, column=0) buttons_p_w_mser = PanedWindow(f11, orient=HORIZONTAL) try_button = Button(f11, text="Try", command=self.try_mser) buttons_p_w_mser.add(try_button) change_button = Button(f11, text="New img", command=self.change_mser) buttons_p_w_mser.add(change_button) buttons_p_w_mser.grid(row=1, column=0) # other frame f12 = ttk.Labelframe(frame_other, text="Refinement") f12.grid(row=0, columnspan=2, pady=5, padx=5) Label(f12, text=u"\N{GREEK CAPITAL LETTER PHI}_l").grid(row=1, column=0) self.low_thresh_scale = Scale(f12, from_=0, to=1, resolution=0.05, orient=HORIZONTAL, length=90) self.low_thresh_scale.set(0.45) self.low_thresh_scale.grid(row=0, column=1, rowspan=2) Label(f12, text=u"\N{GREEK CAPITAL LETTER PHI}_h").grid(row=3, column=0) self.high_thresh_scale = Scale(f12, from_=0, to=1, resolution=0.05, orient=HORIZONTAL, length=90) self.high_thresh_scale.set(0.65) self.high_thresh_scale.grid(row=2, column=1, rowspan=2) f13 = ttk.Labelframe(frame_other, text="Dots distance") f13.grid(row=1, columnspan=2, pady=5, padx=5) Label(f13, text=u" \N{GREEK SMALL LETTER SIGMA}").grid(row=1, column=0) self.dots_distance_scale = Scale(f13, from_=1, to=20, resolution=1, orient=HORIZONTAL, length=90) self.dots_distance_scale.set(6) self.dots_distance_scale.grid(row=0, column=1, rowspan=2) f14 = ttk.Labelframe(frame_other, text="Tracks") f14.grid(row=0, column=3, pady=5, padx=5) Label(f14, text="N").grid(row=1, column=0) self.num_frames_tracks_spinbox = Spinbox(f14, from_=2, to=num_frames, width=10) self.num_frames_tracks_spinbox.delete(0, END) self.num_frames_tracks_spinbox.insert(END, num_frames) self.num_frames_tracks_spinbox.grid(row=0, column=1, rowspan=2) Label(f14, text=u"\N{GREEK SMALL LETTER TAU}").grid(row=3, column=0) self.gaps_scale = Scale(f14, from_=1, to=10, resolution=1, orient=HORIZONTAL, length=90) self.gaps_scale.set(2) self.gaps_scale.grid(row=2, column=1, rowspan=2) self.notebook.pack(padx=1, pady=1) save_button = Button(self, text=" Save and Close window ", command=self.withdraw) save_button.pack(pady=2) def _select_all(self): for i, var in enumerate(self.features_vars): var.set(1) def _clear_selection(self): for i, var in enumerate(self.features_vars): var.set(0) def change_mser(self): rand_row = random.randint(1, 512 - 200) rand_col = random.randint(1, 512 - 110) self.mser_area = self.mser_image[rand_row:rand_row + 180, rand_col:rand_col + 100] self.update_mser_image(self.mser_area) def try_mser(self): delta = self.delta_scale.get() min_area = self.min_area_scale.get() max_area = self.max_area_scale.get() image = self.mser_area red_c = image[:, :, 0] red_c = cv2.equalizeHist(red_c) det_img = image.copy() mser = cv2.MSER(delta, _min_area=min_area, _max_area=max_area) regions = mser.detect(red_c) cp = list() new_c = np.zeros(self.mser_area.shape, dtype=np.uint8) for r in regions: for point in r: cp.append(point) det_img[point[1], point[0], 0] = 0 det_img[point[1], point[0], 1] = 0 det_img[point[1], point[0], 2] = 204 #new_c[point[1], point[0]] = 255 self.update_mser_image(det_img) def update_mser_image(self, new_image): self.mser_img_array = Image.fromarray(new_image) self.mser_img.paste(self.mser_img_array) def get_patch_size(self): patch_size = self.patch_size_spinbox.get() return int(patch_size) def get_num_frames_tracks(self): num_frames_tracks = self.num_frames_tracks_spinbox.get() return int(num_frames_tracks) def get_mser_opts(self): return [ self.delta_scale.get(), self.min_area_scale.get(), self.max_area_scale.get() ] def get_forest_opts(self): return [ self.num_trees_scale.get(), self.depth_tree_scale.get(), self.percentage_feats_scale.get() ] def get_low_thresh(self): return self.low_thresh_scale.get() def get_high_thresh(self): return self.high_thresh_scale.get() def get_dots_distance(self): return int(self.dots_distance_scale.get()) def get_selection_mask(self): if self.selection is not None: return self.selection selection_mask = np.zeros((self.max_num_feats, ), dtype='bool') for i, var in enumerate(self.features_vars): selection_mask[i] = var.get() self.selection = selection_mask return selection_mask
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)
class ScanDialog(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.worker = None self.elapsed = 0 self.settings = Settings(self) # self.initUI() follows self.parent.title("Scan Images") self.pack(fill=BOTH, expand=1) r = 0 # current grid row Label(self, text="Name prefix:").grid(row=r, column=0) Label(self, text="Number suffix:").grid(row=r, column=1) r += 1 self.newName = StringVar() self.newName.set('Scan_') newName = Entry(self, textvariable=self.newName, width=60) newName.grid(row=1, column=0) newName.bind("<Return>", lambda event: self.scan()) newName.bind("<KP_Enter>", lambda event: self.scan()) newName.bind("<Escape>", lambda event: self.parent.destroy()) newName.focus_set() self.newNameEntry = newName self.numberSuffix = Spinbox(self, from_=1, to=999) self.numberSuffix.bind("<Return>", lambda event: self.scan()) self.numberSuffix.bind("<KP_Enter>", lambda event: self.scan()) self.numberSuffix.grid(row=r, column=1) r += 1 self.okButton = Button(self, text="Scan", command=self.scan, width=60, height=5) self.okButton.grid(row=r, column=0) cancelButton = Button(self, text="Cancel", command=self.parent.destroy) cancelButton.grid(row=r, column=1) r += 1 settings_panel = tk.Frame(self) panel = tk.Frame(settings_panel) tk.Label(panel, text="Paper Format").pack() tk.Radiobutton(panel, text="A4", value=1.0, variable=self.settings.scale).pack(anchor=tk.W) tk.Radiobutton(panel, text="A5", value=2 ** (-0.5), variable=self.settings.scale).pack(anchor=tk.W) tk.Radiobutton(panel, text="A6", value=0.5, variable=self.settings.scale).pack(anchor=tk.W) panel.pack(side=tk.LEFT, anchor=tk.N) panel = tk.Frame(settings_panel) tk.Label(panel, text="File Format").pack() tk.Radiobutton(panel, text="PNG", value='.png', variable=self.settings.extension).pack(anchor=tk.W) tk.Radiobutton(panel, text="JPG", value='.jpg', variable=self.settings.extension).pack(anchor=tk.W) panel.pack(side=tk.LEFT, anchor=tk.N) panel = tk.Frame(settings_panel) tk.Label(panel, text="Scan Mode").pack() tk.Radiobutton(panel, text="Color", value='color', variable=self.settings.scan_mode).pack(anchor=tk.W) tk.Radiobutton(panel, text="Gray", value='gray', variable=self.settings.scan_mode).pack(anchor=tk.W) tk.Radiobutton(panel, text="Lineart", value='lineart', variable=self.settings.scan_mode).pack(anchor=tk.W) panel.pack(side=tk.LEFT, anchor=tk.N) settings_panel.grid(row=r, column=0, columnspan=2) r += 1 self.statusLabel = Label(self, text="Idle") self.statusLabel.grid(row=r, column=0, columnspan=2) def _checkAlive(self): if self.worker is None: return if self.worker.is_alive(): self.after(100, self._checkAlive) self.elapsed += 1 self.statusLabel.config(text='Scanning, please wait... (%.1f s)' % (self.elapsed/10.0)) else: self.worker = None self.okButton.config(state=NORMAL) self.numberSuffix.invoke('buttonup') self.newNameEntry.focus_set() self.statusLabel.config(text='Idle (last scan: %.1f s)' % (self.elapsed/10.0)) def _ext(self): return self.settings.ext() def scan(self): target = '%s%03d%s' % (self.newName.get(), int(self.numberSuffix.get()), self._ext(), ) if os.path.exists(target): if not tkMessageBox.askokcancel(title='Scan Images', message='File exists. Overwrite?'): print 'Not scanning: %s - file exists!' % target new_name = self.newName.get() for i in xrange(int(self.numberSuffix.get()), 1000): new_target = '%s%03d.%s' % (new_name, int(self.numberSuffix.get()), self._ext(), ) if not os.path.exists(new_target): print 'Next available filename: %s' % (new_target, ) self.numberSuffix.delete(0, 'end') self.numberSuffix.insert(0, i) break return print "Scanning to filename '%s' ..." % (target, ) if s is None: print('No scanner present. Connect and restart application.') return if self.worker is None: self.worker = ScanWorker(target, self.settings) self.worker.start() self.elapsed = 0 self.after(100, self._checkAlive) self.okButton.config(state=DISABLED) self.statusLabel.config(text='Scanning, please wait...') else: print "Error - not started, worker exists."
class Extruder(LabelFrame): def __init__(self, root, prtr, settings, log, *arg): LabelFrame.__init__(self, root, *arg, text="Extruder") self.app = root self.printer = prtr self.settings = settings self.log = log self.bExtrude = Button(self, text="Extrude", width=10, command=self.doExtrude) self.bExtrude.grid(row=1, column=1, padx=2) self.spDistance = Spinbox(self, from_=1, to=MAXDIST, width=6, justify=RIGHT) self.spDistance.grid(row=1, column=2) self.spDistance.delete(0, END) self.spDistance.insert(0, STARTDIST) self.spDistance.bind("<FocusOut>", self.valDistance) self.spDistance.bind("<Leave>", self.valDistance) l = Label(self, text="mm", justify=LEFT) l.grid(row=1, column=3, sticky=W) self.bReverse = Button(self, text="Reverse", width=10, command=self.doReverse) self.bReverse.grid(row=2, column=1, padx=2) self.spSpeed = Spinbox(self, from_=1, to=MAXFEED, width=6, justify=RIGHT) self.spSpeed.grid(row=2, column=2) self.spSpeed.delete(0, END) self.spSpeed.insert(0, self.settings.efeed) self.spSpeed.bind("<FocusOut>", self.valSpeed) self.spSpeed.bind("<Leave>", self.valSpeed) l = Label(self, text="mm/min", justify=LEFT) l.grid(row=2, column=3, sticky=W) def valDistance(self, *arg): invalid = False try: y = float(self.spDistance.get()) except: self.log.logMsg("Value for distance not a valid number") invalid = True else: if y <=0 or y >MAXDIST: self.log.logMsg("Value for Distance out of range (0-%d)" % MAXDIST) invalid = True if invalid: self.spDistance.delete(0, END) self.spDistance.insert(0, STARTDIST) return True def valSpeed(self, *arg): invalid = False try: x = int(self.spSpeed.get()) except: self.log.logMsg("Value for E feed rate not a valid integer") invalid = True else: if x <=0 or x >MAXFEED: self.log.logMsg("Value for E feed rate out of range(0-%d)" % MAXFEED) invalid = True if invalid: self.spSpeed.delete(0, END) self.spSpeed.insert(0, "%d" % self.settings.efeed) else: if self.settings.efeed != x: self.settings.efeed = x self.settings.setModified() return True def doExtrude(self): if self.app.printerAvailable(cmd="G91"): dist = self.spDistance.get() self.printer.send_now("G91") self.printer.send_now("G1 E%s F%s" % (dist, self.settings.efeed)) self.printer.send_now("G90") def doReverse(self): if self.app.printerAvailable(cmd="G91"): dist = self.spDistance.get() self.printer.send_now("G91") self.printer.send_now("G1 E-%s F%s" % (dist, self.settings.efeed)) self.printer.send_now("G90")
def initUI(self): self.parent.title("FIND SPE 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 self.graph_cb = BooleanVar() self.bins = IntVar() self.path = StringVar() self.n_files = IntVar() self.start_s = IntVar() self.end_s = IntVar() self.guess = IntVar() search = Image.open("next_logo.jpg") search_temp = search.resize((160, 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) #Number of Files and Bins. Spin Box self.n_files.set("2000") sb1 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.n_files) sb1.grid(row=1, column=4, sticky=W) sb1_label = Label(self, text="Files") sb1_label.grid(row=1, column=3, padx=5, sticky=E) self.bins.set("50") sb2 = Spinbox(self, from_=10, to=200, width=6, textvariable=self.bins) sb2.grid(row=1, column=6, sticky=W) sb2_label = Label(self, text="Hist. Bins") sb2_label.grid(row=1, column=5, padx=5, sticky=E) # INTEGRATION LIMITS Integration_label = Label(self, text="INTEGRATION", font="Verdana 12 bold") Integration_label.grid(row=3, column=4, padx=5, columnspan=2) self.start_s.set("1732") sb3 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.start_s) sb3.grid(row=4, column=4, sticky=W) sb3_label = Label(self, text="StartPoint") sb3_label.grid(row=4, column=3, padx=5, sticky=E) self.end_s.set("1752") sb4 = Spinbox(self, from_=1, to=10000, width=6, textvariable=self.end_s) sb4.grid(row=4, column=6, sticky=W) sb4_label = Label(self, text="EndPoint") sb4_label.grid(row=4, column=5, padx=5, sticky=E) sb4_label = Label(self, text="") sb4_label.grid(row=4, column=7, padx=5, sticky=E) # FITTING PARAMETERS Integration_label = Label(self, text="FITTING", font="Verdana 12 bold") Integration_label.grid(row=6, column=4, padx=5, columnspan=2) self.guess.set("-20") sb5 = Spinbox(self, from_=-50, to=-1, width=6, textvariable=self.guess) sb5.grid(row=7, column=4, sticky=W) sb5_label = Label(self, text="SPE guess") sb5_label.grid(row=7, column=5, padx=5, sticky=W) #Check buttons cb1 = Checkbutton(self, text="MultiGraph Output", variable=self.graph_cb) cb1.select() cb1.grid(row=7, column=6, sticky=W) #Text Box #self.path.set("F:/DATOS_DAC/spe_1230/2046/pmt_0_trace_evt_") self.path.set("spe_1230_2046.h5.z") e1 = Entry(self, textvariable=self.path, width=45) e1.grid(row=10, column=3, sticky=W, columnspan=10, padx=10, pady=5) e1_label = Label(self, text="DataSet path (including name file)") e1_label.grid(row=9, column=3, sticky=W, columnspan=10, padx=10) # Main buttons obtn = Button(self, text="GO!!", command=self.SPE_f) obtn.grid(row=14, column=5, sticky=E, pady=5) cbtn = Button(self, text="Quit", command=self.quit) cbtn.grid(row=14, column=6, sticky=E, pady=5) hbtn = Button(self, text="Help") hbtn.grid(row=14, column=0, sticky=W, pady=5)