Primeros pasos con Python OpenCV

Computer Vision es una de las técnicas a partir de las cuales podemos entender imágenes y vídeos y podemos extraer información de ellos. Es un subconjunto de la inteligencia artificial que recopila información de imágenes o videos digitales. 

Python OpenCV es la biblioteca de visión artificial más popular. Al usarlo, uno puede procesar imágenes y videos para identificar objetos, rostros o incluso la escritura a mano de un ser humano. Cuando se integra con varias bibliotecas, como NumPy, Python es capaz de procesar la estructura de array de OpenCV para su análisis.

En este artículo, discutiremos Python OpenCV en detalle junto con algunas operaciones comunes como cambiar el tamaño, recortar, leer, guardar imágenes, etc. con la ayuda de buenos ejemplos.

Instalación

Para instalar OpenCV, uno debe tener Python y PIP preinstalados en su sistema. Si Python no está presente, consulte ¿Cómo instalar Python en Linux? y siga las instrucciones proporcionadas. Si PIP no está presente, consulte ¿Cómo instalar PIP en Linux? y siga las instrucciones proporcionadas.

Después de instalar Python y PIP, escriba el siguiente comando en la terminal.

pip3 install opencv-python

Imágenes de lectura

Para leer las imágenes se utiliza el método cv2.imread() . Este método carga una imagen del archivo especificado. Si la imagen no se puede leer (debido a la falta del archivo, permisos incorrectos, formato no compatible o no válido), este método devuelve una array vacía.

Imagen utilizada:

Ejemplo: Python OpenCV Leer imagen

# Python code to read image
import cv2
 
# To read image from disk, we use
# cv2.imread function, in below method,
img = cv2.imread("geeks.png", cv2.IMREAD_COLOR)
 
print(img)

Producción:

[[[ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]
  ...
  [ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]]

 [[ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]
  ...
  [ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]]

 [[ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]
  ...
  [ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]]

 ...

 [[ 72 133   9]
  [ 72 133   9]
  [ 72 133   9]
  ...
  [ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]]

 [[ 72 133   9]
  [ 72 133   9]
  [ 72 133   9]
  ...
  [ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]]

 [[ 72 133   9]
  [ 72 133   9]
  [ 72 133   9]
  ...
  [ 87 157  14]
  [ 87 157  14]
  [ 87 157  14]]]

Visualización de imágenes

El método cv2.imshow() se usa para mostrar una imagen en una ventana. La ventana se ajusta automáticamente al tamaño de la imagen.

Ejemplo: Imágenes de visualización de Python OpenCV

# Python code to read image
import cv2
 
# To read image from disk, we use
# cv2.imread function, in below method,
img = cv2.imread("geeks.png", cv2.IMREAD_COLOR)
 
# Creating GUI window to display an image on screen
# first Parameter is windows title (should be in string format)
# Second Parameter is image array
cv2.imshow("GeeksforGeeks", img)
 
# To hold the window on screen, we use cv2.waitKey method
# Once it detected the close input, it will release the control
# To the next line
# First Parameter is for holding screen for specified milliseconds
# It should be positive integer. If 0 pass an parameter, then it will
# hold the screen until user close it.
cv2.waitKey(0)
 
# It is for removing/deleting created GUI window from screen
# and memory
cv2.destroyAllWindows()

Producción:

Guardar imágenes

El método cv2.imwrite() se utiliza para guardar una imagen en cualquier dispositivo de almacenamiento. Esto guardará la imagen según el formato especificado en el directorio de trabajo actual.

Ejemplo: Python OpenCV Guardar imágenes

# Python program to explain cv2.imwrite() method
 
# importing cv2
import cv2
 
image_path = 'geeks.png'
 
# Using cv2.imread() method
# to read the image
img = cv2.imread(image_path)
 
# Filename
filename = 'savedImage.jpg'
 
# Using cv2.imwrite() method
# Saving the image
cv2.imwrite(filename, img)
 
# Reading and showing the saved image
img = cv2.imread(filename)
cv2.imshow("GeeksforGeeks", img)
 
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Imágenes giratorias

El método cv2.rotate() se usa para rotar una array 2D en múltiplos de 90 grados. La función cv::rotate rota la array de tres maneras diferentes.

