Categorías
Python

La guía definitiva para Clases de datos en Python 3.7

 

Tabla de Contenido Espacios

  • ¿Cuáles son color?
  • Segmentación simple uso de los espacios de color SpacesColor y lectura de imágenes en OpenCVVisualizing Nemo en color RGB SpaceVisualizing Nemo en VHS color SpacePicking a cabo una Espacios Rango
  • imágenes en color y la lectura en OpenCV
  • Visualización Nemo en RGB Espacio de color
  • Visualización Nemo en VHS en color espacio
  • la selección de un rango
  • Hace este Segmentación Generalizar a los parientes de Nemo?
  • Conclusión Espacios
  • imágenes en color y la lectura en OpenCV
  • Visualización Nemo en RGB Espacio de color
  • Visualización Nemo en VHS Espacio de color
  • la selección de un rango

Puede ser la época de aprendizaje profundo y grande de datos, donde los algoritmos complejos analizan imágenes por mostrándose millones de ellos, pero los espacios de color siguen siendo sorprendentemente útil para el análisis de imágenes. Los métodos simples todavía pueden ser de gran alcance.

En este artículo, usted aprenderá a simple segmento de un objeto de una imagen basada en el color en Python usando OpenCV. Una biblioteca popular de visión por ordenador escrito en C / C ++ con enlaces para Python, OpenCV ofrece maneras fáciles de manipular los espacios de color.

Mientras que usted no necesita estar familiarizado con OpenCV o los otros paquetes de ayuda utilizados en este artículo, se supone que usted tiene por lo menos un conocimiento básico de la codificación en Python. Bono

gratuito: Haga clic aquí para obtener el pitón de detección de la cara y OpenCV Ejemplos Mini-Guía que muestra ejemplos de códigos de prácticas de las técnicas de visión por ordenador Python en el mundo real. Espacios

¿Cuáles son color?

En el espacio de color más común, RGB (Red Green Blue), se representan los colores en función de su color rojo, verde y azul componentes. En términos más técnicos, RGB describe un color como una tupla de tres componentes. Cada componente puede tener un valor entre 0 y 255, donde la tupla (0, 0, 0) representa negro y (255, 255, 255) representa blanco.

RGB se considera un espacio de “aditivo” color , y los colores se puede imaginar como producidos de brillar cantidades de luz roja, azul y verde sobre un fondo negro.

Aquí hay algunos ejemplos más de los colores en RGB:

RGB es uno de los cinco grandes modelos de espacio de color, cada una de las cuales tiene muchas ramificaciones. Hay tantos espacios de color debido a los diferentes espacios de color son útiles para diferentes propósitos .

En el mundo de la impresión, CMYK es útil porque describe las combinaciones requeridas para producir un color en un fondo blanco. Mientras que el 0 tupla en RGB es negro, en CMYK el 0 tupla es de color blanco. Nuestras impresoras contienen una bolsa de tinta de cian, magenta, amarillo y negro.

En ciertos tipos de campos médicos, portaobjetos de vidrio montado con muestras de tejidos teñidos se escanean y se guardan como imágenes. Ellos pueden ser analizados en el espacio HED , una representación de las saturaciones de la mancha tipos-hematoxilina, eosina, y DAB-aplicadas al tejido original.

HSV y HSL son descripciones de tono, la saturación y el brillo / luminancia, que son particularmente útiles para la identificación de contraste de las imágenes. Estos espacios de color se utilizan con frecuencia en las herramientas de selección de color en software y para el diseño web.

En realidad, el color es un fenómeno continuo, lo que significa que hay un número infinito de colores. Espacios de color, sin embargo, representan color a través de estructuras discretas (un número fijo de número entero entero valores), que es aceptable ya que el ojo humano y la percepción también están limitados. Los espacios de color son totalmente capaces de representar todos los colores que son capaces de distinguir entre.

Ahora que entendemos el concepto de espacios de color, podemos pasar a utilizarlos en OpenCV.

Segmentación simple uso de espacios de color

para demostrar la técnica de segmentación de color el espacio, hemos proporcionado un pequeño conjunto de datos de imágenes de pez payaso en los materiales reales Python repository aquí para descargar y jugar. Pez payaso son fácilmente identificables por su color naranja brillante, por lo que son un candidato bueno para la segmentación. Vamos a ver lo bien que podemos encontrar a Nemo en una imagen.

