Haartraining ou corrélation de phase (FFTW)

Version imprimable

Voir 40 message(s) de cette discussion en une page

18/06/2012, 17h08
supernovagm

Là tu n'auras que 2 des 4 matrices (horizontale et verticale), pourquoi pas pour détecter un rectangle, mais pour une ellipse c'est pas forcément top à mon avis.

En revanche tu peux effectivement faire un GaussianBlur avant ton Sobel (ça va épaissir les contours tout en réduisant le bruit mais pas trop sinon ça te sort un effet dégradé qui supprime les contours de Sobel).
19/06/2012, 09h21
Linkis

J'ai déjà mis le GaussianBlur. Dans mon cas, je dois remplacer Vec3b par uchar?
D'ailleurs, pourquoi as-tu laissé la variable "k"?
19/06/2012, 09h43
supernovagm

oui tu met uchar (= niveau de gris) et sans le [k]
en fait pour la couleur je fais un Sobel sur chaque composantes plutôt que sur le niveau de gris, ça marche mieux je trouve, donc j'appelle une fonction avec le "k" correspondant à sa composante (k=0..2)
19/06/2012, 09h50
Linkis
Et, dans ton cas, tu n'as pas eu besoin de passer par:
Code:

1 2 3 Scalar intensity; intensity = img.at<uchar>(y,x); pixelValue = intensity.val[0];
?
19/06/2012, 09h59
supernovagm

tu peux t'en affranchir en ouvrant ton image en tant qu'image niveau de gris :

Code:

cv::Mat image = cv::imread("ton_image.jpg", CV_LOAD_IMAGE_GRASCALE);

ou en convertissant ton image :

Code:

cv::cvtColor(image, image, CV_BGR2GRAY);
19/06/2012, 10h15
Linkis

^^ Mes premières lignes codes servent à passer en niveau de gris, mais lorsque j'ai changé le flag de imread que Sobel a fonctionné, et lorsque je suis revenu à ce que je faisais ( cvtColor ), Sobel fonctionnait. J'ai du modifier qqch entre temps, mais quoi... tant pis^^^
Mon image de sortie n'est pas du tout bonne, mais, je vais relire le code tranquillement!

