Comparing Two Bitmaps for Equality

4:43 12 Mar '08

CodeProject has somehow messed up the source code for this article. If you do a 'view source' on this page you will see the correct code. I will get an editor to fix it. But in the mean time you can change the two lines to: BYTE pLeftBits = new BYTE[BitmapInfoLeft.bmiHeader.biSizeImage]; BYTE pRightBits = new BYTE[BitmapInfoRight.bmiHeader.biSizeImage]; . I hope this helps.
Sign In·View Thread·Permalink

Extending this Idea

0:36 27 Jan '07

This is a great article but do you know how i could extend it to produce a third bitmap that is black and white, and where all the white pixels represent a difference in the two bitmaps?
Sign In·View Thread·Permalink	1.00/5 (1 vote)

9:52 27 Jan '07

A simple way would be to create a monochrome bitmap of the required size and do a simple GetPixel on each of the two previous bitmaps and a SetPixel on the new one.

for (int w = 0; w < width; ++w)
{
   for (int h = 0; h < height; ++h)
   {
      if (GetPixel(DC1, w, h) != GetPixel(DC2, w, h))
         SetPixel(DCNew, w, h, RGB(255, 255, 255));
      else
         SetPixel(DCNew, w, h, RGB(0, 0, 0));
   }
}

You may be right
I may be crazy
-- Billy Joel --

Within you lies the power for good, use it!!!

2:43 28 Jan '07

Hi, Thanks for that, i see where your going but im not that familiar with this topic so can you explain how you would create a monochrome bitmap and how you would get the height and width of the bitmap. Thanks.
Sign In·View Thread·Permalink

9:17 28 Jan '07

The width and height of the bitmap are in the BITMAPINFOHEADER referenced in the code above. It can also be obtained via a call to GetObject() where you fill a BITMAP structure from a HBITMAP object.

Use CreateBitmap() to create a monochrome bitmap, specifying 1 for the planes and bits per pixel, and NULL for the bits.

HBITMAP MonoBitmap = CreateBitmap(width, height, 1, 1, NULL);

Lookup BITMAPINFOHEADER, BITMAP, GetObject(), and CreateBitmap() in MSDN.

You may be right
I may be crazy
-- Billy Joel --

Within you lies the power for good, use it!!!

0:35 5 Feb '07

ok for the life of me i cant seem to get this to work can you take a look at my code and see whats wrong:

this is my code for placing my bit array into a HBITMAP

HDC image1Dc = CreateCompatibleDC ( hdc );

HBITMAP btmpNew = CreateCompatibleBitmap(hdc,pVih->bmiHeader.biWidth,pVih->bmiHeader.biHeight);

HBITMAP btmpNewTemp = (HBITMAP)SelectObject(image1Dc,btmpNew);

				

SetDIBits(

	image1Dc,

	btmpNew,

	0,

	pVih->bmiHeader.biHeight,

	cb.pBuffer,

	(BITMAPINFO*)&pVih->bmiHeader,

	DIB_RGB_COLORS

	);

 

width = pVih->bmiHeader.biWidth;

height = pVih->bmiHeader.biHeight;

if (btmpOld != NULL && btmpNew != NULL)

{

	CompareBitmaps(btmpOld, btmpNew);

}

And then this is my CompareBitmaps function



bool CWebcamTestViz::CompareBitmaps(HBITMAP HBitmapLeft, HBITMAP HBitmapRight)

{	

 

	HDC dc1 = CreateCompatibleDC ( NULL );

	HDC dc2 = CreateCompatibleDC ( NULL );

	HDC dcNew = CreateCompatibleDC ( NULL );

	int pixelCount = 0;

 

	SelectObject(dc1,HBitmapLeft);

	SelectObject(dc2,HBitmapRight);

	HBITMAP MonoBitmap = CreateBitmap(width, height, 1, 1, NULL);

	HBITMAP MonoBitmapTemp = (HBITMAP)SelectObject(dcNew,MonoBitmap);

 

	for (int w = 0; w < width; w+=5)

	{

	   for (int h = 0; h < height; h+=5)

	   {

		  if (GetPixel(dc1, w, h) != GetPixel(dc2, w, h))

		  {

			SetPixel(dcNew, w, h, RGB(255, 255, 255));

			pixelCount++;

		  }

		  else

		  {

			 SetPixel(dcNew, w, h, RGB(225, 0, 0));

		  }

	   }

	}

	

	

	if (pixelCount>50)

	{

		BitBlt(memDC,100,100,

				width,

				height,

				dcNew,0,0,SRCCOPY);	

 

		::DeleteObject(dc1);

		::DeleteObject(dc2);

		::SelectObject(dcNew,MonoBitmapTemp);

		::DeleteObject(MonoBitmap);

		::DeleteObject(dcNew);

		return true;

	}

	else

	{

		::DeleteObject(dc1);

		::DeleteObject(dc2);

		::SelectObject(dcNew,MonoBitmapTemp);

		::DeleteObject(MonoBitmap);

		::DeleteObject(dcNew);

		return false;

	}

}

