Classe rotation image TImages

Version imprimable

Salut,

Une nouvelle classe qui permet la rotation d'une image d'un angle quelconque. C'est la classe TImages,

elle s'utilise de la manière suivante :

Code:

1
2
3
4
5
6
7
8
9
10
11
#include "Images.h"
...
TImages *i=new TImages(FFichier);
 
i->Angle=FAngle;
 
Image1->Height=i->Hauteur;
Image1->Width=i->Largeur;
Image1->Picture->Bitmap->Assign(i->Image);
 
delete i;

où FFichier est le nom du fichier d'entrée .bmp ou .jpg et FAngle l'angle de rotation en degré de l'image de sortie, dans ce cas j'ai affecté la sortie vers un objet visuel TImage que j'ai retaillé à la taille du Bitmap sortant.

voici le .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
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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
//---------------------------------------------------------------------------
#include "Images.h"
//---------------------------------------------------------------------------
TImages::TImages(AnsiString fichier)
{
   FBitmap=NULL;
   FBitmapDest=NULL;
   FAngle=0;
   FFichier=fichier;
   Traitement();
}
//---------------------------------------------------------------------------
TImages::~TImages()
{
   if (FBitmap)
      delete FBitmap;
 
   if (FBitmapDest)
      delete FBitmapDest;
}
//---------------------------------------------------------------------------
void TImages::Traitement(void)
{
   TStringList *ext=new TStringList();
   ext->Add(".jpg");
   ext->Add(".bmp");
   int index=ext->IndexOf(ExtractFileExt(FFichier));
   delete ext;
 
   if (index==-1)
      return;
 
   if (FBitmap)
      delete FBitmap;
   FBitmap=new Graphics::TBitmap();
 
   if (FBitmapDest)
      delete FBitmapDest;
   FBitmapDest=new Graphics::TBitmap();
 
   // Chargement Image d'entrée
   TJPEGImage * jpg;
   switch(index)
   {
      case 0:
         jpg=new TJPEGImage();
         jpg->LoadFromFile(FFichier);
         FBitmap->Assign(jpg);
         delete jpg;
      break;
      case 1:
         FBitmap->LoadFromFile(FFichier);
      break;
   }
 
   // Calcul Image de sortie
   switch (FAngle%360)
   {
      case 0:         FBitmapDest->Assign(FBitmap);           break;
      case 90:
      case -270:      TournePlusAngleDroit();                 break;
      case -90:
      case 270:       TourneMoinsAngleDroit();                break;
      case 180:
      case -180:      TourneAnglePI();                        break;
      default:        TourneAngleNonParticulier();            break;
   }
}
//---------------------------------------------------------------------------
void TImages::TourneMoinsAngleDroit(void)
{
   FBitmap->PixelFormat=pf32bit;                      FBitmapDest->PixelFormat=pf32bit;
   FBitmapDest->Height=FBitmap->Width;                FBitmapDest->Width=FBitmap->Height;
 
   Byte ** tablesource=ImageVersTableau(FBitmap);     Byte ** tabledestination=ImageVersTableau(FBitmapDest);
 
   int i,j,k,pos,pos2;
 
   for(j=0;j<FBitmap->Height;j++)
   {
      pos2=(FBitmapDest->Width-j-1)<<2;
      for(i=0;i<FBitmap->Width;i++)
      {
         pos=i<<2;
         for (k=0;k<4;k++)
            tabledestination[i][pos2+k]=tablesource[j][pos+k];
      }
   }
   if (tablesource)  delete [] tablesource;           if (tabledestination)  delete [] tabledestination;
}
//---------------------------------------------------------------------------
void TImages::TournePlusAngleDroit(void)
{
   FBitmap->PixelFormat=pf32bit;                   FBitmapDest->PixelFormat=pf32bit;
   FBitmapDest->Height=FBitmap->Width;             FBitmapDest->Width=FBitmap->Height;
 
   Byte ** tablesource=ImageVersTableau(FBitmap);   Byte ** tabledestination=ImageVersTableau(FBitmapDest);
 
   int i,j,k,pos,pos2,pos3;
 
   for(i=0;i<FBitmap->Height;i++)
   {
      pos2=i<<2;
      for(j=0;j<FBitmap->Width;j++)
      {
         pos=j<<2;
         pos3=FBitmapDest->Height-j-1;
         for (k=0;k<4;k++)
            tabledestination[pos3][pos2+k]=tablesource[i][pos+k];
      }
   }
   delete [] tablesource;
   delete [] tabledestination;
}
//---------------------------------------------------------------------------
int TImages::LireHauteur(void)
{
   if (!FBitmapDest)
      return 0;
 
   return (FBitmapDest->Height);
}
//---------------------------------------------------------------------------
int TImages::LireLargeur(void)
{
   if (!FBitmapDest)
      return 0;
 
   return (FBitmapDest->Width);
}
//---------------------------------------------------------------------------
void TImages::SetAngle(int angle)
{
   FAngle=angle;
   Traitement();
}
//---------------------------------------------------------------------------
void TImages::TourneAnglePI(void)
{
   FBitmap->PixelFormat=pf32bit;                   FBitmapDest->PixelFormat=pf32bit;
   FBitmapDest->Height=FBitmap->Height;            FBitmapDest->Width=FBitmap->Width;
 
   Byte ** tablesource=ImageVersTableau(FBitmap);  Byte ** tabledestination=ImageVersTableau(FBitmapDest);
 
   int i,j,k,pos,pos2,pos3;
 
   for (int j=0;j<FBitmap->Height;j++)
   {
      pos3=FBitmap->Height-j-1;
      for (int i=0;i<FBitmap->Width;i++)
      {
         pos=i<<2;
         pos2=(FBitmap->Width-i-1)<<2;
 
         for (k=0;k<4;k++)
            tabledestination[pos3][pos2+k]=tablesource[j][pos+k];
      }
   }
 
   delete [] tablesource;
   delete [] tabledestination;
}
//---------------------------------------------------------------------------
void TImages::TourneAngleNonParticulier()
{
   double radians=FAngle*2*M_PI/360.0;
 
   double sinus=sin(radians);                                           double cosinus=cos(radians);
 
   int largeursource=FBitmap->Width;                                    int hauteursource=FBitmap->Height;
 
   int x2=largeursource*cosinus;                                        int y2=-largeursource*sinus;
   int x3=hauteursource*sinus;                                          int y3=hauteursource*cosinus;
   int x4=largeursource*cosinus+hauteursource*sinus;                    int y4=-largeursource*sinus+hauteursource*cosinus;
 
   int largeurdest=Maxi(abs(x4),abs(x2-x3));                            int hauteurdest=Maxi(abs(y4),abs(y2-y3));
   FBitmapDest->PixelFormat=pf32bit;                                    FBitmap->PixelFormat=pf32bit;
   FBitmapDest->Width=largeurdest;                                      FBitmapDest->Height=hauteurdest;
 
   int decalagex=Mini(Mini(0,x2),Mini(x3,x4));                          int decalagey=Mini(Mini(0,y2),Mini(y3,y4));
   double offsetx=((double)decalagex)*cosinus-((double)decalagey)*sinus;double offsety=((double)decalagex)*sinus+((double)decalagey)*cosinus;
 
   TCanvas *canvas=FBitmapDest->Canvas;                                 canvas->Brush->Style=bsSolid;
   canvas->Brush->Color=COULEURFOND;                                    canvas->Rectangle(0,0,largeurdest,hauteurdest);
 
   Byte ** tablesource=ImageVersTableau(FBitmap);                       Byte ** tabledestination=ImageVersTableau(FBitmapDest);
 
   int x_0,x_1,y_0,y_1,x,y,x_0_d,x_1_d,j_d,i,j,k;
   double fx0,fx1,fy0,fy1,fy1fx0,fy1fx1,fy0fx0,fy0fx1;
   for (i=0;i<hauteurdest;i++)
      for(j=0;j<largeurdest;j++)
      {
         x=((double)j)*cosinus-((double)i)*sinus+offsetx;               y=((double)j)*sinus+((double)i)*cosinus+offsety;
 
         x_0=floor(x);           x_1=x_0+1;                             y_0=floor(y);                y_1=y_0+1;
 
         if (y_1<0 || y_1>=hauteursource)     continue;                 if (y_0<0 || y_0>=hauteursource)     continue;
         if (x_1<0 || x_1>=largeursource)     continue;                 if (x_0<0 || x_0>=largeursource)     continue;
 
         fx1=x-x_0;              fx0=1-fx1;                             fy1=y-y_0;                   fy0=1-fy1;
         fy1fx0=fy1*fx0;         fy1fx1=fy1*fx1;                        fy0fx0=fy0*fx0;              fy0fx1=fy0*fx1;
         x_0_d=x_0<<2;           x_1_d=x_1<<2;                          j_d=j<<2;
 
         for (k=0;k<4;k++)
         {
            tabledestination[i][j_d+k]=(Byte)((
               fy1fx0*(double)tablesource[y_1][x_0_d+k]+
               fy1fx1*(double)tablesource[y_1][x_1_d+k]+
               fy0fx0*(double)tablesource[y_0][x_0_d+k]+
               fy0fx1*(double)tablesource[y_0][x_1_d+k]));
         }
      }
   if (tablesource)      delete [] tablesource;                         if (tabledestination)       delete [] tabledestination;
}
//---------------------------------------------------------------------------
int TImages::Maxi(int x,int y)
{
   return x > y ? x : y;
}
//---------------------------------------------------------------------------
int TImages::Mini(int x,int y)
{
   return x < y ? x : y;
}
//---------------------------------------------------------------------------
Byte ** TImages::ImageVersTableau(Graphics::TBitmap * image)
{
   Byte ** tableau=new Byte*[image->Height];
   for (int i=0;i<image->Height;i++)
      tableau[i]=(Byte *)image->ScanLine[i];
   return tableau;
}
//---------------------------------------------------------------------------