Ejemplo: Python OpenCV Rotar imagen

# Python program to explain cv2.rotate() method
 
# importing cv2
import cv2
 
# path
path = 'geeks.png'
 
# Reading an image in default mode
src = cv2.imread(path)
 
# Window name in which image is displayed
window_name = 'Image'
 
# Using cv2.rotate() method
# Using cv2.ROTATE_90_CLOCKWISE rotate
# by 90 degrees clockwise
image = cv2.rotate(src, cv2.cv2.ROTATE_90_CLOCKWISE)
 
# Displaying the image
cv2.imshow(window_name, image)
cv2.waitKey(0)

Producción:

Las funciones anteriores nos restringen a rotar la imagen en el múltiplo de 90 grados solamente. También podemos rotar la imagen en cualquier ángulo definiendo la array de rotación que enumera el punto de rotación, el grado de rotación y el factor de escala.

Ejemplo: Python OpenCV Rotar imagen por cualquier ángulo

import cv2
import numpy as np
 
FILE_NAME = 'geeks.png'
 
# Read image from the disk.
img = cv2.imread(FILE_NAME)
 
# Shape of image in terms of pixels.
(rows, cols) = img.shape[:2]
 
# getRotationMatrix2D creates a matrix needed
# for transformation. We want matrix for rotation
# w.r.t center to 45 degree without scaling.
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), 45, 1)
res = cv2.warpAffine(img, M, (cols, rows))
 
cv2.imshow("GeeksforGeeks", res)
 
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Cambiar el tamaño de la imagen

El cambio de tamaño de la imagen se refiere a la escala de las imágenes. Ayuda a reducir la cantidad de píxeles de una imagen y eso tiene varias ventajas, por ejemplo, puede reducir el tiempo de entrenamiento de una red neuronal cuanto mayor es la cantidad de píxeles en una imagen, mayor es la cantidad de Nodes de entrada que a su vez aumenta la complejidad del modelo. También ayuda a hacer zoom en las imágenes. Muchas veces necesitamos cambiar el tamaño de la imagen, es decir, reducirla o ampliarla para cumplir con los requisitos de tamaño.

OpenCV nos proporciona varios métodos de interpolación para cambiar el tamaño de una imagen. Elección del método de interpolación para cambiar el tamaño:

• cv2.INTER_AREA: Esto se usa cuando necesitamos reducir una imagen.
• cv2.INTER_CUBIC: Esto es lento pero más eficiente.
• cv2.INTER_LINEAR: Esto se usa principalmente cuando se requiere hacer zoom. Esta es la técnica de interpolación predeterminada en OpenCV.

Ejemplo: cambio de tamaño de imagen de Python OpenCV

import cv2
import numpy as np
import matplotlib.pyplot as plt
 
image = cv2.imread("geeks.png", 1)
# Loading the image
 
half = cv2.resize(image, (0, 0), fx = 0.1, fy = 0.1)
bigger = cv2.resize(image, (1050, 1610))
 
stretch_near = cv2.resize(image, (780, 540),
            interpolation = cv2.INTER_NEAREST)
 
 
Titles =["Original", "Half", "Bigger", "Interpolation Nearest"]
images =[image, half, bigger, stretch_near]
count = 4
 
for i in range(count):
    plt.subplot(2, 3, i + 1)
    plt.title(Titles[i])
    plt.imshow(images[i])
 
plt.show()

Producción:

Espacios de color

Los espacios de color son una forma de representar los canales de color presentes en la imagen que le dan a la imagen ese tono particular. Hay varios espacios de color diferentes y cada uno tiene su propio significado. Algunos de los espacios de color populares son RGB (rojo, verde, azul), CMYK (cian, magenta, amarillo, negro), HSV (tono, saturación, valor), etc.

 El método cv2.cvtColor() se usa para convertir una imagen de un espacio de color a otro. Hay más de 150 métodos de conversión de espacio de color disponibles en OpenCV.

Ejemplo: espacios de color Python OpenCV

# Python program to explain cv2.cvtColor() method
 
# importing cv2
import cv2
 
# path
path = 'geeks.png'
 
# Reading an image in default mode
src = cv2.imread(path)
 
