Umbral de OpenCV en Python con cv2.threshold()

Introducción

La umbralización es una técnica simple y eficiente para realizar una segmentación básica en una imagen y para binarizarla (convertirla en una imagen binaria) donde los píxeles son 0 or 1 (o 255 si está utilizando números enteros para representarlos).

Por lo general, puede usar el umbral para realizar una segmentación simple de fondo y primer plano en una imagen, y se reduce a variantes en una técnica simple para cada píxel:

if pixel_value > threshold:
    pixel_value = MAX
else:
    pixel_value = 0

Este proceso esencial se conoce como Umbral binario. Ahora, hay varias formas de modificar esta idea general, incluida la inversión de las operaciones (cambiar el > firmar con un < señal), configurando el pixel_value En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”. threshold en lugar de un valor máximo/0 (conocido como truncado), manteniendo el pixel_value sí mismo si está por encima de la threshold o si está debajo del threshold.

Todos estos han sido convenientemente implementados en OpenCV como:

• cv2.THRESH_BINARY
• cv2.THRESH_BINARY_INV
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2.THRESH_TOZERO_INV

… respectivamente. Estos son métodos relativamente "ingenuos" en el sentido de que son bastante simples, no tienen en cuenta el contexto en las imágenes, tienen conocimiento de qué formas son comunes, etc. Para estas propiedades, tendríamos que emplear mucho más costoso y potente desde el punto de vista computacional. tecnicas

Ahora, incluso con los métodos "ingenuos" - algo Se pueden implementar heurísticas para encontrar buenos umbrales, y estos incluyen el método Otsu y el método Triangle:

• cv2.THRESH_OTSU
• cv2.THRESH_TRIANGLE

Otra forma de superar algunos de los problemas con el umbral básico con un solo valor de umbral es usar umbral adaptativo que aplica un valor de umbral en cada región pequeña de una imagen, en lugar de globalmente.

Umbral simple con OpenCV

La umbralización en la API de Python de OpenCV se realiza a través de la cv2.threshold() método – que acepta una imagen (matriz NumPy, representada con números enteros), el umbral, el valor máximo y el método de umbralización (cómo threshold y maximum_value son usados):

img = cv2.imread('objects.jpg')

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)


blurred = cv2.GaussianBlur(img, (7, 7), 0)

ret, img_masked = cv2.threshold(blurred, 220, 255, cv2.THRESH_BINARY)

El código de retorno es solo el umbral aplicado:

print(f"Threshold: {ret}") 

Aquí, dado que el umbral es 220 y hemos usado el THRESH_BINARY método: cada valor de píxel anterior 220 se incrementará a 255, mientras que cada valor de píxel debajo 220 será bajado a 0, creando una imagen en blanco y negro, con una “máscara”, cubriendo los objetos en primer plano.

¿Por qué 220? Saber cómo se ve la imagen le permite hacer algunas conjeturas aproximadas sobre qué umbral puede elegir. En la práctica, rara vez querrá establecer un umbral manual, y cubriremos la selección de umbral automático en un momento.

¡Grafiquemos el resultado! Las ventanas de OpenCV pueden ser un poco complicadas, por lo que trazaremos la imagen original, la imagen borrosa y los resultados usando Matplotlib:

fig, ax = plt.subplots(1, 3, figsize=(12, 8))
ax[0].imshow(img)
ax[1].imshow(blurred)
ax[2].imshow(img_masked)

Métodos de umbral

Como se mencionó anteriormente, hay varias formas de usar el umbral y el valor máximo en una función. Hemos echado un vistazo al umbral binario inicialmente. Vamos a crear una lista de métodos y aplicarlos uno por uno, trazando los resultados:

methods = [cv2.THRESH_BINARY, cv2.THRESH_BINARY_INV, cv2.THRESH_TRUNC, cv2.THRESH_TOZERO, cv2.THRESH_TOZERO_INV]
names = ['Binary Threshold', 'Inverse Binary Threshold', 'Truncated Threshold', 'To-Zero Threshold', 'Inverse To-Zero Threshold']

