Erreur avec "const"

**wilfryjules** · 22/03/2013, 23h01

Bonjour à tous!

Alors voilà j'ai une erreur avec les fameux "const" mais même après avoir lu le cours je suis incapable de la résoudre !

Voici le code, l'erreur est en rouge :

fourier_mag.cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
11


Vector<fourier_mag::Center> fourier_mag::mag_blob (Mat &img1, Mat &img2, Vector<Center> &centers) 
{
	fourier_mag::findBlobs(img1, img2, centers);

        return centers;
}

// ERREUR : impossible d'initialiser une référence de type "std::vector<cv::SimpleBlobDetector::Center, std::allocator<cv::SimpleBlobDetector::Center>> & "(non qualifié const) avec une valeur de type "const cv::Vector<cv::SimpleBlobDetector::Center>"

fourier_mag.h :

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
 
class fourier_mag : CV_EXPORTS_W SimpleBlobDetector
{
 
	public:
 
		void shiftDFT(Mat& fImage );
                Mat create_spectrum_magnitude_display(Mat& complexImg, bool rearrange);
		Mat DFT_mag(Mat& img);
 
		Mat mag_thres(Mat& mag);
 
 		Vector<Center> mag_blob (Mat &img1, Mat &img2, Vector<Center> &centers);
 
 
};
 
#endif

features2d.h :

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
48
49
50
51
52
53
54
55
56
 
 
 
class CV_EXPORTS_W SimpleBlobDetector : public FeatureDetector
{
 
public:
 
  struct CV_EXPORTS_W_SIMPLE Params
  {
      CV_WRAP Params();
      CV_PROP_RW float thresholdStep;
      CV_PROP_RW float minThreshold;
      CV_PROP_RW float maxThreshold;
      CV_PROP_RW size_t minRepeatability;
      CV_PROP_RW float minDistBetweenBlobs;
 
      CV_PROP_RW bool filterByColor;
      CV_PROP_RW uchar blobColor;
 
      CV_PROP_RW bool filterByArea;
      CV_PROP_RW float minArea, maxArea;
 
      CV_PROP_RW bool filterByCircularity;
      CV_PROP_RW float minCircularity, maxCircularity;
 
      CV_PROP_RW bool filterByInertia;
      CV_PROP_RW float minInertiaRatio, maxInertiaRatio;
 
      CV_PROP_RW bool filterByConvexity;
      CV_PROP_RW float minConvexity, maxConvexity;
 
      void read( const FileNode& fn );
      void write( FileStorage& fs ) const;
  };
 
  CV_WRAP SimpleBlobDetector(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params());
 
  virtual void read( const FileNode& fn );
  virtual void write( FileStorage& fs ) const;
 
 
protected:
 
  struct CV_EXPORTS Center
  {
      Point2d location;
      double radius;
      double confidence;
  };
 
  virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
  virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
 
  Params params;
};

blobdetector.cpp:

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
48
49
50
51
52
53
54
55
56
57
58
59
60
 
 
 
void SimpleBlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, vector<Center> &centers) const
{
	(void)image;
	centers.clear();
 
	vector < vector<Point> > contours;
	Mat tmpBinaryImage = binaryImage.clone();
	findContours(tmpBinaryImage, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
 
#ifdef DEBUG_BLOB_DETECTOR
	//  Mat keypointsImage;
	//  cvtColor( binaryImage, keypointsImage, CV_GRAY2RGB );
	//
	//  Mat contoursImage;
	//  cvtColor( binaryImage, contoursImage, CV_GRAY2RGB );
	//  drawContours( contoursImage, contours, -1, Scalar(0,255,0) );
	//  imshow("contours", contoursImage );
#endif
 
	for (size_t contourIdx = 0; contourIdx < contours.size(); contourIdx++)
	{
		Center center;
		center.confidence = 1;
		Moments moms = moments(Mat(contours[contourIdx]));
 
		if (params.filterByArea)
		{
			double area = moms.m00;
			if (area < params.minArea || area >= params.maxArea)
				continue;
		}
 
 
 
		//compute blob radius
 
		vector<double> dists;
		for (size_t pointIdx = 0; pointIdx < contours[contourIdx].size(); pointIdx++)
		{
			Point2d pt = contours[contourIdx][pointIdx];
			dists.push_back(norm(center.location - pt));
		}
		std::sort(dists.begin(), dists.end());
		center.radius = (dists[(dists.size() - 1) / 2] + dists[dists.size() / 2]) / 2.;
 
 
		centers.push_back(center);
 
#ifdef DEBUG_BLOB_DETECTOR
		//    circle( keypointsImage, center.location, 1, Scalar(0,0,255), 1 );
#endif
	}
#ifdef DEBUG_BLOB_DETECTOR
	//  imshow("bk", keypointsImage );
	//  waitKey();
#endif
}

Voilà j'espère qu'il y a assez d'éléments !

En vous remerciant !

**Ehonn** · 23/03/2013, 02h00

Bonjour
Une erreur trouvée en lisant en diagonale, la fonction Vector<fourier_mag::Center> n'a pas de return.

**Bousk** · 23/03/2013, 10h56

Bonjour,

qu'est-ce que Vector ? Mélangés à des std::vector ?
Est-ce un typedef de ce dernier ? Ou bien il existe une fonction de transformation de l'un en l'autre ?

**koala01** · 23/03/2013, 11h02

Salut,

De manière générale:
on peut transmettre un objet non constant à une fonction prend une référence constante en argument: on aura alors la certitude que la fonction appelée ne modifiera pas l'objet qui a servi de paramètre.

Par contre, on ne peut pas transmettre un objet constant à une fonction qui prend une référence non constante en argument: La fonction appelante ne serait vraiment pas contente si un de ses objets constants venait à être modifié par la fonction appelée

Le message d'erreur t'indique que tu essaye de passer un objet constant (ou une référence constante vers un objet) à une fonction qui attend une référence non constante, et que cela ne va vraiment pas, parce que, justement, la fonction appelée (mag_blob) risque de modifier la référence qu'elle reçoit (centers), vu qu'elle ne s'est pas engagée à ne pas le faire

Le problème, c'est que tu nous as donné énormément de code, sauf le principal (ou du moins, une lecture rapide ne m'a pas permis de le repérer): l'appel de ta fonction mag_blob.

