Este es un gran problema de modelado. Tengo las siguientes recomendaciones / ideas:

1. Divida la imagen en RGB y luego procese.
2. preprocesamiento.
3. Búsqueda dinámica de parámetros.
4. Agregue restricciones.
5. Asegúrese de lo que está tratando de detectar.

En más detalle:

1: Como se señaló en otras respuestas, convertir directamente a escala de grises descarta demasiada información, cualquier círculo con un brillo similar al del fondo se perderá. Mucho mejor considerar los canales de color ya sea de forma aislada o en un espacio de color diferente. Hay más o menos dos maneras de ir aquí: realizar HoughCircles en cada canal preprocesado de forma aislada, luego combinar resultados, o, procesar los canales, luego combinarlos, luego operar HoughCircles. En mi intento a continuación, he intentado el segundo método, dividir en canales RGB, procesamiento, luego combinar. Tenga cuidado de sobre saturar la imagen al combinar, utilizo cv.And para evitar este problema (en este etapa mis círculos son siempre anillos negros / discos sobre fondo blanco).

2: El preprocesamiento es bastante complicado, y a menudo es mejor jugar con algo. He hecho uso de AdaptiveThreshold, que es un método de convolución realmente poderoso que puede mejorar los bordes de una imagen mediante la fijación de píxeles en función de su promedio local (procesos similares también ocurren en la ruta temprana del sistema visual de mamíferos). Esto también es útil, ya que reduce algo de ruido. He usado dilate/erode con una sola pasada. Y he mantuviste los otros parámetros como los tenías. Parece que usar Canny antes de HoughCircles ayuda mucho a encontrar 'círculos llenos', así que probablemente sea mejor mantenerlo. Este pre-procesamiento es bastante pesado y puede conducir a falsos positivos con algo más 'círculos blobby', pero en nuestro caso esto es quizás deseable?

3: Como usted ha señalado HoughCircles parámetro param2 (su parámetro LOW) necesita ser ajustado para cada imagen con el fin de obtener una solución óptima, de hecho de la docs :

Cuanto más pequeño es, más falsos círculos pueden ser detectados.

El problema es que el punto dulce va a ser diferente para cada imagen. Creo que el mejor enfoque aquí es establecer una condición y hacer una búsqueda a través de diferentes valores param2 hasta que se cumpla esta condición. Sus imágenes muestran círculos que no se superponen, y cuando param2 es demasiado bajo, normalmente obtenemos un montón de círculos superpuestos. Así que sugiero buscar el:

Máximo número de círculos no superpuestos y no contenidos

Así que seguimos llamando a HoughCircles con diferentes valores de param2 hasta que esto se cumpla. Hago esto en mi ejemplo a continuación, simplemente incrementando param2 hasta que alcanza la suposición de umbral. Sería mucho más rápido (y bastante fácil de hacer) si realiza una búsqueda binaria para encontrar cuando se cumple esto, pero debe tener cuidado con el manejo de excepciones, ya que opencv a menudo arroja errores para valores de aspecto inocente de param2 (al menos en mi instalación). Una condición diferente que sería muy útil para que coincida con sería el número de círculos.

4: ¿Hay más restricciones que podamos agregar al modelo? Cuantas más cosas podamos decirle a nuestro modelo, más fácil será la tarea de detectar círculos. Por ejemplo, ¿sabemos:

• El número de círculos. - incluso un límite superior o inferior es útil.
• Posibles colores de los círculos, o del fondo, o de 'no-círculos'.
• Su Tamaño.
• Donde pueden estar en una imagen.

5: ¡Algunas de las manchas en sus imágenes solo podrían llamarse círculos vagamente! Considere los dos 'blobs no circulares' en su segunda imagen, mi código no puede encontrarlos (¡bien!), pero... si los 'photoshop' para que sean más circulares, mi código puede encontrarlos... Tal vez si quieres detectar cosas que no son círculos, un enfoque diferente como Tim Lukins puede ser mejor.

Problemas

