Discussion :

[flolievre]

Bonjour à tous,

C'est la première fois que je post sur le forum, si je m'exprime mal ou que je n'ai pas posté au bon endroit, je m'en excuse d'avance.

Un ami et moi avons développé un petit programme Python permettant de légères modifications sur des images. Lorsque une modification est effectuée sur l'image (par exemple, l'application d'un filtre bleu), la modification s'effectue bien.
Cependant, si une nouvelle modification est apportée (filtre rouge cette fois-ci), le programme ne prend pas en compte le filtre bleu précédemment appliqué.
Nous avons essayé d'arranger cela en vain...
La partie de code actualisant l'image dans le Canvas ressemble à cela : (il y a beaucoup de commentaires mais cela nous permet de nous y retrouver)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def ActualisationDeImage () :
    Fond.destroy()                              # On detruit l'ancienne image
 
    NouvelleImage = Image.open(fichierSortie)   # Le paramètre image représente l'image que l'on veux insérer
 
    NouvellePhoto = ImageTk.PhotoImage(NouvelleImage)   # Avec la fonction ImageTk.PhotoImage (), on peut créer une image compatible Tkinter,
                                                        # qu'on pourra afficher dans un Canvas par la méthode create_image(position, **options)
                                                        # où position réprésente les 2 coordonnées du coin en haut à gauche de l'image,
                                                        # sachant que l'image sera aussi positionnée par rapport au paramètre anchor
                                                        # qui par défaut vaut CENTER. 
 
    NouveauFond = Tk.Canvas(fenetre, width = NouvelleImage.size[0], height = NouvelleImage.size[1])
 
                                                        # Le Canvas ne s'adapte pas par défaut à la place que prennent 
                                                        # les éléments que l'on à dessiner dedans. Donc si l'image que 
                                                        # l'on veux insére est trop grande, on peut être assuré qu'elle sera
                                                        # entièrement visible en renseignant les paramètres width et height à la création du Canvas.
 
    NouveauFond.create_image(0, 0, anchor = Tk.NW, image=NouvellePhoto)  # Pour que l'image soit positionnée en haut à gauche du Canvas,
                                                                         # on doit utiliser la position 0, 0 et rajouter le paramètre anchor = Tk.NW
    NouveauFond.place (x=2, y=2) # On place le Nouveau Fond
    NouveauFond.mainloop()       # On ouvre la Nouvelle Image

Une seconde question, l'une des fonctionnalités du programme est une modification de la luminosité. Pour que cette modification soit plus agréable pour l'utilisateur, nous avons choisi d'utiliser un curseur.
Cependant, celui met énormément de temps avant d'apparaître (tant qu'il n'est pas apparu, on voit uniquement un cadre noir). Est-ce normal ou est ce qu'il y a un moyen plus 'stable' ?
La partie du code liée au curseur est la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#Création d'un widget Luminosité ()
Luminosite=Label(fenetre, text=" Luminosite ", font="Comic 10")
Luminosite.place (x=695, y=35)
 
Valeur = StringVar() # On definit Valeur
Valeur.set(0)        # On donne la valeur que prendra le curseur au départ
 
    # Création d'un widget Curseur
echelle = Scale(fenetre,from_=-150,to=250, resolution=25, orient=HORIZONTAL, length=250, width=10, tickinterval=50, variable=Valeur, command=luminosite)
echelle.place(x=780, y=15)

Voilà, désolé nous sommes débutants et il est difficile au début de se confronter à ce genre d'obstacle ^^'


Merci d'avance et bonne journée.

[wiztricks]

Salut,

Cependant, si une nouvelle modification est apportée (filtre rouge cette fois-ci), le programme ne prend pas en compte le filtre bleu précédemment appliqué.