et le .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
//---------------------------------------------------------------------------
#ifndef ImagesH
#define ImagesH
//---------------------------------------------------------------------------
#include <jpeg.hpp>
#include <Graphics.hpp>
#include <math.h>
//---------------------------------------------------------------------------
#define COULEURFOND clBlack
//---------------------------------------------------------------------------
class TImages
{
   private:
      int Maxi(int x,int y);
      int Mini(int x,int y);
 
      AnsiString FFichier;
      int FAngle;
 
      Graphics::TBitmap * FBitmap;
      Graphics::TBitmap * FBitmapDest;
 
      Byte ** ImageVersTableau(Graphics::TBitmap * image);
      void TourneAngleNonParticulier(void);
      void TourneAnglePI(void);
      void TournePlusAngleDroit(void);
      void TourneMoinsAngleDroit(void);
 
      void Traitement(void);
 
      int LireHauteur(void);
      int LireLargeur(void);
      void SetAngle(int angle); 
 
   public:
      __property int Hauteur = { read = LireHauteur };
      __property int Largeur = { read = LireLargeur };
      __property int Angle = { read = FAngle, write = SetAngle };
 
      __property Graphics::TBitmap * Image = {read = FBitmapDest };
 
      TImages(AnsiString fichier);
      ~TImages();
};
//---------------------------------------------------------------------------
#endif

