c++ - mediana - ruido gaussiano python

Imagen de filtro openCV: reemplace kernel con máximo local

Question

Algunos detalles sobre mi problema:

Estoy tratando de darme cuenta del detector de esquina en openCV (otro algoritmo, que están incorporados: Canny, Harris, etc.).

Tengo una matriz llena con los valores de respuesta. El mayor valor de respuesta es - la mayor probabilidad de esquina es detectar.

Tengo un problema, que en el vecindario de un punto hay pocas esquinas detectadas (pero solo hay una). Necesito reducir el número de esquinas detectadas en falso.

Problema exacto:

Necesito recorrer la matriz con un kernel, calcular el valor máximo de cada kernel, dejar el valor máximo, pero otros valores en kernel hacen que sea igual a cero.

¿Hay funciones openCV incorporadas para hacer esto?

Answer 1

Sugeriría un procedimiento original de 2 pasos (puede haber enfoques más eficientes), que usa funciones integradas de opencv:

1. Paso 1: dilatación morfológica con un núcleo cuadrado (correspondiente a su vecindario). Este paso le da otra imagen, después de reemplazar cada valor de píxel por el valor máximo dentro del kernel.

2. Paso 2: prueba si el valor de esquina de cada píxel de la imagen de respuesta original es igual al valor máximo dado por el paso de dilatación. Si no, entonces obviamente existe una mejor esquina en el vecindario.

Answer 2

Así es como lo haría:

1. Crea un kernel, define un vecindario de píxeles.
2. Crea una nueva imagen dilatando tu imagen usando este kernel. Esta imagen dilatada contiene el valor de vecindad máximo para cada punto.
3. Haga una comparación de igualdad entre estas dos matrices. Dondequiera que estén iguales, es un máximo de vecindad válido, y se establece en 255 en la matriz de comparación.
4. Multiplique la matriz de comparación y la matriz original juntas (escalando apropiadamente).
5. Esta es su matriz final, que contiene solo máximos de barrio.

Esto se ilustra con estas imágenes ampliadas:

Imagen original de 9 píxeles por 9 píxeles:

Después de procesar con un kernel de 5 por 5 píxeles, solo quedan los máximos del vecindario local (es decir, los máximos separados por más de 2 píxeles de un píxel con un valor mayor):

Hay una advertencia. Si dos máximos cercanos tienen el mismo valor, ambos estarán presentes en la imagen final.

Aquí hay un código Python que lo hace, debería ser muy fácil convertirlo a c ++:

import cv

im = cv.LoadImage(''fish2.png'',cv.CV_LOAD_IMAGE_GRAYSCALE)
maxed = cv.CreateImage((im.width, im.height), cv.IPL_DEPTH_8U, 1)
comp = cv.CreateImage((im.width, im.height), cv.IPL_DEPTH_8U, 1)
#Create a 5*5 kernel anchored at 2,2
kernel = cv.CreateStructuringElementEx(5, 5, 2, 2, cv.CV_SHAPE_RECT)

cv.Dilate(im, maxed, element=kernel, iterations=1)
cv.Cmp(im, maxed, comp, cv.CV_CMP_EQ)
cv.Mul(im, comp, im, 1/255.0)

cv.ShowImage("local max only", im)
cv.WaitKey(0)

No me había dado cuenta hasta ahora, pero esto es lo que sugirió @sansuiso en su respuesta.

Esto posiblemente esté mejor ilustrado con esta imagen, antes:

después de procesar con un kernel de 5 por 5:

las regiones sólidas se deben a los valores máximos locales compartidos.

Answer 3

Si está buscando alguna funcionalidad incorporada, FilterEngine lo ayudará a crear un filtro personalizado (kernel).

http://docs.opencv.org/modules/imgproc/doc/filtering.html#filterengine

Además, recomendaría algún tipo de reducción de ruido, por lo general borroso, antes de todo el procesamiento. Eso es a menos que realmente quieras la imagen en bruto.