Curso de programación con OpenCV

OpenCV es una biblioteca de visión artificial que ofrece un amplio conjunto de herramientas para la manipulación y el análisis de imágenes y vídeo. Su diseño modular permite resolver diversos problemas relacionados con la visión por computador, como la detección de características, el reconocimiento de objetos o la calibración de cámaras. Gracias a su enfoque de código abierto, OpenCV ha sido adoptada en ámbitos de investigación, desarrollo y producción, convirtiéndose en una solución versátil para proyectos que van desde aplicaciones móviles hasta sistemas de vigilancia.

La gran mayoría de funciones en OpenCV están optimizadas en C/C++, pero existen enlaces para diversos lenguajes de programación, destacando especialmente el caso de Python. Esta integración ayuda a agilizar el prototipado, ya que Python proporciona un entorno rápido para la creación de algoritmos de visión. Al incluir la palabra clave OpenCV, se refuerza su relevancia en entornos de aprendizaje automático y visión por computador a nivel industrial y académico.

La documentación de OpenCV se actualiza de manera constante, incorporando nuevos algoritmos y optimizando los ya existentes. Esto garantiza que los proyectos implementados con esta biblioteca puedan evolucionar con fluidez, aprovechando las innovaciones más recientes en el campo de la visión artificial. Es común que en publicaciones y foros especializados se recomiende el uso de OpenCV como solución principal para problemas de análisis de imágenes, ya que ofrece rutinas de alto rendimiento y gran fiabilidad en producción.

En proyectos universitarios, OpenCV se integra con facilidad en trabajos de investigación, gracias a la amplitud de sus módulos y a su consistente documentación oficial. Esta compatibilidad también fomenta la colaboración de varios profesionales en equipos multidisciplinares, donde los ingenieros de software y los científicos de datos comparten la misma base de herramientas para el procesamiento y análisis de imágenes y vídeos.

A continuación, se presentan secciones dedicadas a diferentes ámbitos de aplicación de OpenCV, incluyendo ejemplos de código y descripciones detalladas de las funciones y módulos más relevantes. Estas secciones cubren las capacidades de OpenCV de forma extensa, sin repetir información de otras lecciones, para que el estudiante profundice en cada tema con orden y sin sobrecarga de conceptos.

Instalación y configuración

La instalación de OpenCV en Python se realiza fácilmente a través de los gestores de paquetes. Usualmente, se emplea la instrucción pip para obtener la biblioteca. A continuación, se muestra un ejemplo de instalación:

pip install opencv-python

Para proyectos que necesiten funciones más avanzadas como contrib (features adicionales, algoritmos experimentales y optimizaciones), se puede instalar la versión que incluye los módulos extra:

pip install opencv-contrib-python

En muchos casos, se requiere configurar el entorno para que OpenCV reconozca las rutas de bibliotecas compartidas, sobre todo cuando se compila desde código fuente. En sistemas Linux, esto implica instalar dependencias de desarrollo. En Windows, puede utilizarse Visual Studio y CMake. No obstante, la mayoría de los usuarios optan por la instalación con pip para agilizar el proceso de configuración de OpenCV.

En notebooks de Jupyter, el uso de pip install opencv-python suele ser suficiente, siempre que las dependencias estén al día. Tras la instalación, se verifica la versión de OpenCV en Python con un simple script:

import cv2
print(cv2.__version__)

Al confirmar la versión, los desarrolladores pueden asegurarse de que todos los módulos de OpenCV funcionen de manera correcta en el entorno de desarrollo elegido.

Carga y visualización de imágenes

Para trabajar con imágenes en OpenCV, se utilizan funciones que permiten cargarlas desde disco, mostrarlas en pantalla y guardarlas una vez procesadas. El módulo cv2.imread() es clave para leer archivos de imagen, y cv2.imshow() para desplegarlos en una ventana emergente.

OpenCV representa las imágenes en arreglos multidimensionales (matrices) que almacenan la información de color y brillo de cada píxel. A continuación, se muestra un ejemplo de código que abre una imagen y la visualiza:

import cv2

imagen = cv2.imread("ruta/de/tu_imagen.jpg")
cv2.imshow("Imagen original", imagen)
cv2.waitKey(0)
cv2.destroyAllWindows()

