3 respuestas en este tema

[escafandra]

En ocasiones podemos plantearnos redimensionar una imagen para lo que podemos usar la propiedad Stretch de un TImage o dibujar con la API StretchBlt que dibuja redimensionando. El problema es que este método no da muy buena calidad de imagen y puede resultar poco apetecible, al menos en versiones antiguas de delphi y Builder o si trabajamos con la API directamente.

Usando GDI plus podemos conseguir resultados mucho mas aparentes, así que he escrito dos funciones simples, una para dibujar un bitmap al tamaño deseado y otra para cambiar el tamaño de un bitmap de forma que éste puede ser volcado a una imagen o guardado en un archivo con sus nuevas dimensiones.

Estas son las funciones GDI flat usadas:

delphi

// GDI+ Flat API...
function  GdiplusStartup(var GdiToken: DWORD; Startup, Output: PBYTE): Cardinal; stdcall external 'gdiplus';
procedure GdiplusShutdown(GdiToken: DWORD); stdcall external 'gdiplus';
function  GdipCreateBitmapFromHBITMAP(hbm: HBITMAP; hpal: HPALETTE; var GBitmap: THANDLE): Cardinal; stdcall external 'gdiplus';
function  GdipDisposeImage(image: THANDLE): Cardinal; stdcall external 'gdiplus';
function  GdipCreateFromHDC(DC: HDC; var Graphics: Pointer): Cardinal; stdcall external 'gdiplus';
function  GdipDeleteGraphics(graphics: Pointer): Cardinal; stdcall external 'gdiplus';
function  GdipDrawImageRect(graphics: Pointer; Image: THANDLE; x, y, w, h: Single): Cardinal; stdcall external 'gdiplus';

La primera función, DrawImageRect:

delphi

//---------------------------------------------------------------------------
// Dibuja un Bitmap en un hDC ajustando su tamaño para que quepa entero
// en las coordenadas dadas
procedure DrawImageRect(DC: HDC; Bitmap: HBITMAP; X, Y, W, H: integer);
var
  Graphics: Pointer;
  GBitmap:  THANDLE;
begin
  GdipCreateBitmapFromHBITMAP(Bitmap, 0, GBitmap);
  GdipCreateFromHDC(DC, Graphics);
  GdipDrawImageRect(Graphics, GBitmap, X, Y, W, H);
  GdipDisposeImage(GBitmap);
  GdipDeleteGraphics(Graphics);
end;

Un ejemplo de uso:

delphi

 
var
  gdiplusToken: DWORD;
  GdiPlusStartupInput: array[0..1] of int64;
begin
  // Inicializamos GDI+.
  GdiPlusStartupInput[0]:= 1; GdiPlusStartupInput[1]:= 0;
  if GdiplusStartup(gdiplusToken, @GdiPlusStartupInput, nil) <> 0 then exit;
 
  DrawImageRect(Image2.Picture.Bitmap.Canvas.Handle, Image1.Picture.Bitmap.Handle, 20, 20, 200, 150);
  Image2.Invalidate;
 
  // Shutdown GDI+
  GdiplusShutdown(gdiplusToken);
end;

La segunda función CreateResizeBitmap:

delphi

//-----------------------------------------------------------------------------
// Crea y devuelve un Bitmap con unas nuevas dimensiones y la imagen ajustada a estas
function CreateResizeBitmap(Bitmap: HBITMAP; H, W: integer): HBITMAP;
var
  Graphics: Pointer;
  GBitmap: THANDLE;
  DC, dcMem: HDC;
  bmOld: HBITMAP;
begin
  DC:= GetDC(0);
  Result:= CreateCompatibleBitmap(DC, W, H);
  dcMem:= CreateCompatibleDC(DC);
  bmOld:= SelectObject(dcMem, Result);
 
  GdipCreateFromHDC(dcMem, Graphics);
  GdipCreateBitmapFromHBITMAP(Bitmap, 0, GBitmap);
  GdipDrawImageRect(Graphics, GBitmap, 0, 0, H, W);
  GdipDisposeImage(GBitmap);
  GdipDeleteGraphics(Graphics);
 
  SelectObject(dcMem, bmOld);
  DeleteDC(dcMem);
  ReleaseDC(0, DC);
end;

Como creamos un Bitmap nuevo, somos responsables de borrar ese Handle con DeleteObject. Si lo asignamos a un TBitmap la VCL se encargará de hacerlo al destruirlo pero en otro caso somos responsables de su destrucción.

Un ejemplo de uso:

delphi

var
  gdiplusToken: DWORD;
  GdiPlusStartupInput: array[0..1] of int64;
begin
  // Inicializamos GDI+.
  GdiPlusStartupInput[0]:= 1; GdiPlusStartupInput[1]:= 0;
  if GdiplusStartup(gdiplusToken, @GdiPlusStartupInput, nil) <> 0 then exit;
 
  Image1.Picture.Bitmap.Handle:= CreateResizeBitmap(Image1.Picture.Bitmap.Handle, 100, 100); 
  Image1.Invalidate;
 
  // Shutdown GDI+
  GdiplusShutdown(gdiplusToken);