Je sais qu'il existe la jApi qui fait beaucoup plus de choses en matière de traitement d'image mais parfois c'est un peu fastidieux d'ajouter une API complète juste pour faire une action ponctuelle, d'où l'utilité de TImages.

En images :

avant :

http://img15.hostingpics.net/pics/730242essai2.jpg

après :

http://img15.hostingpics.net/pics/569874essai1.jpg

27/02/2013, 08h00
yarp

Je suis d'accord que brancher une librairie d'images pour quelques routines de base est inutile. Dans le genre je te conseil de regarder cette classe qui contient pas mal de fonctions de rendu de base dans un code CBuilder compatible:

http://www.codeproject.com/Articles/...pulation-Class
27/02/2013, 10h43
ShaiLeTroll

Sauf quand la library est intégré à l'OS comme SetWorldTransform et son XFORM structure comme dans le sujet Rotation d'image avec bitblt/xform ou le sujet [débutant] Traitement d'image: WMF ou bmp?
27/02/2013, 12h07
Freeze
super le SetWorldTransform, c'est bien pratique.

concernant la classe CBitmapEx, ça m'intéresse mais je bloque un peu pour l'utiliser, marche-t-elle chez vous ? J'ai du faire un paquet de modifications pour éviter les erreurs (max, min) et les warnings, mais malgré cela, je n'arrive pas à charger quoique ce soit. J'ai l'impression qu'il ne trouve pas les informations nécessaires dans le header de mon bitmap, je suis perplexe sur ce coup...

