Variable qui se remet à 0 TOUTE SEULE

**wilfryjules** · 31/01/2014, 18h55

Bonjour à tous,

Alors voilà, je fais du traitement d'images en c++, et j'ai besoin de chronométrer le temps, afin de stopper le programme si la détection n'a pas abouti.

A chaque chargement d'une image à traiter, j'appelle cette première fonction d'initialisation pour récupérer le temps de départ t_start :

Code :

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

1
2
3
4
 
// square_detect.h
 
int t_start, t_type_start;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
square_detect.cpp
 
// Initialisation: 
 void  square_detect:: init_detection()
 {
     t_start = clock();  
     cout << "CLOCK_START = " << t_start << "\n"; // affiche 136 922
     cout << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << "\n"; // affiche 1000
 
 }

Avec les 10 premières images, ça marche, et lorsque j'atteins une certaine image (la 15eme), le compteur t_start se remet à 0 entre l'initialisation et ce bout de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
if((int)((clock()-t_start)/CLOCKS_PER_SEC) > 60)
{
     cout << "TEMPS ECOULE 1\n";
     cout << "CLOCK = " << (int)clock() << "\n"; // 138 212
     cout << "CLOCK_START = " << t_start << "\n"; // AFFICHE 0 (POURQUOI ???, je ne l'ai pas réinitialisé !!!)
     cout << "CLOCK - CLOCK_START= " << (int)(clock()-t_start) << "\n"; //  affiche 138 216 
     cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n"; // affiche 138  secondes
     goto STOP; // du coup mon programme s'arrête au bout de 2 secondes !
}

J'ai placé un cout << "CLOCK_START = " << t_start << "\n"; à divers endroits du programme, et il affiche 0 très rapidement !! Pourtant je ne l'initialise qu'au début avec clock() et ensuite je n'y touche plus !! Conflit d'adresses vous pensez ??

Je suis donc formel : J'AI UNE VARIABLE QUI SE REMET A ZERO TOUTE SEULE !!!!!

**bertry** · 31/01/2014, 22h31

Salut,
La fonction clock() renvoie un clock_t. Es-tu certain que clock_t est un alias pour un int?

**wilfryjules** · 01/02/2014, 16h53

Salut,

oui je sais, au début j'avais déclarer :

Code :

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

1
2
 
clock_t t_start;

mais rien n'y change. La variable se remet quand même à 0 toute seule !

**JolyLoic** · 01/02/2014, 17h29

Probablement un écrasement mémoire quelque-part.... Avec ton debugger, tu dois pouvoir mettre en place un breakpoint quand une certaine adresse mémoire est modifiée. C'est l'idéal pour debugger ce genre de soucis.

**wilfryjules** · 01/02/2014, 18h26

Merci,

Apparemment, l'exécution se comporte différemment selon l'ordre de déclaration des variables dans le .h !

J'ai donc apparemment résolu mon problème en changeant la ligne de déclaration de cette variable dans le .h

Mais pourquoi diable cela influe-t-il sur l'exécution ?

**Bousk** · 01/02/2014, 18h38

Ca indique de plus en plus un dépassement mémoire.

**wilfryjules** · 01/02/2014, 19h30

C'est souvent le cas en analyse d'image, ça demande énormément de calculs au pc, il est débordé et fait n'importe quoi !

En tout cas j'ai remis de l'ordre dans mon .h, et ça marche relativement bien, ma variable reste stable !

**JolyLoic** · 01/02/2014, 20h13

Le PC ne fait pas n'importe quoi si on ne lui demande pas de faire n'importe quoi, que ce soit en traitement d'images ou dans n'importe quel autre domaine d'application.

Changer l'ordre des variables dans ton header va probablement faire qu'au lieu d'avoir cette variable écrasée, une autre le sera. Tu as remplacé un bug identifié et reproductible (et donc aisé à localiser) par un bug que tu ne connais pas encore, qui si ça se trouve ne se manifestera jamais sauf en faisant planter ton programme lors de la grosse démo, ou pire, produira en sortie des données erronées.

