Discussion :

[AricDestroy]

Bonjour,

Je suis étudiant et je travaille sur la mise en place de méthode de traitement d'images parallélisée sur GeForce8800 GT grâce à CUDA.

Cependant j'ai beaucoup de mal à trouver les renseignements dont j'ai besoin.

Donc si vous connaissez CUDA pourriez vous m'aider.

[progfou]

Tu parles du bar ? (le bar à cuda, ok, je suis dehors [-->]).

Quel est le problème ?

[AricDestroy]

Je cherche a implementer la transformée de Hough, donc je voudrait parcourir une image et pour chaque pixel je veut remplir un accumulateur.

Je me suis basé sur l'exemple Sobel Filter du SDK pour parcourir l'image.

Puis pour chaque pixel, donc pour chaque thread je lance une boucle qui couvre l'ensemble des angles, cependant quand je lance mon application les résulats rendu par ma methode change a chaque fois donc je ne trouve jamais les memes droite.

Pour faire simple la methode fait ceci

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
 
 
//imgOut l'accumulateur
//imgIn image d'origine
// nr et nc correspondent a la taille de l'image
 
 
__global__ void 
Hough(int* imgOut, unsigned char* imgIn, int nr, int nc, int Pitch,int rmax, int angle_max)
{	
	int t = 200;
	int yc, xc;
	yc = (int)(nr/2);
	xc = (int)(nc/2);
	double rr = 0.0;
	int ra;
	double conv = 3.1415926535/180.0;
 
 
	unsigned char * houghImg= (unsigned char *) (((char *) imgIn)+blockIdx.x*Pitch);
 
 
	for ( int i = threadIdx.x; i < nc; i += blockDim.x )
	{
		if(houghImg[i] >= t)
		{
		//si la valeur de l'image (sur laquelle a été effectuée une detection de contour puis une binarisation vaut 1
			for(int alpha = 0 ; alpha < angle_max ; alpha++)
			{
				rr =(yc-blockIdx.x) * sin((double)(alpha*360/angle_max)*conv/2)+(i-xc) * cos((double)(alpha*360/angle_max)*conv/2);
				if(rr<0.0) 
				{
					ra=(int)rr;
				}
				else 
				{
					ra=(int)rr+1;
				}
			        imgOut[alpha+((rmax+ra)*360)]++ ;	
			}
		}
	}
}

Et donc une fois cette methode utiliser dans mon main comme ceci

Code :

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

1
2
3
4
 
//  ih hauteur de l'image
 
Hough<<<ih, 384>>>(Outdata , odata, ih, iw, iw, rmax, angleMax);

le resultat obtenu varie a chaque fois que ce lancement est effecuté

ps:j'espere que tu pourras m'aider

[progfou]

Il varie comment... Si tu pouvais mettre une image d'exemple, ça peut aider

[AricDestroy]

Voila le resultat lorsque je lance la recherche de droite deux fois de suite les droite sont totalement différentes

Je comprend vraiment pas pourquoi.

[AricDestroy]

D'ailleurs j'ai un autre soucis celui ci étant d'ailleur plus mistérieux

j'effectue le calcul suivant

Code :

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

1
2
 
rr =(double)(yc-(blockIdx.x))*(double)sinus + (double)(i-xc)*(double)cosinus;

mais lorsque le calcul s'effectue
je recupere le resultat et l'ensemble des parametres

rr = 37480633
alors que les parametres valent
yc =256
blockIdx.x = 331
sinus = 0.08
i = 242
xc = 256
cosinus = 0.9985

Et donc la je comprend vraiment plus rien

au secours

[pseudocode]

rr = 37480633

petit problème signed / unsigned ?

[AricDestroy]

non c pas ca parce que rr est défini comme un double normal donc y a aucune raison c'est juste mistérieux

[pseudocode]

non c pas ca parce que rr est défini comme un double normal donc y a aucune raison c'est juste mistérieux

