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 : 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
 
#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 : 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
 
// 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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 ?



Alice