Determining if 2 images are the same

Question

This is my program code for comparing if 2 images are the same. It basically uses the open dialog and opens 1 image at a time and puts it in 1 picture box.

I heard that GetPixel() method may be slow. Is there a more efficient and faster way to compare 2 if 2 images are the same?

Bitmap image1 = null;
Bitmap image2 = null;

public Form1()
{
    InitializeComponent();
}

private void button1_Click(object sender, EventArgs e) //first image open
{
    OpenFileDialog openDialog = new OpenFileDialog();
    if (openDialog.ShowDialog() == DialogResult.OK)
    {
        image1 = new Bitmap(openDialog.FileName);
        pictureBox1.Image = image1;
    }   
}

private void button2_Click(object sender, EventArgs e) //second image open
{

    OpenFileDialog openDialog = new OpenFileDialog();
    if (openDialog.ShowDialog() == DialogResult.OK)
    {
        image2 = new Bitmap(openDialog.FileName);
        pictureBox2.Image = image2;
    }  
}

private void button3_Click(object sender, EventArgs e) //compare button
{
    if (compare(image1, image2))
    {
        MessageBox.Show("Same Image.");
    }

    else
    {
        MessageBox.Show("Different Image.");
    }
}

private bool compare(Bitmap bmp1, Bitmap bmp2) 
{
    bool equals = true;
    bool flag = true;  //Inner loop isn't broken

    //Test to see if we have the same size of image
    if (bmp1.Size == bmp2.Size)
    {
        for (int x = 0; x < bmp1.Width; ++x)
        {
            for (int y = 0; y < bmp1.Height; ++y)
            {
                if (bmp1.GetPixel(x, y) != bmp2.GetPixel(x, y))
                {
                    equals = false;
                    flag = false;
                    break;
                }
            }
            if (!flag)
            {
                break;
            }
        }
    }
    else
    {
        equals = false;
    }
    return equals;
}

Answer 1

You can use the LockBits method and pointers to access the image data directly.

Example for 24 bpp images:

bool equals = true;
Rectangle rect = new Rectangle(0, 0, bmp1.Width, bmp1.Height);
BitmapData bmpData1 = bmp1.LockBits(rect, ImageLockMode.ReadOnly, bmp1.PixelFormat);
BitmapData bmpData2 = bmp2.LockBits(rect, ImageLockMode.ReadOnly, bmp2.PixelFormat);
unsafe {
  byte* ptr1 = (byte*)bmpData1.Scan0.ToPointer();
  byte* ptr2 = (byte*)bmpData2.Scan0.ToPointer();
  int width = rect.Width * 3; // for 24bpp pixel data
  for (int y = 0; equals && y < rect.Height; y++) {
    for (int x = 0; x < width; x++) {
      if (*ptr1 != *ptr2) {
        equals = false;
        break;
      }
      ptr1++;
      ptr2++;
    }
    ptr1 += bmpData1.Stride - width;
    ptr2 += bmpData2.Stride - width;
  }
}
bmp1.UnlockBits(bmpData1);
bmp2.UnlockBits(bmpData2);

Answer 2

One thing I have done in the past is to convert the images to 64-bit encoded strings and just string compare. It won't be as fast as using pointers, naturally. However, it can be done entirely in managed code, it doesn't require you to know bits per pixel, and it works for the Image base class.

byte[] image1Bytes;
byte[] image2Bytes;

using(var mstream = new MemoryStream())
{
    image1.Save(mstream, image1.RawFormat);
    image1Bytes = mstream.ToArray();
}

using(var mstream = new MemoryStream())
{
    image2.Save(mstream, image2.RawFormat);
    image2Bytes = mstream.ToArray();
}

var image164 = Convert.ToBase64String(image1Bytes);
var image264 = Convert.ToBase64String(image2Bytes);

return string.Equals(image164, image264);

Answer 3

I'll focus on problems in compare().

You're using the wrong equality comparison for the bitmap size. You need to compare the contents of the Size objects, not whether they are the same reference.

A variable named flag should be a… red flag! Not only is it vaguely named, its presence suggests that your code is ineffective. Avoid using variables for flow control; find more active ways to get to where you need to go.

In this case, the solution is an early return. As soon as you find a single difference between the two images, you're done! You don't even need the equals variable.

I would also rename compare() for clarity, and make it static because it is a pure function of its two parameters.