Ce que vous montrez se contente d'afficher le contenu d'une image lue dans un fichier...
Le contenu du fichier est ce que vous avez sauvegardé après les éventuelles transformations que vous avez appliquées (mais qu'on ne va pas deviner).

Une seconde question, l'une des fonctionnalités du programme est une modification de la luminosité. Pour que cette modification soit plus agréable pour l'utilisateur, nous avons choisi d'utiliser un curseur.
Cependant, celui met énormément de temps avant d'apparaître (tant qu'il n'est pas apparu, on voit uniquement un cadre noir). Est-ce normal ou est ce qu'il y a un moyen plus 'stable' ?

Tout dépend de comment vous avez codé çà... et la encore, impossible de tirer quoi que ce soit du code que vous montrez.

Voilà, désolé nous sommes débutants et il est difficile au début de se confronter à ce genre d'obstacle ^^'

Le premier obstacle est d'arriver à vous faire comprendre. Le plus simple est de poster un petit exemple (du code) qui permette de reproduire ce que vous constatez.

- W

[flolievre]

Un exemple d'une fonction de modification (le filtre bleu) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
def couleurCyan () :                
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à trois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = 0
            v = pixel[1]  
            b = pixel[2]
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas

Est-ce la partie qui pourrait être modifiée pour que les autres modifications soient prises en compte après celles-ci ?

Pour la luminosité, la fonction qui s'en occupe est la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def luminosite(nouvellevaleur):     
    for y in range (H):
        for x in range (L):
            pixel = im1.getpixel((x, y))
 
            R = pixel[0]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Rouge (Valeur comprise entre [0,255])
            V = pixel[1]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Vert (Valeur comprise entre [0,255])
            B = pixel[2]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Bleu (Valeur comprise entre [0,255])
 
            if R < 0: R = 0         # Comme la valeur doit-être comprise entre [0,255], il faut donc suprimer les valeurs inférieurs à 0 et
            if R > 255: R = 255     # supérieurs à 255
 
            if V < 0: V = 0
            if V > 255: V = 255
 
            if B < 0: B = 0
            if B > 255: B = 255
 
            im2.putpixel ((x,y) ,(R,V,B))
 
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage ()

Et le curseur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#Création d'un widget Luminosité 
Luminosite=Label(fenetre, text=" Luminosite ", font="Comic 10")
Luminosite.place (x=695, y=35)
 
Valeur = StringVar() # On definit Valeur
Valeur.set(0)        # On donne la valeur que prendra le curseur au départ
 
    # Création d'un widget Curseur
echelle = Scale(fenetre,from_=-150,to=250, resolution=25, orient=HORIZONTAL, length=250, width=10, tickinterval=50, variable=Valeur, command=luminosite)
echelle.place(x=780, y=15)

J'espère que ce sont les bonnes parties de code :/

[wiztricks]

Quelle est la taille de vos images?
Ou appelez vous widget.quit pour sortir (et terminer) l'appel à ActualisationDeImage (qui fait .mainloop())?

- W

[flolievre]

Les images font toutes du 600*600 et font entre 100 et 200Ko.

Nous n'utilisons widget.quit à aucun moment dans le code. Mainloop() n'est présent qu'à deux endroits dans le code :
- dans la fonction ActualisationDeImage
- A la fin du code pour fermer la fenêtre

[wiztricks]

Les images font toutes du 600*600 et font entre 100 et 200Ko.

Comme vous ne postez pas un code qui permette de reproduire quoi que ce soit, essayez avec des images plus petites.

Nous n'utilisons widget.quit à aucun moment dans le code. Mainloop() n'est présent qu'à deux endroits dans le code

Si vous n'appelez jamais .quit, l'appel à .mainloop() ne se termine pas et ActualisationDeImage non plus.
A chaque appel d'ActualisationDeImage, vous ne libérez pas la mémoire consommée par l'appel précédent.... in fine çà plantera et avant, çà va ramer.

- W

[flolievre]

Comme vous ne postez pas un code qui permette de reproduire quoi que ce soit, essayez avec des images plus petites.

Je ne vois pas quelle partie du code poster pour vous aider ... Cependant je peux poster tout le code mais ça fait un peu indigeste à lire sur le forum non ? :/

Si vous n'appelez jamais .quit, l'appel à .mainloop() ne se termine pas et ActualisationDeImage non plus.
A chaque appel d'ActualisationDeImage, vous ne libérez pas la mémoire consommée par l'appel précédent.... in fine çà plantera et avant, çà va ramer.

D'accord je vois, cependant, à quel endroit dois-je la placer ? Le '.quit' servirait donc à terminer la fonction ActualisationDeImage c'est ça ?

[wiztricks]

Je ne vois pas quelle partie du code poster pour vous aider ... Cependant je peux poster tout le code mais ça fait un peu indigeste à lire sur le forum non ? :/

Essayez avec des images plus petites (10x10) et voir si votre problème persiste... Ca vous pouvez le faire sans rien poster.

D'accord je vois, cependant, à quel endroit dois-je la placer ? Le '.quit' servirait donc à terminer la fonction ActualisationDeImage c'est ça ?

Pourquoi ne pas essayer d'écrire de petits bouts de code pour regarder ce qu'il se passe? Pourquoi appelez mainloop à cet endroit?

La programmation est un de compréhension: vous ne pouvez pas utiliser .mainloop() (ou tout autre méthode/fonction) sans trop savoir pourquoi ni comment puis venir ici demander de l'aide parce que le monstre que vous avez crée échappe à votre contrôle!
Normalement, le code d'un débutant doit être de la forme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
from tkinter import *
 
# un tas de fonctions utilisées comme "callbacks"
 
root = Tk() # création de la fenêtre principale
# création des widgets et association à leur callbacks
root.mainloop()

Si vous sortez de ce canevas, c'est que vous savez programmez (et vous ne demanderiez pas de l'aide ici) ou que vous n'avez pas passé assez de temps dans les tutos. pour apprendre à quoi devait ressembler une application graphique.

