Was ist Gradientenausrichtung und Gradientenstärke?

Wie erläutert durch Dima in seinem Antwortsollten Sie vertraut sein mit dem mathematischen Konzept der Farbverlaufum besser zu verstehen, die Steigung im Bereich der Bildverarbeitung.

Meine Antwort basiert auf der Antwort von mevatron dieser Frage.

Hier finden Sie eine einfache erste Bild, der eine weiße Scheibe auf schwarzem hintergrund:

können Sie berechnen eine Näherung des Gradienten des Bildes. Als Dima erklärte in seiner Antwort, haben Sie zwei Komponenten des Gradienten, eine horizontale und eine vertikale Komponente.

Den folgenden Abbildungen zeigt die horizontale Komponente:

es zeigt, wie viel die Graustufen im Bild ändern in der horizontalen Richtung (es ist die Richtung der positiven x -, scan-das Bild von Links nach rechts), diese änderung ist "codiert" in der grauen Ebene des Bildes mit der horizontalen Komponente: das mittlere graue Niveau bedeutet keine änderung, die hellen Ebenen bedeutet der Wechsel von einem dunklen Wert auf ein helles Wert, die dunklen Ebenen bedeuten einen Wechsel von einem hellen Wert auf einen dunklen Wert. Also, im Bild oben sehen Sie die heller-Wert in den linken Teil des Kreises, weil es im linken Teil des ersten Bildes, dass Sie die schwarz zu weiß übergang, gibt Sie der linken Kante der Scheibe; ähnlich, im Bild oben sehen Sie die dunkler-Wert im rechten Teil des Kreises, denn es ist im rechten Teil des ersten Bildes, dass Sie die weiß-schwarz-übergang, der Ihnen den rechten Rand der Festplatte. Im Bild oben, der innere Teil der Scheibe und hintergrund sind auf eine mittlere graue Niveau, da gibt es keine Veränderung im inneren der Scheibe und im hintergrund.

Können wir analoge Beobachtungen für die vertikale Komponente, es zeigt, wie das Bild ändern in der vertikalen Richtung, D. H. das Scannen des Bildes von oben nach unten:

Können Sie jetzt kombinieren Sie die beiden Komponenten, um die Größe des Verlaufs und der Orientierung des Gradienten.

Dem folgenden Bild ist die Größe des Gradienten:

Wieder, in der obigen Abbildung die änderung im ersten Bild ist codiert in der Grau-Ebene: hier sehen Sie, dass weiß bedeutet eine hohe änderung der ursprünglichen Bildes, während schwarz bedeutet keine Veränderung überhaupt.
Also, wenn man sich das Bild von der Größenordnung des Gradienten kann man sagen "wenn das Bild hell ist, bedeutet es eine große Veränderung in der ursprünglichen Bild, wenn es dunkel ist, es bedeutet keine änderung oder sehr llittle ändern".

Dem folgenden Bild ist die Orientierung des Gradienten:

In der obigen Abbildung die Orientierung wird wieder kodiert als Grauwerte: Sie können sich bei der Orientierung als der Winkel ein Pfeil von den dunklen Teil des Bildes, um den hellen Teil des Bildes, der Winkel bezeichnet wird, um ein xy-Bild, in dem die x läuft von Links nach rechts, während die y läuft von oben nach unten. Im Bild oben sehen Sie alle Graustufen von schwarz (null-Grad) auf das weiße (360 Grad). Wir codieren die Informationen, die mit Farbe:

in der obigen Abbildung werden die Informationen Kodieren, auf diese Weise:

rot: der Winkel ist zwischen 0 und 90 Grad

cyan: der Winkel ist zwischen 90 und 180 Grad

grün: der Winkel liegt zwischen 180 und 270-Grad -

gelb: der Winkel zwischen 270 und 360-Grad -

Hier ist es der C++ OpenCV code für die Herstellung der oben genannten Bilder.

Achten Sie auf die Tatsache, dass für die Berechnung der Orientierung, ich benutze die Funktion cv::phasedie, wie erläutert, in der docgibt einem Winkel von 0, wenn beide die vertikale Komponente und die horizontale Komponente des Gradienten null sind; das kann praktisch sein, aber aus mathematischer Sicht schlicht und einfach falsch, denn wenn beide Komponenten gleich null sind, die Orientierung ist nicht definiert und nicht der einzig sinnvolle Wert für eine Orientierung gehalten, in einem floating-point-C++ - Typ ist ein NaN.

Es ist schlichtweg falsch, weil ein 0-Grad-Orientierung, zum Beispiel, ist bereits in Bezug auf eine horizontale Kante und es kann nicht verwendet werden, die etwas anderes vertreten, wie eine region, die keine Kanten und so einer region, wo die Orientierung bedeutungslos ist.

//original code by https://stackoverflow.com/users/951860/mevatron
//see https://stackoverflow.com/a/11157426/15485
//https://stackoverflow.com/users/15485/uvts-cvs added the code for saving x and y gradient component 

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

#include <iostream>
#include <vector>

using namespace cv;
using namespace std;

Mat mat2gray(const cv::Mat& src)
{
    Mat dst;
    normalize(src, dst, 0.0, 255.0, cv::NORM_MINMAX, CV_8U);

    return dst;
}

Mat orientationMap(const cv::Mat& mag, const cv::Mat& ori, double thresh = 1.0)
{
    Mat oriMap = Mat::zeros(ori.size(), CV_8UC3);
    Vec3b red(0, 0, 255);
    Vec3b cyan(255, 255, 0);
    Vec3b green(0, 255, 0);
    Vec3b yellow(0, 255, 255);
    for(int i = 0; i < mag.rows*mag.cols; i++)
    {
        float* magPixel = reinterpret_cast<float*>(mag.data + i*sizeof(float));
        if(*magPixel > thresh)
        {
            float* oriPixel = reinterpret_cast<float*>(ori.data + i*sizeof(float));
            Vec3b* mapPixel = reinterpret_cast<Vec3b*>(oriMap.data + i*3*sizeof(char));
            if(*oriPixel < 90.0)
                *mapPixel = red;
            else if(*oriPixel >= 90.0 && *oriPixel < 180.0)
                *mapPixel = cyan;
            else if(*oriPixel >= 180.0 && *oriPixel < 270.0)
                *mapPixel = green;
            else if(*oriPixel >= 270.0 && *oriPixel < 360.0)
                *mapPixel = yellow;
        }
    }

    return oriMap;
}

int main(int argc, char* argv[])
{
    Mat image = Mat::zeros(Size(320, 240), CV_8UC1);
    circle(image, Point(160, 120), 80, Scalar(255, 255, 255), -1, CV_AA);

    imshow("original", image);

    Mat Sx;
    Sobel(image, Sx, CV_32F, 1, 0, 3);

    Mat Sy;
    Sobel(image, Sy, CV_32F, 0, 1, 3);

    Mat mag, ori;
    magnitude(Sx, Sy, mag);
    phase(Sx, Sy, ori, true);

    Mat oriMap = orientationMap(mag, ori, 1.0);

    imshow("x", mat2gray(Sx));
    imshow("y", mat2gray(Sy));

    imwrite("hor.png",mat2gray(Sx));
    imwrite("ver.png",mat2gray(Sy));

    imshow("magnitude", mat2gray(mag));
    imshow("orientation", mat2gray(ori));
    imshow("orientation map", oriMap);
    waitKey();

    return 0;
}

InformationsquelleAutor der Antwort Alessandro Jacopson