def setup_GUI(fig):
# working with GUI --------------------------------------------
print '\ninitializing...'
# print 'SHELL, "echo ' + '"Start Time:' + ' >> voxBuildTiming.log"'
# print 'SHELL, "echo %date% %time% >> voxBuildTiming.log"' # windows shell
# print 'SHELL, "date >> voxBuildTiming.log"' # linux shell
GUI = tk.Tk()
GUI.title('CSL - Autovox')
GUI.minsize(150,150)
GUI.geometry('1280x400+0+0')
f0 = tk.Frame(GUI) # defining frame
f0.pack(fill='both',expand=True)
f0_area = tk.Canvas(f0, width=10,height=10) # defining canvas area within frame
f0_area.pack(side=tk.TOP)
graph = FigureCanvasTkAgg(fig)
graph.show()
graph.pack()
# but1 = tk.Button(f0, text='Show Voxel Build', height=1, width=15, command= lambda: show_vox_build())
# but1.pack(side=tk.RIGHT)
# f0_area.create_window(10,10, window=but1)
GUI.mainloop()
class InfoTab(tk.Frame):
def __init__(self, parent):
super().__init__(parent)
def display_chart(self, cnt):
try:
self.pie.destroy()
except AttributeError:
pass
fig = PieChart(cnt)
self.pie = FigureCanvasTkAgg(fig, self).get_tk_widget()
self.pie.pack()
class FigureWidget:
def __init__(self, parent, fig):
self.FigureRoot = parent
self.FigureRoot.title("Time Series Plot")
self.canvas = FigureCanvasTkAgg(fig, master=self.FigureRoot)
self.canvas = self.canvas.get_tk_widget()
self.canvas.pack(fill=BOTH,expand=YES)
def UpdatePlot(self, fig):
self.canvas.destroy()
self.canvas = FigureCanvasTkAgg(fig, master=self.FigureRoot)
self.canvas = self.canvas.get_tk_widget()
self.canvas.pack(fill=BOTH,expand=YES)
def destroy(self):
self.FigureRoot.destroy()
class App:
#constructor
def __init__(self):
self.data=data
self.fewarrows=0
self.MakeWindow()
self.refreshDataFrame()
self.refreshPicFrame()
self.fixent=1 #UGLY FIX FOR ENTRIES/ENTRIESIJ
# self.root.mainloop() -maybe needed for Windows OS
#makes frames and frames within frames needed for correct display
def MakeWindow (self):
self.root=tk.Tk()
self.root.wm_title("Data Input and Graphical Output")
self.outsideframed1=tk.Frame(self.root,width=300, height=800)
self.outsideframepic=tk.Frame(self.root,width=675, height=800)
self.outsideframed1.pack(side=tk.LEFT,fill=None,expand=False)
self.outsideframepic.pack(side=tk.LEFT,fill=None,expand=False)
self.outsideframed1.pack_propagate(False)
self.outsideframepic.pack_propagate(False)
self.framed1=tk.Frame(self.outsideframed1,width=200, height=100)
self.framed1.pack(side=tk.LEFT,fill=None,expand=False)
self.framepic=tk.Frame(self.outsideframepic,borderwidth=5,relief=tk.RIDGE)
self.framepic.pack(side=tk.TOP,fill=tk.BOTH,expand=1) #BIG-BAD
self.refreshDataFrame()
self.refreshPicFrame()
#makes the plot: boxes and the (fancy) arrows connecting them
def createBoxGraph(self):
TextBox.list_box=[] #CLEAR ALL PREVIOUS!!!
f = plt.figure(facecolor = 'white')
f.set_size_inches(8,10)
a = f.add_subplot(111)
a.axis('off')
for index in range(len(data.b)):
xy=data.bxy[index]
TextBox(a,xy[0],xy[1],data.b[index],index,data.labels[index],data.boxcolor[index])
id=0
if (self.fewarrows==0):
for i in range(len(data.b)):
for j in range(len(data.b)):
if i!=j and data.a[i][j]!=0:
arrow=ArrowObject(a,i,j,id)
id=id+1
else:
i=self.box_id
for j in range(len(data.b)):
if i!=j and data.a[i][j]!=0:
arrow=ArrowObject(a,i,j,id)
id=id+1
j=self.box_id
for i in range(len(data.b)):
if i!=j and data.a[i][j]!=0:
arrow=ArrowObject(a,i,j,id)
id=id+1
plt.show(block=False)
#coding trick to close extra figures accidentally created in canvas----
openfigs=plt.get_fignums()
last=openfigs[-1]
plt.close(last)
#coding trick to close extra figures accidentally created in canvas----
return f
#used to scale the sizes of the textboxes
def scalebox(vector):
data2=[0 for i in range(len(vector))]
minbox,maxbox=2,30
minb,maxb=min(vector),max(vector)
if minb!=maxb:
data2=[(vector[i]-minb)/(maxb-minb) for i in range(len(vector))]
vectornew=[(maxbox-minbox)*data2[i]+minbox for i in range(len(vector))]
else:
vectornew=[(minbox+maxbox)/2. for i in range(len(vector))]
return vectornew
#Euler numerical integration of the ordinary differential equations
def recalculate(self,pass_data):
#UGLY FIX FOR ENTRIES/ENTRIESIJ----------------------------------------
if self.fixent==1:
self.data.z[0]=[eval((self.entries[i][1].get())) for i in range(len(self.entries))]
if self.fixent==2:
column=[eval((self.entriesIJ[i][1].get())) for i in range(len(self.entriesIJ))]
self.data.ca[:,self.box_id]=column
#UGLY FIX FOR ENTRIES/ENTRIESIJ----------------------------------------
self.fewarrows=0
pass_data.tt=0
for i in range (1,pass_data.numdata):
mtanh=np.tanh(pass_data.z[i-1])
cterm=np.dot(pass_data.ca,mtanh)
pass_data.dx=pass_data.dt*(pass_data.ma*pass_data.z[i-1] + pass_data.ba + cterm)
pass_data.tt=pass_data.tt+pass_data.dt
pass_data.t[i]=pass_data.tt
pass_data.z[i]=pass_data.z[i-1]+pass_data.dx
for j in range(pass_data.numc):
pass_data.z[i][j]=max(pass_data.z[i][j],0.)
#holding values constant
if pass_data.hold==1:
pass_data.z[i][pass_data.jfix]=pass_data.jvalue
#make new plot
App.MakePlot(data)
#scale b's from z[-1]
vector=data.z[-1]
data.b=App.scalebox(vector)
#set z[0]=z[-1] for the NEXT iteration
pass_data.z[0]=pass_data.z[-1]
#CLEAR and REFRESH DATA and PIC frames
App.ClearFrame(self.framed1)
App.ClearFrame(self.framepic)
self.refreshDataFrame()
self.refreshPicFrame()
#makes plot of x(i) vs. time
def MakePlot(pass_data):
print('\nYour plot is ready')
localtime = time.asctime( time.localtime(time.time()) )
x_start=pass_data.z[0]
x_final=pass_data.z[-1]
plt.figure()
plt.axes([0.1,.075,.8,.7])
plt.plot(pass_data.t,pass_data.z[:,0:pass_data.numc])
#print labels on lines
xtext=25
for i in range (pass_data.numc):
ytext=pass_data.z[-1,i]
varis=str(i) #first variable is 0
plt.text(xtext,ytext,varis)
xtext=xtext-1
programname='teal.py, tealclass.py, data.py '+localtime
param1='\n input files= '+str(pass_data.fnamec)+' ' +str(pass_data.fnameb)+' '+str(pass_data.fnamem) +' '+str(pass_data.fnamebtextbxy) + ' dt='+str(pass_data.dt)
start=App.displayinput(pass_data.z[0],75)
finish=App.displayinput(pass_data.z[-1],75)
param2='\nstart= ' + start + '\nfinish= ' + finish
titlelsl=programname+param1 + param2
plt.title(titlelsl, fontsize=8)
plt.show(block=False) #IMPORTANT: to SHOW graph but NOT stop execution
#rounds numbers for x(start), x(final) in the title of plot x(i) vs. time
def displayinput(vector1,number):
#creates string to print from np.array(vector1)
#that is approximately number characters per line
c=''
v1=vector1.tolist()
v2=[round(v1[i],6) for i in range (len(v1))]
a=str(v2)
a2=a.replace(' ','')
a3=list(a2)
a3[0],a3[-1]='',''
numend=0
for i in range(0,len(a3)):
if (a3[i]==',' and numend >= number):
numend=0
a3[i]=',\n'
numend=numend+1
c=''.join(a3)
c2=c.replace(',',', ')
return c2
#clear and refresh ONLY the left initial condition dataframe
def refreshDataFrame(self):
self.fixent=1 #UGLY FIX FOR ENTRIES/ENTRIESIJ
App.ClearFrame(self.framed1)
#frame and buttons on top
newframe=tk.Frame(self.framed1)
newframe.pack(side=tk.TOP,pady=0)
tk.Label(newframe,text='initial conditions',fg='blue').pack(side=tk.LEFT,padx=30,pady=5)
tk.Button(newframe,text='original',command= self.resetIC).pack(side=tk.RIGHT,padx=30,pady=5)
newframe2=tk.Frame(self.framed1)
newframe2.pack(side=tk.TOP,pady=0)
cal1=tk.Button(newframe2,text='CALCULATE',command=(lambda: self.recalculate(data)))
cal1.pack(side=tk.LEFT,padx=30,pady=5)
tk.Button(newframe2,text='ENTER',command=self.refreshPicFrame).pack(side=tk.LEFT,padx=30,pady=5)
#frame for entry widgets for initial conditions
self.framecanvas=tk.Frame(self.framed1)
self.framecanvas.pack(side=tk.BOTTOM,pady=0)
#adding the scroll bar
sizescroll=31*data.numc
self.canvas = tk.Canvas(self.framecanvas,width=400,height=800,scrollregion=(0,0,sizescroll,sizescroll)) #FROM LAUNY
self.canvas.pack(side=tk.LEFT)
scrollbar = tk.Scrollbar(self.framecanvas, command=self.canvas.yview)
scrollbar.pack(side=tk.LEFT, fill='y')
self.canvas.config(width=280,height=800)
self.canvas.configure(yscrollcommand = scrollbar.set)
self.frame = tk.Frame(self.canvas)
self.canvas.create_window((0,0), window=self.frame, anchor='nw')
# creating the initial condition entry widgets
fields=data.labels
default=[str(i) for i in range(len(data.labels))]
entries = []
self.data.zround=[str(round(self.data.z[-1,i],6)) for i in range(len(self.data.z[0]))]
for field in fields:
row = tk.Frame(self.frame)
lab = tk.Label(row, width=12, text=field, anchor='w')
ent = tk.Entry(row,width=10)
row.pack(side=tk.TOP, padx=5, pady=0, expand=1)
lab.pack(side=tk.LEFT,expand=1)
ent.pack(side=tk.RIGHT, expand=tk.YES, fill=tk.Y)
ent.insert(10,self.data.zround[fields.index(field)])
entries.append((field, ent))
self.entries=entries
#TRANSFORM ALL ENTRIES INTO STARTING VALUES FOR COMPUTATION
self.data.z[0]=[eval((entries[i][1].get())) for i in range(len(entries))]
self.outsideframed1.pack(expand=1) #KEEPING THIS FOR THE MOMENT HERE
return
#redraw the textboxes and the arrows connecting them
def refreshPicFrame(self):
#UGLY FIX FOR ENTRIES/ENTRIESIJ----------------------------------------
if self.fixent==1:
self.data.z[0]=[eval((self.entries[i][1].get())) for i in range(len(self.entries))]
if self.fixent==2:
column=[eval((self.entriesIJ[i][1].get())) for i in range(len(self.entriesIJ))]
self.data.ca[:,self.box_id]=column
#UGLY FIX FOR ENTRIES/ENTRIESIJ----------------------------------------
#scale b's from z[0] - NOT Z[-1] like in A NEW CALCULATION
vector=data.z[0]
self.data.b=App.scalebox(vector)
#set z[0]=z[-1] for the NEXT iteration
App.ClearFrame(self.framepic)
self.canvas=tk.Canvas(self.framepic,width=800, height=2400)
f=self.createBoxGraph()
self.canvas = FigureCanvasTkAgg(f, master=self.framepic)
self.canvas.show()
self.canvas._tkcanvas.pack()
cid=f.canvas.mpl_connect('button_press_event',self.onclick)
#clear and refresh ONLY the left cij adjacency matrix dataframe
def refreshCIJFrame(self):
self.fixent=2 #UGLY FIX FOR ENTRIES/ENTRIESIJ
App.ClearFrame(self.framed1)
fromto='FROM '+data.labels[self.box_id]+' TO'
#frame and top buttons
newframe=tk.Frame(self.framed1)
newframe.pack(side=tk.TOP,pady=0)
tk.Label(newframe,text=fromto,bg='thistle1',fg='red').pack(side=tk.LEFT,padx=5)
tk.Button(newframe,text='ALL Cij',command= self.FullrefreshPicFrame).pack(side=tk.LEFT,padx=5)
tk.Button(newframe,text='IC',command= self.refreshDataFrame).pack(side=tk.LEFT,padx=5)
newframe2=tk.Frame(self.framed1)
newframe2.pack(side=tk.TOP,pady=0)
cal2=tk.Button(newframe2,text='CALCULATE',command=(lambda: self.recalculate(data)))
cal2.pack(side=tk.LEFT,padx=30,pady=5)
tk.Button(newframe2,text='ENTER',command=self.refreshPicFrame).pack(side=tk.LEFT,padx=30,pady=5)
#frame for entry widgets for cij adjacency matrix
self.framecanvas=tk.Frame(self.framed1)
self.framecanvas.pack(side=tk.BOTTOM,pady=0)
#adding the scroll bar
sizescroll=31*data.numc
self.canvas = tk.Canvas(self.framecanvas,width=400,height=800,scrollregion=(0,0,sizescroll,sizescroll)) #FROM LAUNY
self.canvas.pack(side=tk.LEFT)
scrollbar = tk.Scrollbar(self.framecanvas, command=self.canvas.yview)
scrollbar.pack(side=tk.LEFT, fill='y')
self.canvas.config(width=280,height=800)
self.canvas.configure(yscrollcommand = scrollbar.set)
self.frame = tk.Frame(self.canvas)
self.canvas.create_window((0,0), window=self.frame, anchor='nw')
# creating the cij adjacency matrix entry widgets
fields=self.data.labels
entriesIJ = []
for field in fields:
row = tk.Frame(self.frame)
lab = tk.Label(row, width=15, text=field, anchor='w',bg='thistle1')
entIJ = tk.Entry(row,bg='thistle1')
row.pack(side=tk.TOP, padx=5, pady=1, expand=1)
lab.pack(side=tk.LEFT,expand=1)
entIJ.pack(side=tk.RIGHT, expand=tk.YES, fill=tk.Y)
entIJ.insert(10,self.data.ca[fields.index(field)][self.box_id])
entriesIJ.append((field, entIJ))
self.entriesIJ=entriesIJ
#TRANSFORM ALL ENTRIES INTO STARTING VALUES FOR COMPUTATION
column=[eval((self.entriesIJ[i][1].get())) for i in range(len(self.entriesIJ))]
self.data.ca[:,self.box_id]=column
self.outsideframed1.pack(expand=1)
return
#return the textbox id that was clicked
def onclick(self,event):
for box in TextBox.list_box:
contains, attrd = box.text.contains(event)
if(contains):
id=box.id
print('\nid,bname(id)= ',id, data.labels[id])
# print('box_%d' % id)
# print('box_' + data.bname[id])
# print('show vars ')
# self.update_dataFrame(id)
self.box_id=id
self.fewarrows=1
self.refreshCIJFrame()
# TextBox.selected_box_id=id
return;
#reset the initial conditions to the input data ic(i) default values
def resetIC(self):
self.data.z[-1]=[self.data.ica[i] for i in range(len(self.data.z[0]))]
self.refreshDataFrame()
#not used
def FullrefreshPicFrame(self):
self.fewarrows=0
self.refreshPicFrame()
#not used, but nice to have to end execution
def myquit(self):
print ('\n I did press CLOSE!')
self.root.destroy()
#removes ALL widgets in frame
#seemed a better option than forget
def ClearFrame(frame):
for widget in frame.winfo_children():
widget.destroy()
# frame.pack_forget()
#not used
#thought needed for binding scroll bar, apparently not
def on_configure(event):
# update scrollregion after starting 'mainloop'
# when all widgets are in canvas
# self.canvas=canvas
canvas.configure(scrollregion=canvas.bbox('all'))
#summing postive and negtive into two seperate arrays
# pass_data.negindex/posindex are not needed
# to excute run App.sumpn(pass_data)
def sumpn(pass_data):
negkeys={} # will be used for get the keys to be used in the summing
poskeys={}
pass_data.avg=0
pass_data.avgpos=0
pass_data.avgneg=0
for x in range(0,len(pass_data.btextbxydata)):
if (pass_data.btextbxydata[x][1]=="gray"):
#pass_data.negindex.append(x)
pass_data.negfin[x]=pass_data.z[-1][x]
negkeys=list(pass_data.negfin.keys())
else:
#pass_data.posindex.append(x)
pass_data.posfin[x]=pass_data.z[-1][x]
poskeys=list(pass_data.posfin.keys())
#adding the positve and negative values
for i in range(0,len(negkeys)):
pass_data.sumneg+=pass_data.negfin[negkeys[i]]
pass_data.avgneg=(pass_data.sumneg/len(negkeys))
if(i==(len(negkeys)-1)):
pass_data.sumneg=0
pass_data.negfin={}
for j in range(0,len(poskeys)):
pass_data.sumpos+=pass_data.posfin[poskeys[j]]
pass_data.avgpos=(pass_data.sumpos/len(poskeys))
if(j==(len(poskeys)-1)):
pass_data.sumpos=0
pass_data.posfin={}
pass_data.avg=pass_data.avgpos-pass_data.avgneg
pass_data.avgpos=0
pass_data.avgneg=0
scheme='user_defined',
classification_kwds={'bins': cluslist},
legend=True)
ax.set_title('Covid-19 Choropleth Map',
fontdict={
'fontsize': 30,
'fontfamily': 'Bahnschrift'
},
loc='center',
color="#FFFFFF")
ax.get_legend().texts[0].set_text('0 - ' + str(cluslist[0]))
[
ax.get_legend().texts[txt].set_text(
str(cluslist[txt - 1]) + ' - ' + str(cluslist[txt]))
for txt in range(1, len(ax.get_legend().texts))
]
[i.set_color("white") for i in ax.get_legend().texts]
ax.set_axis_off()
ax.set_xlim([-1.5e7, 1.7e7])
ax.get_legend().set_bbox_to_anchor((.12, .5))
ax.get_legend().get_frame().set_linewidth(0.0)
ax.get_legend().get_frame().set_facecolor('#191919')
ax.get_figure().patch.set_facecolor('#191919')
#The GUI
root = Tk()
root.state('zoomed')
root.config(bg='#191919')
canvas = FigureCanvasTkAgg(ax.get_figure(), root).get_tk_widget()
canvas.pack()
root.mainloop()
class LakeSurvey(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.titleframe = tk.Frame(self)
self.titleframe.pack()
self.comboframe = tk.Frame(self)
self.comboframe.pack()
self.canvasframe = tk.Frame(self)
self.canvasframe.pack()
self.label = tk.Label(self.titleframe,
text='Fish survey for: ' + DEFAULT_LAKE,
font=LARGE_FONT)
self.label.pack(anchor='center', pady=10)
self.combovals = data['lakeName'].unique()
self.combovals.sort()
self.var = StringVar()
self.lakecombo = ttk.Combobox(self.comboframe, textvariable=self.var)
self.lakecombo.config(values=list(self.combovals))
self.lakecombo.bind('<<ComboboxSelected>>',
lambda x: change_lake(self.var.get()))
self.lakecombo.pack(side=tk.LEFT, anchor='center', padx=10, pady=10)
self.button1 = ttk.Button(self.comboframe,
text='Refresh',
command=lambda: self.refresh_button())
self.button1.pack(side=tk.LEFT, anchor='center')
self.button2 = ttk.Button(
self.comboframe,
text='Home',
command=lambda: controller.show_frame(StartPage))
self.button2.pack(side=tk.LEFT, anchor='center')
self.canvasframe.canvas = self.lake_plot()
self.canvas.pack(fill=tk.BOTH, expand=True, padx=100)
def lake_plot(self):
f = plt.figure()
a = f.add_subplot(111)
q1 = data[data['lakeName'] == DEFAULT_LAKE]
df = q1[['avgLen', 'avgWt', 'fishType']]
n = np.arange(len(df['fishType']))
a.clear()
a.bar(n, df['avgLen'], DEFAULT_WIDTH, label='Average Length')
a.bar(n + DEFAULT_WIDTH,
df['avgWt'],
DEFAULT_WIDTH,
label='Average Weight',
color='g')
a.set_xticks(n + DEFAULT_WIDTH)
a.set_xticklabels(list(df['fishType']), rotation=0, fontsize='small')
a.legend(bbox_to_anchor=(.8, 1.02), loc=8, ncol=2)
a.grid(False)
self.canvas = FigureCanvasTkAgg(f, self)
self.canvas = self.canvas.get_tk_widget()
return self.canvas
def refresh_button(self):
self.label.config(text='Fish survey for: ' + DEFAULT_LAKE)
self.canvas.destroy()
self.canvasframe.canvas = self.lake_plot()
self.canvas.pack(fill=tk.BOTH, expand=True, padx=100)
def set_option(self):
global DEFAULT_LAKE
DEFAULT_LAKE = self.lakecombo.values.get()
class matplotlibSwitchGraphs:
def __init__(self, master):
self.master = master
self.frame = Frame(self.master)
self.fig, self.ax = config_plot()
self.graphIndex = 0
self.canvas = FigureCanvasTkAgg(self.fig, self.master)
self.config_window()
self.draw_graph('janvier')
self.frame.pack(expand=YES, fill=BOTH)
def config_window(self):
self.canvas.mpl_connect("key_press_event", self.on_key_press)
toolbar = NavigationToolbar2Tk(self.canvas, self.master)
toolbar.update()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.button = Button(self.master, text="Quit", command=self._quit)
self.button.pack(side=BOTTOM)
self.button_back = Button(self.master, text="Graphique précédent", command=self.back_graph)
self.button_back.pack(side=BOTTOM)
self.button_next = Button(self.master, text="Graphique suivant", command=self.next_graph)
self.button_next.pack(side=BOTTOM)
def draw_graph(self, month):
if(month == 'année'):
df_temp = pd.DataFrame(columns = ['Température'])
for column in df:
for value in df[column]:
df_temp = df_temp.append({'Températeure':value},ignore_index=True)
df_temp.dropna()
self.ax.clear()
self.ax.plot(df_temp['Température'])
self.ax.set(title='Année')
self.canvas.draw()
else:
self.ax.clear()
self.ax.plot(df[month])
self.ax.set(title=month)
self.canvas.draw()
def on_key_press(event):
key_press_handler(event, self.canvas, toolbar)
def _quit(self):
self.master.quit()
def next_graph(self):
if self.graphIndex == 0:
self.draw_graph('février')
self.graphIndex = 1
elif self.graphIndex == 1:
self.draw_graph('mars')
self.graphIndex = 2
elif self.graphIndex == 2:
self.draw_graph('avril')
self.graphIndex = 3
elif self.graphIndex == 3:
self.draw_graph('mai')
self.graphIndex = 4
elif self.graphIndex == 4:
self.draw_graph('juin')
self.graphIndex = 5
elif self.graphIndex == 5:
self.draw_graph('juillet')
self.graphIndex = 6
elif self.graphIndex == 6:
self.draw_graph('août')
self.graphIndex = 7
elif self.graphIndex == 7:
self.draw_graph('septembre')
self.graphIndex = 8
elif self.graphIndex == 8:
self.draw_graph('octobre')
self.graphIndex = 9
elif self.graphIndex == 9:
self.draw_graph('novembre')
self.graphIndex = 10
elif self.graphIndex == 10:
self.draw_graph('décembre')
self.graphIndex = 11
elif self.graphIndex == 11:
self.draw_graph('janvier')
self.graphIndex = 0
elif self.graphIndex == 12:
self.draw_graph('année')
self.graphIndex = 12
def back_graph(self):
if self.graphIndex == 0:
self.draw_graph('décembre')
self.graphIndex = 11
elif self.graphIndex == 11:
self.draw_graph('novembre')
self.graphIndex = 10
elif self.graphIndex == 10:
self.draw_graph('octobre')
self.graphIndex = 9
elif self.graphIndex == 9:
self.draw_graph('septembre')
self.graphIndex = 8
elif self.graphIndex == 8:
self.draw_graph('août')
self.graphIndex = 7
elif self.graphIndex == 7:
self.draw_graph('juillet')
self.graphIndex = 6
elif self.graphIndex == 6:
self.draw_graph('juin')
self.graphIndex = 5
elif self.graphIndex == 5:
self.draw_graph('mai')
self.graphIndex = 4
elif self.graphIndex == 4:
self.draw_graph('avril')
self.graphIndex = 3
elif self.graphIndex == 3:
self.draw_graph('mars')
self.graphIndex = 2
elif self.graphIndex == 2:
self.draw_graph('février')
self.graphIndex = 1
elif self.graphIndex == 1:
self.draw_graph('janvier')
self.graphIndex = 0
elif self.graphIndex == 12:
self.draw_graph('année')
self.graphIndex = 12
def main():
root = Tk()
matplotlibSwitchGraphs(root)
root.mainloop()
def show_graph():
main()
fenetre = Tk()
fenetre.title("Data tp 1")
fenetre.geometry('800x800')
canvas=Canvas(fenetre,bg='#FFFFFF',width=800,height=800,scrollregion=(0,0,1500,1500))
hbar=Scrollbar(fenetre,orient=HORIZONTAL)
hbar.pack(side=BOTTOM,fill=X)
hbar.config(command=canvas.xview)
vbar=Scrollbar(fenetre,orient=VERTICAL)
vbar.pack(side=RIGHT,fill=Y)
vbar.config(command=canvas.yview)
canvas.config(width=800,height=800)
canvas.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set)
canvas.pack(side=LEFT,expand=True,fill=BOTH)
for index, column in enumerate(df):
canvas.create_text(100,(index*120)+20,fill="black",font="Times 15 bold",
text="Mois : "+str(column))
canvas.create_text(100,(index*120)+40,fill="black",font="Times 10",
text="Moyenne : "+str(df[column].mean()))
canvas.create_text(100,(index*120)+60,fill="black",font="Times 10",
text="Ecart type : "+str(df[column].std()))
canvas.create_text(100,(index*120)+80,fill="black",font="Times 10",
text="Minimum : "+str(df[column].min()))
canvas.create_text(100,(index*120)+100,fill="black",font="Times 10",
text="Maximum : "+str(df[column].max()))
b = Button(fenetre, text="Afficher les graphiques", width=10, command=show_graph,background="white",foreground="black",activebackground="white",activeforeground="black")
b.place(x=300, y=20, anchor="nw", width=150, height=30)
fenetre.mainloop()
class LeftFrame(Frame):
"""
Classe pour la "frame" qui sera la partie gauche de l'insterface.
Celle-ci accueillera les grilles et les plots des statistiques
"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.canvas = None
self.nb_colonnes = 0
self.nb_lignes = 0
self.pas_colonne = 0
self.pas_ligne = 0
self.initialize()
def initialize(self):
self.affiche_grille(self.parent.grilles[0])
self.rescale()
def clean(self):
"""
Vide le contenu de la frame en supprimant les objets contenus dans celle-ci,
en vue de le remplacer par autre chose
"""
for i in self.winfo_children():
i.destroy()
def rescale(self):
"""
Change l'échelle prise par la fenêtre pour un affichage plus pratique,
on n'a alors plus qu'à spécifier les coordonnées comme dans la grille et cette fonction repositionne tout
pour que l'affichage fasse la taille de la fenêtre
"""
if self.canvas is not None and self.pas_colonne != 0 and self.pas_ligne != 0:
self.canvas.scale(ALL, -1, -1, self.pas_colonne, self.pas_ligne)
def afficher_resultat(self, resultat, tps_creat=None, tps_calc=None):
"""
Affiche pour chaque instance du fichier d'entrée:
la chaîne de caractère représentant le chemin emprunté par le robot,
ainsi que le temps de création du graphe et le temps de calcul de ce résultat
:param resultat: liste des chaines de caractères résultats du calcul du chemin le plus rapide des instances
:param tps_creat: temps de création du graphe pour chaque instance
:param tps_calc: temps de calcul du chemin le plus rapide pour chaque instance (sans la création du graphe)
:type resultat: list
:type tps_creat: list
:type tps_calc: list
"""
self.clean()
if tps_creat:
label = Label(self,
text="La moyenne du temps de création de graphe sur ce fichier est : " +
str(np.mean(tps_creat)) + " secondes")
label.pack()
if tps_calc:
label = Label(self,
text="La moyenne du temps de calcul du chemin le plus rapide sur ce fichier est : " +
str(np.mean(tps_calc)) + " secondes")
label.pack()
for i in range(len(resultat)):
label = Label(self, text="Problème n°"+str(i))
label.pack()
label_res = Label(self, text=resultat[i])
label_res.pack()
if tps_creat:
label_tps_creat = Label(self, text="La création du graphe a pris " + str(tps_creat[i]) + " secondes")
label_tps_creat.pack()
if tps_calc:
label_tps_calc = Label(self, text="Le calcul de la solution a pris " + str(tps_calc[i]) + " secondes")
label_tps_calc.pack()
def affiche_grille(self, grille): # Ne pas oublier de faire un rescale après appel à cette fonction !!!
"""
Affiche la grille passée en paramètre dans la partie gauche de la fenêtre
:param grille: grille représentant le dépôt constituée de 3 éléments :
- un tuple pour le nombre de lignes et de colonnes
- une liste représentant les lignes du dépôt avec les '0' et '1'
- une liste pour les coordonnées du point de départ, d'arrivée, et l'orientation du robot au départ
:type grille: list
"""
self.clean()
# Récupération des éléments de la grille
self.nb_lignes, self.nb_colonnes = grille[0]
lignes = grille[1]
ligne = grille[2]
self.canvas = Canvas(self, width=leftframewidth, height=leftframeheight)
# Récupération des données du problème
self.pas_colonne = leftframewidth//(self.nb_colonnes + 2)
self.pas_ligne = leftframeheight//(self.nb_lignes + 2)
rayon = 1/2 # rayon des cercles du robot au départ et à l'arrivée
# Dessin du quadrillage
for i in range(0, self.nb_lignes):
for j in range(0, self.nb_colonnes):
if lignes[i][j] == '0':
rectangle(self.canvas, j, i, j+1, i+1)
else:
rectangle(self.canvas, j, i, j+1, i+1, color=couleur_obstacles)
# Dessin du point de départ du robot avec sa flèche
dessine_depart(self.canvas, int(ligne[1]), int(ligne[0]), rayon, ligne[-1])
# Dessin du point d'arrivée du robot
cercle(self.canvas, int(ligne[3]), int(ligne[2]), rayon)
self.canvas.pack()
def affiche_chemin(self, grille, chemin_list, chemin_str):
"""
Affiche la grille et le chemin le plus rapide du robot entre son point de départ et d'arrivée
:param grille: grille représentant le dépôt constituée de 3 éléments (cf affiche_grille)
:param chemin_list: liste de coordonnées des points empruntés par le robot dans sont chemin
:param chemin_str: chaine de caractères résultat du calcul du chemin le plus rapide dans cette grille
:type grille: list
:type chemin_list: list
:type chemin_str: str
"""
# Affichage de la grille elle-même
self.affiche_grille(grille)
# Ajout du chemin par des lignes
for i in range(1, len(chemin_list)):
self.canvas.create_line(chemin_list[i-1][1], chemin_list[i-1][0],
chemin_list[i][1], chemin_list[i][0], width=3)
# on redessine le point de départ pour que ce soit plus "joli"
ligne = grille[2]
rayon = 1/2
dessine_depart(self.canvas, int(ligne[1]), int(ligne[0]), rayon, ligne[-1])
self.canvas.create_text(0, self.nb_lignes+1/2, text=chemin_str, font=("Helvetica", 10), anchor=NW)
self.rescale()
def modifier_grille(self):
"""
Ajoute un lien entre clic gauche et les rectangles de la grille
pour pouvoir modifier leur statut (obstacle ou non)
"""
self.canvas.tag_bind("case", "<Button-1>", self.toggle_obstacle)
def toggle_obstacle(self, event):
"""
Changement du status (obstacle ou non) d'un rectangle de la grille lorsqu'on clique dessus
:param event: clic gauche sur un rectangle
"""
# Récupération du rectangle sur lequel on a cliqué
w = event.widget.find_closest(event.x, event.y)
ligne = (w[0]-1)//self.nb_colonnes
colonne = (w[0]-1) % self.nb_colonnes
# Changement de la grille elle-même en changeant la case correspondante,
# et changement de la couleur du rectangle
if self.parent.grilles[0][1][ligne][colonne] == '1':
self.parent.grilles[0][1][ligne][colonne] = '0'
self.canvas.itemconfig(w, fill="white")
else:
self.parent.grilles[0][1][ligne][colonne] = '1'
self.canvas.itemconfig(w, fill=couleur_obstacles)
def affiche_patienter(self):
"""
Demande à l'utilisateur de patienter pendant le calcul des statistiques qu'il a demandées
"""
self.clean()
label = Label(self, text="Patientez s'il vous plaît\nCalcul des statistiques en cours", font=("Helvetica", 50))
label.grid()
def affiche_plot(self, figure):
"""
Affichage dans la fenêtre du plot correspondant aux statistiques demandées
:param figure: élément figure matplotlib à afficher
"""
self.clean()
self.canvas = FigureCanvasTkAgg(figure, master=self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg(self.canvas, self)
toolbar.update()
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
class LakeSurvey(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.titleframe = tk.Frame(self)
self.titleframe.pack()
self.comboframe = tk.Frame(self)
self.comboframe.pack()
self.canvasframe = tk.Frame(self)
self.canvasframe.pack()
self.label = tk.Label(self.titleframe, text='Fish survey for: '+DEFAULT_LAKE, font=LARGE_FONT)
self.label.pack(anchor='center', pady=10)
self.combovals = data['lakeName'].unique()
self.combovals.sort()
self.var = StringVar()
self.lakecombo = ttk.Combobox(self.comboframe, textvariable=self.var)
self.lakecombo.config(values=list(self.combovals))
self.lakecombo.bind('<<ComboboxSelected>>', lambda x: change_lake(self.var.get()))
self.lakecombo.pack(side=tk.LEFT, anchor='center', padx=10, pady=10)
self.button1 = ttk.Button(self.comboframe, text='Refresh',
command=lambda: self.refresh_button())
self.button1.pack(side=tk.LEFT, anchor='center')
self.button2 = ttk.Button(self.comboframe, text='Home',
command=lambda: controller.show_frame(StartPage))
self.button2.pack(side=tk.LEFT, anchor='center')
self.canvasframe.canvas = self.lake_plot()
self.canvas.pack(fill=tk.BOTH, expand=True, padx=100)
def lake_plot(self):
f = plt.figure()
a = f.add_subplot(111)
q1 = data[data['lakeName'] == DEFAULT_LAKE]
df = q1[['avgLen', 'avgWt', 'fishType']]
n = np.arange(len(df['fishType']))
a.clear()
a.bar(n, df['avgLen'], DEFAULT_WIDTH, label='Average Length')
a.bar(n+DEFAULT_WIDTH, df['avgWt'], DEFAULT_WIDTH, label='Average Weight', color='g')
a.set_xticks(n+DEFAULT_WIDTH)
a.set_xticklabels(list(df['fishType']),rotation=0, fontsize='small')
a.legend(bbox_to_anchor=(.8, 1.02), loc=8, ncol=2)
a.grid(False)
self.canvas = FigureCanvasTkAgg(f, self)
self.canvas = self.canvas.get_tk_widget()
return self.canvas
def refresh_button(self):
self.label.config(text='Fish survey for: '+DEFAULT_LAKE)
self.canvas.destroy()
self.canvasframe.canvas = self.lake_plot()
self.canvas.pack(fill=tk.BOTH, expand=True, padx=100)
def set_option(self):
global DEFAULT_LAKE
DEFAULT_LAKE = self.lakecombo.values.get()
class supreme(Tk):
def __init__(self, *args, **kwargs):
Tk.__init__(self, *args, **kwargs)
self.title("Floor Plan Annotation Tool")
self.geometry("1200x1000")
self.main_menu = Menu(self)
self.config(menu=self.main_menu)
self.fileMenu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_command(label="Open Image",
command=self.open_Folder)
self.folderName = None
self.baseFolder = os.getcwd()
self.folderContent = []
self.csv_file_name = ''
self.xml_file_name = ''
self.f = Figure(figsize=(5, 5), dpi=100)
self.ax = self.f.add_axes([0, 0, 1, 1])
self.df = None
self.s = StringVar()
self.tl_list = []
self.br_list = []
self.t = StringVar()
#plt.ion()
self.canvas = Canvas(width=300, height=400)
self.canvas.pack(pady=100)
self.img = ImageTk.PhotoImage(Image.open("ann_tool.gif"))
self.canvas.create_image(0, 0, image=self.img, anchor=NW)
self.predicted_img = None
def show_pred_image(self, filename):
os.chdir(self.baseFolder)
self.predicted_img, json_result = process_img.predict(
self.folderName, filename)
self.create_csvFile(json_result, filename)
def animate(i):
self.df = pd.read_csv(self.csv_file_name)
lt = []
bt = []
wl = []
hl = []
obj = []
for j in range(self.df.shape[0]):
lt.append(self.df.loc[j]['xleft'])
bt.append(self.df.loc[j]['yleft'])
wl.append(self.df.loc[j]['width'])
hl.append(self.df.loc[j]['height'])
obj.append(self.df.loc[j]['label'])
self.ax.clear()
self.ax.imshow(self.predicted_img)
#print('inside')
self.ax.axis('off')
for left, bottom, w, h, ob in zip(lt, bt, wl, hl, obj):
p = patches.Rectangle((left, bottom),
w,
h,
linewidth=1,
edgecolor='r',
facecolor='none')
self.ax.add_patch(p)
self.ax.text(left + w,
bottom,
ob,
horizontalalignment='right',
verticalalignment='bottom')
self.ax.plot()
if self.canvas != None:
self.canvas.destroy()
self.canvas = FigureCanvasTkAgg(self.f, self)
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=True)
toolbar = NavigationToolbar2TkAgg(self.canvas, self)
toolbar.update()
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=True)
destr_button = Button(self,
text="Discard",
fg='red',
command=self.discardFile)
destr_button.pack(side=LEFT, padx=10, pady=5)
conf_button = Button(self,
text="Confirm",
fg='green',
command=self.confirmFile)
conf_button.pack(side=LEFT, padx=10, pady=5)
def onclick(event):
xcord = event.xdata
ycord = event.ydata
for j in range(self.df.shape[0]):
if (between(xcord, self.df.loc[j]['xleft'],
self.df.loc[j]['xleft'] + self.df.loc[j]['width'])
and between(
ycord, self.df.loc[j]['yleft'],
self.df.loc[j]['yleft'] +
self.df.loc[j]['height'])):
top = Toplevel()
top.geometry('200x120+' +
str(np.random.randint(low=100, high=200)) +
'+' +
str(np.random.randint(low=100, high=200)))
top.title('Edit Object')
button1 = Button(top,
text="Delete",
bg='red',
command=partial(deleteObj, j))
button1.pack()
entry = Entry(top, textvariable=self.s)
self.s.set(root.df.loc[j]['label'])
entry.pack()
button2 = Button(top,
text="Save",
bg='green',
command=partial(saveObj, j))
button2.pack()
else:
if event.dblclick:
toggle_selector.RS = RectangleSelector(
self.ax,
line_select_callback,
drawtype='box',
useblit=True,
button=[1],
minspanx=5,
minspany=5,
spancoords='pixels',
interactive=True)
def between(x, l, r):
if x >= l and x <= r:
return True
else:
return False
def deleteObj(obj_id):
print(obj_id)
self.df.drop([obj_id], axis=0, inplace=True)
df2 = self.df
df2.to_csv(self.csv_file_name, index=False)
def saveObj(obj_id):
obj_name = self.s.get()
self.df['label'][obj_id] = obj_name
df2 = self.df
df2.to_csv(self.csv_file_name, index=False)
def saveNewObj(tl, br):
df2 = pd.DataFrame([[
tl[0], tl[1], br[0] - tl[0], br[1] - tl[1],
self.t.get(), 0.5
]],
columns=[
'xleft', 'yleft', 'width', 'height',
'label', 'confidence'
])
result = self.df.append(df2, ignore_index=True)
result.to_csv(self.csv_file_name, index=False)
self.tl_list = []
self.br_list = []
self.t.set('')
#print('saveNewObj')
toggle_selector.RS.set_active(False)
def toggle_selector(event):
toggle_selector.RS.set_active(True)
def line_select_callback(clk, rls):
#print('line line_select_callback')
self.tl_list.append(int(clk.xdata))
self.tl_list.append(int(clk.ydata))
self.br_list.append(int(rls.xdata))
self.br_list.append(int(rls.ydata))
top = Toplevel()
top.geometry('200x120+' +
str(np.random.randint(low=100, high=200)) + '+' +
str(np.random.randint(low=100, high=200)))
top.title('Add Object')
lb = Label(top, text='Enter Object Name')
lb.pack()
entry = Entry(top, textvariable=self.t)
entry.pack()
button2 = Button(top,
text="Save",
bg='green',
command=partial(saveNewObj, self.tl_list,
self.br_list))
button2.pack()
toggle_selector.RS = RectangleSelector(self.ax,
line_select_callback,
drawtype='box',
useblit=True,
button=[1],
minspanx=5,
minspany=5,
spancoords='pixels',
interactive=True)
bbox = plt.connect('key_press_event', toggle_selector)
cid = self.f.canvas.mpl_connect('button_press_event', onclick)
ani = animation.FuncAnimation(self.f, animate, interval=1000)
#print('after')
plt.show()
#plt.close()
def create_csvFile(self, result, filename):
self.csv_file_name = 'Z' + filename.split('.')[0] + '.csv'
#currFolder = os.getcwd()
os.chdir(self.folderName)
with open(self.csv_file_name, mode='w') as csv_file:
fieldnames = [
'xleft', 'yleft', 'width', 'height', 'label', 'confidence'
]
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
writer.writeheader()
for i, eachline in enumerate(result):
writer.writerow({
'xleft':
eachline['topleft']['x'],
'yleft':
eachline['topleft']['y'],
'width':
eachline['bottomright']['x'] - eachline['topleft']['x'],
'height':
eachline['bottomright']['y'] - eachline['topleft']['y'],
'label':
eachline['label'],
'confidence':
eachline['confidence']
})
def create_xmlFile(self, savedir):
def write_xml(objects, tl, br, savedir):
height, width, depth = self.predicted_img.shape
annotation = ET.Element('annotation')
# ET.SubElement(annotation, 'folder').text = folder
ET.SubElement(annotation, 'filename').text = self.folderContent[0]
ET.SubElement(annotation, 'segmented').text = '0'
size = ET.SubElement(annotation, 'size')
ET.SubElement(size, 'width').text = str(width)
ET.SubElement(size, 'height').text = str(height)
ET.SubElement(size, 'depth').text = str(depth)
for obj, topl, botr in zip(objects, tl, br):
ob = ET.SubElement(annotation, 'object')
ET.SubElement(ob, 'name').text = obj
ET.SubElement(ob, 'pose').text = 'Unspecified'
ET.SubElement(ob, 'truncated').text = '0'
ET.SubElement(ob, 'difficult').text = '0'
bbox = ET.SubElement(ob, 'bndbox')
ET.SubElement(bbox, 'xmin').text = str(topl[0])
ET.SubElement(bbox, 'ymin').text = str(topl[1])
ET.SubElement(bbox, 'xmax').text = str(botr[0])
ET.SubElement(bbox, 'ymax').text = str(botr[1])
xml_str = ET.tostring(annotation)
root = etree.fromstring(xml_str)
xml_str = etree.tostring(root, pretty_print=True)
save_path = os.path.join(
savedir, self.folderContent[0].replace('jpg', 'xml'))
with open(save_path, 'wb') as temp_xml:
temp_xml.write(xml_str)
objects = []
tl = []
br = []
for j in range(self.df.shape[0]):
tl.append((self.df.loc[j]['xleft'], self.df.loc[j]['yleft']))
br.append((self.df.loc[j]['xleft'] + self.df.loc[j]['width'],
self.df.loc[j]['yleft'] + self.df.loc[j]['height']))
objects.append(self.df.loc[j]['label'])
write_xml(objects, tl, br, savedir)
def open_Folder(self):
options = {}
options['initialdir'] = self.baseFolder
options['title'] = 'choose a folder'
options['mustexist'] = False
self.folderName = filedialog.askdirectory(**options)
if self.folderName is not None:
print(self.folderName)
self.folderContent = os.listdir(self.folderName)
self.folderContent = [
files for files in self.folderContent if 'jpg' in files
] #check it
self.folderContent.sort()
#print(self.folderContent)
if 'discard' in self.folderContent:
self.folderContent.remove('discard')
if 'confirm' in self.folderContent:
self.folderContent.remove('confirm')
#os.chdir(self.folderName)
#print(self.folderContent)
else:
print('folder not found')
exit()
self.show_pred_image(self.folderContent[0])
def discardFile(self):
save_discard = 'discard'
#currFolder = os.getcwd()
#os.chdir(self.folderName)
print(os.getcwd())
if os.path.exists(os.path.join(self.folderName,
save_discard)) == False:
os.mkdir(save_discard)
os.rename(self.folderContent[0],
os.path.join(save_discard, self.folderContent[0]))
self.folderContent.pop(0)
os.remove(self.csv_file_name) #check it
if len(self.folderContent) != 0:
self.show_pred_image(self.folderContent[0])
else:
messagebox.showerror('Message', 'All the Images are Processed')
def confirmFile(self):
save_confirm = 'confirm'
#currFolder = os.getcwd()
#os.chdir(self.folderName)
print(os.getcwd())
if os.path.exists(os.path.join(self.folderName,
save_confirm)) == False:
os.mkdir(save_confirm)
self.create_xmlFile(save_confirm)
os.rename(self.folderContent[0],
os.path.join(save_confirm, self.folderContent[0]))
#os.chdir(self.baseFolder)
self.folderContent.pop(0)
os.remove(self.csv_file_name) #check it
if len(self.folderContent) != 0:
self.show_pred_image(self.folderContent[0])
else:
messagebox.showerror('Message', 'All the Images are Processed')