- W

[flolievre]

Je comprends bien ce que vous voulez dire.
Cependant, je fais appel à vous sur le forum puisque je suis bloqué sur un point que je ne comprends. De plus, si je poste sur le forum c'est aussi parce que j'ai effectué des recherches qui ne m'ont pas permis de résoudre ce problème.

Le peu de cours que j'ai pu avoir sur Python m'ont permis d'apprendre certaines choses, certes, mais malheureusement pas assez pour tout comprendre et tout maîtriser.
Le problème du curseur est un problème léger et que je peux facilement contourner.

Le plus gênant est celui de l'image qui ne s'actualise pas lorsqu'un filtre est appliquée et qu'une seconde modification est appliquée par la suite. Le programme réutilise à chaque fois l'image d'origine puisque les fonctions sont codées comme ceci.
Par exemple ici, si j'appuie sur le bouton 'filtre rouge', le filtre s'applique bien mais si ensuite, j'appuie sur la rotation de 90°, la rotation s'appliquera sur l'image d'origine et pas sur l'image a qui nous avons déjà appliqué un filtre rouge.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
def couleurRouge () :             
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = pixel[0]
            v = 0  
            b = 0
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
def Rotation90degresgauche () :   # Florian
    global nombrerotation
    nombrerotation = nombrerotation + 1
    im2 = im1.rotate(nombrerotation*90)     # On utilise la fonction "rotate" qui permet la rotation d'une image
    im2.save(fichierSortie)                 # on stocke l’image résultante
    ActualisationDeImage ()                 # On actualise l'image qui se trouve dans le Canvas

Ce que j'explique est logique puisque nous appliquons toujours les filtres (ou rotations) sur l'image d'origine (im1)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
im1 = Image.open(fichierEntree) # ouverture du fichier image
L = im1.size[0] # L = largeur de l’image, en pixels
H = im1.size[1] # H = hauteur de l'image, en pixels
im2 = Image.new("RGB",(L,H)) # création de l’image destination

Nous avons cherché des solutions pouvant permettre de contourner le problème, mais nous n'avons pas réussi.

[wiztricks]

Le plus gênant est celui de l'image qui ne s'actualise pas lorsqu'un filtre est appliquée et qu'une seconde modification est appliquée par la suite. Le programme réutilise à chaque fois l'image d'origine puisque les fonctions sont codées comme ceci.
Par exemple ici, si j'appuie sur le bouton 'filtre rouge', le filtre s'applique bien mais si ensuite, j'appuie sur la rotation de 90°, la rotation s'appliquera sur l'image d'origine et pas sur l'image a qui nous avons déjà appliqué un filtre rouge.

