class NEATPanel(Frame):
def __init__(self, tile_size, Genomes=[]):
self.root = Tk()
self.root.geometry("780x720")
self.root.update()
self.genoemes_num = len(Genomes)
self.genoemes = Genomes
self.tile_num = 5
self.tile_size = tile_size
self.entry = Entry(self.root)
self.entry.grid(row=0, column=4)
self.root.bind('<Return>', self.hit_enter)
canvas_main = Canvas(self.root, width=620, height=720)
canvas_main.grid(row=0, column=0, sticky='news')
scroll_bar = Scrollbar(self.root,
orient="vertical",
command=canvas_main.yview)
scroll_bar.grid(row=0, column=1, sticky='ns')
canvas_main.configure(yscrollcommand=scroll_bar.set)
self.frame = Frame(
self.root,
width=600,
height=math.ceil(self.genoemes_num / self.tile_num) * 120)
canvas_main.create_window((0, 0), window=self.frame, anchor='nw')
self.canvases = [
Canvas(self.frame,
width=self.tile_size,
height=self.tile_size,
bg='gray') for _ in range(self.genoemes_num)
]
counter = 0
for i in range(math.ceil(self.genoemes_num / self.tile_num)):
for j in range(self.tile_num):
self.canvases[counter].grid(row=i, column=j, sticky='news')
if counter == self.genoemes_num - 1:
break
counter += 1
canvas_main.config(scrollregion=canvas_main.bbox("all"))
self.frame.update_idletasks()
def start(self):
self.root.mainloop()
def hit_enter(self, event):
_input = int(self.entry.get())
#self.canvases[_input].place(x=0,y=0)
self.canvases[_input].grid(row=0,
column=0,
columnspan=2,
rowspan=2,
padx=5,
pady=5)
self.canvases[_input].config(width=320, height=320)
self.frame.update_idletasks()
def right_frame(parent):
rf_width = 300
rf_height = 360
# right side frame
frame_right = LabelFrame(
parent.building_pos_window,
text="Building Position",
width=rf_width - 10,
height=rf_height - 10,
)
frame_right.grid_rowconfigure(0, weight=1)
frame_right.grid_columnconfigure(0, weight=1)
frame_right.grid_propagate(False)
canvas_right = Canvas(frame_right)
canvas_right.grid(row=0, column=0, sticky=N + W)
# Link a scrollbar to the canvas
def on_mousewheel(event):
canvas_right.yview_scroll(int(-1 * (event.delta / 120)), "units")
def bound_to_mousewheel(event):
canvas_right.bind_all("<MouseWheel>", on_mousewheel)
def unbound_to_mousewheel(event):
canvas_right.unbind_all("<MouseWheel>")
y_scrollbar = Scrollbar(frame_right,
orient="vertical",
command=canvas_right.yview)
y_scrollbar.grid(row=0, column=1, sticky='ns')
canvas_right.configure(yscrollcommand=y_scrollbar.set)
inner_frame_right = Frame(canvas_right)
inner_frame_right.bind('<Enter>', bound_to_mousewheel)
inner_frame_right.bind('<Leave>', unbound_to_mousewheel)
canvas_right.create_window((0, 0),
window=inner_frame_right,
anchor='nw')
idx = 0
for e_name in BuildingNames:
building_name_xy_config_frame(
inner_frame_right, idx, e_name.value,
parent.bot_building_pos.get(e_name.value, [-1, -1])
if parent.bot_building_pos is not None else [-1, -1])
idx = idx + 1
inner_frame_right.update_idletasks()
frame_right.config(width=rf_width - 10, height=360 - 10)
canvas_right.config(width=rf_width - 10,
height=360 - 10,
scrollregion=canvas_right.bbox("all"))
frame_right.grid(row=0, column=1, padx=5, pady=5, sticky=N + W)
return inner_frame_right
def information(self):
########################################################################
# Information #
########################################################################
# Renvoie les spécialite offerte par l'école en fonction du choix de l'utilisateur
window = Toplevel(self.root)
window.resizable(True, True)
vsb = Scrollbar(window, orient="vertical")
vsb.grid(row=0, column=1, sticky="ns")
hsb = Scrollbar(window, orient="horizontal")
hsb.grid(row=1, column=0, sticky="ew")
ca = Canvas(window, yscrollcommand=vsb.set, xscrollcommand=hsb.set)
ca.grid(row=0, column=0, sticky="news")
vsb.config(command=ca.yview)
hsb.config(command=ca.xview)
window.grid_rowconfigure(0, weight=1)
window.grid_columnconfigure(0, weight=1)
fr = Frame(ca)
i=1
for a in ["Nom","Admission","Region","Alternance","Specialite"]:
Label(fr, text=a).grid(row=0, column=i)
i+=2
if self.choix["specialites"] == None:
ListeSpe = list(self.specialites.get(0, "end"))
else:
ListeSpe = [
self.specialites.get(i) for i in self.specialites.curselection()
]
if self.choix["alternance"] == None:
alternance = ["Oui", "Non"]
else:
alternance = [self.choix["alternance"][0]]
ligne = 1
for ecole in self.ecolesselect.values():
if ecole["var"].get() == 1:
for i in [value for (key,value) in self.ecolesselect.items() if value['nom']==ecole['nom'] and value["Spe"] in ListeSpe and value["Alternance"] in alternance ]:
j=1
for texte in [i["nom"],i["admission"],i["region"],i["Alternance"],i["Spe"]] :
a = Entry(fr,width=60)
a.insert(0,texte)
a.grid(row=ligne, column=j)
j+=2
a.config(state="disabled")
ligne += 1
ca.create_window(0, 0, window=fr)
fr.update_idletasks()
ca.config(scrollregion=ca.bbox("all"))
def init_gui(self, cim):
"""Make a new tkinter window"""
root = Tk()
root.grid_rowconfigure(0, weight=1)
root.columnconfigure(0, weight=1)
root.title(cim)
root.resizable(False, True)
frame_main = Frame(root)
frame_main.grid(sticky='news')
# Create a frame for the canvas with non-zero row&column weights
frame_canvas = Frame(frame_main)
frame_canvas.grid(row=0, column=0)
frame_canvas.grid_rowconfigure(0, weight=1)
frame_canvas.grid_columnconfigure(0, weight=1)
# Set grid_propagate to False to allow 5-by-5 buttons resizing later
frame_canvas.grid_propagate(False)
# Add a canvas in that frame
canvas = Canvas(frame_canvas)
canvas.grid(row=0, column=0)
canvas.pack(fill="both", expand=True)
# Link a scrollbar to the canvas
vsb = Scrollbar(frame_canvas, orient="vertical", command=canvas.yview)
vsb.grid(row=0, column=1, sticky='ns')
canvas.configure(yscrollcommand=vsb.set)
# Create a frame to contain the scrollable content
frame_progress = Frame(canvas)
canvas.create_window((0, 0), window=frame_progress, anchor='nw')
self.canvas = canvas
self.frame_main = frame_main
for process in self.process_list:
self.init_new_progressbar(frame_progress,
p_length=300,
p_process=process)
frame_progress.update_idletasks()
p = self.process_list[0]
frame_width = p['task_label'].winfo_width(
) + p['progressbar'].winfo_width() + p['status_label'].winfo_width()
rows = 20 if len(self.process_list) > 20 else len(self.process_list)
frame_height = (p['progressbar'].winfo_height() * rows)
frame_canvas.config(width=frame_width + vsb.winfo_width(),
height=frame_height)
canvas.config(width=frame_width + vsb.winfo_width(),
height=frame_height)
canvas.config(scrollregion=canvas.bbox("all"))
canvas.update()
self.frame_main.bind("<Configure>", self.configure)
return root
def __init__(self,
parent: tk.Frame = None,
interval=20,
linenum=10,
save=True,
drag=True,
adaptation=True,
lengthx=20000):
Canvas.__init__(self, parent, bg='#345', closeenough=2)
parent.update_idletasks()
self.pack(fill=tk.BOTH, expand=True)
self.update_idletasks()
self.hScroll = Scrollbar(parent,
orient='horizontal',
command=self.hScrolled)
self.hScroll.pack(side=tk.BOTTOM, fill=tk.X)
self.configure(yscrollcommand=None,
xscrollcommand=self._canvashScrolled)
self.bind("<Button-1>", self.__mouseDown)
self.bind("<MouseWheel>", self.__mouseScale)
self.bind("<B1-Motion>", self.__mouseDownMove)
self.bind("<B1-ButtonRelease>", self.__mouseUp)
self.bind("<Enter>", self.__mouseEnter)
self.bind("<Leave>", self.__mouseLeave)
self.bind("<Motion>", self.__mouseHoverMove)
self["xscrollincrement"] = 1
self["yscrollincrement"] = 1
self.__dataList = []
self._rulerdata = [0] * linenum
self.x = 0
self.scrollx = 3.0
self.offsety = 0
self._interval = interval # main loop interval to handle input data
self._lengthx = lengthx # scrollregion x
self._rulerOn = False
self._dragOn = drag # enable mouse move items
self._gridOn = True # draw grid lines
self._loopOn = True
self._tipOn = False
self._adaptation = adaptation
self._ruler = None
self._rulerX = -1
self._save = save # 保存数据
self._dataWriter = None # 数据保存writer
self._datafile = '' # 保存文件名称
self._scrollOn = False
self._lineNum = linenum
self._firststart = True
# this data is used to keep track of an item being dragged
# in this app, only vertical position
self._drag_data = {"sx": 0, "sy": 0, "x": 0, "y": 0, "item": None}
self._lines = []
self.after(200, self.__initCanvas)
def config_frame(self):
frame_canvas = LabelFrame(self,
text='Config',
width=self.windows_size[0],
height=self.windows_size[1] - 200
)
frame_canvas.grid_rowconfigure(0, weight=1)
frame_canvas.grid_columnconfigure(0, weight=1)
frame_canvas.grid_propagate(False)
# Add a canvas in that frame
canvas = Canvas(frame_canvas)
canvas.grid(row=0, column=0, sticky=N+W)
# Link a scrollbar to the canvas
def on_mousewheel(event):
canvas.yview_scroll(int(-1*(event.delta/120)), "units")
def bound_to_mousewheel(event):
canvas.bind_all("<MouseWheel>", on_mousewheel)
def unbound_to_mousewheel(event):
canvas.unbind_all("<MouseWheel>")
y_scrollbar = Scrollbar(frame_canvas, orient="vertical", command=canvas.yview)
y_scrollbar.grid(row=0, column=1, sticky='ns')
canvas.configure(yscrollcommand=y_scrollbar.set)
inner_frame = Frame(canvas)
inner_frame.bind('<Enter>', bound_to_mousewheel)
inner_frame.bind('<Leave>', unbound_to_mousewheel)
canvas.create_window((0, 0), window=inner_frame, anchor='nw')
for i in range(len(atf.bot_config_title_fns)):
title_fns, sub_fns = atf.bot_config_title_fns[i]
check = section_frame(
self,
inner_frame,
title_fns,
sub_fns
)
check.grid(row=i, column=0, sticky=N + W)
inner_frame.update_idletasks()
frame_canvas.config(width=self.windows_size[0] - 20, height=self.windows_size[1] - 350)
canvas.config(width=self.windows_size[0] - 20, height=self.windows_size[1] - 350, scrollregion=canvas.bbox("all"))
return frame_canvas
def recherche():
global accept
global ch
choix = ch
print(choix)
accept = 0
framemodif.destroy()
cnv2.delete(ALL)
mois = t.get()
annee = t2.get()
couleurfrm = "#99512B"
vScroll2.grid(row=0, column=1, sticky='ns')
cnv2.configure(yscrollcommand=vScroll2.set)
frm2 = Frame(cnv2, bg=couleurfrm)
cnv2.create_window(0, 0, window=frm2, anchor='nw')
n = 0
n2 = 0
n3 = 0
for file in glob.glob("categories/%s/%sfact%s/%s/*.jpg" %
(choix, annee, choix, mois)):
b = os.path.splitext(os.path.basename(file))[0]
verif = b[-1]
if verif == "z":
btext = b.replace("z", "")
photo = ImageTk.PhotoImage(
file="categories/%s/%sfact%s/%s/%s.jpg" %
(choix, anneetoday, choix, mois, b))
bouton = Button(frm2,
compound=TOP,
height=150,
text="%s" % btext,
width=150,
image=photo,
command=lambda i=btext: choose(i))
dic['photo%s' %
n3] = photo ## on sauvegarde dans le dico l'instance
bouton.grid(row=n, column=n2, padx=20, pady=10)
n2 = n2 + 1
n3 = n3 + 1
if n2 == 4:
n2 = 0
n = n + 1
frm2.update_idletasks()
cnv2.configure(scrollregion=(0, 0, frm2.winfo_width(),
frm2.winfo_height()))
def choose(choix2):
os.startfile("categories\%s\%sfact%s\%s\%s.jpg" %
(choix, anneetoday, choix, mois, choix2))
def draw_table(self):
# clear the canvas of past tables
self.tablecanvas.delete("all")
# create the frame to hold the table
frame = Frame(self.tablecanvas)
frame.rowconfigure(0, weight=1)
frame.columnconfigure(0, weight=1)
# PACE HOLDER FOR REAL TABLE GENERATION
for i in range(25):
Button(frame, text=i).grid(row=i, column=i)
# make the window that holds the frame
self.tablecanvas.create_window(0, 0, window=frame, anchor=N + W)
frame.update_idletasks()
# update the scrollable area to the new width
self.tablecanvas.config(scrollregion=self.tablecanvas.bbox("all"))
def ow_frames(input_criteria,
opened_files,
data_frames,
auto_open_var,
output_type,
file_list,
root2=False,
func=0,
file_name='default'):
"""
Search Open Files by Input Criteria and output file
:param input_criteria: Search Column and Search Item(s)
:param opened_files: List of opened files with Checkbutton variables
:param data_frames: list of open files(classes)
:param auto_open_var: Main window Checkbutton variable for Auto-Open
:param output_type: type of output - set to xlsx for a while
:param file_list: Search Order List
"""
def get_checked_l():
checked_list = []
for file in file_list: # Iterate through DataFrames using i as index
ind = file_list.index(file)
if opened_files[ind][2].get() == 1:
checked_list.append(file)
return checked_list
start = time.time()
new_output = [] # Search results per DataFrame
if not _test:
root = Frame(root2)
progress = Progressbar(root,
orient=HORIZONTAL,
length=300,
mode='determinate')
progress.pack(fill=X)
v = StringVar()
Label(root, textvariable=v).pack()
root.pack()
if func == 0 or func == 3:
if func == 0:
print('Searching:\n' + input_criteria[1][1].get())
search_column = (input_criteria[0][1].get()).strip()
out_d_and_n, zeros_dict, font_type_size, col_width, dec_rules,\
dec_place = GenFuncs.get_out_opts(input_criteria, search_column,output_type) # Load Settings
elif func == 3:
out_d_and_n, zeros_dict, font_type_size, col_width, dec_rules,\
dec_place = GenFuncs.get_out_opts(input_criteria, input_criteria[0],output_type, func=1, file_name=file_name) # Load Settings
checked_l = get_checked_l()
for file in checked_l:
ind = file_list.index(file)
if not _test:
progress_bar_ind = checked_l.index(file)
progress['value'] = ((
(progress_bar_ind + 1) / len(checked_l)) * 100) / 2
v.set("Searching : " + GenFuncs.strip_dir(file))
root.update_idletasks()
if func != 3:
results = data_frames[ind].search_col(
search_column, input_criteria[1][1].get(),
zeros_dict) # <-need to move
else:
results = data_frames[ind].search_col(
input_criteria[0], input_criteria[1], zeros_dict)
try:
if not results.empty:
new_output.append(results)
except AttributeError:
pass
else:
new_new_output = opened_files
output_type = 'xlsx'
out_d_and_n, zeros_dict, font_type_size, \
col_width, dec_rules, dec_place = GenFuncs.get_out_opts("", "",output_type, func=1, file_name=file_name) # Load Settings
output_directory = os.path.dirname(out_d_and_n)
for FP_out in os.listdir(
output_directory): # Clean output folder of past search items
if FP_out.endswith("FP_out.xlsx"):
try:
os.remove(os.path.join(output_directory, FP_out))
except PermissionError:
pass
if dec_place != False:
dec_var = '%.' + str(dec_place) + 'f'
else:
dec_var = "%.2f"
if not _test:
v.set("Formatting Output")
root.update_idletasks()
try:
if func == 0 or func == 3:
try:
new_new_output = pd.concat(new_output,
axis=0,
sort=False,
ignore_index=True)
except:
print("No results")
if not _test:
progress.destroy()
v.set("No results")
root.update_idletasks()
time.sleep(2)
root.destroy()
return
#var_file = shelve.open(os.path.join(os.path.expanduser('~'),'var_file'))
#try:
# plug_dicts = var_file['plug_lists']
# var_file.close()
# for key, value in plug_dicts.items():
# if value[0] == 1:
# new_new_output = value[1].run(new_new_output)
#except KeyError:
# var_file.close()
#print('fail retrieve_info')
cols_index = []
for col in new_new_output:
cols_index.append(col)
if output_type == 'csv':
new_new_output.to_csv(out_d_and_n, index=False)
elif output_type == 'xlsx':
writer_orig = pd.ExcelWriter(out_d_and_n, engine='xlsxwriter')
new_new_output.to_excel(writer_orig,
index=False,
sheet_name='SearchOutput',
float_format=dec_var)
workbook = writer_orig.book
worksheet = writer_orig.sheets['SearchOutput']
size = 10
f_rule_cnt = len(font_type_size) + len(col_width) + len(
dec_rules)
crnt_rule = 0
if font_type_size != {}: # Set Global Font Size / Type
try:
size = int(list(font_type_size.values())[0])
if size != False:
workbook.formats[0].set_font_size(size)
if list(font_type_size.keys())[0] != False:
workbook.formats[0].set_font_name(
list(font_type_size.keys())[0])
if not _test:
progress['value'] = ((
(crnt_rule / f_rule_cnt) * 100) / 2) + 50
crnt_rule += 1
v.set(v.get() + ".")
root.update_idletasks()
except IndexError:
pass
if len(col_width) > 0: # Set Column / Widths
for rule in col_width.items():
worksheet.set_column(rule[0], int(rule[1]))
if not _test:
progress['value'] = ((
(crnt_rule / f_rule_cnt) * 100) / 2) + 50
crnt_rule += 1
v.set(v.get() + ".")
root.update_idletasks()
try:
writer_orig.save()
except Exception as e:
print(e)
print("File with same criteria already open?")
if auto_open_var.get() == 1:
try:
if platform == "linux" or platform == "linux2":
opener = "open" if sys.platform == "darwin" else "xdg-open"
subprocess.call([opener, out_d_and_n])
else:
os.startfile(out_d_and_n, 'open')
except:
print(
'Error while trying to open application\nPlease set default xlsx application'
)
end = time.time()
print('-------' + str(end - start) + '-------')
else:
end = time.time()
print('-------' + str(end - start) + '-------')
print('done')
if not _test:
root.destroy()
except PermissionError as e:
print(str(e)[:28] + ": Close File Before Searching")
class Game(ABC):
def __init__(self):
self.frame = Frame(window, bg=bgc)
self.start = 0
self.end = 0
self.qstart = 0
self.qend = 0
self.questions = self.generate()
self.progress = 0
self.cq = self.questions[self.progress]
self.sv = tk.StringVar()
self.start_questions()
def factors(self, n):
# chain.from_iterable takes (x, y) as input and returns x y
return(set(chain.from_iterable(((self.check(i, n//i) for i in range(
2, min(int(n**0.5) + 1, 13)) if n % i == 0)))))
def format_percentage(self, v):
p = v["first"]*100
if p % 1 != 0.5:
p = round(p)
return ("{first}% of {second}").format(first=p, second=v["second"])
def check(self, a, b):
if 1 < b < 13:
return (a, b)
else:
return(a, a)
@abstractmethod
def generate(self):
pass
def create_grid(self):
self.ans.config(justify=tk.RIGHT)
self.first.config(anchor="e", text=self.cq["first"])
self.second.config(text=self.cq["second"])
self.op.config(text=self.cq["op"])
self.iframe.columnconfigure(0, weight=0)
self.iframe.columnconfigure(1, weight=0)
def create_one_line(self):
self.ans.config(justify=tk.CENTER)
self.iframe.columnconfigure(0, weight=1)
self.iframe.columnconfigure(1, weight=1)
self.first.config(anchor="center", text=self.cq["format"])
self.second.config(text="")
self.op.config(text="")
def start_questions(self):
# self.show_stats()
self.frame.grid(row=0, column=0, sticky="news")
for i in range(3):
self.frame.rowconfigure(i, weight=1)
self.frame.columnconfigure(i, weight=1)
self.progressbar = Progressbar(self.frame, orient=tk.HORIZONTAL,
length=200, mode="determinate", value=0)
self.progressbar.grid(row=0, column=1, sticky="ew")
Button(self.frame, text="x", anchor="se", bg=bgc, fg=fc, bd=0,
activebackground=bgc, command=main_menu,
font=(font.Font(family="Consolas", size=25))
).grid(row=0, column=0, sticky="nw")
HoverButton(self.frame, command=lambda: self.next_question(True),
text="skip").grid(row=2, column=1, sticky="new")
self.iframe = Frame(self.frame, bg=bgc)
self.first = Label(self.iframe, font=qF, anchor="e", bg=bgc, fg=fc)
self.second = Label(self.iframe, font=qF, anchor="e", bg=bgc, fg=fc)
self.op = Label(self.iframe, font=qF, anchor="e", bg=bgc, fg=fc)
self.ans = Entry(self.iframe, font=qF, bg=bgc, fg=fc, width=10,
textvariable=self.sv, insertbackground=fc, bd=0)
self.iframe.grid(row=1, column=1, sticky="news")
self.iframe.rowconfigure(0, weight=1)
self.iframe.rowconfigure(4, weight=1)
self.ans.delete(0, "end")
self.sv.trace_add("write", self.check_value)
if self.cq["op"] not in normal_op:
self.create_one_line()
else:
self.create_grid()
self.first.grid(row=1, column=0, columnspan=2, sticky="news")
self.second.grid(row=2, column=1, sticky="news")
self.op.grid(row=2, column=0, sticky="news")
self.ans.grid(row=3, column=0, columnspan=2, sticky="news")
self.ans.focus_set()
self.start = time()
self.qstart = time()
def check_value(self, name, index, mode):
if self.sv.get() == self.cq["answer"]:
window.after(150, self.next_question)
def next_question(self, skip=False):
self.qend = time()
if (skip):
self.cq["time"] = "SKIP"
else:
self.cq["time"] = self.qend - self.qstart
self.progress += 1
if self.progress < len(self.questions):
self.cq = self.questions[self.progress]
self.progressbar["value"] = 100*(
self.progress/len(self.questions)
)
if self.cq["op"] not in normal_op:
self.create_one_line()
else:
self.create_grid()
self.ans.delete(0, "end")
self.qstart = time()
else:
self.end = time()
self.show_stats()
def show_stats(self):
self.frame.destroy()
self.frame = Frame(window, bg=bgc)
self.frame.grid(row=0, column=0, sticky="news")
self.frame.rowconfigure(0, weight=1)
self.frame.rowconfigure(4, weight=1)
self.frame.columnconfigure(0, weight=1)
self.frame.columnconfigure(3, weight=1)
lblFrame = Frame(self.frame, bg=bgc)
# lblFrame.grid_propagate(False)
# lblFrame.rowconfigure(0, weight=1)
# lblFrame.rowconfigure(3, weight=1)
# lblFrame.columnconfigure(0, weight=1)
# lblFrame.columnconfigure(2, weight=1)
lblFrame.grid(row=2, column=2, sticky="news")
diff = self.end-self.start
Label(lblFrame, text=("Time taken: {0:0.1f}s".format(diff)),
font=f, anchor="w", bg=bgc, fg=fc
).grid(row=0, column=0, padx=20, pady=(30, 0), sticky="news")
avg = c = 0
for q in self.questions:
if q["time"] != "SKIP":
avg += q["time"]
c += 1
if c != 0:
avg /= c
else:
avg = 0
# Label(lblFrame, text="Avg time taken: {0:0.1f}s".format(avg),
# font=f, anchor="w", bg=bgc, fg=fc).grid(row=1, column=0, padx=20,
# sticky="news")
HoverButton(self.frame, text="choose level", command=main_menu
).grid(row=3, column=2, padx=10, pady=20, sticky="ew")
# play again button is added on in respective inherited methods
graphFrame = Frame(self.frame, bg=bgc)
graphFrame.grid(row=1, column=2, sticky="news")
# graphFrame.grid_propagate(False)
graphCanvas = Canvas(graphFrame, bg=bgc, highlightthickness=0)
graphCanvas.grid()
graph = SpeedGraph(graphCanvas, 50, 50, 250, 250, 15, avg)
graphCanvas.create_text(
150, 25, text="Average time taken", fill=tbgc,
font=(font.Font(family="Consolas", size=20))
)
oframe = Frame(
self.frame, bg=sbgc, bd=5, relief=tk.GROOVE, padx=10
)
oframe.grid(row=1, column=1, rowspan=2, sticky='nw')
oframe.grid_rowconfigure(0, weight=1)
oframe.grid_columnconfigure(0, weight=1)
# prevents children of the frame resizing frame
oframe.grid_propagate(False)
# Add a canvas in that frame
canvas = Canvas(oframe, bg=sbgc, highlightbackground=sbgc)
canvas.grid(row=0, column=0, sticky="news", padx=20, pady=20)
# Link a scrollbar to the canvas
vsb = Scrollbar(oframe, orient=tk.VERTICAL, command=canvas.yview)
vsb.grid(row=0, column=1, sticky='ns', padx=5, pady=5)
canvas.configure(yscrollcommand=vsb.set)
hsb = Scrollbar(oframe, orient=tk.HORIZONTAL, command=canvas.xview)
hsb.grid(row=1, column=0, sticky="ew", padx=5, pady=5)
canvas.configure(xscrollcommand=hsb.set)
# Create a frame to contain the results
self.iframe = Frame(canvas, bg=sbgc)
canvas.create_window((0, 0), window=self.iframe, anchor='nw')
Result(self.iframe, text="Question"
).grid(row=0, column=0, padx=5, sticky="news")
Result(self.iframe, text="Answer"
).grid(row=0, column=1, padx=5, sticky="news")
Result(self.iframe, text="Time"
).grid(row=0, column=2, padx=5, sticky="news")
global normal_op
for c, v in enumerate(self.questions):
if v["op"] in normal_op:
Result(self.iframe, text=v["format"]
).grid(row=c+1, column=0, padx=5, sticky="news")
else:
Result(self.iframe, text=v["format"]
).grid(row=c+1, column=0, padx=5, sticky="news")
Result(self.iframe, text=v["answer"]
).grid(row=c+1, column=1, padx=5, sticky="news")
if v["time"] == "SKIP":
Result(self.iframe, text=v["time"]
).grid(row=c+1, column=2, padx=5, sticky="news")
else:
Result(self.iframe, text=("{0:0.1f} sec").format(v["time"])
).grid(row=c+1, column=2, padx=5, sticky="news")
self.iframe.update_idletasks() # NEED THIS for BBOX INFO
oframe.config(width=400, height=400)
canvas.config(scrollregion=canvas.bbox("all"))
feeds = []
print(liste)
root=Tk()
root.resizable(False, False)###on peut pas modifier la taille de la fenetre
couleurprin="#DEB887"
couleursec="#FEFEE0"
couleurfrm="#99512B"
frameprincipale = Frame(root,width=1000,height=600,bg=couleurprin)###on cree une frame 1000*600 (taille de la fenetre)
frameprincipale.pack()
frameprincipale.pack_propagate(0)### taille de la frame fixe
frame=Frame(frameprincipale)
frame.pack(side=LEFT)
frameshowrss=Frame(frame)
frameshowrss.grid(row=0, column=0)
cnv = Canvas(frameshowrss,bg=couleursec,width=1000,height=600)
cnv.grid(row=0, column=1)
vScroll = Scrollbar(frameshowrss, orient=VERTICAL, command=cnv.yview)
vScroll.grid(row=0, column=0, sticky='ns')
cnv.configure(yscrollcommand=vScroll.set)
frm = Frame(cnv,bg=couleurfrm)
cnv.create_window(0, 0, window=frm, anchor='nw')
for elment,journal,url in liste:
c=Button(frm,text="%s - %s"%(elment,journal),command=lambda i=url:choose(i,))
c.pack(side=TOP)
def choose(url):
webbrowser.open(url)
frm.update_idletasks()
cnv.configure(scrollregion=(0, 0, frm.winfo_width(), frm.winfo_height()))
root.mainloop()
def facture():
def retour():
frameshowfracture.destroy()
framecategorie.destroy()
bmenu.destroy()
menu()
bajout.destroy()
bfacture.destroy()
frameshowfracture = Frame(frameprincipale, bg=couleursec)
frameshowfracture.pack(side=RIGHT, fill=BOTH, expand=1)
framecategorie = Frame(frameprincipale, bg=couleurfrm)
framecategorie.pack(side=LEFT)
framefactureshow = Frame(frameshowfracture, bg=couleursec)
framefactureshow.grid()
cnv2 = Canvas(framefactureshow, bg=couleursec, width=805, height=600)
cnv2.grid(row=0, column=0)
bmenu = Button(framecategorie, text="menuprincipal", command=retour)
bmenu.grid()
framefacture = Frame(framecategorie, bg=couleursec)
framefacture.grid()
cnv = Canvas(framefacture, bg=couleursec, width=150, height=550)
cnv.grid(row=0, column=1)
vScroll = Scrollbar(framefacture, orient=VERTICAL, command=cnv.yview)
vScroll.grid(row=0, column=0, sticky='ns')
cnv.configure(yscrollcommand=vScroll.set)
frm = Frame(cnv, bg=couleurfrm)
cnv.create_window(0, 0, window=frm, anchor='nw')
n = 0
n2 = 0
for categor in categorieini: ###cree bouton de la liste des categorie
c = Button(frm,
text=categor,
width=20,
height=5,
bg=couleursec,
command=lambda i=categor: ch(i)).grid(pady=10,
row=n,
column=n2)
n = n + 1
frm.update_idletasks()
cnv.configure(scrollregion=(0, 0, frm.winfo_width(), frm.winfo_height()))
vScroll2 = Scrollbar(framefactureshow, orient=VERTICAL, command=cnv2.yview)
def ch(choix): ###fonction appelée après clique sur bouton
global accept
global ch
ch = choix
def recherche():
global accept
global ch
choix = ch
print(choix)
accept = 0
framemodif.destroy()
cnv2.delete(ALL)
mois = t.get()
annee = t2.get()
couleurfrm = "#99512B"
vScroll2.grid(row=0, column=1, sticky='ns')
cnv2.configure(yscrollcommand=vScroll2.set)
frm2 = Frame(cnv2, bg=couleurfrm)
cnv2.create_window(0, 0, window=frm2, anchor='nw')
n = 0
n2 = 0
n3 = 0
for file in glob.glob("categories/%s/%sfact%s/%s/*.jpg" %
(choix, annee, choix, mois)):
b = os.path.splitext(os.path.basename(file))[0]
verif = b[-1]
if verif == "z":
btext = b.replace("z", "")
photo = ImageTk.PhotoImage(
file="categories/%s/%sfact%s/%s/%s.jpg" %
(choix, anneetoday, choix, mois, b))
bouton = Button(frm2,
compound=TOP,
height=150,
text="%s" % btext,
width=150,
image=photo,
command=lambda i=btext: choose(i))
dic['photo%s' %
n3] = photo ## on sauvegarde dans le dico l'instance
bouton.grid(row=n, column=n2, padx=20, pady=10)
n2 = n2 + 1
n3 = n3 + 1
if n2 == 4:
n2 = 0
n = n + 1
frm2.update_idletasks()
cnv2.configure(scrollregion=(0, 0, frm2.winfo_width(),
frm2.winfo_height()))
def choose(choix2):
os.startfile("categories\%s\%sfact%s\%s\%s.jpg" %
(choix, anneetoday, choix, mois, choix2))
vScroll2.grid_forget()
if accept == 0:
framemodif = Frame(cnv2)
framemodif.pack(padx=50, pady=250)
iframemois = Frame(framemodif, bd=2,
relief=RIDGE) ###frame qui permet ajout du mois
Label(iframemois, text='entrer le mois :').pack(
side=LEFT,
padx=5) ###label qui indique ce que doit faire l'utilisateur
t = StringVar(
) ###on indique la variable qui va prendre la valeur de ce que va rentrer l'utilisateur
Entry(iframemois, textvariable=t, bg='white').pack(
side=LEFT, padx=5
) ###on place la case qui permet a l'utilisateur d'ecrire
iframemois.pack(expand=1, fill=X, pady=10, padx=5)
iframeannee = Frame(
framemodif, bd=2,
relief=RIDGE) ###frame qui permet ajout de l'annee
Label(iframeannee, text="entrer l'annee :").pack(side=LEFT, padx=5)
t2 = StringVar(
) ###on indique la variable qui va prendre la valeur de ce que va rentrer l'utilisateur
Entry(iframeannee, textvariable=t2, bg='white').pack(
side=LEFT, padx=5
) ###on place la case qui permet a l'utilisateur d'ecrire
iframeannee.pack(expand=1, fill=X, pady=10, padx=5)
button1 = Button(
framemodif, text="rechercher",
command=recherche) ###le bouton qui appelle fonction recherche
button1.pack()
accept = 1
def ajout():
def retour():
frameshowfracture.destroy()
framecategorie.destroy()
bmenu.destroy()
menu()
def ajouter():
global ch
try:
choix = ch
mois = t.get()
annee = t2.get()
for infile in glob.glob("ajout facture/*.jpg"):
size = 128, 128
file, ext = os.path.splitext(infile)
im = Image.open(infile)
im.thumbnail(size, Image.ANTIALIAS)
im.save(infile + "z.jpg", "JPEG")
for file in glob.glob("ajout facture/*.jpg"):
c = os.path.basename(file)
shutil.copy(
"ajout facture\%s" % c, "categories\%s\%sfact%s\%s\%s" %
(choix, annee, choix, mois, c))
os.remove("ajout facture\%s" % c)
retour()
except:
problem.set("imposssible d'ajouter la facture")
bajout.destroy()
bfacture.destroy()
frameshowfracture = Frame(frameprincipale, bg=couleursec)
frameshowfracture.pack(side=RIGHT, fill=BOTH, expand=1)
framecategorie = Frame(frameprincipale, bg=couleurfrm)
framecategorie.pack(side=LEFT)
frameajout = Frame(frameshowfracture, bg=couleursec)
frameajout.pack()
label1 = Label(
frameajout,
text=
"_mettre la facture scanner dans le dossier ajout facture(format en jpg \n_choisissez la categorie ainsi que le mois et l'année \n_cliquez sur ajouter"
)
label1.grid()
categorieini = numpy.load(
"categories/categorieini.npy") ###on amene la liste des categories
categorieini = categorieini.tolist()
frameboutondep = Frame(frameajout, bg=couleursec)
frameboutondep.grid()
cnv = Canvas(frameboutondep, bg=couleursec, width=600, height=100)
cnv.grid(row=0, column=0)
hScroll = Scrollbar(frameboutondep, orient=HORIZONTAL, command=cnv.xview)
hScroll.grid(row=1, column=0, sticky='we')
cnv.configure(xscrollcommand=hScroll.set)
frm = Frame(cnv, bg=couleurfrm)
cnv.create_window(0, 0, window=frm, anchor='nw')
for categor in categorieini: ###cree bouton de la liste des categorie
c = Button(frm,
text=categor,
width=10,
height=5,
bg=couleursec,
command=lambda i=categor: ch(i))
c.pack(side=LEFT, padx=10) ###plac
frm.update_idletasks()
cnv.configure(scrollregion=(0, 0, frm.winfo_width(), frm.winfo_height()))
def ch(choix): ###fonction appelé apres clique sur bouton
global ch
ch = choix
cho.set("vous avez choisie la categorie %s" % choix)
problem.set("")
cho = StringVar()
label2 = Label(frameajout, textvariable=cho, bg=couleursec)
label2.grid()
problem = StringVar()
label3 = Label(frameajout, textvariable=problem, bg=couleursec)
label3.grid()
framemodif = Frame(frameajout)
framemodif.grid()
iframemois = Frame(framemodif, bd=2,
relief=RIDGE) ###frame qui permet ajout du mois
Label(iframemois, text='entrer le mois :').pack(
side=LEFT,
padx=5) ###label qui indique ce que doit faire l'utilisateur
t = StringVar(
) ###on indique la variable qui va prendre la valeur de ce que va rentrer l'utilisateur
Entry(iframemois, textvariable=t, bg='white').pack(
side=LEFT,
padx=5) ###on place la case qui permet a l'utilisateur d'ecrire
iframemois.pack(expand=1, fill=X, pady=10, padx=5)
iframeannee = Frame(framemodif, bd=2,
relief=RIDGE) ###frame qui permet ajout de l'annee
Label(iframeannee, text="entrer l'annee :").pack(side=LEFT, padx=5)
t2 = StringVar(
) ###on indique la variable qui va prendre la valeur de ce que va rentrer l'utilisateur
Entry(iframeannee, textvariable=t2, bg='white').pack(
side=LEFT,
padx=5) ###on place la case qui permet a l'utilisateur d'ecrire
iframeannee.pack(expand=1, fill=X, pady=10, padx=5)
button1 = Button(
framemodif, text="ajouter",
command=ajouter) ###le bouton qui appelle fonction recherche
button1.pack()
bmenu = Button(frameshowfracture, text="menuprincipal", command=retour)
bmenu.pack(side=TOP, pady=50)
class GameGrid(Frame):
def __init__(self):
# Frame.__init__(self)
self.score = 0
self.game = Frame()
self.game.grid()
self.game.master.title('2048')
# self.master.bind("<Key>", self.key_down)
# self.gamelogic = gamelogic
self.game.commands = {
c.KEY_UP: logic.up,
c.KEY_DOWN: logic.down,
c.KEY_LEFT: logic.left,
c.KEY_RIGHT: logic.right,
c.KEY_UP_ALT: logic.up,
c.KEY_DOWN_ALT: logic.down,
c.KEY_LEFT_ALT: logic.left,
c.KEY_RIGHT_ALT: logic.right,
c.KEY_H: logic.left,
c.KEY_L: logic.right,
c.KEY_K: logic.up,
c.KEY_J: logic.down
}
self.game.grid_cells = []
self.init_grid(self.game)
self.init_matrix()
self.update_grid_cells(self.game)
def render(self):
self.game.update_idletasks()
self.game.update()
time.sleep(0.01)
time.sleep(0.01)
def init_grid(self, game):
background = Frame(game,
bg=c.BACKGROUND_COLOR_GAME,
width=c.SIZE,
height=c.SIZE)
background.grid()
for i in range(c.GRID_LEN):
grid_row = []
for j in range(c.GRID_LEN):
cell = Frame(background,
bg=c.BACKGROUND_COLOR_CELL_EMPTY,
width=c.SIZE / c.GRID_LEN,
height=c.SIZE / c.GRID_LEN)
cell.grid(row=i,
column=j,
padx=c.GRID_PADDING,
pady=c.GRID_PADDING)
t = Label(master=cell,
text="",
bg=c.BACKGROUND_COLOR_CELL_EMPTY,
justify=CENTER,
font=c.FONT,
width=5,
height=2)
t.grid()
grid_row.append(t)
game.grid_cells.append(grid_row)
def gen(self):
return random.randint(0, c.GRID_LEN - 1)
def init_matrix(self):
self.matrix = logic.new_game(c.GRID_LEN)
self.history_matrixs = list()
self.matrix = logic.add_two(self.matrix)
self.matrix = logic.add_two(self.matrix)
def update_grid_cells(self, game):
for i in range(c.GRID_LEN):
for j in range(c.GRID_LEN):
new_number = self.matrix[i][j]
if new_number == 0:
game.grid_cells[i][j].configure(
text="", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
else:
game.grid_cells[i][j].configure(
text=str(new_number),
bg=c.BACKGROUND_COLOR_DICT[new_number],
fg=c.CELL_COLOR_DICT[new_number])
game.update_idletasks()
def num_actions_available(self):
return 4
def get_state(self):
flat = np.array(self.matrix).flatten().astype(np.float32())
return torch.from_numpy(flat)
def key_down(self, event):
key = event
game_done = False
game_result = False
temp = 0
current_state = self.matrix
if key == c.KEY_BACK and len(self.history_matrixs) > 1:
self.matrix = self.history_matrixs.pop()
self.update_grid_cells()
print('back on step total step:', len(self.history_matrixs))
elif key in self.game.commands:
self.matrix, done = self.game.commands[key](self.matrix)
if done:
self.matrix = logic.add_two(self.matrix)
# record last move
self.history_matrixs.append(self.matrix)
self.update_grid_cells(self.game)
done = False
if logic.game_state(self.matrix) == 'win':
game_done = True
game_result = True
self.game.grid_cells[1][1].configure(
text="You", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
self.game.grid_cells[1][2].configure(
text="Win!", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
if logic.game_state(self.matrix) == 'lose':
game_done = True
game_result = False
self.game.grid_cells[1][1].configure(
text="You", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
self.game.grid_cells[1][2].configure(
text="Lose!", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
if (game_done and game_result):
self.score = sum(np.array(self.matrix).flatten())
elif (game_done and not (game_result)):
self.score = -1 * sum(np.array(self.matrix).flatten())
else:
if (self.score != sum(np.array(self.matrix).flatten())):
for i in range(4):
for j in range(4):
if (self.matrix[i][j] == 2 * current_state[i][j]):
temp += self.matrix[i][j]
self.score = sum(np.array(self.matrix).flatten())
return self.matrix, game_done, temp
else:
# print(0)
return self.matrix, game_done, -100
return self.matrix, game_done, self.score
def generate_next(self):
index = (self.gen(), self.gen())
while self.matrix[index[0]][index[1]] != 0:
index = (self.gen(), self.gen())
self.matrix[index[0]][index[1]] = 2
class Gui(Frame):
#==============================================================================
# Metodos Basicos
#==============================================================================
def __init__(self, parent=None):
Frame.__init__(self, parent)
# Atributos GUI
self.parent = parent
self.file_opt = self.flopt = {}
w, h = self.parent.winfo_screenwidth(), self.parent.winfo_screenheight(
)
self.largura = w - 20
self.altura = h - 20
# Atributos funcionais
self.img = None
self.imgOld = None
self.arqImg = StringVar()
self.arqImg.set('')
self.formatos = {}
self.formatos['gif'] = 'GIF'
self.formatos['jpg'] = 'JPEG'
self.formatos['jpeg'] = 'JPEG'
self.formatos['png'] = 'PNG'
self.formatos['bmp'] = 'BMP'
self.formatos['tif'] = 'TIFF'
self.formatos['tiff'] = 'TIFF'
self.formatos['ppm'] = 'PPM'
self.formatos['pbm'] = 'PPM'
self.formatos['pgm'] = 'PPM'
self.tipos = [('Imagens', ('*.jpg', '*.png', '*.gif', '*.bmp', '*.ppm',
'*.pgm', '*.pbm')), ('JPEG', '*.jpg'),
('PNG', '*.png'), ('GIF', '*.gif'), ('BMP', '*.bmp'),
('PPM', '*.ppm'), ('PGM', '*.pgm'), ('PBM', '*.pbm'),
('Todos arquivos', '*')]
# Cria/atualiza GUI
self.createWidgets()
self.update_idletasks()
#==============================================================================
# Metodos relacionados ao comportamento da GUI
#==============================================================================
def createWidgets(self):
self.canvas = Canvas(self.parent, width=1366, height=768)
self.scroll = Scrollbar(self.parent,
orient="vertical",
command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.scroll.set)
self.scroll.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
# Configura barra de menus
self.menubar = Menu(self.parent)
self.parent.config(menu=self.menubar)
# Menu arquivo e suas opcoes
self.menuArquivo = Menu(self.menubar)
self.menuArquivo.add_command(label='Abrir',
underline=0,
command=self.abrir)
self.menuArquivo.add_separator()
self.menuArquivo.add_command(label='Salvar',
underline=0,
command=self.salvar)
self.menuArquivo.add_command(label='Salvar Como...',
underline=0,
command=self.salvarComo)
self.menuArquivo.add_separator()
self.menuArquivo.add_command(label='Fechar imagem(ns)',
underline=0,
command=self.fecharArquivo)
self.menuArquivo.add_command(label="Sair",
underline=3,
command=self.onExit)
self.menubar.add_cascade(label="Arquivo",
underline=0,
menu=self.menuArquivo)
# Menu editar e suas opcoes
self.menuEditar = Menu(self.menubar)
self.menuEditar.add_command(label='Desfazer',
underline=0,
command=self.desfazer)
self.menubar.add_cascade(label="Editar",
underline=0,
menu=self.menuEditar)
# Menu Imagem e suas opcoes
self.menuImagem = Menu(self.menubar)
self.submenuConverte = Menu(self.menuImagem)
self.submenuConverte.add_command(label='Colorido RGB',
underline=0,
command=lambda: self.converte('RGB'))
self.submenuConverte.add_command(label='Colorido RGBA',
underline=0,
command=lambda: self.converte('RGBA'))
self.submenuConverte.add_command(label='Escala de cinza',
underline=0,
command=lambda: self.converte('L'))
self.submenuConverte.add_command(label='Binario',
underline=0,
command=lambda: self.converte('1'))
self.menuImagem.add_command(label='Informacoes gerais',
underline=0,
command=self.info)
self.menuImagem.add_separator()
self.menuImagem.add_cascade(label='Converter',
underline=0,
menu=self.submenuConverte)
self.menubar.add_cascade(label="Imagem",
underline=0,
menu=self.menuImagem)
# Menu de operacoes sobre cores e suas opcoes
self.menuCores = Menu(self.menubar)
self.submenuCinza = Menu(self.menuCores)
self.submenuCinza.add_command(label='Decomposicao de Maximo',
underline=18,
command=self.emConstrucao)
self.submenuCinza.add_command(label='Decomposicao de Minimo',
underline=18,
command=self.emConstrucao)
self.submenuCinza.add_command(label='Average',
underline=0,
command=lambda: self.mudaCor('average'))
self.submenuCinza.add_command(label='Lightness',
underline=0,
command=self.emConstrucao)
self.submenuCinza.add_command(label='Luminosity',
underline=0,
command=self.emConstrucao)
self.submenuCinza.add_command(label='Componente R',
underline=11,
command=lambda: self.mudaCor('r'))
self.submenuCinza.add_command(label='Componente G',
underline=11,
command=self.emConstrucao)
self.submenuCinza.add_command(label='Componente B',
underline=11,
command=self.emConstrucao)
self.submenuCinza.add_command(label='Quantidade arbitraria de tons',
underline=0,
command=self.emConstrucao)
self.submenuHalftone = Menu(self.menuCores)
self.submenuHalftone.add_command(
label='Bayer 2x2',
underline=6,
command=lambda: self.halftoning('bayer2'))
self.submenuHalftone.add_command(label='Bayer 5x5',
underline=6,
command=self.emConstrucao)
self.submenuHalftone.add_command(label='Atkinson',
underline=0,
command=self.emConstrucao)
self.submenuHalftone.add_command(label='Sierra Lite',
underline=0,
command=self.emConstrucao)
self.submenuHalftone.add_command(label='Jarvis, Judice, and Ninke',
underline=0,
command=self.emConstrucao)
self.submenuHalftone.add_command(
label='Floyd-Steinberg',
underline=0,
command=lambda: self.halftoning('floyd'))
self.menuCores.add_cascade(label='Tons de cinza',
underline=0,
menu=self.submenuCinza)
self.menuCores.add_command(label='Inverter',
underline=0,
command=lambda: self.mudaCor('inv'))
self.menuCores.add_command(label='Sepia',
underline=0,
command=self.emConstrucao)
self.menuCores.add_separator()
self.menuCores.add_command(label='Pseudo Binaria',
underline=0,
command=self.binaria)
self.menuCores.add_cascade(label='Halftoning',
underline=0,
menu=self.submenuHalftone)
self.menuCores.add_separator()
self.menuCores.add_command(label='Cisalhamento de Cor',
underline=0,
command=self.emConstrucao)
self.menuCores.add_command(label='Balanco de cores',
underline=0,
command=self.balancoCor)
self.menuCores.add_command(label='Quantizacao de cores',
underline=0,
command=self.emConstrucao)
self.menubar.add_cascade(label="Cores",
underline=0,
menu=self.menuCores)
# Menu de operacoes topologicas e suas opcoes
self.menuTopologia = Menu(self.menubar)
self.menuTopologia.add_command(label='Rotular Componentes',
underline=0,
command=self.emConstrucao)
self.menuTopologia.add_command(label='Transformada da Distancia',
underline=0,
command=self.emConstrucao)
self.menuTopologia.add_command(label='Esqueletizacao',
underline=0,
command=self.emConstrucao)
self.menubar.add_cascade(label="Topologia",
underline=0,
menu=self.menuTopologia)
# Menu do trabalho e suas opcoes
self.trabalho = Menu(self.menubar)
self.trabalho.add_command(label='Tarefa 01',
underline=20,
command=self.abrir)
# Grupo principal, onde serao atualizados os widgets
self.grupoPrincipal = Frame(self.canvas,
width=self.largura,
height=self.altura,
bd=1,
padx=10,
pady=10)
self.grupoPrincipal.pack()
#self.grupoPrincipal.grid_propagate(False) # Faz com que o Frame nao seja redimensionado com a mudanca dos widgets
self.canvas.create_window((4, 20),
window=self.grupoPrincipal,
anchor="nw",
tags="self.grupoPrincipal")
self.grupoPrincipal.bind("<Configure>", self.OnFrameConfigure)
def OnFrameConfigure(self, event):
'''Reset the scroll region to encompass the inner frame'''
self.canvas.configure(scrollregion=self.canvas.bbox("all"))
def onExit(self):
self.parent.destroy()
def limpaTela(self):
for widget in self.grupoPrincipal.winfo_children():
widget.destroy()
def emConstrucao(self):
tkm.showinfo(title="Em construcao", message="Recurso em Construcao...")
def load_file(self, titulo, varFile, tipos):
if os.path.isfile(varFile.get()):
path = os.path.dirname(varFile.get())
self.flopt['initialdir'] = path
else:
self.flopt['initialdir'] = os.path.curdir
self.flopt['filetypes'] = tipos
arquivo = tkf.askopenfilename(title=titulo, **self.flopt)
if arquivo:
varFile.set(arquivo)
def widgetFile(self, master, titulo, texto, varFile, tuplaFiletype):
esteFrame = LabelFrame(master, text=titulo, padx=5, pady=5)
j = 0
varFile.set("Nenhum arquivo informado")
labelRotulo = Label(esteFrame, text=texto)
labelRotulo.grid(row=j, column=0, sticky=cte.E)
botao = Button(
esteFrame,
text="Procurar",
command=lambda: self.load_file(texto, varFile, tuplaFiletype),
width=10)
botao.grid(row=j, column=1, pady=5, sticky=cte.W)
j += 1
labelArq = Label(esteFrame, textvariable=varFile, bg='white')
labelArq.grid(row=j, column=0, columnspan=2)
return esteFrame
def refreshImg(self):
try:
self.grupoPrincipal.photo = ImageTk.PhotoImage(self.img.img)
if hasattr(self.grupoPrincipal, 'canvas'):
self.grupoPrincipal.canvas.destroy()
self.grupoPrincipal.canvas = Canvas(self.grupoPrincipal)
self.grupoPrincipal.canvas.create_image(
0, 0, image=self.grupoPrincipal.photo, anchor=cte.NW)
self.grupoPrincipal.canvas.config(bg='white',
width=self.img.altura,
height=self.img.largura)
#self.grupoPrincipal.canvas.place(x=self.parent.winfo_screenwidth()/2, y=self.parent.winfo_screenheight()/2, anchor=cte.CENTER)
self.grupoPrincipal.canvas.place(x=0, y=0, anchor=cte.NW)
self.grupoPrincipal.update_idletasks()
except Exception as e:
tkm.showerror('Erro', 'O seguinte erro ocorreu: %s' % str(e.args))
#==============================================================================
# Metodos relacionados ao meno Arquivo
#==============================================================================
def abrir(self):
try:
self.limpaTela()
self.load_file('Arquivos de Imagem', self.arqImg, self.tipos)
self.img = Imagem(self.arqImg.get())
self.refreshImg()
except Exception as e:
tkm.showerror('Erro', 'O seguinte erro ocorreu: %s' % str(e.args))
def saveFile(self):
try:
nome, extensao = os.path.splitext(self.arqImg.get())
extensao = extensao.replace('.', '')
self.img.salva(self.arqImg.get(), self.formatos[extensao.lower()])
tkm.showinfo(
'Sucesso', 'Arquivo %s salvo com sucesso' %
os.path.basename(self.arqImg.get()))
except Exception as e:
tkm.showerror('Erro', 'O seguinte erro ocorreu: %s' % str(e.args))
def salvar(self):
if self.arqImg.get() == '':
tkm.showwarning('Aviso', 'Nao ha arquivo aberto para ser salvo')
else:
try:
self.saveFile()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
def salvarComo(self):
if self.arqImg.get() == '':
tkm.showwarning('Aviso', 'Nao ha arquivo aberto para ser salvo')
else:
try:
if os.path.isfile(self.arqImg.get()):
path = os.path.dirname(self.arqImg.get())
self.flopt['initialdir'] = path
else:
self.flopt['initialdir'] = os.path.curdir
self.flopt['filetypes'] = self.tipos
nomeArq = tkf.asksaveasfilename(title='Salvar imagem como...',
**self.flopt)
if nomeArq:
self.arqImg.set(nomeArq)
self.saveFile()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
def fecharArquivo(self):
if not hasattr(
self.grupoPrincipal,
'canvas') or self.grupoPrincipal.canvas.find_all() == ():
tkm.showwarning('Aviso', 'Nao ha imagens abertas')
else:
try:
self.img = self.imgOld = None
self.grupoPrincipal.canvas.delete('all')
self.grupoPrincipal.update_idletasks()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
#==============================================================================
# Metodos relacionados ao menu Editar
#==============================================================================
def desfazer(self):
if self.arqImg.get() == '' or self.img is None:
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
elif self.imgOld is None:
tkm.showwarning('Aviso', 'Impossivel Desfazer')
else:
try:
temp = self.img
self.img = self.imgOld
self.imgOld = temp
self.refreshImg()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
#==============================================================================
# Metodos relacionados ao menu Cores
#==============================================================================
def mudaCor(self, metodo):
if self.arqImg.get() == '' or self.img is None:
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
else:
try:
self.imgOld = self.img
self.img = cor.mudaCor(self.imgOld, metodo)
self.refreshImg()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
def binaria(self):
if self.arqImg.get() == '' or self.img is None:
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
else:
try:
self.imgOld = self.img
self.img = cor.binaria(self.imgOld)
self.refreshImg()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
def getFatoresBalanco(self):
self.fatores = [float(self.escalaFatorR.get())]
self.fatores.append(float(self.escalaFatorG.get()))
self.fatores.append(float(self.escalaFatorB.get()))
self.w.destroy()
def formBalanco(self):
self.fator = None
self.fatores = None
self.w = Toplevel(self)
self.w.wm_title("Informar os fatores de ajuste")
self.w.geometry("+%d+%d" %
(self.winfo_rootx() + 50, self.winfo_rooty() + 50))
self.w.focus_set()
i = 0
self.labelFatorR = Label(self.w, text='Ajuste em R', width=25)
self.labelFatorR.grid(row=i, column=0)
self.escalaFatorR = Scale(self.w,
from_=0,
to=2,
resolution=0.05,
length=350,
orient=cte.HORIZONTAL)
self.escalaFatorR.set(0.5)
self.escalaFatorR.grid(row=i, column=1)
i += 1
self.labelFatorG = Label(self.w, text='Ajuste em G', width=25)
self.labelFatorG.grid(row=i, column=0)
self.escalaFatorG = Scale(self.w,
from_=0,
to=2,
resolution=0.05,
length=350,
orient=cte.HORIZONTAL)
self.escalaFatorG.set(0.5)
self.escalaFatorG.grid(row=i, column=1)
i += 1
self.labelFatorB = Label(self.w, text='Ajuste em B', width=25)
self.labelFatorB.grid(row=i, column=0)
self.escalaFatorB = Scale(self.w,
from_=0,
to=2,
resolution=0.05,
length=350,
orient=cte.HORIZONTAL)
self.escalaFatorB.set(0.5)
self.escalaFatorB.grid(row=i, column=1)
i += 1
self.botaoFator = Button(self.w,
text='Ok',
command=self.getFatoresBalanco,
width=10)
self.botaoFator.grid(row=i, column=0, columnspan=2)
self.w.grid()
def balancoCor(self):
if self.arqImg.get() == '' or self.img is None:
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
else:
try:
self.formBalanco()
self.wait_window(self.w)
if self.fatores is not None:
self.imgOld = self.img
self.img = cor.balanco(self.imgOld, self.fatores[0],
self.fatores[1], self.fatores[2])
self.refreshImg()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
def halftoning(self, metodo='bayer2'):
if self.arqImg.get() == '' or self.img is None:
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
else:
try:
self.imgOld = self.img
if metodo == 'bayer2':
self.img = cor.bayer(self.imgOld)
elif metodo == 'floyd':
self.img = cor.floyd(self.imgOld)
else:
raise Exception('Metodo de halftoning desconhecido')
self.refreshImg()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
#==============================================================================
# Metodos relacionados ao menu Imagem
#==============================================================================
def converte(self, modo='RGB'):
if self.arqImg.get() == '' or self.img is None:
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
else:
try:
self.imgOld = self.img.copia()
self.img.converte(modo)
self.refreshImg()
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
def info(self):
if self.arqImg.get() == '':
tkm.showwarning('Aviso', 'Nao ha arquivo aberto')
else:
try:
texto = 'Imagem %s, modo: %s (%d x %d pixels)' % (
self.img.img.format, self.img.img.mode,
self.img.img.size[0], self.img.img.size[1])
tkm.showinfo('Aviso', texto)
except Exception as e:
tkm.showerror('Erro',
'O seguinte erro ocorreu: %s' % str(e.args))
class Game2048Env(gym.Env):
metadata = {'render.modes': ['human', 'ansi']}
def __init__(self):
# Definitions for game. Board-matrix must be square.
self.grid_cells = []
self.user_ui = Frame()
self.size = 4
self.w = self.size
self.h = self.size
squares = self.size * self.size
self.score = 0
# Members for gym implementation:
self.action_space = spaces.Discrete(4)
# Suppose that the maximum tile is as if you have powers of 2 across the board-matrix.
self.observation_space = spaces.Box(0,
2**squares, (self.w * self.h, ),
dtype=np.int)
# Guess that the maximum reward is also 2**squares though you'll probably never get that.
self.reward_range = (0., float(2**squares))
# Initialise the random seed of the gym environment.
self.seed()
# Reset the board-matrix, ready for a new game.
self.reset()
def seed(self, seed=None):
"""Set the random seed for the gym environment."""
self.np_random, seed = seeding.np_random(seed)
return [seed]
# Implementation of gym interface:
def step(self, action):
"""Perform one step of the game. This involves moving and adding a new tile."""
logging.debug("Action {}".format(action))
score = 0
done = None
try:
score = float(self.move(action))
self.score += score
assert score <= 2**(self.w * self.h)
self.add_tile()
done = self.isend()
reward = float(score)
except IllegalMove as e:
logging.debug("Illegal move")
done = False
reward = 0. # Illegal move non ha reward
observation = self.Matrix
info = {"max_tile": self.highest()}
'''
with open("mosseCSV.csv", "a") as f:
savetxt(f, self.Matrix, delimiter=',')
'''
return observation, reward, done, info
def reset(self):
"""Reset the game board-matrix and add 2 tiles."""
self.Matrix = np.zeros((self.h, self.w), np.int)
self.score = 0
logging.debug("Adding tiles")
self.add_tile()
self.add_tile()
# savetxt('mosseCSV.csv', self.Matrix, delimiter=',')
# Iniziallizzazione dell'interfaccia grafica
self.user_ui.master.title('2048 - MachineLearning Project')
background = Frame(bg=c.BACKGROUND_COLOR_GAME,
width=c.SIZE,
height=c.SIZE)
background.grid()
for i in range(c.GRID_LEN):
grid_row = []
for j in range(c.GRID_LEN):
cell = Frame(background,
bg=c.BACKGROUND_COLOR_CELL_EMPTY,
width=c.SIZE / c.GRID_LEN,
height=c.SIZE / c.GRID_LEN)
cell.grid(row=i,
column=j,
padx=c.GRID_PADDING,
pady=c.GRID_PADDING)
t = Label(master=cell,
text="",
bg=c.BACKGROUND_COLOR_CELL_EMPTY,
justify=CENTER,
font=c.FONT,
width=5,
height=2)
t.grid()
grid_row.append(t)
self.grid_cells.append(grid_row)
return self.Matrix
def render(self, mode='human'):
""" Visualizzazione grafica dell'environment. Può essere fatta anche in modo testuale """
'''
outfile = StringIO() if mode == 'ansi' else sys.stdout
s = 'Score: {}\n'.format(self.score)
s += 'Highest: {}\n'.format(self.highest())
npa = np.array(self.Matrix)
grid = npa.reshape((self.size, self.size))
s += "{}\n".format(grid)
outfile.write(s)
return outfile
'''
for i in range(4):
for j in range(4):
o = self.get(i, j)
# print(o) #Qua ci entra
if o == 0:
self.grid_cells[i][j].configure(
text="", bg=c.BACKGROUND_COLOR_CELL_EMPTY)
else:
self.grid_cells[i][j].configure(
text=str(o),
bg=c.BACKGROUND_COLOR_DICT[o],
fg=c.CELL_COLOR_DICT[o])
time.sleep(0.1) # Rende visibili i cabiamenti all'occhio umano
if self.isend():
if self.highest() < 2048:
self.grid_cells[1][1].configure(text="YOU", bg='#f54021')
self.grid_cells[1][2].configure(text="LOSE", bg='#f54021')
else:
self.grid_cells[1][1].configure(text="YOU", bg='#00ff00')
self.grid_cells[1][2].configure(text="WIN", bg='#00ff00')
self.user_ui.update_idletasks()
time.sleep(2) # Rimane 2 secondi il messaggio di sconfitta
self.user_ui.update_idletasks() # Aggiorna l'interfaccia grafica
def add_tile(self):
"""Add a tile with value 2 or 4 with different probabilities."""
val = 0
if self.np_random.random_sample() > 0.8:
val = 4
else:
val = 2
empties = self.empties()
assert empties
empty_idx = self.np_random.choice(len(empties))
empty = empties[empty_idx]
logging.debug("Adding %s at %s", val, (empty[0], empty[1]))
self.set(empty[0], empty[1], val)
def get(self, x, y):
"""Get the value of one square."""
return self.Matrix[x, y]
def set(self, x, y, val):
"""Set the value of one square."""
self.Matrix[x, y] = val
def empties(self):
"""Return a list of tuples of the location of empty squares."""
empties = list()
for y in range(self.h):
for x in range(self.w):
if self.get(x, y) == 0:
empties.append((x, y))
return empties
def highest(self):
"""Report the highest tile on the board-matrix."""
highest = 0
for y in range(self.h):
for x in range(self.w):
highest = max(highest, self.get(x, y))
return highest
def move(self, direction, trial=False):
"""Perform one move of the game. Shift things to one side then,
combine. directions 0, 1, 2, 3 are up, right, down, left.
Returns the score that [would have] got."""
if not trial:
if direction == 0:
logging.debug("Up")
elif direction == 1:
logging.debug("Right")
elif direction == 2:
logging.debug("Down")
elif direction == 3:
logging.debug("Left")
changed = False
move_score = 0
dir_div_two = int(direction / 2)
dir_mod_two = int(direction % 2)
shift_direction = dir_mod_two ^ dir_div_two # 0 for towards up left, 1 for towards bottom right
# Construct a range for extracting row/column into a list
rx = list(range(self.w))
ry = list(range(self.h))
if dir_mod_two == 0:
# Up or down, split into columns
for y in range(self.h):
old = [self.get(x, y) for x in rx]
(new, ms) = self.shift(old, shift_direction)
move_score += ms
if old != new:
changed = True
if not trial:
for x in rx:
self.set(x, y, new[x])
else:
# Left or right, split into rows
for x in range(self.w):
old = [self.get(x, y) for y in ry]
(new, ms) = self.shift(old, shift_direction)
move_score += ms
if old != new:
changed = True
if not trial:
for y in ry:
self.set(x, y, new[y])
if not changed:
raise IllegalMove
return move_score
def combine(self, shifted_row):
"""Combine same tiles when moving to one side. This function always
shifts towards the left. Also count the score of combined tiles."""
move_score = 0
combined_row = [0] * self.size
skip = False
output_index = 0
for p in pairwise(shifted_row):
if skip:
skip = False
continue
combined_row[output_index] = p[0]
if p[0] == p[1]:
combined_row[output_index] += p[1]
move_score += p[0] + p[1]
# Skip the next thing in the list.
skip = True
output_index += 1
if shifted_row and not skip:
combined_row[output_index] = shifted_row[-1]
return combined_row, move_score
def shift(self, row, direction):
"""Shift one row left (direction == 0) or right (direction == 1), combining if required."""
length = len(row)
assert length == self.size
assert direction == 0 or direction == 1
# Shift all non-zero digits up
shifted_row = [i for i in row if i != 0]
# Reverse list to handle shifting to the right
if direction:
shifted_row.reverse()
(combined_row, move_score) = self.combine(shifted_row)
# Reverse list to handle shifting to the right
if direction:
combined_row.reverse()
assert len(combined_row) == self.size
return combined_row, move_score
def isend(self):
"""Check if the game is ended. Game ends if there is a 2048 tile or
there are no legal moves. If there are empty spaces then there must
be legal moves."""
if self.highest() == 2048:
return True
for direction in range(4):
try:
self.move(direction, trial=True)
# Not the end if we can do any move
return False
except IllegalMove:
pass
return True
def get_board(self):
"""Get the whole board-matrix, useful for testing."""
return self.Matrix
def set_board(self, new_board):
"""Set the whole board-matrix, useful for testing."""
self.Matrix = new_board
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.pack()
self.create_widgets()
self.base_image_paths = []
self.base_images = []
self.base_img_canvas = []
self.base_voltages = []
self.base_idx = 0
self.mole_image_paths = []
self.mole_images = []
self.mole_img_canvas = []
self.mole_voltages = []
self.mole_idx = 0
def create_widgets(self):
pane = PanedWindow(self.master, orient='vertical')
pane.pack(expand=True, fill=tk.BOTH, side='left')
self.frame = Frame(pane, bd=2, relief='ridge')
pane.add(self.frame)
# Main frame
Label(self.frame, text='Theoritical d of Base:').grid(row=0,
column=0,
padx=10,
pady=10)
self.theoretical_d = Entry(self.frame, width=15)
self.theoretical_d.grid(column=1, row=0)
Label(self.frame, text='Å').grid(row=0, column=2)
# Images of Base frame
self.fm_base = Frame(pane, bd=2, relief='ridge', pady=20)
pane.add(self.fm_base)
Label(self.fm_base, text='○ Images of Base').grid(row=0, column=0)
Label(self.fm_base, text='Images').grid(row=1, column=0, pady=100)
Label(self.fm_base, text='Base Voltage[V]').grid(row=2,
column=0,
pady=20)
self.fm_base_canvas = Canvas(self.fm_base,
width=1000,
highlightthickness=0)
self.fm_base_canvas.grid(row=1,
column=1,
rowspan=2,
sticky='news',
padx=35)
self.fm_base_bar = Scrollbar(self.fm_base,
orient='horizontal',
command=self.fm_base_canvas.xview)
self.fm_base_bar.grid(row=3, column=1, sticky='ew', padx=35)
self.fm_base_canvas.config(xscrollcommand=self.fm_base_bar.set)
self.fm_base_canvas_frame = Frame(self.fm_base_canvas)
self.fm_base_canvas.create_window((0, 20),
window=self.fm_base_canvas_frame,
anchor='nw')
self.fm_base_btn = ttk.Button(self.fm_base, text='select images')
self.fm_base_btn.config(command=lambda: self.select_file(isBase=True))
self.fm_base_btn.grid(row=0, column=1, sticky='w', padx=30)
# Images of Molecules frame
self.fm_mole = Frame(pane, bd=2, relief='ridge', pady=20)
pane.add(self.fm_mole)
Label(self.fm_mole, text='○ Images of Molecules').grid(row=0, column=0)
Label(self.fm_mole, text='Images').grid(row=1, column=0, pady=100)
Label(self.fm_mole, text='Base Voltage[V]').grid(row=2,
column=0,
pady=20)
self.fm_mole_canvas = Canvas(self.fm_mole,
width=1000,
highlightthickness=0)
self.fm_mole_canvas.grid(row=1, column=1, rowspan=2, sticky='news')
self.fm_mole_bar = Scrollbar(self.fm_mole,
orient='horizontal',
command=self.fm_mole_canvas.xview)
self.fm_mole_bar.grid(row=3, column=1, sticky='ew')
self.fm_mole_canvas.config(xscrollcommand=self.fm_mole_bar.set)
self.fm_mole_canvas_frame = Frame(self.fm_mole_canvas)
self.fm_mole_canvas.create_window((0, 20),
window=self.fm_mole_canvas_frame,
anchor='nw')
self.fm_mole_btn = ttk.Button(self.fm_mole, text='select images')
self.fm_mole_btn.config(command=lambda: self.select_file(isBase=False))
self.fm_mole_btn.grid(row=0, column=1, sticky='w', padx=30)
# Run blob detection
self.fm_run = Frame(pane, bd=2, relief='ridge', pady=10)
pane.add(self.fm_run)
ttk.Button(self.fm_run, text='RUN', command=self.run).pack()
def run(self):
theoretical_d = float(self.theoretical_d.get().replace('\x10', ''))
base_voltages = [
float(base_voltage.get().replace('\x10', ''))
for base_voltage in self.base_voltages
]
mole_voltages = [
float(mole_voltage.get().replace('\x10', ''))
for mole_voltage in self.mole_voltages
]
r = detector.detect_base_blob(theoretical_d, self.base_image_paths,
base_voltages)
detector.detect_mole_blob(r, self.mole_image_paths, mole_voltages)
def select_file(self, isBase):
# initialdir = os.path.abspath(os.path.dirname("__file__"))
initialdir = os.path.abspath(os.path.dirname('../data/'))
files = filedialog.askopenfilenames(initialdir=initialdir)
if isBase:
for idx, filename in enumerate(files):
i = self.base_idx
self.base_img_canvas.append(Canvas(self.fm_base_canvas_frame))
self.base_voltages.append(Entry(self.fm_base_canvas_frame))
self.base_image_paths.append(filename)
self.base_images.append(self.read_image(filename))
self.base_img_canvas[i].create_image(
self.base_images[i]['width'] / 2,
self.base_images[i]['height'] / 2,
image=self.base_images[i]['img'])
self.base_img_canvas[i].grid(row=0, column=self.base_idx)
self.base_voltages[i].grid(row=1,
column=self.base_idx,
pady=(20, 0))
self.base_idx += 1
self.fm_base_canvas_frame.update_idletasks()
self.fm_base_canvas.config(
scrollregion=self.fm_base_canvas.bbox('all'))
else:
for idx, filename in enumerate(files):
i = self.mole_idx
self.mole_img_canvas.append(Canvas(self.fm_mole_canvas_frame))
self.mole_voltages.append(Entry(self.fm_mole_canvas_frame))
self.mole_image_paths.append(filename)
self.mole_images.append(self.read_image(filename))
self.mole_img_canvas[i].create_image(
self.mole_images[i]['width'] / 2,
self.mole_images[i]['height'] / 2,
image=self.mole_images[i]['img'])
self.mole_img_canvas[i].grid(row=0, column=self.mole_idx)
self.mole_voltages[i].grid(row=1,
column=self.mole_idx,
pady=(20, 0))
self.mole_idx += 1
self.fm_mole_canvas_frame.update_idletasks()
self.fm_mole_canvas.config(
scrollregion=self.fm_mole_canvas.bbox('all'))
def read_image(self, path):
img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
height = int(img.shape[0] / 5)
width = int(img.shape[1] / 5)
img = cv2.resize(img, (width, height))
img = Image.fromarray(img)
img = ImageTk.PhotoImage(img)
return {'img': img, 'height': height, 'width': width}
