Discussion :

[info_sara]

bonjour,
je voudrais savoir quelle est la différence entre "cvResetImageROI", "cvSetImageROI"
à mes connaissance la première est pour définir l'image comme une région d'intérêt mais le deuxième défini une région d'intérêt Cvrect
mais j'ai pas compris comment ils ont travaillé et est ec qu'on peux travaillé avec les deux dans le même code ?

[info_sara]

je voudrais savoir l'utilité de cette fct aussi "CV_IMAGE_ELEM" je sais quelle est utilisé pour accés à les coordonnais de l'image mais j'ai pas bien compris ces paramètre

[glen1789]

Code :

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

1
2
3
4
/* get reference to pixel at (col,row),
   for multi-channel images (col) should be multiplied by number of channels */
#define CV_IMAGE_ELEM( image, elemtype, row, col )       \
    (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])

En fait c'est qu'une macro pour aller chercher un pixel dans une image

[glen1789]

En gros setImageROI definie une region d'interet dans l'image (comme tu dis a travers un cvRect). Donc ensuite tu peux travailler avec cette ROI comme si c'etait une image complete.
resetImageROI c'est rien qu'une fonction pour annuler la selection d'une ROI et reconsiderer l'image toute entiere, en gros c'est la meme chose que le codesuivant:

Code :

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

1
2
3
 
cvSetImageROI( image, cvRect( 0, 0, image->width, image->height ));
cvSetImageCOI( image, 0 );

sauf qu'en plus il fait un release de la structure ROI precedemment definie.

[info_sara]

merci glen
j'ai compris bien cvSetImageROI

Code :

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

 float* pixel_coords = &CV_IMAGE_ELEM(pCoords, float, v, u*3);

c à dire trouver les coordonnée du pixel (u,v) dans l'image pcoords?

[snowpy]

ca te renvoie la valeur du channel du pixel correspondant, en gros tu lui demande la valeur du channel du pixel situé en x,y

http://osdir.com/ml/lib.opencv/2006-03/msg00914.html

[info_sara]

merci snowpy
mais je n'ais pas compris bien l'explication du site

[snowpy]

ta plusieurs moyen de récupérer les channels d'un pixel, ta le cvget2D mais tu as aussi ca CV_IMAGE_ELEM et ca I(x,y) ~ ((uchar*)(img->imageData + img->widthStep*y))[x]
. Cela réalise la même fonction, récupérer le pixel et ses couleurs et séparer la couleur suivant le nombre de channel correspondant (BGR, HSV) selon le nombre de channel de ton image.

[info_sara]

merci glen1789 et snowpy
c'est résolu

[info_sara]

bonjour,
toujours j'ai un problème avec CV_IMAGE_ELEM
j'ai trouvé ça

Code :

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

1
2
3
4
5
6
7
8
 
 IplImage* pCoords;
  pCoords = cvCreateImage(frame_size, IPL_DEPTH_32F, 3);
//(u,v) coordonnée d'un pixel 
  float* pixel_coords = &CV_IMAGE_ELEM(pCoords, float, v, u*3);
        float x = pixel_coords[0]; 
        float y = pixel_coords[1];  
        float z = pixel_coords[2];

dans ce code là , comment il a utilisé CV_IMAGE_ELEM malgré notre image pCoords est vide ????? en plus de ça il a récupérer 3 coordonnée ????

[snowpy]

2 possibilités :

- première possibilité, c'est faux et ca ne fonctionne pas
- deuxième possibilité, quand on crée une image, il remplie celle-ci par defaut, en gros quand tu fais le create au lieu d'avoir un vide il mets une couleur uniforme pour créer une image par défaut.

J'avoue ne jamais avoir testé, essaye de faire un create et d'afficher le résultat pour voir. Mais je pense que la deuxième possibilité sera la bonne.

[sara123]

bonjour snowpy

Code :

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

deuxième possibilité, quand on crée une image, il remplie celle-ci par defaut, en gros quand tu fais le create au lieu d'avoir un vide il mets une couleur uniforme pour créer une image par défaut.

je ne pense pas si elle est en couleur uniforme par ce que il a travaillé ensuite par les valeur de X,Y,Z

Code :

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

1
2
3
4
5
// Set vector X with pixel 4D homogeneous coordinates (x, y, z, 1).
        SET_VECTOR_4D(m_X, x, y, z, 1);
 
        // Calculate eye coordinates Z = W * X. 
        cvGEMM(m_W, m_X, 1, 0, 0, m_Z);