Si vous écrivez im2 = rotate(im1) puis im2 = Rouge(im1), vous appliquez deux transformations à la même image de départ qui fabriqueront une nouvelle image.
Pour les composer, il faut pouvoir écrire im2 = rotate(Rouge(im1)). i.e appliquer rouge à l'image retournée par rotate.
Comme vos im1 & im2 sont des variables globales, si la nouvelle image (im2) ne remplace pas l'image de départ (im1), impossible de "composer".

- W

[flolievre]

Bonjour,


J'ai essayé plusieurs choses sur la fonction Rotation90degresgauche mais rien n'a fonctionné.

Etant donné que ce sont en effet deux variables globales (im1 et im2), je ne peux pas additionner les filtres ou un filtre et une rotation.
Cependant, en essayant d'ajouter dans la fonction Rotation, le code de la fonction Rouge, c'est à dire tenter deux modifications avec une seule fonction, je n'ai rien obtenu.
Ce que je veux dire c'est que j'ai fait en sorte que la fonction Rotation commence par modifier les pixels de l'image pour que le filtre rouge s'applique, puis juste après d'effectuer une rotation. Cependant, il n'y a que le filtre rouge qui s'applique ..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def Rotation90degresgauche () :   
    global nombrerotation
    nombrerotation = nombrerotation + 1
 
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = pixel[0]
            v = 0  
            b = 0
 
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
            im2.rotate(nombrerotation*90)
            im2.save(fichierSortie)
 
 
 
    #im2 = im1.rotate(nombrerotation*90)     # On utilise la fonction "rotate" qui permet la rotation d'une image
    #im2.save(fichierSortie)                 # on stocke l’image résultante
    ActualisationDeImage ()                 # On actualise l'image qui se trouve dans le Canvas

Désolé, cela fait très brouillon et mal codé mais j'essayais juste d'appliquer deux modifications en une seule fois.

[wiztricks]

J'ai essayé plusieurs choses sur la fonction Rotation90degresgauche mais rien n'a fonctionné.

Ce n'est pas si compliqué d'écrire "im1 = im2" à la sortie de vos fonctions.

- W

[flolievre]

Le "im1 = im2" ne fonctionne pas, probablement parce que les variables im1 et im2 sont globales.

Cependant, j'ai essayé d'effectuer les modifications sur les deux images, et de les stocker totues les deux aussi. Ce qui n'est pas très correct en soi puisque cela modifie les deux images (et donc celle d'origine).
Voici l'exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
def couleurCyan () :                
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = 0
            v = pixel[1]  
            b = pixel[2]
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
            im1.putpixel((x,y),(r,v,b))
 
 
    im1.save(fichierEntree)
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas

[wiztricks]

Salut,

Le "im1 = im2" ne fonctionne pas, probablement parce que les variables im1 et im2 sont globales

Je dirais que im1 étant globale, écrire im1 = im2 dans la fonction sans autre précaution retournera "UnboundLocalError".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
def couleurCyan () :   
    global im1             
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = 0
            v = pixel[1]  
            b = pixel[2]
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
     im2.save(fichierSortie) # on stocke l’image résultante
     im1 = im2
     ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas

nota: j'ai effectué l'assignation avant l'appel à ActualisationDeImage. Car à cause de vos appels inconsidérés à .mainloop dans cette fonction là, car "après" ne sera jamais exécuté.
- W

[flolievre]

Tout à fait, c'est bien l'erreur qui est retournée par Python.

Donc les modifications que j'ai faites précédemment me permettent d'effectuer plusieurs modifications à la suite.
Cependant, lorsque j'effectue ces modifications, elles s'effectuent aussi bien sur le fichier entrée (im1) que sur le fichier de sortie (im2). J'ai donc retirer le im1.save(fichierEntree) donc ce problème est réglé