Si j'étais toi, après que ce changement d'ordre ait donné un indice de plus qu'il y a bien quelque-part un dépassement de données, je reviendrais à l'ordre initial, et je chercherais sérieusement le bug dans mon code.

**koala01** · 02/02/2014, 09h10

Salut,

Je ne peux que plussoter loic : Tu n'as absolument pas résolu ton problème, tu l'as simplement déplacé

J'ai déjà peur quand je vois ton code, surtout la ligne

Code :

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

     goto STOP; // du coup mon programme s'arrête au bout de 2 secondes !

Si tu avais la chance de travailler dans mon équipe, tu passerais, dans le meilleur des cas, par la fenêtre du huitième étage

Je sais que l'instruction goto existe en C++ tout comme dans de nombreux langages, mais les développeurs de tous les langages mettent très largement en garde contre son utilisation. Dans le meilleur des cas, cela tend à transformer ton code en un monstrueux tas de spagetti dans lequel il est impossible de se retrouver à l'exécution, dans le pire des cas (qui arrive très régulièrement en C++), cela t'empêche de profiter de mécanismes particulièrement utiles comme les exceptions ou le RAII.

Pourrais tu déjà nous donner l'ensemble du code de la fonction dans laquelle tu as ce fameux test avec ton horrible goto STOP, car il y a fort à parier (du moins, avec un peu de chance) que le problème se situe dedans?

Et j'en profiterais volontiers pour t'indiquer la manière de te passer du goto

**jblecanard** · 03/02/2014, 10h59

Salut

Rien à rajouter sur les interventions de Koala01 et JolyLoïc. Pour trouver les impacts de ton bug, que tu as sûrement toujours mais qui du coup est caché avec ta modification, tu peux utiliser un outil de contrôle de la mémoire comme valgrind, il va bien te montrer où est-ce que ton code fait de sales choses.

**wilfryjules** · 10/02/2014, 13h02

merci pour vos réponses,

J'ai donc bien compris, le bug est sûrement toujours là, caché...

Concernant les goto, je les ai utilisés car je veux arrêter mon programme au bout d'un certain temps, si l'analyse d'image n'est toujours pas convaincante. J'ai pas mal de boucles... j'aurais peut être pu utiliser les break mais ça ne marche pas très bien j'ai l'impression. Après si vous avez une autre solution, j'accepte.

Je peux pas trop vous montrer mon code, c'est assez perso.

**koala01** · 10/02/2014, 15h59

Comme je te l'ai demandé plus haut :

Envoyé par koala01

Pourrais tu déjà nous donner l'ensemble du code de la fonction dans laquelle tu as ce fameux test avec ton horrible goto STOP, car il y a fort à parier (du moins, avec un peu de chance) que le problème se situe dedans?

Et j'en profiterais volontiers pour t'indiquer la manière de te passer du goto

Je peux pas trop vous montrer mon code, c'est assez perso.

Oui, mais, ho! Tu viens nous demander de l'aide sur une erreur que tu crois avoir corrigée, mais qui ne demande qu'à te claquer à la figure.

On ne te demande pas non plus de baisser ton pantalon devant nous! On te demande juste de nous montrer un minimum de code qui nous permette de nous faire une idée un tant soit peu précise de l'ampleur du problème.

Outre le problème du goto (qui n'est finalement qu'un détail), je serais très intéressé par le fait de voir de quelle manière tu gères tes images, car je suis presque persuadé que le gros du problème vient de là

**jblecanard** · 11/02/2014, 01h18

Salut

Envoyé par koala01

Outre le problème du goto (qui n'est finalement qu'un détail), je serais très intéressé par le fait de voir de quelle manière tu gères tes images, car je suis presque persuadé que le gros du problème vient de là

Je suis d'accord !

