Discussion :

[skatzoo]

Bonjour,
je travaille sur un mini-projet: mise en correspondance dans des images stéréo"(image gauche et droite).
je voudrais, lorsqu'on clik sur un point de l'image gauche, qu'on puisse retrouver son correspondant dans l'image droite. Si vous pourriez me donner une méthode qui me permettrais de faire cela

[Vinsss84]

Ce ue tu peux faire c'est : clic sur un point de l'image de gauche (resp droite) et affichage de la ligne épipolaire comprenant ce point dans l'image de droute (resp gauche). Si tu pouvais trouver directement le point tu aurais résolu tout les problèmes de stéréo-correlation.

Pour ça c'est relativement simple : calcul de la matrice fondamental puis a partir de la matrice fondamentale on récupere la ligne épipolaire qui comprendra le correspondant.

Pour la matrice fondamentale 2 méthodes pour la trouver : calibration stéréo puis calcul ou estimation grace à la fonction dediée d'open cv. Dans ce cas utiliser au minimum 9 points dans mes souvenirs.

Sinon si tes images sont rectifiées tu peux utiliser la fonction de correlation implémentée dans OpenCv et déduire la position du correspondant dans la ligne en fonction de la valeur de disparité.

[skatzoo]

désolé pour cette réponse tardive Vinsss84.
la fonction cvfindfundamentalmatrix permet de trouver la matrice fondamentale, mais elle en prend en param deux matrices(imgs gauche et droite), on peut trouver la matrice pour img gauche, mais mon probleme c celle de l'image droite

[Vinsss84]

