Discussion :

[Black Templar]

Bonjour à tous !

J'aimerais me lancer dans la programmation d'algorithme de traitement d'image.
Mais voila, après avoir trouvé plusieurs petits algorithme, j'ai vite remarqué que je ne pouvais pas tout réinventé (trop dur :p) J'ai donc parcouru internet pour trouvé des algos.

Je me rend compte qu'on utilise beaucoup le calcul matriciel dans ce domaine.
Là dessus, j'ai plusieurs question.

Quand on veut appliquer une matrice carré de côté '2*n+1', on l'applique à quoi ?? à une matrice de côté '2*n+1' centré sur un pixel (X,Y) contenant les niveaux de gris des pixels autours de (X,Y) (donc n pixels au dessus, n en dessous, n a gauche et n a droite) ? et on fait ça pour tout les pixels de l'image ?

Y-a-t-il des tutos qui introduise le calcul matriciel en traitement d'image (avec des exemples de préférences) ? Parce que là, j'ai ma matrice, mais je ne sais pas à quoi l'appliquer ^^ Tout ce que j'ai trouvé sur internet sous entend que je sais déjà comment je vais appliquer mon filtre.

Petit exemple :
image (1 = blanc et 0 = noir pour simplifier):

Code :

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

1
2
3
4
5
0 0 0 0 0
0 0 0 1 0
0 1 1 1 0
0 1 0 0 0
0 0 0 0 0

matrice:

Code :

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

1
2
3
-1 -1 -1
 0  0  0
 1  1  1

pour le pixel (1, 1) (le (0,0) est en haut à gauche) ça me donnerais

Code :

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

1
2
3
-1 -1 -1      0 0 0      0 -1 -1
 0  0  0  *   0 0 0  =   0  0  0
 1  1  1      1 1 1      0  1  1

Et cette matrice, on en fait quoi pour la retransformer en pixel ???



Je sais, je galère ...

[ToTo13]

Bonjour,

on parle de matrice, mais on peut aussi parler de tableau à deux dimensions. Ce n'est pas du calcul matriciel à proprement parlé.

Cette question a déjà été largement débattue sur le forum. Fais donc une recherche dans ce forum avec le mot clef "convolution".

Pour le cours, il y a celui de Millie qui traite de la convolution d'une image.

Lis donc tous ceci et dis nous ce que tu ne comprends pas, on éclaircira les points obscurs.

[Black Templar]

Merci.

Je pense avoir compris.
Mais maintenant, lorsque je l'implémante, ça ne mache pas trop

Je fais ça en Qt.
J'ai une fonction qui applique un filtre 3*3 à mon image

l'image de base est a_monImage

Code C++ :

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
void WidgetPrincipal::filtre(int matrice[3][3])
{
	QImage *image = a_monImage;		// a_monImage est l'image a traiter.
	QColor value;
	int temp = 0, progression = 0, couleur, pixel;
 
	int normeP = 0, normeN = 0, norme;
 
	for(int i = 0; i < 3; i++)
		for(int j = 0; j < 3; j++)
			if(matrice[i][j] > 0)
				normeP += matrice[i][j];	// Somme des termes positifs de la matrice
			else
				normeN += matrice[i][j];	// Somme des termes négatifs de la matrice
 
	if(normeP > fabs(normeN))
		norme = normeP;
	else
		norme = normeN;						// Normalisation au max(termes positif, termes négatifs)
 
	for(int x = 1; x < a_monImage->width()-1; x++)	// On ne pren pas en comptes les pixels du bord
    {
        for(int y = 1; y < a_monImage->height()-1; y++)
		{
			pixel = 0;
			for(int i = -1; i <=1; i++)
			{
				for(int j = -1; j <= 1; j++)
				{
					value= a_monImage->pixel(x+i, y+j);
					couleur = (value.red() + value.green() + value.blue()) / 3;		// Niveau de gris
					pixel += couleur * matrice[i+1][j+1];						// Calcul
				}
			}
 
			pixel /= norme;		//normalisation
			pixel = fabs(pixel);
			//pixel = 255*log(fabs(pixel)+1)/log(255);
 
			value.setRgb(pixel, pixel, pixel);
			image->setPixel(x, y, value.rgb());		// Modification de l'image temporaire
 
			temp = (100*x*a_monImage->height()+y)/((a_monImage->height()-1)*(a_monImage->width()-1));	// Calcul du pourcentage de calcul
            if((int)temp != (int)progression)
            {
                progression = temp;
                emit nouvelleProgression(progression);
            } 
		}
	}
	a_monImage = image;		// L'image vaut l'image temporaire
}

J'applique ce filtre pour détecté les bord de mon image

Code C++ :

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

1
2
	int matrice[3][3] = {{-1,-1,-1},{0,0,0},{1,1,1}};
	filtre(matrice);

mais le rendu n'a rien a voir avec ce que je trouve ici : http://xphilipp.developpez.com/artic...ge=page_6#LFL3

Voila ce que j'obtiens ...

[Jorganiz]

Si j'ai bien compris ton code, ton image temporaire et ton image originale sont en fait deux pointeurs vers les mêmes données. Si c'est le cas, pas étonnant que le résultat ne soit pas celui attendu : tu lis des valeurs dans l'image que tu es en train de modifier, donc les calculs sont faux. Pour remédier à cela, l'image temporaire doit être une copie de l'image originale et non un pointeur vers la même zone.

D'autres conseils :

1) Pour un filtre comme le PREWITT, il me semble qu'il vaut mieux diviser ta variable "pixel" par 1 (en fait, ne pas modifier sa valeur), plutôt que par 3 qui sera ici la norme calculée par ton code.

2) Pourquoi ignorer les pixels du bord ?

3)
couleur = (value.red() + value.green() + value.blue()) / 3;

pourra être remplacé par :

couleur = (30 * value.red() + 59 * value.green() + 11 * value.blue()) / 100;

s'il est important, pour l'objectif que tu vises, que les niveaux de gris calculés soient réalistes. (nos yeux sont plus sensibles au vert qu'au bleu par exemple, d'où la nécessiter de pondérer les value.xxx)

[Black Templar]

Merci beaucoup !

C'était bien un problème de pointeur ! Je modifiais directement l'image en question au lieu de modifier une copie !

Et merci aussi pour la formule du niveau de gris ! Je ne savais pas

A bientôt !