J'ajouterais qu'il semble que tu n'aies pas appliqué les deux conseils qui t'ont été donnés, à savoir placer un breakpoint sur l'adresse de la variable et passer un coup de valgrind sur ton exécutable. Ils sont pourtant simples à mettre en oeuvre. Si ton programme mérite tellement d'être caché des regards, peut-être mérite-t-il aussi un minimum de soin

.

**wilfryjules** · 11/02/2014, 16h48

Merci c'est très gentil de votre part, je vous montre donc mon main:

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

int main(int argc, char** argv)
{
		
	vector <string> names;
	int Nb = 68;
	string png = ".png";
	string pic = "pic";
	string total; 	 
	
        square_detect sq;

	
 	char chh[255];

	for(int i=0; i<Nb; i++)
	{
		sprintf(chh, "%d", i+1);
		total = pic + chh + png;
		names.push_back(total);
	}
	
	namedWindow("square_detection", 1 );

	vector<vector<Point> > squares;
		   
	for(int i=16; i<Nb ; i++ )
	{
	    cvDestroyAllWindows();
	    Mat image = imread(names.at(i), 1);

		if( image.empty() )
	    {
	        cout << "Couldn't load " << names[i] << endl; 
	        continue;
	    }

		
		IplImage* iplImage = &image.operator IplImage();
			 		 
		// declare a destination IplImage object with correct size, depth and channels
		IplImage *imageResize = cvCreateImage (cvSize (500 , 400), iplImage->depth, iplImage->nChannels);

		//use cvResize to resize source to a destination image
		cvResize(iplImage, imageResize);
		
		Mat imgMatResize(imageResize); 					
	 
	    sq.findSquares(imgMatResize, squares, 0); // A chaque nouvelle image capturée, je rentre dans cette fonction, qui appelle d'autres fonctions de filtrage de la même classe (square_detect). La variable globale t_start, initialisé à 0 en tête de cette fonction, se remettait à 0 toute seule dans cette même fonction, autrement dit pour la même image. 
		 
	    sq.drawSquares(imgMatResize, squares);
	
	    int c = waitKey();
	        
		 
	}

Je fais un logiciel de reconnaissance automatique de plaques d'immatriculations par analyse d'image, ça marche plutôt bien alors je tiens à garder mon code.

Voici l'architecture de ma fonction, si vous pouvez m'indiquer comment me passer des goto (je suis débutant) :

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
 
 
 
 
/* returns sequence of squares detected on the image. The sequence is stored in the specified memory storage */
Mat square_detect::findSquares(const Mat &image, vector<vector<Point>>& squares, int mode)
{
	cout << "\n\n\n\n\n\n\n\n\n\n\n\nON DOIT LANCER L'INITIALISATION ICI: \n";
	init_detection(); 
 
    START:
 
	t_start = clock();
 
	cout << "CLOCK_START = " << t_start << "\n"; // INITIALISATION DE T_START
	cout << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << "\n";
	cout << "CLOCK_START = " << t_start << "\n";
 
 
	// PLUSIEURS BOULES DE TRAITEMENTS, FILTRAGES...... JE TIENS A GARDER CA PERSO
 
 
												if(flag_detection_plaque)
												{
													cout << "TERMINE\n";
													goto STOP3;
 
												}
 
												cout << "CLOCK_START = " << t_start << "\n";
 
												if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
												{
													cout << "TEMPS ECOULE 1\n";
													cout << "CLOCK = " << (int)clock() << "\n";
													cout << "CLOCK_START = " << t_start << "\n";
													cout << "CLOCK - CLOCK_START= " << (int)(clock()-t_start) << "\n";
													cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
													nbre_temps_max++;
													goto STOP1;
												}
 
											} // if(text.size()>3)
 
										} // good processing  
 
										if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
										{
											cout << "TEMPS ECOULE 2\n";
											cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
											nbre_temps_max++;
											goto STOP1;
										}
 
									} // if tab_null[m] == false 
 
									if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
									{
										cout << "TEMPS ECOULE 3\n";
										cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
										nbre_temps_max++;
										goto STOP1;
									}
 
								} // for(int m=0; m<5; m++), plusieurs seuils  
 
								if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
								{
									cout << "TEMPS ECOULE 4\n";
									cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
									nbre_temps_max++;
									goto STOP1;
								}
 
							} // for(int cpl=0; cpl<2; cpl++)  
 
							if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
							{
								cout << "TEMPS ECOULE 5\n";
								cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
								nbre_temps_max++;
								goto STOP1;
							}
 
						} //  
 
						if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
						{
							cout << "TEMPS ECOULE 6\n";
							cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
							nbre_temps_max++;
							goto STOP1;
						}
					} //for(int s=0; s < squares.size(); s++) on étudie tous les rectangles détectés
 
					if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
					{
						cout << "TEMPS ECOULE 7\n";
						cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
						nbre_temps_max++;
						goto STOP1;
					}
 
				} //if(approxCurve.size() == 4 && fabs(contourArea(Mat(approxCurve))) > 300.....)
 
				if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
				{
					cout << "TEMPS ECOULE 8\n";
					cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
					nbre_temps_max++;
					goto STOP1;
				}
 
			}// for( size_t sizeT = 0; sizeT < contours.size(); sizeT ++ )
 
			if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
			{
				cout << "TEMPS ECOULE 9\n";
				cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
				nbre_temps_max++;
				goto STOP1;
			}
 
		} // for(int l=0; l<N; l++)
 
		if((int)((clock()-t_start)/CLOCKS_PER_SEC) > temps_max_detection)
		{
			cout << "TEMPS ECOULE 10\n";
			cout << "TEMPS = " << (int)((clock()-t_start)/CLOCKS_PER_SEC) << " secondes\n";
			nbre_temps_max++;
			goto STOP1;
		}
 
	}//  for( int c = 0; c < 3; c++ ) for every channel
 
    STOP1:
 
	if(nbre_temps_max==1)
	{
		flag_color = true; // JE RELANCE TOUTE L'ANALYSE AVEC LA MÊME IMAGE, EN TENANT COMPTE CETTE FOIS D'UN NOUVEAU PARAMETRE, LA COULEUR
		goto START;
	}
 
	STOP3:
	return plaque;
}