private static bool Equals(Bitmap bmp1, Bitmap bmp2) 
{
    if (!bmp1.Size.Equals(bmp2.Size))
    {
        return false;
    }
    for (int x = 0; x < bmp1.Width; ++x)
    {
        for (int y = 0; y < bmp1.Height; ++y)
        {
            if (bmp1.GetPixel(x, y) != bmp2.GetPixel(x, y))
            {
                return false;
            }
        }
    }
    return true;
}

Answer 4

Note that Bitmap inherits from Image, which implements IDisposable. This means you very much better call Dispose() on those objects are you are done with them (way many paths here with UI event handlers), or put them into using blocks. Same goes for OpenFileDialog.

As per my comments, some using usage (and try..finally usage, incorporating Guffa's answer):

private Bitmap image1;

private Bitmap image2;

public Form1()
{
    this.InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
    using (var openDialog = new OpenFileDialog())
    {
        if (openDialog.ShowDialog() != DialogResult.OK)
        {
            return;
        }

        this.DisposeImage1();
        this.image1 = new Bitmap(openDialog.FileName);
    }

    this.pictureBox1.Image = this.image1;
}

private void button2_Click(object sender, EventArgs e)
{
    using (var openDialog = new OpenFileDialog())
    {
        if (openDialog.ShowDialog() != DialogResult.OK)
        {
            return;
        }

        this.DisposeImage2();
        this.image2 = new Bitmap(openDialog.FileName);
    }

    this.pictureBox2.Image = this.image2;
}

private void button3_Click(object sender, EventArgs e)
{
    MessageBox.Show(Compare(this.image1, this.image2) ? "Same Image." : "Different Image.");
}

private void Form1_FormClosed(object sender, FormClosedEventArgs e)
{
    this.DisposeImage2();
    this.DisposeImage1();
}

private static bool Compare(Bitmap bmp1, Bitmap bmp2)
{
    // Test to see if we have the same size of image
    if (bmp1.Size != bmp2.Size)
    {
        return false;
    }

    var rect = new Rectangle(0, 0, bmp1.Width, bmp1.Height);
    var bmpData1 = bmp1.LockBits(rect, ImageLockMode.ReadOnly, bmp1.PixelFormat);

    try
    {
        var bmpData2 = bmp2.LockBits(rect, ImageLockMode.ReadOnly, bmp1.PixelFormat);

        try
        {
            unsafe
            {
                var ptr1 = (byte*)bmpData1.Scan0.ToPointer();
                var ptr2 = (byte*)bmpData2.Scan0.ToPointer();
                var width = 3 * rect.Width; // for 24bpp pixel data

                for (var y = 0; y < rect.Height; y++)
                {
                    for (var x = 0; x < width; x++)
                    {
                        if (*ptr1 != *ptr2)
                        {
                            return false;
                        }

                        ptr1++;
                        ptr2++;
                    }

                    ptr1 += bmpData1.Stride - width;
                    ptr2 += bmpData2.Stride - width;
                }
            }
        }
        finally
        {
            bmp2.UnlockBits(bmpData2);
        }
    }
    finally
    {
        bmp1.UnlockBits(bmpData1);
    }

    return true;
}

private void DisposeImage1()
{
    if (this.image1 == null)
    {
        return;
    }

    this.pictureBox1.Image = null;
    this.image1.Dispose();
    this.image1 = null;
}

private void DisposeImage2()
{
    if (this.image2 == null)
    {
        return;
    }

    this.pictureBox2.Image = null;
    this.image2.Dispose();
    this.image2 = null;
}

Answer 5

Have a look at this SO question.

https://stackoverflow.com/q/35151067/4062881

It decreases the size of image, turns it B&W, and then uses GetPixel() to generate hash.

It is much faster, efficient, and works! It is able to find equal images with:

• different file formats (e.g. jpg, png, bmp)
• rotation (90, 180, 270) - by changing the iteration order of i and j
• different dimensions (same aspect is required)
• different compression (tolerance is required in case of quality loss like jpeg artifacts) - you can accept a 99% equality to be the same image and 50% to be a different one.

Cheers..!! ;)

Answer 6

Why convert in base64 or compare every pixel if there's hash comparison? Do something like this:

byte[] fileData = File.ReadAllBytes(filePath);
byte[] hash = MD5.Create().ComputeHash(fileData);

And simply compare the hashes.

You'll need MD5CryptoServiceProvider for that.