Los paquetes de Python clave que necesita para seguir adelante son NumPy, el paquete más importante para la computación científica en Python, Matplotlib, una biblioteca de trazado y de OpenCV supuesto. En este artículo se utiliza OpenCV 3.2.0, 1.12.1 NumPy y Matplotlib 2.0.2. Ligeramente diferentes versiones no hará una diferencia significativa en términos de seguir adelante y agarrar los conceptos.

Si no está familiarizado con NumPy o Matplotlib, se puede leer acerca de ellos en la guía oficial NumPy y el excelente artículo de Brad Solomon en Matplotlib. Espacios

imágenes en color y la lectura en OpenCV

En primer lugar, tendrá que configurar el entorno. En este artículo se supone que tiene Python 3.x instalado en su sistema. Tenga en cuenta que mientras que la versión actual de OpenCV es 3.x, el nombre del paquete de importación sigue siendo cv2:

>>> import cv2

Si no ha instalado previamente OpenCV en su ordenador, la importación fallará hasta que lo haga eso primero. Se puede encontrar un tutorial fácil de usar para la instalación en diferentes sistemas operativos aquí, así como la propia guía de instalación de OpenCV. Una vez que haya importado con éxito OpenCV, se puede ver en todas las conversiones de espacio de color del OpenCV proporciona y se puede ahorrar a todos en una variable:

>>> flags = [i for i in dir(cv2) if i.startswith('COLOR_')]

La lista y el número de banderas pueden variar ligeramente dependiendo de la versión de OpenCV, pero en cualquier caso, habrá un montón! Ver cuántas banderas que tiene disponible:

>>> len(flags)
258
>>> flags[40]
'COLOR_BGR2RGB'

Los primeros caracteres después color_ indican el espacio de color de origen, y los caracteres después del 2 son el espacio de color de destino. Esta bandera representa una conversión de BGR (azul, verde, rojo) a RGB. Como se puede ver, los dos espacios de color son muy similares, con sólo el primer y último canales intercambiados.

Tendrá matplotlib.pyplot para la visualización de las imágenes y NumPy por alguna manipulación de imágenes. Si usted no tiene ya instalados Matplotlib o NumPy, tendrá que PIP3 Instalar matplotlib y PIP3 instalan numpy antes de intentar las importaciones:

>>> import matplotlib.pyplot as plt
>>> import numpy as np

Ahora ya está listo para cargar y examinar una imagen. Tenga en cuenta que si está trabajando desde la línea de comandos o terminal, las imágenes aparecerán en una ventana emergente. Si está trabajando en un cuaderno Jupyter o algo similar, simplemente se muestran a continuación. Independientemente de su configuración, debería ver la imagen generada por el programa () comando:

