Laplacien de l'utilisation du filtre gaussien

Question

Ceci est une formule pour le filtrage de journal:
_{(source: ed.ac.uk )}

En outre dans les applications avec filtrage des journaux, je vois que la fonction est appelée avec un seul paramètre: sigma (σ). Je veux essayer le filtrage en utilisant cette formule LoG (précédente tentative a été par le filtre gaussienne puis filtre laplacien avec une taille de filtre fenêtre) Mais en regardant cette formule, je ne peux pas comprendre comment la taille du filtre est relié à cette formule, cela signifie que la taille du filtre est fixé? Pouvez-vous expliquer comment l'utiliser?

Answer 1

Comme vous l'avez probablement deviné maintenant des autres réponses et des liens, objet filtre détecte les contours et lignes dans l'image. Ce qui manque encore est une explication de ce que σ est.

σ

est échelle du filtre. Est une ligne à l'échelle d'un pixel d'une ligne ou le bruit? Est une ligne de 6 pixels de largeur d'une ligne ou d'un objet avec deux bords parallèles distincts? Est un gradient qui change du noir au blanc dans 6 ou 8 pixels d'un bord ou juste un gradient? Il est quelque chose que vous devez décider, et la valeur de σ reflète votre décision - la plus grande σ est le plus large sont les lignes, le plus lisse les bords, et plus de bruit est ignoré

.

Ne pas confondre entre l'échelle du filtre (σ) et la taille de l'approximation discrète (généralement appelé pochoir). Dans Paul href="http://homepages.inf.ed.ac.uk/rbf/HIPR2/log.htm" σ = 1.4 et la taille du pochoir est 9. Alors qu'il est généralement raisonnable d'utiliser la taille du pochoir de 4σ à 6σ, ces deux grandeurs sont tout à fait indépendante. Un pochoir plus grande offre une meilleure approximation du filtre, mais dans la plupart des cas, vous n'avez pas besoin une très bonne approximation.

Answer 2

Ce fut quelque chose qui me confondre aussi, et ce ne fut pas jusqu'à ce que je devais faire la même chose que vous pour un projet uni que je compris ce que vous étiez censé faire avec la formule!

Vous pouvez utiliser cette formule pour générer un filtre logarithme discret. Si vous écrivez un morceau de code pour mettre en œuvre cette formule, vous pouvez alors pour générer un filtre pour une utilisation dans convolution d'image. Pour générer, par exemple un modèle de 5x5, appelez simplement le code avec x et y allant de -2 à +2.

Cela va générer les valeurs à utiliser dans un modèle de suivi du trafic. Si vous représenter graphiquement les valeurs que vous ce produit devriez voir la forme « chapeau mexicain » typique de ce filtre, comme ceci:

_{(source: ed.ac.uk )}

Vous pouvez affiner le modèle en changeant la façon dont il est large (la taille) et la valeur sigma (comment large le pic est). Le plus large et plus large du modèle moins affectée par le bruit, le résultat sera parce qu'il fonctionne sur une zone plus large.

Une fois que vous avez le filtre, vous pouvez l'appliquer à l'image par le modèle avec convolution l'image. Si vous ne l'avez pas fait ça avant, consultez ces quelques tutoriels. tutoriels applet java plus mathsy .

Pour l'essentiel, à chaque emplacement de pixel, vous "place" votre modèle de convolution, centré sur ce pixel. Vous multipliez alors les valeurs de pixels environnantes par le modèle dans le « pixel » correspondant et ajouter le résultat. Voici donc la nouvelle valeur de pixel à cet endroit (en général, vous avez également à normaliser (échelle) la sortie pour le ramener dans la plage de valeurs correcte).

Le code ci-dessous donne une idée approximative de la façon dont vous pourriez mettre en œuvre. S'il vous plaît pardonner toutes les erreurs / fautes de frappe, etc. car il n'a pas été testé.

J'espère que cette aide.

private float LoG(float x, float y, float sigma)
{
    // implement formula here
    return (1 / (Math.PI * sigma*sigma*sigma*sigma)) * //etc etc - also, can't remember the code for "to the power of" off hand
}

private void GenerateTemplate(int templateSize, float sigma)
{
    // Make sure it's an odd number for convenience
    if(templateSize % 2 == 1)
    {
        // Create the data array
        float[][] template = new float[templateSize][templatesize];

        // Work out the "min and max" values. Log is centered around 0, 0
        // so, for a size 5 template (say) we want to get the values from
        // -2 to +2, ie: -2, -1, 0, +1, +2 and feed those into the formula.
        int min = Math.Ceil(-templateSize / 2) - 1;
        int max = Math.Floor(templateSize / 2) + 1;

        // We also need a count to index into the data array...
        int xCount = 0;
        int yCount = 0;

        for(int x = min; x <= max; ++x)
        {
            for(int y = min; y <= max; ++y)
            {
                // Get the LoG value for this (x,y) pair
                template[xCount][yCount] = LoG(x, y, sigma);
                ++yCount;
            }
            ++xCount;
        }
    }
}

Answer 3

Juste à des fins de visualisation, voici une intrigue simple couleur Matlab 3D du laplacien de gaussienne de ondelette (Mexican Hat). Vous pouvez modifier le paramètre sigma (σ de) et de voir son effet sur la forme du graphique:

sigmaSq = 0.5 % Square of σ parameter
[x y] = meshgrid(linspace(-3,3), linspace(-3,3)); 
z = (-1/(pi*(sigmaSq^2))) .* (1-((x.^2+y.^2)/(2*sigmaSq))) .*exp(-(x.^2+y.^2)/(2*sigmaSq)); 
surf(x,y,z)

Vous pouvez également comparer les effets du paramètre sigma sur le chapeau mexicain procédant comme suit:

t = -5:0.01:5;
sigma = 0.5;

mexhat05 = exp(-t.*t/(2*sigma*sigma)) * 2 .*(t.*t/(sigma*sigma) - 1) / (pi^(1/4)*sqrt(3*sigma));

sigma = 1;
mexhat1 = exp(-t.*t/(2*sigma*sigma)) * 2 .*(t.*t/(sigma*sigma) - 1) / (pi^(1/4)*sqrt(3*sigma));

sigma = 2;
mexhat2 = exp(-t.*t/(2*sigma*sigma)) * 2 .*(t.*t/(sigma*sigma) - 1) / (pi^(1/4)*sqrt(3*sigma));

plot(t, mexhat05, 'r', ...
     t, mexhat1, 'b', ...
     t, mexhat2, 'g');

Ou tout simplement utiliser la boîte à outils Wavelet fourni par Matlab comme suit:

lb = -5; ub = 5; n = 1000; 
[psi,x] = mexihat(lb,ub,n); 
plot(x,psi), title('Mexican hat wavelet')

J'ai trouvé cela utile lors de l'application pour la détection de ce bord en vision par ordinateur. Bien que pas la réponse exacte, espérons que cette aide.

Answer 4

Il semble être un filtre circulaire continue dont le rayon est sqrt (2) * sigma. Si vous souhaitez implémenter ce traitement pour l'image que vous aurez besoin de l'approximer.

Il y a un exemple pour sigma = 1.4 ici: http: // homepages.inf.ed.ac.uk/rbf/HIPR2/log.htm