Bon, je croyais que j'avais un problème d'accès au pixel, mais je ne vois pas l'erreur. Auriez-vous une idée?
[ ci-joint, un joli résultat de mon Sobel avec l'invite de commande! ]

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
void SobelF( Mat* p_img, int thresholdValue )
{
	int h = p_img->rows;
	int w = p_img->cols;
	printf("height = %d, width = %d \n", h, w);
	int gradInter[4] = {0,0,0,0};
	int gMax = 0;
	int nbPixelsAnalyses = 0;
 
	//Bruit gaussien pour éliminer le bruit
	GaussianBlur( *p_img, *p_img, Size(3,3), 0, 0, BORDER_DEFAULT );
 
 
		for( int x = 1; x < w-1; x++ )
		{
			for( int y = 1; y < h-1; y++ )
			{
				//Initialisation de la matrice de travail extraite de l'image initiale
				uchar kernel[9] = {(*p_img).at<uchar>(y-1, x-1),
						(*p_img).at<uchar>(y, x-1),
						(*p_img).at<uchar>(y+1, x-1),
					(*p_img).at<uchar>(y-1, x),
						(*p_img).at<uchar>(y, x),
						(*p_img).at<uchar>(y+1, x),
					(*p_img).at<uchar>(y-1, x+1),
						(*p_img).at<uchar>(y, x+1),
						(*p_img).at<uchar>(y+1, x+1)};
 
				//Calcul de la convolution avec les 4 matrices
						//Pour les formes rectangulaires
				gradInter[0] = abs((-1) * kernel[0] +
					(-2) * kernel[3] +
					(-1) * kernel[6] +
					kernel[2] +
					2 * kernel[5] +
					kernel[8]); 
				gradInter[1] = abs(kernel[0] +
					2 * kernel[1] +
					kernel[2] +
					(-1) * kernel[6] +
					(-2) * kernel[7] +
					(-1) * kernel[8]); 
 
						//Pour les formes circulaires
				gradInter[2] = abs(kernel[1] +
					2 * kernel[2] +
					(-1) * kernel[3] +
					kernel[5] +
					(-2) * kernel[6] +
					(-1) * kernel[7]); 
				gradInter[3] = abs(2 * kernel[0] +
					kernel[1] +
					kernel[3] +
					(-1) * kernel[5] +
					(-1) * kernel[7] +
					(-2) * kernel[8]); 
 
				//Recherche du maximum
				gMax = 0;
				for( int i = 0; i < 4; i++ )
				{
					if( gradInter[i] > gMax )
						gMax = gradInter[i];
				}
 
				//Seuillage
				if( gMax > thresholdValue )
				{	
					circle( *p_img, Point(y,x), 0, Scalar(255), -1, 8, 0 );
					nbPixelsAnalyses++;
				}
				else
				{
					circle( *p_img, Point(y,x), 0, Scalar(0), -1, 8, 0 );
					nbPixelsAnalyses++;
				}
			}
		}
		printf("nbPixelsAnalyses = %d, nbPixelsTotal = heigth*width = %d\n", nbPixelsAnalyses, ((h-2)*(w-2)) );
		printf("Sobel done!\n");
}

J'ai voulu voir si toute l'image était analysée, d'où la variable nbPixelsAnalyses. En effet, vous pouvez voir sur l'image ci-jointe qu'une partie de l'image n'est pas traitée. Cependant, sur l'invite de commande, on voit bien que l'image est traitée entièrement Le problème peut donc venir de la fonction de dessin circle: d'ailleurs, auriez-vous une méthode moins bourin que celle-ci?

19/06/2012, 13h23
supernovagm

ça vient de

Code:

Point(y,x)

qu'il faut transformer en

Code:

Point(x,y)

Oui, je sais, ce n'est pas logique, mais quand on voit toujours ces erreurs on apprend à les trouver logique.
ex :
image.at<uchar>(y,x) est équivalent à image.at<uchar>(cv::Point(x, y))

Quel est l’intérêt de vouloir dessiner un cercle ? colorier le pixel en blanc devrait suffire ?
19/06/2012, 14h10
Linkis

Dans une autre fonction, je voulais changer la valeur d'un pixel, et je n'y arrivais pas avec image.at<uchar>(cv:: Point(x, y)), alors j'avais fait avec circle.
Sinon, je garde aussi ta phrase
"quand on voit toujours ces erreurs on apprend à les trouver logique."
qui encore a bien sa place sa place ici: mon image de sortie ne ressemble à rien car je modifie l'image au fur et à mesure...:oops: je me fais tout petit!
19/06/2012, 14h36
Linkis

2 pièce(s) jointe(s)

Voilà deux images: après ce filtre de Sobel ( thresholdValue = 15 ) et après quatre fermetures avec un disque 2x2.
Je te remercie beaucoup pour Sobel. Je vais oser et repartir sur FindContours :D
26/06/2012, 16h45
Linkis

4 pièce(s) jointe(s)

Désolé pour le retard, mais je me suis penché entre temps sur d'autres problèmes ( un autre type de défaut, un fichier de config, transposition du code en orientée objet ).

J'ai ajouté findContours et à l'entrée de cette fonction bien sympathique j'ai mis une image binaire, sortie du filtre de Sobel. Grâce au fichier de config, je fais varier le seuil de ce filtre selon la caméra utilisée, et grâce à une étude pifomètrique, j'ai gardé une valeur de seuil pour chaque caméra.
Voici quelques résultats.

Je n'ai affiché qu'un contour "intéressant" ( qui correspond à un défaut ), mais d'autres contours sont détectés

Maintenant, je cherche un moyen de discrimer ces contours.
20/07/2012, 09h52
Linkis

Voilà qqs nouvelles.

J'ai bien avancé: je parviens à détecter les bulles. Pour ce faire, je dessine tous les contours, et remplir tous les contours. J'obtiens une image binaire.
Je fais un premier tri en éliminant les formes dont le nombres de pixels constituant l'intérieur de chaque contour.
J'élimine aussi le contour du disque à l'aide d'un masque obtenu par FitEllipse.
J'applique encore un FindContours et détermine l'intérieur de chaque contour.
Je réalise la même discrimination par la taille et hop, j'obtiens des trucs sympas.
J'ai encore pas mal de trucs à améliorer, mais ça va :D
[ je posterai peut-être des images lorsque tout sera bien fait! ]

Merci infiniment à toi, supernovagm.
20/07/2012, 10h00
supernovagm

de rien,

on attend les images maintenant :D
30/08/2012, 16h26
Linkis

4 pièce(s) jointe(s)

Je finis mon stage et je me suis rendu compte que j'avais oublié de poster des images. Voilà deux exemples :D

Depuis mon dernier post, j'ai vraiment amélioré la technique, en enlevant des zones qui pouvaient être considérées comme des bulles ( exemple: les trois griffes présentes sur le contour/ Merci matchTemplate ^^ ), en discriminant les contours par leur taille et leur position,...

Sur tous les échantillons récoltés, j'ai 100% de réussite :D

En attendant ma soutenance, je peux tout de même te remercier infiniment pour ton aide, supernovagm!

Voir 40 message(s) de cette discussion en une page