Discussion :

[info_sara]

bonjour ;
je voudrais calculé le steepest descent d'une image en utilisant l'opencv
leur formule est

pour faire ça je dois
1-calculé le gradient avec W(x,p)
2-ensuite calculer le jacobien dans (x,p)
Note: il faut noté que je fais ces calculé pour résoudre un problème d'alignement où l'image dans le premier frame est "T" et dans le deuxiéme est 'I') le pixel (u,v) et de premier image quands je multiplié ce pixel avec la matrice W j'obtiens (u2,v2) dans le deuxième frame
je vous présenté maintenant comment j'ai le calculé pour une matrice w

dans cette matrice il y a un vecteur p =(wz, tx, ty);
pour calculé le gradient j'ai fait ça

Code :

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

1
2
3
4
 cvSobel(pImgI, pGradIx, 1, 0); // Gradient in X direction
 cvConvertScale(pGradIx, pGradIx, 0.125); // Normalize
 cvSobel(pImgI, pGradIy, 0, 1); // Gradient in Y direction
 cvConvertScale(pGradIy, pGradIy, 0.125); // Normalize

ensuite la 1 ére étape est calculé comme ça

Code :

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

1
2
float Ix = interpolate<short>(pGradIx, u2, v2);
         float Iy = interpolate<short>(pGradIy, u2, v2);

enfin j'ai calculé le steepest decent comme cela

Code :

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

1
2
3
4
5
 // Calculate steepest descent image's element.
         float stdesc[3]; // an element of steepest descent image
         stdesc[0] = (float)(-v*Ix+u*Iy);
         stdesc[1] = (float)Ix;
         stdesc[2] = (float)Iy;

je voudraos maintenant faire le même travail mais avec cette matrice

où comme on vu le vecteur p ne dépend pas seulement su (u,v) (l'emplacement du pixel) mais il dépend de 6 paramètre qui sont (x,y,z,wx,wy,wz)
j'ai pas pu le calculé dans cette cas la seul chose qui je connus que la matrice de stdesc doit être contenir 6 élément float stdesc[6];
pourriez vous m'aider pour le calculé SVP ma tête sera cassé et j'ai pas trouvé la solution

[snowpy]

pour le gradient je pense pas qu'il y est de souci pour le jacobien, le jacobien n'est rien d'autre que le déterminant d'une matrice jacobienne. Plusieurs possibilité pour le calculer 2 énoncé ICI
Une autre possibilité est de le calculer à la main

[info_sara]

bon premièrement snowpy je vous remercie pour vos réponses qui toujours m'aider

pour le gradient je pense pas qu'il y est de souci pour le jacobien

oui , il n'a pas
mais dans le premier code on a utilisé le gradient pour calculé le steepect non?

Code :

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

1
2
3
4
5
6
7
8
float Ix = interpolate<short>(pGradIx, u2, v2);
         float Iy = interpolate<short>(pGradIy, u2, v2);
 
         // Calculate steepest descent image's element.
         float stdesc[3]; // an element of steepest descent image
         stdesc[0] = (float)(-v*Ix+u*Iy);
         stdesc[1] = (float)Ix;
         stdesc[2] = (float)Iy;

est ce que vous pourrize m'expliqué un peu comment on obtient la matrice jacobienne en utilisant notre matrice W [4*4]

[snowpy]

oui j'avais zappé le but même de ta démarche ^^

Pour i = 1, ..., m, la ie ligne de cette matrice est la transposée du vecteur gradient au point M de la fonction fi.

sinon ta un peu plus de détail ICI

je ne connais pas la fonction interpolate par contre :s

[info_sara]

je ne connais pas la fonction interpolate

interpolate est défini comme ça

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
 
// Interpolation pour trouver la valeur d'un pixel trouvé aprés transformation 
 
float interpolate(IplImage* pImage, float x, float y)
{
	// Get the nearest integer pixel coords (xi;yi).
	int xi = cvFloor(x);
	int yi = cvFloor(y);
 
	float k1 = x-xi; // Coefficients for interpolation formula.
	float k2 = y-yi;
 
	int f1 = xi<pImage->width-1;  // Check that pixels to the right  
	int f2 = yi<pImage->height-1; // and to down direction exist.
 
	T* row1 = &CV_IMAGE_ELEM(pImage, T, yi, xi);
	T* row2 = &CV_IMAGE_ELEM(pImage, T, yi+1, xi);
 
	// Interpolate pixel intensity.
	float interpolated_value = (1.0f-k1)*(1.0f-k2)*(float)row1[0] +
				(f1 ? ( k1*(1.0f-k2)*(float)row1[1] ):0) +
				(f2 ? ( (1.0f-k1)*k2*(float)row2[0] ):0) +						
				((f1 && f2) ? ( k1*k2*(float)row2[1] ):0) ;
 
	return interpolated_value;
 
}

desolé, mais j'ai rien compris comment le lien que vous avez me donner conne va être m'aider? (je ne sais pas peut être ma tête a été bloqué )

en tous le cas toujour, je trouve des chose cizare dans ce site par ce que il est le seul site qui il a trouvé travaillé avec le steepest decent ou jacobien
http://www.koders.com/cpp/fid21C089B...x?s=opencv#L45
il a le calculé comme ça

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
 // Interpolate gradient intensity in x direction.
          float Ix = 0.125f*interpolate<short>(m_pGradIx, u2, v2);
                    
          // Interpolate gradient intensity in y direction.
          float Iy = 0.125f*interpolate<short>(m_pGradIy, u2, v2);
                              
          // Calculate elements of the steepest descent images.

          float k1 = ProjectionMat[0] * (fFrameWidth/2.0f) / (z*z) * Ix;
          float k2 = -ProjectionMat[5] * (fFrameHeight/2.0f) / (z*z) * Iy;
          
          float stdesc[6];

          stdesc[0] = k1*(x*y) + k2*(y*y+z*z);
          stdesc[1] = k1*(-x*x-z*z) + k2*(-x*y);
          stdesc[2] = k1*(y*z) + k2*(-x*z);
          stdesc[3] = k1*(-z);
          stdesc[4] = k2*(-z);
          stdesc[5] = k1*(x) + k2*(y);

est ce que il est nécessaire que je travaille comme ça ? surtout dans le calcule de k1,K2
quand j'applique le déterminante il ne nous donne pas les même résultat

[snowpy]

tu cherche à faire quoi, personnellement je suis un peu perdu dans le code que tu donne vue que je sais pas trop ce qu'il veut faire ^^