Mais ce que je peux te dire, c'est que tu sembles appeler mag_blob:

Soit depuis une fonction libre qui utilise un Vector<Center> constant (ou une référence constante vers un Vector<Center>) et qui le transmet à mag_blob
Soit depuis une fonction membre constante d'une classe qui utilise en interne un Vector<Center>

Pour le reste, faudra chercher où est fait l'appel à cette fonction

**wilfryjules** · 25/03/2013, 00h24

Merci Koala pour tous ces renseignements !
Cependant même si j'ai compris le cours, pas moyen de régler ce soucis !!

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Vector<fourier_mag::Center> fourier_mag:: mag_blob (const Mat &img1, const Mat &img2, Vector<fourier_mag::Center> &centers) const
{
	// virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
	
	fourier_mag::findBlobs(img1, img2, centers); // ERREUR QUAND MÊME

	return centers;
}

fourier_mag.h

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
 
 
 
class fourier_mag : CV_EXPORTS_W SimpleBlobDetector  
{
 
	public:
 
		void shiftDFT(Mat& fImage );
                Mat create_spectrum_magnitude_display(Mat& complexImg, bool rearrange);
		Mat DFT_mag(Mat& img);
 
		Mat mag_thres(Mat& mag);
 
		Vector<Center> mag_blob (const Mat &img1, const Mat &img2, Vector<Center> &centers) const;
 
 
 
};
 
#endif

featrres2d.hpp :

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
48
49
50
51
52
53
54
55
56
57
 
 
 
class CV_EXPORTS_W SimpleBlobDetector : public FeatureDetector
{
 
public:
 
  struct CV_EXPORTS_W_SIMPLE Params
  {
      CV_WRAP Params();
      CV_PROP_RW float thresholdStep;
      CV_PROP_RW float minThreshold;
      CV_PROP_RW float maxThreshold;
      CV_PROP_RW size_t minRepeatability;
      CV_PROP_RW float minDistBetweenBlobs;
 
      CV_PROP_RW bool filterByColor;
      CV_PROP_RW uchar blobColor;
 
      CV_PROP_RW bool filterByArea;
      CV_PROP_RW float minArea, maxArea;
 
      CV_PROP_RW bool filterByCircularity;
      CV_PROP_RW float minCircularity, maxCircularity;
 
      CV_PROP_RW bool filterByInertia;
      CV_PROP_RW float minInertiaRatio, maxInertiaRatio;
 
      CV_PROP_RW bool filterByConvexity;
      CV_PROP_RW float minConvexity, maxConvexity;
 
      void read( const FileNode& fn );
      void write( FileStorage& fs ) const;
  };
 
  CV_WRAP SimpleBlobDetector(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params());
 
  virtual void read( const FileNode& fn );
  virtual void write( FileStorage& fs ) const;
 
 
protected:
 
  struct CV_EXPORTS Center
  {
      Point2d location;
      double radius;
      double confidence;
  };
 
  // fonctions constantes : elles ne modifient pas l'objet qui les appelle
  virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
  virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
 
  Params params;
};

**koala01** · 25/03/2013, 07h41

Essayes de "remonter" tous les appels fait (de manière directe ou indirecte) à fourier_mag:: mag_blobEn effet, cette fonction prend une référence non constante en argument, et le compilateur se plaint de recevoir un objet marqué comme constant.

De toutes évidence, tu devrais sans doute avoir une structure qui contient, d'un coté un objet de type fourier_mag et de l'autre le fameux vecteur, et tu essayes (sans doute) d'appeler mag_blob au départ d'une fonction constante.

Ceci dit, pourrais tu nous donner les messages qui précèdent et qui suivent l'erreur au moment de la compilation. Cela nous permettrait très certainement d'y voir beaucoup plus clair et de ne pas "partir à l'aveuglette" comme je suis occupé à le faire sur base de déductions

**Bousk** · 25/03/2013, 09h17