comment il a récupérer les X,Y,Z de chaque pixel
le code se trouve ici merci de le voir et me dire est ce que il est en couleur uniforme ou non
http://www.koders.com/cpp/fid21C089B...x?s=opencv#L45
et dans ce lien il a crée l'image
http://www.koders.com/cpp/fidC00B8EF....aspx?s=opencv
j'ai pas trouvé où il a changé les paramètres de l'image

[snowpy]

je ne pense pas si elle est en couleur uniforme par ce que il a travaillé ensuite par les valeur de X,Y,Z

attention à ne pas confondre couleur et channel. On va prendre le cas d'une image RGB (pour HSV et le reste ca reste valable). Imaginons que je remplice mon image entièrement de blanc. La couleur est uniforme. Or les trois channels sont concerné à savoir que pour avoir du blanc RGB tu auras R > 223 , G > 223 , B > 223
Table RGB
La j'ai pris le cas d'une couleur constitué des trois mais si tu regarde dans la table si tu prends que du rouge par exemple les channels G et B sont à zéro mais ils existent quand même.

Code :

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

1
2
3
4
5
6
7
8
for(i=0; i<template_rect.width; i+=step)
    {
      int u = i + template_rect.x;
      //float Xw = u + 0.5f;
 
      for(j=0; j<template_rect.height; j+=step)
      {
        int v = j + template_rect.y;

Début de boucle il va parcourir tous les pixels de l'image. Ensuite pour chaque pixel

Code :

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

1
2
3
4
5
// Retrive stored eye coordinates (Xe;Ye;Ze) coordinates for current pixel.
        float* pixel_coords = &CV_IMAGE_ELEM(pCoords, float, v, u*3);
        float x = pixel_coords[0]; 
        float y = pixel_coords[1];  
        float z = pixel_coords[2];

il récupère la valeur du channel 1 2 et 3 (RGB, HSV ca dépend du format de l'image)

j'ai pas trouvé où il a changé les paramètres de l'image

Que veux tu dire par paramètre ?

edit: je ne sais pas à quoi correspond SET_VECTOR_4D, mais je pense savoir ce qui te choc. Il utilise la valeur des channels comme coordonnées, il réalise une modélisation des couleurs une sorte d'histogramme

[info_sara]

Code :

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

il récupère la valeur du channel 1 2 et 3 (RGB, HSV ca dépend du format de l'image)

mais X,Y,Z ce sont les coordonnées du pixel non?( les coordonnées c-à-d X: pour l'axe x ,Y : pour laxe Y et Z pour le z)

Que veux tu dire par paramètre ?

c-a-d où il a remplis l'image parce que normalement il faut faire un copy de l'image de frame ou quelque chose comme ça

Code :

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

1
2
3
4
5
#define SET_VECTOR_4D(vector4d, x, y, z, w)\
  CV_MAT_ELEM(*(vector4d), float, 0, 0) = ( x ) ;\
  CV_MAT_ELEM(*(vector4d), float, 1, 0) = ( y ) ;\
  CV_MAT_ELEM(*(vector4d), float, 2, 0) = ( z );\
  CV_MAT_ELEM(*(vector4d), float, 3, 0) = ( w )

ça le role de SET_VECTOR_4D

[snowpy]

mais X,Y,Z ce sont les coordonnées du pixel non?

Non, ce sont les valeurs des channels du pixel en cour.

C'est un peu comme si tu fesais un histogramme en x tu aura une couleur et tu te sers de ca comme abscisse mais physiquement ca ne représente pas une coordonnée de pixel.

autant pour moi j'avais pas vu la déclaration.

Code :

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

1
2
 
SET_VECTOR_4D(m_X, x, y, z, 1);

il ne fait que stocker les 3 channels récupéré dans une matrice pour pouvoir faire sa multiplication de matrice à la ligne suivante (il applique un filtre), il n'est pas question d'image ici. Tout ce que j'a dis avant n'été donc pas bon il ne fait que les stocker dans une matrice pour réaliser la multiplication (le pourquoi je ne sais pas )

[info_sara]

Code :

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

Non, ce sont les valeurs des channels du pixel en cour.

je pense pas que sont des valeurs de channel
parce que la multiplication doit être faite sur les coordonnées du pixel
(il multiplié les coordonnées du pixels pour connaitre la nouvelle emplacement du pixel )
par exemple

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
for(i=0; i<omega.width; i++)
   {
     u = i + omega.x;
 
     for(j=0; j<omega.height; j++)
     {
       v = j + omega.y;
 
       // Set vector X with pixel coordinates (u,v,1)
       SET_VECTOR(X, u, v);
 
       // Warp Z=W*X
       cvGEMM(W, X, 1, 0, 0, Z);
 
       // (u2,v2) - pixel coordinates in the coordinate frame of I.
       float u2, v2;
 
       // Get coordinates of warped pixel in coordinate frame of I.
       GET_VECTOR(Z, u2, v2);
 
       // Get the nearest integer pixel coords (u2i;v2i).
       int u2i = cvFloor(u2);
       int v2i = cvFloor(v2);
 
       if(u2i>=0 && u2i<pImgI->width && // check if pixel is inside I.
          v2i>=0 && v2i<pImgI->height)
       {
         pixel_count++;
...........

ici il a travaillé en (u,v)
mais dans le code du lien il a fait 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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
for(i=0; i<template_rect.width; i+=step)
    {
      int u = i + template_rect.x;
 
      for(j=0; j<template_rect.height; j+=step)
      {
        int v = j + template_rect.y;
 
        // Now we have viewport coordinates of current pixel in (u;v).
 
 
        // Get pixel 3D coordinates (x;y;z).
        float* pixel_coords = &CV_IMAGE_ELEM(pCoords, float, v, u*3);
        float x = pixel_coords[0]; 
        float y = pixel_coords[1];  
        float z = pixel_coords[2];
 
        assert(z!=0);
 
        // Set vector X with pixel 4D homogeneous coordinates (x, y, z, 1).
        SET_VECTOR_4D(m_X, x, y, z, 1);
 
        // Transform Z = W * X. 
        cvGEMM(m_W, m_X, 1, 0, 0, m_Z);
 
        // Project X = P * Z.
        cvGEMM(m_P, m_Z, 1, 0, 0, m_X);
 
        // Get normalized device coordinates of the transformed pixel.
        float Xd, Yd, Zd, Wd;
        GET_VECTOR_4D(m_X, Xd, Yd, Zd, Wd);
 
        // Convert normalized device coordinates (Xd, Yd, Zd, Wd) to window coordinates (u2;v2). 
        // We ignore Zd, because we don't need it here.
        float u2 = fFrameWidth/2.0f * (1.0f + Xd/Wd);
        float v2 = fFrameHeight/2.0f * (1.0f - Yd/Wd);
 
        // Get the nearest integer pixel coords (u2i;v2i).
        int u2i = cvFloor(u2);
        int v2i = cvFloor(v2);
 
        // Check if pixel (u2i, v2i) is inside pImgI.
        if(u2i>=0 && u2i<pImgI->width && 
          v2i>=0 && v2i<pImgI->height)
        {
          pixel_count++; // Increase count 
..............

la declaration de SET_VECTOR_4D se trouve ici
http://www.koders.com/c/fid3B035BF58....aspx?s=opencv
ma tête sera cassé et j'ai pas compris comment il a travaillé par X,Y,Z

[snowpy]

Code :

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

1
2
3
float x = pixel_coords[0]; 
        float y = pixel_coords[1];  
        float z = pixel_coords[2];

tu parles bien de ceci en x,y,z ?

oui pour la déclaration je l'ai vue après ma première réponse.

[info_sara]

Code :

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

1
2
3
float x = pixel_coords[0]; 
        float y = pixel_coords[1];  
        float z = pixel_coords[2];

oui je parle sur ces coordonnées
il a les utilisé dans la multiplication pour connaitre la nouvelle position du pixel ensuite il a fait la projection et la normalisation pour connaitre l'emplacement 2d du pixel

[snowpy]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Method 1: Using Inbuilt macro:
CV_IMAGE_ELEM( image_header, elemtype, y, x_Nc )
 
Suppose, we have 8-bit 1-channel image I (IplImage* img):
 
I(x,y) ~ CV_IMAGE_ELEM( img, uchar, y, x);
 
Suppose, we have 8-bit 3-channel image I (IplImage* img):
 
I(x,y)blue ~ CV_IMAGE_ELEM( img, uchar, y, x*3);
I(x,y)green ~ CV_IMAGE_ELEM( img, uchar, y, x*3+1);
I(x,y)red ~ CV_IMAGE_ELEM( img, uchar, y, x*3+2);

il récupère la valeur des channels

hum ou pas je cherche et je poste quand j'ai résolu

[info_sara]

mais quelle est l'utilité de récupérer les canaux de l'image ?
je sais que son objectif de multiplication est de trouvé la nouvelle position du pixel qui est (u2,v2)