En entornos basados en notebooks o scripts sin interfaz gráfica, suele preferirse el uso de bibliotecas como Matplotlib para desplegar la imagen. Esto no depende exclusivamente de OpenCV, pero sí complementa sus capacidades de visualización.

Para guardar imágenes procesadas, se emplea cv2.imwrite(), que acepta parámetros como la ruta de salida y la matriz resultante. Gracias a estas funciones, la interacción con archivos gráficos en OpenCV resulta directa y coherente, facilitando los flujos de trabajo en cualquier proyecto de visión por computador.

Procesamiento de imágenes

OpenCV ofrece diversas funciones para manipular las propiedades de las imágenes. Algunas de las operaciones más comunes incluyen la modificación del brillo, el contraste y la aplicación de transformaciones de color. Cuando se habla de realzar los atributos de una imagen, OpenCV cuenta con herramientas eficientes para realizar estos ajustes de forma precisa.

Para cambiar el brillo de una imagen, se puede sumar un valor constante a cada píxel. Para ajustar el contraste, se multiplica cada valor de píxel por un factor determinado. A continuación, se muestra un fragmento de código ilustrativo:

import cv2
import numpy as np

imagen = cv2.imread("ruta/de/tu_imagen.jpg")
# Aumentar brillo y contraste
alpha = 1.2  # factor de contraste
beta = 30    # incremento de brillo
imagen_ajustada = cv2.convertScaleAbs(imagen, alpha=alpha, beta=beta)
cv2.imwrite("ruta/de/imagen_ajustada.jpg", imagen_ajustada)

En este ejemplo, se utiliza la función cv2.convertScaleAbs() de OpenCV para aplicar el factor de contraste alpha y el valor de brillo beta. Es frecuente iterar sobre estos parámetros hasta obtener el resultado esperado. Con estas herramientas, es sencillo automatizar procesos de retoque y corrección de imagen.

Transformaciones geométricas

Las transformaciones geométricas permiten redimensionar, girar y recortar imágenes con gran control. OpenCV incluye funciones para realizar escalados y rotaciones basadas en la definición de puntos de anclaje, ángulos y factores de ampliación.

Para cambiar el tamaño de una imagen, puede emplearse cv2.resize(). A su vez, la función cv2.getRotationMatrix2D() genera la matriz de transformación que define cómo rotar la imagen en torno a un punto central y un ángulo determinado. A continuación, se presenta un ejemplo:

import cv2

imagen = cv2.imread("ruta/de/tu_imagen.jpg")
# Redimensionar
imagen_redimensionada = cv2.resize(imagen, (300, 300))

