def getView(self, window):
view = Frame(window)
Label(view, text=self.question).pack()
if (self.screentype == "Scale"):
var = DoubleVar()
slider = Scale(view,
from_=0,
to=100,
orient=HORIZONTAL,
variable=var,
command=self.updateButtonText)
slider.pack()
self.btn = Button(
master=view,
text="Your Answer = " + str(slider.get()),
command=lambda *args: self.check(str(slider.get()), view))
self.btn.pack()
elif (self.screentype == "Radio"):
var = StringVar()
Radiobutton(
view,
text=self.answers[0],
value="A",
variable=var,
command=lambda *args: self.check(var.get(), view)).pack()
Radiobutton(
view,
text=self.answers[1],
value="B",
variable=var,
command=lambda *args: self.check(var.get(), view)).pack()
Radiobutton(
view,
text=self.answers[2],
value="C",
variable=var,
command=lambda *args: self.check(var.get(), view)).pack()
Radiobutton(
view,
text=self.answers[3],
value="D",
variable=var,
command=lambda *args: self.check(var.get(), view)).pack()
var.set(None)
else:
Button(view,
text=self.answers[0],
command=lambda *args: self.check("A", view)).pack()
Button(view,
text=self.answers[1],
command=lambda *args: self.check("B", view)).pack()
Button(view,
text=self.answers[2],
command=lambda *args: self.check("C", view)).pack()
Button(view,
text=self.answers[3],
command=lambda *args: self.check("D", view)).pack()
return view
class StatusFrame(Frame):
def __init__(self, root):
super().__init__(root, padding=10)
self.var_stat = StringVar()
self.var_stat.set("Ready")
self.lbl_stat = Label(self, textvariable=self.var_stat)
self.lbl_stat.pack(anchor=W)
self.var_statmin = StringVar()
self.var_statmin.set("|> ")
self.lbl_statmin = Label(self, textvariable=self.var_statmin)
self.lbl_statmin.pack(anchor=W)
self.var_prog = DoubleVar()
self.var_prog.set(0)
self.prog_stat = Progressbar(self, maximum=100, variable=self.var_prog)
self.prog_stat.pack(fill=X, anchor=W)
def set_minor(self, message):
self.var_statmin.set(message)
def set_major(self, message):
self.var_stat.set(message)
def set_progress(self, progress):
self.var_prog.set(progress)
class TScaleObj:
needDrawingUpdate = True
def __init__(self,cellx,celly,window,title,defaultValue):
self.InitEntry(defaultValue)
#Label init
self.label = Label(window, text=title)
self.label.grid(column=cellx,row=celly, sticky = "W" )
#Entry init
self.entry = Entry(window,textvariable=self.EntryValue)
self.entry.grid(column=cellx,row=celly+1, sticky = "W" )
#Buttons init
self.buttSub = Button(window,text = "Sub" ,command= self.Sub,image = image_minus)
self.buttSub.grid(column=cellx+3,row=celly+1, sticky = "W")
self.buttAdd = Button(window,text = "Add",command=self.Add,image = image_plus )
self.buttAdd.grid(column=cellx+2,row=celly+1, sticky = "W")
self.buttValidate = Button(window,text = "<-",command=self.setNewEntry,image = image_valid )
self.buttValidate.grid(column=cellx+1,row=celly+1, sticky = "W")
def UpdateValidEntry(self,value):
self.lastValidEntry = value
self.RefreshDisplayedValue()
self.needDrawingUpdate = True
def setNewEntry(self):
newValue = self.EntryValue.get()
if(self.CheckForValidEntry(newValue)):
self.UpdateValidEntry(float(newValue))
else :
self.RefreshDisplayedValue()
def CheckForValidEntry(self,value):
try:
v = float(value)
if v <0:
floatable = False
else :
floatable = True
except:
floatable = False
return floatable
def RefreshDisplayedValue(self):
self.EntryValue.set(self.lastValidEntry)
def IncrementEntryValue(self,inc):
newValue = self.lastValidEntry + inc
if self.CheckForValidEntry(newValue):
self.UpdateValidEntry(newValue)
def Add(self):
self.IncrementEntryValue(0.001)
def Sub(self):
self.IncrementEntryValue(-0.001)
def InitEntry (self,defaultValue):
self.EntryValue = DoubleVar()
self.EntryValue.set(defaultValue)
self.lastValidEntry = defaultValue
def handle_common_properties(widgets):
color = [None]
def on_choose_color():
color[0] = askcolor()[1]
widgets["color_btn"]["command"] = on_choose_color
marker = StringVar()
widgets["marker_lent"].entry["textvariable"] = marker
alpha = DoubleVar()
alpha.set(1.0)
widgets["alpha_scale"].scale["variable"] = alpha
return color, marker, alpha
def add_vectors(self):
self.clear()
num_vectors = DoubleVar()
dimension = DoubleVar()
num_vectors.set(2)
dimension.set(2)
num_vectors_entry = Entry(mainframe,
width=5,
textvariable=num_vectors,
font=MATRIX_FONT)
num_vectors_entry.grid(column=1, row=2, sticky=W)
dimension_entry = Entry(mainframe,
width=5,
textvariable=dimension,
font=MATRIX_FONT)
dimension_entry.grid(column=1, row=3, sticky=W)
num_vectors_label = Label(mainframe, text="vectors", font=LABEL_FONT)
num_vectors_label.grid(column=2, row=2, sticky=E)
dimension_label = Label(mainframe, text="dimensions", font=LABEL_FONT)
dimension_label.grid(column=2, row=3, sticky=E)
def add_vectors_input():
try:
num_vectors_value = num_vectors.get()
dimension_value = dimension.get()
if 2 <= num_vectors_value <= 15 and 2 <= dimension_value <= 15 and num_vectors_value % 1 == 0 and dimension_value % 1 == 0:
self.vectors_input(int(num_vectors_value),
int(dimension_value), ADD_VECTORS)
else:
raise ValueError
except ValueError:
messagebox.showerror(
"Error",
"Number of vectors or dimensions must be between 2 and 15")
except TclError:
messagebox.showerror("Error", "Invalid input")
return
submit = Button(mainframe,
text="Submit",
command=add_vectors_input,
font=LABEL_FONT)
submit.grid(column=1, row=4, columnspan=2, sticky=W)
dimension_header = Label(
mainframe,
text="Enter the number of vectors to add and their dimensions:",
font=LABEL_FONT)
dimension_header.grid(column=1, row=1, columnspan=FILL, sticky=W)
def initUI(self):
"""Initialize the User Interface"""
global var
columns = [0, 1, 2, 3, 4] # columns grid padding
rows = [0, 1, 2, 3, 4, 5] # rows grid padding
var = StringVar()
self.master.title("Speed-Reader")
Style().configure("Tbutton", padding=(0, 5, 0, 5), font="serif 10")
self.columnconfigure(columns, pad=5, minsize=25)
self.rowconfigure(rows, pad=5, minsize=25)
self.textLabel = Label(self, textvariable=var)
self.textLabel.grid(row=0, column=2)
self.restart = Button(self,
text="Restart Text",
command=self.restart_txt)
self.restart.grid(row=1, column=2)
self.pause = Button(self, text="PLAY/PAUSE", command=self.pause_txt)
self.pause.grid(row=2, column=2)
init_slide_val = DoubleVar() # create initial slider value variable
self.speed_slider = Scale(
self,
cursor='sb_h_double_arrow',
from_=100,
to=300,
length=200,
tickinterval=50,
resolution=50,
orient='horizontal',
variable=init_slide_val,
command=lambda x: self.change_speed(self.speed_slider.get()))
init_slide_val.set(200) # initialize the slider to 200 WPM
self.speed_slider.grid(row=3, column=2)
self.quit = Button(self, text="QUIT", command=self.master.destroy)
self.quit.grid(row=4, column=2)
self.addFile = Button(self, text="OPEN", command=self.UploadAction)
self.addFile.grid(row=5, column=2)
self.textLabel.after(1000, self.display_text)
self.pack()
def rref(self):
self.clear()
rows = DoubleVar()
columns = DoubleVar()
rows.set(2)
columns.set(2)
row_entry = Entry(mainframe,
width=5,
textvariable=rows,
font=MATRIX_FONT)
row_entry.grid(column=1, row=2, sticky=W)
column_entry = Entry(mainframe,
width=5,
textvariable=columns,
font=MATRIX_FONT)
column_entry.grid(column=1, row=3, sticky=W)
row_label = Label(mainframe, text="rows", font=LABEL_FONT)
row_label.grid(column=2, row=2, sticky=E)
column_label = Label(mainframe, text="columns", font=LABEL_FONT)
column_label.grid(column=2, row=3, sticky=E)
def rref_input():
try:
row_value = rows.get()
column_value = columns.get()
if 2 <= row_value <= 15 and 2 <= column_value <= 15 and row_value % 1 == 0 and column_value % 1 == 0:
self.matrix_input(int(row_value), int(column_value), RREF)
else:
raise ValueError
except ValueError:
messagebox.showerror("Error",
"Matrix must be between 2x2 and 15x15")
except TclError:
messagebox.showerror("Error", "Invalid input")
return
submit = Button(mainframe,
text="Submit",
command=rref_input,
font=LABEL_FONT)
submit.grid(column=1, row=4, columnspan=2, sticky=W)
dimension_header = Label(
mainframe,
text="Enter the dimensions of the matrix (2x2 - 15x15):",
font=LABEL_FONT)
dimension_header.grid(column=1, row=1, columnspan=4, sticky=W)
def systems(self):
self.clear()
var = DoubleVar()
eq = DoubleVar()
var.set(2)
eq.set(2)
var_entry = Entry(mainframe,
width=5,
textvariable=var,
font=MATRIX_FONT)
var_entry.grid(column=1, row=2, sticky=W)
eq_entry = Entry(mainframe, width=5, textvariable=eq, font=MATRIX_FONT)
eq_entry.grid(column=1, row=3, sticky=W)
var_label = Label(mainframe, text="variables (2-10)", font=LABEL_FONT)
var_label.grid(column=2, row=2, sticky=E)
eq_label = Label(mainframe, text="equations (2-10)", font=LABEL_FONT)
eq_label.grid(column=2, row=3, sticky=E)
def systems_input():
try:
var_value = var.get()
eq_value = eq.get()
if 2 <= var_value <= 10 and 2 <= eq_value <= 10 and var_value % 1 == 0 and eq_value % 1 == 0:
self.matrix_input(int(eq_value),
int(var_value) + 1, SYSTEMS)
else:
raise ValueError
except ValueError:
messagebox.showerror(
"Error",
"Number of variables or equations must be between 2 and 10"
)
except TclError:
messagebox.showerror("Error", "Invalid input")
return
submit = Button(mainframe,
text="Submit",
command=systems_input,
font=LABEL_FONT)
submit.grid(column=1, row=4, columnspan=2, sticky=W)
dimension_header = Label(
mainframe,
text="Enter the number of variables and equations:",
font=LABEL_FONT)
dimension_header.grid(column=1, row=1, columnspan=4, sticky=W)
class Progress(Progressbar):
def __init__(self, master=None, box=None, autoplay=True, **kw):
super().__init__(master=master, **kw)
self.box = box
self.time = DoubleVar(master=master, value=0)
self.timestr = StringVar(master=master, value='Current MP3:')
self.current_mp3id_str = StringVar(master=master, value='')
self.pb = Progressbar(master=master, variable=self.time)
# self.pb['value'] = self.time.get()
# self.pb['maximum'] = self.length.get()
self.label = Label(master=master, textvariable=self.timestr, text='Current MP3:')
self.label.pack()
self.current_mp3id = Label(master, textvariable=self.current_mp3id_str)
self.current_mp3id.pack()
self.pb.pack()
# self.started = False
self.update(autoplay=autoplay)
# def update_loop(self, autoplay=True):
# while True:
# self.update()
def update(self, autoplay=True):
if not self.box.started:
pass
else:
mp3id = self.box.current_mp3id
time = self.box.mp3.get_time()/1000
length = self.box.mp3.get_length()/1000
timestr = f'{time:.2f} / {length:.2f}'
self.time.set(time)
self.timestr.set(timestr)
self.current_mp3id_str.set(f'Current MP3: {mp3id}')
# self.length.set(self.box.mp3.get_length())
self.pb['maximum'] = length
if self.box.mp3.get_state()==State.Ended:
self.timestr.set(f'{length:.2f} / {length:.2f}')
if autoplay:
self.box.next()
self.box.play()
# print('update ',timestr)
try:
print(self.mp3)
except:
pass
# self.length = self.box.mp3.get_length()
self.after(100, func=self.update)
def make_form(self):
form = Frame(self, relief='raised', border=2)
left = Frame(form)
right = Frame(form)
form.pack(fill='both')
left.pack(side='left')
right.pack(side='right', expand='yes', fill='both')
for feature in feature_names:
lab = Label(left, width=15, text=feature + ':')
ent = Entry(right)
lab.pack(side='top')
ent.pack(side='top', pady=.5, expand='yes', fill='both')
var = DoubleVar()
ent.config(textvariable=var)
var.set('0.0')
self.measurements.append(var)
def update_variables(self):
new_variable_array = []
new_lvw_array = []
for i in np.arange(0, int(self.number_of_variables.get()), 1):
x_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=15)
x_label["font"] = ft
x_label["fg"] = "#000"
x_label["justify"] = "center"
x_label["text"] = "x" + str(i + 1)
x_label.grid(row=3, column=i + 1)
x_val_var = DoubleVar(root)
if (i < len(self.variables)):
x_val_var.set(self.variables[i].value.get())
x_value_entry = tk.Entry(root, textvariable=x_val_var)
x_value_entry["borderwidth"] = "1px"
ft = tkFont.Font(family='Times', size=10)
x_value_entry["font"] = ft
x_value_entry["fg"] = "#333333"
x_value_entry["justify"] = "center"
x_value_entry.grid(row=4, column=i + 1)
x_w_var = DoubleVar(root)
if (i < len(self.variables)):
x_w_var.set(self.variables[i].weight.get())
x_weight_entry = tk.Entry(root, textvariable=x_w_var)
x_weight_entry["borderwidth"] = "1px"
ft = tkFont.Font(family='Times', size=10)
x_weight_entry["font"] = ft
x_weight_entry["fg"] = "#333333"
x_weight_entry["justify"] = "center"
x_weight_entry.grid(row=5, column=i + 1)
new_variable_array.append(Item(i, x_val_var, x_w_var))
new_lvw_array.append((x_label, x_value_entry, x_weight_entry))
self.variables = new_variable_array
self.lvw = new_lvw_array
return 0
def create_buttons(self, parent, create_sliders):
self.jso = Button(parent,
text="Import from .json",
command=self.import_json)
self.jso.grid(row=0, column=0, sticky="w")
self.sav = Button(parent,
text="Import from .sav",
command=self.import_sav)
self.sav.grid(row=0, column=1, sticky="w")
self.scales = []
# create sliders
if create_sliders:
self.jso.grid_configure(row=0, column=0)
self.sav.grid_configure(row=1, column=0)
resources = [
'minerals', 'energy', 'physics', 'society', 'engineering'
]
colors = ["red", "yellow", "blue", "green", "orange"]
for i in range(len(resources)):
var = DoubleVar()
var.set(500)
callback = lambda event, tag=i: self.weight_update(event, tag)
b = Scale(parent,
from_=1,
to=1000,
variable=var,
length=135,
orient='horizontal',
troughcolor=colors[i],
resolution=1,
label=resources[i],
showvalue=0)
b.grid(row=2 + i, column=0, sticky="w")
b.bind('<ButtonRelease-1>',
self.redraw) # redraw when user release scale
self.scales.append(var)
def dot_product(self):
self.clear()
dimension = DoubleVar()
dimension.set(2)
dimension_entry = Entry(mainframe,
width=5,
textvariable=dimension,
font=MATRIX_FONT)
dimension_entry.grid(column=1, row=2, sticky=W)
dimension_label = Label(mainframe, text="dimensions", font=LABEL_FONT)
dimension_label.grid(column=2, row=2, sticky=E)
def dot_product_input():
try:
dimension_value = dimension.get()
if 2 <= dimension_value <= 15 and dimension_value % 1 == 0:
self.vectors_input(2, int(dimension_value), DOT_PRODUCT)
else:
raise ValueError
except ValueError:
messagebox.showerror(
"Error", "Number of dimensions must be between 2 and 15")
except TclError:
messagebox.showerror("Error", "Invalid input")
return
submit = Button(mainframe,
text="Submit",
command=dot_product_input,
font=LABEL_FONT)
submit.grid(column=1, row=4, columnspan=FILL, sticky=W)
dimension_header = Label(
mainframe,
text="Enter the number of dimensions for the vectors:",
font=LABEL_FONT)
dimension_header.grid(column=1, row=1, columnspan=FILL, sticky=W)
class Parameter:
def __init__(self, name, var):
self.name = name
self.var = var
self.val = float(var.get())
self.doublevar = DoubleVar(value=self.val)
def getVal(self):
try:
val = float(self.var.get())
if val == 0 and cantBeZero(self.name):
return self.doublevar.get()
self.doublevar.set(val)
return val
except ValueError:
return self.doublevar.get()
def udv(self, *args):
self.setVal(self.doublevar.get())
def setVal(self, value):
self.var.set(value)
self.doublevar.set(value)
class App:
def __init__(self, master):
self.initDone = False
self.initGuiData()
self.master = master
self.master.title("Hot wire cutter (version 0.1.f)")
self.nb = ttk.Notebook(self.master)
self.nb.enable_traversal()
self.queueTkSendMsg = queue.Queue()
self._thread_cmd = threading.Thread(target=self.execCmd,
args=(self.queueTkSendMsg, "rien"))
self._thread_cmd.setDaemon(
True
) #added by mstrens in order to kill automatically the thread when program close
self._thread_cmd.start()
self.queueTkGetMsg = queue.Queue()
self.tGrbl = Grbl(
self.nb, self, self.queueTkGetMsg
) #create an instance of Gerbil in order to communicate with GRBL
# queue is used to get message back from interface
self.tProfil = Profil(self.nb,
self) #add a tab for selecting the profile
self.tTransform = Transform(self.nb,
self) #add a tab to modify the profile
self.tBloc = Bloc(self.nb,
self) #add a tab to design the wing and the bloc
self.tMargin = Margin(self.nb,
self) #add a tab to design the vertical margin
self.tMaterial = Material(self.nb,
self) #add a tab to specify the material
self.tGuillotine = Guillotine(
self.nb, self, self.queueTkSendMsg) #add a tab to make guillotine
self.tCut = Cut(self.nb, self) #add a tab to cut
self.tTable = Table(self.nb,
self) #add a tab to define the Table (size)
self.nb.pack()
atexit.register(self.tGrbl.disconnectToGrbl)
self.initDone = True
self.running = True
self.periodicCall()
self.validateAllOn = True
self.validateAll(0) #validate all
#self.tBloc.toTableRight.set(self.tTable.dY.get() - self.tTable.lG.get() - self.tTable.lD.get() - self.tBloc.toTableLeft.get() - self.tBloc.lX.get() )
#print (self.tBloc.toTableRight.get())
def execCmd(self, queue, rien):
"""
thread in order to execute task outside the main tkhtread (when they can take to much time e.g.)
get Cmd via a queue queueTkSendMsg
used e.g. when a button is clicked in Thinker
not sure it is really requested for this application
"""
while True:
msg = queue.get()
if msg == "Connect":
self.tGrbl.connectToGrbl()
self.tGuillotine.updateBtnState()
elif msg == "Disconnect":
self.tGrbl.disconnectToGrbl()
self.tGuillotine.updateBtnState()
def processIncoming(self):
"""Handle all messages currently in the queue, if any."""
while self.queueTkGetMsg.qsize():
try:
msg = self.queueTkGetMsg.get(0) + "\n"
# Check contents of message and do whatever is needed. As a
# simple test, print it (in real life, you would
# suitably update the GUI's display in a richer fashion).
#print("getting a message in queue",msg)
self.tGuillotine.msgBox.insert(END, msg)
except queue.Empty:
# just on general principles, although we don't
# expect this branch to be taken in this case
pass
def periodicCall(self):
"""
Check every 200 ms if there is something new in the queue.
execute it when tkinter is sleeping
"""
self.processIncoming()
if not self.running:
# This is the brutal stop of the system. You may want to do
# some cleanup before actually shutting it down.
#import sys
#sys.exit(1)
pass
self.master.after(200, self.periodicCall)
#def calback(self, a , b, c):
# print("do something")
def initGuiData(self):
#not saved with config
self.validateAllOn = False
self.warningMsg = StringVar(value="")
self.cutMsg = StringVar(value="")
self.limMinX = DoubleVar(
value='0.0') # min value to plot on X axis (not saved in .ini)
self.limMinY = DoubleVar(
value='0.0') # min value to plot on Y axis (not saved in .ini)
self.zoom = StringVar(value="1X")
#self.zoom.trace('w', self.calback)
self.configUploadFileName = None
self.tableUploadFileName = None
self.tableSaveFileName = None
self.materialUploadFileName = None
self.materialSaveFileName = None
self.connected = StringVar(value="OFF")
self.grblStatus = StringVar(value="Not connected")
self.grblXG = DoubleVar(value="0") #grbl horizontal left pos
self.grblYG = DoubleVar(value="0") #grbl vertical left pos
self.grblXD = DoubleVar(value="0") #grbl horizontal right pos
self.grblYD = DoubleVar(value="0") #grbl vertical right pos
self.grblF = DoubleVar(value="0") #grbl feed rate
self.grblS = DoubleVar(value="0") #grbl heating
self.gMoveAxis = StringVar(
value="Both") # grbl axis to move (left,right)
self.gMoveDist = DoubleVar(value="10") #grbl mistance to move
# Transformed profil based on original (filled by validateTransform) ; is an numpy array and not a usual List
#take care of Chord, but not of position of block and margins...
self.tRootX = np.array([])
self.tRootY = np.array([])
self.tRootS = []
self.tTipX = np.array([])
self.tTipY = np.array([])
self.tTipS = []
# Position profil (in a numpy array) based on "t" profile and position of block and margins...
self.pRootX = np.array([])
self.pRootY = np.array([])
self.pRootS = []
self.pTipX = np.array([])
self.pTipY = np.array([])
self.pTipS = []
#guillotine
self.gVSpeedNoCut = DoubleVar(value='5')
self.gHSpeedNoCut = DoubleVar(value='5')
self.gCuttingSpeed = DoubleVar(value='5')
self.gApplyCalculatedHeating = IntVar(value='1')
self.gHeating = DoubleVar(value='50')
self.gType = StringVar(value="Vertical")
self.gCuttingWhile = StringVar(value="Both")
#self.gHeatWhileArming = IntVar(value='1')
self.gVDist = DoubleVar(value='10')
self.gHDist = DoubleVar(value='10')
#saved in config
#profil
self.oRootX = [
] # original profil : usual python List ; saved in the files
self.oRootY = []
self.oRootS = [] # synchro points
self.oTipX = []
self.oTipY = []
self.oTipS = []
self.nameRoot = StringVar(value="")
self.nameTip = StringVar(value="")
#transform
self.cRoot = DoubleVar(value='200.0') #chord
self.cTip = DoubleVar(value='150.0') #chord
self.incidenceRoot = DoubleVar(value='0.0')
self.thicknessRoot = DoubleVar(value='100.0')
self.vInvertRoot = IntVar(value='0')
self.incidenceTip = DoubleVar(value='0.0')
self.thicknessTip = DoubleVar(value='100.0')
self.vInvertTip = IntVar(value='0')
self.covering = DoubleVar(value='0.0')
self.keepChord = IntVar(value='0')
self.smooth = IntVar(value='0')
self.nbrPoints = IntVar(value='50')
self.repartition = DoubleVar(value='2.0')
self.reducePoints = IntVar(value='0')
#bloc
self.blocLX = DoubleVar(value='600.0') #Length = envergure
self.blocHZ = DoubleVar(value='50.0') #height of the bloc
self.fLeading = DoubleVar(value='10.0') #fleche
self.fTrailing = DoubleVar(
value='-30'
) #self.cRoot.get() - self.cTip.get() - self.fLeading.get()) #calculated
self.mLeading = DoubleVar(value='5.0')
self.mTrailingRoot = DoubleVar(value='10.0')
self.mTrailingTip = DoubleVar(value='10.0')
self.leftRightWing = StringVar(value='Left')
self.blocPosition = StringVar(value='Left') #Left or Right position
self.blocToTableLeft = DoubleVar(
value='100.0') #calculated but depend on bloc position
self.blocToTableRight = DoubleVar(
value='10.0') #calculated but depend on bloc position
self.blocToTableTrailingRoot = IntVar(value='50')
self.blocToTableTrailingTip = IntVar(value='50') #calculated
self.blocToTableLeadingRoot = IntVar(value='50') #calculated
self.blocToTableLeadingTip = IntVar(value='50') #calculated
#margin
self.hTrailingRoot = DoubleVar(value='10.0')
self.hTrailingTip = DoubleVar(value='10.0') #calculated
self.hLeadingRoot = DoubleVar(value='10.0') #calculated
self.hLeadingTip = DoubleVar(value='10.0') #calculated
self.hMaxRoot = DoubleVar(value='10.0') #calculated
self.hMaxTip = DoubleVar(value='10.0') #calculated
self.hMinRoot = DoubleVar(value='10.0') #calculated
self.hMinTip = DoubleVar(value='10.0') #calculated
self.hOffset = DoubleVar(value='10.0') #heigh of the base of the bloc
self.alignProfil = StringVar(value="Trailing")
self.hProfil = DoubleVar(
value='20.0') #heigh of the profile in the bloc
self.angleInRoot = DoubleVar(value='0.0')
self.angleInTip = DoubleVar(value='0.0')
self.angleOutRoot = DoubleVar(value='0.0')
self.angleOutTip = DoubleVar(value='0.0')
"""
self.hMaxRootNorm = 0
self.hMinRootNorm = 0
self.hLeadingRootNorm = 0
self.hMaxTipNorm = 0
self.hMinTipNorm = 0
self.hLeadingTipNorm = 0
"""
#Material
self.mSpeedHigh = DoubleVar(value='10.0') #speed max
self.mSpeedHalf = DoubleVar(value='5.0') #speed min
self.mSpeedLow = DoubleVar(value='1.0') #speed min
self.mRadSpHigh = DoubleVar(value='0.9') #Radiance at high max
self.mRadSpHalf = DoubleVar(value='1.5') #Radiance at half speed
self.mHeatSpHigh = IntVar(value='90') #Heat at High speed
self.mHeatSpLow = IntVar(value='40') #Heat at low speed
self.mName = StringVar(value="No material name")
#table
self.tableYY = DoubleVar(value='1000.0') # distance between 2 axis
self.tableYG = DoubleVar(
value='20.0') #distance between left Y axis and left table edge
self.tableYD = DoubleVar(value='20.0') # same on the rigth side
self.cMaxY = DoubleVar(value='500.0') # max course in Y
self.cMaxZ = DoubleVar(value='200.0') # max course in Z (height)
self.vMaxY = DoubleVar(value='10.0') # max speed in Y
self.vMaxZ = DoubleVar(value='5.0') # max speed in Z (height)
self.tHeatingMax = DoubleVar(value='100.0') # max heating
self.tName = StringVar(value="No table name")
#self.tComPort = StringVar(value="Select a Com port")
self.tComPort = StringVar(value="COM6")
self.tBaudrate = StringVar(value="115200")
self.tPreHeat = DoubleVar(value='5.0') # delay between Heat and move
self.tPostHeat = DoubleVar(value='5.0') # delay between Move and Heat
#cut
self.vCut = DoubleVar(
value='2.0'
) # max speed for cutting (on root or tip depending the longest)
self.gCodeStart1 = StringVar(value="")
self.gCodeStart2 = StringVar(value="")
self.gCodeStart3 = StringVar(value="")
self.gCodeStart4 = StringVar(value="")
self.gCodeEnd1 = StringVar(value="")
self.gCodeEnd2 = StringVar(value="")
self.gCodeEnd3 = StringVar(value="")
self.gCodeEnd4 = StringVar(value="")
self.gCodeLetters = StringVar(value="XYZA")
#self.validatePart()
def uploadConfig(self):
#global configUploadFileName
#configUploadFileName = filedialog.askopenfilename(initialdir="C:/Data/",
self.configUploadFileName = filedialog.askopenfilename(\
filetypes =(("Ini files", "*.ini"),("All files","*.*")),
title = "Choose a file."
)
if len(self.configUploadFileName) > 0:
self.validateAllOn = False
#config.read('config.ini')
config = configparser.ConfigParser()
config.add_section("Profil")
config.add_section("Transform")
config.add_section("Bloc")
config.add_section("Material")
config.add_section("Table")
config.add_section("Cut")
config.add_section("Guillotine")
config.read(self.configUploadFileName)
self.oRootX = stringToListOfFloat(config.get("Profil", "RootX"))
self.oRootY = stringToListOfFloat(config.get("Profil", "RootY"))
self.oRootS = stringToListOfFloat(config.get("Profil", "RootS"))
self.oTipX = stringToListOfFloat(config.get("Profil", "TipX"))
self.oTipY = stringToListOfFloat(config.get("Profil", "TipY"))
self.oTipS = stringToListOfFloat(config.get("Profil", "TipS"))
self.nameRoot.set(value=config.get("Profil", "nameRoot"))
self.nameTip.set(value=config.get("Profil", "nameTip"))
self.cRoot.set(value=config.getfloat("Transform", "cRoot"))
self.cTip.set(value=config.getfloat("Transform", "cTip"))
self.incidenceRoot.set(
value=config.getfloat("Transform", "incidenceRoot"))
self.thicknessRoot.set(
value=config.getfloat("Transform", "thicknessRoot"))
self.vInvertRoot.set(
value=config.getint("Transform", "vInvertRoot"))
self.incidenceTip.set(
value=config.getfloat("Transform", "incidenceTip"))
self.thicknessTip.set(
value=config.getfloat("Transform", "thicknessTip"))
self.vInvertTip.set(value=config.getint("Transform", "vInvertTip"))
self.covering.set(value=config.getfloat("Transform", "covering"))
self.keepChord.set(value=config.getint("Transform", "keepChord"))
self.smooth.set(value=config.getint("Transform", "smooth"))
self.nbrPoints.set(value=config.getint("Transform", "nbrPoints"))
self.repartition.set(
value=config.getfloat("Transform", "repartition"))
self.reducePoints.set(
value=config.getint("Transform", "reducePoints"))
self.blocLX.set(value=config.getfloat("Bloc", "blocLX"))
self.blocHZ.set(value=config.getfloat("Bloc", "blocHZ"))
self.fLeading.set(value=config.getfloat("Bloc", "fLeading"))
self.mLeading.set(value=config.getfloat("Bloc", "mLeading"))
self.mTrailingRoot.set(
value=config.getfloat("Bloc", "mTrailingRoot"))
self.mTrailingTip.set(
value=config.getfloat("Bloc", "mTrailingTip"))
self.leftRightWing.set(value=config.get("Bloc", "leftRightWing"))
self.blocPosition.set(value=config.get("Bloc", "blocPosition"))
self.blocToTableLeft.set(
value=config.getfloat("Bloc", "blocToTableLeft"))
self.blocToTableRight.set(
value=config.getfloat("Bloc", "blocToTableRight"))
self.blocToTableTrailingRoot.set(
value=config.getint("Bloc", "blocToTableTrailingRoot"))
self.blocToTableTrailingTip.set(
value=config.getint("Bloc", "blocToTableTrailingTip"))
self.blocToTableLeadingRoot.set(
value=config.getint("Bloc", "blocToTableLeadingRoot"))
self.blocToTableLeadingTip.set(
value=config.getint("Bloc", "blocToTableLeadingTip"))
self.hTrailingRoot.set(
value=config.getfloat("Bloc", "hTrailingRoot"))
self.hTrailingTip.set(
value=config.getfloat("Bloc", "hTrailingTip"))
self.hLeadingRoot.set(
value=config.getfloat("Bloc", "hLeadingRoot"))
self.hLeadingTip.set(value=config.getfloat("Bloc", "hLeadingTip"))
self.hMaxRoot.set(value=config.getfloat("Bloc", "hMaxRoot"))
self.hMaxTip.set(value=config.getfloat("Bloc", "hMaxTip"))
self.hMinRoot.set(value=config.getfloat("Bloc", "hMinRoot"))
self.hMinTip.set(value=config.getfloat("Bloc", "hMinTip"))
self.hOffset.set(value=config.getfloat("Bloc", "hOffset"))
self.alignProfil.set(value=config.get("Bloc", "alignProfil"))
self.hProfil.set(value=config.get("Bloc", "hProfil"))
try:
self.angleInRoot.set(
value=config.getfloat("Bloc", "angleInRoot"))
self.angleInTip.set(
value=config.getfloat("Bloc", "angleInTip"))
self.angleOutRoot.set(
value=config.getfloat("Bloc", "angleOutRoot"))
self.angleOutTip.set(
value=config.getfloat("Bloc", "angleOutTip"))
except:
pass
"""
self.hMaxRootNorm = config.get("Bloc", "hMaxRootNorm")
self.hMinRootNorm = config.get("Bloc", "hMinRootNorm")
self.hLeadingRootNorm = config.get("Bloc", "hLeadingRootNorm")
self.hMaxTipNorm = config.get("Bloc", "hMaxTipNorm")
self.hMinTipNorm = config.get("Bloc", "hMinTipNorm")
self.hLeadingTipNorm = config.get("Bloc", "hLeadingTipNorm")
"""
self.mSpeedHigh.set(
value=config.getfloat("Material", "mSpeedHigh"))
self.mSpeedHalf.set(
value=config.getfloat("Material", "mSpeedHalf"))
self.mSpeedLow.set(value=config.getfloat("Material", "mSpeedLow"))
self.mRadSpHigh.set(
value=config.getfloat("Material", "mRadSpHigh"))
self.mRadSpHalf.set(
value=config.getfloat("Material", "mRadSpHalf"))
self.mHeatSpHigh.set(
value=config.getfloat("Material", "mHeatSpHigh"))
self.mHeatSpLow.set(
value=config.getfloat("Material", "mHeatSpLow"))
self.mName.set(value=config.get("Material", "mName"))
self.tableYY.set(value=config.getfloat("Table", "tableYY"))
self.tableYG.set(value=config.getfloat("Table", "tableYG"))
self.tableYD.set(value=config.getfloat("Table", "tableYD"))
self.cMaxY.set(value=config.getfloat("Table", "cMaxY"))
self.cMaxZ.set(value=config.getfloat("Table", "cMaxZ"))
self.vMaxY.set(value=config.getfloat("Table", "vMaxY"))
self.vMaxZ.set(value=config.getfloat("Table", "vMaxZ"))
self.tHeatingMax.set(value=config.getfloat("Table", "tHeatingMax"))
self.tName.set(value=config.get("Table", "tName"))
self.tComPort.set(value=config.get("Table", "tComPort"))
self.tBaudrate.set(value=config.get("Table", "tBaudrate"))
self.tPreHeat.set(value=config.getfloat("Table", "tPreHeat"))
self.tPostHeat.set(value=config.getfloat("Table", "tPostHeat"))
self.vCut.set(value=config.getfloat("Cut", "vCut"))
self.gCodeStart1.set(value=config.get("Cut", "gCodeStart1"))
self.gCodeStart2.set(value=config.get("Cut", "gCodeStart2"))
self.gCodeStart3.set(value=config.get("Cut", "gCodeStart3"))
self.gCodeStart4.set(value=config.get("Cut", "gCodeStart4"))
self.gCodeEnd1.set(value=config.get("Cut", "gCodeEnd1"))
self.gCodeEnd2.set(value=config.get("Cut", "gCodeEnd2"))
self.gCodeEnd3.set(value=config.get("Cut", "gCodeEnd3"))
self.gCodeEnd4.set(value=config.get("Cut", "gCodeEnd4"))
self.gCodeLetters.set(value=config.get("Cut", "gCodeLetters"))
self.gVSpeedNoCut.set(
value=config.getfloat("Guillotine", "gVSpeedNoCut"))
self.gHSpeedNoCut.set(
value=config.getfloat("Guillotine", "gHSpeedNoCut"))
self.gCuttingSpeed.set(
value=config.getfloat("Guillotine", "gCuttingSpeed"))
self.gApplyCalculatedHeating.set(
value=config.getint("Guillotine", "gApplyCalculatedHeating"))
self.gHeating.set(value=config.getfloat("Guillotine", "gHeating"))
self.gType.set(value=config.get("Guillotine", "gType"))
self.gCuttingWhile.set(
value=config.get("Guillotine", "gCuttingWhile"))
self.gVDist.set(value=config.getfloat("Guillotine", "gVDist"))
self.gHDist.set(value=config.getfloat("Guillotine", "gHDist"))
"""
x ,y , self.hMaxRootNorm, self.hMinRootNorm , self.hLeadingRootNorm = self.normaliseProfil(
self.oRootX, self.oRootY, self.cRoot.get(), 0, 0)
x ,y , self.hMaxTipNorm, self.hMinTipNorm , self.hLeadingTipNorm = self.normaliseProfil(
self.oTipX, self.oTipY, self.cTip.get(), 0, 0)
"""
self.validateAllOn = True
self.validateAll(0)
self.tProfil.updatePlotRoot()
self.tProfil.updatePlotTip()
def uploadTable(self):
self.tableUploadFileName = filedialog.askopenfilename(\
filetypes =(("Table files", "*.tab"),("All files","*.*")),
title = "Choose a file to upload a table."
)
if len(self.tableUploadFileName) > 0:
#config.read('config.ini')
config = configparser.ConfigParser()
config.add_section("Table")
config.add_section("Cut")
config.read(self.tableUploadFileName)
self.tableYY.set(value=config.getfloat("Table", "tableYY"))
self.tableYG.set(value=config.getfloat("Table", "tableYG"))
self.tableYD.set(value=config.getfloat("Table", "tableYD"))
self.cMaxY.set(value=config.getfloat("Table", "cMaxY"))
self.cMaxZ.set(value=config.getfloat("Table", "cMaxZ"))
self.vMaxY.set(value=config.getfloat("Table", "vMaxY"))
self.vMaxZ.set(value=config.getfloat("Table", "vMaxZ"))
self.tHeatingMax.set(value=config.getfloat("Table", "tHeatingMax"))
self.tName.set(value=config.get("Table", "tName"))
self.tComPort.set(value=config.get("Table", "tComPort"))
self.tBaudrate.set(value=config.get("Table", "tBaudrate"))
self.tPreHeat.set(value=config.getfloat("Table", "tPreHeat"))
self.tPostHeat.set(value=config.getfloat("Table", "tPostHeat"))
self.vCut.set(value=config.getfloat("Cut", "vCut"))
self.gCodeStart1.set(value=config.get("Cut", "gCodeStart1"))
self.gCodeStart2.set(value=config.get("Cut", "gCodeStart2"))
self.gCodeStart3.set(value=config.get("Cut", "gCodeStart3"))
self.gCodeStart4.set(value=config.get("Cut", "gCodeStart4"))
self.gCodeEnd1.set(value=config.get("Cut", "gCodeEnd1"))
self.gCodeEnd2.set(value=config.get("Cut", "gCodeEnd2"))
self.gCodeEnd3.set(value=config.get("Cut", "gCodeEnd3"))
self.gCodeEnd4.set(value=config.get("Cut", "gCodeEnd4"))
self.gCodeLetters.set(value=config.get("Cut", "gCodeLetters"))
self.validateAll(
20) # recalculate and redraw bloc, margin and after
def uploadMaterial(self):
self.materialUploadFileName = filedialog.askopenfilename(\
filetypes =(("Material", "*.mat"),("All files","*.*")),
title = "Choose a file to upload a material"
)
if len(self.materialUploadFileName) > 0:
#config.read('config.ini')
config = configparser.ConfigParser()
config.add_section("Material")
config.read(self.materialUploadFileName)
self.mSpeedHigh.set(
value=config.getfloat("Material", "mSpeedHigh"))
self.mSpeedHalf.set(
value=config.getfloat("Material", "mSpeedHalf"))
self.mSpeedLow.set(value=config.getfloat("Material", "mSpeedLow"))
self.mRadSpHigh.set(
value=config.getfloat("Material", "mRadSpHigh"))
self.mRadSpHalf.set(
value=config.getfloat("Material", "mRadSpHalf"))
self.mHeatSpHigh.set(
value=config.getfloat("Material", "mHeatSpHigh"))
self.mHeatSpLow.set(
value=config.getfloat("Material", "mHeatSpLow"))
self.mName.set(value=config.get("Material", "mName"))
self.validateAll(30) # recalculate and redraw cutting
def saveConfig(self):
config = configparser.ConfigParser()
config.add_section("Profil")
config.add_section("Transform")
config.add_section("Bloc")
config.add_section("Material")
config.add_section("Table")
config.add_section("Cut")
config.add_section("Guillotine")
#save all paramaters
config.set(
"Profil", "RootX",
str('[{:s}]'.format(', '.join(
['{}'.format(x) for x in self.oRootX]))))
config.set(
"Profil", "RootY",
str('[{:s}]'.format(', '.join(
['{}'.format(x) for x in self.oRootY]))))
config.set(
"Profil", "RootS",
str('[{:s}]'.format(', '.join(
['{}'.format(x) for x in self.oRootS]))))
config.set(
"Profil", "TipX",
str('[{:s}]'.format(', '.join(['{}'.format(x)
for x in self.oTipX]))))
config.set(
"Profil", "TipY",
str('[{:s}]'.format(', '.join(['{}'.format(x)
for x in self.oTipY]))))
config.set(
"Profil", "TipS",
str('[{:s}]'.format(', '.join(['{}'.format(x)
for x in self.oTipS]))))
config.set("Profil", "nameRoot", self.nameRoot.get())
config.set("Profil", "nameTip", self.nameTip.get())
config.set("Transform", "cRoot", str(self.cRoot.get()))
config.set("Transform", "cTip", str(self.cTip.get()))
config.set("Transform", "incidenceRoot", str(self.incidenceRoot.get()))
config.set("Transform", "thicknessRoot", str(self.thicknessRoot.get()))
config.set("Transform", "vInvertRoot", str(self.vInvertRoot.get()))
config.set("Transform", "incidenceTip", str(self.incidenceTip.get()))
config.set("Transform", "thicknessTip", str(self.thicknessTip.get()))
config.set("Transform", "vInvertTip", str(self.vInvertTip.get()))
config.set("Transform", "covering", str(self.covering.get()))
config.set("Transform", "keepChord", str(self.keepChord.get()))
config.set("Transform", "smooth", str(self.smooth.get()))
config.set("Transform", "nbrPoints", str(self.nbrPoints.get()))
config.set("Transform", "repartition", str(self.repartition.get()))
config.set("Transform", "reducePoints", str(self.reducePoints.get()))
config.set("Bloc", "blocLX", str(self.blocLX.get()))
config.set("Bloc", "blocHZ", str(self.blocHZ.get()))
config.set("Bloc", "fLeading", str(self.fLeading.get()))
config.set("Bloc", "fTrailing", str(self.fTrailing.get()))
config.set("Bloc", "mLeading", str(self.mLeading.get()))
config.set("Bloc", "mTrailingRoot", str(self.mTrailingRoot.get()))
config.set("Bloc", "mTrailingTip", str(self.mTrailingTip.get()))
config.set("Bloc", "leftRightWing", self.leftRightWing.get())
config.set("Bloc", "blocPosition", self.blocPosition.get())
config.set("Bloc", "blocToTableLeft", str(self.blocToTableLeft.get()))
config.set("Bloc", "blocToTableRight",
str(self.blocToTableRight.get()))
config.set("Bloc", "blocToTableTrailingRoot",
str(self.blocToTableTrailingRoot.get()))
config.set("Bloc", "blocToTableTrailingTip",
str(self.blocToTableTrailingTip.get()))
config.set("Bloc", "blocToTableLeadingRoot",
str(self.blocToTableLeadingRoot.get()))
config.set("Bloc", "blocToTableLeadingTip",
str(self.blocToTableLeadingTip.get()))
config.set("Bloc", "hTrailingRoot", str(self.hTrailingRoot.get()))
config.set("Bloc", "hTrailingTip", str(self.hTrailingTip.get()))
config.set("Bloc", "hLeadingRoot", str(self.hLeadingRoot.get()))
config.set("Bloc", "hLeadingTip", str(self.hLeadingTip.get()))
config.set("Bloc", "hMaxRoot", str(self.hMaxRoot.get()))
config.set("Bloc", "hMaxTip", str(self.hMaxTip.get()))
config.set("Bloc", "hMinRoot", str(self.hMinRoot.get()))
config.set("Bloc", "hMinTip", str(self.hMinTip.get()))
config.set("Bloc", "hOffset", str(self.hOffset.get()))
config.set("Bloc", "alignProfil", self.alignProfil.get())
config.set("Bloc", "hProfil", str(self.hProfil.get()))
config.set("Bloc", "angleInRoot", str(self.angleInRoot.get()))
config.set("Bloc", "angleInTip", str(self.angleInTip.get()))
config.set("Bloc", "angleOutRoot", str(self.angleOutRoot.get()))
config.set("Bloc", "angleOutTip", str(self.angleOutTip.get()))
config.set("Material", "mSpeedHigh", str(self.mSpeedHigh.get()))
config.set("Material", "mSpeedHalf", str(self.mSpeedHalf.get()))
config.set("Material", "mSpeedLow", str(self.mSpeedLow.get()))
config.set("Material", "mRadSpHigh", str(self.mRadSpHigh.get()))
config.set("Material", "mRadSpHalf", str(self.mRadSpHalf.get()))
config.set("Material", "mHeatSpHigh", str(self.mHeatSpHigh.get()))
config.set("Material", "mHeatSpLow", str(self.mHeatSpLow.get()))
config.set("Material", "mName", self.mName.get())
config.set("Table", "tableYY", str(self.tableYY.get()))
config.set("Table", "tableYG", str(self.tableYG.get()))
config.set("Table", "tableYD", str(self.tableYD.get()))
config.set("Table", "cMaxY", str(self.cMaxY.get()))
config.set("Table", "cMaxZ", str(self.cMaxZ.get()))
config.set("Table", "vMaxY", str(self.vMaxY.get()))
config.set("Table", "vMaxZ", str(self.vMaxZ.get()))
config.set("Table", "tHeatingMax", str(self.tHeatingMax.get()))
config.set("Table", "tName", self.tName.get())
config.set("Table", "tComPort", self.tComPort.get())
config.set("Table", "tBaudrate", self.tBaudrate.get())
config.set("Table", "tPreHeat", str(self.tPreHeat.get()))
config.set("Table", "tPostHeat", str(self.tPostHeat.get()))
config.set("Cut", "vCut", str(self.vCut.get()))
config.set("Cut", "gCodeStart1", self.gCodeStart1.get())
config.set("Cut", "gCodeStart2", self.gCodeStart2.get())
config.set("Cut", "gCodeStart3", self.gCodeStart3.get())
config.set("Cut", "gCodeStart4", self.gCodeStart4.get())
config.set("Cut", "gCodeEnd1", self.gCodeEnd1.get())
config.set("Cut", "gCodeEnd2", self.gCodeEnd2.get())
config.set("Cut", "gCodeEnd3", self.gCodeEnd3.get())
config.set("Cut", "gCodeEnd4", self.gCodeEnd4.get())
config.set("Cut", "gCodeLetters", self.gCodeLetters.get())
config.set("Guillotine", "gVSpeedNoCut", str(self.gVSpeedNoCut.get()))
config.set("Guillotine", "gHSpeedNoCut", str(self.gHSpeedNoCut.get()))
config.set("Guillotine", "gCuttingSpeed",
str(self.gCuttingSpeed.get()))
config.set("Guillotine", "gApplyCalculatedHeating",
str(self.gApplyCalculatedHeating.get()))
config.set("Guillotine", "gHeating", str(self.gHeating.get()))
config.set("Guillotine", "gType", self.gType.get())
config.set("Guillotine", "gCuttingWhile", self.gCuttingWhile.get())
config.set("Guillotine", "gVDist", str(self.gVDist.get()))
config.set("Guillotine", "gHDist", str(self.gHDist.get()))
configSaveFileName = filedialog.asksaveasfilename(title="Save as...", defaultextension="*.ini",\
filetypes=[("Ini files","*.ini"),("All files", "*")], initialfile=self.configUploadFileName)
if len(configSaveFileName) > 0:
config.write(open(configSaveFileName, 'w'))
def saveTable(self):
config = configparser.ConfigParser()
config.add_section("Table")
config.add_section("Cut")
config.set("Table", "tableYY", str(self.tableYY.get()))
config.set("Table", "tableYG", str(self.tableYG.get()))
config.set("Table", "tableYD", str(self.tableYD.get()))
config.set("Table", "cMaxY", str(self.cMaxY.get()))
config.set("Table", "cMaxZ", str(self.cMaxZ.get()))
config.set("Table", "vMaxY", str(self.vMaxY.get()))
config.set("Table", "vMaxZ", str(self.vMaxZ.get()))
config.set("Table", "tHeatingMax", str(self.tHeatingMax.get()))
config.set("Table", "tName", self.tName.get())
config.set("Table", "tComPort", self.tComPort.get())
config.set("Table", "tBaudrate", self.tBaudrate.get())
config.set("Table", "tPreHeat", str(self.tPreHeat.get()))
config.set("Table", "tPostHeat", str(self.tPostHeat.get()))
config.set("Cut", "vCut", str(self.vCut.get()))
config.set("Cut", "gCodeStart1", self.gCodeStart1.get())
config.set("Cut", "gCodeStart2", self.gCodeStart2.get())
config.set("Cut", "gCodeStart3", self.gCodeStart3.get())
config.set("Cut", "gCodeStart4", self.gCodeStart4.get())
config.set("Cut", "gCodeEnd1", self.gCodeEnd1.get())
config.set("Cut", "gCodeEnd2", self.gCodeEnd2.get())
config.set("Cut", "gCodeEnd3", self.gCodeEnd3.get())
config.set("Cut", "gCodeEnd4", self.gCodeEnd4.get())
config.set("Cut", "gCodeLetters", self.gCodeLetters.get())
if self.tableSaveFileName == None:
self.tableSaveFileName = self.tableUploadFileName
self.tableSaveFileName = filedialog.asksaveasfilename(title="Save table as...", defaultextension="*.tab",\
filetypes=[("Table files","*.tab"),("All files", "*")], initialfile=self.tableSaveFileName)
if len(self.tableSaveFileName) > 0:
config.write(open(self.tableSaveFileName, 'w'))
def saveMaterial(self):
config = configparser.ConfigParser()
config.add_section("Material")
config.set("Material", "mSpeedHigh", str(self.mSpeedHigh.get()))
config.set("Material", "mSpeedHalf", str(self.mSpeedHalf.get()))
config.set("Material", "mSpeedLow", str(self.mSpeedLow.get()))
config.set("Material", "mRadSpHigh", str(self.mRadSpHigh.get()))
config.set("Material", "mRadSpHalf", str(self.mRadSpHalf.get()))
config.set("Material", "mHeatSpHigh", str(self.mHeatSpHigh.get()))
config.set("Material", "mHeatSpLow", str(self.mHeatSpLow.get()))
config.set("Material", "mName", self.mName.get())
if self.materialSaveFileName == None:
self.materialSaveFileName = self.materialUploadFileName
self.materialSaveFileName = filedialog.asksaveasfilename(title="Save material as...", defaultextension="*.material",\
filetypes=[("Material files","*.material"),("All files", "*")], initialfile=self.materialSaveFileName)
if len(self.materialSaveFileName) > 0:
config.write(open(self.materialSaveFileName, 'w'))
def validatePart(self):
self.fTrailing.set(-(self.cRoot.get() - self.cTip.get() -
self.fLeading.get()))
if self.blocPosition.get() == "Left":
self.tBloc.blocToTableRightBox[
'validate'] = 'none' # disable validate, otherwise we call validate inside validate
self.blocToTableRight.set(self.tableYY.get() - self.tableYG.get() -
self.tableYD.get() -
self.blocToTableLeft.get() -
self.blocLX.get())
self.tBloc.blocToTableRightBox[
'validate'] = 'focusout' #enable after the update
else:
self.tBloc.blocToTableRightBox[
'validate'] = 'none' # disable validate, otherwise we call validate inside validate
self.blocToTableLeft.set(self.tableYY.get() - self.tableYG.get() -
self.tableYD.get() -
self.blocToTableRight.get() -
self.blocLX.get())
self.tBloc.blocToTableRightBox['validate'] = 'focusout'
self.blocToTableTrailingTip.set(self.blocToTableTrailingRoot.get() -
self.fTrailing.get())
self.blocToTableLeadingRoot.set(self.blocToTableTrailingRoot.get() +
self.cRoot.get() +
self.mTrailingRoot.get() +
self.mLeading.get())
self.blocToTableLeadingTip.set(self.blocToTableTrailingTip.get() +
self.cTip.get() +
self.mTrailingTip.get() +
self.mLeading.get())
#self.mSpeedHalf.set(self.mSpeedHigh.get() / 2) #half speed = high speed /2
def validateAll(self, level):
# level is used to avoid to recalculate some data when not needed
# 0 = calculate all (original profil change)
# 10 = calculate Transform and after (Transform profil: chord, incidence...)
# 20 = calculate Bloc/margin and after (change table or bloc position)
# 30 = calculate cutting (change speed, material)
if self.initDone and self.validateAllOn: #avoid validate during the set up of tkinter widgets and when validateAll is disabled
#try:
if level == 0:
self.tProfil.updatePlotRoot()
self.tProfil.updatePlotTip()
if level <= 10:
#create tRoot and tTipX based on oRoot and oTip and chords but not based on bloc and margin
# draw the view in Transform (= tRoot and tTip)
if (len(self.oRootX) > 0) and (len(self.oTipX) > 0):
#create tRoot and tTipX based on oRoot and oTip and chords but not based on bloc and margin
self.tTransform.validateTransform()
self.tTransform.updatePlotRoot()
self.tTransform.updatePlotTip()
if level <= 20:
pass
#create pRoot and pTipX based on tRoot and tTip and based on Table, bloc and margin
self.validatePart()
#print("validatePart is done")
self.calculatePositions()
#print("calculatepositions is done")
# draw the bloc ()
self.tBloc.updatePlotBloc()
#print("updatePlotBloc is done")
#draw the margins
self.tMargin.updatePlotMargin()
#print("updatePlotMargin is done")
#update heating for guillotine
self.tGuillotine.updateGuillotineHeating()
#print("updateGuillotineHeating is done")
if level <= 30: # calculate Cut based on Material
self.mSpeedHalf.set(self.mSpeedHigh.get() /
2) #half speed = high speed /2
if (len(self.pRootX) > 0) and (len(self.pTipX) > 0):
pass
#print("begin calculateRedraw")
self.tCut.calculateRedraw()
#print("end calculateRedraw")
warningMsg = ""
if (len(self.oRootX) <= 1) and (len(self.oTipX) <= 1):
warningMsg = "Root and Tip profiles missing"
elif len(self.oRootX) <= 1:
warningMsg = "Root profile missing"
elif len(self.oTipX) <= 1:
warningMsg = "Tip profile missing"
elif (self.tRootS.count(4) + self.tRootS.count(10)) != (
self.tTipS.count(4) + self.tTipS.count(10)):
warningMsg = "Transformed root and tip profiles must have the same number of synchro points"
self.warningMsg.set(warningMsg)
#next 2 lines are normally as comment
#except:
return True
def calculatePositions(self):
#create bRoot and bTipX based on tRoot and tTip and based on bloc and margin
#calculate Root and Tip offset to apply
if (len(self.tRootX) > 0) and (len(
self.tTipX) > 0): # and (len(self.tRootX) == len(self.tTipX)):
#calculate relative height of max, min leading
hMaxRootNorm, hMinRootNorm, hLeadingRootNorm = self.calculateRelativeHeigths(
self.tRootX, self.tRootY)
hMaxTipNorm, hMinTipNorm, hLeadingTipNorm = self.calculateRelativeHeigths(
self.tTipX, self.tTipY)
#Apply vertical aligment
if self.alignProfil.get() == "Trailing":
self.hTrailingRoot.set(self.hProfil.get())
self.hTrailingTip.set(self.hProfil.get())
elif self.alignProfil.get() == "Leading":
self.hTrailingRoot.set(self.hProfil.get() - hLeadingRootNorm)
self.hTrailingTip.set(self.hProfil.get() - hLeadingTipNorm)
elif self.alignProfil.get() == "Extrados":
self.hTrailingRoot.set(self.hProfil.get() - hMaxRootNorm)
self.hTrailingTip.set(self.hProfil.get() - hMaxTipNorm)
elif self.alignProfil.get() == "Intrados":
self.hTrailingRoot.set(self.hProfil.get() - hMinRootNorm)
self.hTrailingTip.set(self.hProfil.get() - hMinTipNorm)
self.hLeadingRoot.set(self.hTrailingRoot.get() + hLeadingRootNorm)
self.hLeadingTip.set(self.hTrailingTip.get() + hLeadingTipNorm)
self.hMaxRoot.set(self.blocHZ.get() - self.hTrailingRoot.get() -
hMaxRootNorm)
self.hMaxTip.set(self.blocHZ.get() - self.hTrailingTip.get() -
hMaxTipNorm)
self.hMinRoot.set(self.hTrailingRoot.get() + hMinRootNorm)
self.hMinTip.set(self.hTrailingTip.get() + hMinTipNorm)
#apply offsets
self.pRootX = self.tRootX + self.blocToTableTrailingRoot.get(
) + self.mTrailingRoot.get()
self.pTipX = self.tTipX + self.blocToTableTrailingTip.get(
) + self.mTrailingTip.get()
self.pRootY = self.tRootY + self.hOffset.get(
) + self.hTrailingRoot.get()
self.pTipY = self.tTipY + self.hOffset.get(
) + self.hTrailingRoot.get()
self.pRootS = list(self.tRootS) #create list of synchro
self.pTipS = list(self.tTipS) #create list of synchro
"""
def validateFloat(self, reason, val , name , old, min , max):
if reason == "focusout":
try :
v = float(val)
if v >= float(min) and v <= float(max):
return True
return True
except :
return False
elif reason == "focusout":
if float(val) > float(max):
print("focus out max exceeded")
return False
return self.validateAll()
return True
"""
def normaliseArrayProfil(self, aX, aY, chord):
#normalise the profil with chord
if len(aX) > 0:
minX = np.min(aX)
maxX = np.max(aX)
ratio = chord / (maxX - minX)
aXn = aX * ratio
aXn = aXn - aXn[0]
aXn = -1.0 * aXn # multiply by -1 to reverse the order
aYn = aY * ratio
aYn = aYn - aYn[0]
return aXn, aYn
"""
def normaliseProfil (self , pX , pY , coord , oY, oZ):
#normalise the profil with coord and offset of origin
if len(pX) > 0:
aX = np.array(pX)
aY = np.array(pY)
minX = np.min(aX)
idxMin = np.where(aX == minX) #return an array with indexes
maxX = np.max(aX)
minY = np.min(aY)
maxY = np.max(aY)
ratio= coord / ( maxX - minX )
aX = aX * ratio
aX = aX - aX[0]
aX = -1 * aX # multiply by -1 to reverse the order
aX = aX + oY
aY = aY * ratio
aY = aY - aY[0]
aY = aY + oZ
maxh = (maxY / ( maxX - minX ) ) - pY[0]
minh = (minY / ( maxX - minX ) ) - pY[0]
if len(idxMin) > 0 and len(idxMin[0]) > 0:
r = idxMin[0][0]
leadingh = (pY[r] / ( maxX - minX ) ) - pY[0]
else:
leadingh = 0
#print("normalised aX=", aX , "aY=", aY)
return aX.tolist() , aY.tolist() ,maxh ,minh, leadingh
"""
def calculateRelativeHeigths(self, pX, pY):
maxX = np.max(pX)
idxMax = np.where(pX == maxX) #return an array with indexes
minY = np.min(pY)
maxY = np.max(pY)
maxh = maxY - pY[0]
minh = minY - pY[0]
if len(idxMax) > 0 and len(idxMax[0]) > 0:
r = idxMax[0][0]
leadingh = pY[r] - pY[0]
else:
leadingh = 0
return maxh, minh, leadingh
class Calc:
def __init__(self, master):
self.master = master
self.master.title("Calculator")
#self.master.geometry("400x300")
self.master.bind('<Return>', self.get_field)
self.total = 0
self.total_var = DoubleVar()
self.total_var.set(self.total)
self.expression = ''
self.exp = StringVar()
self.exp_label = Label(self.master, textvariable=self.exp)
self.exp_label.grid(row=0, column=0)
self.total_label = Label(self.master, textvariable=self.total_var)
self.total_label.grid(row=0, column=1)
# optional input field
self.enter = Entry(self.master)
self.enter.grid(row=1, column=1)
# creating operation buttons
self.plus = Button(self.master,
text='+',
command=lambda: self.update('+'))
self.plus.grid(row=4, column=3)
self.minus = Button(self.master,
text='-',
command=lambda: self.update('-'))
self.minus.grid(row=5, column=3)
self.multiply = Button(self.master,
text='*',
command=lambda: self.update('*'))
self.multiply.grid(row=2, column=3)
self.divide = Button(self.master,
text='/',
command=lambda: self.update('/'))
self.divide.grid(row=3, column=3)
self.delete = Button(self.master,
text='del',
command=lambda: self.update('del'))
self.delete.grid(row=1, column=2)
self.mod = Button(self.master,
text='%',
command=lambda: self.update('%'))
self.mod.grid(row=5, column=2)
self.exponent = Button(self.master,
text='^',
command=lambda: self.update('**'))
self.exponent.grid(row=6, column=2)
self.dot = Button(self.master,
text='.',
command=lambda: self.update('.'))
self.dot.grid(row=5, column=1)
self.equal = Button(self.master,
text='=',
command=lambda: self.update('='))
self.equal.grid(row=6, column=3)
self.reset = Button(self.master,
text='C',
command=lambda: self.update('C'))
self.reset.grid(row=1, column=3)
# start with 2 row and default column
row = 2
column = 0
# create 9 integers buttons
for num in range(10):
# add function to every button, on press -> add number to expression
number = Button(self.master,
text=str(num),
command=lambda num=num: self.update(str(num)))
number.grid(row=row, column=column)
# numbers will be in 3 columns if it's third column -> move to next row
if column == 2:
column = 0
row += 1
else:
column += 1
def get_field(self, event):
# in input field empty we use existing total
if self.enter.get() == "":
self.expression += str(self.total)
# if input start with operation -> use existing total as first number
elif self.enter.get()[0] in "+-/*%":
self.expression = str(self.total_var.get()) + self.enter.get()
else:
self.expression += self.enter.get()
self.exp.set(self.expression)
self.enter.delete(0, END)
def update(self, char):
# clear all
if char == 'C':
self.expression = ""
self.total = 0
# delete last element from expression
elif char == "del":
self.expression = self.expression[:-1]
elif char == '=':
try:
# evaluate expression
self.total = eval(self.expression)
self.expression = ""
except NameError:
messagebox.showerror("Error", "You entered character")
except ZeroDivisionError:
messagebox.showerror("Error", "You cannot divide by zero")
else:
# add value to expression
self.expression += char
# if expression start with operation -> use existing total as first number
if self.expression[0] in "+-/*%":
self.expression = str(float(
self.total_var.get())) + self.expression
self.exp.set(self.expression)
self.total_var.set(self.total)
self.enter.delete(0, END)
class AppRow(MagicSession, Frame):
"""
Row for each app in mixer.
handles refreshing the gui if session is changed external.
handles user input and changing session volume/mute.
"""
def __init__(self, root_frame_instance):
super().__init__(volume_callback=self.update_volume,
mute_callback=self.update_mute,
state_callback=self.update_state)
self.root_frame_instance = root_frame_instance
# ______________ DISPLAY NAME ______________
self.app_name = self.magic_root_session.app_exec
print(f":: new session: {self.app_name}")
# ______________ CREATE FRAME ______________
# super(MagicSession, self).__init__(root_frame_instance)
Frame.__init__(self, root_frame_instance)
# _______________ NAME LABEL _______________
self.name_label = Label(self,
text=self.app_name,
font=("Consolas", 12, "italic"))
# _____________ VOLUME SLIDER _____________
self.volume_slider_state = DoubleVar()
self.volume_slider = Scale(self,
variable=self.volume_slider_state,
command=self._slide_volume,
from_=0,
to=100,
takefocus=False,
orient=HORIZONTAL)
# set initial:
self.volume_slider_state.set(self.volume * 100)
# ______________ MUTE BUTTON ______________
self.mute_button_state = StringVar()
self.mute_button = Button(self,
style="",
textvariable=self.mute_button_state,
command=self._toogle_mute,
takefocus=False)
# set initial:
self.update_mute(self.mute)
# _____________ SESSION STATUS _____________
self.status_line = Frame(self, style="", width=6)
# set initial:
self.update_state(self.state)
# ________________ SEPARATE ________________
self.separate = Separator(self, orient=HORIZONTAL)
# ____________ ARRANGE ELEMENTS ____________
# set column[1] to take the most space
# and make all others as small as possible:
self.columnconfigure(1, weight=1)
# grid
self.name_label.grid(row=0, column=0, columnspan=2, sticky="EW")
self.mute_button.grid(row=1, column=0)
self.volume_slider.grid(row=1, column=1, sticky="EW", pady=10, padx=20)
self.separate.grid(row=2, column=0, columnspan=3, sticky="EW", pady=10)
self.status_line.grid(row=0, rowspan=2, column=2, sticky="NS")
# _____________ DISPLAY FRAME _____________
self.pack(pady=0, padx=15, fill='x')
def update_volume(self, new_volume):
"""
when volume is changed externally
(see callback -> AudioSessionEvents -> OnSimpleVolumeChanged )
"""
# compare if the windows callback is because we set the slider:
# if so drop update since we made the change
# and all is already up to date - this will prevent lagg
print(f"{self.app_name} volume: {new_volume}")
self.volume_slider_state.set(new_volume * 100)
def update_mute(self, new_mute):
""" when mute state is changed by user or through other app """
if new_mute:
icon = "🔈"
self.mute_button.configure(style="Muted.TButton")
else:
icon = "🔊"
self.mute_button.configure(style="Unmuted.TButton")
# .set is a method of tkinters variables
# it will change the button text
print(f"{self.app_name} mute: {icon}")
self.mute_button_state.set(icon)
def update_state(self, new_state):
"""
when status changed
(see callback -> AudioSessionEvents -> OnStateChanged)
"""
print(f"{self.app_name} state: {new_state}")
if new_state == AudioSessionState.Inactive:
# AudioSessionStateInactive
self.status_line.configure(style="Inactive.TFrame")
elif new_state == AudioSessionState.Active:
# AudioSessionStateActive
self.status_line.configure(style="Active.TFrame")
elif new_state == AudioSessionState.Expired:
# AudioSessionStateExpired
self.status_line.configure(style="TFrame")
"""when session expires"""
print(f":: closed session: {self.app_name}")
self.destroy()
def _slide_volume(self, value):
""" when slider moved by user """
new_volume = float(value) / 100
# check if new user value really is new: (ttk bug)
if self.volume != new_volume:
# since self.volume is true data through windows
# it will generally differ, but 1.0 == 1
print(f"with pycaw: {self.app_name} volume: {new_volume}")
self.volume = new_volume
def _toogle_mute(self):
""" when mute button pressed """
new_mute = self.toggle_mute()
self.update_mute(new_mute)
class SettingsFrame(Frame):
"""
Frame inheritance class for application settings and controls.
"""
def __init__(self, app, *args, **kwargs):
"""
Constructor
"""
self.__app = app # Reference to main application class
self.__master = self.__app.get_master() # Reference to root class (Tk)
Frame.__init__(self, self.__master, *args, **kwargs)
# Initialise up key variables
self._image_num = 0
self._image_name = "image"
self._settype = StringVar()
self._zoom = DoubleVar()
self._radius = DoubleVar()
self._exponent = IntVar()
self._zx_off = DoubleVar()
self._zy_off = DoubleVar()
self._cx_off = DoubleVar()
self._cy_off = DoubleVar()
self._maxiter = IntVar()
self._zx_coord = DoubleVar()
self._zy_coord = DoubleVar()
self._theme = StringVar()
self._shift = IntVar()
self._themes = None
self._filename = StringVar()
self._filepath = None
self._frames = IntVar()
self._zoominc = DoubleVar()
self._autoiter = IntVar()
self._autosave = IntVar()
self._validsettings = True
self.body()
def body(self):
"""
Set up frame and widgets.
"""
# Create settings panel widgets
# pylint: disable=W0108
self.lbl_settype = Label(self, text=LBLMODE)
self.spn_settype = Spinbox(
self,
values=("BurningShip", "Tricorn", "Julia", "Mandelbrot"),
width=8,
bg=GOOD,
wrap=True,
textvariable=self._settype,
)
self.lbl_zoom = Label(self, text=LBLZOOM)
self.ent_zoom = Entry(
self,
border=2,
relief="sunken",
width=12,
bg=GOOD,
justify=RIGHT,
textvariable=self._zoom,
)
self.lbl_zoominc = Label(self, text=LBLZOOMINC, justify=LEFT)
self.ent_zoominc = Entry(self,
width=5,
border=2,
bg=GOOD,
justify=RIGHT,
textvariable=self._zoominc)
self.lbl_zx_off = Label(self, text=LBLZXOFF)
self.ent_zx_off = Entry(
self,
border=2,
relief="sunken",
width=12,
bg=GOOD,
justify=RIGHT,
textvariable=self._zx_off,
)
self.lbl_zy_off = Label(self, text=LBLZYOFF)
self.ent_zy_off = Entry(
self,
border=2,
relief="sunken",
width=12,
bg=GOOD,
justify=RIGHT,
textvariable=self._zy_off,
)
self.lbl_cx_off = Label(self, text=LBLCX)
self.ent_cx_off = Entry(
self,
border=2,
relief="sunken",
width=12,
bg=GOOD,
justify=RIGHT,
textvariable=self._cx_off,
state=DISABLED,
)
self.lbl_cy_off = Label(self, text=LBLCY)
self.ent_cy_off = Entry(
self,
border=2,
relief="sunken",
width=12,
bg=GOOD,
justify=RIGHT,
textvariable=self._cy_off,
state=DISABLED,
)
self.lbl_niter = Label(self, text=LBLITER, justify=LEFT)
self.ent_maxiter = Entry(
self,
border=2,
relief="sunken",
bg=GOOD,
width=8,
justify=RIGHT,
textvariable=self._maxiter,
)
self.chk_autoiter = Checkbutton(self,
text="Auto",
variable=self._autoiter,
onvalue=1,
offvalue=0)
self.lbl_theme = Label(self, text=LBLTHEME, justify=LEFT)
self.lbl_radius = Label(self, text=LBLRAD, justify=LEFT)
self.ent_radius = Entry(
self,
border=2,
relief="sunken",
bg=GOOD,
width=8,
justify=RIGHT,
textvariable=self._radius,
)
self.lbl_exp = Label(self, text=LBLEXP)
self.spn_exp = Spinbox(
self,
border=2,
relief="sunken",
bg=GOOD,
width=4,
from_=2,
to=20,
wrap=True,
textvariable=self._exponent,
)
self.sep_1 = ttk.Separator(
self,
orient=HORIZONTAL,
)
self.lbx_theme = Listbox(
self,
border=2,
relief="sunken",
bg=GOOD,
width=6,
height=5,
justify=LEFT,
exportselection=False,
)
self.lbl_shift = Label(self, text=LBLSHIFT, justify=LEFT)
self.scl_shift = Scale(
self,
from_=0,
to=100,
orient=HORIZONTAL,
variable=self._shift,
border=2,
relief="sunken",
sliderlength=20,
troughcolor=GOOD,
)
self.scrollbar = Scrollbar(self, orient=VERTICAL)
self.lbx_theme.config(yscrollcommand=self.scrollbar.set)
self.scrollbar.config(command=self.lbx_theme.yview)
self.lbx_theme.select_set(0)
self.lbx_theme.event_generate("<<ListboxSelect>>")
self.lbl_coords = Label(self, text="Re, Im", fg="grey")
self.btn_plot = Button(
self,
text=BTNPLOT,
width=8,
fg="green",
command=lambda: self.__app.frm_fractal.plot(),
)
self.btn_cancel = Button(
self,
text=BTNCAN,
width=8,
command=lambda: self.__app.frm_fractal.cancel_press(),
)
self.btn_reset = Button(self, text=BTNRST, width=8, command=self.reset)
self.ent_save = Entry(
self,
textvariable=self._filename,
width=6,
border=2,
relief="sunken",
bg=GOOD,
justify=LEFT,
)
self._filename.set(self._image_name + str(self._image_num))
self.btn_save = Button(self,
text=BTNSAVE,
width=8,
command=self.save_image)
self.lbl_auto = Label(self, text=LBLAUTO, justify=LEFT)
self.btn_autozoom = Button(
self,
text=BTNZOOM,
width=8,
command=lambda: self.__app.frm_fractal.animate_zoom(),
)
self.btn_autospin = Button(
self,
text=BTNSPIN,
width=8,
command=lambda: self.__app.frm_fractal.animate_spin(),
state=DISABLED,
)
self.chk_autosave = Checkbutton(self,
text=BTNSAVE,
variable=self._autosave,
onvalue=1,
offvalue=0)
self.lbl_frames = Label(self, text=FRMSTXT)
self.ent_frames = Entry(self,
width=5,
border=2,
bg=GOOD,
justify=RIGHT,
textvariable=self._frames)
# Get list of available themes
for idx, theme in enumerate(THEMES):
self.lbx_theme.insert(idx, theme)
self.body_arrange() # Position all widgets in frame
self.reset() # Reset all settings to their defaults
self.set_traces(
) # Trace entry variables for validation and event handling
def body_arrange(self):
"""
Position widgets in frame
"""
# Position all widgets in their parent frames
self.btn_plot.grid(column=0,
row=1,
ipadx=3,
ipady=3,
sticky=(W),
padx=3,
pady=3)
self.btn_cancel.grid(column=1,
row=1,
ipadx=3,
ipady=3,
sticky=(W),
padx=3,
pady=3)
self.btn_reset.grid(column=2,
row=1,
ipadx=3,
ipady=3,
sticky=(W),
padx=3,
pady=3)
self.ent_save.grid(column=0,
row=2,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.btn_save.grid(column=2,
row=2,
ipadx=3,
ipady=3,
sticky=(W),
padx=3,
pady=3)
self.lbl_auto.grid(column=0, row=3, sticky=(W))
self.btn_autozoom.grid(column=1,
row=3,
ipadx=3,
ipady=3,
sticky=(W),
padx=3,
pady=3)
self.btn_autospin.grid(column=2,
row=3,
ipadx=3,
ipady=3,
sticky=(W),
padx=3,
pady=3)
self.lbl_frames.grid(column=0, row=4, sticky=(W))
self.ent_frames.grid(column=1, row=4, sticky=(W), padx=3, pady=3)
self.chk_autosave.grid(column=2, row=4, sticky=(W), padx=3, pady=3)
self.sep_1.grid(column=0, row=5, columnspan=3, pady=5, sticky=(W, E))
self.lbl_settype.grid(column=0, row=6, sticky=(W))
self.spn_settype.grid(column=1,
row=6,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.lbl_zoom.grid(column=0, row=7, sticky=(W))
self.ent_zoom.grid(column=1,
row=7,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.lbl_zoominc.grid(column=0, row=8, sticky=(W))
self.ent_zoominc.grid(column=1, row=8, sticky=(W), padx=3, pady=3)
self.lbl_zx_off.grid(column=0, row=9, sticky=(W))
self.ent_zx_off.grid(column=1,
row=9,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.lbl_zy_off.grid(column=0, row=10, sticky=(W))
self.ent_zy_off.grid(column=1,
row=10,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.lbl_cx_off.grid(column=0, row=11, sticky=(W))
self.ent_cx_off.grid(column=1,
row=11,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.lbl_cy_off.grid(column=0, row=12, sticky=(W))
self.ent_cy_off.grid(column=1,
row=12,
columnspan=2,
sticky=(W, E),
padx=3,
pady=3)
self.lbl_niter.grid(column=0, row=13, sticky=(W))
self.ent_maxiter.grid(column=1, row=13, sticky=(W), padx=3, pady=3)
self.chk_autoiter.grid(column=2, row=13, sticky=(W), padx=3, pady=3)
self.lbl_radius.grid(column=0, row=14, sticky=(W))
self.ent_radius.grid(column=1, row=14, sticky=(W), padx=3, pady=3)
self.lbl_exp.grid(column=0, row=15, sticky=(W))
self.spn_exp.grid(column=1, row=15, sticky=(W), padx=3, pady=3)
self.lbl_theme.grid(column=0, row=16, sticky=(W))
self.lbx_theme.grid(column=1,
row=16,
padx=3,
pady=3,
columnspan=2,
sticky=(N, S, W, E))
self.scrollbar.grid(column=2, row=16, sticky=(N, S, E))
self.lbl_shift.grid(column=0, row=17, sticky=(W))
self.scl_shift.grid(column=1,
row=17,
columnspan=2,
padx=3,
pady=3,
sticky=(W, E))
self.lbx_theme.bind("<<ListboxSelect>>", self.get_sel_theme)
def set_traces(self):
"""
Set up entry variable traces for validation and event handling
"""
self._validsettings = True
self._settype.trace("w", self.val_settings)
self._zoom.trace("w", self.val_settings)
self._zx_off.trace("w", self.val_settings)
self._zy_off.trace("w", self.val_settings)
self._cx_off.trace("w", self.val_settings)
self._cy_off.trace("w", self.val_settings)
self._maxiter.trace("w", self.val_settings)
self._radius.trace("w", self.val_settings)
self._exponent.trace("w", self.val_settings)
self._filename.trace("w", self.val_settings)
self._frames.trace("w", self.val_settings)
self._zoominc.trace("w", self.val_settings)
def val_settings(self, *args, **kwargs):
"""
Validate all user-entered settings.
(A personal choice but I find this user experience more intuitive
than the standard validatecommand method for Entry widgets)
"""
self._validsettings = True
self.__app.set_status("")
if self.is_float(self.ent_zoom.get()) and self._zoom.get() > 0:
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_zoom, flg)
if self.is_float(self.ent_zx_off.get()):
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_zx_off, flg)
if self.is_float(self.ent_zy_off.get()):
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_zy_off, flg)
if self.is_float(self.ent_cx_off.get()):
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_cx_off, flg)
if self.is_float(self.ent_cy_off.get()):
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_cy_off, flg)
if self.is_integer(self.ent_maxiter.get()) and self._maxiter.get() > 0:
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_maxiter, flg)
if self.is_float(self.ent_radius.get()) and self._radius.get() > 0:
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_radius, flg)
if self.is_integer(self.spn_exp.get()) and self._exponent.get() > 1:
flg = GOOD
else:
flg = BAD
self.flag_entry(self.spn_exp, flg)
if self.is_integer(self.ent_frames.get()) and self._frames.get() > 0:
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_frames, flg)
if self.is_float(self.ent_zoominc.get()) and self._zoominc.get() > 0:
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_zoominc, flg)
if self.is_filename(self.ent_save.get()):
flg = GOOD
else:
flg = BAD
self.flag_entry(self.ent_save, flg)
if self.spn_settype.get() in {"Mandelbrot", "Tricorn", "BurningShip"}:
self.btn_autospin.config(state=DISABLED)
self.ent_cx_off.config(state=DISABLED)
self.ent_cy_off.config(state=DISABLED)
self._cx_off.set(0)
self._cy_off.set(0)
flg = GOOD
elif self.spn_settype.get() == "Julia":
self.btn_autospin.config(state=NORMAL)
self.ent_cx_off.config(state=NORMAL)
self.ent_cy_off.config(state=NORMAL)
flg = GOOD
else:
flg = BAD
self.flag_entry(self.spn_settype, flg)
def flag_entry(self, ent, flag):
"""
Flag entry field as valid or invalid and set global validity status flag.
This flag is used throughout to determine whether functions can proceed
or not.
"""
ent.config(bg=flag)
if flag == BAD:
self._validsettings = False
self.__app.set_status(VALERROR, "red")
def is_float(self, flag):
"""
Validate if entry is a float.
"""
try:
float(flag)
return True
except ValueError:
return False
def is_integer(self, flag):
"""
Validate if entry is a positive integer.
"""
try:
int(flag)
if int(flag) > 0:
return True
return False
except ValueError:
return False
def is_filename(self, flag):
"""
Validate if entry represents a valid filename using a regexp.
"""
return match("^[\w\-. ]+$", flag) and flag != ""
def reset(self):
"""
Reset settings to defaults.
"""
self._settype.set("Mandelbrot")
self._zoom.set(0.75)
self._zx_off.set(-0.5)
self._zy_off.set(0.0)
self._cx_off.set(0.0)
self._cy_off.set(0.0)
self._maxiter.set(128)
self._radius.set(2.0)
self._exponent.set(2)
self._frames.set(10)
self._zoominc.set(2.0)
self._autoiter.set(1)
self._autosave.set(0)
self._theme.set("Default")
self._filename.set("image0")
self._shift.set(0)
self.set_sel_theme()
self.__app.set_status(SETINITTXT)
def get_sel_theme(self, *args, **kwargs):
"""
Get selected theme from listbox and set global variable.
"""
idx = self.lbx_theme.curselection()
if idx == "":
idx = 0
self._theme.set(self.lbx_theme.get(idx))
def set_sel_theme(self):
"""
Lookup index of selected theme and highlight that listbox position.
NB: this requires 'exportselection=False' option to be set on listbox to
work properly.
"""
for idx, theme in enumerate(THEMES):
if theme == self._theme.get():
self.lbx_theme.activate(idx)
self.lbx_theme.see(idx)
break
def get_settings(self):
"""
Return all current settings as a dict.
"""
if not self._validsettings:
settings = {"valid": self._validsettings}
return settings
settings = {
"settype": self._settype.get(),
"zoom": self._zoom.get(),
"zxoffset": self._zx_off.get(),
"zyoffset": self._zy_off.get(),
"cxoffset": self._cx_off.get(),
"cyoffset": self._cy_off.get(),
"maxiter": self._maxiter.get(),
"autoiter": self._autoiter.get(),
"autosave": self._autosave.get(),
"radius": self._radius.get(),
"exponent": self._exponent.get(),
"theme": self._theme.get(),
"shift": self._shift.get(),
"filepath": self._filepath,
"filename": self._filename.get(),
"frames": self._frames.get(),
"zoominc": self._zoominc.get(),
"valid": self._validsettings,
}
return settings
def update_settings(self, **kwargs):
"""
Update settings from keyword parms.
"""
if "settype" in kwargs:
self._settype.set(kwargs["settype"])
if "zoom" in kwargs:
self._zoom.set(kwargs["zoom"])
if "zxoffset" in kwargs:
self._zx_off.set(kwargs["zxoffset"])
if "zyoffset" in kwargs:
self._zy_off.set(kwargs["zyoffset"])
if "cxoffset" in kwargs:
self._cx_off.set(kwargs["cxoffset"])
if "cyoffset" in kwargs:
self._cy_off.set(kwargs["cyoffset"])
if "maxiter" in kwargs:
self._maxiter.set(kwargs["maxiter"])
if "autoiter" in kwargs:
self._autoiter.set(kwargs["autoiter"])
if "autosave" in kwargs:
self._autosave.set(kwargs["autosave"])
if "radius" in kwargs:
self._radius.set(kwargs["radius"])
if "exponent" in kwargs:
self._exponent.set(kwargs["exponent"])
if "filepath" in kwargs:
self._filepath.set(kwargs["filepath"])
if "filename" in kwargs:
self._filename.set(kwargs["filename"])
if "frames" in kwargs:
self._frames.set(kwargs["frames"])
if "zoominc" in kwargs:
self._zoominc.set(kwargs["zoominc"])
if "theme" in kwargs:
self._theme.set(kwargs["theme"])
self.set_sel_theme()
if "shift" in kwargs:
self._shift.set(kwargs["shift"])
def set_filepath(self):
"""
Sets filepath for saved files for the duration of this session.
"""
default = os.getcwd() # Default _filepath is current working directory
if self._filepath is None:
self._filepath = filedialog.askdirectory(title=SAVETITLE,
initialdir=default,
mustexist=True)
if self._filepath == "":
self._filepath = None # User cancelled
return self._filepath
def save_image(self):
"""
Save image as PNG file to selected filepath and automatically increment default
image name. NB: currently this will overwrite any existing file of the same
name without warning.
"""
# Bug out if the settings are invalid
settings = self.__app.frm_settings.get_settings()
if not settings["valid"]:
return
# Check if image has been created
image = self.__app.frm_fractal.mandelbrot.get_image()
if image is None:
self.__app.set_status(NOIMGERROR, "red")
return
# Set _filename and path
if self.set_filepath() is None: # User cancelled
return
fname = self._filename.get()
fqname = self._filepath + "/" + fname
# Save the image along with its metadata
try:
# image.write(fqname + ".png", format="png")
image.save(fqname + ".png", format="png")
self.save_metadata()
except OSError:
self.__app.set_status(SAVEERROR, "red")
self._filepath = None
return
self._image_num += 1
self._filename.set(self._image_name + str(self._image_num))
self.__app.set_status(IMGSAVETXT + fqname + ".png", "green")
# Return focus to image frame
self.__app.frm_fractal.focus_set()
def save_metadata(self):
"""
Save json file containing meta data associated with image,
allowing it to be imported and reproduced.
"""
if self._filepath is None:
if self.set_filepath() is None: # User cancelled
return
fname = self._filename.get()
fqname = self._filepath + "/" + fname
filename = fqname + ".json"
createtime = strftime("%b %d %Y %H:%M:%S %Z", gmtime())
jsondata = {
MODULENAME: {
"filename": fqname + ".png",
"created": createtime,
"settype": self._settype.get(),
"zoom": self._zoom.get(),
"zoominc": self._zoominc.get(),
"frames": self._frames.get(),
"escradius": self._radius.get(),
"exponent": self._exponent.get(),
"maxiter": self._maxiter.get(),
"zxoffset": self._zx_off.get(),
"zyoffset": self._zy_off.get(),
"cxoffset": self._cx_off.get(),
"cyoffset": self._cy_off.get(),
"theme": self._theme.get(),
"shift": self._shift.get(),
}
}
try:
with open(filename, "w") as outfile:
dump(jsondata, outfile)
except OSError:
self.__app.set_status(METASAVEERROR, "red")
self._filepath = None
# Return focus to image frame
self.__app.frm_fractal.focus_set()
def import_metadata(self):
"""
Update settings from imported json metadata file.
"""
# Select and read file
try:
default = os.getcwd()
filepath = filedialog.askopenfilename(
initialdir=default,
title=SELTITLE,
filetypes=(("json files", "*.json"), ("all files", "*.*")),
)
if filepath == "": # User cancelled
return
with open(filepath, "r") as infile:
jsondata = infile.read()
except OSError:
self.__app.set_status(OPENFILEERROR, "red")
return
# Parse file
try:
settings = loads(jsondata).get(MODULENAME)
# Set plot parameters
self._settype.set(settings.get("settype", "Mandelbrot"))
self._zoom.set(settings.get("zoom", 1))
self._zoominc.set(settings.get("zoominc", 2.0))
self._frames.set(settings.get("frames", 10))
self._radius.set(settings.get("escradius", 2.0))
self._exponent.set(settings.get("exponent", 2))
self._maxiter.set(settings.get("maxiter", 256))
self._zx_off.set(settings.get("zxoffset", 0))
self._zy_off.set(settings.get("zyoffset", 0))
self._cx_off.set(settings.get("cxoffset", 0))
self._cy_off.set(settings.get("cyoffset", 0))
self._theme.set(settings.get("theme", "Default"))
self._shift.set(settings.get("shift", 0))
except OSError:
self.__app.set_status(BADJSONERROR, "red")
return
self.set_sel_theme()
fbase = os.path.basename(filepath)
filename, fileext = os.path.splitext(fbase)
self.__app.set_status(
"Metadata file " + filename + fileext + METAPROMPTTXT, "green")
# Return focus to image frame
self.__app.frm_fractal.focus_set()
class SmashCalc(ttk.Frame):
def __init__(self, parent):
print("SmashCalc __init__")
ttk.Frame.__init__(self, parent)
self.parent = parent
self.chars_url = "{}/characters".format(api_url)
self.get_chars()
self.init_ui()
self.rage = 1
self.move_name = ""
self.enemy_weight = -1
def init_ui(self):
print("UI init")
self.set_title()
# charbox = ttk.Listbox()
print("making frames")
print(type(self.parent))
self.content = ttk.Frame(self.parent, padding=10)
print(type(self.content))
self.content.grid(column=0, row=0, sticky="NSEW")
# self.user_image
# self.enemy_image
print("making boxes")
self.init_user()
self.init_enemy()
self.init_move()
def init_user(self):
self.user_frame = ttk.Frame(self.content, borderwidth=2)
self.user_frame.grid(column=0, row=0)
self.user_frame['padding'] = (20, 10)
# self.user_frame['borderwidth'] = 2
self.user_frame['relief'] = 'sunken'
self.user_label = ttk.Label(self.user_frame, text="Attacker")
self.user_label.grid(column=0, row=0, columnspan=2, rowspan=1)
self.userchar = StringVar()
self.userchar.set('none')
self.user_menu = ttk.Combobox(self.user_frame)
self.user_menu.grid(column=0, row=1, columnspan=2, rowspan=1)
self.user_menu['values'] = self.chars
self.user_menu.bind('<<ComboboxSelected>>', self.on_user_menu_input)
self.userdmg = StringVar()
self.userdmg.set('')
self.userdmg.trace('w', self.on_user_damage_input)
self.rage_box = ttk.Label(self.user_frame, text="Rage multiplier:")
self.rage_box.grid(column=0, row=5, columnspan=2, sticky="W")
self.user_percentbox = ttk.Label(self.user_frame, text="%:")
self.user_percentbox.grid(column=0,
row=2,
columnspan=1,
rowspan=1,
sticky="W")
validate_cmd = (self.register(self.on_percent_validate), '%d', '%S',
'%P')
self.user_damage_entry = ttk.Entry(self.user_frame,
textvariable=self.userdmg,
validate="key",
validatecommand=validate_cmd)
self.user_damage_entry.grid(column=1,
row=2,
columnspan=1,
rowspan=1,
sticky="W")
def init_enemy(self):
self.enemy_frame = ttk.Frame(self.content, borderwidth=2)
self.enemy_frame.grid(column=1, row=0)
self.enemy_frame['padding'] = (20, 10)
# self.enemy_frame['borderwidth'] = 2
self.enemy_frame['relief'] = 'sunken'
self.enemy_label = ttk.Label(self.enemy_frame, text="Target")
self.enemy_label.grid(column=0, row=0, columnspan=2, rowspan=1)
self.enemychar = StringVar()
self.enemychar.set('none')
self.enemy_menu = ttk.Combobox(self.enemy_frame)
self.enemy_menu.grid(column=0, row=1, columnspan=2, rowspan=1)
self.enemy_menu['values'] = self.chars
self.enemy_menu.bind('<<ComboboxSelected>>', self.on_enemy_menu_input)
self.enemydmg = StringVar()
self.enemydmg.set('')
self.enemydmg.trace('w', self.on_enemy_damage_input)
self.enemy_percentbox = ttk.Label(self.enemy_frame, text="%:")
self.enemy_percentbox.grid(column=0,
row=2,
columnspan=1,
rowspan=1,
sticky="W")
validate_cmd = (self.register(self.on_percent_validate), '%d', '%S',
'%P')
self.enemy_damage_entry = ttk.Entry(self.enemy_frame,
textvariable=self.enemydmg,
validate="key",
validatecommand=validate_cmd)
self.enemy_damage_entry.grid(column=1,
row=2,
columnspan=1,
rowspan=1,
sticky="W")
self.weight_box = ttk.Label(self.enemy_frame, text="Weight:")
self.weight_box.grid(column=0, row=3, columnspan=2, sticky="W")
self.is_crouch = DoubleVar()
self.is_smash = DoubleVar()
self.is_meteor = DoubleVar()
self.is_crouch.set(1)
self.is_smash.set(1)
self.is_meteor.set(1)
self.crouch_check = ttk.Checkbutton(self.enemy_frame,
variable=self.is_crouch,
text="Crouching",
command=self.on_crouch_check,
offvalue=1,
onvalue=0.85)
self.smash_check = ttk.Checkbutton(self.enemy_frame,
variable=self.is_smash,
text="Charging smash",
command=self.on_smash_check,
offvalue=1,
onvalue=1.2)
self.meteor_check = ttk.Checkbutton(self.enemy_frame,
variable=self.is_meteor,
text="Grounded meteor",
command=self.on_meteor_check,
offvalue=1,
onvalue=0.8)
self.crouch_check.grid(column=2, row=1, sticky="W")
self.smash_check.grid(column=2, row=2, sticky="W")
self.meteor_check.grid(column=2, row=3, sticky="W")
def init_move(self):
self.move_frame = ttk.Frame(self.content, borderwidth=2)
self.move_frame['padding'] = (20, 10)
# self.move_frame['borderwidth'] = 2
self.move_frame['relief'] = 'sunken'
self.move_frame.grid(column=0, row=1, columnspan=2, sticky="WE")
self.move_label = ttk.Label(self.move_frame, text="Attacking move:")
self.move_label.grid(column=0, row=0, sticky="W")
self.move_menu = ttk.Combobox(self.move_frame)
self.move_menu.grid(column=0,
row=1,
columnspan=1,
rowspan=1,
sticky="NSEW")
self.move_menu['width'] = 40
# self.moves = []
# self.move_menu['values'] = self.moves
self.move_menu.bind('<<ComboboxSelected>>', self.on_move_menu_input)
self.move_info_frame = MoveFrame(self.move_frame)
def get_chars(self):
print("getting all char data")
response = urllib.request.urlopen(
self.chars_url).read().decode('utf-8')
chars_data = json.loads(response)
self.chars = []
self.name_to_id = {}
for char in chars_data:
self.chars.append(char['name'])
self.name_to_id[char['name']] = char['id']
def set_title(self, title=""):
if (title != ""):
self.parent.title("SmashCalc - {}".format(title))
else:
self.parent.title("SmashCalc")
def on_user_menu_input(self, val):
self.userchar = self.user_menu.get()
print("user entry! {}".format(self.userchar))
moves_url = "{}/characters/{}/moves".format(
api_url, self.name_to_id[self.userchar])
response = urllib.request.urlopen(moves_url).read().decode('utf-8')
self.moves_data = json.loads(response)
self.moves = []
self.move_to_id = {}
self.moves_dict = {}
for move in self.moves_data:
print(type(move))
print(move)
# print(type(self.move_to_id))
# print(self.move_to_id)
# print("{}, {}".format(move['name'], move['id']))
self.moves.append(move['name'])
# self.move_to_id[move['name']] = move['id']
self.moves_dict[move['name']] = move
self.set_title(self.userchar)
self.move_info_frame.clear_fields()
# print(self.moves)
# print(self.move_to_id)
# print(self.moves_data)
self.move_menu['values'] = self.moves
# self.movebox =
# self.move_data = {}
self.update_move_fields(clear=True)
def on_enemy_menu_input(self, val):
self.enemychar = self.enemy_menu.get()
print("enemy entry! {}".format(self.enemychar))
data_url = "{}/characters/{}/characterattributes".format(
api_url, self.name_to_id[self.enemychar])
response = urllib.request.urlopen(data_url).read().decode('utf-8')
attr_data = json.loads(response)
# print(attr_data)
for item in attr_data:
print(item)
print(item['name'])
if (item['name'] == 'WEIGHT VALUE'):
self.enemy_weight = float(item['value'])
print("weight of {} is {}".format(self.enemychar,
self.enemy_weight))
self.weight_box['text'] = "Weight: {}".format(int(self.enemy_weight))
self.update_kb()
def on_move_menu_input(self, val):
# data_url = "{}/characters/{}/characterattributes".format(
# api_url, self.name_to_id[self.enemychar])
# response = urllib.request.urlopen(data_url).read().decode('utf-8')
# self.move_data = json.loads(response)
# print(self.name_to_id)
# print(self.moves_data[0])
self.move_name = self.move_menu.get()
print(self.moves_dict[self.move_menu.get()])
self.update_move_fields()
# self.BKB
# self.name
# self.
self.update_kb()
def on_user_damage_input(self, *args):
print("user percent changed!")
# self.percent = self.userdmg.get()
# print(self.percent)
print(self.userdmg.get())
if (self.userdmg.get() == ''):
return
dmg = float(self.userdmg.get())
if (dmg < 35):
self.rage = 1
elif (dmg > 150):
self.rage = 1.15
else:
self.rage = 1 + (dmg - 35) * (.15) / (115)
print("rage is now {}".format(self.rage))
self.rage_box['text'] = "Rage multiplier: {: <4.2f}x".format(self.rage)
self.update_kb()
def on_enemy_damage_input(self, *args):
print("enemy percent changed!")
if (self.enemydmg.get() != ''):
self.update_kb()
# validate_cmd = (self.register(self.on_percent_validate), '%d', '%S', '%P')
def on_percent_validate(self, why, change, new_value):
print("validation")
if (why == '1'):
print("reason: insertion")
elif (why == '0'):
print("reason: deletion")
else:
print("UKNOWN REASON: {}".format(why))
if (new_value == ''):
print("empty box")
return True
try:
float(new_value)
# self.percent = float(new_value)
except ValueError:
return False
# print(self.percent)
# if (self.percent < 35):
# self.rage = 1
# elif (self.percent > 150):
# self.rage = 1.15
# else:
# self.rage = 1 + (self.percent - 35) * (.15) / (115)
# print("rage is now {}".format(self.rage))
# self.rage_box['text'] = "Rage multiplier: {: <4.2f}x".format(self.rage)
# self.update_kb()
return True
def on_crouch_check(self):
print("crouch: {}".format(self.is_crouch))
self.update_kb()
def on_smash_check(self):
print("smash: {}".format(self.is_smash))
self.update_kb()
def on_meteor_check(self):
print("meteor: {}".format(self.is_meteor))
self.update_kb()
def update_move_fields(self, clear=False):
if (clear):
self.move_name = ""
self.kb = 0
return
else:
print(self.moves_dict)
print("move name: {}".format(self.move_name))
print(self.moves_dict[self.move_name])
self.move_info_frame.set_fields(self.moves_dict[self.move_name])
self.update_kb()
# set_kb(self, target_weight, target_percent, staleness=1, misc_variable=1):
def update_kb(self):
print("update_kb?")
if (self.move_name != "" and self.move_info_frame.empty == False
and self.enemy_weight > 0):
print("updating")
misc_var = float(self.rage) * self.is_crouch.get(
) * self.is_smash.get() * self.is_meteor.get()
# Using onvalue and offvalue so don't need these.
# if (self.is_crouch):
# misc_var = misc_var * 0.85
# if (self.is_smash):
# misc_var = misc_var * 1.2
# if (self.is_meteor):
# misc_var = misc_var * 0.8
# self.move_info_frame.set_kb(self.enemy_weight, self.enemy_damage_entry.get(), staleness=1, misc_variable=misc_var)
self.move_info_frame.set_kb(self.enemy_weight,
float(self.enemydmg.get()),
staleness=1,
misc_variable=misc_var)
else:
print("nevermind")
pass
class Calculator():
def __init__(self, master):
self.master = master
master.title('Calculator')
self.total = 0.0
self.entered_number = 0.0
self.total_label_text = DoubleVar()
self.total_label_text.set(self.total)
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Total:")
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master,
validate="key",
validatecommand=(vcmd, '%P'))
self.add_button = Button(master,
text="+",
command=lambda: self.update("add"))
self.subtract_button = Button(master,
text="-",
command=lambda: self.update("subtract"))
self.reset_button = Button(master,
text="Clear",
command=lambda: self.update("reset"))
self.multiply_button = Button(master,
text="*",
command=lambda: self.update("multiply"))
# LAYOUT
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=2, sticky=E)
self.entry.grid(row=1, column=0, columnspan=3, sticky=W + E)
self.add_button.grid(row=2, column=0, sticky=W + E)
self.subtract_button.grid(row=2, column=1, sticky=W + E)
self.reset_button.grid(row=2, column=2, sticky=W + E)
self.multiply_button.grid(row=3, column=1, sticky=W + E)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.entered_number = 0.0
return True
try:
self.entered_number = float(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "add":
self.total += self.entered_number
elif method == "subtract":
self.total -= self.entered_number
elif method == "multiply":
self.total *= self.entered_number
else: # reset
self.total = 0
self.total_label_text.set(self.total)
self.entry.delete(0, END)
class TkMainGui(ttk.Frame):
def __init__(self, root, default_folder=""):
ttk.Frame.__init__(self, root, padding="3 3 12 12")
self.default_folder = default_folder
logger.debug("Create main frame")
self.grid(column=0, row=0, sticky=(N, W, E, S))
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
logger.debug("Create variable")
self.program_path = StringVar()
file_path = os.path.join(self.default_folder, "30kV ElementsView.exe")
self.program_path.set(file_path)
self.basename = StringVar()
self.basename.set("test")
self.acquisition_mode = StringVar()
self.acquisition_mode.set(ACQUISITION_MODE_MANUAL)
self.number_spectra = IntVar()
self.number_spectra.set(100)
self.delay_spectrum_s = DoubleVar()
self.delay_spectrum_s.set(1)
self.overwrite = BooleanVar()
self.overwrite.set(False)
self.fast_acquisition = BooleanVar()
self.fast_acquisition.set(False)
self.is_top_window = BooleanVar()
self.is_top_window.set(False)
self.is_manual_acquisition_button = BooleanVar()
self.is_manual_acquisition_button.set(False)
self.is_save_as = BooleanVar()
self.is_save_as.set(False)
self.results_text = StringVar()
widget_width = 40
logger.debug("Create program button")
row_id = 1
file_path_entry = ttk.Entry(self,
width=widget_width,
textvariable=self.program_path)
file_path_entry.grid(column=2, row=row_id, sticky=(W, E))
ttk.Button(self,
width=widget_width,
text="Select ElementView program file",
command=self.open_element_view_program).grid(column=3,
row=row_id,
sticky=W)
logger.debug("Create basename label and edit entry")
row_id += 1
basename_label = ttk.Label(self,
width=widget_width,
text="basename: ",
state="readonly")
basename_label.grid(column=2, row=row_id, sticky=(W, E))
basename_entry = ttk.Entry(self,
width=widget_width,
textvariable=self.basename)
basename_entry.grid(column=3, row=row_id, sticky=(W, E))
row_id += 1
acquisition_mode_label = ttk.Label(self,
width=widget_width,
text="Acquisition mode: ",
state="readonly")
acquisition_mode_label.grid(column=2, row=row_id, sticky=(W, E))
acquisition_mode_entry = ttk.Combobox(
self,
width=widget_width,
textvariable=self.acquisition_mode,
values=[ACQUISITION_MODE_LIVE, ACQUISITION_MODE_MANUAL])
acquisition_mode_entry.grid(column=3, row=row_id, sticky=(W, E))
row_id += 1
number_spectra_label = ttk.Label(self,
width=widget_width,
text="Number of spectra: ",
state="readonly")
number_spectra_label.grid(column=2, row=row_id, sticky=(W, E))
number_spectra_entry = ttk.Entry(self,
width=widget_width,
textvariable=self.number_spectra)
number_spectra_entry.grid(column=3, row=row_id, sticky=(W, E))
row_id += 1
delay_spectrum_label = ttk.Label(
self,
width=widget_width,
text="Delay between of spectrum (s): ",
state="readonly")
delay_spectrum_label.grid(column=2, row=row_id, sticky=(W, E))
delay_spectrum_entry = ttk.Entry(self,
width=widget_width,
textvariable=self.delay_spectrum_s)
delay_spectrum_entry.grid(column=3, row=row_id, sticky=(W, E))
row_id += 1
ttk.Checkbutton(self,
width=widget_width,
text="Overwrite file",
variable=self.overwrite).grid(column=3,
row=row_id,
sticky=(W, E))
row_id += 1
ttk.Checkbutton(self,
width=widget_width,
text="Fast acquisition",
variable=self.fast_acquisition).grid(column=3,
row=row_id,
sticky=(W, E))
row_id += 1
ttk.Button(self,
width=widget_width,
text="Find ElementView",
command=self.find_element_view).grid(column=3,
row=row_id,
sticky=W)
logger.debug("ElementView elements")
row_id += 1
ttk.Checkbutton(self,
width=widget_width,
text="Top window",
variable=self.is_top_window,
state=DISABLED).grid(column=3,
row=row_id,
sticky=(W, E))
row_id += 1
ttk.Checkbutton(self,
width=widget_width,
text="Manual acquisition",
variable=self.is_manual_acquisition_button,
state=DISABLED).grid(column=3,
row=row_id,
sticky=(W, E))
row_id += 1
ttk.Checkbutton(self,
width=widget_width,
text="Save as",
variable=self.is_save_as,
state=DISABLED).grid(column=3,
row=row_id,
sticky=(W, E))
row_id += 1
self.start_button = ttk.Button(self,
width=widget_width,
text="Start script",
command=self.start_script,
state=DISABLED)
self.start_button.grid(column=3, row=row_id, sticky=W)
row_id += 1
results_label = ttk.Label(self,
textvariable=self.results_text,
state="readonly")
results_label.grid(column=2, row=row_id, sticky=(W, E))
for child in self.winfo_children():
child.grid_configure(padx=5, pady=5)
basename_entry.focus()
self.results_text.set("Start")
def open_element_view_program(self):
logger.debug("open_element_view_program")
file_path = filedialog.askopenfilename(filetypes=(("executable file",
"*.exe"), ),
initialdir=self.default_folder)
logger.debug(file_path)
self.program_path.set(file_path)
def find_element_view(self):
try:
app = Application(backend="win32").connect(
path=self.program_path.get())
logger.info("Application connected")
# logger.info("app: {}".format(app.print_control_identifiers(depth=1)))
try:
top_window = app.top_window()
top_window.wait("exists enabled visible ready")
self.is_top_window.set(True)
logger.info("top_window: {}".format(
top_window.print_control_identifiers(depth=1)))
try:
logger.info("Button2: {}".format(
top_window.Button2.print_control_identifiers(depth=1)))
self.is_manual_acquisition_button.set(True)
except Exception as message:
logger.error(message)
self.is_manual_acquisition_button.set(False)
try:
top_window.menu_select("File -> Save")
logger.info("File->Save")
app.Comment.wait("exists enabled visible ready")
logger.info(app.Comment.print_control_identifiers())
# app.CommentEdit.Edit.SetEditText("auto script")
app.Comment.OK.click()
logger.info("Comment")
app['Save As'].wait("exists enabled visible ready")
logger.info(
app['Save As'].print_control_identifiers(depth=2))
app['Save As'].Cancel.click()
logger.info("Cancel")
self.is_save_as.set(True)
except Exception as message:
logger.error(message)
self.is_save_as.set(False)
except Exception as message:
logger.errror(message)
self.is_top_window.set(False)
self.is_manual_acquisition_button.set(False)
self.is_save_as.set(False)
except (TimeoutError, AppNotConnected,
ProcessNotFoundError) as message:
logger.error(message)
self.is_top_window.set(False)
self.is_manual_acquisition_button.set(False)
self.is_save_as.set(False)
if self.is_top_window.get() and self.is_manual_acquisition_button.get(
) and self.is_save_as.get():
self.results_text.set("ElementView elements found")
self.start_button.config(state=NORMAL)
else:
self.results_text.set("ElementView elements NOT found")
self.start_button.config(state=DISABLED)
def start_script(self):
self.save_spectra()
def save_spectra(self):
acquisition_mode = self.acquisition_mode.get()
safe_acquisition = not self.fast_acquisition.get()
overwrite = self.overwrite.get()
if self.fast_acquisition.get():
Timings.Fast()
Timings.window_find_timeout = 2
if acquisition_mode == ACQUISITION_MODE_MANUAL:
self.results_text.set("Manual save")
if acquisition_mode == ACQUISITION_MODE_LIVE:
self.results_text.set("Live save")
app = Application(backend="win32").connect(
path=self.program_path.get())
logger.info("Application connected")
top_window = app.window(title_re=".*ElementsView.*")
if safe_acquisition:
top_window.wait("exists enabled visible ready")
for spectrum_id in range(1, self.number_spectra.get() + 1):
logger.info("Spectrum id: {:d}".format(spectrum_id))
if safe_acquisition:
top_window.wait("exists enabled visible ready")
if acquisition_mode == ACQUISITION_MODE_MANUAL:
top_window.Button2.click()
time.sleep(self.delay_spectrum_s.get())
if safe_acquisition:
top_window.wait("exists enabled visible ready")
top_window.menu_select("File -> Save")
if safe_acquisition:
app.Comment.wait("exists enabled visible ready")
app.CommentEdit.Edit.SetEditText("auto script")
app.Comment.OK.click()
save_as_window = app['Save As']
if safe_acquisition:
save_as_window.wait("exists enabled visible ready")
file_name = "%s_%i.elv" % (self.basename.get(), spectrum_id)
save_as_window.Edit.SetEditText(file_name)
save_as_window.Save.click()
if overwrite:
try:
window_confirm = app['Confirm Save As']
if safe_acquisition:
window_confirm.wait("exists enabled visible ready")
if self.overwrite.get():
window_confirm.Yes.click()
else:
window_confirm.No.click()
save_as_window.Cancel.click()
self.results_text.set("Cancel save file already exist")
return
except Exception as message:
logger.error(message)
logger.info("Done")
self.results_text.set("Done")
def __init__(self, master, par=False):
"""
GUI for selecting default parameters - will write parameters to file \
of users choosing.
:type master: Tk
:param master: Tkinter window
:type par: EQcorrscanParameters
:param par: Default parameters to start-up with.
"""
from tkinter import Label, Button, Entry, DoubleVar, StringVar, IntVar
from tkinter import BooleanVar, OptionMenu, Checkbutton
import tkMessageBox
from eqcorrscan.utils import parameters
from obspy import UTCDateTime
import warnings
# Set the default par, only if they don't already exist.
if not par:
par = parameters.EQcorrscanParameters([''], 2, 10, 4, 100, 2,
'1900-01-01', '2300-01-01',
'', 'seishub', 4, False, '',
'jpg', False, 8, 'MAD', 6)
# Callback functions for all variables (ugly)
def update_template_names(*args):
par.template_names = [
name.strip() for name in template_names.get().split(',')
]
template_names.set(', '.join(par.template_names))
def update_lowcut(*args):
par.lowcut = lowcut.get()
lowcut.set(par.lowcut)
def update_highcut(*args):
par.highcut = highcut.get()
if par.highcut >= 0.5 * par.samp_rate:
msg = ('Highcut must be less than the Nyquist, setting to ' +
str((par.samp_rate / 2.0) - 1))
tkMessageBox.showwarning(title="Nyquist error", message=msg)
par.highcut = (par.samp_rate / 2.0) - 1
highcut.set(par.highcut)
def update_filt_order(*args):
par.filt_order = filt_order.get()
filt_order.set(par.filt_order)
def update_samp_rate(*args):
par.samp_rate = samp_rate.get()
if par.highcut >= 0.5 * par.samp_rate:
msg = ('Highcut must be less than the Nyquist, setting to ' +
str((par.samp_rate / 2.0) - 1))
tkMessageBox.showwarning(title="Nyquist error", message=msg)
par.highcut = (par.samp_rate / 2.0) - 1
highcut.set(par.highcut)
samp_rate.set(par.samp_rate)
def update_debug(*args):
par.debug = debug.get()
debug.set(par.debug)
def update_startdate(*args):
par.startdate = UTCDateTime(startdate.get())
startdate.set(str(par.startdate))
def update_enddate(*args):
par.enddate = UTCDateTime(enddate.get())
enddate.set(str(par.enddate))
def update_archive(*args):
par.archive = archive.get()
archive.set(par.archive)
def update_arc_type(*args):
par.arc_type = arc_type.get()
arc_type.set(par.arc_type)
def update_cores(*args):
par.cores = cores.get()
cores.set(par.cores)
def update_plotvar(*args):
par.plotvar = plotvar.get()
plotvar.set(par.plotvar)
def update_plot_format(*args):
par.plot_format = plot_format.get()
plot_format.set(par.plot_format)
def update_tempdir(*args):
par.tempdir = tempdir.get()
tempdir.set(par.tempdir)
def update_threshold(*args):
par.threshold = threshold.get()
threshold.set(par.threshold)
def update_threshold_type(*args):
par.threshold_type = threshold_type.get()
threshold_type.set(par.threshold_type)
def update_plotdir(*args):
par.plotdir = plotdir.get()
plotdir.set(par.plotdir)
def update_trigger_interval(*args):
par.trigger_interval = trigger_interval.get()
trigger_interval.set(par.trigger_interval)
# Set some grid parameters
nrows = 25
ncolumns = 3
self.master = master
master.title("EQcorrscan parameter setup")
self.label = Label(master, text="Alpha GUI for default setup")
self.label.grid(column=0, columnspan=ncolumns, row=0)
# Set up parameter input
self.t_names_label = Label(master, text="Template names", anchor='e')
self.t_names_label.grid(column=0, row=1, sticky='e')
template_names = StringVar()
template_names.set(', '.join(par.template_names))
self.t_names_box = Entry(master, bd=2, textvariable=template_names)
self.t_names_box.grid(column=1, row=1)
template_names.trace("w", update_template_names)
self.t_names_lookup = Button(
master,
text="Lookup",
command=lambda: self.get_template_names(par))
self.t_names_lookup.grid(column=2, row=1)
self.lowcut_label = Label(master, text="Lowcut (Hz)", anchor='e')
self.lowcut_label.grid(column=0, row=2, sticky='e')
lowcut = DoubleVar()
lowcut.set(par.lowcut)
self.lowcut_box = Entry(master, bd=2, textvariable=lowcut)
self.lowcut_box.grid(column=1, row=2)
lowcut.trace("w", update_lowcut)
self.highcut_label = Label(master, text="Highcut (Hz)", anchor='e')
self.highcut_label.grid(column=0, row=3, sticky='e')
highcut = DoubleVar()
highcut.set(par.highcut)
self.highcut_box = Entry(master, bd=2, textvariable=highcut)
self.highcut_box.grid(column=1, row=3)
highcut.trace("w", update_highcut)
self.filt_order_label = Label(master, text="Filter order")
self.filt_order_label.grid(column=0, row=4, sticky='e')
filt_order = DoubleVar()
filt_order.set(par.filt_order)
self.filt_order_box = Entry(master, bd=2, textvariable=filt_order)
self.filt_order_box.grid(column=1, row=4)
filt_order.trace("w", update_filt_order)
self.samp_rate_label = Label(master, text="Sample rate (Hz)")
self.samp_rate_label.grid(column=0, row=5, sticky='e')
samp_rate = DoubleVar()
samp_rate.set(par.samp_rate)
self.samp_rate_box = Entry(master, bd=2, textvariable=samp_rate)
self.samp_rate_box.grid(column=1, row=5)
samp_rate.trace("w", update_samp_rate)
self.debug_label = Label(master, text="Debug")
self.debug_label.grid(column=0, row=6, sticky='e')
debug = IntVar()
debug.set(par.debug)
self.debug_box = Entry(master, bd=2, textvariable=debug)
self.debug_box.grid(column=1, row=6)
debug.trace("w", update_debug)
self.startdate_label = Label(master, text="Start date (yyyy-mm-dd)")
self.startdate_label.grid(column=0, row=6, sticky='e')
startdate = StringVar()
startdate.set(par.startdate)
self.startdate_box = Entry(master, bd=2, textvariable=startdate)
self.startdate_box.grid(column=1, row=6)
startdate.trace("w", update_startdate)
self.enddate_label = Label(master, text="End date (yyyy-mm-dd)")
self.enddate_label.grid(column=0, row=8, sticky='e')
enddate = StringVar()
enddate.set(par.enddate)
self.enddate_box = Entry(master, bd=2, textvariable=enddate)
self.enddate_box.grid(column=1, row=8)
enddate.trace("w", update_enddate)
self.archive_label = Label(master, text="Archive")
self.archive_label.grid(column=0, row=9, sticky='e')
archive = StringVar()
archive.set(par.archive)
self.archive_box = Entry(master, bd=2, textvariable=archive)
self.archive_box.grid(column=1, row=9)
archive.trace("w", update_archive)
self.archive_lookup = Button(master,
text="Lookup",
command=lambda: self.get_archive(par))
self.archive_lookup.grid(column=2, row=9)
self.arc_type_label = Label(master, text="Archive type")
self.arc_type_label.grid(column=0, row=10, sticky='e')
arc_type = StringVar()
arc_type.set(par.arc_type)
self.arc_type_box = OptionMenu(master, arc_type, "seishub", "fdsn",
"day_vols")
self.arc_type_box.grid(column=1, row=10, sticky='w,e')
arc_type.trace("w", update_arc_type)
self.cores_label = Label(master, text="Number of cores")
self.cores_label.grid(column=0, row=11, sticky='e')
cores = IntVar()
cores.set(par.cores)
self.cores_box = Entry(master, bd=2, textvariable=cores)
self.cores_box.grid(column=1, row=11)
cores.trace("w", update_cores)
self.plotvar_label = Label(master, text="Plotting on/off")
self.plotvar_label.grid(column=0, row=12, sticky='e')
plotvar = BooleanVar()
plotvar.set(par.plotvar)
self.plotvar_box = Checkbutton(master,
text='Plot on',
var=plotvar,
onvalue=True,
offvalue=False)
self.plotvar_box.grid(column=1, row=12)
plotvar.trace("w", update_plotvar)
self.plotdir_label = Label(master, text="Plot directory")
self.plotdir_label.grid(column=0, row=13, sticky='e')
plotdir = StringVar()
plotdir.set(par.plotdir)
self.plotdir_box = Entry(master, bd=2, textvariable=plotdir)
self.plotdir_box.grid(column=1, row=13)
plotdir.trace("w", update_plotdir)
self.plotdir_lookup = Button(master,
text="Lookup",
command=lambda: self.get_plotdir(par))
self.plotdir_lookup.grid(column=2, row=13)
self.plot_format_label = Label(master, text="Plot format")
self.plot_format_label.grid(column=0, row=14, sticky='e')
plot_format = StringVar()
plot_format.set(par.plot_format)
self.plot_format_box = OptionMenu(master, plot_format, "jpg", "eps",
"pdf", "png")
self.plot_format_box.grid(column=1, row=14, sticky='w,e')
plot_format.trace("w", update_plot_format)
self.tempdir_label = Label(master, text="Temporary directory")
self.tempdir_label.grid(column=0, row=15, sticky='e')
tempdir = StringVar()
tempdir.set(par.tempdir)
self.tempdir_box = Entry(master, bd=2, textvariable=tempdir)
self.tempdir_box.grid(column=1, row=15)
tempdir.trace("w", update_tempdir)
self.tempdir_lookup = Button(master,
text="Lookup",
command=lambda: self.get_tempdir(par))
self.tempdir_lookup.grid(column=2, row=15)
self.threshold_label = Label(master, text="Threshold")
self.threshold_label.grid(column=0, row=16, sticky='e')
threshold = DoubleVar()
threshold.set(par.threshold)
self.threshold_box = Entry(master, bd=2, textvariable=threshold)
self.threshold_box.grid(column=1, row=16)
threshold.trace("w", update_threshold)
self.threshold_type_label = Label(master, text="Threshold type")
self.threshold_type_label.grid(column=0, row=17, sticky='e')
threshold_type = StringVar()
threshold_type.set(par.threshold_type)
self.threshold_type_box = OptionMenu(master, threshold_type, "MAD",
"absolute", "av_chan_corr")
self.threshold_type_box.grid(column=1, row=17, sticky='w,e')
threshold_type.trace("w", update_threshold_type)
self.trigger_interval_label = Label(master,
text="Minimum trigger " +
"interval (s)")
self.trigger_interval_label.grid(column=0, row=18, sticky='e')
trigger_interval = DoubleVar()
trigger_interval.set(par.trigger_interval)
self.trigger_interval_box = Entry(master,
bd=2,
textvariable=trigger_interval)
self.trigger_interval_box.grid(column=1, row=18)
trigger_interval.trace("w", update_trigger_interval)
# End of user editable section, now we have read/write buttons
self.read_button = Button(master,
text="Read parameters",
command=lambda: self.read_par(master))
self.read_button.grid(column=0, row=nrows - 2, sticky='w,e')
self.write_button = Button(master,
text="Write parameters",
command=lambda: self.write_par(par))
self.write_button.grid(column=1, row=nrows - 2, sticky='w,e')
class Gui(Frame):
def __init__(self, control, *args, **kwargs):
Frame.__init__(self, *args, **kwargs)
self.config(padx=2)
self.queue = Queue()
self.control = control
self.disabledWhileRunning = []
self.formulae = list(map(lambda t: StringVar(self, t), ["x/22.5+4", "50-x*50/180"]))
self.executionTime = DoubleVar(self, "360")
self.programSpeed = IntVar(self, "292")
self.maxTravel = IntVar(self, "-200000")
self.loadSettings()
self.createWidgets()
self.thread = None
def compileFormulae(self):
rv = []
for f in self.formulae:
body = "def formula5480750923(x):\n return " + f.get()
l = {}
try:
exec(body, {}, l)
except:
rv.append(None)
continue
compiled = l["formula5480750923"]
compiled(0)
rv.append(compiled)
return rv
def plotFormulae(self):
try:
compiled = self.compileFormulae()
except:
return
for g in self.graphs:
g.points = []
self.canvas.x.end = self.executionTime.get()
self.canvas.clear()
for x in range(self.canvas.x.start, int(self.canvas.x.end)):
point = []
for c in range(len(compiled)):
v = None
if compiled[c]:
v = compiled[c](x)
assert isinstance(v, float)
point.append(v)
self.__addPoint__(x, point)
self.canvas.update()
def __start__(self):
self.canvas.x.end = self.executionTime.get()
pumps = self.compileFormulae()
self.setValues()
self.control.mover.setSpeed(abs(int(self.programSpeed.get())))
start_time = float(self.current_time.get())
def calcPumpValues(time):
values = list(map(lambda x: x(time), pumps))
self.__addPoint__(time, values)
self.current_time.set(time)
return values
def thFunc():
try:
for g in self.graphs:
g.points = []
self.control.executeProgram(start_time, calcPumpValues)
finally:
self.invoke(self.__enableControls__)
self.__disableControls__()
self.canvas.clear()
self.thread = Thread(target=thFunc, name="Control")
self.thread.start()
def __enableControls__(self):
for e in self.disabledWhileRunning:
e.config(state=NORMAL)
def __disableControls__(self):
for e in self.disabledWhileRunning:
e.config(state="disabled")
def __addPoint__(self, x, values):
for v in values:
assert isinstance(v, float)
def c():
for i in range(len(self.canvas.graphs)):
self.canvas.graphs[i].addPoint(x, values[i])
self.invoke(c)
def invoke(self, callable):
self.after_idle(callable)
def __stop__(self):
self.control.stop()
def __quit__(self):
def quitting():
self.__stop__()
if self.thread and self.thread.is_alive():
print("Thread is active")
return False
self.quit()
return True
run_repeating(self, quitting)
def __move__(self, steps):
speed = int(self.speed.get())
if speed < 0:
speed *= -1
self.speed.set(speed)
self.control.mover.setSpeed(speed)
self.control.mover.go(steps)
def __up__(self):
steps = int(self.steps.get())
self.__move__(steps)
def __down__(self):
steps = int(self.steps.get())
self.__move__(-steps)
def showValues(self):
self.maxTravel.set(self.control.mover.maxTravel)
self.executionTime.set(self.control.fullTime)
self.programSpeed.set(self.control.mover.getSpeed())
def setValues(self):
self.control.mover.maxTravel = int(self.maxTravel.get())
self.control.fullTime = float(self.executionTime.get())
self.control.mover.setSpeed(abs(int(self.programSpeed.get())))
def loadSettings(self):
config = Config()
try:
config.read()
except KeyError:
pass
config.configureControl(self.control)
for i in range(len(self.formulae)):
self.formulae[i].set(config.formulae[i])
self.showValues()
def saveSettings(self):
self.setValues()
config = Config()
config.getFromControl(self.control)
for i in range(len(self.formulae)):
config.formulae[i] = self.formulae[i].get()
config.write()
def createWidgets(self):
panel = Frame(self, name="mainMenu")
panel.grid(sticky=W)
Button(panel, name="quit", text="Выход", command=self.__quit__).grid(row=0, column=0)
Button(panel, name="reconnect", text="Пересоединение", command=self.control.reconnect).grid(row=0, column=1)
b = Button(panel, text="Загрузить", command=self.loadSettings)
b.grid(row=0, column=2)
self.disabledWhileRunning.append(b)
b = Button(panel, text="Сохранить", command=self.saveSettings)
b.grid(row=0, column=3)
self.disabledWhileRunning.append(b)
panel = LabelFrame(self, text="Прямое управление стаканом", name="motor")
panel.grid(sticky=W)
b = Button(panel, text="Вверх", command=self.__up__, name="up")
b.grid(row=0, column=0)
self.disabledWhileRunning.append(b)
b = Button(panel, text="Вниз", command=self.__down__, name="down")
b.grid(row=1, column=0)
self.disabledWhileRunning.append(b)
Label(panel, text="Шаг:").grid(sticky=E, row=0, column=1)
self.steps = IntVar(self, "10000")
Entry(panel, textvariable=self.steps, width=6).grid(sticky=W, row=0, column=2)
Label(panel, text="Скорость:").grid(sticky=E, row=1, column=1)
self.speed = IntVar(self, "2000")
Entry(panel, textvariable=self.speed, width=6).grid(sticky=W, row=1, column=2)
self.position = IntVar(self, "1000")
def readPosition():
try:
self.position.set(self.control.mover.getPosition())
except (ConnectionResetError, Timeout):
pass
run_repeating(self, readPosition, 10000)
b = Button(panel, text="Прочитать положение", command=readPosition)
b.grid(row=0, column=3, columnspan=2)
self.disabledWhileRunning.append(b)
Label(panel, text="Положение:").grid(sticky=E, row=1, column=3)
Entry(panel, textvariable=self.position, width=8, state="disabled").grid(sticky=W, row=1, column=4)
panel = LabelFrame(self, text="Программа", name="program")
program = panel
panel.grid(sticky=W + E)
panel.columnconfigure(1, weight=1)
row = 0
for f in self.formulae:
columns, rows = self.grid_size()
Label(panel, text="Насос %d:" % (row + 1)).grid(row=row, column=0, sticky=E)
e = Entry(panel, textvariable=f)
e.grid(sticky=E + W, row=row, column=1)
self.disabledWhileRunning.append(e)
f.trace("w", lambda *x: self.after_idle(self.plotFormulae))
row += 1
panel = Frame(program, name="mover")
panel.grid(columnspan=2, sticky=W)
Label(panel, text="Максимальное смещение:").grid(sticky=E)
Entry(panel, textvariable=self.maxTravel).grid(sticky=W, row=0, column=1)
Label(panel, text="Скорость:").grid(sticky=E)
Entry(panel, textvariable=self.programSpeed).grid(sticky=W, row=1, column=1)
Label(panel, text="Время выполнения (в секундах):").grid(sticky=E)
e = Entry(panel, textvariable=self.executionTime)
e.grid(sticky=W, row=2, column=1)
self.current_time = DoubleVar(self, "0")
Label(panel, text="Текущее время:").grid(sticky=E)
e = Entry(panel, textvariable=self.current_time)
e.grid(sticky=W, row=3, column=1)
self.disabledWhileRunning.append(e)
self.executionTime.trace("w", lambda *x: self.plotFormulae())
panel = Frame(program, name="bottom")
panel.grid(columnspan=2, sticky=W)
row = 0
startButton = Button(panel, name="start", text="Старт", command=self.__start__)
startButton.grid(row=row, column=0)
self.disabledWhileRunning.append(startButton)
Button(panel, text="Стоп", command=self.__stop__).grid(row=row, column=1)
self.canvas = GraphCanvas(self)
self.graphs = (Graph(self.canvas), Graph(self.canvas))
self.canvas.x.end = 100
self.canvas.y.end = 24
self.plotFormulae()
self.canvas.grid(sticky=E + W + S + N)
columns, rows = self.grid_size()
self.columnconfigure(columns - 1, weight=1)
self.rowconfigure(rows - 1, weight=1)
def initui(self):
self.parent.title("Light pollution map")
self.style = Style()
self.style.theme_use("alt")
self.grid(row=0, column=0)
padding = {'padx':'5', 'pady':'5'}
big_heading_font = ("Arial", 14, 'bold')
small_heading_font = ("Arial", 10, 'bold')
# Create frames.
# There are three frames for settings - preprocessing, convolve, and contour.
# Each also has an image frame underneath it.
# Layout is as follows:
#
# --------------------------------------------------------------------------
# | | | | |
# | | | | |
# | import_body | process_body | contour_body | export_body |
# | | | | |
# | | | | |
# --------------------------------------------------------------------------
# Settings frames
top = self.winfo_toplevel()
top.rowconfigure(0, weight=1)
top.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(2, weight=1)
self.columnconfigure(3, weight=1)
import_body = Frame(self, relief=RAISED, borderwidth=1)
import_body.grid(row=0, column=0, sticky=N+S+E+W)
process_body = Frame(self, relief=RAISED, borderwidth=1)
process_body.grid(row=0, column=1, sticky=N+S+E+W)
contour_body = Frame(self, relief=RAISED, borderwidth=1)
contour_body.grid(row=0, column=2, sticky=N+S+E+W)
export_body = Frame(self, relief=RAISED, borderwidth=1)
export_body.grid(row=0, column=3, sticky=N+S+E+W)
# =============================================================================================================
#
# Contents of load_image_frame
#
# =============================================================================================================
# Heading
processing_frame_header = Label(import_body, text="Import", font=big_heading_font)
processing_frame_header.grid(row=0, column=0, sticky=N, **padding)
filename_variable = StringVar()
# Import image
import_canvas = Canvas(import_body, width=canvas_size, height=canvas_size, background='black')
import_canvas.grid(row=1, column=0, sticky=N, **padding)
# Load file method
def choosefile():
filename_variable.set(filedialog.askopenfilename(parent=import_body))
image = Image.open(filename_variable.get())
thumbnail = create_thumbnail(image, canvas_size)
import_canvas.create_image(0, 0, image=thumbnail, anchor=NW)
load_image_button = Button(import_body, text="Import image", command=choosefile)
load_image_button.grid(row=2, column=0, columnspan=2, sticky=E+W+S, **padding)
import_body.rowconfigure(2, weight=1)
# =============================================================================================================
#
# Contents of processing_frame
#
# =============================================================================================================
processing_frame_header = Label(process_body, text="Process", font=big_heading_font)
processing_frame_header.grid(row=0, column=0, columnspan=2, sticky=N, **padding)
clipping_variable = IntVar()
constants_label = Label(process_body, text="Clipping",
font=("Arial", 10, 'bold'))
constants_label.grid(row=1, column=0, sticky=E, **padding)
clipping_label = Label(process_body, text="Remove pixels with \n brightness under")
clipping_label.grid(row=2, column=0, sticky=E, **padding)
clipping_entry = Entry(process_body, textvariable=clipping_variable, width=4)
clipping_entry.grid(row=2, column=1, sticky=W, **padding)
clipping_variable.set(value=default_clipping_value)
convolve_header = Label(process_body, text="Kernel", font=small_heading_font)
convolve_header.grid(row=4, column=0, sticky=E, **padding)
kernel_size_variable = IntVar()
kernel_size_label = Label(process_body, text="Convolve kernel size", justify=RIGHT)
kernel_size_label.grid(row=5, column=0, sticky=E, **padding)
kernel_size_entry = Entry(process_body, textvariable=kernel_size_variable, width=4)
kernel_size_entry.grid(row=5, column=1, sticky=W, **padding)
kernel_size_variable.set(value=default_kernel_size)
# Constants for convolve equation
constants_label = Label(process_body, text="Falloff",
font=("Arial", 10, 'bold'))
constants_label.grid(row=6, column=0, sticky=E, **padding)
constant_a_label = Label(process_body, text="Constant A:")
constant_b_label = Label(process_body, text="Constant B:")
constant_c_label = Label(process_body, text="Constant C:")
constant_a_label.grid(row=7, column=0, sticky=E, **padding)
constant_b_label.grid(row=8, column=0, sticky=E, **padding)
constant_c_label.grid(row=9, column=0, sticky=E, **padding)
constant_a_variable = DoubleVar()
constant_b_variable = DoubleVar()
constant_c_variable = DoubleVar()
constant_a_entry = Entry(process_body, textvariable=constant_a_variable, width=4)
constant_b_entry = Entry(process_body, textvariable=constant_b_variable, width=4)
constant_c_entry = Entry(process_body, textvariable=constant_c_variable, width=4)
constant_a_variable.set(default_constant_a)
constant_b_variable.set(default_constant_b)
constant_c_variable.set(default_constant_c)
constant_a_entry.grid(row=7, column=1, **padding)
constant_b_entry.grid(row=8, column=1, **padding)
constant_c_entry.grid(row=9, column=1, **padding)
constants_note = Label(process_body, text="Falloff equation is (Ax^B)-C", font=("Arial", 9))
constants_note.grid(row=10, column=0, columnspan=2, sticky=E, **padding)
# Start button!
def process():
print("Filename was " + filename_variable.get())
image_data = process_image(filename=filename_variable.get(),
kernel_size=kernel_size_variable.get(),
clipping_value=clipping_variable.get(),
constant_a=constant_a_variable.get(),
constant_b=constant_b_variable.get(),
constant_c=constant_c_variable.get()
)
image_data = Image.open("processed_image.png")
thumbnail = create_thumbnail(image_data, canvas_size)
export_canvas.create_image(0, 0, image=thumbnail, anchor=NW)
start_button = Button(process_body, text="Process image", command=process)
start_button.grid(row=11, column=0, columnspan=3, sticky=E+W+S, **padding)
process_body.rowconfigure(11, weight=1)
# =============================================================================================================
#
# Contents of contour_frame
#
# =============================================================================================================
contour_header = Label(contour_body, text="Contour", font=big_heading_font)
contour_header.grid(row=0, column=0, sticky=S, columnspan=2, **padding)
contour_note = Label(contour_body, text="(optional)")
contour_note.grid(row=1, column=0, sticky=S, columnspan=2)
scale_options = {"width":"5", "length":"150"}
slider_padding = {"padx":"2", "pady":"0"}
scale_list = []
scale_values_list = []
default_scale_values = [5, 7, 10, 20, 30, 40, 60, 100, 200]
for i in range(9):
scale = Scale(contour_body, from_=0, to_=255, orient=HORIZONTAL, **scale_options)
scale.grid(row=i+2, column=0, columnspan=2, sticky=S, **slider_padding)
scale.set(default_scale_values[i])
scale_list.append(scale)
for scale in scale_list:
print(scale)
print(type(scale))
#print(scale.get())
def contour():
scale_values_list.clear()
for scale in scale_list:
scale_values_list.append(scale.get())
contour_image(scale_values_list)
image_data = Image.open("Contoured_image.png")
thumbnail = create_thumbnail(image_data, canvas_size)
export_canvas.create_image(0, 0, image=thumbnail, anchor=NW)
contour_button = Button(contour_body, text="Contour image", command=contour)
contour_button.grid(row=11, column=0, columnspan=2, sticky=E+S+W, **padding)
contour_body.rowconfigure(11, weight=1)
contour_body.columnconfigure(1, weight=1)
# =============================================================================================================
#
# Contents of export_body
#
# =============================================================================================================
filename_export_variable = StringVar()
def export_file():
filename_options = {}
filename_options['filetypes'] = [('PNG', '.png')]
filename_options['initialfile'] = 'output.png'
filename_options['parent'] = self
filename_export_variable.set(filedialog.asksaveasfilename(**filename_options))
image_data = Image.open("Contoured_image.png")
image_data.save(filename_export_variable.get())
export_header = Label(export_body, text="Export", font=big_heading_font)
export_header.grid(row=0, column=0, sticky=N, **padding)
export_canvas = Canvas(export_body, width=canvas_size, height=canvas_size, background='black')
export_canvas.grid(row=1, column=0, **padding)
export_button = Button(export_body, text="Export image", command=export_file)
export_button.grid(row=2, column=0, columnspan=2, sticky=E+W+S, **padding)
export_body.rowconfigure(2, weight=1)
class FloatEntry(IntegerEntry):
"""Float class for entry
Parameters
----------
parent : str
parent handle
lf_text : str
text on LabelFrame
l_limit : float
lower limit
u_limit : float
upper limit
def_inp : str
default text
colour : str
frame colour
mod : boolean
enable or disable state switch
Returns
-------
float
"""
def __init__(self,
parent,
lf_text,
l_limit,
u_limit,
def_inp="",
colour='brown',
mod=False):
'''
#self.parent = parent
#self.lf_text = lf_text
#self.mod = mod
#self.def_inp=def_inp
#self.colour = colour
#self.l_limit = l_limit
#self.u_limit = u_limit
'''
super().__init__(parent, lf_text, l_limit, u_limit, def_inp, colour,
mod)
self.out_var = DoubleVar()
self.out_var.set(def_inp)
self.construct(colour)
self.make_entry()
self.limits()
def is_okay(self, text, inp, ind):
""" validation function
Parameters
----------
text : str
text if allowed
inp : str
current input
Returns
-------
boolean
"""
if text in ("", "-", ".", "-."):
return True
try:
float(text)
except ValueError:
return False
return True
class HOPSProgressbar(HOPSWidget):
def __init__(self, window, task='Process', length=None):
self.task = task
if not length:
length = 4 / window.log.plt2screen_w
widget = Frame(window.main_frame)
self.progress = DoubleVar(widget, value=0)
self.progressbar = Progressbar(widget,
variable=self.progress,
length=length *
window.root.winfo_screenwidth(),
orient=HORIZONTAL,
maximum=100,
mode='determinate',
value=0)
self.task_label = Label(widget,
text=self.task +
' - 000.0 % - time left: 00:00:00')
self.element_label = Label(widget, text=' ')
self.task_label.pack()
self.progressbar.pack()
self.element_label.pack()
self.start_time = 0
self.skip_time = 0
self.total_iterations = 1
self.current_iteration = 0
self.show_at = [0]
HOPSWidget.__init__(self, window, widget, 'Progressbar')
def reset(self):
self.progress.set(0)
self.task_label.configure(text=self.task +
' - 000.0 % - time left: 00:00:00')
def initiate(self, total_iterations, show_every=1):
if isinstance(total_iterations, list):
self.total_iterations = len(total_iterations)
self.elements = total_iterations
else:
self.total_iterations = int(total_iterations)
self.elements = None
self.current_iteration = 0
self.start_time = time.time()
self.show_at = list(
range(1, self.total_iterations,
int(show_every))) + [int(self.total_iterations)]
def show_message(self, message):
if message != self.element_label['text']:
self.element_label.configure(text=message)
def update(self, step=1, skip=0):
self.current_iteration += step
self.skip_time += skip
delta_time = time.time() - self.start_time - self.skip_time
time_left = str(
datetime.timedelta(
seconds=int((self.total_iterations - self.current_iteration) *
delta_time / self.current_iteration)))
percent = round(
100 * float(self.current_iteration) / float(self.total_iterations),
1)
if self.current_iteration in self.show_at:
self.task_label.configure(
text=self.task +
' - {0} % - time left: {1} '.format(percent, time_left))
if self.elements:
self.element_label.configure(
text=self.elements[self.current_iteration - 1])
self.progress.set(percent)
class ErlangCT:
def __init__(self, f_path):
self.root = Tk()
self.root.title("P2: Erlang-C Calculator")
# excel file path
self.f_path = f_path
# member variables
self.num_servers = 0 # result: number of servers
self.ew = 0.0 # result: expected waiting time
self.en = 0.0 # result: expected number packets in system
self.ens = 0.0 # result: expected number of busy servers
self.alpha = 0.0 # input: max waiting time
self.l = 0.0 # input: lambda
self.u = 0.0 # input: mu
# text fields and validation for each variable
self.alpha_entry = Entry(self.root)
self.l_entry = Entry(self.root)
self.u_entry = Entry(self.root)
# text field labels
self.alpha_label = Label(self.root,
text="Waiting Time Should Not Exceed: ")
self.l_label = Label(self.root, text="Desired Arrival Rate (lambda): ")
self.u_label = Label(self.root, text="Desired Service Rate (mu): ")
# calcualte button
self.calculate_button = Button(
self.root,
text="Calculate",
command=lambda: self.update("calculate"))
self.main_menu_button = Button(
self.root,
text="Main Menu",
command=lambda: self.update("main-menu"))
# initialize result text field
self.num_servers_result = IntVar()
self.num_servers_result.set(self.num_servers)
self.ew_result = DoubleVar()
self.ew_result.set(self.ew)
self.en_result = DoubleVar()
self.en_result.set(self.en)
self.ens_result = DoubleVar()
self.ens_result.set(self.en)
# result text field labels
self.num_servers_text_label = Label(self.root,
text="Number of Servers Required:")
self.num_servers_result_label = Label(
self.root, textvariable=self.num_servers_result)
self.es_text_label = Label(self.root, text="Expected Waiting Time:")
self.ew_result_label = Label(self.root, textvariable=self.ew_result)
self.en_text_label = Label(self.root,
text="Expected Number Packets in System:")
self.en_result_label = Label(self.root, textvariable=self.en_result)
self.ens_text_label = Label(self.root,
text="Expected Number of Busy Servers:")
self.ens_result_label = Label(self.root, textvariable=self.ens_result)
# Calculator Layout
self.alpha_label.grid(row=1, column=0, columnspan=3, sticky=W)
self.alpha_entry.grid(row=1, column=4, columnspan=1, sticky=E)
self.l_label.grid(row=2, column=0, columnspan=3, sticky=W)
self.l_entry.grid(row=2, column=4, columnspan=1, sticky=E)
self.u_label.grid(row=3, column=0, columnspan=3, sticky=W)
self.u_entry.grid(row=3, column=4, columnspan=1, sticky=E)
self.calculate_button.grid(row=4, column=0)
self.num_servers_text_label.grid(row=5, column=0, sticky=W)
self.num_servers_result_label.grid(row=5,
column=3,
columnspan=2,
sticky=E)
self.es_text_label.grid(row=6, column=0, sticky=W)
self.ew_result_label.grid(row=6, column=3, columnspan=2, sticky=E)
self.en_text_label.grid(row=7, column=0, sticky=W)
self.en_result_label.grid(row=7, column=3, columnspan=2, sticky=E)
self.ens_text_label.grid(row=8, column=0, sticky=W)
self.ens_result_label.grid(row=8, column=3, columnspan=2, sticky=E)
self.main_menu_button.grid(row=9, column=0)
def update(self, method):
if method == "calculate":
self.alpha = float(self.alpha_entry.get())
self.l = float(self.l_entry.get())
self.u = float(self.u_entry.get())
result = erlang_c_time(self.l, self.u, self.alpha)
self.num_servers = result['c']
self.ew = result['ew']
self.en = result['en']
self.ens = result['ens']
self.num_servers_result.set(self.num_servers)
self.ew_result.set(self.ew)
self.en_result.set(self.en)
self.ens_result.set(self.ens)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.num_servers = 0
def write_to_excel(self):
wb = load_workbook(self.f_path)
ws = wb["Part 2"]
data = [["Inputs", "Values", "Results", "Values"],
[
"Max P(wait)", "", "Number of Servers",
str(self.num_servers)
], ["Max E(w)",
str(self.alpha), "E(S)",
str(self.ew)],
["Arrival Rate",
str(self.l), "E(N)",
str(self.en)], ["Service Rate",
str(self.u), "", ""]]
i = 1
for v in data:
j = 1
for e in v:
c = ws.cell(row=i, column=j)
c.value = e
j += 1
i += 1
wb.save(self.f_path)
class HOPSFitsWindow(HOPSWidget):
def __init__(self,
window,
input=None,
input_name=None,
input_options=None,
figsize=None,
show_nav=False,
show_controls=False,
show_axes=False,
subplots_adjust=None,
dwmax=8.0,
dhmax=8.0):
widget = Frame(window.main_frame)
self.show_axes = show_axes
if figsize:
try:
wpcent, hpcent, wmax, hmax, ratio, = figsize
wmax, hmax = dwmax, dhmax
w = min(wpcent * window.log.plt2screen_w, wmax)
h = min(hpcent * window.log.plt2screen_h, hmax)
if h * ratio < w:
w = h * ratio
else:
h = w / ratio
except:
w, h = figsize
self.figure = matplotlib.figure.Figure(figsize=(w, h))
else:
self.figure = matplotlib.figure.Figure()
self.figure.patch.set_facecolor('white')
self.canvas = FigureCanvasTkAgg(self.figure, widget)
self.ax = self.figure.add_subplot(111)
self.ax.tick_params(axis='y', rotation=90)
if not self.show_axes:
self.ax.axis('off')
self.figure.subplots_adjust(left=0.01,
right=0.99,
bottom=0.01,
top=0.99)
if subplots_adjust:
self.figure.subplots_adjust(left=subplots_adjust[0],
right=subplots_adjust[1],
bottom=subplots_adjust[2],
top=subplots_adjust[3])
self.data = None
self.mean = 0
self.std = 0
self.image = None
self.sqrt_vmin = DoubleVar(widget, value=0)
self.vmin = IntVar(widget, value=0)
self.sqrt_vmax = DoubleVar(widget, value=10000)
self.vmax = IntVar(widget, value=10000)
self.gamma = DoubleVar(widget, value=0)
self.flip = IntVar(widget, value=0)
self.mirror = IntVar(widget, value=0)
self.white_sky = IntVar(widget, value=0)
if input_name:
if len(input_name) > 50:
split = [
input_name[i:i + 50]
for i in range(0, len(input_name), 50)
]
input_name = '\n'.join(split)
self.fits_name = StringVar(widget, value=input_name)
self.fits_name_label = Label(widget, textvar=self.fits_name)
# extra widgets
control_frame = Frame(widget)
self.control_frame = control_frame
self.info_label = Label(
control_frame,
text=
'Scroll up/down to zoom in/out. Click & drag to move the image.')
self.mouse_data = StringVar(control_frame, value=' ')
self.mouse_data_label = Label(control_frame, textvar=self.mouse_data)
self.black_entry = Scale(control_frame,
resolution=0.1,
variable=self.sqrt_vmin,
orient=HORIZONTAL,
showvalue=False)
self.black_entry.bind("<B1-Motion>", self.contrast)
self.black_entry.bind("<ButtonRelease-1>", self.contrast)
self.black_entry_label_0 = Label(control_frame,
text='Minimum = ',
anchor=E)
self.black_entry_label = Label(control_frame,
textvar=self.vmin,
anchor=W)
self.black_entry['from_'] = 1
self.black_entry['to'] = 1000
self.white_entry = Scale(control_frame,
resolution=0.1,
variable=self.sqrt_vmax,
orient=HORIZONTAL,
showvalue=False)
self.white_entry.bind("<B1-Motion>", self.contrast)
self.white_entry.bind("<ButtonRelease-1>", self.contrast)
self.white_entry_label_0 = Label(control_frame,
text='Maximum = ',
anchor=E)
self.white_entry_label = Label(control_frame,
textvar=self.vmax,
anchor=W)
self.white_entry['from_'] = 1
self.white_entry['to'] = 1000
self.gamma_entry = Scale(control_frame,
resolution=0.001,
variable=self.gamma,
orient=HORIZONTAL,
showvalue=False)
self.gamma_entry.bind("<B1-Motion>", self.contrast)
self.gamma_entry.bind("<ButtonRelease-1>", self.contrast)
self.gamma_entry_label_0 = Label(control_frame,
text='Stretch factor = ',
anchor=E)
self.gamma_entry_label = Label(control_frame,
textvar=self.gamma,
anchor=W)
self.gamma_entry['from_'] = 0
self.gamma_entry['to'] = 1
self.flip_button = Checkbutton(control_frame,
text='Flip',
variable=self.flip,
command=self.flip_fov)
self.mirror_button = Checkbutton(control_frame,
text='Mirror',
variable=self.mirror,
command=self.mirror_fov)
self.reverse_color_button = Checkbutton(control_frame,
text='White Sky',
variable=self.white_sky,
command=self.reverse_color)
self.reset_button = Button(control_frame,
text='RESET',
command=self.reset)
self.info_label.grid(row=1, column=1, columnspan=4)
self.mouse_data_label.grid(row=2, column=1, columnspan=4)
self.black_entry_label_0.grid(row=3, column=1, columnspan=2)
self.black_entry_label.grid(row=3, column=3)
self.black_entry.grid(row=4,
column=1,
columnspan=4,
sticky=N + S + E + W)
self.white_entry_label_0.grid(row=5, column=1, columnspan=2)
self.white_entry_label.grid(row=5, column=3)
self.white_entry.grid(row=6,
column=1,
columnspan=4,
sticky=N + S + E + W)
self.gamma_entry_label_0.grid(row=7, column=1, columnspan=2)
self.gamma_entry_label.grid(row=7, column=3)
self.gamma_entry.grid(row=8,
column=1,
columnspan=4,
sticky=N + S + E + W)
self.reset_button.grid(row=9, column=1)
self.flip_button.grid(row=9, column=2)
self.mirror_button.grid(row=9, column=3)
self.reverse_color_button.grid(row=9, column=4)
Label(control_frame, text=' ').grid(row=10, column=1, columnspan=4)
self.picked = False
if input:
self.load_fits(input, input_name, input_options)
self.canvas.get_tk_widget().pack(side=TOP)
if show_nav:
toolbar = NavigationToolbar2Tk(self.canvas, self.widget)
toolbar.pack(side=BOTTOM)
self.fits_name_label.pack()
if show_controls:
control_frame.pack()
self.canvas.callbacks.connect('scroll_event', self.zoom)
self.canvas.callbacks.connect('motion_notify_event', self.move)
self.canvas.callbacks.connect('button_press_event', self.pick)
self.canvas.callbacks.connect('button_release_event', self.pick)
HOPSWidget.__init__(self, window, widget, 'FitsWindow')
def load_fits(self, input, input_name=None, input_options=None, draw=True):
if isinstance(input, str):
fits = get_fits_data(input)
input_name = os.path.split(input)[1]
elif isinstance(input, pf.ImageHDU) or isinstance(
input, pf.PrimaryHDU) or isinstance(input, pf.CompImageHDU):
fits = [input]
else:
raise RuntimeError('Invalid input ', type(input))
if input_name:
if len(input_name) > 50:
split = [
input_name[i:i + 50]
for i in range(0, len(input_name), 50)
]
input_name = '\n'.join(split)
self.fits_name.set(input_name)
self.data = fits[0].data
try:
self.mean = fits[0].header[self.window.log.mean_key]
self.std = fits[0].header[self.window.log.std_key]
except:
self.mean = np.median(fits[0].data)
self.std = plc.mad(fits[0].data) * 1.5
self.black_entry['from_'] = np.sqrt(max(0, np.min(self.data)))
self.black_entry['to'] = np.sqrt(np.max(self.data))
self.white_entry['from_'] = np.sqrt(max(0, np.min(self.data)))
self.white_entry['to'] = np.sqrt(np.max(self.data))
self.ax.cla()
if not self.show_axes:
self.ax.axis('off')
self.ax.tick_params(axis='y', rotation=90)
self.vmin.set(
max(1, int(self.mean + self.window.log.frame_low_std * self.std)))
self.vmax.set(
max(1,
int(self.mean + self.window.log.frame_upper_std * self.std)))
self.gamma.set(0)
if input_options:
if input_options[0] != 'auto':
self.vmin.set(input_options[0])
if input_options[1] != 'auto':
self.vmax.set(input_options[1])
self.gamma.set(input_options[2])
self.flip.set(input_options[3])
self.mirror.set(input_options[4])
self.white_sky.set(input_options[5])
self.sqrt_vmin.set(np.sqrt(self.vmin.get()))
self.sqrt_vmax.set(np.sqrt(self.vmax.get()))
self.image = self.ax.imshow(self.data**(10**-self.gamma.get()),
origin='lower',
extent=(0, len(self.data[0]), 0,
len(self.data)),
cmap=Greys,
vmin=self.vmin.get(),
vmax=self.vmax.get())
if self.white_sky.get():
self.image.set_cmap(Greys)
else:
self.image.set_cmap(Greys_r)
if self.flip.get():
self.ax.set_ylim(len(self.data) + 5, 0)
else:
self.ax.set_ylim(0, len(self.data) + 5)
if self.mirror.get():
self.ax.set_xlim(len(self.data[0]) + 5, 0)
else:
self.ax.set_xlim(0, len(self.data[0]) + 5)
if draw:
self.draw()
def reverse_color(self):
if self.white_sky.get():
self.image.set_cmap(Greys)
else:
self.image.set_cmap(Greys_r)
self.draw()
def flip_fov(self):
lims = self.ax.get_ylim()
if self.flip.get():
self.ax.set_ylim(max(lims), min(lims))
else:
self.ax.set_ylim(min(lims), max(lims))
self.draw()
def mirror_fov(self):
lims = self.ax.get_xlim()
if self.mirror.get():
self.ax.set_xlim(max(lims), min(lims))
else:
self.ax.set_xlim(min(lims), max(lims))
self.draw()
def contrast(self, event):
if self.sqrt_vmin.get() >= self.sqrt_vmax.get():
self.sqrt_vmin.set(self.sqrt_vmax.get() - 1)
self.vmin.set(int(self.sqrt_vmin.get()**2))
self.vmax.set(int(self.sqrt_vmax.get()**2))
self.image.set_data(np.maximum(0, self.data)**(10**-self.gamma.get()))
self.image.set_clim(self.vmin.get()**(10**-self.gamma.get()),
self.vmax.get()**(10**-self.gamma.get()))
self.draw()
def get_fov_options(self):
return [
self.vmin.get(),
self.vmax.get(),
self.gamma.get(),
self.flip.get(),
self.mirror.get(),
self.white_sky.get()
]
def pick(self, event):
if isinstance(event, matplotlib.backend_bases.MouseEvent):
if event.inaxes is None:
pass
elif event.name == 'button_press_event':
self.picked = (event.xdata, event.ydata)
elif event.name == 'button_release_event':
self.picked = False
def move(self, event):
if isinstance(event, matplotlib.backend_bases.MouseEvent):
if event.inaxes is None:
pass
elif event.name == 'motion_notify_event':
try:
self.mouse_data.set(
'Mouse on: x={0:.2f}, y={1:.2f}, counts={2:.2f}'.
format(event.xdata, event.ydata,
self.data[int(event.ydata),
int(event.xdata)]))
except:
self.mouse_data.set(
'Mouse on: x={0:.2f}, y={1:.2f}, counts={2}'.format(
event.xdata, event.ydata, '-'))
if self.picked:
dx = event.xdata - self.picked[0]
dy = event.ydata - self.picked[1]
self.ax.set_xlim(self.ax.get_xlim()[0] - dx,
self.ax.get_xlim()[1] - dx)
self.ax.set_ylim(self.ax.get_ylim()[0] - dy,
self.ax.get_ylim()[1] - dy)
self.draw()
def zoom(self, event):
if isinstance(event, matplotlib.backend_bases.MouseEvent):
if event.inaxes is None:
pass
elif event.name == 'scroll_event':
zoom_factor = 1.2
scale_factor = 1.0
if event.button == 'up':
scale_factor = 1 / zoom_factor
elif event.button == 'down':
scale_factor = zoom_factor
xdata = event.xdata
ydata = event.ydata
cur_xlim = self.ax.get_xlim()
cur_ylim = self.ax.get_ylim()
cur_xrange = (cur_xlim[1] - cur_xlim[0])
cur_yrange = (cur_ylim[1] - cur_ylim[0])
new_xrange = cur_xrange * scale_factor
new_yrange = cur_yrange * scale_factor
new_xmin = xdata - new_xrange * (xdata -
cur_xlim[0]) / cur_xrange
new_ymin = ydata - new_yrange * (ydata -
cur_ylim[0]) / cur_yrange
self.ax.set_xlim([new_xmin, new_xmin + new_xrange])
self.ax.set_ylim([new_ymin, new_ymin + new_yrange])
self.draw()
def reset(self):
self.ax.set_xlim(0, len(self.data[0]) + 5)
self.ax.set_ylim(0, len(self.data) + 5)
if self.flip.get():
self.ax.set_ylim(self.ax.get_ylim()[1], self.ax.get_ylim()[0])
if self.mirror.get():
self.ax.set_xlim(self.ax.get_xlim()[1], self.ax.get_xlim()[0])
self.vmin.set(
max(1, int(self.mean + self.window.log.frame_low_std * self.std)))
self.sqrt_vmin.set(np.sqrt(self.vmin.get()))
self.vmax.set(
max(1,
int(self.mean + self.window.log.frame_upper_std * self.std)))
self.sqrt_vmax.set(np.sqrt(self.vmax.get()))
self.gamma.set(0)
self.image.set_data(np.maximum(0, self.data)**(10**-self.gamma.get()))
self.image.set_clim(self.vmin.get()**(10**-self.gamma.get()),
self.vmax.get()**(10**-self.gamma.get()))
self.draw()
def draw(self, update_level=1):
self.canvas.draw()
if update_level == 0:
pass
elif update_level == 1:
self.window.update_idletasks()
elif update_level == 2:
self.window.update()
def disable(self):
for child in self.widget.winfo_children():
try:
child.configure(state='disable')
except:
pass
def activate(self):
for child in self.widget.winfo_children():
try:
child.configure(state='active')
except:
pass
class MyApp(Tk):
"""
This class serves as a central control.
Where are all process are launched and variables are set and shared.
"""
__title__ = "Senior"
def __init__(self, *args, **kwargs):
Tk.__init__(self, *args, **kwargs)
container = Frame(self)
container.grid()
self.serial = SerialComm()
self.frames = {}
self.q = LifoQueue()
self.eye_tracker = EyeTracker(self.q)
self.variables = {}
self.fps = IntVar()
self.fps.set(20)
self.temp = IntVar()
self.temp.set(20)
self.temp.trace("w", self.send_command)
self.variables[self.temp.__str__()] = 't', self.temp
self.temp_current = StringVar()
self.temp_current.set('Temperature')
self.tts = StringVar()
self.tts.set('Type and Play')
self.temp_offset = IntVar()
self.temp_offset.set(5)
self.temp_offset.trace("w", self.send_command)
self.variables[self.temp_offset.__str__()] = 'o', self.temp_offset
self.samples = 9
self.window = IntVar()
self.window.trace("w", self.send_command)
self.variables[self.window.__str__()] = 'w', self.window
self.mouse_control = BooleanVar()
self.mouse_control.set(False)
self.talk = BooleanVar()
self.talk.set(True)
self.alarm = BooleanVar()
self.alarm.set(False)
self.alarm.trace("w", self.send_command)
self.variables[self.alarm.__str__()] = 'a', self.alarm
self.light = BooleanVar()
self.light.set(False)
self.light.trace("w", self.send_command)
self.variables[self.light.__str__()] = 'l', self.light
self.heater = BooleanVar()
self.heater.set(False)
self.heater.trace("w", self.send_command)
self.variables[self.heater.__str__()] = 'h', self.heater
self.ac = BooleanVar()
self.ac.set(False)
self.ac.trace("w", self.send_command)
self.variables[self.ac.__str__()] = 'f', self.ac
self.move = BooleanVar()
self.move.set(False)
self.w, self.h = pyautogui.size()
self.hor_div = DoubleVar()
self.hor_div.set(5)
self.hor_div.trace("w", self.send_command)
self.variables[self.hor_div.__str__()] = 'hor', self.hor_div
self.ver_div = DoubleVar()
self.ver_div.set(5)
self.ver_div.trace("w", self.send_command)
self.variables[self.ver_div.__str__()] = 'ver', self.ver_div
self.mouse_directions = []
self.mouse = MouseAndSpeech(self)
self.t = Thread(target=self.mouse.process)
self.t.start()
self.frame = None
self.draw = False
frame = Preview(container, self)
self.frames[Preview] = frame
frame.grid(row=0, column=1, sticky="nsew", rowspan=100)
self.current_frame = frame
frame = Settings(container, self)
self.frames[Settings] = frame
frame.grid(row=0, column=0, sticky="nsew", pady=10, padx=10)
frame.grid_remove()
frame = Applications(container, self)
self.frames[Applications] = frame
frame.grid(row=0, column=0, sticky="nsew", pady=10, padx=10)
frame.grid_remove()
# Menu Bar
menu = MyMenu(self)
self.config(menu=menu)
Tk.iconbitmap(self, default=resource_path('icon.ico'))
Tk.wm_title(self, "Senior")
w = (self.winfo_screenwidth() - self.eye_tracker.window_size) // 2
self.geometry('+{}+{}'.format(w, 0))
self.protocol("WM_DELETE_WINDOW", lambda: self.close())
def show_frame(self, cont):
"""
This method is used to switch betwen views.
"""
if self.current_frame is not None:
self.current_frame.grid_remove()
frame = self.frames[cont]
frame.grid()
self.current_frame = frame
if cont is Applications:
frame.button_alarm.focus()
def send_command(self, widget, *args):
"""
This method send data to the Arduino whenever a button is clicked.
"""
w = self.variables[widget]
try:
indicator = w[0]
value = str(int(w[1].get()))
if indicator == 'f' and value == '1':
self.heater.set(False)
self.serial.send_serial('h0')
elif indicator == 'h' and value == '1':
self.ac.set(False)
self.serial.send_serial('f0')
elif indicator == 't':
self.heater.set(False)
self.ac.set(False)
s = indicator + value
self.serial.send_serial(s)
if len(value) > 0:
value = float(w[1].get())
if indicator in ['ver', 'hor']:
x_offset = self.ver_div.get()
y_offset = self.hor_div.get()
if indicator == 'ver':
y_offset = value * (self.h // 100)
elif indicator == 'hor':
x_offset = value * (self.w // 100)
self.mouse_directions = [(-x_offset, -y_offset),
(0, -y_offset),
(x_offset, -y_offset),
(-x_offset, 0), 0, (x_offset, 0),
(-x_offset, y_offset),
(0, y_offset),
(x_offset, y_offset), 0]
except:
pass
def close(self):
"""
Method used to to close the program orderly so no threads are left hanging.
"""
print(self.__title__)
while self.mouse.isTalking:
print('Is Talking')
self.eye_tracker.video_capture.release()
clear_queue(self.q)
self.q.put(False)
self.q.join()
self.t.join()
self.destroy()
def __init__(self, master, par=False):
"""
GUI for selecting default parameters - will write parameters to file \
of users choosing.
:type master: Tk
:param master: Tkinter window
:type par: EQcorrscanParameters
:param par: Default parameters to start-up with.
"""
from tkinter import Label, Button, Entry, DoubleVar, StringVar, IntVar
from tkinter import BooleanVar, OptionMenu, Checkbutton
import tkMessageBox
from eqcorrscan.utils import parameters
from obspy import UTCDateTime
import warnings
# Set the default par, only if they don't already exist.
if not par:
par = parameters.EQcorrscanParameters([''], 2, 10, 4, 100, 2,
'1900-01-01', '2300-01-01',
'', 'seishub', 4, False, '',
'jpg', False, 8, 'MAD', 6)
# Callback functions for all variables (ugly)
def update_template_names(*args):
par.template_names = [name.strip() for name in
template_names.get().split(',')]
template_names.set(', '.join(par.template_names))
def update_lowcut(*args):
par.lowcut = lowcut.get()
lowcut.set(par.lowcut)
def update_highcut(*args):
par.highcut = highcut.get()
if par.highcut >= 0.5 * par.samp_rate:
msg = ('Highcut must be less than the Nyquist, setting to ' +
str((par.samp_rate / 2.0) - 1))
tkMessageBox.showwarning(title="Nyquist error",
message=msg)
par.highcut = (par.samp_rate / 2.0) - 1
highcut.set(par.highcut)
def update_filt_order(*args):
par.filt_order = filt_order.get()
filt_order.set(par.filt_order)
def update_samp_rate(*args):
par.samp_rate = samp_rate.get()
if par.highcut >= 0.5 * par.samp_rate:
msg = ('Highcut must be less than the Nyquist, setting to ' +
str((par.samp_rate / 2.0) - 1))
tkMessageBox.showwarning(title="Nyquist error",
message=msg)
par.highcut = (par.samp_rate / 2.0) - 1
highcut.set(par.highcut)
samp_rate.set(par.samp_rate)
def update_debug(*args):
par.debug = debug.get()
debug.set(par.debug)
def update_startdate(*args):
par.startdate = UTCDateTime(startdate.get())
startdate.set(str(par.startdate))
def update_enddate(*args):
par.enddate = UTCDateTime(enddate.get())
enddate.set(str(par.enddate))
def update_archive(*args):
par.archive = archive.get()
archive.set(par.archive)
def update_arc_type(*args):
par.arc_type = arc_type.get()
arc_type.set(par.arc_type)
def update_cores(*args):
par.cores = cores.get()
cores.set(par.cores)
def update_plotvar(*args):
par.plotvar = plotvar.get()
plotvar.set(par.plotvar)
def update_plot_format(*args):
par.plot_format = plot_format.get()
plot_format.set(par.plot_format)
def update_tempdir(*args):
par.tempdir = tempdir.get()
tempdir.set(par.tempdir)
def update_threshold(*args):
par.threshold = threshold.get()
threshold.set(par.threshold)
def update_threshold_type(*args):
par.threshold_type = threshold_type.get()
threshold_type.set(par.threshold_type)
def update_plotdir(*args):
par.plotdir = plotdir.get()
plotdir.set(par.plotdir)
def update_trigger_interval(*args):
par.trigger_interval = trigger_interval.get()
trigger_interval.set(par.trigger_interval)
# Set some grid parameters
nrows = 25
ncolumns = 3
self.master = master
master.title("EQcorrscan parameter setup")
self.label = Label(master, text="Alpha GUI for default setup")
self.label.grid(column=0, columnspan=ncolumns, row=0)
# Set up parameter input
self.t_names_label = Label(master, text="Template names", anchor='e')
self.t_names_label.grid(column=0, row=1, sticky='e')
template_names = StringVar()
template_names.set(', '.join(par.template_names))
self.t_names_box = Entry(master, bd=2, textvariable=template_names)
self.t_names_box.grid(column=1, row=1)
template_names.trace("w", update_template_names)
self.t_names_lookup = Button(master, text="Lookup",
command=lambda: self.get_template_names(par))
self.t_names_lookup.grid(column=2, row=1)
self.lowcut_label = Label(master, text="Lowcut (Hz)", anchor='e')
self.lowcut_label.grid(column=0, row=2, sticky='e')
lowcut = DoubleVar()
lowcut.set(par.lowcut)
self.lowcut_box = Entry(master, bd=2, textvariable=lowcut)
self.lowcut_box.grid(column=1, row=2)
lowcut.trace("w", update_lowcut)
self.highcut_label = Label(master, text="Highcut (Hz)", anchor='e')
self.highcut_label.grid(column=0, row=3, sticky='e')
highcut = DoubleVar()
highcut.set(par.highcut)
self.highcut_box = Entry(master, bd=2, textvariable=highcut)
self.highcut_box.grid(column=1, row=3)
highcut.trace("w", update_highcut)
self.filt_order_label = Label(master, text="Filter order")
self.filt_order_label.grid(column=0, row=4, sticky='e')
filt_order = DoubleVar()
filt_order.set(par.filt_order)
self.filt_order_box = Entry(master, bd=2, textvariable=filt_order)
self.filt_order_box.grid(column=1, row=4)
filt_order.trace("w", update_filt_order)
self.samp_rate_label = Label(master, text="Sample rate (Hz)")
self.samp_rate_label.grid(column=0, row=5, sticky='e')
samp_rate = DoubleVar()
samp_rate.set(par.samp_rate)
self.samp_rate_box = Entry(master, bd=2, textvariable=samp_rate)
self.samp_rate_box.grid(column=1, row=5)
samp_rate.trace("w", update_samp_rate)
self.debug_label = Label(master, text="Debug")
self.debug_label.grid(column=0, row=6, sticky='e')
debug = IntVar()
debug.set(par.debug)
self.debug_box = Entry(master, bd=2, textvariable=debug)
self.debug_box.grid(column=1, row=6)
debug.trace("w", update_debug)
self.startdate_label = Label(master, text="Start date (yyyy-mm-dd)")
self.startdate_label.grid(column=0, row=6, sticky='e')
startdate = StringVar()
startdate.set(par.startdate)
self.startdate_box = Entry(master, bd=2, textvariable=startdate)
self.startdate_box.grid(column=1, row=6)
startdate.trace("w", update_startdate)
self.enddate_label = Label(master, text="End date (yyyy-mm-dd)")
self.enddate_label.grid(column=0, row=8, sticky='e')
enddate = StringVar()
enddate.set(par.enddate)
self.enddate_box = Entry(master, bd=2, textvariable=enddate)
self.enddate_box.grid(column=1, row=8)
enddate.trace("w", update_enddate)
self.archive_label = Label(master, text="Archive")
self.archive_label.grid(column=0, row=9, sticky='e')
archive = StringVar()
archive.set(par.archive)
self.archive_box = Entry(master, bd=2, textvariable=archive)
self.archive_box.grid(column=1, row=9)
archive.trace("w", update_archive)
self.archive_lookup = Button(master, text="Lookup",
command=lambda: self.get_archive(par))
self.archive_lookup.grid(column=2, row=9)
self.arc_type_label = Label(master, text="Archive type")
self.arc_type_label.grid(column=0, row=10, sticky='e')
arc_type = StringVar()
arc_type.set(par.arc_type)
self.arc_type_box = OptionMenu(master, arc_type,
"seishub", "fdsn", "day_vols")
self.arc_type_box.grid(column=1, row=10, sticky='w,e')
arc_type.trace("w", update_arc_type)
self.cores_label = Label(master, text="Number of cores")
self.cores_label.grid(column=0, row=11, sticky='e')
cores = IntVar()
cores.set(par.cores)
self.cores_box = Entry(master, bd=2, textvariable=cores)
self.cores_box.grid(column=1, row=11)
cores.trace("w", update_cores)
self.plotvar_label = Label(master, text="Plotting on/off")
self.plotvar_label.grid(column=0, row=12, sticky='e')
plotvar = BooleanVar()
plotvar.set(par.plotvar)
self.plotvar_box = Checkbutton(master, text='Plot on', var=plotvar,
onvalue=True, offvalue=False)
self.plotvar_box.grid(column=1, row=12)
plotvar.trace("w", update_plotvar)
self.plotdir_label = Label(master, text="Plot directory")
self.plotdir_label.grid(column=0, row=13, sticky='e')
plotdir = StringVar()
plotdir.set(par.plotdir)
self.plotdir_box = Entry(master, bd=2, textvariable=plotdir)
self.plotdir_box.grid(column=1, row=13)
plotdir.trace("w", update_plotdir)
self.plotdir_lookup = Button(master, text="Lookup",
command=lambda: self.get_plotdir(par))
self.plotdir_lookup.grid(column=2, row=13)
self.plot_format_label = Label(master, text="Plot format")
self.plot_format_label.grid(column=0, row=14, sticky='e')
plot_format = StringVar()
plot_format.set(par.plot_format)
self.plot_format_box = OptionMenu(master, plot_format,
"jpg", "eps", "pdf", "png")
self.plot_format_box.grid(column=1, row=14, sticky='w,e')
plot_format.trace("w", update_plot_format)
self.tempdir_label = Label(master, text="Temporary directory")
self.tempdir_label.grid(column=0, row=15, sticky='e')
tempdir = StringVar()
tempdir.set(par.tempdir)
self.tempdir_box = Entry(master, bd=2, textvariable=tempdir)
self.tempdir_box.grid(column=1, row=15)
tempdir.trace("w", update_tempdir)
self.tempdir_lookup = Button(master, text="Lookup",
command=lambda: self.get_tempdir(par))
self.tempdir_lookup.grid(column=2, row=15)
self.threshold_label = Label(master, text="Threshold")
self.threshold_label.grid(column=0, row=16, sticky='e')
threshold = DoubleVar()
threshold.set(par.threshold)
self.threshold_box = Entry(master, bd=2, textvariable=threshold)
self.threshold_box.grid(column=1, row=16)
threshold.trace("w", update_threshold)
self.threshold_type_label = Label(master, text="Threshold type")
self.threshold_type_label.grid(column=0, row=17, sticky='e')
threshold_type = StringVar()
threshold_type.set(par.threshold_type)
self.threshold_type_box = OptionMenu(master, threshold_type,
"MAD", "absolute", "av_chan_corr")
self.threshold_type_box.grid(column=1, row=17, sticky='w,e')
threshold_type.trace("w", update_threshold_type)
self.trigger_interval_label = Label(master,
text="Minimum trigger " +
"interval (s)")
self.trigger_interval_label.grid(column=0, row=18, sticky='e')
trigger_interval = DoubleVar()
trigger_interval.set(par.trigger_interval)
self.trigger_interval_box = Entry(master, bd=2,
textvariable=trigger_interval)
self.trigger_interval_box.grid(column=1, row=18)
trigger_interval.trace("w", update_trigger_interval)
# End of user editable section, now we have read/write buttons
self.read_button = Button(master, text="Read parameters",
command=lambda: self.read_par(master))
self.read_button.grid(column=0, row=nrows-2, sticky='w,e')
self.write_button = Button(master, text="Write parameters",
command=lambda: self.write_par(par))
self.write_button.grid(column=1, row=nrows-2, sticky='w,e')
class ErlangB:
def __init__(self, f_path):
self.root = Tk()
self.root.title("P1: Erlang-B Calculator")
# excel file path
self.f_path = f_path
# member variables
self.num_servers = 0 # result: number of servers
self.pb_actual = 0.0 # result: actual probability of blocking
self.pb = 0.0 # input: desired probability of blocking
self.l = 0.0 # input: lambda
self.u = 0.0 # input: mu
# text fields and validation for each variable
self.pb_entry = Entry(self.root)
self.l_entry = Entry(self.root)
self.u_entry = Entry(self.root)
# text field labels
self.pb_label = Label(self.root, text="Desired Probability of Blocking: ")
self.l_label = Label(self.root, text="Desired Arrival Rate (lambda): ")
self.u_label = Label(self.root, text="Desired Service Rate (mu): ")
# calcualte button
self.calculate_button = Button(self.root, text="Calculate", command=lambda: self.update("calculate"))
self.main_menu_button = Button(self.root, text="Main Menu", command=lambda: self.update("main-menu"))
# initialize result text field
self.num_servers_result = IntVar()
self.num_servers_result.set(self.num_servers)
self.pb_actual_result = DoubleVar()
self.pb_actual_result.set(self.pb_actual)
# result text field labels
self.num_servers_text_label = Label(self.root, text="Number of Servers Required:")
self.num_servers_result_label = Label(self.root, textvariable=self.num_servers_result)
self.pb_actual_text_label = Label(self.root, text="Actual Probability of Blocking:")
self.pb_actual_result_label = Label(self.root, textvariable=self.pb_actual_result)
# Calculator Layout
self.pb_label.grid(row=0, column=0, columnspan=3, sticky=W)
self.pb_entry.grid(row=0, column=4, columnspan=1, sticky=E)
self.l_label.grid(row=1, column=0, columnspan=3, sticky=W)
self.l_entry.grid(row=1, column=4, columnspan=1, sticky=E)
self.u_label.grid(row=2, column=0, columnspan=3, sticky=W)
self.u_entry.grid(row=2, column=4, columnspan=1, sticky=E)
self.calculate_button.grid(row=3, column=0)
self.num_servers_text_label.grid(row=4, column=0, sticky=W)
self.num_servers_result_label.grid(row=4, column=3, columnspan=2, sticky=E)
self.pb_actual_text_label.grid(row=5, column=0, sticky=W)
self.pb_actual_result_label.grid(row=5, column=3, columnspan=2, sticky=E)
self.main_menu_button.grid(row=6, column=0)
def update(self, method):
if method == "calculate":
self.pb = float(self.pb_entry.get())
self.l = float(self.l_entry.get())
self.u = float(self.u_entry.get())
result = erlang_b(self.pb, self.l, self.u)
self.num_servers = result['c']
self.pb_actual = result['pb_actual']
self.num_servers_result.set(self.num_servers)
self.pb_actual_result.set(self.pb_actual)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.num_servers = 0
def write_to_excel(self):
wb = load_workbook(self.f_path)
ws = wb["Part 1"]
data = [
["Inputs", "Values", "Results", "Values"],
["Max P(blocking)", str(self.pb),"Number of Servers", str(self.num_servers)],
["Arrival Rate", str(self.l), "P(blocking)", str(self.pb_actual)],
["Service Rate", str(self.u),"", ""]
]
i = 1
for v in data:
j = 1
for e in v:
c = ws.cell(row = i, column = j)
c.value = e
j += 1
i += 1
wb.save(self.f_path)
def __init__(self, root):
root.title("TP3 - Branch & Bound")
root.resizable(width=False, height=False)
# Labels
res_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=15)
res_label["font"] = ft
res_label["fg"] = "#000"
res_label["justify"] = "center"
self.res_label = res_label
number_of_variables_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=18)
number_of_variables_label["font"] = ft
number_of_variables_label["fg"] = "#333333"
number_of_variables_label["justify"] = "center"
number_of_variables_label["text"] = "Var Num"
number_of_variables_label.grid(row=0, column=0)
max_weight_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=18)
max_weight_label["font"] = ft
max_weight_label["fg"] = "#333333"
max_weight_label["justify"] = "center"
max_weight_label["text"] = "Max W"
max_weight_label.grid(row=0, column=4)
# Entries
num_var = tk.IntVar(root)
num_var.set(7)
number_of_variables = tk.Entry(root, textvariable=num_var)
number_of_variables["borderwidth"] = "1px"
ft = tkFont.Font(family='Times', size=10)
number_of_variables["font"] = ft
number_of_variables["fg"] = "#333333"
number_of_variables["justify"] = "center"
number_of_variables.grid(padx=10, row=0, column=1)
self.number_of_variables = num_var
max_w_var = tk.IntVar(root)
max_w_var.set(1)
max_weight_entry = tk.Entry(root, textvariable=max_w_var)
max_weight_entry["borderwidth"] = "1px"
ft = tkFont.Font(family='Times', size=10)
max_weight_entry["font"] = ft
max_weight_entry["fg"] = "#333333"
max_weight_entry["justify"] = "center"
max_weight_entry.grid(row=0, column=5)
self.max_weight_entry = max_w_var
change_var_entries = tk.Button(root)
change_var_entries["activebackground"] = "#cc0000"
change_var_entries["activeforeground"] = "#ffffff"
change_var_entries["bg"] = "#f0f0f0"
ft = tkFont.Font(family='Times', size=18)
change_var_entries["font"] = ft
change_var_entries["fg"] = "#000"
change_var_entries["justify"] = "center"
change_var_entries["text"] = "Change"
change_var_entries.grid(row=0, column=2)
change_var_entries[
"command"] = self.change_num_of_variables_entries_command
solve_button = tk.Button(root)
solve_button["activebackground"] = "#cc0000"
solve_button["activeforeground"] = "#ffffff"
solve_button["bg"] = "#f0f0f0"
ft = tkFont.Font(family='Times', size=18)
solve_button["font"] = ft
solve_button["fg"] = "#f00"
solve_button["justify"] = "center"
solve_button["text"] = "Search"
solve_button.grid(row=1, column=0)
solve_button["command"] = self.solve_button_command
# init variable entires
x_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=15)
x_label["font"] = ft
x_label["fg"] = "#000"
x_label["justify"] = "center"
x_label["text"] = "Values"
x_label.grid(row=4, column=0)
x_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=15)
x_label["font"] = ft
x_label["fg"] = "#000"
x_label["justify"] = "center"
x_label["text"] = "Weights"
x_label.grid(row=5, column=0)
for i in np.arange(0, int(self.number_of_variables.get()), 1):
x_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=15)
x_label["font"] = ft
x_label["fg"] = "#000"
x_label["justify"] = "center"
x_label["text"] = "x" + str(i + 1)
x_label.grid(row=3, column=i + 1)
x_val_var = DoubleVar(root)
x_val_var.set(0)
x_value_entry = tk.Entry(root, textvariable=x_val_var)
x_value_entry["borderwidth"] = "1px"
ft = tkFont.Font(family='Times', size=10)
x_value_entry["font"] = ft
x_value_entry["fg"] = "#333333"
# x_value_entry['relief'] = "groove"
x_value_entry["justify"] = "center"
x_value_entry.grid(row=4, column=i + 1)
x_w_var = DoubleVar(root)
x_w_var.set(1)
x_weight_entry = tk.Entry(root, textvariable=x_w_var)
x_weight_entry["borderwidth"] = "1px"
ft = tkFont.Font(family='Times', size=10)
x_weight_entry["font"] = ft
x_weight_entry["fg"] = "#333333"
# x_weight_entry['relief'] = "groove"
x_weight_entry["justify"] = "center"
x_weight_entry.grid(row=5, column=i + 1)
self.variables.append(Item(i, x_val_var, x_w_var))
self.lvw.append((x_label, x_value_entry, x_weight_entry))
# default exo values buttons!
x_label = tk.Label(root)
ft = tkFont.Font(family='Times', size=15)
x_label["font"] = ft
x_label["fg"] = "#000"
x_label["justify"] = "center"
x_label["text"] = "Default Values of:"
x_label.grid(row=6, column=0)
tp3_button = tk.Button(root)
tp3_button["activebackground"] = "#cc0000"
tp3_button["activeforeground"] = "#ffffff"
tp3_button["bg"] = "#f0f0f0"
ft = tkFont.Font(family='Times', size=13)
tp3_button["font"] = ft
tp3_button["fg"] = "#000"
tp3_button["justify"] = "center"
tp3_button["text"] = "TP3"
tp3_button.grid(row=6, column=1, pady=10)
tp3_button["command"] = self.tp3_values_set
td2_exo5_button = tk.Button(root)
td2_exo5_button["activebackground"] = "#cc0000"
td2_exo5_button["activeforeground"] = "#ffffff"
td2_exo5_button["bg"] = "#f0f0f0"
ft = tkFont.Font(family='Times', size=13)
td2_exo5_button["font"] = ft
td2_exo5_button["fg"] = "#000"
td2_exo5_button["justify"] = "center"
td2_exo5_button["text"] = "TD2EXO5"
td2_exo5_button.grid(row=6, column=2, pady=10)
td2_exo5_button["command"] = self.td2_exo5_values_set
td2_exo7_button = tk.Button(root)
td2_exo7_button["activebackground"] = "#cc0000"
td2_exo7_button["activeforeground"] = "#ffffff"
td2_exo7_button["bg"] = "#f0f0f0"
ft = tkFont.Font(family='Times', size=13)
td2_exo7_button["font"] = ft
td2_exo7_button["fg"] = "#000"
td2_exo7_button["justify"] = "center"
td2_exo7_button["text"] = "TD2EXO7"
td2_exo7_button.grid(row=6, column=3, pady=10)
td2_exo7_button["command"] = self.td2_exo7_values_set
class ProcessScreen(Frame):
progressBarRun = Progressbar
progressBarStyle = Style
progressNumber = DoubleVar
TextProgressProcess = Label
scanStructObject = scanStruct
log = logController
btProcessFinish = Button
def configureScreen(self):
self.bind("<Configure>", self.configureWidth)
self.log = logController()
self.progressNumber = DoubleVar()
self.progressBarStyle = Style()
self.progressBarStyle.theme_use('clam')
self.progressBarStyle.configure("Horizontal.TProgressbar",
troughcolor='#616161',
background="#34A853",
lightcolor='#34A853',
darkcolor="#34A853")
self.progressBarRun = Progressbar(self,
style="Horizontal.TProgressbar",
variable=self.progressNumber,
maximum=10)
self.progressBarRun.pack(fill=X, padx=10, pady=10)
self.TextProgressProcess = Label(self)
self.TextProgressProcess["bg"] = "#9E9E9E"
self.TextProgressProcess["font"] = ("Roboto Black", "20")
self.TextProgressProcess["fg"] = "white"
self.TextProgressProcess.pack(padx=10, pady=15, expand=True)
self.btProcessFinish = Button(self)
self.btProcessFinish["font"] = ("Roboto Black", "20")
self.btProcessFinish["fg"] = "white"
self.btProcessFinish["relief"] = "flat"
self.btProcessFinish["command"] = self.ProcessFinish
def configureWidth(self, event):
self.TextProgressProcess["wraplength"] = event.width - 15
def executeProcess(self, dirMainExec):
self.scanStructObject = scanStruct(dirMainExec)
self.ConfigScan()
taskExecuteProcess = Thread(target=self.ExecuteScan, args=[])
taskExecuteProcess.start()
def ExecuteScan(self):
executeScanTask = Thread(target=self.scanStructObject.execute, args=[])
executeScanTask.start()
while (self.scanStructObject.isExecuteProcess):
taskUpdProgress = Thread(target=self.updProgressBarRun, args=[])
taskUpdProgress.start()
sleep(0.5)
if (self.progressNumber.get() == 10):
clearTask = Thread(target=self.ClearProgressBar, args=[])
clearTask.start()
if (self.scanStructObject.wasFoundSomething):
if (len(self.scanStructObject.getApperservers()) > 0):
self.master.appservers = self.scanStructObject.getApperservers(
)
else:
self.master.appservers = {}
if (len(self.scanStructObject.getSmartclients()) > 0):
self.master.smartclients = self.scanStructObject.getSmartclients(
)
else:
self.master.smartclients = {}
stageTask = Thread(target=self.updExecuteProcess, args=[])
stageTask.start()
self.master.resultScreen.clear()
self.master.resultScreen.ShowInformationResult()
self.btProcessFinish.pack(fill=X, padx=40, pady=20)
self.btProcessFinish["bg"] = "#34A853"
self.btProcessFinish["text"] = "Proximo >"
self.TextProgressProcess[
"text"] = "Pronto, agora é só ver os resultados!! :)"
else:
self.btProcessFinish.pack(fill=X, padx=40, pady=20)
self.btProcessFinish["bg"] = "#EA4335"
self.btProcessFinish["text"] = "< Anterior"
self.TextProgressProcess[
"text"] = "Não foi encontrado nada nessa pasta :("
def updExecuteProcess(self):
self.TextProgressProcess["text"] = "Gerando Cards do resultado..."
self.progressNumber.set(10)
def ClearProgressBar(self):
self.progressNumber.set(0)
def updProgressBarRun(self):
self.progressNumber.set(self.progressNumber.get() + 1)
self.TextProgressProcess[
"text"] = self.scanStructObject.textProgressExecute
def ProcessFinish(self):
if (self.scanStructObject.wasFoundSomething):
self.master.gotoResult()
else:
self.master.returnToHome()
def ClearComponent(self):
self.btProcessFinish.pack_forget()
self.TextProgressProcess[
"text"] = "Procurando arquivos da estrutura Protheus..."
self.ClearProgressBar()
def ConfigScan(self):
linha = ''
StringErro = ''
try:
with open('configScan.csv', 'r') as configArqCSV:
readerArq = reader(configArqCSV, delimiter=';')
for linha in readerArq:
if (linha[0].upper() == 'APPSERVERKEYS'):
for appServerKey in linha:
if (appServerKey.upper() == 'APPSERVERKEYS'):
pass
else:
self.scanStructObject.addAppServerKey(
appServerKey)
if (linha[0].upper() == 'SMARTCLIENTKEYS'):
for smartclientKey in linha:
if (smartclientKey.upper() == 'SMARTCLIENTKEYS'):
pass
else:
self.scanStructObject.addSmartClientKey(
smartclientKey)
if (linha[0].upper() == 'RPONAME'):
self.scanStructObject.cNameRPO = linha[1] + ".rpo"
except Exception as e:
StringErro += '###########################################################\n'
StringErro += "Erro no CSVConfig: \t" + str(e) + "\n"
StringErro += '###########################################################\n'
self.log.consoleLogAdd(StringErro)
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
Home_Button = ttk.Button(self, text = "Home", command = lambda: controller.show_frame(home_module.Home)) # Button to open Home screen
Home_Button.grid(column = 2, row = 9, sticky = "nwes")
WDB_Button = ttk.Button(self, text = "Watts To dB", command = lambda: controller.show_frame(watts_to_decibels.WDB))# Button to open W to dB screen
WDB_Button.grid(column = 1, row = 9, sticky = "nwes")
def dB_W(*args):
try:
Value = float(Data_In.get())
Range_Set = str(Range_1.get())
if Range_Set == 'dBm':
dBm.set(Value)
dBW.set(Value - 30)
dBk.set(Value - 60)
mW.set(pow(10, (Value / 10)))
W.set(pow(10, (Value / 10)) / 1000)
kW.set(pow(10, (Value / 10)) / 1000000)
if Range_Set == 'dBW':
dBm.set(Value + 30)
dBW.set(Value)
dBk.set(Value - 30)
mW.set(pow(10, (Value / 10)) * 1000)
W.set(pow(10, (Value / 10)))
kW.set(pow(10, (Value / 10)) / 1000)
if Range_Set == 'dBk':
dBm.set(Value + 60)
dBW.set(Value + 30)
dBk.set(Value)
mW.set(pow(10, (Value / 10)) * 1000000)
W.set(pow(10, (Value / 10)) * 1000)
kW.set(pow(10, (Value / 10)))
except ValueError:
dBm.set(0.0)
dBW.set(0.0)
dBk.set(0.0)
mW.set(0.0)
W.set(0.0)
kW.set(0.0)
def dB_range_select(*args):
Range_Set = str(Range_1.get())
if Range_Set == 'dBm':
Range_2.set("mW")
if Range_Set == 'dBW':
Range_2.set("W")
if Range_Set == 'dBk':
Range_2.set("kW")
Range_1 = StringVar()
Range_1.set('dBm')
Range_2 = StringVar()
Range_2.set('mW')
Range_Selection = ttk.Combobox(self, textvariable = Range_1, state = 'readonly')
Range_Selection['values'] = ('dBm', 'dBW', 'dBk')
Range_Selection.grid(column = 2, row = 1, sticky = "nwes")
Range_Selection.bind('<<ComboboxSelected>>', dB_range_select)
Data_In = StringVar()
Data_In.set(0)
dBm = StringVar()
dBm.set(0.0)
dBW = StringVar()
dBW.set(0.0)
dBk = StringVar()
dBk.set(0.0)
mW = StringVar()
mW.set(0.0)
W = StringVar()
W.set(0.0)
kW = DoubleVar()
kW.set(0.0)
dB_entry = ttk.Entry(self, width = 7, textvariable = Data_In)
dB_entry.grid(column = 2, row = 2, sticky = "nwes")
ttk.Label(self, textvariable = dBm).grid(column = 2, row = 3, sticky = "nwes")
ttk.Label(self, textvariable = dBW).grid(column = 2, row = 4, sticky = "nwes")
ttk.Label(self, textvariable = dBk).grid(column = 2, row = 5, sticky = "nwes")
ttk.Label(self, textvariable = mW).grid(column = 2, row = 6, sticky = "nwes")
ttk.Label(self, textvariable = W).grid(column = 2, row = 7, sticky = "nwes")
ttk.Label(self, textvariable = kW).grid(column = 2, row = 8, sticky = "nwes")
ttk.Button(self, text = "Calculate", command = dB_W).grid(column = 3, row = 9, sticky = "nwes")
ttk.Label(self, text = "Please choose a range :").grid(column = 1, row = 1, sticky = "nwes")
ttk.Label(self, text = "Please enter a number :").grid(column = 1, row = 2, sticky = "nwes")
ttk.Label(self, textvariable = Range_1).grid(column = 3, row = 2, sticky = "nwes")
ttk.Label(self, text = "Is equivalent to :").grid(column = 1, row = 3, sticky = "nwes")
ttk.Label(self, textvariable = Range_2).grid(column = 3, row = 3, sticky = "nwes")
ttk.Label(self, text = "dBm").grid(column = 3, row = 3, sticky = "nwes")
ttk.Label(self, text = "dBW").grid(column = 3, row = 4, sticky = "nwes")
ttk.Label(self, text = "dBk").grid(column = 3, row = 5, sticky = "nwes")
ttk.Label(self, text = "mW").grid(column = 3, row = 6, sticky = "nwes")
ttk.Label(self, text = "W").grid(column = 3, row = 7, sticky = "nwes")
ttk.Label(self, text = "kW").grid(column = 3, row = 8, sticky = "nwes")
for child in DBW.winfo_children(self):
child.grid_configure(padx = 5, pady = 5)
