Traitement d'image avec Python sans modules

Version imprimable

21/11/2010, 22h43
kevgen

Traitement d'image avec Python sans modules

Bien le bonjour,

J'ai là un projet à réaliser, mais sans utiliser un seul module prédéfinis, donc pas question d'utiliser de PIL.Image, de rotate() etc ...

Je dois donc ouvrir mon image comme un fichier texte, cette image est au format PPM en variante brute (ASCII) et doit être affichée sous forme de matrice

Je dois par exemple obtenir

P3
4 2
29
0 0 0 1 2 3 2 2 2 3 6 4
4 4 4 10 10 10 20 29 20 20 20 20

voulant dire :
– Identificateur du fichier ; dans le cas de PPM brute, on a toujours P3 ;
– Nombre de colonnes de l’image ;
– Nombre de lignes de l’image ;
– Valeur maximale dans les matrices des intensités.

Ensuite, je dois pouvoir appliquer rotation de 90° vers la gauche, vers la droite, symetrie horizontale et symetrie verticale, et sauvegarder l'image modifiée dans un nouveau fichier ppm

Je suis débutant en programmation, et je ne sais pas dutout comment m'y prendre, si on pouvait me mettre sur la piste ça serait super cool :)
22/11/2010, 09h52
josmiley

Citation:

Envoyé par kevgen

Je suis débutant en programmation, et je ne sais pas dutout comment m'y prendre, si on pouvait me mettre sur la piste ça serait super cool :)

commence par apprendre les bases de python.
voilà pour les fonctions de base...
http://docs.python.org/library/funct...t-in-functions

Bonjour,
Ce n'est pas très compliqué, mais il y a quand même des listes de listes, il ne faut pas se mélanger les crayons. Je vous ai fait un bout de test qui télécharge et enregistre un fichier cat.ppm, puis fabrique cat2.ppm (symétrie verticale) et cat3.ppm (symétrie horizontale). C'est un peu plus complexe que votre exemple puisque les pixels font 3 octets qu'il ne faut pas mélanger sous peine de ne pas avoir les bonnes couleurs.
Si c'est totalement confus pour vous, suivez le conseil de josmiley, puisque c'est du code assez basique. Pour quelques points précis, vous pouvez demander des explications.

Code:

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
import urllib
 
filename = 'cat.ppm'
url = 'http://igm.univ-mlv.fr/~incerti/IMAGES/COLOR/CatLogo.128.ppm'
print u'Télécharge %s sur %s' % (filename, url)
urllib.urlretrieve(url, filename)
print u'Voilà, %s écrit...\n' % filename
 
#3 lignes d'information 
lines = open(filename, 'r').readlines()[:3]
for line in lines:
    print line,
 
#longueur du prologue
prologlen =  len(''.join(lines))
 
#extraction nombre de lignes et nombre de colonnes
ncols, nlines = map(int, lines[1].split())
 
#ouverture puis lecture en mode binaire
buff = open(filename, 'rb').read()
 
#Je ne connais pas le format ppm, ça marche avec CE fichier
prolog  = buff[:prologlen]
imgbuff = buff[prologlen:]
 
#calcul de la taille du pixel
pixsize  = len(imgbuff) / (nlines * ncols)
#et donc de la ligne (en pixels)
linesize = ncols
 
#image -> liste de pixels (triplets)
pixels = [imgbuff[i:i+pixsize] for i in range(0, len(imgbuff), pixsize)]
#image (liste de pixels) -> lignes (liste de listes de pixels)
lignes = [pixels[i:i+linesize] for i in range(0, len(pixels), linesize)]
 
#fonction d'affichage du pixel (decimal ou hexa)
def formatPixel(pixel, base=10):
    if len(pixel) == 3:
        fs = (base == 10 and '[%3u %3u %3u]') or (base == 16 and '[%2x %2x %2x]')
        return fs % (ord(pixel[0]), ord(pixel[1]), ord(pixel[2])) 
 
#affichage sous forme de matrice (juste les 10 premières colonnes)
for ligne in lignes:
    for pixel in ligne[:10]:
        print formatPixel(pixel, 16),
    print 
 
#inverser la liste "en place" (symétrie horizontale)
lignes.reverse()
#refabriquer imgbuff à partir de la liste inversée
imgbuff = ''.join([''.join(_) for _ in lignes])
 
f = open('cat2.ppm', 'wb')
f.write(prolog + imgbuff)
print u'\ncat2.ppm écrit'
 
#on inverse à nouveau, retour à l'image d'origine
lignes.reverse()
 
#on inverse chaque ligne (symétrie verticale)
#et on refabrique imgbuff à partir de la liste inversée
imgbuff = ''.join([''.join(ligne[::-1]) for ligne in lignes])
 
f = open('cat3.ppm', 'wb')
f.write(prolog + imgbuff)
print u'cat3.ppm écrit'

22/11/2010, 17h26
kevgen

Merci pour la réponse, je vai aller décortiquer tout ça

Si quelqu'un est motivé, il y a moyen d'implémenter les transformations de la matrice sans réellement toucher aux données de celle-ci en mémoire, mais en réinterprétant la façon dont elles sont stockées en mémoire.

On pourrait ne modifier que ces variables:
1) le nombre de colonnes et de lignes (w, h)
2) les indices du coin supérieur gauche de la matrice (x0,y0)
3) l'incrément à appliquer aux indices pour passer à la colonne suivante (dcx, dcy)
4) l'incrément à appliquer aux indices pour passer à la ligne suivante (dlx, dly)

Initialement, on aurait:
Code:

1 2 3 x0, y0 = 0,0 dcx, dcy = 0,1 # pour passer à la colonne suivante, on incrémente le 2nd indice dlx, dly = 1,0 # pour passer à la ligne suivante, on incrémente le 1er indice
Une symétrie verticale, par exemple, consisterait en les opérations suivantes:
Code:

1 2 3 4 # on passe à la dernière ligne x0, y0 = x0 - dlx, y0 - dly # en exploitant les indices négatifs en Python # ou bien: x0, y0 = x0 + (h-1) * dlx, y0 + (h-1) * dly dlx, dly = -dlx, -dly # on inverse le sens de parcours des lignes
On utilisera ces variables à la fin, au moment d'écrire le résultat, pour parcourir la matrice (qui elle n'a jamais bougé) dans le bon ordre.
L'intérêt de la chose est que chaque transformation est O(1) au lieu d'être O(w*h), aux prix d'un léger surcoût lors du parcours final.