Forum Clubic

C : tableau : accès par pointeurs

Bonjour

J’ai des tableaux qui representent des images (donc soit des tableaux de RGB soit des tableaux de reels qui stockent la luminosité).
Et je souhaite faire une déformation sur cette image, toujours la meme, le plus rapidement possible.
Mon idée est donc de la calculer une seule fois pour chaque pixel, puis ensuite de réutiliser ce calul.

Pour bien comprendre j’apellerai T le tableau image de départ et D sa déformée.
Dans un premier temps je voudrais pouvoir déformer n’importe quel tableau T que je passe en parametre.
Donc je me suis dis je pourrai creer un tableau qui stocke la différence de pointeur entre deux pixels entre l’image originale et déformes.
Exemple si le Pixel x de D (0,0) correspond au Pixel y de T [5,8] une fois déformé, je vais calculer la différence entre les pointeurs T(0,0) et T[5,8] et stocker cette diférence, puis quand je voudrais deformer une image, je prendrai le pointeurs du tableau T(0,0) pour lui appliquer cette différence, et j’enregistre la valeur pointée dans D. Bonne idée ou pas?
Mais une différence entre deux pointeurs ca se stocke comment? Par exemple si on a un pointeur p vers une case d’un tableau et qu’on fait p+5 on avance de 5 cases dans le tableau. dans ce cas 5 pourrait etre un int, mais est ce que p1-p2 si ce sont deux pointeurs vers un objet quelconque est un int?

Dans un deuxieme temps ce sera toujours le meme tableau image T qui sera déformé, donc j’avais pensé faire un tableau de pointeurs qui pointent vers les elements de mon image T, mais au lieu de faire pointer le premier pointeur sur le pixel (0,0) de T je le ferai pointer vers le pixel [5,8] de T. C’est une bonne idée ou pas?

Merci !
Edité le 19/12/2007 à 17:27

Franchement je t’avoue que personellement j’ai pas compris grand chose à ton explication. La seule question à laquelle je peux répondre c’est la différence entre p1 et p2 c’est effectivement un int et tu peux très bien faire p = p + (p2 - p1) (considérant que p2 > p1).

Je sais que c’est pas facile a comprendre, mais c’est pas facile a expliquer non plus, et je m’y suis repris a plusieurs fois pour essayer d’expliquer le plus clairement que je pouvais.
Merci pour ta réponse en tout cas.

Sinon, je refais l’explication en plus court, mais pour les details il faut relire mon premier post :

un image (tableau de pixel dans mon cas) a deformer.
Plutot que de calculer la deformation a chaque fois je la calcul une fois au debut.
Pour “enregistrer” cette deformation je veux enregistrer, pour chaque pixel, comment il va se deformer, donc se deplacer en fait.
Donc mon probleme est comment effectuer cet enregistrement, et j’ai pensé a passer par les pointeurs, et dans un cas je dois stocker un “deplacement” de pointeur, et dans l’autre directement l’adresse du pixel déformé.

D’accord, je comprends mieux.
Ta déformation est uniquement un changement d’emplacement d’un pixel vers un autre ? ou y a-t-il en plus des modifications potentielle sur la couleur par exemple ?
Dois tu garder le tableau d’origine (appelé D je crois dans ton post).
Une approche toute simple serait de définir les élements comme une strucutre contenant :
typedef struct PixelD_s
{
int RGB[3]; // ou un int sur lequel tu fais du décalage de bits pour avoir les trois couleurs
int posPostDeformation, //index de la case ou devra se trouver le pixel après déformation
} PixelD;

Une deuxieme approche c’est effectivement d’avoir 3 tableaux. Un pour D, Un pour conserver le déplacement pour chaque pixel et un pour l’image de déstination.

Petite note si tu as un tableau à 2 dimension, tu peux définir posPostDeformation comme un tableau de 2 ints pour conserver l’x et l’y du pixel.

J’espère ne pas répondre à côté de ce que tu demandes. Simplement, il n’est pas nécessaire de travailler directement avec des pointeurs… Il vaut mieux que tu travail avec les index dans le tableau.

Oui voilà c’est ce que je veux faire. :slight_smile:
Mais comme je dois faire du temps reel, je veux la solution la plus rapide possible. Donc stocker l’index de la case ou devra se trouver le pixel apres deformation peut marcher mais ca sera moins rapide que de travailler directement avec des pointeurs.

Surtout dans le cas où plus tard je deformerais toujours le meme tableau (dont les valeurs changeront), je me disais autant stocker un tableau de pointeur qui contiendra les adresses des pixels de ce tableau mais avec les position déformés.

J’ai un problème pour implémenter la méthode avec la différence de pointeur :
je penses que ca vient du fait que mon tableau d’image est declaré comme ca :


Pixel** tab = new Pixel*[hauteur]
pour i de 0 a hauteur 
	Pixel[i] = new Pixel[largeur]

Ensuite quand je calcul la difference entre les pixels pour ma deformation dans un tableau int** tDef je fait :


pour tous i,j
	tDef[i][j] = &(tab[i_deforme][j_deforme]) - &(tab[i][j]);

et quand je veux deformer un pixel je fait :


Pour tous i,j
	Pixel* pix = &(tab[i][j])
	tab_deforme[i][j] = pix + tDef[i][j]

Je me demande si ca viendrai pas du fait que l’espace memoire de mes tableaux n’est pas contigue (pixel[i] est contigue, mais entre pixel[i] et pixel[j] donc deux lignes différentes pas forcement, je me trompe?)
Donc quand la deformation atteint une autre ligne de mon tableau, ca foire.
Si ca vient de là, comment je dois faire?

merci
Edité le 20/12/2007 à 11:48

C’est tout aussi rapide dans ce cas… tu manipule un int dans les deux cas et le temps d’accès est le même.

Sinon je pense que
“tab_deforme[i][j] = pix + tDef[i][j]” y a un probleme.

Tu es en train de stcoker la difference de pointeur dans ton tableau final. (A moins que se soit un résumé de ton vrai code)… en tout cas cette ligne n’est pas correcte en l’état

oui c’est un résumé de mon code… en fait j’ai des valeurs RGB dans cette structure et je fait en fait :
tab_deforme[i][j].R=(*(pix+tDef[i][j]).R
pareil pour G et B
Sinon pour la différence de vitesse, ca vient du fait que avec ta solution il faudrait faire :
tab_deforme[i][j].R = tab_origine[ posPostDeformation[i][j].i ][ posPostDeformation[i][j].j ].R
c’est a dire en terme d’accés calculer la position du pointeur de posPostDeformation pour i puis pour j + caluler la position dans le tab_origine. Ce qui donne 2 calculs de pointeurs dans un tableau a une dimension + 1 calcul de pointeur dans un tableau a deux dimension.
Avec la méthode que je voudrai faire il n’y a q’un calcul de pointeur d’un tableau a deux dimension + 1 addition.
Edité le 20/12/2007 à 14:02


/* 
pour un buffer 32 bits
   color etant un int
   pixels : tableau d'entier 
*/
*((unsigned int *)(buffer->pixels) + x + y * buffer->width) = color

Edité le 20/12/2007 à 23:03