conversion d'une image en fichier hexadécimal

Version imprimable

13/03/2015, 20h10
titi ten

conversion d'une image en fichier hexadécimal

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.
16/03/2015, 09h03
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.

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:

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;
}
 
//==============================================================================================
//==============================================================================================

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:

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:

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:

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:

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:

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.

22/03/2015, 15h34
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.
30/03/2015, 01h48
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 ;)
30/03/2015, 09h40
ternel

Au plaisir :D

N'hésite pas à poser des questions précises, avec "je n'ai pas très bien compris", on ne peut pas t'aider.

Souviens-toi: Ne fait qu'une seule chose à la fois.
Si ce que fait un bloc de code n'est pas exprimable précisément avec une paire de phrase, c'est qu'il faut le découper en blocs plus petits.
Les deux moyens pour le faire sont la fonction et la classe.
31/03/2015, 13h52
titi ten

bonjour,
Merci Mr Leternel ^_^
mais en fait, vous voulez dire quoi par une pair de phrase dans un bloc ?!!
Merci.
31/03/2015, 14h16
ternel

Le code est écrit en C++, un langage destiné à l'ordinateur.
Pour les humains, on utilise le français (par exemple).

Je considère qu'un programme est lisible quand je peux exprimer le fonctionnement de chaque bloc de code en une ou deux phrases.

C'est pour cela que je pense qu'il faut voir un programme comme des définitions de vocabulaire et une histoire (dont main() serait la trame).

De même que je considère un dictionnaire qui ferait des définitions de trois pages comme incompréhensible, les fonctions doivent être explicables en quelques phrases simples.
31/03/2015, 14h47
titi ten

D'accord Mr Le Ter Nel ^^
J'ai compris merci beaucoup :)