Discussion :

[tris33]

Bonjour à tous;

Je suis en première année de fac informatique, et pour ce deuxième semestre un projet de programmation en Python nous a été donné.
Il consiste en la réalisation d'un petit programme de traitement d'image avec Tkinter, avec différents outils tels que la symétrie droite/gauche, ajout de bandes noires sur l'images, effet négatif ... et d'autres.

Mon projet est à rendre pour demain, et je suis bloqué, vraiment bloqué, au début. Autrement dit il nous faut pour traiter l'image, la passer sous un tableau2D... ce que je n'arrive pas du tout à faire malgré les différents fichiers disponibles pour nous aider.
La semaine prochaine sont mes partiels, je suis à fond dans mes révisions et ai du mal à me plonger dans la prog.
Je sais que ce qu'on nous demande n'est pas très compliqué, mais j'avoue n'avoir pas vraiment suivis les différents TD concernant le projet et ai vite été largué.
Je ne pourrai pas faire de miracles pour demain, mais si quelqu'un, habile en Python, pouvait me donner un petit coup de pouce magique afin d'avancer un peu mon projet, je lui en serai très reconnaissant.
Je rappelle que je sais très bien que le forum n'est pas là pour pondre le travail de untel ou untel, je n'ai pas l'habitude de demander tant d'aide, mais je me sens dans la merde et ... voilà. :s

J'ai pour l'instant créé mon canevas, mon petit menu, ma fonction pour ouvrir une image et adapter le canevas, je bloque sur la fonction pour enregistrer l'image, et surtout pour passer cette image sous un tableau2D afin de la traiter.

Pour ça je vous donne ce que j'ai fait pour le moment, et vous transmet les fichiers fournis (type énoncés, modules...) par les enseignants.

[Ici notre support de travail, contenant des "cours", énoncés, et autres fichiers] = http://dept-info.labri.fr/ENSEIGNEME...1/support.html

Dans mon programme, je dispose d'un :

main.py

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
from Tkinter import *
from interface import *
from pgm import *
 
#On cree une fenetre
fen = Tk()
 
#image initialisee, on cree un caneva
zone_image = {'cadre':None,'image':None}
zone_image['cadre'] = Canvas(fen, height= 300, width = 300, background='black')
zone_image['cadre'].bind("<Button-1>", pointeur)
zone_image['cadre'].pack()
 
#On cree le menu et l'ajoute
mon_menu = Menu(fen)
fen.config(menu=mon_menu)
 
menu_fichier = Menu(mon_menu)
mon_menu.add_cascade(label="Fichier", menu=menu_fichier)
menu_fichier.add_command(label="Ouvrir...", command=lambda: ouvrireimage(zone_image))
menu_fichier.add_command(label="Sauver sous...", command=lambda:sauverimage())
menu_fichier.add_command(label="Quitter", command=lambda:fen.destroy())
 
menu_traitement = Menu(mon_menu)
mon_menu.add_cascade(label="Traitement d'image", menu=menu_traitement)
menu_traitement.add_command(label="Symetrie droite/gauche", command=lambda:symetriedg())
 
fen.mainloop()

interface.py (qui contient les callback)

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
 
from Tkinter import *
import tkFileDialog
from interface import *
from pgm import *
from traitement import *
 
 
def ouvrireimage(zone_image):
    global image
    global nom_image
    zone_image['cadre'].delete(ALL)
    nom_image = tkFileDialog.askopenfilename()
    if nom_image != ():
        afficherimage(zone_image)
 
 
def afficherimage(zone_image):
    zone_image['image'] = PhotoImage(file=nom_image)
    zone_image['cadre'].create_image(0, 0, anchor=NW, image = zone_image['image'])
    zone_image['cadre'].configure(height = zone_image['image'].height(), width = zone_image['image'].width())
 
 
def pointeur (event):
    x,y = event.x,event.y 
    print x,y
 
def sauverimage():
    nom_image = asksaveasfilename()
    print(nom_fichier)

