def ProgressBarWait(Progress: ttk.Progressbar):
Random = randint(3, 25)
Now = Progress["value"]
if Now + Random <= 94:
Progress["value"] += Random
Progress.update()
sleep(0.5)
def __display_download(self):
self.display_type = self.DOWNLOAD
self.frame.update()
para_label = Label(self.frame,
text="Parameters",
anchor=W,
width=int(self.frame.winfo_width()))
para_label.pack()
url_frame = Frame(self.frame, width=self.frame.winfo_width())
url_frame.pack()
url_label = Label(url_frame, text="URL")
url_label.pack(side=LEFT)
url_label.update()
self.url_entry = url_entry = Entry(url_frame,
width=self.frame.winfo_width() -
url_label.winfo_width())
self.url_entry.pack(side=LEFT, fill=X)
speed_label = Label(self.frame,
text="",
anchor=W,
textvariable=self.speed,
width=int(self.frame.winfo_width()))
speed_label.pack(side=BOTTOM)
prog_bar = Progressbar(self.frame,
orient=HORIZONTAL,
length=self.frame.winfo_width(),
mode="determinate",
value=0,
variable=self.progress)
prog_bar.pack(side=BOTTOM)
prog_bar.update()
exec_btn = Button(self.frame, text="Download", command=self.__download)
exec_btn.pack(side=BOTTOM)
def export_all_X_ray_graphs(import_X_ray_scans, analyze_1D, run_program):
location = askdirectory(title="Please choose a directory")
if location is not None and location is not '':
for widget in analyze_1D.Frame1_2.winfo_children():
widget.destroy()
Label(analyze_1D.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(analyze_1D.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(import_X_ray_scans.phi)
for i in range(len(import_X_ray_scans.phi)):
progress["value"] = progress["value"] + 1
progress.update()
f = plt.figure(figsize=(10, 10), dpi=100)
plt.plot(import_X_ray_scans.matrix_two_theta[i],
import_X_ray_scans.matrix_intensity[i],
label="" + str(i + 1) + "")
plt.xlabel(r"$2\theta$")
plt.ylabel("Intensity")
plt.title("Original" + "/n" + "phi=" +
str(float(import_X_ray_scans.phi[i])) + "_psi=" +
str(float(import_X_ray_scans.psi[i])))
plt.savefig(str(location) + "/original_phi=" +
str(float(import_X_ray_scans.phi[i])) + "; psi=" +
str(float(import_X_ray_scans.psi[i])) + ".png",
bbox_inches="tight")
plt.close()
for widget in analyze_1D.Frame1_2.winfo_children():
widget.destroy()
run_program.fenetre.mainloop()
def export_all_fitting_calibrate_graph(calcul_2D,calib_2D,analyze_2D,run_program):
location=askdirectory(title="Please choose a directory")
if location is not None and location is not '':
for widget in analyze_2D.Frame1_2.winfo_children():
widget.destroy()
Label(analyze_2D.Frame1_2,text="Export").pack(side=LEFT)
progress = Progressbar(analyze_2D.Frame1_2,orient="horizontal",mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(calib_2D.phi)*calcul_2D.gamma_number_step
for i in range(len(calcul_2D.phi)):
for j in range(calcul_2D.gamma_number_step):
progress["value"] = progress["value"]+1
progress.update()
fig=plt.figure(facecolor="0.94",figsize=(10,10),dpi=100)
plt.xlabel(r"$2\theta(°)$")
plt.ylabel("Intensity")
plt.title("Fitting_phi="+str(float(calcul_2D.phi[i]))+"; psi="+str(float(calcul_2D.psi[i]))+"; step="+str(j+1)+'\n'+
r"$\gamma(°)$"+" integrate from "+str("%0.1f" %(calcul_2D.gamma_i[round(calcul_2D.gamma_from+j*calcul_2D.gamma_stepline-calcul_2D.gamma_stepline/2)]))
+"° to "+str("%0.1f" %(calcul_2D.gamma_i[round(calcul_2D.gamma_from+j*calcul_2D.gamma_stepline+calcul_2D.gamma_stepline/2)]))+"°")
try:
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_intensity[i][j],label='original')
except (IndexError,ValueError):
pass
else:
try:
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_background_intensity[i][j],label='background')
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_real_intensity[i][j],label='substrat background')
except (IndexError,ValueError):
pass
else:
try:
x=[calcul_2D.all_two_theta_pearson[i*calcul_2D.gamma_number_step+j],calcul_2D.all_two_theta_pearson[i*calcul_2D.gamma_number_step+j]]
y=[min(calcul_2D.all_matrix_real_intensity[i][j]),max(calcul_2D.all_matrix_real_intensity[i][j])]
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F1_peak1[i][j],label='k alpha 1')
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F2_peak1[i][j],label='k alpha 2')
if len(calcul_2D.peaks)>=2:
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F1_peak2[i][j])
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F2_peak2[i][j])
if len(calcul_2D.peaks)==3:
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F1_peak3[i][j])
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F2_peak3[i][j])
plt.plot(calcul_2D.two_theta_limit,calcul_2D.all_matrix_F_pearson[i][j],label='fitting pearson vii')
plt.plot(x,y,label=r"$2\theta_{0}$""="+str(calcul_2D.all_two_theta_pearson[i*calcul_2D.gamma_number_step+j])+"")
except (IndexError,ValueError):
pass
else:
plt.legend(loc='upper left', bbox_to_anchor=(-0.1, -0.2, 1.2, 0),ncol=3,mode="expand",borderaxespad=0.,fontsize='x-small')
plt.subplots_adjust(bottom=0.3)
plt.savefig(str(location)+"/"+str(i*calcul_2D.gamma_number_step+j+1)+"_Fitting_phi="+str(float(calcul_2D.phi[i]))+"; psi="+str(float(calcul_2D.psi[i]))+";step="+str(j+1)+".png", bbox_inches="tight")
plt.close(fig)
for widget in analyze_2D.Frame1_2.winfo_children():
widget.destroy()
run_program.fenetre.mainloop()
def done():
global COPY, MOVE
# Get the number of the operations that need to be done
items = len(MOVE)
for file in COPY:
for dest in COPY[file]:
items += 1
# Make the top-level window of the progress bar
prog = Toplevel(root)
prog.minsize(200, 70)
progFrame = Frame(prog, bg="#333333", width=250, height=70)
progFrame.pack(expand=TRUE, fill='both')
progFrame.pack_propagate(0)
progress_label = Label(progFrame,
text="Processing...",
bg="#333333",
fg="#ffffff",
font="Verdana 10 bold")
progress_label.pack(pady=5)
progress = Progressbar(progFrame,
orient=HORIZONTAL,
maximum=items,
length=200,
mode='determinate')
progress.pack(pady=5)
# Do all the copying
for file in COPY:
for dest in COPY[file]:
try:
shutil.copy2(file, dest)
# Except there is a file with the same name
except shutil.SameFileError:
messagebox.showinfo(
'Error', "Unable to copy " + path_leaf(file) + " to " +
dest + " which has a file with the same name.")
pass
# Update the progress bar
progress['value'] += 1
progress.update()
# Do all the moving
for file in MOVE:
try:
shutil.move(file, MOVE[file])
# Except there is a file with the same name
except shutil.Error:
messagebox.showinfo(
'Error', "Unable to move " + path_leaf(file) + " to " +
MOVE[file] + " which has a file with the same name.")
pass
# Update the progress bar
progress['value'] += 1
progress.update()
# Show the "DONE!" message and close the program
messagebox.showinfo('Done', 'Done!')
root.destroy()
def __display_fetch_downlod(self):
self.display_type = self.FETCHDOWNLOAD
self.frame.update()
left_frame = Frame(self.frame,
width=int(self.frame.winfo_width() / 2),
height=50,
padx=5)
left_frame.pack(side=LEFT)
left_frame.pack_propagate(0)
left_frame.update()
para_label = Label(left_frame,
text="Parameters",
anchor=W,
width=int(left_frame.winfo_width()))
para_label.pack()
url_frame = Frame(left_frame, width=left_frame.winfo_width())
url_frame.pack()
url_label = Label(url_frame, text="URL")
url_label.pack(side=LEFT)
url_label.update()
self.url_entry = url_entry = Entry(url_frame,
width=left_frame.winfo_width() -
url_label.winfo_width())
self.url_entry.pack(side=LEFT, fill=X)
speed_label = Label(left_frame,
text="",
anchor=W,
textvariable=self.speed,
width=int(self.frame.winfo_width()))
speed_label.pack(side=BOTTOM)
prog_bar = Progressbar(left_frame,
orient=HORIZONTAL,
length=self.frame.winfo_width(),
mode="determinate",
value=0,
variable=self.progress)
prog_bar.pack(side=BOTTOM)
prog_bar.update()
exec_btn = Button(left_frame,
text="Fetch&Download",
command=self.__fetch_download)
exec_btn.pack(side=BOTTOM)
right_frame = Frame(self.frame,
width=self.frame.winfo_width() / 2,
padx=5)
right_frame.pack(side=LEFT)
self.__display_proxy(right_frame)
right_frame.update()
left_frame.config(height=right_frame.winfo_height())
class RegularityRallyGUI(RegularityRally):
STATES = {-1: 'Select configuration',
0: 'Ready',
1: 'Fast Lap',
2: 'Untimed Lap',
3: 'Set Lap',
4: 'Confirmation Lap'}
def __init__(self):
super().__init__()
# Data attribute initialization.
self.root_dir = pathlib.Path(__file__).parent.parent.absolute()
self.config_dir = os.path.join(self.root_dir, 'config')
# Overwrite initial state. Config read is mandatory here.
self.state = -1
# GUI attribute initialization.
self.master = None
self.font = None
self.w = None
self.h = None
self.l_state = None
self.l_mark = None
self.l_cur_lap = None
self.l_cur_lap_disp = None
self.l_set_lap = None
self.l_set_lap_disp = None
self.t_laps = None
self.bar_progress = None
self.style_progress = None
# Get start time.
self.time_stamps = []
# Window initialization.
self.init_window()
def init_window(self):
# Create main window
self.master = Tk()
self.master.title('Regularity Rally Timer')
# Resize window.
self.master.state('zoomed')
self.w = self.master.winfo_screenwidth()
self.h = self.master.winfo_screenheight()
# Init font variable.
self.font = tk_font.Font(family="Helvetica", size=36, weight="bold")
# Create menu
menu_bar = Menu(self.master)
file_menu = Menu(menu_bar, tearoff=0)
file_menu.add_command(label='New', command=self.new_cb)
file_menu.add_command(label='Exit', command=self.master.quit)
menu_bar.add_cascade(label="File", menu=file_menu)
extras_menu = Menu(menu_bar, tearoff=0)
extras_menu.add_command(label='Set new start time', command=None)
extras_menu.add_command(label='Manage Config Files', command=None)
extras_menu.add_command(label='Options', command=None)
menu_bar.add_cascade(label="Extras", menu=extras_menu)
self.master.config(menu=menu_bar)
# Init Widgets.
# TODO: Resize and anchor Labels.
# Information row.
row_count = 0
self.l_state = Label(self.master, text='Select Configuration', font=self.font)
self.l_state.grid(row=row_count, column=0)
self.l_mark = Label(self.master, text='', font=self.font)
self.l_mark.grid(row=row_count, column=1)
self.t_laps = Text(self.master, width=20, font=("Consolas", 32))
self.t_laps.grid(row=row_count, column=2, rowspan=3)
self.master.grid_rowconfigure(row_count, weight=1)
# Labels row.
row_count += 1
self.l_cur_lap = Label(self.master, text='Current Lap', anchor='w', font=self.font)
self.l_cur_lap.grid(row=row_count, column=0)
self.l_set_lap = Label(self.master, text='Current Set Lap', anchor='w', font=self.font)
self.l_set_lap.grid(row=row_count, column=1)
self.master.grid_rowconfigure(row_count, weight=1)
# Time display row.
row_count += 1
self.l_cur_lap_disp = Label(self.master, text='__:__:__._', anchor='w', font=self.font)
self.l_cur_lap_disp.grid(row=row_count, column=0)
self.l_set_lap_disp = Label(self.master, text='__:__:__._', anchor='w', font=self.font)
self.l_set_lap_disp.grid(row=row_count, column=1)
self.master.grid_rowconfigure(row_count, weight=1)
# Progressbar and countdown row.
row_count += 1
# Create the progressbar style to be labeled.
self.style_progress = Style(self.master)
self.style_progress.layout("LabeledProgressbar",
[('LabeledProgressbar.trough',
{'children': [('LabeledProgressbar.pbar',
{'side': 'left', 'sticky': 'ns'}),
("LabeledProgressbar.label", # label inside the bar
{"sticky": ""})],
'sticky': 'nswe'})])
self.bar_progress = Progressbar(self.master, orient='horizontal', length=1000, mode='determinate',
style="LabeledProgressbar")
self.bar_progress.grid(row=row_count, column=0, columnspan=3, ipady=25)
# Column configuration.
self.master.grid_columnconfigure(0, weight=1)
self.master.grid_columnconfigure(1, weight=1)
# Define Binds.
self.master.bind('1', self.one_cb)
self.master.bind('2', self.two_cb)
# Start master mainloop.
self.master.after(10, self.gui_update)
self.master.mainloop()
def gui_update(self):
# Calculate time delta of current lap.
if self.state > 0:
# Call regularity update.
self.reg_update()
# Update current lap time display.
self.l_cur_lap_disp['text'] = '{:02}:{:02}:{:02}.{}'.format(self.curlap_decoded[0],
self.curlap_decoded[1],
self.curlap_decoded[2],
floor(self.curlap_decoded[3]/100))
# Update countdown display, if confirmation lap.
if self.state == 4:
# Update progress bar.
self.bar_progress['value'] = self.curlap_countdown_seconds
self.style_progress.configure("LabeledProgressbar", text='{:.2f}'.format(self.curlap_countdown_seconds))
self.bar_progress.update()
# Update mark label.
if self.mark_count < len(self.mark_labels):
self.l_mark['text'] = self.mark_labels[self.mark_count]
else:
self.bar_progress['value'] = 0
self.style_progress.configure("LabeledProgressbar", text='')
# Schedule next call.
self.master.after(10, self.gui_update)
# Method called, when new race should be created.
def new_cb(self):
# Select and open a configuration.
conf_file = open(filedialog.askopenfilename(initialdir=self.config_dir,
title='Select file',
filetypes=(('Configuration', "*.cfg"), ("all files", "*.*"))))
# Read configuration.
self.read_config(conf_file.name)
# Write state.
self.state = 0
self.l_state['text'] = 'Ready'
# Method for new lap.
# Only update displays here. Set data in regularityRally.reg_new_lap()
def one_cb(self, _):
if self.state == -1:
self.new_cb()
else:
# Store last state.
last_state = self.state
# Perform new lap method.
self.reg_new_lap()
# Change label.
self.l_state['text'] = self.STATES[self.state]
if self.state in [3, 4]:
marks = list(self.config['marks'].keys())
self.l_mark['text'] = marks[0]
# Update lap times text field.
self.t_laps.delete(1.0, 'end')
for lt_id, lt in enumerate(self.lap_times_decoded):
# Get text char from config. If id out of config, set 'F.
if lt_id < len(self.config['states']):
state_char = self.STATES[self.config['states'][lt_id]][0]
else:
state_char = 'F'
# Set char for each lap.
self.t_laps.insert('end', '{:>2}: {:02}:{:02}:{:02}.{:03} {}\n'.format(lt_id + 1,
lt[0], lt[1], lt[2], lt[3],
state_char))
# Update GUI items related to set lap.
if self.cur_set_time is not None:
# Update shown set time.
self.l_set_lap_disp['text'] = '{:02}:{:02}:{:02}.{:01}'.format(self.cur_set_time_decoded[0],
self.cur_set_time_decoded[1],
self.cur_set_time_decoded[2],
floor(self.cur_set_time_decoded[3]/100))
# Update progressbar maximum to set lap time to show countdown.
self.bar_progress['maximum'] = self.cur_set_time
def two_cb(self, _):
# Execute superclass method.
self.mark_reached()
# Write next mark to label.
marks = list(self.config['marks'].keys())
if len(marks) > self.mark_count:
self.l_mark['text'] = marks[self.mark_count]
else:
self.l_mark['text'] = 'countdown'
class Extractor(Frame):
def __init__(self, master=None, **kw):
Frame.__init__(self, master, **kw)
self.background = '#3c3f41'
self.border_color = '#303030'
self.checkbox_color = '#393c3d'
self.args = {
"data_dir": "",
"data_file": "",
"pred_dir": "predictions",
"prepared_data": "processed_data",
}
self.textboxes = {}
self.checkboxes = {}
self.thread = None
self.running = False
self._init_ui()
def _init_ui(self):
ws = self.master.winfo_screenwidth()
hs = self.master.winfo_screenheight()
h = hs - 100
w = int(h / 1.414) + 100
x = (ws / 2) - (w / 2)
y = (hs / 2) - (h / 2)
self.master.geometry('%dx%d+%d+%d' % (w, h, x, y))
self.master.maxsize(w, h)
self.master.minsize(w, h)
self.master.title("InvoiceNet - Extractor")
self.pack(fill=BOTH, expand=True)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=0)
self.rowconfigure(1, weight=1)
self.rowconfigure(2, weight=0)
self.rowconfigure(3, weight=1)
self.configure(bg=self.background, bd=0)
logo_frame = Frame(self, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=1)
param_frame = Frame(self, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=1)
progress_frame = Frame(self, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=1)
main_frame = Frame(self, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=1)
logo_frame.grid(row=0, column=0, sticky='news')
param_frame.grid(row=1, column=0, sticky='news')
progress_frame.grid(row=2, column=0, sticky='news', padx=50, pady=(0, 20))
main_frame.grid(row=3, column=0, sticky='news')
# Logo Frame
logo_frame.columnconfigure(0, weight=1)
logo_frame.columnconfigure(1, weight=1)
logo_frame.columnconfigure(2, weight=2)
logo_frame.rowconfigure(0, weight=1)
self.logo_img = ImageTk.PhotoImage(Image.open(r'widgets/logo.png'))
Label(logo_frame, bg=self.background, image=self.logo_img, anchor='w').grid(row=0, column=0, sticky='news')
Label(logo_frame, text="InvoiceNet - Extractor", bg=self.background,
fg="white", font=("Arial", 24, "bold")).grid(row=0, column=1, sticky='news', padx=50)
# Param Frame
param_frame.columnconfigure(0, weight=1)
param_frame.columnconfigure(1, weight=0)
param_frame.columnconfigure(2, weight=0)
param_frame.columnconfigure(3, weight=1)
param_frame.rowconfigure(0, weight=1)
param_frame.rowconfigure(1, weight=0)
param_frame.rowconfigure(2, weight=0)
param_frame.rowconfigure(3, weight=0)
param_frame.rowconfigure(4, weight=0)
param_frame.rowconfigure(5, weight=0)
param_frame.rowconfigure(6, weight=1)
data_file_param = Frame(param_frame, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
data_dir_param = Frame(param_frame, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
prepare_dir_param = Frame(param_frame, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
pred_dir_param = Frame(param_frame, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
field_param = Frame(param_frame, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
data_file_param.grid(row=1, column=1, pady=10, padx=20)
data_dir_param.grid(row=2, column=1, pady=10, padx=20)
prepare_dir_param.grid(row=3, column=1, pady=10, padx=20)
pred_dir_param.grid(row=4, column=1, pady=10, padx=20)
field_param.grid(row=1, column=2, rowspan=4, pady=10, padx=10, sticky='news')
# Invoice File
data_file_frame = Frame(data_file_param, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
data_file_frame.pack(side=TOP, fill=BOTH)
Label(data_file_frame, text="Invoice File:", bg=self.background,
fg="white", font=("Arial", 8, "bold"), anchor='w').pack(side=LEFT, fill=BOTH)
HoverButton(data_file_frame, image_path=r'widgets/open_file.png',
command=lambda: self._open("data_file"),
width=18, height=18, bg=self.background, bd=0,
highlightthickness=0, activebackground='#558de8').pack(side=RIGHT)
self.textboxes["data_file"] = Text(data_file_param, height=1, width=20)
self.textboxes["data_file"].insert('1.0', self.args["data_file"])
self.textboxes["data_file"].pack(side=BOTTOM)
# Invoice Directory
data_dir_frame = Frame(data_dir_param, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
data_dir_frame.pack(side=TOP, fill=BOTH)
Label(data_dir_frame, text="Invoice Folder:", bg=self.background,
anchor='w', fg="white", font=("Arial", 8, "bold")).pack(side=LEFT, fill=BOTH)
HoverButton(data_dir_frame, image_path=r'widgets/open_dir.png',
command=lambda: self._open("data_dir"),
width=18, height=18, bg=self.background, bd=0,
highlightthickness=0, activebackground='#558de8').pack(side=RIGHT)
self.textboxes["data_dir"] = Text(data_dir_param, height=1, width=20)
self.textboxes["data_dir"].insert('1.0', self.args["data_dir"])
self.textboxes["data_dir"].pack(side=BOTTOM)
# Prepared Data Directory
prepare_dir_frame = Frame(prepare_dir_param, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
prepare_dir_frame.pack(side=TOP, fill=BOTH)
Label(prepare_dir_frame, text="Processed Data Folder:", bg=self.background,
anchor='w', fg="white", font=("Arial", 8, "bold")).pack(side=LEFT, fill=BOTH)
HoverButton(prepare_dir_frame, image_path=r'widgets/open_dir.png',
command=lambda: self._open("prepared_data"),
width=18, height=18, bg=self.background, bd=0,
highlightthickness=0, activebackground='#558de8').pack(side=RIGHT)
self.textboxes["prepared_data"] = Text(prepare_dir_param, height=1, width=20)
self.textboxes["prepared_data"].insert('1.0', self.args["prepared_data"])
self.textboxes["prepared_data"].pack(side=BOTTOM)
# Prediction Directory
pred_dir_frame = Frame(pred_dir_param, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
pred_dir_frame.pack(side=TOP, fill=BOTH)
Label(pred_dir_frame, text="Prediction Folder:", bg=self.background,
anchor='w', fg="white", font=("Arial", 8, "bold")).pack(side=LEFT, fill=BOTH)
HoverButton(pred_dir_frame, image_path=r'widgets/open_dir.png',
command=lambda: self._open("pred_dir"),
width=18, height=18, bg=self.background, bd=0,
highlightthickness=0, activebackground='#558de8').pack(side=RIGHT)
self.textboxes["pred_dir"] = Text(pred_dir_param, height=1, width=20)
self.textboxes["pred_dir"].insert('1.0', self.args["pred_dir"])
self.textboxes["pred_dir"].pack(side=BOTTOM)
# Field Checkboxes
field_frame = Frame(field_param, bg=self.checkbox_color, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=1)
field_frame.pack(expand=True, fill=BOTH, pady=10)
Label(field_frame, text="Field:", width=30, bg=self.checkbox_color,
anchor='w', fg="white", font=("Arial", 8, "bold")).pack(side=TOP, fill=X, padx=5, pady=5)
checkbox_frame = Frame(field_frame, bg=self.checkbox_color, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=1)
checkbox_frame.pack(expand=True, fill=BOTH, side=BOTTOM)
checkbox_frame.columnconfigure(0, weight=1)
checkbox_frame.columnconfigure(1, weight=1)
checkbox_frame.columnconfigure(2, weight=1)
checkbox_frame.columnconfigure(3, weight=1)
for i in range(len(FIELDS) // 2):
checkbox_frame.rowconfigure(i, weight=1)
for idx, key in enumerate(FIELDS):
self.checkboxes[key] = BooleanVar(checkbox_frame, value=False)
state = False
if os.path.exists('./models/invoicenet/'):
state = key in os.listdir('./models/invoicenet/')
Checkbutton(checkbox_frame, fg="black", bg=self.checkbox_color,
activebackground=self.background, variable=self.checkboxes[key], anchor='w',
state="normal" if state else "disabled", highlightthickness=0).grid(row=idx // 2,
column=2 if idx % 2 else 0,
sticky='news', padx=(10, 0))
Label(checkbox_frame, text=key, bg=self.checkbox_color,
anchor='w', fg="white", font=("Arial", 8, "bold")).grid(row=idx // 2, column=3 if idx % 2 else 1, sticky='news')
# Prepare Data Button
HoverButton(param_frame, image_path=r'widgets/prepare.png', command=self._prepare_data,
text='Prepare Data', compound='center', font=("Arial", 10, "bold"), bg=self.background,
bd=0, highlightthickness=0, activebackground=self.background).grid(row=5, column=1, columnspan=2,
padx=20, pady=(20, 0),
sticky='news')
# Progress Frame
self.progress_label = Label(progress_frame, text="Preparing data:", bg=self.background,
anchor='w', fg="white", font=("Arial", 8, "bold"))
self.progress_label.pack(side=TOP, expand=True, fill=X, pady=5)
self.progressbar = Progressbar(progress_frame, orient=HORIZONTAL, length=100, mode='determinate')
self.progressbar.pack(side=BOTTOM, expand=True, fill=X)
# Main Frame
main_frame.columnconfigure(0, weight=1)
main_frame.rowconfigure(0, weight=1)
main_frame.rowconfigure(1, weight=1)
button_frame = Frame(main_frame, bg=self.background, bd=0, relief=SUNKEN,
highlightbackground=self.border_color, highlightthickness=0)
button_frame.grid(row=0, column=0, sticky='news')
button_frame.rowconfigure(0, weight=1)
button_frame.columnconfigure(0, weight=1)
button_frame.columnconfigure(1, weight=0)
button_frame.columnconfigure(2, weight=1)
self.start_button = HoverButton(button_frame, image_path=r'widgets/begin.png', command=self._start,
text='Extract', compound='center', font=("Arial", 10, "bold"), bg=self.background,
bd=0, highlightthickness=0, activebackground=self.background)
self.start_button.grid(row=0, column=1)
self.logger = Logger(main_frame, bg=self.background, bd=0, relief=SUNKEN)
self.logger.grid(row=1, column=0, sticky='news')
def _extract(self):
self.logger.log("Extracting information from invoices...\n")
predictions = {}
for key in FIELDS:
if self.checkboxes[key].get():
test_data = RealData(field=key, data_dir=os.path.join(self.args["prepared_data"], 'predict/'))
model = AttendCopyParse(field=key, test_data=test_data, batch_size=1, restore=True)
preds = model.test_set(out_path=self.args["pred_dir"])
for file in preds.keys():
if file in predictions:
predictions[file][key] = preds[file][key]
else:
predictions[file] = preds[file]
for file in predictions:
self.logger.log("Invoice: {}".format('.'.join([file.split('.')[0], 'pdf'])))
for key in predictions[file]:
self.logger.log(" - {}: {}".format(key, predictions[file][key]))
self.logger.log(" ")
self.logger.log("Extracted information stored in '{}'".format(self.args["pred_dir"]))
self.start_button.configure(state='normal')
def _get_inputs(self):
self.args["data_file"] = self.textboxes["data_file"].get("1.0", 'end-1c')
self.args["data_dir"] = self.textboxes["data_dir"].get("1.0", 'end-1c')
self.args["prepared_data"] = self.textboxes["prepared_data"].get("1.0", 'end-1c')
self.args["pred_dir"] = self.textboxes["pred_dir"].get("1.0", 'end-1c')
if not self.args["prepared_data"].endswith('/'):
self.args["prepared_data"] += '/'
if not self.args["pred_dir"].endswith('/'):
self.args["pred_dir"] += '/'
if self.args["data_dir"] == '':
return
if not self.args["data_dir"].endswith('/'):
self.args["data_dir"] += '/'
def _start(self):
self._get_inputs()
if not os.path.exists(self.args["prepared_data"]):
messagebox.showerror("Error", "Prepared data folder does not exist!")
return
files = glob.glob(self.args["prepared_data"] + "**/*.json", recursive=True)
if not files:
messagebox.showerror("Error",
"Could not find processed data in \"{}\". Did you prepare data for extraction?".format(
self.args["prepared_data"]))
return
selected = False
for key in FIELDS:
if self.checkboxes[key].get():
selected = True
break
if not selected:
messagebox.showerror("Error", "No fields were selected!")
return
if not self.running:
self.running = True
self.thread = StoppableThread(target=self._extract)
self.thread.daemon = True
self.thread.start()
self.start_button.configure(state='disabled')
def _open(self, key):
if key == 'data_file':
path = filedialog.askopenfilename(initialdir='.', title="Select Invoice File",
filetypes=[("PDF files", "*.pdf")])
else:
path = filedialog.askdirectory(initialdir='.', title="Select Directory Containing Invoices")
if not path:
return
self.args[key] = path
self.textboxes[key].delete('1.0', END)
self.textboxes[key].insert('1.0', self.args[key])
def _prepare_data(self):
self._get_inputs()
if self.args["data_dir"] == '':
messagebox.showerror("Error", "No files were selected!")
return
if not os.path.exists(self.args["data_dir"]):
messagebox.showerror("Error", "No files were selected!")
return
self.progressbar["value"] = 0
self.progress_label.configure(text="Preparing Data:")
data_dir = os.path.join(self.args["prepared_data"], 'predict')
os.makedirs(data_dir, exist_ok=True)
filenames = [os.path.abspath(f) for f in glob.glob(data_dir + "**/*.json", recursive=True)]
filenames += [os.path.abspath(f) for f in glob.glob(data_dir + "**/*.png", recursive=True)]
for f in filenames:
os.remove(f)
filenames = []
if self.args["data_dir"] and os.path.exists(self.args["data_dir"]):
filenames = [os.path.abspath(f) for f in glob.glob(self.args["data_dir"] + "**/*.pdf", recursive=True)]
if self.args["data_file"] and os.path.exists(self.args["data_file"]):
filenames += [self.args["data_file"]]
self.logger.log("Total: {}".format(len(filenames)))
self.logger.log("Preparing data for extraction...")
total_samples = len(filenames)
sample_idx = 0
for filename in tqdm(filenames):
try:
page = pdf2image.convert_from_path(filename)[0]
page.save(os.path.join(data_dir, os.path.basename(filename)[:-3] + 'png'))
height = page.size[1]
width = page.size[0]
ngrams = util.create_ngrams(page)
for ngram in ngrams:
if "amount" in ngram["parses"]:
ngram["parses"]["amount"] = util.normalize(ngram["parses"]["amount"], key="amount")
if "date" in ngram["parses"]:
ngram["parses"]["date"] = util.normalize(ngram["parses"]["date"], key="date")
fields = {field: '0' for field in FIELDS}
data = {
"fields": fields,
"nGrams": ngrams,
"height": height,
"width": width,
"filename": os.path.abspath(os.path.join(data_dir, os.path.basename(filename)[:-3] + 'png'))
}
with open(os.path.join(data_dir, os.path.basename(filename)[:-3] + 'json'),
'w') as fp:
fp.write(simplejson.dumps(data, indent=2))
except Exception as exp:
self.logger.log("Skipping {} : {}".format(filename, exp))
sample_idx += 1
self.progress_label.configure(text="Preparing data [{}/{}]:".format(sample_idx, total_samples))
self.progressbar["value"] = (sample_idx / total_samples) * 100
self.progressbar.update()
self.progress_label.configure(text="Completed!")
self.progressbar["value"] = 100
self.progressbar.update()
self.logger.log("Prepared data stored in '{}'".format(data_dir))
class main_calcul:
def __init__(self,import_XRD,angles_modif,main):
try:
self.process(import_XRD,angles_modif,main)
except Exception as e:
showinfo(title="Warning",message=str(e)+"\n"+"\n"+str(traceback.format_exc()))
return
main.root.mainloop()
def process(self,import_XRD,angles_modif,main):
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2,text="Caculation").pack(side=LEFT)
self.progress = Progressbar(main.Frame1_2,orient="horizontal",mode='determinate')
self.progress.pack(side=LEFT)
self.progress["value"] = 0
self.progress["maximum"] = len(import_XRD.phi)+7
self.check_angles_modif(angles_modif,import_XRD)
self.check_peak_shift_correction(import_XRD)
#----------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.test_interval(import_XRD)
#----------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.test_material(import_XRD)
#----------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.test_x_ray(import_XRD)
#----------------------------------------
if self.interval_valid==True and self.material_valid==True and self.x_ray_valid==True:
self.destroy_widget(main)
self.peak_finder(import_XRD,angles_modif,main)
#-------------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_fitting_frame(import_XRD,stress_calcul,main)
#-------------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
stress_calcul.method_sin2psi(stress_calcul,self)
#-------------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
stress_calcul.method_fundamental(stress_calcul,self)
#-------------------------------------------
if stress_calcul.stress_valid>=1:
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_stress_graph(stress_calcul,import_XRD,main)
if stress_calcul.stress_valid>=2:
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_stress_tensor(stress_calcul,main)
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_variation_peak(stress_calcul,main)
for widget in main.Frame1_2.winfo_children():
widget.destroy()
if stress_calcul.stress_valid>=1:
pack_Frame_1D(main,5)
else:
pack_Frame_1D(main,4)
def check_angles_modif(self,angles_modif,import_XRD):
if import_XRD.angles_modif_valid==True:
self.phi=angles_modif.phi*1
self.chi=angles_modif.chi*1
self.omega=angles_modif.omega*1
self.twotheta=angles_modif.twotheta*1
self.data_x=angles_modif.data_x*1
else:
self.phi=import_XRD.phi*1
self.chi=import_XRD.chi*1
self.omega=import_XRD.omega*1
self.twotheta=import_XRD.twotheta*1
self.data_x=import_XRD.data_x*1
def check_peak_shift_correction(self,import_XRD):
self.peak_shift_correction_coefficient=import_XRD.peak_shift_correction_coefficient*1
#---------------------------------
def test_interval(self,import_XRD):
self.interval_valid=False
#test_entry_number
try:
twotheta_f=float(import_XRD.Entry_twotheta_from.get())
twotheta_t=float(import_XRD.Entry_twotheta_to.get())
background_f=((import_XRD.Entry_background_from.get()).rstrip(',')).split(',')
background_t=((import_XRD.Entry_background_to.get()).rstrip(',')).split(',')
for i in range(len(background_f)):
background_f[i]=float(background_f[i])
background_t[i]=float(background_t[i])
self.background_polynominal_degrees=int(import_XRD.Entry_background_polynominal_degrees.get())
except Exception:
showinfo(title="Error",message="Please insert all the limit parameters and verify that they are number\nPlease use '.' instead of ',' to insert a number")
return
#find index limit
twotheta_f_index=(np.abs(np.asarray(self.data_x[0])-twotheta_f)).argmin()
twotheta_t_index=(np.abs(np.asarray(self.data_x[0])-twotheta_t)).argmin()
background_f_index=[]
background_t_index=[]
for i in range(len(background_f)):
background_f_index.append((np.abs(np.asarray(self.data_x[0])-background_f[i])).argmin())
background_t_index.append((np.abs(np.asarray(self.data_x[0])-background_t[i])).argmin())
self.twotheta_f_index=min(twotheta_f_index,twotheta_t_index)
self.twotheta_t_index=max(twotheta_f_index,twotheta_t_index)
self.background_f_index=[]
self.background_t_index=[]
for i in range(len(background_f_index)):
self.background_f_index.append(min(background_f_index[i],background_t_index[i]))
self.background_t_index.append(max(background_f_index[i],background_t_index[i]))
#append limit
data_x_limit=self.data_x[0][self.twotheta_f_index:self.twotheta_t_index]
if len(data_x_limit)==0:
showinfo(title="Error",message="Limits out of range")
return
#check peaks reference
self.peaks_position_ref=[]
self.peaks_limit=[]
self.peaks_width=[]
try:
self.peaks_position_ref.append(float(import_XRD.Entry_peak[0].get()))
except Exception:
try:
self.peaks_position_ref.append(float(import_XRD.Entry_twotheta0.get()))
except Exception:
return
try:
self.peaks_limit.append(float(import_XRD.Entry_limit_peak[0].get()))
except Exception:
self.peaks_limit.append(1)
try:
self.peaks_width.append(float(import_XRD.Entry_peak_width[0].get()))
except Exception:
self.peaks_width.append(1)
if len(import_XRD.Entry_peak)==2:
position_ref=((import_XRD.Entry_peak[1].get()).rstrip(',')).split(',')
for i in range(len(position_ref)):
try:
self.peaks_position_ref.append(float(position_ref[i]))
except Exception:
pass
#find index peaks reference
for i in range(len(self.peaks_position_ref)):
index=(np.abs(np.asarray(data_x_limit)-self.peaks_position_ref[i])).argmin()
if index==0 or index==len(data_x_limit)-1:
showinfo(title="Error",message="Peak out of limit")
return
#find other informations
if len(import_XRD.Entry_peak)==2:
limit_peak=((import_XRD.Entry_limit_peak[1].get()).rstrip(',')).split(',')
peak_width=((import_XRD.Entry_peak_width[1].get()).rstrip(',')).split(',')
for i in range(1,len(self.peaks_position_ref)):
try:
self.peaks_limit.append(float(limit_peak[i]))
except Exception:
self.peaks_limit.append(1)
try:
self.peaks_width.append(float(peak_width[i]))
except Exception:
self.peaks_width.append(1)
self.interval_valid=True
#----------------------------------------------------
def test_material(self,import_XRD):
#check material
self.material_valid=False
try:
self.twotheta0=float(import_XRD.Entry_twotheta0.get())
except Exception:
showinfo(title="Error",message=u"Please check the value of unstressed 2\u03B8")
return
else:
try:
self.s1=float(import_XRD.Entry_s1.get())
self.s2_2=float(import_XRD.Entry_half_s2.get())
except Exception:
try:
Young=float(import_XRD.Entry_Young.get())
Poisson=float(import_XRD.Entry_Poisson.get())
except Exception:
showinfo(title="Error",message="Please check the value of (s1,s2/2) or (E,v)")
return
self.s1=-Poisson/Young
self.s2_2=(Poisson+1)/Young
self.material_valid=True
self.material_valid=True
#----------------------------------------------------
def test_x_ray(self,import_XRD):
self.x_ray_valid=False
try:
self.kalpha_1=float(import_XRD.Entry_kalpha[0].get())
self.kalpha_2=float(import_XRD.Entry_kalpha[1].get())
self.kalpha_ratio=float(import_XRD.Entry_kalpha[2].get())
except Exception:
showinfo(title="Error",message="Please check the value of X-ray propreties")
return
self.x_ray_valid=True
#--------------------------------------------------
def destroy_widget(self,main):
for widget in main.Frame3_4_1.winfo_children():
widget.destroy()
for widget in main.Frame3_4_2_1.winfo_children():
widget.destroy()
for widget in main.Frame3_4_2_2.winfo_children():
widget.destroy()
for widget in main.Frame3_4_3_1.winfo_children():
widget.destroy()
for widget in main.Frame3_4_3_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_2_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_2_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_2_3.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_2.winfo_children():
widget.destroy()
for widget in main.Frame3_6_1.winfo_children():
widget.destroy()
for widget in main.Frame3_6_2.winfo_children():
widget.destroy()
for widget in main.Frame3_6_3.winfo_children():
widget.destroy()
for widget in main.Frame3_7_1.winfo_children():
widget.destroy()
for widget in main.Frame3_7_2.winfo_children():
widget.destroy()
def destroy_widget_2(self,main):
for widget in main.Frame3_5_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_2_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_2_3.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_2.winfo_children():
widget.destroy()
for widget in main.Frame3_6_1.winfo_children():
widget.destroy()
for widget in main.Frame3_6_2.winfo_children():
widget.destroy()
for widget in main.Frame3_6_3.winfo_children():
widget.destroy()
for widget in main.Frame3_7_1.winfo_children():
widget.destroy()
for widget in main.Frame3_7_2.winfo_children():
widget.destroy()
#--------------------------------------------------
def peak_finder(self,import_XRD,angles_modif,main):
self.data_y_background_fit=[]
self.data_y_limit=[]
self.data_x_limit=[]
self.data_y_net=[]
self.data_y_fit=[]
self.data_y_k1_fit=[]
self.data_y_k2_fit=[]
self.data_y_fit_total=[]
self.peaks_position=[]
self.error_peaks_position=[]
self.peak_intensity=[]
self.error_peak_intensity=[]
self.FWHM=[]
self.error_FWHM=[]
self.a=[]
self.r=[]
self.peak_non_valide=[]
self.peak_rejection=[]
try:
r=float(import_XRD.Entry_r.get())
except Exception:
r=0
for i in range(len(import_XRD.phi)):
self.progress["value"] = self.progress["value"]+1
self.progress.update()
#-------------------------------------------
try:
data_y_limit=import_XRD.data_y[i][self.twotheta_f_index:self.twotheta_t_index]
data_x_limit=self.data_x[i][self.twotheta_f_index:self.twotheta_t_index]
self.data_y_limit.append(data_y_limit)
self.data_x_limit.append(data_x_limit)
background_data_y_limit=[]
background_data_x_limit=[]
for j in range(len(self.background_f_index)):
for k in range(self.background_f_index[j],self.background_t_index[j]):
background_data_y_limit.append(import_XRD.data_y[i][k])
background_data_x_limit.append(self.data_x[i][k])
background_fit_coefficient=np.polyfit(background_data_x_limit,background_data_y_limit,self.background_polynominal_degrees)
except Exception:
self.data_y_background_fit.append([])
self.data_y_net.append([])
self.append_zero()
self.peak_non_valide.append(i+1)
else:
data_y_background_fit=[]
for j in range(len(data_x_limit)):
data_y_background_fit_i=0
for k in range(self.background_polynominal_degrees+1):
data_y_background_fit_i=data_y_background_fit_i+background_fit_coefficient[k]*data_x_limit[j]**(self.background_polynominal_degrees-k)
data_y_background_fit.append(data_y_background_fit_i)
data_y_net=list(np.array(data_y_limit)-np.array(data_y_background_fit))
self.data_y_background_fit.append(data_y_background_fit)
self.data_y_net.append(data_y_net)
init_guess=float(import_XRD.init_guess.get())
p0_guess=initial_guess(data_y_net,data_x_limit,self.peaks_position_ref,self.peaks_limit,self.peaks_width,init_guess)
peak_shape=float(import_XRD.peak_shape.get())
function_fit=import_XRD.function_fit.get()
peak_fit_result=peak_fit(data_y_net,data_x_limit,self.kalpha_1,self.kalpha_2,self.kalpha_ratio,p0_guess,peak_shape,function_fit)
if len(peak_fit_result)==0:
self.append_zero()
self.peak_non_valide.append(i+1)
else:
self.peaks_position.append(peak_fit_result[0][0])
self.error_peaks_position.append(peak_fit_result[1][0])
self.peak_intensity.append(peak_fit_result[2][0])
self.error_peak_intensity.append(peak_fit_result[3][0])
self.FWHM.append(peak_fit_result[4][0])
self.error_FWHM.append(peak_fit_result[5][0])
self.data_y_fit_total.append(peak_fit_result[6])
self.data_y_k1_fit.append(peak_fit_result[7])
self.data_y_k2_fit.append(peak_fit_result[8])
self.r.append(peak_fit_result[9])
self.a.append(peak_fit_result[10][0])
self.data_y_fit.append(peak_fit_result[11])
if self.r[i]<r:
self.peak_rejection.append(i+1)
self.data_x_limit_init=self.data_x_limit*1
self.peaks_position_init=self.peaks_position*1
self.Entry_peak_non_valide=Entry(main.Frame3_5_2_1,width=100)
self.Entry_peak_rejection=Entry(main.Frame3_5_2_1,width=100)
self.Entry_peak_remove=Entry(main.Frame3_5_2_1,width=100)
for i in range(len(self.peak_non_valide)):
self.Entry_peak_non_valide.insert(END,str(self.peak_non_valide[i])+",")
for i in range(len(self.peak_rejection)):
self.Entry_peak_rejection.insert(END,str(self.peak_rejection[i])+",")
#--------------------------------------------------
def show_fitting_frame(self,import_XRD,stress_calcul,main):
self.original = IntVar()
Check_button=Checkbutton(main.Frame3_4_3_2, text="Original intensity", variable=self.original)
Check_button.grid(row=0,column=0,sticky=W)
Check_button.select()
self.background = IntVar()
Check_button=Checkbutton(main.Frame3_4_3_2, text="Background", variable=self.background)
Check_button.grid(row=1,column=0,sticky=W)
Check_button.select()
self.net_intensity = IntVar()
Check_button=Checkbutton(main.Frame3_4_3_2, text="Net intensity", variable=self.net_intensity)
Check_button.grid(row=2,column=0,sticky=W)
Check_button.select()
self.I_alpha1 = IntVar()
Check_button=Checkbutton(main.Frame3_4_3_2, text=u"I (\u03BB\u2081)", variable=self.I_alpha1)
Check_button.grid(row=3,column=0,sticky=W)
Check_button.select()
self.I_alpha2 = IntVar()
Check_button=Checkbutton(main.Frame3_4_3_2, text=u"I (\u03BB\u2082)", variable=self.I_alpha2)
Check_button.grid(row=4,column=0,sticky=W)
Check_button.select()
self.I_total = IntVar()
Check_button=Checkbutton(main.Frame3_4_3_2, text="I fit total", variable=self.I_total)
Check_button.grid(row=5,column=0,sticky=W)
Check_button.select()
scrollbar = Scrollbar(main.Frame3_4_1)
scrollbar.pack( side = RIGHT, fill=Y)
mylist = Listbox(main.Frame3_4_1, yscrollcommand = scrollbar.set)
for i in range(len(self.phi)):
mylist.insert(END, str(i+1)+u".\u03C6="+str(float(self.phi[i]))+u"; \u03C7="+str(float(self.chi[i]))+u"; \u03C9="+str(float(self.omega[i])))
mylist.pack( side = LEFT, fill = BOTH,expand=YES)
mylist.bind("<ButtonRelease-1>", lambda event: show_fit_graph(event,self,stress_calcul,main))
scrollbar.config( command = mylist.yview )
for i in range(len(self.phi)):
if str(i+1) in self.peak_non_valide or str(i+1) in self.peak_rejection:
continue
fig=plt.figure(facecolor="0.94")
plt.xlabel(r"$2\theta$")
plt.ylabel("Intensity")
plt.title(u"\u03C6="+str(float(self.phi[i]))+u"; \u03C7="+str(float(self.chi[i])))
plt.plot(self.data_x_limit[i],self.data_y_limit[i],'ro',markersize=2,label='Original intensity')
plt.plot(self.data_x_limit[i],self.data_y_background_fit[i],'k',label='Background')
plt.plot(self.data_x_limit[i],self.data_y_net[i],'go',markersize=2,label='Net intensity')
x=[self.peaks_position[i],self.peaks_position[i]]
y=[min(self.data_y_net[i]),max(self.data_y_limit[i])]
plt.plot(self.data_x_limit[i],self.data_y_k1_fit[i],'b',label=r"I($\lambda_{1}$)")
plt.plot(self.data_x_limit[i],self.data_y_k2_fit[i],'c',label=r"I($\lambda_{2}$)")
plt.plot(self.data_x_limit[i],self.data_y_fit_total[i],'m',label=r"I($\lambda_{1}$)"+r" + I($\lambda_{2}$)")
plt.plot(x,y,'b--',label=r"peak 2$\theta_{1}$ = "+str('%0.2f' % self.peaks_position[i])+"°")
plt.legend(loc='upper left', bbox_to_anchor=(-0.1, -0.2, 1.2, 0),ncol=3,mode="expand",borderaxespad=0.)
plt.subplots_adjust(bottom=0.3)
plt.close()
canvas = FigureCanvasTkAgg(fig, master=main.Frame3_4_2_1)
canvas.get_tk_widget().pack(fill=BOTH,expand=YES)
break
Button(main.Frame3_4_3_1, text = 'Export all as image',bg="white", command = lambda: export_all_fit_graph(self,main)).pack(side=TOP,padx=10, pady=10)
Button(main.Frame3_4_3_1, text = 'Export all as text',bg="white", command = lambda: export_all_fit_data(self,main)).pack(side=TOP,padx=10, pady=10)
fig_style(self,main.Frame3_4_3_3)
#---------------------------------
def modification_stress(self,import_XRD,angles_modif,main):
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2,text="Caculation").pack(side=LEFT)
self.progress = Progressbar(main.Frame1_2,orient="horizontal",mode='determinate')
self.progress.pack(side=LEFT)
self.progress["value"] = 0
self.progress["maximum"] = len(import_XRD.phi)+7
self.check_angles_modif(angles_modif,import_XRD)
self.check_peak_shift_correction(import_XRD)
#----------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.test_interval(import_XRD)
#----------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.test_material(import_XRD)
#----------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.test_x_ray(import_XRD)
#----------------------------------------
if self.interval_valid==True and self.material_valid==True and self.x_ray_valid==True:
self.destroy_widget_2(main)
#-------------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
stress_calcul.method_sin2psi(stress_calcul,self)
#-------------------------------------------
self.progress["value"] = self.progress["value"]+1
self.progress.update()
stress_calcul.method_fundamental(stress_calcul,self)
#-------------------------------------------
if stress_calcul.stress_valid>=1:
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_stress_graph(stress_calcul,import_XRD,main)
if stress_calcul.stress_valid>=2:
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_stress_tensor(stress_calcul,main)
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.show_variation_peak(stress_calcul,main)
for widget in main.Frame1_2.winfo_children():
widget.destroy()
if stress_calcul.stress_valid>=1:
pack_Frame_1D(main,5)
else:
pack_Frame_1D(main,4)
main.root.mainloop()
#-----------------------------------------------------
def show_stress_graph(self,stress_calcul,import_XRD,main):
self.experimental = IntVar()
Check_button=Checkbutton(main.Frame3_5_3_2, text="Experimental", variable=self.experimental)
Check_button.grid(row=0,column=0,sticky=W)
Check_button.select()
self.annotate = IntVar()
Check_button=Checkbutton(main.Frame3_5_3_2, text="Annotate", variable=self.annotate)
Check_button.grid(row=1,column=0,sticky=W)
Check_button.select()
if stress_calcul.stress_valid>=1:
self.sin2khi_method = IntVar()
Check_button=Checkbutton(main.Frame3_5_3_2, text=u'Sin\u00B2\u03A8 method', variable=self.sin2khi_method)
Check_button.grid(row=2,column=0,sticky=W)
Check_button.select()
self.fundamental_method = IntVar()
Check_button=Checkbutton(main.Frame3_5_3_2, text="Fundamental method", variable=self.fundamental_method)
Check_button.grid(row=3,column=0,sticky=W)
Check_button.select()
#--Frame3_5-----------------------------------------------------
scrollbar = Scrollbar(main.Frame3_5_1)
scrollbar.pack( side = RIGHT, fill=Y)
mylist = Listbox(main.Frame3_5_1, yscrollcommand = scrollbar.set )
for i in range(len(stress_calcul.liste_phi)):
mylist.insert(END, str(i+1)+u".\u03D5="+str(float(stress_calcul.liste_phi[i])))
mylist.pack( side = LEFT, fill = BOTH )
mylist.bind("<ButtonRelease-1>", lambda event: show_stress_graph(event,self,stress_calcul,main))
scrollbar.config( command = mylist.yview )
Label(main.Frame3_5_2_1, text="(Peak number)(1,2,3,...)").grid(row=0,column=1,sticky=W)
Label(main.Frame3_5_2_1, text="Graph non valide").grid(row=1,column=0,sticky=W)
self.Entry_peak_non_valide.grid(row=1,column=1,sticky=W)
self.Entry_peak_non_valide.config(state='disabled')
Label(main.Frame3_5_2_1, text="Peak rejection").grid(row=2,column=0,sticky=W)
self.Entry_peak_rejection.grid(row=2,column=1,sticky=W)
self.Entry_peak_rejection.config(state='disabled')
Label(main.Frame3_5_2_1, text="Remove peaks",bg="white").grid(row=3,column=0,sticky=W)
self.Entry_peak_remove.grid(row=3,column=1,sticky=W)
Button(main.Frame3_5_2_1,compound=CENTER, text="APPLY MODIFICATION",bg="white",command=lambda:self.modification_stress(import_XRD,angles_modif,main)).grid(row=4,column=1,sticky=W)
Label(main.Frame3_5_2_2, text="Stress behaviour").grid(row=0,column=0,sticky=W)
self.stress_behaviour = IntVar()
Radiobutton(main.Frame3_5_2_2, text="No Shear", variable=self.stress_behaviour, value=1).grid(row=1,column=0,sticky=W)
Radiobutton(main.Frame3_5_2_2, text="Shear", variable=self.stress_behaviour, value=2).grid(row=2,column=0,sticky=W)
self.stress_behaviour.set(1)
self.stress_dimension = IntVar()
self.stress_dimension.set(2)
if len(stress_calcul.liste_phi)>=3:
Label(main.Frame3_5_2_2, text="Stress dimension").grid(row=0,column=1,sticky=W)
Radiobutton(main.Frame3_5_2_2, text="Biaxial", variable=self.stress_dimension, value=2).grid(row=1,column=1,sticky=W)
Radiobutton(main.Frame3_5_2_2, text="Triaxial", variable=self.stress_dimension, value=3).grid(row=2,column=1,sticky=W)
Frame_a=Frame(main.Frame3_5_2_3)
Frame_a.pack(fill=BOTH, expand=YES)
Frame_b=Frame(main.Frame3_5_2_3)
Frame_b.pack(fill=BOTH, expand=YES)
if stress_calcul.stress_valid>=1:
Label(Frame_a,text=u'STRESS AT \u03D5='+str(stress_calcul.liste_phi[0])).grid(row=0,column=0,sticky=W)
Label(Frame_a,text="Unit: MPa").grid(row=0,column=1,sticky=W)
Label(Frame_a,text=u'Sin\u00B2\u03A8 method').grid(row=1,column=0,sticky=W)
Label(Frame_a,text=u'\u03C3\u03D5= '+str('%0.1f' % stress_calcul.sigma_phi_linear[0])+u"\u00B1"+str('%0.1f' % stress_calcul.error_sigma_phi_linear[0])).grid(row=2,column=0,sticky=W)
if len(stress_calcul.liste_phi)>=1:
Label(Frame_a,text=u' Fundamental method').grid(row=1,column=2,sticky=W)
if stress_calcul.length_strain>=3:
Label(Frame_a,text=u' \u03C3\u03D5= '+str('%0.1f' % stress_calcul.sigma_phi_biaxial[0])+u"\u00B1"+str('%0.1f' % stress_calcul.error_sigma_phi_biaxial[0])).grid(row=2,column=2,sticky=W)
fig=plt.figure(facecolor="0.94")
ax = fig.add_subplot(111)
plt.plot(stress_calcul.sinpsi_2[0],stress_calcul.strain[0],'ro',label='Experimental')
for j in range(len(stress_calcul.psi[0])):
plt.annotate(str(stress_calcul.index_psi[0][j]),xy=(stress_calcul.sinpsi_2[0][j],stress_calcul.strain[0][j]))
if stress_calcul.stress_valid>=1:
plt.plot(stress_calcul.sinpsi_2_sorted[0],stress_calcul.strain_linear_fit[0],'b',label=u'Sin\u00B2\u03A8 method')
if len(stress_calcul.liste_phi)>=1:
if stress_calcul.length_strain>=3:
plt.plot(stress_calcul.sinpsi_2_sorted[0],stress_calcul.strain_biaxial[0],'m',label='Fundamental method')
plt.xlabel(r"$sin^{2}\psi$")
plt.ylabel('Elastic strain '+r"$\varepsilon$")
plt.title(u"\u03D5="+str(stress_calcul.liste_phi[0]))
plt.legend(loc='upper left', bbox_to_anchor=(0.0, -0.3, 1, 0),ncol=3,mode="expand",borderaxespad=0.)
plt.subplots_adjust(bottom=0.4)
plt.subplots_adjust(left=0.2)
plt.close()
canvas = FigureCanvasTkAgg(fig, master=Frame_b)
canvas.get_tk_widget().pack(fill=BOTH, expand=YES)
fig_style(stress_calcul,main.Frame3_5_3_3)
Button(main.Frame3_5_3_1, text = 'Export all as image',bg="white", command = lambda: export_all_stress_graph(self,stress_calcul,main)).pack(side=TOP,padx=10, pady=10)
Button(main.Frame3_5_3_1, text = 'Export all as text',bg="white", command = lambda:export_all_stress_data(self,stress_calcul,main)).pack(side=TOP,padx=10, pady=10)
def show_stress_tensor(self,stress_calcul,main):
self.selection="Biaxial"
scrollbar = Scrollbar(main.Frame3_6_1)
scrollbar.pack( side = RIGHT, fill=Y)
mylist = Listbox(main.Frame3_6_1, yscrollcommand = scrollbar.set )
if stress_calcul.length_strain>=3:
mylist.insert(END, "Biaxial")
if stress_calcul.length_strain>=5:
mylist.insert(END, "Biaxial+shear")
if stress_calcul.length_strain>=6:
mylist.insert(END, "Triaxial")
mylist.pack( side = LEFT, fill = BOTH )
mylist.bind("<ButtonRelease-1>", lambda event: show_stress_tensor(event,stress_calcul,main))
scrollbar.config( command = mylist.yview )
#------------------------------------
Frame_a=Frame(main.Frame3_6_2)
Frame_a.pack(fill=BOTH, expand=YES)
Frame_b=Frame(main.Frame3_6_2)
Frame_b.pack(fill=BOTH, expand=YES)
Label(Frame_a,text="STRESS TENSOR - Biaxial").grid(row=0,column=0,sticky=W)
Label(Frame_a,text="Unit: MPa").grid(row=0,column=2,sticky=W)
Label(Frame_a,text=u'Sin\u00B2\u03A8 method').grid(row=1,column=0,sticky=W)
if stress_calcul.stress_valid>=2:
Label(Frame_a,text=u'\u03C3\u2081\u2081= '+str('%0.1f' % stress_calcul.tensor_biaxial_1[0][0])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial_1[1][0,0]))).grid(row=2,column=0,sticky=W)
Label(Frame_a,text=u'\u03C3\u2081\u2082= '+str('%0.1f' % stress_calcul.tensor_biaxial_1[0][1])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial_1[1][1,1]))).grid(row=2,column=1,sticky=W)
Label(Frame_a,text=u'\u03C3\u2082\u2081= '+str('%0.1f' % stress_calcul.tensor_biaxial_1[0][1])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial_1[1][1,1]))).grid(row=3,column=0,sticky=W)
Label(Frame_a,text=u'\u03C3\u2082\u2082= '+str('%0.1f' % stress_calcul.tensor_biaxial_1[0][2])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial_1[1][2,2]))).grid(row=3,column=1,sticky=W)
fig=plt.figure(facecolor="0.94")
theta=np.arange(0,np.radians(361),np.radians(5))
ax = fig.add_subplot(111, polar=True)
plt.title("Simulation stress-phi")
ax.plot(theta,np.negative(stress_calcul.all_sigma_phi_biaxial_1))
ax.set_yticks([min(np.negative(stress_calcul.all_sigma_phi_biaxial_1)),max(np.negative(stress_calcul.all_sigma_phi_biaxial_1))])
ax.set_yticklabels([str('%0.1f' % min(stress_calcul.all_sigma_phi_biaxial_1))+'MPa',str('%0.1f' % max(stress_calcul.all_sigma_phi_biaxial_1))+'MPa'])
plt.close(fig)
canvas = FigureCanvasTkAgg(fig, master=Frame_b)
canvas.get_tk_widget().pack(fill=BOTH, expand=YES,side=TOP)
#------------------------------------------------------
if len(stress_calcul.liste_phi)>=2:
Frame_c=Frame(main.Frame3_6_3)
Frame_c.pack(fill=BOTH, expand=YES)
Frame_d=Frame(main.Frame3_6_3)
Frame_d.pack(fill=BOTH, expand=YES)
Label(Frame_c,text="").grid(row=0,column=0,sticky=W)
Label(Frame_c,text="Fundamental method").grid(row=1,column=0,sticky=W)
Label(Frame_c,text=u'\u03C3\u2081\u2081= '+str('%0.1f' % stress_calcul.tensor_biaxial[0][0])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial[1][0,0]))).grid(row=2,column=0,sticky=W)
Label(Frame_c,text=u'\u03C3\u2081\u2082= '+str('%0.1f' % stress_calcul.tensor_biaxial[0][1])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial[1][1,1]))).grid(row=2,column=1,sticky=W)
Label(Frame_c,text=u'\u03C3\u2082\u2081= '+str('%0.1f' % stress_calcul.tensor_biaxial[0][1])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial[1][1,1]))).grid(row=3,column=0,sticky=W)
Label(Frame_c,text=u'\u03C3\u2082\u2082= '+str('%0.1f' % stress_calcul.tensor_biaxial[0][2])+u"\u00B1"+str('%0.1f' % np.sqrt(stress_calcul.tensor_biaxial[1][2,2]))).grid(row=3,column=1,sticky=W)
fig=plt.figure(facecolor="0.94")
plt.title("Simulation stress-phi")
theta=np.arange(0,np.radians(361),np.radians(5))
ax = fig.add_subplot(111, polar=True)
ax.plot(theta,np.negative(stress_calcul.all_sigma_phi_biaxial))
ax.set_yticks([min(np.negative(stress_calcul.all_sigma_phi_biaxial)),max(np.negative(stress_calcul.all_sigma_phi_biaxial))])
ax.set_yticklabels([str('%0.1f' % min(stress_calcul.all_sigma_phi_biaxial))+'MPa',str('%0.1f' % max(stress_calcul.all_sigma_phi_biaxial))+'MPa'])
plt.close(fig)
canvas = FigureCanvasTkAgg(fig, master=Frame_d)
canvas.get_tk_widget().pack(fill=BOTH, expand=YES,side=TOP)
def show_variation_peak(self,stress_calcul,main):
scrollbar = Scrollbar(main.Frame3_7_1)
scrollbar.pack( side = RIGHT, fill=Y)
mylist = Listbox(main.Frame3_7_1, yscrollcommand = scrollbar.set )
mylist.insert(END, u"1.peak shift - \u03D5")
mylist.insert(END, u"2.peak shift - \u03C8")
mylist.pack( side = LEFT, fill = BOTH )
mylist.bind("<ButtonRelease-1>", lambda event: show_other_info(event,self,stress_calcul,main))
scrollbar.config( command = mylist.yview )
fig=plt.figure(facecolor="0.94")
plt.plot(stress_calcul.psi_calib,stress_calcul.peak_shift,'ro',label='peak shift')
plt.xlabel(u"\u03C8(°)")
plt.ylabel("peak shift(%)")
plt.title("Variation of peak shift")
plt.legend(loc='upper left', bbox_to_anchor=(-0.1, -0.2, 1.2, 0),ncol=3,mode="expand",borderaxespad=0.,fontsize='x-small')
plt.subplots_adjust(bottom=0.3)
plt.close(fig)
canvas = FigureCanvasTkAgg(fig, master=main.Frame3_7_2)
canvas.get_tk_widget().pack(side=TOP,fill=BOTH, expand=YES)
def append_zero(self):
self.peaks_position.append(float('NaN'))
self.error_peaks_position.append(float('NaN'))
self.peak_intensity.append(float('NaN'))
self.error_peak_intensity.append(float('NaN'))
self.FWHM.append(float('NaN'))
self.error_FWHM.append(float('NaN'))
self.data_y_fit_total.append([])
self.data_y_k1_fit.append([])
self.data_y_k2_fit.append([])
self.data_y_fit.append([])
self.r.append(float('NaN'))
self.a.append(float('NaN'))
def export_all_stress_data_2D(calib_2D, calcul_2D, stress_calcul, analyze_2D,
run_program):
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".text",
filetypes=[('text files', '.txt'), ('all files', '.*')])
if f is not None and f is not '':
for widget in analyze_2D.Frame1_2.winfo_children():
widget.destroy()
Label(analyze_2D.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(analyze_2D.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(stress_calcul.phi_stress) + 2
if stress_calcul.stress_valid >= 1:
f.write("Linear fit\n")
for i in range(len(stress_calcul.liste_phi)):
f.write("Phi=" + str(stress_calcul.liste_phi[i]))
f.write("; a=" + str(stress_calcul.a[i]))
f.write("; b=" + str(stress_calcul.b[i]) + "\n")
if stress_calcul.stress_valid == 1:
f.write("FUNDAMENTAL METHOD \n")
f.write("Uniaxial: " + "sigma= " +
str(stress_calcul.sigma_phi_uniaxial[0]) + "+/-" +
str(stress_calcul.error_sigma_phi_uniaxial[0]) + "MPa" +
"\n")
f.write("Uniaxial+shear: " + "sigma= " +
str(stress_calcul.sigma_phi_uniaxial_shear[0]) + "+/-" +
str(stress_calcul.error_sigma_phi_uniaxial_shear[0]) +
"MPa" + "\n")
f.write("Uniaxial+shear: " + "shear= " +
str(stress_calcul.shear_phi_uniaxial_shear[0]) + "+/-" +
str(stress_calcul.error_shear_phi_uniaxial_shear[0]) +
"MPa" + "\n")
f.write("--------------\n")
f.write("SIN2PSI METHOD\n")
f.write("Linear fit: " + "sigma= " +
str(stress_calcul.sigma_phi_linear[0]) + "+/-" +
str(stress_calcul.error_sigma_phi_linear[0]) + "MPa" +
"\n")
f.write("Elliptic fit: " + "sigma= " +
str(stress_calcul.sigma_phi_elliptic[0]) + "+/-" +
str(stress_calcul.error_sigma_phi_elliptic[0]) + "MPa" +
"\n")
f.write("Elliptic fit: " + "shear= " +
str(stress_calcul.shear_phi_elliptic[0]) + "+/-" +
str(stress_calcul.error_shear_phi_elliptic[0]) + "MPa" +
"\n")
if stress_calcul.stress_valid >= 2 and stress_calcul.sigma12_valid == False:
progress["value"] = progress["value"] + 1
progress.update()
f.write('STRESS TENSOR' + "\n")
f.write("---------------------------------------------------- \n")
f.write("FUNDAMENTAL METHOD \n")
f.write("---Biaxial stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_simple[0][0]) + "+/-" +
str(stress_calcul.tensor_biaxial_simple[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_simple[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_simple[1][1, 1]**0.5) +
"MPa" + "\n")
f.write("---------------------- \n")
f.write("---Biaxial+shear stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_simple_shear[0][0]) +
"+/-" +
str(stress_calcul.tensor_biaxial_simple_shear[1][0,
0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_simple_shear[0][1]) +
"+/-" +
str(stress_calcul.tensor_biaxial_simple_shear[1][1,
1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_biaxial_simple_shear[0][2]) +
"+/-" +
str(stress_calcul.tensor_biaxial_simple_shear[1][2,
2]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_biaxial_simple_shear[0][3]) +
"+/-" +
str(stress_calcul.tensor_biaxial_simple_shear[1][3,
3]**0.5) +
"MPa" + "\n")
f.write('sigma 33 = 0MPa\n')
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("SIN2PSI METHOD\n")
f.write("---Biaxial stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_simple_1[0][0]) + "+/-" +
str(stress_calcul.tensor_biaxial_simple_1[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_simple_1[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_simple_1[1][1, 1]**0.5) +
"MPa" + "\n")
f.write("---------------------- \n")
f.write("---Biaxial+shear stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_simple_shear_1[0][0]) +
"+/-" + str(stress_calcul.tensor_biaxial_simple_shear_1[1][
0, 0]**0.5) + "MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_simple_shear_1[0][1]) +
"+/-" + str(stress_calcul.tensor_biaxial_simple_shear_1[1][
1, 1]**0.5) + "MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_biaxial_simple_shear_1[0][2]) +
"+/-" + str(stress_calcul.tensor_biaxial_simple_shear_1[1][
2, 2]**0.5) + "MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_biaxial_simple_shear_1[0][3]) +
"+/-" + str(stress_calcul.tensor_biaxial_simple_shear_1[1][
3, 3]**0.5) + "MPa" + "\n")
f.write('sigma 33 = 0MPa\n')
progress["value"] = progress["value"] + 1
progress.update()
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write('STRESS AT PHI\n')
f.write("---------------------------------------------------- \n")
f.write("FUNDAMENTAL METHOD \n")
for i in range(len(stress_calcul.liste_phi)):
f.write("----Phi= " + str(stress_calcul.liste_phi[i]) +
"(°)----\n")
f.write("Biaxial: " + "sigma= " +
str(stress_calcul.sigma_phi_biaxial_simple[i]) +
"+/-" +
str(stress_calcul.error_sigma_phi_biaxial_simple[i]) +
"MPa" + "\n")
f.write("Biaxial+shear: " + "sigma= " +
str(stress_calcul.sigma_phi_biaxial_simple_shear[i]) +
"+/-" + str(stress_calcul.
error_sigma_phi_biaxial_simple_shear[i]) +
"MPa" + "\n")
f.write("Biaxial+shear: " + "shear= " +
str(stress_calcul.shear_phi_biaxial_simple_shear[i]) +
"+/-" + str(stress_calcul.
error_shear_phi_biaxial_simple_shear[i]) +
"MPa" + "\n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("SIN2PSI METHOD\n")
for i in range(len(stress_calcul.liste_phi)):
f.write("----Phi= " + str(stress_calcul.liste_phi[i]) +
"(°)----\n")
f.write("Linear fit: " + "sigma= " +
str(stress_calcul.sigma_phi_linear[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_linear[i]) + "MPa" +
"\n")
f.write("Elliptic: " + "sigma= " +
str(stress_calcul.sigma_phi_elliptic[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_elliptic[i]) +
"MPa" + "\n")
f.write("Elliptic: " + "shear= " +
str(stress_calcul.shear_phi_elliptic[i]) + "+/-" +
str(stress_calcul.error_shear_phi_elliptic[i]) +
"MPa" + "\n")
if stress_calcul.sigma12_valid == True:
progress["value"] = progress["value"] + 1
progress.update()
f.write('STRESS TENSOR' + "\n")
f.write("---------------------------------------------------- \n")
f.write("FUNDAMENTAL METHOD \n")
f.write("---Biaxial stress----- \n")
f.write('sigma 11 = ' + str(stress_calcul.tensor_biaxial[0][0]) +
"+/-" + str(stress_calcul.tensor_biaxial[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' + str(stress_calcul.tensor_biaxial[0][2]) +
"+/-" + str(stress_calcul.tensor_biaxial[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_biaxial[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial[1][1, 1]**0.5) + "MPa" +
"\n")
f.write("---------------------- \n")
f.write("---Biaxial+shear stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_shear[0][0]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_shear[0][2]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_biaxial_shear[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][1, 1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_biaxial_shear[0][3]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][3, 3]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_biaxial_shear[0][4]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][4, 4]**0.5) +
"MPa" + "\n")
f.write('sigma 33 = 0MPa\n')
if stress_calcul.stress_valid >= 3:
f.write("---Triaxial stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_triaxial[0][0]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_triaxial[0][2]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_triaxial[0][1]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][1, 1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_triaxial[0][3]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][3, 3]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_triaxial[0][4]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][4, 4]**0.5) +
"MPa" + "\n")
f.write('sigma 33 = ' +
str(stress_calcul.tensor_triaxial[0][5]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][5, 5]**0.5) +
"MPa" + "\n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("SIN2PSI METHOD\n")
f.write("---Biaxial stress----- \n")
f.write('sigma 11 = ' + str(stress_calcul.tensor_biaxial_1[0][0]) +
"+/-" + str(stress_calcul.tensor_biaxial_1[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' + str(stress_calcul.tensor_biaxial_1[0][2]) +
"+/-" + str(stress_calcul.tensor_biaxial_1[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_biaxial_1[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_1[1][1, 1]**0.5) + "MPa" +
"\n")
f.write("---------------------- \n")
f.write("---Biaxial+shear stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_shear_1[0][0]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear_1[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_shear_1[0][2]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear_1[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_biaxial_shear_1[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear_1[1][1, 1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_biaxial_shear_1[0][3]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear_1[1][3, 3]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_biaxial_shear_1[0][4]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear_1[1][4, 4]**0.5) +
"MPa" + "\n")
f.write('sigma 33 = 0MPa\n')
if stress_calcul.stress_valid >= 3:
f.write("---Triaxial stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_triaxial_1[0][0]) + "+/-" +
str(stress_calcul.tensor_triaxial_1[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_triaxial_1[0][2]) + "+/-" +
str(stress_calcul.tensor_triaxial_1[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_triaxial_1[0][1]) + "+/-" +
str(stress_calcul.tensor_triaxial_1[1][1, 1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_triaxial_1[0][3]) + "+/-" +
str(stress_calcul.tensor_triaxial_1[1][3, 3]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_triaxial_1[0][4]) + "+/-" +
str(stress_calcul.tensor_triaxial_1[1][4, 4]**0.5) +
"MPa" + "\n")
f.write('sigma 33 = ' +
str(stress_calcul.tensor_triaxial_1[0][5]) + "+/-" +
str(stress_calcul.tensor_triaxial_1[1][5, 5]**0.5) +
"MPa" + "\n")
progress["value"] = progress["value"] + 1
progress.update()
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write('STRESS AT PHI\n')
f.write("---------------------------------------------------- \n")
f.write("FUNDAMENTAL METHOD \n")
for i in range(len(stress_calcul.liste_phi)):
f.write("----Phi= " + str(stress_calcul.liste_phi[i]) +
"(°)----\n")
f.write("Biaxial: " + "sigma= " +
str(stress_calcul.sigma_phi_biaxial[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_biaxial[i]) + "MPa" +
"\n")
f.write("Biaxial+shear: " + "sigma= " +
str(stress_calcul.sigma_phi_biaxial_shear[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_biaxial_shear[i]) +
"MPa" + "\n")
f.write("Biaxial+shear: " + "shear= " +
str(stress_calcul.shear_phi_biaxial_shear[i]) + "+/-" +
str(stress_calcul.error_shear_phi_biaxial_shear[i]) +
"MPa" + "\n")
if len(stress_calcul.liste_phi) >= 3:
f.write("Triaxial: " + "sigma= " +
str(stress_calcul.sigma_phi_triaxial[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_triaxial[i]) +
"MPa" + "\n")
f.write("Triaxial: " + "shear= " +
str(stress_calcul.shear_phi_triaxial[i]) + "+/-" +
str(stress_calcul.error_shear_phi_triaxial[i]) +
"MPa" + "\n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("SIN2PSI METHOD\n")
for i in range(len(stress_calcul.liste_phi)):
f.write("----Phi= " + str(stress_calcul.liste_phi[i]) +
"(°)----\n")
f.write("Linear fit: " + "sigma= " +
str(stress_calcul.sigma_phi_linear[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_linear[i]) + "MPa" +
"\n")
f.write("Elliptic: " + "sigma= " +
str(stress_calcul.sigma_phi_elliptic[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_elliptic[i]) +
"MPa" + "\n")
f.write("Elliptic: " + "shear= " +
str(stress_calcul.shear_phi_elliptic[i]) + "+/-" +
str(stress_calcul.error_shear_phi_elliptic[i]) +
"MPa" + "\n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write(
"phi(°) psi(°) omega(°) gamma(°) peak_2theta(°) phi_gamma(°) psi_gamma(°)\n"
)
for i in range(len(stress_calcul.phi_stress)):
progress["value"] = progress["value"] + 1
progress.update()
for j in range(calcul_2D.gamma_number_step):
gamma_range = round(calcul_2D.gamma_from +
j * calcul_2D.gamma_stepline)
try:
f.write(str("%3.4g" % stress_calcul.phi_stress[i]))
f.write(str("%10.4g" % stress_calcul.psi_stress[i]))
f.write(str("%12.4g" % calcul_2D.omega[i]))
f.write(str("%15.4g" % calcul_2D.gamma_i[gamma_range]))
f.write(
str("%15.4g" % calcul_2D.all_two_theta_pearson[
i * calcul_2D.gamma_number_step + j]))
f.write(
str("%15.4g" % stress_calcul.phi_gamma[
i * calcul_2D.gamma_number_step + j]))
f.write(
str("%15.4g" % stress_calcul.psi_gamma[
i * calcul_2D.gamma_number_step + j]))
except TypeError:
pass
f.write("\n")
f.close()
for widget in analyze_2D.Frame1_2.winfo_children():
widget.destroy()
run_program.fenetre.mainloop()
def export_all_fit_data(main_calcul, calib_2D, main):
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".text",
filetypes=[('text files', '.txt'), ('all files', '.*')])
if f is not None and f is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(main_calcul.phi) * main_calcul.gamma_number
for nimage in range(len(main_calcul.phi)):
for i_graph in range(main_calcul.gamma_number):
progress["value"] = progress["value"] + 1
progress.update()
i = calib_2D.nimage * main_calcul.gamma_number + i_graph
j_start = int(main_calcul.gamma_f_index +
i_graph * main_calcul.gamma_step)
j_end = int(main_calcul.gamma_f_index +
(i_graph + 1) * main_calcul.gamma_step)
f.write("Phi=" + str(main_calcul.phi[nimage]) + "°\n")
f.write("Chi=" + str(main_calcul.chi[nimage]) + "°\n")
f.write("Omega=" + str(main_calcul.omega[nimage]) + "°\n")
f.write("peak position=" + str(main_calcul.peaks_position[i]) +
"° +/- " + str(main_calcul.error_peaks_position[i]) +
"°\n")
f.write("FWHM=" + str(main_calcul.FWHM[i]) + "° +/- " +
str(main_calcul.error_FWHM[i]) + "°\n")
f.write("Peak intensity=" +
str(main_calcul.peak_intensity[i]) + " +/- " +
str(main_calcul.error_peak_intensity[i]) + "\n")
f.write("a=" + str(main_calcul.a[i]) + "\n")
f.write("r=" + str(main_calcul.r[i]) + "\n")
f.write("gamma integrate from " +
str(int(main_calcul.gamma_y[j_start])) + "° to " +
str(int(main_calcul.gamma_y[j_end])) + "°\n")
f.write(" two_theta(°)\t")
f.write("instensity\t")
f.write("background\t")
f.write("substrat_background\t")
f.write(" I_kalpha1\t")
f.write(" I_kalpha2\t")
f.write("I_Pearson_VII fit\t")
f.write("\n")
for j in range(len(main_calcul.data_x_limit)):
try:
f.write(str(main_calcul.data_x_limit[j]) + "\t")
f.write(str(main_calcul.data_y_limit[i][j]) + "\t")
f.write(
str(main_calcul.data_y_background_fit[i][j]) +
"\t")
f.write(str(main_calcul.data_y_net[i][j]) + "\t")
f.write(str(main_calcul.data_y_k1_fit[i][j]) + "\t")
f.write(str(main_calcul.data_y_k2_fit[i][j]) + "\t")
f.write(str(main_calcul.data_y_fit_total[i][j]) + "\t")
f.write("\n")
except (IndexError, ValueError):
pass
f.write("--------------------------------------\n")
f.write("--------------------------------------\n")
f.close()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
main.root.mainloop()
def export_calib_data(calib_2D, angles_modif, import_XRD, main):
from residual_stress_2D.calib_XRD_2D import calib_pyFai
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".xlf",
filetypes=[('X-Light format', '.xlf'),
('all files', '.*')])
if f is not None and f is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = 3
rotate = import_XRD.rotate
flip = import_XRD.flip
if calib_2D.angles_modif_valid == True:
twotheta_x = angles_modif.twotheta_x
gamma_y = angles_modif.gamma_y
phi = angles_modif.phi[calib_2D.nimage]
chi = angles_modif.chi[calib_2D.nimage]
omega = angles_modif.omega[calib_2D.nimage]
twotheta_center = angles_modif.twotheta_center[calib_2D.nimage]
else:
twotheta_x = calib_2D.twotheta_x
gamma_y = calib_2D.gamma_y
phi = calib_2D.phi[calib_2D.nimage]
chi = calib_2D.chi[calib_2D.nimage]
omega = calib_2D.omega[calib_2D.nimage]
twotheta_center = calib_2D.twotheta_center[calib_2D.nimage]
progress["value"] = progress["value"] + 1
progress.update()
data = read_data_2D(calib_2D.nimage, import_XRD)
if len(data.shape) == 3:
data = data[import_XRD.nimage_i[calib_2D.nimage]]
if len(data) == 0:
showinfo(title="Warning",
message="Can not read data of " + str(filename))
return
if rotate == 0:
nrow = import_XRD.nrow[calib_2D.nimage]
ncol = import_XRD.ncol[calib_2D.nimage]
center_row = import_XRD.center_row[calib_2D.nimage]
center_col = import_XRD.center_col[calib_2D.nimage]
if rotate == 90:
data = np.rot90(data, k=1, axes=(0, 1))
nrow = import_XRD.ncol[calib_2D.nimage]
ncol = import_XRD.nrow[calib_2D.nimage]
center_row = import_XRD.center_col[calib_2D.nimage]
center_col = import_XRD.center_row[calib_2D.nimage]
if rotate == 180:
data = np.rot90(data, k=2, axes=(0, 1))
nrow = import_XRD.nrow[calib_2D.nimage]
ncol = import_XRD.ncol[calib_2D.nimage]
center_row = import_XRD.center_row[calib_2D.nimage]
center_col = import_XRD.center_col[calib_2D.nimage]
if rotate == 270:
data = np.rot90(data, k=3, axes=(0, 1))
nrow = import_XRD.ncol[calib_2D.nimage]
ncol = import_XRD.nrow[calib_2D.nimage]
center_row = import_XRD.center_col[calib_2D.nimage]
center_col = import_XRD.center_row[calib_2D.nimage]
if flip == 1:
data = np.flip(data, axis=0)
if flip == 2:
data = np.flip(data, axis=1)
progress["value"] = progress["value"] + 1
progress.update()
calib = calib_pyFai(import_XRD, data, nrow, ncol, center_row,
center_col, twotheta_center)
if len(calib) > 0:
data = calib[0]
else:
showinfo(title="Warning",
message="Can not calib file " + str(filename))
return
if float(calib_2D.Check_twotheta_flip.get()) == 1:
data = np.flip(data, axis=1)
if len(data) > 0:
progress["value"] = progress["value"] + 1
progress.update()
nrow = len(gamma_y)
ncol = len(twotheta_x)
f.write("Phi=" + str(phi) + "\n")
f.write("Chi=" + str(chi) + "\n")
f.write("Omega=" + str(omega) + "\n")
f.write("2theta=" + str(twotheta_center) + "\n")
f.write("Wavelength=" + str(import_XRD.k_alpha[calib_2D.nimage]) +
"\n")
f.write("Distance=" + str(import_XRD.distance[calib_2D.nimage]) +
"\n")
f.write("------------------------------------------\n")
f.write("NRow=" + str(nrow) + "\n")
f.write("Center Row=" + str(center_row) + "\n")
for i in range(nrow):
f.write(str(gamma_y[i]) + " ")
f.write("\n")
f.write("NCol=" + str(ncol) + "\n")
f.write("Center Col=" + str(center_col) + "\n")
for i in range(ncol):
f.write(str(twotheta_x[i]) + " ")
f.write("\n")
f.write("------------------------------------------\n")
f.write("------------------------------------------\n")
progress["value"] = progress["value"] + 1
progress.update()
for i in range(nrow):
f.write(" ".join(str(e) for e in data[i]))
f.write("\n")
progress["value"] = progress["value"] + 1
progress.update()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
f.close()
main.root.mainloop()
def export_all_original_data(import_XRD, main):
location = askdirectory(title="Please choose a directory")
if location is not None and location is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(import_XRD.nfile)
rotate = import_XRD.rotate
flip = import_XRD.flip
for i in range(len(import_XRD.nfile)):
progress["value"] = progress["value"] + 1
progress.update()
f_split = (import_XRD.file_link[import_XRD.nfile[i]]).split("/")
filename = f_split[len(f_split) - 1]
name = str(location) + '/' + str(
filename.split('.')[0]) + '_' + str(
import_XRD.nimage_i[i]) + '.xlf'
f = open(name, 'w')
data = read_data_2D(i, import_XRD)
if len(data.shape) == 3:
data = data[import_XRD.nimage_i[i]]
if len(data) == 0:
showinfo(title="Warning",
message="Can not read data of " + str(filename))
return
if rotate == 0:
nrow = import_XRD.nrow[i]
ncol = import_XRD.ncol[i]
center_row = import_XRD.center_row[i]
center_col = import_XRD.center_col[i]
row_tick = import_XRD.row_tick[i]
col_tick = import_XRD.col_tick[i]
if rotate == 90:
data = np.rot90(data, k=1, axes=(0, 1))
nrow = import_XRD.ncol[i]
ncol = import_XRD.nrow[i]
center_row = import_XRD.center_col[i]
center_col = import_XRD.center_row[i]
row_tick = import_XRD.col_tick[i]
col_tick = import_XRD.row_tick[i]
if rotate == 180:
data = np.rot90(data, k=2, axes=(0, 1))
nrow = import_XRD.nrow[i]
ncol = import_XRD.ncol[i]
center_row = import_XRD.center_row[i]
center_col = import_XRD.center_col[i]
row_tick = import_XRD.row_tick[i]
col_tick = import_XRD.col_tick[i]
if rotate == 270:
data = np.rot90(data, k=3, axes=(0, 1))
nrow = import_XRD.ncol[i]
ncol = import_XRD.nrow[i]
center_row = import_XRD.center_col[i]
center_col = import_XRD.center_row[i]
row_tick = import_XRD.col_tick[i]
col_tick = import_XRD.row_tick[i]
if flip == 1:
data = np.flip(data, axis=0)
if flip == 2:
data = np.flip(data, axis=1)
f.write("Phi=" + str(import_XRD.phi[i]) + "\n")
f.write("Chi=" + str(import_XRD.chi[i]) + "\n")
f.write("Omega=" + str(import_XRD.omega[i]) + "\n")
f.write("2theta=" + str(import_XRD.twotheta_center[i]) + "\n")
f.write("Wavelength=" + str(import_XRD.k_alpha[i]) + "\n")
f.write("Distance=" + str(import_XRD.distance[i]) + "\n")
f.write("------------------------------------------\n")
f.write("NRow=" + str(nrow) + "\n")
f.write("Center Row=" + str(center_row) + "\n")
for j in range(nrow):
f.write(str(row_tick[j]) + " ")
f.write("\n")
f.write("NCol=" + str(ncol) + "\n")
f.write("Center Col=" + str(center_col) + "\n")
for j in range(ncol):
f.write(str(col_tick[j]) + " ")
f.write("\n")
f.write("------------------------------------------\n")
f.write("------------------------------------------\n")
progress["value"] = progress["value"] + 1
progress.update()
for i in range(nrow):
f.write(" ".join(str(e) for e in data[i]))
if i < nrow - 1:
f.write("\n")
f.close()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
main.root.mainloop()
class MainFrame(Frame):
''' This class implements main GUI of the application.
Attributes:
parent (Tk object): parent of this frame (Tk()).
params_frame (ParamsFrame): frame with parameters.
data_frame (DataFrame): frame with data and solution.
progress_bar (Progressbar): progress bar widget.
increment (int): progress bar increment, it is modified
in other classes that are responsible for solving
the problem and update progress.
weights_status_lbl (Label): label that displays if weight
restrictions are feasible.
weights_status_str (StringVar): StringVar object used for
tracking if weight restrictions are feasible.
current_categories (list of str): list of current categories.
Args:
parent (Tk object): parent of this frame (Tk()).
'''
def __init__(self, parent, *args, **kwargs):
Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
self.params_frame = None
self.data_frame = None
self.progress_bar = None
self.increment = 0
self.weights_status_lbl = None
self.weights_status_str = StringVar()
self.weights_status_str.trace('w', self.on_weights_status_change)
self.current_categories = []
self.create_widgets()
def create_widgets(self):
''' Creates all widgets that belong to this frame.
'''
self.parent.title('pyDEA')
self.pack(fill=BOTH, expand=1)
self.columnconfigure(0, weight=1, pad=5)
self.columnconfigure(1, weight=0, pad=5)
self.rowconfigure(0, pad=3, weight=1)
self.rowconfigure(1, pad=3)
self.rowconfigure(2, pad=3)
self.rowconfigure(3, pad=3)
self.current_categories = []
data_from_params_file = StringVar()
str_var_for_input_output_boxes = ObserverStringVar()
self.params_frame = ParamsFrame(self, self.current_categories,
data_from_params_file,
str_var_for_input_output_boxes,
self.weights_status_str)
data_frame = DataFrame(self, self.params_frame,
self.current_categories, data_from_params_file,
str_var_for_input_output_boxes)
self.data_frame = data_frame
data_frame.grid(row=0,
column=0,
sticky=N + S + W + E,
padx=15,
pady=15)
self.params_frame.grid(row=0,
column=1,
sticky=W + E + S + N,
padx=15,
pady=15,
columnspan=2)
lbl_progress = Label(self, text='Progress')
lbl_progress.grid(row=1, column=0, sticky=W, padx=10, pady=5)
self.progress_bar = Progressbar(self, mode='determinate', maximum=100)
self.progress_bar.grid(row=2, column=0, sticky=W + E, padx=10, pady=5)
run_btn = Button(self, text='Run', command=self.run)
run_btn.grid(row=2, column=1, sticky=W, padx=10, pady=10)
self.weights_status_lbl = Label(self, text='', foreground='red')
self.weights_status_lbl.grid(row=2,
column=2,
padx=10,
pady=5,
sticky=W)
def on_weights_status_change(self, *args):
''' This method is called when weight restrictions status is changed.
'''
self.weights_status_lbl.config(text=self.weights_status_str.get())
def run(self):
''' This method is called when the user presses Run button.
Solves the problem and displays solution.
'''
clean_up_pickled_files()
params = self.params_frame.params
run_method = RunMethodGUI(self)
run_method.run(params)
def construct_categories(self):
''' Returns current categories.
Returns:
(list of str): list of current categories
'''
return [
category.strip() for category in self.current_categories
if category
]
def on_dmu_change(self, *args):
''' Updates progress bar.
'''
self.progress_bar.step(self.increment)
self.progress_bar.update()
class Application(Frame):
def __init__(self, master=None, *args, **kwargs):
"""
urls - text
output_dir - dir picker
limit - num field
format - select
tree - checkbox
debug - checkbox
"""
super().__init__(master, *args, **kwargs)
self.root = master
self.grid(padx=20, pady=20)
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.url = StringVar()
self.output_dir = StringVar(value=HOME_DIR)
self.format = StringVar()
self.playlist_name = StringVar()
self.index = StringVar(value='0')
self.limit = StringVar(value='50')
self.use_tree = StringVar(value='1')
self.slugify = StringVar(value='0')
self.logs_var = StringVar(value='foo')
self.should_stop = False
self.download_btn: Button = None
self.stop_btn: Button = None
self.info_label: Label = None
self.error_label: Label = None
self.progress: Progressbar = None
list_params_frame = Frame(self, width=400)
output_dir_frame = Frame(self, width=400)
misc_frame = Frame(self, width=400)
download_frame = Frame(self, width=400)
self.set_list_params_frame(list_params_frame)
self.set_output_dir_frame(output_dir_frame)
self.set_misc_frame(misc_frame)
self.set_download_frame(download_frame)
list_params_frame.grid(row=0, pady=(0, 20), sticky='ew')
output_dir_frame.grid(row=1, pady=(0, 20), sticky='ew')
misc_frame.grid(row=2, pady=(0, 20), sticky='ew')
download_frame.grid(row=3, sticky='ew')
def set_list_params_frame(self, frame: Frame):
label = Label(
frame,
text='Deezer URL of playlist, artist, album or user profile',
font='Helvetica 14 bold')
label.grid(row=0, column=0, sticky='w')
list_id_entry = Entry(frame, textvariable=self.url, width=50)
list_id_entry.focus_set()
list_id_entry.grid(row=1, column=0, sticky='ew', columnspan=5)
def set_output_dir_frame(self, frame: Frame):
label = Label(frame, text='Output dir', font='Helvetica 14 bold')
label.grid(row=0, column=0, sticky='w')
output_dir = Entry(frame, textvariable=self.output_dir, width=50)
output_dir.grid(row=1, column=0, sticky='ew', columnspan=5)
output_dir_btn = Button(frame,
text="pick directory",
command=self.browse_button)
output_dir_btn.grid(row=2, column=0, sticky='ew', columnspan=5)
def set_misc_frame(self, frame: Frame):
def validate_int(value: str, acttyp: str):
if acttyp == '1': # insert
try:
int(value)
return True
except ValueError:
return False
return True
playlist_lbl = Label(frame, text='Playlist name')
playlist_lbl.grid(row=0, column=0, sticky='w')
playlist_inp = Entry(frame, textvariable=self.playlist_name)
playlist_inp.grid(row=0, column=1, sticky='ew', columnspan=5)
index_label = Label(frame, text='Start index')
index_label.grid(row=1, column=0, sticky='w')
index_entry = Entry(frame, textvariable=self.index, validate="key")
index_entry['validatecommand'] = (index_entry.register(validate_int),
'%P', '%d')
index_entry.grid(row=1, column=1, sticky='w')
limit_label = Label(frame, text='Load limit')
limit_label.grid(row=2, column=0, sticky='w')
limit_entry = Entry(frame, textvariable=self.limit, validate="key")
limit_entry['validatecommand'] = (limit_entry.register(validate_int),
'%P', '%d')
limit_entry.grid(row=2, column=1, sticky='w')
format_label = Label(frame, text='Audio format')
format_label.grid(row=3, column=0, sticky='w')
format_options = ('mp3', 'flac')
self.format.set(format_options[0])
format_menu = OptionMenu(frame, self.format, *format_options)
format_menu.grid(row=3, column=1, sticky='w')
tree_checkbox = Checkbutton(
frame,
text="save as tree (artist / album / song)",
onvalue='1',
offvalue='0',
variable=self.use_tree)
tree_checkbox.grid(row=4, column=0, sticky='w', columnspan=2)
slugify_checkbox = Checkbutton(frame,
text="slugify",
onvalue='1',
offvalue='0',
variable=self.slugify)
slugify_checkbox.grid(row=5, column=0, sticky='w', columnspan=2)
def set_download_frame(self, frame: Frame):
self.download_btn = Button(frame,
text='Download',
width=24,
command=self.download_click)
self.download_btn.grid(row=0, sticky='ew')
self.stop_btn = Button(frame,
text='Stop',
width=24,
command=self.stop_work,
state=DISABLED)
self.stop_btn.grid(row=0, column=1, sticky='ew')
self.progress = Progressbar(frame,
orient="horizontal",
value=0,
style="red.Horizontal.TProgressbar")
self.progress.grid(row=1, sticky='ew', columnspan=2)
self.info_label = Label(frame, font='Helvetica 14 bold')
self.info_label.grid(row=2, sticky='ew', columnspan=2, pady=5)
self.error_label = Label(frame, font='Helvetica 14 bold', fg='red')
self.error_label.grid(row=3, sticky='ew', columnspan=2, pady=5)
def browse_button(self):
filename = filedialog.askdirectory()
if filename:
self.output_dir.set(filename)
def download_click(self):
self.download_btn.configure(state=DISABLED)
self.stop_btn.configure(state=NORMAL)
threading.Thread(target=self.download).start()
def stop_work(self):
self.should_stop = True
self.show_error('waiting for one last song to load before stop...')
self.stop_btn.configure(state=DISABLED)
def show_msg(self, msg: str):
self.info_label.config(text=msg)
self.info_label.update()
def show_error(self, msg: str):
self.error_label.config(text=msg)
self.error_label.update()
def set_progress(self, val: int):
self.progress['value'] = val
self.progress.update()
def download(self):
try:
self.show_error('')
self.show_msg('loading tracks...')
loader = Loader(
urls=self.url.get(),
output_dir=self.output_dir.get(),
index=int(self.index.get()),
limit=int(self.limit.get()),
format=self.format.get(),
tree=self.use_tree.get() == '1',
playlist_name=self.playlist_name.get(),
slugify=self.slugify.get() == '1',
)
self.set_progress(0)
self.output_dir.set(loader.output_dir)
self.update()
loaded, skipped, failed = 0, 0, 0
for status, track, i, prog in loader.load_gen():
num = f'{i + 1}/{len(loader)}'
if status == LoadStatus.STARTING:
self.show_msg(f"{num} - init")
elif status == LoadStatus.SEARCHING:
self.show_msg(f"{num} - searching for video")
elif status == LoadStatus.LOADING:
self.show_msg(f"{num} - loading video")
elif status == LoadStatus.MOVING:
self.show_msg(f"{num} - moving file")
elif status == LoadStatus.RESTORING_META:
self.show_msg(f"{num} - restoring audio meta data")
elif status == LoadStatus.SKIPPED:
skipped += 1
elif status == LoadStatus.FAILED:
failed += 1
elif status == LoadStatus.FINISHED:
loaded += 1
logger.debug('loaded track %s', track)
elif status == LoadStatus.ERROR:
self.show_error('something went horribly wrong')
self.set_progress(int((i + prog) / len(loader) * 100))
if self.should_stop and status in LoadStatus.finite_states():
break
self.set_progress(100)
self.show_msg(
f"DONE. loaded: {loaded}, skipped: {skipped}, failed: {failed}"
)
except Exception as e:
logger.exception(e)
self.show_msg('')
self.show_error(str(e))
finally:
self.download_btn.configure(state=NORMAL)
self.stop_btn.configure(state=DISABLED)
self.should_stop = False
class Trainer(Frame):
def __init__(self, master=None, **kw):
Frame.__init__(self, master, **kw)
self.background = '#303030'
self.border_color = '#404040'
self.args = {
"data_dir": "",
"prepared_data": "processed_data",
"field": list(FIELDS.keys())[0],
"batch_size": 4
}
self.textboxes = {}
self.thread = None
self.running = False
self._init_ui()
def _init_ui(self):
ws = self.master.winfo_screenwidth()
hs = self.master.winfo_screenheight()
h = hs - 100
w = int(h / 1.414) + 100
x = (ws / 2) - (w / 2)
y = (hs / 2) - (h / 2)
self.master.geometry('%dx%d+%d+%d' % (w, h, x, y))
self.master.maxsize(w, h)
self.master.minsize(w, h)
self.master.title("InvoiceNet - Trainer")
self.pack(fill=BOTH, expand=True)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=0)
self.rowconfigure(1, weight=1)
self.rowconfigure(2, weight=0)
self.rowconfigure(3, weight=1)
self.configure(bg=self.background, bd=0)
logo_frame = Frame(self,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=1)
param_frame = Frame(self,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=1)
progress_frame = Frame(self,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
main_frame = Frame(self,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=1)
logo_frame.grid(row=0, column=0, sticky='news')
param_frame.grid(row=1, column=0, sticky='news')
progress_frame.grid(row=2,
column=0,
sticky='news',
padx=50,
pady=(0, 20))
main_frame.grid(row=3, column=0, sticky='news')
# Logo Frame
logo_frame.columnconfigure(0, weight=1)
logo_frame.columnconfigure(1, weight=0)
logo_frame.columnconfigure(2, weight=0)
logo_frame.columnconfigure(3, weight=1)
logo_frame.rowconfigure(0, weight=1)
self.logo_img = ImageTk.PhotoImage(Image.open(r'widgets/logo.png'))
Label(logo_frame, bg=self.background,
image=self.logo_img).grid(row=0,
column=1,
sticky='news',
pady=10)
Label(logo_frame,
text="InvoiceNet",
bg=self.background,
fg="white",
font=("Arial", 24, "bold")).grid(row=0,
column=2,
sticky='news',
padx=20,
pady=10)
# Param Frame
param_frame.columnconfigure(0, weight=1)
param_frame.columnconfigure(1, weight=0)
param_frame.columnconfigure(2, weight=0)
param_frame.columnconfigure(3, weight=1)
param_frame.rowconfigure(0, weight=1)
param_frame.rowconfigure(1, weight=0)
param_frame.rowconfigure(2, weight=0)
param_frame.rowconfigure(3, weight=0)
param_frame.rowconfigure(4, weight=1)
data_param = Frame(param_frame,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
out_param = Frame(param_frame,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
field_param = Frame(param_frame,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
batch_param = Frame(param_frame,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
data_param.grid(row=1, column=1, pady=(0, 20), padx=20)
out_param.grid(row=2, column=1, pady=20, padx=20)
field_param.grid(row=1, column=2, pady=(0, 20), padx=20)
batch_param.grid(row=2, column=2, pady=20, padx=20)
df = Frame(data_param,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
df.pack(side=TOP, fill=BOTH)
Label(df,
text="Data Folder:",
bg=self.background,
fg="white",
font=("Arial", 8, "bold"),
anchor='w').pack(side=LEFT, fill=BOTH)
HoverButton(df,
image_path=r'widgets/open_dir_small.png',
command=lambda: self._open_dir("data_dir"),
width=18,
height=18,
bg=self.background,
bd=0,
highlightthickness=0,
activebackground='#558de8').pack(side=RIGHT)
self.textboxes["data_dir"] = Text(data_param, height=1, width=20)
self.textboxes["data_dir"].insert('1.0', self.args["data_dir"])
self.textboxes["data_dir"].pack(side=BOTTOM)
of = Frame(out_param,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
of.pack(side=TOP, fill=BOTH)
Label(of,
text="Processed Data Folder:",
bg=self.background,
anchor='w',
fg="white",
font=("Arial", 8, "bold")).pack(side=LEFT, fill=BOTH)
HoverButton(of,
image_path=r'widgets/open_dir_small.png',
command=lambda: self._open_dir("prepared_data"),
width=18,
height=18,
bg=self.background,
bd=0,
highlightthickness=0,
activebackground='#558de8').pack(side=RIGHT)
self.textboxes["prepared_data"] = Text(out_param, height=1, width=20)
self.textboxes["prepared_data"].insert('1.0',
self.args["prepared_data"])
self.textboxes["prepared_data"].pack(side=BOTTOM)
Label(field_param,
text="Field:",
bg=self.background,
anchor='w',
fg="white",
font=("Arial", 8, "bold")).pack(side=TOP, fill=BOTH)
self.field_text = StringVar(field_param)
self.field_text.set(list(FIELDS.keys())[0])
keys = list(FIELDS.keys())
field_list = OptionMenu(field_param, self.field_text, *keys)
field_list.configure(highlightthickness=0, width=20, bg='#ffffff')
field_list.pack(side=BOTTOM)
for key in keys:
field_list['menu'].entryconfigure(key, state="normal")
Label(batch_param,
text="Batch Size:",
bg=self.background,
anchor='w',
fg="white",
font=("Arial", 8, "bold")).pack(side=TOP, fill=BOTH)
self.batch_text = StringVar(batch_param)
self.batch_text.set("4")
batch_list = OptionMenu(batch_param, self.batch_text,
*[str(2**i) for i in range(8)])
batch_list.configure(highlightthickness=0, width=20, bg='#ffffff')
batch_list.pack(side=BOTTOM)
HoverButton(param_frame,
image_path=r'widgets/prepare.png',
command=self._prepare_data,
text='Prepare Data',
compound='center',
font=("Arial", 10, "bold"),
bg=self.background,
bd=0,
highlightthickness=0,
activebackground=self.background).grid(row=3,
column=1,
columnspan=2,
padx=20,
pady=(20, 0),
sticky='news')
# Progress Frame
self.progress_label = Label(progress_frame,
text="Preparing data:",
bg=self.background,
anchor='w',
fg="white",
font=("Arial", 8, "bold"),
bd=0,
highlightthickness=0)
self.progress_label.pack(side=TOP, expand=True, fill=X, pady=(10, 5))
self.progressbar = Progressbar(progress_frame,
orient=HORIZONTAL,
length=100,
mode='determinate')
self.progressbar.pack(side=BOTTOM, expand=True, fill=X)
# Main Frame
main_frame.columnconfigure(0, weight=1)
main_frame.rowconfigure(0, weight=1)
main_frame.rowconfigure(1, weight=1)
button_frame = Frame(main_frame,
bg=self.background,
bd=0,
relief=SUNKEN,
highlightbackground=self.border_color,
highlightthickness=0)
button_frame.grid(row=0, column=0, sticky='news')
button_frame.rowconfigure(0, weight=1)
button_frame.columnconfigure(0, weight=1)
button_frame.columnconfigure(1, weight=0)
button_frame.columnconfigure(2, weight=1)
self.start_button = HoverButton(button_frame,
image_path=r'widgets/begin.png',
command=self._start,
text='Start',
compound='center',
font=("Arial", 10, "bold"),
bg=self.background,
bd=0,
highlightthickness=0,
activebackground=self.background)
self.stop_button = HoverButton(button_frame,
image_path=r'widgets/stop.png',
command=self._stop,
text='Stop',
compound='center',
font=("Arial", 10, "bold"),
bg=self.background,
bd=0,
highlightthickness=0,
activebackground=self.background)
self.start_button.grid(row=0, column=1)
self.stop_button.grid(row=0, column=1)
self.stop_button.grid_forget()
self.logger = Logger(main_frame,
height=18,
bg=self.background,
bd=0,
relief=SUNKEN)
self.logger.grid(row=1, column=0, sticky='news')
def _train(self):
train_data = InvoiceData.create_dataset(
field=self.args["field"],
data_dir=os.path.join(self.args["prepared_data"], 'train/'),
batch_size=self.args["batch_size"])
val_data = InvoiceData.create_dataset(
field=self.args["field"],
data_dir=os.path.join(self.args["prepared_data"], 'val/'),
batch_size=self.args["batch_size"])
restore = None
if os.path.exists(
os.path.join('./models/invoicenet/', self.args["field"])):
restore = messagebox.askyesno(
title="Restore",
message=
"A checkpoint was found! Do you want to restore checkpoint for training?"
)
restore = True if restore else False
model = AttendCopyParse(field=self.args["field"], restore=restore)
print_interval = 20
early_stop_steps = 0
best = float("inf")
train_iter = iter(train_data)
val_iter = iter(val_data)
self.logger.log("Initializing training!")
start = time.time()
step = 0
while True:
train_loss = model.train_step(next(train_iter))
if not np.isfinite(train_loss):
raise ValueError("NaN loss")
if step % print_interval == 0:
took = time.time() - start
val_loss = model.val_step(next(val_iter))
self.logger.log(
"[step: %d | %.2f steps/s]: train loss: %.4f val loss: %.4f"
% (step, (step + 1) / took, train_loss, val_loss))
if not np.isfinite(val_loss):
self.logger.log("ERROR: NaN loss")
self.thread.stop()
if val_loss < best:
early_stop_steps = 0
best = val_loss
model.save("best")
else:
early_stop_steps += print_interval
if early_stop_steps >= 500:
self.logger.log(
"Validation loss has not improved for 500 steps")
self.thread.stop()
step += 1
if self.thread.stopped():
self.logger.log("Training terminated!")
break
self.running = False
self.stop_button.grid_forget()
self.start_button.grid(row=0, column=1)
def _get_inputs(self):
self.args["field"] = self.field_text.get()
self.args["batch_size"] = int(self.batch_text.get())
self.args["data_dir"] = self.textboxes["data_dir"].get("1.0", 'end-1c')
self.args["prepared_data"] = self.textboxes["prepared_data"].get(
"1.0", 'end-1c')
if not self.args["prepared_data"].endswith('/'):
self.args["prepared_data"] += '/'
if self.args["data_dir"] == '':
return
if not self.args["data_dir"].endswith('/'):
self.args["data_dir"] += '/'
def _start(self):
self._get_inputs()
if not os.path.exists(self.args["prepared_data"]):
messagebox.showerror("Error",
"Prepared data folder does not exist!")
return
files = glob.glob(self.args["prepared_data"] + "**/*.json",
recursive=True)
if not files:
messagebox.showerror(
"Error",
"Could not find processed data in \"{}\". Did you prepare training data?"
.format(self.args["prepared_data"]))
return
if not self.running:
self.running = True
self.thread = StoppableThread(target=self._train)
self.thread.daemon = True
self.thread.start()
self.start_button.grid_forget()
self.stop_button.grid(row=0, column=1)
def _stop(self):
if self.running:
self.thread.stop()
self.running = False
self.logger.log("Stopping training...")
def _open_dir(self, key):
dir_name = filedialog.askdirectory(
initialdir='.', title="Select Directory Containing Invoices")
if not dir_name:
return
self.args[key] = dir_name
self.textboxes[key].delete('1.0', END)
self.textboxes[key].insert('1.0', self.args[key])
def _prepare_data(self):
self._get_inputs()
if self.args["data_dir"] == '':
messagebox.showerror("Error", "Data folder does not exist!")
return
if not os.path.exists(self.args["data_dir"]):
messagebox.showerror("Error", "Data folder does not exist!")
return
self.progressbar["value"] = 0
self.progress_label.configure(text="Preparing Data:")
os.makedirs(os.path.join(self.args["prepared_data"], 'train'),
exist_ok=True)
os.makedirs(os.path.join(self.args["prepared_data"], 'val'),
exist_ok=True)
filenames = [
os.path.abspath(f)
for f in glob.glob(self.args["data_dir"] + "**/*.pdf",
recursive=True)
]
random.shuffle(filenames)
idx = int(len(filenames) * 0.2)
train_files = filenames[idx:]
val_files = filenames[:idx]
self.logger.log("Total: {}".format(len(filenames)))
self.logger.log("Training: {}".format(len(train_files)))
self.logger.log("Validation: {}".format(len(val_files)))
total_samples = len(filenames)
sample_idx = 0
for phase, filenames in [('train', train_files), ('val', val_files)]:
self.logger.log("Preparing {} data...".format(phase))
for filename in tqdm(filenames):
# try:
page = pdf2image.convert_from_path(filename)[0]
page.save(
os.path.join(self.args["prepared_data"], phase,
os.path.basename(filename)[:-3] + 'png'))
height = page.size[1]
width = page.size[0]
ngrams = util.create_ngrams(page)
for ngram in ngrams:
if "amount" in ngram["parses"]:
ngram["parses"]["amount"] = util.normalize(
ngram["parses"]["amount"], key="amount")
if "date" in ngram["parses"]:
ngram["parses"]["date"] = util.normalize(
ngram["parses"]["date"], key="date")
with open(filename[:-3] + 'json', 'r') as fp:
labels = simplejson.loads(fp.read())
fields = {}
for field in FIELDS:
if field in labels:
if FIELDS[field] == FIELD_TYPES["amount"]:
fields[field] = util.normalize(labels[field],
key="amount")
elif FIELDS[field] == FIELD_TYPES["date"]:
fields[field] = util.normalize(labels[field],
key="date")
else:
fields[field] = labels[field]
else:
fields[field] = ''
data = {
"fields":
fields,
"nGrams":
ngrams,
"height":
height,
"width":
width,
"filename":
os.path.abspath(
os.path.join(self.args["prepared_data"], phase,
os.path.basename(filename)[:-3] + 'png'))
}
with open(
os.path.join(self.args["prepared_data"], phase,
os.path.basename(filename)[:-3] + 'json'),
'w') as fp:
fp.write(simplejson.dumps(data, indent=2))
# except Exception as exp:
# self.logger.log("Skipping {} : {}".format(filename, exp))
sample_idx += 1
self.progress_label.configure(
text="Preparing data [{}/{}]:".format(
sample_idx, total_samples))
self.progressbar["value"] = (sample_idx / total_samples) * 100
self.progressbar.update()
self.progress_label.configure(text="Completed!")
self.progressbar["value"] = 100
self.progressbar.update()
self.logger.log("Prepared data stored in '{}'".format(
self.args["prepared_data"]))
class App(object):
def __init__(self, object):
self.path = StringVar()
self.progress = StringVar()
self.frame1 = Frame(object)
self.frame1.pack()
self.frame2 = Frame(object)
self.frame2.pack()
self.frame3 = Frame(object)
self.frame3.pack()
self.label_path = Label(self.frame1, text="目标路径：")
self.label_path.pack(padx=2, pady=2, side=LEFT)
self.entry_path = Label(self.frame1, width=34, relief=GROOVE, textvariable=self.path)
self.entry_path.pack(padx=2, pady=2, side=LEFT)
self.btn_select = Button(self.frame1, text="路径选择", height=1, command=self.select)
self.btn_select.pack(padx=2, pady=2, side=LEFT)
self.label_url = Label(self.frame2, text="输入链接：")
self.label_url.pack(padx=2, pady=2, side=LEFT)
self.txt_url = Entry(self.frame2, width=34)
self.txt_url.pack(padx=2, pady=2, side=LEFT)
self.btn_download = Button(self.frame2, text="立即下载", command=self.download)
self.btn_download.pack(padx=2, pady=2, side=LEFT)
self.label_progress = Label(self.frame3, text="当前进度：")
self.label_progress.pack(padx=2, pady=2, side=LEFT)
self.bar = Progressbar(self.frame3, length=242)
self.bar.pack(padx=2, pady=2, side=LEFT, fill=X)
self.bar['value'] = 0
self.label = Label(self.frame3, textvariable=self.progress, width=8)
self.label.pack(padx=2, pady=2, side=LEFT)
# 设置进度条
def set_progress(self, value):
self.bar['value'] = value
self.bar.update()
# 显示路径
def set_label_path(self, strs):
self.path.set(strs)
# 当前下载进度 ，形式为 xx/x, 如10/20
def set_progress_text(self, strs):
self.progress.set(strs)
# 选择文件路径
def select(self):
path_ = filedialog.askdirectory()
self.set_label_path(path_)
# 开始下载
def download(self):
self.set_progress(0)
url = self.txt_url.get()
if url == '':
messagebox.showinfo("提醒", "链接不能为空！")
elif self.path.get() == '':
messagebox.showinfo("提醒", "路径不能为空！")
else:
html = self.get_html_page(url)
items = self.parse_page(html)
self.save_picture(items)
messagebox.showinfo("Title", "下载完成！")
def get_html_page(self, url):
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36'
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
return response.text
else:
return None
def parse_page(self, html):
pattern = re.compile('<img [^>]*data-src="([^>]+?)wx_fmt=(.+?)"[^>]*?>', re.S)
# pattern = re.compile('<img.*?>', re.S)
items = re.findall(pattern, str(html))
for item in items:
if item[1] == "other":
items.remove(item)
return items
def save_picture(self, items):
num = 0
length = len(items)
for item in items:
pic = requests.get(item[0])
# 以当前时间为前缀
currentTime = strftime("%Y%m%d%H%M%S", localtime())
with open(self.path.get() + '/' + currentTime + str(num) + '.' + item[1], 'wb') as file:
file.write(pic.content)
self.set_progress((num + 1) / length *100)
pro = str(num + 1) + '/'+str(length)
self.set_progress_text(pro)
num = num + 1
def export_original_data(nfile, nimage, nimage_i, import_XRD, main):
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".xlf",
filetypes=[('X-Light format', '.xlf'),
('all files', '.*')])
if f is not None and f is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = 3
f_split = (import_XRD.file_link[nfile]).split("/")
filename = f_split[len(f_split) - 1]
rotate = import_XRD.rotate
flip = import_XRD.flip
progress["value"] = progress["value"] + 1
progress.update()
data = read_data_2D(nimage, import_XRD)
if len(data.shape) == 3:
data = data[nimage_i]
if len(data) == 0:
showinfo(title="Warning",
message="Can not read data of " + str(filename))
return
progress["value"] = progress["value"] + 1
progress.update()
if rotate == 0:
nrow = import_XRD.nrow[nimage]
ncol = import_XRD.ncol[nimage]
center_row = import_XRD.center_row[nimage]
center_col = import_XRD.center_col[nimage]
row_tick = import_XRD.row_tick[nimage]
col_tick = import_XRD.col_tick[nimage]
if rotate == 90:
data = np.rot90(data, k=1, axes=(0, 1))
nrow = import_XRD.ncol[nimage]
ncol = import_XRD.nrow[nimage]
center_row = import_XRD.center_col[nimage]
center_col = import_XRD.center_row[nimage]
row_tick = import_XRD.col_tick[nimage]
col_tick = import_XRD.row_tick[nimage]
if rotate == 180:
data = np.rot90(data, k=2, axes=(0, 1))
nrow = import_XRD.nrow[nimage]
ncol = import_XRD.ncol[nimage]
center_row = import_XRD.center_row[nimage]
center_col = import_XRD.center_col[nimage]
row_tick = import_XRD.row_tick[nimage]
col_tick = import_XRD.col_tick[nimage]
if rotate == 270:
data = np.rot90(data, k=3, axes=(0, 1))
nrow = import_XRD.ncol[nimage]
ncol = import_XRD.nrow[nimage]
center_row = import_XRD.center_col[nimage]
center_col = import_XRD.center_row[nimage]
row_tick = import_XRD.col_tick[nimage]
col_tick = import_XRD.row_tick[nimage]
if flip == 1:
data = np.flip(data, axis=0)
if flip == 2:
data = np.flip(data, axis=1)
f.write("Phi=" + str(import_XRD.phi[nimage]) + "\n")
f.write("Chi=" + str(import_XRD.chi[nimage]) + "\n")
f.write("Omega=" + str(import_XRD.omega[nimage]) + "\n")
f.write("2theta=" + str(import_XRD.twotheta_center[nimage]) + "\n")
f.write("Wavelength=" + str(import_XRD.k_alpha[nimage]) + "\n")
f.write("Distance=" + str(import_XRD.distance[nimage]) + "\n")
f.write("------------------------------------------\n")
f.write("NRow=" + str(nrow) + "\n")
f.write("Center Row=" + str(center_row) + "\n")
for i in range(nrow):
f.write(str(row_tick[i]) + " ")
f.write("\n")
f.write("NCol=" + str(ncol) + "\n")
f.write("Center Col=" + str(center_col) + "\n")
for i in range(ncol):
f.write(str(col_tick[i]) + " ")
f.write("\n")
f.write("------------------------------------------\n")
f.write("------------------------------------------\n")
progress["value"] = progress["value"] + 1
progress.update()
for i in range(nrow):
f.write(" ".join(str(e) for e in data[i]))
if i < nrow - 1:
f.write("\n")
progress["value"] = progress["value"] + 1
progress.update()
f.close()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
main.root.mainloop()
def export_all_fit_data(main_calcul, main):
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".txt",
filetypes=[('text files', '.txt'), ('all files', '.*')])
if f is not None and f is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(main_calcul.phi)
for i in range(len(main_calcul.peaks_position)):
progress["value"] = progress["value"] + 1
progress.update()
f.write("Range " + str(i + 1) + "\n")
f.write("Phi=" + str(float(main_calcul.phi[i])) + "\n")
f.write("Psi=" + str(float(main_calcul.chi[i])) + "\n")
f.write("Omega=" + str(float(main_calcul.omega[i])) + "\n")
f.write("a=" + str(main_calcul.a[i]) + "\n")
f.write("r=" + str(main_calcul.r[i]) + "\n")
f.write("pic 2 theta: " + str(main_calcul.peaks_position[i]) +
"\n")
f.write("\n")
f.write(" twotheta\t")
f.write(" original\t")
f.write("background\t")
f.write("substrat_background\t")
f.write(" kalpha1\t")
f.write(" kalpha2\t")
f.write("fitting_pearson_vii\t")
f.write("\n")
for j in range(len(main_calcul.data_x_limit[i])):
try:
f.write(
str("%10.4g" % main_calcul.data_x_limit[i][j]) + "\t")
f.write(
str("%10.4g" % main_calcul.data_y_limit[i][j]) + "\t")
f.write(
str("%10.4g" %
main_calcul.data_y_background_fit[i][j]) + "\t")
f.write(
str("%19.4g" % main_calcul.data_y_net[i][j]) + "\t")
f.write(
str("%10.4g" % main_calcul.data_y_k1_fit[i][j]) + "\t")
f.write(
str("%10.4g" % main_calcul.data_y_k2_fit[i][j]) + "\t")
f.write(
str("%19.4g" % main_calcul.data_y_fit_total[i][j]) +
"\t")
f.write("\n")
except (IndexError, ValueError):
pass
f.write(
"--------------------------------------------------------------\n"
)
f.write("\n")
f.close()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
main.root.mainloop()
def export_all_calib_data(calib_2D, angles_modif, import_XRD, main):
from residual_stress_2D.calib_XRD_2D import calib_pyFai
location = askdirectory(title="Please choose a directory")
if location is not None and location is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(import_XRD.nfile)
rotate = import_XRD.rotate
flip = import_XRD.flip
for i in range(len(import_XRD.nfile)):
progress["value"] = progress["value"] + 1
progress.update()
f_split = (import_XRD.file_link[import_XRD.nfile[i]]).split("/")
filename = f_split[len(f_split) - 1]
name = str(location) + '/calib_' + str(
filename.split('.')[0]) + '_' + str(
import_XRD.nimage_i[i]) + '.xlf'
f = open(name, 'w')
if calib_2D.angles_modif_valid == True:
twotheta_x = angles_modif.twotheta_x
gamma_y = angles_modif.gamma_y
phi = angles_modif.phi[i]
chi = angles_modif.chi[i]
omega = angles_modif.omega[i]
twotheta_center = angles_modif.twotheta_center[i]
else:
twotheta_x = calib_2D.twotheta_x
gamma_y = calib_2D.gamma_y
phi = calib_2D.phi[i]
chi = calib_2D.chi[i]
omega = calib_2D.omega[i]
twotheta_center = calib_2D.twotheta_center[i]
data = read_data_2D(i, import_XRD)
if len(data.shape) == 3:
data = data[import_XRD.nimage_i[i]]
if len(data) == 0:
showinfo(title="Warning",
message="Can not read data of " + str(filename))
return
if rotate == 0:
nrow = import_XRD.nrow[i]
ncol = import_XRD.ncol[i]
center_row = import_XRD.center_row[i]
center_col = import_XRD.center_col[i]
if rotate == 90:
data = np.rot90(data, k=1, axes=(0, 1))
nrow = import_XRD.ncol[i]
ncol = import_XRD.nrow[i]
center_row = import_XRD.center_col[i]
center_col = import_XRD.center_row[i]
if rotate == 180:
data = np.rot90(data, k=2, axes=(0, 1))
nrow = import_XRD.nrow[i]
ncol = import_XRD.ncol[i]
center_row = import_XRD.center_row[i]
center_col = import_XRD.center_col[i]
if rotate == 270:
data = np.rot90(data, k=3, axes=(0, 1))
nrow = import_XRD.ncol[i]
ncol = import_XRD.nrow[i]
center_row = import_XRD.center_col[i]
center_col = import_XRD.center_row[i]
if flip == 1:
data = np.flip(data, axis=0)
if flip == 2:
data = np.flip(data, axis=1)
calib = calib_pyFai(import_XRD, data, nrow, ncol, center_row,
center_col, twotheta_center)
if len(calib) > 0:
data = calib[0]
else:
showinfo(title="Warning",
message="Can not calib file " + str(filename))
return
if float(calib_2D.Check_twotheta_flip.get()) == 1:
data = np.flip(data, axis=1)
if len(data) > 0:
progress["value"] = progress["value"] + 1
progress.update()
data = calib[0]
nrow = len(gamma_y)
ncol = len(twotheta_x)
f.write("Phi=" + str(phi) + "\n")
f.write("Chi=" + str(chi) + "\n")
f.write("Omega=" + str(omega) + "\n")
f.write("2theta=" + str(twotheta_center) + "\n")
f.write("Wavelength=" + str(import_XRD.k_alpha[i]) + "\n")
f.write("Distance=" + str(import_XRD.distance[i]) + "\n")
f.write("------------------------------------------\n")
f.write("NRow=" + str(nrow) + "\n")
f.write("Center Row=" + str(center_row) + "\n")
for j in range(nrow):
f.write(str(gamma_y[j]) + " ")
f.write("\n")
f.write("NCol=" + str(ncol) + "\n")
f.write("Center Col=" + str(center_col) + "\n")
for j in range(ncol):
f.write(str(twotheta_x[j]) + " ")
f.write("\n")
f.write("------------------------------------------\n")
f.write("------------------------------------------\n")
progress["value"] = progress["value"] + 1
progress.update()
for i in range(nrow):
f.write(" ".join(str(e) for e in data[i]))
f.write("\n")
f.close()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
main.root.mainloop()
def export_all_fitting_graphs(calcul_1D, analyze_1D, run_program):
location = askdirectory(title="Please choose a directory")
if location is not None and location is not '':
for widget in analyze_1D.Frame1_2.winfo_children():
widget.destroy()
Label(analyze_1D.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(analyze_1D.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(calcul_1D.phi)
for i in range(len(calcul_1D.phi)):
progress["value"] = progress["value"] + 1
progress.update()
try:
x = [
calcul_1D.two_theta_pearson[i],
calcul_1D.two_theta_pearson[i]
]
y = [
min(calcul_1D.matrix_real_intensity[i]),
max(calcul_1D.matrix_intensity_limit[i])
]
fig = plt.figure(figsize=(10, 10), dpi=100)
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_intensity_limit[i],
label='original')
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_background_intensity[i],
label='background')
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_real_intensity[i],
label='substrat background')
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F1_peak1[i],
label='k alpha 1')
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F2_peak1[i],
label='k alpha 2')
if len(calcul_1D.peaks) >= 2:
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F1_peak2[i])
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F2_peak2[i])
if len(calcul_1D.peaks) == 3:
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F1_peak3[i])
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F2_peak3[i])
plt.plot(calcul_1D.matrix_two_theta_limit[i],
calcul_1D.matrix_F_pearson[i],
label='fitting pearson vii')
plt.plot(x,
y,
label=r"$2\theta_{0}$"
"=" + str(calcul_1D.two_theta_pearson[i]) + "")
plt.xlabel(r"$2\theta$")
plt.ylabel("Intensity")
plt.title("phi=" + str(float(calcul_1D.phi[i])) + "; psi=" +
str(float(calcul_1D.psi[i])) + "")
plt.legend(loc='upper left',
bbox_to_anchor=(-0.1, -0.2, 1.2, 0),
ncol=3,
mode="expand",
borderaxespad=0.,
fontsize='x-small')
plt.subplots_adjust(bottom=0.3)
except (IndexError, ValueError):
plt.close(fig)
else:
plt.savefig(str(location) + "/fitting_phi=" +
str(float(calcul_1D.phi[i])) + "_psi=" +
str(float(calcul_1D.psi[i])) + ".png",
bbox_inches="tight")
plt.close(fig)
for widget in analyze_1D.Frame1_2.winfo_children():
widget.destroy()
run_program.fenetre.mainloop()
def export_all_stress_data(calib_2D, main_calcul, stress_calcul, main):
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".text",
filetypes=[('text files', '.txt'), ('all files', '.*')])
if f is not None and f is not '':
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(main.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(main_calcul.phi) + 2
if stress_calcul.stress_valid >= 1:
f.write("SIN2PSI METHOD\n")
for i in range(len(stress_calcul.liste_phi)):
f.write("Phi= " + str(stress_calcul.liste_phi[i]) + "°")
f.write("Linear fit: " + "sigma= " +
str(stress_calcul.sigma_phi_linear[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_linear[i]) + "MPa" +
"\n")
f.write("Elliptic fit: " + "sigma= " +
str(stress_calcul.sigma_phi_elliptic[i]) + "+/-" +
str(stress_calcul.error_sigma_phi_elliptic[i]) +
"MPa" + "\n")
f.write("Elliptic fit: " + "shear= " +
str(stress_calcul.shear_phi_elliptic[i]) + "+/-" +
str(stress_calcul.error_shear_phi_elliptic[i]) +
"MPa" + "\n")
f.write("-------------------\n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
progress["value"] = progress["value"] + 1
progress.update()
f.write("FUNDAMENTAL METHOD \n")
if len(stress_calcul.liste_phi
) >= 1 and stress_calcul.length_strain == 3:
f.write("---Biaxial stress----- \n")
f.write('sigma 11 = ' + str(stress_calcul.tensor_biaxial[0][0]) +
"+/-" + str(stress_calcul.tensor_biaxial[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' + str(stress_calcul.tensor_biaxial[0][1]) +
"+/-" + str(stress_calcul.tensor_biaxial[1][1, 1]**0.5) +
"MPa" + "\n")
f.write("---------------------- \n")
if len(stress_calcul.liste_phi
) >= 1 and stress_calcul.length_strain == 4:
f.write("---Biaxial stress----- \n")
f.write('sigma 11 = ' + str(stress_calcul.tensor_biaxial[0][0]) +
"+/-" + str(stress_calcul.tensor_biaxial[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' + str(stress_calcul.tensor_biaxial[0][2]) +
"+/-" + str(stress_calcul.tensor_biaxial[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_biaxial[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial[1][1, 1]**0.5) + "MPa" +
"\n")
f.write("---------------------- \n")
if len(stress_calcul.liste_phi
) >= 1 and stress_calcul.length_strain == 5:
f.write("---Biaxial+shear stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_shear[0][0]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_shear[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][1, 1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_biaxial_shear[0][2]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_biaxial_shear[0][3]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][3, 3]**0.5) +
"MPa" + "\n")
f.write("---------------------- \n")
if len(stress_calcul.liste_phi
) >= 1 and stress_calcul.length_strain >= 6:
f.write("---Biaxial+shear stress----- \n")
f.write('sigma 11 = ' +
str(stress_calcul.tensor_biaxial_shear[0][0]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' +
str(stress_calcul.tensor_biaxial_shear[0][2]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 12 = ' +
str(stress_calcul.tensor_biaxial_shear[0][1]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][1, 1]**0.5) +
"MPa" + "\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_biaxial_shear[0][3]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][3, 3]**0.5) +
"MPa" + "\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_biaxial_shear[0][4]) + "+/-" +
str(stress_calcul.tensor_biaxial_shear[1][4, 4]**0.5) +
"MPa" + "\n")
f.write("---------------------- \n")
if len(stress_calcul.liste_phi
) >= 1 and stress_calcul.length_strain >= 6:
f.write("---Triaxial stress----- \n")
f.write('sigma 11 = ' + str(stress_calcul.tensor_triaxial[0][0]) +
"+/-" + str(stress_calcul.tensor_triaxial[1][0, 0]**0.5) +
"MPa" + "\n")
f.write('sigma 22 = ' + str(stress_calcul.tensor_triaxial[0][2]) +
"+/-" + str(stress_calcul.tensor_triaxial[1][2, 2]**0.5) +
"MPa" + "\n")
f.write('sigma 12 = sigma 21 = ' +
str(stress_calcul.tensor_triaxial[0][1]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][1, 1]**0.5) + "MPa" +
"\n")
f.write('sigma 13 = sigma 31 = ' +
str(stress_calcul.tensor_triaxial[0][3]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][3, 3]**0.5) + "MPa" +
"\n")
f.write('sigma 23 = sigma 32 = ' +
str(stress_calcul.tensor_triaxial[0][4]) + "+/-" +
str(stress_calcul.tensor_triaxial[1][4, 4]**0.5) + "MPa" +
"\n")
f.write('sigma 33 = ' + str(stress_calcul.tensor_triaxial[0][5]) +
"+/-" + str(stress_calcul.tensor_triaxial[1][5, 5]**0.5) +
"MPa" + "\n")
f.write("---------------------- \n")
f.write("---------------------------------------------------- \n")
f.write("---------------------------------------------------- \n")
f.write(
"phi(°) psi(°) omega(°) gamma(°) peak_2theta(°) phi_gamma(°) psi_gamma(°)\n"
)
for i in range(len(main_calcul.phi)):
progress["value"] = progress["value"] + 1
progress.update()
for j in range(main_calcul.gamma_number):
gamma_range = int(main_calcul.gamma_f_index +
j * main_calcul.gamma_step +
main_calcul.gamma_step / 2)
try:
f.write(str("%3.4g" % main_calcul.phi[i]))
f.write(str("%10.4g" % main_calcul.chi[i]))
f.write(str("%12.4g" % main_calcul.omega[i]))
f.write(str("%15.4g" % main_calcul.gamma_y[gamma_range]))
f.write(
str("%15.4g" % main_calcul.peaks_position[
i * main_calcul.gamma_number + j]))
f.write(
str("%15.4g" % stress_calcul.phi_regroup[
i * main_calcul.gamma_number + j]))
f.write(
str("%15.4g" % stress_calcul.psi_regroup[
i * main_calcul.gamma_number + j]))
except TypeError:
pass
f.write("\n")
f.close()
for widget in main.Frame1_2.winfo_children():
widget.destroy()
main.root.mainloop()
def export_all_stress_graphs(stress_calcul, analyze_1D, run_program):
location = askdirectory(title="Please choose a directory")
if location is not None and location is not '':
for widget in analyze_1D.Frame1_2.winfo_children():
widget.destroy()
Label(analyze_1D.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(analyze_1D.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(stress_calcul.liste_phi)
for i in range(len(stress_calcul.liste_phi)):
progress["value"] = progress["value"] + 1
progress.update()
fig = plt.figure(figsize=(10, 10), dpi=100)
ax = fig.add_subplot(111)
plt.plot(stress_calcul.matrix_sin_psi_i_2[i],
stress_calcul.matrix_displacement[i],
'ro',
label='Experimental')
for j in range(len(stress_calcul.matrix_psi_i[i])):
plt.annotate(str("%0.1f" % stress_calcul.matrix_psi_i[i][j]),
xy=(stress_calcul.matrix_sin_psi_i_2[i][j],
stress_calcul.matrix_displacement[i][j]))
if stress_calcul.stress_valid >= 1:
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.matrix_F_linear[i],
'b',
label='Linear fit')
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.matrix_F_elliptic[i],
'k',
label='Eliptic fit')
if stress_calcul.stress_valid == 1:
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[0],
stress_calcul.e_uniaxial,
'm',
label='Uniaxial')
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[0],
stress_calcul.e_uniaxial_shear,
'y',
label='Uniaxial+shear')
if stress_calcul.sigma12_valid == False and stress_calcul.stress_valid >= 2:
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.e_biaxial_simple[i],
'm',
label='Biaxial')
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.e_biaxial_simple_shear[i],
'y',
label='Biaxial+shear')
if stress_calcul.sigma12_valid == True:
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.e_biaxial[i],
'm',
label='Biaxial')
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.e_biaxial_shear[i],
'y',
label='Biaxial+shear')
if stress_calcul.stress_valid >= 3:
plt.plot(stress_calcul.matrix_sin_psi_i_2_sorted[i],
stress_calcul.e_triaxial[i],
'r',
label='Triaxial')
plt.xlabel(r"$sin^{2}\psi$")
plt.ylabel('Strain')
plt.title("phi=" + str(stress_calcul.liste_phi[i]) + "")
plt.legend(loc='upper left',
bbox_to_anchor=(0.0, -0.3, 1, 0),
ncol=3,
mode="expand",
borderaxespad=0.,
fontsize='x-small')
plt.subplots_adjust(bottom=0.4)
plt.savefig(str(location) + "/stress_phi=" +
str(float(stress_calcul.liste_phi[i])) + ".png",
bbox_inches="tight")
plt.close()
for widget in analyze_1D.Frame1_2.winfo_children():
widget.destroy()
run_program.fenetre.mainloop()
def export_all_fitting_data_2D(calcul_2D, calib_2D, analyze_2D, run_program):
f = asksaveasfile(title="Export data",
mode='w',
defaultextension=".text",
filetypes=[('text files', '.txt'), ('all files', '.*')])
if f is not None and f is not '':
for widget in analyze_2D.Frame1_2.winfo_children():
widget.destroy()
Label(analyze_2D.Frame1_2, text="Export").pack(side=LEFT)
progress = Progressbar(analyze_2D.Frame1_2,
orient="horizontal",
mode='determinate')
progress.pack(side=LEFT)
progress["value"] = 0
progress["maximum"] = len(calcul_2D.phi) * calcul_2D.gamma_number_step
for i in range(len(calcul_2D.phi)):
for j in range(calcul_2D.gamma_number_step):
progress["value"] = progress["value"] + 1
progress.update()
f.write("phi=" + str(calcul_2D.phi[i]) + "\n")
f.write("psi=" + str(calcul_2D.psi[i]) + "\n")
f.write("peak=" + str(calcul_2D.all_two_theta_pearson[
i * calcul_2D.gamma_number_step + j]) + " +/- " +
str(calcul_2D.all_error_two_theta_pearson[
i * calcul_2D.gamma_number_step + j]) + "\n")
f.write("peak width=" + str(calcul_2D.all_peak_width[
i * calcul_2D.gamma_number_step + j]) + " +/- " +
str(calcul_2D.all_error_peak_width[
i * calcul_2D.gamma_number_step + j]) + "\n")
f.write("peak intensity=" +
str(calcul_2D.all_I_max[i * calcul_2D.gamma_number_step
+ j]) + " +/- " +
str(calcul_2D.all_error_I_max[
i * calcul_2D.gamma_number_step + j]) + "\n")
f.write("gamma integrate from " + str(
int(calcul_2D.gamma_i[int(
calcul_2D.gamma_from + j * calcul_2D.gamma_stepline -
calcul_2D.gamma_stepline / 2)])) + "° to " + str(
int(calcul_2D.gamma_i[
int(calcul_2D.gamma_from +
j * calcul_2D.gamma_stepline +
calcul_2D.gamma_stepline / 2)])) + "\n")
f.write(" two_theta\t")
f.write("instensity\t")
f.write("background\t")
f.write("substrat_background\t")
f.write(" kalpha1\t")
f.write(" kalpha2\t")
f.write("fitting_pearson_vii\t")
f.write("\n")
for m in range(len(calcul_2D.two_theta_limit)):
try:
f.write(str(calcul_2D.two_theta_limit[m]) + "\t")
f.write(
str(calcul_2D.all_matrix_intensity[i][j][m]) +
"\t")
f.write(
str(calcul_2D.all_matrix_background_intensity[i][j]
[m]) + "\t")
f.write(
str(calcul_2D.all_matrix_real_intensity[i][j][m]) +
"\t")
f.write(
str(calcul_2D.all_matrix_F1_peak1[i][j][m]) + "\t")
f.write(
str(calcul_2D.all_matrix_F2_peak1[i][j][m]) + "\t")
f.write(
str(calcul_2D.all_matrix_F_pearson[i][j][m]) +
"\t")
f.write("\n")
except (IndexError, ValueError):
pass
f.write("--------------------------------------\n")
f.write("--------------------------------------\n")
f.close()
for widget in analyze_2D.Frame1_2.winfo_children():
widget.destroy()
run_program.fenetre.mainloop()
class BatchEditTopLevel(tk.Toplevel):
def __init__(self, master=None, cnf={}, **kw):
super(BatchEditTopLevel, self).__init__(master=master, cnf={}, **kw)
self.resizable(width=False, height=False)
self.initialize()
def get_source_format_selected(self):
source_format_selected = [
chk_btn.cget("text").lower()
for chk_btn, state in self.source_format_list
if state.get() == True
]
return source_format_selected
def initialize(self):
# Source format Checkbox list
self.source_format_list = []
self.frame_source_format = tk.LabelFrame(self, text="Source formats")
self.frame_source_format.pack(side=tk.TOP, fill=tk.BOTH)
# Tuple list to save btn widget & the checkbox state variable
for idx, filetype in enumerate(OPEN_FILETYPES[1:]):
checkbox_state = tk.IntVar()
self.source_format_list.append((
tk.Checkbutton(
self.frame_source_format,
text=filetype[1][1:].upper(),
variable=checkbox_state,
onvalue=True,
offvalue=False,
),
checkbox_state,
))
self.source_format_list[idx][0].pack(side=tk.LEFT)
# Setting default input format
self.source_format_list[0][0].toggle()
# Destination Format Option Menu
self.frame_destination_format = tk.Frame(self)
self.frame_destination_format.pack(side=tk.TOP, fill=tk.X)
tk.Label(self.frame_destination_format,
text="Destination format:").pack(side=tk.LEFT)
self.dest_format = tk.StringVar(self)
self.dest_format.set(SAVE_EXT_LIST[0].upper())
self.dest_menu = tk.OptionMenu(
self.frame_destination_format,
self.dest_format,
*[fmt.upper() for fmt in SAVE_EXT_LIST],
)
self.dest_menu.pack(side=tk.LEFT)
tk.Button(
self.frame_destination_format,
text="Process Batch Edit",
command=self._root().batch_edit,
).pack(side=tk.LEFT)
def _select_folder(folder_path, Event=None):
folder_path.set(filedialog.askdirectory(initialdir=os.curdir))
self.focus()
def widget_entry_template(
frame,
label,
starting_value="",
entry_width=60,
label_width=len("Destination folder:"),
):
entry_frame = tk.Frame(frame)
entry_frame.pack(side=tk.TOP, fill=tk.X)
tk.Label(entry_frame, text=label, width=label_width,
anchor=tk.W).pack(side=tk.LEFT)
entry_frame.entry_value = tk.StringVar(value=starting_value)
entry_path = tk.Entry(
entry_frame,
textvariable=entry_frame.entry_value,
width=60,
exportselection=0,
)
entry_path.pack(side=tk.LEFT)
tk.Button(
entry_frame,
text="...",
command=lambda: (_select_folder(entry_frame.entry_value)),
).pack(side=tk.LEFT)
return entry_frame
self.frame_batch_src_path = widget_entry_template(
self, "Source folder:")
self.frame_batch_dest_path = widget_entry_template(
self, "Destination folder:")
self.frame_progress_bar = tk.LabelFrame(self,
relief=tk.RIDGE,
bd=2,
text="Awaiting process")
self.frame_progress_bar.pack(side=tk.TOP, fill=tk.BOTH)
self.progress_bar = Progressbar(
self.frame_progress_bar,
orient=HORIZONTAL,
length=self.cget("width"),
mode="determinate",
)
self.progress_bar.pack(side=tk.LEFT)
def update_progress_bar_label(self, current: int):
max = self.progress_bar["maximum"]
self.progress_bar["value"] = current
self.frame_progress_bar.configure(
text=f"Completed {current}/{max} file(s)")
self.progress_bar.update()
def tableBox1(self):
while self.filenameQueue:
if self.__ButtonState:
paths = self.filenameQueue[0]
if not os.path.exists(paths[1]):
sourceFilename = os.path.split(paths[0])[1]
destFilename = os.path.split(paths[1])[1]
maximumValue = os.path.getsize(paths[0])
#print(maximumValue)
row = Frame(self.__veriticalScrollFrame.interior)
sourceLab = Label(row, text=r'..\%s\%s' %(self.currentDate, sourceFilename), relief='sunken', width=30)
destLab = Label(row, text=r'..\%s\%s' %(self.currentDate, destFilename), relief='sunken', width=30)
oprtnProgress = Progressbar(row, orient='horizontal', length=250, maximum=maximumValue, mode='determinate', value=0)
row.pack(side='top', expand='yes', fill='both')
sourceLab.pack(side='left', expand='yes', fill='both')
destLab.pack(side='left', expand='yes', fill='both')
oprtnProgress.pack(side='left', expand='yes', fill='both')
"""
updateQueueValue = Queue()
copying_in_thread = Thread(target=self.copyingFiles, args=(maximumValue, paths[0], paths[1], updateQueueValue))
copying_in_thread.start()
while True:
time.sleep(0.25)
if not updateQueueValue.empty():
value = updateQueueValue.get()
print(value)
oprtnProgress['value'] = value
oprtnProgress.update()
else:
print('job done')
break
updateQueueValue.task_done()
copying_in_thread.join()
"""
updateValue = self.chunkSize
with open(paths[0], 'rb') as fileFrom:
with open(paths[1], 'wb') as fileTo:
for _ in range(int(ceil(maximumValue//self.chunkSize)+1)):
bytesForm = fileFrom.read(self.chunkSize)
if bytesForm:
fileTo.write(bytesForm)
oprtnProgress['value'] = updateValue
oprtnProgress.update()
updateValue = updateValue+self.chunkSize
self.update()
self.filenameQueue.remove(paths)
else:
self.filenameQueue.remove(paths)
else:
print('operation Interrupted')
break
else:
self.after(3000, self.tableBox1)
class Application:
def __init__(self, master=None):
self.fontePadrao = ("Arial", "12")
self.primeiroContainer = Frame(master)
self.primeiroContainer["pady"] = 20
self.primeiroContainer.pack()
self.segundoContainer = Frame(master)
self.segundoContainer["padx"] = 20
self.segundoContainer.pack()
self.terceiroContainer = Frame(master)
self.terceiroContainer["padx"] = 20
self.terceiroContainer.pack()
self.quartoContainer = Frame(master)
self.quartoContainer["pady"] = 20
self.quartoContainer.pack()
self.quintoContainer = Frame(master)
self.quintoContainer["pady"] = 20
self.quintoContainer.pack()
self.sextoContainer = Frame(master)
self.sextoContainer["pady"] = 20
self.sextoContainer.pack()
self.titulo = Label(self.primeiroContainer, text="Gerador de código")
self.titulo["font"] = ("Arial", "14", "bold")
self.titulo.pack()
self.barcode_type = Label(self.segundoContainer,
text="Tipo barcode",
font=self.fontePadrao)
self.barcode_type.pack(side=LEFT)
self.barcode_type = Entry(self.segundoContainer)
self.barcode_type["width"] = 10
self.barcode_type["font"] = ("Calibri", "12")
self.barcode_type.pack(side=LEFT)
self.includetext = Label(self.segundoContainer,
text="Incluir Texto",
font=self.fontePadrao)
self.includetext.pack(side=LEFT)
self.includetext = Entry(self.segundoContainer)
self.includetext["width"] = 10
self.includetext["font"] = ("Calibri", "12")
self.includetext.pack(side=RIGHT)
self.pathfileLabel = Label(self.terceiroContainer,
text="Local (*csv)",
font=self.fontePadrao)
self.pathfileLabel.pack(side=LEFT)
self.pathfile = Entry(self.terceiroContainer)
self.pathfile["width"] = 50
self.pathfile["font"] = ("Calibri", "12")
self.pathfile.pack(side=LEFT)
self.search_path_file = Button(self.terceiroContainer)
self.search_path_file["text"] = "Localizar Arquivo"
self.search_path_file["width"] = 15
self.search_path_file["command"] = self.open_explore_file
self.search_path_file["fg"] = "black"
self.search_path_file.pack(side=RIGHT, padx=10, pady=10)
self.pathsaveLabel = Label(self.quartoContainer,
text="Local salvar",
font=self.fontePadrao)
self.pathsaveLabel.pack(side=LEFT)
self.pathsave = Entry(self.quartoContainer)
self.pathsave["width"] = 50
self.pathsave["font"] = ("Calibri", "12")
self.pathsave.pack(side=LEFT)
self.search_path_dir = Button(self.quartoContainer)
self.search_path_dir["text"] = "Localizar diretorio"
self.search_path_dir["width"] = 15
self.search_path_dir["command"] = self.open_explore_dir
self.search_path_dir.pack(side=RIGHT, padx=10, pady=10)
self.generator = Button(self.quintoContainer)
self.generator["text"] = "Executar"
self.generator["font"] = ("Calibri", "12")
self.generator["fg"] = "white"
self.generator["width"] = 20
self.generator["bg"] = "blue"
self.generator["command"] = self.create_code
self.generator.pack()
# self.mensagem = Label(self.sextoContainer, text="")
# self.mensagem["font"] = ("Calibri", "12", "italic")
# self.mensagem.pack()
self.progress = Progressbar(self.sextoContainer,
orient="horizontal",
maximum=100,
mode="determinate")
def open_explore_file(self):
filename = askopenfilename()
self.pathfile.delete(0, END)
self.pathfile.insert(0, filename)
def open_explore_dir(self):
directory = askdirectory()
self.pathsave.delete(0, END)
self.pathsave.insert(0, directory)
def progress_bar(self, current_value, count_lines):
percent = (current_value * 100) / count_lines
self.progress["value"] = percent
self.progress.update()
def count_lines(self, file):
return sum(1 for row in open(file)) - 1
def check_file(self, local_save, diretorio):
full_path = f'{local_save}/{diretorio}'
if not os.path.exists(full_path):
return False
return True
def create_code(self):
self.progress.pack(side=TOP, ipadx=100)
file = self.pathfile.get()
local_save = self.pathsave.get()
code = self.barcode_type.get()
text = True if self.includetext.get() == 'S' or self.includetext.get(
) == 's' else False
count_lines = self.count_lines(file)
current_value = 1
try:
with open(file, 'r', encoding='utf-8') as kit:
file = csv.reader(kit, delimiter=';', quotechar=';')
next(file)
for row in file:
dir_exist = self.check_file(local_save, row[2])
if not dir_exist:
os.mkdir(f'{local_save}/{row[2]}')
image = treepoem.generate_barcode(
barcode_type=code,
data=row[0],
options={"includetext": text})
image.convert('1').save(
f'{local_save}/{row[2]}/{row[1]}.png')
current_value += 1
self.progress.after(
1000,
self.progress_bar(current_value=current_value,
count_lines=count_lines))
kit.close()
messagebox.showinfo("Sucesso", "Códigos gerados!")
root.quit()
except Exception as e:
messagebox.showerror("Erro", str(e))
class import_XRD:
def __init__(self,main):
try:
self.process(main)
except Exception as e:
showinfo(title="Warning",message=str(e)+"\n"+"\n"+str(traceback.format_exc()))
return
#else:
#angles_modif.__init__(angles_modif,main)
main.root.mainloop()
def process(self,main):
format_='*.gfrm;*.edf;*.tif;*.tiff;*.npy;*.cbf;*.mccd;*.xlf;*.nxs;*.raw;*.gfrm;*.EDF;*.TIF;*.TIFF;*.NPY;*.CBF;*.MCCD;*.XLF;*.NXS;*.RAW'
f = askopenfilenames(parent=main.root,title="Open file",filetypes=[('all supported format',format_),('all files','.*')])
self.file_link = main.root.tk.splitlist(f) #list of file link, 1 dimensional list
if len(self.file_link)>0:
self.import_image_header(main) #read image header
if len(self.phi)>0:
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.destroy_widget(main) #reset all frame (see frame list in fonction)
self.graphic_frame3_1(main) #graphical representation
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.attribute_graphic_frame3_2(main) #reset button in list (see in fonction)
for widget in main.Frame1_2.winfo_children():
widget.destroy()
pack_Frame_2D(main,1)
def import_image_header(self,main):
for widget in main.Frame1_2.winfo_children():
widget.destroy()
Label(main.Frame1_2,text="Import").pack(side=LEFT)
self.progress = Progressbar(main.Frame1_2,orient="horizontal",mode='determinate')
self.progress.pack(side=LEFT)
self.progress["value"] = 0
self.progress["maximum"] = len(self.file_link)+2
#-----------------find and affiche list phi, chi--------------------------------------
self.filename=[] #list of file name, 1 dimensional list
self.phi=[] #list of phi, 1 dimensional list
self.chi=[] #list of chi, 1 dimensional list
self.omega=[] #list of omega, 1 dimensional list
self.twotheta_center=[] #list of twotheta center, 1 dimensional list
self.k_alpha=[] #list of phi, 2 dimensional list: self.kalpha=[[kalpha1,kalpha2],[kalpha1,kalpha2],...]; kalpha1, kalpha2 are float
self.nrow=[] #list of number of row, 1 dimensional list
self.ncol=[] #list of number of column, 1 dimensional list
self.row_tick=[] #list of number of row tick, 2 dimensional list: self.row_tick=[[row_tick],[row_tick],....]; with len(row_tick)=nrow
self.col_tick=[] #list of number of column tick, 2 dimensional list: self.col_tick=[[col_tick],[col_tick],....]; with len(col_tick)=ncol
self.center_row=[] #list of detector center in row, 1 dimensional list
self.center_col=[] #list of detector center in column, 1 dimensional list
self.distance=[] #list of distance from detector to sample, 1 dimensional list
self.nfile=[] #list index of number of file of image, 1 dimensional list
self.nimage_i=[] #list index of number of image in one file, 1 dimensional list
self.nimage=[] #list index of number of image in total, 1 dimensional list
self.file_info=[] #list of header information of image, 2 dimensional list: self.file_info=[[header_info],[header_info],....]
self.image=-1 #index of image
self.dtyp='uint32' #for raw image
self.sep='' #for raw image
for i in range(len(self.file_link)):
self.progress["value"] = self.progress["value"]+1
self.progress.update()
self.i=i
self.f=self.file_link[i] #take file link
f_split=self.f.split("/")
self.filename.append(f_split[len(f_split)-1]) #take filename
read_header_2D(i,self) #read image header with all the information above (phi, chi....), see \read_file\image_2D\read_image_2D
def destroy_widget(self,main):
for widget in main.Frame3_1_1.winfo_children():
widget.destroy()
for widget in main.Frame3_1_2.winfo_children():
widget.destroy()
for widget in main.Frame3_1_3_1.winfo_children():
widget.destroy()
for widget in main.Frame3_1_3_2.winfo_children():
widget.destroy()
for widget in main.Frame3_1_4.winfo_children():
widget.destroy()
#for widget in main.Frame3_2_1_1.winfo_children():
#widget.destroy()
#for widget in main.Frame3_2_1_2.winfo_children():
#widget.destroy()
for widget in main.Frame3_2_2.winfo_children():
widget.destroy()
for widget in main.Frame3_2_3.winfo_children():
widget.destroy()
for widget in main.Frame3_2_4.winfo_children():
widget.destroy()
for widget in main.Frame3_3_1.winfo_children():
widget.destroy()
#for widget in main.Frame3_3_2_1.winfo_children():
#widget.destroy()
#for widget in main.Frame3_3_2_2.winfo_children():
#widget.destroy()
for widget in main.Frame3_3_3.winfo_children():
widget.destroy()
#for widget in main.Frame3_4_1.winfo_children():
#widget.destroy()
#for widget in main.Frame3_4_2.winfo_children():
#widget.destroy()
#for widget in main.Frame3_4_3.winfo_children():
#widget.destroy()
for widget in main.Frame3_4_4_1_1.winfo_children():
widget.destroy()
for widget in main.Frame3_4_4_1_2.winfo_children():
widget.destroy()
for widget in main.Frame3_4_4_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_3_3.winfo_children():
widget.destroy()
for widget in main.Frame3_5_4_1.winfo_children():
widget.destroy()
for widget in main.Frame3_5_4_2.winfo_children():
widget.destroy()
for widget in main.Frame3_5_4_3.winfo_children():
widget.destroy()
for widget in main.Frame3_6_1.winfo_children():
widget.destroy()
for widget in main.Frame3_6_2_1.winfo_children():
widget.destroy()
for widget in main.Frame3_6_2_2.winfo_children():
widget.destroy()
for widget in main.Frame3_6_2_3.winfo_children():
widget.destroy()
for widget in main.Frame3_6_3_1.winfo_children():
widget.destroy()
for widget in main.Frame3_6_3_2.winfo_children():
widget.destroy()
for widget in main.Frame3_6_3_3.winfo_children():
widget.destroy()
for widget in main.Frame3_7_1.winfo_children():
widget.destroy()
for widget in main.Frame3_7_2.winfo_children():
widget.destroy()
for widget in main.Frame3_7_3.winfo_children():
widget.destroy()
for widget in main.Frame3_8_1.winfo_children():
widget.destroy()
for widget in main.Frame3_8_2.winfo_children():
widget.destroy()
def graphic_frame3_1(self,main):
Label(main.Frame3_1_3_2, text="Image legend",bg="white").grid(row=0,column=0)
Label(main.Frame3_1_3_2, text="from").grid(row=1,column=0)
self.legend_from_entry = Entry(main.Frame3_1_3_2,width=6)
self.legend_from_entry.grid(row=2,column=0)
Label(main.Frame3_1_3_2, text="to").grid(row=3,column=0)
self.legend_to_entry = Entry(main.Frame3_1_3_2,width=6)
self.legend_to_entry.grid(row=4,column=0)
#Images color
self.cmap_var=StringVar()
Radiobutton(main.Frame3_1_3_2, text="hot", variable=self.cmap_var, value="hot").grid(row=5,column=0,sticky=W)
Radiobutton(main.Frame3_1_3_2, text="cool", variable=self.cmap_var, value="GnBu").grid(row=6,column=0,sticky=W)
Radiobutton(main.Frame3_1_3_2, text="gray", variable=self.cmap_var, value="gray").grid(row=7,column=0,sticky=W)
Radiobutton(main.Frame3_1_3_2, text="nipy", variable=self.cmap_var, value="nipy_spectral").grid(row=8,column=0,sticky=W)
self.cmap_var.set("hot")
#images list
scrollbar = Scrollbar(main.Frame3_1_1)
scrollbar.pack(side = RIGHT, fill=Y)
mylist= Listbox(main.Frame3_1_1, yscrollcommand = scrollbar.set)
mylist.pack(side = LEFT, fill = BOTH,expand=YES)
for i in range(len(self.phi)):
mylist.insert(END, str(i+1)+u'. \u03C6='+str(self.phi[i])+" ; "+u'\u03C7='+str(self.chi[i])+u"; \u03C9="+str(float(self.omega[i]))+
' (.'+str(self.nfile[i]+1)+'.'+str(self.nimage_i[i]+1)+'.)')
self.rotate=0 #init ratation value
self.flip=0 #init flip value
mylist.bind("<ButtonRelease-1>", lambda event: show_original_image(event,self,main))
scrollbar.config(command = mylist.yview)
#----------------affiche the first image valide---------------------------------------
data=read_data_2D_1(0,self,main) #read image data
data_dim=len(data.shape) #image dimension
if data_dim==2:
self.intensity_2D=data
elif data_dim==3:
self.intensity_2D=data[0]
else:
self.intensity_2D=[]
self.legend_from_entry.insert(0,0)
self.legend_to_entry.insert(0,max(map(max, self.intensity_2D)))
#plot image on frame
fig=plt.figure(1,facecolor="0.94")
plt.imshow(self.intensity_2D,cmap="hot",origin='lower')
plt.title(u'\u03C6='+str(float(self.phi[0]))+" ; "+u'\u03C7='+str(float(self.chi[0]))+u"; \u03C9="+str(float(self.omega[0])))
nrow=self.nrow[0]
ncol=self.ncol[0]
plt.yticks((1,nrow*0.25,nrow*0.5,nrow*0.75,nrow), ('%0.1f' % self.row_tick[0][0],
'%0.1f' % self.row_tick[0][int(nrow*0.25)],
'%0.1f' % self.row_tick[0][int(nrow*0.5)],
'%0.1f' % self.row_tick[0][int(nrow*0.75)],
'%0.1f' % self.row_tick[0][int(nrow-1)]))
plt.xticks((1,ncol*0.25,ncol*0.5,ncol*0.75,ncol), ('%0.1f' % self.col_tick[0][0],
'%0.1f' % self.col_tick[0][int(ncol*0.25)],
'%0.1f' % self.col_tick[0][int(ncol*0.5)],
'%0.1f' % self.col_tick[0][int(ncol*0.75)],
'%0.1f' % self.col_tick[0][int(ncol-1)]))
plt.xlabel("pixel")
plt.ylabel("pixel")
plt.colorbar( cax=plt.axes([0.9, 0.45, 0.02, 0.4]) )
plt.close()
canvas = FigureCanvasTkAgg(fig, main.Frame3_1_2)
canvas.get_tk_widget().pack(fill=BOTH, expand=YES)
Button(main.Frame3_1_3_1,compound=CENTER, text="Original",bg="white",command=lambda:rotate_0(self,main)).pack()
Button(main.Frame3_1_3_1,compound=CENTER, text="Rotate +90°",bg="white",command=lambda:rotate_270(self,main)).pack()
Button(main.Frame3_1_3_1,compound=CENTER, text="Rotate -90°",bg="white",command=lambda:rotate_90(self,main)).pack()
Button(main.Frame3_1_3_1,compound=CENTER, text="Rotate +180°",bg="white",command=lambda:rotate_180(self,main)).pack()
Button(main.Frame3_1_3_1,compound=CENTER, text="Flip horizontal",bg="white",command=lambda:flip_horizontal(self,main)).pack()
Button(main.Frame3_1_3_1,compound=CENTER, text="Flip vertical",bg="white",command=lambda:flip_vertical(self,main)).pack()
scrollbar = Scrollbar(main.Frame3_1_4)
scrollbar.pack(side = RIGHT, fill=BOTH)
mylist = Listbox(main.Frame3_1_4, yscrollcommand = scrollbar.set)
for i in range(len(self.file_info[0])):
mylist.insert(END,str(self.file_info[0][i]))
mylist.pack(side = LEFT, fill=BOTH,expand=YES)
scrollbar.config( command = mylist.yview )
#----------Frame3_2-------------------------------------------------------------------------
def graphic_frame3_2(self,main):
Label(main.Frame3_2_1_1, text="PONI PARAMETERS", bg="white").grid(row=0,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Pixel size 1 (m)").grid(row=1,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Pixel size 2 (m)").grid(row=2,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Distance (m)").grid(row=3,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Poni 1 (m)").grid(row=4,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Poni 2 (m)").grid(row=5,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Rotation 1 (radians)").grid(row=6,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Rotation 2 (radians)").grid(row=7,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Rotation 3 (radians)").grid(row=8,column=0,sticky=W)
Label(main.Frame3_2_1_1, text="Wavelength (m)").grid(row=9,column=0,sticky=W)
self.Entry_pixel_1 = Entry(main.Frame3_2_1_1)
self.Entry_pixel_2 = Entry(main.Frame3_2_1_1)
self.Entry_distance_calib = Entry(main.Frame3_2_1_1)
self.Entry_poni_1 = Entry(main.Frame3_2_1_1)
self.Entry_poni_2 = Entry(main.Frame3_2_1_1)
self.Entry_rot_1 = Entry(main.Frame3_2_1_1)
self.Entry_rot_2 = Entry(main.Frame3_2_1_1)
self.Entry_rot_3 = Entry(main.Frame3_2_1_1)
self.Entry_wl_calib = Entry(main.Frame3_2_1_1)
self.Entry_pixel_1.grid(row=1, column=1,sticky=W)
self.Entry_pixel_2.grid(row=2, column=1,sticky=W)
self.Entry_distance_calib.grid(row=3, column=1,sticky=W)
self.Entry_poni_1.grid(row=4, column=1,sticky=W)
self.Entry_poni_2.grid(row=5, column=1,sticky=W)
self.Entry_rot_1.grid(row=6, column=1,sticky=W)
self.Entry_rot_2.grid(row=7, column=1,sticky=W)
self.Entry_rot_3.grid(row=8, column=1,sticky=W)
self.Entry_wl_calib.grid(row=9, column=1,sticky=W)
Label(main.Frame3_2_1_1, text="2\u03B8 direction in original images").grid(row=10,column=0,sticky=W)
self.direction_2theta=IntVar()
Radiobutton(main.Frame3_2_1_1, text="horizontal", variable=self.direction_2theta, value=1).grid(row=10,column=1,sticky=W)
Radiobutton(main.Frame3_2_1_1, text="vertical", variable=self.direction_2theta, value=2).grid(row=10,column=2,sticky=W)
self.direction_2theta.set(1)
Button(main.Frame3_2_1_1,compound=CENTER, text="PONI definition",bg="white",command=definition_poni).grid(row=11,column=0,sticky=W)
Button(main.Frame3_2_1_1,compound=CENTER, text="Import poni parameters",bg="white",command=lambda:import_poni_parameters(self,main)).grid(row=0,column=1,sticky=W)
self.button_run_calib=Button(main.Frame3_2_1_1,compound=CENTER, text="RUN CALIBRATION",bg="white",command=lambda:None)
self.button_run_calib.grid(row=0,column=2,sticky=W)
Button(main.Frame3_2_1_1,compound=CENTER, text="Create PONI parameters",bg="white",command=lambda:pyFAI_calib()).grid(row=12,column=0,sticky=W)
def attribute_graphic_frame3_2(self,main):
self.button_run_calib.config(command=lambda:calib_2D(self,main))
calib_2D.button_apply.config(command=lambda:None)
calib_2D.button_init.config(command=lambda:None)
calib_2D.button_advance.config(command=lambda:None)
calib_2D.button_init_wavelength.config(command=lambda:None)
calib_2D.button_psc.config(command=lambda:None)
calib_2D.Button_limit_preview.config(command=lambda:None)
calib_2D.Button_fit_preview.config(command=lambda:None)
calib_2D.Button_run_calcul.config(command=lambda:None)
angles_modif.Button_import_gma.config(command=lambda:None)
angles_modif.Button_next.config(command=lambda:None)
angles_modif.Button_apply_gma.config(command=lambda:None)
def displayLoop(TS):
#use to tkinter to produce a window, title it, set its size
root = tk.Tk()
root.title('VAN Monitor')
root.geometry("700x350")
#produce first label, used to show recieved messages
label = tk.Label(root, text="")
label.config(font=("Courier", 15))
label.pack(padx=20, pady=20)
label.config(text="Last recieved: ")
#produce additional label for listing ultrasound distances in cm
uslabel = tk.Label(root, text="Ultrasound distance:")
uslabel.config(font=("Courier", 15))
uslabel.pack(padx=20, pady=2)
#also show this using a progressbar
bar = Progressbar(root, length=650)
bar['value'] = 0
bar.pack(padx=20, pady=2)
#labelled, progressbar showing IMU acceleration of buggy, stringly affected by buggy angle due to gravity
acclabel = tk.Label(root, text="Inclination: ")
acclabel.config(font=("Courier", 15))
acclabel.pack(padx=20, pady=2)
accbar = Progressbar(root, length=650)
accbar['value'] = 0
accbar.pack(padx=20, pady=2)
#labelled progressbar showing velocity of buggy rotation from above (IMU Z axis)
turnlabel = tk.Label(root, text="Turnspeed: ")
turnlabel.config(font=("Courier", 15))
turnlabel.pack(padx=20, pady=2)
turnbar = Progressbar(root, length=650)
turnbar['value'] = 0
turnbar.pack(padx=20, pady=2)
#text changed depending on whether buggy is blocked or not
obsticleLabel = tk.Label(root, text=" ")
obsticleLabel.config(font=("Courier", 15))
obsticleLabel.pack(padx=20, pady=0)
#text changed depending on whether buggy is rolled over or not
rolloverLabel = tk.Label(root, text=" ")
rolloverLabel.config(font=("Courier", 15))
rolloverLabel.pack(padx=0, pady=0)
#start these labels without assuming the state of the buggy, messages updating these only sent when states change
obsticleLabel.config(text="No report")
rolloverLabel.config(text="No report")
while (TS.running):
time.sleep(0.001)
if TS.received: #TS.received set by serial thread, list of received message bytes
try: #corrupt messages should not have been added, but use try as an additional precaution
message = TS.received #copy message content to integer variables, destination not used
src = int(message[1])
cmd = int(message[3])
dat0 = int(message[4])
dat1 = int(message[5])
TS.received.clear(
) #clear to prevent acting on same message twice
except:
TS.received.clear() #clear corrupt message
else:
TS.received.clear(
) #clear anyway, in case of possibility of some value being evaulated as false
#attempt to get source and command names, if not in definitions.py, proceed using integer value
try:
srcName = address2Name[src]
except:
srcName = src
try:
cmdName = command2Name[cmd]
except:
cmdName = cmd
#messages from ultrasound are a 'special case'- Ans use a unique method of display
if srcName == "ULTRASOUND":
distance = int(
(256 * dat0) + dat1
) #convert both databytes to single integer (sign not required)
bar['value'] = distance / 100 #scale for progressbar
bar.update()
uslabel.config(
text="Ultrasound distance: " +
str(int(distance / 60)) + "cm"
) # /60 scale factor calulated from reading at 50cm
#another special case- reports from motors use dat0 as boolean clearahead(ultrasound), dat1 as boolean upright(IMU)
elif ((srcName == "MOTORS") and (cmdName == "REPORT")):
if (dat0 == 1):
obsticleLabel.config(text="Clear Ahead")
else:
obsticleLabel.config(text="Obstructed")
if (dat1 == 1):
rolloverLabel.config(text="Upright")
else:
rolloverLabel.config(text="Rolled Over")
#special cases where IMU sends X axis acceleration with cmd=P0, or Z axis rotation velocity with cmd=P1
elif (srcName == "IMU"):
if (cmdName == "P0"):
data = bytearray()
data.extend(
dat0.to_bytes(1, 'big', signed=False)
) #requires conversion from 2 uint8's to one signed int16
data.extend(dat1.to_bytes(1, 'big', signed=False))
acceleration = int.from_bytes(data, 'big', signed=True)
data.clear()
accbar[
'value'] = 50 - acceleration / 20 #scale to give +/-90deg incline uses entire progressbar
accbar.update()
elif (cmdName == "P1"):
data = bytearray()
data.extend(dat0.to_bytes(1, 'big', signed=False))
data.extend(dat1.to_bytes(1, 'big', signed=False))
turnspeed = int.from_bytes(data, 'big', signed=True)
data.clear()
turnbar[
'value'] = 50 - turnspeed / 8 #not calibrated, scaled for maximum turning speed
turnbar.update()
#default for any other messages, where its components are simply listed
else:
lastMessage = str(srcName) + " " + str(
cmdName) + " " + str(dat0) + " " + str(dat1)
label.config(text="Last recieved: " + lastMessage)
label.update()
root = tk.Tk()
root.withdraw()
folder_path = Path(filedialog.askdirectory(title="Select folder with the outline.txt files..."))
progress_bar_window = tk.Tk()
progress_bar_window.title("Processing files...")
progress_bar_window.geometry('600x100')
num_files = len(list(folder_path.glob('*outlines.txt')))
bar = Progressbar(progress_bar_window, length=500)
bar['value'] = 0
bar['maximum'] = 500
bar.update()
bar.grid(column=0, row=0)
bar.pack()
file_cntr = 1
for file_path in folder_path.glob('*outlines.txt'):
with open(file_path, 'r') as textfile:
tmp_folder_path = file_path.parent / "tmp"
tmp_folder_path.mkdir(exist_ok=True)
# initialize zip file object
zip_obj = ZipFile(file_path.parent / (str(file_path.stem) + '.zip'), 'w')
line_cntr = 0
for line in textfile:
class MainFrame(Frame):
''' This class implements main GUI of the application.
Attributes:
parent (Tk object): parent of this frame (Tk()).
params_frame (ParamsFrame): frame with parameters.
data_frame (DataFrame): frame with data and solution.
progress_bar (Progressbar): progress bar widget.
increment (int): progress bar increment, it is modified
in other classes that are responsible for solving
the problem and update progress.
weights_status_lbl (Label): label that displays if weight
restrictions are feasible.
weights_status_str (StringVar): StringVar object used for
tracking if weight restrictions are feasible.
current_categories (list of str): list of current categories.
Args:
parent (Tk object): parent of this frame (Tk()).
'''
def __init__(self, parent, *args, **kwargs):
Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
self.params_frame = None
self.data_frame = None
self.progress_bar = None
self.increment = 0
self.weights_status_lbl = None
self.weights_status_str = StringVar()
self.weights_status_str.trace('w', self.on_weights_status_change)
self.current_categories = []
self.create_widgets()
def create_widgets(self):
''' Creates all widgets that belong to this frame.
'''
self.parent.title('pyDEA')
self.pack(fill=BOTH, expand=1)
self.columnconfigure(0, weight=1, pad=5)
self.columnconfigure(1, weight=0, pad=5)
self.rowconfigure(0, pad=3, weight=1)
self.rowconfigure(1, pad=3)
self.rowconfigure(2, pad=3)
self.rowconfigure(3, pad=3)
self.current_categories = []
data_from_params_file = StringVar()
str_var_for_input_output_boxes = ObserverStringVar()
self.params_frame = ParamsFrame(self, self.current_categories,
data_from_params_file,
str_var_for_input_output_boxes,
self.weights_status_str)
data_frame = DataFrame(self, self.params_frame, self.current_categories,
data_from_params_file,
str_var_for_input_output_boxes)
self.data_frame = data_frame
data_frame.grid(row=0, column=0, sticky=N+S+W+E, padx=15, pady=15)
self.params_frame.grid(row=0, column=1, sticky=W+E+S+N, padx=15,
pady=15, columnspan=2)
lbl_progress = Label(self, text='Progress')
lbl_progress.grid(row=1, column=0, sticky=W, padx=10, pady=5)
self.progress_bar = Progressbar(self, mode='determinate', maximum=100)
self.progress_bar.grid(row=2, column=0, sticky=W+E, padx=10, pady=5)
run_btn = Button(self, text='Run', command=self.run)
run_btn.grid(row=2, column=1, sticky=W, padx=10, pady=10)
self.weights_status_lbl = Label(self, text='', foreground='red')
self.weights_status_lbl.grid(row=2, column=2, padx=10, pady=5, sticky=W)
def on_weights_status_change(self, *args):
''' This method is called when weight restrictions status is changed.
'''
self.weights_status_lbl.config(text=self.weights_status_str.get())
def run(self):
''' This method is called when the user presses Run button.
Solves the problem and displays solution.
'''
clean_up_pickled_files()
params = self.params_frame.params
run_method = RunMethodGUI(self)
run_method.run(params)
def construct_categories(self):
''' Returns current categories.
Returns:
(list of str): list of current categories
'''
return [category.strip() for category in self.current_categories
if category]
def on_dmu_change(self, *args):
''' Updates progress bar.
'''
self.progress_bar.step(self.increment)
self.progress_bar.update()