Theres probably loads of errors!

9:58 6 Feb '07

I have not gone through your code to find all the errors, but you may find this tool[^] helpful. I use it all the time when I am doing anything that has to do with bitmaps. You may be right I may be crazy -- Billy Joel -- Within you lies the power for good - Use it!
Sign In·View Thread·Permalink	1.00/5 (1 vote)

3:55 7 Feb '07

Right i have managed to compare the two bitmaps now and produce a image to represent their differences. I have dome this via GetPixel and SetPixel, but these functions are far to slow for my purpose. Do you know of a different way to compare the pixels.

I have read that comparing them as DIBs is quicker so i have created two DIBs and placed them in seperate DCs but i dont know how to compopare them.

Can you help?

7:43 7 Feb '07

GetPixel() and SetPixel are slow, do doubt. But they are an easy way of doing it. To access the bitmap data directly is a lot more work for the programmer, but it definitely will run faster.

If you are going to go this way you have to take into account the colour depth of the bitmap. For colour depths of less than 16 bits per pixel your bitmap will have a colour table that the bitmap data indexes into. See GetDIBColorTable() and SetDIBColorTable().

For 16, 24 and 32 bit colour depths the data contains the actual colour values. The thing to remember about these is that every row in the bitmap data is DWORD aligned. 32 bits are the easiest to work with as in them every 32 bits is another colour and the DWORD alignment is automatic. 16 bits will have a dummy colour value at the end of every row if the width of the bitmap is an odd number, and 24 bits will have 1, 2 or 3 dummy bytes at the end of a row depending on the width of the bitmap. If you need to access the the individual red, green, blue, and alpha components of each colour than you also have to take into account the colour masks, but as long as both your images have the same colour depth that should not be neccesary.

See GetDIBits() and SetDIBits()

If you have any more questions you may get more and better answers if you ask them on the Visual C++ message board.

Good Luck!

You may be right
I may be crazy
-- Billy Joel --

Within you lies the power for good, use it!!!

Rafal Struzyk

7:09 11 Jul '07

Well... they used to be slow - have a look at my VERY simple CImage optimization wrapper
Sign In·View Thread·Permalink

Re: Great but far too simple

18:56 23 Mar '07

Ok, it has taken me a while. But I liked your idea so much I wanted to implement it in my Image Viewer[^] application. Here is what I came with:

note - pja::CBitmap and pja::CCompatibleDC are simple wrappers around the HBITMAP and HDC types

pja::CBitmap Compare(const pja::CBitmap &Bitmap1, const pja::CBitmap &Bitmap2, int x = 0, int y = 0, COLORREF ClrSame = 0x00FFFFFF, COLORREF ClrDiff = 0x00000000);
 