traitement.py (qui contient les fonctions de traitement d'image)

Code :

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

Je n'ai donc pour l'instant rien dedans

J'ai aussi un fichier :

tableau2D.py (que je n'arrive pas à utiliser)

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
# -*- coding:utf-8 -*-
 
# création d'un vecteur taille l initialisé à val
def creer_tableau_1D(l, val):
    t = [val]*l  
    return t
 
# création d'une matrice [h,l] initialisée à val
# le premier indice correspond à la hauteur
def creer_tableau (h, l, val):
    t = creer_tableau_1D(h, None) 
    for i in range(0, h):
        t[i] = creer_tableau_1D(l, val)
    return t
 
# affichage sommaire
def afficher_tableau(t):
    print()
    for i in range(len(t)):
        print(t[i])
 
 
#tests
if __name__ == "__main__":
    m = creer_tableau(10, 5, 0)
    afficher_tableau(m)
 
# parcours ligne par ligne
#     cpt = 0
#     h = len(m)
#     l = len(m[0])
#     for i in range(h):
#         for j in range(l):
#             m[i][j] = cpt
#         cpt += 1
 
# parcours colonne par colonne
    cpt = 0
    h = len(m)
    l = len(m[0])
    for j in range(l):
        for i in range(h):
            m[i][j] = cpt
        cpt += 1
 
    afficher_tableau(m)

et pgm.py

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
# -*- coding:utf-8 -*-
 
from tableaux2D import *
from string import *
 
# lecture/ecriture de fichier pgm binaire
 
def creer_fichier(l,h,nom,type):
    file = open(nom,'w')
    file.write(type + '\n')
    file.write(str(l) + ' ' + str(h) + '\n')
    file.write('255 \n')
    return file
 
def creer_image_pgm_binaire(t, nom):
    h = len(t)
    l = len(t[0])
    file =creer_fichier(l,h,nom,'P5')
    for i in range(h):
        for j in range(l):
            file.write('%c'%t[i][j]) #transforme un entier entre 0 et 255 en octet
    file.close()
 
 
def lire_fichier_pgm_binaire (nom):
    f = open (nom)
 
  #lecture du "magic number" P5
    mode = f.readline()
 
  #lecture des dimensions (il faut sauter les éventuelles lignes de commentaire)
    dim = f.readline()
    while dim[0] == '#':
        dim = f.readline()
    t_dim = split(dim)
    largeur = int(t_dim[0])
    hauteur = int(t_dim[1])
 
  # création du tableau image
    t_image = creer_tableau(hauteur, largeur, 0)
 
  # lecture de la valeur maximale d'un niveau de gris (255)
    val_max = f.readline()
 
    for i in range(hauteur):
        for j in range(largeur):
            t_image[i][j] = ord(f.read(1)) # transforme un octet en entier
 
    f.close()
    return t_image

Voilà tout, en vous remerciant d'avance.
Matema

[afranck64]

Salut,
ça tente bien (mais j'aime prendre du temps pour ce que je fait alors...) bref j'aimerai savoir de ou 3 choses:
- Les images que tu traites sont elles destinées à etre utilisées dans d'autres logiciels de traitements d'image ou est-ce juste un format personnalisé que tu utilises pour tes images? (Vu que tu as un module <tableau2D> çà m'en a tout l'air)

- Si non, Tu peux te servir d'une librairie graphique déjà disponible la <Python Imaging Library (PIL)> par exemple.

- Pour sauver ton image, je te propose la méthode suivante:

Tu fait les traitements à la fois à l'écran et sur une copie de l'image en mémoire à chaque évènement utilisateur (Dans le cas d'une Image <PIL> il te suffira de faire un "mon_image.save(nom_fichier_avec_extension_voulue").

- Pour le chargement d'image, la lib PIL dispose du module <ImageTk> destinée à créer des images affichables par <Tkinter> alors/

- Tu charges ton image en mémoire: img = Image.open(mon_fichier)
- Tu la convertie en "ImageTk": imgtk = ImageTk.PhotoImage(image = img,master=mon_canvas)"
- Et puis tu la charges dans le Canvas.

Pour le reste c'est de jouer du curseur et des évents. Bon il faudrait déjà ça te convienne d'utiliser une lib.

@+