|
<-- Capítulo III |
Regresar a la página principal |
Capítulo V --> |
|
Capítulo IV |
|||
Bitmap (Mapa de bits) |
|||
 |
|||
|
A continuación se presentaran temas relacionados con la manipulación de BITMAP (Mapa de bits), las cuales pueden ser de mucha ayuda al desarrollar una aplicación que las contengan. Cabe mencionar que las medidas que se usan en estas funciones son en unidades logicas, es decir, parámetros como X, Y, Width y Height, vienen especificado en unidades logicas. Para este proyecto se necesita lo siguiente: 20 PicturesBox 10 Command o botones, Tienen que colocar los PictureBox de esta manera, el picture1 va al lado del picture2, el picture3 al lado del picture4, y así sucesivamente, el tamaño de los PictureBox en píxel es 60X60, es decir, tendrán una columna de impares y una columnas de pares, luego al lado del par picture1 y picture2 colocan Command1, de picture3 y picture4 colocan Command2 y así sucesivamente, y a los PictureBox impares le colocan la imagen azul.jpg, que viene con este documento, y a los PictureBox pares le colocan rojo.jpg. Y luego pegan este código: Arranquen el programa y presionen a los botones y se darán cuenta de lo que sucede, ustedes dirán ¿Eduardo que esto?. En esta sección introduzco una nueva API que es BitBlt. Esta API en pocas palabras lo que hace es copiar una imagen fuente a un dispositivo destino. Pero ustedes dirán: estas mintiendo Eduardo ya que algunos de los cuadritos aparecen con otro color, y yo les digo: lo que ocurre es que hay diferentes formas de copiar una imagen aplicando ciertos cambios lógicos. Como lo veremos a continuación: Api: Declare Function BitBlt Lib "gdi32" (ByVal hDestDC As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) As Long Ya dije que esta API se usa para copiar un bitmap de un lugar a otro, es decir, desde un dispositivo de contexto fuente a un dispositivo de contexto destino, analicemos sus parámetros: hDestDC: dispositivo de contexto DESTINO, es decir, quien recibe la imagen. x, y: estas dos variables determinan el vértice izquierdo superior donde vamos a copiar. nWidth, nHeight: determinan el ancho y alto de la copia. hSrcDC: dispositivo de contexto de ORIGEN, es decir, de donde se saca la imagen a copiar. xSrc, ySrc: estas dos variables determinan el vértice izquierdo superior donde vamos a empezar a copiar. dwRop: Constante que determinan el tipo de copia que se va hacer. Esta variable puede tomar los siguientes valores: Const BLACKNESS = &H42 Const DSTINVERT = &H550009 Const MERGECOPY = &HC000CA Const MERGEPAINT = &HBB0226 Const NOTSRCCOPY = &H330008 Const NOTSRCERASE = &H1100A6 Const PATCOPY = &HF00021 Const PATINVERT = &H5A0049 Const PATPAINT = &HFB0A09 Const SRCAND = &H8800C6 Const SRCCOPY = &HCC0020 Const SRCERASE = &H440328 Const SRCINVERT = &H660046 Const SRCPAINT = &HEE0086 Const WHITENESS = &HFF0062 Creo que los parámetros son fáciles de entender hasta dwRop, para explicar este parámetro vamos al código: Empecemos con command1:
Vamos a leer en castellano esta línea de código: usamos BitBlt cuyo HDC destino es PICTURE2.HDC, lo que recibas lo copias empezando por el vértice 0,0, el tamaño de la copia será Picture1.width, Picture1.height, y se copiara la imagen que esta en Picture1.hdc, y empiezas a copiar desde el punto 0,0, y vas a usar BLACKNESS para copiar. El “castellano” se entiende hasta BLACKNEES. A continuación describimos que hace cada constante: Const BLACKNESS = &H42 Rellena el destino, con el color asociado al primer índice de la paleta. En este caso como no hemos creado ninguna paleta, pues usa la paleta por defecto cuyo primer elemento (0) es el negro, por esa razón vemos negro en el PictureBox destino. Si tuviéramos una paleta de colores asociada, pues entonces tomaría el color perteneciente al índice 0 que no necesariamente tendría que ser negro. Const WHITENESS = &HFF0062 Lo mismo que el anterior pero toma el segundo elemento, es decir, el índice (1), que en la paleta por defecto es el blanco. Const SRCCOPY = &HCC0020 Hace una copia exacta desde el origen hasta el destino, por eso ven el color azul en el PictureBox destino. Const SRCAND = &H8800C6 Hace una copia usando el AND lógico para establecer los píxeles de la imagen destino, y ustedes dirán ¿Qué significa eso? ¿Por qué veo negro en el resultado?. Pues fácil: el color azul se escribe de esta manera en Hexadecimal 0000FF, Los primeros 00 corresponden al ROJO los segundo 00 corresponden al verde y el FF corresponden al Azul, es decimal sería 0 = rojo, 0 = verde, y 255 = azul, es fácil ver esto si lo ven con el PAINT de Windows o cualquier programa grafico, ya que estas imágenes son de 24 bits, significa que hay 3 bytes por color, que sería el RGB, es decir, el rojo, verde y azul equivalen a un 1 byte c/u = 8 bits , y el valor máximo que podemos alcanzar con 8 bits es 255. Lo que nos interesa es 0000FF que en binario sería algo así: ROJO = 00000000 = 0 VERDE = 00000000 = 0 AZUL = 11111111 = 255 Es decir, RGB(0,0,255) o 0000FF Estamos hablando del PictureBox origen que es de color azul, el otro picture destino tiene color rojo que sería: ROJO = 11111111= 255 VERDE = 00000000 = 0 AZUL = 00000000 = 0 Es decir, RGB(255,0,0) o FF0000 Pongamos esto en dos líneas: Color del PictureBox origen: 00000000 00000000 11111111 Color del PictureBox destino: 11111111 00000000 00000000 Si aplicamos un AND lógico = 00000000 00000000 00000000 Es decir, el resultado es RGB(0,0,0) ¿Qué es este color? Pues negro, por esa razón es que el resultado da negro ¿Claro? Si no esta claro revisen sus apuntes de lógica, que algunas ves debieron ver en la carrera de informática. Const PATPAINT = &HFB0A09 Equivale al operador lógico O. El resultado sería así: Color del PictureBox origen: 00000000 00000000 11111111 Color del PictureBox destino: 11111111 00000000 00000000 Si aplicamos un O lógico = 11111111 00000000 11111111 Y tenemos RGB(255,0,255). Lo que equivale al color que ven como resultado, si no me creen, abran paint, colóquense en la sección de editar colores y coloquen R = 255, G = 0 y B = 255 y verán el mismo color. Const SRCERASE = &H440328 Este lo que hace es: Invierte los colores del PictureBox o HDC destino y luego aplica el operador AND con el PictureBox fuente: Color del PictureBox destino: 11111111 00000000 00000000 Invertimos 00000000 11111111 11111111 Color del PictureBox origen: 00000000 00000000 11111111 Color Invertido destino 00000000 11111111 11111111 Si aplicamos un AND lógico = 00000000 00000000 11111111 Y tenemos el azul de nuevo. Const SRCINVERT = &H660046 Aplica el operador lógico XOR. Color del PictureBox origen: 00000000 00000000 11111111 Color del PictureBox destino: 11111111 00000000 00000000 Si aplicamos un XOR lógico = 11111111 00000000 11111111 Pero vamos aplicar de nuevo un XOR, pero con la imágen cambiada, es decir: Color del PictureBox origen: 00000000 00000000 11111111 Color del PictureBox destino: 11111111 00000000 11111111 Si aplicamos un XOR lógico = 11111111 00000000 00000000 Pueden ver que el resultado es la imagen que estaba antes, por esa razón, si ustedes aprietan 2 veces el botón, verán primero el violeta que es el resultado del primer XOR, y luego verán el color que estaba originalmente, este comando o constante es muy usado cuando quieres copiar imágenes y deshacer el cambio. Const NOTSRCCOPY = &H330008 Invierte los colores del dispositivo de origen y lo copia en el destino, sin importar lo que tenga el destino: Color del PictureBox origen: 00000000 00000000 11111111 Invertimos 11111111 11111111 00000000 Const NOTSRCERASE = &H1100A6 Combina los colores usando O y luego los invierte: Color del PictureBox origen: 00000000 00000000 11111111 Color del PictureBox destino: 11111111 00000000 00000000 Si aplicamos un O lógico = 11111111 00000000 11111111 Invertimos el resultado 00000000 11111111 00000000 Y tenemos VERDE. Const DSTINVERT = &H550009 Invierte los colores del destino sin importar la imagen fuente. Color del PictureBox destino: 11111111 00000000 00000000 Invierte 00000000 11111111 11111111 Y tenemos Agua Marine o Azul Claro. Const PATCOPY = &HF00021 Const PATINVERT = &H5A0049 Const PATPAINT = &HFB0A09 Estas constantes hacen lo mismo que sus equivalentes, SRCCOPY, SCRINVERT y SRCPAINT, respectivamente, pero con las brochas. El hecho que haya seleccionado imágenes UNICOLORES fue para que vieran el efecto rápidamente, pero ese cálculo lógico se hace con cualquier imagen de cualquier color. ENCOGIENDO Y ESTIRANDO IMAGENES Para este proyecto necesitamos 8 pictureBox 4 botones (dejen los nombres que VB pone por defecto), a los PictureBox impares (Picture1, Picture3, etc), coloquenle la imagen “imagen4.jpg” que acompaña a este proyecto. Luego peguen este código: Es sencillo ver lo que hace el programa al presionar los distintos botones. Pues solo trabajamos con una sola función API (StretchBlt), que explicamos a continuación: Api: Declare Function StretchBlt Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nSrcWidth As Long, ByVal nSrcHeight As Long, ByVal dwRop As Long) As Long Esta función se encarga de encoger o alargar una imagen, y manipulando algunos parámetros podemos obtener un efecto de espejo. Parámetros: hdc = dispositivo de contexto “destino”, es decir, donde ira la imagen transformada x, y, nWidth, nHeight = es como el “recuadro” destino o donde se ubicara la imagen seleccionada. hSrcDC = dispositivo de contexto que contiene la imagen a transformar. xSrc, ySrc, nSrcWidth, nSrcHeight = es como el “recuadro” origen o donde se encuentra la imagen a manipular. OJO: en el proyecto ustedes ven, como la imagen en los primeros 2 botones, se encoge y se estira, pero ustedes pueden tomar, pasando bien los parámetros de arriba, porciones de la imagen y estirar o encoger esa porción, es decir, no tienen por que trabajar con la imagen completa. dwRop = toma exactamente las mismas constantes que la función Bitblt. Y funciona exactamente igual que Bitblt. Vean que para aplicar los efectos de espejo, lo único que hay que hacer es poner en negativo algunos valores. DEGRADANDO COLORES (GRADIENTE) Esta función es muy bonita, pero no funciona en Windows 95, es decir, sirve para sistemas operativos del 98 en adelante. Para este proyecto solo tienen que pegar este código al formulario: Cuando arrancan el proyecto verán un Msgbox que le indica el como quieren el degradado. Hay dos maneras de hacerlo de manera triangular o rectangular, si presionan “NO” al Msgbox, el programa les pedirá 2 colores, traten de colocar colores bien distintos para que vean el efecto, luego verán que el formulario presenta una degradación de un color a otro. En caso de presionar “SI” el programa muestra un degradado triangular. Para esas degradaciones existen 2 funciones dedicadas a ello. Una se encarga de la rectangular y la otra de la triangular. Presten atención, ya que las funciones tienen ciertos detalles a tener en cuenta. Empecemos por la más sencilla que es la rectangular. Api: Declare Function GradientFillRect Lib "msimg32" Alias "GradientFill" (ByVal hDC As Long, pVertex As TRIVERTEX, ByVal dwNumVertex As Long, pMesh As GRADIENT_RECT, ByVal dwNumMesh As Long, ByVal dwMode As Long) As Long Esta funciones no son tan fáciles de entender, una de las primeras cosas a entender es que el hecho que tenga como parámetro un HDC, no implica que la degradación o gradiente se aplica a todo el HDC, se pueden tener 10 rectángulos ubicados en distintas partes del HDC y cada rectángulo poseer una degradación distinta de los demás. Así que presten mucha atención a los parámetros. pVertex = es una estructura del tipo TRIVERTEX que se representa de la siguiente manera: Private Type TRIVERTEX End Type Esta estructura configura las esquinas de un rectángulo, con cada color, luego Windows se encarga de hacer el gradiente o degradado de una esquina a otra. Hay un detalle importante vean que el color se tiene que separar en RED, GREEN, y BLUE esto nunca antes lo habían usado, siempre usábamos la función RGB para establecer un color, pero ahora la función RGB no funciona de mucho, ya que se necesitan los colores por separado. Es por esa razón que tengo 3 funciones: ColorAzul, ColorVerde, ColorRojo, estas funciones lo que hacen es que dado un color en formato RGB, descomponen cada una de sus componentes, por ejemplo ColorAzul, recibe el valor del color y esta función retorna solo el color azul. Recuerden algo, los colores no son mas que números, en Internet para resolver este problema lo que hacían era usar un calculo hexadecimal, no recuerdo por que yo no use eso, lo que sucede es que yo quería que funcionara para cualquier color y creo que esa técnica no funcionaba, y como consecuencia tuve que diseñar mis propias funciones, pero aquellos que puedan encontrar una forma mas rápida y efectiva de separar los colores, pues usenlo. El parámetro Alpha de la estructura según la documentación es para uso futuro. dwNumVertex = determina el número de vértices. Que en nuestro caso son 2. pMesh = pasamos un arreglo con el orden de los vértices. dwNumMesh = determinamos cuantos rectángulos tenemos. dwMode = determina como queremos el gradiente, es decir si vertical (arriba-abajo) u horizontal (izquierda-derecha). Puede tomar dos valores: Const GRADIENT_FILL_RECT_H As Long = &H0 ‘ Horizontal Const GRADIENT_FILL_RECT_V As Long = &H1 ‘ Vertical Para verlo mas claro analicemos el ejemplo: vert(0), es nuestro primer vértice el cual empezamos en 0,0 y le configuramos sus respectivos RGB por separados asignándole las variables que diseñe para ellos. El llenado de esas variables lo ven en el evento Form_Load. Luego vert(1) determina la esquina inferior derecha, la cual toma los valores de altura y anchura del respectivo formulario. Llenamos la variable “gRect” de esta manera:
Este 0 en “UpperLeft”, significa que la esquina superior izquierda se corresponde al elemento 0 del vector o arreglo “vert”, y 1 significa lo mismo pero para la posición número 1 del mismo vector. A continuación llamamos a la función:
Aquí le decimos a Windows lo siguiente: “en el HDC = Me.hDC, dibuja un gradiente cuyo vértices empiezan en el vector “vert(0)” a su vez le indicamos que son 2, luego te paso el orden de cómo configuro los vértices, en la variable “gRect”, le indicamos que queremos 1 rectángulo, y al final le indicamos que el gradiente lo haga de manera horizontal”. Ahora vamos a una función un poquito compleja ya que es triangular, se trabaja de la misma manera pero en ves de 2 vértices tendremos 3 y yo lo complique un poquito al no graficar solo un triangulo sino 4. Api: Declare Function GradientFillTriangle Lib "msimg32" Alias "GradientFill" (ByVal hDC As Long, pVertex As TRIVERTEX, ByVal dwNumVertex As Long, pMesh As GRADIENT_TRIANGLE, ByVal dwNumMesh As Long, ByVal dwMode As Long) As Long Los parámetros son exactamente iguales a su homologa de arriba, con la diferencia que al final al parámetro “dwMode” le ponemos GRADIENT_FILL_TRIANGLE. Indicando que va a rellenar el triangulo que configuramos. Ustedes cuando presionan “SI” en el Msgbox ven 4 triángulos que se detallan un poquito en la figura de abajo:  Las líneas de color crema son colocadas a propósito, para que distingan los 4 triángulos. Todos ustedes inmediatamente intuyen que se necesitan 12 vértices para los 4 triángulos, en realidad si se necesitan, pero como en nuestro ejemplo si se dan cuenta, nuestro centro es blanco, es decir, un vértice de cada triangulo tiene el color blanco, en nuestro caso es el vértice del centro. Por consiguiente, en nuestro ejemplo usamos solo 5 vértices y no 12. ¿Cómo hacemos eso? Pueden ver que el vector o arreglo “coloretriangulo” tiene configurado 5 vértices, estos vértices se configuran igual que el rectángulo. Lo importante esta en el vector “triángulos”, ya que este arreglo que a su ves contiene una estructura de tipo TRIVERTEX, configura como son cada triangulo. Analicemos el código: Triangulo 1
Triangulo 2
Y así sucesivamente con los 2 restantes, dense cuenta que todos los triángulos tienen un vértice en común es el número 2. Que si vemos su configuración es la siguiente: Vean que el X e Y no es mas que el centro del formulario, y el color que uso es &HFFFFFF que es el blanco. Luego de configurar nuestros triángulos con sus respectivos vértices llamamos a la función:
Aquí le decimos a Windows lo siguiente: “en el HDC = Me.hDC, dibuja un gradiente cuyo vértices están en el vector “colortriangulo(0)” a su vez le indicamos que son 5, luego le paso el orden de cómo configuro los vértices de cada triangulo en la variable “triángulos”, le indicamos que configuramos 4 triángulos, y al final le indicamos que llene con el degrado cada triangulo.” ¿Lo ven? Puede ser difícil al principio, para mi lo fue, es interesante ver que algo que podrías considerar relativamente simple, requiera de muchas cositas para su funcionamiento, pero queda claro que con esta función se pueden hacer efectos muy interesantes a nivel grafico. NOTA: aquí utilizamos 2 funciones API, una para el degrado rectangular y otra para el triangulo, en caso de usar C++ o C pueden usar una solo función que se llama GradientFill, ¿Cómo sabe si es rectangular o triangular?. Básicamente por el parámetro número 4, “pMesh” y por el último parámetro donde le pasamos las constantes GRADIENT_FILL_RECT_H, GRADIENT_FILL_RECT_V o GRADIENT_FILL_TRIANGLE. De todas maneras pueden informarse por la ayuda de la documentación oficial en Internet. A partir de Windows 98, se incluyo una nueva librería que permite poner imágenes encima de otras con cierta semitransparencia, efecto muy interesante en algunas ocasiones. Para este proyecto solo se necesitan 2 pictureBox, déjenlos con los nombre que VB les pone por defecto. Luego coloquen las imágenes Costa3.jpg y Costa4.jpg en la carpeta donde esta el proyecto, al picture1 le colocan Costa3.jpg, al picture2 Costa4.jpg y por último peguen este código en el formulario: Para ver el efecto, den clic a la imagen que se muestra en el picture que cubre toda la pantalla, a medida que dan clic se dan cuenta que la otra imagen poco a poco se va superponiendo a la original. Api: Declare Function AlphaBlend Lib "msimg32.dll" (ByVal hdcDest As Long, ByVal xOriginDest As Long, ByVal yOriginDest As Long, ByVal WidthDest As Long, ByVal HeightDest As Long, ByVal hdcSrc As Long, ByVal xOriginSrc As Long, ByVal yOriginSrc As Long, ByVal WidthSrc As Long, ByVal HeightSrc As Long, ByVal BLENDFUNCT As Long) As Long Esta es la función encargada de tal efecto, ella consta de 10 parámetros similares a las funciones antes vistas: HdcDest = HDC del dispositivo destino. XOriginDest = Coordenada X de la esquina superior izquierda del rectángulo destino YOriginDest = Coordenada Y de la esquina superior izquierda del rectángulo destino WidthDest = Ancho del rectángulo destino. HeightDest = Alto del rectángulo destino HdcSrc = HDC del dispositivo origen XOrigintSrc = Coordenada X de la esquina superior izquierda del rectángulo origen YOriginSrc = Coordenada Y de la esquina superior izquierda del rectángulo origen WidthSrc = Ancho del rectángulo origen HeightSrc = Alto del rectángulo origen. Estos parámetros ya deben de ser familiares para ustedes, el parámetro donde se configura el efecto de transparencia es el último, BLENDFUNCT que es una estructura. Private Type BLENDFUNCTION End Type Esta estructura todavía esta en sus inicios. El parámetro BlendOp en al actualidad solo puede tomar un solo parámetro y es AC_SRC_OVER. BlendFlags se le pone 0 ya que todavía no se le ha programado la utilidad que en un futuro deberá cumplir. El parámetro de la estructura que en realidad es importante es SourceConstantAlpha este puede tomar un valor entre 0 y 255, siendo 0 transparencia total, y 255 opacidad total. Jugando con los valores intermedios tenemos la semitransparencia, es decir, podemos ver las dos imágenes al mismo tiempo. Por último tenemos el parámetro AlphaFormat que en nuestro ejemplo tiene 0, lo que significa que la transparencia es global. En caso de tomar esta constante: Private Const AC_SRC_ALPHA = &H1 La transparencia sería Local. ¿Qué es eso de transparencia local y global? En nuestro proyecto usamos transparencia global, lo que quiere decir, es que se aplica la misma transparencia a todos los píxeles de la imagen. ¿Qué quiero decir? Si ponen en SourceConstantAlpha = 125 la función procesara la transparencia en todos los píxeles basándose en el valor de 125. Con la transparencia local no sucede lo mismo, pero en este caso hay que usar imágenes de 32 Bits, no se pueden usar imágenes de 24 Bits. ¿Por qué? Las imágenes de 32 Bits se componen de la siguiente manera 0x00aavvrr, siendo a = azul, v = verde y r = rojo el RGB que ustedes conocen. Pero ahora hay un 00 a la izquierda del azul, ese 00 es la intensidad ALPHA para ese píxel, es decir, la transparencia de un píxel es independiente del otro píxel. Lo que no sucede con la transparencia global. No muestro un ejemplo de ello, ya que carezco de un software grafico que permita crear una imagen de 32 bit donde pueda tocar este byte encargado del ALPHA o transparencia. Pero en caso de que ustedes lo hagan, la función se escribe exactamente igual con la diferencia que en la estructura BLENDFUNCTION en el parámetro AlphaFormat colocan la constante que mencione arriba. Cabe destacar que al usar Transparencia Local no importa el valor que introduzcan en SourceConstantAlpha, ya que él toma el valor del byte alpha del píxel de la imagen. En nuestro proyecto yo lo que hago es incrementar SourceConstantAlpha con una variable “contador” cada vez que se presiona clic en la imagen. Este contador empieza desde 0 hasta 255 que es cuando se ve la segunda imagen completa. ¿Si el último parámetro es una estructura por que en la función aparece como un tipo Long? En realidad no se por que el valor es de tipo long, pero lo curioso no es la estructura, es esta función API:
Esta función API la ayuda de MSND no la tiene, así que no la va explicar tal cual como es, sino que voy hacer una interpretación lógica de la función. Ya vimos que la función API AlphaBlend no acepta la estructura como parámetro sino un valor de tipo “long” (Estoy hablando del parámetro número 11), lo que yo entiendo que hace esta API es convertir la estructura a una variable de tipo LONG (NOTA: estoy suponiendo que la función API realiza eso, ya que no encontré en la ayuda de MSDN la definición de la misma), ya que si vemos el API en su declaración: Private Declare Sub RtlMoveMemory Lib "kernel32.dll" (Destination As Any, Source As Any, ByVal Length As Long) Luego que convertimos la estructura a una variable de tipo long se la pasamos sin problema a la función API AlphaBlend. Esto de “convertir” depende de cómo se vea, pueda que la variable colocada en “Destination” tenga es un puntero a la estructura. Es usual ver en la televisión esos programas que muestran los trucos para hacer las películas, uno de los cuales es grabar a los actores en un fondo cuyo color sea sólido y luego la computadora suplanta ese color por una imagen ya cargada. Menciono esto, ya que Windows a partir de la versión 98 incluyó una función que hace tal efecto, es decir, dada una imagen con un color fijo de fondo podemos extraer ese color dejando solo la imagen que nos interesa. Para este proyecto solo se necesitan 2 pictureBox y un botón, los nombres de cada control serán los que VB les pone por defecto, al “picture1”, le asignan la imagen “transparencia.bmp” que viene con este documento. Y luego pegan este código: Como pueden ver es un ejemplo muy sencillo, al correr el programa ven una imagen con un fondo amarillo, luego al presionar clic en el botón, el picture 2 toma la imagen pero sin ese color. Api: Declare Function TransparentBlt Lib "msimg32.dll" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nSrcWidth As Long, ByVal nSrcHeight As Long, ByVal crTransparent As Long) As Boolean A estas alturas del manual los 10 primeros parámetros de esta función ya deben de ser familiares para ustedes, los primeros 5 especifican el área del HDC destino que recibirá la imagen, los otros 5 especifican el área del HDC de origen, es decir, quien contiene la imagen original. El parámetro interesante es el último “crTransparent”, este último parámetro no es mas que el color que tomaremos como transparente, es decir, en nuestro proyecto tenemos en el parámetro RGB(255,255,0) , con esto le indicamos que a la imagen de origen, le quite todos los píxeles que son amarillo. Ustedes en sus imágenes pueden usar cualquier color como transparente, eso quedara a criterio de cada uno. |
|||
|
<-- Capítulo III |
Regresar arriba |
Regresar a la página principal |
Capítulo V --> |
BitBlt Picture2.hdc, 0, 0, Picture1.Width, Picture1.Height, Picture1.hdc, 0, 0, BLACKNESSDesarrollado por Eduardo Roa. Copyright 2002-2003 Todos los derechos reservados