Voilà ce que je fais pour tester :
Code:

1 2 3 4 5 6 7 #include "BitmapEx.h" ... CBitmapEx *c=new CBitmapEx(); c->Load(FFichier.c_str()); c->Rotate(45); c->Save(FFichierDest.c_str()); delete c;
à suivre donc...
27/02/2013, 12h18
yarp

C'est une classe MFC, j'aurais du être plus précis. Ce sont les algos qui sont récupérables pas la classe. CBitmapEx contient pas mal de méthodes utiles pour quelques effets simples, c'est tout son interêt.
Il faut prendre les méthodes et les adapter de la même façon que tu as fait avec par exemple ta méthode TourneAngleNonParticulier(). C'est très facile à faire.

Concernant CBitmapEx - Free C++ Bitmap Manipulation Class de darkoman, je confirme qu'elle est utilisable sous Borland C++ Builder 6 avec quelques modifications.

Sous cette forme par exemple :

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
#include "BitmapEx.h"
...
CBitmapEx *c=new CBitmapEx();
 
// chargement bitmap 8 à 32 bits via nom fichier
c->Load(FFichier.c_str()); 
 
// chargement via TBitmap (FBitmap)
// c->Load((HBITMAP)FBitmap->Handle); 
 
c->Negate();  // Applique un filtre négatif
c->FlipVertical(); // Retourne l'image verticalement
c->Rotate(45); // Rotation en degrés
 
// Affichage en 32 bits sur TImage via TBitmap
HBITMAP bitmap=NULL;
c->Save(bitmap);
Graphics::TBitmap *b=new Graphics::TBitmap();
b->Handle=bitmap;
Image1->Height=c->GetHeight();
Image1->Width=c->GetWidth();
Image1->Picture->Bitmap->Assign(b); 
Image1->Repaint();
b->ReleaseHandle();
DeleteObject(bitmap);
delete b;
 
// Affichage en 32 bits sur un Device Context (Panel1) via Handle
Panel1->Height=c->GetHeight(); 
Panel1->Width=c->GetWidth();
Panel1->Repaint();
c->Draw(GetDC(Panel1->Handle)); 
 
c->Save(FFichierDest.c_str()); // Sauvegarde en 24 bits
delete c;

J'ai du corriger pas mal de warnings et des erreurs de compatibilités (min,max) mais aussi afin d'éviter l'effet de remplissage à 2 octets qui créé une perturbation dans la classe au niveau du sizeof(BITMAPFILEHEADER) en renvoyant une taille de 16 (#pragma pack(push,2)) au lieu de 14.

La modification consiste à déclarer une structure dupliquée de BITMAPFILEHEADER en changeant le nom et à la rajouter dans le BitmapEx.h mais avec une contrainte de remplissage d'un octet seulement (#pragma pack(push,1)), ensuite j'ai remplacé tous les BITMAPFILEHEADER en BITMAPFILEHEADERC dans le .cpp et le .h :

Code:

1
2
3
4
5
6
7
8
9
#pragma pack(push,1)
typedef struct tagBITMAPFILEHEADERC {
        WORD    bfType;
        DWORD   bfSize;
        WORD    bfReserved1;
        WORD    bfReserved2;
        DWORD   bfOffBits;
} BITMAPFILEHEADERC, FAR *LPBITMAPFILEHEADERC, *PBITMAPFILEHEADERC;
#pragma pack(pop)