code après une calibration gauche et droite :

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
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
//The computeFondamentalMatrix method allow us to compute the Fondamental matrix from the extrinsic parameters
CvMat Stereo::ComputeFondamentalMatrix(double rotL[],double rotR[],double intrinsicL[], 
							 double intrinsicR[], double tranL[], double tranR[])
{	//we have recover the intrinsic camera parameters from calibration
	//we can compute the essential and the fundamental matrix 
 
 
 
 
	//CvMat declaration - rot vectr, rot matrix, intrinsic matrix L and R
;
int i,j;
 
 
 
  CvMat Intrinsic_L  = cvMat( 3, 3, CV_64FC1, intrinsicL ); //paramètres intrinsèques
  CvMat Intrinsic_R  = cvMat( 3, 3, CV_64FC1, intrinsicR );
 
  //Vecteur de Rotation
 
  CvMat Rot_vect_L = cvMat( 1, 3, CV_64FC1, rotL);
  CvMat Rot_vect_R = cvMat( 1, 3, CV_64FC1, rotR);
 
 
  //Declaration de la matrice 3x3 qui sera la matrice de rotation
 
  CvMat* Rot_matrix_L = cvCreateMat(3,3,CV_64FC1);
  CvMat* Rot_matrix_R = cvCreateMat(3,3,CV_64FC1);
  //Declaration de la matrice 4x4 qui contiendra rotation+translation
 
  CvMat* Extrinsic_matrix_L = cvCreateMat(4,4,CV_64FC1);
  CvMat* Extrinsic_matrix_R = cvCreateMat(4,4,CV_64FC1);
 
  //Matrice stereo nécessaire au calcul de la matrice essentielle
 
   CvMat *Stereo_matrix = cvCreateMat( 4, 4, CV_64FC1 );
   CvMat *tmp1    = cvCreateMat( 3, 3, CV_64FC1 );
   CvMat *tmp2    = cvCreateMat( 3, 3, CV_64FC1 );
   CvMat *E_matrix = cvCreateMat( 3,3, CV_64FC1 );
   CvMat *Fondamental_matrix = cvCreateMat(3,3, CV_64FC1);
	//cvRodrigues2 //convert the rot vector to rot matrix for L cam 
  /*
  (r1)						   (r11 r12 r13)
  (r2)========Rodrigues2======>(r21 r22 r23)
  (r3)						   (r31 r32 r33)
  */
  cvRodrigues2(&Rot_vect_L,Rot_matrix_L,0);
  cvRodrigues2(&Rot_vect_R,Rot_matrix_R,0);
	//fill the Extrinsic matrix
	/*
	(r11 r12 r13 t1)
	(r21 r22 r23 t2)
	(r31 r32 r33 t3)
	( 0   0   0  1 )
	*/
  //fill the Left Extrinsic Matrix
  cvmSet(Extrinsic_matrix_L,0,0,cvmGet(Rot_matrix_L,0,0));
  cvmSet(Extrinsic_matrix_L,0,1,cvmGet(Rot_matrix_L,0,1));
  cvmSet(Extrinsic_matrix_L,0,2,cvmGet(Rot_matrix_L,0,2));
  cvmSet(Extrinsic_matrix_L,1,0,cvmGet(Rot_matrix_L,1,0));
  cvmSet(Extrinsic_matrix_L,1,1,cvmGet(Rot_matrix_L,1,1));
  cvmSet(Extrinsic_matrix_L,1,2,cvmGet(Rot_matrix_L,1,2));
 
  cvmSet(Extrinsic_matrix_L,2,0,cvmGet(Rot_matrix_L,2,0));
  cvmSet(Extrinsic_matrix_L,2,1,cvmGet(Rot_matrix_L,2,1));
  cvmSet(Extrinsic_matrix_L,2,2,cvmGet(Rot_matrix_L,2,2));
 
  cvmSet(Extrinsic_matrix_L,0,3,tranL[0]);
  cvmSet(Extrinsic_matrix_L,1,3,tranL[1]);
  cvmSet(Extrinsic_matrix_L,2,3,tranL[2]);
 
  cvmSet(Extrinsic_matrix_L,3,0,0);
  cvmSet(Extrinsic_matrix_L,3,1,0);
  cvmSet(Extrinsic_matrix_L,3,2,0);
 
  cvmSet(Extrinsic_matrix_L,3,3,1);
 
 
  //fill the Right Extrinsic Matrix
 
  cvmSet(Extrinsic_matrix_R,0,0,cvmGet(Rot_matrix_R,0,0));
  cvmSet(Extrinsic_matrix_R,0,1,cvmGet(Rot_matrix_R,0,1));
  cvmSet(Extrinsic_matrix_R,0,2,cvmGet(Rot_matrix_R,0,2));
  cvmSet(Extrinsic_matrix_R,1,0,cvmGet(Rot_matrix_R,1,0));
  cvmSet(Extrinsic_matrix_R,1,1,cvmGet(Rot_matrix_R,1,1));
  cvmSet(Extrinsic_matrix_R,1,2,cvmGet(Rot_matrix_R,1,2));
 
  cvmSet(Extrinsic_matrix_R,2,0,cvmGet(Rot_matrix_R,2,0));
  cvmSet(Extrinsic_matrix_R,2,1,cvmGet(Rot_matrix_R,2,1));
  cvmSet(Extrinsic_matrix_R,2,2,cvmGet(Rot_matrix_R,2,2));
 
  cvmSet(Extrinsic_matrix_R,0,3,tranR[0]);
  cvmSet(Extrinsic_matrix_R,1,3,tranR[1]);
  cvmSet(Extrinsic_matrix_R,2,3,tranR[2]);
 
  cvmSet(Extrinsic_matrix_R,3,0,0);
  cvmSet(Extrinsic_matrix_R,3,1,0);
  cvmSet(Extrinsic_matrix_R,3,2,0);
 
  cvmSet(Extrinsic_matrix_R,3,3,1);
 
	//Calcul de la matrice Stéréo
	//stereo_matrix=Extrinsic_R * (Extrinsic_L)-1
 
	cvInvert(Extrinsic_matrix_L,Extrinsic_matrix_L,CV_LU);//L^-1
	cvMatMul(Extrinsic_matrix_R,Extrinsic_matrix_L,Stereo_matrix);
//compute b value which will be usefull to compute 3D coordinates
//b = sqrt(bx²+by²+bz²)
//bx by bz are the translation coeffs of stereo matrix and represents the displacement between the 2cams
 
printf("\n\n%c Matrice Stereo :\n", 16);
for(int f = 0 ; f<4 ; f++)
	{
	printf("[");
	for(int g = 0 ; g<4 ;g++ )
		{
			printf("% f  ",cvmGet(Stereo_matrix,f,g));
		}
	printf("]\n");
	}
b = cvSqrt(cvmGet(Stereo_matrix,0,3)*cvmGet(Stereo_matrix,0,3)+cvmGet(Stereo_matrix,1,3)*cvmGet(Stereo_matrix,1,3)+cvmGet(Stereo_matrix,2,3)*cvmGet(Stereo_matrix,2,3));
printf("B = %f\n",b);
	//compute essential matrix from R matrix
 
 
  tmp1->data.db[0] = 0;
  tmp1->data.db[1] = - Stereo_matrix->data.db[11] ;
  tmp1->data.db[2] =   Stereo_matrix->data.db[7] ;
  tmp1->data.db[3] =   Stereo_matrix->data.db[11] ;
  tmp1->data.db[4] = 0;
  tmp1->data.db[5] = - Stereo_matrix->data.db[3] ;
  tmp1->data.db[6] = - Stereo_matrix->data.db[7] ;
  tmp1->data.db[7] =   Stereo_matrix->data.db[3] ;
  tmp1->data.db[8] = 0;
 
 
   for( i=0 ; i < 3; i++)
   {for( j=0 ; j < 3; j++)
   cvmSet(tmp2,i,j,cvmGet(Stereo_matrix,i,j));
     }
 
 //compute the essential matrix from the product of tmp1&tmp2 : Horaud, chap6 p 192 Vision Par ordinateur
 
//(a') (0 -bz by)   (r11 r12 r13) (x)
//(b')=(bz 0 -bx) x (r21 r22 r23)x(y)
//(c') (-by bx 0)   (r31 r32 r33) (1)
 
 
//droite img droite = tmp1*tmp2*coordonées point dans l'image gauche
 
  cvMatMul(tmp1,tmp2,E_matrix);
 //compute fondamental matrix from essential matrix and Intrinsic param
 //(C'^-1)t x E x C^-1=F?
 //Inversion des matrices de parametres intrinsèques  
  cvInvert(&Intrinsic_L,&Intrinsic_L,CV_LU);
  cvInvert(&Intrinsic_R,&Intrinsic_R,CV_LU);
 
//Transposition de la matrice de la caméra droite
 
 cvTranspose(&Intrinsic_R,&Intrinsic_R);
 cvMatMul(&Intrinsic_R,E_matrix,E_matrix);
 cvMatMul(E_matrix,&Intrinsic_L,Fondamental_matrix);
 
//Release Matrix
 cvReleaseMat(&tmp1);
 cvReleaseMat(&tmp2);
 cvReleaseMat(&E_matrix);
 cvReleaseMat(&Stereo_matrix);
 cvReleaseMat(&Extrinsic_matrix_R);
 cvReleaseMat(&Extrinsic_matrix_L);
 cvReleaseMat(&Rot_matrix_L);
 cvReleaseMat(&Rot_matrix_L);
 
 return *Fondamental_matrix; //
 
 
 
}

