[C++] - Lecture/ecriture d'une bmp

Bonjour,

j'essaie de réaliser une classe me permettant de lire/modifier/sauvegarder des bmps sans passer par des mfc....

Pour cela j'ai créé la classe CBmp :

-> .h

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
 
#if !defined(AFX_BMP_H__5323A95E_AE0A_4AC5_8951_F0F466DF8DCD__INCLUDED_)
#define AFX_BMP_H__5323A95E_AE0A_4AC5_8951_F0F466DF8DCD__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Bmp.h : header file
//
 
// manipulation des flux
#include <iostream>
using std::cout ;
using std::cin ;
using std::ios ;
using std::endl ;
 
// manipulation des fichiers
#include <fstream>
using std::ofstream ;
using std::ifstream ;
#include <sstream>
using std::stringstream ;
 
#include <string>
using std::string ;
 
/////////////////////////////////////////////////////////////////////////////
// CBmp window
class CBmp
{
// Construction
public:
	CBmp();
 
// Attributes
private :
   WORD  m_fType ; // 2 octets, signature
   DWORD m_fSize ; // 4 octets, taille du fichier
   WORD  m_fReserved1 ; // 2 octets, pas utilisé
   WORD  m_fReserved2 ; // 2 octets, pas utilisé
   DWORD m_fOffBits ;   // 4 octets, offset de l'image
 
   DWORD m_iSize ;   // 4 octets, taille de l'entête
   DWORD m_iWidth ;  // 4 octets, largeur image
   DWORD m_iHeight ; // 4 octets, hauteur image
   WORD  m_iPlanes ; // 2 octest, nombre de plans
   WORD  m_iBitCount ;        // 2 octets, nombre de bits
   DWORD m_iCompression ;     // 4 octets, compression
   DWORD m_iSizeImage ;       // 4 octets, taille de l'image
   DWORD m_iXpelsPerMeter ;   // 4 octets, nb pixels/metre en X
   DWORD m_iYpelsPerMeter ;   // 4 octets, nb pixels/metre en Y
   DWORD m_iClrUsed ;         // 4 octets, nombre de couleurs utilisés
   DWORD m_iClrImportant ;    // 4 octets, couleur importante
 
 
   char * m_imageData ;         //!< tableau de l'image 
 
// Implementation
public:
	virtual ~CBmp();
   void Open(string _imgPath) ;
   void SaveBmp(string _path) ;
 
};
 
#endif // !defined(AFX_BMP_H__5323A95E_AE0A_4AC5_8951_F0F466DF8DCD__INCLUDED_)

-> .cpp

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
 
// Bmp.cpp : implementation file
//
 
#include "stdafx.h"
#include "Bmp.h"
 
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
 
/////////////////////////////////////////////////////////////////////////////
// CBmp
 
CBmp::CBmp()
{
}
 
CBmp::~CBmp()
{
}
 
void CBmp::Open(string _imgPath)
{
   //--------------------------
   // ouverture du fichier en lecture seule binaire
 
   ifstream f ;
   f.open(_imgPath.c_str(),std::ios_base::binary) ;
 
   if (f.is_open() != 0)
   {  
      f.read(reinterpret_cast<char*>(&m_fType), sizeof(WORD));
      f.read(reinterpret_cast<char*>(&m_fSize), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_fReserved1), sizeof(WORD));
      f.read(reinterpret_cast<char*>(&m_fReserved2), sizeof(WORD));
      f.read(reinterpret_cast<char*>(&m_fOffBits), sizeof(DWORD));
 
      f.read(reinterpret_cast<char*>(&m_iSize), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iWidth), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iHeight), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iPlanes), sizeof(WORD));
      f.read(reinterpret_cast<char*>(&m_iBitCount), sizeof(WORD));
      f.read(reinterpret_cast<char*>(&m_iCompression), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iSizeImage), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iXpelsPerMeter), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iYpelsPerMeter), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iClrUsed), sizeof(DWORD));
      f.read(reinterpret_cast<char*>(&m_iClrImportant), sizeof(DWORD));
 
      //--------------------------
      // Mémorisation de l'entête et des caractéristiques de l'image        
      m_imageData = new char[m_iSize*sizeof(char)] ; 
 
      // recopie de l'image
      f.read(reinterpret_cast<char*>(&m_imageData), m_iSize*sizeof(char));
 
      //----------------------------
      // fermeture du fichier de l'image
      f.close() ;
   }
}
 
void CBmp::SaveBmp(string _path)
{
   ofstream f ;
   f.open(_path.c_str(),std::ios_base::binary) ;
   if (f.is_open() != 0)
   {
      f.write(reinterpret_cast<const char*>(&m_fType), sizeof(WORD));
      f.write(reinterpret_cast<const char*>(&m_fSize), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_fReserved1), sizeof(WORD));
      f.write(reinterpret_cast<const char*>(&m_fReserved2), sizeof(WORD));
      f.write(reinterpret_cast<const char*>(&m_fOffBits), sizeof(DWORD));
 
      f.write(reinterpret_cast<const char*>(&m_iSize), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iWidth), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iHeight), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iPlanes), sizeof(WORD));
      f.write(reinterpret_cast<const char*>(&m_iBitCount), sizeof(WORD));
      f.write(reinterpret_cast<const char*>(&m_iCompression), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iSizeImage), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iXpelsPerMeter), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iYpelsPerMeter), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iClrUsed), sizeof(DWORD));
      f.write(reinterpret_cast<const char*>(&m_iClrImportant), sizeof(DWORD));
 
      f.write(reinterpret_cast<const char*>(&m_imageData), m_iSize*sizeof(char));
 
      f.close() ;
   }
}

Mon problème est le suivant, quand je lance mon test sur ces deux fonctions :

Code:

1
2
3
CBmp img ;
   img.Open("dragonBall.bmp") ;
   img.SaveBmp("test.bmp") ;

Et bien j'ai la création d'une image test.bmp mais c'est un carré noir de la taille de l'image de départ ....

Pourtant l'image de départ est un joli dragon ball sautillant !!!!

est ce que vous auriez une idée de là où je me serai plantée ?

:D

Alice

Quel est l'intérêt de recoder une telle classe ? Tu as plein de bibliothèques qui te feront ça bien mieux et pour plein de formats de fichiers (voir FAQ C++ si tu veux des liens).

Je vois que tu lis m_iSize octets pour les pixels, alors que tu indiques en commentaire qu'il s'agit de la taille de l'en-tête. Ca peut être la source de ton erreur.

A part ça, ton code est très incomplet : il faut gérer les différents formats de pixels (24 bits, monochrome, 8 bits palettisé, ...), l'éventuelle compression RLE, etc... En gros tu vas te faire ch*** pour pas grand chose.

Hi,

Effectivement après une dure journée de ratatinnage de neurones, de compression du stress et autre tourmente, ...:marteau:
Mon chéri vient de me conseiller exactement la même chose que toi : UTILISE des LIB déjà existantes !!!!

Bon je vais tester imageMagick demain matin, et Inch'Allah !

:merci: pour tes liens et tes conseils

Alice
-------------------------------------------------------------------
PS : j'vais aller :zzz: un tout petit peu pour me remettre mes toutes petites cellules grises en place !!