je ne parlais pas de la déclaration mais de l'affichage (tag de printf).

[AricDestroy]

En fait je récupere mes valeurs en affectant a des elements donnés de mon accumulateur les valeurs rechercher, et pour faire cela je cast mes valeurs en int.

Du coup printf("%i ") devrait marcher

[ToTo13]

Bonjour,

concernant ta première erreur...
Combien de tirage aléatoire fais tu pour remplir tes accumulateurs ?
Etant donné que tu n'as que très peu de points pour trouver les droites, il est nécessaire de faire un maximum de tirages.

[progfou]

Tu cast comment ? Tu peux nous donner ce bout de code également ?

[AricDestroy]

J'ai résolu le probleme de mes variables aux valeurs incohérentes

Code :

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

1
2
 
rr =((double)yc-(double)(blockIdx.x))*(double)sinus + (double)i-(double)xc)*(double)cosinus;

Il ne voulait pas caster les resultats de yc - blockIdx.x en double il a fallu caster chaque variable pour obtenir un résultats cohérents


En révanche je n'éffectue pas de tirage aléatoire, je regarde tout mes points et je calcul pour chaque point les coordonnées polaires des différentes droites.
Le GPU est sensé accélérer le traitement en traitant en parallèle un grand nombre de points.

Le probleme doit se trouver dans le fait que j'utilise blockIdx.x et i
comme identifiant respectivement des lignes et des colonnes.
Et je sais pas si c'est cohérent de voir les choses comme ça.

Code :

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

1
2
3
4
5
6
7
 
unsigned char * houghImg= (unsigned char *) (((char *) 
imgIn)+blockIdx.x*Pitch);
 
 
	for ( int i = threadIdx.x; i < nc; i += (int)blockDim.x )
{...}

[AricDestroy]

D'ailleurs en augmentant le nombre de point j'obtient ce resultat.

On peut voir que j'ai lancé trois fois de suite ma fonction et qu'elle trouve trois résultats différents sauf pour deux droite qui sont totalement fausse.

Pourtant je me suis basé sur du code de transformée de Hough réalisé en séquentiel qui marche très bien.

[pseudocode]

Ton framework Multi-thread, il écraserait pas les variables locales, par hasard ?

[AricDestroy]

Excuse moi, mais qu'est ce que tu entend par frameWork Multi thread ????

En tout cas mes variables locales ont l'air d'avoir des valeurs correct

[AricDestroy]

Le probleme c'est le résultat final, ce qui m'intéresse surtout c'est de savoir comment on parcours une image et quel sont les variables sur lesquel on peut s'appuyer pour avec acces a la position du pixel en x et en y

Si vous avez des exemples ca peut m'intéresser

merci d'avance

[pseudocode]

Moi, ce qui m'intéresserait surtout c'est de savoir pourquoi un algo deterministe donne des résultats différents a chaque execution.

[AricDestroy]

je me pose la meme question, et justement les seules variables sur lesquelles je n'ai aucun controle sont la position en et celle en y.

Je considère que id du thread et l'id du block correspondent a ces valeurs cependant si ce n'est pas le cas ça explique peut etre le pourquoi du comment

J'ai des image 512*512 par exemple pour fixer la taille de la grill et des blocks je me suis appuyé sur un des exemple fourni par le SDK de CUDA 1.1 mais est ce que c'est cohérent je n'en suis pas sur

Dans l'exemple ils fixent la taille d'un block a 384 sur une image a 512*512 mais j'ai du mal a comprendre pourquoi

En effet en traitant des image 512*512 je pensais que le nombre de threads devait valoir 512*512 mais ce n'est visiblement pas le cas


J'ai donc décider de fixer la taille d'un block a 512
et la taille de la grille a 512 aussi ainsi je considère qu'un block correspond a une ligne mais ca ne fonctionne pas.

Si quelqu'un peut m'expliquer, ca pourrait être cool

[AricDestroy]

SVP