Et voilà le travail, une classe très complète pour travailler les images, on peut même faire des effets de feu, d'eau et de fumée sur les rafraichissements d'images (voir ici pour la documentation complète); une liste non-exhaustive des fonctions :

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
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
// Les actions
void Create(long width, long height);
void Create(CBitmapEx& bitmapEx);
void Create(CBitmapEx* pBitmapEx);
void Load(LPTSTR lpszBitmapFile);
void Load(LPBYTE lpBitmapData);
void Load(HBITMAP hBitmap);
void Save(LPTSTR lpszBitmapFile);
void Save(LPBYTE lpBitmapData);
void Save(HBITMAP& hBitmap);
 
// Les transformations
void Scale(long horizontalPercent=100, long verticalPercent=100);
void Rotate(long degrees=0, _PIXEL bgColor=_RGB(0,0,0));
void Crop(long x, long y, long width, long height);
void FlipHorizontal();
void FlipVertical();
void MirrorLeft();
void MirrorRight();
void MirrorTop();
void MirrorBottom();
 
// Les filtres
void Clear(_PIXEL clearColor=_RGB(0,0,0));
void Negative();
void Grayscale();
void Sepia(long depth=34);
void Emboss();
void Engrave();
void Pixelize(long size=4);
void Brightness(long brightness=0);
void Contrast(long contrast=0);
void Blur();
void GaussianBlur();
void Sharp();
void Colorize(_PIXEL color);
void Rank(BOOL bMinimum=TRUE);
void Spread(long distanceX=8, long distanceY=8);
void Offset(long offsetX=16, long offsetY=16);
void BlackAndWhite(long offset=128);
void EdgeDetect();
void GlowingEdges(long threshold=2, long scale=5);
void EqualizeHistogram(long levels=255);
void Median();
void Posterize(long levels=4);
void Solarize(long threshold=128);
 
// Traçer dans le bitmap
void Draw(HDC hDC);
void Draw(HDC hDC, long dstX, long dstY);
void Draw(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY);
void Draw(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long alpha);
void Draw(long dstX, long dstY, long dstWidth, long dstHeight, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long srcWidth, long srcHeight);
void Draw(long dstX, long dstY, long dstWidth, long dstHeight, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long srcWidth, 
	long srcHeight, long alpha);
void Draw(_QUAD dstQuad, CBitmapEx& bitmapEx);
void Draw(_QUAD dstQuad, CBitmapEx& bitmapEx, long alpha);
void Draw(_QUAD dstQuad, CBitmapEx& bitmapEx, long srcX, long srcY, 
	long srcWidth, long srcHeight);
void Draw(_QUAD dstQuad, CBitmapEx& bitmapEx, long srcX, long srcY, 
	long srcWidth, long srcHeight, long alpha);