**koala01** · 11/02/2014, 17h44

Houlà!!! Il y a encore plus la place pour le progres que ce que je ne craignais

Je ne comprends déjà pas trop pourquoi tu crées 68 noms de fichiers (pourquoi 68 et pas 70 ou 100 ou...

) mais que tu n'utilises que 52. Pourquoi te faire ch... à créer les noms de fichier numérotés de 1 à 17 inclus si c'est pour ne pas les utiliser

Ensuite, un std;;vector<std::vector<Point>>, pour représenter une image, c'est plutôt moyen-moyen

. Cela se justifie dans certaines circonstances quand il est possible que toutes les lignes ne fassent pas la meme taille, mais, ici, on parle a priori d'image et, jusqu'à preuve du contraire, chaque ligne de l'image sera composée du même nombre de données. (Au passage, avoir nommé une classe qui est sensée représenter (la couleur

d')un pixel dénote un très mauvais choix de nom

).

Autrement dit, pour une image qui est composée de L lignes de C points, tu sais d'office qu'il te faudra maintenir en mémoire un total de L*C points. Pourquoi ne pas "linéariser" ces données dans un tableau à une seule dimension

Si tu sais que chaque ligne est composée de MaxColonne colonnes, tu peux accéder facilement à n'importe quel point de n'importe quel ligne avec la formule point_recherché = numero_de_ligne * MaxColonne + numero_de_colonne. Cela facilite énormément la tâche, et il est même possible que tu gagnes en performances