end;

Podremos guardar el HBITMAP con la VCL o bien usando GDI+ como en ejemplo de este hilo.

Finalmente añadir que debemos inicializar GDI+ antes de usar las funciones y cerrarlo después. Esto se puede incluir en las funciones para automatizarlo pero si vamos a hacer uso intensivo de GDI+ no tiene sentido abrir y cerrar cada vez, por ese motivo no lo he incluido en las funciones individuales. Podemos inicializar GDI+ al inicio del programa o de la sección que lo usa y cerrar al terminar.


Saludos.

[escafandra]

Ahora voy a publicar las funciones equivalentes en C++ tambien usando GDI+ flat:

cpp

#pragma link "Gdiplus.lib"
 
extern "C" {
DWORD WINAPI GdiplusStartup(ULONG_PTR *hToken, void *input, void *Output);
void  WINAPI GdiplusShutdown(ULONG_PTR token);
DWORD WINAPI GdipCreateBitmapFromHBITMAP(HBITMAP hBmp, HPALETTE hPal, HANDLE* GBitmap);
DWORD WINAPI GdipCreateFromHDC(HDC hDC, HANDLE* hGraphics);
DWORD WINAPI GdipDisposeImage(HANDLE hImage);
DWORD WINAPI GdipDeleteGraphics(HANDLE hGraphics);
DWORD WINAPI GdipGetDC(HANDLE hGraphics, HDC* hdc);
DWORD WINAPI GdipDrawImageRect(HANDLE hGraphics, HANDLE himage, float x, float y, float width, float height);
}
 
//-----------------------------------------------------------------------------
// Devuelve un Bitmap con unas nuevas dimensiones y la imagen ajustada a estas
HBITMAP CreateResizeBitmap(HBITMAP hBitmap, int W, int H)
{
  HANDLE Graphics;
  HANDLE GBitmap;
  HDC hDC = GetDC(0);
  HDC hdcMem = CreateCompatibleDC(0);
  HBITMAP Result = CreateCompatibleBitmap(hDC, W, H);
  HBITMAP hbmOld = SelectObject(hdcMem, Result);
 
  GdipCreateFromHDC(hdcMem, &Graphics);
  GdipCreateBitmapFromHBITMAP(hBitmap, 0, &GBitmap);
  GdipDrawImageRect(Graphics, GBitmap, 0, 0, W, H);
  GdipDisposeImage(GBitmap);
  GdipDeleteGraphics(Graphics);
 
  //Result = GetCurrentObject(hdcMem, OBJ_BITMAP);
  SelectObject(hdcMem, hbmOld);
  DeleteDC(hdcMem);
  ReleaseDC(0, hDC);
  return Result;
}
 
//---------------------------------------------------------------------------
// Dibuja un Bitmap en un hDC ajustando su tamaño para que quepa entero
// en las coordenadas dadas
void DrawImageRect(HDC hDC, HBITMAP hBitmap, int X, int Y, int W, int H)
{
  HANDLE Graphics;
  HANDLE GBitmap;
 
  GdipCreateBitmapFromHBITMAP(hBitmap, 0, &GBitmap);
  GdipCreateFromHDC(hDC, &Graphics);
  GdipDrawImageRect(Graphics, GBitmap, X, Y, W, H);
  GdipDisposeImage(GBitmap);
  GdipDeleteGraphics(Graphics);
}

Usando DrawImageRect:

cpp

// Initialize GDI+.
__int64 gdiplusStartupInput[3];
ULONG_PTR  gdiplusToken;
gdiplusStartupInput[0] = 1; gdiplusStartupInput[1] = 0;
if(GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL)) return;
 
DrawImageRect(GetDC(0), Image2->Picture->Bitmap->Handle, 0, 0, 100, 100);
Image2->Invalidate();
 
 
//shutdown GDI+
GdiplusShutdown(gdiplusToken);

Usando CreateResizeBitmap:

cpp

// Initialize GDI+.
__int64 gdiplusStartupInput[3];
ULONG_PTR  gdiplusToken;
gdiplusStartupInput[0] = 1; gdiplusStartupInput[1] = 0;
 
Image1->Picture->Bitmap->Handle = CreateResizeBitmap(Image1->Picture->Bitmap->Handle, 100, 100);
Image1->Invalidate();
 
// Shutdown GDI+
GdiplusShutdown(gdiplusToken);

Los comentarios de la versión delphi son válidos para la versión Builder.


Saludos.

[ELKurgan]

Muchas gracias por el aporte, maestro.

[poliburro]

Amigo mio, muy muy interesante aporte. Muchas gracias por compartirnos parte de tu conocimiento.

Saludos