1 algoritmo básico
si el centro de rotación cx, cy; ángulo de rotación a; posición x, y del píxel en la rotación nx, NY
nx Cosa * = X + (X-CX) -sina * (y-CY)
NY = y + sina * (x-cx) + cosa * (y-cy)
2 Rotación de texto
http://www.codeguru.com/bitmap/RotateByShear.shtml
http://www.codeguru.com/bitmap/rotate_bitmap.shtml
http://www.ittide.com/document/article/graphic/12.html
Rotar imagen de 256 bits
/ ************************ * *********************************************
*
* Función nombre:
* RotateDIB ()
*
* Parámetros:
* LPSTR lpDIB-puntero al DIB de origen
* int iRotateAngle-el ángulo de rotación (0-360 grados)
*
* Valor de retorno:
* HGLOBAL-devuelve el nuevo identificador DIB si la rotación es correcto, de lo contrario devuelve NULL.
*
* Descripción:
* Esta función se utiliza para rotar la imagen DIB con el centro de la imagen como centro y devolver el asa del DIB recién generado.
* Llamar a esta función ampliará automáticamente la imagen para mostrar todos los píxeles. La función utiliza el
algoritmo de interpolación * de vecino más cercano para la interpolación.
*
********************************************** *********************** /
HGLOBAL WINAPI RotateDIB (LPSTR lpDIB, int iRotateAngle)
{ // Ancho y alto de la imagen de origen // float irotateangle = iRotateAngle * 3.1415926 / 180 LONG lWidth; LONG lHeight; // el ancho y alto de la imagen después de la rotación LONG lNewWidth; LONG lNewHeight; // el número de bytes por línea de la imagen LONG lLineBytes; // el ancho de la imagen después de la rotación (lNewWidth ', debe ser 4 múltiplos) a LONG lNewLineBytes; // puntero a la imagen de origen LPSTR lpDIBBits; // puntero al puntero de píxel de origen LPSTR lpSrc; // después de girar el mango nuevo DIB hDIB hDIB; // puntero a la rotación del imagen correspondiente a píxeles LPSTR lpDst; // Puntero a la imagen rotada LPSTR lpNewDIB;
LPSTR lpNewDIBBits;
// Puntero a la estructura BITMAPINFO (Win3.0)
LPBITMAPINFOHEADER lpbmi;
// Puntero a la estructura
BITMAPCOREINFO LPBITMAPCOREHEADER lpbmc;
// Variable de bucle ; (las coordenadas del píxel en el nuevo DIB)
LONG i The
;
coordenadas del píxel en la fuente DIB
LONG i0;
LONG j0;
// Ángulo de rotación (radianes)
float fRotateAngle;
// El seno y el coseno del ángulo de rotación
float fSina, fCosa;
// Las coordenadas de las cuatro esquinas de la fuente image (en el centro de la imagen es el origen del sistema de coordenadas)
float fSrcX1, fSrcY1, fSrcX2, fSrcY2, fSrcX3, fSrcY3, fSrcX4, fSrcY4;
// las coordenadas de las cuatro esquinas después de la rotación (el origen del sistema de coordenadas es el image center)
float fDstX1, fDstY1, fDstX2, fDstX2, fDstY3, fDstX4, fDstY4;
// Dos constantes intermedias
float f1, f2;
// Encuentra la posición inicial del píxel de la imagen DIB de origen
lpDIBBits = :: FindDIBBits (lpDIB);
/ / Obtener el "ancho" de la imagen (un múltiplo de 4)
lWidth = :: DIBWidth (lpDIB);
// Calcular el número de bytes por línea de la imagen
lLineBytes = WIDTHBYTES (lWidth * 8);
// Obtener la altura de la imagen
lHeight = :: DIBHeight (lpDIB);
// Cambiar el ángulo de rotación de grados Convertir a radianes
fRotateAngle = (float) RADIAN (iRotateAngle);
// Calcula el seno del ángulo de rotación (doble) fRotateAngle
fSina = (float) sin (fRotateAngle);
// Calcula el coseno del ángulo de rotación (double) fRotateAngle
fCosa = (float) cos (fRotateAngle);
// Calcula las coordenadas de las cuatro esquinas de la imagen original (toma el centro de la imagen como el origen del sistema de coordenadas)
fSrcX1 = (float) (- (lWidth- 1) / 2);
fSrcY1 = (flotar) ((lAltura- 1) / 2);
fSrcX2 = (flotar) ((lAncho-1) / 2);
fSrcY2 = (flotar) ((lAltura-1) / 2) ;
fSrcX3 = (flotar) (- (lAncho-1) / 2);
fSrcY3 = (flotar) (- (lAltura-1) / 2);
fSrcX4 = (flotar) ((lAncho-1) / 2);
fSrcY4 = (float) (- (lHeight-1) / 2);
// Calcula las coordenadas de las cuatro esquinas de la nueva imagen (toma el centro de la imagen como el origen del sistema de coordenadas)
fDstX1 = fCosa * fSrcX1 + fSina * fSrcY1;
fDstY1 = -fSina * fSrcX1 + fCosa * fSrcY1;
fDstX2 = fCosa * fSrcX2 + fSina * fSrcY2;
fDstY2 = -fSina * fSrcX2 + fCosa * fSrcY2;
fDstX3 = fCosa * fSrcX3 + fSina *
fSrcY3 = -fSrcY3;
fSrcY 3 fCosa * fSrcX4 + fSina * fSrcY4;
fDstY4 = -fSina * fSrcX4 + fCosa * fSrcY4;
// Calcular el ancho real de la imagen rotada
lNewWidth = (LONG) (max (fabs (fDstX4-fDstX1), fabs (fDstX3) );
// Calcula el número de bytes en cada línea de la nueva imagen
lNewLineBytes = WIDTHBYTES (lNewWidth * 8);
// Calcula la altura de la imagen rotada
lNewHeight = (LONG) (max (fabs (fDstY4-fDstY1), fabs (fDstY3 -fDstY2)) + 0,5);
// Dos constantes, por lo que
f1 no se calcula cada vez después = (float) (-0.5 * (lNewWidth-1) * fCosa-0.5 * (lNewHeight-1) * fSina
+ 0.5 * (lWidth-1));
f2 = (float) (0.5 * (lNewWidth-1) * fSina-0.5 * (lNewHeight-1) * fCosa
+ 0.5 * (lHeight-1));
// Asignar memoria para guardar el nuevo DIB
hDIB = (HDIB):: GlobalAlloc (GHND, lNewLineBytes * lNewHeight + * (LPDWORD) lpDIB + :: PaletteSize (lpDIB));
// Determine si la asignación de memoria falla
si (hDIB == NULL)
{ // No se pudo asignar la devolución de memoria NULL; } // Bloquear memoria lpNewDIB = (char *) :: GlobalLock ((HGLOBAL) hDIB); // Copiar el encabezado DIB y la paleta memcpy (lpNewDIB, lpDIB, * (LPDWORD) lpDIB + :: PaletteSize (lpDIB)); // Encontrado nuevo DIB posición inicial del píxel lpNewDIBBits = :: FindDIBBits (lpNewDIB); // Obtener puntero
lpbmi = (LPBITMAPINFOHEADER) lpNewDIB;
lpbmc = (LPBITMAPCOREHEADER) lpNewDIB;
// Actualiza la altura y el ancho de la imagen en el DIB
if (IS_WIN30_DIB (lpNewDIB))
{ // Para Windows 3.0Ne DIB lpbmi-> biwidth = lpbmi- > > biHeight = lNewHeight; } else { // Para DIB en otros formatos lpbmc-> bcWidth = (unsigned short) lNewWidth; lpbmc-> bcHeight = (unsigned short) lNewHeight; } // Opere en cada línea de la imagen para (i = 0; i <lNewHeight; i ++) { // Opere en cada columna de la imagen para (j = 0; j <lNewWidth; j ++) { // Puntero a la i-ésima fila y j-ésimo píxel del nuevo DIB // Note el ancho y el alto es el ancho y alto del nuevo DIB lpDst = (char *) lpNewDIBBits + lNewLineBytes * (lNewHeight-1-i) + j;
// Calcula la coordenada del píxel en la fuente DIB
i0 = (LONG) (- ((float) j) * fSina + ((float) i) * fCosa + f2 + 0.5);
j0 = (LONG) ((( float) j) * fCosa + ((float) i) * fSina + f1 + 0.5);
// Determinar si está dentro del rango de la imagen fuente
if ((j0> = 0) && (j0 <lWidth) && ( i0> = 0) && (i0 <lHeight))
{ // Puntero a la línea i0th y el j0th pixel del DIB de origen lpSrc = (char *) lpDIBBits + lLineBytes * (lHeight-1-i0) + j0; // Copiar los píxeles * lpDst = * lpSrc; } else { // Para los píxeles que no están en la imagen de origen, asigne directamente un valor de 255 * ((unsigned char *) lpDst) = 255; } } } // return hDIB; }
Optimización adicional, modo de visualización actual
16:
555 bits: 0rrrrrgggggbbbbb
565 bits: rrrrrggggggbbbbb
24:
rrrrrrrggggggggbbbbbbbb
32:
aaaaaaaarrrrrrrrggggggggbbbbbbbb
Determine el modo de visualización GetDeviceCaps (* m_pDC, BITSPIXEL) para
Utilice dc-> GetCurrentBitmap () -> GetBitmapBits para obtener los datos.