Arrivons en à la boucle que je remet ici, essentiellement pour la garder sous les yeux

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
	for(int i=16; i<Nb ; i++ )
	{
	    cvDestroyAllWindows();
	    Mat image = imread(names.at(i), 1);
 
		if( image.empty() )
	    {
	        cout << "Couldn't load " << names[i] << endl; 
	        continue;
	    }
 
 
		IplImage* iplImage = &image.operator IplImage();
 
		// declare a destination IplImage object with correct size, depth and channels
		IplImage *imageResize = cvCreateImage (cvSize (500 , 400), iplImage->depth, iplImage->nChannels);
 
		//use cvResize to resize source to a destination image
		cvResize(iplImage, imageResize);
 
		Mat imgMatResize(imageResize); 					
 
	    sq.findSquares(imgMatResize, squares, 0); // A chaque nouvelle image capturée, je rentre dans cette fonction, qui appelle d'autres fonctions de filtrage de la même classe (square_detect). La variable globale t_start, initialisé à 0 en tête de cette fonction, se remettait à 0 toute seule dans cette même fonction, autrement dit pour la même image. 
 
	    sq.drawSquares(imgMatResize, squares);
 
	    int c = waitKey();
 
 
	}

Si je me fie à son nom, la fonction cvDestroyAllWindows(); est visiblement sensée détruire toutes les fenêtres. Mais je ne peux m'empêcher de me demander "quelle fenêtre

". je ne connais pas trop openCV, mais je ne vois aucune création de fenêtre dans la boucle (ni avant). Je vois qu'on crée à chaque fois une image, qu'on manipule cette image, mais de fenêtre, il n'est pas question

.
Vient ensuite, la ligne Mat image = imread(names.at(i), 1);. Elle n'est pas fausse en soi, mais bon, comme nous avons la certitude que i sera toujours un index valide dans names, pourquoi ne pas utiliser l'opérateur crochet :question; Mat image = imread(names[i], 1); serait tout aussi juste

Au passage, j'insiste une fois encore sur l'importance capitale qu'il y a à choisir des noms explicites pour tes types, tes fonctions et tes variables. Je me doute que Mat est visiblement une matrice (laisse moi deviner: un horrible truc qui maintient un Point ** ou un std::vector<std::vector<>> en interne

) et que imread est une fonction qui va lire l'image. Mais ne trouves tu pas que le code serait beaucoup plus lisible, y compris pour toi d'ici trois mois, s'il prenait la forme de PointMatrice image = readImage(ames[i], 1);. En plus, j'ai beau me creuser la cervelle, je n'ai aucune idée de ce à quoi pourrait bien servir le 1 transmis sous la forme d'une valeur magique à la fonction

Est-il seulement utile

Puis vient la ligne qui, à mon sens, a de très fortes chances de faire tout foirer:

Code :

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

IplImage* iplImage = &image.operator IplImage();

Déclarer un pointeur à qui l'on donne l'adresse du résultat d'une fonction est souvent une très mauvaise idée. Et l'utilisation de operator() ne me semble vraiment pas être particulièrement judicieuse

Je serais très très de voir la "tronche" de ta classe Mat

IplImage *imageResize = cvCreateImage (cvSize (500 , 400), iplImage->depth, iplImage->nChannels); Et voici sans doute l'endroit où tout se joue : A priori, iplImage est un pointeur qui pointe sur une variable temporaire qui a été détruite la valeur de nChannels n'est donc absolument pas garantie

Les deux lignes suivantes souffrent du même problème

Code :

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

1
2
3
		cvResize(iplImage, imageResize);
 
		Mat imgMatResize(imageResize);

Enfin, pour les lignes

Code :

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

1
2
3
4
 
	    sq.findSquares(imgMatResize, squares, 0); // A chaque nouvelle image capturée, je rentre dans cette fonction, qui appelle d'autres fonctions de filtrage de la même classe (square_detect). La variable globale t_start, initialisé à 0 en tête de cette fonction, se remettait à 0 toute seule dans cette même fonction, autrement dit pour la même image. 
 
	    sq.drawSquares(imgMatResize, squares);

