Informatique Première : Autres algorithmes Thèmes

(1)

Informatique Première : Autres algorithmes

Thèmes

Le but de cette partie est d’étudier un exemple d’utilisation de l’algorithme kppv (k plus proches voisins) pour la reconnaissance de formes.

Projet 1 : Création d’images PBM

Trouver un algorithme qui permet de tracer un chemin aléatoire entre deux points donnés, c’est-à-dire une suite de points tels que deux points qui se suivent ont la même abscisse ou la même ordonnée.

Trouver un autre algorithme qui permet de tracer un trait aléatoire plus ou moins épais entre deux points donnés.

Utiliser cet algorithme pour créer des images PBM aléatoires de dix pixels qui représente un ou un plus ou moins grand, plus ou moins épais et plus ou moins bien formé avec des pixels hors des bords.

Créer deux fichiers 'base_v' et 'base_non_v' de 60 images de chaque type.

Ces 120 images formeront la base de données du projet 3.

Projet 2 : Affichage d’images PBM

Écrire le code Python d’une fonction affiche qui affiche une image du projet 1 sur vingt pixels de côté entourée par une bordure de un pixel (contenue dans les vingt) pour qu’elle soit lisible.

Trouver un algorithme qui permet de lisser le trait de l’image et afficher les 120 images du projet 1sur 12 lignes et 10 colonnes.

Projet 3 : Algorithme des k ppv

Écrire le code Python d’une fonction distance qui renvoie une distance entre deux images du format précédent c’est-à-dire un nombre positif qui mesure la proximité des images.

Écrire le code Python d’une fonction ppv qui renvoie la liste triée des distances entre une image donnée et les 120 images de la base de données et leur annotation (1 pour la forme v et 0 pour l’autre).

Utiliser cette fonction pour choisir une valeur de k qui permette de décider efficacement si une image construite avec l’algorithme du projet 1 est de la forme v ou ^.

Méthode proposée

Projet 1

Algorithme du chemin (fonction chemin)

Déterminer le nombre x de déplacements horizontaux et le nombre y de déplacements verticaux entre le point

a et le point b en fonction de leurs coordonnées.

Construire une liste horiz de x entiers distincts compris entre 0 inclus et x+y exclu puis une liste de (x+y)0

(vertical) ou 1 (horizontal). Renvoyer une liste de points correspondants à cette liste.

Algorithme du trait (fonction trait)

Prendre deux chemins et renvoyer une liste de tous les pixels entre les deux chemins.

Représentation d’une forme (fonctions trace_v et trace_non_v)

Prendre trois points a, b, c dans des régions bien choisies de l’image et tracer les traits reliant a et b ainsi que

b et c. Renvoyer la liste des points correspondants.

Utiliser la fonction ecrit_fichier qui prend le nom du fichier et le nombre d’images à écrire en paramètres ainsi que la fonction de traçage (trace_v ou trace_non_v)

Projet 2

La fonction affiche prend trois paramètres : image (la liste des points correspondant à une image) et x et y

(les coordonnées du point où se place le canevas). La fonction lit_fichier renvoie la liste des listes de points des images d’un fichier et la fonction affiche_liste affiche toutes les images d’une liste ainsi que les numéros permettant de les repérer (on placera les images tous les 30 pixels).

Pour le lissage, supprimer tous les coins saillants et combler tous les coins entrants.

(2)

Projet 3

Pour la distance, le plus simple est de prendre le nombre de pixels différents entre les deux images.

La fonction cree_base crée une liste avec les 120 images du projet 1.

La fonction ppv renvoie la liste annotation des annotations (1 si v et 0 sinon) des images d’un jeu de données triées dans l’ordre croissant des distances entre une image donnée et les images du jeu de données.

La fonction essai_kppv qui affiche le résultat (0, 1 ou 0,1) de la comparaison d’une image avec toutes celles d’un jeu de données pour tous les k variant entre 1 et 10 afin de choisir k au mieux et la fonction kppv renvoie un résultat définitif.

Questions Projet 1

On considère le code ci-dessous :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

def chemin(a, b):

if a[1]<b[1]: e = 1 else: e = -1

x = b[0]-a[0]

y = abs(b[1]-a[1]) liste = [0]*(x+y)

horiz = alea_distincts(x, x+y) for i in horiz: liste[i] = 1 points = [a]

