def __init__(self, master=None, text=None, state=0, padding=0):
self.var = IntVar()
self.padding = padding
self.master = master
self.text = text
command = lambda name=text: self.check_button_states(name)
self.button = Checkbutton(master,
command=command,
text=text,
variable=self.var,
onvalue=1,
offvalue=0)
if state == 1:
self.button.select()
def __init__(self, master, count):
self.text = ''
self.points = 0
self.comment_txt = Entry(master=master)
self.comment_txt.grid(column=0, row=count)
self.comment_txt.insert(END, "")
self.point_txt = Entry(master=master)
self.point_txt.grid(column=1, row=count)
self.point_txt.insert(END, "0")
self.var = IntVar()
self.chk = Checkbutton(master, text=" ", variable=self.var)
self.chk.grid(column=2, row=count)
def __init__(self, parent, model):
self.model = model
self.parent = parent
self.window = Toplevel(parent.window)
self.mutations = self.model.get_mutations()
self.window.title('Mutator')
self.window.geometry('600x400')
self.window.transient(master=parent.window)
self.window.grab_set()
Label(self.window, text='Wybrane mutacje').grid(sticky=tk.NW)
for i in range(0, len(self.mutations)):
Checkbutton(self.window,
text=self.mutations[i][0],
variable=self.mutations[i][1]).grid(row=i + 1,
sticky=tk.NW)
def pricesWindow(previousWindow):
# closes menu and opens prices window
pricesSelection = Tk()
previousWindow.withdraw()
pricesSelection.configure(bg='light cyan')
pricesSelection.title('Prices of Items')
pricesSelection.geometry('400x310')
label = Label(pricesSelection, text = 'Select item(s):',
bd = 0,
relief = 'solid',
width = 15,
height = 2,
bg = 'light cyan')
label.pack()
# values of checkbox variables
toiletPaperS = BooleanVar(pricesSelection)
toiletPaperL = BooleanVar(pricesSelection)
handSanitizerS = BooleanVar(pricesSelection)
handSanitizerL = BooleanVar(pricesSelection)
waterGal = BooleanVar(pricesSelection)
waterBot = BooleanVar(pricesSelection)
wipesS = BooleanVar(pricesSelection)
wipesL = BooleanVar(pricesSelection)
# creation of checkboxes
Checkbutton(pricesSelection, text = 'Toilet Paper (Small Pack, 12)', variable = toiletPaperS, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Toilet Paper (Bulk, 24)', variable = toiletPaperL, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Hand Sanitizer (travel size, 2 fl. oz.)', variable = handSanitizerS, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Hand Sanitizer (medium size, 12 fl. oz.)', variable = handSanitizerL, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Poland Spring Water Jug (1 Gallon)', variable = waterGal, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Poland Spring Pack (24 Bottles)', variable = waterBot, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Heavy Duty Wipes (30 ct)', variable = wipesS, onvalue = 1, offvalue = 0, bg='light cyan').pack()
Checkbutton(pricesSelection, text = 'Heavy Duty Wipes (60 ct)', variable = wipesL, onvalue = 1, offvalue = 0, bg='light cyan').pack()
# button that creates graph
graphPrices = Button(pricesSelection, text = 'Graph Selected', bg='white', command = lambda:pricesData([toiletPaperS, toiletPaperL, handSanitizerS, handSanitizerL, waterGal, waterBot, wipesS, wipesL]))
graphPrices.place(x=50, y=250)
# button that graphs all
graphAll = Button(pricesSelection, text = 'Graph All', bg='white', command = lambda:pricesData())
graphAll.place(x=168, y=250)
# return to menu button
menuButton = Button(pricesSelection, text = 'Return to Menu', bg='white', command = lambda:menuWindow(pricesSelection))
menuButton.place(x=250, y=250)
def add_row():
global i
i = i + 1
items = []
for j in range(0, 2): #Columns
b = Entry(root, width=10)
items.append(b)
b.grid(row=i, column=j)
var = IntVar()
c = Checkbutton(root, variable=var, width=10, anchor='w')
c.val = var
items.append(c)
c.grid(row=i, column=2)
rows.append(items)
def body(self, master):
self.checkVar = IntVar()
Label(master, text=self.prompt).grid(row=0, sticky=W)
self.e1 = Entry(master)
self.e1.grid(row=0, column=1)
self.cb = Checkbutton(master,
text="Save to keychain",
variable=self.checkVar)
self.cb.pack()
self.cb.grid(row=1, columnspan=2, sticky=W)
self.e1.configure(show='*')
def title_checkbox(app, parent, on_click=lambda v: v):
variable = BooleanVar()
variable.set(TRUE if getattr(app.bot_config, name) else FALSE)
def command():
setattr(app.bot_config, name, variable.get())
write_bot_config(app.bot_config,
app.device.serial.replace(':', "_"))
on_click(variable.get())
checkbox = Checkbutton(parent,
text=text,
variable=variable,
command=command)
return checkbox, variable
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.test01 = BooleanVar()
checkbutton = Checkbutton(parent,
text='check it',
variable=self.test01,
command=self.testcheck)
checkbutton.pack()
testbutton = Button(parent, text='check test', command=self.testcheck)
testbutton.pack()
self.parent.title('Checkbutton test')
def show(self):
frame = Frame(Interface.functional_area)
frame.pack(fill=X)
label = Label(frame, text=self._button_text)
label.pack(side=LEFT)
for text, value in self._options:
var = BooleanVar()
var.set(value)
check_button = Checkbutton(frame,
text=text,
variable=var,
onvalue=True,
offvalue=False)
check_button.pack(side=LEFT)
self._value_list.append(var)
def run_frame_fun(run_frame):
global file_entry
global save_entry
global file_path
global save_path
global progress_bar
global autorun_output
Label(run_frame, text='Input File: ', padx=10, pady=10).grid(row=0,
column=0)
Label(run_frame, text='Output File: ', padx=10, pady=10).grid(row=1,
column=0)
file_entry = Entry(run_frame, width=110)
file_entry.grid(row=0, column=1)
file_entry.insert(0, file_path)
file_entry.configure(state='disabled')
save_entry = Entry(run_frame, width=110)
save_entry.grid(row=1, column=1)
save_entry.insert(0, save_path)
save_entry.configure(state='disabled')
Button(run_frame,
text="Find Input",
state=ACTIVE,
command=set_file,
padx=10).grid(row=0, column=2, padx=5)
Button(run_frame,
text="Find Ouptut",
state=ACTIVE,
command=set_save,
padx=5).grid(row=1, column=2, padx=5)
progress_bar = ttk.Progressbar(run_frame,
orient=HORIZONTAL,
length=666,
mode='determinate')
progress_bar.grid(row=2, column=1, pady=(25, 5))
is_ready()
c = Checkbutton(run_frame, text='Auto-Open', variable=autorun_output)
c.grid(row=2, column=0, pady=(25, 5))
return run_frame
def __create_component(self):
index = 0
for index, f in enumerate([
name for name in os.listdir(self.__folder_path)
if os.path.isfile(os.path.join(self.__folder_path, name))
]):
self.__check_var.append(BooleanVar())
self.__check_var[index].set(True)
self.__check_button_list.append(
Checkbutton(self,
text=f,
variable=self.__check_var[index],
onvalue=True,
offvalue=False,
background='blue'))
self.__check_button_list[index].grid(row=index,
column=0,
sticky=W,
columnspan=2)
self.__msg_text = Text(self)
self.__msg_text.grid(row=1, column=2, rowspan=20)
self.__msg_text.config(state=tkinter.DISABLED)
self.__msg_text.tag_config('warning',
background='yellow',
foreground='blue')
self.__msg_text.tag_config('finished',
background='blue',
foreground='white')
self.__msg_text.tag_config('starting', background='green')
self.__msg_text.tag_config('error',
background='red',
foreground='yellow')
Label(self, text='Processing log').grid(row=0, column=2)
Button(self, text='Invert',
command=self._invert_checkbutton).grid(row=index + 1, column=0)
Button(self, text='Select All',
command=self._select_all_checkbutton).grid(row=index + 2,
column=0)
Button(self,
text='Deselect All',
command=self._deselect_all_checkbutton).grid(row=index + 2,
column=1)
Button(self, text='MagicBack',
command=self._backup_event).grid(row=index + 3, column=0)
Button(self, text='Restore',
command=self._restore_event).grid(row=index + 3, column=1)
def __init__(self, parent, controller):
self.controller = controller
Frame.__init__(self, parent, bg="black",)
height = 500
width = 550
canvas = Canvas(
self, height=height, width=width, bg='black')
canvas.pack()
loginlabel = Label(self, image=controller.loginbg)
loginlabel.place(relheight=1, relwidth=1)
b = Button(self, text="Submit", bg='#202021', fg='white', activebackground='black',
activeforeground='white', bd=0, image=controller.loginimage, command=lambda: self.getDat())
b.place(relx=0.22, rely=0.68, relheight=0.05, relwidth=0.315)
b2 = Button(self, text="Cancel", bg='#202021', fg='white', activebackground='black',
bd=0, activeforeground='white', image=controller.cancelimage)
b2.place(relx=0.6, rely=0.68, relheight=0.05, relwidth=0.317)
# --------------------------------------
self.c = IntVar()
self.check = Checkbutton(self, text='Remember ID and Password', bg='#202021',
fg='grey', activeforeground='white', activebackground='#202021', variable=self.c)
self.check.place(relx=0.4, rely=0.59)
self.label_logo = Label(
self, text="LIGHT", fg='white', font=1000, bg='#202021', image=controller.logoimage)
self.label_logo.place(relx=0.35, relheight=0.33, relwidth=0.4)
self.label2 = Label(
self, text="Password: "******"Username: "******"*", bd=2)
self.entry_pass.place(relx=0.4, rely=0.48,
relheight=0.05, relwidth=0.5)
def __init__(self, master):
self.master = master
master.title("Presenting choices with check buttons and radio buttons")
# Create a checkbutton and show in window
self.checkbutton = Checkbutton(master,
text='SPAN? ',
font=('Arial', 12, 'bold'))
self.checkbutton.pack()
self.spam = StringVar()
self.spam.set('SPAM!')
self.spam.get()
self.checkbutton.config(text="Span",
variable=self.spam,
onvalue="Span Please",
offvalue="Boo Span")
print(self.spam.get())
print(self.spam.get())
self.breakfast = StringVar()
self.radiobutton = Radiobutton(root,
text="SPAM",
variable=self.breakfast)
self.radiobutton.pack()
self.rbeggs = Radiobutton(root,
text="Eggs",
variable=self.breakfast,
value='Eggs')
self.rbeggs.pack()
self.rbsausage = Radiobutton(root,
text="Sausage",
variable=self.breakfast,
value='Sausage')
self.rbsausage.pack()
self.rbspan = Radiobutton(root,
text="SPAM",
variable=self.breakfast,
value='SPAM')
self.rbspan.pack()
self.breakfast.get()
self.checkbutton.config(variable=self.breakfast)
def create_widgets(self):
self.canvas = Canvas(
self,
bg=CANVAS_BACKGROUND_COLOR,
bd=0,
highlightthickness=0,
relief=FLAT
)
self.canvas.pack(side=LEFT, fill=BOTH, expand=1)
self.control_panel = Frame(
self,
bg=CONTROL_PANEL_BACKGROUND_COLOR,
width=500,
#width=self.width/9
)
self.control_panel.pack(side=LEFT, fill=Y, expand=0)
self.cp_wrap = Frame(
self.control_panel,
bg=CONTROL_PANEL_BACKGROUND_COLOR,
width=150,
#width=self.width/9
)
self.cp_wrap.pack(fill=X, expand=0)
self.button1 = Button(
self.control_panel,
text=self.button1_text,
command=self.reset
)
self.button1.pack()
self.trans = TransformationInputs(
self.control_panel,
bg=CONTROL_PANEL_BACKGROUND_COLOR
)
self.check_button1 = Checkbutton(
self.control_panel,
text='Axes on mid',
bg=CONTROL_PANEL_BACKGROUND_COLOR,
bd=0,
variable=self.mid_ax,
onvalue=True, offvalue=False
)
self.trans.pack()
self.check_button1.pack(side=TOP)
self.trans.create_elements()
def check_btn(master, text, variable, command=None):
new_checkbtn = Checkbutton(
master.ui,
text=text,
variable=variable,
**master.theme,
command=command,
font=master.FONTS["buttons"]["small"],
activebackground=master.bg,
activeforeground=master.fg,
highlightcolor=master.bg,
selectcolor=master.bg,
onvalue=True,
offvalue=False,
)
return new_checkbtn
def addAttribute(self, propertyWindow, addProp, objtype=None):
PropertyName = (propertyWindow.grid_slaves(addProp + 1, 1)[0]).get()
PropertyVal = (propertyWindow.grid_slaves(addProp + 2, 1)[0]).get()
v = Tkinter.IntVar()
for i in range(addProp, addProp + 5):
for w in propertyWindow.grid_slaves(row=i):
w.grid_forget()
c = Checkbutton(propertyWindow, text=PropertyName, variable=v)
c.grid(column=0, row=addProp, padx=5, sticky='w')
c.is_selected = v
DefaultVal = StringVar(self.root, value=PropertyVal)
Entry(propertyWindow, textvariable=DefaultVal).grid(column=1,
row=addProp,
sticky='we')
self.addPropertywidget(propertyWindow, addProp + 1, objtype)
def createWidgets(self):
self.initialize_variables()
# Background
self.canvas = Canvas(self.root, height=self.HEIGHT, width=self.WIDTH)
self.background_label = Label(self.root, bg='#3C1E5F')
self.background_label.place(relwidth=1, relheight=1)
self.canvas.pack()
# Upper frame with logo and info message
self.higher_frame = Frame(self.root, bg='#FFD164', bd=5)
self.higher_frame.place(relx=0.5, rely=0.1, relwidth=0.85, relheight=0.35, anchor='n')
self.logo = Canvas(self.higher_frame, bd=1)
self.logo.place(relx=0, rely=0, relwidth=1, relheight=0.5)
self.img = PhotoImage(file="logo.png")
self.img = self.img.subsample(6)
self.logo.create_image(0, 0, anchor='nw', image=self.img)
self.var = "Sentiment Classification and Categorization of txt files"
self.infoMessage = Message(self.higher_frame, text=self.var, justify='center', width=350, font=("Courier bold", 16))
self.infoMessage.place(relx=0.4, rely=0.05, relwidth=0.5, relheight=0.3)
# Menubar with Option, Result and Direct input
self.menubar()
# Lower frame with scrollbars for displaying of categories and file names
self.lower_frame = Frame(self.root, bg='#FFD164', bd=5)
self.lower_frame.place(relx=0.5, rely=0.35, relwidth=0.85, relheight=0.55, anchor='n')
self.lower_frame.grid_rowconfigure(0, weight=1)
self.lower_frame.grid_columnconfigure(0, weight=1)
self.optionCanvas = Canvas(self.lower_frame, bg='white', bd=3)
self.optionCanvas.place(relwidth=1, relheight=1)
# select language (English or Swedish)
self.selectLanguage(self.optionCanvas)
# open folder with input files
self.openFolder = Label(self.optionCanvas, text="Open a folder with input files", justify='left',
bg='white',
font=("Courier bold", 12))
self.openFolder.place(relx=0.1, rely=0.4, relwidth=0.3, relheight=0.2)
self.button = Button(self.optionCanvas, text="Browse", font=("Courier", 12), bg='#EE7C7D',
activebackground='#f2d9e6',
command=lambda: self.fileDialog())
self.button.place(relx=0.5, rely=0.4, relwidth=0.3, relheight=0.15)
# save result in excel file
self.CheckVar = IntVar()
self.excelFileCheckbutton = Checkbutton(self.optionCanvas, text="Save as excel", variable=self.CheckVar, \
onvalue=1, offvalue=0, bg='white', font=("Courier bold", 12), height=5, width=20)
self.excelFileCheckbutton.place(relx=0.1, rely=0.6, relwidth=0.3, relheight=0.15)
def create_header_frame(self):
header = tk.Frame(self)
header.grid(sticky='new', row=0, column=0)
trigger_channel_label = tk.Label(header, text="Trigger Channel")
trigger_channel_label.grid(row=0, column=0, pady=(5, 0), sticky='nw')
trigger_channel_entry = tk.OptionMenu(header, self.trigger_channel,
*self.trigger_channels)
trigger_channel_entry.grid(row=0, column=1)
trigger_type_label = tk.Label(header, text="Trigger Type")
trigger_type_label.grid(row=0, column=2, pady=(5, 0), sticky='nw')
trigger_type_entry = tk.OptionMenu(header, self.trigger_type,
*self.trigger_types)
trigger_type_entry.grid(row=0, column=3)
precapture_size_label = tk.Label(header, text="Precapture size")
precapture_size_label.grid(row=0, column=4, pady=(5, 0), sticky='nw')
precapture_size_entry = tk.OptionMenu(header, self.precapture_size,
*self.precapture_percentages)
precapture_size_entry.grid(row=0, column=5)
sample_divisor_label = tk.Label(header, text="Sample Rate")
sample_divisor_label.grid(row=0, column=6, pady=(5, 0), sticky='nw')
sample_divisor_entry = tk.OptionMenu(header, self.sample_divisor,
*self.sample_divisors)
sample_divisor_entry.grid(row=0, column=7)
trigger_delay_enable_checkbox = Checkbutton(
header,
text="Trigger Delay Enable",
variable=self.trigger_delay_enabled)
trigger_delay_enable_checkbox.grid(row=0,
column=8,
pady=(5, 0),
sticky='nw')
trigger_delay_label = tk.Label(header, text="Delay")
trigger_delay_label.grid(row=0, column=9, pady=(5, 0), sticky='nw')
self.trigger_delay_entry = ttk.Combobox(header,
values=self.trigger_delays,
state='readonly')
self.trigger_delay_entry.set(self.trigger_delays[0])
self.trigger_delay_entry.bind("<<ComboboxSelected>>",
self.trigger_delay_dropdown)
self.trigger_delay_entry.grid(row=0, column=10)
def __init__(self, parent=None, picks=None):
Frame.__init__(self, parent)
self.frame = parent
picks = picks or list()
self.check_btn = dict()
self.check_vars = list()
self.board_num = IntVar()
self.boards_shown = 0
self.fig = object()
self.cnv = object()
self.label_txt = object()
self.shot_label = object()
self.animator_obj = object()
self.xml_info = dict()
self.boards = {
0: 'SSP',
1: 'XGRAD',
2: 'YGRAD',
3: 'ZGRAD',
4: 'RHO1',
5: 'RHO2',
6: 'THETA1',
7: 'THETA2'
}
for i, pick in enumerate(picks):
self.check_vars.append(IntVar())
self.check_vars[i].set(0)
self.check_btn[i] = Checkbutton(self.frame,
text=pick,
variable=self.check_vars[i])
for i, button in enumerate(self.check_btn):
self.check_btn[i]["command"] = \
lambda board=self.check_vars[i], id_num=button: self.toggle(board, id_num)
self.check_btn[i].pack(side="left",
anchor="nw",
fill="x",
expand=True)
def writeProgramField(
self,
programWidget,
program,
highlight=None
): # TODO (improv) prevent small/empty frame when loading prog
self.clearFrame(programWidget)
self.breakpoints = []
self.programScrollFrame = TKHelper.ScrollFrame(programWidget)
tableRelief = "solid"
global programTableView
programTableView = self.programScrollFrame.viewPort
for idx, key in enumerate(PROGRAM_HEADERS):
Label(self.programScrollFrame.viewPort,
text=key,
font=('bold'),
relief=tableRelief).grid(row=0, column=idx, sticky="snew")
self.programScrollFrame.viewPort.columnconfigure(idx,
minsize=len(key))
for _lineNo, pLine in enumerate(program):
_var = IntVar()
self.breakpoints.append(_var)
_bg = colorScheme[
"highlightBg"] if _lineNo == highlight else colorScheme[
"defaultBg"]
Checkbutton(self.programScrollFrame.viewPort,
relief=tableRelief,
bg=_bg,
variable=_var).grid(row=_lineNo + 1,
column=0,
sticky="snew")
Label(self.programScrollFrame.viewPort,
text=str(_lineNo + 1),
relief=tableRelief,
bg=_bg).grid(row=_lineNo + 1, column=1, sticky="snew")
for idx, token in enumerate(self.parseLine(pLine.split())):
Label(self.programScrollFrame.viewPort,
text=token,
relief=tableRelief,
bg=_bg).grid(row=_lineNo + 1,
column=2 + idx,
sticky="snew")
self.programScrollFrame.pack(side="top", fill="both", expand=True)
def construct_input_boxes(self):
bottom_frame = Frame(self)
chrom_title = Label(bottom_frame, text="Chromosomes:")
self.chrom_entry = Entry(bottom_frame, width=10)
self.chrom_entry.insert(0, "30")
chrom_title.grid(row=0, column=0, padx=10)
self.chrom_entry.grid(row=0, column=1, padx=10)
head_title = Label(bottom_frame, text="Head length:")
self.head_entry = Entry(bottom_frame, width=10)
self.head_entry.insert(0, "8")
head_title.grid(row=0, column=2, padx=10)
self.head_entry.grid(row=0, column=3, padx=10)
gene_title = Label(bottom_frame, text="Number of Genes:")
self.gene_entry = Entry(bottom_frame, width=10)
self.gene_entry.insert(0, "4")
gene_title.grid(row=0, column=4, padx=10)
self.gene_entry.grid(row=0, column=5, padx=10)
cycle_title = Label(bottom_frame, text="Number of Cycles:")
self.cycle_entry = Entry(bottom_frame, width=10)
self.cycle_entry.insert(0, "500")
cycle_title.grid(row=1, column=0, padx=10, pady=10)
self.cycle_entry.grid(row=1, column=1, padx=10, pady=10)
k_fold_title = Checkbutton(bottom_frame,
text="K-fold Validation:",
variable=self.k_control)
self.k_fold_entry = Entry(bottom_frame, width=10)
self.k_fold_entry.insert(0, "10")
k_fold_title.grid(row=1, column=2, padx=10, pady=10)
self.k_fold_entry.grid(row=1, column=3, padx=10, pady=10)
start_button = Button(bottom_frame,
text="START",
bg="#98fb98",
width=12,
command=self.start_training)
cancel_button = Button(bottom_frame,
text="CANCEL",
bg="#ff9292",
width=12)
start_button.grid(row=1, column=4, padx=2, pady=10)
cancel_button.grid(row=1, column=5, padx=2, pady=10)
bottom_frame.pack(side="bottom", pady=40)
def init_star(self):
def load_star():
f = filedialog.askopenfilename()
self.star_file.set(f)
def analyze_star():
star = starshot.Starshot(self.star_file.get(), sid=self.star_sid.get(),
dpi=self.star_dpi.get())
star.analyze(radius=self.star_radius.get(), tolerance=self.star_tolerance.get(),
recursive=self.star_recursive.get())
name, _ = osp.splitext(self.star_file.get())
fname = name + '.pdf'
fname = utilities.file_exists(fname)
star.publish_pdf(fname)
self.star_pdf.set(fname)
utilities.open_path(fname)
self.star_tab = Frame(self.notebook)
self.star_file = StringVar()
self.star_pdf = StringVar()
self.star_dpi = DoubleVar()
self.star_sid = DoubleVar()
self.star_radius = DoubleVar(value=0.85)
self.star_tolerance = DoubleVar(value=1)
self.star_recursive = BooleanVar(value=True)
Button(self.star_tab, text='Load starshot file...', command=load_star).grid(column=1, row=1)
Label(self.star_tab, textvariable=self.star_file).grid(column=1, row=2)
Label(self.star_tab, text='DPI (if file is not DICOM):').grid(column=1, row=3)
Entry(self.star_tab, width=7, textvariable=self.star_dpi).grid(column=2, row=3)
Label(self.star_tab, text='SID (mm; if file is not DICOM):').grid(column=1, row=4)
Entry(self.star_tab, width=7, textvariable=self.star_sid).grid(column=2, row=4)
Label(self.star_tab, text='Normalized analysis radius (0.2-1.0):').grid(column=1, row=5)
Entry(self.star_tab, width=7, textvariable=self.star_radius).grid(column=2, row=5)
Checkbutton(self.star_tab, text='Recursive analysis?', variable=self.star_recursive).grid(column=1, row=6)
Label(self.star_tab, text='Tolerance (mm):').grid(column=1, row=7)
Entry(self.star_tab, width=7, textvariable=self.star_tolerance).grid(column=2, row=7)
Button(self.star_tab, text='Analyze', command=analyze_star).grid(column=1, row=9)
Label(self.star_tab,
text='Analysis will analyze the file(s) according to the settings, \nsave a PDF in the same directory as the original file location and then open it.').grid(
column=1, row=10)
Label(self.star_tab, text='Save file:').grid(column=1, row=11)
Label(self.star_tab, textvariable=self.star_pdf).grid(column=1, row=12)
self.notebook.add(self.star_tab, text='Starshot')
for child in self.star_tab.winfo_children():
child.grid_configure(padx=10, pady=5)
def __init__(self, parent=None, picks=None, side=LEFT, anchor=W):
'''
Constructor
:param parent: the parent
:param picks:
:param side: the side to pack to
:param anchor: the location
'''
if not picks:
picks = []
Frame.__init__(self, parent)
self.vars = []
for pick in picks:
var = IntVar()
chk = Checkbutton(self, text=pick, variable=var)
chk.pack(side=side, anchor=anchor, expand=YES)
self.vars.append(var)
def make_Checkbutton_2(self, frame):
""" Checkbutton: Italic : at LabelFrame_1(2,1)"""
self.Checkbutton_2 = Checkbutton(frame,
text="Italic",
width="15",
anchor="w")
self.Checkbutton_2.grid(row=2, column=1)
self.Checkbutton_2_StringVar = StringVar()
# >>>>>>insert any user code below this comment for section "make_Checkbutton_2"
self.Checkbutton_2.configure(variable=self.Checkbutton_2_StringVar,
onvalue="yes",
offvalue="no")
self.Checkbutton_2_StringVar.set("no")
self.Checkbutton_2_StringVar_traceName = self.Checkbutton_2_StringVar.trace_variable(
"w", self.Checkbutton_2_StringVar_Callback)
def create_sheet(master, sheet: str, column: int, canvas_master):
ConfigFrame.SHEET_VAR_DICT[sheet] = IntVar()
ConfigFrame.SHEET_LABEL_DICT[sheet] = Checkbutton(
master=master,
variable=ConfigFrame.SHEET_VAR_DICT[sheet],
command=lambda: switch_sheet(sheet, canvas_master))
ConfigFrame.SHEET_LABEL_DICT[sheet].config(
ConfigFrame.SHEET_ATTR_DICT[sheet])
ConfigFrame.SHEET_LABEL_DICT[sheet].grid({
'row': 0,
'column': column,
'sticky': 'nswe'
})
if sheet == 'R':
ConfigFrame.SHEET_VAR_DICT[sheet].set(1)
ConfigFrame.SHEET_LABEL_DICT[sheet]['state'] = DISABLED
return
def build_overview(self, data, header):
self.overview_frame.destroy()
self.overview_frame = Frame(self.right_frame, bd=1, relief=GROOVE)
self.overview_frame.grid(row=0, column=1, rowspan=2, sticky=W+E+N+S)
self.overview_frame.columnconfigure(0, weight=1)
self.overview_frame.rowconfigure(0, weight=1)
win_frame = Frame(self.overview_frame, background="#ffffff")
x_frame = Frame(self.overview_frame)
y_frame = Frame(self.overview_frame)
z_frame = Frame(self.overview_frame)
win_frame.grid(row=0, column=0, sticky=W+E+N+S)
x_frame.grid(row=1, column=0, sticky=W+E)
y_frame.grid(row=0, column=1, sticky=N+S)
z_frame.grid(row=1, column=1, sticky=W+E+N+S)
scroll_frame = ScrollableFrame(win_frame, x_frame, y_frame)
# (De) select all
Button(scroll_frame,
text="Select",
justify=LEFT,
anchor=W,
command=lambda: self.toggle_all(1)).grid(row=0, column=0, sticky=W+E)
Button(scroll_frame,
text="Deselect",
justify=LEFT,
anchor=W,
command=lambda: self.toggle_all(0)).grid(row=0, column=1, sticky=W+E)
if header:
self.include_cols = []
for i, genre in enumerate(header):
var = IntVar(self.master)
var.set(1)
self.include_cols.append(var)
Checkbutton(scroll_frame,
text=str(genre),
justify=LEFT,
anchor=W,
variable=var,
command=lambda: self.toggle_col()).grid(row=i+1, column=0, sticky=W+E, columnspan=2)
self.col_map = [var.get() for var in self.include_cols]
self.settings["max_clust"].set(str(len(header)))
self.toggle_col()
def body(self, master):
col = 0
row = 0
for i, action in enumerate(
self.action_space_filter._action_space.get_all_actions()):
Checkbutton(master,
text=action.get_readable_with_index(),
variable=self.action_choices[i]).grid(column=col,
row=row,
pady=3,
padx=3)
row += 1
if row == 8:
row = 0
col += 1
return None # Returns widget to have initial focus
def askopendir_train():
set_dir_data_path = filedialog.askdirectory(parent=cont_training, title='Choose a directory')
dir_data_path_train.set(set_dir_data_path)
mydata = Create_npy_files(dir_data_path_train.get())
try:
zero_perc, fg_bg_ratio = mydata.check_class_balance()
text = "Average percentage of background pixels in augmented label data: " + str(round(zero_perc*100,2))
place_text(cont_training, text, 30, 360, None, None)
text2 = "Foreground to background pixel ratio: 1 to " + str(fg_bg_ratio) + " "*30
place_text(cont_training, text2, 30, 380, None, None)
popup_newex_var.set("New")
popupMenu_new_ex = OptionMenu(cont_training, popup_newex_var, *set(["New", "Existing"]))
popupMenu_new_ex.place(bordermode=OUTSIDE, x=30, y=90, height=30, width=100)
weight_images = os.listdir(dir_data_path_train.get() + os.sep + "aug_weights")
if len(weight_images) == 0:
place_text(cont_training, "No weight map images detected.", 30, 280, 30, 180)
use_weight_map.set(0)
else:
use_weight_map.set(False)
Checkbutton(cont_training, text="Use weight map", variable=use_weight_map, onvalue=True,
offvalue=False).place(bordermode=OUTSIDE, x=30, y=250, height=30, width=120)
text_bs = "When using a weight map for training, use a lower batch size"
place_text(cont_training, text_bs, 30, 275, None, None)
place_text(cont_training, "to not overload your GPU/CPU memory", 30, 290, None, None)
place_text(cont_training, "Class balance weight factor", 30, 325, None, None)
place_entry(cont_training, balancer, 250, 320, 30, 50)
except:
text_er = "Error: Please choose the MitoSegNet Project directory"
self.place_text(cont_training, text_er, 500, 30, 20, 380)
def drawWidgets(self):
label1 = Label(self.window, text="Choose pairs you want to delete:")
label1.pack(side="top", padx="10", pady="5")
self.tmp = OrderedDict()
self.tmp = {str(key) + ': ' + str(self.parent.pixel_points[key]) + ' ' + str(self.parent.fix_points[key]):IntVar(value=0) for key, value in enumerate(self.parent.fix_points)}
for key, value in self.tmp.items():
self.c = Checkbutton(self.window, text = str(key), variable = value, onvalue = 1, offvalue = 0)
self.c.pack(side="top", anchor=W, padx="10", pady="5")
btn1 = Button(self.window, text="Delete selected", command=lambda *args: self.del_sel(self.window))
btn1.pack(side="top", fill="both", padx="10", pady="5")
btn2 = Button(self.window, text="Save pairs to disk", command=lambda *args: self.parent.save_pairs())
btn2.pack(side="top", fill="both", padx="10", pady="5")
def make_Checkbutton_4(self, frame):
""" Checkbutton: Overstrike : at LabelFrame_1(4,1)"""
self.Checkbutton_4 = Checkbutton(frame,
text="Overstrike",
width="15",
anchor="w")
self.Checkbutton_4.grid(row=4, column=1)
self.Checkbutton_4_StringVar = StringVar()
# >>>>>>insert any user code below this comment for section "make_Checkbutton_4"
self.Checkbutton_4.configure(variable=self.Checkbutton_4_StringVar,
onvalue="yes",
offvalue="no")
self.Checkbutton_4_StringVar.set("no")
self.Checkbutton_4_StringVar_traceName = self.Checkbutton_4_StringVar.trace_variable(
"w", self.Checkbutton_4_StringVar_Callback)
