C++ – Hand detection using OpenCV

ccomputer visionimage processingopencv

I am using the OpenCV library for an image processing project to detect hands. I initialized the image in iplimage, colored it, and then converted it to HSV with cvCvtColor(imageHand,imageHand,CV_BGR2HSV );
I don't know the efficient algorithm so that's my problem. Please check my code:

for( int row = 0; row < imageHand->height; row++ )
{
    for ( int col = 0; col < imageHand->width; col++ )
    {
       h =(imageHand->imageData[imageHand->widthStep * row + col * 3]) ;
    s = (imageHand->imageData[imageHand->widthStep * row + col * 3 + 1]);
    v = (imageHand->imageData[imageHand->widthStep * row + col * 3 + 2]);

         if(  h>85)
         {
     imageHand->imageData[imageHand->widthStep * row + col * 3 ]     = 0 ;
     imageHand->imageData[imageHand->widthStep * row + col * 3 + 1 ] =0 ;
     imageHand->imageData[imageHand->widthStep * row + col * 3 + 2 ] = 0 ;
         }
         else
         {
         imageHand->imageData[imageHand->widthStep * row + col * 3 ]     = 255 ;
     imageHand->imageData[imageHand->widthStep * row + col * 3 + 1 ] = 255 ;
         imageHand->imageData[imageHand->widthStep * row + col * 3 + 2 ] = 255 ;

         }


     }
}

I think the range of the searched h is > 85!?
If you know a better algorithm than please guide me.

Best Answer

If you take a look at this site, Hand detection using opencv, you'll find a similar algorithm to what you're using. I would say that the easiest way of detecting a hand would be through the use of colour (i.e. skin detection). I would definitely recommend looking at the algorithm provided by that site first. There's another part that also goes into gesture recognition, if that's an eventual problem you're going to need to handle.

Other possibilities include:

Background Subtraction
- This is very simple and prone to breaking, especially if you're planning on the background changing. But, if you're expecting to only use it in front of, say, a white wall... this could be an easy way of going about it.
Shape Analysis
- There has been some success with detecting fingertips using the Generalised Hough Transform. False positives can become a worry, however and efficiency is a worry, particularly in situations with a significant amount of background.

Related Solutions

C++ – Why is “using namespace std;” considered bad practice

This is not related to performance at all. But consider this: you are using two libraries called Foo and Bar:

using namespace foo;
using namespace bar;

Everything works fine, and you can call Blah() from Foo and Quux() from Bar without problems. But one day you upgrade to a new version of Foo 2.0, which now offers a function called Quux(). Now you've got a conflict: Both Foo 2.0 and Bar import Quux() into your global namespace. This is going to take some effort to fix, especially if the function parameters happen to match.

If you had used foo::Blah() and bar::Quux(), then the introduction of foo::Quux() would have been a non-event.

Python – Peak detection in a 2D array

I detected the peaks using a local maximum filter. Here is the result on your first dataset of 4 paws: Peaks detection result

I also ran it on the second dataset of 9 paws and it worked as well.

Here is how you do it:

import numpy as np
from scipy.ndimage.filters import maximum_filter
from scipy.ndimage.morphology import generate_binary_structure, binary_erosion
import matplotlib.pyplot as pp

#for some reason I had to reshape. Numpy ignored the shape header.
paws_data = np.loadtxt("paws.txt").reshape(4,11,14)

#getting a list of images
paws = [p.squeeze() for p in np.vsplit(paws_data,4)]


def detect_peaks(image):
    """
    Takes an image and detect the peaks usingthe local maximum filter.
    Returns a boolean mask of the peaks (i.e. 1 when
    the pixel's value is the neighborhood maximum, 0 otherwise)
    """

    # define an 8-connected neighborhood
    neighborhood = generate_binary_structure(2,2)

    #apply the local maximum filter; all pixel of maximal value 
    #in their neighborhood are set to 1
    local_max = maximum_filter(image, footprint=neighborhood)==image
    #local_max is a mask that contains the peaks we are 
    #looking for, but also the background.
    #In order to isolate the peaks we must remove the background from the mask.

    #we create the mask of the background
    background = (image==0)

    #a little technicality: we must erode the background in order to 
    #successfully subtract it form local_max, otherwise a line will 
    #appear along the background border (artifact of the local maximum filter)
    eroded_background = binary_erosion(background, structure=neighborhood, border_value=1)

    #we obtain the final mask, containing only peaks, 
    #by removing the background from the local_max mask (xor operation)
    detected_peaks = local_max ^ eroded_background

    return detected_peaks


#applying the detection and plotting results
for i, paw in enumerate(paws):
    detected_peaks = detect_peaks(paw)
    pp.subplot(4,2,(2*i+1))
    pp.imshow(paw)
    pp.subplot(4,2,(2*i+2) )
    pp.imshow(detected_peaks)

pp.show()

All you need to do after is use scipy.ndimage.measurements.label on the mask to label all distinct objects. Then you'll be able to play with them individually.

Note that the method works well because the background is not noisy. If it were, you would detect a bunch of other unwanted peaks in the background. Another important factor is the size of the neighborhood. You will need to adjust it if the peak size changes (the should remain roughly proportional).

Best Answer

Related Solutions

C++ – Why is “using namespace std;” considered bad practice

Python – Peak detection in a 2D array

Related Topic