# Window name in which image is displayed
window_name = 'GeeksforGeeks'
 
# Using cv2.cvtColor() method
# Using cv2.COLOR_BGR2GRAY color space
# conversion code
image = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY )
 
# Displaying the image
cv2.imshow(window_name, image)
 
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Operaciones aritmeticas

Las operaciones aritméticas como la suma, la resta y las operaciones bit a bit (Y, O, NO, XOR) se pueden aplicar a las imágenes de entrada. Estas operaciones pueden resultar útiles para mejorar las propiedades de las imágenes de entrada. La aritmética de imágenes es importante para analizar las propiedades de la imagen de entrada. Las imágenes operadas se pueden utilizar además como una imagen de entrada mejorada, y se pueden aplicar muchas más operaciones para aclarar, umbralizar, dilatar, etc. de la imagen.

Adición de imagen:

Podemos agregar dos imágenes usando la función cv2.add(). Esto suma directamente píxeles de imagen en las dos imágenes. Pero agregar los píxeles no es una situación ideal. Entonces, usamos cv2.addweighted(). Recuerde, ambas imágenes deben tener el mismo tamaño y profundidad.

Imagen de entrada 1:

Imagen de entrada2:

# Python program to illustrate
# arithmetic operation of
# addition of two images
     
# organizing imports
import cv2
import numpy as np
     
# path to input images are specified and
# images are loaded with imread command
image1 = cv2.imread('star.jpg')
image2 = cv2.imread('dot.jpg')
 
# cv2.addWeighted is applied over the
# image inputs with applied parameters
weightedSum = cv2.addWeighted(image1, 0.5, image2, 0.4, 0)
 
# the window showing output image
# with the weighted sum
cv2.imshow('Weighted Image', weightedSum)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Resta de Imagen:

Además, podemos restar los valores de píxeles en dos imágenes y fusionarlos con la ayuda de cv2.subtract(). Las imágenes deben ser del mismo tamaño y profundidad.

# Python program to illustrate
# arithmetic operation of
# subtraction of pixels of two images
 
# organizing imports
import cv2
import numpy as np
     
# path to input images are specified and
# images are loaded with imread command
image1 = cv2.imread('star.jpg')
image2 = cv2.imread('dot.jpg')
 
# cv2.subtract is applied over the
# image inputs with applied parameters
sub = cv2.subtract(image1, image2)
 
# the window showing output image
# with the subtracted image
cv2.imshow('Subtracted Image', sub)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Operaciones bit a bit en imagen binaria

Las operaciones bit a bit se utilizan en la manipulación de imágenes y se utilizan para extraer partes esenciales de la imagen. Las operaciones bit a bit utilizadas son:

• Y
• O
• XOR
• NO

Operación AND bit a bit

Conjunción bit a bit de elementos de array de entrada. 

Imagen de entrada 1:

Imagen de entrada 2: 

# Python program to illustrate
# arithmetic operation of
# bitwise AND of two images
     
# organizing imports
import cv2
import numpy as np
     
# path to input images are specified and
# images are loaded with imread command
img1 = cv2.imread('input1.png')
img2 = cv2.imread('input2.png')
 
# cv2.bitwise_and is applied over the
# image inputs with applied parameters
dest_and = cv2.bitwise_and(img2, img1, mask = None)
 
# the window showing output image
# with the Bitwise AND operation
# on the input images
cv2.imshow('Bitwise And', dest_and)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Operación OR bit a bit

Disyunción bit a bit de elementos de array de entrada. 

# Python program to illustrate
# arithmetic operation of
# bitwise OR of two images
     
# organizing imports
import cv2
import numpy as np
     
# path to input images are specified and
# images are loaded with imread command
img1 = cv2.imread('input1.png')
img2 = cv2.imread('input2.png')
 
# cv2.bitwise_or is applied over the
# image inputs with applied parameters
dest_or = cv2.bitwise_or(img2, img1, mask = None)
 
# the window showing output image
# with the Bitwise OR operation
# on the input images
cv2.imshow('Bitwise OR', dest_or)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Operación XOR bit a bit

Operación OR exclusiva bit a bit en elementos de array de entrada. 

# Python program to illustrate
# arithmetic operation of
# bitwise XOR of two images
     
