Ich habe nach dem Quellcode für Filter2D gesucht, ihn aber nicht gefunden. Weder konnte Visual C ++. Gibt es hier Experten für den filter2D-Algorithmus? Ich kennewie es funktionieren soll aber nicht wie es tatsächlich funktioniert. Ich habe meine eigene filter2d () -Funktion erstellt, um Dinge zu testen, und die Ergebnisse unterscheiden sich erheblich von denen von opencvs filter2D (). Hier ist mein Code:

Mat myfilter2d(Mat input, Mat filter){

Mat dst = input.clone();
cout << " filter data successfully found.  Rows:" << filter.rows << " cols:" << filter.cols << " channels:" << filter.channels() << "\n";
cout << " input data successfully found.  Rows:" << input.rows << " cols:" << input.cols << " channels:" << input.channels() << "\n";

for (int i = 0-(filter.rows/2);i<input.rows-(filter.rows/2);i++){
    for (int j = 0-(filter.cols/2);j<input.cols-(filter.cols/2);j++){  //adding k and l to i and j will make up the difference and allow us to process the whole image
        float filtertotal = 0;
        for (int k = 0; k < filter.rows;k++){
            for (int l = 0; l < filter.rows;l++){
                if(i+k >= 0 && i+k < input.rows && j+l >= 0 && j+l < input.cols){  //don't try to process pixels off the endge of the map
                    float a = input.at<uchar>(i+k,j+l);
                    float b = filter.at<float>(k,l);
                    float product = a * b;
                    filtertotal += product;
                }
            }
        }
        //filter all proccessed for this pixel, write it to dst
        st.at<uchar>(i+(filter.rows/2),j+(filter.cols/2)) = filtertotal;

    }
}
return dst;
}

Hat jemand Probleme mit meiner Implementierung? (Abgesehen davon, dass es langsam ist)

Hier ist meine Hinrichtung:

  cvtColor(src,src_grey,CV_BGR2GRAY);
  Mat dst = myfilter2d(src_grey,filter);
  imshow("myfilter2d",dst);
  filter2D(src_grey,dst2,-1,filter);
  imshow("filter2d",dst2);

Hier ist mein Kernel:

float megapixelarray[basesize][basesize] = {
            {1,1,-1,1,1},
            {1,1,-1,1,1},
            {1,1,1,1,1},
            {1,1,-1,1,1},
            {1,1,-1,1,1}
            };

UndHier sind die (wesentlich unterschiedlichen) Ergebnisse:

Gedanken, irgendjemand?

EDIT: Dank Brians Antwort habe ich diesen Code hinzugefügt:

//normalize the kernel so its sum = 1
Scalar mysum = sum(dst);
dst = dst / mysum[0];   //make sure its not 0
dst = dst * -1;  //show negetive

und filter2d hat besser funktioniert. Bestimmte Filter geben eine genaue Übereinstimmung, und andere Filter, wie der Sobel,kläglich scheitern.

Ich nähere mich dem eigentlichen Algorithmus, bin aber noch nicht da. Noch jemand mit irgendwelchen Ideen?