for i in range(x+y):

points.append((points[-1][0]+liste[i], points[-1][1]+e*(1-liste[i]))) return points

def trait(a, b):

if a[0]>b[0]: a, b = b, a c1 = chemin(a, b)

c2 = chemin(a, b) liste=[]

for x in range(a[0], b[0]+1):

points1, points2 = [], []

for y in c1:

if y[0]==x: points1.append(y[1]) for y in c2:

if y[0]==x: points2.append(y[1]) min1 = min(min(points1), min(points2)) max1 = max(max(points1), max(points2)) for y in range(min1, max1+1):

liste.append((x, y)) return liste

1. En observant le code de la fonction chemin, donner sa spécification 2. Expliquer le choix de e lignes 2 et 3.

3. Écrire le code de la fonction alea_distincts utilisée ligne 7

4. Expliquer la ligne 11.

5. Expliquer l’intérêt de la ligne 15.

6. Dire à quoi servent les variables points1 et points 2. 7. Expliquer les lignes 25 à 28.

8. Le code de la fonction trace_v est

def trace_v():

a = (randint(1, 3), randint(1, 3)) b = (4, randint(6, 8))

c = (5, randint(6, 8))

d = (randint(6, 8), randint(1, 3))

return trait(a, b) + trait(b, c) + trait(c, d)

Représenter les pixels possibles pour les points a, b, c et d et écrire le code de la fonction trace_non_v. 9. Écrire le code de la fonction ecrit_fichier en écrivant une liste de points par ligne séparés par des ;

10. Quel est le code qui permet d’écrire les fichiers 'base_v' et 'base_non_v'?

(3)

Projet 2

1. Quel est le code qui permet de tracer les bordures d’une image dans un canevas can de 20*20 ? 2. Quel est le code qui permet d’afficher un pixel noir de coordonnées (x, y) sur un canevas ?

3. Par grossissement un point dont les coordonnées sont comprises entre 1 et 8 inclus est représenté sur un canevas de 20 pixels de côté par quatre pixels vers la droite et vers le bas. Quel est le code qui permet d’afficher ces quatre pixels avec une seule ligne et une double boucle ?

4. Pour un point donné, quels sont les quatre cas à étudier pour le lissage ? Comment les identifier ? On considère le code ci-dessous :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

def affiche_fichier(fichier):

f = open(fichier, 'r') i = 0

liste = f.readline() while(liste):

image = []

liste = liste.split(";") for pt in liste:

if len(pt)>2: image.append((int(pt[1]), int(pt[4]))) affiche(image, 35+30*(i%10), 15+30*(i//10))

liste = f.readline() i += 1

for i in range(10):

lab = Label(fen, text= str(i)) lab.place(x= 30*(i+1)+10, y=-4) for j in range(12):

lab = Label(fen, text= str(10*j)) lab.place(x= 0, y= 30*(j+1)-10) f.close()

5. Quel est le type de la variable liste à la ligne 4 puis à la ligne 7 ? 6. Expliquer les lignes 5, 11 et 12.

7. Expliquer la ligne 9 et l’utilité du test.

9. Utiliser ce code pour écrire celui de la fonction lit_fichier. 10. Utiliser ce code pour écrire celui de la fonction affiche_liste.

Projet 3

On considère le code ci-dessous :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

def distance(image1, image2):

d=0

for i in range(1, 9):

for j in range(1, 9):

d += abs(int((i, j)in image1) - int((i, j) in image2)) return d

def ppv(image, jeu_de_donnees):

n = len(jeu_de_donnees) dist, annotation = [], []

for i in range(n):

dist.append(0)

if i<n//2: annotation.append(1) else: annotation.append(0)

for j in range(n): dist[j] = distance(image, jeu_de_donnees[j]) for i in range(1, n):

for j in range(i):

if dist[i]<dist[j]:

temp = dist[j]

dist[j] = dist[i]

dist[i] = temp temp = annotation[j]

annotation[j] = annotation[i]

annotation[i] = temp return annotation

(4)

2. Le code de la ligne 5 est très condensé. Comment peut-on l’écrire avec une structure conditionnelle ? 3. Donner le code de la fonction cree_base qui renvoie une liste de 120 images comme dans le projet 1.

4. Combien de valeurs la fonction distance peut-elle renvoyer pour les images de la base de données ? 5. Expliquer les lignes 13 et 14.

6. Expliquer les lignes 16 à 24.

7. Écrire le code de la fonction essai_kppv avec les paramètres image et jeu_de_donnees.

8. Écrire un code qui permet d’utiliser cette fonction pour 20% des images de la base de données (10 % de chaque type) comparées avec les 80% restant.

9. Pour la fonction kppv, on choisit de prendre k de 1 à 6 et de renvoyer "?" s’il y a une seule incertitude sur les six cas et l’annotation majoritaire dans le cas contraire.

Écrire le code de la fonction kppv ainsi définie.

10. Écrire un code qui donne le nombre d’erreurs que la fonction kppv pourrait renvoyer sur 1000 essais.

Corrigé

Projet 1

1. D’après la ligne 9, la variable points (valeur de retour) est une liste d’éléments du même type que a

et, d’après la ligne 11, on voit que ce sont des tuples de 2 éléments. De plus, d’après la méthode proposée, x est un entier positif donc on doit avoir b[0]>=a[0].

2. La variable e sert à la ligne 11 pour définir l’ordonnée du point à ajouter. Si b[1] > a[1] alors le chemin descend donc y augmente et on prend e = 1.

Dans le cas contraire, y diminue et on prend e = -1

3. def alea_distincts(k, n):

#renvoie k entiers distincts entre 0 inclus et n exclu l = []

for i in range(k):

m = randint(0, n-1) while m in l:

m = randint(0, n-1) l.append(m)

return l

4. D’après les lignes 6 et 8, liste[i] = 0 (déplacement vertical) ou 1 (déplacement horizontal).

points[-1] le dernier point construit pour le chemin et l’abscisse du point suivant est points[-1][0]

pour un déplacement vertical et points[-1][0]+1 pour un déplacement horizontal ce qui correspond à points[-1][0]+liste[i]. De même pour l’ordonnée en prenant en compte e comme expliqué en 2 car 1-liste[i] = 0 pour un déplacement vertical et 1 pour un déplacement horizontal.

5. Pour pouvoir utiliser la fonction chemin aux lignes 16 et 17, il faut respecter la spécification (voir 1) donc si a[0]>b[0] il faut échanger a et b de façon à avoir a[0]<b[0]

6. Les éléments de la liste points1 sont les ordonnées des points de c1 dont l’abscisse est égale à x (pour tout x entre l’abscisse de a et celle de b incluses). De même pour points 2 avec les points de c2. 7. Pour chaque x, min1 est la plus petite des ordonnées des points d’abscisse x sur c1 et sur c2 et max1 la

plus grande. On ajoute tous les points intermédiaires à la liste liste à la ligne 28. 8. Par symétrie, le code de la fonction trace_non_v est :

def trace_non_v():

c = (6, randint(1, 3))

return trait(a, b) + trait(b, c) + trait(c, d)

9. def ecrit_fichier(n, nom, fonction):

f = open(nom, 'w') for i in range(n):

ch = fonction() for pt in ch:

f.write(str(pt) + ";") f.write("\n")

f.close()

a d

b c

(5)

10. ecrit_fichier(60, 'base_v', trace_v)

ecrit_fichier(60, 'base_non_v', trace_non_v)

Projet 2

1. Les pixels d’abscisse et d’ordonnée 0 ou 1 ne sont pas comptés dans l’intérieur du canevas si bien que les bordures se font pour x=2, x=21, y=2 et y=21. De plus create_line trace les pixels d’une ligne depuis le premier point inclus jusqu’au dernier exclu. On a donc le code suivant :

can.create_line(2, 2, 22, 2) can.create_line(21, 2, 21, 22) can.create_line(2, 2, 2, 22) can.create_line(2, 21, 22, 21)

2. On affiche un pixel noir de coordonnées (x, y) en create_line en partant de ce point jusqu’à un point contigu puisque ce dernier ne sera pas tracé. Par exemple can.create_line(x, y, x, y+1). 3. for i in range(2):

for j in range(2):

can.create_line(2*point[0]+i+2, 2*point[1]+j+2, 2*point[0]+i+2, 2*point[1]+j+3)

Dans la suite du code, point[0] et point[1] seront du type str ; il faudra donc les convertir avec int. 4. Ce sont les quatre dispositions suivantes (le point blanc désignant le point donné) :

On utilise quatre variables testG, testH, testD et testB qui valent 0 ou 1 suivant qu’il y a un point à gauche, au-dessus, à droite ou au-dessous du point donné :

for pt in image:

if int(pt[0])==x-1 and int(pt[1])==y: testG = 1 if int(pt[0])==x and int(pt[1])==y-1: testH = 1 if int(pt[0])==x+1 and int(pt[1])==y: testD = 1 if int(pt[0])==x and int(pt[1])==y+1: testB = 1

5. À la ligne 4, la variable liste est du type str et à la ligne 7 c’est une liste d’éléments de type str

6. Tant que la variable liste (str) n’est pas la chaîne vide, la variable liste récupère la ligne suivante du fichier (ligne 11) et la variable i augmente de 1 si bien que i compte les images affichées ligne 10. 7. D’après I.9, chaque ligne d’un fichier contient les tuples correspondants aux points d’une image

séparés par des points-virgules. La variable pt à la ligne 8 est donc une chaîne de caractères de la forme (x, y) si bien que x = pt[1] et y = pt[4] et il faut les convertir en entier pour faire les opérations dessus. De plus le dernier terme de la ligne est "\n". On l’élimine avec le test de la ligne 9

puisque c’est une chaîne de longueur

8. La fonction affiche place un canevas avec les pixels de l’image au point indiqué en argument.

L’abscisse de ce point augmente de 30 avec i tant que son chiffre des unités est inférieur ou égal à 9 et l’ordonnée de 30 dès que i est un multiple de 10 ce qui permet d’afficher l0 images par ligne.

9. def lit_fichier(nom):

f = open(nom, 'r') liste = f.readline() images = []

i = 0

while(liste):

images.append([])

liste = liste.split(";") for pt in liste:

if len(pt)>2: images[i].append((int(pt[1]), int(pt[4]))) liste = f.readline()

i += 1 f.close() return images

10. def affiche_liste(liste):

n = len(liste) for i in range(n):

affiche(liste[i], 35+30*(i%10), 15+30*(i//10)) for i in range(10):

lab = Label(fen, text= str(i)) lab.place(x= 30*(i+1)+10, y=-4) for j in range(n//10+1):

lab = Label(fen, text= str(10*j)) lab.place(x= 0, y= 30*(j+1)-10)

(6)

Projet 3

1. (i, j) in image1 est un booléen qui prend les valeurs True ou False. La fonction int transforme ces valeurs en 1 ou 0 si bien que int((i, j) in image1) - int((i, j) in image2) vaut 0 si le point de coordonnée (i, j) appartient aux deux images et 1 ou -1 sinon. Avec la fonction abs, c’est 0 ou 1

donc d augmente de 1 quand le point appartient à une seule des deux images.

2. if ((i, j)in image1 and (i, j)not in image2) or ((i, j)in image2 and (i, j)not in image1): d += 1

3. def cree_base():

ecrit_fichier(60, 'base_v', trace_v)

ecrit_fichier(60, 'base_non_v', trace_non_v)

return lit_fichier('base_v') + lit_fichier('base_non_v')

4. En reprenant la question I.8, on constate que tous les points dont les coordonnées sont comprises entre 1 et 8 inclus peuvent être dans une image sauf les points de coordonnées (4, 1) , (4, 2) , … ,

(4, 5) et (5, 1), (5, 2) , … , (5, 5) pour celles qui sont construites avec trace_v et sauf les points de coordonnées (4, 4) , (4, 5) , … , (4, 8) et (5, 4) , (5, 5) , … , (5, 8) pour celles qui sont construites avec trace_non_v. Les points (4, 4), (4, 5), (5, 4) et (5, 5) ne sont donc jamais sur une image. Il ne peut donc y avoir au maximum que 64-4=60 points différents entre deux images si bien que la fonction distance renvoie des valeurs entre 0 et 60 inclus.

5. La première moitié de la liste jeu_de_donnees doit être constituée d’images construites avec trace_v

pour qu’elles soient annotées 1 et la deuxième moitié avec l’autre fonction pour être annotées 0. Les annotations sont les valeurs de la liste annotation à l’indice correspondant à l’indice de l’image dans la liste jeu_de_donnees.

6. On reconnaît une version de la méthode de tri par insertion appliqué à la liste dist. Les lignes 22 à 24

permettent de garder les annotations dans le même ordre que les distances.

7. def essai_kppv(image, jeu_de_donnees):

annotation = ppv(image, jeu_de_donnees) for k in range(1, 11):

nbreDe0, nbreDe1=0,0 for i in range(k):

if annotation[i]==0: nbreDe0 += 1 else: nbreDe1 += 1

if nbreDe0>nbreDe1: print("k = "+str(k) + " décision : 0") elif nbreDe0<nbreDe1: print("k = "+str(k) + " décision : 1") else: print("k = "+str(k) + " décision : 0,1")

print('#########')

8. def kppv(image, jeu_de_donnees):

annotation = ppv(image, jeu_de_donnees) resultats = [0]*9

for k in range(1, 7):

nbreDe0, nbreDe1=0,0 for i in range(k):

if annotation[i]==0:

nbreDe0 += 1 else:

nbreDe1 += 1

if nbreDe0<nbreDe1: resultats[k-1] = 1 elif nbreDe0==nbreDe1: return "?"

return max(resultats)

9. jeu_de_donnees = base_images[12: 108]

jeu_test1 = base_images[0: 12]

jeu_test0 = base_images[108: ]

for image in jeu_test1: essai_kppv(image, jeu_de_donnees) print("#########")

for image in jeu_test0: essai_kppv(image, jeu_de_donnees)

10. nbre_erreurs= 0 for i in range(500):

image = trace_v()

if kppv(image, base_images)==0: nbre_erreurs += 1 for i in range(500):

image = trace_non_v()

if kppv(image, base_images)==1: nbre_erreurs += 1 print(nbre_erreurs)

On trouve en moyenne 0 erreur sur 1000 essais.

(7)

Code complet :

from random import randint from tkinter import * fen = Tk()

fen.geometry('400x600+0+0') def alea_distincts(k, n):

#renvoie k entiers distincts entre 0 inclus et n exclu l = []

for i in range(k):

m = randint(0, n-1) while m in l:

m = randint(0, n-1) l.append(m)

return l def chemin(a, b):

if a[1]<b[1]: e = 1 # le chemin descend (y augmente) else: e = -1

x = b[0]-a[0]

y = abs(b[1]-a[1]) liste = [0]*(x+y)

horiz = alea_distincts(x, x+y) # il faut x horizontal sur x+y for i in horiz: liste[i] = 1 # horizontal = 1, vertical = 0 points = [a]

for i in range(x+y):

points.append((points[-1][0]+liste[i], points[-1][1]+e*(1-liste[i]))) return points

def trait(a, b):

if a[0]>b[0]: a, b = b, a # a[0] < b[0]

c1 = chemin(a, b) c2 = chemin(a, b) liste=[]

for x in range(a[0], b[0]+1):

points1, points2 = [], []

for y in c1:

if y[0]==x: points1.append(y[1]) for y in c2:

if y[0]==x: points2.append(y[1]) min1 = min(min(points1), min(points2)) max1 = max(max(points1), max(points2))

for y in range(min1, max1+1): liste.append((x, y)) return liste

def trace_v():

c = (6, randint(6, 8))

return trait(a, b) + trait(b, c) + trait(c, d) def trace_non_v():

c = (6, randint(1, 3))

return trait(a, b) + trait(b, c) + trait(c, d) def lissage(image, can , point):

testG, testH, testD, testB = 0, 0, 0, 0 x, y = int(point[0]), int(point[1])

x1, y1 = 2*int(point[0])+2, 2*int(point[1])+2 for pt in image:

if int(pt[0])==x-1 and int(pt[1])==y: testG = 1 if int(pt[0])==x and int(pt[1])==y-1: testH = 1 if int(pt[0])==x+1 and int(pt[1])==y: testD = 1 if int(pt[0])==x and int(pt[1])==y+1: testB = 1 if (testG, testH, testD, testB) == (1, 1, 0, 0):

can.create_line(x1-1, y1-1, x1-1, y1)

can.create_line(x1+1, y1+1, x1+1, y1+2, fill= "white") if (testG, testH, testD, testB) == (1, 0, 0, 1):

can.create_line(x1-1, y1+2, x1-1, y1+3)

can.create_line(x1+1, y1, x1+1, y1+1, fill= "white") if (testG, testH, testD, testB) == (0, 1, 1, 0):

can.create_line(x1+2, y1-1, x1+2, y1)

can.create_line(x1, y1+1, x1, y1+2, fill= "white") if (testG, testH, testD, testB) == (0, 0, 1, 1):

can.create_line(x1+2, y1+2, x1+2, y1+3)

can.create_line(x1, y1, x1, y1+1, fill= "white")

(8)

def affiche(image, x, y):

can = Canvas(fen, width= 20, height= 20, bg= "white") can.place(x= x, y= y)

can.create_line(2, 2, 22, 2) can.create_line(21, 2, 21, 22) can.create_line(2, 2, 2, 22) can.create_line(2, 21, 22, 21) for point in image:

for i in range(2):

for j in range(2):

can.create_line(2*int(point[0])+i+2, 2*int(point[1])+j+2, 2*int(point[0])+i+2, 2*int(point[1])+j+3) lissage(image, can, point)

def ecrit_fichier(n, nom, fonction):

f = open(nom, 'w') for i in range(n):

ch = fonction()

for pt in ch: f.write(str(pt) + ";") f.write("\n")

f.close()

def lit_fichier(nom):

f = open(nom, 'r') liste = f.readline() images = []

i = 0

while(liste):

images.append([]) liste = liste.split(";") for pt in liste:

if len(pt)>2: images[i].append((int(pt[1]), int(pt[4]))) liste = f.readline()

i += 1 f.close() return images

def affiche_liste(liste):

n = len(liste)

for i in range(n): affiche(liste[i], 35+30*(i%10), 15+30*(i//10)) for i in range(10):

lab = Label(fen, text= str(i)) lab.place(x= 30*(i+1)+10, y=-4) for j in range(n//10+1):

lab = Label(fen, text= str(10*j)) lab.place(x= 0, y= 30*(j+1)-10)

def distance(image1, image2):

d=0

for i in range(1, 9):

for j in range(1, 9):

d += abs(int((i, j) in image1) - int((i, j) in image2)) return d

def cree_base():

ecrit_fichier(60, 'base_v', trace_v)

ecrit_fichier(60, 'base_non_v', trace_non_v)

return lit_fichier('base_v') + lit_fichier('base_non_v') def ppv(image, jeu_de_donnees):

n = len(jeu_de_donnees) dist, annotation = [], []

for i in range(n):

dist.append(0)

if i<n//2: annotation.append(1) else: annotation.append(0) #Récupération des distances

for j in range(n):

dist[j] = distance(image, jeu_de_donnees[j])

#tri parallèle des listes dist et annotation avec dist dans l'ordre croissant for i in range(1,n):

for j in range(i):

if dist[i]<dist[j]:

temp = dist[j]

dist[j] = dist[i]

dist[i] = temp temp = annotation[j]

annotation[j] = annotation[i]

annotation[i] = temp return annotation

(9)

def essai_kppv(image, jeu_de_donnees):

annotation = ppv(image, jeu_de_donnees) for k in range(1, 11):

nbreDe0, nbreDe1=0,0 for i in range(k):

if annotation[i]==0: nbreDe0 += 1 else: nbreDe1 += 1

if nbreDe0>nbreDe1: print("k = "+str(k) + " décision : 0") elif nbreDe0<nbreDe1: print("k = "+str(k) + " décision : 1") else: print("k = "+str(k) + " décision : 0,1")

print('#########')

def kppv(image, jeu_de_donnees):

annotation = ppv(image, jeu_de_donnees) resultats = [0]*9

for k in range(1, 7):

nbreDe0, nbreDe1=0,0 for i in range(k):

if annotation[i]==0:

nbreDe0 += 1 else:

nbreDe1 += 1

if nbreDe0<nbreDe1: resultats[k-1] = 1 elif nbreDe0==nbreDe1: return "?"

return max(resultats) base_images = cree_base()

"""

jeu_de_donnees = base_images[12: 108]

"""

""""""

jeu_de_donnees = base_images[12: 108]

"""

image0 = trace_non_v() image1 = trace_v()

print(kppv(image0, base_images), kppv(image1, base_images)) affiche_liste([image0, image1])

fen.mainloop()