# organizing imports
import cv2
import numpy as np
     
# path to input images are specified and
# images are loaded with imread command
img1 = cv2.imread('input1.png')
img2 = cv2.imread('input2.png')
 
# cv2.bitwise_xor is applied over the
# image inputs with applied parameters
dest_xor = cv2.bitwise_xor(img1, img2, mask = None)
 
# the window showing output image
# with the Bitwise XOR operation
# on the input images
cv2.imshow('Bitwise XOR', dest_xor)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Operación NOT bit a bit

Inversión de elementos de array de entrada. 

# Python program to illustrate
# arithmetic operation of
# bitwise NOT on input image
     
# organizing imports
import cv2
import numpy as np
     
# path to input images are specified and
# images are loaded with imread command
img1 = cv2.imread('input1.png')
img2 = cv2.imread('input2.png')
 
# cv2.bitwise_not is applied over the
# image input with applied parameters
dest_not1 = cv2.bitwise_not(img1, mask = None)
dest_not2 = cv2.bitwise_not(img2, mask = None)
 
# the windows showing output image
# with the Bitwise NOT operation
# on the 1st and 2nd input image
cv2.imshow('Bitwise NOT on image 1', dest_not1)
cv2.imshow('Bitwise NOT on image 2', dest_not2)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Bitwise NO en la imagen 1 

Bitwise NO en la imagen 2 

Traducción de imágenes

La traducción se refiere al desplazamiento rectilíneo de un objeto, es decir, una imagen de un lugar a otro. Si conocemos la cantidad de cambio en la dirección horizontal y vertical, digamos (tx, ty), entonces podemos hacer una array de transformación. Ahora, podemos usar la función cv2.wrapAffine() para implementar las traducciones. Esta función requiere una array de 2×3. La array numpy debe ser de tipo flotante.

Ejemplo: Python OpenCV Image Translation

import cv2
import numpy as np
 
image = cv2.imread('geeks.png')
 
# Store height and width of the image
height, width = image.shape[:2]
 
quarter_height, quarter_width = height / 4, width / 4
 
T = np.float32([[1, 0, quarter_width], [0, 1, quarter_height]])
 
# We use warpAffine to transform
# the image using the matrix, T
img_translation = cv2.warpAffine(image, T, (width, height))
 
cv2.imshow('Translation', img_translation)
cv2.waitKey(0)
 
cv2.destroyAllWindows()

Producción:

Detección de bordes

El proceso de detección de imágenes implica la detección de bordes afilados en la imagen. Esta detección de bordes es esencial en el contexto del reconocimiento de imágenes o la localización/detección de objetos. Existen varios algoritmos para la detección de bordes debido a su amplia aplicabilidad. Usaremos uno de esos algoritmos conocido como Canny Edge Detection . 

Ejemplo: Python OpenCV Canny Edge Detección

import cv2
 
FILE_NAME = 'geeks.png'
 
# Read image from disk.
img = cv2.imread(FILE_NAME)
 
# Canny edge detection.
edges = cv2.Canny(img, 100, 200)
 