Il y a qqch qui me surprend.
Si l'erreur est qu'il passe une référence constante à une méthode qui prend une référence non constante, l'erreur devrait survenir sur une ligne d'appel à mag_blob et non sur la ligne à l'intérieur d'appel à find_blob ?

**koala01** · 25/03/2013, 10h45

Théoriquement, oui, mais:

De prime abord, il n'y a qu'une instruction (à part le return) dans sa fonction.

Pour peu que les différents appels qui arrivent à la fonction mag_blob fassent partie de fourier_mag, il n'est pas impossible qu'il ait une tonne d'autres erreurs avant, toutes provoquées par le passage d'une référence constante

C'est pour cela que j'aimerais avoir TOUS les messages d'erreurs avant (et surtout les premiers

)

**wilfryjules** · 25/03/2013, 12h19

Voilà les résultats de la compilation:

1>------ Début de la régénération globale*: Projet*: OpenCV, Configuration*: Debug x64 ------
1>La génération a démarré 25/03/2013 12:17:26.
1>_PrepareForClean:
1> Suppression du fichier "x64\Debug\OpenCV.lastbuildstate".
1>InitializeBuildStatus:
1> Création de "x64\Debug\OpenCV.unsuccessfulbuild", car "AlwaysCreate" a été spécifié.
1>ClCompile:
1> main.cpp
1> fourier_mag.cpp
1>..\..\..\..\..\..\..\opencv\build\include\opencv2\modules\ProjetPlaque\fourier_mag.cpp(203): error C2664: 'cv::SimpleBlobDetector::findBlobs'*: impossible de convertir le paramètre 3 de 'cv::Vector<_Tp>' en 'std::vector<_Ty> &'
1> with
1> [
1> _Tp=cv::SimpleBlobDetector::Center
1> ]
1> and
1> [
1> _Ty=cv::SimpleBlobDetector::Center
1> ]
1> blobdetector.cpp
1>..\..\..\..\..\..\..\opencv\build\include\opencv2\modules\features2d\src\blobdetector.cpp(44): warning C4067: jetons inattendus après la directive du préprocesseur - saut de ligne attendu
1> Generating Code...
1>
1>ÉCHEC de la build.
1>
1>Temps écoulé 00:00:10.34
========== Régénération globale*: 0 a réussi, 1 a échoué, 0 a été ignoré ==========

Je pense avoir réussi finalement, ça venait du "std" et du fait que j'ai écrit Vector avec une majuscule au lieu de vector sans majuscule.

En début de programme je marque :

using namespace std; afin de ne pas avoir à l'appeler tout le temps.

Si je comprends bien, j'ai utilisé le "cv:Vector" d' OpenCV (librairie d'analyse d'images) au lieu d'utiliser le "std::vector" de Visual Studio...

ça doit être un truc du genre !! J'ai remarqué que les différentes librairies d'analyse d'images (Matrox, OpenCV...) utilisent leurs propres types, je ne vois pas pourquoi ça cause des erreurs à chaque fois. Ils auraient pu se contenter de faire leurs algorithmes de traitement d'images sans utiliser leurs propres int, leurs propres vecteurs....

fourier_mag.cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13

using namespace cv;
using namespace std;
	 
std::vector<fourier_mag::Center> fourier_mag:: mag_blob (const Mat &img1, const Mat &img2, std::vector<fourier_mag::Center> &centers) const
{
	// virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
	
	fourier_mag::findBlobs(img1, img2, centers); // CA MARCHE

	return centers;
}

fourier_mag.h:

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
 
 
using namespace cv;
using namespace std;
 
class fourier_mag : CV_EXPORTS_W SimpleBlobDetector  
{
 
	public:
 
		void shiftDFT(Mat& fImage );
                Mat create_spectrum_magnitude_display(Mat& complexImg, bool rearrange);
		Mat DFT_mag(Mat& img);
 
		Mat mag_thres(Mat& mag);
 
 
		std::vector<Center> mag_blob (const Mat &img1, const Mat &img2, std::vector<Center> &centers) const;
 
 
 
};
 
REMARQUE: J'aurais pu ne pas mettre "std::" dans mon code, car au début j'ai mis "using namespace std". Cependant je ne sais pas si c'est une bonne idée de le mettre, car au final on ne sait plus à quel outil appartient la variable (OpenCv ou Visual studio...) ...
 
J'espère que mon raisonnement est correct, j'attends que vous le validiez pour pouvoir cocher "RESOLU"  :ccool:
 
Merci pour votre aide !! Je suis assez paresseux j'aurais pu lire la compilation tout seul ! ;)

**Bousk** · 25/03/2013, 13h40

Cf mon premier message alors

Envoyé par Bousk

qu'est-ce que Vector ? Mélangés à des std::vector ?
Est-ce un typedef de ce dernier ? Ou bien il existe une fonction de transformation de l'un en l'autre ?

Le message (très clair d'ailleurs) indique qu'il ne sait pas transformer un cv::Vector en std::vector.
Ce qui n'a rien à voir avec une quelconque constance.

Erreur avec "const"

C++

Partager

Partager