>>> nemo = cv2.imread('./images
emo0.jpg')
>>> plt.imshow(nemo)
>>> plt.show()

Hey, Nemo … o Dory? Se dará cuenta de que parece que los canales azul y rojo se han mezclado. De hecho, OpenCV por defecto lee imágenes en formato BGR. Puede utilizar el cvtColor (imagen, bandera) y la bandera miramos por encima de solucionar este problema:

>>> nemo = cv2.cvtColor(nemo, cv2.COLOR_BGR2RGB)
>>> plt.imshow(nemo)
>>> plt.show()

Ahora Nemo parece mucho más a sí mismo.

Visualización Nemo en RGB Espacio de color

HSV es una buena elección del espacio de color para la segmentación por color, pero a ver por qué, vamos a comparar la imagen en ambos espacios de color RGB y HSV mediante la visualización de la distribución del color de sus píxeles. la trama muestra un 3D Esta bastante bien, con cada eje que representa uno de los canales en el espacio de color. Si quieres saber cómo hacer un gráfico 3D, ver la sección colapsada:

Cómo hacer un color 3D Gráfico de dispersión Mostrar / Ocultar

Para hacer la trama, se necesita un poco más de las bibliotecas matplotlib:

>>> from mpl_toolkits.mplot3d import Axes3D
>>> from matplotlib import cm
>>> from matplotlib import colors

Aquellos bibliotecas proporcionan las funcionalidades necesarias para la trama. Que desea colocar cada píxel en su lugar sobre la base de sus componentes y colorearlo por su color. OpenCV split () es muy útil aquí; se divide una imagen en sus canales de componentes. Estas pocas líneas de código dividir la imagen y determinar la trama 3D:

>>> r, g, b = cv2.split(nemo)
>>> fig = plt.figure()
>>> axis = fig.add_subplot(1, 1, 1, projection="3d")

Ahora que ha creado la trama, es necesario configurar los colores de los píxeles. Con el fin de dar color a cada píxel en función de su color verdadero, hay un poco de remodelación y se requiere la normalización. Parece complicado, pero en esencia lo que necesitan los colores correspondientes a cada píxel de la imagen para ser aplastado en una lista y normalizado, de modo que puedan ser pasadas al parámetro facecolors de Matplotlib de dispersión ().

normalización sólo significa condensar la gama de colores 0-255 a 0-1 como se requiere para el parámetro facecolors. Por último, facecolors quiere una lista, no una matriz NumPy:

>>> pixel_colors = nemo.reshape((np.shape(nemo)[0]*np.shape(nemo)[1], 3))
>>> norm = colors.Normalize(vmin=-1.,vmax=1.)
>>> norm.autoscale(pixel_colors)
>>> pixel_colors = norm(pixel_colors).tolist()

Ahora tenemos todos los componentes listo para el trazado: las posiciones de pixel para cada eje y sus colores correspondientes, en los facecolors formato Espera. Se puede construir el gráfico de dispersión y verlo:

>>> axis.scatter(r.flatten(), g.flatten(), b.flatten(), facecolors=pixel_colors, marker=".")
>>> axis.set_xlabel("Red")
>>> axis.set_ylabel("Green")
>>> axis.set_zlabel("Blue")
>>> plt.show()

Aquí está el gráfico de dispersión de color para la imagen Nemo en RGB:

partir de este gráfico, se puede ver que las piezas de color naranja de la duración de la imagen a través de casi toda la gama de valores de rojo, verde y azul. Desde partes de Nemo se extienden sobre toda la trama, la segmentación de Nemo en el espacio RGB basado en rangos de valores RGB no sería fácil.

Visualización Nemo en el espacio de color HSV

Vimos Nemo en el espacio RGB, por lo que ahora vamos a lo ven en el espacio HSV y comparar.

Como se ha mencionado brevemente más arriba, HSV significa tonalidad, saturación y valor (o brillo) , y es un espacio de color cilíndrica. Los colores o tonos, se modelan como una dimensión angular de rotación alrededor de un eje central, vertical, que representa el canal de valor. Los valores van de oscuro (0 en la parte inferior) a la luz en la parte superior. El tercer eje, saturación, define los tonos de color de menos saturado, en el eje vertical, a más saturados que está más lejos del centro:

Para convertir una imagen de RGB a HSV, puede utilizar cvtColor ():

>>> hsv_nemo = cv2.cvtColor(nemo, cv2.COLOR_RGB2HSV)
Ahora

hsv_nemo almacena la representación de Nemo en el VHS. Utilizando la misma técnica que la anterior, podemos ver un gráfico de la imagen en VHS, generada por la sección colapsada a continuación:

la generación de la parcela color 3D de dispersión para la Imagen en VHS Mostrar / Ocultar

El código para mostrar la imagen en HSV es la misma que para RGB. Tenga en cuenta que utilizar la variable mismos pixel_colors para la coloración de los píxeles, ya que Matplotlib espera que los valores para estar en RGB: Espacio

>>> h, s, v = cv2.split(hsv_nemo)
>>> fig = plt.figure()
>>> axis = fig.add_subplot(1, 1, 1, projection="3d")

>>> axis.scatter(h.flatten(), s.flatten(), v.flatten(), facecolors=pixel_colors, marker=".")
>>> axis.set_xlabel("Hue")
>>> axis.set_ylabel("Saturation")
>>> axis.set_zlabel("Value")
>>> plt.show()

En el VHS, las naranjas de Nemo son mucho más localizado y visualmente separables. La saturación y el valor de las naranjas varían, pero se encuentran principalmente dentro de un pequeño intervalo a lo largo del eje de la tonalidad. Este es el punto clave que se puede aprovechar para la segmentación.

que selecciona un rango umbral

Vamos a Nemo sólo se basa en un simple gama de naranjas. Se puede elegir la gama de calcular visualmente la trama anterior o utilizando una aplicación de picking de color en línea como esta herramienta RGB a HSV. Las muestras elegidas aquí son de color naranja claro y un color naranja oscuro que es casi rojo:

>>> light_orange = (1, 190, 200)
>>> dark_orange = (18, 255, 255)

Si desea utilizar Python para mostrar los colores que ha elegido, haga clic en la sección colapsada:

que exhiben los colores HSV Elegido Mostrar / Ocultar

Una forma sencilla de mostrar los colores en Python es hacer pequeñas imágenes cuadradas del color deseado y trazarlos en Matplotlib. Matplotlib solamente interpreta en colores RGB, pero se proporcionan funciones de conversión práctica de los principales espacios de color para que podamos trazar imágenes en otros espacios de color:

>>> from matplotlib.colors import hsv_to_rgb

Entonces, construir los pequeños cuadrados 10x10x3, llenos del color respectivo. Puede utilizar NumPy para llenar fácilmente las plazas con el color:

>>> lo_square = np.full((10, 10, 3), light_orange, dtype=np.uint8) / 255.0
>>> do_square = np.full((10, 10, 3), dark_orange, dtype=np.uint8) / 255.0

Por último, puede trazar juntos mediante la conversión a RGB para la visualización:

>>> plt.subplot(1, 2, 1)
>>> plt.imshow(hsv_to_rgb(do_square))
>>> plt.subplot(1, 2, 2)
>>> plt.imshow(hsv_to_rgb(lo_square))
>>> plt.show()

que produce estas imágenes, lleno de los colores elegidos:

una vez que se obtiene una gama de colores decente, puede utilizar cv2.inRange () para tratar de umbral de Nemo. inRange () toma tres parámetros: la imagen, el rango inferior, y el rango más alto . Devuelve una máscara binaria (un ndarray de 1s y 0s) el tamaño de la imagen en la que los valores de 1 indican los valores dentro del rango, y los valores de cero indican valores fuera:

>>> mask = cv2.inRange(hsv_nemo, light_orange, dark_orange)

imponer la máscara en la parte superior de la imagen original, puede utilizar cv2.bitwise_and (), que mantiene cada píxel de la imagen dada si el valor correspondiente en la máscara es de 1:

>>> result = cv2.bitwise_and(nemo, nemo, mask=mask)

Para ver lo que hizo exactamente, vamos a ver tanto la máscara como la imagen original con la máscara en la parte superior :

>>> plt.subplot(1, 2, 1)
>>> plt.imshow(mask, cmap="gray")
>>> plt.subplot(1, 2, 2)
>>> plt.imshow(result)
>>> plt.show()

Ahí lo tienen! Esto ya se ha hecho un trabajo decente de la captura de las piezas de color naranja de los peces. El único problema es que Nemo también tiene rayas blancas … Afortunadamente, la adición de una segunda máscara que las apariencias para los blancos es muy similar a lo que ya se hizo con las naranjas:

>>> light_white = (0, 0, 200)
>>> dark_white = (145, 60, 255)

Una vez que haya especificado una gama de colores, se puede ver en la colores que han elegido:

Viendo los blancos Mostrar / Ocultar

Para mostrar los blancos, se puede tomar el mismo enfoque que hemos hecho anteriormente con las naranjas:

>>> lw_square = np.full((10, 10, 3), light_white, dtype=np.uint8) / 255.0
>>> dw_square = np.full((10, 10, 3), dark_white, dtype=np.uint8) / 255.0

>>> plt.subplot(1, 2, 1)
>>> plt.imshow(hsv_to_rgb(lw_square))
>>> plt.subplot(1, 2, 2)
>>> plt.imshow(hsv_to_rgb(dw_square))
>>> plt.show()

la parte superior cubre la que he elegido aquí es un muy azul blanco, debido a que el blanco tiene matices de azul en las sombras. Vamos a crear una segunda máscara y ver si captura rayas de Nemo. Se puede construir una segunda máscara de la misma manera como lo hizo la primera: mala

>>> mask_white = cv2.inRange(hsv_nemo, light_white, dark_white)
>>> result_white = cv2.bitwise_and(nemo, nemo, mask=mask_white)

>>> plt.subplot(1, 2, 1)
>>> plt.imshow(mask_white, cmap="gray")
>>> plt.subplot(1, 2, 2)
>>> plt.imshow(result_white)
>>> plt.show()

No! Ahora puede combinar las máscaras. La adición de las dos máscaras en conjunto se traduce en valores de 1 Dondequiera que haya o ange o blanco, que es exactamente lo que se necesita. Vamos a añadir las máscaras juntos y trazar los resultados:

>>> final_mask = mask + mask_white

>>> final_result = cv2.bitwise_and(nemo, nemo, mask=final_mask)
>>> plt.subplot(1, 2, 1)
>>> plt.imshow(final_mask, cmap="gray")
>>> plt.subplot(1, 2, 2)
>>> plt.imshow(final_result)
>>> plt.show()

Esencialmente, usted tiene una segmentación aproximada de Nemo en el espacio de color HSV. Se dará cuenta de que hay algunas píxeles dispersos a lo largo de la frontera de segmentación, y si se quiere, se puede utilizar un desenfoque gaussiano para poner en orden las pequeñas detecciones falsas.

un desenfoque gaussiano es un filtro de imagen que utiliza un tipo de función de llamada de Gauss para transformar cada píxel de la imagen. Tiene como consecuencia de suavizar el ruido de la imagen y la reducción de detalle. Esto es lo que la aplicación de las miradas como la falta de definición de nuestra imagen:

>>> blur = cv2.GaussianBlur(final_result, (7, 7), 0)
>>> plt.imshow(blur)
>>> plt.show()

Hace este Segmentación Generalizar a los parientes de Nemo?

Sólo por diversión, vamos a ver qué tan bien º i s segmentat i en tecn i Que en general i ZES a otra clownf i sh i magos . En los repositorios i toria, hay un selecto i en de s i x i magos de clownf i sh de Google, l i censada para publ i c uso. El i magos son i na subd i rectoría y i ndexed nemo i .jpg, donde i i s la i ndice de 0-5.

En primer lugar, cargar todos los parientes de Nemo en una lista:

path = "./images
emo"

nemos_friends = []
for i in range(6):
friend = cv2.cvtColor(cv2.imread(path + str(i) + ".jpg"), cv2.COLOR_BGR2RGB)
nemos_friends.append(friend)

Se pueden combinar todos los códigos utilizados anteriormente para segmentar un solo pez en una función que tendrá una imagen como entrada y devolver la imagen segmentada. Ampliar esta sección para ver que es lo que parece:

El pescado Segmento función Mostrar / Ocultar

Aquí está la función segment_fish ():

def segment_fish(image):
''' Attempts to segment the clownfish out of the provided image '''

# Convert the image into HSV
hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)

