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 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 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)
