Qu'est-ce que le gradient de l'orientation et de l'ampleur du gradient

Comme l'a expliqué Dima dans son réponse, vous devez être familier avec le concept mathématique de dégradé afin de mieux comprendre le dégradé dans le domaine du traitement de l'image.

Ma réponse est basée sur la réponse de mevatron à ce question.

Vous trouverez ici une simple image initiale d'un disque blanc sur fond noir:

vous pouvez calculer une approximation du gradient de l'image. Comme Dima a expliqué dans sa réponse, vous avez deux composante du gradient, une horizontale et une composante verticale.

Les images ci-dessous vous montre la composante horizontale:

il montre combien les niveaux de gris de votre changement d'image dans le sens horizontal (c'est le sens des x positif, la numérisation de l'image de gauche à droite), ce changement est "codé" dans le niveau de gris de l'image de la composante horizontale: la moyenne des niveaux de gris signifie qu'aucun changement, les niveaux de luminosité variation moyenne de la sombre de la valeur à un brillant de valeur, l'obscurité, la signification des niveaux d'un changement d'une brillante valeur à l'obscurité de la valeur. Ainsi, dans l'image ci-dessus vous voyez le plus brillant de valeur dans la partie gauche du cercle, car il est dans la partie gauche de l'image initiale que vous avez le noir et blanche qui vous donne le bord gauche du disque; de même, dans l'image ci-dessus vous voyez le plus sombre de la valeur dans la partie droite du cercle, car il est dans la partie droite de l'image initiale que vous avez du blanc au noir de la transition qui vous donne le droit de bord du disque. Dans l'image ci-dessus, la partie intérieure du disque et le fond sont une moyenne des niveaux de gris car il n'y a pas de changement à l'intérieur du disque et dans le fond.

On peut faire des observations analogues pour la composante verticale, il montre comment le changement d'image dans le sens vertical, c'est à dire la numérisation de l'image du haut vers le bas:

Vous pouvez maintenant combiner les deux composants dans l'ordre pour obtenir de l'ampleur de la pente et de l'orientation du dégradé.

L'image suivante est la magnitude du gradient:

De nouveau, dans l'image ci-dessus, le changement de l'image initiale est codée dans le niveau de gris: ici vous pouvez voir que le blanc signifie un grand changement dans l'image initiale tandis que le noir signifie pas de changement à tous.
Donc, quand vous regardez l'image de l'ampleur du gradient, vous pouvez dire "si l'image est élevée, cela signifie un grand changement dans l'image initiale; si elle est sombre, il signifie qu'aucun changement ou très llittle changement".

L'image suivante, c'est l'orientation du dégradé:

Dans l'image ci-dessus, l'orientation est encore codé en niveaux de gris: vous pouvez penser à l'orientation de l'angle d'une flèche pointant à partir de la partie sombre de l'image à la partie brillante de l'image; l'angle est appelé xy cadre où x va de gauche à droite, tandis que la y va de haut en bas. Dans l'image ci-dessus, vous voyez tout en niveau de gris du noir (zéro degré) à le blanc (360 degrés). On peut coder les informations avec la couleur:

dans l'image ci-dessus, l'information est de coder de cette façon:

rouge: l'angle est compris entre 0 et 90 degrés

cyan: l'angle est compris entre 90 et 180 degrés

vert: l'angle est compris entre 180 et 270 degrés

jaune: l'angle est compris entre 270 et 360 degrés

Ici, c'est le C++, OpenCV code pour produire des images ci-dessus.

Payer l'attention sur le fait que, pour le calcul de l'orientation, j'utilise la fonction cv::phase qui, comme expliqué dans la doc, donne un angle de 0 lorsque la composante verticale et la composante horizontale de la pente sont à zéro; tout ce qui peut être pratique, mais d'un point de vue mathématique est tout simplement faux, car lorsque les deux composants sont nulles, l'orientation n'est pas définie et le sens de la valeur pour une orientation conservés dans un floating-point C++ est un NaN.

Il est tout simplement faux, car un 0 degré d'orientation, par exemple, est déjà lié à un bord horizontal et il ne peut pas être utilisé pour représenter quelque chose d'autre comme une région sans bords et donc une région où l'orientation est dénuée de sens.

//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;
}