Discussion :

[titi ten]

bonsoir a tous,
je vous remercie tout d'abord d'avoir prété attention a mon problème qui est le suivant :
lire une image (noir et blanc) et la convertir en un fichier qui contient les codes hexadécimaux.
je n'arrive pas a faire la boucle je ais que je dois utiliser un compteur mais le probleme : si la première case et en noir , je compte le nombre de noir suivant puis dés que j'arrive au blanc dois-je mettre un autre compteur2 ou ecrire la valeur du compteur1 dans le fichier en ajoutant le code du "noir" puis le réinitialiser et ainsi de suite mais dans se cas dois-je avoir une condition d'arrêt de boucle ou pas (a mon avis non) .
et y'a il un autre moyen si oui lequel ?
aider moi SVP c'est vraiment urgent.
Merci encore.

[ternel]

Ce que tu dis n'est pas clair. J'ai vaguement idée ce que tu veux faire, mais rien de précis.

Essaie de détailler un peu plus, toujours en français.
Quand ce sera assez détaillé, le code viendra tout seul.

[titi ten]

bonsoir leternel
je vous remercie pour votre aide et votre attention,
mon problème et la compression d'une image en noir et blanc en un fichier texte qui contient le nombre de répétition en hexadécimale d'une couleur donné(noir ou blanc).
exemple: une image avec 4 pixels noir 10 blancs 15 noirs et 2 blancs => sera codé dans le fichier de la sorte : (8004 00h) (800a FFh) (800f 00H) (8002 FFh).
un autre cas quand il n'y a pas de répétitions on aura la taille de l'image suivie des couleurs
exemple: 1pixel noir 1blanc 1noir 1blanc..... => donne le code : (height*width) 00h FFh 00h FFh.........
merci encore pour votre précieuse aide.
voici mon code qui est incomplet et pas correct ("excuse"):

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
#include <iostream>
#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <math.h>
#include <fstream>
 
 
//==============================================================================================//
//     Image Analogies  using only comparison of luminance and using Gaussian Pyramid           //
//==============================================================================================//
 
 
using namespace std;
 
struct ColorPoint
        {
            int LevelB;
            int LevelG;
            int LevelR;
        };
 
int main( int argc, char** argv)
{
        ofstream fileout;
        fileout.open("text.txt");
        CvScalar s;
 
 
        int Width, Height, i, j;
 
        IplImage* srcL;
        IplImage* srcGL;
        srcL=cvLoadImage(argv[1]);
 
        Width= srcL->width;
        Height= srcL->height;
 
        srcGL = cvCreateImage(cvSize(srcL->width,srcL->height),IPL_DEPTH_8U, 1);
        cvConvertImage(srcL, srcGL, 0);
 
 
        cvNamedWindow("win1", CV_WINDOW_AUTOSIZE);
        cvShowImage("win1", srcL);
 
        cvNamedWindow("win2", CV_WINDOW_AUTOSIZE);
        cvShowImage("win2", srcGL);
 
 
        int** imG; int cpt;//int cptN=0,cptB=0;
        imG=new int* [Height];
        for (i=0; i<Height; i++) imG[i]=new int [Width];
 
        for (i=0; i<Height; i=i+1)
            {//cptN=cptB=0;
            for (j=0; j< Width ; j=j+1)
                {
                s=cvGet2D(srcGL,i,j);
                imG[i][j]=s.val[0];
 
                }
            }
 
            i=0;cpt=0;
            while(i<Height)
                {j=0;
                 while(j<Width)
                {
                   if(j<Width-1)
                        if(imG[i][j]==imG[i][j+1]) {cpt++;j++;}
                            else if(cpt=1) {fileout<<"("<<hex<<Height*Width<<")"; for(i=0;i<Height;i++)for(j=0;j<Width;j++) fileout<<imG[i][j]<<"H";cpt=0;}
                                    else {
                                        if(cpt<=15) {fileout<<"(800"<<hex<<cpt<<")"<<imG[i][j]<<"H";cpt=0;}
                                            else if (cpt<=255) {fileout<<"(80"<<hex<<cpt<<")"<<imG[i][j]<<"H";cpt=0;}
                                                    else {fileout<<"(8"<<hex<<cpt<<")"<<imG[i][j]<<"H";cpt=0;}
                                    }
 
                    if(j=Width-1)
                        if(imG[i][j]==imG[i+1][0]) {cpt++;j++;}
                            else if(cpt=1) {fileout<<"("<<hex<<Height*Width<<")"; for(i=0;i<Height;i++)for(j=0;j<Width;j++) fileout<<imG[i][j]<<"H";cpt=0;}
                                    else {
                                        if(cpt<=15) {fileout<<"(800"<<hex<<cpt<<")"<<imG[i][j]<<"H";cpt=0;}
                                            else if (cpt<=255) {fileout<<"(80"<<hex<<cpt<<")"<<imG[i][j]<<"H";cpt=0;}
                                                    else {fileout<<"(8"<<hex<<cpt<<")"<<imG[i][j]<<"H";cpt=0;}
                                    }
                }}
 
 
        cvWaitKey(0);
 
        cvDestroyWindow("win1");
        cvDestroyWindow("win2");
 
 
 
//===============================
 
        cvReleaseImage(&srcL);
 
        return 0;
}
 