Pour revenir au curseur qui s'affiche régulièrement en cadre noir, pouvez-vous m'apporter des précisions sur mon erreur lié au code ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
def luminosite(nouvellevaleur):     
    for y in range (H):
        for x in range (L):
            pixel = im1.getpixel((x, y))
 
            R = pixel[0]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Rouge (Valeur comprise entre [0,255])
            V = pixel[1]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Vert (Valeur comprise entre [0,255])
            B = pixel[2]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Bleu (Valeur comprise entre [0,255])
 
            if R < 0: R = 0         # Comme la valeur doit-être comprise entre [0,255], il faut donc suprimer les valeurs inférieurs à 0 et
            if R > 255: R = 255     # supérieurs à 255
 
            if V < 0: V = 0
            if V > 255: V = 255
 
            if B < 0: B = 0
            if B > 255: B = 255
 
            im2.putpixel ((x,y) ,(R,V,B))
            im1.putpixel((x,y),(R,V,B))
 
 
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage ()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#Création d'un widget Luminosité 
Luminosite=Label(fenetre, text=" Luminosite ", font="Comic 10")
Luminosite.place (x=695, y=35)
 
Valeur = StringVar() # On definit Valeur
Valeur.set(0)        # On donne la valeur que prendra le curseur au départ
 
    # Création d'un widget Curseur
echelle = Scale(fenetre,from_=-150,to=250, resolution=25, orient=HORIZONTAL, length=250, width=10, tickinterval=50, variable=Valeur, command=luminosite)
echelle.place(x=780, y=15)

[wiztricks]

Pour revenir au curseur qui s'affiche régulièrement en cadre noir, pouvez-vous m'apporter des précisions sur mon erreur lié au code ?

Comme je ne sais pas reproduire avec les informations que vous donnez, je ne sais pas.

- W

[flolievre]

