Problème d'exécution avec cvIntegral()

Version imprimable

1 pièce(s) jointe(s)

Bonjour tout le monde,

Je suis en train d'essayer d'utiliser la méthode cvIntegral de OpenCV pour obtenir la somme des valeurs des pixels d'une image.

Seulement, je rencontre un problème avec OpenCV au moment de l'exécution, bien qu'il n'y ait aucune erreur :?

Voici mon petit bout de code :
Code:

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 // Déclaration d'un pointeur sur IplImage : IplImage *image; // Chargement de l'image depuis un fichier : image = cvLoadImage("Images/test6.bmp"); // Création d'une fenêtre dont la taille s'adapte à ce qu'elle contient : cvNamedWindow("Fenêtre", CV_WINDOW_AUTOSIZE); // Caractéristiques de l'image : int h = image->height; int w = image->width; // Déclaration de deux CvMat pour les calculs : CvMat* sum = cvCreateMat(h, w, CV_32F); CvMat* sqsum = cvCreateMat(h, w, CV_32F); // Calcul de sum et sqsum à partir de l'image : cvIntegral(image, sum, sqsum); // Résultats : cout << "***** SOMME *****"; cout << endl; for(int y=0;y<10;y++) { for(int x=0;x<10;x++) { cout << cvmGet(sum, y, x); } cout << endl; } // ...
Voici ci-dessous l'erreur que j'obtiens. Cependant, si je mets en commentaire la ligne avec l'utilisation de la méthode cvIntegral (ligne 94 sur le screen), le programme fonctionne ...

Auriez-vous une idée ?

Merci ;)

17/03/2011, 20h51
nihao

Bonjour,

Dans la doc ils disent :

Citation:

void cvIntegral( const CvArr* I, CvArr* S, CvArr* Sq=0, CvArr* T=0 );

I
The source image, w×h, single-channel, 8-bit, or floating-point (32f or 64f).
S
The sum image, w+1×h+1, single-channel, 32-bit integer or double precision floating-point (64f).
Sq
The square sum image, w+1×h+1, single-channel, double precision floating-point (64f).
T
The tilted sum image (sum of rotated by 45° image), w+1×h+1, single-channel, the same data type as sum.

The function cvIntegral calculates one or more integral images for the source image as following:

S(X,Y)=sumx<X,y<YI(x,y)

Sq(X,Y)=sumx<X,y<YI(x,y)2

T(X,Y)=sumy<Y,abs(x-X)<yI(x,y)

After that the images are calculated, they can be used to calculate sums of pixels over an arbitrary rectangles, for example:

sumx1<=x<x2,y1<=y<y2I(x,y)=S(x2,y2)-S(x1,y2)-S(x2,y1)+S(x1,x1)

It makes possible to do a fast blurring or fast block correlation with variable window size etc.

Donc :

1 - Le "Images/test6.bmp" doit être en niveau de gris (je crois que par défaut opencv charge les images couleur sur 3 canaux)

2 - il faut w+1 x h+1 pour la taille de sum et sqsum

Cordialement

1 pièce(s) jointe(s)

Tout d'abord, merci nihao pour ton aide ;)

Citation:

Envoyé par nihao

2 - il faut w+1 x h+1 pour la taille de sum et sqsum

Je ne comprends pas bien pourquoi la taille de sum et sqsum doit être plus grande que l'image :?

Finalement, j'ai donc utilisé ceci :

Code:

IplImage *image_nvg = cvCreateImage(cvGetSize(image), image->depth, 1);

Afin d'être sûr d'avoir une image en niveaux de gris.

Maintenant, mon code est le suivant :

Code:

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
// Déclaration d'un pointeur sur IplImage :
    IplImage *image = cvLoadImage("Images/test6.bmp");
    IplImage *image_nvg = cvCreateImage(cvGetSize(image), image->depth, 1);
 
    // Création d'une fenêtre dont la taille s'adapte à ce qu'elle contient :
    cvNamedWindow("Fenêtre", CV_WINDOW_AUTOSIZE);
 
    // Caractéristiques de l'image :
    int h = image->height;
    int w = image->width;
 
    // Déclaration de deux CvMat pour les calculs :
    CvMat* sum = cvCreateMat(h+1, w+1, CV_32F);
    CvMat* sqsum = cvCreateMat(h+1, w+1, CV_32F);
 
    // Calcul de sum et sqsum à partir de l'image :
    cvIntegral(image_nvg, sum, sqsum);
 
    // Résultats :
    cout << "***** SOMME *****";
    cout << endl;
 
    for(int y=0;y<10;y++)
    {
        for(int x=0;x<10;x++)
        {
            cout << cvmGet(sum, y, x);
        }
        cout << endl;
    }
 
    // Affichage de l'image dans la fenêtre ci-dessus :
    cvShowImage("Fenêtre", image_nvg);
 
    // On attend que l'utilisateur appuie sur une touche :
    cvWaitKey(0);
 
    //Destruction de la fenêtre.
    cvDestroyWindow("Fenêtre");
 
    //Libération des IplImage :
    cvReleaseImage(&image);
    cvReleaseImage(&image_nvg);
 
    return 0;
}

