Discussion :

[Guntreg]

Bonjour,

Je rencontre actuellement un problème pour passer un algorithme de traitement d'images déjà conçu sur Pocket PC. En effet, la fonction Image.LoadFile(path) tant utilisée sur le framework .NET classique n'existe pas dans la version compact. J'ai du donc utiliser directement le type bitmap :
Bitmap im = new Bitmap(path_pda)
Jusqu'ici tout va bien mais lors du parcours des valeurs de chaque pixels je me retrouve avec des valeurs sur 5 bits (0 8 16 24 ... etc ) ce qui manque tout de même de précision pour un traitement.
Aprés diverses recherches je pense que ceci est du au type de données bitmap qui est orienté pour l'affichage et qui au moment du chargement de l'image la convertie directement en System.Drawing.Imaging.PixelFormat.Format16bppRgb555 qui est le format de pixel par default pour l'affichage sur un Pocket PC.
J'ai bien sur essayé d'aller lire directement les valeurs des pixels avec des pointeus dans un bloc unsafe{} mais la pareil ... toutes les valeurs était coupées à une précision 5 bits.
Je pense donc que c'est à l'ouverture de l'image en new bitmap() que la conversion est effectuée par le compact framework .

Quelqu'un a t il une solution a me proposer ou vais-je être obligé de coder une fonction perso en c# pour décoder moi même mes images bmp ??

Merci d'avance d'avoir eu la patience d'essayer de comprendre mon problème ...

[Guntreg]

Bon ben j'ai implémenté ma propre fonction pour ouvrir les bmp... ça marche sans probleme meme si elle ne traite que les fichiers bmp sans compression et seulement en 24bpp.
voila le code non commenté et adapté à mes structures ... (je suis pret à remettre un peu ça au clair si qqun est interressé) ...

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
 
 
    class bmp_reader
    {
 
        public Matrice open_bmp_file(string filename,Boolean info) {
 
            int nBytes;
            byte[] ByteArray;
            int nBytesRead;
            int TailleDeLImage, TailleFichier, offset, tailleStruct2, width, height, nb_bits_px;
            byte[] donnees;
            int i, j;
            int nb_octets_px;
            String Compression;
            Matrice image;
            //System.IO.StreamReader bmp_stream_reader;
            //bmp_stream_reader = new StreamReader(filename);
            //bmp_stream_reader.Read((char[])tbl_byte, 0, 2);
 
            //Create a file stream from an existing file.
            FileInfo fi=new FileInfo(filename);       
            FileStream fs=fi.OpenRead();
 
 
            //On lit l'entête et on vérifie que le fichier est bien signé BMP
            nBytes=2;
            ByteArray=new byte[nBytes];
            nBytesRead=fs.Read(ByteArray, 0, nBytes);
            if (ASCIIEncoding.ASCII.GetString(ByteArray, 0, 2) != "BM")
            {
                System.Windows.Forms.MessageBox.Show(ByteArray + " : Ce fichier n'est pas un fichier BMP Windows valide");
            }
            else
            {
                MessageBox.Show("Fichier BMP valide");
            }
 
 
            //On lit la taille du fichier contenue dans 4 octets (non fiable)
            nBytes=4;
            ByteArray=new byte[nBytes];
            nBytesRead=fs.Read(ByteArray, 0, nBytes);
            TailleFichier = bytes2int32(ByteArray);
            if (info)
            {
                MessageBox.Show("TailleFichier : " + TailleFichier);
            }
 
            //On lit la valeur qui nous dit où commencer la lecture des données de l'image (offset)
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            offset = bytes2int32(ByteArray);
            if (info)
            {
                MessageBox.Show("offset : " + offset);
            }
 
            //Taille de la 2eme structure
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            tailleStruct2 = bytes2int32(ByteArray);
            if (info)
            {
                MessageBox.Show("tailleStruct2 : " + tailleStruct2);
            }
 
            //On lit la valeur de la largeur et hauteur de l'image
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            width = bytes2int32(ByteArray);
            if (info)
            {
                MessageBox.Show("width : " + width);
            }
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            height = bytes2int32(ByteArray);
            if (info)
            {
                MessageBox.Show("height : " + height);
            }
 
            //On lit le nombre de bits par pixel couleur
            nBytes = 2;
            ByteArray = new byte[nBytes];
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            nb_bits_px = bytes2int32(ByteArray);
            nb_octets_px = (int)(nb_bits_px/8);
            if (info)
            {
                MessageBox.Show("nb_bits_px : " + nb_bits_px);
            }
 
 
            //On lit la compression utilisée
            nBytes = 4;
            ByteArray = new byte[nBytes];
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            switch(bytes2int32(ByteArray)) {
            case 0 :
                Compression = "Aucune";
                break;
            case 1 :
                Compression = "RLE-8";
                break;
            case 2 :
                Compression = "RLE-4";
                break;
            case 3 :
                Compression = "BitField";
                break;
            default :
                Compression = "Inconnue";
                break;
            }
            if (info)
            {
                MessageBox.Show("Compression : " + Compression);
            }
 
 
            //On lit la taille de l'image en octet contenue dans 4 octets 
            nBytes = 4;
            ByteArray = new byte[nBytes];
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
            TailleDeLImage = bytes2int32(ByteArray);
            if (info)
            {
                MessageBox.Show("TailleDeLImage : " + TailleDeLImage);
            }
 
            //Saut des informations de palettes :
            nBytes = 16;
            ByteArray = new byte[nBytes];
            nBytesRead = fs.Read(ByteArray, 0, nBytes);
 
 
            //Recuperation des valeurs de pixels
            ByteArray = new byte[nb_octets_px];
            donnees = new byte[nb_octets_px * width * height];
            for (j = height - 1; j >= 0; j--)
            {
                //for (j = height-1; j >= 0; j--)
                for (i=0; i<width; i++)
                {
                    nBytesRead = fs.Read(ByteArray, 0, nb_octets_px);
                    donnees[(j * width + i) * nb_octets_px] = ByteArray[2];
                    donnees[(j * width + i) * nb_octets_px + 1] = ByteArray[1];
                    donnees[(j * width + i) * nb_octets_px + 2] = ByteArray[0];
                    //MessageBox.Show("R : " + ByteArray[2] + "  G : " + ByteArray[1] + "  B : " + ByteArray[0]);
                }
            } 
 
 
            image = new Matrice(Matrice.TYPE_RGB,width,height,donnees);
 
            //Verification
            //image.Parcours();
            return image;
 
        }
 
 
        private int bytes2int32(byte[] tblbytes)
        {
            int val;
            int i;
            val = 0;
 
            for (i = 0; i < tblbytes.GetLength(0); i++)
            {
                val = val + (int)System.Math.Pow(2,8*i) * (int)tblbytes[i];
            }
 
            return val;
        }
 
    }

P.S.: Les erreurs ne sont pas non plus gérées ...