[Python] Fonction de moyennage en niveaux de gris

[Samuel9-14]

Bonjour à tous,
je cherche à écrire une fonction qui prend en argument une image en niveau de gris et qui donne une image "floutée", c'est-à-dire qu'elle moyenne chaque pixel avec sa matrice de pixels de voisins (25 pixels en tout moyennés). Le problème c'est que quand je reconstruis l'image à partir de l'limage moyennée, je n'ai qu'une image toute noire.
Quelqu'un a une idée ?

Pour info, l'image d'origine est une image en niveau de gris seuillée. C'est une matrice composée plus ou moins aléatoirement de 0 et de 255.

s=0
def Moyennage(img):
    img_moyennee = np.ones((len(img[:,1]),len(img[:,2])),int)
    for x in range(len(img[1,:])):
        for y in range(len(img[:,1])):
            if x-2>=0 and y-2>=0 and x+2<=len(img[1,:])-2 and y+2<=len(img[:,1])-2:
                global s
                s=0
                for x2 in range(x-2,x+2):
                    for y2 in range(y-2,y+2):
                        s+=img[x2,y2]
            img_moyennee[x,y]=s/25
            print(img_moyennee)

            return img_moyennee

Merci d'avance.
-----

[CM63]

Il faut faire l'opération avec des flottants et prendre la partie entière du résultat, parce que là, par exemple 24/25 ça fait 0.

[Samuel9-14]

Ha oui en effet !
Si je déclare s en flottant c'est suffisant j'imagine ? (c'est-à-dire que Python va interpréter ma somme d'entiers comme un flottant ?).

Mais d'un autre côté le cas de figure "24/25" ne peut pas se présenter puisque mes pixels ont pour valeur 0 ou de 255. Donc les valeurs possibles pour s sont dans l'ensemble suivant {0,255,510,1020,...,255*25} et dans ces cas là s ne prend jamais la valeur 0.

[Jack]

prendre la partie entière du résultat, parce que là, par exemple 24/25 ça fait 0.

Du coup, ça revient au même, le résultat va être 0

[A voir en vidéo sur Futura]

[Samuel9-14]

En fait le problème a l'air d'être algorithmique puisque mon programme tourne sans erreur mais ma matrice d'origine (composée de 1) reste inchangée, à aprt le premier terme qui se met à 0...

[CM63]

Du coup, ça revient au même, le résultat va être 0

Evidemment, mais c'était un exemple, si le calcul est plus compliqué, ça revient pas au même.

[CM63]

Si je comprends bien tu veux obtenir des niveaux de gris à partir de pixels d'origine qui ne sont que 1 ou 0, dans ce cas il vaut quelque par multiplier par 256, par exemple pour que le résultat varie entre 0 et 255 plutôt qu'entre 0 et 1. Et attention à faire les divisions en dernier de façon à ce que la partie entière ne soit prise qu'à la fin.

[Samuel9-14]