pja::CBitmap Compare(const pja::CBitmap &Bitmap1,   // The first bitmap
                     const pja::CBitmap &Bitmap2,   // The second bitmap
                     int x, int y,                  // The offset of the second bitmap from the first bitmap
                     COLORREF ClrSame,              // Colour used for pixels that are the same
                     COLORREF ClrDiff)              // Colour used for pixels that are different
{
    // Sanity check
    ASSERT (x > -Bitmap2.Width() && x < Bitmap1.Width());
    ASSERT (y > -Bitmap2.Height() && y < Bitmap1.Height());
 
    if (x <= -Bitmap2.Width() || x >= Bitmap1.Width() || y <= -Bitmap2.Height() || y >= Bitmap1.Height())
    {
        return pja::CBitmap();
    }
 
    // Setup the rectangles for where stuff gets drawn
    CRect Bitmap1Rect(0, 0, Bitmap1.Width(), Bitmap1.Height());
    CRect Bitmap2Rect(0, 0, Bitmap2.Width(), Bitmap2.Height());
 
    if (x < 0)
        Bitmap1Rect.OffsetRect(-x, 0);
    else
        Bitmap2Rect.OffsetRect(x, 0);
 
    if (y < 0)
        Bitmap1Rect.OffsetRect(0, -y);
    else
        Bitmap2Rect.OffsetRect(0, y);
 
    CRect FinalRect = Bitmap1Rect | Bitmap2Rect;
    CRect CombinedRect = Bitmap1Rect & Bitmap2Rect;
 
    // Create the bitmaps needed
    pja::CBitmap FinalBitmap(NULL, FinalRect.Width(), FinalRect.Height());
    pja::CBitmap CombinedBitmap(NULL, CombinedRect.Width(), CombinedRect.Height());
    pja::CBitmap MonoBitmap(CreateBitmap(CombinedRect.Width(), CombinedRect.Height(), 1, 1, NULL));
 
    // DCs for all the bitmaps
    pja::CCompatibleDC Bitmap1DC;
    pja::CCompatibleDC Bitmap2DC;
    pja::CCompatibleDC FinalBitmapDC;
    pja::CCompatibleDC CombinedBitmapDC;
    pja::CCompatibleDC MonoBitmapDC;
 
    // Select the bitmaps into the DCs
    SelectObject(Bitmap1DC, Bitmap1);
    SelectObject(Bitmap2DC, Bitmap2);
    SelectObject(FinalBitmapDC, FinalBitmap);
    SelectObject(CombinedBitmapDC, CombinedBitmap);
    SelectObject(MonoBitmapDC, MonoBitmap);
 
    // Combine the two supplied bitmaps,
    // same pixels will be white - all others will be whatever
    BitBlt(CombinedBitmapDC,
           0, 0, CombinedRect.Width(), CombinedRect.Height(),
           Bitmap1DC,
           CombinedRect.left > Bitmap1Rect.left ? CombinedRect.left : 0,
           CombinedRect.top > Bitmap1Rect.top ? CombinedRect.top : 0,
           SRCCOPY);
 
    BitBlt(CombinedBitmapDC, 0, 0, CombinedRect.Width(), CombinedRect.Height(),
           Bitmap2DC,
           CombinedRect.left > Bitmap2Rect.left ? CombinedRect.left : 0,
           CombinedRect.top > Bitmap2Rect.top ? CombinedRect.top : 0,
           0x00990066); //DSxn ROP

    // On 32 bit bitmaps we have to reset the alpha channel to zero
    if (CombinedBitmap.BitsPixel() >= 32)
    {
        SelectObject(CombinedBitmapDC, GetStockObject(WHITE_BRUSH));
        PatBlt(CombinedBitmapDC, 0, 0, CombinedBitmap.Width(), CombinedBitmap.Height(), 0x00A000C9); // DPa ROP
    }
 
    // transfer the combined bitmap to a black and white monochrome bitmap
    // white stays white, the rest turns black
    SetBkColor(CombinedBitmapDC, 0x00FFFFFF);
    BitBlt(MonoBitmapDC, 0, 0, CombinedRect.Width(), CombinedRect.Height(), CombinedBitmapDC, 0, 0, SRCCOPY);
 
    // Fill the background of the final bitmap with our background colour
    // TODO: Change this line when this function is imported into the Image Viewer
    //FillRect(FinalBitmapDC, FinalRect, CBrush(reinterpret_cast<COLORREF>(AfxGetMainWnd()->SendMessage(WMU_GETBGCOLOUR, 0, 0);
    FillRect(FinalBitmapDC, FinalRect, CBrush(RGB(236, 233, 216)));
 
    // Draw our two bitmaps
    if (FinalRect != CombinedRect)
    {
        BitBlt(FinalBitmapDC, Bitmap1Rect.left, Bitmap1Rect.top, Bitmap1Rect.Width(), Bitmap1Rect.Height(), Bitmap1DC, 0, 0, SRCCOPY);
        BitBlt(FinalBitmapDC, Bitmap2Rect.left, Bitmap2Rect.top, Bitmap2Rect.Width(), Bitmap2Rect.Height(), Bitmap2DC, 0, 0, SRCCOPY);
    }
 
    // Draw the differences using the supplied colours
    SetBkColor(FinalBitmapDC, ClrSame);
    SetTextColor(FinalBitmapDC, ClrDiff);
    BitBlt(FinalBitmapDC, CombinedRect.left, CombinedRect.top, CombinedRect.Width(), CombinedRect.Height(), MonoBitmapDC, 0, 0, SRCCOPY);
 
    return FinalBitmap;
}

You may be right
I may be crazy
-- Billy Joel --

Within you lies the power for good, use it!!!

Great but far too simple

IntVestor

6:53 21 Dec '06

The article is great but let's imagine two bitmaps with single different pixel each. Function will false them even if they obviosly are similar. So when comparing actual pixel data its possible to add some error level (passed in % in third variable).
That may be usefull when comparing images with different compression rate - for some lossy format.
Guess that will be more useful.

Yet again great article.