FTP | CCD | Buscar | Trucos | Trabajo | Foros |
#1
|
||||
|
||||
AlphaBlend
saludos, como indica el título de este post mi duda es relacionada con esta API, lo que quiero lograr es opacidad entre dos Bitmaps, tengo una referencia implementada para C++ y cuando intento llevarla a Pascal usando Delphi no me funciona absolutamente nada, en realidad no tengo ni idea de que hace realmente con los objetos en juego, si alguien ya tiene alguna experiencia con esta API les pido que me den una mano, aquí les va la referencia quie tengo pero para C++,
Código:
void DrawAlphaBlend (HWND hWnd, HDC hdcwnd) { HDC hdc; // handle of the DC we will create BLENDFUNCTION bf; // structure for alpha blending HBITMAP hbitmap; // bitmap handle BITMAPINFO bmi; // bitmap header VOID *pvBits; // pointer to DIB section ULONG ulWindowWidth, ulWindowHeight; // window width/height ULONG ulBitmapWidth, ulBitmapHeight; // bitmap width/height RECT rt; // used for getting window dimensions UINT32 x,y; // stepping variables UCHAR ubAlpha; // used for doing transparent gradient UCHAR ubRed; UCHAR ubGreen; UCHAR ubBlue; float fAlphaFactor; // used to do premultiply // get window dimensions GetClientRect(hWnd, &rt); // calculate window width/height ulWindowWidth = rt.right - rt.left; ulWindowHeight = rt.bottom - rt.top; // make sure we have at least some window size if ((!ulWindowWidth) || (!ulWindowHeight)) return; // divide the window into 3 horizontal areas ulWindowHeight = ulWindowHeight / 3; // create a DC for our bitmap -- the source DC for AlphaBlend hdc = CreateCompatibleDC(hdcwnd); // zero the memory for the bitmap info ZeroMemory(&bmi, sizeof(BITMAPINFO)); // setup bitmap info // set the bitmap width and height to 60% of the width and height of each of the three horizontal areas. Later on, the blending will occur in the center of each of the three areas. bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmi.bmiHeader.biWidth = ulBitmapWidth = ulWindowWidth - (ulWindowWidth/5)*2; bmi.bmiHeader.biHeight = ulBitmapHeight = ulWindowHeight - (ulWindowHeight/5)*2; bmi.bmiHeader.biPlanes = 1; bmi.bmiHeader.biBitCount = 32; // four 8-bit components bmi.bmiHeader.biCompression = BI_RGB; bmi.bmiHeader.biSizeImage = ulBitmapWidth * ulBitmapHeight * 4; // create our DIB section and select the bitmap into the dc hbitmap = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, &pvBits, NULL, 0x0); SelectObject(hdc, hbitmap); // in top window area, constant alpha = 50%, but no source alpha // the color format for each pixel is 0xaarrggbb // set all pixels to blue and set source alpha to zero for (y = 0; y < ulBitmapHeight; y++) for (x = 0; x < ulBitmapWidth; x++) ((UINT32 *)pvBits)[x + y * ulBitmapWidth] = 0x000000ff; bf.BlendOp = AC_SRC_OVER; bf.BlendFlags = 0; bf.SourceConstantAlpha = 0x7f; // half of 0xff = 50% transparency bf.AlphaFormat = 0; // ignore source alpha channel if (!AlphaBlend(hdcwnd, ulWindowWidth/5, ulWindowHeight/5, ulBitmapWidth, ulBitmapHeight, hdc, 0, 0, ulBitmapWidth, ulBitmapHeight, bf)) return; // alpha blend failed // in middle window area, constant alpha = 100% (disabled), source // alpha is 0 in middle of bitmap and opaque in rest of bitmap for (y = 0; y < ulBitmapHeight; y++) for (x = 0; x < ulBitmapWidth; x++) if ((x > (int)(ulBitmapWidth/5)) && (x < (ulBitmapWidth-ulBitmapWidth/5)) && (y > (int)(ulBitmapHeight/5)) && (y < (ulBitmapHeight-ulBitmapHeight/5))) //in middle of bitmap: source alpha = 0 (transparent). // This means multiply each color component by 0x00. // Thus, after AlphaBlend, we have a, 0x00 * r, // 0x00 * g,and 0x00 * b (which is 0x00000000) // for now, set all pixels to red ((UINT32 *)pvBits)[x + y * ulBitmapWidth] = 0x00ff0000; else // in the rest of bitmap, source alpha = 0xff (opaque) // and set all pixels to blue ((UINT32 *)pvBits)[x + y * ulBitmapWidth] = 0xff0000ff; endif; bf.BlendOp = AC_SRC_OVER; bf.BlendFlags = 0; bf.AlphaFormat = AC_SRC_ALPHA; // use source alpha bf.SourceConstantAlpha = 0xff; // opaque (disable constant alpha) if (!AlphaBlend(hdcwnd, ulWindowWidth/5, ulWindowHeight/5+ulWindowHeight, ulBitmapWidth, ulBitmapHeight, hdc, 0, 0, ulBitmapWidth, ulBitmapHeight, bf)) return; // bottom window area, use constant alpha = 75% and a changing // source alpha. Create a gradient effect using source alpha, and // then fade it even more with constant alpha ubRed = 0x00; ubGreen = 0x00; ubBlue = 0xff; for (y = 0; y < ulBitmapHeight; y++) for (x = 0; x < ulBitmapWidth; x++) { // for a simple gradient, base the alpha value on the x // value of the pixel ubAlpha = (UCHAR)((float)x / (float)ulBitmapWidth * 255); //calculate the factor by which we multiply each component fAlphaFactor = (float)ubAlpha / (float)0xff; // multiply each pixel by fAlphaFactor, so each component // is less than or equal to the alpha value. ((UINT32 *)pvBits)[x + y * ulBitmapWidth] = (ubAlpha << 24) | //0xaa000000 ((UCHAR)(ubRed * fAlphaFactor) << 16) | //0x00rr0000 ((UCHAR)(ubGreen * fAlphaFactor) << 8) | //0x0000gg00 ((UCHAR)(ubBlue * fAlphaFactor)); //0x000000bb } bf.BlendOp = AC_SRC_OVER; bf.BlendFlags = 0; bf.AlphaFormat = AC_SRC_ALPHA; // use source alpha bf.SourceConstantAlpha = 0xbf; // use constant alpha, with // 75% opaqueness AlphaBlend(hdcwnd, ulWindowWidth/5, ulWindowHeight/5+2*ulWindowHeight, ulBitmapWidth, ulBitmapHeight, hdc, 0, 0, ulBitmapWidth, ulBitmapHeight, bf); // do cleanup DeleteObject(hbitmap); DeleteDC(hdc); } mil gracias de antemano colega, espero que me puedan ayudar. saludos! aeff! |
#2
|
||||
|
||||
SemiPanel.pas
Cita:
|
#3
|
||||
|
||||
saludos, colega, el código que me planteas realmente no lo entiendo, mira, yo soy un novat en este mundo de la programación con gráficos y Dispositivos de Contextos (DC), no se que me quieres dar a entender, mira, esta cita creo que fue sacada de un foro para los miembros millenium ¿verdad?, y yo no pertenezco a esta categoría por razones ajenas a este foro, mira, si pudieras darme una explicación más detallada realmente estaría muy agradecido, mi objetivo es lograr opacidad entre dos Bitmaps o al menos entender esta API y lograrla hacerla funcionar.
me puedes ayudar?? mil gracias de antemano! saludos! aeff! |
#4
|
||||
|
||||
bueno, existe una implementación de un componente en ese foro, el [TSemiPanel], ¿no?, funciona perfectamente, ahora, me puedes explicar el funcionamiento básico de esta función que logra la opacidad, es decir, en parte ando buscando una explicación en pseudocódigo, porque realmente no entiendo nada de nada de estas operaciones.
mil gracias de antemano! saludos! aeff! |
#5
|
||||
|
||||
Conociendo el código que postea cHackAll, la explicación puede durar años
Si te consuela, yo tampoco entiendo el código, tendría que estudiarlo durante días Saludos
__________________
Si usted entendió mi comentario, contácteme y gustosamente, se lo volveré a explicar hasta que no lo entienda, Gracias. |
#6
|
||||
|
||||
Cita:
Cita:
Ahora, cada imagen estaría compuesta (en el mejor de los casos) por una matriz de pixeles X * Y, cada una de 24 bits (8 del R, 8 del G y 8 del B ). Para "mezclar" dos pixeles debes promediar cada R, G y B Código:
Sí; R1 = 10, G1 = 10, B1 = 10 R2 = 250, G2 = 250, B2 = 0 entonces; R = (10 + 250) / 2 = 130 G = (10 + 250) / 2 = 130 B = (10 + 0) / 2 = 5 Lee tambien. Saludos |
#7
|
||||
|
||||
saludos, cHackAll, me alegra me hallas respondido colega, hasta el momento se me van aclarando las dudas, pero a la vez se me van ocurriendo más, en una de las explicaciones que planteas dentro del enlace que me recomendaste publicas lo siguiente:
Código:
x = ((x1 / MAX(x)) * ((Alpha / MAX(Alpha)) * MAX(x)) + x2) / 2 Donde: x = Resultado x1 = R, G o B del pixel de la imagen x2 = R, G o B del pixel de fondo Alpha = valor "Alpha channel" MAX(x) = valor maximo de x MAX(Alpha) = valor máximo de Alpha mil gracias de antemano colega. saludos! aeff! |
#8
|
||||
|
||||
Cita:
MAX(x) segun dicha ecuacion sería 255 (máximo de R, G & B) y MAX(Alpha) podría ser 100 siempre y cuando Alpha sea el porcentaje. PD; La ecuacion esta pensada para un proceso generico, sin embargo el #2 y el #6 son mas concretos al caso. Saludos |
#9
|
||||
|
||||
saludos!
mira colega, anteriormente mencionas: Cita:
Cita:
programáticamente sería asi, una función:
ahora, esta implementación da como resultado el promedio dado por Alpha entre dos canales, y esta otra función para mezclar todos los canales de un área:
sin embargo, necesito la ayuda de ustedes para que me ayuden a optimizar el código, ¿de que forma puedo hacer que funcione más rápido? mil gracias de antemano! saludos! aeff! Última edición por aeff fecha: 30-11-2008 a las 08:23:21. |
#10
|
||||
|
||||
es decir, algún método para que el Canvas deje de pintar mientras cambio el valor de sus pixeles y luego que aplique los cambios????
saludos! |
#11
|
||||
|
||||
Claro, estas trabajando con Canvas.Pixels[X, Y] para acceder a cada pixel, eso es muy lento cuando trabajas con toda la imagen. cHackAll en su ejemplo te muestra como acceder a un puntero que apunta a los pixels de una línea
Así sólo tabajas en memoria y ganas tiempo. En este hilo, encontrarás cómo llegar a la imagen en memoria de un bitmap, concretamente aquí. Saludos. |
|
|
Temas Similares | ||||
Tema | Autor | Foro | Respuestas | Último mensaje |
Aplicar AlphaBlend pero a un componente | quetzal | Varios | 1 | 19-09-2004 09:56:24 |
|