Mais toujours le même problème :?

D'autres idées ? Je continue pour ma part de chercher mais je ne vois pas vraiment d'où cela peut provenir..

Merci!

Bonjour, ou plutot bonne nuit...
Possible qu"il y ai un problème avec cvIntegral.
Les routines de OpenSurf en ont besoin mais se serve d'une routine "maison"

Code:

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
/*********************************************************** 
*  --- OpenSURF ---                                       *
*  This library is distributed under the GNU GPL. Please   *
*  use the contact form at http://www.chrisevansdev.com    *
*  for more information.                                   *
*                                                          *
*  C. Evans, Research Into Robust Visual Features,         *
*  MSc University of Bristol, 2008.                        *
*                                                          *
************************************************************/
 
#include "utils.h"
 
#include "integral.h"
 
//! Computes the integral image of image img.  Assumes source image to be a 
//! 32-bit floating point.  Returns IplImage of 32-bit float form.
IplImage *Integral(IplImage *source)
{
  // convert the image to single channel 32f
  IplImage *img = getGray(source);
  IplImage *int_img = cvCreateImage(cvGetSize(img), IPL_DEPTH_32F, 1);
 
  // set up variables for data access
  int height = img->height;
  int width = img->width;
  int step = img->widthStep/sizeof(float);
  float *data   = (float *) img->imageData;  
  float *i_data = (float *) int_img->imageData;  
 
  // first row only
  float rs = 0.0f;
  for(int j=0; j<width; j++) 
  {
    rs += data[j]; 
    i_data[j] = rs;
  }
 
  // remaining cells are sum above and to the left
  for(int i=1; i<height; ++i) 
  {
    rs = 0.0f;
    for(int j=0; j<width; ++j) 
    {
      rs += data[i*step+j]; 
      i_data[i*step+j] = rs + i_data[(i-1)*step+j];
    }
  }
 
  // release the gray image
  cvReleaseImage(&img);
 
  // return the integral image
  return int_img;
}

(le getGray c'est cvCvtColor(imgsrc,imgdst,CV_BGR2GRAY))

A voir...

2 pièce(s) jointe(s)

Merci nihao pour ta réponse ;)

Citation:

Envoyé par nihao

Possible qu"il y ai un problème avec cvIntegral.

En fait, je voulais utiliser cvIntegral pour ne pas avoir à recoder la méthode de sommation des valeurs des pixels de l'image. La méthode en elle-même fonctionnait toutefois correctement mais seulement si la résolution de l'image était pas très grande. Je m'explique :

Lorsque l'image avait une résolution strictement inférieure à 420x420, le programme fonctionnait correctement et j'avais le screen 1 (résolution 415x415 par exemple).