Haciendo pesado preprocesamiento AdaptiveThresholding y `Canny' puede haber mucha distorsión en las características de una imagen, lo que puede conducir a una detección de círculo falso o un informe de radio incorrecto. Por ejemplo, un disco sólido grande después del procesamiento puede aparecer como un anillo, por lo que HughesCircles puede encontrar el anillo interior. Además, incluso los documentos señalan que:

...por lo general, la función detecta bien los centros de los círculos, sin embargo, puede no encontrar los radios correctos.

Si necesita radios más precisos detection, I suggest the following approach (not implemented):

• En la imagen original, traza de rayos desde el centro del círculo reportado, en una cruz en expansión (4 rayos: arriba/abajo/izquierda/derecha)
• Haga esto por separado en cada canal RGB
• Combine esta información para cada canal para cada rayo de una manera sensible (es decir. flip, offset, scale, etc. según sea necesario)
• tome el promedio de los primeros píxeles en cada rayo, use esto para detectar donde una desviación significativa en el ray aparece.
• Estos 4 puntos son estimaciones de puntos en la circunferencia.
• Utilice estas cuatro estimaciones para determinar un radio más preciso, y la posición del centro(!).
• Esto podría generalizarse mediante el uso de un anillo en expansión en lugar de cuatro rayos.

Resultados

El código al final hace bastante bien la mayor parte del tiempo, estos ejemplos se hicieron con el código como se muestra:

Detecta todos los círculos en su primera imagen:

Cómo se ve la imagen preprocesada antes de aplicar el filtro canny (los círculos de diferentes colores son muy visibles):

Detecta todos menos dos (blobs) en la segunda imagen:

Segunda imagen alterada (los blobs son circulares, y el óvalo grande se hace más circular, mejorando así la detección), todos detectados:

Hace bastante bien en la detección de centros en esta pintura de Kandinsky (no puedo encontrar anillos concéntricos debido a la condición de límite).

Código:

import cv
import numpy as np

output = cv.LoadImage('case1.jpg')
orig = cv.LoadImage('case1.jpg')

# create tmp images
rrr=cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
ggg=cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
bbb=cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
processed = cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
storage = cv.CreateMat(orig.width, 1, cv.CV_32FC3)

def channel_processing(channel):
    pass
    cv.AdaptiveThreshold(channel, channel, 255, adaptive_method=cv.CV_ADAPTIVE_THRESH_MEAN_C, thresholdType=cv.CV_THRESH_BINARY, blockSize=55, param1=7)
    #mop up the dirt
    cv.Dilate(channel, channel, None, 1)
    cv.Erode(channel, channel, None, 1)

def inter_centre_distance(x1,y1,x2,y2):
    return ((x1-x2)**2 + (y1-y2)**2)**0.5

def colliding_circles(circles):
    for index1, circle1 in enumerate(circles):
        for circle2 in circles[index1+1:]:
            x1, y1, Radius1 = circle1[0]
            x2, y2, Radius2 = circle2[0]
            #collision or containment:
            if inter_centre_distance(x1,y1,x2,y2) < Radius1 + Radius2:
                return True

def find_circles(processed, storage, LOW):
    try:
        cv.HoughCircles(processed, storage, cv.CV_HOUGH_GRADIENT, 2, 32.0, 30, LOW)#, 0, 100) great to add circle constraint sizes.
    except:
        LOW += 1
        print 'try'
        find_circles(processed, storage, LOW)
    circles = np.asarray(storage)
    print 'number of circles:', len(circles)
    if colliding_circles(circles):
        LOW += 1
        storage = find_circles(processed, storage, LOW)
    print 'c', LOW
    return storage

def draw_circles(storage, output):
    circles = np.asarray(storage)
    print len(circles), 'circles found'
    for circle in circles:
        Radius, x, y = int(circle[0][2]), int(circle[0][0]), int(circle[0][1])
        cv.Circle(output, (x, y), 1, cv.CV_RGB(0, 255, 0), -1, 8, 0)
        cv.Circle(output, (x, y), Radius, cv.CV_RGB(255, 0, 0), 3, 8, 0)

#split image into RGB components
cv.Split(orig,rrr,ggg,bbb,None)
#process each component
channel_processing(rrr)
channel_processing(ggg)
channel_processing(bbb)
#combine images using logical 'And' to avoid saturation
cv.And(rrr, ggg, rrr)
cv.And(rrr, bbb, processed)
cv.ShowImage('before canny', processed)
# cv.SaveImage('case3_processed.jpg',processed)
#use canny, as HoughCircles seems to prefer ring like circles to filled ones.
cv.Canny(processed, processed, 5, 70, 3)
#smooth to reduce noise a bit more
cv.Smooth(processed, processed, cv.CV_GAUSSIAN, 7, 7)
cv.ShowImage('processed', processed)
#find circles, with parameter search
storage = find_circles(processed, storage, 100)
draw_circles(storage, output)
# show images
cv.ShowImage("original with circles", output)
cv.SaveImage('case1.jpg',output)

cv.WaitKey(0)

Ah, sí the los antiguos invariantes de color/tamaño para el problema de los círculos (TAMBIÉN conocido como la transformada de Hough es demasiado específica y no robusta)...

En el pasado he confiado mucho más en las funciones de análisis estructural y de forma de OpenCV. Usted puede obtener una muy buena idea de la carpeta "muestras" de lo que es posible - en particular fitellipse.py y squares.py.

Para su aclaración, presento una versión híbrida de estos ejemplos y basada en su fuente original. Los contornos detectados están en verde y las elipses ajustadas en rojo.

Todavía no está ahí:

• Los pasos de preprocesamiento necesitan un poco de ajuste para detectar los círculos más débiles.
• Puede probar el contorno más a fondo para determinar si es un círculo o no...

¡Buena suerte!

import cv
import numpy as np

# grab image
orig = cv.LoadImage('circles3.jpg')

# create tmp images
grey_scale = cv.CreateImage(cv.GetSize(orig), 8, 1)
processed = cv.CreateImage(cv.GetSize(orig), 8, 1)

cv.Smooth(orig, orig, cv.CV_GAUSSIAN, 3, 3)

cv.CvtColor(orig, grey_scale, cv.CV_RGB2GRAY)

# do some processing on the grey scale image
cv.Erode(grey_scale, processed, None, 10)
cv.Dilate(processed, processed, None, 10)
cv.Canny(processed, processed, 5, 70, 3)
cv.Smooth(processed, processed, cv.CV_GAUSSIAN, 15, 15)

#storage = cv.CreateMat(orig.width, 1, cv.CV_32FC3)
storage = cv.CreateMemStorage(0)

contours = cv.FindContours(processed, storage, cv.CV_RETR_EXTERNAL)
# N.B. 'processed' image is modified by this!

#contours = cv.ApproxPoly (contours, storage, cv.CV_POLY_APPROX_DP, 3, 1) 
# If you wanted to reduce the number of points...

cv.DrawContours (orig, contours, cv.RGB(0,255,0), cv.RGB(255,0,0), 2, 3, cv.CV_AA, (0, 0)) 

def contour_iterator(contour):
  while contour:
    yield contour
    contour = contour.h_next()

for c in contour_iterator(contours):
  # Number of points must be more than or equal to 6 for cv.FitEllipse2
  if len(c) >= 6:
    # Copy the contour into an array of (x,y)s
    PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2)

    for (i, (x, y)) in enumerate(c):
      PointArray2D32f[0, i] = (x, y)

    # Fits ellipse to current contour.
    (center, size, angle) = cv.FitEllipse2(PointArray2D32f)

    # Convert ellipse data from float to integer representation.
    center = (cv.Round(center[0]), cv.Round(center[1]))
    size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5))

    # Draw ellipse
    cv.Ellipse(orig, center, size, angle, 0, 360, cv.RGB(255,0,0), 2,cv.CV_AA, 0)

# show images
cv.ShowImage("image - press 'q' to quit", orig)
#cv.ShowImage("post-process", processed)
cv.WaitKey(-1)

EDITAR:

Solo una actualización para decir que creo que un tema importante para todas estas respuestas es que hay una serie de suposiciones y restricciones adicionales que se puede aplicar a lo que busca reconocer como circular . Mi propia respuesta no hace ninguna pretensión en esto-ni en el pre-procesamiento de bajo nivel o el ajuste geométrico de alto nivel. El hecho de que muchos de los círculos no son realmente tan redondos debido a la forma en que se dibujan o las transformaciones no afines/proyectivas de la imagen, y con las otras propiedades en la forma en que se representan/capturan (color, ruido, iluminación, grosor del borde), todo resulta en cualquier número de posibles círculos candidatos dentro de una sola imagen.

Hay técnicas mucho más sofisticadas. Pero te costarán. Personalmente me gusta @fraxel idea de utilizar el adaptativa umbral. Eso es rápido, confiable y razonablemente robusto. A continuación, puede probar más los contornos finales (por ejemplo, usar momentos Hu) o accesorios con una prueba de relación simple del eje elipse, por ejemplo, if ((min(size)/max(size))>0.7).

Como siempre con la Visión por Computadora existe la tensión entre el pragmatismo, el principio y la parsomonía. Como me gusta de decirle a la gente que piensa que CV es fácil, no lo es-es de hecho famoso un AI completo problema. Lo mejor que a menudo puede esperar fuera de esto es algo que funciona la mayor parte del tiempo.

Mirando a través de su código, me di cuenta de lo siguiente:

• Conversión de escala de grises. Entiendo por qué lo estás haciendo, pero date cuenta de que estás lanzando información de distancia allí. Como puedes ver en las imágenes de "post-proceso", tus círculos amarillos son la misma intensidad que el fondo, solo que en un color diferente.

• Detección de bordes después de la eliminación de ruido (erae / dilatar). Esto no debería ser necesario; Canny debería hacerse cargo de esto.

• Detección de Canny edge. Los círculos "abiertos" tienen dos bordes, uno interno y otro externo. Dado que están bastante cerca, el filtro Canny Gauss podría sumarlos. Si no lo hace, tendrá dos bordes juntos. Es decir, antes de Canny, tienes círculos abiertos y llenos. Después, tienes 0/2 y 1 borde, respectivamente. Dado que Hough vuelve a llamar a Canny, en el primer caso los dos bordes podrían suavizarse juntos (dependiendo del ancho inicial), por lo que el algoritmo core Hough puede tratar los círculos abiertos y llenos igual.

Entonces, mi primera recomendación sería cambiar la asignación de escala de grises. No uses intensidad, sino tono / saturación / valor. Además, usa un enfoque diferencial: estás buscando bordes. Por lo tanto, calcular una transformación HSV, suavizar una copia, y luego tomar la diferencia entre la copia original y suavizado. Esto le dará dH, dS, dV valores (variación local en Tono, Saturación, Valor) para cada punto. Cuadrar y agregar para obtener una imagen unidimensional, con picos cerca de todos los bordes (interior y exterior).

Mi segunda recomendación sería la normalización local, pero no estoy seguro de si eso es siquiera necesario. La idea es que no te importa mucho el valor exacto de la señal de borde que saliste, realmente debería ser binaria de todos modos (borde o no). Por lo tanto, puede normalizar cada valor dividiendo por un promedio local (donde local está en el orden de magnitud del tamaño de su borde).

La transformación de Hough utiliza un "modelo" para encontrar ciertas características en una imagen (típicamente) detectada en los bordes, como puede saber. En el caso de HoughCircles ese modelo es un círculo perfecto. Esto significa que probablemente no existe una combinación de parámetros que lo harán detectar los círculos en forma de elipse y erráticamente en su imagen sin aumentar el número de falsos positivos. Por otro lado, debido al mecanismo de votación subyacente, un círculo perfecto no cerrado o un círculo perfecto con una "dent" podría aparecer constantemente. Así que dependiendo de su salida esperada puede o no querer usar este método.

Dicho esto, hay algunas cosas que veo que podrían ayudarte en tu camino con esta función:{[16]]}

1. HoughCircles llama a Canny internamente, así que supongo que puedes dejar esa llamada.
2. param1 (que se llama HIGH) se inicializa típicamente alrededor de un valor de 200. Se utiliza como parámetro para la llamada interna a Canny: cv.Canny(processed, cannied, HIGH, HIGH/2). Podría ayudar a ejecute Canny usted mismo para ver cómo la configuración HIGH afecta a la imagen con la que trabaja la transformación de Hough.
3. param2 (que se llama LOW) se inicializa típicamente alrededor de un valor 100. Es el umbral de votación para los acumuladores de la transformada de Hough. Fijarlo más alto significa más falsos negativos, más bajos falsos positivos. Creo que este es el primero con el que quieres empezar a jugar.

Ref: http://docs.opencv.org/3.0-beta/modules/imgproc/doc/feature_detection.html#houghcircles

Update re: filled circles : Después de encontrar las formas de círculo con la transformación de Hough, puede probar si están llenas muestreando el color límite y comparándolo con uno o más puntos dentro del supuesto círculo. Alternativamente, puede comparar uno o más puntos dentro del supuesto círculo con un color de fondo dado. El círculo se llena si la comparación anterior tiene éxito, o en el caso de la comparación alternativa si falla.

Ok mirando las imágenes. Sugiero usar **Active Contours**

• Contornos activos Lo bueno de los contornos activos es que casi encajan perfectamente en cualquier forma dada. Ya sean cuadrados o triángulos y en su caso son los candidatos perfectos.
• Si eres capaz de extraer el centro de los círculos, eso es genial. Los contornos activos siempre necesitan un punto a partir del cual puedan crecer o encogerse para ajustarse. No es necesario que los centros estén siempre alineados al centro. Un poco de compensación todavía estará bien.
• Y en su caso, si deja que los contornos crezcan desde el centro hacia afuera, descansarán en los límites del círculo.
• Tenga en cuenta que los contornos activos que crecen o se contraen utilizan energía de globo lo que significa que puede establecer la dirección de los contornos, hacia adentro o hacia afuera.
• Probablemente necesite usar la imagen degradada en escala de grises. Pero aún así puedes probar en color también. Si funciona!
• Y si no proporciona los centros, echan en porciones de contornos activos, hacen entonces crecer / encoger. Los contornos que se asientan se mantienen, los inconstantes se desechan. Este es un enfoque de fuerza bruta. Será intensivo de CPU. Pero requerirá un trabajo más cuidadoso para asegurarse de dejar contornos correctos y tirar los malos.

Espero que así puedas resolver el problema.