je ne dirai qu'une chose : es tu sur que squares est correctement vidé par la fonction findSquares

Car, tant que l'image chargée en i est plus petite que l'image chargée en i-1, cela ne posera pas de problème. Mais si l'image chargée en i est plus petite que l'image chargée en i-1, tu risques quelques désagréments majeurs parce que tu risque d'avoir "des restes de l'image précédante"

Il semblerait que la solution soit "ailleurs" comme dirait l'agent mulder. Mais les quelques de code que tu montre ne sont vraiment pas un modèle du genre en terme de qualité et de sécurité

Invité · 11/02/2014, 22h45

Bonsoir,

À noter que les fonctions OpenCV du style cvQuelqueChose font partie de l'interface C et non C++, de même que le type IplImage.
En C++, on utilisera les fonctions du namespace cv:: et la classe cv::Mat.

**wilfryjules** · 11/02/2014, 23h05

Merci Koala pour toutes tes réponses, c'est vrai que je suis un peu bourrin, j'aurais peut être du chercher à comprendre d'où venait l'erreur de cette remise à 0 de variable...

Je pense qu'il est trop tard dorénavant... j'ai plus de 2500 lignes de codes dans la même classe.

Sinon pour répondre à tes questions:

- je ne créé pas 75 noms d'images pour rien, c'est juste que je change régulièrement le main pour tester uniquement les plaques d'immatriculations qui m'intéressent
- vector<std::vector<Point>> ne représente pas une image, mais une "courbe polynomiale fermée".
- cvDestroyAllWindows(),, j'avais mis ça par sécurité, ça sert sûrement à rien
- names.at(i) ou names[i], oui c'est vrai, pour un vecteur ça veut dire la même chose
- Mat image, "Mat" est spécifique à OpenCv je crois, c'est bel et bien le meilleur support pour traiter les images, avec IplImage, faut jongler avec les 2
- IplImage* iplImage = &image.operator IplImage(); à mon avis j'ai recopié ça quelque part...

Pour la suite je pense que tu as raison, j'ai rajouté un :

squares.clear();

juste avant d'appeler ma fonction findSquares !

Sinon mon code fonctionne plutôt bien pour l'instant !

Pour répondre à Jérome , je suis obligé d'utiliser IplImage car avec Mat on ne peut pas tout faire, on est forcé de jongler avec les 2. Après je ne fais pas non plus un logiciel super critique pour Airbus ! j'aime la rigueur, mais pas trop!

**jblecanard** · 12/02/2014, 00h34

Salut

Envoyé par wilfryjules

Je pense qu'il est trop tard dorénavant... !

Sûrement pas. Les fuites de mémoires et conflits d'adressage sont des erreurs courantes, surtout sur un code qui grossit. Les outils sont là pour aider le programmeur à les surveiller.

Envoyé par wilfryjules

je change régulièrement le main pour tester uniquement les plaques d'immatriculations qui m'intéressent

Une bonne manière de faire celà est de passer des arguments sur la ligne de commande.

Envoyé par wilfryjules

names.at(i) ou names[i], oui c'est vrai, pour un vecteur ça veut dire la même chose

Puisqu'on parle de traitement d'image, il est utile de préciser que at est plus coûteux en exécution que [] et qui si on a besoin de performances, il est plus efficace d'utiliser un algo propre avec []. Bien ŝur, ça n'a d'impact qui si on traite une quantité conséquente de données.

Envoyé par wilfryjules

Mat image, "Mat" est spécifique à OpenCv je crois, c'est bel et bien le meilleur support pour traiter les images, avec IplImage, faut jongler avec les 2

En effet, et Mat a d'ailleurs une manière assez particulière de gérer ses données en interne. Un objet Mat est une sorte de shared_ptr, c'est fait pour éviter les copies au maximum mais c'est franchement piégeux.

Variable qui se remet à 0 TOUTE SEULE

C++

Discussions similaires

Partager

Partager