Cependant, si la résolution dépassait 420x420 ou l'égalait, le programme ne fonctionnait plus à l'exécution (même s'il n'y avait aucune erreur à la compilation) et je me retrouvais avec le screen 2 (résolution 500x500 par exemple) (la fenêtre avec l'image s'ouvre tout en gris et se referme aussitôt donc impossible de la prendre en capture d'écran).

Voici mon code avec la méthode de sommation qui semble retourner les bonnes valeurs quand le programme fonctionne (j'affiche les premières valeurs des cvMat pour vérifier dans le main, comme vous pouvez le voir sur le screen 1) et le main.

Méthode sommation :
Code:

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 void sommeImage(IplImage* image, int h, int w, CvMat* sum, CvMat* sqsum) { cvmSet(sum, 0, 0, cvGet2D(image, 0, 0).val[0]); cvmSet(sqsum, 0, 0, cvGet2D(image, 0, 0).val[0]*cvGet2D(image, 0, 0).val[0]); // Remplissage de la première colonne : for (int y=1;y<h;y++) { cvmSet(sum, y, 0, cvGet2D(image, y, 0).val[0]+cvmGet(sum, y-1, 0)); cvmSet(sqsum, y, 0, cvGet2D(image, y, 0).val[0]*cvGet2D(image, y, 0).val[0]+cvmGet(sqsum, y-1, 0)); } // Remplissage de la première ligne : for (int x=1;x<w;x++) { cvmSet(sum, 0, x, cvGet2D(image, 0, x).val[0]+cvmGet(sum, 0, x-1)); cvmSet(sqsum, 0, x, cvGet2D(image, 0, x).val[0] * cvGet2D(image, 0, x).val[0]+cvmGet(sqsum, 0, x-1)); } // Calcul sur les autres pixels : for (int y=1;y<h;y++) { for (int x=1;x<w;x++) { cvmSet(sum, y, x, cvGet2D(image, y, x).val[0]+cvmGet(sum, y, x-1)+cvmGet(sum, y-1, x)-cvmGet(sum, y-1, x-1)); cvmSet(sqsum, y, x, cvGet2D(image, y, x).val[0]*cvGet2D(image, y, x).val[0]+cvmGet(sqsum, y, x-1)+cvmGet(sqsum, y-1, x)-cvmGet(sqsum, y-1, x-1)); } } }
Main :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 int main() { // Déclaration d'un pointeur sur IplImage : IplImage *image = cvLoadImage("Images/test6.bmp"); // IplImage *image_nvg = cvCreateImage(cvGetSize(image), image->depth, 1); // Création d'une fenêtre dont la taille s'adapte à ce qu'elle contient : cvNamedWindow("Fenêtre", CV_WINDOW_AUTOSIZE); // Caractéristiques de l'image : int h = image->height; int w = image->width; // Déclaration de deux CvMat pour les calculs : CvMat* sum = cvCreateMat(h, w, CV_32FC1); CvMat* sqsum = cvCreateMat(h, w, CV_32FC1); // Calcul de sum et sqsum à partir de l'image : sommeImage(image, h, w, sum, sqsum); // [...]
Auriez-vous une idée ?

Merci ;)

Bonjour,

Le code suivant fonctionne chez moi (remarque bien le cvCvtColor, h+1, w+1 et CV_64FC1 pour sqsum)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main()
{
    // Déclaration d'un pointeur sur IplImage :
    IplImage *image = cvLoadImage("Images/test6.bmp");
    IplImage *image_nvg = cvCreateImage(cvGetSize(image),8, 1);
    cvCvtColor(image,image_nvg,CV_BGR2GRAY);
 
    // Création d'une fenêtre dont la taille s'adapte à ce qu'elle contient :
    cvNamedWindow("Fenêtre", CV_WINDOW_AUTOSIZE);
 
    // Caractéristiques de l'image :
    int h = image->height;
    int w = image->width;
 
    // Déclaration de deux CvMat pour les calculs :
    CvMat* sum = cvCreateMat(h+1, w+1, CV_32FC1);
    //CvMat* sqsum = cvCreateMat(h, w, CV_32FC1);
    CvMat* sqsum = cvCreateMat(h+1, w+1, CV_64FC1);
 
    // Calcul de sum et sqsum à partir de l'image :
    cvIntegral(image_nvg, sum, sqsum);
 
// [...]

Ca marche aussi avec une image couleur. Les 3 canaux seront traités séparément. Il faut mettre CV_XXC3 mais ton cvmGet dans la suite du prog ne fonctionnera pas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main()
{
    // Déclaration d'un pointeur sur IplImage :
    IplImage *image = cvLoadImage("Images/test6.bmp");
    //IplImage *image_nvg = cvCreateImage(cvGetSize(image),8, 1);
    //cvCvtColor(image,image_nvg,CV_BGR2GRAY);
 
    // Création d'une fenêtre dont la taille s'adapte à ce qu'elle contient :
    cvNamedWindow("Fenêtre", CV_WINDOW_AUTOSIZE);
 
    // Caractéristiques de l'image :
    int h = image->height;
    int w = image->width;
 
    // Déclaration de deux CvMat pour les calculs :
    CvMat* sum = cvCreateMat(h+1, w+1, CV_32FC3);
    //CvMat* sqsum = cvCreateMat(h, w, CV_32FC1);
    CvMat* sqsum = cvCreateMat(h+1, w+1, CV_64FC3);
 
    // Calcul de sum et sqsum à partir de l'image :
    cvIntegral(image, sum, sqsum);
 
// [...]

Voila.

Cordialement

20/03/2011, 12h28
betsprite

Bonjour,

Merci bihao pour ton aide, le code fonctionne correctement cette fois :)

Citation:

Envoyé par nihao

Le code suivant fonctionne chez moi (remarque bien le cvCvtColor, h+1, w+1 et CV_64FC1 pour sqsum)

Cependant, je ne comprends pas bien ce que fait la méthode cvCvtColor et pourquoi elle est indispensable ici et pourquoi il faut pour sqsum CV_64FC1 pour le format des données stockées.

Après j'imagine que le h+1 et w+1 au lieu de h et w, c'est arbitraire non ?

Merci ;)
07/11/2011, 16h37
visechelle

Nécessité du h+1 et w+1

Un peu tard mais au cas où quelqu'un chercherait l'info, le h+1 et le w+1 sont nécessaires (cf. doc OpenCV, Learning OpenCV page 183). En fait la première colonne et la première ligne sont remplies de zéros pour permettre un calcul efficace des sommes.
Pour plus d'info voir : http://www.aishack.in/2010/07/integral-images/

Cordialement,

Paul