Voilà à quoi cela ressemble. Le curseur est tout de même fonctionnel (si l'on appuie au bon endroit, la luminosité augmente ou diminue).
Étonnement, il arrive qu'il s'affiche, cependant, c'est totalement aléatoire.

[wiztricks]

Salut,

Voilà à quoi cela ressemble. Le curseur est tout de même fonctionnel (si l'on appuie au bon endroit, la luminosité augmente ou diminue).

En programmant comme vous pouvez, vous créez des problèmes qui souvent n'existent pas (pour le programmeur normal).
Sans reproduire, pas facile de savoir dans quel guêpier vous vous êtes fourré.

- W

[marco056]

Si vous voulez réellement de l'aide, postez le programme en entier (éventuellement en ne laissant qu'une des fonctions proposées) afin qu'il puisse tourner chez soi sans y passer des heures.

[flolievre]

Voici une partie du code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
# -*- coding: cp1252 -*-
 
##### Import #####
import Tkinter
from Tkinter import*            # Ce module permet la creation d'une fenetre graphique
import tkFileDialog as Selector # Module permettant de selectionner l'image que l'on veut
import  Tkinter as Tk           # On importe le module Tk () pour la creation d'une fenetre Widget
import webbrowser               # webbrowser permet l'ouverture de l'image avec la visionneuse de photos Windows
import PIL
import Image, ImageTk
from tkMessageBox import *      # Permet l'ouverture de boîtes de dialogue standard pour l’affichage de messages
 
##### Fonctions #####
 
def ActualisationDeImage () :
    Fond.destroy()                              # On detruit l'ancienne image
 
    NouvelleImage = Image.open(fichierSortie)   # Le paramètre image représente l'image que l'on veux insérer
 
    NouvellePhoto = ImageTk.PhotoImage(NouvelleImage)   # Avec la fonction ImageTk.PhotoImage (), on peut créer une image compatible Tkinter,
                                                        # qu'on pourra afficher dans un Canvas par la méthode create_image(position, **options)
                                                        # où position réprésente les 2 coordonnées du coin en haut à gauche de l'image,
                                                        # sachant que l'image sera aussi positionnée par rapport au paramètre anchor
                                                        # qui par défaut vaut CENTER. 
 
    NouveauFond = Tk.Canvas(fenetre, width = NouvelleImage.size[0], height = NouvelleImage.size[1])
 
                                                        # Le Canvas ne s'adapte pas par défaut à la place que prennent 
                                                        # les éléments que l'on à dessiner dedans. Donc si l'image que 
                                                        # l'on veux insére est trop grande, on peut être assuré qu'elle sera
                                                        # entièrement visible en renseignant les paramètres width et height à la création du Canvas.
 
    NouveauFond.create_image(0, 0, anchor = Tk.NW, image=NouvellePhoto)  # Pour que l'image soit positionnée en haut à gauche du Canvas,
                                                                         # on doit utiliser la position 0, 0 et rajouter le paramètre anchor = Tk.NW
    NouveauFond.place (x=2, y=2) # On place le Nouveau Fond
    NouveauFond.mainloop()       # On ouvre la Nouvelle Image 
 
 
 
def NouvelleImage () :       
    webbrowser.open(fichierSortie)
 
 
def ImageDeDepart () :       
    webbrowser.open(fichierEntree)
 
 
def MessageAide () :
    showinfo(' AIDE ' , "Les boutons couleurs permettent de changer la couleur de l'image. Les boutons filtres appliquent des filtres sur la photo. \
Par exemple, le bouton niveau de gis, change l'image en niveau de gris. Le bouton posterise permet de transformer l'image en une peinture. \
Le seuillage permet de reduire les couleurs de l'image en seulement deux couleurs, le noir et le blanc. Le négatif, permet d'inverser \
les couleurs de l'image. Ensuite, les boutons de redimenssionnement permettent de redimanssionner l'image. Les boutons de deplacement de l'image \
font tourner l'image sur elle-même et dans différentes positions (90 - 180 - 270 degrés).")
 
 
 
def couleurCyan () :                # Martin  
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = 0
            v = pixel[1]  
            b = pixel[2]
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
            im1.putpixel((x,y),(r,v,b))
 
 
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas
 
 
 
def couleurRouge () :             # Martin  
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = pixel[0]
            v = 0  
            b = 0
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
            im1.putpixel((x,y),(r,v,b))
 
 
 
    im2.save(fichierSortie) # on stocke l’image résultante    
    ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas
 
 
 
def couleurBleu () :                  
    for y in range(H): # on balaie toutes les lignes de l’image source, de 0 à H-1
        for x in range(L): # pour chaque ligne on balaie toutes les colonnes, de 0 à L-1
            pixel = im1.getpixel((x,y)) # en stockant le pixel (x,y) dans une liste p à tois éléments
                                # p[0] est la composante rouge, p[1] la composante verte, et p[2] la composante bleue
            r = 0
            v = 0  
            b = pixel[2]
            im2.putpixel((x,y),(r,v,b)) # on écrit le pixel modifié sur l’image destination
            im1.putpixel((x,y),(r,v,b))
 
 
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage () # On actualise l'image qui se trouve dans le Canvas
 
 
 
def luminosite(nouvellevaleur):      
    for y in range (H):
        for x in range (L):
            pixel = im1.getpixel((x, y))
 
            R = pixel[0]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Rouge (Valeur comprise entre [0,255])
            V = pixel[1]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Vert (Valeur comprise entre [0,255])
            B = pixel[2]+ int(nouvellevaleur)   # On augmente de int(nouvellevaleur) la valeur des pixels Bleu (Valeur comprise entre [0,255])
 
            if R < 0: R = 0         # Comme la valeur doit-être comprise entre [0,255], il faut donc suprimer les valeurs inférieurs à 0 et
            if R > 255: R = 255     # supérieurs à 255
 
            if V < 0: V = 0
            if V > 255: V = 255
 
            if B < 0: B = 0
            if B > 255: B = 255
 
            im2.putpixel ((x,y) ,(R,V,B))
            im1.putpixel((x,y),(R,V,B))
 
 
 
    im2.save(fichierSortie) # on stocke l’image résultante
    ActualisationDeImage ()
 
 
 
 
def ModifDimensions () :  
 
    Hauteur = eval(Champ1.get())                        #On récupère la valeur de la hauteur saisie par l'utilisateur
    Largeur = eval(Champ2.get())                        #on récupère la valeur de la largeur saisie par l'utilisateur
 
    im2 = im1.resize((Hauteur,Largeur), Image.NEAREST)  # Fonction mathématiques qui permet de récuperer les valeurs données par l'utilisateur
    im2.save(fichierSortie)
    ActualisationDeImage ()                             # On actualise l'image qui se trouve dans le Canvas
 
 
def Rotation90degresgauche () :   
    global nombrerotation
    nombrerotation = nombrerotation + 1
    im2 = im1.rotate(nombrerotation*90)     # On utilise la fonction "rotate" qui permet la rotation d'une image
    im2.save(fichierSortie)                 # on stocke l’image résultante
    ActualisationDeImage ()                 # On actualise l'image qui se trouve dans le Canvas
 
 
def Rotation90degresdroite () :  
    global nombrerotation
    nombrerotation = nombrerotation + 1
    im2 = im1.rotate(nombrerotation*(-90))  # On utilise la fonction "rotate" qui permet la rotation d'une image
    im2.save(fichierSortie)                 # on stocke l’image résultante
    ActualisationDeImage ()                 # On actualise l'image qui se trouve dans le Canvas
 
 
 
#####Création de la Fenêtre #####
 
#Titre de la fenetre
fenetre = Tk.Tk()       # On met Tk.Tk(), car Tk() est deja utilisé plus bas
fenetre.title ("Retouche photo")
 
# Les images qui vont être utilisées doivent-être définies
fichierEntree = Selector.askopenfilename(filetypes=[('all files','.*'), ('png files','.png')])   # Image d'entrée, qui est a selectionner.
 
fichierSortie = Selector.asksaveasfilename(title=" POUR SAUVEGARDER, IL FAUT METTRE L'EXTENSION DE L'IMAGE: .PNG, .JPEG, .GIF, ...")
# Image crée après la sauvegarde. On doit donner le nom et l'endroit où l'image sera sauvegardée.
 
 
 
# Création d'un widget Canvas (zone graphique)
Canvas = Canvas(fenetre, width = 1050, height =600, bg ="gray")
Canvas.pack()
 
image = Image.open(fichierEntree)   # Le paramètre image représente l'image que l'on veux insérer
 
photo = ImageTk.PhotoImage(image)   # Avec la fonction ImageTk.PhotoImage (), on peut créer une image compatible Tkinter,
                                    # qu'on pourra afficher dans un Canvas par la méthode create_image(position, **options)
                                    # où position réprésente les 2 coordonnées du coin en haut à gauche de l'image,
                                    # sachant que l'image sera aussi positionnée par rapport au paramètre anchor qui par défaut vaut CENTER. 
 
Fond = Tk.Canvas(fenetre, width = image.size[0], height = image.size[1]) # Le Canvas ne s'adapte pas par défaut à la place que prennent 
                                                                         # les éléments que l'on à dessiner dedans. Donc si l'image que 
                                                                         # l'on veux insére est trop grande, on peut être assuré qu'elle sera
                                                                         # entièrement visible en renseignant les paramètres width et height
                                                                         # à la création du Canvas.
 
 
Fond.create_image(0, 0, anchor = Tk.NW, image=photo)    # Pour que l'image soit positionnée en haut à gauche du Canvas,
                                                        #on doit utiliser la position 0, 0 et rajouter le paramètre anchor = Tk.NW
Fond.place (x=2, y=2)
 
 
 
# On definit la Largeur et la Longueur de l'image ainsi que la creation de l'image d'entrée et de sortie
# Ces valeurs seront utiles pour chaque fonction qui sera appliquée sur l'image par la suite
 
im1 = Image.open(fichierEntree) # ouverture du fichier image
L = im1.size[0] # L = largeur de l’image, en pixels
H = im1.size[1] # H = hauteur de l'image, en pixels
im2 = Image.new("RGB",(L,H)) # création de l’image destination
# « vide » pour l’instant
 
 
###### Boutons ######
 
#Création d'un widget Luminosité 
Luminosite=Label(fenetre, text=" Luminosite ", font="Comic 10")
Luminosite.place (x=695, y=35)
 
Valeur = StringVar() # On definit Valeur
Valeur.set(0)        # On donne la valeur que prendra le curseur au départ
 
    # Création d'un widget Curseur
echelle = Scale(fenetre,from_=-150,to=250, resolution=25, orient=HORIZONTAL, length=250, width=10, tickinterval=50, variable=Valeur, command=luminosite)
echelle.place(x=780, y=15)
 
 
 
# Création d'un widget Couleurs 
Couleurs=Label(fenetre, text=" Couleurs", font="Comic 10")
Couleurs.place (x=695, y=103)
 
    # Création d'un widget Button Couleur Cyan 
BoutonCouleurCyan = Button(fenetre, text ='Cyan', command = couleurCyan, fg='black', bg='cyan', font="Comic 10")
BoutonCouleurCyan.place(x=764, y=100)
 
    # Création d'un widget Button Couleur Rouge 
BoutonCouleurRouge = Button(fenetre, text ='Rouge', command = couleurRouge, fg='black', bg='red', font="Comic 10")
BoutonCouleurRouge.place(x=906, y=100)
 
    # Création d'un widget Button Couleur Bleu 
BoutonCouleurBleu = Button(fenetre, text ='Bleu', command = couleurBleu, fg='white', bg='blue', font="Comic 10")
BoutonCouleurBleu.place(x=1011, y=100)
 
 
 
# Création d'un widget Rotation     
Rotation45degres=Label(fenetre, text=" Rotation ", font="Comic 10")
Rotation45degres.place (x=695, y=250)
 
    # Pour la fonction rotation de l'image, il faut definir la valeur que prend le Nombre de Rotation
nombrerotation = 0 
 
    #Création d'un widget Button Rotation 90° vers la droite  
photorotationdroite = PhotoImage(file='rotationdroite.gif')
BoutonRotation90degresdroite = Button(fenetre, image=photorotationdroite, command = Rotation90degresdroite)
BoutonRotation90degresdroite.place(x=910, y=250)
 
    #Création d'un widget Button Rotation 90° vers la gauche 
photorotationgauche = PhotoImage(file='rotationgauche.gif')
BoutonRotation90degresgauche = Button(fenetre, image=photorotationgauche , command = Rotation90degresgauche)
BoutonRotation90degresgauche.place(x=830, y=250)
 
 
 
#Création d'un widget Modification des Dimensions   
ModifDimension=Label(fenetre,text=" Dimensions ", font="Comic 10")
ModifDimension.place(x=695, y=340)
 
    #Création d'un label Hauteur en pixels  
hauteurpix = Label(fenetre,text="Hauteur en pixels", font="Comic 9")
hauteurpix.place(x=795, y=340)
 
    #Création d'un label Largeur en pixels   
largeurpix=Label(fenetre,text="Largeur en pixels", font="Comic 9")
largeurpix.place(x=795, y=380)
 
    # Création d'un widget Entry (champ de saisie hauteur de l'image)
Hauteur = IntVar()
Champ1 = Entry(fenetre, textvariable= Hauteur)
Champ1.focus_set()
Champ1.place(x=925, y=340)
 
    # Création d'un widget Entry (champ de saisie largeur de l'image)
Largeur = IntVar()
Champ2 = Entry(fenetre, textvariable= Largeur)
Champ2.focus_set()
Champ2.place(x=925, y=380)
 
    # Création d'un widget Button (bouton Valider)
BoutonValider = Button(fenetre, text ='Valider', command = ModifDimensions, font="Comic 9")
BoutonValider.place(x=925, y=420)
 
 
 
# Création d'un widget Button pour afficher un message d'aide
ButtonMessageAide = Button(fenetre, text = "?", command = MessageAide, font="Comic 14", bg = "blue", fg = "white")
ButtonMessageAide.place(x=1022, y=563)
 
 
# Création d'un widget Button pour afficher l'image de depart
ButtonImageDeDepart = Button(fenetre, text = "Afficher l'image de depart", command = ImageDeDepart, font="Comic 10")
ButtonImageDeDepart.place(x=692, y=540)
 
 
# Création d'un widget Button pour afficher la nouvelle image
BoutonNouvelleImage = Button(fenetre, text ='Afficher la nouvelle image', command=NouvelleImage, font="Comic 10")
BoutonNouvelleImage.place(x=857, y=540)
 
 
# Création d'un widget Button (bouton Quitter)
BoutonQuitter = Button(fenetre, text =' Quitter ', command = fenetre.destroy, font="Comic 9")
BoutonQuitter.place(x=695, y=480)
 
 
fenetre.mainloop()  # Permet l'ouverture de la fenetre

Et voici une des images que nous utilisons :