def thresh(img_path, method, index):
    img = cv2.imread(img_path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    blurred = cv2.GaussianBlur(img, (7, 7), 0)
    ret, img_masked = cv2.threshold(blurred, 220, 255, method)

    fig, ax = plt.subplots(1, 3, figsize=(12, 4))
    fig.suptitle(names[index], fontsize=18)
    ax[0].imshow(img)
    ax[1].imshow(blurred)
    ax[2].imshow(img_masked)
    plt.tight_layout()

for index, method in enumerate(methods):
    thresh('coins.jpeg', method, index)

THRESH_BINARY y THRESH_BINARY_INV son inversos entre sí, y binarizan una imagen entre 0 y 255, asignándolos al fondo y al primer plano respectivamente, y viceversa.

THRESH_TRUNC binariza la imagen entre threshold y 255.

THRESH_TOZERO y THRESH_TOZERO_INV binarizar entre 0 y el valor de píxel actual (src(x, y)). Echemos un vistazo a las imágenes resultantes:

Estos métodos son lo suficientemente intuitivos, pero, ¿cómo podemos automatizar un buen valor de umbral y qué significa un valor de "buen umbral"? La mayoría de los resultados hasta ahora tenían máscaras no ideales, con marcas y motas. Esto sucede debido a la diferencia en las superficies reflectantes de las monedas: no tienen un color uniforme debido a la diferencia en la forma en que las crestas reflejan la luz.

Podemos, hasta cierto punto, combatir esto encontrando un mejor umbral global.

Umbral automático/optimizado con OpenCV

OpenCV emplea dos métodos efectivos de búsqueda de umbral global: el método de Otsu y el método Triangle.

El método de Otsu asume que está funcionando en bimodal imágenes Las imágenes bimodales son imágenes cuyos histogramas de color solo contienen dos picos (es decir, solo tienen dos valores de píxel distintos). Teniendo en cuenta que cada uno de los picos pertenece a una clase como "fondo" y "primer plano", el umbral ideal está justo en el medio de ellos.

Crédito de la imagen: https://scipy-lectures.org/

Puede hacer que algunas imágenes sean más bimodales con desenfoques gaussianos, pero no todas.

Un algoritmo alternativo, a menudo con mejor rendimiento, es el algoritmo triangular, que calcula la distancia entre el máximo y el mínimo del histograma de nivel de gris y dibuja una línea. El punto en el que esa línea se aleja al máximo del resto del histograma se elige como umbral:

Ambos asumen una imagen en escala de grises, por lo que necesitaremos convertir la imagen de entrada a gris a través de cv2.cvtColor():

img = cv2.imread(img_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

ret, mask1 = cv2.threshold(blurred, 0, 255, cv2.THRESH_OTSU)
ret, mask2 = cv2.threshold(blurred, 0, 255, cv2.THRESH_TRIANGLE)

masked = cv2.bitwise_and(img, img, mask=mask1)

Ejecutemos la imagen con ambos métodos y visualicemos los resultados:

methods = [cv2.THRESH_OTSU, cv2.THRESH_TRIANGLE]
names = ['Otsu Method', 'Triangle Method']

def thresh(img_path, method, index):
    img = cv2.imread(img_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (7, 7), 0)

    ret, img_masked = cv2.threshold(blurred, 0, 255, method)
    print(f"Threshold: {ret}")

    fig, ax = plt.subplots(1, 3, figsize=(12, 5))
    fig.suptitle(names[index], fontsize=18)
    ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    ax[1].imshow(cv2.cvtColor(gray, cv2.COLOR_BGR2RGB))
    ax[2].imshow(cv2.cvtColor(img_masked, cv2.COLOR_BGR2RGB))

for index, method in enumerate(methods):
    thresh('coins.jpeg', method, index)

Aquí, el método del triángulo supera al método de Otsu, porque la imagen no es bimodal:

import numpy as np

img = cv2.imread('coins.jpeg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

histogram_gray, bin_edges_gray = np.histogram(gray, bins=256, range=(0, 255))
histogram_blurred, bin_edges_blurred = np.histogram(blurred, bins=256, range=(0, 255))

fig, ax = plt.subplots(1, 2, figsize=(12, 4))

ax[0].plot(bin_edges_gray[0:-1], histogram_gray)
ax[1].plot(bin_edges_blurred[0:-1], histogram_blurred)

Sin embargo, está claro cómo el método del triángulo pudo trabajar con la imagen y producir un resultado más satisfactorio.

Limitaciones de la Umbral de OpenCV

La creación de umbrales con OpenCV es simple, fácil y eficiente. Sin embargo, es bastante limitado. Tan pronto como introduce elementos coloridos, fondos no uniformes y condiciones de iluminación cambiantes, el umbral global como concepto se vuelve demasiado rígido.

Las imágenes suelen ser demasiado complejas para que un solo umbral sea suficiente, y esto se puede abordar parcialmente a través de umbral adaptativo, donde se aplican muchos umbrales locales en lugar de uno único global. Aunque también es limitada, la umbralización adaptativa es mucho más flexible que la umbralización global.

Conclusión

En los últimos años, la segmentación binaria (como la que hicimos aquí) y la segmentación de etiquetas múltiples (donde puede codificar un número arbitrario de clases) se ha modelado con éxito con redes de aprendizaje profundo, que son mucho más potentes y flexibles. Además, pueden codificar contexto global y local en las imágenes que están segmentando. La desventaja es que necesita datos para capacitarlos, así como tiempo y experiencia.

Para un umbral simple y sobre la marcha, puede usar OpenCV. Para una segmentación precisa a nivel de producción, querrá usar redes neuronales.

Yendo más lejos: aprendizaje profundo práctico para la visión por computadora

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos revisar nuestro Curso: “Aprendizaje Profundo Práctico para Visión por Computador con Python”.

¿Otro curso de visión artificial?

No haremos clasificación de dígitos MNIST o moda MNIST. Cumplieron su parte hace mucho tiempo. Demasiados recursos de aprendizaje se centran en conjuntos de datos básicos y arquitecturas básicas antes de permitir que las arquitecturas avanzadas de caja negra carguen con la carga del rendimiento.

queremos centrarnos en desmitificación, sentido práctico, comprensión, intuición y proyectos reales. Querer aprender cómo ¿Tu puedes hacer la diferencia? Lo llevaremos en un viaje desde la forma en que nuestros cerebros procesan imágenes hasta escribir un clasificador de aprendizaje profundo de grado de investigación para el cáncer de mama y redes de aprendizaje profundo que "alucinan", enseñándole los principios y la teoría a través del trabajo práctico, equipándolo con el conocimientos y herramientas para convertirse en un experto en la aplicación del aprendizaje profundo para resolver la visión artificial.

¿Qué hay adentro?

• Los primeros principios de la visión y cómo se puede enseñar a las computadoras a “ver”
• Diferentes tareas y aplicaciones de la visión artificial
• Las herramientas del oficio que facilitarán tu trabajo
• Encontrar, crear y utilizar conjuntos de datos para la visión por computadora
• La teoría y aplicación de las Redes Neuronales Convolucionales
• Manejo de cambio de dominio, co-ocurrencia y otros sesgos en conjuntos de datos
• Transfiera el aprendizaje y utilice el tiempo de capacitación y los recursos computacionales de otros para su beneficio
• Construyendo y entrenando un clasificador de cáncer de mama de última generación
• Cómo aplicar una buena dosis de escepticismo a las ideas principales y comprender las implicaciones de las técnicas ampliamente adoptadas
• Visualización del "espacio conceptual" de ConvNet usando t-SNE y PCA
• Casos prácticos de cómo las empresas utilizan técnicas de visión artificial para lograr mejores resultados
• Evaluación adecuada del modelo, visualización del espacio latente e identificación de la atención del modelo.
• Realizar investigaciones de dominio, procesar sus propios conjuntos de datos y establecer pruebas modelo
• Arquitecturas de vanguardia, la progresión de las ideas, qué las hace únicas y cómo implementarlas
• KerasCV: una biblioteca WIP para crear canalizaciones y modelos de última generación
• Cómo analizar y leer documentos e implementarlos usted mismo
• Selección de modelos en función de su aplicación
• Creación de una canalización de aprendizaje automático de extremo a extremo
• Panorama e intuición sobre la detección de objetos con Faster R-CNN, RetinaNets, SSD y YOLO
• Instancia y segmentación semántica
• Reconocimiento de objetos en tiempo real con YOLOv5
• Capacitación de detectores de objetos YOLOv5
• Trabajando con Transformers usando KerasNLP (biblioteca WIP de fuerza industrial)
• Integrando Transformers con ConvNets para generar subtítulos de imágenes
• sueño profundo
• Optimización del modelo de Deep Learning para visión artificial