Calculating sharpness of an image

Question

I found on the internet that laplacian method is quite good technique to compute the sharpness of a image. I was trying to implement it in opencv 2.4.10. How can I get the sharpness measure after applying the Laplacian function? Below is the code:

Mat src_gray, dst;
int kernel_size = 3;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;

GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );

/// Convert the image to grayscale
cvtColor( src, src_gray, CV_RGB2GRAY );

/// Apply Laplace function
Mat abs_dst;

Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );

//compute sharpness
??

Can someone please guide me on this?

Answer 1

Not exactly the answer, but I got a formula using an intuitive approach that worked on the wild.

I'm currently working in a script to detect multiple faces in a picture with a crowd, using mtcnn , which it worked very well, however it also detected many faces so blurry that you couldn't say it was properly a face.

Example image:

Faces detected:

Matrix of detected faces:

mtcnn detected about 123 faces, however many of them had little resemblance as a face. In fact, many faces look more like a stain than anything else...

So I was looking a way of 'filtering' those blurry faces. I tried the Laplacian filter and FFT way of filtering I found on this answer , however I had inconsistent results and poor filtering results.

I turned my research in computer vision topics, and finally tried to implement an 'intuitive' way of filtering using the following principle:

When more blurry is an image, less 'edges' we have

If we compare a crisp image with a blurred version of the same image, the results tends to 'soften' any edges or adjacent contrasting regions. Based on that principle, I was finding a way of weighting edges and then a simple way of 'measuring' the results to get a confidence value.

I took advantage of Canny detection in OpenCV and then apply a mean value of the result (Python):

def getBlurValue(image):
    canny = cv2.Canny(image, 50,250)
    return np.mean(canny)

Canny return 2x2 array same image size . I selected threshold 50,250 but it can be changed depending of your image and scenario.

Then I got the average value of the canny result, (definitively a formula to be improved if you know what you're doing).

When an image is blurred the result will get a value tending to zero, while crisp image tend to be a positive value, higher when crisper is the image.

This value depend on the images and threshold, so it is not a universal solution for every scenario, however a best value can be achieved normalizing the result and averaging all the faces (I need more work on that subject).

In the example, the values are in the range 0-27.

I averaged all faces and I got about a 3.7 value of blur

If I filter images above 3.7:

So I kept with mosth crisp faces:

That consistently gave me better results than the other tests.

Ok, you got me. This is a tricky way of detecting a blurriness values inside the same image space. But I hope people can take advantage of this findings and apply what I learned in its own projects.