- 1. Segmentación y contornos
- 2. Modo de jerarquía y recuperación
- 3. Aproximación de contornos y búsqueda de su casco convexo
- 4. Casco convexo
- 5. Coincidencia de contorno por formas
- 6. Identificar formas (círculo, rectángulo, triángulo, cuadrado, estrella)
- 7. Detección de línea
- 8. Detección de manchas
- 9. Filtrar las manchas: contar círculos y elipses
En los tutoriales anteriores, usamos OpenCV para el procesamiento básico de imágenes y realizamos algunas operaciones avanzadas de edición de imágenes. Como sabemos, OpenCV es una biblioteca Commuter Vision de código abierto que tiene interfaces C ++, Python y Java y es compatible con Windows, Linux, Mac OS, iOS y Android. Por lo que se puede instalar fácilmente en Raspberry Pi con entorno Python y Linux. Y Raspberry Pi con OpenCV y cámara adjunta se puede usar para crear muchas aplicaciones de procesamiento de imágenes en tiempo real como detección de rostros, bloqueo de rostros, seguimiento de objetos, detección de matrículas de automóviles, sistema de seguridad para el hogar, etc. En este tutorial aprenderemos cómo hacerlo. segmentación de imágenes mediante OpenCV. Las operaciones que vamos a realizar se enumeran a continuación:
- Segmentación y contornos
- Modo de jerarquía y recuperación
- Aproximación de contornos y búsqueda de su casco convexo
- Conex Casco
- Contorno a juego
- Identificación de formas (círculo, rectángulo, triángulo, cuadrado, estrella)
- Detección de línea
- Detección de manchas
- Filtrar las manchas: contar círculos y elipses
1. Segmentación y contornos
La segmentación de imágenes es un proceso mediante el cual dividimos imágenes en diferentes regiones. Mientras que los contornos son las líneas o curvas continuas que delimitan o cubren el límite completo de un objeto en una imagen. Y aquí usaremos una técnica de segmentación de imágenes llamada contornos para extraer las partes de una imagen.
También los contornos son muy importantes en
- Detección de objetos
- Análisis de formas
Y tienen un campo de aplicación muy amplio, desde el análisis de imágenes del mundo real hasta el análisis de imágenes médicas, como en las resonancias magnéticas.
Sepamos cómo implementar contornos en opencv, extrayendo contornos de cuadrados.
importar cv2 importar numpy como np
Carguemos una imagen simple con 3 cuadrados negros
imagen = cv2.imread ('cuadrados.jpg') cv2.imshow ('imagen de entrada', imagen) cv2.waitKey (0)
Escala de grises
gris = cv2.cvtColor (imagen, cv2.COLOR_BGR2GRAY)
Encuentra bordes astutos
edged = cv2.Canny (gris, 30,200) cv2.imshow ('bordes astutos ', edged) cv2.waitKey (0)
Encontrar contornos
# use una copia de su imagen, por ejemplo, - edged.copy (), ya que al encontrar contornos alteran la imagen # tenemos que agregar _, antes de los contornos como un argumento vacío debido a la actualización de la versión OpenCV _, contours, jerarquía = cv2.findContours (con bordes, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('bordes astutos después del contorno', con bordes) cv2.waitKey (0)
Imprimir el archivo de contorno para saber qué se compone de contornos
print (contours) print ('Números de contornos encontrados =' + str (len (contours)))
Dibujar todos los contornos
#use -1 como tercer parámetro para dibujar todos los contornos cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()
Salida de consola -],],], …,],],]], dtype = int32), formación(],],
], …,
],],]], dtype = int32), matriz (],],], …,],],]], dtype = int32)]
Número de contornos encontrados = 3. Entonces hemos encontrado un total de tres contornos.
Ahora, en el código anterior también habíamos impreso el archivo de contorno usando , este archivo dice cómo se ven estos contornos, como se imprime en la salida de la consola anterior.
En la salida de la consola anterior tenemos una matriz que se parece a las coordenadas de los puntos x, y. OpenCV almacena contornos en listas de listas. Simplemente podemos mostrar la salida de la consola anterior de la siguiente manera:
CONTORNO 1 CONTORNO 2 CONTORNO 3
], matriz (], matriz (],],],],],],],
…,…,…,],],],],],],]], dtype = int32),]], dtype = int32),]], dtype = int32)]
Ahora, como usamos la función de longitud en el archivo de contorno, obtenemos la longitud igual a 3, significa que había tres listas de listas en ese archivo, es decir, tres contornos.
Ahora, imagine CONTOUR 1 es el primer elemento en esa matriz y esa lista contiene una lista de todas las coordenadas y estas coordenadas son los puntos a lo largo de los contornos que acabamos de ver, como los cuadros rectangulares verdes.
Existen diferentes métodos para almacenar estas coordenadas y estos se denominan métodos de aproximación, básicamente los métodos de aproximación son de dos tipos
- cv2.CHAIN_APPROX_NONE
- cv2.CHAIN_APPROX_SIMPLE
cv2.CHAIN_APPROX_NONE almacena todo el punto límite, pero no necesariamente necesitamos todos los puntos límite, si el punto forma una línea recta, solo necesitamos el punto de inicio y el punto final en esa línea.
cv2.CHAIN_APPROX_SIMPLE en cambio solo proporciona los puntos inicial y final de los contornos delimitadores, el resultado es un almacenamiento de información de contorno mucho más eficiente.
_, contornos, jerarquía = cv2.findContours (con bordes, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
En el código anterior cv2.RETR_EXTERNAL es el modo de recuperación mientras que cv2.CHAIN_APPROX_NONE es
el método de aproximación.
Así que hemos aprendido sobre los contornos y el método de aproximación, ahora exploremos la jerarquía y el modo de recuperación.
2. Modo de jerarquía y recuperación
El modo de recuperación define la jerarquía en contornos como subcontornos, o contorno externo o todos los contornos.
Ahora hay cuatro modos de recuperación ordenados por tipos de jerarquía.
cv2.RETR_LIST: recupera todos los contornos.
cv2.RETR_EXTERNAL: recupera únicamente contornos externos o externos.
cv2.RETR_CCOMP: recupera todo en una jerarquía de 2 niveles.
cv2.RETR_TREE: recupera todo en una jerarquía completa.
La jerarquía se almacena en el siguiente formato
Ahora, ilustremos la diferencia entre los dos primeros modos de recuperación, cv2.RETR_LIST y cv2.RETR_EXTERNAL.
importar cv2 importar numpy como np
Carguemos una imagen simple con 3 cuadrados negros
imagen = cv2.imread ('donut cuadrado.jpg') cv2.imshow ('imagen de entrada', imagen) cv2.waitKey (0)
Escala de grises
gris = cv2.cvtColor (imagen, cv2.COLOR_BGR2GRAY)
Encuentra Canny Edges
edged = cv2.Canny (gris, 30,200) cv2.imshow ('bordes astutos ', edged) cv2.waitKey (0)
Encontrar contornos
# use una copia de su imagen, por ejemplo - edged.copy (), ya que al encontrar contornos alteran la imagen # tenemos que agregar _, antes de los contornos como un argumento vacío debido a la actualización de la versión cv abierta _, contours, jerarquía = cv2.findContours (con bordes, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('bordes astutos después del contorno', con bordes) cv2.waitKey (0)
Imprimir el archivo de contorno para saber de qué se compone el contorno.
print (contours) print ('Números de contornos encontrados =' + str (len (contours)))
Dibujar todos los contornos
#use -1 como tercer parámetro para dibujar todos los contornos cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destruir todas las ventanas
importar cv2 importar numpy como np
Carguemos una imagen simple con 3 cuadrados negros
imagen = cv2.imread ('donut cuadrado.jpg') cv2.imshow ('imagen de entrada', imagen) cv2.waitKey (0)
Escala de grises
gris = cv2.cvtColor (imagen, cv2.COLOR_BGR2GRAY)
Encuentra bordes astutos
edged = cv2.Canny (gris, 30,200) cv2.imshow ('bordes astutos ', edged) cv2.waitKey (0)
Encontrar contornos
# use una copia de su imagen, por ejemplo - edged.copy (), ya que al encontrar contornos alteran la imagen # tenemos que agregar _, antes de los contornos como un argumento vacío debido a la actualización de la versión cv abierta _, contornos, jerarquía = cv2.findContours (con bordes, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('bordes astutos después del contorno', con bordes) cv2.waitKey (0)
Imprimir el archivo de contorno para saber de qué se compone el contorno.
print (contours) print ('Números de contornos encontrados =' + str (len (contours)))
Dibujar todos los contornos
#use -1 como tercer parámetro para dibujar todos los contornos cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()
Entonces, a través de la demostración de los códigos anteriores, pudimos ver claramente la diferencia entre cv2.RETR_LIST y cv2.RETR_EXTERNNAL , en cv2.RETR_EXTERNNAL solo se tienen en cuenta los contornos externos mientras que los contornos internos se ignoran.
Mientras que en cv2.RETR_LIST también se tienen en cuenta los contornos interiores.
3. Aproximación de contornos y búsqueda de su casco convexo
Al aproximar contornos, una forma de contorno se aproxima a otra forma de contorno, que puede no ser muy similar a la primera forma de contorno.
Por aproximación usamos approxPolyDP función de OPENCV que se explica a continuación
cv2.approxPolyDP (contorno, precisión de aproximación, cerrado)
Parámetros:
- Contorno: es el contorno individual que deseamos aproximar.
- Precisión de aproximación: parámetro importante para determinar la precisión de la aproximación, los valores pequeños dan una aproximación precisa, los valores grandes dan información más genérica. Una buena regla general es menos del 5% del perímetro del contorno.
- Cerrado: un valor booleano que indica si el contorno aproximado puede estar abierto o cerrado.
Intentemos aproximarnos a la figura simple de una casa.
importar numpy como np importar cv2
Cargue la imagen y guarde una copia
imagen = cv2.imread ('casa.jpg') orig_image = image.copy () cv2.imshow ('imagen original', orig_image) cv2.waitKey (0)
Escala de grises y binarizar la imagen
gris = cv2.cvtColor (imagen, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold (gris, 127,255, cv2.THRESH_BINARY_INV)
Encuentra contornos
_, contornos, jerarquía = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
Itere a través de cada contorno y calcule su rectángulo delimitador
para c en contornos: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (orig_image, (x, y), (x + w, y + h), (0,0,255), 2) cv2.imshow ('Rect delimitador ', orig_image) cv2.waitKey (0)
Itere a través de cada contorno y calcule el contorno aproximado
para c en contornos:
#calcular la precisión como un porcentaje de la precisión del perímetro del contorno = 0.03 * cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, precision, True) cv2.drawContours (image,, 0, (0,255,0), 2) cv2.imshow ('Aprox polyDP', imagen) cv2.waitKey (0) cv2.destroyAllWindows ()
4. Casco convexo
El casco convexo son básicamente los bordes exteriores, representados por líneas de dibujo sobre una figura determinada.
Podría ser el polígono más pequeño que pueda caber alrededor del objeto.
import cv2 import numpy as np image = cv2.imread ('star.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('original image', image) cv2.waitKey (0)
Umbral de la imagen
ret, thresh = cv2.threshold (gris, 176,255,0)
Encuentra contornos
_, contornos, jerarquía = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
Ordene los contornos por área y luego elimine el contorno de marco más grande
n = len (contornos) -1 contornos = ordenados (contornos, clave = cv2.contourArea, reverso = Falso)
Itera a través de los contornos y dibuja un casco convexo
para c en contornos:
casco = cv2.convexHull (c) cv2.drawContours (imagen,, 0, (0,255,0), 2) cv2.imshow ('casco convexo', imagen) cv2.waitKey (0) cv2.destroyAllWindows ()
5. Coincidencia de contorno por formas
cv2.matchShapes (plantilla de contorno, método de contorno, parámetro de método)
Salida: valor de coincidencia (un valor más bajo significa una coincidencia más cercana)
plantilla de contorno: este es nuestro contorno de referencia que estamos tratando de encontrar en una nueva imagen.
contorno: el contorno individual que estamos comprobando.
Método - Tipo de coincidencia de contorno (1,2,3).
parámetro de método: déjelo solo como 0.0 (no se utiliza en python opencv)
importar cv2 importar numpy como np
Cargue la plantilla de forma o la imagen de referencia
plantilla = cv2.imread ('estrella.jpg', 0) cv2.imshow ('plantilla', plantilla) cv2.waitKey (0)
Cargue la imagen de destino con las formas que estamos tratando de hacer coincidir
objetivo = cv2.imread ('shapestomatch.jpg') gris = cv2.cvtColor (objetivo, cv2.COLOR_BGR2GRAY)
Umbral de ambas imágenes primero antes de usar cv2.findContours
ret, thresh1 = cv2.threshold (plantilla, 127,255,0) ret, thresh2 = cv2.threshold (gris, 127,255,0)
Encuentra contornos en la plantilla
_, contornos, jerarquía = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) #necesitamos ordenar los contornos por área para poder eliminar el contorno más grande que es
Esquema de la imagen
sorted_contours = sorted (contours, key = cv2.contourArea, reverse = True) # extraemos el segundo contorno más grande que será nuestra plantilla contour tempelate_contour = contours #extraer los contornos de la segunda imagen de destino _, contours, jerarquía = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) para c en contornos: #iterate a través de cada contorno en la imagen de destino y usa cv2.matchShape para comparar la forma del contorno match = cv2.matchShapes (tempelate_contour, c, 1,0.0) imprimir ("coincidencia") # si el valor de coincidencia es menor que 0,15 si coincide <0,16: más cercano_contour = c else: más cercano_contour = cv2.drawContours (objetivo,, - 1, (0,255,0), 3) cv2.imshow ('salida',objetivo) cv2.waitKey (0) cv2.destroyAllWindows ()
Salida de consola -
0.16818605122199104
0.19946910256158912
0.18949760627309664
0.11101058276281539
Hay tres métodos diferentes con diferentes funciones matemáticas, podemos experimentar con cada método simplemente reemplazando los valores del método cv2.matchShapes (tempelate_contour, c, 1, 0.0) que varían de 1, 2 y 3, para cada valor obtendrá una coincidencia diferente valores en la salida de la consola.
6. Identificar formas (círculo, rectángulo, triángulo, cuadrado, estrella)
OpenCV también se puede utilizar para detectar diferentes tipos de formas automáticamente a partir de la imagen. Al usar el siguiente código, podremos detectar círculos, rectángulos, triángulos, cuadrados y estrellas de la imagen.
importar cv2 importar numpy como np
Carga y luego escala de grises imágenes
imagen = cv2.imread ('formas.jpg') gris = cv2.cvtColor (imagen, cv2.COLOR_BGR2GRAY) cv2.imshow ('identificando formas', imagen) cv2.waitKey (0) ret, thresh = cv2.threshold (gris, 127,255,1)
Extraer contornos
_, contornos, jerarquía = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
Para cnt en contornos:
Obtenga polígonos aproximados approx = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True) if len (approx) == 3: shape_name = "Triangle" cv2.drawContours (image,, 0, (0,255, 0), - 1)
encontrar el centro del contorno para colocar el texto en el centro
M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagen, nombre_forma, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (aprox) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M /METRO)
Verifique si ese polígono de cuatro lados es cuadrado o rectángulo
# cv2.boundingRect devolver la anchura izquierda y altura en píxeles, a partir de la parte superior de esquina #left, para el cuadrado que sería más o menos igual si abs (Wh) <= 3: shape_name = "cuadrada" centro de contorno #find para colocar texto en center cv2.drawContours (image,, 0, (0,125,255), - 1) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "Reactangle" # encuentra el centro del contorno para colocar el texto en el centro cv2.drawContours (image,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagen, nombre_forma, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox) == 10: nombre_forma = 'estrella' cv2.drawContours (imagen,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagen, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox)> = 15: shape_name = 'circle' cv2.drawContours (image,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identificación de formas', imagen) cv2.waitKey (0) cv2.destroyAllWindows ()
7. Detección de línea
La detección de líneas es un concepto muy importante en OpenCV y tiene un uso prometedor en el mundo real. Los coches autónomos utilizan algoritmos de detección de líneas para la detección de carriles y carreteras.
En la detección de línea nos ocuparemos de dos algoritmos,
- Algoritmo de línea Hough
- Algoritmo Probalístico de Hough Line.
Es posible que haya recordado la representación de la recta de las matemáticas de la escuela secundaria con la ecuación, y = mx + c.
Sin embargo, en OpenCV la línea se representa de otra manera
La ecuación anterior ρ = xcosӨ + ysincosӨ es la representación OpenCV de la línea, donde ρ es la distancia perpendicular de la línea desde el origen y Ө es el ángulo formado por la normal de esta línea al origen (medido en radianes, donde 1pi radianes / 180 = 1 grado).
La función OpenCV para la detección de línea se da como
cv2.HoughLines (imagen binarizada, ρ precisión, Ө precisión, umbral), donde el umbral es el voto mínimo para que se considere una línea.
Ahora detectemos líneas para una imagen de caja con la ayuda de la función de línea Hough de opencv.
importar cv2 importar numpy como np image = cv2.imread ('box.jpg')
Escala de grises y bordes astutos extraídos
gris = cv2.cvtColor (imagen, cv2.COLOR_BGR2GRAY) bordes = cv2.Canny (gris, 100,170, apertureSize = 3)
Ejecute líneas Hough con una precisión de rho de 1 píxel
#theta precisión de (np.pi / 180) que es 1 grado # el umbral de línea se establece en 240 (número de puntos en la línea) líneas = cv2.HoughLines (bordes, 1, np.pi / 180, 240) # iteramos a través de cada línea y conviértalo al formato #required by cv2.lines (es decir, que requiere puntos finales) para i en el rango (0, len (líneas)): para rho, theta en líneas: a = np.cos (theta) b = np.sin (theta) x0 = a * rho y0 = b * rho x1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.line (imagen, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('sin líneas', imagen) cv2.waitKey (0) cv2.destroyAllWindows ()
Ahora repitamos la detección de la línea anterior con otro algoritmo de línea probabilística de Hough.
La idea detrás de la línea probabilística de Hough es tomar un subconjunto aleatorio de puntos suficiente para la detección de líneas.
La función OpenCV para la línea probabilística de Hough se representa como cv2.HoughLinesP (imagen binarizada, precisión ρ, precisión Ө, umbral, longitud de línea mínima, espacio de línea máximo)
Ahora detectemos líneas de caja con la ayuda de líneas probabilísticas de Hough.
importar cv2 importar numpy como np
Escala de grises y bordes astutos extraídos
image = cv2.imread ('box.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) bordes = cv2.Canny (gray, 50,150, apertureSize = 3) # de nuevo usamos las mismas precisiones rho y theta # sin embargo, especificamos un voto mínimo (pts a lo largo de la línea) de 100 # y una longitud de línea mínima de 5 píxeles y un espacio máximo entre las líneas de 10 píxeles líneas = cv2.HoughLinesP (bordes, 1, np.pi / 180,100,100,10) para i in range (0, len (líneas)): para x1, y1, x2, y2 en líneas: cv2.line (image, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', imagen) cv2.waitKey (0) cv2.destroyAllWindows
8. Detección de manchas
Los blobs se pueden describir como un grupo de píxeles conectados que comparten una propiedad común. El método para utilizar el detector de manchas OpenCV se describe a través de este diagrama de flujo.
Para dibujar los puntos clave usamos cv2.drawKeypoints que toma los siguientes argumentos.
cv2.drawKeypoints (imagen de entrada, keypoints, blank_output_array, color, banderas)
donde en las banderas podría estar
cv2.DRAW_MATCHES_FLAGS_DEFAULT
cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG
cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
y en blanco aquí no es más que una matriz de ceros uno por uno
Ahora realicemos la detección de manchas en una imagen de girasoles, donde las manchas serían las partes centrales de la flor ya que son comunes entre todas las flores.
importar cv2 importar numpy como np image = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)
Configurar detector con parámetros predeterminados
detector = cv2.SimpleBlobDetector_create ()
Detectar manchas
puntos clave = detector.detect (imagen)
Dibujar manchas detectadas como círculos rojos
# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS asegúrese de que el # tamaño del círculo corresponda al tamaño del blob en blanco = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagen, puntos clave, en blanco, (0,255,255), cv2.DRAW_MATCHES_FLAGS)
Mostrar puntos clave
cv2.imshow ('blobs', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()
A pesar de que el código funciona bien, algunas de las manchas se pasan por alto debido a los tamaños desiguales de las flores, ya que las flores en el frente son grandes en comparación con las flores al final.
9. Filtrar las manchas: contar círculos y elipses
Podemos utilizar parámetros para filtrar las manchas según su forma, tamaño y color. Para usar parámetros con el detector de manchas usamos la función de OpenCV
cv2.SimpleBlobDetector_Params ()
Veremos filtrar los blobs principalmente por estos cuatro parámetros que se enumeran a continuación:
Zona
params.filterByArea = Verdadero / Falso params.minArea = píxeles params.maxArea = píxeles
Circularidad
params.filterByCircularity = True / False params.minCircularity = 1 es perfecto, 0 es opuesto
Convexidad: área de mancha / área de casco convexo
params.filterByConvexity = Verdadero / Falso params.minConvexity = Área
Inercia
params.filterByInertia = Verdadero / Falso params.minInertiaRatio = 0.01
Ahora intentemos filtrar blobs por los parámetros mencionados anteriormente.
importar cv2 importar numpy como np image = cv2.imread ('blobs.jpg') cv2.imshow ('imagen original', imagen) cv2.waitKey (0)
Inicialice el detector usando los parámetros predeterminados
detector = cv2.SimpleBlobDetector_create ()
Detectar manchas
puntos clave = detector.detect (imagen)
Dibuja manchas en nuestra imagen como círculos rojos
blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagen, keypoints, blank, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "número total de blobs" + str (len (puntos clave)) cv2.putText (blobs, texto, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)
Mostrar imagen con puntos clave de blob
cv2.imshow ('blob usando parámetros predeterminados', blobs) cv2.waitKey (0)
Establecer nuestros parámetros de filtrado
#inicializar la configuración de parámetros usando cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()
Establecer parámetros de filtrado de área
params.filterByArea = True params.minArea = 100
Establecer parámetros de filtrado de circularidad
params.filterByCircularity = True params.minCircularity = 0.9
Establecer parámetro de filtrado de convexidad
params.filterByConvexity = Falso params.minConvexity = 0.2
Establecer parámetro de filtrado de inercia
params.filterByInertia = True params.minInertiaRatio = 0.01
Crear detector con parámetro
detector = cv2.SimpleBlobDetector_create (params)
Detectar manchas
puntos clave = detector.detect (imagen)
Dibuja manchas en las imágenes como círculos rojos
blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagen, keypoints, blank, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "número total de manchas circulares" + str (len (puntos clave)) cv2.putText (blobs, texto, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)
Mostrar manchas
cv2.imshow ('filtrado de blobs circulares', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()
Así es como se puede realizar la segmentación de imágenes en Python-OpenCV. Para comprender bien la visión por computadora y OpenCV, lea los artículos anteriores (Comenzando con Python OpenCV y manipulaciones de imágenes en Python OpenCV y podrá hacer algo genial con Computer Vision.