# Rotar
centro = (imagen.shape[1] // 2, imagen.shape[0] // 2)
angulo = 45
escala = 1.0
matriz_rotacion = cv2.getRotationMatrix2D(centro, angulo, escala)
imagen_rotada = cv2.warpAffine(imagen, matriz_rotacion, (imagen.shape[1], imagen.shape[0]))

cv2.imwrite("ruta/de/imagen_redimensionada.jpg", imagen_redimensionada)
cv2.imwrite("ruta/de/imagen_rotada.jpg", imagen_rotada)

Estas rutinas son muy usadas en aplicaciones donde se requiere la normalización de imágenes o la corrección de la orientación en un preprocesamiento. OpenCV gestiona estos procesos con alta precisión, garantizando resultados consistentes en la mayoría de formatos gráficos.

Detección de características

La detección de características se refiere a la localización de puntos relevantes en la imagen que pueden describir objetos o escenas de manera distintiva. OpenCV incluye métodos como SIFT (Scale-Invariant Feature Transform), SURF (Speeded-Up Robust Features) y ORB (Oriented FAST and Rotated BRIEF). Estas técnicas identifican rasgos locales que permiten reconocer patrones, incluso si la imagen se escalar o rota.

Para utilizar estos métodos, primero se instancian los detectores correspondientes. A continuación, un ejemplo simplificado con ORB, ya que es un algoritmo libre de patentes y disponible en la versión contrib de OpenCV:

import cv2

imagen = cv2.imread("ruta/de/tu_imagen.jpg", cv2.IMREAD_GRAYSCALE)
orb = cv2.ORB_create()
keypoints, descriptors = orb.detectAndCompute(imagen, None)
imagen_con_puntos = cv2.drawKeypoints(imagen, keypoints, None, color=(0,255,0))
cv2.imwrite("ruta/de/imagen_con_orb.jpg", imagen_con_puntos)

En este fragmento, OpenCV detecta los puntos clave con ORB, calcula sus descriptores y luego los dibuja sobre la imagen de entrada. Este enfoque se emplea en numerosos sistemas de visión artificial para la detección de objetos, seguimiento y reconstrucción de escenas en 3D.

Filtros y convolución

El filtrado en OpenCV involucra la convolución de la imagen con matrices definidas (kernels) que dan como resultado efectos como suavizado, detección de bordes o resaltado de contornos. Una de las técnicas más habituales es la aplicación de un filtro de desenfoque gaussiano con cv2.GaussianBlur(), que reduce el ruido y permite resaltar regiones de interés.

Los filtros de convolución se aplican definiendo el tamaño del kernel y, en algunos casos, el valor de la desviación estándar para los filtros gausianos. A continuación, un ejemplo de desenfoque gaussiano básico:

import cv2

imagen = cv2.imread("ruta/de/tu_imagen.jpg")
desenfoque_gaussiano = cv2.GaussianBlur(imagen, (5,5), 0)
cv2.imwrite("ruta/de/imagen_gaussiano.jpg", desenfoque_gaussiano)

Otros filtros populares incluyen el desenfoque promedio (cv2.blur()), el filtro de mediana (cv2.medianBlur()) y el filtro bilateral (cv2.bilateralFilter()), todos presentes en OpenCV para cubrir distintos requerimientos de procesamiento. La elección del filtro depende del tipo de ruido y de la naturaleza de las imágenes que se procesan.

Procesamiento de vídeo

El manejo de vídeo con OpenCV permite leer flujos de datos desde archivos o cámaras en tiempo real. Se hace uso de cv2.VideoCapture() para abrir el dispositivo de captura, mientras que la extracción de fotogramas se realiza con cap.read(). Cada fotograma se trata como una imagen, lo que hace posible aplicar cualquier operación de OpenCV sobre él.

Un pequeño ejemplo para reproducir un vídeo y mostrarlo en pantalla:

import cv2

cap = cv2.VideoCapture("ruta/de/tu_video.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow("Frame", frame)
    if cv2.waitKey(30) & 0xFF == 27:  # tecla Esc
        break

cap.release()
cv2.destroyAllWindows()

En este código, OpenCV lee cada fotograma, lo muestra y espera brevemente la pulsación de la tecla Esc. Este enfoque se usa en aplicaciones de procesamiento en tiempo real, como la detección de movimientos, la vigilancia y el análisis de tráfico.

Detección de objetos

La detección de objetos abarca técnicas que identifican y localizan instancias específicas dentro de una escena. OpenCV ofrece algoritmos como Haar Cascades, que permiten detectar rostros, ojos y gestos. Además, se integra de forma flexible con modelos de aprendizaje profundo (Deep Learning), ofreciendo soporte para frameworks como TensorFlow o PyTorch.

Un ejemplo clásico de la detección de rostros con Haar Cascades en OpenCV es el siguiente:

import cv2

face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
imagen = cv2.imread("ruta/de/tu_imagen.jpg")
grises = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)

rostros = face_cascade.detectMultiScale(grises, scaleFactor=1.1, minNeighbors=5)

for (x, y, w, h) in rostros:
    cv2.rectangle(imagen, (x, y), (x+w, y+h), (0,255,0), 2)

cv2.imwrite("ruta/de/imagen_rostros.jpg", imagen)

En este fragmento, OpenCV busca en la matriz de la imagen características similares a un rostro humano utilizando Haar Cascades. Aunque existen métodos más robustos basados en redes neuronales, esta técnica sigue siendo útil en contextos donde se busca una aproximación rápida y sin dependencias adicionales.

Reconocimiento facial

En el reconocimiento facial, la meta es identificar o verificar la identidad de una persona a partir de su rostro. OpenCV ofrece algoritmos básicos de reconocimiento y también permite integrar modelos de aprendizaje profundo. Para una aproximación inicial, se utilizan métodos como EigenFaces, FisherFaces o LBPH (Local Binary Patterns Histograms). El siguiente ejemplo resume una forma de entrenar un reconocedor LBPH en OpenCV:

import cv2
import numpy as np
import os

# Directorio que contiene subcarpetas con imágenes de cada persona
root_dir = "ruta/de/carpeta_faces"

labels = []
faces_data = []
personas = os.listdir(root_dir)

for etiqueta, persona in enumerate(personas):
    persona_path = os.path.join(root_dir, persona)
    for img_name in os.listdir(persona_path):
        img_path = os.path.join(persona_path, img_name)
        imagen = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
        faces_data.append(imagen)
        labels.append(etiqueta)

labels = np.array(labels)
reconocedor = cv2.face.LBPHFaceRecognizer_create()
reconocedor.train(faces_data, labels)
reconocedor.save("modelo_lbph.xml")

En este ejemplo, se asume que cada subcarpeta en root_dir corresponde a una persona diferente, con varias imágenes de entrenamiento. OpenCV suministra la herramienta para el reconocimiento a través de la clase LBPHFaceRecognizer. Una vez entrenado, el modelo puede cargar nuevas imágenes y realizar una predicción. Este flujo de trabajo es habitual en aplicaciones sencillas de control de acceso.

Segmentación de imágenes

La segmentación consiste en dividir la imagen en regiones o conjuntos de píxeles con propiedades similares, como el color o la textura. OpenCV ofrece métodos como la umbralización (thresholding), que separa objetos del fondo en función de un valor de intensidad, y algoritmos más avanzados como Watershed o GrabCut.

Un ejemplo sencillo es la aplicación de la umbralización adaptativa, donde OpenCV calcula un valor de umbral local para cada región de la imagen:

import cv2

imagen = cv2.imread("ruta/de/tu_imagen.jpg", cv2.IMREAD_GRAYSCALE)
umbral_adaptativo = cv2.adaptiveThreshold(imagen, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                          cv2.THRESH_BINARY, 11, 2)
cv2.imwrite("ruta/de/imagen_umbral.jpg", umbral_adaptativo)

Esta técnica se utiliza cuando la iluminación de la escena no es uniforme. OpenCV permite afinar parámetros como el tipo de umbral, el tamaño de la región de vecindad y la constante substraída, consiguiendo una segmentación más precisa que con la umbralización global.

Visión en 3D

La visión en 3D comprende procesos de reconstrucción estereoscópica, calibración de cámaras, generación de mapas de profundidad y estimación de pose. OpenCV proporciona rutinas para calibrar cámaras, compensar la distorsión de los lentes y, en conjunto, estimar la relación espacial entre la cámara y los objetos de la escena.

El proceso de calibración requiere tomar varias capturas de un tablero de ajedrez desde diferentes ángulos. Después, se utiliza cv2.findChessboardCorners() para localizar las esquinas, y cv2.calibrateCamera() para obtener los parámetros de la cámara. Con estos parámetros, OpenCV corrige la distorsión de la lente y permite una proyección precisa de objetos en el espacio tridimensional.

En la reconstrucción estereoscópica, dos imágenes provenientes de cámaras separadas horizontalmente se analizan para encontrar correspondencias entre sus características, y OpenCV genera un mapa de profundidad que describe la geometría de la escena. Esta técnica se aplica en robótica, realidad aumentada y sistemas de inspección industrial.

Integración con otras bibliotecas externas

La biblioteca OpenCV se integra de forma nativa con librerías como NumPy, lo que facilita el paso de datos entre matrices de imágenes y estructuras de cálculo científico. Además, puede combinarse con scikit-learn para el desarrollo de modelos de machine learning orientados a la visión por computador, o con TensorFlow y PyTorch para implementar redes neuronales convolucionales.

Cuando se trabaja con Jupyter notebooks, es común utilizar la función de trazado de Matplotlib para visualizar resultados. Por ejemplo:

import cv2
import matplotlib.pyplot as plt

imagen = cv2.imread("ruta/de/tu_imagen.jpg")
# Convertir a RGB para mostrarlo con Matplotlib
imagen_rgb = cv2.cvtColor(imagen, cv2.COLOR_BGR2RGB)
plt.imshow(imagen_rgb)
plt.title("Imagen en RGB con Matplotlib")
plt.show()

En este fragmento, se observa cómo OpenCV y Matplotlib cooperan para leer y mostrar una imagen. A la vez, se conserva la conveniencia que ofrece NumPy para manipular matrices. La compatibilidad de OpenCV con otras bibliotecas del ecosistema Python la convierte en una opción muy utilizada para desarrollar soluciones de visión artificial end-to-end.