Comparar dos variables HBITMAP (C++)

[carbon]

Hola a todos. Tengo un programa en donde capturo una parte de la pantalla, luego lo hago nuevamente y quisiera comparar esas dos "capturas". Tengo lo siguiente:

Código C++:

HBITMAP Cap1, Cap2;
 
// Capturar parte de pantalla
    LPDEVMODE DM;
    HBITMAP hBmpImage;
    HDC lhDcSource;
    HDC lhDcTarget;
 
    lhDcSource = CreateDC("DISPLAY", "", "", DM);
    lhDcTarget = CreateCompatibleDC(lhDcSource);
 
    hBmpImage = CreateCompatibleBitmap(lhDcSource, 100, 13);
 
    SelectObject(lhDcTarget, hBmpImage);
    BitBlt(lhDcTarget, 0, 0, 100, 13, lhDcSource, 150, 100, SRCCOPY);
 
     Cap1 = hBmpImage; // Primera captura
     Cap2 = hBmpImage; // Segunda captura
 
    DeleteDC(lhDcTarget);
    ReleaseDC((HWND)hBmpImage, lhDcSource);
 

He probado con Cap1 == Cap2 pero siempre resulta diferente, que deberia hacer? Mas alla de que obviamente en el codigo anterior siempre seran iguales las capturas 1 y 2.

Gracias desde ya!

[Fw190]

Yo programo en C, mis conocimientos de C++ son muy básicos, así que pido disculpas si se me escapa alguna tontería.

Del código que has posteado, deduzco que HBITMAP debe ser una estructura de datos o una clase. En tal caso, las asignaciones tendrían que hacerse elemento a elemento (ya sea "a pelo" o en una función de sobrecarga del operador '='), y lo mismo ocurriría con las comparaciones de igualdad (operador '=='). Supongo que la clase/estructura HBITMAP te la proporciona alguna librería, ya sea de tu propio compilador o añadida externa, en la que el operador de asignación ('=') viene sobrecargado "de serie", pero no así el operador de igualdad ('==').

Otra posibilidad es que Cap1, Cap2 sean simplemente punteros (es decir, que el tipo HBITMAP corresponda a un puntero a algo), con lo cual Cap1 y Cap2 van a ser distintos, aunque apunten a dos bloques de memoria que contengan lo mismo. Si este es el caso, obviamente la comparación tendrías que hacerla entre los citados bloques de memoria.

Tanto si es un caso como si es el otro, todo pasa por conocer la estructura de HBITMAP (o lo apuntado por ello).

Saludos,

[carbon]

Hola Fw190, gracias por la respuesta!

Es exactamente como dices (en el segundo caso), por lo que he visto son dos punteros apuntando a dos bloques de memoria, lo que he comprobado al mostrar en pantalla las variables Cap1 y Cap2. Siendo este el tema, como debería hacer?

Muchas gracias nuevamente,

P.D: HBITMAP corresponde a windows.h

[Fw190]

No indicaste qué compilador utilizas, conviene indicarlo de cara a precisar mejor una respuesta.

En efecto, HBITMAP (así como otros muchos tipos) está definido en Windows.h como puntero a void, por lo menos en el compilador que tengo disponible en este momento (Lcc-Win32), y es de suponer que estará definido igual en otros compiladores.

Puesto que lo que tienes son punteros a los bloques de memoria donde están los datos, para hacer comparaciones tendrías que conocer la estructura del bloque de memoria y comparar los elementos que te interesen. También, conociendo el tamaño del bloque, se podría comparar directamente un bloque de memoria con otro, pero aquí puede ocurrir que sean distintos algunos elementos de cada estructura aunque la parte del dibujo sea igual.

Consulta las ayudas que tenga tu compilador sobre las APIs de Windows, a partir de, por ejemplo, CreateCompatibleBitmap, a ver si a través de algún enlace te lleva a las estructuras de datos que necesitas.

Edita Windows.h, ahí verás varias estructuras de datos relacionadas con bitmaps. Únicamente habría que saber cuál de ellas es la que te corresponde.

[carbon]

Hola nuevamente. Uso el compilador MinGW con Code::Blocks. Gracias por tu respuesta. Yo he intentado obtener la direccion de memoria del pointer y leerla, pero para hacerlo necesito saber el tamaño y no se si este camino, para poder comparar estas dos variables finalmente, es el correcto. Que opinas de esto?
Con respecto a lo que me dices, el código original es de visual basic 6, y yo lo he migrado a C++ y es ahí en donde surgen los problemas (no manejo con mucha facilidad este lenguaje). Por lo tanto no sabría decirte por qué es que se utiliza el tipo HBITMAP o si es el más adecuado.

Gracias de nuevo!

[Fw190]

Bien, en principio, una vez que tienes el puntero, sería cuestión de ir mirando a cuál de esas estructuras (esas que deben aparecer en Windows.h) podría corresponder. Es decir, suponiendo que sea una de ellas, utilizar los elementos que te indiquen las dimensiones y el apuntador a los datos para ver si la cosa cuadra o no. Una vez que des con el tipo de estructura concreto, ya sería comparar los bloques de memoria apuntados.

Para estas comprobaciones, lo suyo sería utilizar un depurador, colocar puntos de ruptura justo después de cargar las imágenes, y examinar la memoria correspondiente. El depurador para compiladores GNU creo que se llama gdb, pero no sé qué posibilidades de visualización de variables tiene. A las bravas, puedes guardar bloques de memoria en archivos binarios y examinarlos mediante algún editor hexadecimal (en internet puedes encontrar varios, gratuitos).

También puede ser que en alguna librería gráfica encuentres lo que necesitas para lo que quieres hacer, por ejemplo mira en estas páginas:

http://www.thefreecountry.com/sourcecode/graphics.shtml
http://www.freebyte.com/programming/...phicslibraries

Saludos,

[carbon]

Agradezco realmente tu ayuda, intentaré hacer lo mejor posible de acuerdo a tus consejos y comento!

Gracias!