//==============================================================================================
//==============================================================================================

[ternel]

Note préliminaire:
En C++, on utilisera <cmath> plutot que le déprécié <math.h>
Les fonctions seront définis dans std::

Je pense que je procéderai en deux temps:
Supposons que les données bruts de l'image soit disponible via la classe suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
namespace image {
class brute {
public:
    typedef ... size_type;
//...
public:
    size_type hauteur() const;
    size_type largeur() const;
    bool blanc(size_type ligne, size_type colonne) const;//retourne true si le pixel désigné est blanc.
};
}//image::

Cette classe peut tout-à-fait être une boite noire appelant les fonctions de ta bibliothèque.

Tu veux avoir un autre format?
Autant avoir une classe optimisée pour ce format, et constructible depuis une image.

Code :

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

1
2
3
4
5
6
7
8
namespace image {
class bit_blocs {
public:
    typedef ... size_type;//choisit ce qu'il te faut
public:
    bit_blocs(image::brute const&);
};
}//image::

Maintenant, j'ai une opération unique à définir: la conversion d'une suite de 0 et 1 en une suite de {taille, couleur}
Tu sais d'avance qu'il n'y a que deux couleurs, tu pourrais te dire autant considérer que deux blocs successifs sont toujours de couleurs opposée, ne gardant en mémoire que la couleur du premier.
Sauf que la taille d'un bloc est limité par le type qu'on va choisir pour la représenter.

Donc, j'opte pour cette structure interne (et privée):

Code :

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

1
2
3
4
struct bloc {
    size_type taille;
    bool color;
};

Par défaut, une suite, c'est un std::vector.
restera à créer la liste des blocs dans le constructeur.

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
namespace image {
class bit_blocs {
public:
    typedef ... size_type;//choisit ce qu'il te faut
private:
    struct bloc {
        size_type taille;
        bool color;
    };
    typedef std::vector<bloc> blocs_type;
    blocs_type blocs;
public:
    bit_blocs(image::brute const&);
};
}//image::

Maintenant, tu es en mesure d'avoir un objet dans le format qu'il faut.
Reste à écrire ca dans un fichier.
deux fonctions à définir:

Code :

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

1
2
std::ostream& operator<<(std::ostream& , bit_blocs::bloc const&)
std::ostream& operator<<(std::ostream& , bit_blocs const&)

et le tour est joué.

Une fois que ca sera fait, tu pourras faire franchement mieux question mémoire, si tu veux uniquement créer le fichier, mais que tu ne veux pas utiliser ce format dans le programme.
Il est possible de créer un "itérateur générant" (le nom est de moi) qui crée les blocs à la volée, pendant que tu parcours l'image.

[titi ten]

bonjour,
merci encore Mr leternel.
je n'ai pas tres bien compris parce que je ne maitrise pas vraiment le C++.Je viens de commencer a apprendre le C++ (PS: notre prof nous a donner le code et ou a demander de faire la boucle de conversion comme des idiots "désolé pour le terme") bref , je vais essayé de comprendre puis d'utiliser votre méthode.
Merci beaucoup c'est tres gentil de votre part.

[titi ten]

Tres heureuse
Merci beaucoup Mr Leternel
Je viens juste de finir mon Tp et il marche.
En faite au début les ecritures dans le fichier je les avais mises dans une boucle et sa marchait pas, mais apres j'ai utiliser des fonctions et sa marche tres bien.
Merci