# Write image back to disk.
cv2.imshow('Edges', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Umbral simple

La umbralización es una técnica en OpenCV, que es la asignación de valores de píxel en relación con el valor de umbral proporcionado. En la determinación de umbrales, cada valor de píxel se compara con el valor de umbral. Si el valor del píxel es menor que el umbral, se establece en 0; de lo contrario, se establece en un valor máximo (generalmente 255). La umbralización es una técnica de segmentación muy popular, utilizada para separar un objeto considerado como primer plano de su fondo. Un umbral es un valor que tiene dos regiones a cada lado, es decir, por debajo del umbral o por encima del umbral.

En Computer Vision, esta técnica de umbralización se realiza en imágenes en escala de grises. Entonces, inicialmente, la imagen debe convertirse en un espacio de color en escala de grises.

If f (x, y) < T
  then f (x, y) = 0
else
  f (x, y) = 255

where
f (x, y) = Coordinate Pixel Value
T = Threshold Value.

En OpenCV con Python, la función cv2.threshold se usa para el umbral.

La técnica básica de Umbralización es la Umbralización Binaria. Para cada píxel, se aplica el mismo valor de umbral. Si el valor del píxel es menor que el umbral, se establece en 0; de lo contrario, se establece en un valor máximo. Las diferentes Técnicas Simples de Umbralización son:

• cv2.THRESH_BINARY: si la intensidad de píxeles es mayor que el umbral establecido, el valor se establece en 255; de lo contrario, se establece en 0 (negro).
• cv2.THRESH_BINARY_INV: Caso invertido o opuesto de cv2.THRESH_BINARY.
• cv.THRESH_TRUNC: si el valor de intensidad de píxel es mayor que el umbral, se trunca al umbral. Los valores de píxel se establecen para que sean los mismos que el umbral. Todos los demás valores siguen siendo los mismos.
• cv.THRESH_TOZERO: la intensidad de píxeles se establece en 0, para todas las intensidades de píxeles, menos que el valor de umbral.
• cv.THRESH_TOZERO_INV: Caso invertido o opuesto de cv2.THRESH_TOZERO.

Ejemplo: Umbral simple de Python OpenCV

# Python program to illustrate
# simple thresholding type on an image
 
# organizing imports
import cv2
import numpy as np
 
# path to input image is specified and
# image is loaded with imread command
image1 = cv2.imread('geeks.png')
 
# cv2.cvtColor is applied over the
# image input with applied parameters
# to convert the image in grayscale
img = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
 
# applying different thresholding
# techniques on the input image
# all pixels value above 120 will
# be set to 255
ret, thresh1 = cv2.threshold(img, 120, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img, 120, 255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img, 120, 255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img, 120, 255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img, 120, 255, cv2.THRESH_TOZERO_INV)
 
# the window showing output images
# with the corresponding thresholding
# techniques applied to the input images
cv2.imshow('Binary Threshold', thresh1)
cv2.imshow('Binary Threshold Inverted', thresh2)
cv2.imshow('Truncated Threshold', thresh3)
cv2.imshow('Set to 0', thresh4)
cv2.imshow('Set to 0 Inverted', thresh5)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Umbral adaptativo

El umbral adaptativo es el método en el que el valor del umbral se calcula para regiones más pequeñas. Esto conduce a diferentes valores de umbral para diferentes regiones con respecto al cambio de iluminación. Usamos cv2.adaptiveThreshold para esto.

Ejemplo: Umbral adaptable de Python OpenCV

# Python program to illustrate
# adaptive thresholding type on an image
 
# organizing imports
import cv2
import numpy as np
 
# path to input image is specified and
# image is loaded with imread command
image1 = cv2.imread('geeks.png')
 
# cv2.cvtColor is applied over the
# image input with applied parameters
# to convert the image in grayscale
img = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
 
# applying different thresholding
# techniques on the input image
thresh1 = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
                                cv2.THRESH_BINARY, 199, 5)
 
thresh2 = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                cv2.THRESH_BINARY, 199, 5)
 
# the window showing output images
# with the corresponding thresholding
# techniques applied to the input image
cv2.imshow('Adaptive Mean', thresh1)
cv2.imshow('Adaptive Gaussian', thresh2)
 
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

Umbral de Otsu

En Otsu Thresholding , no se elige un valor de umbral, sino que se determina automáticamente. Se considera una imagen bimodal (dos valores de imagen distintos). El histograma generado contiene dos picos. Por lo tanto, una condición genérica sería elegir un valor de umbral que se encuentre en el medio de los dos valores máximos del histograma. Usamos la función tradicional cv2.threshold y usamos cv2.THRESH_OTSU como un indicador adicional.

Ejemplo: Python OpenCV Otsu Umbral

# Python program to illustrate
# Otsu thresholding type on an image
 
# organizing imports
import cv2
import numpy as np
 
# path to input image is specified and
# image is loaded with imread command
image1 = cv2.imread('geeks.png')
 
# cv2.cvtColor is applied over the
# image input with applied parameters
# to convert the image in grayscale
img = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
 
# applying Otsu thresholding
# as an extra flag in binary
# thresholding
ret, thresh1 = cv2.threshold(img, 120, 255, cv2.THRESH_BINARY +
                             cv2.THRESH_OTSU)
 
