IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Problème d'allocation mémoire


Sujet :

C++

  1. #1
    Futur Membre du Club
    Profil pro
    Inscrit en
    Août 2005
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2005
    Messages : 10
    Points : 6
    Points
    6
    Par défaut Problème d'allocation mémoire
    Bonjour, je suis bien embêter

    Je suis en possession d'une classe Image (CImg):
    -1 nom d'image
    -1 attribut de cette classe est un pointeur de classe Histogramme (CHist).

    Dans CHist:
    -1 tableau de float (valeurs)
    Dans une 3eme classe Recherche (CSearch):
    -1 méthode retourne un vecteur de (CImg)

    J'explique un peu ce que fait cette méthode:

    Lecture d'un fichier de données ou des noms d'images et leur histogramme est référencés.
    Jusqua fin du fichier
    *Je lit donc la premiere ligne pour avoir le nom que je stocke dans un CString.
    *Je lit ensuite l'histogramme que je remet dan un CString puis dans un tablo de float.
    *Je crée donc l'instance Histo.
    *Je lui met à l'aide du tableau de float toutes ces valeurs.
    *Je crée l'instance CImg, je lui donne son nom (1ereligne fichier) je lui référence l'histogramme.
    *Puis je rajoute l'image au vecteur. (pushback)

    Je me demandé donc comment faire pour l'allocation des multitudes instances de la CImg également de CHist dans cette méthode afin de ne rien perdre et que cela se fasse proprement.
    càd : soit avec un new et delete (comment m'y prendre)
    soit direct CImg im;
    Chist h;

    ?????

    J'ai également un problème sur les 2 CString qui prennent la meme adresse des leur déclaration, pourquoi?


    Merci d'avance .

  2. #2
    Membre habitué Avatar de galak63
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    126
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2006
    Messages : 126
    Points : 146
    Points
    146
    Par défaut
    Il faudrait que tu nous montres le code de tes 2 classes
    Le plus dur dans la mort, c'est qu'on loupe l'apéro ...
    www.usirugby.rf.lv

  3. #3
    Futur Membre du Club
    Profil pro
    Inscrit en
    Août 2005
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2005
    Messages : 10
    Points : 6
    Points
    6
    Par défaut
    Les voici:

    ImgDisque (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
     
    #include "stdafx.h"
    #include "ImgDisque.h"
     
    CImgDisque::CImgDisque(void)
    {
    	CString img_reference_fichier=NULL;//met rien dans sa référence, son chemin
    }
     
    CImgDisque::~CImgDisque(void)
    {
    	CString img_reference_fichier=NULL;//met rien dans sa référence, son chemin
    }
     
    CString CImgDisque::GetReference(void)
    {
    	return this->img_reference_fichier;	
    }
     
    void CImgDisque::SetReference(CString reference)
    {
    	this->img_reference_fichier=reference;
    }
     
    void CImgDisque::SetHisto(CHistogramme* histog)
    {
    	this->histo=histog;
    }
     
    CHistogramme* CImgDisque::GetHisto(void)
    {
    	return this->histo;
    }
     
    //methode qui retourne la distance entre l'image requete et l'image disque
    //distance simple entre chaque bins de l'histogramme
    float CImgDisque::GetDistance(void)
    {
    	return this->distance;
    }
     
    //methode qui référence à l'image disque la distance entre l'image requete et l'image disque
    //distance simple entre chaque bins de l'histogramme
    void CImgDisque::SetDistance(float dist)
    {
    	this->distance=dist;
    }

    ImgDisque (.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
     
     
    #pragma once
    #include <cv.h>
    #include <highgui.h>
    #pragma comment(lib,"cv.lib")
    #pragma comment(lib,"highgui.lib")
    #pragma comment(lib,"cxcore.lib")
     
    #include "Histogramme.h"
     
    // ImgDisque
     
    class CImgDisque
    {
     
    private:
    	CString img_reference_fichier; //attribut du chemin de l'image
    	CHistogramme* histo;//pointe vers un objet histogramme
    	float  distance;//distance avec l'image requete
     
    public:
     
    	//ructeur par defaut
    	CImgDisque(void);
    	//destructeur
    	~CImgDisque(void);
     
    	//retourne la reference de l'image disque
    	CString GetReference(void);
    	//on donne la reference de l'image disque
    	void SetReference(CString);
    	//retourne l'histogramme de l'image disque
    	CHistogramme* GetHisto(void);
    	//nomme l'histogramme de l'image disque
    	void SetHisto(CHistogramme*);
    	//retourne la distance entre l'histo requete et lhisto disque
    	float GetDistance(void);
    	//affecte la distance entre histos
    	void SetDistance(float);
    };
    [code]

    Histogramme (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
    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
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
     
    #include "stdafx.h"
    #include "Histogramme.h"
    #include <math.h>
    #include <vector>
     
     
    // Histogramme
     
    //constructeur par défaut
    CHistogramme::CHistogramme(void)
    {
    	nbCouleurs=64;
    }
     
    //constructeur
    CHistogramme::CHistogramme(int nbres_coul)
    {
    	this->nbCouleurs=nbres_coul;//donne le nombre de couleur de l'histogramme calculé
    }
     
    //constructeur
    CHistogramme::CHistogramme(const CHistogramme& histogramme)
    {
    	Element=histogramme.Element;
    }
     
    //destructeur
    CHistogramme::~CHistogramme(void)
    {
    	delete[] this->Element; //destruction du tableau où toute les valeurs sont connues
    }
     
    //méthode de calcul de l'histogramme d'une image avec l'aide des méthodes OPENCV
    //avec le nombre de couleurs et le chemin de l'image
    void CHistogramme::Calcul(int nbres_coul,CString reference)
    {
    	IplImage* image= 0;
    	IplImage* rgb[3];
    	CvHistogram* hist;
     
    	nbCouleurs=nbres_coul;
    	Element=new float[nbres_coul];//tableau qui va contenir toutes les valeurs de l'histogramme
     
    	int n=cvRound(cvCbrt(nbres_coul));//arrondi pour la creation de la "base réduite RVB"
     
    	//size of the histogram -1D histogram
    	int taillehist[3]={n,n,n};
    	int bins = taillehist[0]*taillehist[1]*taillehist[2];
    	int hsize[] = {bins};
     
    	//max and min value of the histogram
    	float max_value = 0, min_value = 0;
    	//value and normalized value
    	float value;
    	int normalized;
     
    	image =cvLoadImage(reference,1);//chargement de l'image
     
    	//desentracelement de l'image
    	//creation de 3 images pour les 3 composantes RVB
     
    	/*------------------------ATTENTION-----------------------------
    	// Il faut savoir que OPENCV est en BGR par défaut et non pas en
    	// RGB
    	/--------------------------------------------------------------*/
     
    	rgb[0]=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
    	rgb[1]=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
    	rgb[2]=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
     
    	cvCvtPixToPlane(image,rgb[2],rgb[1],rgb[0],NULL);//creation de l'image des 3 composantes reunies
     
    	//get the histogram and some info about it
    	hist = cvCreateHist( 3, taillehist, CV_HIST_ARRAY, NULL,1);//creation d'un histogramme
    	cvCalcHist( rgb, hist, 0, NULL);//calcul de l'histogramme
    	cvGetMinMaxHistValue( hist, &min_value, &max_value);//recupere les valeurs max et min de l'histogramme pour faire la normalisation par la suite
    	cvNormalizeHist(hist,100.00);//normalisation
     
    	//récupération des valeurs de l'histogramme
    	for(int i=0; i < bins; i++){
    			value = cvQueryHistValue_1D( hist, i);
    			Element[i]=value;
    	}
    	cvWaitKey();
    	cvReleaseHist(&hist);
    }
     
    //méthode de calcul de l'histogramme d'une image avec l'aide des méthodes OPENCV
    //en donnant juste le chemin de l'image
    void CHistogramme::Calcul(CString reference)
    {
    	IplImage* image= 0;
    	IplImage* imgHistogram = 0;
    	IplImage* rgb[3];
    	CvHistogram* hist;
    	int nbres_coul;
     
    	nbres_coul=this->nbCouleurs;
    	Element=new float[nbres_coul];//tableau qui va contenir toutes les valeurs de l'histogramme
     
    	int n=cvRound(cvCbrt(nbres_coul));//arrondi pour la creation de la "base réduite RVB"
     
    	//size of the histogram -1D histogram
    	int taillehist[3]={n,n,n};
    	int bins = taillehist[0]*taillehist[1]*taillehist[2];
    	int hsize[] = {bins};
     
    	//max and min value of the histogram
    	float max_value = 0, min_value = 0;
    	//value and normalized value
    	float value;
    	int normalized;
     
    	image = cvLoadImage(reference,1);
     
    	//desentracelement de l'image
    	//creation de 3 images pour les 3 composantes RVB
     
    	/*------------------------ATTENTION-----------------------------
    	// Il faut savoir que OPENCV est en BGR par défaut et non pas en
    	// RGB
    	/--------------------------------------------------------------*/
     
    	rgb[0]=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
    	rgb[1]=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
    	rgb[2]=cvCreateImage(cvGetSize(image),IPL_DEPTH_8U,1);
     
    	cvCvtPixToPlane(image,rgb[2],rgb[1],rgb[0],NULL);//creation de l'image des 3 composantes reunies
     
    	//get the histogram and some info about it
    	hist = cvCreateHist( 3, taillehist, CV_HIST_ARRAY, NULL,1);//creation d'un histogramme
    	cvCalcHist( rgb, hist, 0, NULL);//calcul de l'histogramme
    	cvGetMinMaxHistValue( hist, &min_value, &max_value);//recupere les valeurs max et min de l'histogramme pour faire la normalisation par la suite
    	cvNormalizeHist(hist,100.00);//normalisation
     
    	//récupération des valeurs de l'histogramme
    	for(int i=0; i < bins; i++){
    			value = cvQueryHistValue_1D( hist, i);
    			Element[i]=value;
    	}
    	cvWaitKey();
    	cvReleaseHist(&hist);
    	cvReleaseImage(&image);
    }
     
    //méthode de calcul des distances entre chaqie bins des histogrammes
    float CHistogramme::Distance(CHistogramme* histo)
    {
    	float distance=0;
    	for(int i=0; i<this->nbCouleurs;i++)
    	{
    		distance+=abs(histo->GetElement()[i]-this->Element[i]);
    	}
    	return distance;
    }
     
    //affecte les valeurs de l'histogramme
    void CHistogramme::SetElement(float* nb_px)
    {
    	this->Element=nb_px;
    }
     
    //retourne les elements (valeurs de lhistogramme)
    float* CHistogramme::GetElement(void)
    {
    	return this->Element;
    }
     
    //retourne le ,ombre de couleurs de l'histogramme
    int CHistogramme::GetNbCouleurs(void)
    {
    	return this->nbCouleurs;
    }
     
    //référence le nombre de couleurs de l'histogramme
    void CHistogramme::SetNbCouleurs(int nbres_coul)
    {
    	this->nbCouleurs=nbres_coul;
    }


    Histogramme (.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
     
    #pragma once
     
    #include <cv.h>
    #include <highgui.h>
    #pragma comment(lib,"cv.lib")
    #pragma comment(lib,"highgui.lib")
    #pragma comment(lib,"cxcore.lib")
     
     
    // Histogramme
     
    class CHistogramme
    {
     
    private:
     
    	float *Element;
    	int nbCouleurs;
     
    public:
    	//constructeur par defaut
    	CHistogramme(void);
    	CHistogramme(int);
    	//constructeur de copie
    	CHistogramme(const CHistogramme& histogramme);
    	//destructeur par defaut
    	~CHistogramme(void);
     
    //calcul histogramme d'une image selon les nombres de couleurs voulues
    void Calcul(int,CString);
     
    //calcul histogramme d'une image selon les nombres de couleurs voulues
    void Calcul(CString);
     
    //méthode de calcul des distances entre chaqie bins des histogrammes
    float Distance(CHistogramme*);
     
    //retourne les elements (valeurs de lhistogramme)
    float* CHistogramme::GetElement(void);
     
    //affecte les valeurs de l'histogramme
    void CHistogramme::SetElement(float*);
     
    //retourne le ,ombre de couleurs de l'histogramme
    int CHistogramme::GetNbCouleurs(void);
     
    //référence le nombre de couleurs de l'histogramme
    void CHistogramme::SetNbCouleurs(int);
    };

    Search(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
    57
     
    #pragma once
     
    #include <cv.h>
    #include <highgui.h>
    #include <vector>
    #include <fstream>
    #include <iostream> 
    #include <stdio.h>
    #include <algorithm>
     
    #pragma comment(lib,"cv.lib")
    #pragma comment(lib,"highgui.lib")
    #pragma comment(lib,"cxcore.lib")
     
    #include "ImgDisque.h"
    #include "Chaine.h"
    #include "ImgRequete.h"
    #include "Fonction.h"
     
    // Search
     
    class Search
    {
     
    private:
     
    	CImgRequete *imgRq;	//image requete
    	std::vector<CImgDisque*> vecImgDisc; //vecteur des images disque
    	float* nb_px; //tableau des resultat de l'histogramme
    	char* fich; //nom de fichier d'une image disque
    	CImgDisque* disc1;
    	CHistogramme* histodisc1;
     
     
    public:
    	//constructeur
    	Search(void);
    	//destructeur
    	~Search(void);
    	//metode de recherche
    	void Recherche(CImgRequete*,CString);
    	//méthode qui cree le fichier pour l'affichage html des resultats
    	void AfficheResultat(CString);
    	//reference l'image requete
    	void SetImageRequete(CImgRequete*);
    	//retourne l'image requete
    	CImgRequete* GetImageRequete(void);
    	//référence vecteur
    	void SetVecteurDisque(std::vector<CImgDisque*>);
    	//retourne le vecteur
    	std::vector<CImgDisque*> GetVecteurDisque(void);
    	//triage du vecteur
    	std::vector<CImgDisque*> TriVecteur(std::vector<CImgDisque*>);
    	//triage du vecteur
    	void TriVecteur(void);
    };
    Search.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
    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
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
     
     
    // Search.cpp : fichier d'implémentation
    //
     
    #include "stdafx.h"
    #include "Search.h"
    #include <fstream>
    #include <string>
    #include <sstream>
     
     
    // Search
     
    //constructeur par défaut
    Search::Search(void)
    {
    }
     
    //destructeur par défaut
    Search::~Search(void)
    {
     
    	//destruction des elements alloués dynamiquement a chaque image du vecteur
    	for(int i=0;i<vecImgDisc.size();i++)
    	{
    		//destruction du tableau de flotant de l'histogramme
    		delete[] vecImgDisc[i]->GetHisto()->GetElement();
    		//destruction de l'emplacement memoire pour stocker l'emplacement de l'image
    		//delete vecImgDisc[i]->GetReference();
     
    		//delete histodisc1;	
    		//delete disc1;
     
    		//destruction de l'objet histogramme
    		//delete vecImgDisc[i]->GetHisto();
    		//desturction de l'objet image
    		delete vecImgDisc[i];
     
    	}
    	//destruction du vecteur
    	this->vecImgDisc.empty();
    }
     
    //creation d'une structure afin de pouvoir trier le vecteur selon un attribut des objets du vecteur
    struct infDistance
    {
    	bool operator()(CImgDisque* a,CImgDisque* b)
    	{
    		return (a->GetDistance()<b->GetDistance());
    	}
    };
     
    //méthode de recherche
    void Search::Recherche(CImgRequete* req1, CString dossier)
    {
     
    	int nb_car_fich=0;
    	int nb_car_histo=0;
    	int nb_couleurs=0;
     
    	char parametre[20];
     
    	std::ifstream f ((char *) (LPCTSTR)dossier); //pour la lecture du fichier ou est stockée la base d'image
    	std::istringstream strligfich,strligfich2; //pour la lecture mot à mot
     
    	if(f) //si l'ouverture du fichier se fait correctement
    	{
    		while(f.getline(parametre,sizeof(parametre),'\n')) //tant que la lecture d'une ligne est possible
    		{
    			disc1=new CImgDisque();
    			histodisc1=new CHistogramme();
     
    			//on recherche les valeurs mises en parametres afin de pouvoir récuperer 
    			//la taille a allouer pour le nom du fichier et lhistogramme
    			strligfich.str(parametre);
    			strligfich >> nb_car_fich >> nb_car_histo >> nb_couleurs ; //lecture mot à mot
    			strligfich.clear(); //efface sinon il met à la suite à chaque fois
     
    			nb_car_fich=nb_car_fich+1;// le +1 est venu du fait de caractere '\0' est mis automatiquement
    			nb_car_histo=nb_car_histo+1;
     
    			fich= new char[nb_car_fich];//alloue pour buffer la lecture de la seconde ligne
    			f.getline(fich,nb_car_fich);//lit la seconde ligne
    			disc1->SetReference((CString)fich);//affecte la reference à l'objet CImgDisque
     
    			char* histog=new char[nb_car_histo];//alloue pour buffer de la 3eme ligne
    			f.getline(histog,nb_car_histo,'\n');//lit la troisième ligne où on trouve les valeurs de l'histo
    			strligfich2.str(histog);
     
    			nb_px=new float[nb_couleurs];//alloue pour le tableau de flottant des nb de pixels	
    			//récupère les coefficients de l'histogramme au fur est a mesure qu'il trouve un mot
    			for (int i=0;i<nb_couleurs;i++)
    			{
    				strligfich2 >> nb_px[i];
    			}
    			strligfich2.clear(); //efface pour la meme raison que strligfich
     
     
    			/*----------------------------------------ATTENTION------------------------------------
    			/ Si dans le futur une autre ligne est ajoutée dans le fichier texte de la base image,
    			/ il faudra la lire avant de rebouclé sinon un décalage se fera pour les différents
    			/ parametres
    			/-------------------------------------------------------------------------------------*/
     
     
    			histodisc1->SetElement(nb_px); //on indique à l'histogramme ses valeurs récupérés
    			disc1->SetHisto(histodisc1); //on indique à l'image que histodisc1 est l'histogramme associé à l'image qu'il a en référence
     
    			disc1->SetDistance(req1->GetHisto()->Distance(histodisc1));//calcul de la distance avec l'histo de l'image requete passé en parametre de la methode 
     
    			vecImgDisc.push_back(disc1);//ajout de l'image au vecteur (tout l'objet)
     
    			delete[] histog;//destruction suite à l'allocation faite
          		}
    	}
    	else //sinon affichage d'un message erreur
    	{
    		//
    	}
    	f.close(); //fermeture du fichier
     
    }
     
    //méthode pour créer le fichier html de l'affichage des reponses
    void Search::AfficheResultat(CString chemin_html)
    {
    	CString pageHtml;
    	CString chaine;
    	CString test;
     
    	//concatenation de chaine de texte
    	pageHtml+="<head>";
    	pageHtml+="<title>Réponse de la recherche</title>";
    	pageHtml+="</head>";
    	pageHtml+="<body>";
    	pageHtml+="<p><h1>Image requête :</h1></p>";
    	pageHtml+="<p><img src=\"";
     
    	pageHtml+=(char *) (LPCTSTR) this->imgRq->GetReference();//recuperation du chemin de l'image requete
     
    	pageHtml+="\" width=\"200\" />";
    	pageHtml+="<p><h1>Résultats :</h1></p>";
    	pageHtml+="<table width=\"100%\" border=\"1\" cellspacing=\"0\" cellpadding=\"0\">";//affichage de l'image requete
     
    	//creation d'une ligne
    	for(int i=0;i<ceil((double)(vecImgDisc.size())/10); i++)
    	{
    		//debut de ligne
    		pageHtml+="<tr>";
     
    		//creation des colonnes du tableau
    		for(int j=0;j<10;j++)
    		{
    			if((10*i+j)<vecImgDisc.size())
    			{
    				chaine.Format("%f",vecImgDisc[10*i+j]->GetDistance());//donne la distance des images du vecteur en CString depuis flottant
     
    				pageHtml+="<td>";
    				test=vecImgDisc[10*i+j]->GetReference(); //recuperation du chemin des images du vecteur
    				pageHtml+="<p align=\"center\"><a href=\""+vecImgDisc[10*i+j]->GetReference();
    				pageHtml+="\" target=\"_blank\"><img src=\""+(CString)vecImgDisc[10*i+j]->GetReference().GetString()+"\" width=\"50\"align=\"middle\" border=\"0\" /></a></p>";
    				pageHtml+="<p align=\"center\">Distance : "+ chaine +"</p>";
    				pageHtml+="</td>";		
    			}
    		}
    		pageHtml+="</tr>";
    	}
    	pageHtml+="</table></body></html>";
     
    	//creation d'un fichier afin de pouvoir l'appeler par la suite dans l'affichage
    	std::ofstream f ((char *) (LPCTSTR) chemin_html);
    	if (f.is_open())
    	{
    		f<<pageHtml;//ecriture dans le fichier
    	}
    	f.close();
    }
     
    //methode de tri du vecteur
    std::vector<CImgDisque*> Search::TriVecteur(std::vector<CImgDisque*> vecteur_entree)
    {
    	std::vector<CImgDisque*> vecteur_sortie;
    	std::sort(vecteur_entree.begin(),vecteur_entree.end(),infDistance()); //triage selon structure crée
    	return vecteur_sortie=vecteur_entree;
    }
     
    //methode de tri du vecteur
    void Search::TriVecteur(void)
    {
    	std::sort(vecImgDisc.begin(),vecImgDisc.end(),infDistance()); //triage selon structure crée
    }
     
    //référence l'image
    void Search::SetImageRequete(CImgRequete* iR)
    {
    	this->imgRq=iR;
    }
     
    //retourne l'attribut l'image requete de l'objet
    CImgRequete* Search::GetImageRequete(void)
    {
    	return this->imgRq;
    }
     
    //reference le vecteur
    void Search::SetVecteurDisque(std::vector<CImgDisque*> vec)
    {
    	this->vecImgDisc=vec;
    }
     
    //retourne le vecteur
    std::vector<CImgDisque*> Search::GetVecteurDisque(void)
    {
    	return this->vecImgDisc;
    }

    "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
     
    Search recherche; //creation d'un objet de recherche
     
    			filePath=fold.GetFolderPath(); //affectation du nom du dossier
    			mStrSearch.SetWindowText(filePath); //mise à jour du EDIT du chemin du dossier de recherche
     
    			//calcul de l'histogramme associé à limage selon une methode de réduction couleurs
    			reqtest.SetHisto(&histoREQ);
    			reqtest.GetHisto()->Calcul(palette,reqtest.GetReference());
    			recherche.SetImageRequete(&reqtest); //affectation de l'histogramme calculer à l'image requête
     
    			//recherche dans la base avec en parametre les dossiers à lire
    			pal.Format("%d",palette);
    			recherche.Recherche(&reqtest,filePath+"\\baservb"+pal+".txt");
     
    			//triage du vecteur resultant à la recherche
    			recherche.TriVecteur();
                // equivalence à ---> recherche.SetVecteurDisque(recherche.TriVecteur(recherche.GetVecteurDisque()));
     
    			//affichage des résultats
    			recherche.AfficheResultat(res_html); //creation du fichier html
    			affhtml.Navigate2((COleVariant)res_html,NULL,NULL,NULL,NULL); //affichage dans le ActiveX


    Merci aux courageux car là je s'atture
    Celui qui me répond aura ma reconnaissance éternelle

  4. #4
    Membre confirmé Avatar de themadmax
    Profil pro
    Inscrit en
    Juillet 2005
    Messages
    446
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2005
    Messages : 446
    Points : 496
    Points
    496
    Par défaut
    1. Ton constructeur et destrcuter CImgDisque
    contienne des lignes qui me paresse bizard
    2. Pour info en C++ tu n'as pas besoin de metre this->, mais pour les indentifier on rajout m_ ou _ devant.
    3. Dans ~CHistogramme(void) il me semble que tu devrais faire attention a ton delete [] ( rajout un test si le pointeur et met le a NULL)
    4. Pense tout le temp a refactorise ton code ne jms avoir du code doublon functions CHistogramme::Calcul

    Sinon pour repondre a ta question je comprend pas vraiment ce que tu veux faire. Tu calcul la distance entre les histogrammes d'images, pour quoi faire ?

    Si tu veut juste stoker tes objects tu peut utiliser std::vector
    ________________________________________________
    http://bliquid.fr : Blog sur Android et l'Acer Liquid

  5. #5
    Futur Membre du Club
    Profil pro
    Inscrit en
    Août 2005
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2005
    Messages : 10
    Points : 6
    Points
    6
    Par défaut
    Pour répondre à la question

    1.J'ai une image requête où je calcule l'histogramme qui appartient à une classe semblable à CImgDisque.
    Ensuite dans le vecteur je veux mettre toutes les images d'un dossier avec leur histo, chemin et la distance entre leur histo avec celui de limage requete.
    Cela me permet alors de ranger les images du dossier de la plus proche en couleur à la plus lointaine de limage requete.

    2.Pour le constructeur et destructeur quelle sont les lignes qui te paraissent bizarre. et commen faire un test sur le delete[]?

    3. Qu'est ce que refactoriser le nommer autrement?

    4. Enfin le problème d'allocation que je parlais est dans la méthode recherche de la classe Search;
    je fais de bon delete dans le destructeur?? ou alors commment faire autrement que dans le destructeur pour disc1 histodisc1 ...??

    J'ai de bon résultats et je voulais savoir si il n'y a pas de problèmes mémoire pour enfin faire quelque chose de propre !

    Merci à Vous !!!

  6. #6
    Membre confirmé Avatar de themadmax
    Profil pro
    Inscrit en
    Juillet 2005
    Messages
    446
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2005
    Messages : 446
    Points : 496
    Points
    496
    Par défaut
    Dans ton constructeur tu redefinis ta variable membre.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    CString img_reference_fichier=NULL;
    Tu devrai pas enlever le CString ?

    Un pointeur doit etre alloué et detruit 1 seule fois, pour evité quelques accidents tu peux tester ton pointeur.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    if ( pData != NULL )
        delete[] pData;
    pData = NULL; //On le remet a NULL il ne sera plus detruit
    ( voir aussi smartpointer et assert )

    Le refactoring c'est de pas avoir du code redondant http://www.design-up.com/articles/ex...rammation.html
    Tes 2 fonctions calcul contiennent de nombreuses lignes de code identique, l'une ne pourrai pas appeler l'autre ? Et si un bug se produit tu n'aurras qu'une modif a faire et pas 2 !

    Je comprend pas pourquoi tu ne detruit pas dans Search::~Search, juste ta liste d'histo vue que lui meme detruit le pointeur Element. Quand tu fais un delete met TOUJOURS ton pointeur a NULL. ( regarde aussi for each )

    Tu peux aussi utilisé une surcharge de l'operateur new http://www.flipcode.com/articles/art...oryleaks.shtml
    Car a vue d'oeil il y a des petits pb.

    Vue que tu utilise les STL pourquoi utilisé les CString ?
    ________________________________________________
    http://bliquid.fr : Blog sur Android et l'Acer Liquid

Discussions similaires

  1. Problème d'allocation mémoire > 2Go
    Par tnarol dans le forum C++
    Réponses: 19
    Dernier message: 09/07/2008, 12h03
  2. Problème d'allocation mémoire
    Par Fibus dans le forum GTK+ avec C & C++
    Réponses: 6
    Dernier message: 10/01/2008, 16h35
  3. Problème d'allocation mémoire et fork
    Par Conap dans le forum Langage
    Réponses: 3
    Dernier message: 20/07/2006, 15h34
  4. Problème d'allocation mémoire
    Par araya dans le forum C
    Réponses: 2
    Dernier message: 04/05/2006, 20h03
  5. Problème d'allocation mémoire
    Par cali1983 dans le forum C++
    Réponses: 10
    Dernier message: 10/03/2006, 23h23

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo