Comparing bitmap images for differences?

Discussion in 'Python' started by lanwrangler@gmail.com, May 1, 2007.

  1. Guest

    I know it's a long shot but does anyone have any pointers to generic
    algorithms - or, even better, Python code - for comparing images and
    computing a value for the "difference" between them?

    What I want to do is to compare two bitmap images (taken from a
    webcam, so I'll likely be using PIL) and get some idea of the
    "difference" between them so I can tell if something in the image has
    changed, eg, a person has entered the field of view. I've had a look
    at the PIL documentation and all it really told me was how little I
    knew about image processing :) and I couldn't see any recipes in the
    Python Cookbook that are aimed at this problem area. In a perfect
    world I'd love a method such as CompareImage(Img1, Img2) which would
    give a result of 255 if they're identical and 0 if not one pixel
    matches with a sliding scale inbetween but I know I'm probably asking
    for a lot there...

    Some ideas I've had is, maybe, increasing the contrast on both images
    (to take out variation in lighting etc), then compressing the results
    to get a hash value and comparing the hash, but that sounds likely to
    produce a lot of false positives. I note that PIL provides a
    histogram function for counting pixel colour values which sounds
    potentially useful and if no-one's got any better ideas I'll probably
    start working in that direction. Or, maybe, dump the bitmap data into
    a numpy array and do some kind of FFT on that but that feels very CPU-
    intensive.

    Those are my ideas so far but I thought it would be worth asking here
    first in case there are some known-good algorithms for doing this kind
    of thing rather than me trying to re-invent a wheel that ends up
    triangular...

    Thanks!
    Matthew.
     
    , May 1, 2007
    #1
    1. Advertising

  2. schrieb:
    > I know it's a long shot but does anyone have any pointers to generic
    > algorithms - or, even better, Python code - for comparing images and
    > computing a value for the "difference" between them?
    >
    > What I want to do is to compare two bitmap images (taken from a
    > webcam, so I'll likely be using PIL) and get some idea of the
    > "difference" between them so I can tell if something in the image has
    > changed, eg, a person has entered the field of view. I've had a look
    > at the PIL documentation and all it really told me was how little I
    > knew about image processing :) and I couldn't see any recipes in the
    > Python Cookbook that are aimed at this problem area. In a perfect
    > world I'd love a method such as CompareImage(Img1, Img2) which would
    > give a result of 255 if they're identical and 0 if not one pixel
    > matches with a sliding scale inbetween but I know I'm probably asking
    > for a lot there...
    >
    > Some ideas I've had is, maybe, increasing the contrast on both images
    > (to take out variation in lighting etc), then compressing the results
    > to get a hash value and comparing the hash, but that sounds likely to
    > produce a lot of false positives. I note that PIL provides a
    > histogram function for counting pixel colour values which sounds
    > potentially useful and if no-one's got any better ideas I'll probably
    > start working in that direction. Or, maybe, dump the bitmap data into
    > a numpy array and do some kind of FFT on that but that feels very CPU-
    > intensive.
    >
    > Those are my ideas so far but I thought it would be worth asking here
    > first in case there are some known-good algorithms for doing this kind
    > of thing rather than me trying to re-invent a wheel that ends up
    > triangular...


    There is the excellent OpenCV-library from intel which is FOSS and has a
    python-binding. Either using swig, or a ctypes-version:

    http://wwwx.cs.unc.edu/~gb/wp/blog/2007/02/04/python-opencv-wrapper-using-ctypes/

    With that, you can approach your problem. What is usually done is that a
    sequence of background images is sampled & an average is built. Then the
    actual image is subtracted from that image, with an epsilon to account
    for noise.

    The result is then converted to a binary image for further processing.
    There are some blob-detection-recipes out there.

    Another approach is to use the motion-detection parts of the lib.

    Diez
     
    Diez B. Roggisch, May 1, 2007
    #2
    1. Advertising

  3. 3c273 Guest

    > Those are my ideas so far but I thought it would be worth asking here
    > first in case there are some known-good algorithms for doing this kind
    > of thing rather than me trying to re-invent a wheel that ends up
    > triangular...
    >
    > Thanks!
    > Matthew.
    >

    This might get you started.
    http://tinyurl.com/7qexl
    Louis
     
    3c273, May 1, 2007
    #3
  4. Terry Reedy Guest

    <> wrote in message
    news:...
    |I know it's a long shot but does anyone have any pointers to generic
    | algorithms - or, even better, Python code - for comparing images and
    | computing a value for the "difference" between them?

    If PIL and the other posted ideas are not enough, another approach is to
    convert the image from PIL format to NumPy array format. (pygame has
    functions to do this, I believe, since it uses NumPy (actually the older
    Numerical Python at present) for its surface arrays.) You can then do most
    any calculation you want.

    tjr
     
    Terry Reedy, May 1, 2007
    #4
  5. Guest

    On May 1, 3:42 pm, "Diez B. Roggisch" <> wrote:
    > With that, you can approach your problem. What is usually done is that a
    > sequence of background images is sampled & an average is built. Then the
    > actual image is subtracted from that image, with an epsilon to account
    > for noise.


    Thanks for the tip for an algorithm - I can see how that could work
    really nicely (and it gives me some ideas for other things, too!)
    Thanks also for the link to the OpenCV bindings. I'll give 'em a try
    and see what happens.

    Regards,
    Matthew.
     
    , May 2, 2007
    #5
  6. Guest

    On May 1, 7:15 pm, "3c273" <> wrote:
    > This might get you started.http://tinyurl.com/7qexl


    Wow, I thought briefly along those lines but then thought "No, it
    can't possibly be that easy" :) It looks like the approach given in
    that link could benefit hugely from using numpy to treat the bitmaps
    as arrays to speed up processing but that should be pretty
    straightforward. I'll give it a try as-is and then look at
    optimisation if required. Saying that, and thinking about the itch
    I'm trying to scratch here, I think I could also safely ignore the
    borders of the image so that would reduce the processing requirements
    anyway. Add in a FIFO file buffer so I can do pre/post-event image
    capture plus a spot of SMTP mail alerting and the job's done!

    Thanks again.
    Matthew.
     
    , May 2, 2007
    #6
  7. On May 2, 10:36 am, "" <>
    wrote:
    > Thanks for the tip for an algorithm - I can see how that could work
    > really nicely (and it gives me some ideas for other things, too!)
    > Thanks also for the link to the OpenCV bindings. I'll give 'em a try
    > and see what happens.


    I did similar stuff for a project at Uni, but for tracking
    pedestrians... in (eurgh) Java.
    Tad boring, but might help a little bit: http://uni.johnsto.co.uk/crowd/

    Unfortunately it only got tested on pre-recorded feeds, not live ones.
    The background removal was fun. I think I ended up getting the
    background by converting every 5th frame to grayscale, and calculating
    the median for each pixel position across the sample. A couple filters
    to remove tiny 1 or 2 pixel specks of noise, and then went onto blob
    detection for identifying people and tracking their movement across
    the entire video.

    The same filtering in numpy should be really quite fast indeed!
     
    Dave Johnston, May 3, 2007
    #7
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Gandalf

    Masked bitmap from bitmap

    Gandalf, Jan 29, 2004, in forum: Python
    Replies:
    0
    Views:
    591
    Gandalf
    Jan 29, 2004
  2. xqggz
    Replies:
    1
    Views:
    425
    Victor Bazarov
    Jun 19, 2007
  3. Home_Job_opportunity
    Replies:
    0
    Views:
    503
    Home_Job_opportunity
    Jan 8, 2009
  4. Home_Job_opportunity
    Replies:
    0
    Views:
    589
    Home_Job_opportunity
    Jan 14, 2009
Loading...

Share This Page