code pour l'estimation de la matrice fondamentale avec une selection de points

La fonction de calcul :

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
int Camera::ComputeMatriceFondamentaleEstim () 
{
 
	CvMat *fundamental_matrix;
	fundamental_matrix = cvCreateMat(3,3,CV_32FC1);	//Création de la matrice fondamentale Matrice 3x3 par définition
 
	CvMat *status;
	status = cvCreateMat(1,48,CV_8UC1);
 
	// initialisation à '0' de la matrice fondamentale
 
	for (int j=0;j<3;j++)
		{
			for (int k=0;k<3;k++)
			{
				cvmSet(fundamental_matrix,k,j,0);
			}
		}
 
	// détermination de la matrice fondamentale
	int fm_count = cvFindFundamentalMat( points_camL,points_camR,fundamental_matrix,CV_FM_RANSAC,1.0,0.99,status );
 
	FundamentalMatrixEstim = fundamental_matrix;
 
 
return 0;
 
 
}

le code pour l'appeler consiste à réaliser la selection manuelle de points en correspondance dans les images gauche et droite ; stockés dans points_camL et points_camR

[skatzoo]

Merci Vinsss84, je m'y mets tt de suite, je te mets au courant de mes résultats

[Vinsss84]

Bon couragen tiens moi au courant. Je peut te faire passer le code complet si je cherche mais je pense pas que ça soit très intéressant pour toi.