# Set the orange range
light_orange = (1, 190, 200)
dark_orange = (18, 255, 255)

# Apply the orange mask
mask = cv2.inRange(hsv_image, light_orange, dark_orange)

# Set a white range
light_white = (0, 0, 200)
dark_white = (145, 60, 255)

# Apply the white mask
mask_white = cv2.inRange(hsv_image, light_white, dark_white)

# Combine the two masks
final_mask = mask + mask_white
result = cv2.bitwise_and(image, image, mask=final_mask)

# Clean up the segmentation using a blur
blur = cv2.GaussianBlur(result, (7, 7), 0)
return blur

Con esa función útil, a continuación, puede segmento de todos los peces: Vista de

results = [segment_fish(friend) for friend in nemos_friends]

Let todos los resultados por trazarlos en un bucle:

for i in range(1, 6):
plt.subplot(1, 2, 1)
plt.imshow(nemos_friends[i])
plt.subplot(1, 2, 2)
plt.imshow(results[i])
plt.show()

emo_friend_2.c97bd4642274.png»>

La sombra mitad inferior del sobrino de Nemo está completamente excluida, pero los bits de la anémona púrpura en el fondo de la mirada terriblemente como rayas de Nemo azules teñidas …

emo_friend_4.3da61ed16efa.png»>

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *