def construct_Arbre(self, methode, liste, i=0):
self.canvas.delete("all")
self.arbre = Arbre(methode, liste, i)
self.arbre.MAJ()
self.arbre.calcul_Pos_SA()
self.arbre.calcul_barycentre()
self.texte.config(text=Arbre.typeArbre, fg="white")
self.afficheArbre(self.arbre, 1920 // 2, 0)
def arbre_feuille(self):
#pour chaque tuple(freq,char) de notre liste de l'alpha freq:
for (freq,char) in self.listeAlpha_freq:
#ajouter à la liste Arbre:
# - la frequence correspondant à la "valeur" de l'arbre/feuille;
# - le caractere correspondant au "label" de l'arbre/feuille;
self.listeArbre.append(Arbre(freq,char))
#puis retourner la liste Arbre
return self.listeArbre
def creation_feuille(self):
#on parcourt les tuples (frequences,caractere) present dans la liste
#(frequence,alphabet)
#print("les feuilles",liste_afreq,"\n")
for (freq,alpha) in self.liste_afreq:
#on ajoute a la liste des arbres chaque tuple en creant un arbre
#a partir de chaque tuple
self.listeArbre.append(Arbre(freq,alpha))
return self.listeArbre
class Main: #classe ou o fait les test
a = Freqlettre('extraitalice.txt') #on crée un objet Freqlettre
print(a.liste_freq_et_lettre) #on affiche la liste de tuple
b = a.creation_fichier() #on crée le fichier avec les tuples
arbre = Arbre('', a.liste_freq_et_lettre) #création d'un arbre
liste = arbre.tant_que(
) #on applique la methode tant_que a notre objet arbre pour parcourir ttes les feuilles, enlever
#les 2 premiers elem et construire l'arbre
liste[0].affiche_arbre() #affichage du dernier arbre restant dans la liste
a.ecrire_octet(liste[0]) #crée le fichier avec les caractères spéciaux
def extraireSousGraphe(self, point, typeVehicule, etatPatient):
# On utilise la classe Arbre pour créer l'arbre de chemins simples possibles
# variable point étant la racine de l'arbre
arbre = Arbre(point)
arbre.remplirArbre(self.listeSommets, self.matriceArete, typeVehicule,
etatPatient)
# Créer liste contenant les feuilles de l'arbres uniquement
liste = []
arbre.creerListeChemins(liste)
maxDist = 0
indexMax = -1
# Trouver feuille ayant la plus grande distance (en min)
for i in range(len(liste)):
if liste[i].distance > maxDist:
maxDist = liste[i].distance
indexMax = i
# Affichage du chemin et la longueur de celui-ci en minutes
print("\nChemin le plus long sur une charge :\n")
if not indexMax == -1:
strChemin = []
liste[indexMax].afficheChemin(strChemin)
strChemin[len(strChemin) - 1] = strChemin[len(strChemin) - 1][:-3]
for string in strChemin:
print(string, end="")
print("\nLongueur : " + str(maxDist) + " minutes\n")
def __init__(self, game, playerTurn=0, valFirstPlayerIsValJ2=False):
# generation de l'arbre des differents etats possibles
debutchrono = time.time()
self.arbre = Arbre(game)
finchrono = time.time()
self.maximise = playerTurn == 1
self.invertGame = valFirstPlayerIsValJ2 # invertion is needed because the first player of the tree is J1
print('valFirstPlayerIsValJ2: ', valFirstPlayerIsValJ2)
print("Travail termine ! temps ecoule: ",
str(round(finchrono - debutchrono, 3)))
self.game = game
self.node = self.arbre.node
def constructionArbre(l):
A = Arbre()
if len(l) == 0:
showinfo("Erreur", "Le fichier est vide")
return A
elif len(l) == 1:
A = Feuille(l[0])
return A
A.gauche = Feuille(l[0])
A.droit = Feuille(l[1])
for i in range(2, len(l)):
A = A.constructionArbre(l[i])
A.equilibre()
return A
def branch_bound(self, V):
# Affichage au début de l'algo
if self.timed == 0:
self.send_to_Trace("Debut du Branch & Bound :\n", "in")
self.timed = time.time()
# Initialisation de l'algo
arbre = Arbre(V, self)
# Initialisation de la liste des feuilles
sol = arbre.update()
# Tant qu'on a pas de solution, on met à jour la liste des feuilles
while not sol:
sol = arbre.update()
if isinstance(sol, str):
print sol
return
# Construction de la solution entière à partir de la feuille
solution = []
while sol:
solution += [(sol.motObj, sol.mot, sol.value)]
sol = sol.pere
# Affichage de la solution et du temps de calcul
self.timed = time.time() - self.timed
self.send_to_Trace("Fin du Branch & Bound ", "out")
self.send_to_Trace(" Temps :" + str(self.timed) + "\n", "time")
self.res = solution
self.sendResult(self.res)
self.pause()
with self.pause_cond:
while self.paused:
self.pause_cond.wait()
self.timed = time.time()
def branch_bound(self, V):
# Affichage au début de l'algo
if self.timed == 0:
self.send_to_Trace("Debut du Branch & Bound :\n", "in")
self.timed = time.time()
# Initialisation de l'algo
arbre = Arbre(V, self)
# Initialisation de la liste des feuilles
sol = arbre.update()
# Tant qu'on a pas de solution, on met à jour la liste des feuilles
while not sol:
sol = arbre.update()
if isinstance(sol, str):
print sol
return
# Construction de la solution entière à partir de la feuille
solution = []
while sol:
solution += [(sol.motObj, sol.mot, sol.value)]
sol = sol.pere
# Affichage de la solution et du temps de calcul
self.timed = time.time() - self.timed
self.send_to_Trace("Fin du Branch & Bound ", "out")
self.send_to_Trace(" Temps :" + str(self.timed) + "\n", "time")
self.res = solution
self.sendResult(self.res)
self.pause()
with self.pause_cond:
while self.paused:
self.pause_cond.wait()
self.timed = time.time()
def constructionMobile(l):
A = Arbre()
if type(l[0]) is int:
A.gauche = Feuille(l[0])
elif type(l[0]) is list:
A.gauche = constructionMobile(l[0])
if len(l) <= 1:
return A.gauche
if type(l[1]) is int:
A.droit = Feuille(l[1])
elif type(l[1]) is list:
A.droit = constructionMobile(l[1])
A.equilibre()
return A
def creationArbre(self):
# On prend les 2 plus petit elements de listeArbre
abr1 = self.listeArbre[0]
abr2 = self.listeArbre[1]
# On cree un nouvel arbre qui va avoir 2 enfants (abr1 et abr2)
arbre = Arbre("", abr1.valeur + abr2.valeur, abr2, abr1)
# On enleve les 2 plus petit elements de listeArbre
self.listeArbre.pop(1)
self.listeArbre.pop(0)
# On recupère l'index de la place ou doit etre placer arbre
index = self.indexNouvelArbre(arbre)
# On ajoute arbre au bon endroit dans listeArbre
self.listeArbre[index:index] = [arbre]
def creationArbre(self):
#on recupere les deux arbres les plus petits de la liste, ce qui correspond
#aux arbres a la premiere et deuxieme places dans la liste
ab1=self.listeArbre[0]
ab2=self.listeArbre[1]
#on cree un nouvel arbre qui prend en frequence la somme des deux arbres
#en label une chaine vide et en fils gauche le plus petit des 2 et en fils
#droit le plus grand
arbre=Arbre(ab1.valeur+ab2.valeur,'',ab1,ab2)
#on enleve de la liste des arbres le plus grand des 2 puis le plus petit
self.listeArbre.pop(1)
self.listeArbre.pop(0)
#on recherche l'index correspond au nouvel arbre precedemment cree
index=self.indexNewArbre(arbre)
#on ajoute dans la liste arbre a sa place le nouvel arbre
self.listeArbre[index:index]=[arbre]
def arbre(self):
#le 1er arbre :
arbre1=self.listeArbre[0]#le plus petit
#le 2eme arbre :
arbre2=self.listeArbre[1]#le deuxième plus petit
#on crée un arbre qui va additionner la fréq des deux arbres/feuilles
#et qui va mettre en fils droit l'arbre2 et en fils gauche l'arbre3
arbre=Arbre(valeur=arbre1.valeur+arbre2.valeur,
label='',fils_droit=arbre2,fils_gauche=arbre1)
#on supprime ensuite les deux arbres de gauche de la listeArbre
self.listeArbre.pop(1)
self.listeArbre.pop(0)
#on appelle la méthode index() qui retourne l'index de l'arbre présent dans la liste en fct de sa valeur et label
index=self.RecupIndexNewArbre(arbre)
#que l'on va utiliser pour ajouter l'arbre à
#la bonne place dans la liste Arbre:
self.listeArbre[index:index]=[arbre]
def assert_arbre_prob(input):
arbre = Arbre()
root = arbre.root
add_children(root, 10)
assert_answer(input, arbre)
def creationFeuille(self):
for (u, v) in self.elem:
self.listeArbre.append(Arbre(v, u))
class Interface(Frame):
"""
"""
def __init__(self, fenetre):
Frame.__init__(self, fenetre)
frame_gauche = Frame(fenetre) # partie boutons
frame_droite = Frame(fenetre) # partie Image Module
frame_gauche.pack(side=LEFT, fill="y")
frame_droite.pack(side=RIGHT, fill="both", expand=1)
frame_gauche.config(background="#303030")
Bouton_A = Button(
frame_gauche,
text="Ouvrir fichier Arbre",
fg="white",
bg="#7F7F7F",
highlightbackground="#303030",
highlightthickness=3,
command=self.openfile_Arbre,
).grid(
row=0, column=0, sticky=W + N + E + S
) # ouvrir Arbre
Bouton_B = Button(
frame_gauche,
text="Ouvrir fichier Liste",
fg="white",
bg="#7F7F7F",
highlightbackground="#303030",
highlightthickness=3,
command=self.openfile_Liste,
).grid(
row=1, column=0, sticky=W + N + E + S
) # ouvrir Liste
self.texte = Label(
frame_gauche, text="Pas d'arbre Ouvert", bg="#7F7F7F", highlightbackground="#303030", highlightthickness=3
)
self.texte.grid(row=2, column=0, sticky=W + N + E + S) # ouvrir Liste
self.canvas = Canvas(
frame_droite, background="#EDEDED", scrollregion=(0, 0, 1920, 1080)
) # partie ou on dessine les arbres
# les ScrollBar de la partie ou on dessine
hbar = Scrollbar(frame_droite, orient=HORIZONTAL, activebackground="#333333")
hbar.pack(side=BOTTOM, fill=X)
hbar.config(command=self.canvas.xview)
vbar = Scrollbar(frame_droite, orient=VERTICAL, activebackground="#333333")
vbar.pack(side=RIGHT, fill=Y)
vbar.config(command=self.canvas.yview)
# configuration du canevas dessin
self.canvas.config(
width=640,
height=480,
xscrollcommand=hbar.set,
yscrollcommand=vbar.set,
highlightbackground="#000000",
borderwidth=1,
highlightthickness=2,
)
self.canvas.pack(expand=True, fill=BOTH)
self.canvas.bind("<4>", lambda event: self.canvas.yview("scroll", -1, "units"))
self.canvas.bind("<5>", lambda event: self.canvas.yview("scroll", 1, "units"))
def openfile_Arbre(self):
self.filename = askopenfilename(parent=self)
try:
f = open(self.filename)
except IOError:
print("Pas de fichier")
return
liste1 = f.readline()
liste1 = eval(liste1)
self.construct_Arbre("A", liste1)
def openfile_Liste(self):
self.filename = askopenfilename(parent=self)
# POPUP
self.popup = Toplevel()
self.popup.title("Options d'ouverture")
# choix binaire/n-aire
self.radio_var = StringVar(self.popup)
self.radio_var.set(1)
binaire = Radiobutton(
self.popup, text="Binaire", variable=self.radio_var, value=1, command=self.select_Naire
).grid(row=0, column=0, sticky=W)
naire = Radiobutton(
self.popup, text="N-aire", variable=self.radio_var, value=2, command=self.select_Naire
).grid(row=0, column=1, sticky=W)
# choix methode construction
lab_Methode = Label(self.popup, text="Methode de Construction :").grid(row=1, column=0, sticky=W)
self.var_methode = StringVar(self.popup)
self.var_methode.set("Arbre binaire Complet")
self.listeMethode = OptionMenu(self.popup, self.var_methode, *dict[1].keys())
self.listeMethode.grid(row=1, column=1, sticky=W)
# choix nombre d'arrete
lab_nb_Arretes = Label(self.popup, text="Nombre d'arrete :").grid(row=2, column=0, sticky=W)
self.nombre_arrete = StringVar()
self.nombre_arrete.set(3)
self.entry = Entry(self.popup, textvariable=self.nombre_arrete, state="disable")
self.entry.grid(row=2, column=1, sticky=W)
#
Bouton_A = Button(self.popup, text="Annuler", command=self.popup.destroy).grid(row=3, column=1, sticky=W)
Bouton_OK = Button(self.popup, text="OK", command=self.optionListe).grid(row=3, column=1, sticky=E)
def select_Naire(self):
if int(self.radio_var.get()) == 1: # si binaire
self.entry.configure(state="disabled") # nombre d'arrete non modifiable
# On change la liste des options d'ouverture
liste = [i for i in dict[1].keys()]
self.var_methode.set(liste[0])
menu = self.listeMethode["menu"]
menu.delete(0, "end")
for item in liste:
menu.add_command(label=item, command=lambda item=item: self.var_methode.set(item))
elif int(self.radio_var.get()) == 2: # si n-naire
self.entry.configure(state="normal")
liste = [i for i in dict[2].keys()]
self.var_methode.set(liste[0])
menu = self.listeMethode["menu"]
menu.delete(0, "end")
for item in liste:
menu.add_command(label=item, command=lambda item=item: self.var_methode.set(item))
def optionListe(self):
print("Vous Avez Choisi la : " + self.var_methode.get() + " nb arrete: " + str(self.nombre_arrete.get()))
f = open(self.filename)
liste1 = f.readlines()
liste1 = [int(i) for i in liste1]
methode = dict[int(self.radio_var.get())][self.var_methode.get()]
self.construct_Arbre(methode, liste1, int(self.nombre_arrete.get()))
self.popup.destroy()
self.arbre.saveArbre("test1")
def afficheArbre(self, arbre, x, y):
self.canvas.create_line(x, y, x, y + 30, width=3)
if arbre.sous_arbre:
self.canvas.create_line(
x - arbre.barycentre, y + 30, x + (arbre.longueur_Tige_Total - arbre.barycentre), y + 30, width=3
)
a, b = x - arbre.barycentre, y + 30
for i, elt in enumerate(arbre.sous_arbre):
self.afficheArbre(elt, a + arbre.ecarts_Tiges[i], b)
else:
pconst = arbre.pprop
self.canvas.create_oval(
x - pconst // 2, y + 30, x + pconst // 2, y + 30 + (pconst), fill="deep sky blue", width=2
)
self.canvas.create_text(x, (y + 35 + (pconst // 4)), text=arbre.poids)
def rollWheel(event):
if event.num == 4:
self.module.yview("scroll", -1, "units")
elif event.num == 5:
self.module.yview("scroll", 1, "units")
def construct_Arbre(self, methode, liste, i=0):
self.canvas.delete("all")
self.arbre = Arbre(methode, liste, i)
self.arbre.MAJ()
self.arbre.calcul_Pos_SA()
self.arbre.calcul_barycentre()
self.texte.config(text=Arbre.typeArbre, fg="white")
self.afficheArbre(self.arbre, 1920 // 2, 0)
def constructionArbreLong(l):
A = Arbre()
if len(l) == 1:
A = Feuille(l[0])
return A
else:
A.droit = Feuille(l[0])
A.gauche = Feuille(l[1])
for i in range(2, len(l)):
tmp = Arbre()
tmp.gauche = Feuille(l[i])
tmp.droit = A
A = tmp
A.equilibre()
return A
def testArbre(self):
graphe = Graphe("centresLocaux.txt")
arbre = Arbre(2)
arbre.fillArbre(graphe.listeSommets, graphe.matriceArete, 0, 1)
