laplaciano de uso del filtro gaussiano

Question

Esta es una fórmula para el filtrado de registro: alt text http://homepages.inf.ed.ac.uk/rbf/HIPR2/eqns/eqnlog2.gif

También en aplicaciones con filtrado LoG veo que la función se llama con un solo parámetro: sigma (σ). Quiero probar el filtrado LoG usando esa fórmula (el intento anterior fue por filtro gaussiano y luego filtro laplaciano con un tamaño de ventana de filtro) Pero al ver esa fórmula no puedo entender cómo el tamaño del filtro está conectado con esta fórmula, ¿significa que el tamaño del filtro es fijo? ¿Puedes explicarme cómo usarlo?

Answer 1

Como usted probablemente ha figurado por ahora de las otras respuestas y enlaces, filtro de registro detecta los bordes y líneas en la imagen. Lo que aún falta es una explicación de lo que es σ.

σ es la escala del filtro. ¿Es una línea de un píxel de ancho una línea o ruido? ¿Hay una línea de 6 píxeles de ancho en una línea o un objeto con dos bordes paralelos distintos? ¿Es un degradado que cambia de negro a blanco en 6 u 8 píxeles en un borde o simplemente en un degradado?Es algo que tiene que decidir, y el valor de σ refleja su decisión — cuanto mayor es σ cuanto más anchas sean las líneas, más suaves serán los bordes, y se ignorará más ruido.

No se confunda entre la escala del filtro (σ) y el tamaño de la aproximación discreta (generalmente llamada estarcido). En Paul's link σ = 1.4 y el tamaño de la plantilla es 9. Si bien es razonable usar un tamaño de plantilla de 4σ a 6σ, estas dos cantidades son bastante independientes. Una plantilla más grande proporciona una mejor aproximación del filtro, pero en la mayoría de los casos no necesita una muy buena aproximación.

Answer 2

Parece ser un filtro circular continuo cuyo radio es sqrt (2) * sigma. Si desea implementar esto para el procesamiento de imágenes, deberá aproximarlo.

Hay un ejemplo para sigma = 1,4 aquí: http://homepages.inf.ed.ac.uk/rbf/HIPR2/log.htm

Answer 3

Esto fue algo que me confundió demasiado, y no fue hasta que tuve que hacer lo mismo que por un proyecto uni que entendí lo que eras se supone que tiene que ver con la fórmula!

Puede usar esta fórmula para generar un filtro LoG discreto. Si escribe un poco de código para implementar esa fórmula, puede generar un filtro para usar en la convolución de la imagen. Para generar, digamos una plantilla de 5x5, simplemente llame al código con xey que van de -2 a +2.

Esto generará los valores para usar en una plantilla LoG. Si representa los valores que esta produce debería ver el "sombrero mexicano" forma típica de este filtro, así:

LoG template http://homepages.inf.ed.ac.uk/rbf/HIPR2/figs/logcont.gif

Puede ajustar con precisión la plantilla cambiando lo amplio que es (el tamaño) y el valor de sigma (qué tan ancho es el pico). Cuanto más amplia y amplia sea la plantilla, menos afectado se verá el ruido porque funcionará en un área más amplia.

Una vez que tenga el filtro, puede aplicarlo a la imagen al convolucionar la plantilla con la imagen. Si no has hecho esto antes, mira estos tutoriales. java applet tutorialsmore mathsy.

Básicamente, en cada ubicación de píxel, "coloca" la plantilla de convolución centrada en ese píxel. Luego, multiplica los valores de píxel circundantes por el "píxel" correspondiente en la plantilla y suma el resultado. Este es entonces el nuevo valor de píxel en esa ubicación (por lo general, también debe normalizar (escalar) la salida para devolverla al rango de valores correcto).

El siguiente código proporciona una idea aproximada de cómo puede implementar esto. Por favor perdona cualquier error/error tipográfico, etc. ya que no ha sido probado.

Espero que esto ayude.

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 4

Solo para fines de visualización, aquí hay un gráfico de Matlab 3D en color simple de la wavelet Laplaciano de Gaussian (Sombrero mexicano). Puede cambiar el parámetro sigma (σ) y ver su efecto en la forma de la gráfica:

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) 

También puede comparar los efectos del parámetro sigma en el sombrero mexicano haciendo lo siguiente:

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'); 

o simplemente utilizar la caja de herramientas Wavelet proporcionada por Matlab de la siguiente manera:

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

he encontrado esto útil al aplicar la presente para la detección de bordes en la visión por ordenador. Aunque no es la respuesta exacta, espero que esto ayude.