void DrawTransparent(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, _PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long alpha, 
	_PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(long dstX, long dstY, long dstWidth, long dstHeight, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long srcWidth, 
	long srcHeight, _PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(long dstX, long dstY, long dstWidth, long dstHeight, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long srcWidth, 
	long srcHeight, long alpha, _PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(_QUAD dstQuad, CBitmapEx& bitmapEx, 
	_PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(_QUAD dstQuad, CBitmapEx& bitmapEx, long alpha, 
	_PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(_QUAD dstQuad, CBitmapEx& bitmapEx, long srcX, 
	long srcY, long srcWidth, long srcHeight, _PIXEL transparentColor=_RGB(0,0,0));
void DrawTransparent(_QUAD dstQuad, CBitmapEx& bitmapEx, long srcX, 
	long srcY, long srcWidth, long srcHeight, long alpha, 
	_PIXEL transparentColor=_RGB(0,0,0));
void DrawBlended(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long startAlpha, 
	long endAlpha, DWORD mode=GM_NONE);
void DrawBlended(long dstX, long dstY, long dstWidth, long dstHeight, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long srcWidth, 
	long srcHeight, long startAlpha, long endAlpha, DWORD mode=GM_NONE);
void DrawMasked(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, 
	_PIXEL transparentColor=_RGB(255,255,255));
void DrawAlpha(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long alpha, 
	_PIXEL alphaColor=_RGB(0,0,0));
void DrawCombined(long dstX, long dstY, long width, long height, 
	CBitmapEx& bitmapEx, long srcX, long srcY, DWORD mode=CM_SRC_AND_DST);
void DrawCombined(long dstX, long dstY, long dstWidth, long dstHeight, 
	CBitmapEx& bitmapEx, long srcX, long srcY, long srcWidth, 
	long srcHeight, DWORD mode=CM_SRC_AND_DST);
void DrawTextA(long dstX, long dstY, LPSTR lpszText, _PIXEL textColor, 
	long textAlpha, LPTSTR lpszFontName, long fontSize, 
	BOOL bBold=FALSE, BOOL bItalic=FALSE);
void DrawTextW(long dstX, long dstY, LPWSTR lpszText, 
	_PIXEL textColor, long textAlpha, LPTSTR lpszFontName, 
	long fontSize, BOOL bBold=FALSE, BOOL bItalic=FALSE);
 
// Remplacement de couleur
void ReplaceColor(long x, long y, _PIXEL newColor, 
	long alpha=20, long error=100, BOOL bImage=TRUE);
 
// Les informations
LPBITMAPFILEHEADER GetFileInfo() {return &m_bfh;}
LPBITMAPINFOHEADER GetInfo() {return &m_bih;}
long GetWidth() {return m_bih.biWidth;}
long GetHeight() {return m_bih.biHeight;}
long GetPitch() {return m_iPitch;}
long GetBpp() {return m_iBpp;}
long GetPaletteEntries() {return m_iPaletteEntries;}
LPRGBQUAD GetPalette() {return m_lpPalette;}
DWORD GetSize() {return m_dwSize;}
LPBYTE GetData() {return m_lpData;}
void SetResampleMode(RESAMPLE_MODE mode=RM_NEARESTNEIGHBOUR) 
	{m_ResampleMode = mode;}
RESAMPLE_MODE GetResampleMode() {return m_ResampleMode;}
BOOL IsValid() {return (m_lpData != NULL);}
void GetRedChannel(LPBYTE lpBuffer);
void GetGreenChannel(LPBYTE lpBuffer);
void GetBlueChannel(LPBYTE lpBuffer);
void GetRedChannelHistogram(long lpBuffer[256], BOOL bPercent=FALSE);
void GetGreenChannelHistogram(long lpBuffer[256], BOOL bPercent=FALSE);
void GetBlueChannelHistogram(long lpBuffer[256], BOOL bPercent=FALSE);
 
// Accès par pixel
_PIXEL GetPixel(long x, long y);
void SetPixel(long x, long y, _PIXEL pixel);

Et pour finir, je vous mets les 4 fichiers nécessaires avec la correction :

BitmapEx.cpp
BitmapEx.h
stdafx.cpp
stdafx.h

01/03/2013, 08h27
yarp

Oui tu peux travailler avec des DIB au lieu de TBitmap. Je pensais que tu voulais travailler avec la VCL. Note que c'est faisable également directement avec TBitmap.
J'ai une classe similaire, qui s'appelle également CBitmapEx :)

L'avantage de travailler avec des DIB au lieu d'objets VCL est que ce genre de code disponible largement sur le net est récupérable très facilement, et pour afficher une image un TPaintBox fait très bien l'affaire.

A noter également que avec cette classe pour les routines de dessin et certains objets de base on peux dès lors utiliser aussi la librairie WTL au lieu de TCanvas (http://tech.groups.yahoo.com/group/wtl/).
Je dessine avec CRect au lieu de TRect, CPoint au lieu de TPoint.
Pourquoi me direz vous ? les classes de la WTL collent de plus près à l'API Win32 et cela facilite son implémentation dans votre application. Par exemple le CustomDraw qui est assez mal fait dans CBuilder, et en général pour récupérer toutes les routines de dessin chinées ici et là. Faudrait que je trouve la temps de vous montrer ça plus en détail.

En tout cas bravo et merci pour la classe.