Restent plusieurs questions en suspend :

- images rectifiées ou non?
- calibration effectuée?

[TN_CODER]

Bon couragen tiens moi au courant. Je peut te faire passer le code complet si je cherche mais je pense pas que ça soit très intéressant pour toi.

Restent plusieurs questions en suspend :

- images rectifiées ou non?
- calibration effectuée?

Merci insss84 pour votre aide,
en faite j'ai une question, après avoir calculer la matrice fondamental et ensuite la matrice "epilineMat" qui contient les a,b et c qui verifier a.x + b.y + c=0 avec la fonction :cvComputeCorrespondEpilines (points,1,f_mat,epilineMat);
maintenant je veux savoir comment je peux afficher les droites epipolaire, normalement il me faut 2 point pour utiliser la fonction cvLine(pt1,pt2)
donc la question est comment déterminer les 2 points pour afficher la droite epipolaire.

Merci d'avance.
Liwa.

[Vinsss84]

euh, y = ax+b
Il ya plus difficile que de déterminer les points d'une droite à partir de son éuqation

prend par exemple x = 0 et le y correspondant et y = 0 et le x correspondant et rulez

[TN_CODER]

euh, y = ax+b
Il ya plus difficile que de déterminer les points d'une droite à partir de son éuqation

prend par exemple x = 0 et le y correspondant et y = 0 et le x correspondant et rulez

merci

[Vinsss84]

pas de quoi, parfois les questions les plus simples sont celles dont on ne vois pas la réponse immédiatement

[TN_CODER]

ca y est j'ai termine le dessin des ligne epipolaires.
Ma question mnt pour j'ai le meme point d'intersection dans les deux images gauche et droite?
et que représente se point d'intersection?
sinon je croix que l'etape suivante est celle de la rectification epipolaire, ce qoi le principe?



Merci.
Liwa.

[Vinsss84]

ce sont les epipoles gauche et droits
le principe de la rectification épipolaire est de ramener les deux images dans un même plan , de façon à avoir des lignes épipolaires parallèle. Le problème est donc de trouver la transformation mathématique qui va permettre de renvoyer les épipoles à l'infini.
En pratique, une translation et une rotation.
Je te conseille les travaux de A.Fusiello qui a écrit quelques papiers assez clairs sur le sujet. Je posterai demain ma version OpenCv de rectification épipolaire, utilisant les travaux d'A.Fusiello et également ceux de J.Y Bouguet.

Bon courage.

[TN_CODER]

j'ai utilise cvFindFundamentalMat & cvComputeCorrespondEpilines pour dessiner, en
utilisant cvLine, les lignes epipolaire apres avoir faire le matching des points
dans les 2 images, mais comme vous voiez au dessus il me semble okay.

Ma question est comment utilise les lignes epipolaires pour rectifier l'image?
cvPreWarpImage n'est pas bien documente.
est ce qu'il y a d'autre fonction pour la rectification de l'image?sinon comment
je peux utiliser cvPreWarpImage pour la rectification?
en d'autre terme comment je peux faire la rotation et la translation de l'image
pour rendre les lignes epipolaires parallèles a l'axe des X.

Merci

[Vinsss84]

Alors juste une question, as tu effectuée une calibration des tes caméras? Si ça n'est pas le cas, je n'ai pas la solution pour ne l'avoir jamais cherchée
En toute logique il faut chercher la matrice de rotation permettant de ramener les lignes épipolaires à l'infini pour une des caméras... Ca c'est pas gagné.
Si tu as calibré je pourrai te fournir un code de rectification qui fonctionne t te l'expliquer... mardi

[visio]

Salut, je suis dans le deuxieme cas, j'ai deux cameras calibrées, j'ai calculé la matrice fondamentale, et par tracé des lignes épipolaires celle ci semble exacte.
Mais je bloque sur l'etape de rectification, je pense qu'il faut utiliser cvMakeScanlines et cvPreWarpImage mais c'est vrai que la doc n'est pas du tout claire...
Merci

[Vinsss84]

mouais il y a a priori une focntion de rectification incluse dans open cv mais je n'ai jamais pu la faire marcher correctement j'avais donc developpé mon propre code.
Je vais essayer de faire un recapitulatif des étapes, ce week end si vous êtes sages