# the window showing output image
# with the corresponding thresholding
# techniques applied to the input image
cv2.imshow('Otsu Threshold', thresh1)
 
# De-allocate any associated memory usage
if cv2.waitKey(0) & 0xff == 27:
    cv2.destroyAllWindows()

Producción:

desenfoque de imagen

Imagen borrosa se refiere a hacer que la imagen sea menos clara o distinta. Se realiza con la ayuda de varios núcleos de filtro de paso bajo. Tipos importantes de desenfoque:

• Desenfoque gaussiano : el desenfoque gaussiano es el resultado de desenfocar una imagen mediante una función gaussiana. Es un efecto ampliamente utilizado en el software de gráficos, normalmente para reducir el ruido de la imagen y reducir los detalles. También se utiliza como etapa de preprocesamiento antes de aplicar nuestros modelos de aprendizaje automático o aprendizaje profundo. Por ejemplo, de un núcleo gaussiano (3 × 3)
• Desenfoque de mediana: el filtro de mediana es una técnica de filtrado digital no lineal, que a menudo se usa para eliminar el ruido de una imagen o señal. El filtrado de mediana se usa mucho en el procesamiento de imágenes digitales porque, bajo ciertas condiciones, conserva los bordes mientras elimina el ruido. Es uno de los mejores algoritmos para eliminar el ruido de sal y pimienta.
• Desenfoque bilateral: un filtro bilateral es un filtro de suavizado no lineal, que conserva los bordes y reduce el ruido para las imágenes. Reemplaza la intensidad de cada píxel con un promedio ponderado de los valores de intensidad de los píxeles cercanos. Este peso se puede basar en una distribución gaussiana. Por lo tanto, los bordes afilados se conservan mientras se descartan los débiles.

Ejemplo: Python OpenCV Blur Image

# importing libraries
import cv2
import numpy as np
 
image = cv2.imread('geeks.png')
 
cv2.imshow('Original Image', image)
cv2.waitKey(0)
 
# Gaussian Blur
Gaussian = cv2.GaussianBlur(image, (7, 7), 0)
cv2.imshow('Gaussian Blurring', Gaussian)
cv2.waitKey(0)
 
# Median Blur
median = cv2.medianBlur(image, 5)
cv2.imshow('Median Blurring', median)
cv2.waitKey(0)
 
 
# Bilateral Blur
bilateral = cv2.bilateralFilter(image, 9, 75, 75)
cv2.imshow('Bilateral Blurring', bilateral)
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Filtrado Bilateral

Se utiliza un filtro bilateral para suavizar las imágenes y reducir el ruido mientras se conservan los bordes. Sin embargo, estas circunvoluciones a menudo dan como resultado una pérdida de información de borde importante, ya que borran todo, independientemente de que sea ruido o un borde. Para contrarrestar este problema, se introdujo el filtro bilateral no lineal. OpenCV tiene una función llamada bilateralFilter() con los siguientes argumentos:

• d: Diámetro de cada vecindad de píxeles.
• sigmaColor: Valor de   en el espacio de color. Cuanto mayor sea el valor, los colores más alejados entre sí comenzarán a mezclarse.
• sigmaColor: Valor de   en el espacio de coordenadas. Cuanto mayor sea su valor, más píxeles adicionales se mezclarán, dado que sus colores se encuentran dentro del rango sigmaColor.

Ejemplo: imagen bilateral Python OpenCV

import cv2
 
# Read the image
img = cv2.imread('geeks.png')
 
# Apply bilateral filter with d = 30,
# sigmaColor = sigmaSpace = 100
bilateral = cv2.bilateralFilter(img, 15, 100, 100)
 
# Save the output
cv2.imshow('Bilateral', bilateral)
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Contornos de imagen

Los contornos se definen como la línea que une todos los puntos a lo largo del límite de una imagen que tienen la misma intensidad. Los contornos son útiles en el análisis de formas, en encontrar el tamaño del objeto de interés y en la detección de objetos. OpenCV tiene la función findContour() que ayuda a extraer los contornos de la imagen. Funciona mejor en imágenes binarias, por lo que primero debemos aplicar técnicas de umbralización, bordes de Sobel, etc.

Ejemplo: Contorno de imagen Python OpenCV

import cv2
import numpy as np
 