Oui et non, ma matrice d'origine, celle que j'appelle 'img' dans ma fonction, est déjà une matrice de 0 et 255 (et non de 0 et de 1). Et ma fonction est censée renvoyer une matrice de valeurs comprises entre 0 et 255 (valeurs discrètes soit dit en passant, elles prennent leur valeur dans l'ensemble {0, 255/25, 510/25, 1020/25,...255} ). Donc une matrice qui, elle, est en niveaux de gris. En fait je cherche juste à "flouter" mon image d'origine.


Une fois floutée je seuille encore l'image avec un seuil bien choisi. Le but est de débruiter une image enregistrée dans des conditions d'exposition un peu particulières.

[CM63]

Bon ben le plus simple est de travailler avec des flottants, en gros ça va faire comme des rationnels, car les nombres sont faibles.
Par exemple tu travaille avec des nombres flottants entre 0.0 et 1.0, et en dernier tu multiplies par 256.

[Samuel9-14]

Je ne vois pas ce que ça va changer en fait. J'ai essayé en prenant s comme nombre flottant, mais ça ne change rien à mon problème.

[CM63]

Ben en fait j'ai la flemme de regarder le détail de ton ton code, mais c'est la bonne solution de travailler avec des flottants: ça évite les arrondis.

[CM63]

Si je regarde le détail de ton code, je ne comprends pas tout, quel est le rôle de np.ones() par exemple?

[Samuel9-14]

np.ones sert juste à construire la matrice constituant la nouvelle image. C'est une pré-allocation.

[CM63]

Ok, je regarde la suite, mais comme je n'ai pas Python sur mon portable, ça ne va pas être simple. Je ne sais plus comment on fait pour convertir un entier en flottant, je regarde sur le web.

[Samuel9-14]

Merci !
Je crois que rajouter un "." après l'entier fait la conversion en flottant.

[Jack]

Je ne connais pas assez python pour aider, mais je ne vois pas en quoi passer en flottant va améliorer les choses.

[CM63]

J'ai l'impression que l'instruction :

img_moyennee = np.ones((len(img[:,1]),len(img[:,2])),int)

ne sert à rien, puisque par la suite img_moyennee est à nouveau à gauche du signe égal.

Et sinon, si tu mets:

img_moyennee[x,y]=int(s/25.0)

En mettant bien le 0. à la fin du 25, est-ce que c'est mieux?

[Samuel9-14]

Dans la suite je fais juste appel aux éléments de img_moyennee pour leur attribuer une valeur, mais jamais au tableau entier.

Ca ne change rien non.

Mais en fait en mettant des print un peu partout je me rends compte que mon programme s'arrête après la première itération, alors qu'il devrait en faire... plus d'un million. Et je ne vois vraiment pas où ça coince.

[CM63]

Mais Jack a raison, ce n'est pas une histoire de flottants, on ajoute 25 nombres entiers compris entre 0 et 255, et ensuite on divise par 25, on devrait bien obtenir, même en mode entier, un nombre entre 0 et 255.
Il faut plutôt voir ce qu'il y a dans le tableau au départ, est-il rempli correctement?
Et peut-être aussi si tes boucles sont bien écrites, en mettant des prints sur un cas simple (avec beaucoup moins de valeurs).

[Samuel9-14]

J'ai fait ça et j'avais probablement un problème avec ma condition "if", du coup je l'ai supprimée. Elle servait à gérer les effets de bord mais je peux le faire "à la main" dans les conditions de la boucle for.
Le programme a l'air de tourner correctement mais je reviens à un problème que j'avais au début, à savoir un problème "d'index out of range". Bon, ça je devrais pouvoir le régler tout seul.

[Jack]

Ton out of range me fait penser à une mauvaise gestion des index d'un tableau. Si img est un tableau, j'ai l'impression que tu fais commencer le rang du 1er élément à 1 au lieu de 0

[Samuel9-14]

Ha non en fait c'était ma pré-allocation qui était faite un peu n'importe comment, j'avais un tableau de 800*800 au lieu de 800*1280. Bon, une nouvelle erreur ne devrait pas tarder à apparaître mais pour le moment c'est bon, je laisse tourner le programme.

[CM63]

Un détail : il ne faut pas toujours diviser par 25: aux bords de l'image, tu ajoutes moins de 25 valeurs, en fait il faudrait les compter, mettre avant la boucle:

s2=0

Dans la boucle:

s2+=1

Après la boucle:

img_moyennee[x,y]=s/s2

[Samuel9-14]

En fait dans mon problème les effets de bord sont clairement négligeables, donc je ne m'embête pas et je les mets systématiquement à 0.

Finalement mon programme a l'air de bien fonctionner, je récupère une image bien débruitée et à peu près fidèle à ce à quoi je m'attendais.
Merci pour les coups de pouce !

[CM63]

Pour une fois, l'expression "effets de bords" est employée dans le bon sens