Affiner l'image à l'aide du filtre laplacien

Je pense que le problème, c'est que vous êtes le flou de l'image avant de prendre la 2e dérivées.

Voici le code de travail avec l'API C++ (je suis en utilisant Opencv 2.4.3). J'ai essayé aussi avec MATLAB et le résultat est le même.

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <iostream>

using namespace cv;
using namespace std;


int main(int /*argc*/, char** /*argv*/) {

    Mat img, imgLaplacian, imgResult;

    //------------------------------------------------------------------------------------------- test, first of all
    //now do it by hand
    img = (Mat_<uchar>(4,4) << 0,1,2,3,4,5,6,7,8,9,0,11,12,13,14,15); 

    //first, the good result
    Laplacian(img, imgLaplacian, CV_8UC1);
    cout << "let opencv do it" << endl;
    cout << imgLaplacian << endl;

    Mat kernel = (Mat_<float>(3,3) << 
        0,  1, 0,
        1, -4, 1,
        0,  1, 0); 
    int window_size = 3;

    //now, reaaallly by hand
    //note that, for avoiding padding, the result image will be smaller than the original one.
    Mat frame, frame32;
    Rect roi;
    imgLaplacian = Mat::zeros(img.size(), CV_32F);
    for(int y=0; y<img.rows-window_size/2-1; y++) {
        for(int x=0; x<img.cols-window_size/2-1; x++) {
            roi = Rect(x,y, window_size, window_size);
            frame = img(roi);
            frame.convertTo(frame, CV_32F);
            frame = frame.mul(kernel);
            float v = sum(frame)[0];
            imgLaplacian.at<float>(y,x) = v;
        }
    }
    imgLaplacian.convertTo(imgLaplacian, CV_8U);
    cout << "dudee" << imgLaplacian << endl;

    //a little bit less "by hand"..
    //using cv::filter2D
    filter2D(img, imgLaplacian, -1, kernel);
    cout << imgLaplacian << endl;


    //------------------------------------------------------------------------------------------- real stuffs now
    img = imread("moon.jpg", 0); //load grayscale image

    //ok, now try different kernel
    kernel = (Mat_<float>(3,3) << 
        1,  1, 1,
        1, -8, 1,
        1,  1, 1); //another approximation of second derivate, more stronger

    //do the laplacian filtering as it is
    //well, we need to convert everything in something more deeper then CV_8U
    //because the kernel has some negative values, 
    //and we can expect in general to have a Laplacian image with negative values
    //BUT a 8bits unsigned int (the one we are working with) can contain values from 0 to 255
    //so the possible negative number will be truncated
    filter2D(img, imgLaplacian, CV_32F, kernel);
    img.convertTo(img, CV_32F);
    imgResult = img - imgLaplacian;

    //convert back to 8bits gray scale
    imgResult.convertTo(imgResult, CV_8U);
    imgLaplacian.convertTo(imgLaplacian, CV_8U);

    namedWindow("laplacian", CV_WINDOW_AUTOSIZE);
    imshow( "laplacian", imgLaplacian );

    namedWindow("result", CV_WINDOW_AUTOSIZE);
    imshow( "result", imgResult );

    while( true ) {
        char c = (char)waitKey(10);
        if( c == 27 ) { break; }
    }

    return 0;
}

Amusez-vous!

Que vous devez faire img - laplace au lieu de img + laplace.

laplace: f(x,y) = f(x-1,y+1) + f(x-1,y-1) + f(x,y+1) + f(x+1,y) - 4*f(x,y)

Donc si vous voyez soustraire de laplace de l'image d'origine, vous verriez que le signe moins devant 4*f(x,y) est annulée et ce terme devient positif.

Vous pourriez aussi avoir noyau avec -5 in the center pixel instead of -4 de faire le laplacien d'un processus en une étape au lieu de faire de l'obtention de la transformée de laplace et de faire img - laplace Pourquoi? Essayez dérivant que vous-même.

Ce serait le dernier noyau.

Tapis de noyau = (Mat_(3,3) <<
-1, 0, -1,
0, -5, 0,
-1, 0, -1);