# Let's load a simple image with 3 black squares
image = cv2.imread('geeks.png')
cv2.waitKey(0)
 
# Grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
# Find Canny edges
edged = cv2.Canny(gray, 30, 200)
cv2.waitKey(0)
 
# Finding Contours
# Use a copy of the image e.g. edged.copy()
# since findContours alters the image
contours, hierarchy = cv2.findContours(edged,
    cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
 
cv2.imshow('Canny Edges After Contouring', edged)
cv2.waitKey(0)
 
print("Number of Contours found = " + str(len(contours)))
 
# Draw all contours
# -1 signifies drawing all contours
cv2.drawContours(image, contours, -1, (0, 255, 0), 3)
 
cv2.imshow('Contours', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Erosión y Dilatación

Las operaciones morfológicas más básicas son dos: Erosión y Dilatación .

Fundamentos de la erosión:

• Erosiona los límites del objeto en primer plano
• Se utiliza para disminuir las características de una imagen.

Trabajo de erosión: 

• Un núcleo (una array de tamaño impar (3,5,7) se convoluciona con la imagen.
• Un píxel en la imagen original (ya sea 1 o 0) se considerará 1 solo si todos los píxeles debajo del kernel son 1; de lo contrario, se erosiona (se vuelve a cero).
• Por lo tanto, todos los píxeles cercanos al límite se descartarán según el tamaño del kernel.
• Entonces, el grosor o el tamaño del objeto de primer plano disminuye o simplemente la región blanca disminuye en la imagen.

Fundamentos de la dilatación:

• Aumenta el área del objeto.
• Se utiliza para acentuar las características.

Trabajo de dilatación:

• Un núcleo (una array de tamaño impar (3,5,7) se convoluciona con la imagen
• Un elemento de píxel en la imagen original es ‘1’ si al menos un píxel debajo del núcleo es ‘1’.
• Aumenta la región blanca en la imagen o aumenta el tamaño del objeto en primer plano

Ejemplo: Erosión y dilatación de Python OpenCV

# Python program to demonstrate erosion and
# dilation of images.
import cv2
import numpy as np
 
# Reading the input image
img = cv2.imread('geeks.png', 0)
 
# Taking a matrix of size 5 as the kernel
kernel = np.ones((5,5), np.uint8)
 
# The first parameter is the original image,
# kernel is the matrix with which image is
# convolved and third parameter is the number
# of iterations, which will determine how much
# you want to erode/dilate a given image.
img_erosion = cv2.erode(img, kernel, iterations=1)
img_dilation = cv2.dilate(img, kernel, iterations=1)
 
cv2.imshow('Input', img)
cv2.imshow('Erosion', img_erosion)
cv2.imshow('Dilation', img_dilation)
 
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción
 

Coincidencia de características

ORB es una fusión del detector de punto clave FAST y el descriptor BRIEF con algunas funciones adicionales para mejorar el rendimiento. FAST son características de la prueba de segmento acelerado que se utiliza para detectar características de la imagen proporcionada. También utiliza una pirámide para producir características multiescala. Ahora no calcula la orientación y los descriptores de las características, por lo que aquí es donde BRIEF entra en el papel.

ORB usa descriptores BRIEF pero BRIEF funciona mal con la rotación. Entonces, lo que hace ORB es rotar el BRIEF de acuerdo con la orientación de los puntos clave. Usando la orientación del parche, se encuentra su array de rotación y rota el BRIEF para obtener la versión rotada. ORB es una alternativa eficiente a los algoritmos SIFT o SURF utilizados para la extracción de características, en el costo de cómputo, el rendimiento coincidente y, principalmente, las patentes. SIFT y SURF están patentados y se supone que debe pagarles por su uso. Pero ORB no está patentado. 

import numpy as np
import cv2
 
     
# Read the query image as query_img
# and train image This query image
# is what you need to find in train image
# Save it in the same directory
# with the name image.jpg
query_img = cv2.imread('geeks.png')
train_img = cv2.imread('geeks.png')
 
# Convert it to grayscale
query_img_bw = cv2.cvtColor(query_img,cv2.COLOR_BGR2GRAY)
train_img_bw = cv2.cvtColor(train_img, cv2.COLOR_BGR2GRAY)
 
# Initialize the ORB detector algorithm
orb = cv2.ORB_create()
 
# Now detect the keypoints and compute
# the descriptors for the query image
# and train image
queryKeypoints, queryDescriptors = orb.detectAndCompute(query_img_bw,None)
trainKeypoints, trainDescriptors = orb.detectAndCompute(train_img_bw,None)
 
# Initialize the Matcher for matching
# the keypoints and then match the
# keypoints
matcher = cv2.BFMatcher()
matches = matcher.match(queryDescriptors,trainDescriptors)
 
# draw the matches to the final image
# containing both the images the drawMatches()
# function takes both images and keypoints
# and outputs the matched query image with
# its train image
final_img = cv2.drawMatches(query_img, queryKeypoints,
train_img, trainKeypoints, matches[:20],None)
 
final_img = cv2.resize(final_img, (1000,650))
 
# Show the final image
cv2.imshow("Matches", final_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Dibujar en imágenes

Veamos algunas de las funciones de dibujo y dibujemos formas geométricas en imágenes usando OpenCV. Algunas de las funciones de dibujo son:

• cv2.line() : Se usa para dibujar una línea en una imagen.
• cv2.rectangle() : Se usa para dibujar un rectángulo en una imagen.
• cv2.circle() : Se usa para dibujar un círculo en una imagen.
• cv2.putText() : Se usa para escribir texto en la imagen.

Para demostrar los usos de las funciones mencionadas anteriormente, necesitamos una imagen de tamaño 400 X 400 llena de un color sólido (negro en este caso). Para hacer esto, podemos utilizar la función numpy.zeroes para crear la imagen requerida. 

Ejemplo: Python OpenCV dibujar en la imagen

# Python3 program to draw rectangle
# shape on solid image
import numpy as np
import cv2
 
# Creating a black image with 3
# channels RGB and unsigned int datatype
img = np.zeros((400, 400, 3), dtype = "uint8")
 
# Creating rectangle
cv2.rectangle(img, (30, 30), (300, 200), (0, 255, 0), 5)
 
cv2.imshow('dark', img)
 
# Allows us to see image
# until closed forcefully
cv2.waitKey(0)
cv2.destroyAllWindows()

Producción:

Reconocimiento facial

Haremos reconocimiento facial en este artículo usando algo conocido como cascadas haar . Haar Cascade es un enfoque basado en el aprendizaje automático en el que se utilizan muchas imágenes positivas y negativas para entrenar al clasificador.

• Imágenes positivas: Estas imágenes contienen las imágenes que queremos que identifique nuestro clasificador.
• Imágenes negativas: Imágenes de todo lo demás, que no contienen el objeto que queremos detectar.

Archivo utilizado: 

• haarcascade_frontalface_default.xml
• haarcascade_eye.xml

Ejemplo: Python OpenCV Face Recognition

# OpenCV program to detect face in real time
# import libraries of python OpenCV
# where its functionality resides
import cv2
 
# Trained XML classifiers describes some features of some
# object we want to detect a cascade function is trained
# from a lot of positive(faces) and negative(non-faces)
# images.
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
 
# Trained XML file for detecting eyes
eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
 
# capture frames from a camera
cap = cv2.VideoCapture(0)
 
# loop runs if capturing has been initialized.
while 1:
 
    # reads frames from a camera
    ret, img = cap.read()
 
    # convert to gray scale of each frames
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
    # Detects faces of different sizes in the input image
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
 
    for (x,y,w,h) in faces:
        # To draw a rectangle in a face
        cv2.rectangle(img,(x,y),(x+w,y+h),(255,255,0),2)
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]
 
        # Detects eyes of different sizes in the input image
        eyes = eye_cascade.detectMultiScale(roi_gray)
 
        # To draw a rectangle in eyes
        for (ex,ey,ew,eh) in eyes:
            cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,127,255),2)
 
    # Display an image in a window
    cv2.imshow('img',img)
 
    # Wait for Esc key to stop
    k = cv2.waitKey(30) & 0xff
    if k == 27:
        break
 
# Close the window
cap.release()
 
# De-allocate any associated memory usage
cv2.destroyAllWindows()

Producción